cpuset: Allow to modify isolcpus through cpuset

kernel/sched/isolation.c +6 -0

+// Only support HK_FLAG_DOMAIN for now
+// TODO: propagate the changes through all interested subsystems:
+// workqueues, net, pci; ...
+void housekeeping_cpumask_set(struct cpumask *mask, enum hk_flags flags)
+{
+	/* Only HK_FLAG_DOMAIN change supported for now */

Add a new cpuset.isolation_mask file in order to be able to modify the housekeeping cpumask for each individual isolation feature on runtime. In the future this will include nohz_full, unbound timers, unbound workqueues, unbound kthreads, managed irqs, etc...

Start with supporting domain exclusion and CPUs passed through "isolcpus=".

The cpuset.isolation_mask defaults to 0. Setting it to 1 will exclude the given cpuset from the domains (they will be attached to NULL domain). As long as a CPU is part of any cpuset with cpuset.isolation_mask set to 1, it will remain isolated even if it overlaps with another cpuset that has cpuset.isolation_mask set to 0. The same applies to parent and subdirectories.

If a cpuset is a subset of "isolcpus=", it automatically maps it and cpuset.isolation_mask will be set to 1. This subset is then cleared from the initial "isolcpus=" mask. The user is then free to override cpuset.isolation_mask to 0 in order to revert the effect of "isolcpus=".

Here is an example of use where the CPU 7 has been isolated on boot and get re-attached to domains later from cpuset:

	$ cat /proc/cmdline
		isolcpus=7
	$ cd /sys/fs/cgroup/cpuset
	$ mkdir cpu7
	$ cd cpu7
	$ cat cpuset.cpus
		0-7
	$ cat cpuset.isolation_mask
		0
	$ ls /sys/kernel/debug/domains/cpu7	# empty because isolcpus=7
	$ echo 7 > cpuset.cpus
	$ cat cpuset.isolation_mask	# isolcpus subset automatically mapped
		1
	$ echo 0 > cpuset.isolation_mask
	$ ls /sys/kernel/debug/domains/cpu7/
		domain0  domain1

CHECKME: Should we have individual cpuset.isolation.$feature files for
each isolation feature instead of a single mask file?

CHECKME: The scheduler is unhappy when _every_ CPUs are isolated

Signed-off-by Frederic Weisbecker <[email protected]>

Cc Thomas Gleixner <[email protected]>

Cc Juri Lelli <[email protected]>

Cc Marcelo Tosatti <[email protected]>

Cc Nitesh Lal <[email protected]>

Cc Nicolas Saenz <[email protected]>

Cc Peter Zijlstra <[email protected]>

Cc Christoph Lameter <[email protected]>

Cc Tejun Heo <[email protected]>

Cc Zefan Li <[email protected]>

Cc Alex Belits <[email protected]>

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

kernel/cgroup/cpuset.c +107 -4

index adb5190c4429..ecb63be04408 100644
@@ -82,6 +82,7 @@ struct cpuset {
 	struct cgroup_subsys_state css;
 
 	unsigned long flags;		/* "unsigned long" so bitops work */
+	unsigned long isol_flags;
 
 	/*
 	 * On default hierarchy:

@@ -258,6 +259,17 @@ static inline int is_spread_slab(const struct cpuset *cs)
 	return test_bit(CS_SPREAD_SLAB, &cs->flags);
 }
 
+/* bits in struct cpuset flags field */
+typedef enum {
+	CS_ISOL_DOMAIN,
+	CS_ISOL_MAX
+} isol_flagbits_t;
+
+static inline int is_isol_domain(const struct cpuset *cs)
+{
+	return test_bit(CS_ISOL_DOMAIN, &cs->isol_flags);
+}
+
 static inline int is_partition_root(const struct cpuset *cs)
 {
 	return cs->partition_root_state > 0;

@@ -269,6 +281,13 @@ static struct cpuset top_cpuset = {
 	.partition_root_state = PRS_ENABLED,
 };
 
+/*
+ * CPUs passed through "isolcpus=" on boot, waiting to be mounted
+ * as soon as we meet a cpuset directory whose cpus_allowed is a
+ * subset of "isolcpus="
+ */
+static cpumask_var_t unmounted_isolcpus_mask;
+
 /**
  * cpuset_for_each_child - traverse online children of a cpuset
  * @child_cs: loop cursor pointing to the current child

@@ -681,6 +700,39 @@ static inline int nr_cpusets(void)
 	return static_key_count(&cpusets_enabled_key.key) + 1;
 }
 
+static int update_domain_housekeeping_mask(void)
+{
+	struct cpuset *cp;	/* top-down scan of cpusets */
+	struct cgroup_subsys_state *pos_css;
+	cpumask_var_t domain_mask;
+
+	if (!zalloc_cpumask_var(&domain_mask, GFP_KERNEL))
+		return -ENOMEM;
+
+	cpumask_andnot(domain_mask, cpu_possible_mask, unmounted_isolcpus_mask);
+
+	rcu_read_lock();
+	cpuset_for_each_descendant_pre(cp, pos_css, &top_cpuset) {
+		if (is_isol_domain(cp))
+			cpumask_andnot(domain_mask, domain_mask, cp->cpus_allowed);
+
+		if (cpumask_subset(cp->cpus_allowed, unmounted_isolcpus_mask)) {
+			unsigned long flags;
+			cpumask_andnot(unmounted_isolcpus_mask, unmounted_isolcpus_mask,
+				       cp->cpus_allowed);
+			spin_lock_irqsave(&callback_lock, flags);
+			cp->isol_flags |= BIT(CS_ISOL_DOMAIN);
+			spin_unlock_irqrestore(&callback_lock, flags);
+		}
+	}
+	rcu_read_unlock();
+
+	housekeeping_cpumask_set(domain_mask, HK_FLAG_DOMAIN);
+	free_cpumask_var(domain_mask);
+
+	return 0;
+}
+
 /*
  * generate_sched_domains()
  *

@@ -741,6 +793,7 @@ static int generate_sched_domains(cpumask_var_t **domains,
 	struct cpuset **csa;	/* array of all cpuset ptrs */
 	int csn;		/* how many cpuset ptrs in csa so far */
 	int i, j, k;		/* indices for partition finding loops */
+	int err;
 	cpumask_var_t *doms;	/* resulting partition; i.e. sched domains */
 	struct sched_domain_attr *dattr;  /* attributes for custom domains */
 	int ndoms = 0;		/* number of sched domains in result */

@@ -752,6 +805,10 @@ static int generate_sched_domains(cpumask_var_t **domains,
 	dattr = NULL;
 	csa = NULL;
 
+	err = update_domain_housekeeping_mask();
+	if (err < 0)
+		pr_err("Can't update housekeeping cpumask\n");
+
 	/* Special case for the 99% of systems with one, full, sched domain */
 	if (root_load_balance && !top_cpuset.nr_subparts_cpus) {
 		ndoms = 1;

@@ -1449,7 +1506,7 @@ static void update_cpumasks_hier(struct cpuset *cs, struct tmpmasks *tmp)
 		 * root as well.
 		 */
 		if (!cpumask_empty(cp->cpus_allowed) &&
-		    is_sched_load_balance(cp) &&
+		    (is_sched_load_balance(cp) || is_isol_domain(cs)) &&
 		   (!cgroup_subsys_on_dfl(cpuset_cgrp_subsys) ||
 		    is_partition_root(cp)))
 			need_rebuild_sched_domains = true;

@@ -1935,6 +1992,30 @@ static int update_flag(cpuset_flagbits_t bit, struct cpuset *cs,
 	return err;
 }
 
+/*
+ * update_isol_flags - read a 0 or a 1 in a file and update associated isol flag
+ * mask:	the new mask value to apply (see isol_flagbits_t)
+ * cs:		the cpuset to update
+ *
+ * Call with cpuset_mutex held.
+ */
+static int update_isol_flags(struct cpuset *cs, u64 mask)
+{
+	unsigned long old_mask = cs->isol_flags;
+
+	if (mask & ~(BIT_ULL(CS_ISOL_MAX) - 1))
+		return -EINVAL;
+
+	spin_lock_irq(&callback_lock);
+	cs->isol_flags = (unsigned long)mask;
+	spin_unlock_irq(&callback_lock);
+
+	if (mask ^ old_mask)
+		rebuild_sched_domains_locked();
+
+	return 0;
+}
+
 /*
  * update_prstate - update partititon_root_state
  * cs:	the cpuset to update

@@ -2273,6 +2354,9 @@ typedef enum {
 	FILE_MEMORY_PRESSURE,
 	FILE_SPREAD_PAGE,
 	FILE_SPREAD_SLAB,
+//CHECKME: should we have individual cpuset.isolation.$feature files
+//instead of a mask of features in a single file?
+	FILE_ISOLATION_MASK,
 } cpuset_filetype_t;
 
 static int cpuset_write_u64(struct cgroup_subsys_state *css, struct cftype *cft,

@@ -2314,6 +2398,9 @@ static int cpuset_write_u64(struct cgroup_subsys_state *css, struct cftype *cft,
 	case FILE_SPREAD_SLAB:
 		retval = update_flag(CS_SPREAD_SLAB, cs, val);
 		break;
+	case FILE_ISOLATION_MASK:
+		retval = update_isol_flags(cs, val);
+		break;
 	default:
 		retval = -EINVAL;
 		break;

@@ -2481,6 +2568,8 @@ static u64 cpuset_read_u64(struct cgroup_subsys_state *css, struct cftype *cft)
 		return is_spread_page(cs);
 	case FILE_SPREAD_SLAB:
 		return is_spread_slab(cs);
+	case FILE_ISOLATION_MASK:
+		return cs->isol_flags;
 	default:
 		BUG();
 	}

@@ -2658,6 +2747,13 @@ static struct cftype legacy_files[] = {
 		.private = FILE_MEMORY_PRESSURE_ENABLED,
 	},
 
+	{
+		.name = "isolation_mask",
+		.read_u64 = cpuset_read_u64,
+		.write_u64 = cpuset_write_u64,
+		.private = FILE_ISOLATION_MASK,
+	},
+
 	{ }	/* terminate */
 };
 

@@ -2834,9 +2930,12 @@ static void cpuset_css_offline(struct cgroup_subsys_state *css)
 	if (is_partition_root(cs))
 		update_prstate(cs, 0);
 
-	if (!cgroup_subsys_on_dfl(cpuset_cgrp_subsys) &&
-	    is_sched_load_balance(cs))
-		update_flag(CS_SCHED_LOAD_BALANCE, cs, 0);
+	if (!cgroup_subsys_on_dfl(cpuset_cgrp_subsys)) {
+		if (is_sched_load_balance(cs))
+			update_flag(CS_SCHED_LOAD_BALANCE, cs, 0);
+		if (is_isol_domain(cs))
+			update_isol_flags(cs, cs->isol_flags & ~BIT(CS_ISOL_DOMAIN));
+	}
 
 	if (cs->use_parent_ecpus) {
 		struct cpuset *parent = parent_cs(cs);

@@ -2873,6 +2972,9 @@ static void cpuset_bind(struct cgroup_subsys_state *root_css)
 		top_cpuset.mems_allowed = top_cpuset.effective_mems;
 	}
 
+	cpumask_andnot(unmounted_isolcpus_mask, cpu_possible_mask,
+		       housekeeping_cpumask(HK_FLAG_DOMAIN));
+
 	spin_unlock_irq(&callback_lock);
 	percpu_up_write(&cpuset_rwsem);
 }

@@ -2932,6 +3034,7 @@ int __init cpuset_init(void)
 	top_cpuset.relax_domain_level = -1;
 
 	BUG_ON(!alloc_cpumask_var(&cpus_attach, GFP_KERNEL));
+	BUG_ON(!alloc_cpumask_var(&unmounted_isolcpus_mask, GFP_KERNEL));
 
 	return 0;
 }

Signature · 1 line

2.25.1

Quoted 7 lines · Frederic Weisbecker

Add a new cpuset.isolation_mask file in order to be able to modify the housekeeping cpumask for each individual isolation feature on runtime. In the future this will include nohz_full, unbound timers, unbound workqueues, unbound kthreads, managed irqs, etc...

Start with supporting domain exclusion and CPUs passed through "isolcpus=".

It is possible to just add return -ENOTSUPPORTED for the features whose support is not present?

Quoted 3 lines

CHECKME: Should we have individual cpuset.isolation.$feature files for
each isolation feature instead of a single mask file?

Yes, guess that is useful, for example due to the -ENOTSUPPORTED comment above.

Guarantees on updates
=====================

Perhaps start with a document with:

On return to the write to the cpumask file, what are the guarantees?

For example, for kthread it is that any kernel threads from that point on should start with the new mask. Therefore userspace should respect the order:

1) Change kthread mask.
2) Move threads.

