diff options
Diffstat (limited to 'debian/patches-rt/0046-printk-nbcon-Add-function-for-printers-to-reacquire-.patch')
| -rw-r--r-- | debian/patches-rt/0046-printk-nbcon-Add-function-for-printers-to-reacquire-.patch | 119 |
1 files changed, 119 insertions, 0 deletions
diff --git a/debian/patches-rt/0046-printk-nbcon-Add-function-for-printers-to-reacquire-.patch b/debian/patches-rt/0046-printk-nbcon-Add-function-for-printers-to-reacquire-.patch new file mode 100644 index 0000000000..75a090edc3 --- /dev/null +++ b/debian/patches-rt/0046-printk-nbcon-Add-function-for-printers-to-reacquire-.patch @@ -0,0 +1,119 @@ +From: John Ogness <john.ogness@linutronix.de> +Date: Fri, 20 Oct 2023 10:01:58 +0000 +Subject: [PATCH 46/48] printk: nbcon: Add function for printers to reacquire + ownership +Origin: https://www.kernel.org/pub/linux/kernel/projects/rt/6.10/older/patches-6.10.2-rt14.tar.xz + +Since ownership can be lost at any time due to handover or +takeover, a printing context _must_ be prepared to back out +immediately and carefully. However, there are scenarios where +the printing context must reacquire ownership in order to +finalize or revert hardware changes. + +One such example is when interrupts are disabled during +printing. No other context will automagically re-enable the +interrupts. For this case, the disabling context _must_ +reacquire nbcon ownership so that it can re-enable the +interrupts. + +Provide nbcon_reacquire() for exactly this purpose. It allows a +printing context to reacquire ownership using the same priority +as its previous ownership. + +Note that after a successful reacquire the printing context +will have no output buffer because that has been lost. This +function cannot be used to resume printing. + +Signed-off-by: John Ogness <john.ogness@linutronix.de> +Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de> +--- + include/linux/console.h | 6 ++++++ + kernel/printk/nbcon.c | 41 +++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 47 insertions(+) + +--- a/include/linux/console.h ++++ b/include/linux/console.h +@@ -372,6 +372,10 @@ struct console { + * + * The callback should allow the takeover whenever it is safe. It + * increases the chance to see messages when the system is in trouble. ++ * If the driver must reacquire ownership in order to finalize or ++ * revert hardware changes, nbcon_reacquire() can be used. However, ++ * on reacquire the buffer content is no longer available. A ++ * reacquire cannot be used to resume printing. + * + * The callback can be called from any context (including NMI). + * Therefore it must avoid usage of any locking and instead rely +@@ -591,6 +595,7 @@ extern void nbcon_cpu_emergency_flush(vo + extern bool nbcon_can_proceed(struct nbcon_write_context *wctxt); + extern bool nbcon_enter_unsafe(struct nbcon_write_context *wctxt); + extern bool nbcon_exit_unsafe(struct nbcon_write_context *wctxt); ++extern void nbcon_reacquire(struct nbcon_write_context *wctxt); + #else + static inline void nbcon_cpu_emergency_enter(void) { } + static inline void nbcon_cpu_emergency_exit(void) { } +@@ -598,6 +603,7 @@ static inline void nbcon_cpu_emergency_f + static inline bool nbcon_can_proceed(struct nbcon_write_context *wctxt) { return false; } + static inline bool nbcon_enter_unsafe(struct nbcon_write_context *wctxt) { return false; } + static inline bool nbcon_exit_unsafe(struct nbcon_write_context *wctxt) { return false; } ++static inline void nbcon_reacquire(struct nbcon_write_context *wctxt) { } + #endif + + extern int console_set_on_cmdline; +--- a/kernel/printk/nbcon.c ++++ b/kernel/printk/nbcon.c +@@ -839,6 +839,38 @@ bool nbcon_exit_unsafe(struct nbcon_writ + EXPORT_SYMBOL_GPL(nbcon_exit_unsafe); + + /** ++ * nbcon_reacquire - Reacquire a console after losing ownership while printing ++ * @wctxt: The write context that was handed to the write callback ++ * ++ * Since ownership can be lost at any time due to handover or takeover, a ++ * printing context _must_ be prepared to back out immediately and ++ * carefully. However, there are scenarios where the printing context must ++ * reacquire ownership in order to finalize or revert hardware changes. ++ * ++ * This function allows a printing context to reacquire ownership using the ++ * same priority as its previous ownership. ++ * ++ * Note that after a successful reacquire the printing context will have no ++ * output buffer because that has been lost. This function cannot be used to ++ * resume printing. ++ */ ++void nbcon_reacquire(struct nbcon_write_context *wctxt) ++{ ++ struct nbcon_context *ctxt = &ACCESS_PRIVATE(wctxt, ctxt); ++ struct console *con = ctxt->console; ++ struct nbcon_state cur; ++ ++ while (!nbcon_context_try_acquire(ctxt)) ++ cpu_relax(); ++ ++ wctxt->outbuf = NULL; ++ wctxt->len = 0; ++ nbcon_state_read(con, &cur); ++ wctxt->unsafe_takeover = cur.unsafe_takeover; ++} ++EXPORT_SYMBOL_GPL(nbcon_reacquire); ++ ++/** + * nbcon_emit_next_record - Emit a record in the acquired context + * @wctxt: The write context that will be handed to the write function + * @use_atomic: True if the write_atomic() callback is to be used +@@ -944,6 +976,15 @@ static bool nbcon_emit_next_record(struc + nbcon_context_release(ctxt); + return false; + } ++ ++ if (!wctxt->outbuf) { ++ /* ++ * Ownership was lost and reacquired by the driver. ++ * Handle it as if ownership was lost. ++ */ ++ nbcon_context_release(ctxt); ++ return false; ++ } + + /* + * Since any dropped message was successfully output, reset the |