[PATCHSET sched_ext/for-6.19-fixes] sched_ext: Fix missing post-enqueue handling in move_local_task_to_local_dsq()

[PATCHSET sched_ext/for-6.19-fixes] sched_ext: Fix missing post-enqueue handling in move_local_task_to_local_dsq()

[Tejun Heo]

Hello,

move_local_task_to_local_dsq() was missing post-enqueue handling which
matters now that scx_bpf_dsq_move() can be called while the CPU is busy.

 0001-sched_ext-Factor-out-local_dsq_post_enq-from-dispatc.patch
 0002-sched_ext-Fix-missing-post-enqueue-handling-in-move_.patch

diffstat:
 kernel/sched/ext.c | 44 +++++++++++++++++++++++++++++---------------
 1 file changed, 29 insertions(+), 15 deletions(-)

--
tejun

[PATCH 1/2] sched_ext: Factor out local_dsq_post_enq() from dispatch_enqueue()

[Tejun Heo]

Factor out local_dsq_post_enq() which performs post-enqueue handling for
local DSQs - triggering preemption or resched_curr() if the enqueued task
has higher priority than the currently running task. No functional change.

This will be used by the next patch to fix move_local_task_to_local_dsq().

Signed-off-by: Tejun Heo <tj@kernel.org>
---
 kernel/sched/ext.c |   34 +++++++++++++++++++---------------
 1 file changed, 19 insertions(+), 15 deletions(-)

--- a/kernel/sched/ext.c
+++ b/kernel/sched/ext.c
@@ -975,6 +975,22 @@ static void refill_task_slice_dfl(struct
 	__scx_add_event(sch, SCX_EV_REFILL_SLICE_DFL, 1);
 }
 