Updates to interface
====================

Also, thinking about updates to the interface (which today are one cpumask per isolation feature) might be useful. What can happen:

1) New isolation feature is added, feature name added to the interface.

Userspace must support new filename. If not there, then thats an old kernel without support for it.

2) If an isolation feature is removed, a file will be gone. What should be the behaviour there? Remove the file? (userspace should probably ignore the failure in that case?) (then features names should not be reused, as that can confuse #1 above).

Or maybe have a versioned scheme?

Quoted 6 lines · Marcelo Tosatti

Quoted 5 lines · Frederic Weisbecker

Add a new cpuset.isolation_mask file in order to be able to modify the housekeeping cpumask for each individual isolation feature on runtime. In the future this will include nohz_full, unbound timers, unbound workqueues, unbound kthreads, managed irqs, etc...

Quoted 5 lines

Quoted 2 lines

Start with supporting domain exclusion and CPUs passed through "isolcpus=".

It is possible to just add return -ENOTSUPPORTED for the features whose support is not present?

Maybe, although that looks like a specialized error for corner cases.

Quoted 12 lines

Quoted 2 lines

CHECKME: Should we have individual cpuset.isolation.$feature files for
each isolation feature instead of a single mask file?

Yes, guess that is useful, for example due to the -ENOTSUPPORTED comment above.

Guarantees on updates
=====================

Perhaps start with a document with:

Quoted 9 lines

On return to the write to the cpumask file, what are the guarantees?

For example, for kthread it is that any kernel threads from that point on should start with the new mask. Therefore userspace should respect the order:

1) Change kthread mask.
2) Move threads.

