cgroup/cpuset: Fix partition CPU ownership and isolation accounting

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] Removing the check for /sys/devices/system/cpu/isolated drops critical test coverage for the dynamically updated housekeeping mask. --

--- Patch [1]: [PATCH 01/17] selftests/cgroup: Drop invalid boot isolation comparison --- commit 9327a9b65fdcaad904f3dc133a330232cb860c67
Author: Guopeng Zhang <[email protected]>
selftests/cgroup: Drop invalid boot isolation comparison

This commit removes the comparison between the cgroup cpuset.cpus.isolated mask and the housekeeping mask at /sys/devices/system/cpu/isolated in the test_cpuset_prs.sh selftest. The change is intended to fix test failures when isolcpus=domain is present by removing the HKICPUS read and comparison.

Quoted 4 lines

tools/testing/selftests/cgroup/test_cpuset_prs.sh +0 -0

index da8f7b9201784..fdb3185570d40 100755

[ ... ]

tools/testing/selftests/cgroup/test_cpuset_prs.sh check_isolcpus() · line 842

Quoted 9 lines

tools/testing/selftests/cgroup/test_cpuset_prs.sh +0 -5

@@ -835,11 +834,6 @@ check_isolcpus()
 	ISOLCPUS=
 	EXPECTED_ISOLCPUS=$EXPECTED_SDOMAIN
 
-	#
-	# The inverse of HK_TYPE_DOMAIN cpumask in $HKICPUS should match $ISOLCPUS
-	#
-	[[ "$ISOLCPUS" != "$HKICPUS" ]] && return 1
-

[Severity: Medium]
Does removing this check completely drop critical test coverage for the dynamically updated housekeeping mask?

Commit 6df415aa46ec specifically deferred housekeeping_update() execution to a workqueue. By removing this comparison, the test no longer verifies that those deferred updates correctly apply the isolated CPUs to the housekeeping subsystem.

Instead of removing the check entirely, could we fix it by re-reading HKICPUS inside a retry loop and comparing it against EXPECTED_ISOLCPUS?

Quoted 3 lines

tools/testing/selftests/cgroup/test_cpuset_prs.sh +0 -0

 	#
 	# Use the sched domain in debugfs to check isolated CPUs, if available
 	#

From: Guopeng Zhang <[email protected]>

effective_xcpus includes CPUs granted to valid child partitions. Passing the whole mask to isolated_cpus_update() during a root-to-isolated or isolated-to-root change applies the parent's new state to child-owned CPUs as well.

Build a mask of CPUs owned by the partition by subtracting the effective_xcpus of valid children. Use this mask when updating isolated_cpus for a partition type change.

Fixes 11e5f407b64a ("cgroup/cpuset: Keep track of CPUs in isolated partitions")

Signed-off-by Guopeng Zhang <[email protected]>

---
  kernel/cgroup/cpuset.c | 30 ++++++++++++++++++++++++++++--
  1 file changed, 28 insertions(+), 2 deletions(-)

kernel/cgroup/cpuset.c +27 -1

index 2538faac9aba..468272baadb2 100644
@@ -2155,6 +2155,30 @@ static void compute_partition_effective_cpumask(struct cpuset *cs,
  	rcu_read_unlock();
  }
 
+/*
+ * Compute CPUs owned directly by a partition.
+ *
+ * effective_xcpus includes CPUs granted to valid child partitions. Exclude
+ * those CPUs when changing only this partition's type.
+ */
+static void compute_partition_owned_cpumask(struct cpuset *cs,
+					    struct cpumask *owned_cpus)
+{
+	struct cgroup_subsys_state *css;
+	struct cpuset *child;
+
+	lockdep_assert_held(&cpuset_mutex);
+	cpumask_copy(owned_cpus, cs->effective_xcpus);
+
+	rcu_read_lock();
+	cpuset_for_each_child(child, css, cs) {
+		if (is_partition_valid(child))
+			cpumask_andnot(owned_cpus, owned_cpus,
+				       child->effective_xcpus);
+	}
+	rcu_read_unlock();
+}
+
  /*
   * update_cpumasks_hier - Update effective cpumasks and tasks in the subtree
   * @cs:  the cpuset to consider

@@ -2990,8 +3014,10 @@ static int update_prstate(struct cpuset *cs, int new_prs)
  	} else if (old_prs && new_prs) {
  		/*
  		 * A change in load balance state only, no change in cpumasks.
-		 * Need to update isolated_cpus.
+		 * Need to update isolated_cpus for CPUs owned by this partition,
+		 * excluding CPUs distributed to valid child partitions.
  		 */
