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 16/16] selftests/sched: Add a test of SCHED_DEADLINE bandwidth accounting
Date: Wed, 18 Nov 2026 21:04:46 +0000 [thread overview]
Message-ID: <sashiko-outbox-221967@kernel.org> (raw)
In-Reply-To: <92d746027d4034afb4e9c55bd1b686312a2401ab.1795031605.git.mathieu.desnoyers@efficios.com>
Thank you for your contribution! Sashiko AI review found 9 potential
issues to consider:
- [Medium] selftests/sched: sub-cgroup start and unconditional cpu
toggle in move_cancelled()
- [Medium] selftests/sched: broken PI and runtime logic in
deboost_new_params_reboost()
- [Medium] selftests/sched: pi_chain_donor_leaves() fails due to
unpropagated dl.pi_se
- [Medium] selftests/sched: rebuild_record_taken() fails under
isolcpus=domain,0,1
- [Low] selftests/sched: rebuild_record_taken() fails instead of
skipping without debugfs
- [Low] selftests/sched: data race on late.done and unjoined thread in
move_cancelled()
- [Low] selftests/sched: unchecked -1 error return from probe() in
bandwidth comparisons
- [Low] selftests/sched: unused variables, write-only fair_tid, and dead
mode branches
- [Low] selftests/sched: re-init of active robust mutex shm_lock in
shm_lock_init()
--
commit ec25de481fdb21f02eb990530342399d3485450d
Author: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
selftests/sched: Add a test of SCHED_DEADLINE bandwidth accounting
This commit adds deadline_bw_test, a kselftest covering SCHED_DEADLINE
bandwidth accounting across priority inheritance, parameter changes,
cpuset moves, task deaths, yields, runtime overruns, bandwidth
reclaiming, fair server changes, and CPU hotplug.
Link: https://github.com/jlelli/sched-deadline-tests
> diff --git a/tools/testing/selftests/sched/deadline/deadline_bw_test.c b/tools/testing/selftests/sched/deadline/deadline_bw_test.c
> new file mode 100644
> index 0000000000000..1e64402f90df0
> --- /dev/null
> +++ b/tools/testing/selftests/sched/deadline/deadline_bw_test.c
[ ... ]
> + sem_post(&rb_donor_go);
> + t0 = now_ns();
> + while (!rb_donor_locking || proc_state_of(donor_tid) != 'S') {
> + if (now_ns() - t0 > NSEC_PER_SEC) {
> + ksft_print_msg("the donor did not block on the lock\n");
> + err = -1;
> + goto out;
> + }
> + }
> + err = set_deadline(rb_waiter_tid, 2 * NSEC_PER_MSEC, PERIOD);
> + if (err) {
> + ksft_print_msg("the waiter refused as a deadline task: %s\n",
> + strerror(-err));
> + goto out;
> + }
> + err = set_deadline(0, 5 * NSEC_PER_MSEC, PERIOD);
[Severity: Medium]
Does deboost_new_params_reboost() exercise reboosting after a deboost as
its comment describes?
When reboost_owner() calls set_deadline() on rb_waiter_tid while W is
blocked on pi_lock, W is not queued on a runqueue, so __setparam_dl()
updates W's static parameters and switched_to_dl() returns without setting
W->dl.deadline. rt_mutex_adjust_pi() then copies W->dl.deadline (0) into
W's waiter node on pi_lock, which sorts ahead of D's deadline in
rt_waiter_node_less() and makes W the top waiter boosting O immediately,
before D times out.
Also, when O calls set_deadline() on itself while running, the kernel
enqueues O with ENQUEUE_RESTORE | ENQUEUE_MOVE without replenishing, and
rt_mutex_setprio() on deboost does not compare O's remaining runtime
against its new static runtime or start a new period, so the test passes
without testing a reboost on deboost.
[ ... ]
> +static pthread_mutex_t pi_lock2;
> +static sem_t holder_go;
> +static atomic_int holder_holds, chain_waits, donor_done, x_waits, l2_takes;
> +static atomic_int chain_rank, x_rank;
> +static _Atomic pid_t x_tid, fair_tid;
[ ... ]
> + donor_tid = 0;
> + x_tid = 0;
> + fair_tid = 0;
> + return 0;
> +}
[Severity: Low]
fair_tid is set in pi_init_lock2() but never read, which triggers a
-Wunused-but-set-variable warning under -Wall. Similarly, nisol and isol
in main() are populated by read_online(&isol, 1) and never used or freed,
sleeper_cpu is never modified from -1 (leaving the sleeper_cpu >= 0 block
in dl_sleeper_tid() unreachable), struct hp_case::no_hp is never set, and
several helper modes (was_dl != 0 in pi_asleep(), modes 1 and 2 in
deboost_case(), spin_ms == 8 in refill_case(), modes 0 and 2..5 in
return_case(), and MV_YIELDED in mover()) have no callers.
[ ... ]
> + have[LV_Z] = !pthread_create(&t[LV_Z], NULL, leave_waiter, (void *)2L);
> + if (!have[LV_Z] ||
> + wait_for(1000, (leave_tid[LV_Z] && proc_state_of(leave_tid[LV_Z]) == 'S') ||
> + leave_err)) {
> + ksft_print_msg("Z never blocked on L1\n");
> + goto out;
> + }
> + sleep_ns(10 * NSEC_PER_MSEC); /* the chain walk of Z is done */
> + err = leave_err ? -EINVAL : set_other(leave_tid[LV_W]);
[Severity: Medium]
Does pi_chain_donor_leaves() fail because Z is never propagated past M to
O as O's donor?
When Z blocks on L1, task_blocks_on_rt_mutex() updates M->dl.pi_se to
&Z->dl, but M is sleeping on L2, so M->prio (-1) and M->dl.deadline do not
change. In rt_mutex_adjust_prio_chain(), rt_waiter_node_equal() sees that
M's waiter node on L2 still matches M's prio and deadline and stops without
requeueing M on L2 or calling rt_mutex_adjust_prio() on O:
kernel/locking/rtmutex.c:rt_mutex_adjust_prio_chain() {
...
if (rt_waiter_node_equal(&waiter->tree, task_to_waiter_node(task))) {
if (!detect_deadlock)
goto out_unlock_pi;
else
requeue = false;
}
...
}
O->dl.pi_se therefore stays &W->dl. After set_other(leave_tid[LV_W]) and
the 250ms sleep clear W's deadline parameters, waking O replenishes O from
W's zeroed parameters with runtime = 0 and deadline = rq_clock(rq), so O
preempts and starves Y on P's CPU and fails the y_ns < 30ms check.
[ ... ]
> +/* What late_setter() does, and the result. */
> +static struct {
> + pid_t pid;
> + uint64_t runtime;
> + uint64_t delay;
> + atomic_int go;
> + int ret;
> + uint64_t done;
> +} late;
> +
> +/*
> + * Make late.pid a deadline task of late.runtime every 100ms, late.delay
> + * ns after late.go. Store the result in late.ret and the time it returned
> + * in late.done.
> + */
> +static void *late_setter(void *arg)
> +{
> + uint64_t start;
> +
> + while (!late.go)
> + ;
> + start = now_ns();
> + while (now_ns() - start < late.delay)
> + ;
> + late.ret = set_deadline(late.pid, late.runtime, PERIOD);
> + late.done = now_ns();
> + return arg;
> +}
[ ... ]
> +static int move_cancelled(void)
> +{
> + int with_p, with_r, ret = KSFT_PASS, i, err;
> + const char *name = "move_cancelled";
> + uint64_t start, len;
> + pid_t pid;
> +
> + mv_state[0] = 0;
> + mv_state[3] = 0;
> + mv_state[4] = 0;
> + mv_state[5] = 0;
> + pid = pinned_mover(2048, 1);
> + if (pid < 0 || child_up(name, 0) || wait_for(5000, mv_state[5])) {
> + reap(pid);
> + return mv_state[0] == -2 ? KSFT_SKIP : KSFT_FAIL;
> + }
> + if (mv_state[5] < 0 || write_file(root, "cgroup.subtree_control", "+cpu")) {
> + ksft_print_msg("%s: no SCHED_FIFO thread or no cpu controller\n", name);
> + reap(pid);
> + return KSFT_SKIP;
> + }
[ ... ]
> + if (wait_for(5000, late.done)) {
> + ksft_print_msg("%s: sched_setattr() still waits after a cancelled move\n",
> + name);
> + ret = KSFT_FAIL;
> + break; /* the thread cannot be joined */
> + }
> + join(t);
> + if (late.ret) {
> + ksft_print_msg("%s: sched_setattr: %s\n", name, strerror(-late.ret));
> + ret = KSFT_FAIL;
> + }
> + }
> + sleep_ns(3 * PERIOD);
> + if (ret == KSFT_PASS &&
> + (admits_in(cg_p, with_p, "P, after the cancelled moves") ||
> + admits_in(root, with_r, "the root domain of the process")))
> + ret = KSFT_FAIL;
> +out:
> + reap(pid);
> + if (write_file(root, "cgroup.subtree_control", "-cpu"))
> + ksft_print_msg("%s: the cpu controller stays enabled\n", name);
> + return ret;
> +}
[Severity: Medium]
What happens in move_cancelled() when deadline_bw_test is started from a
non-root cgroup (such as a systemd session or service cgroup)?
Unlike kill_case() and death_group(), main() and move_cancelled() never
move the test process into root before forking pinned_mover(2048, 1).
With CONFIG_RT_GROUP_SCHED=y, a non-root cgroup has no RT runtime by
default, so either fifo_sleeper() fails sched_setscheduler(SCHED_FIFO)
with EPERM when +cpu is already enabled, or enabling +cpu on root fails
with EINVAL while the child cgroup contains a SCHED_FIFO task, causing
move_cancelled() to always skip. Also, unlike run_p_cases() and
cs_setup() with +cpuset, move_cancelled() unconditionally writes -cpu to
root/cgroup.subtree_control at exit even if the cpu controller was already
enabled before the test ran.
[Severity: Low]
In the same loop, late.done is a plain uint64_t written by late_setter()
while move_cancelled() polls it in wait_for(5000, late.done), which is a
data race. If that wait times out, breaking out before join(t) also
leaves t unjoined in the main process even though reap(pid) at out: kills
pid and unblocks late_setter().
[ ... ]
> +/* Set up shm_lock. Return 0, or -1 if it cannot be set up. */
> +static int shm_lock_init(void)
> +{
> + pthread_mutexattr_t a;
> + int err;
> +
> + err = pthread_mutexattr_init(&a);
> + if (!err)
> + err = pthread_mutexattr_setpshared(&a, PTHREAD_PROCESS_SHARED);
> + if (!err)
> + err = pthread_mutexattr_setprotocol(&a, PTHREAD_PRIO_INHERIT);
> + if (!err)
> + err = pthread_mutexattr_setrobust(&a, PTHREAD_MUTEX_ROBUST);
> + if (!err)
> + err = pthread_mutex_init(shm_lock, &a);
[ ... ]
> + } else {
> + reap(waiter);
> + waiter = -1;
> + sleep_ns(50 * NSEC_PER_MSEC); /* the owner deboosted asleep */
> + }
> +out:
> + reap(waiter);
> + reap(owner);
> + return ret;
> +}
[Severity: Low]
Does shm_lock_init() re-initialize shm_lock without destroying it across
death_pi_waiter, death_pi_owner, and death_pi_deadline_owner?
shm_lock lives in MAP_SHARED memory, and in death_pi_waiter, reap(owner)
kills the owner with SIGKILL while it still holds shm_lock, leaving the
robust mutex in the FUTEX_OWNER_DIED state when the next test case calls
pthread_mutex_init(shm_lock, &a). shm_lock_init() (and
pi_chain_two_owners()) also omits pthread_mutexattr_destroy(&a).
[ ... ]
> +static int hotplug_server(void)
> +{
> + int base, off10, off30;
> +
> + if (server_set(hp_cpu, SERVER_RUNTIME, SERVER_PERIOD)) {
> + ksft_print_msg("the fair server of CPU %d cannot be set\n", hp_cpu);
> + return KSFT_SKIP;
> + }
> + base = probe(NULL);
> + if (cpu_online(hp_cpu, 0)) {
> + ksft_print_msg("offline of CPU %d refused\n", hp_cpu);
> + return KSFT_FAIL;
> + }
> + off10 = probe(NULL);
> + cpu_up(hp_cpu);
> + if (server_set(hp_cpu, 3 * SERVER_RUNTIME, SERVER_PERIOD) ||
> + admits(base - 2, "a fair server of 30%"))
> + return KSFT_FAIL;
> + if (cpu_online(hp_cpu, 0)) {
> + ksft_print_msg("offline of CPU %d refused, its fair server at 30%%\n", hp_cpu);
> + return KSFT_FAIL;
> + }
> + off30 = probe(NULL);
> + cpu_up(hp_cpu);
> + if (off30 != off10) {
[Severity: Low]
Can hotplug_server() pass when probe(NULL) fails and returns -1?
If both offline probes return -1, off30 != off10 evaluates to false; base
is not checked for <= 0 either. move_refused() and move_zero_bw()
similarly compare probe(cg_p) != base_p || probe(root) != base_r without
checking whether base_p or base_r failed with -1.
[ ... ]
> +static int rebuild_record_taken(void)
> +{
> + int a = top_cpu(3), b = top_cpu(2), c = online[0], d = top_cpu(1);
> + int fd[2] = { -1, -1 }, i, n, err, cpu, ret = KSFT_SKIP;
> + long long q, h, q0, h0, bw;
> + char buf[4096];
> + pid_t pid = -1;
> +
> + if (ncpus < 4 || !cpu_hotpluggable(a) || !cpu_hotpluggable(b) ||
> + !cpu_hotpluggable(d)) {
> + ksft_print_msg("needs 4 CPUs, 3 of them hotpluggable\n");
> + return KSFT_SKIP;
> + }
> + if (cs_setup())
> + return KSFT_SKIP;
> + /* Q has every housekeeping CPU but A, B and D. */
> + for (i = n = 0; i < ncpus - 3; i++)
> + n += snprintf(buf + n, sizeof(buf) - n, "%s%d", n ? "," : "",
> + online[i]);
> + if (make_partition_cpus(cs_q, buf)) {
> + ksft_print_msg("Q cannot be a partition root of CPUs %s\n", buf);
> + goto out;
> + }
> + ret = KSFT_FAIL;
> + err = cpu_online(d, 0);
> + if (err) {
> + ksft_print_msg("offline of CPU %d: %s\n", d, strerror(-err));
> + goto out;
> + }
> + bw = total_bw_of(a);
> + if (bw == -1 || pipe(fd)) {
> + ksft_print_msg("no total_bw of CPU %d, or no pipe\n", a);
> + goto out;
> + }
[Severity: Low]
Should rebuild_record_taken() return KSFT_SKIP instead of KSFT_FAIL when
total_bw_of(a) returns -1 because /sys/kernel/debug/sched/debug is not
available?
ret is set to KSFT_FAIL before total_bw_of(a) is checked, whereas the
other debugfs-dependent cases skip when debugfs files cannot be read.
> + mv_state[0] = 0;
> + mv_state[1] = 0;
> + pid = fork_child("a deadline task");
> + if (!pid) {
> + cpu_set_t set;
> + char ch;
> +
> + CPU_ZERO(&set);
> + CPU_SET(a, &set);
> + CPU_SET(b, &set);
> + if (sched_setaffinity(0, sizeof(set), &set) ||
> + set_deadline(0, 10 * NSEC_PER_MSEC, PERIOD)) {
[ ... ]
> + if (fallback_wake(fd[1], pid))
> + goto out;
> + /* Go on after a failure: the totals tell more. */
> + cpu = task_cpu_of(pid);
> + if (cpu != c)
> + ksft_print_msg("woken on CPU %d, not %d\n", cpu, c);
> + else if (!totals_check("woken", d, c, q, h))
> + ret = KSFT_PASS;
> + reap(pid);
> + pid = -1;
> + sleep_ns(3 * PERIOD);
> + if (totals_of(d, c, &q0, &h0)) {
> + ret = KSFT_FAIL;
> + goto out;
> + }
> + if (q != q0 || h != h0 + bw) {
> + ksft_print_msg("Q counts %lld of %lld, the root cgroup %lld\n",
> + q - q0, bw, h - h0);
> + ret = KSFT_FAIL;
> + }
[Severity: Medium]
Does rebuild_record_taken() fail when CPU 0 is isolated with
isolcpus=domain,0,1?
When CPU 0 is isolated, online[0] is the first housekeeping CPU (for
example, c = 2). The child in the root cgroup overwrites its inherited
housekeeping affinity with {a, b}. Once a and b are taken offline and
cs_q takes the remaining housekeeping CPUs except c,
dl_add_task_root_domain() queries cpuset_cpus_allowed_locked() for
top_cpuset, which includes the isolated CPUs 0 and 1, so
cpumask_first_and(cpu_active_mask, msk) picks CPU 0 and adds bw to CPU 0's
default root domain rather than CPU c's housekeeping root domain (leaving
h == h0 instead of h0 + bw). Likewise, waking pid via fallback_wake()
hits select_fallback_rq() -> cpuset_cpus_allowed_fallback(), which resets
pid's affinity to top_cpuset.cpus_allowed and wakes pid on CPU 0 instead
of CPU c.
--
Sashiko AI review · https://sashiko.dev/#/patchset/cover.1795031605.git.mathieu.desnoyers@efficios.com?part=16
next prev parent reply other threads:[~2026-11-18 21:04 UTC|newest]
Thread overview: 31+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-18 20:06 [PATCH 00/16] sched/deadline: first bandwidth accounting fixes and selftests Mathieu Desnoyers
2026-11-18 20:06 ` [PATCH 01/16] sched: Refuse SCHED_FLAG_KEEP_PARAMS that would change the policy or the class Mathieu Desnoyers
2026-11-18 20:06 ` [PATCH 02/16] sched/deadline: Do not admit bandwidth for parameters that are kept Mathieu Desnoyers
2026-11-18 20:06 ` [PATCH 03/16] sched: Let a task boosted by a deadline waiter change its policy Mathieu Desnoyers
2026-11-18 20:06 ` [PATCH 04/16] sched/deadline: Do not divide by zero active CPUs of a root domain Mathieu Desnoyers
2026-11-18 20:23 ` sashiko-bot
2026-11-18 21:08 ` Mathieu Desnoyers
2026-11-18 20:06 ` [PATCH 05/16] sched/deadline: Refuse dl_server debugfs writes while the rq is offline Mathieu Desnoyers
2026-11-18 20:06 ` [PATCH 06/16] sched: Take cpuset_mutex for a deadline policy change only with pi Mathieu Desnoyers
2026-11-18 20:17 ` sashiko-bot
2026-11-18 21:09 ` Mathieu Desnoyers
2026-11-18 20:06 ` [PATCH 07/16] sched/deadline: Do not lose a throttled task switched out and back Mathieu Desnoyers
2026-11-18 20:31 ` sashiko-bot
2026-11-18 21:09 ` Mathieu Desnoyers
2026-11-18 20:06 ` [PATCH 08/16] sched/deadline: Do not replenish a boost from cleared parameters Mathieu Desnoyers
2026-11-18 20:35 ` sashiko-bot
2026-11-18 21:10 ` Mathieu Desnoyers
2026-11-18 20:06 ` [PATCH 09/16] sched/deadline: Reset the deadline and the runtime with the parameters Mathieu Desnoyers
2026-11-18 20:38 ` sashiko-bot
2026-11-18 21:10 ` Mathieu Desnoyers
2026-11-18 20:06 ` [PATCH 10/16] sched/deadline: Release the bandwidth of a task that leaves the class asleep Mathieu Desnoyers
2026-11-18 20:06 ` [PATCH 11/16] sched/deadline: Reject SCHED_DEADLINE on exited tasks Mathieu Desnoyers
2026-11-18 20:06 ` [PATCH 12/16] sched/deadline: Fix this_bw when a task is changed during a remote wakeup Mathieu Desnoyers
2026-11-18 20:46 ` sashiko-bot
2026-11-18 21:11 ` Mathieu Desnoyers
2026-11-18 20:06 ` [PATCH 13/16] sched/deadline: Check SCHED_DEADLINE affinity under the rq lock Mathieu Desnoyers
2026-11-18 20:06 ` [PATCH 14/16] sched/debug: Show the deadline bandwidth of each runqueue Mathieu Desnoyers
2026-11-18 20:06 ` [PATCH 15/16] selftests/sched: Add a test of SCHED_DEADLINE policy round trips Mathieu Desnoyers
2026-11-18 20:06 ` [PATCH 16/16] selftests/sched: Add a test of SCHED_DEADLINE bandwidth accounting Mathieu Desnoyers
2026-11-18 21:04 ` sashiko-bot [this message]
2026-11-18 21:12 ` 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-221967@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