Yep.

Quoted 8 lines

Updates to interface
====================

Also, thinking about updates to the interface (which today are one cpumask per isolation feature) might be useful. What can happen:

1) New isolation feature is added, feature name added to the interface.

Quoted 7 lines

Userspace must support new filename. If not there, then thats an old kernel without support for it.

2) If an isolation feature is removed, a file will be gone. What should be the behaviour there? Remove the file? (userspace should probably ignore the failure in that case?) (then features names should not be reused, as that can confuse #1 above).

Heh, yeah that's complicated. I guess we should use one flag per file as that fits well within the current cpuset design. But we must carefully choose the new files to make sure they have the least chances to be useless in the long term.

Quoted 1 line

Or maybe have a versioned scheme?

I suspect we should avoid that at all costs :-)

Thanks!

Add a new cpuset.isolation_mask file in order to be able to modify the housekeeping cpumask for each individual isolation feature on runtime. In the future this will include nohz_full, unbound timers, unbound workqueues, unbound kthreads, managed irqs, etc...

Start with supporting domain exclusion and CPUs passed through "isolcpus=".

The cpuset.isolation_mask defaults to 0. Setting it to 1 will exclude the given cpuset from the domains (they will be attached to NULL domain). As long as a CPU is part of any cpuset with cpuset.isolation_mask set to 1, it will remain isolated even if it overlaps with another cpuset that has cpuset.isolation_mask set to 0. The same applies to parent and subdirectories.

