Changes in / [a65ccc4:61c91532] in mainline

Files:

• abi/include/abi/syscall.h (modified) (1 diff)
• kernel/genarch/src/drivers/ega/ega.c (modified) (3 diffs)
• kernel/genarch/src/drivers/ns16550/ns16550.c (modified) (1 diff)
• kernel/genarch/src/drivers/pl011/pl011.c (modified) (2 diffs)
• kernel/genarch/src/fb/fb.c (modified) (13 diffs)
• kernel/generic/include/console/chardev.h (modified) (1 diff)
• kernel/generic/include/console/console.h (modified) (3 diffs)
• kernel/generic/include/putchar.h (deleted)
• kernel/generic/include/stdio.h (modified) (1 diff)
• kernel/generic/src/console/console.c (modified) (10 diffs)
• kernel/generic/src/console/kconsole.c (modified) (8 diffs)
• kernel/generic/src/log/log.c (modified) (8 diffs)
• kernel/generic/src/printf/vprintf.c (modified) (3 diffs)
• kernel/generic/src/syscall/syscall.c (modified) (1 diff)
• kernel/test/print/print4.c (modified) (1 diff)
• uspace/app/kio/kio.c (modified) (8 diffs)
• uspace/app/trace/syscalls.c (modified) (1 diff)
• uspace/lib/c/generic/io/kio.c (modified) (2 diffs)
• uspace/lib/c/include/io/kio.h (modified) (2 diffs)

abi/include/abi/syscall.h

@@ -110 +110 @@
         SYS_DEBUG_CONSOLE,
 
-        SYS_KLOG
+        SYS_KLOG,
+        SYS_KIO_READ,
 } syscall_t;
 

kernel/genarch/src/drivers/ega/ega.c

@@ -69 +69 @@
         uint8_t *backbuf;
         ioport8_t *base;
+        mbstate_t mbstate;
 } ega_instance_t;
 
-static void ega_putuchar(outdev_t *, char32_t);
+static void ega_write(outdev_t *, const char *, size_t);
 static void ega_redraw(outdev_t *);
 
 static outdev_operations_t egadev_ops = {
-        .write = ega_putuchar,
+        .write = ega_write,
         .redraw = ega_redraw,
         .scroll_up = NULL,
@@ -538 +539 @@
 }
 
