288 lines
9.1 KiB
Diff
288 lines
9.1 KiB
Diff
|
From: John Ogness <john.ogness@linutronix.de>
|
||
|
Date: Wed, 4 Sep 2024 14:11:28 +0206
|
||
|
Subject: [PATCH 46/54] printk: nbcon: Rely on kthreads for normal operation
|
||
|
Origin: https://www.kernel.org/pub/linux/kernel/projects/rt/6.11/older/patches-6.11-rt7.tar.xz
|
||
|
|
||
|
Once the kthread is running and available
|
||
|
(i.e. @printk_kthreads_running is set), the kthread becomes
|
||
|
responsible for flushing any pending messages which are added
|
||
|
in NBCON_PRIO_NORMAL context. Namely the legacy
|
||
|
console_flush_all() and device_release() no longer flush the
|
||
|
console. And nbcon_atomic_flush_pending() used by
|
||
|
nbcon_cpu_emergency_exit() no longer flushes messages added
|
||
|
after the emergency messages.
|
||
|
|
||
|
The console context is safe when used by the kthread only when
|
||
|
one of the following conditions are true:
|
||
|
|
||
|
1. Other caller acquires the console context with
|
||
|
NBCON_PRIO_NORMAL with preemption disabled. It will
|
||
|
release the context before rescheduling.
|
||
|
|
||
|
2. Other caller acquires the console context with
|
||
|
NBCON_PRIO_NORMAL under the device_lock.
|
||
|
|
||
|
3. The kthread is the only context which acquires the console
|
||
|
with NBCON_PRIO_NORMAL.
|
||
|
|
||
|
This is satisfied for all atomic printing call sites:
|
||
|
|
||
|
nbcon_legacy_emit_next_record() (#1)
|
||
|
|
||
|
nbcon_atomic_flush_pending_con() (#1)
|
||
|
|
||
|
nbcon_device_release() (#2)
|
||
|
|
||
|
It is even double guaranteed when @printk_kthreads_running
|
||
|
is set because then _only_ the kthread will print for
|
||
|
NBCON_PRIO_NORMAL. (#3)
|
||
|
|
||
|
Signed-off-by: John Ogness <john.ogness@linutronix.de>
|
||
|
Reviewed-by: Petr Mladek <pmladek@suse.com>
|
||
|
Link: https://lore.kernel.org/r/20240904120536.115780-10-john.ogness@linutronix.de
|
||
|
Signed-off-by: Petr Mladek <pmladek@suse.com>
|
||
|
Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
|
||
|
---
|
||
|
kernel/printk/internal.h | 26 +++++++++++++++++++++++++
|
||
|
kernel/printk/nbcon.c | 17 ++++++++++------
|
||
|
kernel/printk/printk.c | 48 ++++++++++++++++++++++++++++++++++++++++++++++-
|
||
|
3 files changed, 84 insertions(+), 7 deletions(-)
|
||
|
|
||
|
--- a/kernel/printk/internal.h
|
||
|
+++ b/kernel/printk/internal.h
|
||
|
@@ -113,6 +113,13 @@ static inline bool console_is_usable(str
|
||
|
/* The write_atomic() callback is optional. */
|
||
|
if (use_atomic && !con->write_atomic)
|
||
|
return false;
|
||
|
+
|
||
|
+ /*
|
||
|
+ * For the !use_atomic case, @printk_kthreads_running is not
|
||
|
+ * checked because the write_thread() callback is also used
|
||
|
+ * via the legacy loop when the printer threads are not
|
||
|
+ * available.
|
||
|
+ */
|
||
|
} else {
|
||
|
if (!con->write)
|
||
|
return false;
|
||
|
@@ -176,6 +183,7 @@ static inline void nbcon_atomic_flush_pe
|
||
|
static inline bool nbcon_legacy_emit_next_record(struct console *con, bool *handover,
|
||
|
int cookie, bool use_atomic) { return false; }
|
||
|
static inline void nbcon_kthread_wake(struct console *con) { }
|
||
|
+static inline void nbcon_kthreads_wake(void) { }
|
||
|
|
||
|
static inline bool console_is_usable(struct console *con, short flags,
|
||
|
bool use_atomic) { return false; }
|
||
|
@@ -190,6 +198,7 @@ extern bool legacy_allow_panic_sync;
|
||
|
/**
|
||
|
* struct console_flush_type - Define available console flush methods
|
||
|
* @nbcon_atomic: Flush directly using nbcon_atomic() callback
|
||
|
+ * @nbcon_offload: Offload flush to printer thread
|
||
|
* @legacy_direct: Call the legacy loop in this context
|
||
|
* @legacy_offload: Offload the legacy loop into IRQ
|
||
|
*
|
||
|
@@ -197,6 +206,7 @@ extern bool legacy_allow_panic_sync;
|
||
|
*/
|
||
|
struct console_flush_type {
|
||
|
bool nbcon_atomic;
|
||
|
+ bool nbcon_offload;
|
||
|
bool legacy_direct;
|
||
|
bool legacy_offload;
|
||
|
};
|
||
|
@@ -211,6 +221,22 @@ static inline void printk_get_console_fl
|
||
|
|
||
|
switch (nbcon_get_default_prio()) {
|
||
|
case NBCON_PRIO_NORMAL:
|
||
|
+ if (have_nbcon_console && !have_boot_console) {
|
||
|
+ if (printk_kthreads_running)
|
||
|
+ ft->nbcon_offload = true;
|
||
|
+ else
|
||
|
+ ft->nbcon_atomic = true;
|
||
|
+ }
|
||
|
+
|
||
|
+ /* Legacy consoles are flushed directly when possible. */
|
||
|
+ if (have_legacy_console || have_boot_console) {
|
||
|
+ if (!is_printk_legacy_deferred())
|
||
|
+ ft->legacy_direct = true;
|
||
|
+ else
|
||
|
+ ft->legacy_offload = true;
|
||
|
+ }
|
||
|
+ break;
|
||
|
+
|
||
|
case NBCON_PRIO_EMERGENCY:
|
||
|
if (have_nbcon_console && !have_boot_console)
|
||
|
ft->nbcon_atomic = true;
|
||
|
--- a/kernel/printk/nbcon.c
|
||
|
+++ b/kernel/printk/nbcon.c
|
||
|
@@ -1494,6 +1494,7 @@ static int __nbcon_atomic_flush_pending_
|
||
|
static void nbcon_atomic_flush_pending_con(struct console *con, u64 stop_seq,
|
||
|
bool allow_unsafe_takeover)
|
||
|
{
|
||
|
+ struct console_flush_type ft;
|
||
|
unsigned long flags;
|
||
|
int err;
|
||
|
|
||
|
@@ -1523,10 +1524,12 @@ static void nbcon_atomic_flush_pending_c
|
||
|
|
||
|
/*
|
||
|
* If flushing was successful but more records are available, this
|
||
|
- * context must flush those remaining records because there is no
|
||
|
- * other context that will do it.
|
||
|
+ * context must flush those remaining records if the printer thread
|
||
|
+ * is not available do it.
|
||
|
*/
|
||
|
- if (prb_read_valid(prb, nbcon_seq_read(con), NULL)) {
|
||
|
+ printk_get_console_flush_type(&ft);
|
||
|
+ if (!ft.nbcon_offload &&
|
||
|
+ prb_read_valid(prb, nbcon_seq_read(con), NULL)) {
|
||
|
stop_seq = prb_next_reserve_seq(prb);
|
||
|
goto again;
|
||
|
}
|
||
|
@@ -1754,17 +1757,19 @@ void nbcon_device_release(struct console
|
||
|
|
||
|
/*
|
||
|
* This context must flush any new records added while the console
|
||
|
- * was locked. The console_srcu_read_lock must be taken to ensure
|
||
|
- * the console is usable throughout flushing.
|
||
|
+ * was locked if the printer thread is not available to do it. The
|
||
|
+ * console_srcu_read_lock must be taken to ensure the console is
|
||
|
+ * usable throughout flushing.
|
||
|
*/
|
||
|
cookie = console_srcu_read_lock();
|
||
|
+ printk_get_console_flush_type(&ft);
|
||
|
if (console_is_usable(con, console_srcu_read_flags(con), true) &&
|
||
|
+ !ft.nbcon_offload &&
|
||
|
prb_read_valid(prb, nbcon_seq_read(con), NULL)) {
|
||
|
/*
|
||
|
* If nbcon_atomic flushing is not available, fallback to
|
||
|
* using the legacy loop.
|
||
|
*/
|
||
|
- printk_get_console_flush_type(&ft);
|
||
|
if (ft.nbcon_atomic) {
|
||
|
__nbcon_atomic_flush_pending_con(con, prb_next_reserve_seq(prb), false);
|
||
|
} else if (ft.legacy_direct) {
|
||
|
--- a/kernel/printk/printk.c
|
||
|
+++ b/kernel/printk/printk.c
|
||
|
@@ -2384,6 +2384,9 @@ asmlinkage int vprintk_emit(int facility
|
||
|
if (ft.nbcon_atomic)
|
||
|
nbcon_atomic_flush_pending();
|
||
|
|
||
|
+ if (ft.nbcon_offload)
|
||
|
+ nbcon_kthreads_wake();
|
||
|
+
|
||
|
if (ft.legacy_direct) {
|
||
|
/*
|
||
|
* The caller may be holding system-critical or
|
||
|
@@ -2733,6 +2736,7 @@ void suspend_console(void)
|
||
|
|
||
|
void resume_console(void)
|
||
|
{
|
||
|
+ struct console_flush_type ft;
|
||
|
struct console *con;
|
||
|
|
||
|
if (!console_suspend_enabled)
|
||
|
@@ -2750,6 +2754,10 @@ void resume_console(void)
|
||
|
*/
|
||
|
synchronize_srcu(&console_srcu);
|
||
|
|
||
|
+ printk_get_console_flush_type(&ft);
|
||
|
+ if (ft.nbcon_offload)
|
||
|
+ nbcon_kthreads_wake();
|
||
|
+
|
||
|
pr_flush(1000, true);
|
||
|
}
|
||
|
|
||
|
@@ -3061,6 +3069,7 @@ static inline void printk_kthreads_check
|
||
|
*/
|
||
|
static bool console_flush_all(bool do_cond_resched, u64 *next_seq, bool *handover)
|
||
|
{
|
||
|
+ struct console_flush_type ft;
|
||
|
bool any_usable = false;
|
||
|
struct console *con;
|
||
|
bool any_progress;
|
||
|
@@ -3072,12 +3081,22 @@ static bool console_flush_all(bool do_co
|
||
|
do {
|
||
|
any_progress = false;
|
||
|
|
||
|
+ printk_get_console_flush_type(&ft);
|
||
|
+
|
||
|
cookie = console_srcu_read_lock();
|
||
|
for_each_console_srcu(con) {
|
||
|
short flags = console_srcu_read_flags(con);
|
||
|
u64 printk_seq;
|
||
|
bool progress;
|
||
|
|
||
|
+ /*
|
||
|
+ * console_flush_all() is only responsible for nbcon
|
||
|
+ * consoles when the nbcon consoles cannot print via
|
||
|
+ * their atomic or threaded flushing.
|
||
|
+ */
|
||
|
+ if ((flags & CON_NBCON) && (ft.nbcon_atomic || ft.nbcon_offload))
|
||
|
+ continue;
|
||
|
+
|
||
|
if (!console_is_usable(con, flags, !do_cond_resched))
|
||
|
continue;
|
||
|
any_usable = true;
|
||
|
@@ -3388,9 +3407,25 @@ EXPORT_SYMBOL(console_stop);
|
||
|
|
||
|
void console_start(struct console *console)
|
||
|
{
|
||
|
+ struct console_flush_type ft;
|
||
|
+ bool is_nbcon;
|
||
|
+
|
||
|
console_list_lock();
|
||
|
console_srcu_write_flags(console, console->flags | CON_ENABLED);
|
||
|
+ is_nbcon = console->flags & CON_NBCON;
|
||
|
console_list_unlock();
|
||
|
+
|
||
|
+ /*
|
||
|
+ * Ensure that all SRCU list walks have completed. The related
|
||
|
+ * printing context must be able to see it is enabled so that
|
||
|
+ * it is guaranteed to wake up and resume printing.
|
||
|
+ */
|
||
|
+ synchronize_srcu(&console_srcu);
|
||
|
+
|
||
|
+ printk_get_console_flush_type(&ft);
|
||
|
+ if (is_nbcon && ft.nbcon_offload)
|
||
|
+ nbcon_kthread_wake(console);
|
||
|
+
|
||
|
__pr_flush(console, 1000, true);
|
||
|
}
|
||
|
EXPORT_SYMBOL(console_start);
|
||
|
@@ -4116,6 +4151,8 @@ static bool __pr_flush(struct console *c
|
||
|
|
||
|
/* Flush the consoles so that records up to @seq are printed. */
|
||
|
printk_get_console_flush_type(&ft);
|
||
|
+ if (ft.nbcon_atomic)
|
||
|
+ nbcon_atomic_flush_pending();
|
||
|
if (ft.legacy_direct) {
|
||
|
console_lock();
|
||
|
console_unlock();
|
||
|
@@ -4153,8 +4190,10 @@ static bool __pr_flush(struct console *c
|
||
|
* that they make forward progress, so only increment
|
||
|
* @diff for usable consoles.
|
||
|
*/
|
||
|
- if (!console_is_usable(c, flags, true))
|
||
|
+ if (!console_is_usable(c, flags, true) &&
|
||
|
+ !console_is_usable(c, flags, false)) {
|
||
|
continue;
|
||
|
+ }
|
||
|
|
||
|
if (flags & CON_NBCON) {
|
||
|
printk_seq = nbcon_seq_read(c);
|
||
|
@@ -4630,8 +4669,15 @@ EXPORT_SYMBOL_GPL(kmsg_dump_rewind);
|
||
|
*/
|
||
|
void console_try_replay_all(void)
|
||
|
{
|
||
|
+ struct console_flush_type ft;
|
||
|
+
|
||
|
+ printk_get_console_flush_type(&ft);
|
||
|
if (console_trylock()) {
|
||
|
__console_rewind_all();
|
||
|
+ if (ft.nbcon_atomic)
|
||
|
+ nbcon_atomic_flush_pending();
|
||
|
+ if (ft.nbcon_offload)
|
||
|
+ nbcon_kthreads_wake();
|
||
|
/* Consoles are flushed as part of console_unlock(). */
|
||
|
console_unlock();
|
||
|
}
|