If a cpuset is a subset of "isolcpus=", it automatically maps it and cpuset.isolation_mask will be set to 1. This subset is then cleared from the initial "isolcpus=" mask. The user is then free to override cpuset.isolation_mask to 0 in order to revert the effect of "isolcpus=".

Here is an example of use where the CPU 7 has been isolated on boot and get re-attached to domains later from cpuset:

	$ cat /proc/cmdline
		isolcpus=7
	$ cd /sys/fs/cgroup/cpuset
	$ mkdir cpu7
	$ cd cpu7
	$ cat cpuset.cpus
		0-7
	$ cat cpuset.isolation_mask
		0
	$ ls /sys/kernel/debug/domains/cpu7	# empty because isolcpus=7
	$ echo 7 > cpuset.cpus
	$ cat cpuset.isolation_mask	# isolcpus subset automatically mapped
		1
	$ echo 0 > cpuset.isolation_mask
	$ ls /sys/kernel/debug/domains/cpu7/
		domain0  domain1

Quoted 23 lines · Frederic Weisbecker

Add a new cpuset.isolation_mask file in order to be able to modify the housekeeping cpumask for each individual isolation feature on runtime. In the future this will include nohz_full, unbound timers, unbound workqueues, unbound kthreads, managed irqs, etc...

Start with supporting domain exclusion and CPUs passed through "isolcpus=".

The cpuset.isolation_mask defaults to 0. Setting it to 1 will exclude the given cpuset from the domains (they will be attached to NULL domain). As long as a CPU is part of any cpuset with cpuset.isolation_mask set to 1, it will remain isolated even if it overlaps with another cpuset that has cpuset.isolation_mask set to 0. The same applies to parent and subdirectories.

