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

From: Mathieu Desnoyers

Date: Mon Nov 16 2026 - 14:26:58 EST


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;
}
if (!task_on_cpu(rq, p)) {
--
2.47.3