Re: [PATCH] sched/isolation: Publish new HK_TYPE_DOMAIN cpumask under cpuset_mutex

From: Ridong Chen

Date: Tue Nov 17 2026 - 19:03:55 EST




On 11/18/2026 12:15 AM, Waiman Long wrote:
On 11/17/26 3:39 AM, Ridong wrote:
From: Ridong Chen <chenridong@xxxxxxxxxx>

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@xxxxxxxxxx>
---
  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)

Yes, that should work too.

Acked-by: Waiman Long <longman@xxxxxxxxxx>

I will let other decide which one do they want.

Thanks.

--
Best regards
Ridong