+		compute_partition_owned_cpumask(cs, tmpmask.new_cpus);
  		if (((new_prs == PRS_ISOLATED) &&
  		     !isolated_cpus_can_update(cs->effective_xcpus, NULL)) ||
  		    prstate_housekeeping_conflict(new_prs, cs->effective_xcpus))

Quoted 65 lines · Guopeng Zhang

From: Guopeng Zhang <[email protected]>

effective_xcpus includes CPUs granted to valid child partitions. Passing the whole mask to isolated_cpus_update() during a root-to-isolated or isolated-to-root change applies the parent's new state to child-owned CPUs as well.

Build a mask of CPUs owned by the partition by subtracting the effective_xcpus of valid children. Use this mask when updating isolated_cpus for a partition type change.

Fixes 11e5f407b64a ("cgroup/cpuset: Keep track of CPUs in isolated partitions")

Signed-off-by Guopeng Zhang <[email protected]>

---
  kernel/cgroup/cpuset.c | 30 ++++++++++++++++++++++++++++--

  1 file changed, 28 insertions(+), 2 deletions(-)

kernel/cgroup/cpuset.c +0 -0

index 2538faac9aba..468272baadb2 100644
@@ -2155,6 +2155,30 @@ static void compute_partition_effective_cpumask(struct cpuset *cs,
       rcu_read_unlock();
   }

  +/*
+ * Compute CPUs owned directly by a partition.
+ *
+ * effective_xcpus includes CPUs granted to valid child partitions. Exclude
+ * those CPUs when changing only this partition's type.
+ */

kernel/cgroup/cpuset.c +18 -0

+static void compute_partition_owned_cpumask(struct cpuset *cs,
+                        struct cpumask *owned_cpus)
+{
+    struct cgroup_subsys_state *css;
+    struct cpuset *child;
+
+    lockdep_assert_held(&cpuset_mutex);
+    cpumask_copy(owned_cpus, cs->effective_xcpus);
+
+    rcu_read_lock();
+    cpuset_for_each_child(child, css, cs) {
+        if (is_partition_valid(child))
+            cpumask_andnot(owned_cpus, owned_cpus,
+                       child->effective_xcpus);
+    }
+    rcu_read_unlock();
+}
+

  /*
   * update_cpumasks_hier - Update effective cpumasks and tasks in the subtree
   * @cs:  the cpuset to consider

kernel/cgroup/cpuset.c +3 -1

@@ -2990,8 +3014,10 @@ static int update_prstate(struct cpuset *cs, int new_prs)
       } else if (old_prs && new_prs) {
           /*
            * A change in load balance state only, no change in cpumasks.
-         * Need to update isolated_cpus.
+         * Need to update isolated_cpus for CPUs owned by this partition,
+         * excluding CPUs distributed to valid child partitions.
            */
+        compute_partition_owned_cpumask(cs, tmpmask.new_cpus);

          if (((new_prs == PRS_ISOLATED) && !isolated_cpus_can_update(cs->effective_xcpus, NULL)) || prstate_housekeeping_conflict(new_prs, cs->effective_xcpus))

kernel/cgroup/cpuset.c +0 -0

@@ -3030,7 +3056,7 @@ static int update_prstate(struct cpuset *cs, int new_prs)
       if (!is_partition_valid(cs))

