1 files changed, 54 insertions, 77 deletions

diff --git a/kernel/printk.c b/kernel/printk.c
index e2129e83fd75..a7f7559c5f6c 100644
--- a/kernel/printk.c
+++ b/kernel/printk.c
@@ -38,7 +38,7 @@
 /*
  * Architectures can override it:
  */
-void __attribute__((weak)) early_printk(const char *fmt, ...)
+void asmlinkage __attribute__((weak)) early_printk(const char *fmt, ...)
 {
 }
 
@@ -75,6 +75,8 @@ EXPORT_SYMBOL(oops_in_progress);
 static DECLARE_MUTEX(console_sem);
 static DECLARE_MUTEX(secondary_console_sem);
 struct console *console_drivers;
+EXPORT_SYMBOL_GPL(console_drivers);
+
 /*
  * This is used for debugging the mess that is the VT code by
  * keeping track if we have the console semaphore held. It's
@@ -121,6 +123,8 @@ struct console_cmdline
 static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];
 static int selected_console = -1;
 static int preferred_console = -1;
+int console_set_on_cmdline;
+EXPORT_SYMBOL(console_set_on_cmdline);
 
 /* Flag: console code may call schedule() */
 static int console_may_schedule;
@@ -231,7 +235,7 @@ static inline void boot_delay_msec(void)
 /*
  * Return the number of unread characters in the log buffer.
  */
-int log_buf_get_len(void)
+static int log_buf_get_len(void)
 {
         return logged_chars;
 }
@@ -268,19 +272,6 @@ int log_buf_copy(char *dest, int idx, int len)
 }
 
 /*
- * Extract a single character from the log buffer.
- */
-int log_buf_read(int idx)
-{
-        char ret;
-
-        if (log_buf_copy(&ret, idx, 1) == 1)
-                return ret;
-        else
-                return -1;
-}
-
-/*
  * Commands to do_syslog:
  *
  *      0 -- Close the log.  Currently a NOP.
@@ -665,18 +656,17 @@ static int acquire_console_semaphore_for_printk(unsigned int cpu)
         spin_unlock(&logbuf_lock);
         return retval;
 }
-
-static const char printk_recursion_bug_msg [] =
-                        KERN_CRIT "BUG: recent printk recursion!\n";
-static int printk_recursion_bug;
+static const char recursion_bug_msg [] =
+                KERN_CRIT "BUG: recent printk recursion!\n";
+static int recursion_bug;
+        static int new_text_line = 1;
+static char printk_buf[1024];
 
 asmlinkage int vprintk(const char *fmt, va_list args)
 {
-        static int log_level_unknown = 1;
-        static char printk_buf[1024];
-
-        unsigned long flags;
         int printed_len = 0;
+        int current_log_level = default_message_loglevel;
+        unsigned long flags;
         int this_cpu;
         char *p;
 
@@ -699,7 +689,7 @@ asmlinkage int vprintk(const char *fmt, va_list args)
                  * it can be printed at the next appropriate moment:
                  */
                 if (!oops_in_progress) {
-                        printk_recursion_bug = 1;
+                        recursion_bug = 1;
                         goto out_restore_irqs;
                 }
                 zap_locks();
@@ -709,70 +699,62 @@ asmlinkage int vprintk(const char *fmt, va_list args)
         spin_lock(&logbuf_lock);
         printk_cpu = this_cpu;
 
