* [PATCH 0/2] sched, livepatch: Fix transition stall for CPU-bound tasks
@ 2026-11-17 4:52 Dylan Hatch
2026-11-17 4:52 ` [PATCH 1/2] " Dylan Hatch
2026-11-17 4:52 ` [PATCH 2/2] selftests/livepatch: Add cond_resched() kthread transition test Dylan Hatch
0 siblings, 2 replies; 3+ messages in thread
From: Dylan Hatch @ 2026-11-17 4:52 UTC (permalink / raw)
To: Josh Poimboeuf, Miroslav Benes, Petr Mladek, Joe Lawrence,
Song Liu, Ingo Molnar, Peter Zijlstra, Juri Lelli,
Vincent Guittot, Shuah Khan
Cc: Dietmar Eggemann, Steven Rostedt, Ben Segall, Mel Gorman,
Valentin Schneider, K Prateek Nayak, Sebastian Andrzej Siewior,
Thomas Gleixner, live-patching, linux-kselftest, linux-kernel,
Dylan Hatch
Commit 676e8cf70cb0 ("sched,livepatch: Untangle cond_resched() and
live-patching") moved klp_sched_try_switch() from _cond_resched() into
__schedule() and gated it on READ_ONCE(curr->__state) & TASK_FREEZABLE.
This causes livepatch transitions to stall when CPU-bound kthreads or
PF_USER_WORKER threads (such as vhost-<pid>) spin in a kernel loop with
cond_resched():
1. A sole runnable task on a CPU (cfs_rq->nr_queued == 1) never has
TIF_NEED_RESCHED set during sched_tick(), and wake_up_state(task,
TASK_INTERRUPTIBLE) in klp_send_signals() is a no-op for a
TASK_RUNNING task. Because _cond_resched() is a no-op under
CONFIG_PREEMPTION=y, the task only enters __schedule(SM_PREEMPT) on
return from interrupts via irqentry_exit_cond_resched() when
TIF_NEED_RESCHED is set.
2. Even when __schedule() is entered via preemption or an unfreezable
sleep (such as PF_NOFREEZE kthreads or PF_USER_WORKER threads
sleeping in TASK_INTERRUPTIBLE), curr->__state does not have
TASK_FREEZABLE set, so klp_sched_try_switch() skips the task.
Patch 1 fixes both issues by dropping the TASK_FREEZABLE check from
klp_sched_try_switch() (relying on stack_trace_save_tsk_reliable() in
klp_check_stack()) and calling resched_curr(rq) in sched_tick() when
klp_sched_need_resched() is true for the current task.
Patch 2 adds a livepatch kselftest (test-cond-resched.sh) that spawns
kthreads spinning in a cpu_relax() + cond_resched_tasks_rcu_qs() loop
and verifies that livepatch transitions complete without stalling.
Note on reliable stacktraces across exception boundaries:
Because _cond_resched() is a no-op under CONFIG_PREEMPTION=y, a sole
runnable spinning kthread enters __schedule(SM_PREEMPT) from
preempt_schedule_irq() with an in-kernel interrupt pt_regs frame on the
stack. Switching the task in klp_sched_try_switch() therefore requires
arch_stack_walk_reliable() to support unwinding across in-kernel
exception frames. This works on x86_64 with CONFIG_UNWINDER_ORC=y, where
test-cond-resched.sh passes with this series.
On architectures or configurations where arch_stack_walk_reliable()
currently rejects in-kernel exception frames (arm64, powerpc, s390, or
x86 with CONFIG_FRAME_POINTER=y), test-cond-resched.sh exposes this
limitation and will fail until exception-boundary unwinding is
supported. On arm64, the test passes when combined with the proposed
kernel SFrame unwinder series [1] or equivalent .eh_frame-derived
unwind tables [2].
This series is available on github: [3].
Ref:
[1]: https://lore.kernel.org/all/20261117020648.323464-1-dylanbhatch@google.com/
[2]: https://lore.kernel.org/all/20261117043504.1021063-1-dylanbhatch@google.com/
[3]: https://github.com/dylanbhatch/linux/tree/stall
Dylan Hatch (2):
sched, livepatch: Fix transition stall for CPU-bound tasks
selftests/livepatch: Add cond_resched() kthread transition test
include/linux/livepatch_sched.h | 13 ++-
kernel/sched/core.c | 3 +-
tools/testing/selftests/livepatch/Makefile | 3 +-
.../selftests/livepatch/test-cond-resched.sh | 73 ++++++++++++++
.../selftests/livepatch/test_modules/Makefile | 1 +
.../test_modules/test_klp_cond_resched.c | 94 +++++++++++++++++++
6 files changed, 183 insertions(+), 4 deletions(-)
create mode 100755 tools/testing/selftests/livepatch/test-cond-resched.sh
create mode 100644 tools/testing/selftests/livepatch/test_modules/test_klp_cond_resched.c
--
2.56.0.679.gc527c65306-goog
^ permalink raw reply [flat|nested] 3+ messages in thread
* [PATCH 1/2] sched, livepatch: Fix transition stall for CPU-bound tasks
2026-11-17 4:52 [PATCH 0/2] sched, livepatch: Fix transition stall for CPU-bound tasks Dylan Hatch
@ 2026-11-17 4:52 ` Dylan Hatch
2026-11-17 4:52 ` [PATCH 2/2] selftests/livepatch: Add cond_resched() kthread transition test Dylan Hatch
1 sibling, 0 replies; 3+ messages in thread
From: Dylan Hatch @ 2026-11-17 4:52 UTC (permalink / raw)
To: Josh Poimboeuf, Miroslav Benes, Petr Mladek, Joe Lawrence,
Song Liu, Ingo Molnar, Peter Zijlstra, Juri Lelli,
Vincent Guittot, Shuah Khan
Cc: Dietmar Eggemann, Steven Rostedt, Ben Segall, Mel Gorman,
Valentin Schneider, K Prateek Nayak, Sebastian Andrzej Siewior,
Thomas Gleixner, live-patching, linux-kselftest, linux-kernel,
Dylan Hatch
Commit 676e8cf70cb0 ("sched,livepatch: Untangle cond_resched() and
live-patching") moved klp_sched_try_switch() from cond_resched() into
__schedule() and gated it on READ_ONCE(curr->__state) & TASK_FREEZABLE.
This causes livepatch transitions to stall when a CPU-bound kthread or
PF_USER_WORKER thread (such as vhost-<pid>) spins in a kernel loop with
cond_resched() for two reasons:
1. A sole runnable task on a CPU (cfs_rq->nr_queued == 1) never has
TIF_NEED_RESCHED set during sched_tick(), and wake_up_state(task,
TASK_INTERRUPTIBLE) in klp_send_signals() is a no-op for a
TASK_RUNNING kthread. Because _cond_resched() is a no-op under
CONFIG_PREEMPTION=y, the task only enters __schedule(SM_PREEMPT) on
return from interrupts via irqentry_exit_cond_resched() when
TIF_NEED_RESCHED is set.
2. Even when __schedule() is entered via preemption or an unfreezable
sleep (such as PF_NOFREEZE kthreads or PF_USER_WORKER threads
sleeping in TASK_INTERRUPTIBLE), curr->__state does not have
TASK_FREEZABLE set, so klp_sched_try_switch() skips the task.
Livepatch safety in __schedule() is already guaranteed by
stack_trace_save_tsk_reliable() inside klp_check_stack().
Fix both issues by:
- Removing the TASK_FREEZABLE check from klp_sched_try_switch() and
checking TIF_PATCH_PENDING inline via klp_sched_need_resched().
- Calling resched_curr(rq) in sched_tick() when klp_sched_need_resched()
is true for the current task, ensuring CPU-bound tasks with a pending
livepatch enter __schedule() at the next timer tick.
Note that when a CPU-bound task is the sole runnable task on its CPU,
entering __schedule(SM_PREEMPT) from preempt_schedule_irq() leaves an
in-kernel interrupt pt_regs frame on the stack during
klp_sched_try_switch(). Completing the transition in that context
requires arch_stack_walk_reliable() to support unwinding across
in-kernel exception frames (as CONFIG_UNWINDER_ORC=y does on x86_64);
configs and architectures whose reliable unwinder rejects in-kernel
exception frames (x86 with CONFIG_FRAME_POINTER=y, arm64, powerpc, and
s390) still require another runnable task to context-switch the spinning
task out until exception-boundary reliable unwinding (e.g. via SFrame)
is available.
Fixes: 676e8cf70cb0 ("sched,livepatch: Untangle cond_resched() and live-patching")
Signed-off-by: Dylan Hatch <dylanbhatch@google.com>
---
include/linux/livepatch_sched.h | 13 +++++++++++--
kernel/sched/core.c | 3 ++-
2 files changed, 13 insertions(+), 3 deletions(-)
diff --git a/include/linux/livepatch_sched.h b/include/linux/livepatch_sched.h
index 065c185f27638..748b6012e2e06 100644
--- a/include/linux/livepatch_sched.h
+++ b/include/linux/livepatch_sched.h
@@ -11,15 +11,24 @@ void __klp_sched_try_switch(void);
DECLARE_STATIC_KEY_FALSE(klp_sched_try_switch_key);
+static __always_inline bool klp_sched_need_resched(struct task_struct *curr)
+{
+ return static_branch_unlikely(&klp_sched_try_switch_key) &&
+ unlikely(test_tsk_thread_flag(curr, TIF_PATCH_PENDING));
+}
+
static __always_inline void klp_sched_try_switch(struct task_struct *curr)
{
- if (static_branch_unlikely(&klp_sched_try_switch_key) &&
- READ_ONCE(curr->__state) & TASK_FREEZABLE)
+ if (klp_sched_need_resched(curr))
__klp_sched_try_switch();
}
#else /* !CONFIG_LIVEPATCH */
static inline void klp_sched_try_switch(struct task_struct *curr) {}
+static inline bool klp_sched_need_resched(struct task_struct *curr)
+{
+ return false;
+}
#endif /* CONFIG_LIVEPATCH */
#endif /* _LINUX_LIVEPATCH_SCHED_H_ */
diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index 04b62c16fa8ca..fcea9cea3edf1 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -5854,7 +5854,8 @@ void sched_tick(void)
hw_pressure = arch_scale_hw_pressure(cpu_of(rq));
update_hw_load_avg(rq_clock_task(rq), rq, hw_pressure);
- if (dynamic_preempt_lazy() && tif_test_bit(TIF_NEED_RESCHED_LAZY))
+ if ((dynamic_preempt_lazy() && tif_test_bit(TIF_NEED_RESCHED_LAZY)) ||
+ klp_sched_need_resched(curr))
resched_curr(rq);
donor->sched_class->task_tick(rq, donor, 0);
--
2.56.0.679.gc527c65306-goog
^ permalink raw reply related [flat|nested] 3+ messages in thread
* [PATCH 2/2] selftests/livepatch: Add cond_resched() kthread transition test
2026-11-17 4:52 [PATCH 0/2] sched, livepatch: Fix transition stall for CPU-bound tasks Dylan Hatch
2026-11-17 4:52 ` [PATCH 1/2] " Dylan Hatch
@ 2026-11-17 4:52 ` Dylan Hatch
1 sibling, 0 replies; 3+ messages in thread
From: Dylan Hatch @ 2026-11-17 4:52 UTC (permalink / raw)
To: Josh Poimboeuf, Miroslav Benes, Petr Mladek, Joe Lawrence,
Song Liu, Ingo Molnar, Peter Zijlstra, Juri Lelli,
Vincent Guittot, Shuah Khan
Cc: Dietmar Eggemann, Steven Rostedt, Ben Segall, Mel Gorman,
Valentin Schneider, K Prateek Nayak, Sebastian Andrzej Siewior,
Thomas Gleixner, live-patching, linux-kselftest, linux-kernel,
Dylan Hatch
Add a livepatch kselftest (test-cond-resched.sh) and helper module
(test_klp_cond_resched) to verify that a livepatch transition completes
while CPU-bound kthreads spin in a cpu_relax() +
cond_resched_tasks_rcu_qs() loop on other online CPUs.
After commit 676e8cf70cb0 ("sched,livepatch: Untangle cond_resched() and
live-patching"), klp_sched_try_switch() was moved from cond_resched()
into __schedule() and gated on TASK_FREEZABLE. A sole runnable kthread
spinning in a cond_resched() loop never gets TIF_NEED_RESCHED set and
does not have TASK_FREEZABLE set, causing the livepatch transition to
stall.
Note that because _cond_resched() is a no-op under CONFIG_PREEMPTION=y,
a sole runnable spinning kthread enters __schedule(SM_PREEMPT) via
preempt_schedule_irq() with an in-kernel interrupt pt_regs frame on the
stack. Passing this test without another runnable task on the CPU
therefore requires arch_stack_walk_reliable() to support unwinding
across in-kernel exception frames (such as x86_64 with
CONFIG_UNWINDER_ORC=y); on architectures or configs where
arch_stack_walk_reliable() currently rejects in-kernel exception frames
(arm64, powerpc, s390, or x86 with CONFIG_FRAME_POINTER=y), this test
exposes the lack of exception-boundary reliable unwinding.
Signed-off-by: Dylan Hatch <dylanbhatch@google.com>
---
tools/testing/selftests/livepatch/Makefile | 3 +-
.../selftests/livepatch/test-cond-resched.sh | 73 ++++++++++++++
.../selftests/livepatch/test_modules/Makefile | 1 +
.../test_modules/test_klp_cond_resched.c | 94 +++++++++++++++++++
4 files changed, 170 insertions(+), 1 deletion(-)
create mode 100755 tools/testing/selftests/livepatch/test-cond-resched.sh
create mode 100644 tools/testing/selftests/livepatch/test_modules/test_klp_cond_resched.c
diff --git a/tools/testing/selftests/livepatch/Makefile b/tools/testing/selftests/livepatch/Makefile
index a080eb54a215d..14741d8da4209 100644
--- a/tools/testing/selftests/livepatch/Makefile
+++ b/tools/testing/selftests/livepatch/Makefile
@@ -11,7 +11,8 @@ TEST_PROGS := \
test-ftrace.sh \
test-sysfs.sh \
test-syscall.sh \
- test-kprobe.sh
+ test-kprobe.sh \
+ test-cond-resched.sh
TEST_FILES := settings
diff --git a/tools/testing/selftests/livepatch/test-cond-resched.sh b/tools/testing/selftests/livepatch/test-cond-resched.sh
new file mode 100755
index 0000000000000..4a7c013c863db
--- /dev/null
+++ b/tools/testing/selftests/livepatch/test-cond-resched.sh
@@ -0,0 +1,73 @@
+#!/bin/bash
+# SPDX-License-Identifier: GPL-2.0
+
+. $(dirname $0)/functions.sh
+
+MOD_LIVEPATCH=test_klp_livepatch
+MOD_COND_RESCHED=test_klp_cond_resched
+
+setup_config
+
+if [[ $(nproc) -lt 3 ]]; then
+ skip "test-cond-resched requires at least 3 online CPUs"
+fi
+
+function cleanup_cond_resched() {
+ # Stop the spinning kthread first so any stalled livepatch transition
+ # can complete before unloading the livepatch module.
+ rmmod $MOD_COND_RESCHED 2>/dev/null || true
+ if [[ -e "$SYSFS_KLP_DIR/$MOD_LIVEPATCH" ]]; then
+ echo 0 > "$SYSFS_KLP_DIR/$MOD_LIVEPATCH/enabled" 2>/dev/null || true
+ loop_until '[[ ! -e "$SYSFS_KLP_DIR/$MOD_LIVEPATCH" ]]' || true
+ fi
+ rmmod $MOD_LIVEPATCH 2>/dev/null || true
+ cleanup
+}
+trap cleanup_cond_resched EXIT INT TERM HUP
+
+# - start CPU-bound kthreads spinning in a cpu_relax() +
+# cond_resched_tasks_rcu_qs() loop on other online CPUs
+# - load a livepatch and verify the patching transition completes
+# - disable and unload the livepatch and verify the unpatching transition
+# completes
+# - unload the cond_resched kthread module
+
+start_test "kthread spinning in cond_resched() transition"
+
+load_mod $MOD_COND_RESCHED
+
+load_lp $MOD_LIVEPATCH
+
+if [[ "$(cat /proc/cmdline)" != "$MOD_LIVEPATCH: this has been live patched" ]] ; then
+ echo -e "FAIL\n\n"
+ die "livepatch kselftest(s) failed"
+fi
+
+disable_lp $MOD_LIVEPATCH
+unload_lp $MOD_LIVEPATCH
+
+if [[ "$(cat /proc/cmdline)" == "$MOD_LIVEPATCH: this has been live patched" ]] ; then
+ echo -e "FAIL\n\n"
+ die "livepatch kselftest(s) failed"
+fi
+
+unload_mod $MOD_COND_RESCHED
+
+check_result "% insmod test_modules/$MOD_COND_RESCHED.ko
+$MOD_COND_RESCHED: cond_resched_fn: spinning in cond_resched()
+% insmod test_modules/$MOD_LIVEPATCH.ko
+livepatch: enabling patch '$MOD_LIVEPATCH'
+livepatch: '$MOD_LIVEPATCH': initializing patching transition
+livepatch: '$MOD_LIVEPATCH': starting patching transition
+livepatch: '$MOD_LIVEPATCH': completing patching transition
+livepatch: '$MOD_LIVEPATCH': patching complete
+% echo 0 > $SYSFS_KLP_DIR/$MOD_LIVEPATCH/enabled
+livepatch: '$MOD_LIVEPATCH': initializing unpatching transition
+livepatch: '$MOD_LIVEPATCH': starting unpatching transition
+livepatch: '$MOD_LIVEPATCH': completing unpatching transition
+livepatch: '$MOD_LIVEPATCH': unpatching complete
+% rmmod $MOD_LIVEPATCH
+% rmmod $MOD_COND_RESCHED
+$MOD_COND_RESCHED: cond_resched_fn: stopping"
+
+exit 0
diff --git a/tools/testing/selftests/livepatch/test_modules/Makefile b/tools/testing/selftests/livepatch/test_modules/Makefile
index a13d398585dcb..1502ff9070b88 100644
--- a/tools/testing/selftests/livepatch/test_modules/Makefile
+++ b/tools/testing/selftests/livepatch/test_modules/Makefile
@@ -6,6 +6,7 @@ obj-m += test_klp_atomic_replace.o \
test_klp_callbacks_demo.o \
test_klp_callbacks_demo2.o \
test_klp_callbacks_mod.o \
+ test_klp_cond_resched.o \
test_klp_kprobe.o \
test_klp_livepatch.o \
test_klp_mod_patch.o \
diff --git a/tools/testing/selftests/livepatch/test_modules/test_klp_cond_resched.c b/tools/testing/selftests/livepatch/test_modules/test_klp_cond_resched.c
new file mode 100644
index 0000000000000..ae1d1e3aab106
--- /dev/null
+++ b/tools/testing/selftests/livepatch/test_modules/test_klp_cond_resched.c
@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * test_klp_cond_resched.c - Support module for testing livepatch
+ * transitions while a CPU-bound kthread spins in cond_resched().
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/completion.h>
+#include <linux/cpumask.h>
+#include <linux/kernel.h>
+#include <linux/kthread.h>
+#include <linux/module.h>
+#include <linux/processor.h>
+#include <linux/rcupdate.h>
+#include <linux/sched.h>
+#include <linux/smp.h>
+
+#define NUM_COND_RESCHED_TASKS 2
+
+static struct task_struct *cond_resched_tsks[NUM_COND_RESCHED_TASKS];
+static atomic_t cond_resched_ready = ATOMIC_INIT(NUM_COND_RESCHED_TASKS);
+static DECLARE_COMPLETION(cond_resched_started);
+
+static int cond_resched_fn(void *data)
+{
+ if (atomic_dec_and_test(&cond_resched_ready)) {
+ pr_info("%s: spinning in cond_resched()\n", __func__);
+ complete(&cond_resched_started);
+ }
+ while (!kthread_should_stop()) {
+ cpu_relax();
+ cond_resched_tasks_rcu_qs();
+ }
+ return 0;
+}
+
+static void stop_cond_resched_tasks(void)
+{
+ int i;
+
+ for (i = 0; i < NUM_COND_RESCHED_TASKS; i++) {
+ if (cond_resched_tsks[i]) {
+ kthread_stop(cond_resched_tsks[i]);
+ cond_resched_tsks[i] = NULL;
+ }
+ }
+}
+
+static int test_klp_cond_resched_init(void)
+{
+ int cur_cpu, cpu, i = 0;
+ int target_cpus[NUM_COND_RESCHED_TASKS];
+
+ cur_cpu = get_cpu();
+ for_each_online_cpu(cpu) {
+ if (cpu != cur_cpu)
+ target_cpus[i++ % NUM_COND_RESCHED_TASKS] = cpu;
+ }
+ put_cpu();
+
+ if (i < NUM_COND_RESCHED_TASKS)
+ return -EINVAL;
+
+ for (i = 0; i < NUM_COND_RESCHED_TASKS; i++) {
+ struct task_struct *tsk;
+
+ tsk = kthread_create_on_cpu(cond_resched_fn, NULL,
+ target_cpus[i],
+ "klp_cond_resched/%u");
+ if (IS_ERR(tsk)) {
+ stop_cond_resched_tasks();
+ return PTR_ERR(tsk);
+ }
+ cond_resched_tsks[i] = tsk;
+ }
+
+ for (i = 0; i < NUM_COND_RESCHED_TASKS; i++)
+ wake_up_process(cond_resched_tsks[i]);
+
+ wait_for_completion(&cond_resched_started);
+ return 0;
+}
+
+static void test_klp_cond_resched_exit(void)
+{
+ stop_cond_resched_tasks();
+ pr_info("cond_resched_fn: stopping\n");
+}
+
+module_init(test_klp_cond_resched_init);
+module_exit(test_klp_cond_resched_exit);
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Livepatch test: cond_resched() kthread transition");
--
2.56.0.679.gc527c65306-goog
^ permalink raw reply related [flat|nested] 3+ messages in thread
end of thread, other threads:[~2026-11-17 4:53 UTC | newest]
Thread overview: 3+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-17 4:52 [PATCH 0/2] sched, livepatch: Fix transition stall for CPU-bound tasks Dylan Hatch
2026-11-17 4:52 ` [PATCH 1/2] " Dylan Hatch
2026-11-17 4:52 ` [PATCH 2/2] selftests/livepatch: Add cond_resched() kthread transition test Dylan Hatch
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.