summaryrefslogtreecommitdiffstats
path: root/debian/patches-rt/0021-printk-nbcon-Add-unsafe-flushing-on-panic.patch
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--debian/patches-rt/0021-printk-nbcon-Add-unsafe-flushing-on-panic.patch159
1 files changed, 159 insertions, 0 deletions
diff --git a/debian/patches-rt/0021-printk-nbcon-Add-unsafe-flushing-on-panic.patch b/debian/patches-rt/0021-printk-nbcon-Add-unsafe-flushing-on-panic.patch
new file mode 100644
index 0000000000..7b79f9d743
--- /dev/null
+++ b/debian/patches-rt/0021-printk-nbcon-Add-unsafe-flushing-on-panic.patch
@@ -0,0 +1,159 @@
+From: John Ogness <john.ogness@linutronix.de>
+Date: Fri, 20 Oct 2023 10:03:42 +0000
+Subject: [PATCH 21/46] printk: nbcon: Add unsafe flushing on panic
+Origin: https://www.kernel.org/pub/linux/kernel/projects/rt/6.9/older/patches-6.9-rt5.tar.xz
+
+Add nbcon_atomic_flush_unsafe() to flush all nbcon consoles
+using the write_atomic() callback and allowing unsafe hostile
+takeovers. Call this at the end of panic() as a final attempt
+to flush any pending messages.
+
+Note that legacy consoles use unsafe methods for flushing
+from the beginning of panic (see bust_spinlocks()). Therefore,
+systems using both legacy and nbcon consoles may still fail to
+see panic messages due to unsafe legacy console usage.
+
+Signed-off-by: John Ogness <john.ogness@linutronix.de>
+Reviewed-by: Petr Mladek <pmladek@suse.com>
+Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
+---
+ include/linux/printk.h | 5 +++++
+ kernel/panic.c | 1 +
+ kernel/printk/nbcon.c | 32 +++++++++++++++++++++++++-------
+ 3 files changed, 31 insertions(+), 7 deletions(-)
+
+--- a/include/linux/printk.h
++++ b/include/linux/printk.h
+@@ -197,6 +197,7 @@ extern asmlinkage void dump_stack(void)
+ void printk_trigger_flush(void);
+ extern bool nbcon_driver_try_acquire(struct console *con);
+ extern void nbcon_driver_release(struct console *con);
++void nbcon_atomic_flush_unsafe(void);
+ #else
+ static inline __printf(1, 0)
+ int vprintk(const char *s, va_list args)
+@@ -286,6 +287,10 @@ static inline void nbcon_driver_release(
+ {
+ }
+
++static inline void nbcon_atomic_flush_unsafe(void)
++{
++}
++
+ #endif
+
+ bool this_cpu_in_panic(void);
+--- a/kernel/panic.c
++++ b/kernel/panic.c
+@@ -457,6 +457,7 @@ void panic(const char *fmt, ...)
+ * Explicitly flush the kernel log buffer one last time.
+ */
+ console_flush_on_panic(CONSOLE_FLUSH_PENDING);
++ nbcon_atomic_flush_unsafe();
+
+ local_irq_enable();
+ for (i = 0; ; i += PANIC_TIMER_STEP) {
+--- a/kernel/printk/nbcon.c
++++ b/kernel/printk/nbcon.c
+@@ -1044,6 +1044,7 @@ bool nbcon_legacy_emit_next_record(struc
+ * write_atomic() callback
+ * @con: The nbcon console to flush
+ * @stop_seq: Flush up until this record
++ * @allow_unsafe_takeover: True, to allow unsafe hostile takeovers
+ *
+ * Return: 0 if @con was flushed up to @stop_seq Otherwise, error code on
+ * failure.
+@@ -1062,7 +1063,8 @@ bool nbcon_legacy_emit_next_record(struc
+ * returned, it cannot be expected that the unfinalized record will become
+ * available.
+ */
+-static int __nbcon_atomic_flush_pending_con(struct console *con, u64 stop_seq)
++static int __nbcon_atomic_flush_pending_con(struct console *con, u64 stop_seq,
++ bool allow_unsafe_takeover)
+ {
+ struct nbcon_write_context wctxt = { };
+ struct nbcon_context *ctxt = &ACCESS_PRIVATE(&wctxt, ctxt);
+@@ -1071,6 +1073,7 @@ static int __nbcon_atomic_flush_pending_
+ ctxt->console = con;
+ ctxt->spinwait_max_us = 2000;
+ ctxt->prio = nbcon_get_default_prio();
++ ctxt->allow_unsafe_takeover = allow_unsafe_takeover;
+
+ if (!nbcon_context_try_acquire(ctxt))
+ return -EPERM;
+@@ -1100,13 +1103,15 @@ static int __nbcon_atomic_flush_pending_
+ * write_atomic() callback
+ * @con: The nbcon console to flush
+ * @stop_seq: Flush up until this record
++ * @allow_unsafe_takeover: True, to allow unsafe hostile takeovers
+ *
+ * This will stop flushing before @stop_seq if another context has ownership.
+ * That context is then responsible for the flushing. Likewise, if new records
+ * are added while this context was flushing and there is no other context
+ * to handle the printing, this context must also flush those records.
+ */
+-static void nbcon_atomic_flush_pending_con(struct console *con, u64 stop_seq)
++static void nbcon_atomic_flush_pending_con(struct console *con, u64 stop_seq,
++ bool allow_unsafe_takeover)
+ {
+ unsigned long flags;
+ int err;
+@@ -1120,7 +1125,7 @@ static void nbcon_atomic_flush_pending_c
+ */
+ local_irq_save(flags);
+
+- err = __nbcon_atomic_flush_pending_con(con, stop_seq);
++ err = __nbcon_atomic_flush_pending_con(con, stop_seq, allow_unsafe_takeover);
+
+ local_irq_restore(flags);
+
+@@ -1144,8 +1149,9 @@ static void nbcon_atomic_flush_pending_c
+ * __nbcon_atomic_flush_pending - Flush all nbcon consoles using their
+ * write_atomic() callback
+ * @stop_seq: Flush up until this record
++ * @allow_unsafe_takeover: True, to allow unsafe hostile takeovers
+ */
+-static void __nbcon_atomic_flush_pending(u64 stop_seq)
++static void __nbcon_atomic_flush_pending(u64 stop_seq, bool allow_unsafe_takeover)
+ {
+ struct console *con;
+ int cookie;
+@@ -1163,7 +1169,7 @@ static void __nbcon_atomic_flush_pending
+ if (nbcon_seq_read(con) >= stop_seq)
+ continue;
+
+- nbcon_atomic_flush_pending_con(con, stop_seq);
++ nbcon_atomic_flush_pending_con(con, stop_seq, allow_unsafe_takeover);
+ }
+ console_srcu_read_unlock(cookie);
+ }
+@@ -1178,7 +1184,19 @@ static void __nbcon_atomic_flush_pending
+ */
+ void nbcon_atomic_flush_pending(void)
+ {
+- __nbcon_atomic_flush_pending(prb_next_reserve_seq(prb));
++ __nbcon_atomic_flush_pending(prb_next_reserve_seq(prb), false);
++}
++
++/**
++ * nbcon_atomic_flush_unsafe - Flush all nbcon consoles using their
++ * write_atomic() callback and allowing unsafe hostile takeovers
++ *
++ * Flush the backlog up through the currently newest record. Unsafe hostile
++ * takeovers will be performed, if necessary.
++ */
++void nbcon_atomic_flush_unsafe(void)
++{
++ __nbcon_atomic_flush_pending(prb_next_reserve_seq(prb), true);
+ }
+
+ /**
+@@ -1307,7 +1325,7 @@ void nbcon_driver_release(struct console
+ cookie = console_srcu_read_lock();
+ if (console_is_usable(con, console_srcu_read_flags(con)) &&
+ prb_read_valid(prb, nbcon_seq_read(con), NULL)) {
+- __nbcon_atomic_flush_pending_con(con, prb_next_reserve_seq(prb));
++ __nbcon_atomic_flush_pending_con(con, prb_next_reserve_seq(prb), false);
+ }
+ console_srcu_read_unlock(cookie);
+ }