[RFC PATCH v4 0/4] genirq/cpuhotplug: Adjust managed interrupts according to change of housekeeping cpumask

[RFC PATCH v4 0/4] genirq/cpuhotplug: Adjust managed interrupts according to change of housekeeping cpumask

[Costa Shulyupin]

This series of patches is based on series
isolation: Exclude dynamically isolated CPUs from housekeeping masks:
https://lore.kernel.org/lkml/20240821142312.236970-1-longman@redhat.com/
Its purpose is to exclude dynamically isolated CPUs from some
housekeeping masks so that subsystems that check the housekeeping masks
at run time will not use those isolated CPUs.

However, some of subsystems can use obsolete housekeeping CPU masks.
Therefore, to prevent the use of these isolated CPUs, it is necessary to
explicitly propagate changes of the housekeeping masks to all subsystems
depending on the mask.

Signed-off-by: Costa Shulyupin <costa.shul@redhat.com>

---

v4:
- Use CPU hotplug as recommended by Thomas Gleixner.

v3:
- Address the comments by Thomas Gleixner.

v2:
- Focus in this patch series on managed interrupts only.

Costa Shulyupin (4):
  cgroup/cpuset: Add HK_TYPE_MANAGED_IRQ to HOUSEKEEPING_FLAGS
  genirq/cpuhotplug: Dynamically isolate CPUs from managed interrupts
  cgroup/cpuset: Restart CPUs whose isolated_cpus bits have changed
  DO NOT MERGE: Test CPU isolation from managed interrupts

 MAINTAINERS             |   2 +
 kernel/cgroup/cpuset.c  |  36 +++++++++++
 kernel/irq/cpuhotplug.c |   3 +
 tests/managed_irq.sh    | 135 ++++++++++++++++++++++++++++++++++++++++
 4 files changed, 176 insertions(+)
 create mode 100755 tests/managed_irq.sh

-- 
2.47.0

[RFC PATCH v4 1/4] cgroup/cpuset: Add HK_TYPE_MANAGED_IRQ to HOUSEKEEPING_FLAGS

[Costa Shulyupin]

update_isolation_cpumasks() should also update
housekeeping.cpumasks[HK_TYPE_MANAGED_IRQ]

The patch amends
https://lore.kernel.org/lkml/20240821142312.236970-3-longman@redhat.com/

Signed-off-by: Costa Shulyupin <costa.shul@redhat.com>
---
 kernel/cgroup/cpuset.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/kernel/cgroup/cpuset.c b/kernel/cgroup/cpuset.c
index fb23eee3f18d..570941d782ef 100644
--- a/kernel/cgroup/cpuset.c
+++ b/kernel/cgroup/cpuset.c
@@ -90,6 +90,7 @@ static struct list_head remote_children;
 #define HOUSEKEEPING_FLAGS	(BIT(HK_TYPE_TIMER)  | BIT(HK_TYPE_RCU)  |\
 				 BIT(HK_TYPE_SCHED)  | BIT(HK_TYPE_MISC) |\
 				 BIT(HK_TYPE_DOMAIN) | BIT(HK_TYPE_WQ)   |\
