All of lore.kernel.org
 help / color / mirror / Atom feed
From: Ridong <ridong.chen@linux.dev>
To: longman@redhat.com, frederic@kernel.org, tj@kernel.org,
	peterz@infradead.org, mingo@redhat.com, juri.lelli@redhat.com,
	vincent.guittot@linaro.org, dietmar.eggemann@arm.com,
	rostedt@goodmis.org, bsegall@google.com, mgorman@suse.de,
	vschneid@redhat.com, kprateek.nayak@amd.com, hannes@cmpxchg.org,
	mkoutny@suse.com
Cc: linux-kernel@vger.kernel.org, cgroups@vger.kernel.org,
	guopeng.zhang@linux.dev, mathieu.desnoyers@efficios.com,
	Ridong Chen <chenridong@xiaomi.com>
Subject: [PATCH] sched/isolation: Publish new HK_TYPE_DOMAIN cpumask under cpuset_mutex
Date: Tue, 17 Nov 2026 16:39:15 +0800	[thread overview]
Message-ID: <20261117083915.2971979-1-ridong.chen@linux.dev> (raw)
In-Reply-To: <054a53a3-c038-48fe-ac01-fc24fd8065d0@linux.dev>

From: Ridong Chen <chenridong@xiaomi.com>

Commit a84097e625f2 ("cgroup/cpuset: Call housekeeping_update() without
holding cpus_read_lock") calls housekeeping_update() after dropping
cpus_read_lock and cpuset_mutex, so the HK_TYPE_DOMAIN cpumask is now
switched and freed outside of those locks. But readers holding either
lock may still access it without rcu_read_lock() as allowed by
housekeeping_dereference_check(), and synchronize_rcu() doesn't wait
for them:

  CPU A                                  CPU B
  rebuild_sched_domains()                cpuset_update_sd_hk_unlock()
                                           mutex_unlock(&cpuset_mutex)
                                           cpus_read_unlock()
    mutex_lock(&cpuset_mutex)
    p = housekeeping_cpumask(DOMAIN)
                                           housekeeping_update()
                                             rcu_assign_pointer()
                                             synchronize_rcu()
                                             kfree(old)
    access p <- UAF

Fix it by moving the pointer switch into housekeeping_publish(), which
is called before dropping the locks. Then CPU A either finishes before
CPU B switches the pointer, or only sees the new cpumask:

  CPU A                                  CPU B
                                         cpuset_update_sd_hk_unlock()
                                           housekeeping_publish()
                                             rcu_assign_pointer()
    mutex_lock(&cpuset_mutex) <- wait
                                           mutex_unlock(&cpuset_mutex)
                                           cpus_read_unlock()
    p = housekeeping_cpumask(DOMAIN)       housekeeping_update()
        <- new cpumask                       synchronize_rcu()
                                             kfree(old)

The rest of housekeeping_update(), including the workqueue flushes,
still runs without those locks.

Fixes: a84097e625f2 ("cgroup/cpuset: Call housekeeping_update() without holding cpus_read_lock")
Signed-off-by: Ridong Chen <chenridong@xiaomi.com>
---
 include/linux/sched/isolation.h |  6 ++++--
 kernel/cgroup/cpuset.c          | 12 ++++++++----
 kernel/sched/isolation.c        | 23 ++++++++++++++++-------
 3 files changed, 28 insertions(+), 13 deletions(-)

diff --git a/include/linux/sched/isolation.h b/include/linux/sched/isolation.h
index cf0fd03dd7a24..09fabf42e3224 100644
--- a/include/linux/sched/isolation.h
+++ b/include/linux/sched/isolation.h
@@ -43,7 +43,8 @@ extern const struct cpumask *housekeeping_cpumask(enum hk_type type);
 extern bool housekeeping_enabled(enum hk_type type);
 extern void housekeeping_affine(struct task_struct *t, enum hk_type type);
 extern bool housekeeping_test_cpu(int cpu, enum hk_type type);
-extern int housekeeping_update(struct cpumask *isol_mask);
+extern struct cpumask *housekeeping_publish(struct cpumask *isol_mask);
+extern void housekeeping_update(struct cpumask *isol_mask, struct cpumask *old);
 extern void __init housekeeping_init(void);
 
 #else
@@ -71,7 +72,8 @@ static inline bool housekeeping_test_cpu(int cpu, enum hk_type type)
 	return true;
 }
 
-static inline int housekeeping_update(struct cpumask *isol_mask) { return 0; }
+static inline struct cpumask *housekeeping_publish(struct cpumask *isol_mask) { return NULL; }
+static inline void housekeeping_update(struct cpumask *isol_mask, struct cpumask *old) { }
 static inline void housekeeping_init(void) { }
 #endif /* CONFIG_CPU_ISOLATION */
 
