Hi Michal,
On Mon, Oct 19, 2026 at 12:41:45PM +0000, Michal Blaszczyk wrote:
> The watchdog measures how long a task has been waiting from
> p->scx.runnable_at, which set_task_runnable() resets when the task becomes
> runnable after it last ran. ops_dequeue() never asks for a reset, as the
> dequeue of a waiting task is temporary, e.g. for a migration or an
> attribute change.
>
> Leaving the scheduler isn't temporary. A task which is switched out of
> SCHED_EXT while it's waiting keeps its runnable_at. When it's switched back
> and becomes runnable, its wait appears to have started before it left, and
> the time it spent in another class counts towards the timeout. If the
> watchdog checks before the task runs, it aborts the scheduler:
>
> sched_ext: class_switch_stall: runner[418] failed to run for 3.010s
>
> Here, the task waited for a few milliseconds before it was switched to
> SCHED_OTHER, slept outside of SCHED_EXT for three seconds, and was charged
> for all of it as soon as it woke up on SCHED_EXT again.
>
> The same happens when scx_sub_enable_workfn() hands a waiting task over to
> a new sub-scheduler, which can then be blamed for time the task waited
> under the parent. scx_rehome_task() isn't affected, as it moves the task
> through SCX_TASK_INIT, which resets runnable_at. The stale runnable_at also
> skews the default core-sched ordering in scx_prio_less().
>
> Reset runnable_at in scx_disable_task(), when the task leaves the control
> of its scheduler.
>
> Fixes: 8a010b81b3a5 ("sched_ext: Implement runnable task stall watchdog")
> Assisted-by: LLM
> Signed-off-by: Michal Blaszczyk <[email protected]>
This makes sense to me and I reproduced the issue (thanks for providing
a selftest).
Reviewed-by: Andrea Righi <[email protected]>
-Andrea
> ---
> kernel/sched/ext/ext.c | 14 +++++++++++++-
> 1 file changed, 13 insertions(+), 1 deletion(-)
>
> diff --git a/kernel/sched/ext/ext.c b/kernel/sched/ext/ext.c
> index 07857039aee69..120df09b9e0af 100644
> --- a/kernel/sched/ext/ext.c
> +++ b/kernel/sched/ext/ext.c
> @@ -2424,7 +2424,11 @@ static void ops_dequeue(struct rq *rq, struct
> task_struct *p, u64 deq_flags)
> struct scx_sched *sch = scx_task_sched(p);
> unsigned long opss;
>
> - /* dequeue is always temporary, don't reset runnable_at */
> + /*
> + * Don't reset runnable_at. If @p is waiting, the wait continues across
> + * temporary dequeues, e.g. for a migration or an attribute change.
> + * scx_disable_task() ends it if @p leaves its scheduler.
> + */
> clr_task_runnable(p, false);
>
> retry:
> @@ -4517,6 +4521,14 @@ static void scx_disable_task(struct scx_sched *sch,
> struct task_struct *p)
> scx_set_task_slice(p, 0);
> p->scx.reenq_cnt = 0;
>
> + /*
> + * If @p is runnable but not running, its wait started at runnable_at,
> + * which ops_dequeue() didn't reset. Leaving @sch ends the wait. Reset
> + * runnable_at the next time @p is enqueued on SCX, so that the watchdog
> + * doesn't count the time @p spends elsewhere.
> + */
> + p->scx.flags |= SCX_TASK_RESET_RUNNABLE_AT;
> +
> /*
> * Verify the task is not in BPF scheduler's custody. If flag
> * transitions are consistent, the flag should always be clear
> --
> 2.56.0.176.g3575e65682-goog
>
