printk/nmi: generic solution for safe printk in NMI

printk() takes some locks and could not be used a safe way in NMI
context.

The chance of a deadlock is real especially when printing stacks from
all CPUs.  This particular problem has been addressed on x86 by the
commit a9edc8809328 ("x86/nmi: Perform a safe NMI stack trace on all
CPUs").

The patchset brings two big advantages.  First, it makes the NMI
backtraces safe on all architectures for free.  Second, it makes all NMI
messages almost safe on all architectures (the temporary buffer is
limited.  We still should keep the number of messages in NMI context at
minimum).

Note that there already are several messages printed in NMI context:
WARN_ON(in_nmi()), BUG_ON(in_nmi()), anything being printed out from MCE
handlers.  These are not easy to avoid.

This patch reuses most of the code and makes it generic.  It is useful
for all messages and architectures that support NMI.

The alternative printk_func is set when entering and is reseted when
leaving NMI context.  It queues IRQ work to copy the messages into the
main ring buffer in a safe context.

__printk_nmi_flush() copies all available messages and reset the buffer.
Then we could use a simple cmpxchg operations to get synchronized with
writers.  There is also used a spinlock to get synchronized with other
flushers.

We do not longer use seq_buf because it depends on external lock.  It
would be hard to make all supported operations safe for a lockless use.
It would be confusing and error prone to make only some operations safe.

The code is put into separate printk/nmi.c as suggested by Steven
Rostedt.  It needs a per-CPU buffer and is compiled only on
architectures that call nmi_enter().  This is achieved by the new
HAVE_NMI Kconfig flag.

The are MN10300 and Xtensa architectures.  We need to clean up NMI
handling there first.  Let's do it separately.

The patch is heavily based on the draft from Peter Zijlstra, see

  https://lkml.org/lkml/2015/6/10/327

[arnd@arndb.de: printk-nmi: use %zu format string for size_t]
[akpm@linux-foundation.org: min_t->min - all types are size_t here]
Signed-off-by: Petr Mladek <pmladek@suse.com>
Suggested-by: Peter Zijlstra <peterz@infradead.org>
Suggested-by: Steven Rostedt <rostedt@goodmis.org>
Cc: Jan Kara <jack@suse.cz>
Acked-by: Russell King <rmk+kernel@arm.linux.org.uk>	[arm part]
Cc: Daniel Thompson <daniel.thompson@linaro.org>
Cc: Jiri Kosina <jkosina@suse.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Ralf Baechle <ralf@linux-mips.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: David Miller <davem@davemloft.net>
Cc: Daniel Thompson <daniel.thompson@linaro.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

4 files changed, 265 insertions, 18 deletions

diff --git a/kernel/printk/Makefile b/kernel/printk/Makefile
index 85405bdcf2b3..abb0042a427b 100644
--- a/kernel/printk/Makefile
+++ b/kernel/printk/Makefile
@@ -1,2 +1,3 @@
 obj-y   = printk.o
+obj-$(CONFIG_PRINTK_NMI)                += nmi.o
 obj-$(CONFIG_A11Y_BRAILLE_CONSOLE)      += braille.o
diff --git a/kernel/printk/internal.h b/kernel/printk/internal.h
new file mode 100644
index 000000000000..2de99faedfc1
--- /dev/null
+++ b/kernel/printk/internal.h
@@ -0,0 +1,44 @@
+/*
+ * internal.h - printk internal definitions
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+#include <linux/percpu.h>
+
+typedef __printf(1, 0) int (*printk_func_t)(const char *fmt, va_list args);
+
+int __printf(1, 0) vprintk_default(const char *fmt, va_list args);
+
+#ifdef CONFIG_PRINTK_NMI
+
+/*
+ * printk() could not take logbuf_lock in NMI context. Instead,
+ * it temporary stores the strings into a per-CPU buffer.
+ * The alternative implementation is chosen transparently
+ * via per-CPU variable.
+ */
+DECLARE_PER_CPU(printk_func_t, printk_func);
+static inline __printf(1, 0) int vprintk_func(const char *fmt, va_list args)
+{
+        return this_cpu_read(printk_func)(fmt, args);
+}
+
+#else /* CONFIG_PRINTK_NMI */
+
+static inline __printf(1, 0) int vprintk_func(const char *fmt, va_list args)
+{
+        return vprintk_default(fmt, args);
+}
+
+#endif /* CONFIG_PRINTK_NMI */
diff --git a/kernel/printk/nmi.c b/kernel/printk/nmi.c
new file mode 100644
index 000000000000..303cf0d15e57
--- /dev/null
+++ b/kernel/printk/nmi.c
@@ -0,0 +1,219 @@
+/*
+ * nmi.c - Safe printk in NMI context
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/preempt.h>
+#include <linux/spinlock.h>
+#include <linux/smp.h>
+#include <linux/cpumask.h>
+#include <linux/irq_work.h>
+#include <linux/printk.h>
+
+#include "internal.h"
+
+/*
+ * printk() could not take logbuf_lock in NMI context. Instead,
+ * it uses an alternative implementation that temporary stores
+ * the strings into a per-CPU buffer. The content of the buffer
+ * is later flushed into the main ring buffer via IRQ work.
+ *
+ * The alternative implementation is chosen transparently
+ * via @printk_func per-CPU variable.
+ *
+ * The implementation allows to flush the strings also from another CPU.
+ * There are situations when we want to make sure that all buffers
+ * were handled or when IRQs are blocked.
+ */
+DEFINE_PER_CPU(printk_func_t, printk_func) = vprintk_default;
+static int printk_nmi_irq_ready;
+
+#define NMI_LOG_BUF_LEN (4096 - sizeof(atomic_t) - sizeof(struct irq_work))
+
+struct nmi_seq_buf {
+        atomic_t                len;    /* length of written data */
+        struct irq_work         work;   /* IRQ work that flushes the buffer */
+        unsigned char           buffer[NMI_LOG_BUF_LEN];
+};
+static DEFINE_PER_CPU(struct nmi_seq_buf, nmi_print_seq);
+
+/*
+ * Safe printk() for NMI context. It uses a per-CPU buffer to
+ * store the message. NMIs are not nested, so there is always only
+ * one writer running. But the buffer might get flushed from another
+ * CPU, so we need to be careful.
+ */
+static int vprintk_nmi(const char *fmt, va_list args)
+{
+        struct nmi_seq_buf *s = this_cpu_ptr(&nmi_print_seq);
+        int add = 0;
+        size_t len;
+
+again:
+        len = atomic_read(&s->len);
+
+        if (len >= sizeof(s->buffer))
+                return 0;
+
+        /*
+         * Make sure that all old data have been read before the buffer was
+         * reseted. This is not needed when we just append data.
+         */
+        if (!len)
+                smp_rmb();
+
+        add = vsnprintf(s->buffer + len, sizeof(s->buffer) - len, fmt, args);
+
+        /*
+         * Do it once again if the buffer has been flushed in the meantime.
+         * Note that atomic_cmpxchg() is an implicit memory barrier that
+         * makes sure that the data were written before updating s->len.
+         */
+        if (atomic_cmpxchg(&s->len, len, len + add) != len)
+                goto again;
+
+        /* Get flushed in a more safe context. */
+        if (add && printk_nmi_irq_ready) {
+                /* Make sure that IRQ work is really initialized. */
+                smp_rmb();
+                irq_work_queue(&s->work);
+        }
+
+        return add;
+}
+
+/*
+ * printk one line from the temporary buffer from @start index until
+ * and including the @end index.
+ */
+static void print_nmi_seq_line(struct nmi_seq_buf *s, int start, int end)
+{
+        const char *buf = s->buffer + start;
+
+        printk("%.*s", (end - start) + 1, buf);
+}
+
+/*
+ * Flush data from the associated per_CPU buffer. The function
+ * can be called either via IRQ work or independently.
+ */
+static void __printk_nmi_flush(struct irq_work *work)
+{
+        static raw_spinlock_t read_lock =
+                __RAW_SPIN_LOCK_INITIALIZER(read_lock);
+        struct nmi_seq_buf *s = container_of(work, struct nmi_seq_buf, work);
+        unsigned long flags;
+        size_t len, size;
+        int i, last_i;
+
+        /*
+         * The lock has two functions. First, one reader has to flush all
+         * available message to make the lockless synchronization with
+         * writers easier. Second, we do not want to mix messages from
+         * different CPUs. This is especially important when printing
+         * a backtrace.
+         */
+        raw_spin_lock_irqsave(&read_lock, flags);
+
+        i = 0;
+more:
+        len = atomic_read(&s->len);
+
+        /*
+         * This is just a paranoid check that nobody has manipulated
+         * the buffer an unexpected way. If we printed something then
+         * @len must only increase.
+         */
+        if (i && i >= len)
+                pr_err("printk_nmi_flush: internal error: i=%d >= len=%zu\n",
+                       i, len);
+
+        if (!len)
+                goto out; /* Someone else has already flushed the buffer. */
+
+        /* Make sure that data has been written up to the @len */
+        smp_rmb();
+
+        size = min(len, sizeof(s->buffer));
+        last_i = i;
+
+        /* Print line by line. */
+        for (; i < size; i++) {
+                if (s->buffer[i] == '\n') {
+                        print_nmi_seq_line(s, last_i, i);
+                        last_i = i + 1;
+                }
+        }
+        /* Check if there was a partial line. */
+        if (last_i < size) {
+                print_nmi_seq_line(s, last_i, size - 1);
+                pr_cont("\n");
+        }
+
+        /*
+         * Check that nothing has got added in the meantime and truncate
+         * the buffer. Note that atomic_cmpxchg() is an implicit memory
+         * barrier that makes sure that the data were copied before
+         * updating s->len.
+         */
+        if (atomic_cmpxchg(&s->len, len, 0) != len)
+                goto more;
+
+out:
+        raw_spin_unlock_irqrestore(&read_lock, flags);
+}
+
+/**
+ * printk_nmi_flush - flush all per-cpu nmi buffers.
+ *
+ * The buffers are flushed automatically via IRQ work. This function
+ * is useful only when someone wants to be sure that all buffers have
+ * been flushed at some point.
+ */
+void printk_nmi_flush(void)
+{
+        int cpu;
+
+        for_each_possible_cpu(cpu)
+                __printk_nmi_flush(&per_cpu(nmi_print_seq, cpu).work);
+}
+
+void __init printk_nmi_init(void)
+{
+        int cpu;
+
+        for_each_possible_cpu(cpu) {
+                struct nmi_seq_buf *s = &per_cpu(nmi_print_seq, cpu);
+
+                init_irq_work(&s->work, __printk_nmi_flush);
+        }
+
+        /* Make sure that IRQ works are initialized before enabling. */
+        smp_wmb();
+        printk_nmi_irq_ready = 1;
+
+        /* Flush pending messages that did not have scheduled IRQ works. */
+        printk_nmi_flush();
+}
+
+void printk_nmi_enter(void)
+{
+        this_cpu_write(printk_func, vprintk_nmi);
+}
+
+void printk_nmi_exit(void)
+{
+        this_cpu_write(printk_func, vprintk_default);
+}
diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c
index bfbf284e4218..71eba0607034 100644
--- a/kernel/printk/printk.c
+++ b/kernel/printk/printk.c
@@ -55,6 +55,7 @@
 
 #include "console_cmdline.h"
 #include "braille.h"
+#include "internal.h"
 
 int console_printk[4] = {
         CONSOLE_LOGLEVEL_DEFAULT,       /* console_loglevel */
@@ -1807,14 +1808,6 @@ int vprintk_default(const char *fmt, va_list args)
 }
 EXPORT_SYMBOL_GPL(vprintk_default);
 
-/*
- * This allows printk to be diverted to another function per cpu.
- * This is useful for calling printk functions from within NMI
- * without worrying about race conditions that can lock up the
- * box.
- */
-DEFINE_PER_CPU(printk_func_t, printk_func) = vprintk_default;
-
 /**
  * printk - print a kernel message
  * @fmt: format string
@@ -1838,21 +1831,11 @@ DEFINE_PER_CPU(printk_func_t, printk_func) = vprintk_default;
  */
 asmlinkage __visible int printk(const char *fmt, ...)
 {
-        printk_func_t vprintk_func;
         va_list args;
         int r;
 
         va_start(args, fmt);
-
-        /*
-         * If a caller overrides the per_cpu printk_func, then it needs
-         * to disable preemption when calling printk(). Otherwise
-         * the printk_func should be set to the default. No need to
-         * disable preemption here.
-         */
-        vprintk_func = this_cpu_read(printk_func);
         r = vprintk_func(fmt, args);
-
         va_end(args);
 
         return r;