Re: [PATCH v2] sched/isolation: Enable cpuset_mutex/cpus_read_lock synchronization before freeing old housekeeping cpumask

From: Waiman Long

Date: Tue Nov 17 2026 - 11:02:26 EST


On 11/17/26 3:34 AM, Ridong Chen wrote:


On 11/17/2026 1:18 PM, Waiman Long wrote:
Commit a84097e625f2 ("cgroup/cpuset: Call housekeeping_update() without
holding cpus_read_lock") adds a new cpuset_top_mutex on top but drops
cpus_read_lock and cpuset_mutex before calling housekeeping_update()
which calls other functions that may acquire cpus_read_lock leading
to a possibility of deadlock if cpus_read_lock isn't dropped before
calling housekeeping_update().

This commit also changes lockdep_is_cpuset_held() to return true if
either cpuset_mutex or cpuset_top_mutex is held. lockdep_is_cpuset_held()
is used by housekeeping_dereference_check() as one of the conditions
that rcu_read_lock() is not needed to access HK_TYPE_DOMAIN
cpumask which can be changed by housekeeping_update() at run
time. The housekeeping_dereference_check() function also uses
lockdep_is_cpus_write_held() as another condition that can skip the
use of rcu_read_lock().

In reality, both cpuset_mutex and cpus_write_lock are now no longer
valid conditions to skip rcu_read_lock(). It is certainly possible
that there can be a parallel housekeeping_update() call going on if
only cpuset_mutex or cpus_write_lock is held. This can lead to a
potential use-after-free situation when HK_TYPE_DOMAIN housekeeping
cpumask is being accessed.

One possible solution is to hold rcu_read_lock for functions that may
be called with only cpuset_mutex or cpus_write_lock is held. Quite a
large number of functions will need to be modified if rcu_read_lock()
has to be added. A far simpler solution is to synchronize with other
cpuset_mutex and cpus_write_lock critical sections before freeing the old
housekeeping cpumask. This will ensure that code within those critical
sections will not have a UaF situation when accessing housekeeping
cpumask. This commit implements the latter solution and make the code
in lockdep_is_cpuset_held() and housekeeping_dereference_check() correct.

Fixes: a84097e625f2 ("cgroup/cpuset: Call housekeeping_update() without holding cpus_read_lock")
Signed-off-by: Waiman Long <longman@xxxxxxxxxx>
---
  kernel/sched/isolation.c | 10 ++++++++++
  1 file changed, 10 insertions(+)

diff --git a/kernel/sched/isolation.c b/kernel/sched/isolation.c
index 156025ef81b7..5634d6a597bd 100644
--- a/kernel/sched/isolation.c
+++ b/kernel/sched/isolation.c
@@ -159,6 +159,16 @@ int housekeeping_update(struct cpumask *isol_mask)
      err = kthreads_update_housekeeping();
      WARN_ON_ONCE(err < 0);
  +    /*
+     * Synchronize with cpuset_mutex and cpus_read_lock to make sure that
+     * cpuset_mutex and cpus_write_lock critical sections afterward will
+     * not have access to the old housekeeping cpumask.
+     */
+    cpus_read_lock();
+    cpuset_lock();
+    cpuset_unlock();
+    cpus_read_unlock();
+
      kfree(old);
        return 0;

Hi Waiman,

Taking the locks and releasing them right away looks a bit odd to me.
It is not obvious what the empty critical section protects until one
reads the commit message.

Let me check that I understand the problem correctly.
housekeeping_dereference_check() lets readers holding cpus_write_lock
or cpuset_mutex access HK_TYPE_DOMAIN without rcu_read_lock(). After
commit a84097e625f2, the pointer is switched and the old cpumask is
freed after cpuset_mutex and cpus_read_lock have been dropped, and
synchronize_rcu() does not wait for those readers. For example:

  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

Here CPU A reads the mask in asym_cpu_capacity_scan() or
dl_get_task_effective_cpus().

If that is right, the root cause is that the pointer is now switched
outside of those locks.

The way that housekeeping cpumask is being accessed is that you are going to either get the old cpumask pointer or the new cpumask pointer.  It won't be a mess-up version. So lock protection is not essential in this regard.

In the case of old pointer being used, the important point is that it cannot be freed while its content is being accessed.

 So instead of adding a lock barrier before
kfree(), how about switching the pointer before the locks are
dropped? housekeeping_update() could be split into two parts:

 - housekeeping_publish(): allocate, check and publish the new mask,
   called with cpus_read_lock and cpuset_mutex held.

 - housekeeping_update(): synchronize_rcu(), the workqueue flushes and
   kfree(old), called after the locks are dropped as it is now.

Then a reader holding cpuset_mutex either finishes before the pointer
is switched, or only sees the new mask:

  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 same applies to cpus_write_lock readers, as cpus_read_lock is held
until the new mask is published. The workqueue flushes still run
without those locks, so the deadlock fixed by a84097e625f2 does not come
back.

That will certainly work too. I choose the current solution as it is more localized instead of spreading out to a large code section. Either one will work.

Cheers,
Longman