Skip to contentSkip to conversation

genirq: Add support for percpu_devid IRQ affinity

PATCH Superseded Marc Zyngier 3 participants 38 messages Sep 8, 2025 – Sep 11, 2025

Subsystems (12)

v1 of 4 Superseded Latest is v4 →

lore
Share & tools
lore

Marc Zyngier

author maintainer
#0 lore raw

cover genirq: Add support for percpu_devid IRQ affinity

The percpu_devid class of interrupts represent interrupts that are generally produced by CPUs or per-CPU devices (timer, PMU), and are more or less directly wired to that same CPU.

The core code has a baked-in assumption that all CPUs have the same devices wired to the same interrupt, making the whole system homogeneous in that respect.

Unfortunately, this is wishful thinking, and the big-little contraption has proved more often than not that sanity was not necessarily part of the design requirements.

The typical problem on ARM systems is that while all CPUs have a PMU, not all PMUs are the same and require a slightly different programing model. The driver therefore has to treat them differently. Another problem is that some devices are only present on a subset of the CPUs, and not others.

All in all, it means that these percpu_devid interrupts (which are represented as PPIs on the GIC class of interrupt controllers) are not ideally handled by the core code.

At least two interrupt controllers (GICv3 and Apple AIC) have invented their own schemes to paper over these problems. In the GICv3 case (the most over-engineered one), the low-level irqchip creates a mux irqchip for each PPI (up to 64 of them), and each possible affinity class represents an interrupt in this mux. Like this (compressed for readability):

# grep pmu /proc/interrupts 
 38: 0    0    0    0    0    0  GICv3-23   0 Level     arm-pmu
 39: 0    0    0    0    0    0  GICv3-23   1 Level     arm-pmu

Yes, this is nuts. But by hiding that the PPI is split between two affinity groups, and exposing two interrupts that are apparently system-wide, we trick the core code into not exploding.

While this solution has worked for the past 9 years, it creates its own class of issues. The most glaring one is that we cannot configure these interrupts as NMIs, as they are muxed interrupts and we don't allow NMIs outside of the root interrupt controller (this would imply taking locks that are not safe in this context). As it turns out, some of the heaviest users of profiling are also users of the most crazy systems out there (cough phones cough)...

It is also pretty bad that the core IRQ code cannot handle natively what has become an extremely common HW setup, for better or worse.

Finally, I have no desire to replicate the same horror on the next generation of ARM interrupt controller (GICv5), and this is the opportunity to put things right.

This series therefore aims at teaching the core code about these interrupts, removing all sort of irqchip-specific handling, and allow NMIs to be naturally handled in these setups.

We want:

- a single irqdesc representing the system-wide percpu interrupt

- the irqaction to carry the affinity the handler applies to

For that, we have a few problems to solve:

- communicating the affinity of an interrupt from the firmware to the device driver.

This is currently done via the irq_{g,s}et_percpu_devid_partition(), but this is stored on a per-irqdesc basis, which wouldn't work anymore with the scheme described above.

For that, we expose a new irqdomain op, implemented by the irqchips, that can retrieve FW-specific information including interrupt affinity, which then gets processed by ACPI and OF helpers to report the affinity to the platform layer. A new platform-level API can retrieve both the interrupt and its affinity, and the three drivers that make use of such affinity are updated to use this interface.

- teaching the core code about affinity-specific interrupts by allowing a percpu interrupt to be requested for a specific affinity.

This involves tracking the affinity at the irqaction level and enforce that it isn't possible to request the interrupt twice with overlapping affinities. A new flavour of request_irq() is provided for that purpose, and the drivers updated to make use of it.

- kill the irqchip-specific infrastructure, allowing the normal flow of interrupt request to be restored.

With that, we end-up with this on the same platform as above:

# grep pmu /proc/interrupts
 27: 0   0   0   0    0    0  GICv3  23 Level     arm-pmu, arm-pmu

which is much more satisfactory, and allows the use of NMIs. It doesn't hurt that the whole thing ends up with a negative diffstat.

Patches on top of v6.17-rc5, tested on a bunch of asymmetric systems:

- RK3399 (GICv3, DT)
- O6 (GICv3, ACPI)
- M1 (AIC, DT)

as well as on a saner symmetric system (Synquacer).

Marc Zyngier (24):
irqdomain: Add firmware info reporting interface
ACPI: irq: Add IRQ affinity reporting interface
of/irq: Add IRQ affinity reporting interface
platform: Add firmware-agnostic irq and affinity retrieval interface irqchip/gic-v3: Add FW info retrieval support irqchip/apple-aic: Add FW info retrieval support
coresight: trbe: Convert to new IRQ affinity retrieval API
perf: arm_pmu: Convert to new IRQ affinity retrieval API
perf: arm_spe_pmu: Convert to new IRQ affinity retrieval API
perf: arm_pmu: Add PMU/CPU affinity tracking
genirq: Merge irqaction::{dev_id,percpu_dev_id}
genirq: Factor-in percpu irqaction creation
genirq: Add affinity to percpu_devid interrupt requests
genirq: Update request_percpu_nmi() to take an affinity
genirq: Allow per-cpu interrupt sharing for non-overlapping affinities
genirq: Add request_percpu_irq_affinity() helper
perf: arm_pmu: Request specific affinities for percpu NMI/IRQ
perf: arm_spe_pmu: Request specific affinities for percpu IRQ
coresight: trbe: Request specific affinities for percpu IRQ irqchip/gic-v3: Drop support for custom PPI partitions irqchip/apple-aic: Drop support for custom PMU irq partitions
irqchip: Kill irq-partition-percpu
genirq: Kill irq_{g,s}et_percpu_devid_partition()
perf: arm_pmu: Kill last use of per-CPU cpu_armpmu pointer

Will Deacon (1):
perf: arm_pmu: Use a backend-specific pointer for percpu interrupt
request

 arch/arm64/kernel/smp.c                      |   2 +-
 drivers/acpi/irq.c                           |  15 ++
 drivers/base/platform.c                      |  60 ++++-
 drivers/hwtracing/coresight/coresight-trbe.c |   9 +-
 drivers/irqchip/Kconfig                      |   4 -
 drivers/irqchip/Makefile                     |   1 -
 drivers/irqchip/irq-apple-aic.c              |  59 +++--
 drivers/irqchip/irq-gic-v3.c                 | 172 +++++--------
 drivers/irqchip/irq-partition-percpu.c       | 241 -------------------
 drivers/of/irq.c                             |  20 ++
 drivers/perf/arm_pmu.c                       |  61 +++--
 drivers/perf/arm_pmu_acpi.c                  |   7 +-
 drivers/perf/arm_pmu_platform.c              |  24 +-
 drivers/perf/arm_pmuv3.c                     |   2 +-
 drivers/perf/arm_spe_pmu.c                   |  13 +-
 include/linux/acpi.h                         |   7 +
 include/linux/interrupt.h                    |  24 +-
 include/linux/irq.h                          |   4 -
 include/linux/irqchip/irq-partition-percpu.h |  53 ----
 include/linux/irqdesc.h                      |   1 -
 include/linux/irqdomain.h                    |  30 +++
 include/linux/of_irq.h                       |   7 +
 include/linux/perf/arm_pmu.h                 |   7 +-
 include/linux/platform_device.h              |   2 +
 kernel/irq/chip.c                            |   8 +-
 kernel/irq/irqdesc.c                         |  24 +-
 kernel/irq/irqdomain.c                       |  33 ++-
 kernel/irq/manage.c                          | 128 +++++++---
 28 files changed, 449 insertions(+), 569 deletions(-)
 delete mode 100644 drivers/irqchip/irq-partition-percpu.c
 delete mode 100644 include/linux/irqchip/irq-partition-percpu.h
Signature · 1 line
2.39.2
author maintainer
#1 lore raw

PATCH 1/25 irqdomain: Add firmware info reporting interface

Allow an irqdomain callback to report firmware-provided information that is otherwise not available in a generic way. This is reported using a new data structure (struct irq_fwspec_info).

This callback is optional and the only information that can be reported currently is the affinity of an interrupt. However, the containing structure is designed to be extensible, allowing other potentially relevant information to be reported in the future.

---
 include/linux/irqdomain.h | 30 ++++++++++++++++++++++++++++++
 kernel/irq/irqdomain.c    | 33 ++++++++++++++++++++++++++++-----
 2 files changed, 58 insertions(+), 5 deletions(-)
include/linux/irqdomain.h +30 -0
index 4a86e6b915dd6..9ec93fb2f5753 100644
@@ -44,6 +44,27 @@ struct irq_fwspec {
 	u32			param[IRQ_DOMAIN_IRQ_SPEC_PARAMS];
 };
 
+/**
+ * struct irq_fwspec_info - firmware provided IRQ information structure
+ *
+ * @fwspec:		IRQ specifier
+ * @cpumask:		Affinity mask for this interrupt
+ * @flags:		Information validity flags
+ *
+ * This structure reports firmware-specific information about an
+ * interrupt. The only significant information is the affinity of a
+ * per-CPU interrupt, but this is designed to be extended as required.
+ */
+struct irq_fwspec_info {
+	struct irq_fwspec	fwspec;
+	const struct cpumask	*affinity;
+
+#define IRQ_FWSPEC_INFO_FWSPEC_VALID	BIT(0)
+#define IRQ_FWSPEC_INFO_AFFINITY_VALID	BIT(1)
+
+	unsigned long		flags;
+};
+
 /* Conversion function from of_phandle_args fields to fwspec  */
 void of_phandle_args_to_fwspec(struct device_node *np, const u32 *args,
 			       unsigned int count, struct irq_fwspec *fwspec);
