summaryrefslogtreecommitdiffstats
path: root/debian/patches-rt/0092-printk-remove-logbuf_lock.patch
diff options
context:
space:
mode:
Diffstat (limited to 'debian/patches-rt/0092-printk-remove-logbuf_lock.patch')
-rw-r--r--debian/patches-rt/0092-printk-remove-logbuf_lock.patch486
1 files changed, 486 insertions, 0 deletions
diff --git a/debian/patches-rt/0092-printk-remove-logbuf_lock.patch b/debian/patches-rt/0092-printk-remove-logbuf_lock.patch
new file mode 100644
index 000000000..6f45ee8b3
--- /dev/null
+++ b/debian/patches-rt/0092-printk-remove-logbuf_lock.patch
@@ -0,0 +1,486 @@
+From 74a8c8a0d6b64df822c5946a582ca3adeec24e63 Mon Sep 17 00:00:00 2001
+From: John Ogness <john.ogness@linutronix.de>
+Date: Tue, 26 Jan 2021 17:43:19 +0106
+Subject: [PATCH 092/323] printk: remove logbuf_lock
+Origin: https://www.kernel.org/pub/linux/kernel/projects/rt/5.10/older/patches-5.10.204-rt100.tar.xz
+
+Since the ringbuffer is lockless, there is no need for it to be
+protected by @logbuf_lock. Remove @logbuf_lock.
+
+This means that printk_nmi_direct and printk_safe_flush_on_panic()
+no longer need to acquire any lock to run.
+
+@console_seq, @exclusive_console_stop_seq, @console_dropped are
+protected by @console_lock.
+
+Signed-off-by: John Ogness <john.ogness@linutronix.de>
+Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
+---
+ kernel/printk/internal.h | 4 +-
+ kernel/printk/printk.c | 118 ++++++++++++------------------------
+ kernel/printk/printk_safe.c | 29 +++------
+ 3 files changed, 48 insertions(+), 103 deletions(-)
+
+diff --git a/kernel/printk/internal.h b/kernel/printk/internal.h
+index 3a8fd491758c..e7acc2888c8e 100644
+--- a/kernel/printk/internal.h
++++ b/kernel/printk/internal.h
+@@ -12,8 +12,6 @@
+
+ #define PRINTK_NMI_CONTEXT_OFFSET 0x010000000
+
+-extern raw_spinlock_t logbuf_lock;
+-
+ __printf(4, 0)
+ int vprintk_store(int facility, int level,
+ const struct dev_printk_info *dev_info,
+@@ -59,7 +57,7 @@ void defer_console_output(void);
+ __printf(1, 0) int vprintk_func(const char *fmt, va_list args) { return 0; }
+
+ /*
+- * In !PRINTK builds we still export logbuf_lock spin_lock, console_sem
++ * In !PRINTK builds we still export console_sem
+ * semaphore and some of console functions (console_unlock()/etc.), so
+ * printk-safe must preserve the existing local IRQ guarantees.
+ */
+diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c
+index b992be31824f..dde1696d7564 100644
+--- a/kernel/printk/printk.c
++++ b/kernel/printk/printk.c
+@@ -357,41 +357,6 @@ enum log_flags {
+ LOG_CONT = 8, /* text is a fragment of a continuation line */
+ };
+
+-/*
+- * The logbuf_lock protects kmsg buffer, indices, counters. This can be taken
+- * within the scheduler's rq lock. It must be released before calling
+- * console_unlock() or anything else that might wake up a process.
+- */
+-DEFINE_RAW_SPINLOCK(logbuf_lock);
+-
+-/*
+- * Helper macros to lock/unlock logbuf_lock and switch between
+- * printk-safe/unsafe modes.
+- */
+-#define logbuf_lock_irq() \
+- do { \
+- printk_safe_enter_irq(); \
+- raw_spin_lock(&logbuf_lock); \
+- } while (0)
+-
+-#define logbuf_unlock_irq() \
+- do { \
+- raw_spin_unlock(&logbuf_lock); \
+- printk_safe_exit_irq(); \
+- } while (0)
+-
+-#define logbuf_lock_irqsave(flags) \
+- do { \
+- printk_safe_enter_irqsave(flags); \
+- raw_spin_lock(&logbuf_lock); \
+- } while (0)
+-
+-#define logbuf_unlock_irqrestore(flags) \
+- do { \
+- raw_spin_unlock(&logbuf_lock); \
+- printk_safe_exit_irqrestore(flags); \
+- } while (0)
+-
+ /* syslog_lock protects syslog_* variables and write access to clear_seq. */
+ static DEFINE_RAW_SPINLOCK(syslog_lock);
+
+@@ -403,6 +368,7 @@ static u64 syslog_seq;
+ static size_t syslog_partial;
+ static bool syslog_time;
+
++/* All 3 protected by @console_sem. */
+ /* the next printk record to write to the console */
+ static u64 console_seq;
+ static u64 exclusive_console_stop_seq;
+@@ -769,27 +735,27 @@ static ssize_t devkmsg_read(struct file *file, char __user *buf,
+ if (ret)
+ return ret;
+
+- logbuf_lock_irq();
++ printk_safe_enter_irq();
+ if (!prb_read_valid(prb, atomic64_read(&user->seq), r)) {
+ if (file->f_flags & O_NONBLOCK) {
+ ret = -EAGAIN;
+- logbuf_unlock_irq();
++ printk_safe_exit_irq();
+ goto out;
+ }
+
+- logbuf_unlock_irq();
++ printk_safe_exit_irq();
+ ret = wait_event_interruptible(log_wait,
+ prb_read_valid(prb, atomic64_read(&user->seq), r));
+ if (ret)
+ goto out;
+- logbuf_lock_irq();
++ printk_safe_enter_irq();
+ }
+
+ if (r->info->seq != atomic64_read(&user->seq)) {
+ /* our last seen message is gone, return error and reset */
+ atomic64_set(&user->seq, r->info->seq);
+ ret = -EPIPE;
+- logbuf_unlock_irq();
++ printk_safe_exit_irq();
+ goto out;
+ }
+
+@@ -799,7 +765,7 @@ static ssize_t devkmsg_read(struct file *file, char __user *buf,
+ &r->info->dev_info);
+
+ atomic64_set(&user->seq, r->info->seq + 1);
+- logbuf_unlock_irq();
++ printk_safe_exit_irq();
+
+ if (len > count) {
+ ret = -EINVAL;
+@@ -834,7 +800,7 @@ static loff_t devkmsg_llseek(struct file *file, loff_t offset, int whence)
+ if (offset)
+ return -ESPIPE;
+
+- logbuf_lock_irq();
++ printk_safe_enter_irq();
+ switch (whence) {
+ case SEEK_SET:
+ /* the first record */
+@@ -855,7 +821,7 @@ static loff_t devkmsg_llseek(struct file *file, loff_t offset, int whence)
+ default:
+ ret = -EINVAL;
+ }
+- logbuf_unlock_irq();
++ printk_safe_exit_irq();
+ return ret;
+ }
+
+@@ -870,15 +836,15 @@ static __poll_t devkmsg_poll(struct file *file, poll_table *wait)
+
+ poll_wait(file, &log_wait, wait);
+
+- logbuf_lock_irq();
+- if (prb_read_valid_info(prb, user->seq, &info, NULL)) {
++ printk_safe_enter_irq();
++ if (prb_read_valid_info(prb, atomic64_read(&user->seq), &info, NULL)) {
+ /* return error when data has vanished underneath us */
+ if (info.seq != atomic64_read(&user->seq))
+ ret = EPOLLIN|EPOLLRDNORM|EPOLLERR|EPOLLPRI;
+ else
+ ret = EPOLLIN|EPOLLRDNORM;
+ }
+- logbuf_unlock_irq();
++ printk_safe_exit_irq();
+
+ return ret;
+ }
+@@ -911,9 +877,9 @@ static int devkmsg_open(struct inode *inode, struct file *file)
+ prb_rec_init_rd(&user->record, &user->info,
+ &user->text_buf[0], sizeof(user->text_buf));
+
+- logbuf_lock_irq();
++ printk_safe_enter_irq();
+ atomic64_set(&user->seq, prb_first_valid_seq(prb));
+- logbuf_unlock_irq();
++ printk_safe_exit_irq();
+
+ file->private_data = user;
+ return 0;
+@@ -1535,11 +1501,11 @@ static int syslog_print(char __user *buf, int size)
+ size_t n;
+ size_t skip;
+
+- logbuf_lock_irq();
++ printk_safe_enter_irq();
+ raw_spin_lock(&syslog_lock);
+ if (!prb_read_valid(prb, syslog_seq, &r)) {
+ raw_spin_unlock(&syslog_lock);
+- logbuf_unlock_irq();
++ printk_safe_exit_irq();
+ break;
+ }
+ if (r.info->seq != syslog_seq) {
+@@ -1569,7 +1535,7 @@ static int syslog_print(char __user *buf, int size)
+ } else
+ n = 0;
+ raw_spin_unlock(&syslog_lock);
+- logbuf_unlock_irq();
++ printk_safe_exit_irq();
+
+ if (!n)
+ break;
+@@ -1603,7 +1569,7 @@ static int syslog_print_all(char __user *buf, int size, bool clear)
+ return -ENOMEM;
+
+ time = printk_time;
+- logbuf_lock_irq();
++ printk_safe_enter_irq();
+ /*
+ * Find first record that fits, including all following records,
+ * into the user-provided buffer for this dump.
+@@ -1624,12 +1590,12 @@ static int syslog_print_all(char __user *buf, int size, bool clear)
+ break;
+ }
+
+- logbuf_unlock_irq();
++ printk_safe_exit_irq();
+ if (copy_to_user(buf + len, text, textlen))
+ len = -EFAULT;
+ else
+ len += textlen;
+- logbuf_lock_irq();
++ printk_safe_enter_irq();
+
+ if (len < 0)
+ break;
+@@ -1640,7 +1606,7 @@ static int syslog_print_all(char __user *buf, int size, bool clear)
+ latched_seq_write(&clear_seq, seq);
+ raw_spin_unlock(&syslog_lock);
+ }
+- logbuf_unlock_irq();
++ printk_safe_exit_irq();
+
+ kfree(text);
+ return len;
+@@ -1648,11 +1614,11 @@ static int syslog_print_all(char __user *buf, int size, bool clear)
+
+ static void syslog_clear(void)
+ {
+- logbuf_lock_irq();
++ printk_safe_enter_irq();
+ raw_spin_lock(&syslog_lock);
+ latched_seq_write(&clear_seq, prb_next_seq(prb));
+ raw_spin_unlock(&syslog_lock);
+- logbuf_unlock_irq();
++ printk_safe_exit_irq();
+ }
+
+ /* Return a consistent copy of @syslog_seq. */
+@@ -1740,12 +1706,12 @@ int do_syslog(int type, char __user *buf, int len, int source)
+ break;
+ /* Number of chars in the log buffer */
+ case SYSLOG_ACTION_SIZE_UNREAD:
+- logbuf_lock_irq();
++ printk_safe_enter_irq();
+ raw_spin_lock(&syslog_lock);
+ if (!prb_read_valid_info(prb, syslog_seq, &info, NULL)) {
+ /* No unread messages. */
+ raw_spin_unlock(&syslog_lock);
+- logbuf_unlock_irq();
++ printk_safe_exit_irq();
+ return 0;
+ }
+ if (info.seq != syslog_seq) {
+@@ -1774,7 +1740,7 @@ int do_syslog(int type, char __user *buf, int len, int source)
+ error -= syslog_partial;
+ }
+ raw_spin_unlock(&syslog_lock);
+- logbuf_unlock_irq();
++ printk_safe_exit_irq();
+ break;
+ /* Size of the log buffer */
+ case SYSLOG_ACTION_SIZE_BUFFER:
+@@ -2630,7 +2596,6 @@ void console_unlock(void)
+ size_t len;
+
+ printk_safe_enter_irqsave(flags);
+- raw_spin_lock(&logbuf_lock);
+ skip:
+ if (!prb_read_valid(prb, console_seq, &r))
+ break;
+@@ -2674,7 +2639,6 @@ void console_unlock(void)
+ console_msg_format & MSG_FORMAT_SYSLOG,
+ printk_time);
+ console_seq++;
+- raw_spin_unlock(&logbuf_lock);
+
+ /*
+ * While actively printing out messages, if another printk()
+@@ -2701,8 +2665,6 @@ void console_unlock(void)
+
+ console_locked = 0;
+
+- raw_spin_unlock(&logbuf_lock);
+-
+ up_console_sem();
+
+ /*
+@@ -2711,9 +2673,7 @@ void console_unlock(void)
+ * there's a new owner and the console_unlock() from them will do the
+ * flush, no worries.
+ */
+- raw_spin_lock(&logbuf_lock);
+ retry = prb_read_valid(prb, console_seq, NULL);
+- raw_spin_unlock(&logbuf_lock);
+ printk_safe_exit_irqrestore(flags);
+
+ if (retry && console_trylock())
+@@ -2780,9 +2740,9 @@ void console_flush_on_panic(enum con_flush_mode mode)
+ if (mode == CONSOLE_REPLAY_ALL) {
+ unsigned long flags;
+
+- logbuf_lock_irqsave(flags);
++ printk_safe_enter_irqsave(flags);
+ console_seq = prb_first_valid_seq(prb);
+- logbuf_unlock_irqrestore(flags);
++ printk_safe_exit_irqrestore(flags);
+ }
+ console_unlock();
+ }
+@@ -3011,7 +2971,7 @@ void register_console(struct console *newcon)
+ * console_unlock(); will print out the buffered messages
+ * for us.
+ */
+- logbuf_lock_irqsave(flags);
++ printk_safe_enter_irqsave(flags);
+ /*
+ * We're about to replay the log buffer. Only do this to the
+ * just-registered console to avoid excessive message spam to
+@@ -3029,7 +2989,7 @@ void register_console(struct console *newcon)
+ console_seq = syslog_seq;
+ raw_spin_unlock(&syslog_lock);
+
+- logbuf_unlock_irqrestore(flags);
++ printk_safe_exit_irqrestore(flags);
+ }
+ console_unlock();
+ console_sysfs_notify();
+@@ -3415,10 +3375,10 @@ void kmsg_dump(enum kmsg_dump_reason reason)
+
+ /* initialize iterator with data about the stored records */
+ iter.active = true;
+- logbuf_lock_irqsave(flags);
++ printk_safe_enter_irqsave(flags);
+ iter.cur_seq = latched_seq_read_nolock(&clear_seq);
+ iter.next_seq = prb_next_seq(prb);
+- logbuf_unlock_irqrestore(flags);
++ printk_safe_exit_irqrestore(flags);
+
+ /* invoke dumper which will iterate over records */
+ dumper->dump(dumper, reason, &iter);
+@@ -3505,9 +3465,9 @@ bool kmsg_dump_get_line(struct kmsg_dumper_iter *iter, bool syslog,
+ unsigned long flags;
+ bool ret;
+
+- logbuf_lock_irqsave(flags);
++ printk_safe_enter_irqsave(flags);
+ ret = kmsg_dump_get_line_nolock(iter, syslog, line, size, len);
+- logbuf_unlock_irqrestore(flags);
++ printk_safe_exit_irqrestore(flags);
+
+ return ret;
+ }
+@@ -3547,7 +3507,7 @@ bool kmsg_dump_get_buffer(struct kmsg_dumper_iter *iter, bool syslog,
+ if (!iter->active || !buf || !size)
+ goto out;
+
+- logbuf_lock_irqsave(flags);
++ printk_safe_enter_irqsave(flags);
+ if (prb_read_valid_info(prb, iter->cur_seq, &info, NULL)) {
+ if (info.seq != iter->cur_seq) {
+ /* messages are gone, move to first available one */
+@@ -3557,7 +3517,7 @@ bool kmsg_dump_get_buffer(struct kmsg_dumper_iter *iter, bool syslog,
+
+ /* last entry */
+ if (iter->cur_seq >= iter->next_seq) {
+- logbuf_unlock_irqrestore(flags);
++ printk_safe_exit_irqrestore(flags);
+ goto out;
+ }
+
+@@ -3591,7 +3551,7 @@ bool kmsg_dump_get_buffer(struct kmsg_dumper_iter *iter, bool syslog,
+
+ iter->next_seq = next_seq;
+ ret = true;
+- logbuf_unlock_irqrestore(flags);
++ printk_safe_exit_irqrestore(flags);
+ out:
+ if (len_out)
+ *len_out = len;
+@@ -3627,9 +3587,9 @@ void kmsg_dump_rewind(struct kmsg_dumper_iter *iter)
+ {
+ unsigned long flags;
+
+- logbuf_lock_irqsave(flags);
++ printk_safe_enter_irqsave(flags);
+ kmsg_dump_rewind_nolock(iter);
+- logbuf_unlock_irqrestore(flags);
++ printk_safe_exit_irqrestore(flags);
+ }
+ EXPORT_SYMBOL_GPL(kmsg_dump_rewind);
+
+diff --git a/kernel/printk/printk_safe.c b/kernel/printk/printk_safe.c
+index 2e9e3ed7d63e..7df8a88d4115 100644
+--- a/kernel/printk/printk_safe.c
++++ b/kernel/printk/printk_safe.c
+@@ -16,7 +16,7 @@
+ #include "internal.h"
+
+ /*
+- * printk() could not take logbuf_lock in NMI context. Instead,
++ * In NMI and safe mode, printk() avoids taking locks. 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.
+@@ -266,18 +266,6 @@ void printk_safe_flush(void)
+ */
+ void printk_safe_flush_on_panic(void)
+ {
+- /*
+- * Make sure that we could access the main ring buffer.
+- * Do not risk a double release when more CPUs are up.
+- */
+- if (raw_spin_is_locked(&logbuf_lock)) {
+- if (num_online_cpus() > 1)
+- return;
+-
+- debug_locks_off();
+- raw_spin_lock_init(&logbuf_lock);
+- }
+-
+ if (raw_spin_is_locked(&safe_read_lock)) {
+ if (num_online_cpus() > 1)
+ return;
+@@ -319,9 +307,7 @@ void noinstr printk_nmi_exit(void)
+ * reordering.
+ *
+ * It has effect only when called in NMI context. Then printk()
+- * will try to store the messages into the main logbuf directly
+- * and use the per-CPU buffers only as a fallback when the lock
+- * is not available.
++ * will store the messages into the main logbuf directly.
+ */
+ void printk_nmi_direct_enter(void)
+ {
+@@ -376,20 +362,21 @@ __printf(1, 0) int vprintk_func(const char *fmt, va_list args)
+ #endif
+
+ /*
+- * Try to use the main logbuf even in NMI. But avoid calling console
++ * Use the main logbuf even in NMI. But avoid calling console
+ * drivers that might have their own locks.
+ */
+- if ((this_cpu_read(printk_context) & PRINTK_NMI_DIRECT_CONTEXT_MASK) &&
+- raw_spin_trylock(&logbuf_lock)) {
++ if ((this_cpu_read(printk_context) & PRINTK_NMI_DIRECT_CONTEXT_MASK)) {
++ unsigned long flags;
+ int len;
+
++ printk_safe_enter_irqsave(flags);
+ len = vprintk_store(0, LOGLEVEL_DEFAULT, NULL, fmt, args);
+- raw_spin_unlock(&logbuf_lock);
++ printk_safe_exit_irqrestore(flags);
+ defer_console_output();
+ return len;
+ }
+
+- /* Use extra buffer in NMI when logbuf_lock is taken or in safe mode. */
++ /* Use extra buffer in NMI. */
+ if (this_cpu_read(printk_context) & PRINTK_NMI_CONTEXT_MASK)
+ return vprintk_nmi(fmt, args);
+
+--
+2.43.0
+