Adding debian version 6.10.3-1.debian/6.10.3-1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

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