From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.remote-ip=158.69.130.18 ARC-Seal: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; cv=none; t=1794924678; b=5KCJ9n9ghf3MAHQzKLU4vbtuHwCfvVS7XRvXc9cRet5bnews2H2nTmi0jMLR9aQgQOAI AHE56AUDDJc3WIdy5KA8Ahhbz71mxCfk1R9FYmVpMJReQsEM7pDbFPsfX4I0ZLK42wCxD nag9e8rYzI0JlUyJLMbYY+PP59Rv9b/cKgW0JMwfv7JCxsL+/OGpAybDGCD2Eh4MkulN1 lgq3q16qn1BkIuQtl3yM9s0LlQAmEQvZjv4MJ2is2i9ljAfmowJfPL77Hg1O+pERETRer v8HbzQa7VHvxmqGroM/d/WbUFkvO02FBWBmo30gjHlhZna6I5VXCs3hdy38H+NSt9YQ== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1794924678; h=DMARC-Filter:DKIM-Signature:Received:From:To:Cc:Subject:Date: Message-Id:X-Mailer:In-Reply-To:References:MIME-Version: Content-Transfer-Encoding; bh=jJ4TJgnTADdTkzPG1Tf8obqekT6REPhvch3DXj7ESUY=; b=SkC5LMquIYi2+xTMgZ1luFT9hoPJgeyXlQzpkh3RptU9eGUPubPV5X+r6CxjP1JIeCu7 sK8x1xeB7XXH8GgFCwdqf8hq4kwEb2L88yddTykhEocTSACZ2BroUhTm/IPUlW0k/OGwH 9qAnwNgGKIdwnPnsOtxjb8qK+kRbXfgxNfvjYivpDUvsGObdkhJieTu/iS1esAjgn+iBB QHRe0psT2SQfnn7fId7HIPw2WIHKPFebxbZ57SVmHQC2dbXj6IFtdMJnucMkpOMshE/k1 3bNwMkBs8nGa7hAGvPJO9RdtWpMt9AECBe5PNLKclGUs6mO6obrZLymu69LWPnnMv1A== ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass header.from=efficios.com; spf=pass smtp.mailfrom=efficios.com; dkim=pass header.d=efficios.com header.i=@efficios.com header.a=rsa-sha256 header.s=smtpout1 header.b=Ts2s9X7F; arc=none smtp.remote-ip=158.69.130.18 Received: from smtpout.efficios.com (smtpout.efficios.com [158.69.130.18]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (prime256v1)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A609F60A5BC0; Tue, 17 Nov 2026 14:11:11 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.2 smtp.subspace.kernel.org A609F60A5BC0 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=efficios.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=efficios.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=efficios.com header.i=@efficios.com header.a=rsa-sha256 header.s=smtpout1 header.b=Ts2s9X7F DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=efficios.com; s=smtpout1; t=1794924668; bh=jJ4TJgnTADdTkzPG1Tf8obqekT6REPhvch3DXj7ESUY=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Ts2s9X7FglglUtELmuqM8shPRoRql3ds0JRj69XsnlJrCSQgwpeBBws44H6Kvk776 R+D8N9Jj3O5YkQeyKliD65Vy17hN3QU2I/7ZhPZEB8tMyrF7LS5DVx+I0FFm0QpGol l7yPW+fEMVyq02Xy/oq8ahT83jdelrUCe+xwLyPNTlwssOUZ9FAWWm8/sCoUu/mugl 1s+6Uhh9rrDMrAgWsqBYXZo63YRAPL2fkiZ+LppVk9biokoLFWYXcvb9v3MkwZuYsS 2VbeaxpM0kb1Faqw9VpY86knuKHmSkEOABEhLDhnsbHKwftENenvHUlnnFwD+A8+Y3 ptdVPxCsXW3ew== Received: from thinkos.internal.efficios.com (mtl.efficios.com [216.120.195.104]) by smtpout.efficios.com (Postfix) with ESMTPSA id 4jTRV4021vzRTP; Tue, 17 Nov 2026 09:11:08 -0500 (EST) From: Mathieu Desnoyers To: juri.lelli@redhat.com, peterz@infradead.org, mingo@redhat.com, vincent.guittot@linaro.org Cc: linux-kernel@vger.kernel.org, Mathieu Desnoyers , tglx@kernel.org, will@kernel.org, boqun@kernel.org, dietmar.eggemann@arm.com, rostedt@goodmis.org, bsegall@google.com, mgorman@suse.de, vschneid@redhat.com, kprateek.nayak@amd.com, luca.abeni@santannapisa.it, mathieu.poirier@linaro.org, longman@redhat.com, ridong.chen@linux.dev, tj@kernel.org, hannes@cmpxchg.org, mkoutny@suse.com, shuah@kernel.org, bigeasy@linutronix.de, clrkwllms@kernel.org, parri.andrea@gmail.com, m.szyprowski@samsung.com, kayracizmeci@gmail.com, weihengqiuu@gmail.com, cgroups@vger.kernel.org, linux-kselftest@vger.kernel.org, linux-rt-devel@lists.linux.dev, stable@vger.kernel.org Subject: [PATCH v7 20/40] sched/deadline: Check SCHED_DEADLINE affinity under the rq lock Date: Tue, 17 Nov 2026 09:10:41 -0500 Message-Id: <188f014132c93ce3527652e2df7f77ffdfa55f36.1794922146.git.mathieu.desnoyers@efficios.com> X-Mailer: git-send-email 2.39.5 In-Reply-To: References: X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list MIME-Version: 1.0 Content-Transfer-Encoding: 8bit From: Andrea Parri A task can end up SCHED_DEADLINE with an affinity narrower than its root domain when sched_setaffinity() and sched_setattr() race on it. Both calls succeed, although each fails when made after the other: sched_setattr() with -EPERM, sched_setaffinity() with -EBUSY. __sched_setaffinity() calls dl_task_check_affinity() before __set_cpus_allowed_ptr() takes task_rq_lock(), whereas __sched_setscheduler() runs its admission test and switches the policy under a single task_rq_lock(). So both calls can pass their checks: CPU 1: sched_setaffinity(p, cpu0) CPU 2: sched_setattr(p, DEADLINE) dl_task_check_affinity() !task_has_dl_policy(p): return 0 task_rq_lock() admission test passes p->policy = SCHED_DEADLINE task_rq_unlock() __set_cpus_allowed_ptr() task_rq_lock() p->cpus_mask = cpu0 The window includes CPU 1 spinning on task_rq_lock() while CPU 2 holds it. With one thread narrowing a sleeping task to CPU 0 while another makes it SCHED_DEADLINE, 923514, 959547 and 983997 of 1000000 rounds ended with both calls succeeding on three boots of a 4-CPU guest. Move the check into __set_cpus_allowed_ptr_locked(), next to the PF_NO_SETAFFINITY re-check, under the same lock as the admission test. Whichever call takes task_rq_lock() second then sees the other's result: sched_setaffinity() fails with -EBUSY if p is already SCHED_DEADLINE, and sched_setattr() fails with -EPERM if p's affinity is already cpu0. A new SCA_DL_CHECK flag selects the check, and only __sched_setaffinity() sets it, so sched_setaffinity() and relax_compatible_cpus_allowed_ptr() keep the check and other callers stay unchecked. restrict_cpus_allowed_ptr() already does its deadline check this way. __sched_setaffinity() clears SCA_DL_CHECK before the second __set_cpus_allowed_ptr() call it makes after racing with a cpuset update, so the cpuset mask still wins there, as it does when cpuset_update_tasks_cpumask() narrows a deadline task. SCA_CHECK stays set for the PF_NO_SETAFFINITY re-check. With this applied, the same test ends with both calls succeeding in 0 of 1000000 rounds on each of three boots, and sched_setaffinity() fails with -EBUSY whenever it loses. The race was reported by Sebastian. The fix was written with the help of an LLM. Fixes: 332ac17ef5bf ("sched/deadline: Add bandwidth management for SCHED_DEADLINE tasks") Reported-by: Sebastian Andrzej Siewior Closes: https://lore.kernel.org/20261103081149.DuyWNhVe@linutronix.de Signed-off-by: Andrea Parri Cc: stable@vger.kernel.org Reviewed-by: Sebastian Andrzej Siewior Signed-off-by: Mathieu Desnoyers --- kernel/sched/core.c | 11 +++++++++++ kernel/sched/sched.h | 1 + kernel/sched/syscalls.c | 12 +++++++----- 3 files changed, 19 insertions(+), 5 deletions(-) diff --git a/kernel/sched/core.c b/kernel/sched/core.c index a22df8b43a1a..c77cae5d1be1 100644 --- a/kernel/sched/core.c +++ b/kernel/sched/core.c @@ -3195,6 +3195,17 @@ static int __set_cpus_allowed_ptr_locked(struct task_struct *p, goto out; } + /* + * Check under the same lock that __sched_setscheduler() holds for + * its admission test, so that p cannot become SCHED_DEADLINE + * between this check and the mask update below. + */ + if (ctx->flags & SCA_DL_CHECK) { + ret = dl_task_check_affinity(p, ctx->new_mask); + if (ret) + goto out; + } + if (!(ctx->flags & SCA_MIGRATE_ENABLE)) { if (cpumask_equal(&p->cpus_mask, ctx->new_mask)) { if (ctx->flags & SCA_USER) diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h index d87296abec4c..fd6d36b6b1e2 100644 --- a/kernel/sched/sched.h +++ b/kernel/sched/sched.h @@ -2982,6 +2982,7 @@ extern struct task_struct *pick_task_idle(struct rq *rq, struct rq_flags *rf); #define SCA_MIGRATE_DISABLE 0x02 #define SCA_MIGRATE_ENABLE 0x04 #define SCA_USER 0x08 +#define SCA_DL_CHECK 0x10 extern void update_group_capacity(struct sched_domain *sd, int cpu); diff --git a/kernel/sched/syscalls.c b/kernel/sched/syscalls.c index 306cd8d32173..4f47b17151ed 100644 --- a/kernel/sched/syscalls.c +++ b/kernel/sched/syscalls.c @@ -1238,11 +1238,7 @@ int __sched_setaffinity(struct task_struct *p, struct affinity_context *ctx) cpumask_and(new_mask, ctx->new_mask, cpus_allowed); ctx->new_mask = new_mask; - ctx->flags |= SCA_CHECK; - - retval = dl_task_check_affinity(p, new_mask); - if (retval) - goto out_free_new_mask; + ctx->flags |= SCA_CHECK | SCA_DL_CHECK; retval = __set_cpus_allowed_ptr(p, ctx); if (retval) @@ -1271,6 +1267,12 @@ int __sched_setaffinity(struct task_struct *p, struct affinity_context *ctx) if (empty) cpumask_copy(new_mask, cpus_allowed); } + + /* + * The cpuset mask must win here, as it does when + * cpuset_update_tasks_cpumask() sets it on a deadline task. + */ + ctx->flags &= ~SCA_DL_CHECK; __set_cpus_allowed_ptr(p, ctx); retval = -EINVAL; } -- 2.47.3