+static void local_dsq_post_enq(struct scx_dispatch_q *dsq, struct task_struct *p,
+			       u64 enq_flags)
+{
+	struct rq *rq = container_of(dsq, struct rq, scx.local_dsq);
+	bool preempt = false;
+
+	if ((enq_flags & SCX_ENQ_PREEMPT) && p != rq->curr &&
+	    rq->curr->sched_class == &ext_sched_class) {
+		rq->curr->scx.slice = 0;
+		preempt = true;
+	}
+
+	if (preempt || sched_class_above(&ext_sched_class, rq->curr->sched_class))
+		resched_curr(rq);
+}
+
 static void dispatch_enqueue(struct scx_sched *sch, struct scx_dispatch_q *dsq,
 			     struct task_struct *p, u64 enq_flags)
 {
@@ -1086,22 +1102,10 @@ static void dispatch_enqueue(struct scx_
 	if (enq_flags & SCX_ENQ_CLEAR_OPSS)
 		atomic_long_set_release(&p->scx.ops_state, SCX_OPSS_NONE);
 
-	if (is_local) {
-		struct rq *rq = container_of(dsq, struct rq, scx.local_dsq);
-		bool preempt = false;
-
-		if ((enq_flags & SCX_ENQ_PREEMPT) && p != rq->curr &&
-		    rq->curr->sched_class == &ext_sched_class) {
-			rq->curr->scx.slice = 0;
-			preempt = true;
-		}
-
-		if (preempt || sched_class_above(&ext_sched_class,
-						 rq->curr->sched_class))
-			resched_curr(rq);
-	} else {
+	if (is_local)
+		local_dsq_post_enq(dsq, p, enq_flags);
+	else
 		raw_spin_unlock(&dsq->lock);
-	}
 }
 
 static void task_unlink_from_dsq(struct task_struct *p,

Re: [PATCH 1/2] sched_ext: Factor out local_dsq_post_enq() from dispatch_enqueue()

[Andrea Righi]

On Thu, Dec 11, 2025 at 12:48:08PM -1000, Tejun Heo wrote:
> Factor out local_dsq_post_enq() which performs post-enqueue handling for
> local DSQs - triggering preemption or resched_curr() if the enqueued task
> has higher priority than the currently running task. No functional change.

Maybe "higher priority" is a bit misleading, how about: "triggering
resched_curr() if SCX_ENQ_PREEMPT is specified or if the current CPU is
idle".

Thanks,
-Andrea

> 
> This will be used by the next patch to fix move_local_task_to_local_dsq().
> 
> Signed-off-by: Tejun Heo <tj@kernel.org>
> ---
>  kernel/sched/ext.c |   34 +++++++++++++++++++---------------
>  1 file changed, 19 insertions(+), 15 deletions(-)
> 
> --- a/kernel/sched/ext.c
> +++ b/kernel/sched/ext.c
> @@ -975,6 +975,22 @@ static void refill_task_slice_dfl(struct
>  	__scx_add_event(sch, SCX_EV_REFILL_SLICE_DFL, 1);
>  }
>  
> +static void local_dsq_post_enq(struct scx_dispatch_q *dsq, struct task_struct *p,
> +			       u64 enq_flags)
> +{
> +	struct rq *rq = container_of(dsq, struct rq, scx.local_dsq);
> +	bool preempt = false;
> +
> +	if ((enq_flags & SCX_ENQ_PREEMPT) && p != rq->curr &&
> +	    rq->curr->sched_class == &ext_sched_class) {
> +		rq->curr->scx.slice = 0;
> +		preempt = true;
> +	}
> +
> +	if (preempt || sched_class_above(&ext_sched_class, rq->curr->sched_class))
> +		resched_curr(rq);
> +}
> +
>  static void dispatch_enqueue(struct scx_sched *sch, struct scx_dispatch_q *dsq,
>  			     struct task_struct *p, u64 enq_flags)
>  {
> @@ -1086,22 +1102,10 @@ static void dispatch_enqueue(struct scx_
>  	if (enq_flags & SCX_ENQ_CLEAR_OPSS)
>  		atomic_long_set_release(&p->scx.ops_state, SCX_OPSS_NONE);
>  
> -	if (is_local) {
> -		struct rq *rq = container_of(dsq, struct rq, scx.local_dsq);
> -		bool preempt = false;
> -
> -		if ((enq_flags & SCX_ENQ_PREEMPT) && p != rq->curr &&
> -		    rq->curr->sched_class == &ext_sched_class) {
> -			rq->curr->scx.slice = 0;
> -			preempt = true;
> -		}
> -
> -		if (preempt || sched_class_above(&ext_sched_class,
> -						 rq->curr->sched_class))
> -			resched_curr(rq);
> -	} else {
> +	if (is_local)
> +		local_dsq_post_enq(dsq, p, enq_flags);
> +	else
>  		raw_spin_unlock(&dsq->lock);
> -	}
>  }
>  
>  static void task_unlink_from_dsq(struct task_struct *p,

[PATCH 2/2] sched_ext: Fix missing post-enqueue handling in move_local_task_to_local_dsq()

[Tejun Heo]

move_local_task_to_local_dsq() is used when moving a task from a non-local
DSQ to a local DSQ on the same CPU. It directly manipulates the local DSQ
without going through dispatch_enqueue() and was missing the post-enqueue
handling that triggers preemption when SCX_ENQ_PREEMPT is set or the
enqueued task should preempt a lower priority task.

This was fine when the function was only used from consume_dispatch_q()
where the CPU is already vacant and looking for the next task. However, the
function is now also used by move_task_between_dsqs() which backs
scx_bpf_dsq_move() which may be called while the CPU is busy.

Add local_dsq_post_enq() call to move_local_task_to_local_dsq(). As the
dispatch path doesn't need post-enqueue handling, add SCX_RQ_IN_BALANCE
early exit to keep consume_dispatch_q() behavior unchanged and avoid
triggering unnecessary resched when scx_bpf_dsq_move() is used from the
dispatch path.

Signed-off-by: Tejun Heo <tj@kernel.org>
---
 kernel/sched/ext.c |   10 ++++++++++
 1 file changed, 10 insertions(+)

--- a/kernel/sched/ext.c
+++ b/kernel/sched/ext.c
@@ -981,6 +981,14 @@ static void local_dsq_post_enq(struct sc
 	struct rq *rq = container_of(dsq, struct rq, scx.local_dsq);
 	bool preempt = false;
 
+	/*
+	 * If @rq is in balance, the CPU is already vacant and looking for the
+	 * next task to run. No need to preempt or trigger resched after moving
+	 * @p into its local DSQ.
+	 */
+	if (rq->scx.flags & SCX_RQ_IN_BALANCE)
+		return;
+
 	if ((enq_flags & SCX_ENQ_PREEMPT) && p != rq->curr &&
 	    rq->curr->sched_class == &ext_sched_class) {
 		rq->curr->scx.slice = 0;
@@ -1629,6 +1637,8 @@ static void move_local_task_to_local_dsq
 
 	dsq_mod_nr(dst_dsq, 1);
 	p->scx.dsq = dst_dsq;
+
+	local_dsq_post_enq(dst_dsq, p, enq_flags);
 }
 
 /**

Re: [PATCH 2/2] sched_ext: Fix missing post-enqueue handling in move_local_task_to_local_dsq()

[Andrea Righi]

On Thu, Dec 11, 2025 at 12:48:09PM -1000, Tejun Heo wrote:
> move_local_task_to_local_dsq() is used when moving a task from a non-local
> DSQ to a local DSQ on the same CPU. It directly manipulates the local DSQ
> without going through dispatch_enqueue() and was missing the post-enqueue
> handling that triggers preemption when SCX_ENQ_PREEMPT is set or the
> enqueued task should preempt a lower priority task.

Ditto, lower sched class / idle task maybe?

Thanks,
-Andrea

> 
> This was fine when the function was only used from consume_dispatch_q()
> where the CPU is already vacant and looking for the next task. However, the
> function is now also used by move_task_between_dsqs() which backs
> scx_bpf_dsq_move() which may be called while the CPU is busy.
> 
> Add local_dsq_post_enq() call to move_local_task_to_local_dsq(). As the
> dispatch path doesn't need post-enqueue handling, add SCX_RQ_IN_BALANCE
> early exit to keep consume_dispatch_q() behavior unchanged and avoid
> triggering unnecessary resched when scx_bpf_dsq_move() is used from the
> dispatch path.
> 
> Signed-off-by: Tejun Heo <tj@kernel.org>
> ---
>  kernel/sched/ext.c |   10 ++++++++++
>  1 file changed, 10 insertions(+)
> 
> --- a/kernel/sched/ext.c
> +++ b/kernel/sched/ext.c
> @@ -981,6 +981,14 @@ static void local_dsq_post_enq(struct sc
>  	struct rq *rq = container_of(dsq, struct rq, scx.local_dsq);
>  	bool preempt = false;
>  
> +	/*
> +	 * If @rq is in balance, the CPU is already vacant and looking for the
> +	 * next task to run. No need to preempt or trigger resched after moving
> +	 * @p into its local DSQ.
> +	 */
> +	if (rq->scx.flags & SCX_RQ_IN_BALANCE)
> +		return;
> +
>  	if ((enq_flags & SCX_ENQ_PREEMPT) && p != rq->curr &&
>  	    rq->curr->sched_class == &ext_sched_class) {
>  		rq->curr->scx.slice = 0;
> @@ -1629,6 +1637,8 @@ static void move_local_task_to_local_dsq
>  
>  	dsq_mod_nr(dst_dsq, 1);
>  	p->scx.dsq = dst_dsq;
> +
> +	local_dsq_post_enq(dst_dsq, p, enq_flags);
>  }
>  
>  /**

Re: [PATCH 2/2] sched_ext: Fix missing post-enqueue handling in move_local_task_to_local_dsq()

[Christian Loehle]

On 12/11/25 22:48, Tejun Heo wrote:
> move_local_task_to_local_dsq() is used when moving a task from a non-local
> DSQ to a local DSQ on the same CPU. It directly manipulates the local DSQ
> without going through dispatch_enqueue() and was missing the post-enqueue
> handling that triggers preemption when SCX_ENQ_PREEMPT is set or the
> enqueued task should preempt a lower priority task.
> 
> This was fine when the function was only used from consume_dispatch_q()
> where the CPU is already vacant and looking for the next task. However, the
> function is now also used by move_task_between_dsqs() which backs
> scx_bpf_dsq_move() which may be called while the CPU is busy.

When was this changed? I couldn't find the commit when looking briefly :/

> 
> Add local_dsq_post_enq() call to move_local_task_to_local_dsq(). As the
> dispatch path doesn't need post-enqueue handling, add SCX_RQ_IN_BALANCE
> early exit to keep consume_dispatch_q() behavior unchanged and avoid
> triggering unnecessary resched when scx_bpf_dsq_move() is used from the
> dispatch path.
> 
> Signed-off-by: Tejun Heo <tj@kernel.org>
> ---
>  kernel/sched/ext.c |   10 ++++++++++
>  1 file changed, 10 insertions(+)
> 
> --- a/kernel/sched/ext.c
> +++ b/kernel/sched/ext.c
> @@ -981,6 +981,14 @@ static void local_dsq_post_enq(struct sc
>  	struct rq *rq = container_of(dsq, struct rq, scx.local_dsq);
>  	bool preempt = false;
>  
> +	/*
> +	 * If @rq is in balance, the CPU is already vacant and looking for the
> +	 * next task to run. No need to preempt or trigger resched after moving
> +	 * @p into its local DSQ.
> +	 */
> +	if (rq->scx.flags & SCX_RQ_IN_BALANCE)
> +		return;
> +
>  	if ((enq_flags & SCX_ENQ_PREEMPT) && p != rq->curr &&
>  	    rq->curr->sched_class == &ext_sched_class) {
>  		rq->curr->scx.slice = 0;
> @@ -1629,6 +1637,8 @@ static void move_local_task_to_local_dsq
>  
>  	dsq_mod_nr(dst_dsq, 1);
>  	p->scx.dsq = dst_dsq;
> +
> +	local_dsq_post_enq(dst_dsq, p, enq_flags);
>  }
>  
>  /**
> 

Re: [PATCH 2/2] sched_ext: Fix missing post-enqueue handling in move_local_task_to_local_dsq()

[Tejun Heo]

On Thu, Dec 11, 2025 at 11:35:17PM +0000, Christian Loehle wrote:
> On 12/11/25 22:48, Tejun Heo wrote:
> > move_local_task_to_local_dsq() is used when moving a task from a non-local
> > DSQ to a local DSQ on the same CPU. It directly manipulates the local DSQ
> > without going through dispatch_enqueue() and was missing the post-enqueue
> > handling that triggers preemption when SCX_ENQ_PREEMPT is set or the
> > enqueued task should preempt a lower priority task.
> > 
> > This was fine when the function was only used from consume_dispatch_q()
> > where the CPU is already vacant and looking for the next task. However, the
> > function is now also used by move_task_between_dsqs() which backs
> > scx_bpf_dsq_move() which may be called while the CPU is busy.
> 
> When was this changed? I couldn't find the commit when looking briefly :/

4c30f5ce4f7a ("sched_ext: Implement scx_bpf_dispatch[_vtime]_from_dsq()")
which was v6.12, so upstream history-wise, the above paragraph isn't
accurate. It was broken from get-go. Will update the commit message. I'm
split on whether I should tag stable for it given that the usage pattern
isn't very common and there's some risk in the behavior change. Hmm... might
as well.

Thanks.

-- 
tejun

Re: [PATCHSET sched_ext/for-6.19-fixes] sched_ext: Fix missing post-enqueue handling in move_local_task_to_local_dsq()

[Andrea Righi]

Hi Tejun,

On Thu, Dec 11, 2025 at 12:48:07PM -1000, Tejun Heo wrote:
> Hello,
> 
> move_local_task_to_local_dsq() was missing post-enqueue handling which
> matters now that scx_bpf_dsq_move() can be called while the CPU is busy.
> 
>  0001-sched_ext-Factor-out-local_dsq_post_enq-from-dispatc.patch
>  0002-sched_ext-Fix-missing-post-enqueue-handling-in-move_.patch

A couple of comments about the commit description, but overall looks good
to me.

Reviewed-by: Andrea Righi <arighi@nvidia.com>

Thanks,
-Andrea

> 
> diffstat:
>  kernel/sched/ext.c | 44 +++++++++++++++++++++++++++++---------------
>  1 file changed, 29 insertions(+), 15 deletions(-)
> 
> --
> tejun

[PATCHSET v2 sched_ext/for-6.19-fixes] sched_ext: Fix missing post-enqueue handling in move_local_task_to_local_dsq()

[Tejun Heo]

Hello,

move_local_task_to_local_dsq() was missing post-enqueue handling which
matters now that scx_bpf_dsq_move() can be called while the CPU is busy.

v2: Updated commit messages and added Cc stable.

v1: http://lkml.kernel.org/r/20251211224809.3383633-1-tj@kernel.org

 0001-sched_ext-Factor-out-local_dsq_post_enq-from-dispatc.patch
 0002-sched_ext-Fix-missing-post-enqueue-handling-in-move_.patch

Based on sched_ext/for-6.19-fixes (9f769637a93f).

diffstat:
 kernel/sched/ext.c | 44 +++++++++++++++++++++++++++++---------------
 1 file changed, 29 insertions(+), 15 deletions(-)

--
tejun

[PATCH 1/2] sched_ext: Factor out local_dsq_post_enq() from dispatch_enqueue()

[Tejun Heo]

Factor out local_dsq_post_enq() which performs post-enqueue handling for
local DSQs - triggering resched_curr() if SCX_ENQ_PREEMPT is specified or if
the current CPU is idle. No functional change.

This will be used by the next patch to fix move_local_task_to_local_dsq().

Cc: stable@vger.kernel.org # v6.12+
Reviewed-by: Andrea Righi <arighi@nvidia.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
---
 kernel/sched/ext.c | 34 +++++++++++++++++++---------------
 1 file changed, 19 insertions(+), 15 deletions(-)

diff --git a/kernel/sched/ext.c b/kernel/sched/ext.c
index c4465ccefea4..c78efa99406f 100644
--- a/kernel/sched/ext.c
+++ b/kernel/sched/ext.c
@@ -982,6 +982,22 @@ static void refill_task_slice_dfl(struct scx_sched *sch, struct task_struct *p)
 	__scx_add_event(sch, SCX_EV_REFILL_SLICE_DFL, 1);
 }
 
+static void local_dsq_post_enq(struct scx_dispatch_q *dsq, struct task_struct *p,
+			       u64 enq_flags)
+{
+	struct rq *rq = container_of(dsq, struct rq, scx.local_dsq);
+	bool preempt = false;
+
+	if ((enq_flags & SCX_ENQ_PREEMPT) && p != rq->curr &&
+	    rq->curr->sched_class == &ext_sched_class) {
+		rq->curr->scx.slice = 0;
+		preempt = true;
+	}
+
+	if (preempt || sched_class_above(&ext_sched_class, rq->curr->sched_class))
+		resched_curr(rq);
+}
+
 static void dispatch_enqueue(struct scx_sched *sch, struct scx_dispatch_q *dsq,
 			     struct task_struct *p, u64 enq_flags)
 {
@@ -1093,22 +1109,10 @@ static void dispatch_enqueue(struct scx_sched *sch, struct scx_dispatch_q *dsq,
 	if (enq_flags & SCX_ENQ_CLEAR_OPSS)
 		atomic_long_set_release(&p->scx.ops_state, SCX_OPSS_NONE);
 
-	if (is_local) {
-		struct rq *rq = container_of(dsq, struct rq, scx.local_dsq);
-		bool preempt = false;
-
-		if ((enq_flags & SCX_ENQ_PREEMPT) && p != rq->curr &&
-		    rq->curr->sched_class == &ext_sched_class) {
-			rq->curr->scx.slice = 0;
-			preempt = true;
-		}
-
-		if (preempt || sched_class_above(&ext_sched_class,
-						 rq->curr->sched_class))
-			resched_curr(rq);
-	} else {
+	if (is_local)
+		local_dsq_post_enq(dsq, p, enq_flags);
+	else
 		raw_spin_unlock(&dsq->lock);
-	}
 }
 
 static void task_unlink_from_dsq(struct task_struct *p,
-- 
2.52.0

Re: [PATCH 1/2] sched_ext: Factor out local_dsq_post_enq() from dispatch_enqueue()

[Emil Tsalapatis]

On Thu Dec 11, 2025 at 8:45 PM EST, Tejun Heo wrote:
> Factor out local_dsq_post_enq() which performs post-enqueue handling for
> local DSQs - triggering resched_curr() if SCX_ENQ_PREEMPT is specified or if
> the current CPU is idle. No functional change.
>
> This will be used by the next patch to fix move_local_task_to_local_dsq().
>
> Cc: stable@vger.kernel.org # v6.12+
> Reviewed-by: Andrea Righi <arighi@nvidia.com>
> Signed-off-by: Tejun Heo <tj@kernel.org>
> ---

Reviewed-by: Emil Tsalapatis <emil@etsalapatis.com>

>  kernel/sched/ext.c | 34 +++++++++++++++++++---------------
>  1 file changed, 19 insertions(+), 15 deletions(-)
>
> diff --git a/kernel/sched/ext.c b/kernel/sched/ext.c
> index c4465ccefea4..c78efa99406f 100644
> --- a/kernel/sched/ext.c
> +++ b/kernel/sched/ext.c
> @@ -982,6 +982,22 @@ static void refill_task_slice_dfl(struct scx_sched *sch, struct task_struct *p)
>  	__scx_add_event(sch, SCX_EV_REFILL_SLICE_DFL, 1);
>  }
>  
> +static void local_dsq_post_enq(struct scx_dispatch_q *dsq, struct task_struct *p,
> +			       u64 enq_flags)
> +{
> +	struct rq *rq = container_of(dsq, struct rq, scx.local_dsq);
> +	bool preempt = false;
> +
> +	if ((enq_flags & SCX_ENQ_PREEMPT) && p != rq->curr &&
> +	    rq->curr->sched_class == &ext_sched_class) {
> +		rq->curr->scx.slice = 0;
> +		preempt = true;
> +	}
> +
> +	if (preempt || sched_class_above(&ext_sched_class, rq->curr->sched_class))
> +		resched_curr(rq);
> +}
> +
>  static void dispatch_enqueue(struct scx_sched *sch, struct scx_dispatch_q *dsq,
>  			     struct task_struct *p, u64 enq_flags)
>  {
> @@ -1093,22 +1109,10 @@ static void dispatch_enqueue(struct scx_sched *sch, struct scx_dispatch_q *dsq,
>  	if (enq_flags & SCX_ENQ_CLEAR_OPSS)
>  		atomic_long_set_release(&p->scx.ops_state, SCX_OPSS_NONE);
>  
> -	if (is_local) {
> -		struct rq *rq = container_of(dsq, struct rq, scx.local_dsq);
> -		bool preempt = false;
> -
> -		if ((enq_flags & SCX_ENQ_PREEMPT) && p != rq->curr &&
> -		    rq->curr->sched_class == &ext_sched_class) {
> -			rq->curr->scx.slice = 0;
> -			preempt = true;
> -		}
> -
> -		if (preempt || sched_class_above(&ext_sched_class,
> -						 rq->curr->sched_class))
> -			resched_curr(rq);
> -	} else {
> +	if (is_local)
> +		local_dsq_post_enq(dsq, p, enq_flags);
> +	else
>  		raw_spin_unlock(&dsq->lock);
> -	}
>  }
>  
>  static void task_unlink_from_dsq(struct task_struct *p,

[PATCH 2/2] sched_ext: Fix missing post-enqueue handling in move_local_task_to_local_dsq()

[Tejun Heo]

move_local_task_to_local_dsq() is used when moving a task from a non-local
DSQ to a local DSQ on the same CPU. It directly manipulates the local DSQ
without going through dispatch_enqueue() and was missing the post-enqueue
handling that triggers preemption when SCX_ENQ_PREEMPT is set or the idle
task is running.

The function is used by move_task_between_dsqs() which backs
scx_bpf_dsq_move() and may be called while the CPU is busy.

Add local_dsq_post_enq() call to move_local_task_to_local_dsq(). As the
dispatch path doesn't need post-enqueue handling, add SCX_RQ_IN_BALANCE
early exit to keep consume_dispatch_q() behavior unchanged and avoid
triggering unnecessary resched when scx_bpf_dsq_move() is used from the
dispatch path.

Fixes: 4c30f5ce4f7a ("sched_ext: Implement scx_bpf_dispatch[_vtime]_from_dsq()")
Cc: stable@vger.kernel.org # v6.12+
Reviewed-by: Andrea Righi <arighi@nvidia.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
---
 kernel/sched/ext.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/kernel/sched/ext.c b/kernel/sched/ext.c
index c78efa99406f..695503a2f7d1 100644
--- a/kernel/sched/ext.c
+++ b/kernel/sched/ext.c
@@ -988,6 +988,14 @@ static void local_dsq_post_enq(struct scx_dispatch_q *dsq, struct task_struct *p
 	struct rq *rq = container_of(dsq, struct rq, scx.local_dsq);
 	bool preempt = false;
 
+	/*
+	 * If @rq is in balance, the CPU is already vacant and looking for the
+	 * next task to run. No need to preempt or trigger resched after moving
+	 * @p into its local DSQ.
+	 */
+	if (rq->scx.flags & SCX_RQ_IN_BALANCE)
+		return;
+
 	if ((enq_flags & SCX_ENQ_PREEMPT) && p != rq->curr &&
 	    rq->curr->sched_class == &ext_sched_class) {
 		rq->curr->scx.slice = 0;
@@ -1636,6 +1644,8 @@ static void move_local_task_to_local_dsq(struct task_struct *p, u64 enq_flags,
 
 	dsq_mod_nr(dst_dsq, 1);
 	p->scx.dsq = dst_dsq;
+
+	local_dsq_post_enq(dst_dsq, p, enq_flags);
 }
 
 /**
-- 
2.52.0

Re: [PATCH 2/2] sched_ext: Fix missing post-enqueue handling in move_local_task_to_local_dsq()

[Emil Tsalapatis]

On Thu Dec 11, 2025 at 8:45 PM EST, Tejun Heo wrote:
> move_local_task_to_local_dsq() is used when moving a task from a non-local
> DSQ to a local DSQ on the same CPU. It directly manipulates the local DSQ
> without going through dispatch_enqueue() and was missing the post-enqueue
> handling that triggers preemption when SCX_ENQ_PREEMPT is set or the idle
> task is running.
>
> The function is used by move_task_between_dsqs() which backs
> scx_bpf_dsq_move() and may be called while the CPU is busy.
>
> Add local_dsq_post_enq() call to move_local_task_to_local_dsq(). As the
> dispatch path doesn't need post-enqueue handling, add SCX_RQ_IN_BALANCE
> early exit to keep consume_dispatch_q() behavior unchanged and avoid
> triggering unnecessary resched when scx_bpf_dsq_move() is used from the
> dispatch path.
>
> Fixes: 4c30f5ce4f7a ("sched_ext: Implement scx_bpf_dispatch[_vtime]_from_dsq()")
> Cc: stable@vger.kernel.org # v6.12+
> Reviewed-by: Andrea Righi <arighi@nvidia.com>
> Signed-off-by: Tejun Heo <tj@kernel.org>

Reviewed-by: Emil Tsalapatis <emil@etsalapatis.com>

> ---
>  kernel/sched/ext.c | 10 ++++++++++
>  1 file changed, 10 insertions(+)
>
> diff --git a/kernel/sched/ext.c b/kernel/sched/ext.c
> index c78efa99406f..695503a2f7d1 100644
> --- a/kernel/sched/ext.c
> +++ b/kernel/sched/ext.c
> @@ -988,6 +988,14 @@ static void local_dsq_post_enq(struct scx_dispatch_q *dsq, struct task_struct *p
>  	struct rq *rq = container_of(dsq, struct rq, scx.local_dsq);
>  	bool preempt = false;
>  
> +	/*
> +	 * If @rq is in balance, the CPU is already vacant and looking for the
> +	 * next task to run. No need to preempt or trigger resched after moving
> +	 * @p into its local DSQ.
> +	 */
> +	if (rq->scx.flags & SCX_RQ_IN_BALANCE)
> +		return;
> +
>  	if ((enq_flags & SCX_ENQ_PREEMPT) && p != rq->curr &&
>  	    rq->curr->sched_class == &ext_sched_class) {
>  		rq->curr->scx.slice = 0;
> @@ -1636,6 +1644,8 @@ static void move_local_task_to_local_dsq(struct task_struct *p, u64 enq_flags,
>  
>  	dsq_mod_nr(dst_dsq, 1);
>  	p->scx.dsq = dst_dsq;
> +
> +	local_dsq_post_enq(dst_dsq, p, enq_flags);
>  }
>  
>  /**

Re: [PATCHSET v2 sched_ext/for-6.19-fixes] sched_ext: Fix missing post-enqueue handling in move_local_task_to_local_dsq()

[Tejun Heo]

> Tejun Heo (2):
>   sched_ext: Factor out local_dsq_post_enq() from dispatch_enqueue()
>   sched_ext: Fix missing post-enqueue handling in move_local_task_to_local_dsq()

Applied to sched_ext/for-6.19-fixes.

Thanks.
--
tejun