From f8959fec5f38a3e0cc0152ddf1644ebed9e148cd Mon Sep 17 00:00:00 2001 From: John Ogness Date: Fri, 20 Oct 2023 10:03:42 +0000 Subject: [PATCH 132/184] printk: nbcon: Add unsafe flushing on panic 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 Signed-off-by: Sebastian Andrzej Siewior --- include/linux/printk.h | 5 +++++ kernel/panic.c | 3 +++ kernel/printk/internal.h | 2 ++ kernel/printk/nbcon.c | 46 ++++++++++++++++++++++++++++++++++++---- 4 files changed, 52 insertions(+), 4 deletions(-) diff --git a/include/linux/printk.h b/include/linux/printk.h index 9b2dca459423..28b350940b33 100644 --- a/include/linux/printk.h +++ b/include/linux/printk.h @@ -196,6 +196,7 @@ extern asmlinkage void dump_stack(void) __cold; void printk_trigger_flush(void); extern void nbcon_handle_port_lock(struct uart_port *up); extern void nbcon_handle_port_unlock(struct uart_port *up); +void nbcon_atomic_flush_unsafe(void); #else static inline __printf(1, 0) int vprintk(const char *s, va_list args) @@ -284,6 +285,10 @@ static inline void nbcon_handle_port_unlock(struct uart_port *up) { } +static inline void nbcon_atomic_flush_unsafe(void) +{ +} + #endif #ifdef CONFIG_SMP diff --git a/kernel/panic.c b/kernel/panic.c index 56c730f82c59..58754f615429 100644 --- a/kernel/panic.c +++ b/kernel/panic.c @@ -442,6 +442,9 @@ void panic(const char *fmt, ...) /* Do not scroll important messages printed above */ suppress_printk = 1; + + nbcon_atomic_flush_unsafe(); + local_irq_enable(); for (i = 0; ; i += PANIC_TIMER_STEP) { touch_softlockup_watchdog(); diff --git a/kernel/printk/internal.h b/kernel/printk/internal.h index f345a423d254..9b86e9d87a9c 100644 --- a/kernel/printk/internal.h +++ b/kernel/printk/internal.h @@ -77,6 +77,7 @@ void nbcon_seq_force(struct console *con, u64 seq); bool nbcon_alloc(struct console *con); void nbcon_init(struct console *con); void nbcon_free(struct console *con); +enum nbcon_prio nbcon_get_default_prio(void); void nbcon_atomic_flush_all(void); bool nbcon_atomic_emit_next_record(struct console *con); @@ -133,6 +134,7 @@ static inline void nbcon_seq_force(struct console *con, u64 seq) { } static inline bool nbcon_alloc(struct console *con) { return false; } static inline void nbcon_init(struct console *con) { } static inline void nbcon_free(struct console *con) { } +static inline enum nbcon_prio nbcon_get_default_prio(void) { return NBCON_PRIO_NONE; } static inline void nbcon_atomic_flush_all(void) { } static bool nbcon_atomic_emit_next_record(struct console *con) { return false; } diff --git a/kernel/printk/nbcon.c b/kernel/printk/nbcon.c index a73de484090c..39399b36eee8 100644 --- a/kernel/printk/nbcon.c +++ b/kernel/printk/nbcon.c @@ -996,6 +996,21 @@ static bool nbcon_atomic_emit_one(struct nbcon_write_context *wctxt) return ctxt->backlog; } +/** + * nbcon_get_default_prio - The appropriate nbcon priority to use for nbcon + * printing on the current CPU + * + * Return: The nbcon_prio to use for acquiring an nbcon console in this + * context for printing. + */ +enum nbcon_prio nbcon_get_default_prio(void) +{ + if (this_cpu_in_panic()) + return NBCON_PRIO_PANIC; + + return NBCON_PRIO_NORMAL; +} + /** * nbcon_atomic_emit_next_record - Print one record for an nbcon console * using the write_atomic() callback @@ -1014,7 +1029,7 @@ bool nbcon_atomic_emit_next_record(struct console *con) struct nbcon_context *ctxt = &ACCESS_PRIVATE(&wctxt, ctxt); ctxt->console = con; - ctxt->prio = NBCON_PRIO_NORMAL; + ctxt->prio = nbcon_get_default_prio(); return nbcon_atomic_emit_one(&wctxt); } @@ -1023,11 +1038,13 @@ bool nbcon_atomic_emit_next_record(struct console *con) * __nbcon_atomic_flush_all - 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_all(u64 stop_seq) +static void __nbcon_atomic_flush_all(u64 stop_seq, bool allow_unsafe_takeover) { struct nbcon_write_context wctxt = { }; struct nbcon_context *ctxt = &ACCESS_PRIVATE(&wctxt, ctxt); + enum nbcon_prio prio = nbcon_get_default_prio(); struct console *con; bool any_progress; int cookie; @@ -1051,7 +1068,8 @@ static void __nbcon_atomic_flush_all(u64 stop_seq) memset(ctxt, 0, sizeof(*ctxt)); ctxt->console = con; ctxt->spinwait_max_us = 2000; - ctxt->prio = NBCON_PRIO_NORMAL; + ctxt->prio = prio; + ctxt->allow_unsafe_takeover = allow_unsafe_takeover; any_progress |= nbcon_atomic_emit_one(&wctxt); } @@ -1071,7 +1089,21 @@ static void __nbcon_atomic_flush_all(u64 stop_seq) */ void nbcon_atomic_flush_all(void) { - __nbcon_atomic_flush_all(prb_next_reserve_seq(prb)); + __nbcon_atomic_flush_all(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. + * + * Context: Any context which could not be migrated to another CPU. + */ +void nbcon_atomic_flush_unsafe(void) +{ + __nbcon_atomic_flush_all(prb_next_reserve_seq(prb), true); } /** @@ -1164,6 +1196,9 @@ static inline bool uart_is_nbcon(struct uart_port *up) * * If @up is an nbcon console, this console will be acquired and marked as * unsafe. Otherwise this function does nothing. + * + * nbcon consoles acquired via the port lock wrapper always use priority + * NBCON_PRIO_NORMAL. */ void nbcon_handle_port_lock(struct uart_port *up) { @@ -1198,6 +1233,9 @@ EXPORT_SYMBOL_GPL(nbcon_handle_port_lock); * * If @up is an nbcon console, the console will be marked as safe and * released. Otherwise this function does nothing. + * + * nbcon consoles acquired via the port lock wrapper always use priority + * NBCON_PRIO_NORMAL. */ void nbcon_handle_port_unlock(struct uart_port *up) { -- 2.34.1