Changeset 690ad20 in mainline for kernel/generic/src/console/console.c

Timestamp:

2025-04-17T15:29:16Z (5 days ago)

Author:

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

Branches:

master

Children:

39e1b9a

Parents:

d5b37b6

git-author:

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

git-committer:

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

Message:

Convert kio buffer to bytes (part 1)

File:

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

kernel/generic/src/console/console.c

@@ -40 +40 @@
 #include <errno.h>
 #include <ipc/event.h>
+#include <log.h>
 #include <panic.h>
 #include <preemption.h>
 #include <proc/task.h>
-#include <putchar.h>
 #include <stdatomic.h>
 #include <stdio.h>
 #include <stdlib.h>  /* malloc */
+#include <str.h>
 #include <synch/mutex.h>
 #include <synch/spinlock.h>
@@ -53 +54 @@
 
 #define KIO_PAGES    8
-#define KIO_LENGTH   (KIO_PAGES * PAGE_SIZE / sizeof(char32_t))
+#define KIO_LENGTH   (KIO_PAGES * PAGE_SIZE)
 
 /** Kernel log cyclic buffer */
-static char32_t kio[KIO_LENGTH];
+static char kio[KIO_LENGTH];
 
 /** Kernel log initialized */
@@ -78 +79 @@
 /** Kernel log spinlock */
 IRQ_SPINLOCK_INITIALIZE(kio_lock);
+
+static IRQ_SPINLOCK_INITIALIZE(early_mbstate_lock);
+static mbstate_t early_mbstate;
 
 static indev_t stdin_sink;
@@ -245 +249 @@
         irq_spinlock_lock(&kio_lock, true);
 
+        static mbstate_t mbstate;
+
         /* Print characters that weren't printed earlier */
         while (kio_written != kio_processed) {
-                char32_t tmp = kio[kio_processed % KIO_LENGTH];
-                kio_processed++;
+                size_t offset = kio_processed % KIO_LENGTH;
+                size_t len = min(kio_written - kio_processed, KIO_LENGTH - offset);
+                size_t bytes = 0;
+
+                char32_t ch = str_decode_r(&kio[offset], &bytes, len, U'�', &mbstate);
+                assert(bytes <= 4);
+                kio_processed += bytes;
 
                 /*
@@ -256 +267 @@
                  */
                 irq_spinlock_unlock(&kio_lock, true);
-                stdout->op->write(stdout, tmp);
+                stdout->op->write(stdout, ch);
                 irq_spinlock_lock(&kio_lock, true);
         }
@@ -263 +274 @@
 }
 
-/** Put a character into the output buffer.
- *
- * The caller is required to hold kio_lock
- */
-void kio_push_char(const char32_t ch)
-{
-        kio[kio_written % KIO_LENGTH] = ch;
-        kio_written++;
-}
-
-void putuchar(const char32_t ch)
+void kio_push_bytes(const char *s, size_t n)
+{
+        /* Skip the section we know we can't keep. */
+        if (n > KIO_LENGTH) {
+                size_t lost = n - KIO_LENGTH;
+                kio_written += lost;
+                s += lost;
+                n -= lost;
+        }
+
+        size_t offset = kio_written % KIO_LENGTH;
+        if (offset + n > KIO_LENGTH) {
+                size_t first = KIO_LENGTH - offset;
+                size_t last = n - first;
+                memcpy(kio + offset, s, first);
+                memcpy(kio, s + first, last);
+        } else {
+                memcpy(kio + offset, s, n);
+        }
+
+        kio_written += n;
+}
+
+static void early_putstr(const char *s, size_t n)
+{
+        irq_spinlock_lock(&early_mbstate_lock, true);
+
+        size_t offset = 0;
+        char32_t c;
+
+        while ((c = str_decode_r(s, &offset, n, U_SPECIAL, &early_mbstate)))
+                early_putuchar(c);
+
+        irq_spinlock_unlock(&early_mbstate_lock, true);
+}
+
+void putstr(const char *s, size_t n)
 {
         bool ordy = ((stdout) && (stdout->op->write));
 
         irq_spinlock_lock(&kio_lock, true);
-        kio_push_char(ch);
+        kio_push_bytes(s, n);
         irq_spinlock_unlock(&kio_lock, true);
 
@@ -295 +332 @@
                  * a no-op on certain hardware configurations.
                  */
-                early_putuchar(ch);
-        }
-
-        /* Force notification on newline */
-        if (ch == '\n')
+                early_putstr(s, n);
+        }
+
+        /* Force notification when containing a newline */
+        if (memchr(s, '\n', n) != NULL)
                 kio_update(NULL);
 }
@@ -336 +373 @@
                 size_t first = KIO_LENGTH - offset;
                 size_t last = actual_read - first;
-                size_t first_bytes = first * sizeof(kio[0]);
-                size_t last_bytes = last * sizeof(kio[0]);
-
-                rc = copy_to_uspace(buf, &kio[offset], first_bytes);
+
+                rc = copy_to_uspace(buf, &kio[offset], first);
                 if (rc == EOK)
-                        rc = copy_to_uspace(buf + first_bytes, &kio[0], last_bytes);
+                        rc = copy_to_uspace(buf + first, &kio[0], last);
         } else {
-                rc = copy_to_uspace(buf, &kio[offset], actual_read * sizeof(kio[0]));
+                rc = copy_to_uspace(buf, &kio[offset], actual_read);
         }