@@ -69,6 +90,8 @@ void of_phandle_args_to_fwspec(struct device_node *np, const u32 *args,
  * @translate:	Given @fwspec, decode the hardware irq number (@out_hwirq) and
  *		linux irq type value (@out_type). This is a generalised @xlate
  *		(over struct irq_fwspec) and is preferred if provided.
+ * @get_info: Given @info, report additional firmware-provided information.
+ *            Optional.
  * @debug_show:	For domains to show specific data for an interrupt in debugfs.
  *
  * Functions below are provided by the driver and called whenever a new mapping
@@ -96,6 +119,7 @@ struct irq_domain_ops {
 	void	(*deactivate)(struct irq_domain *d, struct irq_data *irq_data);
 	int	(*translate)(struct irq_domain *d, struct irq_fwspec *fwspec,
 			     unsigned long *out_hwirq, unsigned int *out_type);
+	int (*get_info)(struct irq_fwspec_info *info);
 #endif
 #ifdef CONFIG_GENERIC_IRQ_DEBUGFS
 	void	(*debug_show)(struct seq_file *m, struct irq_domain *d,
@@ -602,6 +626,8 @@ void irq_domain_free_irqs_parent(struct irq_domain *domain, unsigned int irq_bas
 
 int irq_domain_disconnect_hierarchy(struct irq_domain *domain, unsigned int virq);
 
+int irq_populate_fwspec_info(struct irq_fwspec_info *info);
+
 static inline bool irq_domain_is_hierarchy(struct irq_domain *domain)
 {
 	return domain->flags & IRQ_DOMAIN_FLAG_HIERARCHY;
@@ -685,6 +711,10 @@ static inline bool irq_domain_is_msi_device(struct irq_domain *domain)
 	return false;
 }
 
+static inline int irq_populate_fwspec_info(struct irq_fwspec_info *info)
+{
+	return -EINVAL;
+}
 #endif	/* CONFIG_IRQ_DOMAIN_HIERARCHY */
 
 #ifdef CONFIG_GENERIC_MSI_IRQ
kernel/irq/irqdomain.c +28 -5
index dc473faadcc81..f857606e3ffbe 100644
@@ -867,13 +867,9 @@ void of_phandle_args_to_fwspec(struct device_node *np, const u32 *args,
 }
 EXPORT_SYMBOL_GPL(of_phandle_args_to_fwspec);
 
-unsigned int irq_create_fwspec_mapping(struct irq_fwspec *fwspec)
+static struct irq_domain *fwspec_to_domain(struct irq_fwspec *fwspec)
 {
 	struct irq_domain *domain;
-	struct irq_data *irq_data;
-	irq_hw_number_t hwirq;
-	unsigned int type = IRQ_TYPE_NONE;
-	int virq;
 
 	if (fwspec->fwnode) {
 		domain = irq_find_matching_fwspec(fwspec, DOMAIN_BUS_WIRED);
@@ -883,6 +879,33 @@ unsigned int irq_create_fwspec_mapping(struct irq_fwspec *fwspec)
 		domain = irq_default_domain;
 	}
 
+	return domain;
+}
+
+#ifdef	CONFIG_IRQ_DOMAIN_HIERARCHY
+int irq_populate_fwspec_info(struct irq_fwspec_info *info)
+{
+	struct irq_domain *domain;
+
+	domain = fwspec_to_domain(&info->fwspec);
+	if (!domain || !domain->ops->get_info) {
+		info->flags = 0;
+		return 0;
+	}
+
+	return domain->ops->get_info(info);
+}
+#endif
+
+unsigned int irq_create_fwspec_mapping(struct irq_fwspec *fwspec)
+{
+	struct irq_domain *domain;
+	struct irq_data *irq_data;
+	irq_hw_number_t hwirq;
+	unsigned int type = IRQ_TYPE_NONE;
+	int virq;
+
+	domain = fwspec_to_domain(fwspec);
 	if (!domain) {
 		pr_warn("no irq domain found for %s !\n",
 			of_node_full_name(to_of_node(fwspec->fwnode)));
Signature · 1 line
2.39.2
#2 lore raw

Re: [PATCH 01/25] irqdomain: Add firmware info reporting interface

Quoted 4 lines · Marc Zyngier

+/**
+ * struct irq_fwspec_info - firmware provided IRQ information structure
+ *
+ * @fwspec: IRQ specifier

s/IRQ/interrupt/g

Quoted 7 lines

+ * @cpumask: Affinity mask for this interrupt
+ * @flags: Information validity flags
+ *
+ * This structure reports firmware-specific information about an
+ * interrupt. The only significant information is the affinity of a
+ * per-CPU interrupt, but this is designed to be extended as required.
+ */

include/linux/irqdomain.h struct irq_fwspec { · line 65

Quoted 8 lines
include/linux/irqdomain.h +8 -0
+struct irq_fwspec_info {
+	struct irq_fwspec	fwspec;
+	const struct cpumask	*affinity;
+
+#define IRQ_FWSPEC_INFO_FWSPEC_VALID	BIT(0)
+#define IRQ_FWSPEC_INFO_AFFINITY_VALID	BIT(1)
+
+	unsigned long		flags;

Can you please not stick the defines into the struct. That makes my eyes bleed.

Also the ordering looks strange as flags should be before the fields it validates for readability sake, no?

include/linux/irqdomain.h void of_phandle_args_to_fwspec(struct device_node *np, const u32 *args, · line 94

Quoted 11 lines
include/linux/irqdomain.h +4 -0
+};
+
 /* Conversion function from of_phandle_args fields to fwspec  */
 void of_phandle_args_to_fwspec(struct device_node *np, const u32 *args,
 			       unsigned int count, struct irq_fwspec *fwspec);
@@ -69,6 +90,8 @@ void of_phandle_args_to_fwspec(struct device_node *np, const u32 *args,
  * @translate:	Given @fwspec, decode the hardware irq number (@out_hwirq) and
  *		linux irq type value (@out_type). This is a generalised @xlate
  *		(over struct irq_fwspec) and is preferred if provided.
+ * @get_info: Given @info, report additional firmware-provided information.
+ *            Optional.

get_info() is pretty generic. Can we have some more descriptive name for that? Also please keep the tabular formatting of the doc intact.

include/linux/irqdomain.h struct irq_domain_ops { · line 122

Quoted 8 lines
include/linux/irqdomain.h +1 -0
  * @debug_show:	For domains to show specific data for an interrupt in debugfs.
  *
  * Functions below are provided by the driver and called whenever a new mapping
@@ -96,6 +119,7 @@ struct irq_domain_ops {
 	void	(*deactivate)(struct irq_domain *d, struct irq_data *irq_data);
 	int	(*translate)(struct irq_domain *d, struct irq_fwspec *fwspec,
 			     unsigned long *out_hwirq, unsigned int *out_type);
+	int (*get_info)(struct irq_fwspec_info *info);

TAB between int and '(*'

include/linux/irqdomain.h void irq_domain_free_irqs_parent(struct irq_domain *domain, unsigned int irq_bas · line 632

Quoted 11 lines
include/linux/irqdomain.h +4 -0
 #endif
 #ifdef CONFIG_GENERIC_IRQ_DEBUGFS
 	void	(*debug_show)(struct seq_file *m, struct irq_domain *d,
@@ -602,6 +626,8 @@ void irq_domain_free_irqs_parent(struct irq_domain *domain, unsigned int irq_bas
 
 int irq_domain_disconnect_hierarchy(struct irq_domain *domain, unsigned int virq);
 
+int irq_populate_fwspec_info(struct irq_fwspec_info *info);
+
+
+#ifdef	CONFIG_IRQ_DOMAIN_HIERARCHY

Stray TAB

kernel/irq/irqdomain.c unsigned int irq_create_fwspec_mapping(struct irq_fwspec *fwspec) · line 890

Quoted 5 lines
kernel/irq/irqdomain.c +5 -0
+int irq_populate_fwspec_info(struct irq_fwspec_info *info)
+{
+	struct irq_domain *domain;
+
+	domain = fwspec_to_domain(&info->fwspec);

Just move that to the declaration line

Quoted 5 lines
kernel/irq/irqdomain.c +5 -0
+	if (!domain || !domain->ops->get_info) {
+		info->flags = 0;
+		return 0;
+	}
+

kernel/irq/irqdomain.c unsigned int irq_create_fwspec_mapping(struct irq_fwspec *fwspec) · line 905

Quoted 10 lines
kernel/irq/irqdomain.c +10 -0
+	return domain->ops->get_info(info);
+}
+#endif
+
+unsigned int irq_create_fwspec_mapping(struct irq_fwspec *fwspec)
+{
+	struct irq_domain *domain;
+	struct irq_data *irq_data;
+	irq_hw_number_t hwirq;
+	unsigned int type = IRQ_TYPE_NONE;

I know you moved it from the original function, but can you please reorder it in reverse fir tree order?

kernel/irq/irqdomain.c unsigned int irq_create_fwspec_mapping(struct irq_fwspec *fwspec) · line 911

Quoted 6 lines
kernel/irq/irqdomain.c +3 -0
+	int virq;
+
+	domain = fwspec_to_domain(fwspec);
 	if (!domain) {
 		pr_warn("no irq domain found for %s !\n",
 			of_node_full_name(to_of_node(fwspec->fwnode)));

Thanks,

tglx

#3 lore raw

Re: [PATCH 01/25] irqdomain: Add firmware info reporting interface

Quoted 11 lines · Thomas Gleixner

kernel/irq/irqdomain.c unsigned int irq_create_fwspec_mapping(struct irq_fwspec *fwspec) · line 890

Quoted 5 lines · Marc Zyngier
kernel/irq/irqdomain.c +5 -0
+int irq_populate_fwspec_info(struct irq_fwspec_info *info)
+{
+	struct irq_domain *domain;
+
+	domain = fwspec_to_domain(&info->fwspec);

Just move that to the declaration line

kernel/irq/irqdomain.c unsigned int irq_create_fwspec_mapping(struct irq_fwspec *fwspec) · line 892

Quoted 2 lines
kernel/irq/irqdomain.c +2 -0
+	if (!domain || !domain->ops->get_info) {
+		info->flags = 0;

It looks like @info is not initialized except for info::fwspec. That's a patently bad idea.

Why has fwspec to be in info in the first place? What's wrong with doing the obvious:

int irq_populate_fwspec_info(struct irq_fwspec *fwspec, struct irq_fwspec_info *info)

{
        memset(info, 0, sizeof(info));

        ....

No?

Thanks,

tglx

author maintainer
#4 lore raw

Re: [PATCH 01/25] irqdomain: Add firmware info reporting interface

In reply to Thomas Gleixner
Quoted 2 lines · Thomas Gleixner

On Mon, Sep 08 2025 at 17:31, Marc Zyngier wrote:

[...]

Quoted 9 lines

include/linux/irqdomain.h void of_phandle_args_to_fwspec(struct device_node *np, const u32 *args, · line 94

Quoted 6 lines
include/linux/irqdomain.h +2 -0
@@ -69,6 +90,8 @@ void of_phandle_args_to_fwspec(struct device_node *np, const u32 *args,
  * @translate:	Given @fwspec, decode the hardware irq number (@out_hwirq) and
  *		linux irq type value (@out_type). This is a generalised @xlate
  *		(over struct irq_fwspec) and is preferred if provided.
+ * @get_info: Given @info, report additional firmware-provided information.
+ *            Optional.

get_info() is pretty generic. Can we have some more descriptive name for that? Also please keep the tabular formatting of the doc intact.

Would get_fwspec_info() be descriptive enough?

	M.
Signature · 1 line
Without deviation from the norm, progress is not possible.
#5 lore raw

Re: [PATCH 01/25] irqdomain: Add firmware info reporting interface

Quoted 17 lines · Marc Zyngier
Quoted 2 lines · Thomas Gleixner

On Mon, Sep 08 2025 at 17:31, Marc Zyngier wrote:

[...]

Quoted 9 lines

include/linux/irqdomain.h void of_phandle_args_to_fwspec(struct device_node *np, const u32 *args, · line 94

Quoted 6 lines
include/linux/irqdomain.h +2 -0
@@ -69,6 +90,8 @@ void of_phandle_args_to_fwspec(struct device_node *np, const u32 *args,
  * @translate:	Given @fwspec, decode the hardware irq number (@out_hwirq) and
  *		linux irq type value (@out_type). This is a generalised @xlate
  *		(over struct irq_fwspec) and is preferred if provided.
+ * @get_info: Given @info, report additional firmware-provided information.
+ *            Optional.

get_info() is pretty generic. Can we have some more descriptive name for that? Also please keep the tabular formatting of the doc intact.

Quoted 1 line

Would get_fwspec_info() be descriptive enough?

I think so

author maintainer
#6 lore raw

PATCH 2/25 ACPI: irq: Add IRQ affinity reporting interface

In reply to Marc Zyngier

Plug the irq_populate_fwspec_info() helper into the ACPI layer to offer an IRQ affinity reporting function. This is currently only supported for the CONFIG_ACPI_GENERIC_GSI configurations, but could later be extended to legacy architectures if necessary.

---
 drivers/acpi/irq.c   | 15 +++++++++++++++
 include/linux/acpi.h |  7 +++++++
 2 files changed, 22 insertions(+)
drivers/acpi/irq.c +15 -0
index 76a856c32c4d0..22f93fe23ddce 100644
@@ -300,6 +300,21 @@ int acpi_irq_get(acpi_handle handle, unsigned int index, struct resource *res)
 }
 EXPORT_SYMBOL_GPL(acpi_irq_get);
 
+const struct cpumask *acpi_irq_get_affinity(acpi_handle handle,
+					    unsigned int index)
+{
+	struct irq_fwspec_info info;
+	unsigned long flags;
+
+	if (!acpi_irq_parse_one(handle, index, &info.fwspec, &flags)) {
+		if (!irq_populate_fwspec_info(&info) &&
+		    info.flags & IRQ_FWSPEC_INFO_AFFINITY_VALID)
+			return info.affinity;
+	}
+
+	return NULL;
+}
+
 /**
  * acpi_set_irq_model - Setup the GSI irqdomain information
  * @model: the value assigned to acpi_irq_model
include/linux/acpi.h +7 -0
index 1c5bb1e887cd1..c506ae4bacc86 100644
@@ -1509,12 +1509,19 @@ static inline int acpi_parse_spcr(bool enable_earlycon, bool enable_console)
 
 #if IS_ENABLED(CONFIG_ACPI_GENERIC_GSI)
 int acpi_irq_get(acpi_handle handle, unsigned int index, struct resource *res);
+const struct cpumask *acpi_irq_get_affinity(acpi_handle handle,
+					    unsigned int index);
 #else
 static inline
 int acpi_irq_get(acpi_handle handle, unsigned int index, struct resource *res)
 {
 	return -EINVAL;
 }
+static inline const struct cpumask *acpi_irq_get_affinity(acpi_handle handle,
+							  unsigned int index)
+{
+	return NULL;
+}
 #endif
 
 #ifdef CONFIG_ACPI_LPIT
Signature · 1 line
2.39.2
#7 lore raw

Re: [PATCH 02/25] ACPI: irq: Add IRQ affinity reporting interface

Quoted 21 lines · Marc Zyngier

Plug the irq_populate_fwspec_info() helper into the ACPI layer to offer an IRQ affinity reporting function. This is currently only supported for the CONFIG_ACPI_GENERIC_GSI configurations, but could later be extended to legacy architectures if necessary.

---
 drivers/acpi/irq.c   | 15 +++++++++++++++
 include/linux/acpi.h |  7 +++++++
 2 files changed, 22 insertions(+)
drivers/acpi/irq.c +1 -0
index 76a856c32c4d0..22f93fe23ddce 100644
@@ -300,6 +300,21 @@ int acpi_irq_get(acpi_handle handle, unsigned int index, struct resource *res)
 }
 EXPORT_SYMBOL_GPL(acpi_irq_get);
 
+const struct cpumask *acpi_irq_get_affinity(acpi_handle handle,

drivers/acpi/irq.c int acpi_irq_get(acpi_handle handle, unsigned int index, struct resource *res) · line 313

Quoted 10 lines
drivers/acpi/irq.c +10 -0
+                                           unsigned int index)
+{
+       struct irq_fwspec_info info;
+       unsigned long flags;
+
+       if (!acpi_irq_parse_one(handle, index, &info.fwspec, &flags)) {
+               if (!irq_populate_fwspec_info(&info) &&
+                   info.flags & IRQ_FWSPEC_INFO_AFFINITY_VALID)
+                       return info.affinity;
+       }

I would prefer fewer logical negations to be used in this, for instance:

if (acpi_irq_parse_one(handle, index, &info.fwspec, &flags))

      return NULL;

if (irq_populate_fwspec_info(&info))

       return NULL;

if (info.flags & IRQ_FWSPEC_INFO_AFFINITY_VALID)

       return info.affinity;

return NULL;

Quoted 32 lines
drivers/acpi/irq.c +4 -0
+
+       return NULL;
+}
+
 /**
  * acpi_set_irq_model - Setup the GSI irqdomain information
  * @model: the value assigned to acpi_irq_model
include/linux/acpi.h +7 -1
index 1c5bb1e887cd1..c506ae4bacc86 100644
@@ -1509,12 +1509,19 @@ static inline int acpi_parse_spcr(bool enable_earlycon, bool enable_console)
 
 #if IS_ENABLED(CONFIG_ACPI_GENERIC_GSI)
 int acpi_irq_get(acpi_handle handle, unsigned int index, struct resource *res);
+const struct cpumask *acpi_irq_get_affinity(acpi_handle handle,
+                                           unsigned int index);
 #else
 static inline
 int acpi_irq_get(acpi_handle handle, unsigned int index, struct resource *res)
 {
        return -EINVAL;
 }
+static inline const struct cpumask *acpi_irq_get_affinity(acpi_handle handle,
+                                                         unsigned int index)
+{
+       return NULL;
+}
 #endif
 
 #ifdef CONFIG_ACPI_LPIT
--
author maintainer
#8 lore raw

PATCH 3/25 of/irq: Add IRQ affinity reporting interface

In reply to Marc Zyngier

Plug the irq_populate_fwspec_info() helper into the OF layer to offer an IRQ affinity reporting function.

---
 drivers/of/irq.c       | 20 ++++++++++++++++++++
 include/linux/of_irq.h |  7 +++++++
 2 files changed, 27 insertions(+)
drivers/of/irq.c +20 -0
index 74aaea61de13c..cb264f44bd6d8 100644
@@ -479,6 +479,26 @@ int of_irq_get(struct device_node *dev, int index)
 }
 EXPORT_SYMBOL_GPL(of_irq_get);
 
+const struct cpumask *of_irq_get_affinity(struct device_node *dev, int index)
+{
+	int rc;
+	struct of_phandle_args oirq;
+	struct irq_fwspec_info info;
+
+	rc = of_irq_parse_one(dev, index, &oirq);
+	if (rc)
+		return NULL;
+
+	of_phandle_args_to_fwspec(oirq.np, oirq.args, oirq.args_count,
+				  &info.fwspec);
+
+	if (!irq_populate_fwspec_info(&info) &&
+	    info.flags & IRQ_FWSPEC_INFO_AFFINITY_VALID)
+		return info.affinity;
+
+	return NULL;
+}
+
 /**
  * of_irq_get_byname - Decode a node's IRQ and return it as a Linux IRQ number
  * @dev: pointer to device tree node
include/linux/of_irq.h +7 -0
index a480063c9cb19..721cbdbc292df 100644
@@ -43,6 +43,8 @@ extern int of_irq_parse_one(struct device_node *device, int index,
 			  struct of_phandle_args *out_irq);
 extern int of_irq_count(struct device_node *dev);
 extern int of_irq_get(struct device_node *dev, int index);
+extern const struct cpumask *of_irq_get_affinity(struct device_node *dev,
+						      int index);
 extern int of_irq_get_byname(struct device_node *dev, const char *name);
 extern int of_irq_to_resource_table(struct device_node *dev,
 		struct resource *res, int nr_irqs);
@@ -77,6 +79,11 @@ static inline int of_irq_get_byname(struct device_node *dev, const char *name)
 {
 	return 0;
 }
+static inline const struct cpumask *of_irq_get_affinity(struct device_node *dev,
+							int index)
+{
+	return NULL;
+}
 static inline int of_irq_to_resource_table(struct device_node *dev,
 					   struct resource *res, int nr_irqs)
 {
Signature · 1 line
2.39.2
author maintainer
#9 lore raw

PATCH 4/25 platform: Add firmware-agnostic irq and affinity retrieval interface

In reply to Marc Zyngier

Expand platform_get_irq_optional() to also return an affinity if available, renaming it to platform_get_irq_affinity() in the process.

platform_get_irq_optional() is preserved with its current semantics by calling into the new helper with a NULL affinity pointer.

---
 drivers/base/platform.c         | 60 +++++++++++++++++++++++++++------
 include/linux/platform_device.h |  2 ++
 2 files changed, 52 insertions(+), 10 deletions(-)
drivers/base/platform.c +50 -10
index 09450349cf323..fad33d6b2349a 100644
@@ -150,25 +150,37 @@ devm_platform_ioremap_resource_byname(struct platform_device *pdev,
 EXPORT_SYMBOL_GPL(devm_platform_ioremap_resource_byname);
 #endif /* CONFIG_HAS_IOMEM */
 
+static const struct cpumask *get_irq_affinity(struct platform_device *dev,
+					      unsigned int num)
+{
+	const struct cpumask *mask = NULL;
+#ifndef CONFIG_SPARC
+	struct fwnode_handle *fwnode = dev_fwnode(&dev->dev);
+
+	if (is_of_node(fwnode))
+		mask = of_irq_get_affinity(to_of_node(fwnode), num);
+	else if (is_acpi_device_node(fwnode))
+		mask = acpi_irq_get_affinity(ACPI_HANDLE_FWNODE(fwnode), num);
+#endif
+
+	return mask ?: cpu_possible_mask;
+}
+
 /**
- * platform_get_irq_optional - get an optional IRQ for a device
+ * platform_get_irq_affinity - get an optional IRQ and its affnity for a device
  * @dev: platform device
  * @num: IRQ number index
+ * @affinity: optional cpumask pointer to get the affinity of a per-cpu IRQ
  *
  * Gets an IRQ for a platform device. Device drivers should check the return
  * value for errors so as to not pass a negative integer value to the
- * request_irq() APIs. This is the same as platform_get_irq(), except that it
- * does not print an error message if an IRQ can not be obtained.
- *
- * For example::
- *
- *		int irq = platform_get_irq_optional(pdev, 0);
- *		if (irq < 0)
- *			return irq;
+ * request_irq() APIs. Optional affinity information is provided in the
+ * affinity pointer if available, and NULL otherwise.
  *
  * Return: non-zero IRQ number on success, negative error number on failure.
  */
-int platform_get_irq_optional(struct platform_device *dev, unsigned int num)
+int platform_get_irq_affinity(struct platform_device *dev, unsigned int num,
+			      const struct cpumask **affinity)
 {
 	int ret;
 #ifdef CONFIG_SPARC
@@ -236,8 +248,36 @@ int platform_get_irq_optional(struct platform_device *dev, unsigned int num)
 out:
 	if (WARN(!ret, "0 is an invalid IRQ number\n"))
 		return -EINVAL;
+
+	if (ret > 0 && affinity)
+		*affinity = get_irq_affinity(dev, num);
+
 	return ret;
 }
+EXPORT_SYMBOL_GPL(platform_get_irq_affinity);
+
+/**
+ * platform_get_irq_optional - get an optional IRQ for a device
+ * @dev: platform device
+ * @num: IRQ number index
+ *
+ * Gets an IRQ for a platform device. Device drivers should check the return
+ * value for errors so as to not pass a negative integer value to the
+ * request_irq() APIs. This is the same as platform_get_irq(), except that it
+ * does not print an error message if an IRQ can not be obtained.
+ *
+ * For example::
+ *
+ *		int irq = platform_get_irq_optional(pdev, 0);
+ *		if (irq < 0)
+ *			return irq;
+ *
+ * Return: non-zero IRQ number on success, negative error number on failure.
+ */
+int platform_get_irq_optional(struct platform_device *dev, unsigned int num)
+{
+	return platform_get_irq_affinity(dev, num, NULL);
+}
 EXPORT_SYMBOL_GPL(platform_get_irq_optional);
 
 /**
include/linux/platform_device.h +2 -0
index 074754c23d330..ad66333ce85ce 100644
@@ -102,6 +102,8 @@ devm_platform_ioremap_resource_byname(struct platform_device *pdev,
 
 extern int platform_get_irq(struct platform_device *, unsigned int);
 extern int platform_get_irq_optional(struct platform_device *, unsigned int);
+extern int platform_get_irq_affinity(struct platform_device *, unsigned int,
+				     const struct cpumask **);
 extern int platform_irq_count(struct platform_device *);
 extern int devm_platform_get_irqs_affinity(struct platform_device *dev,
 					   struct irq_affinity *affd,
Signature · 1 line
2.39.2
author maintainer
#10 lore raw

PATCH 5/25 irqchip/gic-v3: Add FW info retrieval support

In reply to Marc Zyngier

Plug the new .get_info() callback into the GICv3 core driver, using some of the existing PPI affinity handling infrastructure.

---
 drivers/irqchip/irq-gic-v3.c | 55 ++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)
drivers/irqchip/irq-gic-v3.c +55 -0
index dbeb85677b08c..4a90dbf9daedb 100644
@@ -69,6 +69,8 @@ struct gic_chip_data {
 	bool			has_rss;
 	unsigned int		ppi_nr;
 	struct partition_desc	**ppi_descs;
+	struct partition_affinity *parts;
+	unsigned int		nr_parts;
 };
 
 #define T241_CHIPS_MAX		4
@@ -1796,11 +1798,60 @@ static int gic_irq_domain_select(struct irq_domain *d,
 	return d == partition_get_domain(gic_data.ppi_descs[ppi_idx]);
 }
 
+static int gic_irq_get_info(struct irq_fwspec_info *info)
+{
+	struct irq_fwspec *fwspec = &info->fwspec;
+	const struct cpumask *mask = NULL;
+
+	info->flags = 0;
+	info->affinity = NULL;
+
+	/* ACPI is not capable of describing PPI affinity -- yet */
+	if (!is_of_node(fwspec->fwnode))
+		goto out;
+
+	/* If the specifier provides an affinity, use it */
+	if (fwspec->param_count == 4 && fwspec->param[3]) {
+		struct fwnode_handle *fw;
+
+		switch (fwspec->param[0]) {
+		case 1:			/* PPI */
+		case 3:			/* EPPI */
+			break;
+		default:
+			goto out;
+		}
+
+		fw = of_node_to_fwnode(of_find_node_by_phandle(fwspec->param[3]));
+		if (!fw)
+			goto out;
+
+		for (int i = 0; i < gic_data.nr_parts; i++) {
+			if (gic_data.parts[i].partition_id == fw) {
+				mask = &gic_data.parts[i].mask;
+				break;
+			}
+		}
+
+		if (!mask)
+			goto out;
+	} else {
+		mask = cpu_possible_mask;
+	}
+
+	info->affinity = mask;
+	info->flags = (IRQ_FWSPEC_INFO_FWSPEC_VALID |
+		       IRQ_FWSPEC_INFO_AFFINITY_VALID);
+out:
+	return 0;
+}
+
 static const struct irq_domain_ops gic_irq_domain_ops = {
 	.translate = gic_irq_domain_translate,
 	.alloc = gic_irq_domain_alloc,
 	.free = gic_irq_domain_free,
 	.select = gic_irq_domain_select,
+	.get_info = gic_irq_get_info,
 };
 
 static int partition_domain_translate(struct irq_domain *d,
@@ -1839,6 +1890,7 @@ static int partition_domain_translate(struct irq_domain *d,
 static const struct irq_domain_ops partition_domain_ops = {
 	.translate = partition_domain_translate,
 	.select = gic_irq_domain_select,
+	.get_info = gic_irq_get_info,
 };
 
 static bool gic_enable_quirk_msm8996(void *data)
@@ -2231,6 +2283,9 @@ static void __init gic_populate_ppi_partitions(struct device_node *gic_node)
 		part_idx++;
 	}
 
+	gic_data.parts = parts;
+	gic_data.nr_parts = nr_parts;
+
 	for (i = 0; i < gic_data.ppi_nr; i++) {
 		unsigned int irq;
 		struct partition_desc *desc;
Signature · 1 line
2.39.2
#11 lore raw

Re: [PATCH 05/25] irqchip/gic-v3: Add FW info retrieval support

drivers/irqchip/irq-gic-v3.c static int gic_irq_domain_select(struct irq_domain *d, · line 1807

Quoted 7 lines · Marc Zyngier
drivers/irqchip/irq-gic-v3.c +7 -0
+static int gic_irq_get_info(struct irq_fwspec_info *info)
+{
+	struct irq_fwspec *fwspec = &info->fwspec;
+	const struct cpumask *mask = NULL;
+
+	info->flags = 0;
+	info->affinity = NULL;

:)

drivers/irqchip/irq-gic-v3.c static int gic_irq_domain_select(struct irq_domain *d, · line 1811

Quoted 3 lines
drivers/irqchip/irq-gic-v3.c +3 -0
+	/* ACPI is not capable of describing PPI affinity -- yet */
+	if (!is_of_node(fwspec->fwnode))
+		goto out;

'goto out' to return 0? Seriously?

Quoted 22 lines
drivers/irqchip/irq-gic-v3.c +22 -0
+	/* If the specifier provides an affinity, use it */
+	if (fwspec->param_count == 4 && fwspec->param[3]) {
+		struct fwnode_handle *fw;
+
+		switch (fwspec->param[0]) {
+		case 1:			/* PPI */
+		case 3:			/* EPPI */
+			break;
+		default:
+			goto out;
+		}
+
+		fw = of_node_to_fwnode(of_find_node_by_phandle(fwspec->param[3]));
+		if (!fw)
+			goto out;
+
+		for (int i = 0; i < gic_data.nr_parts; i++) {
+			if (gic_data.parts[i].partition_id == fw) {
+				mask = &gic_data.parts[i].mask;
+				break;
+			}
+		}

drivers/irqchip/irq-gic-v3.c static int gic_irq_domain_select(struct irq_domain *d, · line 1844

Quoted 10 lines
drivers/irqchip/irq-gic-v3.c +10 -0
+
+		if (!mask)
+			goto out;
+	} else {
+		mask = cpu_possible_mask;
+	}
+
+	info->affinity = mask;
+	info->flags = (IRQ_FWSPEC_INFO_FWSPEC_VALID |
+		       IRQ_FWSPEC_INFO_AFFINITY_VALID);

It's not really clear to me what the purpose ofIRQ_FWSPEC_INFO_FWSPEC_VALID is. That firmware spec was handed in by the caller, so it should be valid no matter what, no?

Thanks,

tglx

author maintainer
#12 lore raw

PATCH 6/25 irqchip/apple-aic: Add FW info retrieval support

In reply to Marc Zyngier

Plug the new .get_info() callback into the Apple AIC driver, using some of the existing FIQ affinity handling infrastructure.

---
 drivers/irqchip/irq-apple-aic.c | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
drivers/irqchip/irq-apple-aic.c +31 -0
index 032d66dceb8ec..dd89e50a72e83 100644
@@ -651,6 +651,36 @@ static int aic_irq_domain_map(struct irq_domain *id, unsigned int irq,
 	return 0;
 }
 
+static int aic_irq_get_info(struct irq_fwspec_info *info)
+{
+	struct irq_fwspec *fwspec = &info->fwspec;
+	const struct cpumask *mask;
+	u32 intid;
+
+	info->flags = 0;
+	info->affinity = NULL;
+
+	if (fwspec->param[0] != AIC_FIQ)
+		return 0;
+
+	if (fwspec->param_count == 3)
+		intid = fwspec->param[1];
+	else
+		intid = fwspec->param[2];
+
+	if (aic_irqc->fiq_aff[intid])
+		mask = &aic_irqc->fiq_aff[intid]->aff;
+	else
+		mask = cpu_possible_mask;
+
+	info->affinity = mask;
+
+	info->flags = (IRQ_FWSPEC_INFO_FWSPEC_VALID |
+		       IRQ_FWSPEC_INFO_AFFINITY_VALID);
+
+	return 0;
+}
+
 static int aic_irq_domain_translate(struct irq_domain *id,
 				    struct irq_fwspec *fwspec,
 				    unsigned long *hwirq,
@@ -753,6 +783,7 @@ static const struct irq_domain_ops aic_irq_domain_ops = {
 	.translate	= aic_irq_domain_translate,
 	.alloc		= aic_irq_domain_alloc,
 	.free		= aic_irq_domain_free,
+	.get_info	= aic_irq_get_info,
 };
 
 /*
Signature · 1 line
2.39.2
author maintainer
#13 lore raw

PATCH 7/25 coresight: trbe: Convert to new IRQ affinity retrieval API

In reply to Marc Zyngier

Now that the relevant interrupt controllers are equipped with a callback returning the affinity of per-CPU interrupts, switch the TRBE driver over to this new method.

---
 drivers/hwtracing/coresight/coresight-trbe.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/hwtracing/coresight/coresight-trbe.c +3 -3
index 8267dd1a2130d..c512f8faa6012 100644
@@ -1472,9 +1472,10 @@ static void arm_trbe_remove_cpuhp(struct trbe_drvdata *drvdata)
 static int arm_trbe_probe_irq(struct platform_device *pdev,
 			      struct trbe_drvdata *drvdata)
 {
+	const struct cpumask *affinity;
 	int ret;
 
-	drvdata->irq = platform_get_irq(pdev, 0);
+	drvdata->irq = platform_get_irq_affinity(pdev, 0, &affinity);
 	if (drvdata->irq < 0) {
 		pr_err("IRQ not found for the platform device\n");
 		return drvdata->irq;
@@ -1485,8 +1486,7 @@ static int arm_trbe_probe_irq(struct platform_device *pdev,
 		return -EINVAL;
 	}
 
-	if (irq_get_percpu_devid_partition(drvdata->irq, &drvdata->supported_cpus))
-		return -EINVAL;
+	cpumask_copy(&drvdata->supported_cpus, affinity);
 
 	drvdata->handle = alloc_percpu(struct perf_output_handle *);
 	if (!drvdata->handle)
Signature · 1 line
2.39.2
author maintainer
#14 lore raw

PATCH 8/25 perf: arm_pmu: Convert to new IRQ affinity retrieval API

In reply to Marc Zyngier

Now that the relevant interrupt controllers are equipped with a callback returning the affinity of per-CPU interrupts, switch the OF side of the ARM PMU driver over to this new method.

---
 drivers/perf/arm_pmu_platform.c | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)
drivers/perf/arm_pmu_platform.c +9 -7
index 118170a5cedef..9c0494d8a867a 100644
@@ -42,14 +42,13 @@ static int probe_current_pmu(struct arm_pmu *pmu,
 	return ret;
 }
 
-static int pmu_parse_percpu_irq(struct arm_pmu *pmu, int irq)
+static int pmu_parse_percpu_irq(struct arm_pmu *pmu, int irq,
+				const struct cpumask *affinity)
 {
-	int cpu, ret;
 	struct pmu_hw_events __percpu *hw_events = pmu->hw_events;
+	int cpu;
 
-	ret = irq_get_percpu_devid_partition(irq, &pmu->supported_cpus);
-	if (ret)
-		return ret;
+	cpumask_copy(&pmu->supported_cpus, affinity);
 
 	for_each_cpu(cpu, &pmu->supported_cpus)
 		per_cpu(hw_events->irq, cpu) = irq;
@@ -115,9 +114,12 @@ static int pmu_parse_irqs(struct arm_pmu *pmu)
 	}
 
 	if (num_irqs == 1) {
-		int irq = platform_get_irq(pdev, 0);
+		const struct cpumask *affinity;
+		int irq;
+
+		irq = platform_get_irq_affinity(pdev, 0, &affinity);
 		if ((irq > 0) && irq_is_percpu_devid(irq))
-			return pmu_parse_percpu_irq(pmu, irq);
+			return pmu_parse_percpu_irq(pmu, irq, affinity);
 	}
 
 	if (nr_cpu_ids != 1 && !pmu_has_irq_affinity(dev->of_node))
Signature · 1 line
2.39.2
author maintainer
#15 lore raw

PATCH 9/25 perf: arm_spe_pmu: Convert to new IRQ affinity retrieval API

In reply to Marc Zyngier

Now that the relevant interrupt controllers are equipped with a callback returning the affinity of per-CPU interrupts, switch the ARM SPE driver over to this new method.

---
 drivers/perf/arm_spe_pmu.c | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)
drivers/perf/arm_spe_pmu.c +4 -5
index 369e77ad5f13f..a1c86a1f21427 100644
@@ -1211,8 +1211,10 @@ static void arm_spe_pmu_dev_teardown(struct arm_spe_pmu *spe_pmu)
 static int arm_spe_pmu_irq_probe(struct arm_spe_pmu *spe_pmu)
 {
 	struct platform_device *pdev = spe_pmu->pdev;
-	int irq = platform_get_irq(pdev, 0);
+	const struct cpumask *affinity;
+	int irq;
 
+	irq = platform_get_irq_affinity(pdev, 0, &affinity);
 	if (irq < 0)
 		return -ENXIO;
 
@@ -1221,10 +1223,7 @@ static int arm_spe_pmu_irq_probe(struct arm_spe_pmu *spe_pmu)
 		return -EINVAL;
 	}
 
-	if (irq_get_percpu_devid_partition(irq, &spe_pmu->supported_cpus)) {
-		dev_err(&pdev->dev, "failed to get PPI partition (%d)\n", irq);
-		return -EINVAL;
-	}
+	cpumask_copy(&spe_pmu->supported_cpus, affinity);
 
 	spe_pmu->irq = irq;
 	return 0;
Signature · 1 line
2.39.2
author maintainer
#16 lore raw

PATCH 10/25 perf: arm_pmu: Add PMU/CPU affinity tracking

In reply to Marc Zyngier

The ARM PMU code is built around the assumption that different CPU affinities (either a single CPU in the case of an SPI, or a group of CPUs for a PPI) must result in different IRQ numbers.

This scheme is about to be removed, so the driver must be able to match the new behaviour.

For this purpose, add a new per-CPU variable that tracks the PMU affinities on a per-CPU basis, so that the driver can, from any CPU, find out which other CPUs it is sharing an interrupt number with.

It is likely that some simplifications could result from this scheme, but this is good enough to get started.

---
 drivers/perf/arm_pmu.c          | 37 +++++++++++++++++++++++++--------
 drivers/perf/arm_pmu_acpi.c     |  5 +++++
 drivers/perf/arm_pmu_platform.c |  4 ++++
 include/linux/perf/arm_pmu.h    |  1 +
 4 files changed, 38 insertions(+), 9 deletions(-)
drivers/perf/arm_pmu.c +28 -9
index 5c310e803dd78..6e3c72e9b41cd 100644
@@ -26,7 +26,7 @@
 
 #include <asm/irq_regs.h>
 
-static int armpmu_count_irq_users(const int irq);
+static int armpmu_count_irq_users(const int this_cpu, const int irq);
 
 struct pmu_irq_ops {
 	void (*enable_pmuirq)(unsigned int irq);
@@ -64,7 +64,7 @@ static void armpmu_enable_percpu_pmuirq(unsigned int irq)
 static void armpmu_free_percpu_pmuirq(unsigned int irq, int cpu,
 				   void __percpu *devid)
 {
-	if (armpmu_count_irq_users(irq) == 1)
+	if (armpmu_count_irq_users(cpu, irq) == 1)
 		free_percpu_irq(irq, devid);
 }
 
@@ -89,7 +89,7 @@ static void armpmu_disable_percpu_pmunmi(unsigned int irq)
 static void armpmu_free_percpu_pmunmi(unsigned int irq, int cpu,
 				      void __percpu *devid)
 {
-	if (armpmu_count_irq_users(irq) == 1)
+	if (armpmu_count_irq_users(cpu, irq) == 1)
 		free_percpu_nmi(irq, devid);
 }
 
@@ -100,11 +100,20 @@ static const struct pmu_irq_ops percpu_pmunmi_ops = {
 };
 
 DEFINE_PER_CPU(struct arm_pmu *, cpu_armpmu);
+static DEFINE_PER_CPU(const struct cpumask *, pmu_affinity);
 static DEFINE_PER_CPU(int, cpu_irq);
 static DEFINE_PER_CPU(const struct pmu_irq_ops *, cpu_irq_ops);
 
 static bool has_nmi;
 
+void armpmu_register_affinity_group(const struct cpumask *aff_grp)
+{
+	int cpu;
+
+	for_each_cpu(cpu, aff_grp)
+		per_cpu(pmu_affinity, cpu) = aff_grp;
+}
+
 static inline u64 arm_pmu_event_max_period(struct perf_event *event)
 {
 	if (event->hw.flags & ARMPMU_EVT_64BIT)
@@ -580,11 +589,16 @@ static const struct attribute_group armpmu_common_attr_group = {
 	.attrs = armpmu_common_attrs,
 };
 
-static int armpmu_count_irq_users(const int irq)
+static int armpmu_count_irq_users(const int this_cpu, const int irq)
 {
+	const struct cpumask *affinity;
 	int cpu, count = 0;
 
-	for_each_possible_cpu(cpu) {
+	affinity = per_cpu(pmu_affinity, this_cpu);
+	if (WARN_ON(!affinity))
+		return 0;
+
+	for_each_cpu(cpu, affinity) {
 		if (per_cpu(cpu_irq, cpu) == irq)
 			count++;
 	}
@@ -592,12 +606,17 @@ static int armpmu_count_irq_users(const int irq)
 	return count;
 }
 
-static const struct pmu_irq_ops *armpmu_find_irq_ops(int irq)
+static const struct pmu_irq_ops *armpmu_find_irq_ops(int this_cpu, int irq)
 {
 	const struct pmu_irq_ops *ops = NULL;
+	const struct cpumask *affinity;
 	int cpu;
 
-	for_each_possible_cpu(cpu) {
+	affinity = per_cpu(pmu_affinity, this_cpu);
+	if (!affinity)
+		return NULL;
+
+	for_each_cpu(cpu, affinity) {
 		if (per_cpu(cpu_irq, cpu) != irq)
 			continue;
 
@@ -658,7 +677,7 @@ int armpmu_request_irq(int irq, int cpu)
 			has_nmi = true;
 			irq_ops = &pmunmi_ops;
 		}
-	} else if (armpmu_count_irq_users(irq) == 0) {
+	} else if (armpmu_count_irq_users(cpu, irq) == 0) {
 		err = request_percpu_nmi(irq, handler, "arm-pmu", &cpu_armpmu);
 
 		/* If cannot get an NMI, get a normal interrupt */
@@ -672,7 +691,7 @@ int armpmu_request_irq(int irq, int cpu)
 		}
 	} else {
 		/* Per cpudevid irq was already requested by another CPU */
-		irq_ops = armpmu_find_irq_ops(irq);
+		irq_ops = armpmu_find_irq_ops(cpu, irq);
 
 		if (WARN_ON(!irq_ops))
 			err = -EINVAL;
drivers/perf/arm_pmu_acpi.c +5 -0
index 05dda19c5359a..a5956fa728070 100644
@@ -212,6 +212,11 @@ static int arm_pmu_acpi_parse_irqs(void)
 			pr_warn("No ACPI PMU IRQ for CPU%d\n", cpu);
 		}
 
+		if (irq_is_percpu_devid(irq))
+			armpmu_register_affinity_group(cpu_possible_mask);
+		else
+			armpmu_register_affinity_group(cpumask_of(cpu));
+
 		/*
 		 * Log and request the IRQ so the core arm_pmu code can manage
 		 * it. We'll have to sanity-check IRQs later when we associate
drivers/perf/arm_pmu_platform.c +4 -0
index 9c0494d8a867a..0c7d5065e9074 100644
@@ -53,6 +53,8 @@ static int pmu_parse_percpu_irq(struct arm_pmu *pmu, int irq,
 	for_each_cpu(cpu, &pmu->supported_cpus)
 		per_cpu(hw_events->irq, cpu) = irq;
 
+	armpmu_register_affinity_group(&pmu->supported_cpus);
+
 	return 0;
 }
 
@@ -152,6 +154,8 @@ static int pmu_parse_irqs(struct arm_pmu *pmu)
 		cpumask_set_cpu(cpu, &pmu->supported_cpus);
 	}
 
+	armpmu_register_affinity_group(&pmu->supported_cpus);
+
 	return 0;
 }
 
include/linux/perf/arm_pmu.h +1 -0
index 93c9a26492fcf..7bf548678b288 100644
@@ -171,6 +171,7 @@ struct pmu_probe_info {
 int arm_pmu_device_probe(struct platform_device *pdev,
 			 const struct of_device_id *of_table,
 			 const struct pmu_probe_info *probe_table);
+void armpmu_register_affinity_group(const struct cpumask *);
 
 #ifdef CONFIG_ACPI
 int arm_pmu_acpi_probe(armpmu_init_fn init_fn);
Signature · 1 line
2.39.2
author maintainer
#17 lore raw

PATCH 11/25 genirq: Merge irqaction::{dev_id,percpu_dev_id}

In reply to Marc Zyngier

When irqaction::percpu_dev_id was introduced, it was hoped that it could be part of an anonymous union with dev_id, as the two fields are mutually exclusive.

However, toolchains used at the time were often showing terrible support for anonymous unions, breaking the build on a number of architectures. It was therefore decided to keep the two fields separate and address this down the line.

14 years later, the compiler dark age is over, and there is universal support for anonymous unions. Let's get a whole pointer back that can immediately be spent on something else.

---
 include/linux/interrupt.h | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)
include/linux/interrupt.h +4 -2
index 51b6484c04934..0ec1a71ab4e84 100644
@@ -121,8 +121,10 @@ typedef irqreturn_t (*irq_handler_t)(int, void *);
  */
 struct irqaction {
 	irq_handler_t		handler;
-	void			*dev_id;
-	void __percpu		*percpu_dev_id;
+	union {
+		void		*dev_id;
+		void __percpu	*percpu_dev_id;
+	};
 	struct irqaction	*next;
 	irq_handler_t		thread_fn;
 	struct task_struct	*thread;
Signature · 1 line
2.39.2
author maintainer
#18 lore raw

PATCH 12/25 genirq: Factor-in percpu irqaction creation

In reply to Marc Zyngier

Move the code creating a per-cpu irqaction into its own helper, so that future changes to this code can be kept localised.

At the same time, fix the documentation which appears to say the wrong thing when it comes to interrupts being automatically enabled (percpu_devid interrupts never are).

---
 kernel/irq/manage.c | 43 +++++++++++++++++++++++++++----------------
 1 file changed, 27 insertions(+), 16 deletions(-)
kernel/irq/manage.c +27 -16
index c94837382037e..980725bd93e95 100644
@@ -2442,6 +2442,26 @@ int setup_percpu_irq(unsigned int irq, struct irqaction *act)
 	return retval;
 }
 
+static
+struct irqaction *create_percpu_irqaction(irq_handler_t handler,
+					  unsigned long flags,
+					  const char *devname,
+					  void __percpu *dev_id)
+{
+	struct irqaction *action;
+
+	action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
+	if (!action)
+		return NULL;
+
+	action->handler = handler;
+	action->flags = flags | IRQF_PERCPU | IRQF_NO_SUSPEND;
+	action->name = devname;
+	action->percpu_dev_id = dev_id;
+
+	return action;
+}
+
 /**
  * __request_percpu_irq - allocate a percpu interrupt line
  * @irq:	Interrupt line to allocate
@@ -2450,9 +2470,9 @@ int setup_percpu_irq(unsigned int irq, struct irqaction *act)
  * @devname:	An ascii name for the claiming device
  * @dev_id:	A percpu cookie passed back to the handler function
  *
- * This call allocates interrupt resources and enables the interrupt on the
- * local CPU. If the interrupt is supposed to be enabled on other CPUs, it
- * has to be done on each CPU using enable_percpu_irq().
+ * This call allocates interrupt resources, but doesn't enable the interrupt
+ * on any CPU, as all percpu-devid interrupts are flagged with IRQ_NOAUTOEN.
+ * It has to be done on each CPU using enable_percpu_irq().
  *
  * @dev_id must be globally unique. It is a per-cpu variable, and
  * the handler gets called with the interrupted CPU's instance of
@@ -2477,15 +2497,10 @@ int __request_percpu_irq(unsigned int irq, irq_handler_t handler,
 	if (flags && flags != IRQF_TIMER)
 		return -EINVAL;
 
-	action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
+	action = create_percpu_irqaction(handler, flags, devname, dev_id);
 	if (!action)
 		return -ENOMEM;
 
-	action->handler = handler;
-	action->flags = flags | IRQF_PERCPU | IRQF_NO_SUSPEND;
-	action->name = devname;
-	action->percpu_dev_id = dev_id;
-
 	retval = irq_chip_pm_get(&desc->irq_data);
 	if (retval < 0) {
 		kfree(action);
@@ -2546,16 +2561,12 @@ int request_percpu_nmi(unsigned int irq, irq_handler_t handler,
 	if (irq_is_nmi(desc))
 		return -EINVAL;
 
-	action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
+	action = create_percpu_irqaction(handler,
+					 IRQF_NO_THREAD | IRQF_NOBALANCING,
+					 name, dev_id);
 	if (!action)
 		return -ENOMEM;
 
-	action->handler = handler;
-	action->flags = IRQF_PERCPU | IRQF_NO_SUSPEND | IRQF_NO_THREAD
-		| IRQF_NOBALANCING;
-	action->name = name;
-	action->percpu_dev_id = dev_id;
-
 	retval = irq_chip_pm_get(&desc->irq_data);
 	if (retval < 0)
 		goto err_out;
Signature · 1 line
2.39.2
#19 lore raw

Re: [PATCH 12/25] genirq: Factor-in percpu irqaction creation

kernel/irq/manage.c int setup_percpu_irq(unsigned int irq, struct irqaction *act) · line 2449

Quoted 6 lines · Marc Zyngier
kernel/irq/manage.c +5 -0
+static
+struct irqaction *create_percpu_irqaction(irq_handler_t handler,
+					  unsigned long flags,
+					  const char *devname,
+					  void __percpu *dev_id)

static struct irqaction *create_percpu_irqaction(irq_handler_t handler, unsigned long flags,
const char *devname, void __percpu *dev_id)
{

No?

kernel/irq/manage.c int setup_percpu_irq(unsigned int irq, struct irqaction *act) · line 2453

Quoted 4 lines
kernel/irq/manage.c +4 -0
+{
+	struct irqaction *action;
+
+	action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
	struct irqaction *action = kzalloc(sizeof(*action),.....;

kernel/irq/manage.c int request_percpu_nmi(unsigned int irq, irq_handler_t handler, · line 2566

Quoted 4 lines
kernel/irq/manage.c +3 -1
-	action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
+	action = create_percpu_irqaction(handler,
+					 IRQF_NO_THREAD | IRQF_NOBALANCING,
+					 name, dev_id);

Please get rid of these artifical line breaks. You have 100 characters.

Thanks,

tglx

author maintainer
#20 lore raw

PATCH 13/25 genirq: Add affinity to percpu_devid interrupt requests

In reply to Marc Zyngier

Add an affinity field to both the irqaction structure and the interrupt request primitives. Nothing is making use of it yet, and the only value used it NULL, which is used as a shorthand for cpu_possible_mask.

This will shortly get used with actual affinities.

---
 include/linux/interrupt.h |  5 +++--
 kernel/irq/manage.c       | 13 ++++++++++---
 2 files changed, 13 insertions(+), 5 deletions(-)
include/linux/interrupt.h +3 -2
index 0ec1a71ab4e84..52147d5f432b3 100644
@@ -125,6 +125,7 @@ struct irqaction {
 		void		*dev_id;
 		void __percpu	*percpu_dev_id;
 	};
+	const struct cpumask	*affinity;
 	struct irqaction	*next;
 	irq_handler_t		thread_fn;
 	struct task_struct	*thread;
@@ -181,7 +182,7 @@ request_any_context_irq(unsigned int irq, irq_handler_t handler,
 extern int __must_check
 __request_percpu_irq(unsigned int irq, irq_handler_t handler,
 		     unsigned long flags, const char *devname,
-		     void __percpu *percpu_dev_id);
+		     const cpumask_t *affinity, void __percpu *percpu_dev_id);
 
 extern int __must_check
 request_nmi(unsigned int irq, irq_handler_t handler, unsigned long flags,
@@ -192,7 +193,7 @@ request_percpu_irq(unsigned int irq, irq_handler_t handler,
 		   const char *devname, void __percpu *percpu_dev_id)
 {
 	return __request_percpu_irq(irq, handler, 0,
-				    devname, percpu_dev_id);
+				    devname, NULL, percpu_dev_id);
 }
 
 extern int __must_check
kernel/irq/manage.c +10 -3
index 980725bd93e95..ac394f0b422b8 100644
@@ -2446,10 +2446,14 @@ static
 struct irqaction *create_percpu_irqaction(irq_handler_t handler,
 					  unsigned long flags,
 					  const char *devname,
+					  const cpumask_t *affinity,
 					  void __percpu *dev_id)
 {
 	struct irqaction *action;
 
+	if (!affinity)
+		affinity = cpu_possible_mask;
+
 	action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
 	if (!action)
 		return NULL;
@@ -2458,6 +2462,7 @@ struct irqaction *create_percpu_irqaction(irq_handler_t handler,
 	action->flags = flags | IRQF_PERCPU | IRQF_NO_SUSPEND;
 	action->name = devname;
 	action->percpu_dev_id = dev_id;
+	action->affinity = affinity;
 
 	return action;
 }
@@ -2468,6 +2473,7 @@ struct irqaction *create_percpu_irqaction(irq_handler_t handler,
  * @handler:	Function to be called when the IRQ occurs.
  * @flags:	Interrupt type flags (IRQF_TIMER only)
  * @devname:	An ascii name for the claiming device
+ * @affinity:	A cpumask describing the target CPUs for this interrupt
  * @dev_id:	A percpu cookie passed back to the handler function
  *
  * This call allocates interrupt resources, but doesn't enable the interrupt
@@ -2480,7 +2486,7 @@ struct irqaction *create_percpu_irqaction(irq_handler_t handler,
  */
 int __request_percpu_irq(unsigned int irq, irq_handler_t handler,
 			 unsigned long flags, const char *devname,
-			 void __percpu *dev_id)
+			 const cpumask_t *affinity, void __percpu *dev_id)
 {
 	struct irqaction *action;
 	struct irq_desc *desc;
@@ -2497,7 +2503,8 @@ int __request_percpu_irq(unsigned int irq, irq_handler_t handler,
 	if (flags && flags != IRQF_TIMER)
 		return -EINVAL;
 
-	action = create_percpu_irqaction(handler, flags, devname, dev_id);
+	action = create_percpu_irqaction(handler, flags, devname,
+					 affinity, dev_id);
 	if (!action)
 		return -ENOMEM;
 
@@ -2563,7 +2570,7 @@ int request_percpu_nmi(unsigned int irq, irq_handler_t handler,
 
 	action = create_percpu_irqaction(handler,
 					 IRQF_NO_THREAD | IRQF_NOBALANCING,
-					 name, dev_id);
+					 name, NULL, dev_id);
 	if (!action)
 		return -ENOMEM;
 
Signature · 1 line
2.39.2
author maintainer
#21 lore raw

PATCH 14/25 genirq: Update request_percpu_nmi() to take an affinity

In reply to Marc Zyngier

Continue spreading the notion of affinity to the percpu interrupt request code by updating the call sites that use request_percpu_nmi() (all two of them) to take an affinity pointer. This pointer is firmly NULL for now.

---
 arch/arm64/kernel/smp.c   |  2 +-
 drivers/perf/arm_pmu.c    |  4 +++-
 include/linux/interrupt.h |  4 ++--
 kernel/irq/manage.c       | 11 +++++++----
 4 files changed, 13 insertions(+), 8 deletions(-)
arch/arm64/kernel/smp.c +1 -1
index 68cea3a4a35ca..6fb838eee2e7d 100644
@@ -1094,7 +1094,7 @@ static void ipi_setup_sgi(int ipi)
 	irq = ipi_irq_base + ipi;
 
 	if (ipi_should_be_nmi(ipi)) {
-		err = request_percpu_nmi(irq, ipi_handler, "IPI", &irq_stat);
+		err = request_percpu_nmi(irq, ipi_handler, "IPI", NULL, &irq_stat);
 		WARN(err, "Could not request IRQ %d as NMI, err=%d\n", irq, err);
 	} else {
 		err = request_percpu_irq(irq, ipi_handler, "IPI", &irq_stat);
drivers/perf/arm_pmu.c +3 -1
index 6e3c72e9b41cd..d1f738eb77f1e 100644
@@ -678,7 +678,9 @@ int armpmu_request_irq(int irq, int cpu)
 			irq_ops = &pmunmi_ops;
 		}
 	} else if (armpmu_count_irq_users(cpu, irq) == 0) {
-		err = request_percpu_nmi(irq, handler, "arm-pmu", &cpu_armpmu);
+		err = request_percpu_nmi(irq, handler, "arm-pmu",
+					 NULL,
+					 &cpu_armpmu);
 
 		/* If cannot get an NMI, get a normal interrupt */
 		if (err) {
include/linux/interrupt.h +2 -2
index 52147d5f432b3..2134e7c08c169 100644
@@ -197,8 +197,8 @@ request_percpu_irq(unsigned int irq, irq_handler_t handler,
 }
 
 extern int __must_check
-request_percpu_nmi(unsigned int irq, irq_handler_t handler,
-		   const char *devname, void __percpu *dev);
+request_percpu_nmi(unsigned int irq, irq_handler_t handler, const char *devname,
+		   const struct cpumask *affinity, void __percpu *dev_id);
 
 extern const void *free_irq(unsigned int, void *);
 extern void free_percpu_irq(unsigned int, void __percpu *);
kernel/irq/manage.c +7 -4
index ac394f0b422b8..a17ac522622e7 100644
@@ -2530,6 +2530,7 @@ EXPORT_SYMBOL_GPL(__request_percpu_irq);
  * @irq:	Interrupt line to allocate
  * @handler:	Function to be called when the IRQ occurs.
  * @name:	An ascii name for the claiming device
+ * @affinity:	A cpumask describing the target CPUs for this interrupt
  * @dev_id:	A percpu cookie passed back to the handler function
  *
  * This call allocates interrupt resources for a per CPU NMI. Per CPU NMIs
@@ -2547,7 +2548,8 @@ EXPORT_SYMBOL_GPL(__request_percpu_irq);
  * will fail returning a negative value.
  */
 int request_percpu_nmi(unsigned int irq, irq_handler_t handler,
-		       const char *name, void __percpu *dev_id)
+		       const char *name,
+		       const struct cpumask *affinity, void __percpu *dev_id)
 {
 	struct irqaction *action;
 	struct irq_desc *desc;
@@ -2564,13 +2566,14 @@ int request_percpu_nmi(unsigned int irq, irq_handler_t handler,
 	    !irq_supports_nmi(desc))
 		return -EINVAL;
 
-	/* The line cannot already be NMI */
-	if (irq_is_nmi(desc))
+	/* The line cannot be NMI already if the new request covers all CPUs */
+	if (irq_is_nmi(desc) &&
+	    (!affinity || cpumask_equal(affinity, cpu_possible_mask)))
 		return -EINVAL;
 
 	action = create_percpu_irqaction(handler,
 					 IRQF_NO_THREAD | IRQF_NOBALANCING,
-					 name, NULL, dev_id);
+					 name, affinity, dev_id);
 	if (!action)
 		return -ENOMEM;
 
Signature · 1 line
2.39.2
#22 lore raw

Re: [PATCH 14/25] genirq: Update request_percpu_nmi() to take an affinity

kernel/irq/manage.c int request_percpu_nmi(unsigned int irq, irq_handler_t handler, · line 2572

Quoted 10 lines · Marc Zyngier
kernel/irq/manage.c +3 -2
@@ -2564,13 +2566,14 @@ int request_percpu_nmi(unsigned int irq, irq_handler_t handler,
 	    !irq_supports_nmi(desc))
 		return -EINVAL;
 
-	/* The line cannot already be NMI */
-	if (irq_is_nmi(desc))
+	/* The line cannot be NMI already if the new request covers all CPUs */
+	if (irq_is_nmi(desc) &&
+	    (!affinity || cpumask_equal(affinity, cpu_possible_mask)))
 		return -EINVAL;

This check looks odd. What makes sure that the affinities do not overlap?

Thanks,

tglx

author maintainer
#23 lore raw

Re: [PATCH 14/25] genirq: Update request_percpu_nmi() to take an affinity

Quoted 6 lines · Thomas Gleixner
Quoted 4 lines · Marc Zyngier
kernel/irq/manage.c +0 -0
@@ -2564,13 +2566,14 @@ int request_percpu_nmi(unsigned int irq, irq_handler_t handler,
 	    !irq_supports_nmi(desc))
 		return -EINVAL;
 
Quoted 9 lines

kernel/irq/manage.c int request_percpu_nmi(unsigned int irq, irq_handler_t handler, · line 2572

Quoted 6 lines
kernel/irq/manage.c +3 -2
-	/* The line cannot already be NMI */
-	if (irq_is_nmi(desc))
+	/* The line cannot be NMI already if the new request covers all CPUs */
+	if (irq_is_nmi(desc) &&
+	    (!affinity || cpumask_equal(affinity, cpu_possible_mask)))
 		return -EINVAL;

This check looks odd. What makes sure that the affinities do not overlap?

The following patch in the series does, at the point of adding the new irqaction to the list. This is modelled after the current handling of shared interrupts.

	M.
Signature · 1 line
Without deviation from the norm, progress is not possible.
author maintainer
#24 lore raw

PATCH 15/25 genirq: Allow per-cpu interrupt sharing for non-overlapping affinities

In reply to Marc Zyngier

Interrupt sharing for percpu-devid interrupts is forbidden, and for good reasons. These are interrupts generated *from* a CPU and handled by itself (timer, for example). Nobody in their right mind would put two devices on the same pin (and if they have, they get to keep the pieces...).

But this also prevents more benign cases, where devices are connected to groups of CPUs, and for which the affinities are not overlapping. Effectively, the only thing they share is the interrupt number, and nothing else.

Let's tweak the definition of IRQF_SHARED applied to percpu_devid interrupts to allow this particular case. This results in extra validation at the point of the interrupt being setup and freed, as well as a tiny bit of extra complexity for interrupts at handling time (to pick the correct irqaction).

---
 kernel/irq/chip.c   |  8 ++++--
 kernel/irq/manage.c | 67 +++++++++++++++++++++++++++++++++++++--------
 2 files changed, 61 insertions(+), 14 deletions(-)
kernel/irq/chip.c +6 -2
index 0d0276378c707..af90dd440d5ee 100644
@@ -897,8 +897,9 @@ void handle_percpu_irq(struct irq_desc *desc)
 void handle_percpu_devid_irq(struct irq_desc *desc)
 {
 	struct irq_chip *chip = irq_desc_get_chip(desc);
-	struct irqaction *action = desc->action;
 	unsigned int irq = irq_desc_get_irq(desc);
+	unsigned int cpu = smp_processor_id();
+	struct irqaction *action;
 	irqreturn_t res;
 
 	/*
@@ -910,12 +911,15 @@ void handle_percpu_devid_irq(struct irq_desc *desc)
 	if (chip->irq_ack)
 		chip->irq_ack(&desc->irq_data);
 
+	for (action = desc->action; action; action = action->next)
+		if (cpumask_test_cpu(cpu, action->affinity))
+			break;
+
 	if (likely(action)) {
 		trace_irq_handler_entry(irq, action);
 		res = action->handler(irq, raw_cpu_ptr(action->percpu_dev_id));
 		trace_irq_handler_exit(irq, action, res);
 	} else {
-		unsigned int cpu = smp_processor_id();
 		bool enabled = cpumask_test_cpu(cpu, desc->percpu_enabled);
 
 		if (enabled)
kernel/irq/manage.c +55 -12

127 lines not on this page · raw message

Signature · 1 line
2.39.2
author maintainer
#25 lore raw

Re: [PATCH 15/25] genirq: Allow per-cpu interrupt sharing for non-overlapping affinities

Quoted 46 lines · Marc Zyngier

Interrupt sharing for percpu-devid interrupts is forbidden, and for good reasons. These are interrupts generated *from* a CPU and handled by itself (timer, for example). Nobody in their right mind would put two devices on the same pin (and if they have, they get to keep the pieces...).

But this also prevents more benign cases, where devices are connected to groups of CPUs, and for which the affinities are not overlapping. Effectively, the only thing they share is the interrupt number, and nothing else.

Let's tweak the definition of IRQF_SHARED applied to percpu_devid interrupts to allow this particular case. This results in extra validation at the point of the interrupt being setup and freed, as well as a tiny bit of extra complexity for interrupts at handling time (to pick the correct irqaction).

---
 kernel/irq/chip.c   |  8 ++++--
 kernel/irq/manage.c | 67 +++++++++++++++++++++++++++++++++++++--------
 2 files changed, 61 insertions(+), 14 deletions(-)
kernel/irq/chip.c +5 -1
index 0d0276378c707..af90dd440d5ee 100644
@@ -897,8 +897,9 @@ void handle_percpu_irq(struct irq_desc *desc)
 void handle_percpu_devid_irq(struct irq_desc *desc)
 {
 	struct irq_chip *chip = irq_desc_get_chip(desc);
-	struct irqaction *action = desc->action;
 	unsigned int irq = irq_desc_get_irq(desc);
+	unsigned int cpu = smp_processor_id();
+	struct irqaction *action;
 	irqreturn_t res;
 
 	/*
@@ -910,12 +911,15 @@ void handle_percpu_devid_irq(struct irq_desc *desc)
 	if (chip->irq_ack)
 		chip->irq_ack(&desc->irq_data);
 
+	for (action = desc->action; action; action = action->next)
+		if (cpumask_test_cpu(cpu, action->affinity))
+			break;

kernel/irq/chip.c void handle_percpu_devid_irq(struct irq_desc *desc) · line 925

Quoted 10 lines
kernel/irq/chip.c +1 -1
+
 	if (likely(action)) {
 		trace_irq_handler_entry(irq, action);
 		res = action->handler(irq, raw_cpu_ptr(action->percpu_dev_id));
 		trace_irq_handler_exit(irq, action, res);
 	} else {
-		unsigned int cpu = smp_processor_id();
 		bool enabled = cpumask_test_cpu(cpu, desc->percpu_enabled);
 
 		if (enabled)

As Will points out off the list, the above lacks the a similar handling for percpu_devid NMIs, leading to NMIs that are only handled on the first affinity group.

It's easy enough to move the above to common code and share it with handle_percpu_devid_fasteoi_nmi(), but at this point there is hardly any difference with handle_percpu_devid_irq().

Any objection to simply killing the NMI version?

Thanks,

	M.
Signature · 1 line
Without deviation from the norm, progress is not possible.
#26 lore raw

Re: [PATCH 15/25] genirq: Allow per-cpu interrupt sharing for non-overlapping affinities

Quoted 10 lines · Marc Zyngier

On Mon, 08 Sep 2025 17:31:17 +0100,
As Will points out off the list, the above lacks the a similar handling for percpu_devid NMIs, leading to NMIs that are only handled on the first affinity group.

It's easy enough to move the above to common code and share it with handle_percpu_devid_fasteoi_nmi(), but at this point there is hardly any difference with handle_percpu_devid_irq().

Any objection to simply killing the NMI version?

Removing code is always appreciated :)

author maintainer
#27 lore raw

Re: [PATCH 15/25] genirq: Allow per-cpu interrupt sharing for non-overlapping affinities

Quoted 7 lines · Thomas Gleixner
Quoted 5 lines · Marc Zyngier

On Mon, 08 Sep 2025 17:31:17 +0100,
As Will points out off the list, the above lacks the a similar handling for percpu_devid NMIs, leading to NMIs that are only handled on the first affinity group.

Quoted 8 lines
Quoted 5 lines

It's easy enough to move the above to common code and share it with handle_percpu_devid_fasteoi_nmi(), but at this point there is hardly any difference with handle_percpu_devid_irq().

Any objection to simply killing the NMI version?

Removing code is always appreciated :)

Works for me!

	M.
Signature · 1 line
Without deviation from the norm, progress is not possible.
author maintainer
#28 lore raw

PATCH 16/25 genirq: Add request_percpu_irq_affinity() helper

In reply to Marc Zyngier

While it would be nice to simply make request_percpu_irq() take an affinity mask, the churn is likely to be on the irritating side given that most drivers do not give a damn about affinities.

So take the more innocuous path to provide a helper that parallels request_percpu_irq(), with an affinity as a bonus argument.

Yes, request_percpu_irq_affinity() is a bit of a mouthful.

---
 include/linux/interrupt.h | 9 +++++++++
 1 file changed, 9 insertions(+)
include/linux/interrupt.h +9 -0
index 2134e7c08c169..c8e6f4895782c 100644
@@ -196,6 +196,15 @@ request_percpu_irq(unsigned int irq, irq_handler_t handler,
 				    devname, NULL, percpu_dev_id);
 }
 
+static inline int __must_check
+request_percpu_irq_affinity(unsigned int irq, irq_handler_t handler,
+			    const char *devname, const cpumask_t *affinity,
+			    void __percpu *percpu_dev_id)
+{
+	return __request_percpu_irq(irq, handler, 0,
+				    devname, affinity, percpu_dev_id);
+}
+
 extern int __must_check
 request_percpu_nmi(unsigned int irq, irq_handler_t handler, const char *devname,
 		   const struct cpumask *affinity, void __percpu *dev_id);
Signature · 1 line
2.39.2
author maintainer
#29 lore raw

PATCH 17/25 perf: arm_pmu: Use a backend-specific pointer for percpu interrupt request

In reply to Marc Zyngier

From: Will Deacon <[email protected]>

DT and ACPI significantly differ in the way the PMU probing is conducted, resulting in different data being available at different times.

Work around this by providing a per-cpu 'struct arm_pmu *' as a parameter, instead of sampling it from a per-cpu variable.

---
 drivers/perf/arm_pmu.c          | 10 +++++-----
 drivers/perf/arm_pmu_acpi.c     |  2 +-
 drivers/perf/arm_pmu_platform.c |  4 ++--
 include/linux/perf/arm_pmu.h    |  4 ++--
 4 files changed, 10 insertions(+), 10 deletions(-)
drivers/perf/arm_pmu.c +5 -5
index d1f738eb77f1e..044c9c6296997 100644
@@ -628,20 +628,20 @@ static const struct pmu_irq_ops *armpmu_find_irq_ops(int this_cpu, int irq)
 	return ops;
 }
 
-void armpmu_free_irq(int irq, int cpu)
+void armpmu_free_irq(struct arm_pmu * __percpu *armpmu, int irq, int cpu)
 {
 	if (per_cpu(cpu_irq, cpu) == 0)
 		return;
 	if (WARN_ON(irq != per_cpu(cpu_irq, cpu)))
 		return;
 
-	per_cpu(cpu_irq_ops, cpu)->free_pmuirq(irq, cpu, &cpu_armpmu);
+	per_cpu(cpu_irq_ops, cpu)->free_pmuirq(irq, cpu, armpmu);
 
 	per_cpu(cpu_irq, cpu) = 0;
 	per_cpu(cpu_irq_ops, cpu) = NULL;
 }
 
-int armpmu_request_irq(int irq, int cpu)
+int armpmu_request_irq(struct arm_pmu * __percpu *armpmu, int irq, int cpu)
 {
 	int err = 0;
 	const irq_handler_t handler = armpmu_dispatch_irq;
@@ -666,12 +666,12 @@ int armpmu_request_irq(int irq, int cpu)
 			    IRQF_NO_THREAD;
 
 		err = request_nmi(irq, handler, irq_flags, "arm-pmu",
-				  per_cpu_ptr(&cpu_armpmu, cpu));
+				  per_cpu_ptr(armpmu, cpu));
 
 		/* If cannot get an NMI, get a normal interrupt */
 		if (err) {
 			err = request_irq(irq, handler, irq_flags, "arm-pmu",
-					  per_cpu_ptr(&cpu_armpmu, cpu));
+					  per_cpu_ptr(armpmu, cpu));
 			irq_ops = &pmuirq_ops;
 		} else {
 			has_nmi = true;
drivers/perf/arm_pmu_acpi.c +1 -1
index a5956fa728070..a28352e2bff0a 100644
@@ -223,7 +223,7 @@ static int arm_pmu_acpi_parse_irqs(void)
 		 * them with their PMUs.
 		 */
 		per_cpu(pmu_irqs, cpu) = irq;
-		err = armpmu_request_irq(irq, cpu);
+		err = armpmu_request_irq(&probed_pmus, irq, cpu);
 		if (err)
 			goto out_err;
 	}
drivers/perf/arm_pmu_platform.c +2 -2
index 0c7d5065e9074..d9b0e8f6debf2 100644
@@ -169,7 +169,7 @@ static int armpmu_request_irqs(struct arm_pmu *armpmu)
 		if (!irq)
 			continue;
 
-		err = armpmu_request_irq(irq, cpu);
+		err = armpmu_request_irq(&hw_events->percpu_pmu, irq, cpu);
 		if (err)
 			break;
 	}
@@ -185,7 +185,7 @@ static void armpmu_free_irqs(struct arm_pmu *armpmu)
 	for_each_cpu(cpu, &armpmu->supported_cpus) {
 		int irq = per_cpu(hw_events->irq, cpu);
 
-		armpmu_free_irq(irq, cpu);
+		armpmu_free_irq(&hw_events->percpu_pmu, irq, cpu);
 	}
 }
 
include/linux/perf/arm_pmu.h +2 -2
index 7bf548678b288..395d03c282e8c 100644
@@ -191,8 +191,8 @@ bool arm_pmu_irq_is_nmi(void);
 struct arm_pmu *armpmu_alloc(void);
 void armpmu_free(struct arm_pmu *pmu);
 int armpmu_register(struct arm_pmu *pmu);
-int armpmu_request_irq(int irq, int cpu);
-void armpmu_free_irq(int irq, int cpu);
+int armpmu_request_irq(struct arm_pmu * __percpu *armpmu, int irq, int cpu);
+void armpmu_free_irq(struct arm_pmu * __percpu *armpmu, int irq, int cpu);
 
 #define ARMV8_PMU_PDEV_NAME "armv8-pmu"
 
Signature · 1 line
2.39.2
author maintainer
#30 lore raw

PATCH 18/25 perf: arm_pmu: Request specific affinities for percpu NMI/IRQ

In reply to Marc Zyngier

Let the PMU driver request both NMI and normal IRQs with an affinity mask matching the PMU affinity.

---
 drivers/perf/arm_pmu.c | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)
drivers/perf/arm_pmu.c +5 -4
index 044c9c6296997..0d64e929d9bf0 100644
@@ -679,13 +679,14 @@ int armpmu_request_irq(struct arm_pmu * __percpu *armpmu, int irq, int cpu)
 		}
 	} else if (armpmu_count_irq_users(cpu, irq) == 0) {
 		err = request_percpu_nmi(irq, handler, "arm-pmu",
-					 NULL,
-					 &cpu_armpmu);
+					 per_cpu(pmu_affinity, cpu),
+					 armpmu);
 
 		/* If cannot get an NMI, get a normal interrupt */
 		if (err) {
-			err = request_percpu_irq(irq, handler, "arm-pmu",
-						 &cpu_armpmu);
+			err = request_percpu_irq_affinity(irq, handler, "arm-pmu",
+							  per_cpu(pmu_affinity, cpu),
+							  armpmu);
 			irq_ops = &percpu_pmuirq_ops;
 		} else {
 			has_nmi = true;
Signature · 1 line
2.39.2
author maintainer
#31 lore raw

PATCH 19/25 perf: arm_spe_pmu: Request specific affinities for percpu IRQ

In reply to Marc Zyngier

Let the SPE driver request IRQs with an affinity mask matching the SPE implementation affinity.

---
 drivers/perf/arm_spe_pmu.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/perf/arm_spe_pmu.c +2 -2
index a1c86a1f21427..f8763f0771776 100644
@@ -1183,8 +1183,8 @@ static int arm_spe_pmu_dev_init(struct arm_spe_pmu *spe_pmu)
 		return -ENXIO;
 
 	/* Request our PPIs (note that the IRQ is still disabled) */
-	ret = request_percpu_irq(spe_pmu->irq, arm_spe_pmu_irq_handler, DRVNAME,
-				 spe_pmu->handle);
+	ret = request_percpu_irq_affinity(spe_pmu->irq, arm_spe_pmu_irq_handler,
+					  DRVNAME, mask, spe_pmu->handle);
 	if (ret)
 		return ret;
 
Signature · 1 line
2.39.2
author maintainer
#32 lore raw

PATCH 20/25 coresight: trbe: Request specific affinities for percpu IRQ

In reply to Marc Zyngier

Let the TRBE driver request IRQs with an affinity mask matching the TRBE implementation affinity.

---
 drivers/hwtracing/coresight/coresight-trbe.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/hwtracing/coresight/coresight-trbe.c +2 -1
index c512f8faa6012..4a84a6bc2e8fc 100644
@@ -1492,7 +1492,8 @@ static int arm_trbe_probe_irq(struct platform_device *pdev,
 	if (!drvdata->handle)
 		return -ENOMEM;
 
-	ret = request_percpu_irq(drvdata->irq, arm_trbe_irq_handler, DRVNAME, drvdata->handle);
+	ret = request_percpu_irq_affinity(drvdata->irq, arm_trbe_irq_handler, DRVNAME,
+					  affinity, drvdata->handle);
 	if (ret) {
 		free_percpu(drvdata->handle);
 		return ret;
Signature · 1 line
2.39.2
author maintainer
#33 lore raw

PATCH 21/25 irqchip/gic-v3: Drop support for custom PPI partitions

In reply to Marc Zyngier

We are finally getting there. The only thing getting in the way of correctly handling PPIs in the way they were intended is to drop the GICv3 hack that deals with PPI partitions.

---
 drivers/irqchip/Kconfig      |   1 -
 drivers/irqchip/irq-gic-v3.c | 133 +++--------------------------------
 2 files changed, 8 insertions(+), 126 deletions(-)
drivers/irqchip/Kconfig +0 -1
index 6d12c6ab9ea47..c31d2f99d7b91 100644
@@ -36,7 +36,6 @@ config GIC_NON_BANKED
 config ARM_GIC_V3
 	bool
 	select IRQ_DOMAIN_HIERARCHY
-	select PARTITION_PERCPU
 	select GENERIC_IRQ_EFFECTIVE_AFF_MASK if SMP
 	select HAVE_ARM_SMCCC_DISCOVERY
 	select IRQ_MSI_IOMMU
drivers/irqchip/irq-gic-v3.c +8 -125

209 lines not on this page · raw message

Signature · 1 line
2.39.2
author maintainer
#34 lore raw

PATCH 22/25 irqchip/apple-aic: Drop support for custom PMU irq partitions

In reply to Marc Zyngier

Similarly to what has been done for GICv3, drop the irq partitioning support from the AIC driver, effectively merging the two per-cpu interrupts for the PMU.

---
 drivers/irqchip/irq-apple-aic.c | 28 +++++++---------------------
 1 file changed, 7 insertions(+), 21 deletions(-)
drivers/irqchip/irq-apple-aic.c +7 -21
index dd89e50a72e83..5688411f9f0b8 100644
@@ -578,16 +578,9 @@ static void __exception_irq_entry aic_handle_fiq(struct pt_regs *regs)
 	}
 
 	if ((read_sysreg_s(SYS_IMP_APL_PMCR0_EL1) & (PMCR0_IMODE | PMCR0_IACT)) ==
-			(FIELD_PREP(PMCR0_IMODE, PMCR0_IMODE_FIQ) | PMCR0_IACT)) {
-		int irq;
-		if (cpumask_test_cpu(smp_processor_id(),
-				     &aic_irqc->fiq_aff[AIC_CPU_PMU_P]->aff))
-			irq = AIC_CPU_PMU_P;
-		else
-			irq = AIC_CPU_PMU_E;
+			(FIELD_PREP(PMCR0_IMODE, PMCR0_IMODE_FIQ) | PMCR0_IACT))
 		generic_handle_domain_irq(aic_irqc->hw_domain,
-					  AIC_FIQ_HWIRQ(irq));
-	}
+					  AIC_FIQ_HWIRQ(AIC_CPU_PMU_P));
 
 	if (static_branch_likely(&use_fast_ipi) &&
 	    (FIELD_GET(UPMCR0_IMODE, read_sysreg_s(SYS_IMP_APL_UPMCR0_EL1)) == UPMCR0_IMODE_FIQ) &&
@@ -632,18 +625,7 @@ static int aic_irq_domain_map(struct irq_domain *id, unsigned int irq,
 				    handle_fasteoi_irq, NULL, NULL);
 		irqd_set_single_target(irq_desc_get_irq_data(irq_to_desc(irq)));
 	} else {
-		int fiq = FIELD_GET(AIC_EVENT_NUM, hw);
-
-		switch (fiq) {
-		case AIC_CPU_PMU_P:
-		case AIC_CPU_PMU_E:
-			irq_set_percpu_devid_partition(irq, &ic->fiq_aff[fiq]->aff);
-			break;
-		default:
-			irq_set_percpu_devid(irq);
-			break;
-		}
-
+		irq_set_percpu_devid(irq);
 		irq_domain_set_info(id, irq, hw, &fiq_chip, id->host_data,
 				    handle_percpu_devid_irq, NULL, NULL);
 	}
@@ -735,6 +717,10 @@ static int aic_irq_domain_translate(struct irq_domain *id,
 				break;
 			}
 		}
+
+		/* Merge the two PMUs on a single interrupt */
+		if (*hwirq == AIC_CPU_PMU_E)
+			*hwirq = AIC_CPU_PMU_P;
 		break;
 	default:
 		return -EINVAL;
Signature · 1 line
2.39.2
author maintainer
#35 lore raw

PATCH 23/25 irqchip: Kill irq-partition-percpu

In reply to Marc Zyngier

This code is now completely unused, and nobody will ever miss it.

---
 drivers/irqchip/Kconfig                      |   3 -
 drivers/irqchip/Makefile                     |   1 -
 drivers/irqchip/irq-partition-percpu.c       | 241 -------------------
 include/linux/irqchip/irq-partition-percpu.h |  53 ----
 4 files changed, 298 deletions(-)
 delete mode 100644 drivers/irqchip/irq-partition-percpu.c
 delete mode 100644 include/linux/irqchip/irq-partition-percpu.h
drivers/irqchip/Kconfig +0 -3
index c31d2f99d7b91..4bb25d21f6e9b 100644
@@ -450,9 +450,6 @@ config LS_SCFG_MSI
 	depends on PCI_MSI
 	select IRQ_MSI_LIB
 
-config PARTITION_PERCPU
-	bool
-
 config STM32MP_EXTI
 	tristate "STM32MP extended interrupts and event controller"
 	depends on (ARCH_STM32 && !ARM_SINGLE_ARMV7M) || COMPILE_TEST
drivers/irqchip/Makefile +0 -1
index 93e3ced023bb8..da429f3e29ec7 100644
@@ -36,7 +36,6 @@ obj-$(CONFIG_ARM_GIC_V3)		+= irq-gic-v3.o irq-gic-v3-mbi.o irq-gic-common.o
 obj-$(CONFIG_ARM_GIC_ITS_PARENT)	+= irq-gic-its-msi-parent.o
 obj-$(CONFIG_ARM_GIC_V3_ITS)		+= irq-gic-v3-its.o irq-gic-v4.o
 obj-$(CONFIG_ARM_GIC_V3_ITS_FSL_MC)	+= irq-gic-v3-its-fsl-mc-msi.o
-obj-$(CONFIG_PARTITION_PERCPU)		+= irq-partition-percpu.o
 obj-$(CONFIG_ARM_GIC_V5)		+= irq-gic-v5.o irq-gic-v5-irs.o irq-gic-v5-its.o \
 					   irq-gic-v5-iwb.o
 obj-$(CONFIG_HISILICON_IRQ_MBIGEN)	+= irq-mbigen.o
drivers/irqchip/irq-partition-percpu.c deleted +0 -241

241 lines not on this page · raw message

include/linux/irqchip/irq-partition-percpu.h deleted +0 -53

53 lines not on this page · raw message

Signature · 1 line
2.39.2
author maintainer
#36 lore raw

PATCH 24/25 genirq: Kill irq_{g,s}et_percpu_devid_partition()

In reply to Marc Zyngier

These two helpers do not have any user anymore, and can be removed, together with the affinity field kept in the irqdesc structure.

---
 include/linux/irq.h     |  4 ----
 include/linux/irqdesc.h |  1 -
 kernel/irq/irqdesc.c    | 24 +-----------------------
 3 files changed, 1 insertion(+), 28 deletions(-)
include/linux/irq.h +0 -4
index 1d6b606a81efe..c107125f51283 100644
@@ -717,10 +717,6 @@ static inline void irq_set_chip_and_handler(unsigned int irq,
 }
 
 extern int irq_set_percpu_devid(unsigned int irq);
-extern int irq_set_percpu_devid_partition(unsigned int irq,
-					  const struct cpumask *affinity);
-extern int irq_get_percpu_devid_partition(unsigned int irq,
-					  struct cpumask *affinity);
 
 extern void
 __irq_set_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
include/linux/irqdesc.h +0 -1
index fd091c35d5721..37e0b5b5600a4 100644
@@ -82,7 +82,6 @@ struct irq_desc {
 	int			threads_handled_last;
 	raw_spinlock_t		lock;
 	struct cpumask		*percpu_enabled;
-	const struct cpumask	*percpu_affinity;
 #ifdef CONFIG_SMP
 	const struct cpumask	*affinity_hint;
 	struct irq_affinity_notify *affinity_notify;
kernel/irq/irqdesc.c +1 -23
index b64c57b44c203..79df6e3bc3958 100644
@@ -886,8 +886,7 @@ void __irq_put_desc_unlock(struct irq_desc *desc, unsigned long flags, bool bus)
 		chip_bus_sync_unlock(desc);
 }
 
-int irq_set_percpu_devid_partition(unsigned int irq,
-				   const struct cpumask *affinity)
+int irq_set_percpu_devid(unsigned int irq)
 {
 	struct irq_desc *desc = irq_to_desc(irq);
 
@@ -899,31 +898,10 @@ int irq_set_percpu_devid_partition(unsigned int irq,
 	if (!desc->percpu_enabled)
 		return -ENOMEM;
 
-	desc->percpu_affinity = affinity ? : cpu_possible_mask;
-
 	irq_set_percpu_devid_flags(irq);
 	return 0;
 }
 
-int irq_set_percpu_devid(unsigned int irq)
-{
-	return irq_set_percpu_devid_partition(irq, NULL);
-}
-
-int irq_get_percpu_devid_partition(unsigned int irq, struct cpumask *affinity)
-{
-	struct irq_desc *desc = irq_to_desc(irq);
-
-	if (!desc || !desc->percpu_enabled)
-		return -EINVAL;
-
-	if (affinity)
-		cpumask_copy(affinity, desc->percpu_affinity);
-
-	return 0;
-}
-EXPORT_SYMBOL_GPL(irq_get_percpu_devid_partition);
-
 void kstat_incr_irq_this_cpu(unsigned int irq)
 {
 	kstat_incr_irqs_this_cpu(irq_to_desc(irq));
Signature · 1 line
2.39.2
author maintainer
#37 lore raw

PATCH 25/25 perf: arm_pmu: Kill last use of per-CPU cpu_armpmu pointer

In reply to Marc Zyngier

Having removed the use of the cpu_armpmu per-CPU variable from the interrupt handling, the only user left is the BRBE scheduler hook.

It is easy to drop the use of this variable by following the pointer to the generic PMU structure, and get the arm_pmu structure from there.

Perform the conversion and kill cpu_armpmu altogether.

---
 drivers/perf/arm_pmu.c       | 5 -----
 drivers/perf/arm_pmuv3.c     | 2 +-
 include/linux/perf/arm_pmu.h | 2 --
 3 files changed, 1 insertion(+), 8 deletions(-)
drivers/perf/arm_pmu.c +0 -5
index 0d64e929d9bf0..8b3d7022a2d83 100644
@@ -99,7 +99,6 @@ static const struct pmu_irq_ops percpu_pmunmi_ops = {
 	.free_pmuirq = armpmu_free_percpu_pmunmi
 };
 
-DEFINE_PER_CPU(struct arm_pmu *, cpu_armpmu);
 static DEFINE_PER_CPU(const struct cpumask *, pmu_affinity);
 static DEFINE_PER_CPU(int, cpu_irq);
 static DEFINE_PER_CPU(const struct pmu_irq_ops *, cpu_irq_ops);
@@ -739,8 +738,6 @@ static int arm_perf_starting_cpu(unsigned int cpu, struct hlist_node *node)
 	if (pmu->reset)
 		pmu->reset(pmu);
 
-	per_cpu(cpu_armpmu, cpu) = pmu;
-
 	irq = armpmu_get_cpu_irq(pmu, cpu);
 	if (irq)
 		per_cpu(cpu_irq_ops, cpu)->enable_pmuirq(irq);
@@ -760,8 +757,6 @@ static int arm_perf_teardown_cpu(unsigned int cpu, struct hlist_node *node)
 	if (irq)
 		per_cpu(cpu_irq_ops, cpu)->disable_pmuirq(irq);
 
-	per_cpu(cpu_armpmu, cpu) = NULL;
-
 	return 0;
 }
 
drivers/perf/arm_pmuv3.c +1 -1
index f6d7bab5d555c..2dee2d928aaef 100644
@@ -1039,7 +1039,7 @@ static int armv8pmu_user_event_idx(struct perf_event *event)
 static void armv8pmu_sched_task(struct perf_event_pmu_context *pmu_ctx,
 				struct task_struct *task, bool sched_in)
 {
-	struct arm_pmu *armpmu = *this_cpu_ptr(&cpu_armpmu);
+	struct arm_pmu *armpmu = to_arm_pmu(pmu_ctx->pmu);
 	struct pmu_hw_events *hw_events = this_cpu_ptr(armpmu->hw_events);
 
 	if (!hw_events->branch_users)
include/linux/perf/arm_pmu.h +0 -2
index 395d03c282e8c..b54c309a74f0f 100644
@@ -132,8 +132,6 @@ struct arm_pmu {
 
 #define to_arm_pmu(p) (container_of(p, struct arm_pmu, pmu))
 
-DECLARE_PER_CPU(struct arm_pmu *, cpu_armpmu);
-
 u64 armpmu_event_update(struct perf_event *event);
 
 int armpmu_event_set_period(struct perf_event *event);
Signature · 1 line
2.39.2