Changeset 61c91532 in mainline for uspace/app/kio/kio.c

Timestamp:

2025-04-17T16:18:27Z (5 days ago)

Author:

GitHub <noreply@…>

Children:

634340fd

Parents:

a65ccc4 (diff), 888c06e (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:

Wayne Thornton <wmthornton-dev@…> (2025-04-17 16:18:27)

git-committer:

GitHub <noreply@…> (2025-04-17 16:18:27)

Message:

Merge branch 'HelenOS:master' into master

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