Re: [PATCH 6/9] sched_ext: Delegate proxy donor admission to BPF schedulers

[K Prateek Nayak]

Hello Andrea,

On 7/6/2026 12:21 PM, Andrea Righi wrote:
> diff --git a/kernel/sched/core.c b/kernel/sched/core.c
> index 0139cd4a8be7e..f3b6c3c952e69 100644
> --- a/kernel/sched/core.c
> +++ b/kernel/sched/core.c
> @@ -6764,6 +6764,28 @@ static void proxy_deactivate(struct rq *rq, struct task_struct *donor)
>  	block_task(rq, donor, state);
>  }
>  
> +/*
> + * Remove a retained proxy donor before changing its scheduler ownership.
> + * The caller holds p->pi_lock, so p cannot wake and migrate after block_task()
> + * drops it from the runqueue.
> + */
> +void sched_proxy_block_task(struct rq *rq, struct task_struct *p)
> +{
> +	unsigned long state = READ_ONCE(p->__state);
> +
> +	lockdep_assert_held(&p->pi_lock);
> +	lockdep_assert_rq_held(rq);
> +
> +	if (!task_is_blocked(p) || !task_on_rq_queued(p))

nit.

You may want to use p->is_blocked indicator for this which marks if the
task has gone beyond the blocking point in __schedule(). I'll ensure
we doesn't prematurely block task before here before it hits the
correct blocking point in __schedule().

> +		return;
> +	if (WARN_ON_ONCE(state == TASK_RUNNING))
> +		return;
> +
> +	if (task_current_donor(rq, p))
> +		proxy_resched_idle(rq);
> +	block_task(rq, p, state);
> +}
> +
>  static inline void proxy_release_rq_lock(struct rq *rq, struct rq_flags *rf)
>  	__releases(__rq_lockp(rq))
>  {
> @@ -7006,6 +7028,39 @@ find_proxy_task(struct rq *rq, struct task_struct *donor, struct rq_flags *rf)
>  	proxy_migrate_task(rq, rf, p, owner_cpu);
>  	return NULL;
>  }
> +
> +int task_proxy_cpu(struct task_struct *p)
> +{
> +	struct task_struct *owner;
> +	struct mutex *mutex;
> +	int owner_cpu;
> +
> +	if (!task_is_blocked(p))
> +		return -ENOENT;
> +

This entry check should also use p->is_blocked now. Before that, proxy
doesn't start for core.

> +	mutex = READ_ONCE(p->blocked_on);
> +	if (!mutex)
> +		return -ENOENT;
> +
> +	guard(raw_spinlock)(&mutex->wait_lock);
> +	guard(raw_spinlock)(&p->blocked_lock);
> +
> +	if (mutex != __get_task_blocked_on(p))
> +		return -EAGAIN;
> +
> +	owner = __mutex_owner(mutex);
> +	if (!owner)
> +		return -ENOENT;
> +	if (!READ_ONCE(owner->on_rq) || owner->se.sched_delayed)
> +		return -EAGAIN;

This probabaly warrants a different return code since you don't want to
keep retrying until the owner wakes up.

> +
> +	owner_cpu = task_cpu(owner);
> +	if (owner_cpu != task_cpu(p) &&
> +	    (p->nr_cpus_allowed == 1 || is_migration_disabled(p)))
> +		return -EOPNOTSUPP;

Do we need this? Proxy can work even if the owner is on a CPU where
the donor cannot run.

> +
> +	return owner_cpu;
> +}
>  #else /* SCHED_PROXY_EXEC */
>  static struct task_struct *
>  find_proxy_task(struct rq *rq, struct task_struct *donor, struct rq_flags *rf)

-- 
Thanks and Regards,
Prateek