-static void ega_putuchar(outdev_t *dev, char32_t ch)
-{
-        ega_instance_t *instance = (ega_instance_t *) dev->data;
-
-        irq_spinlock_lock(&instance->lock, true);
-
+static void _putuchar(ega_instance_t *instance, char32_t ch)
+{
         switch (ch) {
         case '\n':
@@ -564 +561 @@
         ega_check_cursor(instance);
         ega_move_cursor(instance);
+}
+
+static void ega_write(outdev_t *dev, const char *s, size_t n)
+{
+        ega_instance_t *instance = (ega_instance_t *) dev->data;
+
+        irq_spinlock_lock(&instance->lock, true);
+
+        size_t offset = 0;
+        char32_t ch;
+
+        while ((ch = str_decode_r(s, &offset, n, U_SPECIAL, &instance->mbstate)))
+                _putuchar(instance, ch);
 
         irq_spinlock_unlock(&instance->lock, true);

kernel/genarch/src/drivers/ns16550/ns16550.c

@@ -112 +112 @@
 }
 
-static void ns16550_putuchar(outdev_t *dev, char32_t ch)
+static void ns16550_write(outdev_t *dev, const char *s, size_t n)
 {
         ns16550_instance_t *instance = (ns16550_instance_t *) dev->data;
 
-        if ((!instance->parea.mapped) || (console_override)) {
-                if (ch == '\n')
+        if (instance->parea.mapped && !console_override)
+                return;
+
+        const char *top = s + n;
+        assert(top >= s);
+
+        for (; s < top; s++) {
+                if (*s == '\n')
                         ns16550_sendb(instance, '\r');
 
-                if (ascii_check(ch))
-                        ns16550_sendb(instance, (uint8_t) ch);
-                else
-                        ns16550_sendb(instance, U_SPECIAL);
+                ns16550_sendb(instance, (uint8_t) *s);
         }
 }
 
 static outdev_operations_t ns16550_ops = {
-        .write = ns16550_putuchar,
+        .write = ns16550_write,
         .redraw = NULL
 };

kernel/genarch/src/drivers/pl011/pl011.c

@@ -56 +56 @@
 }
 
-static void pl011_uart_putuchar(outdev_t *dev, char32_t ch)
+static void pl011_uart_write(outdev_t *dev, const char *s, size_t n)
 {
         pl011_uart_t *uart = dev->data;
@@ -64 +64 @@
                 return;
 
-        if (!ascii_check(ch))
-                pl011_uart_sendb(uart, U_SPECIAL);
-        else {
-                if (ch == '\n')
-                        pl011_uart_sendb(uart, (uint8_t) '\r');
-                pl011_uart_sendb(uart, (uint8_t) ch);
+        const char *top = s + n;
+        assert(top >= s);
+
+        for (; s < top; s++) {
+                if (*s == '\n')
+                        pl011_uart_sendb(uart, '\r');
+
+                pl011_uart_sendb(uart, (uint8_t) *s);
         }
 }
 
 static outdev_operations_t pl011_uart_ops = {
-        .write = pl011_uart_putuchar,
+        .write = pl011_uart_write,
         .redraw = NULL,
         .scroll_up = NULL,

kernel/genarch/src/fb/fb.c

@@ -81 +81 @@
         ((glyph) * (instance)->glyphbytes + (y) * (instance)->glyphscanline)
 
+#define TAB_WIDTH 8
+
 typedef void (*rgb_conv_t)(void *, uint32_t);
 
@@ -99 +101 @@
 
         /** Number of rows that fit on framebuffer */
-        unsigned int rowtrim;
+        unsigned int screen_rows;
 
         unsigned int scanline;
@@ -121 +123 @@
         /** Current backbuffer position */
         unsigned int position;
+
+        /** Partial character between writes */
+        mbstate_t mbstate;
+
+        unsigned int row;
+        unsigned int column;
 } fb_instance_t;
 
-static void fb_putuchar(outdev_t *, char32_t);
+static void fb_write(outdev_t *, const char *, size_t);
 static void fb_redraw(outdev_t *);
 static void fb_scroll_up(outdev_t *);
@@ -129 +137 @@
 
 static outdev_operations_t fbdev_ops = {
-        .write = fb_putuchar,
+        .write = fb_write,
         .redraw = fb_redraw,
         .scroll_up = fb_scroll_up,
@@ -247 +255 @@
 
         unsigned int rel_row = row - instance->offset_row;
-        if (rel_row >= instance->rowtrim)
+        if (rel_row >= instance->screen_rows)
                 return;
 
@@ -259 +267 @@
 }
 
-/** Scroll screen down by one row
- *
- */
-static void screen_scroll(fb_instance_t *instance)
-{
-        if ((!instance->parea.mapped) || (console_override)) {
-                for (unsigned int rel_row = 0; rel_row < instance->rowtrim; rel_row++) {
-                        unsigned int y = ROW2Y(rel_row);
-                        unsigned int row = rel_row + instance->offset_row;
-
-                        for (unsigned int yd = 0; yd < FONT_SCANLINES; yd++) {
-                                unsigned int x;
-                                unsigned int col;
-                                size_t bb_pos = BB_POS(instance, 0, row);
-                                size_t bb_pos1 = BB_POS(instance, 0, row + 1);
-
-                                for (col = 0, x = 0; col < instance->cols;
-                                    col++, x += FONT_WIDTH) {
-                                        uint16_t glyph;
-
-                                        if (row < instance->rows - 1) {
-                                                if (instance->backbuf[bb_pos] ==
-                                                    instance->backbuf[bb_pos1])
-                                                        goto skip;
-
-                                                glyph = instance->backbuf[bb_pos1];
-                                        } else
-                                                glyph = 0;
-
-                                        memcpy(&instance->addr[FB_POS(instance, x, y + yd)],
-                                            &instance->glyphs[GLYPH_POS(instance, glyph, yd)],
-                                            instance->glyphscanline);
-                                skip:
-                                        BB_NEXT_COL(bb_pos);
-                                        BB_NEXT_COL(bb_pos1);
-                                }
-                        }
-                }
-        }
-
-        /*
-         * Implement backbuffer scrolling by wrapping around
-         * the cyclic buffer.
-         */
-
-        instance->start_row++;
-        if (instance->start_row == instance->rows)
-                instance->start_row = 0;
-
-        memsetw(&instance->backbuf[BB_POS(instance, 0, instance->rows - 1)],
-            instance->cols, 0);
-}
-
 static void cursor_put(fb_instance_t *instance)
 {
-        unsigned int col = instance->position % instance->cols;
-        unsigned int row = instance->position / instance->cols;
+        unsigned int col = instance->column;
+        unsigned int row = instance->row;
 
         glyph_draw(instance, fb_font_glyph(U_CURSOR), col, row, true);
@@ -322 +277 @@
 static void cursor_remove(fb_instance_t *instance)
 {
-        unsigned int col = instance->position % instance->cols;
-        unsigned int row = instance->position / instance->cols;
+        unsigned int col = instance->column;
+        unsigned int row = instance->row;
 
         glyph_draw(instance, instance->backbuf[BB_POS(instance, col, row)],
@@ -373 +328 @@
 static void fb_redraw_internal(fb_instance_t *instance)
 {
-        for (unsigned int rel_row = 0; rel_row < instance->rowtrim; rel_row++) {
+        for (unsigned int rel_row = 0; rel_row < instance->screen_rows; rel_row++) {
                 unsigned int y = ROW2Y(rel_row);
                 unsigned int row = rel_row + instance->offset_row;
@@ -404 +359 @@
         }
 
-        if (ROW2Y(instance->rowtrim) < instance->yres) {
+        if (ROW2Y(instance->screen_rows) < instance->yres) {
                 unsigned int y;
 
-                for (y = ROW2Y(instance->rowtrim); y < instance->yres; y++)
+                for (y = ROW2Y(instance->screen_rows); y < instance->yres; y++)
                         memcpy(&instance->addr[FB_POS(instance, 0, y)],
                             instance->bgscan, instance->bgscanbytes);
@@ -413 +368 @@
 }
 
+/** Scroll screen down by one row
+ *
+ */
+static void screen_scroll(fb_instance_t *instance)
+{
+        /*
+         * Implement backbuffer scrolling by wrapping around
+         * the cyclic buffer.
+         */
+
+        instance->start_row++;
+        if (instance->start_row == instance->rows)
+                instance->start_row = 0;
+
+        if ((!instance->parea.mapped) || (console_override)) {
+                fb_redraw_internal(instance);
+        }
+}
+
+static void _advance_row(fb_instance_t *instance)
+{
+        instance->column = 0;
+        instance->row++;
+}
+
+static void _advance_column(fb_instance_t *instance)
+{
+        instance->column++;
+        if (instance->column == instance->cols)
+                _advance_row(instance);
+}
+
 /** Print character to screen
  *
@@ -418 +405 @@
  *
  */
-static void fb_putuchar(outdev_t *dev, char32_t ch)
+static void _putuchar(fb_instance_t *instance, char32_t ch)
+{
+        switch (ch) {
+        case '\n':
+                _advance_row(instance);
+                break;
+        case '\r':
+                instance->column = 0;
+                break;
+        case '\b':
+                if (instance->column > 0)
+                        instance->column--;
+                break;
+        case '\t':
+                do {
+                        glyph_draw(instance, fb_font_glyph(' '),
+                            instance->column,
+                            instance->row, false);
+                        _advance_column(instance);
+                } while (instance->column % TAB_WIDTH != 0);
+                break;
+        default:
+                glyph_draw(instance, fb_font_glyph(ch),
+                    instance->column,
+                    instance->row, false);
+                _advance_column(instance);
+        }
+
+        while (instance->row >= instance->rows) {
+                instance->row--;
+                screen_scroll(instance);
+        }
+}
+
+static void fb_write(outdev_t *dev, const char *s, size_t n)
+{
+        fb_instance_t *instance = (fb_instance_t *) dev->data;
+
+        spinlock_lock(&instance->lock);
+        cursor_remove(instance);
+
+        size_t offset = 0;
+        char32_t ch;
+
+        while ((ch = str_decode_r(s, &offset, n, U_SPECIAL, &instance->mbstate)))
+                _putuchar(instance, ch);
+
+        cursor_put(instance);
+        spinlock_unlock(&instance->lock);
+}
+
+/** Scroll the framebuffer up
+ *
+ */
+static void fb_scroll_up(outdev_t *dev)
 {
         fb_instance_t *instance = (fb_instance_t *) dev->data;
         spinlock_lock(&instance->lock);
 
-        switch (ch) {
-        case '\n':
-                cursor_remove(instance);
-                instance->position += instance->cols;
-                instance->position -= instance->position % instance->cols;
-                break;
-        case '\r':
-                cursor_remove(instance);
-                instance->position -= instance->position % instance->cols;
-                break;
-        case '\b':
-                cursor_remove(instance);
-                if (instance->position % instance->cols)
-                        instance->position--;
-                break;
-        case '\t':
-                cursor_remove(instance);
-                do {
-                        glyph_draw(instance, fb_font_glyph(' '),
-                            instance->position % instance->cols,
-                            instance->position / instance->cols, false);
-                        instance->position++;
-                } while (((instance->position % instance->cols) % 8 != 0) &&
-                    (instance->position < instance->cols * instance->rows));
-                break;
-        default:
-                glyph_draw(instance, fb_font_glyph(ch),
-                    instance->position % instance->cols,
-                    instance->position / instance->cols, false);
-                instance->position++;
-        }
-
-        if (instance->position >= instance->cols * instance->rows) {
-                instance->position -= instance->cols;
-                screen_scroll(instance);
-        }
-
+        if (instance->offset_row >= instance->screen_rows / 2)
+                instance->offset_row -= instance->screen_rows / 2;
+        else
+                instance->offset_row = 0;
+
+        fb_redraw_internal(instance);
         cursor_put(instance);
 
@@ -465 +475 @@
 }
 
-/** Scroll the framebuffer up
- *
- */
-static void fb_scroll_up(outdev_t *dev)
+/** Scroll the framebuffer down
+ *
+ */
+static void fb_scroll_down(outdev_t *dev)
 {
         fb_instance_t *instance = (fb_instance_t *) dev->data;
         spinlock_lock(&instance->lock);
 
-        if (instance->offset_row >= instance->rowtrim / 2)
-                instance->offset_row -= instance->rowtrim / 2;
+        if (instance->offset_row + instance->screen_rows / 2 <=
+            instance->rows - instance->screen_rows)
+                instance->offset_row += instance->screen_rows / 2;
         else
-                instance->offset_row = 0;
-
-        fb_redraw_internal(instance);
-        cursor_put(instance);
-
-        spinlock_unlock(&instance->lock);
-}
-
-/** Scroll the framebuffer down
- *
- */
-static void fb_scroll_down(outdev_t *dev)
-{
-        fb_instance_t *instance = (fb_instance_t *) dev->data;
-        spinlock_lock(&instance->lock);
-
-        if (instance->offset_row + instance->rowtrim / 2 <=
-            instance->rows - instance->rowtrim)
-                instance->offset_row += instance->rowtrim / 2;
-        else
-                instance->offset_row = instance->rows - instance->rowtrim;
+                instance->offset_row = instance->rows - instance->screen_rows;
 
         fb_redraw_internal(instance);
@@ -615 +606 @@
         instance->scanline = props->scan;
 
-        instance->rowtrim = Y2ROW(instance->yres);
+        instance->screen_rows = Y2ROW(instance->yres);
 
         instance->cols = X2COL(instance->xres);
-        instance->rows = FB_PAGES * instance->rowtrim;
-
-        instance->start_row = instance->rows - instance->rowtrim;
+        instance->rows = FB_PAGES * instance->screen_rows;
+
+        instance->start_row = instance->rows - instance->screen_rows;
         instance->offset_row = instance->start_row;
-        instance->position = instance->start_row * instance->cols;
+        instance->row = instance->start_row;
+        instance->column = 0;
 
         instance->glyphscanline = FONT_WIDTH * instance->pixelbytes;

kernel/generic/include/console/chardev.h

@@ -81 +81 @@
 /** Output character device operations interface. */
 typedef struct {
-        /** Write character to output. */
-        void (*write)(struct outdev *, char32_t);
+        /** Write string to output. */
+        void (*write)(struct outdev *, const char *, size_t);
 
         /** Redraw any previously cached characters. */

kernel/generic/include/console/console.h

@@ -36 +36 @@
 #define KERN_CONSOLE_H_
 
-#include <typedefs.h>
-#include <print.h>
 #include <console/chardev.h>
 #include <synch/spinlock.h>
@@ -66 +64 @@
 extern void kio_update(void *);
 extern void kio_flush(void);
-extern void kio_push_char(const char32_t);
-SPINLOCK_EXTERN(kio_lock);
+extern void kio_push_bytes(const char *, size_t);
+extern irq_spinlock_t kio_lock;
 
+extern sysarg_t sys_kio_read(uspace_addr_t buf, size_t size, size_t at);
 extern sys_errno_t sys_kio(int cmd, uspace_addr_t buf, size_t size);
 
@@ -79 +78 @@
 extern void console_unlock(void);
 
+extern void putstr(const char *s, size_t n);
+
 #endif /* KERN_CONSOLE_H_ */
 

kernel/generic/include/stdio.h

@@ -37 +37 @@
 
 #include <print.h>
-#include <putchar.h>
 
 #endif

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 +36 @@
 
 #include <abi/kio.h>
-#include <arch.h>
-#include <assert.h>
-#include <atomic.h>
 #include <console/chardev.h>
 #include <console/console.h>
-#include <ddi/ddi.h>
-#include <ddi/irq.h>
 #include <errno.h>
 #include <ipc/event.h>
-#include <ipc/irq.h>
-#include <mm/frame.h> /* SIZE2FRAMES */
+#include <log.h>
 #include <panic.h>
 #include <preemption.h>
-#include <proc/thread.h>
-#include <putchar.h>
+#include <proc/task.h>
 #include <stdatomic.h>
 #include <stdio.h>
@@ -56 +50 @@
 #include <synch/mutex.h>
 #include <synch/spinlock.h>
-#include <synch/waitq.h>
 #include <syscall/copy.h>
 #include <sysinfo/sysinfo.h>
-#include <typedefs.h>
 
 #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 */
-char32_t kio[KIO_LENGTH] __attribute__((aligned(PAGE_SIZE)));
+static char kio[KIO_LENGTH];
 
 /** Kernel log initialized */
@@ -76 +68 @@
 static MUTEX_INITIALIZE(console_mutex, MUTEX_RECURSIVE);
 
-/** 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;
+/** 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;
 
 /** Kernel log spinlock */
-SPINLOCK_INITIALIZE_NAME(kio_lock, "kio_lock");
-
-/** Physical memory area used for kio buffer */
-static parea_t kio_parea;
+IRQ_SPINLOCK_INITIALIZE(kio_lock);
+
+static IRQ_SPINLOCK_INITIALIZE(flush_lock);
+
+static IRQ_SPINLOCK_INITIALIZE(early_mbstate_lock);
+static mbstate_t early_mbstate;
 
 static indev_t stdin_sink;
@@ -104 +95 @@
 };
 
-static void stdout_write(outdev_t *, char32_t);
+static void stdout_write(outdev_t *, const char *, size_t);
 static void stdout_redraw(outdev_t *);
 static void stdout_scroll_up(outdev_t *);
@@ -157 +148 @@
 }
 
-static void stdout_write(outdev_t *dev, char32_t ch)
+static void stdout_write(outdev_t *dev, const char *s, size_t n)
 {
         list_foreach(dev->list, link, outdev_t, sink) {
                 if ((sink) && (sink->op->write))
-                        sink->op->write(sink, ch);
+                        sink->op->write(sink, s, n);
         }
 }
@@ -190 +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);
@@ -257 +229 @@
                 return;
 
-        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);
+        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);
 }
 
@@ -278 +249 @@
                 return;
 
-        spinlock_lock(&kio_lock);
+        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];
 
         /* Print characters that weren't printed earlier */
-        while (kio_stored > 0) {
-                char32_t tmp = kio[(kio_start + kio_len - kio_stored) % KIO_LENGTH];
-                kio_stored--;
+        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;
 
                 /*
-                 * We need to give up the spinlock for
-                 * the physical operation of writing out
-                 * the character.
+                 * We need to give up the spinlock for the physical operation of writing
+                 * out the buffer.
                  */
-                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)
+                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)
 {
         bool ordy = ((stdout) && (stdout->op->write));
 
-        spinlock_lock(&kio_lock);
-        kio_push_char(ch);
-        spinlock_unlock(&kio_lock);
+        irq_spinlock_lock(&kio_lock, true);
+        kio_push_bytes(s, n);
+        irq_spinlock_unlock(&kio_lock, true);
 
         /* Output stored characters */
@@ -340 +341 @@
                  * 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);
+}
+
+/** 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;
 }
 

kernel/generic/src/console/kconsole.c

@@ -39 +39 @@
  */
 
+#include <adt/list.h>
+#include <arch.h>
 #include <assert.h>
-#include <console/kconsole.h>
-#include <console/console.h>
 #include <console/chardev.h>
 #include <console/cmd.h>
+#include <console/console.h>
+#include <console/kconsole.h>
 #include <console/prompt.h>
+#include <debug.h>
+#include <errno.h>
+#include <halt.h>
+#include <macros.h>
+#include <panic.h>
 #include <stdio.h>
-#include <panic.h>
+#include <stdlib.h>
+#include <str.h>
+#include <symtab.h>
+#include <sysinfo/sysinfo.h>
 #include <typedefs.h>
-#include <adt/list.h>
-#include <arch.h>
-#include <macros.h>
-#include <debug.h>
-#include <halt.h>
-#include <str.h>
-#include <sysinfo/sysinfo.h>
-#include <symtab.h>
-#include <errno.h>
-#include <putchar.h>
-#include <stdlib.h>
 
 /** Simple kernel console.
@@ -158 +157 @@
 
 /** Print count times a character */
-_NO_TRACE static void print_cc(char32_t ch, size_t count)
-{
-        size_t i;
-        for (i = 0; i < count; i++)
-                putuchar(ch);
+_NO_TRACE static void print_cc(char ch, size_t count)
+{
+        // FIXME: only lock once
+
+        for (size_t i = 0; i < count; i++)
+                putstr(&ch, 1);
 }
 
@@ -347 +347 @@
                 if (ch == '\n') {
                         /* Enter */
-                        putuchar(ch);
+                        putstr("\n", 1);
                         break;
                 }
@@ -358 +358 @@
                         if (wstr_remove(current, position - 1)) {
                                 position--;
-                                putuchar('\b');
+                                putstr("\b", 1);
                                 printf("%ls ", current + position);
                                 print_cc('\b', wstr_length(current) - position + 1);
@@ -368 +368 @@
                         /* Tab completion */
 
-                        /* Move to the end of the word */
-                        for (; (current[position] != 0) && (!isspace(current[position]));
-                            position++)
-                                putuchar(current[position]);
+                        size_t i = position;
+                        while (current[i] && !isspace(current[i]))
+                                i++;
+
+                        char32_t stash = current[i];
+                        current[i] = 0;
+                        printf("%ls", &current[position]);
+                        current[i] = stash;
+                        position = i;
 
                         /*
@@ -430 +435 @@
                          */
                         size_t off = 0;
-                        size_t i = 0;
-                        while ((ch = str_decode(tmp, &off, STR_NO_LIMIT)) != 0) {
+                        for (size_t i = 0; (ch = str_decode(tmp, &off, STR_NO_LIMIT)); i++)
                                 if (!wstr_linsert(current, ch, position + i, MAX_CMDLINE))
                                         break;
-
-                                i++;
-                        }
 
                         if (found > 1) {
@@ -466 +467 @@
                         /* Left */
                         if (position > 0) {
-                                putuchar('\b');
+                                putstr("\b", 1);
                                 position--;
                         }
@@ -475 +476 @@
                         /* Right */
                         if (position < wstr_length(current)) {
-                                putuchar(current[position]);
+                                printf("%lc", current[position]);
                                 position++;
                         }

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) {

kernel/generic/src/printf/vprintf.c

@@ -37 +37 @@
 #include <print.h>
 #include <printf_core.h>
-#include <putchar.h>
 #include <str.h>
 #include <synch/spinlock.h>
@@ -44 +43 @@
 static errno_t vprintf_str_write(const char *str, size_t size, void *data)
 {
-        size_t offset = 0;
-
-        while (offset < size)
-                putuchar(str_decode(str, &offset, size));
-
+        putstr(str, size);
         return EOK;
 }
@@ -54 +49 @@
 int puts(const char *str)
 {
-        size_t offset = 0;
-        size_t chars = 0;
-        char32_t uc;
-
-        console_lock();
-
-        while ((uc = str_decode(str, &offset, STR_NO_LIMIT)) != 0) {
-                putuchar(uc);
-                chars++;
-        }
-
-        putuchar('\n');
-
-        console_unlock();
-        return chars;
+        size_t n = str_size(str);
+        putstr(str, n);
+        return n;
 }
 

kernel/generic/src/syscall/syscall.c

@@ -137 +137 @@
 
         [SYS_KLOG] = (syshandler_t) sys_klog,
+        [SYS_KIO_READ] = (syshandler_t) sys_kio_read,
 };
 

kernel/test/print/print4.c

@@ -50 +50 @@
         }
 
-        TPRINTF("\nExtended ASCII characters (128 - 255) using printf(\"%%lc\"):\n");
+        TPRINTF("\nExtended ASCII characters (160 - 255) using printf(\"%%lc\"):\n");
 
-        for (group = 4; group < 8; group++) {
+        for (group = 5; group < 8; group++) {
                 TPRINTF("%#x: ", group << 5);
 

uspace/app/kio/kio.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2006 Ondrej Palkovsky
+ * Copyright (c) 2025 Jiří Zárevúcky
  * All rights reserved.
  *
@@ -34 +35 @@
  */
 
+#include <_bits/decls.h>
+#include <libarch/config.h>
 #include <stdio.h>
 #include <async.h>
@@ -47 +50 @@
 #include <adt/prodcons.h>
 #include <tinput.h>
+#include <uchar.h>
 #include <vfs/vfs.h>
 
@@ -55 +59 @@
 typedef struct {
         link_t link;
-        size_t length;
-        char32_t *data;
+        size_t bytes;
+        char *data;
 } item_t;
 
 static prodcons_t pc;
-
-/* Pointer to kio area */
-static char32_t *kio = (char32_t *) AS_AREA_ANY;
-static size_t kio_length;
 
 /* Notification mutex */
 static FIBRIL_MUTEX_INITIALIZE(mtx);
 
+#define READ_BUFFER_SIZE PAGE_SIZE
+
+static size_t current_at;
+static char read_buffer[READ_BUFFER_SIZE];
+
 /** Klog producer
  *
@@ -77 +82 @@
  *
  */
-static void producer(size_t length, char32_t *data)
-{
-        item_t *item = (item_t *) malloc(sizeof(item_t));
+static void producer(size_t bytes, char *data)
+{
+        item_t *item = malloc(sizeof(item_t));
         if (item == NULL)
                 return;
 
-        size_t sz = sizeof(char32_t) * length;
-        char32_t *buf = (char32_t *) malloc(sz);
-        if (buf == NULL) {
+        item->bytes = bytes;
+        item->data = malloc(bytes);
+        if (!item->data) {
                 free(item);
                 return;
         }
 
-        memcpy(buf, data, sz);
+        memcpy(item->data, data, bytes);
 
         link_initialize(&item->link);
-        item->length = length;
-        item->data = buf;
         prodcons_produce(&pc, &item->link);
 }
@@ -120 +123 @@
                 item_t *item = list_get_instance(link, item_t, link);
 
-                for (size_t i = 0; i < item->length; i++)
-                        putuchar(item->data[i]);
-
-                if (log != NULL) {
-                        for (size_t i = 0; i < item->length; i++)
-                                fputuc(item->data[i], log);
-
+                fwrite(item->data, 1, item->bytes, stdout);
+
+                if (log) {
+                        fwrite(item->data, 1, item->bytes, log);
                         fflush(log);
                         vfs_sync(fileno(log));
@@ -149 +149 @@
 static void kio_notification_handler(ipc_call_t *call, void *arg)
 {
+        size_t kio_written = (size_t) ipc_get_arg1(call);
+
         /*
          * Make sure we process only a single notification
          * at any time to limit the chance of the consumer
          * starving.
-         *
-         * Note: Usually the automatic masking of the kio
-         * notifications on the kernel side does the trick
-         * of limiting the chance of accidentally copying
-         * the same data multiple times. However, due to
-         * the non-blocking architecture of kio notifications,
-         * this possibility cannot be generally avoided.
          */
 
         fibril_mutex_lock(&mtx);
 
-        size_t kio_start = (size_t) ipc_get_arg1(call);
-        size_t kio_len = (size_t) ipc_get_arg2(call);
-        size_t kio_stored = (size_t) ipc_get_arg3(call);
-
-        size_t offset = (kio_start + kio_len - kio_stored) % kio_length;
-
-        /* Copy data from the ring buffer */
-        if (offset + kio_stored >= kio_length) {
-                size_t split = kio_length - offset;
-
-                producer(split, kio + offset);
-                producer(kio_stored - split, kio);
-        } else
-                producer(kio_stored, kio + offset);
+        while (current_at != kio_written) {
+                size_t read = kio_read(read_buffer, READ_BUFFER_SIZE, current_at);
+                if (read == 0)
+                        break;
+
+                current_at += read;
+
+                if (read > READ_BUFFER_SIZE) {
+                        /* We missed some data. */
+                        // TODO: Send a message with the number of lost characters to the consumer.
+                        read = READ_BUFFER_SIZE;
+                }
+
+                producer(read, read_buffer);
+        }
 
         async_event_unmask(EVENT_KIO);
@@ -185 +181 @@
 int main(int argc, char *argv[])
 {
-        size_t pages;
-        errno_t rc = sysinfo_get_value("kio.pages", &pages);
-        if (rc != EOK) {
-                fprintf(stderr, "%s: Unable to get number of kio pages\n",
-                    NAME);
-                return rc;
-        }
-
-        uintptr_t faddr;
-        rc = sysinfo_get_value("kio.faddr", &faddr);
-        if (rc != EOK) {
-                fprintf(stderr, "%s: Unable to get kio physical address\n",
-                    NAME);
-                return rc;
-        }
-
-        size_t size = pages * PAGE_SIZE;
-        kio_length = size / sizeof(char32_t);
-
-        rc = physmem_map(faddr, pages, AS_AREA_READ | AS_AREA_CACHEABLE,
-            (void *) &kio);
-        if (rc != EOK) {
-                fprintf(stderr, "%s: Unable to map kio\n", NAME);
-                return rc;
-        }
-
         prodcons_initialize(&pc);
-        rc = async_event_subscribe(EVENT_KIO, kio_notification_handler, NULL);
+        errno_t rc = async_event_subscribe(EVENT_KIO, kio_notification_handler, NULL);
         if (rc != EOK) {
                 fprintf(stderr, "%s: Unable to register kio notifications\n",

uspace/app/trace/syscalls.c

@@ -115 +115 @@
         [SYS_DEBUG_CONSOLE] = { "debug_console", 0, V_ERRNO },
 
-        [SYS_KLOG] = { "klog", 5, V_ERRNO }
+        [SYS_KLOG] = { "klog", 5, V_ERRNO },
+        [SYS_KIO_READ] = { "kio_read", 3, V_INTEGER },
 };
 

uspace/lib/c/generic/io/kio.c

@@ -34 +34 @@
  */
 
+#include <abi/syscall.h>
 #include <stddef.h>
 #include <libc.h>
@@ -112 +113 @@
 }
 
+size_t kio_read(char *buf, size_t n, size_t at)
+{
+        return __SYSCALL3(SYS_KIO_READ, (sysarg_t) buf, n, at);
+}
+
 /** Print formatted text to kio.
  *

uspace/lib/c/include/io/kio.h

@@ -36 +36 @@
 #define _LIBC_IO_KIO_H_
 
-#include <stddef.h>
-#include <stdarg.h>
-#include <io/verify.h>
 #include <_bits/errno.h>
 #include <_bits/size_t.h>
+#include <io/verify.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <uchar.h>
 
 extern void __kio_init(void);
@@ -50 +51 @@
     _HELENOS_PRINTF_ATTRIBUTE(1, 2);
 extern int kio_vprintf(const char *, va_list);
+
+extern size_t kio_read(char *buf, size_t n, size_t at);
 
 /*