-        if (printk_recursion_bug) {
-                printk_recursion_bug = 0;
-                strcpy(printk_buf, printk_recursion_bug_msg);
-                printed_len = sizeof(printk_recursion_bug_msg);
+        if (recursion_bug) {
+                recursion_bug = 0;
+                strcpy(printk_buf, recursion_bug_msg);
+                printed_len = sizeof(recursion_bug_msg);
         }
         /* Emit the output into the temporary buffer */
         printed_len += vscnprintf(printk_buf + printed_len,
                                   sizeof(printk_buf) - printed_len, fmt, args);
 
+
         /*
          * Copy the output into log_buf.  If the caller didn't provide
          * appropriate log level tags, we insert them here
          */
         for (p = printk_buf; *p; p++) {
-                if (log_level_unknown) {
-                        /* log_level_unknown signals the start of a new line */
+                if (new_text_line) {
+                        /* If a token, set current_log_level and skip over */
+                        if (p[0] == '<' && p[1] >= '0' && p[1] <= '7' &&
+                            p[2] == '>') {
+                                current_log_level = p[1] - '0';
+                                p += 3;
+                                printed_len -= 3;
+                        }
+
+                        /* Always output the token */
+                        emit_log_char('<');
+                        emit_log_char(current_log_level + '0');
+                        emit_log_char('>');
+                        printed_len += 3;
+                        new_text_line = 0;
+
                         if (printk_time) {
-                                int loglev_char;
+                                /* Follow the token with the time */
                                 char tbuf[50], *tp;
                                 unsigned tlen;
                                 unsigned long long t;
                                 unsigned long nanosec_rem;
 
-                                /*
-                                 * force the log level token to be
-                                 * before the time output.
-                                 */
-                                if (p[0] == '<' && p[1] >='0' &&
-                                   p[1] <= '7' && p[2] == '>') {
-                                        loglev_char = p[1];
-                                        p += 3;
-                                        printed_len -= 3;
-                                } else {
-                                        loglev_char = default_message_loglevel
-                                                + '0';
-                                }
                                 t = cpu_clock(printk_cpu);
                                 nanosec_rem = do_div(t, 1000000000);
-                                tlen = sprintf(tbuf,
-                                                "<%c>[%5lu.%06lu] ",
-                                                loglev_char,
-                                                (unsigned long)t,
-                                                nanosec_rem/1000);
+                                tlen = sprintf(tbuf, "[%5lu.%06lu] ",
+                                                (unsigned long) t,
+                                                nanosec_rem / 1000);
 
                                 for (tp = tbuf; tp < tbuf + tlen; tp++)
                                         emit_log_char(*tp);
                                 printed_len += tlen;
-                        } else {
-                                if (p[0] != '<' || p[1] < '0' ||
-                                   p[1] > '7' || p[2] != '>') {
-                                        emit_log_char('<');
-                                        emit_log_char(default_message_loglevel
-                                                + '0');
-                                        emit_log_char('>');
-                                        printed_len += 3;
-                                }
                         }
-                        log_level_unknown = 0;
+
                         if (!*p)
                                 break;
                 }
+
                 emit_log_char(*p);
                 if (*p == '\n')
-                        log_level_unknown = 1;
+                        new_text_line = 1;
         }
 
         /*
@@ -890,6 +872,7 @@ static int __init console_setup(char *str)
         *s = 0;
 
         __add_preferred_console(buf, idx, options, brl_options);
+        console_set_on_cmdline = 1;
         return 1;
 }
 __setup("console=", console_setup);
@@ -950,7 +933,7 @@ void suspend_console(void)
 {
         if (!console_suspend_enabled)
                 return;
-        printk("Suspending console(s)\n");
+        printk("Suspending console(s) (use no_console_suspend to debug)\n");
         acquire_console_sem();
         console_suspended = 1;
 }
@@ -1041,7 +1024,9 @@ void release_console_sem(void)
                 _log_end = log_end;
                 con_start = log_end;            /* Flush */
                 spin_unlock(&logbuf_lock);
+                stop_critical_timings();        /* don't trace print latency */
                 call_console_drivers(_con_start, _log_end);
+                start_critical_timings();
                 local_irq_restore(flags);
         }
         console_locked = 0;
@@ -1172,8 +1157,11 @@ void register_console(struct console *console)
                         console->index = 0;
                 if (console->setup == NULL ||
                     console->setup(console, NULL) == 0) {
-                        console->flags |= CON_ENABLED | CON_CONSDEV;
-                        preferred_console = 0;
+                        console->flags |= CON_ENABLED;
+                        if (console->device) {
+                                console->flags |= CON_CONSDEV;
+                                preferred_console = 0;
+                        }
                 }
         }
 
@@ -1320,6 +1308,8 @@ void tty_write_message(struct tty_struct *tty, char *msg)
 }
 
 #if defined CONFIG_PRINTK
+
+DEFINE_RATELIMIT_STATE(printk_ratelimit_state, 5 * HZ, 10);
 /*
  * printk rate limiting, lifted from the networking subsystem.
  *
@@ -1327,22 +1317,9 @@ void tty_write_message(struct tty_struct *tty, char *msg)
  * every printk_ratelimit_jiffies to make a denial-of-service
  * attack impossible.
  */
-int __printk_ratelimit(int ratelimit_jiffies, int ratelimit_burst)
-{
-        return __ratelimit(ratelimit_jiffies, ratelimit_burst);
-}
-EXPORT_SYMBOL(__printk_ratelimit);
-
-/* minimum time in jiffies between messages */
-int printk_ratelimit_jiffies = 5 * HZ;
-
-/* number of messages we send before ratelimiting */
-int printk_ratelimit_burst = 10;
-
 int printk_ratelimit(void)
 {
-        return __printk_ratelimit(printk_ratelimit_jiffies,
-                                printk_ratelimit_burst);
+        return __ratelimit(&printk_ratelimit_state);
 }
 EXPORT_SYMBOL(printk_ratelimit);