kernel/cgroup/cpuset.c static int update_prstate(struct cpuset *cs, int new_prs) · line 3062

Quoted 6 lines

kernel/cgroup/cpuset.c +1 -1

           reset_partition_data(cs);
       else if (isolcpus_updated)
-        isolated_cpus_update(old_prs, new_prs, cs->effective_xcpus);
+        isolated_cpus_update(old_prs, new_prs, tmpmask.new_cpus);
       spin_unlock_irq(&callback_lock);
         /* Force update if switching back to member & update effective_xcpus */

Your use of tmpmask.new_cpus in isolated_cpus_update() can be problematic. isolcpus_updated can be set when an isolated partition is enabled or disabled. In both cases, tmpmask.new_cpus can be used temporarily. So the content of this temporary cpumask may not be what we want to pass into isolated_cpus_update(). I will suggest you only use tmpmask.new_cpus if it is determined to be coming from partition state transition instead of enabling/disabling of partition.

Cheers,
Longman

From: Guopeng Zhang <[email protected]>

update_prstate() checks effective_xcpus against the housekeeping masks before changing a partition between root and isolated. effective_xcpus also contains CPUs granted to valid child partitions, although those CPUs are not affected by the parent's type change. A child-owned CPU can therefore reject an otherwise valid change.

Run the nohz_full and boot-domain housekeeping checks against the mask of CPUs owned by the partition instead.

Fixes 103b08709e8a ("cgroup/cpuset: Fail if isolated and nohz_full don't leave any housekeeping")

Fixes b1034a690129 ("cgroup/cpuset: Ensure domain isolated CPUs stay in root or isolated partition")

Signed-off-by Guopeng Zhang <[email protected]>

---
  kernel/cgroup/cpuset.c | 4 ++--
  1 file changed, 2 insertions(+), 2 deletions(-)

kernel/cgroup/cpuset.c +0 -0

index 468272baadb2..853942c1afeb 100644

Quoted 27 lines · Guopeng Zhang

From: Guopeng Zhang <[email protected]>

update_prstate() checks effective_xcpus against the housekeeping masks before changing a partition between root and isolated. effective_xcpus also contains CPUs granted to valid child partitions, although those CPUs are not affected by the parent's type change. A child-owned CPU can therefore reject an otherwise valid change.

Run the nohz_full and boot-domain housekeeping checks against the mask of CPUs owned by the partition instead.

Fixes 103b08709e8a ("cgroup/cpuset: Fail if isolated and nohz_full don't leave any housekeeping")

Fixes b1034a690129 ("cgroup/cpuset: Ensure domain isolated CPUs stay in root or isolated partition")

Signed-off-by Guopeng Zhang <[email protected]>

---
  kernel/cgroup/cpuset.c | 4 ++--

  1 file changed, 2 insertions(+), 2 deletions(-)

kernel/cgroup/cpuset.c +0 -0

index 468272baadb2..853942c1afeb 100644
@@ -3019,8 +3019,8 @@ static int update_prstate(struct cpuset *cs, int new_prs)
            */
           compute_partition_owned_cpumask(cs, tmpmask.new_cpus);

          if (((new_prs == PRS_ISOLATED) &&
-             !isolated_cpus_can_update(cs->effective_xcpus, NULL)) ||

Quoted 6 lines

-            prstate_housekeeping_conflict(new_prs, cs->effective_xcpus)) +             !isolated_cpus_can_update(tmpmask.new_cpus, NULL)) || +            prstate_housekeeping_conflict(new_prs, tmpmask.new_cpus)) err = PERR_HKEEPING;
          else
              isolcpus_updated = true;

This can be merged into patch 4. This is basically the same change as in patch 4.

From: Guopeng Zhang <[email protected]>

Create an isolated child which owns a CPU isolated at boot, then change its parent from isolated to root. Check that the change succeeds without altering the child or its isolated CPU.

Signed-off-by Guopeng Zhang <[email protected]>

