[PATCH v10 30/40] sched/deadline: Start a period for a task requeued onto an rt_mutex
From: Mathieu Desnoyers
Date: Fri Nov 20 2026 - 15:44:39 EST
The waiter node of an rt_mutex holds the deadline of its task, as a sort
key. task_blocks_on_rt_mutex() copies it when the task blocks. A task
that blocks by itself is running, so its deadline is a current one.
FUTEX_CMP_REQUEUE_PI is different. It makes a task that sleeps in
FUTEX_WAIT_REQUEUE_PI wait on the rt_mutex of a PI futex, with
rt_mutex_start_proxy_lock(). That task is not running. Its deadline can
be one that it would never run with:
- 0, if sched_setattr() made it SCHED_DEADLINE while it slept.
switched_to_dl() leaves its deadline to its next wakeup.
- one that has passed, if it slept past it.
The waiter then sorts before the waiters with a real deadline. At the
unlock, it gets the lock before waiters with earlier deadlines. Its
deadline also decides the boost of the owner.
Fix this in task_blocks_on_rt_mutex(): dl_proxy_block() starts a new
period for such a task, as its wakeup would. A task past its
deadline and before its next period keeps its deadline: its wakeup
throttles it until that period.
The Sashiko AI review of this series found this. The case
requeue_pi_new_period of deadline_bw_test, added later in this series,
tests the deadline of 0. It fails without this patch.
Fixes: 2d3d891d3344 ("sched/deadline: Add SCHED_DEADLINE inheritance logic")
Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@xxxxxxxxxxxx>
Cc: stable@xxxxxxxxxxxxxxx
---
include/linux/sched/deadline.h | 1 +
kernel/locking/rtmutex.c | 3 +++
kernel/sched/deadline.c | 30 ++++++++++++++++++++++++++++++
3 files changed, 34 insertions(+)
diff --git a/include/linux/sched/deadline.h b/include/linux/sched/deadline.h
index a2479c6ddbf0..377f00aec6d9 100644
--- a/include/linux/sched/deadline.h
+++ b/include/linux/sched/deadline.h
@@ -62,6 +62,7 @@ extern int dl_task_bw_reserve_cpu(struct task_struct *p,
const struct cpumask *new_mask);
extern int dl_task_bw_reserved_cpu(struct task_struct *p);
extern void dl_task_bw_unreserve(struct task_struct *p);
+extern void dl_proxy_block(struct task_struct *p);
extern bool dl_task_keeps_root_domain(struct task_struct *p,
const struct cpumask *new_mask,
const struct cpumask *pending);
diff --git a/kernel/locking/rtmutex.c b/kernel/locking/rtmutex.c
index b09816977d4e..5ff123d24b2a 100644
--- a/kernel/locking/rtmutex.c
+++ b/kernel/locking/rtmutex.c
@@ -1245,6 +1245,9 @@ static int __sched task_blocks_on_rt_mutex(struct rt_mutex_base *lock,
return -EDEADLK;
raw_spin_lock(&task->pi_lock);
+ /* A proxy lock: @task sleeps, and its deadline can be stale. */
+ if (task != current)
+ dl_proxy_block(task);
waiter->task = task;
waiter->lock = lock;
waiter_update_prio(waiter, task);
diff --git a/kernel/sched/deadline.c b/kernel/sched/deadline.c
index b1346be9e81d..1c5888b1717d 100644
--- a/kernel/sched/deadline.c
+++ b/kernel/sched/deadline.c
@@ -1573,6 +1573,36 @@ static inline u64 dl_next_period(struct sched_dl_entity *dl_se)
return dl_se->deadline - dl_se->dl_deadline + dl_se->dl_period;
}
+#ifdef CONFIG_RT_MUTEXES
+/*
+ * FUTEX_CMP_REQUEUE_PI makes @p wait on an rt_mutex while @p sleeps.
+ * The waiter node of @p takes its deadline, before any wakeup. @p would
+ * not run with a deadline of 0, which it has if it entered the class
+ * asleep. Nor would it run with a deadline that has passed. Start a new
+ * period then, as its wakeup would. Leave a task past its deadline and
+ * before its next period: its wakeup throttles it until that period.
+ *
+ * The caller holds the pi_lock of @p.
+ */
+void dl_proxy_block(struct task_struct *p)
+{
+ struct sched_dl_entity *dl_se = &p->dl;
+ struct rq_flags rf;
+ struct rq *rq;
+
+ if (!dl_task(p) || is_dl_boosted(dl_se) || !dl_se->dl_runtime)
+ return;
+ rq = __task_rq_lock(p, &rf);
+ update_rq_clock(rq);
+ if (!task_on_rq_queued(p) && !dl_se->dl_throttled &&
+ dl_time_before(dl_se->deadline, rq_clock(rq)) &&
+ (dl_is_implicit(dl_se) ||
+ !dl_time_before(rq_clock(rq), dl_next_period(dl_se))))
+ replenish_dl_new_period(dl_se, rq);
+ __task_rq_unlock(rq, p, &rf);
+}
+#endif
+
/*
* If the entity depleted all its runtime, and if we want it to sleep
* while waiting for some new execution time to become available, we
--
2.47.3