If a cpuset is a subset of "isolcpus=", it automatically maps it and cpuset.isolation_mask will be set to 1. This subset is then cleared from the initial "isolcpus=" mask. The user is then free to override cpuset.isolation_mask to 0 in order to revert the effect of "isolcpus=".

Here is an example of use where the CPU 7 has been isolated on boot and get re-attached to domains later from cpuset:

Quoted 17 lines

	$ cat /proc/cmdline
		isolcpus=7
	$ cd /sys/fs/cgroup/cpuset
	$ mkdir cpu7
	$ cd cpu7
	$ cat cpuset.cpus
		0-7
	$ cat cpuset.isolation_mask
		0
	$ ls /sys/kernel/debug/domains/cpu7	# empty because isolcpus=7
	$ echo 7 > cpuset.cpus
	$ cat cpuset.isolation_mask	# isolcpus subset automatically mapped
		1
	$ echo 0 > cpuset.isolation_mask
	$ ls /sys/kernel/debug/domains/cpu7/
		domain0  domain1

cpusets already has means to create paritions; why are you creating something else?

Quoted 3 lines · Peter Zijlstra

cpusets already has means to create paritions; why are you creating something else?

I was about to answer that the semantics of isolcpus, which reference a NULL domain, are different from SD_LOAD_BALANCE implied by cpuset.sched_load_balance. But then I realize that SD_LOAD_BALANCE has been removed.

How cpuset.sched_load_balance is implemented then? Commit e669ac8ab952df2f07dee1e1efbf40647d6de332 ("sched: Remove checks against SD_LOAD_BALANCE") advertize that setting cpuset.sched_load_balance to 0 ends up creating NULL domain but that's not what I get. For example if I mount a single cpuset root (no other cpuset mountpoints):

$ mount -t cgroup none ./cpuset -o cpuset
$ cd cpuset
$ cat cpuset.cpus
0-7
$ cat cpuset.sched_load_balance
1
$ echo 0 > cpuset.sched_load_balance
$ ls /sys/kernel/debug/domains/cpu1/
domain0  domain1

I still get the domains on all CPUs...

Quoted 26 lines · Frederic Weisbecker

Quoted 3 lines · Peter Zijlstra

cpusets already has means to create paritions; why are you creating something else?

I was about to answer that the semantics of isolcpus, which reference a NULL domain, are different from SD_LOAD_BALANCE implied by cpuset.sched_load_balance. But then I realize that SD_LOAD_BALANCE has been removed.

How cpuset.sched_load_balance is implemented then? Commit e669ac8ab952df2f07dee1e1efbf40647d6de332 ("sched: Remove checks against SD_LOAD_BALANCE") advertize that setting cpuset.sched_load_balance to 0 ends up creating NULL domain but that's not what I get. For example if I mount a single cpuset root (no other cpuset mountpoints):

$ mount -t cgroup none ./cpuset -o cpuset
$ cd cpuset
$ cat cpuset.cpus
0-7
$ cat cpuset.sched_load_balance
1
$ echo 0 > cpuset.sched_load_balance
$ ls /sys/kernel/debug/domains/cpu1/
domain0  domain1

Quoted 1 line

I still get the domains on all CPUs...

Huh. That's on v5.14-rc1 with an automounted cpuset:

$ cat /sys/fs/cgroup/cpuset/cpuset.cpus
0-5
$ cat /sys/fs/cgroup/cpuset/cpuset.sched_load_balance
1

$ ls /sys/kernel/debug/sched/domains/cpu*
/sys/kernel/debug/sched/domains/cpu0:
domain0  domain1

/sys/kernel/debug/sched/domains/cpu1:
domain0 domain1

/sys/kernel/debug/sched/domains/cpu2:
domain0 domain1

/sys/kernel/debug/sched/domains/cpu3:
domain0 domain1

/sys/kernel/debug/sched/domains/cpu4:
domain0 domain1

/sys/kernel/debug/sched/domains/cpu5:
domain0 domain1

$ echo 0 > /sys/fs/cgroup/cpuset/cpuset.sched_load_balance
$ ls /sys/kernel/debug/sched/domains/cpu*
/sys/kernel/debug/sched/domains/cpu0:

/sys/kernel/debug/sched/domains/cpu1:

/sys/kernel/debug/sched/domains/cpu2:

/sys/kernel/debug/sched/domains/cpu3:

/sys/kernel/debug/sched/domains/cpu4:

/sys/kernel/debug/sched/domains/cpu5:

I also checked that you can keep cpuset.sched_load_balance=0 at the root and create exclusive child cpusets with different values of sched_load_balance, giving you some CPUs attached to the NULL domain and some others with a sched_domain hierarchy that stays within the cpuset span.

