Changeset c4cfe4c in mainline for kernel/generic/src/log/log.c

Timestamp:

2025-04-17T16:01:16Z (5 days ago)

Author:

Jiří Zárevúcky <zarevucky.jiri@…>

Branches:

master

Children:

888c06e

Parents:

1db4e2ae (diff), 250a435 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2025-04-17 15:51:11)

git-committer:

Jiří Zárevúcky <zarevucky.jiri@…> (2025-04-17 16:01:16)

Message:

Convert kernel console writing to byte arrays

More buffer per buffer (the original char32_t buffer takes up four
times as much space for the same amount of backlog, which is wasteful).
It is also faster, possibly thanks to bigger chunks being processed in bulk.
Gonna try to figure out if the locking can be improved further.

Also changed to use a syscall for reading KIO buffer from uspace,
to allow better synchronization.

File:

• kernel/generic/src/log/log.c (modified) (8 diffs)

kernel/generic/src/log/log.c

@@ -46 +46 @@
 #include <print.h>
 #include <printf_core.h>
-#include <putchar.h>
 #include <stdarg.h>
 #include <stdlib.h>
@@ -60 +59 @@
 
 /** Cyclic buffer holding the data for kernel log */
-uint8_t log_buffer[LOG_LENGTH] __attribute__((aligned(PAGE_SIZE)));
+static uint8_t log_buffer[LOG_LENGTH] __attribute__((aligned(PAGE_SIZE)));
 
 /** Kernel log initialized */
@@ -66 +65 @@
 
 /** Position in the cyclic buffer where the first log entry starts */
-size_t log_start = 0;
+static size_t log_start = 0;
 
 /** Sum of length of all log entries currently stored in the cyclic buffer */
-size_t log_used = 0;
+static size_t log_used = 0;
 
 /** Log spinlock */
-SPINLOCK_STATIC_INITIALIZE_NAME(log_lock, "log_lock");
+static IRQ_SPINLOCK_INITIALIZE(log_lock);
 
 /** Overall count of logged messages, which may overflow as needed */
@@ -152 +151 @@
 {
         console_lock();
-        spinlock_lock(&log_lock);
-        spinlock_lock(&kio_lock);
+        irq_spinlock_lock(&log_lock, true);
+        irq_spinlock_lock(&kio_lock, true);
 
         log_current_start = (log_start + log_used) % LOG_LENGTH;
@@ -179 +178 @@
         log_used += log_current_len;
 
-        kio_push_char('\n');
-        spinlock_unlock(&kio_lock);
-        spinlock_unlock(&log_lock);
+        kio_push_bytes("\n", 1);
+        irq_spinlock_unlock(&kio_lock, true);
+        irq_spinlock_unlock(&log_lock, true);
 
         /* This has to be called after we released the locks above */
@@ -195 +194 @@
                 return;
 
-        spinlock_lock(&log_lock);
+        irq_spinlock_lock(&log_lock, true);
         if (next_for_uspace < log_used)
                 event_notify_0(EVENT_KLOG, true);
-        spinlock_unlock(&log_lock);
+        irq_spinlock_unlock(&log_lock, true);
 }
 
 static int log_printf_str_write(const char *str, size_t size, void *data)
 {
-        size_t offset = 0;
-
-        while (offset < size)
-                kio_push_char(str_decode(str, &offset, size));
-
+        kio_push_bytes(str, size);
         log_append((const uint8_t *)str, size);
-
         return EOK;
 }
@@ -307 +301 @@
                 rc = EOK;
 
-                spinlock_lock(&log_lock);
+                irq_spinlock_lock(&log_lock, true);
 
                 while (next_for_uspace < log_used) {
@@ -337 +331 @@
                 }
 
-                spinlock_unlock(&log_lock);
+                irq_spinlock_unlock(&log_lock, true);
 
                 if (rc != EOK) {