---
  .../selftests/cgroup/test_cpuset_prs.sh       | 47 +++++++++++++++++++
  1 file changed, 47 insertions(+)

tools/testing/selftests/cgroup/test_cpuset_prs.sh +5 -0

index 9a1cce4807b4..bc8dbb724d5c 100755
@@ -1214,6 +1214,52 @@ test_boot_isolated()
  	echo "$TEST_NAME test PASSED."
  }
 
+#
+# A parent's type change must validate only CPUs owned directly by the parent,
+# not a boot-isolated CPU owned by a valid isolated child partition.
+#
+test_owned_cpus_housekeeping()

Quoted 27 lines · Guopeng Zhang

From: Guopeng Zhang <[email protected]>

Create an isolated child which owns a CPU isolated at boot, then change its parent from isolated to root. Check that the change succeeds without altering the child or its isolated CPU.

Signed-off-by Guopeng Zhang <[email protected]>

---
  .../selftests/cgroup/test_cpuset_prs.sh       | 47 +++++++++++++++++++

  1 file changed, 47 insertions(+)

tools/testing/selftests/cgroup/test_cpuset_prs.sh +0 -0

index 9a1cce4807b4..bc8dbb724d5c 100755
@@ -1214,6 +1214,52 @@ test_boot_isolated()

      echo "$TEST_NAME test PASSED."
  }
  +#

tools/testing/selftests/cgroup/test_cpuset_prs.sh +8 -0