Quoted 2 lines · Peter Zijlstra

cpusets already has means to create paritions; why are you creating something else?

I was about to answer that the semantics of isolcpus, which reference a NULL domain, are different from SD_LOAD_BALANCE implied by cpuset.sched_load_balance. But then I realize that SD_LOAD_BALANCE has been removed.

How cpuset.sched_load_balance is implemented then? Commit e669ac8ab952df2f07dee1e1efbf40647d6de332 ("sched: Remove checks against SD_LOAD_BALANCE") advertize that setting cpuset.sched_load_balance to 0 ends up creating NULL domain but that's not what I get. For example if I mount a single cpuset root (no other cpuset mountpoints):

$ mount -t cgroup none ./cpuset -o cpuset
$ cd cpuset
$ cat cpuset.cpus
0-7
$ cat cpuset.sched_load_balance
1
$ echo 0 > cpuset.sched_load_balance
$ ls /sys/kernel/debug/domains/cpu1/
domain0  domain1

I still get the domains on all CPUs...

Quoted 10 lines · Frederic Weisbecker

Quoted 2 lines · Peter Zijlstra

cpusets already has means to create paritions; why are you creating something else?

I was about to answer that the semantics of isolcpus, which reference a NULL domain, are different from SD_LOAD_BALANCE implied by cpuset.sched_load_balance. But then I realize that SD_LOAD_BALANCE has been removed.

Quoted 5 lines

How cpuset.sched_load_balance is implemented then? Commit e669ac8ab952df2f07dee1e1efbf40647d6de332 ("sched: Remove checks against SD_LOAD_BALANCE") advertize that setting cpuset.sched_load_balance to 0 ends up creating NULL domain but that's not what I get. For example if I mount a single cpuset root (no other cpuset mountpoints):

SD_LOAD_BALANCE was only for when you wanted to stop balancing inside a domain tree. That no longer happens (and hasn't for a *long* time). Cpusets simply creates multiple domain trees (or the empty one if its just one CPU).

Quoted 11 lines

$ mount -t cgroup none ./cpuset -o cpuset
$ cd cpuset
$ cat cpuset.cpus
0-7
$ cat cpuset.sched_load_balance
1
$ echo 0 > cpuset.sched_load_balance
$ ls /sys/kernel/debug/domains/cpu1/
domain0  domain1

Quoted 1 line

I still get the domains on all CPUs...

(note, that's the cgroup-v1 interface, the cgroup-v2 interface is significantly different)

I'd suggest doing: echo 1 > /debug/sched/verbose, if I do the above I get:

[1290784.889705] CPU0 attaching NULL sched-domain.
[1290784.894830] CPU1 attaching NULL sched-domain.

The fact that "isolcpus=" behaviour can't be modified at runtime is an eternal source of discussion and debate opposing a useful feature against a terrible interface.

I've long since tried to figure out a proper way to control this at runtime using cpusets, which isn't easy as a boot time single cpumask is difficult to map to a hierarchy of cpusets that can even overlap.

The idea here is to map the boot-set isolation behaviour to any cpuset directory whose cpumask is a subset of "isolcpus=". I let you browse for details on the last patch.

Note this is still WIP and half-baked, but I figured it's important to validate the interface early.

Quoted 7 lines · Frederic Weisbecker

The fact that "isolcpus=" behaviour can't be modified at runtime is an eternal source of discussion and debate opposing a useful feature against a terrible interface.

I've long since tried to figure out a proper way to control this at runtime using cpusets, which isn't easy as a boot time single cpumask is difficult to map to a hierarchy of cpusets that can even overlap.

I have a cpuset patch that allow disabling of load balancing in a cgroup-v2 setting:

https://lore.kernel.org/lkml/20210621184924.27493-1-longman-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org/

The idea of cpuset partition is that there will be no overlap of cpus in different partitions. So there will be no confusion whether a cpu is load-balanced or not.

Quoted 8 lines

The idea here is to map the boot-set isolation behaviour to any cpuset directory whose cpumask is a subset of "isolcpus=". I let you browse for details on the last patch.

Note this is still WIP and half-baked, but I figured it's important to validate the interface early.

Using different cpumasks for different isolated properties is the easy part. The hard part is to make different subsystems to change their behavior as the isolation masks change dynamically at run time. Currently, they check the housekeeping cpumask only at boot time or when certain events happen.

Cheers,
Longman