diff --git a/kernel/cgroup/cpuset.c b/kernel/cgroup/cpuset.c
index 8a8a424a389f3..1673bb25a797b 100644
--- a/kernel/cgroup/cpuset.c
+++ b/kernel/cgroup/cpuset.c
@@ -1472,17 +1472,21 @@ static void cpuset_update_sd_hk_unlock(void)
 		rebuild_sched_domains_locked();
 
 	if (update_housekeeping) {
+		struct cpumask *old;
+
 		update_housekeeping = false;
 		cpumask_copy(isolated_hk_cpus, isolated_cpus);
 
 		/*
-		 * housekeeping_update() is now called without holding
-		 * cpus_read_lock and cpuset_mutex. Only cpuset_top_mutex
-		 * is still being held for mutual exclusion.
+		 * Publish the new cpumask with cpus_read_lock and cpuset_mutex
+		 * held, but call housekeeping_update() without them. Only
+		 * cpuset_top_mutex is still being held for mutual exclusion.
 		 */
+		old = housekeeping_publish(isolated_hk_cpus);
 		mutex_unlock(&cpuset_mutex);
 		cpus_read_unlock();
-		WARN_ON_ONCE(housekeeping_update(isolated_hk_cpus));
+		if (!WARN_ON_ONCE(IS_ERR(old)))
+			housekeeping_update(isolated_hk_cpus, old);
 		mutex_unlock(&cpuset_top_mutex);
 	} else {
 		cpuset_full_unlock();
diff --git a/kernel/sched/isolation.c b/kernel/sched/isolation.c
index 156025ef81b75..9e202269e42f6 100644
--- a/kernel/sched/isolation.c
+++ b/kernel/sched/isolation.c
@@ -120,23 +120,26 @@ bool housekeeping_test_cpu(int cpu, enum hk_type type)
 }
 EXPORT_SYMBOL_GPL(housekeeping_test_cpu);
 
-int housekeeping_update(struct cpumask *isol_mask)
+/* Called with cpus_read_lock and cpuset_mutex held */
+struct cpumask *housekeeping_publish(struct cpumask *isol_mask)
 {
 	struct cpumask *trial, *old = NULL;
-	int err;
+
+	lockdep_assert_cpus_held();
+	lockdep_assert_cpuset_lock_held();
 
 	trial = kmalloc(cpumask_size(), GFP_KERNEL);
 	if (!trial)
-		return -ENOMEM;
+		return ERR_PTR(-ENOMEM);
 
 	cpumask_andnot(trial, housekeeping_cpumask(HK_TYPE_DOMAIN_BOOT), isol_mask);
 	if (!cpumask_intersects(trial, cpu_online_mask)) {
 		kfree(trial);
-		return -EINVAL;
+		return ERR_PTR(-EINVAL);
 	}
 
 	if (!housekeeping.flags)
-		static_branch_enable(&housekeeping_overridden);
+		static_branch_enable_cpuslocked(&housekeeping_overridden);
 
 	if (housekeeping.flags & HK_FLAG_DOMAIN)
 		old = housekeeping_cpumask_dereference(HK_TYPE_DOMAIN);
@@ -144,6 +147,14 @@ int housekeeping_update(struct cpumask *isol_mask)
 		WRITE_ONCE(housekeeping.flags, housekeeping.flags | HK_FLAG_DOMAIN);
 	rcu_assign_pointer(housekeeping.cpumasks[HK_TYPE_DOMAIN], trial);
 
+	return old;
+}
+
+/* Called without cpus_read_lock and cpuset_mutex held */
+void housekeeping_update(struct cpumask *isol_mask, struct cpumask *old)
+{
+	int err;
+
 	synchronize_rcu();
 
 	pci_probe_flush_workqueue();
@@ -160,8 +171,6 @@ int housekeeping_update(struct cpumask *isol_mask)
 	WARN_ON_ONCE(err < 0);
 
 	kfree(old);
-
-	return 0;
 }
 
 void __init housekeeping_init(void)
-- 
2.34.1


  reply	other threads:[~2026-11-17  8:39 UTC|newest]

Thread overview: 8+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-17  5:18 [PATCH v2] sched/isolation: Enable cpuset_mutex/cpus_read_lock synchronization before freeing old housekeeping cpumask Waiman Long
2026-11-17  6:43 ` Guopeng Zhang
2026-11-17  8:34 ` Ridong Chen
2026-11-17  8:39   ` Ridong [this message]
2026-11-17 16:15     ` [PATCH] sched/isolation: Publish new HK_TYPE_DOMAIN cpumask under cpuset_mutex Waiman Long
2026-11-18  0:03       ` Ridong Chen
2026-11-17 21:18     ` Tejun Heo
2026-11-17 16:02   ` [PATCH v2] sched/isolation: Enable cpuset_mutex/cpus_read_lock synchronization before freeing old housekeeping cpumask Waiman Long

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=20261117083915.2971979-1-ridong.chen@linux.dev \
    --to=ridong.chen@linux.dev \
    --cc=bsegall@google.com \
    --cc=cgroups@vger.kernel.org \
    --cc=chenridong@xiaomi.com \
    --cc=dietmar.eggemann@arm.com \
    --cc=frederic@kernel.org \
    --cc=guopeng.zhang@linux.dev \
    --cc=hannes@cmpxchg.org \
    --cc=juri.lelli@redhat.com \
    --cc=kprateek.nayak@amd.com \
    --cc=linux-kernel@vger.kernel.org \
    --cc=longman@redhat.com \
    --cc=mathieu.desnoyers@efficios.com \
    --cc=mgorman@suse.de \
    --cc=mingo@redhat.com \
    --cc=mkoutny@suse.com \
    --cc=peterz@infradead.org \
    --cc=rostedt@goodmis.org \
    --cc=tj@kernel.org \
    --cc=vincent.guittot@linaro.org \
    --cc=vschneid@redhat.com \
    /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 an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.