Changes in kernel/generic/src/console/console.c [39e1b9a:63ed840] in mainline

File:

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

kernel/generic/src/console/console.c

@@ -2 +2 @@
  * Copyright (c) 2003 Josef Cejka
  * Copyright (c) 2005 Jakub Jermar
- * Copyright (c) 2025 Jiří Zárevúcky
  * All rights reserved.
  *
@@ -35 +34 @@
  */
 
+#include <assert.h>
+#include <console/console.h>
+#include <console/chardev.h>
+#include <sysinfo/sysinfo.h>
+#include <synch/waitq.h>
+#include <synch/spinlock.h>
+#include <typedefs.h>
+#include <ddi/irq.h>
+#include <ddi/ddi.h>
+#include <ipc/event.h>
+#include <ipc/irq.h>
+#include <arch.h>
+#include <panic.h>
+#include <stdio.h>
+#include <putchar.h>
+#include <atomic.h>
+#include <syscall/copy.h>
+#include <errno.h>
+#include <str.h>
+#include <stdatomic.h>
 #include <abi/kio.h>
-#include <console/chardev.h>
-#include <console/console.h>
-#include <errno.h>
-#include <ipc/event.h>
-#include <log.h>
-#include <panic.h>
-#include <preemption.h>
-#include <proc/task.h>
-#include <stdatomic.h>
-#include <stdio.h>
+#include <mm/frame.h> /* SIZE2FRAMES */
 #include <stdlib.h>  /* malloc */
-#include <str.h>
-#include <synch/mutex.h>
-#include <synch/spinlock.h>
-#include <syscall/copy.h>
-#include <sysinfo/sysinfo.h>
 
 #define KIO_PAGES    8
-#define KIO_LENGTH   (KIO_PAGES * PAGE_SIZE)
+#define KIO_LENGTH   (KIO_PAGES * PAGE_SIZE / sizeof(char32_t))
 
 /** Kernel log cyclic buffer */
-static char kio[KIO_LENGTH];
+char32_t kio[KIO_LENGTH] __attribute__((aligned(PAGE_SIZE)));
 
 /** Kernel log initialized */
 static atomic_bool kio_inited = ATOMIC_VAR_INIT(false);
 
-/** A mutex for preventing interleaving of output lines from different threads.
- * May not be held in some circumstances, so locking of any internal shared
- * structures is still necessary.
- */
-static MUTEX_INITIALIZE(console_mutex, MUTEX_RECURSIVE);
-
-/** Number of characters written to buffer. Periodically overflows. */
-static size_t kio_written = 0;
-
-/** Number of characters written to output devices. Periodically overflows. */
-static size_t kio_processed = 0;
-
-/** Last notification sent to uspace. */
-static size_t kio_notified = 0;
+/** First kernel log characters */
+static size_t kio_start = 0;
+
+/** Number of valid kernel log characters */
+static size_t kio_len = 0;
+
+/** Number of stored (not printed) kernel log characters */
+static size_t kio_stored = 0;
+
+/** Number of stored kernel log characters for uspace */
+static size_t kio_uspace = 0;
 
 /** Kernel log spinlock */
-IRQ_SPINLOCK_INITIALIZE(kio_lock);
-
-static IRQ_SPINLOCK_INITIALIZE(flush_lock);
-
-static IRQ_SPINLOCK_INITIALIZE(early_mbstate_lock);
-static mbstate_t early_mbstate;
+SPINLOCK_INITIALIZE_NAME(kio_lock, "kio_lock");
+
+/** Physical memory area used for kio buffer */
+static parea_t kio_parea;
 
 static indev_t stdin_sink;
@@ -95 +95 @@
 };
 
-static void stdout_write(outdev_t *, const char *, size_t);
+static void stdout_write(outdev_t *, char32_t);
 static void stdout_redraw(outdev_t *);
 static void stdout_scroll_up(outdev_t *);
@@ -148 +148 @@
 }
 
