1 files changed, 21 insertions, 33 deletions

diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c
index 5bc54478c963..6e1b21a8a497 100644
--- a/kernel/printk/printk.c
+++ b/kernel/printk/printk.c
@@ -249,9 +249,6 @@ static char __log_buf[__LOG_BUF_LEN] __aligned(LOG_ALIGN);
 static char *log_buf = __log_buf;
 static u32 log_buf_len = __LOG_BUF_LEN;
 
-/* cpu currently holding logbuf_lock */
-static volatile unsigned int logbuf_cpu = UINT_MAX;
-
 /* human readable text of the record */
 static char *log_text(const struct printk_log *msg)
 {
@@ -1380,7 +1377,10 @@ static void zap_locks(void)
         sema_init(&console_sem, 1);
 }
 
-/* Check if we have any console registered that can be called early in boot. */
+/*
+ * Check if we have any console that is capable of printing while cpu is
+ * booting or shutting down. Requires console_sem.
+ */
 static int have_callable_console(void)
 {
         struct console *con;
@@ -1410,36 +1410,22 @@ static inline int can_use_console(unsigned int cpu)
  * messages from a 'printk'. Return true (and with the
  * console_lock held, and 'console_locked' set) if it
  * is successful, false otherwise.
- *
- * This gets called with the 'logbuf_lock' spinlock held and
- * interrupts disabled. It should return with 'lockbuf_lock'
- * released but interrupts still disabled.
  */
 static int console_trylock_for_printk(unsigned int cpu)
-        __releases(&logbuf_lock)
 {
-        int retval = 0, wake = 0;
-
-        if (console_trylock()) {
-                retval = 1;
-
-                /*
-                 * If we can't use the console, we need to release
-                 * the console semaphore by hand to avoid flushing
-                 * the buffer. We need to hold the console semaphore
-                 * in order to do this test safely.
-                 */
-                if (!can_use_console(cpu)) {
-                        console_locked = 0;
-                        wake = 1;
-                        retval = 0;
-                }
-        }
-        logbuf_cpu = UINT_MAX;
-        raw_spin_unlock(&logbuf_lock);
-        if (wake)
+        if (!console_trylock())
+                return 0;
+        /*
+         * If we can't use the console, we need to release the console
+         * semaphore by hand to avoid flushing the buffer. We need to hold the
+         * console semaphore in order to do this test safely.
+         */
+        if (!can_use_console(cpu)) {
+                console_locked = 0;
                 up(&console_sem);
-        return retval;
+                return 0;
+        }
+        return 1;
 }
 
 int printk_delay_msec __read_mostly;
@@ -1572,6 +1558,9 @@ asmlinkage int vprintk_emit(int facility, int level,
         unsigned long flags;
         int this_cpu;
         int printed_len = 0;
+        /* cpu currently holding logbuf_lock in this function */
+        static volatile unsigned int logbuf_cpu = UINT_MAX;
+
 
         boot_delay_msec(level);
         printk_delay();
@@ -1694,13 +1683,12 @@ asmlinkage int vprintk_emit(int facility, int level,
                                                  dict, dictlen, text, text_len);
         }
 
+        logbuf_cpu = UINT_MAX;
+        raw_spin_unlock(&logbuf_lock);
         /*
          * Try to acquire and then immediately release the console semaphore.
          * The release will print out buffers and wake up /dev/kmsg and syslog()
          * users.
-         *
-         * The console_trylock_for_printk() function will release 'logbuf_lock'
-         * regardless of whether it actually gets the console semaphore or not.
          */
         if (console_trylock_for_printk(this_cpu))
                 console_unlock();