From: sashiko-bot@kernel.org
To: "Mathieu Desnoyers" <mathieu.desnoyers@efficios.com>
Cc: linux-rt-devel@lists.linux.dev, tj@kernel.org,
hannes@cmpxchg.org, mkoutny@suse.com,
linux-kernel@vger.kernel.org
Subject: Re: [PATCH v8 15/33] sched/deadline: Keep a task in the root domain that counts its bandwidth
Date: Thu, 19 Nov 2026 20:55:10 +0000 [thread overview]
Message-ID: <sashiko-outbox-224072@kernel.org> (raw)
In-Reply-To: <35ed0190c119025d684ab89cd51e4805c7f7dbad.1795116791.git.mathieu.desnoyers@efficios.com>
Thank you for your contribution! Sashiko AI review found 6 potential
issues to consider:
- [Medium] sched/deadline: missing seqlock memory barriers in
dl_task_bw_span()
- [Medium] sched/deadline: race on rd->span returned by
dl_task_bw_span()
- [Medium] sched: select_fallback_rq() overwrites fallback mask when
state is fail
- [Medium] sched/deadline: dl_task_offline_migration() ignores span when
cpus_ptr inactive
- [Medium] sched/deadline: lost bandwidth in dl_task_offline_migration()
during rebuild
- [Medium] sched/deadline: dl_task_bw_span() returns NULL for
runtime-isolated CPUs
--
commit 13af0f791d03e3d95add27f78ad7796e24778c3d
Author: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
sched/deadline: Keep a task in the root domain that counts its bandwidth
This commit adds dl_task_bw_span() and updates CPU selection and offline
migration paths to keep SCHED_DEADLINE tasks in the root domain that
accounts for their bandwidth.
> diff --git a/kernel/sched/core.c b/kernel/sched/core.c
> index 7615ba02d52b3..fe2919be3775b 100644
> --- a/kernel/sched/core.c
> +++ b/kernel/sched/core.c
[ ... ]
> @@ -3686,6 +3721,26 @@ static int select_fallback_rq(int cpu, struct task_struct *p)
> }
>
> for (;;) {
> + /* The mask is wider now: look again in that root domain. */
> + if (span && state != cpuset) {
> + for_each_cpu_and(dest_cpu, span, p->cpus_ptr) {
> + if (is_cpu_allowed(p, dest_cpu))
> + goto out;
> + }
> + /*
> + * The wider mask has no active CPU in that root
> + * domain. Allow the CPUs of the root domain instead.
> + * At an offline, the cpuset update comes next and sets
> + * the real mask.
> + */
> + if (!span_forced && cpumask_intersects(span, cpu_active_mask) &&
> + cpumask_subset(span, task_cpu_possible_mask(p))) {
> + span_forced = true;
> + set_cpus_allowed_force(p, span);
> + continue;
> + }
> + }
> +
> /* Any allowed, online CPU? */
> for_each_cpu(dest_cpu, p->cpus_ptr) {
> if (!is_cpu_allowed(p, dest_cpu))
[Severity: Medium]
Can this overwrite task_cpu_fallback_mask(p) with span when state is
already fail, and hit BUG() without ever scanning the fallback mask?
When cpuset_cpus_allowed_fallback(p) returns false (such as under cgroup
v1 or CONFIG_CPUSETS=n), case cpuset falls through to case possible,
which installs task_cpu_fallback_mask(p) and sets state = fail. On the
next iteration, state != cpuset is true, so if span has no CPU in
task_cpu_fallback_mask(p) (for example, when span is def_root_domain.span
under isolcpus=domain), this block replaces p->cpus_mask with span and
continues with state == fail. If no CPU in span satisfies
is_cpu_allowed() on the following pass (for instance, an unbound deadline
kthread when the active CPU in span has cpu_dying() set), the loop
reaches case fail: BUG() without testing task_cpu_fallback_mask(p).
> diff --git a/kernel/sched/deadline.c b/kernel/sched/deadline.c
> index fb8f32a31cf91..c33e73e920ebb 100644
> --- a/kernel/sched/deadline.c
> +++ b/kernel/sched/deadline.c
[ ... ]
> @@ -927,18 +929,36 @@ static struct rq *find_lock_later_rq(struct task_struct *task, struct rq *rq);
>
> static struct rq *dl_task_offline_migration(struct rq *rq, struct task_struct *p)
> {
> + const struct cpumask *span;
> struct rq *later_rq = NULL;
> struct dl_bw *dl_b;
>
> later_rq = find_lock_later_rq(p, rq);
> + /*
> + * find_lock_later_rq() looks in the root domain of @rq. Once @rq is
> + * offline, a rebuild attaches it to def_root_domain. That root domain
> + * may not count @p. Do not take @p out of the root domain that counts
> + * it while @p has an active CPU there.
> + */
> + span = dl_task_bw_span(p);
> + if (later_rq && span && !cpumask_test_cpu(later_rq->cpu, span) &&
> + cpumask_first_and_and(cpu_active_mask, p->cpus_ptr, span) < nr_cpu_ids) {
> + double_unlock_balance(rq, later_rq);
> + later_rq = NULL;
> + }
> if (!later_rq) {
> int cpu;
>
> /*
> * If we cannot preempt any rq, fall back to pick any
> - * online CPU:
> + * online CPU. Try the root domain that counts @p first.
> */
> - cpu = cpumask_any_and(cpu_active_mask, p->cpus_ptr);
> + cpu = nr_cpu_ids;
> + if (span)
> + cpu = cpumask_first_and_and(cpu_active_mask,
> + p->cpus_ptr, span);
> + if (cpu >= nr_cpu_ids)
> + cpu = cpumask_any_and(cpu_active_mask, p->cpus_ptr);
> if (cpu >= nr_cpu_ids) {
> /*
> * Failed to find any suitable CPU.
[Severity: Medium]
What happens here when p->cpus_ptr has no active CPUs left, but span
still does?
In sched_cpu_deactivate(), set_cpu_active(cpu, false) and
sched_set_rq_offline() run before cpuset_cpu_inactive() widens the mask
of tasks in a cpuset whose last active CPU just went offline. If
dl_task_timer() fires for a throttled task in that window, p->cpus_ptr
contains no active CPUs, so both cpumask_first_and_and() and
cpumask_any_and() fail. Unlike select_fallback_rq(), this path does not
fall back to an active CPU in span; instead it triggers
WARN_ON_ONCE(dl_bandwidth_enabled()) and picks
cpumask_any(cpu_active_mask), which with isolcpus=domain,0,1 moves a
housekeeping task and its bandwidth to isolated CPU 0 in def_root_domain.
> @@ -981,8 +1001,15 @@ static struct rq *dl_task_offline_migration(struct rq *rq, struct task_struct *p
> * moved to another cpuset while it was not running. If a rebuild
> * dropped the bandwidth, there is nothing to move: the next rebuild
> * counts it.
> + *
> + * Move nothing while the sched domains are rebuilt, or before the
> + * walk that follows has counted @p, as dl_task_move_bw() does. The
> + * CPU picked above then had no span to prefer. The walk counts @p
> + * on the side of the CPU recorded.
> */
> scoped_guard (raw_spinlock, &dl_departed_lock) {
> + if (dl_bw_move_blocked(p))
> + break;
> if (p->dl.dl_bw_gen == dl_bw_gen) {
> struct rq *src_rq = cpu_rq(dl_task_root_domain_cpu(p));
[Severity: Medium]
Can breaking out on dl_bw_move_blocked(p) leave p's bandwidth uncounted
after a rebuild?
If all CPUs in p->cpus_mask are inactive and dl_task_offline_migration()
moves a throttled task to an out-of-mask fallback CPU while a rebuild or
the task-list walk is in progress, skipping this block leaves
p->dl.dl_bw_cpu pointing at the offline CPU. When dl_task_rebuild_cpu()
then visits p (or if the walk already passed p and left it uncounted with
p->dl.dl_bw_gen != dl_bw_gen while dl_bw_walking is still true), the
check
if (cpu == recorded && cpu_active(cpu) && task_on_rq_queued(p))
return cpu;
no longer matches, and p's bandwidth is never added to later_rq's root
domain. This also contradicts the comment just below stating that
dl_task_offline_migration() counts the bandwidth when a rebuild left the
task out.
[ ... ]
> @@ -3757,6 +3799,61 @@ static unsigned int dl_task_root_domain_cpu(struct task_struct *p)
> return cpu;
> }
>
> +/*
> + * Return the CPUs of the root domain that counts the bandwidth of @p, or
> + * NULL if none does. The mask of @p can hold CPUs of another root domain,
> + * with isolcpus="domain". Where a CPU is picked for @p, a CPU of this
> + * root domain comes first: no other root domain admitted @p.
> + *
> + * Return NULL while the sched domains are rebuilt. The CPU recorded can
> + * then sit in def_root_domain on its way to a new root domain. The span
> + * of def_root_domain holds the isolated CPUs, and no longer the
> + * housekeeping CPUs that already left it. A caller would send a
> + * housekeeping task to an isolated CPU.
> + *
> + * Return NULL also for a task that the walk of the task list after the
> + * rebuild has not reached yet. Its dl_bw_gen is not current.
> + *
> + * The caller holds the pi_lock or the rq lock of @p. With interrupts
> + * off, the root domain is not freed.
> + */
> +const struct cpumask *dl_task_bw_span(struct task_struct *p)
> +{
> + unsigned int seq = READ_ONCE(dl_bw_rebuild_seq);
> + struct root_domain *rd;
> + int cpu;
> +
> + if (!task_has_dl_policy(p) || dl_entity_is_special(&p->dl) ||
> + !p->dl.dl_bw || (seq & 1))
> + return NULL;
> + cpu = READ_ONCE(p->dl.dl_bw_cpu);
> + if (cpu < 0 || READ_ONCE(p->dl.dl_bw_gen) != READ_ONCE(dl_bw_gen))
> + return NULL;
> + /*
> + * The CPU recorded can be going offline. It keeps its root domain
> + * until the rebuild attaches it to def_root_domain. The rebuild then
> + * records an active CPU with @p, or leaves @p out. Until then, the
> + * root domain of the CPU recorded still counts @p.
> + *
> + * A CPU that isolcpus="domain" isolates is always in
> + * def_root_domain, which then counts @p. A housekeeping CPU that is
> + * not active and in def_root_domain was attached there by the
> + * rebuild. def_root_domain does not count @p then.
> + */
> + rd = cpu_rq(cpu)->rd;
> + /*
> + * A rebuild that started since writes rq->rd after it made
> + * dl_bw_rebuild_seq odd. Use this root domain only if none did.
> + */
> + smp_rmb();
> + if (READ_ONCE(dl_bw_rebuild_seq) != seq)
> + return NULL;
[Severity: Medium]
Are the sequence-counter memory barriers complete between
dl_task_bw_span() and dl_clear_root_domains()?
dl_task_bw_span() has no read barrier after reading seq before reading
dl_bw_gen and cpu_rq(cpu)->rd (which is also read without READ_ONCE()),
and dl_clear_root_domains() has no write barrier before incrementing
dl_bw_rebuild_seq from odd back to even:
kernel/sched/deadline.c:dl_clear_root_domains() {
...
WRITE_ONCE(dl_bw_gen, dl_bw_gen + 1);
WARN_ON_ONCE(!(dl_bw_rebuild_seq & 1));
WRITE_ONCE(dl_bw_rebuild_seq, dl_bw_rebuild_seq + 1);
...
}
On weakly-ordered architectures, the loads and stores can reorder at the
end of a rebuild:
CPU0 CPU1
dl_task_bw_span() partition_sched_domains_locked()
// reordered loads: detach_destroy_domains()
// reads old dl_bw_gen == 1 rq_attach_root()
// reads mid-rebuild cpu_rq(cpu)->rd = &def_root_domain
// rd == &def_root_domain ...
dl_clear_root_domains()
WRITE_ONCE(dl_bw_gen, 2)
WRITE_ONCE(dl_bw_rebuild_seq, 2)
seq = READ_ONCE(dl_bw_rebuild_seq) // 2
smp_rmb()
READ_ONCE(dl_bw_rebuild_seq) == 2
return rd->span; <-- returns def_root_domain.span for housekeeping task
Using smp_load_acquire(&dl_bw_rebuild_seq) at the start of
dl_task_bw_span(), READ_ONCE(cpu_rq(cpu)->rd), and
smp_store_release(&dl_bw_rebuild_seq, dl_bw_rebuild_seq + 1) in
dl_clear_root_domains() would close this race.
> + if (!cpu_active(cpu) && rd == &def_root_domain &&
> + housekeeping_test_cpu(cpu, HK_TYPE_DOMAIN_BOOT))
> + return NULL;
[Severity: Medium]
Does this return NULL when an offlining CPU belongs to def_root_domain
through runtime cpuset isolation rather than boot-time isolcpus=domain?
CPUs in a cgroup v2 isolated partition (PRS_ISOLATED) or a cgroup v1
cpuset with sched_load_balance=0 are attached to def_root_domain while
active, so def_root_domain counts their tasks' bandwidth. However,
housekeeping_update() only updates HK_TYPE_DOMAIN, leaving runtime-
isolated CPUs set in HK_TYPE_DOMAIN_BOOT. When such a CPU goes offline,
between set_cpu_active(cpu, false) and the sched domain rebuild in
cpuset_cpu_inactive(), this check sees housekeeping_test_cpu(cpu,
HK_TYPE_DOMAIN_BOOT) == true and returns NULL, allowing
select_fallback_rq() and __set_cpus_allowed_ptr_locked() to move the task
and its bandwidth out of def_root_domain without an admission test.
> + return rd->span;
> +}
[Severity: Medium]
Is it safe for callers to read the live rd->span cpumask returned here
when they only hold p->pi_lock?
Checking dl_bw_rebuild_seq only verifies that no rebuild was running up
to the check. Immediately after dl_task_bw_span() returns rd->span, a
rebuild can start on another CPU and rq_attach_root() will mutate
old_rd->span and def_root_domain.span in place:
CPU0 CPU1
select_fallback_rq()
span = dl_task_bw_span(p)
// returns rd->span
...
set_cpus_allowed_force(p, span)
...
set_cpus_allowed_common()
cpumask_copy(&p->cpus_mask,
ctx->new_mask)
partition_sched_domains_locked()
dl_bw_rebuild_begin()
detach_destroy_domains()
rq_attach_root()
cpumask_clear_cpu(..., old_rd->span)
p->nr_cpus_allowed =
cpumask_weight(ctx->new_mask) <-- mismatches p->cpus_mask
Besides desynchronizing p->nr_cpus_allowed from p->cpus_mask, callers can
observe housekeeping CPUs transiently set in def_root_domain.span as
detach_destroy_domains() moves them through def_root_domain, placing an
isolated task on a housekeeping CPU without admission control.
--
Sashiko AI review · https://sashiko.dev/#/patchset/cover.1795116790.git.mathieu.desnoyers@efficios.com?part=15
next prev parent reply other threads:[~2026-11-19 20:55 UTC|newest]
Thread overview: 46+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-19 20:15 [PATCH v8 00/33] sched/deadline: bandwidth accounting fixes and selftests Mathieu Desnoyers
2026-11-19 20:15 ` [PATCH v8 01/33] sched/deadline: Keep departing bandwidth across a root domain rebuild Mathieu Desnoyers
2026-11-19 20:15 ` [PATCH v8 02/33] sched/deadline: Rebuild the root domains' accounting from the task list Mathieu Desnoyers
2026-11-19 20:15 ` [PATCH v8 03/33] sched/deadline: Record the root domain holding a task's bandwidth Mathieu Desnoyers
2026-11-19 20:51 ` sashiko-bot
2026-11-19 20:15 ` [PATCH v8 04/33] sched/deadline: Leave a dying task out of a rebuild of the accounting Mathieu Desnoyers
2026-11-19 20:15 ` [PATCH v8 05/33] selftests/sched: Test SCHED_DEADLINE bandwidth across a root domain rebuild Mathieu Desnoyers
2026-11-19 20:28 ` sashiko-bot
2026-11-19 20:15 ` [PATCH v8 06/33] selftests/sched: Test the root domain rebuild in deadline_bw_test Mathieu Desnoyers
2026-11-19 20:15 ` [PATCH v8 07/33] sched/deadline: Move a task's bandwidth only where room was made Mathieu Desnoyers
2026-11-19 20:15 ` [PATCH v8 08/33] cgroup/cpuset: Wait for an attach before rebuilding the sched domains Mathieu Desnoyers
2026-11-19 20:15 ` [PATCH v8 09/33] sched: Make deadline policy and affinity changes wait for a cpuset attach Mathieu Desnoyers
2026-11-19 20:15 ` [PATCH v8 10/33] cgroup/cpuset: Give back the bandwidth an attach did not move Mathieu Desnoyers
2026-11-19 20:15 ` [PATCH v8 11/33] cgroup/cpuset: Reserve the bandwidth in the root domain a task moves to Mathieu Desnoyers
2026-11-19 20:15 ` [PATCH v8 12/33] selftests/sched: Test cpuset moves in deadline_bw_test Mathieu Desnoyers
2026-11-19 20:15 ` [PATCH v8 13/33] sched/deadline: Make a rebuild count a task in the root domain it runs in Mathieu Desnoyers
2026-11-19 20:15 ` [PATCH v8 14/33] sched/deadline: Move a task's bandwidth to " Mathieu Desnoyers
2026-11-19 20:53 ` sashiko-bot
2026-11-19 20:15 ` [PATCH v8 15/33] sched/deadline: Keep a task in the root domain that counts its bandwidth Mathieu Desnoyers
2026-11-19 20:55 ` sashiko-bot [this message]
2026-11-19 20:15 ` [PATCH v8 16/33] sched/deadline: Keep the last CPU a task has in its root domain Mathieu Desnoyers
2026-11-19 20:22 ` Mathieu Desnoyers
2026-11-19 20:48 ` sashiko-bot
2026-11-19 20:15 ` [PATCH v8 17/33] cgroup/cpuset: Refuse to take a deadline task out of " Mathieu Desnoyers
2026-11-19 20:43 ` sashiko-bot
2026-11-19 20:15 ` [PATCH v8 18/33] selftests/sched: Test the root domain of a task in deadline_bw_test Mathieu Desnoyers
2026-11-19 20:27 ` sashiko-bot
2026-11-19 20:15 ` [PATCH v8 19/33] sched/deadline: Count only active CPUs when spreading extra_bw Mathieu Desnoyers
2026-11-19 20:15 ` [PATCH v8 20/33] rtmutex: Continue the chain walk when a waiter's deadline donor changes Mathieu Desnoyers
2026-11-19 20:16 ` [PATCH v8 21/33] rtmutex: Continue the walk when the owner's top waiter changes lock Mathieu Desnoyers
2026-11-19 20:16 ` [PATCH v8 22/33] selftests/sched: Test the rtmutex chain walk in deadline_bw_test Mathieu Desnoyers
2026-11-19 20:16 ` [PATCH v8 23/33] sched/deadline: Reset the donor's runtime at a deboost in the class Mathieu Desnoyers
2026-11-19 20:53 ` sashiko-bot
2026-11-19 20:16 ` [PATCH v8 24/33] sched/deadline: Replenish a throttled task boosted while asleep Mathieu Desnoyers
2026-11-19 20:16 ` [PATCH v8 25/33] sched/deadline: Count the bandwidth a boosted task is given Mathieu Desnoyers
2026-11-19 20:16 ` [PATCH v8 26/33] sched/deadline: Start a period for a task that enters the class blocked Mathieu Desnoyers
2026-11-19 20:57 ` sashiko-bot
2026-11-19 20:16 ` [PATCH v8 27/33] sched/deadline: Start a period at a deboost out of the class Mathieu Desnoyers
2026-11-19 20:47 ` sashiko-bot
2026-11-19 20:16 ` [PATCH v8 28/33] selftests/sched: Test deadline boosts in deadline_bw_test Mathieu Desnoyers
2026-11-19 20:16 ` [PATCH v8 29/33] sched/deadline: Cancel the replenishment timer with the parameters Mathieu Desnoyers
2026-11-19 20:16 ` [PATCH v8 30/33] sched/deadline: Cap the runtime left of a constrained task at dl_runtime Mathieu Desnoyers
2026-11-19 20:16 ` [PATCH v8 31/33] sched/deadline: Check the runtime of a task that comes back runnable Mathieu Desnoyers
2026-11-19 20:16 ` [PATCH v8 32/33] sched/deadline: Check the runtime of a task whose parameters change Mathieu Desnoyers
2026-11-19 20:59 ` sashiko-bot
2026-11-19 20:16 ` [PATCH v8 33/33] selftests/sched: Test parameter changes in deadline_bw_test Mathieu Desnoyers
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=sashiko-outbox-224072@kernel.org \
--to=sashiko-bot@kernel.org \
--cc=hannes@cmpxchg.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-rt-devel@lists.linux.dev \
--cc=mathieu.desnoyers@efficios.com \
--cc=mkoutny@suse.com \
--cc=sashiko-reviews@lists.linux.dev \
--cc=tj@kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®