Changes in kernel/generic/src/console/console.c [91db0280:feeac0d] in mainline

File:

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

kernel/generic/src/console/console.c

@@ -52 +52 @@
 #include <errno.h>
 #include <str.h>
-#include <abi/kio.h>
-
-#define KIO_PAGES    8
-#define KIO_LENGTH   (KIO_PAGES * PAGE_SIZE / sizeof(wchar_t))
+#include <abi/klog.h>
+
+#define KLOG_PAGES    8
+#define KLOG_LENGTH   (KLOG_PAGES * PAGE_SIZE / sizeof(wchar_t))
 
 /** Kernel log cyclic buffer */
-wchar_t kio[KIO_LENGTH] __attribute__((aligned(PAGE_SIZE)));
+wchar_t klog[KLOG_LENGTH] __attribute__((aligned(PAGE_SIZE)));
 
 /** Kernel log initialized */
-static atomic_t kio_inited = {false};
+static atomic_t klog_inited = {false};
 
 /** First kernel log characters */
-static size_t kio_start = 0;
+static size_t klog_start = 0;
 
 /** Number of valid kernel log characters */
-static size_t kio_len = 0;
+static size_t klog_len = 0;
 
 /** Number of stored (not printed) kernel log characters */
-static size_t kio_stored = 0;
+static size_t klog_stored = 0;
 
 /** Number of stored kernel log characters for uspace */
-static size_t kio_uspace = 0;
+static size_t klog_uspace = 0;
 
 /** Kernel log spinlock */
-SPINLOCK_INITIALIZE_NAME(kio_lock, "kio_lock");
-
-/** Physical memory area used for kio buffer */
-static parea_t kio_parea;
+SPINLOCK_STATIC_INITIALIZE_NAME(klog_lock, "klog_lock");
+
+/** Physical memory area used for klog buffer */
+static parea_t klog_parea;
 
 static indev_t stdin_sink;
@@ -146 +146 @@
  *
  */
-void kio_init(void)
-{
-        void *faddr = (void *) KA2PA(kio);
+void klog_init(void)
+{
+        void *faddr = (void *) KA2PA(klog);
         
         ASSERT((uintptr_t) faddr % FRAME_SIZE == 0);
         
-        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_set(&kio_inited, true);
+        klog_parea.pbase = (uintptr_t) faddr;
+        klog_parea.frames = SIZE2FRAMES(sizeof(klog));
+        klog_parea.unpriv = false;
+        klog_parea.mapped = false;
+        ddi_parea_register(&klog_parea);
+        
+        sysinfo_set_item_val("klog.faddr", NULL, (sysarg_t) faddr);
+        sysinfo_set_item_val("klog.pages", NULL, KLOG_PAGES);
+        
+        event_set_unmask_callback(EVENT_KLOG, klog_update);
+        atomic_set(&klog_inited, true);
 }
 
@@ -247 +247 @@
 }
 
-void kio_update(void *event)
-{
-        if (!atomic_get(&kio_inited))
+void klog_update(void *event)
+{
+        if (!atomic_get(&klog_inited))
                 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);
-}
-
-/** Flush characters that are stored in the output buffer
- * 
- */
-void kio_flush(void)
+        spinlock_lock(&klog_lock);
+        
+        if (klog_uspace > 0) {
+                if (event_notify_3(EVENT_KLOG, true, klog_start, klog_len,
+                    klog_uspace) == EOK)
+                        klog_uspace = 0;
+        }
+        
+        spinlock_unlock(&klog_lock);
+}
+
+void putchar(const wchar_t ch)
 {
         bool ordy = ((stdout) && (stdout->op->write));
         
-        if (!ordy)
-                return;
-
-        spinlock_lock(&kio_lock);
-
-        /* Print characters that weren't printed earlier */
-        while (kio_stored > 0) {
-                wchar_t tmp = kio[(kio_start + kio_len - kio_stored) % KIO_LENGTH];
-                kio_stored--;
-
+        spinlock_lock(&klog_lock);
+        
+        /* Print charaters stored in kernel log */
+        if (ordy) {
+                while (klog_stored > 0) {
+                        wchar_t tmp = klog[(klog_start + klog_len - klog_stored) % KLOG_LENGTH];
+                        klog_stored--;
+                        
+                        /*
+                         * We need to give up the spinlock for
+                         * the physical operation of writting out
+                         * the character.
+                         */
+                        spinlock_unlock(&klog_lock);
+                        stdout->op->write(stdout, tmp);
+                        spinlock_lock(&klog_lock);
+                }
+        }
+        
+        /* Store character in the cyclic kernel log */
+        klog[(klog_start + klog_len) % KLOG_LENGTH] = ch;
+        if (klog_len < KLOG_LENGTH)
+                klog_len++;
+        else
+                klog_start = (klog_start + 1) % KLOG_LENGTH;
+        
+        if (!ordy) {
+                if (klog_stored < klog_len)
+                        klog_stored++;
+        }
+        
+        /* The character is stored for uspace */
+        if (klog_uspace < klog_len)
+                klog_uspace++;
+        
+        spinlock_unlock(&klog_lock);
+        
+        if (ordy) {
                 /*
-                 * We need to give up the spinlock for
-                 * the physical operation of writing out
-                 * the character.
+                 * Output the character. In this case
+                 * it should be no longer buffered.
                  */
-                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 wchar_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 putchar(const wchar_t ch)
-{
-        bool ordy = ((stdout) && (stdout->op->write));
-        
-        spinlock_lock(&kio_lock);
-        kio_push_char(ch);
-        spinlock_unlock(&kio_lock);
-        
-        /* Output stored characters */
-        kio_flush();
-        
-        if (!ordy) {
+                stdout->op->write(stdout, ch);
+        } else {
                 /*
                  * No standard output routine defined yet.
@@ -340 +326 @@
         /* Force notification on newline */
         if (ch == '\n')
-                kio_update(NULL);
+                klog_update(NULL);
 }
 
@@ -348 +334 @@
  *
  */
-sysarg_t sys_kio(int cmd, const void *buf, size_t size)
+sysarg_t sys_klog(int cmd, const void *buf, size_t size)
 {
         char *data;
@@ -354 +340 @@
 
         switch (cmd) {
-        case KIO_UPDATE:
-                kio_update(NULL);
+        case KLOG_UPDATE:
+                klog_update(NULL);
                 return EOK;
-        case KIO_WRITE:
-        case KIO_COMMAND:
+        case KLOG_WRITE:
+        case KLOG_COMMAND:
                 break;
         default:
@@ -380 +366 @@
                 
                 switch (cmd) {
-                case KIO_WRITE:
+                case KLOG_WRITE:
                         printf("%s", data);
                         break;
-                case KIO_COMMAND:
+                case KLOG_COMMAND:
                         if (!stdin)
                                 break;