Re: [RFC PATCH v1 1/8] sched/proxy: Reschedule when a blocked task is woken under a proxy

From: John Stultz

Date: Mon Nov 16 2026 - 16:13:02 EST


On Mon, Nov 16, 2026 at 11:26 AM Mathieu Desnoyers
<mathieu.desnoyers@xxxxxxxxxxxx> wrote:
>
> With proxy execution, a task blocked on a mutex stays on its runqueue.
> The scheduler can pick it as the donor and run the mutex owner in its
> place. When the donor is woken, the CPU must stop running the owner on
> the donor's context.
>
> Commit 7918cf369361 ("sched/proxy: Only return migrate when needed")
> wakes a blocked task in place when it is still on its original CPU.
> ttwu_runnable() then relies on wakeup_preempt() to preempt the running
> task. But every class compares the woken task with rq->donor. When the
> woken task is the donor, it compares the task with itself, and no
> reschedule is requested. Only sched_ext handles this, with WF_TTWU_RQ.
>
> So the old owner keeps the donor's context after the mutex hand-off or
> after a signal. With a SCHED_FIFO donor nothing bounds this: the owner
> runs at the donor's priority until it blocks. With a SCHED_DEADLINE
> donor the owner consumes the donor's runtime.
>
> In a test on one CPU, a SCHED_OTHER owner kept spinning in user space
> after it released the mutex. A SCHED_FIFO waiter then ran 800ms late. A
> SCHED_DEADLINE waiter ran one period late.
>
> The same would happen when a task in the middle of a chain is woken.
> proxy_needs_return() resets the donor only when the woken task is the
> donor.
>
> Fix this in ttwu_runnable(). When a blocked task is woken on a runqueue
> that runs a proxy, reschedule. The next pick walks the chain again. A
> blocked task outside the donor's chain causes a harmless reschedule
> too.
>
> Fixes: 7918cf369361 ("sched/proxy: Only return migrate when needed")
> Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@xxxxxxxxxxxx>
> ---
> kernel/sched/core.c | 13 ++++++++++++-
> 1 file changed, 12 insertions(+), 1 deletion(-)
>
> diff --git a/kernel/sched/core.c b/kernel/sched/core.c
> index dc270a23179d..326026ba0b2b 100644
> --- a/kernel/sched/core.c
> +++ b/kernel/sched/core.c
> @@ -4057,9 +4057,20 @@ static int ttwu_runnable(struct task_struct *p, int wake_flags)
>
> update_rq_clock(rq);
> if (p->is_blocked) {
> + bool returned;
> +
> if (p->se.sched_delayed)
> enqueue_task(rq, p, ENQUEUE_NOCLOCK | ENQUEUE_DELAYED);
> - if (proxy_needs_return(rq, p))
> + returned = proxy_needs_return(rq, p);
> + /*
> + * @p was blocked and this CPU runs a proxy. If @p is the donor
> + * or a task of its chain, the donor no longer waits for the
> + * task that runs. wakeup_preempt() compares @p with the donor,
> + * so it does not see this. Pick again.
> + */
> + if (rq->donor != rq->curr)
> + resched_curr(rq);
> + if (returned)
> return 0;

I need to think on this some more, but my gut reaction is this feels a
bit too subtle or possibly too broad. Particularly the check being
done after proxy_needs_return, but before the exit, it feels like it's
leaning too much on a non-obvious side-effect of proxy_needs_return().

Both the comment and the commit message are also confusing, as if at
the start of ttwu_runnable() if p is the donor, proxy_needs_return()
will have called proxy_reset_donor(), setting rq->donor = rq->curr
(and already calling resched_curr()).

So it seems this patch is mainly trying to handle the case of a
mid-chain wakeup, where p isn't the current donor, but is in the
current chain? I agree that looks to be a problem, but the donor !=
curr check just is testing that we are proxying, not that p is in the
active chain. It could be previously blocked on a different unselected
chain. That said, this may be a good enough approximation (especially
as doing the donor->curr chain walk feels expensive).

Though it feels like maybe the check should be pushed into
proxy_needs_return() instead so it can be more clearly aligned with
the similar proxy_reset_donor() call?

Or am I missing something more?

thanks
-john