Re: [PATCH v7 29/40] sched/deadline: Keep the last CPU a task has in its root domain

From: sashiko-bot

Date: Tue Nov 17 2026 - 10:41:05 EST


Thank you for your contribution! Sashiko AI review found 2 potential
issues to consider:
- [Medium] cgroup/cpuset: missing descendant cpus_allowed filter in
cpuset_cpus_allowed_without()
- [Medium] cgroup/cpuset: filter by task_cpu_possible_mask() in
cpuset_cpus_allowed_without()
--

commit 119af82ab355761f9fade868df0ef32c60b9344b
Author: Mathieu Desnoyers <mathieu.desnoyers@xxxxxxxxxxxx>

sched/deadline: Keep the last CPU a task has in its root domain

This commit refuses to take a CPU offline with -EBUSY when doing so would
leave a SCHED_DEADLINE task with runnable CPUs only outside the root
domain that accounts for its bandwidth.

> diff --git a/kernel/cgroup/cpuset.c b/kernel/cgroup/cpuset.c
> index 7bdb9e21a7edb..3ccd61a37d302 100644
> --- a/kernel/cgroup/cpuset.c
> +++ b/kernel/cgroup/cpuset.c
> @@ -4312,6 +4312,32 @@ void cpuset_cpus_allowed(struct task_struct *tsk, struct cpumask *pmask)
> spin_unlock_irqrestore(&callback_lock, flags);
> }
>
> +/*
> + * Set @pmask to the active CPUs that the cpuset of @tsk gives it once @cpu
> + * is offline: those of the nearest ancestor that keeps one. Leave it empty
> + * if there is none. As cpuset_update_tasks_cpumask() does, keep the CPUs
> + * possible for @tsk. As __set_cpus_allowed_ptr() does, keep those of the
> + * affinity the user set, if one is left. The caller holds the CPU hotplug
> + * lock for writing, which keeps the cpusets and their tasks as they are.
> + * It holds the pi_lock of @tsk, which keeps its user affinity.
> + */
> +void cpuset_cpus_allowed_without(struct task_struct *tsk, int cpu,
> + struct cpumask *pmask)
> +{
> + struct cpuset *cs;
> +
> + guard(rcu)();
> + for (cs = task_cs(tsk); cs; cs = parent_cs(cs)) {
> + cpumask_and(pmask, cs->effective_cpus, cpu_active_mask);
> + cpumask_clear_cpu(cpu, pmask);
> + if (!cpumask_empty(pmask))
> + break;
> + }

[Severity: Medium]
Does cpuset_cpus_allowed_without() return an overly wide mask when it
walks past an intermediate ancestor to find remaining active CPUs?

During cgroup v2 hotplug, compute_effective_cpumask() propagates
effective_cpus top-down, intersecting each descendant's configured
cpus_allowed with its parent's new effective_cpus and only inheriting the
parent's mask when that intersection is empty:

kernel/cgroup/cpuset.c:compute_effective_cpumask() {
has_cpus = cpumask_and(new_cpus, cs->cpus_allowed, parent->effective_cpus);
if (!has_cpus && is_in_v2_mode())
cpumask_copy(new_cpus, parent->effective_cpus);
}

Consider a system with isolcpus=domain,0 and housekeeping CPUs 1-2, where
parent P has cpus_allowed = {1} and child C has cpus_allowed = {0, 1}
(giving C effective_cpus = {1}). When CPU 1 is taken offline, walking up
from C skips P (which becomes empty) and returns top_cpuset's remaining
active CPUs {0, 2}. dl_task_leaves_span() sees CPU 2 in the housekeeping
root domain span {1, 2} and allows the offline. However, once P inherits
{0, 2} from top_cpuset, C computes cpus_allowed & P->effective_cpus =
{0, 1} & {0, 2} = {0}, moving the deadline task and its bandwidth onto
isolated CPU 0 in def_root_domain without admission control.

> + cpumask_and(pmask, pmask, task_cpu_possible_mask(tsk));

[Severity: Medium]
Can intersecting pmask with task_cpu_possible_mask(tsk) after the
ancestor loop leave pmask empty when an ancestor has possible CPUs for
tsk?

On asymmetric arm64 systems where a 32-bit deadline task can only run on
a subset of CPUs, task_cs(tsk)->effective_cpus may retain active
64-bit-only CPUs after the outgoing 32-bit CPU is cleared. The loop then
stops at task_cs(tsk), and intersecting with task_cpu_possible_mask(tsk)
afterward produces an empty pmask. dl_task_leaves_span() treats an empty
msk as false and allows the last 32-bit CPU in the task's root domain to
go offline, after which guarantee_active_cpus() (which filters by
task_cpu_possible_mask(tsk) before testing each ancestor) walks up to an
ancestor with a 32-bit CPU in another root domain and moves the task's
bandwidth there without admission control.

--
Sashiko AI review · https://sashiko.dev/#/patchset/cover.1794922146.git.mathieu.desnoyers@xxxxxxxxxxxx?part=29