mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: Josh Poimboeuf <jpoimboe@kernel.org>
To: Dylan Hatch <dylanbhatch@google.com>
Cc: Miroslav Benes <mbenes@suse.cz>, Petr Mladek <pmladek@suse.com>,
	 Joe Lawrence <joe.lawrence@redhat.com>,
	Song Liu <song@kernel.org>, Ingo Molnar <mingo@redhat.com>,
	 Peter Zijlstra <peterz@infradead.org>,
	Juri Lelli <juri.lelli@redhat.com>,
	 Vincent Guittot <vincent.guittot@linaro.org>,
	Shuah Khan <shuah@kernel.org>,
	 Dietmar Eggemann <dietmar.eggemann@arm.com>,
	Steven Rostedt <rostedt@goodmis.org>,
	 Ben Segall <bsegall@google.com>, Mel Gorman <mgorman@suse.de>,
	 Valentin Schneider <vschneid@redhat.com>,
	K Prateek Nayak <kprateek.nayak@amd.com>,
	 Sebastian Andrzej Siewior <bigeasy@linutronix.de>,
	Thomas Gleixner <tglx@kernel.org>,
	live-patching@vger.kernel.org,  linux-kselftest@vger.kernel.org,
	linux-kernel@vger.kernel.org
Subject: Re: [PATCH 1/2] sched, livepatch: Fix transition stall for CPU-bound tasks
Date: Sat, 21 Nov 2026 13:55:39 -0800	[thread overview]
Message-ID: <awIMltMpXzhXiDpU@jpoimboe> (raw)
In-Reply-To: <20261117045254.1048298-2-dylanbhatch@google.com>

On Tue, Nov 17, 2026 at 04:52:53AM +0000, Dylan Hatch wrote:
> 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")

Oof, so Peter's patch broke all non-ORC for this case :-(

Not sure what we can do about that other than get kernel sframe/eh_frame
working for exception boundary unwinding, as you mention.

> 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);

Hm, so for unpatched tasks this forces a full preemption and stack walk
on every scheduler tick?

Instead can we just kick the thread in the existing klp_send_signals()
escalation path like below (untested)?

diff --git a/include/linux/livepatch_sched.h b/include/linux/livepatch_sched.h
index 065c185f27638..77161f5725dcc 100644
--- a/include/linux/livepatch_sched.h
+++ b/include/linux/livepatch_sched.h
@@ -13,8 +13,7 @@ DECLARE_STATIC_KEY_FALSE(klp_sched_try_switch_key);
 
 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 (static_branch_unlikely(&klp_sched_try_switch_key))
 		__klp_sched_try_switch();
 }
 
diff --git a/kernel/livepatch/transition.c b/kernel/livepatch/transition.c
index e058d21d84b75..1ccbae2051c72 100644
--- a/kernel/livepatch/transition.c
+++ b/kernel/livepatch/transition.c
@@ -402,12 +402,22 @@ static void klp_send_signals(void)
 		 * Meanwhile the task could migrate itself and the action
 		 * would be meaningless. It is not serious though.
 		 */
-		if (task->flags & PF_KTHREAD) {
+		if (task->flags & (PF_KTHREAD | PF_USER_WORKER)) {
 			/*
 			 * Wake up a kthread which sleeps interruptedly and
 			 * still has not been migrated.
 			 */
-			wake_up_state(task, TASK_INTERRUPTIBLE);
+			if (wake_up_state(task, TASK_INTERRUPTIBLE))
+				continue;
+
+			/*
+			 * If it's running, force it through __schedule() so
+			 * it can switch itself in klp_sched_try_switch().
+			 */
+			if (task_curr(task)) {
+				set_tsk_need_resched(task);
+				kick_process(task);
+			}
 		} else {
 			/*
 			 * Send fake signal to all non-kthread tasks which are

  reply	other threads:[~2026-11-21 21:55 UTC|newest]

Thread overview: 4+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-17  4:52 [PATCH 0/2] " Dylan Hatch
2026-11-17  4:52 ` [PATCH 1/2] " Dylan Hatch
2026-11-21 21:55   ` Josh Poimboeuf [this message]
2026-11-17  4:52 ` [PATCH 2/2] selftests/livepatch: Add cond_resched() kthread transition test Dylan Hatch

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=awIMltMpXzhXiDpU@jpoimboe \
    --to=jpoimboe@kernel.org \
    --cc=bigeasy@linutronix.de \
    --cc=bsegall@google.com \
    --cc=dietmar.eggemann@arm.com \
    --cc=dylanbhatch@google.com \
    --cc=joe.lawrence@redhat.com \
    --cc=juri.lelli@redhat.com \
    --cc=kprateek.nayak@amd.com \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-kselftest@vger.kernel.org \
    --cc=live-patching@vger.kernel.org \
    --cc=mbenes@suse.cz \
    --cc=mgorman@suse.de \
    --cc=mingo@redhat.com \
    --cc=peterz@infradead.org \
    --cc=pmladek@suse.com \
    --cc=rostedt@goodmis.org \
    --cc=shuah@kernel.org \
    --cc=song@kernel.org \
    --cc=tglx@kernel.org \
    --cc=vincent.guittot@linaro.org \
    --cc=vschneid@redhat.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®