Changes in kernel/generic/src/console/console.c [1066041:593e023] in mainline

File:

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

kernel/generic/src/console/console.c

@@ -52 +52 @@
 #include <errno.h>
 #include <str.h>
-#include <mm/frame.h> /* SIZE2FRAMES */
-#include <mm/slab.h>  /* malloc */
-
-#define KLOG_PAGES    8
-#define KLOG_LENGTH   (KLOG_PAGES * PAGE_SIZE / sizeof(wchar_t))
+#include <abi/kio.h>
+
+#define KIO_PAGES    8
+#define KIO_LENGTH   (KIO_PAGES * PAGE_SIZE / sizeof(wchar_t))
 
 /** Kernel log cyclic buffer */
-wchar_t klog[KLOG_LENGTH] __attribute__((aligned(PAGE_SIZE)));
+wchar_t kio[KIO_LENGTH] __attribute__((aligned(PAGE_SIZE)));
 
 /** Kernel log initialized */
-static atomic_t klog_inited = {false};
+static atomic_t kio_inited = {false};
 
 /** First kernel log characters */
-static size_t klog_start = 0;
+static size_t kio_start = 0;
 
 /** Number of valid kernel log characters */
-static size_t klog_len = 0;
+static size_t kio_len = 0;
 
 /** Number of stored (not printed) kernel log characters */
-static size_t klog_stored = 0;
+static size_t kio_stored = 0;
 
 /** Number of stored kernel log characters for uspace */
-static size_t klog_uspace = 0;
+static size_t kio_uspace = 0;
 
 /** Kernel log spinlock */
-SPINLOCK_STATIC_INITIALIZE_NAME(klog_lock, "klog_lock");
-
-/** Physical memory area used for klog buffer */
-static parea_t klog_parea;
+SPINLOCK_INITIALIZE_NAME(kio_lock, "kio_lock");
+
+/** Physical memory area used for kio buffer */
+static parea_t kio_parea;
 
 static indev_t stdin_sink;
 static outdev_t stdout_source;
 
+static void stdin_signal(indev_t *, indev_signal_t);
+
 static indev_operations_t stdin_ops = {
-        .poll = NULL
+        .poll = NULL,
+        .signal = stdin_signal
 };
 
 static void stdout_write(outdev_t *, wchar_t);
 static void stdout_redraw(outdev_t *);
+static void stdout_scroll_up(outdev_t *);
+static void stdout_scroll_down(outdev_t *);
 
 static outdev_operations_t stdout_ops = {
         .write = stdout_write,
-        .redraw = stdout_redraw
+        .redraw = stdout_redraw,
+        .scroll_up = stdout_scroll_up,
+        .scroll_down = stdout_scroll_down
 };
 
@@ -114 +120 @@
 }
 