+				 BIT(HK_TYPE_MANAGED_IRQ) |\
 				 BIT(HK_TYPE_KTHREAD))
 
 /*
-- 
2.47.0

[RFC PATCH v4 2/4] genirq/cpuhotplug: Dynamically isolate CPUs from managed interrupts

[Costa Shulyupin]

After change of housekeeping_cpumask(HK_TYPE_MANAGED_IRQ) during runtime
managed interrupts continue to run on isolated CPUs.

Dynamic CPUs isolation is complex task. One of approaches is:
1. Set affected CPUs offline and disable relevant interrupts
2. Change housekeeping_cpumask
3. Set affected CPUs online and enable relevant interrupts

irq_restore_affinity_of_irq() restores managed interrupts
during complex CPU hotplug process of bringing back a CPU online.

Leave the interrupts disabled those affinity doesn't intersect
with new housekeeping_cpumask thereby ensuring isolation
of the CPU from managed intrrupts.

Signed-off-by: Costa Shulyupin <costa.shul@redhat.com>
---
 kernel/irq/cpuhotplug.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/kernel/irq/cpuhotplug.c b/kernel/irq/cpuhotplug.c
index ec2cdcd20bee..839d3e879c0d 100644
--- a/kernel/irq/cpuhotplug.c
+++ b/kernel/irq/cpuhotplug.c
@@ -218,6 +218,9 @@ static void irq_restore_affinity_of_irq(struct irq_desc *desc, unsigned int cpu)
 	if (desc->istate & IRQS_SUSPENDED)
 		return;
 
+	if (!cpumask_intersects(affinity, housekeeping_cpumask(HK_TYPE_MANAGED_IRQ)))
+		return;
+
 	if (irqd_is_managed_and_shutdown(data))
 		irq_startup(desc, IRQ_RESEND, IRQ_START_COND);
 
-- 
2.47.0

[RFC PATCH v4 3/4] cgroup/cpuset: Restart CPUs whose isolated_cpus bits have changed

[Costa Shulyupin]

The goal is to dynamically isolate CPUs to prevent interference
from housekeeping subsystems.

The housekeeping CPU masks, set up by the "isolcpus" and "nohz_full"
boot command line options, are used at boot time to exclude selected
CPUs from running some kernel housekeeping subsystems to minimize
interference with latency sensitive userspace applications such as DPDK.
This options can only be changed with a reboot. This is a problem for
containerized workloads running on OpenShift/Kubernetes where a mix of
low latency and "normal" workloads can be created/destroyed dynamically
and the number of CPUs allocated to each workload is often not known at
boot time.

CPU hotplug can be used to isolate CPUs by restarting related CPUs only,
without complete reboot.

Experimental solution.

Automatically restart changed CPUs when the `isolated_cpus` is modified
through the cgroup/cpuset interface.

No additional manipulation of the CPU online status from userspace is
required, and it remains compatible with existing software.

cpu_device_down()/cpu_device_up() can't be called within subroutines of
cpuset_write_resmask() because it locks `cpu_hotplug_lock` with
cpus_read_lock() but _cpu_down()/_cpu_up() lock `cpu_hotplug_lock` with
cpus_write_lock().

Intuitively the change of `isolated_cpus` should be performed between
cpu_device_down() and cpu_device_up(). Since cpu_device_down(), at
least for managed interrupts, doesn't depends on `isolated_cpus` and
`housekeeping` it is more simple to call cpu_device_down() after change
of `isolated_cpus` and `housekeeping` and cpus_read_unlock().

Signed-off-by: Costa Shulyupin <costa.shul@redhat.com>
---
 kernel/cgroup/cpuset.c | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/kernel/cgroup/cpuset.c b/kernel/cgroup/cpuset.c
index 570941d782ef..d5d2b4036314 100644
--- a/kernel/cgroup/cpuset.c
+++ b/kernel/cgroup/cpuset.c
@@ -3131,6 +3131,27 @@ static void cpuset_attach(struct cgroup_taskset *tset)
 	mutex_unlock(&cpuset_mutex);
 }
 
+/*
+ * Restart CPUs whose isolated_cpus bits have changed.
+ * Enforce subsystems to adopt the new isolated_cpus and housekeeping masks
+ * using CPU hotplug.
+ */
+static void propogate_isolated_cpus_change(struct cpumask *isolated_cpus_prev)
+{
+	unsigned int cpu;
+
+	if (!isolated_cpus_prev)
+		return;
+
+	for_each_online_cpu(cpu) {
+		if (cpumask_test_cpu(cpu, isolated_cpus_prev) !=
+		    cpumask_test_cpu(cpu, isolated_cpus)) {
+			remove_cpu(cpu);
+			add_cpu(cpu);
+		}
+	}
+}
+
 /*
  * Common handling for a write to a "cpus" or "mems" file.
  */
