We use printk-safe now which makes printk-recursion detection code
in vprintk_emit() unreachable. The tricky thing here is that, apart
from detecting and reporting printk recursions, that code also used
to zap_locks() in case of panic() from the same CPU. However,
zap_locks() does not look to be needed anymore:

1) Since commit 08d78658f393 ("panic: release stale console lock to
   always get the logbuf printed out") panic flushing of `logbuf' to
   console ignores the state of `console_sem' by doing
        panic()
                console_trylock();
                console_unlock();

2) Since commit cf9b1106c81c ("printk/nmi: flush NMI messages on the
   system panic") panic attempts to zap the `logbuf_lock' spin_lock to
   successfully flush nmi messages to `logbuf'.

Basically, it seems that we either already do what zap_locks() used to
do but in other places or we ignore the state of the lock. The only
reaming difference is that we don't re-init the console semaphore in
printk_safe_flush_on_panic(), but this is not necessary because we
don't call console drivers from printk_safe_flush_on_panic() due to
the fact that we are using a deferred printk() version (as was
suggested by Petr Mladek).

Signed-off-by: Sergey Senozhatsky <sergey.senozhat...@gmail.com>
---
 kernel/printk/printk.c | 61 --------------------------------------------------
 1 file changed, 61 deletions(-)

diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c
index 80f0177..729dd71 100644
--- a/kernel/printk/printk.c
+++ b/kernel/printk/printk.c
@@ -1600,28 +1600,6 @@ static void call_console_drivers(int level,
        }
 }
 
-/*
- * Zap console related locks when oopsing.
- * To leave time for slow consoles to print a full oops,
- * only zap at most once every 30 seconds.
- */
-static void zap_locks(void)
-{
-       static unsigned long oops_timestamp;
-
-       if (time_after_eq(jiffies, oops_timestamp) &&
-           !time_after(jiffies, oops_timestamp + 30 * HZ))
-               return;
-
-       oops_timestamp = jiffies;
-
-       debug_locks_off();
-       /* If a crash is occurring, make sure we can't deadlock */
-       raw_spin_lock_init(&logbuf_lock);
-       /* And make sure that we print immediately */
-       sema_init(&console_sem, 1);
-}
-
 int printk_delay_msec __read_mostly;
 
 static inline void printk_delay(void)
@@ -1782,17 +1760,13 @@ asmlinkage int vprintk_emit(int facility, int level,
                            const char *dict, size_t dictlen,
                            const char *fmt, va_list args)
 {
-       static bool recursion_bug;
        static char textbuf[LOG_LINE_MAX];
        char *text = textbuf;
        size_t text_len = 0;
        enum log_flags lflags = 0;
        unsigned long flags;
-       int this_cpu;
        int printed_len = 0;
        bool in_sched = false;
-       /* cpu currently holding logbuf_lock in this function */
-       static unsigned int logbuf_cpu = UINT_MAX;
 
        if (level == LOGLEVEL_SCHED) {
                level = LOGLEVEL_DEFAULT;
@@ -1803,42 +1777,8 @@ asmlinkage int vprintk_emit(int facility, int level,
        printk_delay();
 
        printk_safe_enter(flags);
-       this_cpu = smp_processor_id();
-
-       /*
-        * Ouch, printk recursed into itself!
-        */
-       if (unlikely(logbuf_cpu == this_cpu)) {
-               /*
-                * If a crash is occurring during printk() on this CPU,
-                * then try to get the crash message out but make sure
-                * we can't deadlock. Otherwise just return to avoid the
-                * recursion and return - but flag the recursion so that
-                * it can be printed at the next appropriate moment:
-                */
-               if (!oops_in_progress && !lockdep_recursing(current)) {
-                       recursion_bug = true;
-                       printk_safe_exit(flags);
-                       return 0;
-               }
-               zap_locks();
-       }
-
        /* This stops the holder of console_sem just where we want him */
        raw_spin_lock(&logbuf_lock);
-       logbuf_cpu = this_cpu;
-
-       if (unlikely(recursion_bug)) {
-               static const char recursion_msg[] =
-                       "BUG: recent printk recursion!";
-
-               recursion_bug = false;
-               /* emit KERN_CRIT message */
-               printed_len += log_store(0, 2, LOG_PREFIX|LOG_NEWLINE, 0,
-                                        NULL, 0, recursion_msg,
-                                        strlen(recursion_msg));
-       }
-
        /*
         * The printf needs to come first; we need the syslog
         * prefix which might be passed-in as a parameter.
@@ -1881,7 +1821,6 @@ asmlinkage int vprintk_emit(int facility, int level,
 
        printed_len += log_output(facility, level, lflags, dict, dictlen, text, 
text_len);
 
-       logbuf_cpu = UINT_MAX;
        raw_spin_unlock(&logbuf_lock);
        printk_safe_exit(flags);
 
-- 
2.10.2

Reply via email to