Changeset c4cfe4c in mainline for uspace/app/kio/kio.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:

• uspace/app/kio/kio.c (modified) (8 diffs)

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",