@@ -3138,6 +3159,7 @@ ssize_t cpuset_write_resmask(struct kernfs_open_file *of,
 				    char *buf, size_t nbytes, loff_t off)
 {
 	struct cpuset *cs = css_cs(of_css(of));
+	cpumask_var_t isolated_cpus_prev;
 	struct cpuset *trialcs;
 	int retval = -ENODEV;
 
@@ -3167,6 +3189,12 @@ ssize_t cpuset_write_resmask(struct kernfs_open_file *of,
 
 	cpus_read_lock();
 	mutex_lock(&cpuset_mutex);
+	if (!alloc_cpumask_var(&isolated_cpus_prev, GFP_KERNEL)) {
+		retval = -ENOMEM;
+		goto out_unlock;
+	}
+
+	cpumask_copy(isolated_cpus_prev, isolated_cpus);
 	if (!is_cpuset_online(cs))
 		goto out_unlock;
 
@@ -3200,6 +3228,13 @@ ssize_t cpuset_write_resmask(struct kernfs_open_file *of,
 	kernfs_unbreak_active_protection(of->kn);
 	css_put(&cs->css);
 	flush_workqueue(cpuset_migrate_mm_wq);
+
+	/* If isolated_cpus modified, the change must be propagated
+	 * to all subsystems.
+	 */
+	propogate_isolated_cpus_change(isolated_cpus_prev);
+	free_cpumask_var(isolated_cpus_prev);
+
 	return retval ?: nbytes;
 }
 
-- 
2.47.0

[RFC PATCH v4 4/4] DO NOT MERGE: Test CPU isolation from managed interrupts

[Costa Shulyupin]

Test CPU isolation to ensure it is unaffected by managed interrupts.

Target: irq_restore_affinity_of_irq()

Managed interrupts can be created in various ways. One of them:

qemu-img create -f qcow2 test.qcow2 100M
virtme-ng -v --cpus 4 --rw --user root \
	--qemu-opts '\-drive id=d1,if=none,file=test.qcow2 \
	\-device nvme,id=i1,drive=d1,serial=1,bootindex=2'

Signed-off-by: Costa Shulyupin <costa.shul@redhat.com>

---

v4:
- Remove /sys/devices/system/cpu/cpu$isolate/online

v3:
- No changes

v2:
- use shell script only
---
 MAINTAINERS          |   2 +
 tests/managed_irq.sh | 135 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 137 insertions(+)
 create mode 100755 tests/managed_irq.sh

diff --git a/MAINTAINERS b/MAINTAINERS
index 1240e75ecf4b..4a753c2b34c1 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -26046,3 +26046,5 @@ S:	Buried alive in reporters
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
 F:	*
 F:	*/
+
+# disable warning
diff --git a/tests/managed_irq.sh b/tests/managed_irq.sh
new file mode 100755
index 000000000000..3763183fc987
--- /dev/null
+++ b/tests/managed_irq.sh
@@ -0,0 +1,135 @@
+#!/bin/zsh
+# SPDX-License-Identifier: GPL-2.0
+
+# shell script for testing dynamic isolation of managed interrupts.
+# Target: irq_restore_affinity_of_irq()
+
+# cpu# to isolate
+
+isolate=1
+
+managed_affined=$(
+	cd /sys/kernel/debug/irq/irqs/;
+	grep -l -e "affinity: $isolate$" /dev/null $(grep -l IRQD_AFFINITY_MANAGED *) |
+		head -n1
+)
+grep -l -e "affinity: $isolate$" /dev/null \
+	$(grep -l IRQD_AFFINITY_MANAGED /sys/kernel/debug/irq/irqs/*)
+test_irq=${managed_affined%% *}
+echo test_irq=$test_irq
+
+[ -z $test_irq ] && { echo No managed IRQs found;exit 1}
+
+cp -R /sys/kernel/debug/irq/irqs 0.irqs
+
+# Restart CPUs without changing the isolated cpuset.
+# Setup a baseline (the "control group")
+# to compare against the test of isolated mask.
+
+echo 0 > /sys/devices/system/cpu/cpu$isolate/online
+echo 0 > /sys/devices/system/cpu/cpu3/online
+echo 1 > /sys/devices/system/cpu/cpu$isolate/online
+echo 1 > /sys/devices/system/cpu/cpu3/online
+
+rm -rf baseline.irqs
+cp -R /sys/kernel/debug/irq/irqs baseline.irqs
+
+cd /sys/fs/cgroup/
+echo +cpuset > cgroup.subtree_control
+mkdir -p test
+echo isolated > test/cpuset.cpus.partition
+
+effective_affinity=/proc/irq/$test_irq/effective_affinity
+test_irq_debug=/sys/kernel/debug/irq/irqs/$test_irq
+
+errors=0
+
+check()
+{
+	local _status=$?
+	if [[ $_status == 0 ]]
+	then
+		echo PASS
+	else
+		let errors+=1
+		echo "FAIL #$errors:"
+		cat $test_irq_debug
+	fi
+	return $_status
+}
+
+check_activated()
+{
+	echo "Check normal irq affinity"
+	test 0 -ne $((0x$(cat $effective_affinity) & 1 << $isolate))
+	check
+	grep -q IRQD_ACTIVATED $test_irq_debug
+	check
+	grep -q IRQD_IRQ_STARTED $test_irq_debug
+	check
+	! grep -q IRQD_IRQ_DISABLED $test_irq_debug
+	check
+	! grep -q IRQD_IRQ_MASKED $test_irq_debug
+	check
+	! grep -q IRQD_MANAGED_SHUTDOWN $test_irq_debug
+	check
+}
+
+check_shutdown()
+{
+	echo "Check that irq affinity doesn't contain isolated cpu."
+	test 0 -eq $((0x$(cat $effective_affinity) & 1 << $isolate))
+	check
+	! grep -q IRQD_ACTIVATED $test_irq_debug
+	check
+	! grep -q IRQD_IRQ_STARTED $test_irq_debug
+	check
+	grep -q IRQD_IRQ_DISABLED $test_irq_debug
+	check
+	grep -q IRQD_IRQ_MASKED $test_irq_debug
+	check
+	grep -q IRQD_MANAGED_SHUTDOWN $test_irq_debug
+	check
+}
+
+echo "Isolating CPU #$isolate"
+echo $isolate > test/cpuset.cpus
+
+check_shutdown
+
+echo Reset cpuset
+echo "" > test/cpuset.cpus
+
+check_activated
+
+echo "Isolating CPU #$isolate again"
+echo $isolate > test/cpuset.cpus
+
+check_shutdown
+
+echo "Isolating CPU #3 and restore CPU #$isolate"
+echo 3 > test/cpuset.cpus
+
+check_activated
+
+echo Reset cpuset
+echo "" > test/cpuset.cpus
+
+rmdir test
+cd -
+
+rm -rf final.irqs
+cp -R /sys/kernel/debug/irq/irqs final.irqs
+
+sleep 1 # wait till IRQD_IRQ_INPROGRESS, IRQD_IRQ_MASKED
+
+if ! diff -r --ignore-matching-lines=Vector:: baseline.irqs final.irqs; then
+	echo diff failed;
+	let errors+=1
+fi
+
+#
+# return zero on success or number of errors
+#
+echo errors=$errors
+(return $errors)
-- 
2.47.0

Re: [RFC PATCH v4 2/4] genirq/cpuhotplug: Dynamically isolate CPUs from managed interrupts

[Thomas Gleixner]

On Sun, Dec 01 2024 at 14:42, Costa Shulyupin wrote:
> After change of housekeeping_cpumask(HK_TYPE_MANAGED_IRQ) during runtime
> managed interrupts continue to run on isolated CPUs.
>
> Dynamic CPUs isolation is complex task. One of approaches is:
> 1. Set affected CPUs offline and disable relevant interrupts
> 2. Change housekeeping_cpumask
> 3. Set affected CPUs online and enable relevant interrupts
>
> irq_restore_affinity_of_irq() restores managed interrupts
> during complex CPU hotplug process of bringing back a CPU online.
>
> Leave the interrupts disabled those affinity doesn't intersect
> with new housekeeping_cpumask thereby ensuring isolation
> of the CPU from managed intrrupts.

And thereby breaking drivers, which will restore the per cpu queue and
expect interrupts to work.

The semantics of HK_TYPE_MANAGED_IRQ are clearly not what you try to
make them. See the description of the "managed_irq" command line
parameter:

        Isolate from being targeted by managed interrupts
        which have an interrupt mask containing isolated
        CPUs. The affinity of managed interrupts is
        handled by the kernel and cannot be changed via
        the /proc/irq/* interfaces.

        This isolation is best effort and only effective
        if the automatically assigned interrupt mask of a
        device queue contains isolated and housekeeping
        CPUs. If housekeeping CPUs are online then such
        interrupts are directed to the housekeeping CPU
        so that IO submitted on the housekeeping CPU
        cannot disturb the isolated CPU.

        If a queue's affinity mask contains only isolated
        CPUs then this parameter has no effect on the
        interrupt routing decision, though interrupts are
        only delivered when tasks running on those
        isolated CPUs submit IO. IO submitted on
        housekeeping CPUs has no influence on those
        queues.

It's pretty clear, no?

Thanks,

        tglx

Re: [RFC PATCH v4 2/4] genirq/cpuhotplug: Dynamically isolate CPUs from managed interrupts

[Thomas Gleixner]

On Wed, Dec 04 2024 at 15:56, Costa Shulyupin wrote:
> On Sun, 1 Dec 2024 at 15:43, Thomas Gleixner <tglx@linutronix.de> wrote:
> It is introduced by commit a46c27026da1 (blk-mq: don't schedule block
> kworker on isolated CPUs)
>
> I don't know what to do with the remaining drivers.

As long as that is not fixed, you obviously cannot change the semantics.

> I am exploring the possibility of improving CPU isolation from best-effort
> to guaranteed.

If all drivers are fixed then the interrupt enabled state itself becomes
irrelevant. If there is nothing which tickles them then they won't be
raised, no?

Thanks,

        tglx