diff options
Diffstat (limited to '')
| -rw-r--r-- | debian/patches-rt/0020-printk-nbcon-Provide-function-to-flush-using-write_a.patch (renamed from debian/patches-rt/0024-printk-nbcon-Provide-function-to-flush-using-write_a.patch) | 129 |
1 files changed, 68 insertions, 61 deletions
diff --git a/debian/patches-rt/0024-printk-nbcon-Provide-function-to-flush-using-write_a.patch b/debian/patches-rt/0020-printk-nbcon-Provide-function-to-flush-using-write_a.patch index 9f8a3e3765..26c68ed229 100644 --- a/debian/patches-rt/0024-printk-nbcon-Provide-function-to-flush-using-write_a.patch +++ b/debian/patches-rt/0020-printk-nbcon-Provide-function-to-flush-using-write_a.patch @@ -1,26 +1,29 @@ From: Thomas Gleixner <tglx@linutronix.de> Date: Tue, 12 Sep 2023 12:00:08 +0000 -Subject: [PATCH 24/50] printk: nbcon: Provide function to flush using +Subject: [PATCH 20/48] printk: nbcon: Provide function to flush using write_atomic() -Origin: https://www.kernel.org/pub/linux/kernel/projects/rt/6.7/older/patches-6.7-rt6.tar.xz +Origin: https://www.kernel.org/pub/linux/kernel/projects/rt/6.8/older/patches-6.8.2-rt11.tar.xz -Provide nbcon_atomic_flush_all() to perform flushing of all +Provide nbcon_atomic_flush_pending() to perform flushing of all registered nbcon consoles using their write_atomic() callback. -Like with legacy consoles, the nbcon consoles are flushed one -record per console. This allows all nbcon consoles to print -lines pseudo-simultaneously, rather than one console waiting -for the full ringbuffer to dump to another console before -printing anything. -Unlike console_flush_all(), nbcon_atomic_flush_all() will only -flush up through the newest record at the time of the call. -This prevents a CPU from printing unbounded when other CPUs are -adding records. +Unlike console_flush_all(), nbcon_atomic_flush_pending() will +only flush up through the newest record at the time of the +call. This prevents a CPU from printing unbounded when other +CPUs are adding records. -Perform nbcon console atomic flushing in -console_flush_on_panic(). This function is not only used in -panic() but also other locations where there may be stored -messages that need to be flushed. +Also unlike console_flush_all(), nbcon_atomic_flush_pending() +will fully flush one console before flushing the next. This +helps to guarantee that a block of pending records (such as +a stack trace in an emergency situation) can be printed +atomically at once before releasing console ownership. + +nbcon_atomic_flush_pending() is safe in any context because it +uses write_atomic() and acquires with unsafe_takeover disabled. + +Use it in console_flush_on_panic() before flushing legacy +consoles. The legacy write() callbacks are not fully safe when +oops_in_progress is set. Co-developed-by: John Ogness <john.ogness@linutronix.de> Signed-off-by: John Ogness <john.ogness@linutronix.de> @@ -28,31 +31,31 @@ Signed-off-by: Thomas Gleixner (Intel) <tglx@linutronix.de> Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de> --- kernel/printk/internal.h | 2 - kernel/printk/nbcon.c | 100 ++++++++++++++++++++++++++++++++++++++++++++++- + kernel/printk/nbcon.c | 104 ++++++++++++++++++++++++++++++++++++++++++++++- kernel/printk/printk.c | 2 - 3 files changed, 102 insertions(+), 2 deletions(-) + 3 files changed, 106 insertions(+), 2 deletions(-) --- a/kernel/printk/internal.h +++ b/kernel/printk/internal.h -@@ -77,6 +77,7 @@ void nbcon_seq_force(struct console *con +@@ -84,6 +84,7 @@ void nbcon_seq_force(struct console *con bool nbcon_alloc(struct console *con); void nbcon_init(struct console *con); void nbcon_free(struct console *con); -+void nbcon_atomic_flush_all(void); ++void nbcon_atomic_flush_pending(void); /* * Check if the given console is currently capable and allowed to print -@@ -131,6 +132,7 @@ static inline void nbcon_seq_force(struc +@@ -138,6 +139,7 @@ static inline void nbcon_seq_force(struc 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 void nbcon_atomic_flush_all(void) { } ++static inline void nbcon_atomic_flush_pending(void) { } static inline bool console_is_usable(struct console *con, short flags) { return false; } --- a/kernel/printk/nbcon.c +++ b/kernel/printk/nbcon.c -@@ -539,7 +539,6 @@ static struct printk_buffers panic_nbcon +@@ -548,7 +548,6 @@ static struct printk_buffers panic_nbcon * in an unsafe state. Otherwise, on success the caller may assume * the console is not in an unsafe state. */ @@ -60,7 +63,7 @@ Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de> static bool nbcon_context_try_acquire(struct nbcon_context *ctxt) { unsigned int cpu = smp_processor_id(); -@@ -841,7 +840,6 @@ EXPORT_SYMBOL_GPL(nbcon_exit_unsafe); +@@ -850,7 +849,6 @@ EXPORT_SYMBOL_GPL(nbcon_exit_unsafe); * When true is returned, @wctxt->ctxt.backlog indicates whether there are * still records pending in the ringbuffer, */ @@ -68,56 +71,65 @@ Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de> static bool nbcon_emit_next_record(struct nbcon_write_context *wctxt) { struct nbcon_context *ctxt = &ACCESS_PRIVATE(wctxt, ctxt); -@@ -931,6 +929,104 @@ static bool nbcon_emit_next_record(struc +@@ -938,6 +936,108 @@ static bool nbcon_emit_next_record(struc } /** -+ * nbcon_atomic_emit_one - Print one record for an nbcon console using the -+ * write_atomic() callback -+ * @wctxt: An initialized write context struct to use -+ * for this context ++ * __nbcon_atomic_flush_pending_con - Flush specified nbcon console using its ++ * write_atomic() callback ++ * @con: The nbcon console to flush ++ * @stop_seq: Flush up until this record + * -+ * Return: False if the given console could not print a record or there -+ * are no more records to print, otherwise true. ++ * Return: True if taken over while printing. Otherwise false. + * -+ * This is an internal helper to handle the locking of the console before -+ * calling nbcon_emit_next_record(). ++ * If flushing up to @stop_seq was not successful, it only makes sense for the ++ * caller to try again when true was returned. When false is returned, either ++ * there are no more records available to read or this context is not allowed ++ * to acquire the console. + */ -+static bool nbcon_atomic_emit_one(struct nbcon_write_context *wctxt) ++static bool __nbcon_atomic_flush_pending_con(struct console *con, u64 stop_seq) +{ -+ struct nbcon_context *ctxt = &ACCESS_PRIVATE(wctxt, ctxt); ++ struct nbcon_write_context wctxt = { }; ++ struct nbcon_context *ctxt = &ACCESS_PRIVATE(&wctxt, ctxt); ++ ++ ctxt->console = con; ++ ctxt->spinwait_max_us = 2000; ++ ctxt->prio = NBCON_PRIO_NORMAL; + + if (!nbcon_context_try_acquire(ctxt)) + return false; + -+ /* -+ * nbcon_emit_next_record() returns false when the console was -+ * handed over or taken over. In both cases the context is no -+ * longer valid. -+ */ -+ if (!nbcon_emit_next_record(wctxt)) -+ return false; ++ while (nbcon_seq_read(con) < stop_seq) { ++ /* ++ * nbcon_emit_next_record() returns false when the console was ++ * handed over or taken over. In both cases the context is no ++ * longer valid. ++ */ ++ if (!nbcon_emit_next_record(&wctxt)) ++ return true; ++ ++ if (!ctxt->backlog) ++ break; ++ } + + nbcon_context_release(ctxt); + -+ return ctxt->backlog; ++ return false; +} + +/** -+ * __nbcon_atomic_flush_all - Flush all nbcon consoles using their ++ * __nbcon_atomic_flush_pending - Flush all nbcon consoles using their + * write_atomic() callback + * @stop_seq: Flush up until this record + */ -+static void __nbcon_atomic_flush_all(u64 stop_seq) ++static void __nbcon_atomic_flush_pending(u64 stop_seq) +{ -+ struct nbcon_write_context wctxt = { }; -+ struct nbcon_context *ctxt = &ACCESS_PRIVATE(&wctxt, ctxt); + struct console *con; -+ bool any_progress; ++ bool should_retry; + int cookie; + + do { -+ any_progress = false; ++ should_retry = false; + + cookie = console_srcu_read_lock(); + for_each_console_srcu(con) { @@ -133,40 +145,35 @@ Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de> + if (nbcon_seq_read(con) >= stop_seq) + continue; + -+ memset(ctxt, 0, sizeof(*ctxt)); -+ ctxt->console = con; -+ ctxt->spinwait_max_us = 2000; -+ ctxt->prio = NBCON_PRIO_NORMAL; -+ + /* + * Atomic flushing does not use console driver + * synchronization (i.e. it does not hold the port + * lock for uart consoles). Therefore IRQs must be + * disabled to avoid being interrupted and then + * calling into a driver that will deadlock trying -+ * acquire console ownership. ++ * to acquire console ownership. + */ + local_irq_save(irq_flags); + -+ any_progress |= nbcon_atomic_emit_one(&wctxt); ++ should_retry |= __nbcon_atomic_flush_pending_con(con, stop_seq); + + local_irq_restore(irq_flags); + } + console_srcu_read_unlock(cookie); -+ } while (any_progress); ++ } while (should_retry); +} + +/** -+ * nbcon_atomic_flush_all - Flush all nbcon consoles using their ++ * nbcon_atomic_flush_pending - Flush all nbcon consoles using their + * write_atomic() callback + * + * Flush the backlog up through the currently newest record. Any new + * records added while flushing will not be flushed. This is to avoid + * one CPU printing unbounded because other CPUs continue to add records. + */ -+void nbcon_atomic_flush_all(void) ++void nbcon_atomic_flush_pending(void) +{ -+ __nbcon_atomic_flush_all(prb_next_reserve_seq(prb)); ++ __nbcon_atomic_flush_pending(prb_next_reserve_seq(prb)); +} + +/** @@ -179,7 +186,7 @@ Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de> console_srcu_read_unlock(cookie); } -+ nbcon_atomic_flush_all(); ++ nbcon_atomic_flush_pending(); + console_flush_all(false, &next_seq, &handover); } |