Re: [PATCH v2 12/12] sched: Remove sched_class::balance()

[Peter Zijlstra <peterz@infradead.org>]

On Wed, Nov 11, 2026 at 04:47:24PM +0100, Peter Zijlstra wrote:
> On Wed, Nov 11, 2026 at 05:57:01PM +0300, Kayra Cizmeci wrote:
> > Hi Peter!
> 
> > Let's say a fair task named TA is working in CPU1, a DL task named DA is
> > waking up. We enter the normal wakeup path, and call enqueue_task_dl()
> > and from there enqueue_dl_entity(). enqueue_dl_entity() sets next_class
> > to dl_sched_class. Later enqueue, when we call wakeup_preempt TA does
> > not gets preempted because:
> > 
> > void wakeup_preempt(struct rq *rq, struct task_struct *p, int flags)
> > {
> > 	struct task_struct *donor = rq->donor;
> > 
> > 	if (p->sched_class == rq->next_class) {
> > 		rq->next_class->wakeup_preempt(rq, p, flags);
> > 
> 
> Gah, you're right. This don't work right. Let me try again.

Here, something like so then?

---
Subject: sched/deadline: Fix wakeup_preempt() vs dl_server
From: Peter Zijlstra <peterz@infradead.org>
Date: Wed Nov 11 14:12:25 CET 2026

Tejun noted that dl_se enqueues from timers, esp. those for dl_server, do not
pass through wakeup_preempt() and will not cause rq->next_class to be bumped.
As such, when such an enqueue happend in the middle of schedule(), this might
cause a failure to restart the pick and run a lower class entity.

Fixes: 704069649b5b ("sched/core: Rework sched_class::wakeup_preempt() and rq_modified_*()")
Reported-by: Tejun Heo <tj@kernel.org>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
---
 kernel/sched/deadline.c |   40 +++++++++++++++++++++++++---------------
 1 file changed, 25 insertions(+), 15 deletions(-)

--- a/kernel/sched/deadline.c
+++ b/kernel/sched/deadline.c
@@ -715,8 +715,7 @@ static struct rq *dl_task_offline_migrat
 	return later_rq;
 }
 
-static void
-enqueue_dl_entity(struct sched_dl_entity *dl_se, int flags);
+static void enqueue_dl_entity(struct rq *rq, struct sched_dl_entity *dl_se, int flags);
 static void enqueue_task_dl(struct rq *rq, struct task_struct *p, int flags);
 static void dequeue_dl_entity(struct sched_dl_entity *dl_se, int flags);
 static void wakeup_preempt_dl(struct rq *rq, struct task_struct *p, int flags);
@@ -1184,10 +1183,7 @@ static enum hrtimer_restart dl_server_ti
 			dl_se->dl_defer_running = 1;
 		}
 
-		enqueue_dl_entity(dl_se, ENQUEUE_REPLENISH);
-
-		if (!dl_task(dl_se->rq->curr) || dl_entity_preempt(dl_se, &dl_se->rq->curr->dl))
-			resched_curr(rq);
+		enqueue_dl_entity(rq, dl_se, ENQUEUE_REPLENISH);
 
 		__push_dl_task(rq, rf);
 	}
@@ -1520,7 +1516,7 @@ static void update_curr_dl_se(struct rq
 					replenish_dl_new_period(dl_se, rq);
 					start_dl_timer(dl_se);
 				} else {
-					enqueue_dl_entity(dl_se, ENQUEUE_REPLENISH);
+					enqueue_dl_entity(rq, dl_se, ENQUEUE_REPLENISH);
 				}
 			} else {
 				enqueue_task_dl(rq, dl_task_of(dl_se), ENQUEUE_REPLENISH);
@@ -1812,9 +1808,7 @@ void dl_server_start(struct sched_dl_ent
 
 	trace_sched_dl_server_start_tp(dl_se, cpu_of(rq), dl_get_type(dl_se, rq));
 	dl_se->dl_server_active = 1;
-	enqueue_dl_entity(dl_se, ENQUEUE_WAKEUP);
-	if (!dl_task(dl_se->rq->curr) || dl_entity_preempt(dl_se, &rq->curr->dl))
-		resched_curr(dl_se->rq);
+	enqueue_dl_entity(rq, dl_se, ENQUEUE_WAKEUP);
 }
 
 void dl_server_stop(struct sched_dl_entity *dl_se)
@@ -2379,8 +2373,8 @@ static void __dequeue_dl_entity(struct s
 	dec_dl_tasks(dl_se, dl_rq);
 }
 
-static void
-enqueue_dl_entity(struct sched_dl_entity *dl_se, int flags)
+static bool
+_enqueue_dl_entity(struct sched_dl_entity *dl_se, int flags)
 {
 	WARN_ON_ONCE(on_dl_rq(dl_se));
 
@@ -2418,7 +2412,7 @@ enqueue_dl_entity(struct sched_dl_entity
 		if (flags & ENQUEUE_WAKEUP)
 			task_contending(dl_se, flags);
 
-		return;
+		return false;
 	}
 
 	/*
@@ -2442,7 +2436,7 @@ enqueue_dl_entity(struct sched_dl_entity
 	 * deferred task and still got to wait, don't enqueue.
 	 */
 	if (dl_se->dl_throttled && start_dl_timer(dl_se))
-		return;
+		return false;
 
 	/*
 	 * We're about to enqueue, make sure we're not ->dl_throttled!
@@ -2457,6 +2451,22 @@ enqueue_dl_entity(struct sched_dl_entity
 	}
 
 	__enqueue_dl_entity(dl_se);
+	return true;
+}
+
+static void enqueue_dl_entity(struct rq *rq, struct sched_dl_entity *dl_se, int flags)
+{
+	/*
+	 * Deadline can enqueue entities from various timers; and esp.
+	 * dl_server() entities will not pass through wakeup_preempt().
+	 */
+	if (!_enqueue_dl_entity(dl_se, flags))
+		return;
+
+	if (!dl_task(rq->curr) || dl_entity_preempt(dl_se, &rq->curr->dl))
+		resched_curr(dl_se->rq);
+
+	rq->next_class = &dl_sched_class;
 }
 
 static void dequeue_dl_entity(struct sched_dl_entity *dl_se, int flags)
@@ -2534,7 +2544,7 @@ static void enqueue_task_dl(struct rq *r
 	if (task_on_rq_migrating(p))
 		flags |= ENQUEUE_MIGRATING;
 
-	enqueue_dl_entity(dl_se, flags);
+	enqueue_dl_entity(rq, dl_se, flags);
 
 	if (dl_server(dl_se))
 		return;