+static void stdin_signal(indev_t *indev, indev_signal_t signal)
+{
+        switch (signal) {
+        case INDEV_SIGNAL_SCROLL_UP:
+                if (stdout != NULL)
+                        stdout_scroll_up(stdout);
+                break;
+        case INDEV_SIGNAL_SCROLL_DOWN:
+                if (stdout != NULL)
+                        stdout_scroll_down(stdout);
+                break;
+        }
+}
+
 void stdout_wire(outdev_t *outdev)
 {
@@ -126 +146 @@
 static void stdout_write(outdev_t *dev, wchar_t ch)
 {
-        list_foreach(dev->list, cur) {
-                outdev_t *sink = list_get_instance(cur, outdev_t, link);
+        list_foreach(dev->list, link, outdev_t, sink) {
                 if ((sink) && (sink->op->write))
                         sink->op->write(sink, ch);
@@ -135 +154 @@
 static void stdout_redraw(outdev_t *dev)
 {
-        list_foreach(dev->list, cur) {
-                outdev_t *sink = list_get_instance(cur, outdev_t, link);
+        list_foreach(dev->list, link, outdev_t, sink) {
                 if ((sink) && (sink->op->redraw))
                         sink->op->redraw(sink);
+        }
+}
+
+static void stdout_scroll_up(outdev_t *dev)
+{
+        list_foreach(dev->list, link, outdev_t, sink) {
+                if ((sink) && (sink->op->scroll_up))
+                        sink->op->scroll_up(sink);
+        }
+}
+
+static void stdout_scroll_down(outdev_t *dev)
+{
+        list_foreach(dev->list, link, outdev_t, sink) {
+                if ((sink) && (sink->op->scroll_down))
+                        sink->op->scroll_down(sink);
         }
 }
@@ -149 +183 @@
  *
  */
-void klog_init(void)
-{
-        void *faddr = (void *) KA2PA(klog);
+void kio_init(void)
+{
+        void *faddr = (void *) KA2PA(kio);
         
         ASSERT((uintptr_t) faddr % FRAME_SIZE == 0);
         
-        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);
+        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);
 }
 
 void grab_console(void)
 {
+        event_notify_1(EVENT_KCONSOLE, false, true);
         bool prev = console_override;
         
@@ -187 +222 @@
 {
         console_override = false;
+        event_notify_1(EVENT_KCONSOLE, false, false);
 }
 
 /** Activate kernel console override */
-sysarg_t sys_debug_activate_console(void)
+sysarg_t sys_debug_console(void)
 {
 #ifdef CONFIG_KCONSOLE
@@ -232 +268 @@
                         }
                 }
+                
                 if (chr_encode(ch, buf, &offset, buflen - 1) == EOK) {
                         putchar(ch);
@@ -250 +287 @@
 }
 
-void klog_update(void *event)
-{
-        if (!atomic_get(&klog_inited))
+void kio_update(void *event)
+{
+        if (!atomic_get(&kio_inited))
                 return;
         
-        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);
+        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)
+{
+        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--;
+
+                /*
+                 * We need to give up the spinlock for
+                 * the physical operation of writing out
+                 * the character.
+                 */
+                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++;
 }
 
@@ -270 +357 @@
         bool ordy = ((stdout) && (stdout->op->write));
         
-        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;
+        spinlock_lock(&kio_lock);
+        kio_push_char(ch);
+        spinlock_unlock(&kio_lock);
+        
+        /* Output stored characters */
+        kio_flush();
         
         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) {
-                /*
-                 * Output the character. In this case
-                 * it should be no longer buffered.
-                 */
-                stdout->op->write(stdout, ch);
-        } else {
                 /*
                  * No standard output routine defined yet.
@@ -329 +380 @@
         /* Force notification on newline */
         if (ch == '\n')
-                klog_update(NULL);
+                kio_update(NULL);
 }
 
@@ -337 +388 @@
  *
  */
-sysarg_t sys_klog(int fd, const void *buf, size_t size)
+sysarg_t sys_kio(int cmd, const void *buf, size_t size)
 {
         char *data;
         int rc;
-        
+
+        switch (cmd) {
+        case KIO_UPDATE:
+                kio_update(NULL);
+                return EOK;
+        case KIO_WRITE:
+        case KIO_COMMAND:
+                break;
+        default:
+                return ENOTSUP;
+        }
+
         if (size > PAGE_SIZE)
                 return (sysarg_t) ELIMIT;
@@ -357 +419 @@
                 data[size] = 0;
                 
-                printf("%s", data);
+                switch (cmd) {
+                case KIO_WRITE:
+                        printf("%s", data);
+                        break;
+                case KIO_COMMAND:
+                        if (!stdin)
+                                break;
+                        for (unsigned int i = 0; i < size; i++)
+                                indev_push_character(stdin, data[i]);
+                        indev_push_character(stdin, '\n');
+                        break;
+                }
+
                 free(data);
-        } else
-                klog_update(NULL);
-        
+        }
+
         return size;
 }