Changes in kernel/generic/src/console/console.c [b366a6f4:d7533c7] in mainline

File:

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

kernel/generic/src/console/console.c

@@ -53 +53 @@
 #include <str.h>
 
-#define KLOG_PAGES    8
+#define KLOG_PAGES    4
 #define KLOG_LENGTH   (KLOG_PAGES * PAGE_SIZE / sizeof(wchar_t))
+#define KLOG_LATENCY  8
 
 /** Kernel log cyclic buffer */
@@ -60 +61 @@
 
 /** Kernel log initialized */
-static atomic_t klog_inited = {false};
+static bool klog_inited = false;
 
 /** First kernel log characters */
@@ -75 +76 @@
 
 /** Kernel log spinlock */
-SPINLOCK_STATIC_INITIALIZE_NAME(klog_lock, "klog_lock");
+SPINLOCK_STATIC_INITIALIZE_NAME(klog_lock, "*klog_lock");
 
 /** Physical memory area used for klog buffer */
@@ -87 +88 @@
 };
 
-static void stdout_write(outdev_t *, wchar_t);
+static void stdout_write(outdev_t *, wchar_t, bool);
 static void stdout_redraw(outdev_t *);
 
@@ -95 +96 @@
 };
 
-/** Override kernel console lockout */
-bool console_override = false;
+/** Silence output */
+bool silent = false;
 
 /** Standard input and output character devices */
@@ -122 +123 @@
 }
 
-static void stdout_write(outdev_t *dev, wchar_t ch)
-{
-        list_foreach(dev->list, cur) {
+static void stdout_write(outdev_t *dev, wchar_t ch, bool silent)
+{
+        link_t *cur;
+        
+        for (cur = dev->list.next; cur != &dev->list; cur = cur->next) {
                 outdev_t *sink = list_get_instance(cur, outdev_t, link);
                 if ((sink) && (sink->op->write))
-                        sink->op->write(sink, ch);
+                        sink->op->write(sink, ch, silent);
         }
 }
@@ -133 +136 @@
 static void stdout_redraw(outdev_t *dev)
 {
-        list_foreach(dev->list, cur) {
+        link_t *cur;
+        
+        for (cur = dev->list.next; cur != &dev->list; cur = cur->next) {
                 outdev_t *sink = list_get_instance(cur, outdev_t, link);
                 if ((sink) && (sink->op->redraw))
@@ -156 +161 @@
         klog_parea.frames = SIZE2FRAMES(sizeof(klog));
         klog_parea.unpriv = false;
-        klog_parea.mapped = false;
         ddi_parea_register(&klog_parea);
         
@@ -162 +166 @@
         sysinfo_set_item_val("klog.pages", NULL, KLOG_PAGES);
         
-        event_set_unmask_callback(EVENT_KLOG, klog_update);
-        atomic_set(&klog_inited, true);
+        spinlock_lock(&klog_lock);
+        klog_inited = true;
+        spinlock_unlock(&klog_lock);
 }
 
 void grab_console(void)
 {
-        bool prev = console_override;
-        
-        console_override = true;
+        bool prev = silent;
+        
+        silent = false;
         if ((stdout) && (stdout->op->redraw))
                 stdout->op->redraw(stdout);
         
-        if ((stdin) && (!prev)) {
+        if ((stdin) && (prev)) {
                 /*
                  * Force the console to print the prompt.
@@ -184 +189 @@
 void release_console(void)
 {
-        console_override = false;
-}
-
-/** Activate kernel console override */
-sysarg_t sys_debug_activate_console(void)
+        // FIXME arch_release_console
+        silent = true;
+}
+
+/** Tell kernel to get keyboard/console access again */
+sysarg_t sys_debug_enable_console(void)
 {
 #ifdef CONFIG_KCONSOLE
@@ -196 +202 @@
         return false;
 #endif
+}
+
+/** Tell kernel to relinquish keyboard/console access */
+sysarg_t sys_debug_disable_console(void)
+{
+        release_console();
+        return true;
 }
 
@@ -250 +263 @@
 void klog_update(void)
 {
-        if (!atomic_get(&klog_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;
+        if ((klog_inited) && (event_is_subscribed(EVENT_KLOG)) && (klog_uspace > 0)) {
+                event_notify_3(EVENT_KLOG, klog_start, klog_len, klog_uspace);
+                klog_uspace = 0;
         }
         
@@ -266 +275 @@
 void putchar(const wchar_t ch)
 {
-        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);
-                }
+        if ((klog_stored > 0) && (stdout) && (stdout->op->write)) {
+                /* Print charaters stored in kernel log */
+                size_t i;
+                for (i = klog_len - klog_stored; i < klog_len; i++)
+                        stdout->op->write(stdout, klog[(klog_start + i) % KLOG_LENGTH], silent);
+                klog_stored = 0;
         }
         
@@ -294 +292 @@
                 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) {
-                /*
-                 * Output the character. In this case
-                 * it should be no longer buffered.
-                 */
-                stdout->op->write(stdout, ch);
-        } else {
+        if ((stdout) && (stdout->op->write))
+                stdout->op->write(stdout, ch, silent);
+        else {
                 /*
                  * No standard output routine defined yet.
@@ -321 +304 @@
                  * Note that the early_putc() function might be
                  * a no-op on certain hardware configurations.
+                 *
                  */
                 early_putchar(ch);
-        }
-        
-        /* Force notification on newline */
-        if (ch == '\n')
+                
+                if (klog_stored < klog_len)
+                        klog_stored++;
+        }
+        
+        /* The character is stored for uspace */
+        if (klog_uspace < klog_len)
+                klog_uspace++;
+        
+        /* Check notify uspace to update */
+        bool update;
+        if ((klog_uspace > KLOG_LATENCY) || (ch == '\n'))
+                update = true;
+        else
+                update = false;
+        
+        spinlock_unlock(&klog_lock);
+        
+        if (update)
                 klog_update();
 }