+# A parent's type change must validate only CPUs owned directly by the parent,
+# not a boot-isolated CPU owned by a valid isolated child partition.
+#
+test_owned_cpus_housekeeping()
+{
+    TEST_NAME="Child-owned CPU type change"
+    get_boot_isolated_cpu "$TEST_NAME" || return 0
+    echo "Running $TEST_NAME test ..."

Quoted 6 lines

+
+    cd $CGROUP2/test
+    echo member > cpuset.cpus.partition
+    echo +cpuset > cgroup.subtree_control
+    echo 2,$BOOT_CPU > cpuset.cpus
+    [[ $(cat cpuset.cpus.effective) = "2,$BOOT_CPU" ]] || {

You are using the same BOOT_CPU set up in get_boot_isolated_cpu() in patch 3. That creates an hidden dependency on the order of the tests. I will suggest that you set up BOOT_CPU and  BOOT_CPUS as part of the initialization so the data is available to all the tests that want to use it.

From: Guopeng Zhang <[email protected]>

When a housekeeping check rejects a root-to-isolated or isolated-to-root change, update_prstate() marks the partition invalid but leaves its effective_xcpus allocated. Those CPUs remain missing from the partition which owns the invalidated subtree.

Disable a rejected remote partition with remote_partition_disable(). For a local partition, return effective_xcpus to its parent before recording the invalid state. Use the complete mask because descendants are invalidated along with the parent and their CPUs return at the same time.

Fixes 103b08709e8a ("cgroup/cpuset: Fail if isolated and nohz_full don't leave any housekeeping")

Signed-off-by Guopeng Zhang <[email protected]>

---
  kernel/cgroup/cpuset.c | 15 +++++++++++++--
  1 file changed, 13 insertions(+), 2 deletions(-)

kernel/cgroup/cpuset.c +0 -0

index 853942c1afeb..a616012927be 100644

kernel/cgroup/cpuset.c +2 -0

+		} else {
  			isolcpus_updated = true;
+		}
  	} else {
  		/*
  		 * Switching back to member is always allowed even if it

Quoted 25 lines · Guopeng Zhang

From: Guopeng Zhang <[email protected]>

When a housekeeping check rejects a root-to-isolated or isolated-to-root change, update_prstate() marks the partition invalid but leaves its effective_xcpus allocated. Those CPUs remain missing from the partition which owns the invalidated subtree.

Disable a rejected remote partition with remote_partition_disable(). For a local partition, return effective_xcpus to its parent before recording the invalid state. Use the complete mask because descendants are invalidated along with the parent and their CPUs return at the same time.

Fixes 103b08709e8a ("cgroup/cpuset: Fail if isolated and nohz_full don't leave any housekeeping")

Signed-off-by Guopeng Zhang <[email protected]>

---
  kernel/cgroup/cpuset.c | 15 +++++++++++++--

  1 file changed, 13 insertions(+), 2 deletions(-)

kernel/cgroup/cpuset.c +0 -0

index 853942c1afeb..a616012927be 100644
@@ -3020,10 +3020,21 @@ static int update_prstate(struct cpuset *cs, int new_prs)
           compute_partition_owned_cpumask(cs, tmpmask.new_cpus);

Quoted 8 lines

          if (((new_prs == PRS_ISOLATED) && !isolated_cpus_can_update(tmpmask.new_cpus, NULL)) || -            prstate_housekeeping_conflict(new_prs, tmpmask.new_cpus)) +            prstate_housekeeping_conflict(new_prs, tmpmask.new_cpus)) { err = PERR_HKEEPING;
-        else
+            if (is_remote_partition(cs)) {
+                WRITE_ONCE(cs->prs_err, err);

This WRITE_ONCE() is not necessary as it will be done later in the function.

Quoted 8 lines

+                remote_partition_disable(cs, &tmpmask);
+            } else {
+                spin_lock_irq(&callback_lock);
+                partition_xcpus_del(old_prs, parent, cs->effective_xcpus); +                spin_unlock_irq(&callback_lock);
+                cpuset_update_tasks_cpumask(parent, tmpmask.new_cpus); +                update_sibling_cpumasks(parent, cs, &tmpmask); +            }

This code to disable the partition is duplicating what is being done in the last else clause of the outer if, but in a somewhat different way. That is not good programming practice. You can either jump to the partition disabling code below or separate out the partition disabling code controlled by a separate control flag and set the flag to do it.

Cheers,
Longman

Quoted 6 lines

+        } else {
              isolcpus_updated = true;
+        }
      } else {
          /*
           * Switching back to member is always allowed even if it

From: Guopeng Zhang <[email protected]>

When cpuset.cpus changes, compute_partition_effective_cpumask() builds a new exclusive mask but checks child partitions against cs->effective_xcpus. That field still contains the old mask, so a child that no longer fits can remain valid.

Use new_xcpus for the check. A later partcmd_update() may revisit the newly invalid child. Report PERR_INVCPUS if the child CPUs are outside the parent effective exclusive mask so that this visit does not make the child valid again.

Fixes 0c7f293efc87 ("cgroup/cpuset: Add cpuset.cpus.exclusive.effective for v2")

Signed-off-by Guopeng Zhang <[email protected]>

---
  kernel/cgroup/cpuset.c | 10 +++++++---
  1 file changed, 7 insertions(+), 3 deletions(-)

kernel/cgroup/cpuset.c +0 -2

index b9faadf4af6d..b3e749ede7d1 100644
@@ -1987,12 +1987,16 @@ static int update_parent_effective_cpumask(struct cpuset *cs, int cmd,
  				adding = cpumask_and(tmp->addmask,
  						     cs->effective_xcpus,
  						     parent->effective_xcpus);
-		} else if (is_partition_invalid(cs) && !cpumask_empty(xcpus) &&
-			   cpumask_subset(xcpus, parent->effective_xcpus)) {

Quoted 30 lines · Guopeng Zhang

From: Guopeng Zhang <[email protected]>

When cpuset.cpus changes, compute_partition_effective_cpumask() builds a new exclusive mask but checks child partitions against cs->effective_xcpus. That field still contains the old mask, so a child that no longer fits can remain valid.

Use new_xcpus for the check. A later partcmd_update() may revisit the newly invalid child. Report PERR_INVCPUS if the child CPUs are outside the parent effective exclusive mask so that this visit does not make the child valid again.

Fixes 0c7f293efc87 ("cgroup/cpuset: Add cpuset.cpus.exclusive.effective for v2")

Signed-off-by Guopeng Zhang <[email protected]>

---
  kernel/cgroup/cpuset.c | 10 +++++++---

  1 file changed, 7 insertions(+), 3 deletions(-)

kernel/cgroup/cpuset.c +1 -2

index b9faadf4af6d..b3e749ede7d1 100644
@@ -1987,12 +1987,16 @@ static int update_parent_effective_cpumask(struct cpuset *cs, int cmd,
                   adding = cpumask_and(tmp->addmask,
                                cs->effective_xcpus,
                                parent->effective_xcpus);
-        } else if (is_partition_invalid(cs) && !cpumask_empty(xcpus) &&
-               cpumask_subset(xcpus, parent->effective_xcpus)) {
+        } else if (is_partition_invalid(cs) && !cpumask_empty(xcpus)) {
               struct cgroup_subsys_state *css;

kernel/cgroup/cpuset.c static int update_parent_effective_cpumask(struct cpuset *cs, int cmd, · line 1999

Quoted 7 lines

kernel/cgroup/cpuset.c +4 -0

               struct cpuset *child;
               bool exclusive = true;
   +            if (!cpumask_subset(xcpus, parent->effective_xcpus)) {
+                part_error = PERR_INVCPUS;
+                goto write_error;
+            }
+

A invalid partition means part_error should be set to some error code. This change only makes sure the error code is PERR_INVCPUS. Other than that, I don't see any other tangible change here.

Quoted 6 lines

kernel/cgroup/cpuset.c +0 -0

               /*
                * Convert invalid partition to valid has to
                * pass the cpu exclusivity test.

@@ -2144,7 +2148,7 @@ static void compute_partition_effective_cpumask(struct cpuset *cs,
           WARN_ON_ONCE(is_remote_partition(child));
           WRITE_ONCE(child->prs_err, 0);

Quoted 6 lines

kernel/cgroup/cpuset.c +1 -1

           if (!cpumask_subset(child->effective_xcpus,
-                    cs->effective_xcpus))
+                    new_xcpus))
               WRITE_ONCE(child->prs_err, PERR_INVCPUS);

          else if (populated && cpumask_subset(new_ecpus, child->effective_xcpus))

This hunk should probably be grouped into the same patch making change to compute_partition_effective_cpumask().

From: Guopeng Zhang <[email protected]>

update_prstate() uses effective_xcpus for isolation accounting and housekeeping checks when switching a partition between root and isolated. The mask also includes CPUs granted to valid child partitions. Such a type change can alter isolation accounting for child-owned CPUs or fail a housekeeping check because of a CPU the parent does not own.

A rejected type change can leave CPUs assigned to the invalidated partition instead of returning them to the partition that owns the invalidated subtree. When cpuset.cpus changes, child validation can use the old parent mask, and a remote update can observe stale cpus_allowed when it revisits a cpuset. Direct and propagated invalidation can leave isolated_cpus reflecting the released partition's type instead of the type of the partition receiving its CPUs. Releasing an isolated partition can clear boot-isolated CPUs from isolated_cpus.

Limit type-change checks and accounting to CPUs owned directly by the partition. Preserve boot-isolated CPUs when a partition is released, return CPUs after rejected type changes, validate children against the new parent mask, and publish cpus_allowed before a partition update can revisit the cpuset. Fix isolation accounting during direct and propagated invalidation.

Patch 1 removes an invalid selftest comparison that makes test_cpuset_prs.sh fail when boot-time domain isolation is configured. Each kernel fix is followed by a focused selftest update.

Guopeng Zhang (17):
selftests/cgroup: Drop invalid boot isolation comparison cgroup/cpuset: Preserve boot-isolated CPUs on partition release selftests/cgroup: Test boot-isolated CPU partition release cgroup/cpuset: Limit type-change accounting to owned CPUs selftests/cgroup: Test isolated CPU accounting on type changes cgroup/cpuset: Validate type changes against owned CPUs selftests/cgroup: Test type-change validation with child-owned CPUs cgroup/cpuset: Release CPUs when a type change is rejected selftests/cgroup: Test rejected partition type changes cgroup/cpuset: Fix isolated accounting on direct child invalidation selftests/cgroup: Test isolation accounting on direct child
invalidation
cgroup/cpuset: Invalidate children outside the new CPU mask selftests/cgroup: Test child invalidation after shrinking cpuset.cpus cgroup/cpuset: Publish cpus_allowed before partition updates selftests/cgroup: Test shrinking cpuset.cpus in a remote partition cgroup/cpuset: Fix isolated accounting on propagated invalidation selftests/cgroup: Test isolation accounting on propagated invalidation

  kernel/cgroup/cpuset.c                        | 162 ++++++++++--
  .../selftests/cgroup/test_cpuset_prs.sh       | 231 +++++++++++++++++-
  2 files changed, 361 insertions(+), 32 deletions(-)

base-commit: 6a746cd265aed59107ebdaa9ce039bb832922969

Quoted 53 lines · Guopeng Zhang

From: Guopeng Zhang <[email protected]>

update_prstate() uses effective_xcpus for isolation accounting and housekeeping checks when switching a partition between root and isolated. The mask also includes CPUs granted to valid child partitions. Such a type change can alter isolation accounting for child-owned CPUs or fail a housekeeping check because of a CPU the parent does not own.

A rejected type change can leave CPUs assigned to the invalidated partition instead of returning them to the partition that owns the invalidated subtree. When cpuset.cpus changes, child validation can use the old parent mask, and a remote update can observe stale cpus_allowed when it revisits a cpuset. Direct and propagated invalidation can leave isolated_cpus reflecting the released partition's type instead of the type of the partition receiving its CPUs. Releasing an isolated partition can clear boot-isolated CPUs from isolated_cpus.

Limit type-change checks and accounting to CPUs owned directly by the partition. Preserve boot-isolated CPUs when a partition is released, return CPUs after rejected type changes, validate children against the new parent mask, and publish cpus_allowed before a partition update can revisit the cpuset. Fix isolation accounting during direct and propagated invalidation.

Patch 1 removes an invalid selftest comparison that makes test_cpuset_prs.sh fail when boot-time domain isolation is configured. Each kernel fix is followed by a focused selftest update.

Guopeng Zhang (17):
   selftests/cgroup: Drop invalid boot isolation comparison cgroup/cpuset: Preserve boot-isolated CPUs on partition release selftests/cgroup: Test boot-isolated CPU partition release cgroup/cpuset: Limit type-change accounting to owned CPUs selftests/cgroup: Test isolated CPU accounting on type changes cgroup/cpuset: Validate type changes against owned CPUs selftests/cgroup: Test type-change validation with child-owned CPUs cgroup/cpuset: Release CPUs when a type change is rejected selftests/cgroup: Test rejected partition type changes cgroup/cpuset: Fix isolated accounting on direct child invalidation selftests/cgroup: Test isolation accounting on direct child invalidation
   cgroup/cpuset: Invalidate children outside the new CPU mask selftests/cgroup: Test child invalidation after shrinking cpuset.cpus cgroup/cpuset: Publish cpus_allowed before partition updates selftests/cgroup: Test shrinking cpuset.cpus in a remote partition cgroup/cpuset: Fix isolated accounting on propagated invalidation selftests/cgroup: Test isolation accounting on propagated invalidation

  kernel/cgroup/cpuset.c                        | 162 ++++++++++-- .../selftests/cgroup/test_cpuset_prs.sh       | 231 +++++++++++++++++-

  2 files changed, 361 insertions(+), 32 deletions(-)

Quoted 1 line

base-commit: 6a746cd265aed59107ebdaa9ce039bb832922969

Hi Guopeng,

This is a fairly large series, which may make the review process challenging. I would suggest splitting it into smaller, more focused patches. It would also be very helpful if you could provide a reproducer for each bug you are trying to fix, so that we can verify the issue and the fix more effectively.