Changeset af77459 in mainline

Timestamp:

2025-04-17T15:14:03Z (5 days ago)

Author:

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

Branches:

master

Children:

571cc2d

Parents:

1db4e2ae

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2025-04-11 15:27:51)

git-committer:

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

Message:

Simplify kio buffer bookkeeping

We only really need to know the number of characters written.
The rest is easily inferred from buffer size.

Files:

• kernel/generic/src/console/console.c (modified) (4 diffs)
• uspace/app/kio/kio.c (modified) (2 diffs)

kernel/generic/src/console/console.c

@@ -76 +76 @@
 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 */
@@ -259 +256 @@
         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;
+        if (kio_notified != kio_written) {
+                if (event_notify_1(EVENT_KIO, true, kio_written) == EOK)
+                        kio_notified = kio_written;
         }
 
@@ -281 +277 @@
 
         /* 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) {
+                char32_t tmp = kio[kio_processed % KIO_LENGTH];
+                kio_processed++;
 
                 /*
@@ -304 +300 @@
 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++;
+        kio[kio_written % KIO_LENGTH] = ch;
+        kio_written++;
 }
 

uspace/app/kio/kio.c

@@ -68 +68 @@
 static FIBRIL_MUTEX_INITIALIZE(mtx);
 
+static size_t last_notification;
+
 /** Klog producer
  *
@@ -153 +155 @@
          * 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;
+        size_t kio_written = (size_t) ipc_get_arg1(call);
+
+        /* This works just fine even when kio_written overflows. */
+        size_t new_chars = kio_written - last_notification;
+        last_notification = kio_written;
+
+        if (new_chars > kio_length) {
+                /* We missed some data. */
+                // TODO: Send a message with the number of lost bytes to the consumer.
+                new_chars = kio_length;
+        }
+
+        size_t offset = (kio_written - new_chars) % kio_length;
 
         /* Copy data from the ring buffer */
-        if (offset + kio_stored >= kio_length) {
+        if (offset + new_chars > kio_length) {
                 size_t split = kio_length - offset;
 
                 producer(split, kio + offset);
-                producer(kio_stored - split, kio);
-        } else
-                producer(kio_stored, kio + offset);
+                producer(new_chars - split, kio);
+        } else {
+                producer(new_chars, kio + offset);
+        }
 
         async_event_unmask(EVENT_KIO);