[RFC PATCH v1 2/8] sched/proxy: Wake blocked RT and deadline tasks through the full path
From: Mathieu Desnoyers
Date: Mon Nov 16 2026 - 14:26:53 EST
With proxy execution, a task blocked on a mutex stays on its runqueue.
The RT and deadline classes do not put such a task on their pushable
lists. enqueue_task_rt() and put_prev_task_rt() skip a blocked task.
enqueue_task_dl() and put_prev_task_dl() do the same. find_proxy_task()
migrates it instead.
Commit 7918cf369361 ("sched/proxy: Only return migrate when needed")
wakes a blocked task in place when it is still on its original CPU.
That wake-up does no enqueue. It also skips select_task_rq() and the
task_woken() method of the class. So the woken task is runnable, but it
is not pushable, and no other CPU can pull it.
A SCHED_FIFO task woken this way waits behind a higher priority task
while another CPU is idle. In a test on two CPUs, it ran 500ms after
the mutex was released, when the higher priority task stopped. Without
proxy execution it ran at once on the idle CPU. The test uses
SCHED_FIFO. The deadline class has the same code path.
Fix this in proxy_needs_return(). An RT or deadline task takes the full
wake-up path, as a task that was proxy-migrated does. The other classes
keep the in-place wake-up.
Fixes: 7918cf369361 ("sched/proxy: Only return migrate when needed")
Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@xxxxxxxxxxxx>
---
kernel/sched/core.c | 11 +++++++++--
1 file changed, 9 insertions(+), 2 deletions(-)
diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index 326026ba0b2b..cededdcfd5a3 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -3953,8 +3953,15 @@ static inline bool proxy_needs_return(struct rq *rq, struct task_struct *p)
* only set p->wake_cpu when !p->on_rq, and since here p->on_rq, this
* will not apply. But if it did, this check is the safe way around
* and would migrate.
- */
- if (task_cpu(p) == p->wake_cpu)
+ *
+ * The RT and deadline classes place a task at wake-up:
+ * select_task_rq(), the pushable list, a push to another CPU. An
+ * in-place wake-up skips all of that. So their tasks take the full
+ * wake-up path too.
+ */
+ if (task_cpu(p) == p->wake_cpu &&
+ p->sched_class != &rt_sched_class &&
+ p->sched_class != &dl_sched_class)
return false;
scoped_guard(raw_spinlock, &p->blocked_lock) {
--
2.47.3