summaryrefslogtreecommitdiffstats
path: root/debian/patches-rt/0089-printk-add-syslog_lock.patch
diff options
context:
space:
mode:
Diffstat (limited to 'debian/patches-rt/0089-printk-add-syslog_lock.patch')
-rw-r--r--debian/patches-rt/0089-printk-add-syslog_lock.patch159
1 files changed, 159 insertions, 0 deletions
diff --git a/debian/patches-rt/0089-printk-add-syslog_lock.patch b/debian/patches-rt/0089-printk-add-syslog_lock.patch
new file mode 100644
index 000000000..42e77e5ab
--- /dev/null
+++ b/debian/patches-rt/0089-printk-add-syslog_lock.patch
@@ -0,0 +1,159 @@
+From 5521ed0e06ffc572d9f0ebf5421ab23288899804 Mon Sep 17 00:00:00 2001
+From: John Ogness <john.ogness@linutronix.de>
+Date: Thu, 10 Dec 2020 16:58:02 +0106
+Subject: [PATCH 089/323] printk: add syslog_lock
+Origin: https://www.kernel.org/pub/linux/kernel/projects/rt/5.10/older/patches-5.10.204-rt100.tar.xz
+
+The global variables @syslog_seq, @syslog_partial, @syslog_time
+and write access to @clear_seq are protected by @logbuf_lock.
+Once @logbuf_lock is removed, these variables will need their
+own synchronization method. Introduce @syslog_lock for this
+purpose.
+
+@syslog_lock is a raw_spin_lock for now. This simplifies the
+transition to removing @logbuf_lock. Once @logbuf_lock and the
+safe buffers are removed, @syslog_lock can change to spin_lock.
+
+Signed-off-by: John Ogness <john.ogness@linutronix.de>
+Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
+---
+ kernel/printk/printk.c | 41 +++++++++++++++++++++++++++++++++++++----
+ 1 file changed, 37 insertions(+), 4 deletions(-)
+
+diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c
+index a351ed400c04..986fc9fad210 100644
+--- a/kernel/printk/printk.c
++++ b/kernel/printk/printk.c
+@@ -392,8 +392,12 @@ DEFINE_RAW_SPINLOCK(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);
++
+ #ifdef CONFIG_PRINTK
+ DECLARE_WAIT_QUEUE_HEAD(log_wait);
++/* All 3 protected by @syslog_lock. */
+ /* the next printk record to read by syslog(READ) or /proc/kmsg */
+ static u64 syslog_seq;
+ static size_t syslog_partial;
+@@ -412,7 +416,7 @@ struct latched_seq {
+ /*
+ * The next printk record to read after the last 'clear' command. There are
+ * two copies (updated with seqcount_latch) so that reads can locklessly
+- * access a valid value. Writers are synchronized by @logbuf_lock.
++ * access a valid value. Writers are synchronized by @syslog_lock.
+ */
+ static struct latched_seq clear_seq = {
+ .latch = SEQCNT_LATCH_ZERO(clear_seq.latch),
+@@ -472,7 +476,7 @@ bool printk_percpu_data_ready(void)
+ return __printk_percpu_data_ready;
+ }
+
+-/* Must be called under logbuf_lock. */
++/* Must be called under syslog_lock. */
+ static void latched_seq_write(struct latched_seq *ls, u64 val)
+ {
+ raw_write_seqcount_latch(&ls->latch);
+@@ -1532,7 +1536,9 @@ static int syslog_print(char __user *buf, int size)
+ size_t skip;
+
+ logbuf_lock_irq();
++ raw_spin_lock(&syslog_lock);
+ if (!prb_read_valid(prb, syslog_seq, &r)) {
++ raw_spin_unlock(&syslog_lock);
+ logbuf_unlock_irq();
+ break;
+ }
+@@ -1562,6 +1568,7 @@ static int syslog_print(char __user *buf, int size)
+ syslog_partial += n;
+ } else
+ n = 0;
++ raw_spin_unlock(&syslog_lock);
+ logbuf_unlock_irq();
+
+ if (!n)
+@@ -1628,8 +1635,11 @@ static int syslog_print_all(char __user *buf, int size, bool clear)
+ break;
+ }
+
+- if (clear)
++ if (clear) {
++ raw_spin_lock(&syslog_lock);
+ latched_seq_write(&clear_seq, seq);
++ raw_spin_unlock(&syslog_lock);
++ }
+ logbuf_unlock_irq();
+
+ kfree(text);
+@@ -1639,10 +1649,24 @@ static int syslog_print_all(char __user *buf, int size, bool clear)
+ static void syslog_clear(void)
+ {
+ logbuf_lock_irq();
++ raw_spin_lock(&syslog_lock);
+ latched_seq_write(&clear_seq, prb_next_seq(prb));
++ raw_spin_unlock(&syslog_lock);
+ logbuf_unlock_irq();
+ }
+
++/* Return a consistent copy of @syslog_seq. */
++static u64 read_syslog_seq_irq(void)
++{
++ u64 seq;
++
++ raw_spin_lock_irq(&syslog_lock);
++ seq = syslog_seq;
++ raw_spin_unlock_irq(&syslog_lock);
++
++ return seq;
++}
++
+ int do_syslog(int type, char __user *buf, int len, int source)
+ {
+ struct printk_info info;
+@@ -1666,8 +1690,9 @@ int do_syslog(int type, char __user *buf, int len, int source)
+ return 0;
+ if (!access_ok(buf, len))
+ return -EFAULT;
++
+ error = wait_event_interruptible(log_wait,
+- prb_read_valid(prb, syslog_seq, NULL));
++ prb_read_valid(prb, read_syslog_seq_irq(), NULL));
+ if (error)
+ return error;
+ error = syslog_print(buf, len);
+@@ -1716,8 +1741,10 @@ int do_syslog(int type, char __user *buf, int len, int source)
+ /* Number of chars in the log buffer */
+ case SYSLOG_ACTION_SIZE_UNREAD:
+ logbuf_lock_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();
+ return 0;
+ }
+@@ -1746,6 +1773,7 @@ int do_syslog(int type, char __user *buf, int len, int source)
+ }
+ error -= syslog_partial;
+ }
++ raw_spin_unlock(&syslog_lock);
+ logbuf_unlock_irq();
+ break;
+ /* Size of the log buffer */
+@@ -2995,7 +3023,12 @@ void register_console(struct console *newcon)
+ */
+ exclusive_console = newcon;
+ exclusive_console_stop_seq = console_seq;
++
++ /* Get a consistent copy of @syslog_seq. */
++ raw_spin_lock(&syslog_lock);
+ console_seq = syslog_seq;
++ raw_spin_unlock(&syslog_lock);
++
+ logbuf_unlock_irqrestore(flags);
+ }
+ console_unlock();
+--
+2.43.0
+