-static void stdout_write(outdev_t *dev, const char *s, size_t n)
+static void stdout_write(outdev_t *dev, char32_t ch)
 {
         list_foreach(dev->list, link, outdev_t, sink) {
                 if ((sink) && (sink->op->write))
-                        sink->op->write(sink, s, n);
+                        sink->op->write(sink, ch);
         }
 }
@@ -181 +181 @@
 
 /** Initialize kernel logging facility
+ *
+ * The shared area contains kernel cyclic buffer. Userspace application may
+ * be notified on new data with indication of position and size
+ * of the data within the circular buffer.
+ *
  */
 void kio_init(void)
 {
+        void *faddr = (void *) KA2PA(kio);
+
+        assert((uintptr_t) faddr % FRAME_SIZE == 0);
+
+        ddi_parea_init(&kio_parea);
+        kio_parea.pbase = (uintptr_t) faddr;
+        kio_parea.frames = SIZE2FRAMES(sizeof(kio));
+        kio_parea.unpriv = false;
+        kio_parea.mapped = false;
+        ddi_parea_register(&kio_parea);
+
+        sysinfo_set_item_val("kio.faddr", NULL, (sysarg_t) faddr);
+        sysinfo_set_item_val("kio.pages", NULL, KIO_PAGES);
+
         event_set_unmask_callback(EVENT_KIO, kio_update);
         atomic_store(&kio_inited, true);
@@ -229 +248 @@
                 return;
 
-        irq_spinlock_lock(&kio_lock, true);
-
-        if (kio_notified != kio_written) {
-                if (event_notify_1(EVENT_KIO, true, kio_written) == EOK)
-                        kio_notified = kio_written;
-        }
-
-        irq_spinlock_unlock(&kio_lock, true);
+        spinlock_lock(&kio_lock);
+
+        if (kio_uspace > 0) {
+                if (event_notify_3(EVENT_KIO, true, kio_start, kio_len,
+                    kio_uspace) == EOK)
+                        kio_uspace = 0;
+        }
+
+        spinlock_unlock(&kio_lock);
 }
 
@@ -249 +269 @@
                 return;
 
-        irq_spinlock_lock(&kio_lock, true);
-
-        if (!irq_spinlock_trylock(&flush_lock)) {
-                /* Someone is currently flushing. */
-                irq_spinlock_unlock(&kio_lock, true);
-                return;
-        }
-
-        /* A small-ish local buffer so that we can write to output in chunks. */
-        char buffer[256];
+        spinlock_lock(&kio_lock);
 
         /* Print characters that weren't printed earlier */
-        while (kio_written != kio_processed) {
-                size_t offset = kio_processed % KIO_LENGTH;
-                size_t len = min(kio_written - kio_processed, KIO_LENGTH - offset);
-                len = min(len, sizeof(buffer));
-
-                /* Take out a chunk of the big buffer. */
-                memcpy(buffer, &kio[offset], len);
-                kio_processed += len;
+        while (kio_stored > 0) {
+                char32_t tmp = kio[(kio_start + kio_len - kio_stored) % KIO_LENGTH];
+                kio_stored--;
 
                 /*
-                 * We need to give up the spinlock for the physical operation of writing
-                 * out the buffer.
+                 * We need to give up the spinlock for
+                 * the physical operation of writing out
+                 * the character.
                  */
-                irq_spinlock_unlock(&kio_lock, true);
-                stdout->op->write(stdout, buffer, len);
-                irq_spinlock_lock(&kio_lock, true);
-        }
-
-        irq_spinlock_unlock(&flush_lock, false);
-        irq_spinlock_unlock(&kio_lock, true);
-}
-
-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)
+                spinlock_unlock(&kio_lock);
+                stdout->op->write(stdout, tmp);
+                spinlock_lock(&kio_lock);
+        }
+
+        spinlock_unlock(&kio_lock);
+}
+
+/** 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_start + kio_len) % KIO_LENGTH] = ch;
+        if (kio_len < KIO_LENGTH)
+                kio_len++;
+        else
+                kio_start = (kio_start + 1) % KIO_LENGTH;
+
+        if (kio_stored < kio_len)
+                kio_stored++;
+
+        /* The character is stored for uspace */
+        if (kio_uspace < kio_len)
+                kio_uspace++;
+}
+
+void putuchar(const char32_t ch)
 {
         bool ordy = ((stdout) && (stdout->op->write));
 
-        irq_spinlock_lock(&kio_lock, true);
-        kio_push_bytes(s, n);
-        irq_spinlock_unlock(&kio_lock, true);
+        spinlock_lock(&kio_lock);
+        kio_push_char(ch);
+        spinlock_unlock(&kio_lock);
 
         /* Output stored characters */
@@ -341 +331 @@
                  * a no-op on certain hardware configurations.
                  */
-                early_putstr(s, n);
-        }
-
-        /* Force notification when containing a newline */
-        if (memchr(s, '\n', n) != NULL)
+                early_putuchar(ch);
+        }
+
+        /* Force notification on newline */
+        if (ch == '\n')
                 kio_update(NULL);
-}
-
-/** Reads up to `size` characters from kio buffer starting at character `at`.
- *
- * @param size  Maximum number of characters that can be stored in buffer.
- *              Values greater than KIO_LENGTH are silently treated as KIO_LENGTH
- *              for the purposes of calculating the return value.
- * @return Number of characters read. Can be more than `size`.
- *         In that case, `size` characters are written to user buffer
- *         and the extra amount is the number of characters missed.
- */
-sysarg_t sys_kio_read(uspace_addr_t buf, size_t size, size_t at)
-{
-        errno_t rc;
-        size_t missed = 0;
-
-        irq_spinlock_lock(&kio_lock, true);
-
-        if (at == kio_written) {
-                irq_spinlock_unlock(&kio_lock, true);
-                return 0;
-        }
-
-        size_t readable_chars = kio_written - at;
-        if (readable_chars > KIO_LENGTH) {
-                missed = readable_chars - KIO_LENGTH;
-                readable_chars = KIO_LENGTH;
-        }
-
-        size_t actual_read = min(readable_chars, size);
-        size_t offset = (kio_written - readable_chars) % KIO_LENGTH;
-
-        if (offset + actual_read > KIO_LENGTH) {
-                size_t first = KIO_LENGTH - offset;
-                size_t last = actual_read - first;
-
-                rc = copy_to_uspace(buf, &kio[offset], first);
-                if (rc == EOK)
-                        rc = copy_to_uspace(buf + first, &kio[0], last);
-        } else {
-                rc = copy_to_uspace(buf, &kio[offset], actual_read);
-        }
-
-        irq_spinlock_unlock(&kio_lock, true);
-
-        if (rc != EOK) {
-                log(LF_OTHER, LVL_WARN,
-                    "[%s(%" PRIu64 ")] Terminating due to invalid memory buffer"
-                    " in SYS_KIO_READ.\n", TASK->name, TASK->taskid);
-                task_kill_self(true);
-        }
-
-        return actual_read + missed;
 }
 
@@ -437 +374 @@
                 }
                 data[size] = 0;
-
-                uint8_t substitute = '\x1a';
-                str_sanitize(data, size, substitute);
 
                 switch (cmd) {
@@ -461 +395 @@
 }
 
-/** Lock console output, ensuring that lines from different threads don't
- * interleave. Does nothing when preemption is disabled, so that debugging
- * and error printouts in sensitive areas still work.
- */
-void console_lock(void)
-{
-        if (!PREEMPTION_DISABLED)
-                mutex_lock(&console_mutex);
-}
-
-/** Unlocks console output. See console_lock()
- */
-void console_unlock(void)
-{
-        if (!PREEMPTION_DISABLED)
-                mutex_unlock(&console_mutex);
-}
-
 /** @}
  */