Re: [PATCH] Revert "Merge branch 'x86-apic-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip"

Rodrigo Vivi
2017-11-29T23:37:13Z

What's the issue here?

On Wed, Nov 29, 2017 at 08:05:43AM +0000, Maarten Lankhorst wrote:
> ---
> arch/x86/Kconfig | 2 -
> arch/x86/include/asm/apic.h | 270 +++++---
> arch/x86/include/asm/desc.h | 2 +-
> arch/x86/include/asm/hw_irq.h | 6 +-
> arch/x86/include/asm/io_apic.h | 2 +
> arch/x86/include/asm/irq.h | 4 +
> arch/x86/include/asm/irq_vectors.h | 8 +-
> arch/x86/include/asm/irqdomain.h | 1 -
> arch/x86/include/asm/kvm_host.h | 2 +-
> arch/x86/include/asm/trace/irq_vectors.h | 248 -------
> arch/x86/include/asm/x2apic.h | 50 ++
> arch/x86/include/asm/x86_init.h | 2 -
> arch/x86/kernel/apic/Makefile | 2 +-
> arch/x86/kernel/apic/apic.c | 239 ++++---
> arch/x86/kernel/apic/apic_common.c | 46 --
> arch/x86/kernel/apic/apic_flat_64.c | 10 +-
> arch/x86/kernel/apic/apic_noop.c | 25 +-
> arch/x86/kernel/apic/apic_numachip.c | 12 +-
> arch/x86/kernel/apic/bigsmp_32.c | 8 +-
> arch/x86/kernel/apic/io_apic.c | 130 ++--
> arch/x86/kernel/apic/probe_32.c | 29 +-
> arch/x86/kernel/apic/vector.c | 1099 ++++++++++++------------------
> arch/x86/kernel/apic/x2apic.h | 9 -
> arch/x86/kernel/apic/x2apic_cluster.c | 196 ++++--
> arch/x86/kernel/apic/x2apic_phys.c | 44 +-
> arch/x86/kernel/apic/x2apic_uv_x.c | 17 +-
> arch/x86/kernel/i8259.c | 1 -
> arch/x86/kernel/idt.c | 12 +-
> arch/x86/kernel/irq.c | 101 ++-
> arch/x86/kernel/irqinit.c | 4 +-
> arch/x86/kernel/setup.c | 12 +
> arch/x86/kernel/smpboot.c | 99 ++-
> arch/x86/kernel/time.c | 5 -
> arch/x86/kernel/traps.c | 2 +-
> arch/x86/kernel/vsmp_64.c | 19 +
> arch/x86/kernel/x86_init.c | 1 -
> arch/x86/xen/apic.c | 6 +-
> arch/x86/xen/enlighten_pv.c | 1 -
> drivers/iommu/amd_iommu.c | 39 +-
> drivers/iommu/intel_irq_remapping.c | 38 +-
> drivers/pci/msi.c | 2 -
> init/main.c | 2 +-
> kernel/irq/Kconfig | 3 -
> 43 files changed, 1317 insertions(+), 1493 deletions(-)
> create mode 100644 arch/x86/include/asm/x2apic.h
> delete mode 100644 arch/x86/kernel/apic/apic_common.c
> delete mode 100644 arch/x86/kernel/apic/x2apic.h
>
> diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
> index 8eed3f94bfc7..1a060afd9913 100644
> --- a/arch/x86/Kconfig
> +++ b/arch/x86/Kconfig
> @@ -93,10 +93,8 @@ config X86
> select GENERIC_FIND_FIRST_BIT
> select GENERIC_IOMAP
> select GENERIC_IRQ_EFFECTIVE_AFF_MASK if SMP
> - select GENERIC_IRQ_MATRIX_ALLOCATOR if X86_LOCAL_APIC
> select GENERIC_IRQ_MIGRATION if SMP
> select GENERIC_IRQ_PROBE
> - select GENERIC_IRQ_RESERVATION_MODE
> select GENERIC_IRQ_SHOW
> select GENERIC_PENDING_IRQ if SMP
> select GENERIC_SMP_IDLE_THREAD
> diff --git a/arch/x86/include/asm/apic.h b/arch/x86/include/asm/apic.h
> index a9e57f08bfa6..5f01671c68f2 100644
> --- a/arch/x86/include/asm/apic.h
> +++ b/arch/x86/include/asm/apic.h
> @@ -53,15 +53,6 @@ extern int local_apic_timer_c2_ok;
> extern int disable_apic;
> extern unsigned int lapic_timer_frequency;
>
> -extern enum apic_intr_mode_id apic_intr_mode;
> -enum apic_intr_mode_id {
> - APIC_PIC,
> - APIC_VIRTUAL_WIRE,
> - APIC_VIRTUAL_WIRE_NO_CONFIG,
> - APIC_SYMMETRIC_IO,
> - APIC_SYMMETRIC_IO_NO_ROUTING
> -};
> -
> #ifdef CONFIG_SMP
> extern void __inquire_remote_apic(int apicid);
> #else /* CONFIG_SMP */
> @@ -136,13 +127,14 @@ extern void disconnect_bsp_APIC(int virt_wire_setup);
> extern void disable_local_APIC(void);
> extern void lapic_shutdown(void);
> extern void sync_Arb_IDs(void);
> -extern void apic_intr_mode_init(void);
> +extern void init_bsp_APIC(void);
> extern void setup_local_APIC(void);
> extern void init_apic_mappings(void);
> void register_lapic_address(unsigned long address);
> extern void setup_boot_APIC_clock(void);
> extern void setup_secondary_APIC_clock(void);
> extern void lapic_update_tsc_freq(void);
> +extern int APIC_init_uniprocessor(void);
>
> #ifdef CONFIG_X86_64
> static inline int apic_force_enable(unsigned long addr)
> @@ -153,7 +145,7 @@ static inline int apic_force_enable(unsigned long addr)
> extern int apic_force_enable(unsigned long addr);
> #endif
>
> -extern void apic_bsp_setup(bool upmode);
> +extern int apic_bsp_setup(bool upmode);
> extern void apic_ap_setup(void);
>
> /*
> @@ -169,10 +161,6 @@ static inline int apic_is_clustered_box(void)
> #endif
>
> extern int setup_APIC_eilvt(u8 lvt_off, u8 vector, u8 msg_type, u8 mask);
> -extern void lapic_assign_system_vectors(void);
> -extern void lapic_assign_legacy_vector(unsigned int isairq, bool replace);
> -extern void lapic_online(void);
> -extern void lapic_offline(void);
>
> #else /* !CONFIG_X86_LOCAL_APIC */
> static inline void lapic_shutdown(void) { }
> @@ -182,9 +170,6 @@ static inline void disable_local_APIC(void) { }
> # define setup_boot_APIC_clock x86_init_noop
> # define setup_secondary_APIC_clock x86_init_noop
> static inline void lapic_update_tsc_freq(void) { }
> -static inline void apic_intr_mode_init(void) { }
> -static inline void lapic_assign_system_vectors(void) { }
> -static inline void lapic_assign_legacy_vector(unsigned int i, bool r) { }
> #endif /* !CONFIG_X86_LOCAL_APIC */
>
> #ifdef CONFIG_X86_X2APIC
> @@ -280,63 +265,73 @@ struct irq_data;
> * James Cleverdon.
> */
> struct apic {
> - /* Hotpath functions first */
> - void (*eoi_write)(u32 reg, u32 v);
> - void (*native_eoi_write)(u32 reg, u32 v);
> - void (*write)(u32 reg, u32 v);
> - u32 (*read)(u32 reg);
> -
> - /* IPI related functions */
> - void (*wait_icr_idle)(void);
> - u32 (*safe_wait_icr_idle)(void);
> -
> - void (*send_IPI)(int cpu, int vector);
> - void (*send_IPI_mask)(const struct cpumask *mask, int vector);
> - void (*send_IPI_mask_allbutself)(const struct cpumask *msk, int vec);
> - void (*send_IPI_allbutself)(int vector);
> - void (*send_IPI_all)(int vector);
> - void (*send_IPI_self)(int vector);
> -
> - /* dest_logical is used by the IPI functions */
> - u32 dest_logical;
> - u32 disable_esr;
> - u32 irq_delivery_mode;
> - u32 irq_dest_mode;
> -
> - /* Functions and data related to vector allocation */
> - void (*vector_allocation_domain)(int cpu, struct cpumask *retmask,
> - const struct cpumask *mask);
> - int (*cpu_mask_to_apicid)(const struct cpumask *cpumask,
> - struct irq_data *irqdata,
> - unsigned int *apicid);
> - u32 (*calc_dest_apicid)(unsigned int cpu);
> -
> - /* ICR related functions */
> - u64 (*icr_read)(void);
> - void (*icr_write)(u32 low, u32 high);
> -
> - /* Probe, setup and smpboot functions */
> - int (*probe)(void);
> - int (*acpi_madt_oem_check)(char *oem_id, char *oem_table_id);
> - int (*apic_id_valid)(int apicid);
> - int (*apic_id_registered)(void);
> -
> - bool (*check_apicid_used)(physid_mask_t *map, int apicid);
> - void (*init_apic_ldr)(void);
> - void (*ioapic_phys_id_map)(physid_mask_t *phys_map, physid_mask_t *retmap);
> - void (*setup_apic_routing)(void);
> - int (*cpu_present_to_apicid)(int mps_cpu);
> - void (*apicid_to_cpu_present)(int phys_apicid, physid_mask_t *retmap);
> - int (*check_phys_apicid_present)(int phys_apicid);
> - int (*phys_pkg_id)(int cpuid_apic, int index_msb);
> -
> - u32 (*get_apic_id)(unsigned long x);
> - u32 (*set_apic_id)(unsigned int id);
> + char *name;
> +
> + int (*probe)(void);
> + int (*acpi_madt_oem_check)(char *oem_id, char *oem_table_id);
> + int (*apic_id_valid)(int apicid);
> + int (*apic_id_registered)(void);
> +
> + u32 irq_delivery_mode;
> + u32 irq_dest_mode;
> +
> + const struct cpumask *(*target_cpus)(void);
> +
> + int disable_esr;
> +
> + int dest_logical;
> + unsigned long (*check_apicid_used)(physid_mask_t *map, int apicid);
> +
> + void (*vector_allocation_domain)(int cpu, struct cpumask *retmask,
> + const struct cpumask *mask);
> + void (*init_apic_ldr)(void);
> +
> + void (*ioapic_phys_id_map)(physid_mask_t *phys_map, physid_mask_t *retmap);
> +
> + void (*setup_apic_routing)(void);
> + int (*cpu_present_to_apicid)(int mps_cpu);
> + void (*apicid_to_cpu_present)(int phys_apicid, physid_mask_t *retmap);
> + int (*check_phys_apicid_present)(int phys_apicid);
> + int (*phys_pkg_id)(int cpuid_apic, int index_msb);
> +
> + unsigned int (*get_apic_id)(unsigned long x);
> + /* Can't be NULL on 64-bit */
> + unsigned long (*set_apic_id)(unsigned int id);
> +
> + int (*cpu_mask_to_apicid)(const struct cpumask *cpumask,
> + struct irq_data *irqdata,
> + unsigned int *apicid);
> +
> + /* ipi */
> + void (*send_IPI)(int cpu, int vector);
> + void (*send_IPI_mask)(const struct cpumask *mask, int vector);
> + void (*send_IPI_mask_allbutself)(const struct cpumask *mask,
> + int vector);
> + void (*send_IPI_allbutself)(int vector);
> + void (*send_IPI_all)(int vector);
> + void (*send_IPI_self)(int vector);
>
> /* wakeup_secondary_cpu */
> - int (*wakeup_secondary_cpu)(int apicid, unsigned long start_eip);
> + int (*wakeup_secondary_cpu)(int apicid, unsigned long start_eip);
>
> - void (*inquire_remote_apic)(int apicid);
> + void (*inquire_remote_apic)(int apicid);
> +
> + /* apic ops */
> + u32 (*read)(u32 reg);
> + void (*write)(u32 reg, u32 v);
> + /*
> + * ->eoi_write() has the same signature as ->write().
> + *
> + * Drivers can support both ->eoi_write() and ->write() by passing the same
> + * callback value. Kernel can override ->eoi_write() and fall back
> + * on write for EOI.
> + */
> + void (*eoi_write)(u32 reg, u32 v);
> + void (*native_eoi_write)(u32 reg, u32 v);
> + u64 (*icr_read)(void);
> + void (*icr_write)(u32 low, u32 high);
> + void (*wait_icr_idle)(void);
> + u32 (*safe_wait_icr_idle)(void);
>
> #ifdef CONFIG_X86_32
> /*
> @@ -351,7 +346,6 @@ struct apic {
> */
> int (*x86_32_early_logical_apicid)(int cpu);
> #endif
> - char *name;
> };
>
> /*
> @@ -386,7 +380,6 @@ extern struct apic *__apicdrivers[], *__apicdrivers_end[];
> */
> #ifdef CONFIG_SMP
> extern int wakeup_secondary_cpu_via_nmi(int apicid, unsigned long start_eip);
> -extern int lapic_can_unplug_cpu(void);
> #endif
>
> #ifdef CONFIG_X86_LOCAL_APIC
> @@ -470,33 +463,84 @@ static inline unsigned default_get_apic_id(unsigned long x)
> extern void apic_send_IPI_self(int vector);
>
> DECLARE_PER_CPU(int, x2apic_extra_bits);
> +
> +extern int default_cpu_present_to_apicid(int mps_cpu);
> +extern int default_check_phys_apicid_present(int phys_apicid);
> #endif
>
> extern void generic_bigsmp_probe(void);
>
> +
> #ifdef CONFIG_X86_LOCAL_APIC
>
> #include <asm/smp.h>
>
> #define APIC_DFR_VALUE (APIC_DFR_FLAT)
>
> +static inline const struct cpumask *default_target_cpus(void)
> +{
> +#ifdef CONFIG_SMP
> + return cpu_online_mask;
> +#else
> + return cpumask_of(0);
> +#endif
> +}
> +
> +static inline const struct cpumask *online_target_cpus(void)
> +{
> + return cpu_online_mask;
> +}
> +
> DECLARE_EARLY_PER_CPU_READ_MOSTLY(u16, x86_bios_cpu_apicid);
>
> -extern struct apic apic_noop;
>
> static inline unsigned int read_apic_id(void)
> {
> - unsigned int reg = apic_read(APIC_ID);
> + unsigned int reg;
> +
> + reg = apic_read(APIC_ID);
>
> return apic->get_apic_id(reg);
> }
>
> -extern int default_apic_id_valid(int apicid);
> +static inline int default_apic_id_valid(int apicid)
> +{
> + return (apicid < 255);
> +}
> +
> extern int default_acpi_madt_oem_check(char *, char *);
> +
> extern void default_setup_apic_routing(void);
>
> -extern u32 apic_default_calc_apicid(unsigned int cpu);
> -extern u32 apic_flat_calc_apicid(unsigned int cpu);
> +extern struct apic apic_noop;
> +
> +#ifdef CONFIG_X86_32
> +
> +static inline int noop_x86_32_early_logical_apicid(int cpu)
> +{
> + return BAD_APICID;
> +}
> +
> +/*
> + * Set up the logical destination ID.
> + *
> + * Intel recommends to set DFR, LDR and TPR before enabling
> + * an APIC. See e.g. "AP-388 82489DX User's Manual" (Intel
> + * document number 292116). So here it goes...
> + */
> +extern void default_init_apic_ldr(void);
> +
> +static inline int default_apic_id_registered(void)
> +{
> + return physid_isset(read_apic_id(), phys_cpu_present_map);
> +}
> +
> +static inline int default_phys_pkg_id(int cpuid_apic, int index_msb)
> +{
> + return cpuid_apic >> index_msb;
> +}
> +
> +#endif
>
> extern int flat_cpu_mask_to_apicid(const struct cpumask *cpumask,
> struct irq_data *irqdata,
> @@ -504,17 +548,71 @@ extern int flat_cpu_mask_to_apicid(const struct cpumask *cpumask,
> extern int default_cpu_mask_to_apicid(const struct cpumask *cpumask,
> struct irq_data *irqdata,
> unsigned int *apicid);
> -extern bool default_check_apicid_used(physid_mask_t *map, int apicid);
> -extern void flat_vector_allocation_domain(int cpu, struct cpumask *retmask,
> - const struct cpumask *mask);
> -extern void default_vector_allocation_domain(int cpu, struct cpumask *retmask,
> - const struct cpumask *mask);
> -extern void default_ioapic_phys_id_map(physid_mask_t *phys_map, physid_mask_t *retmap);
> +
> +static inline void
> +flat_vector_allocation_domain(int cpu, struct cpumask *retmask,
> + const struct cpumask *mask)
> +{
> + /* Careful. Some cpus do not strictly honor the set of cpus
> + * specified in the interrupt destination when using lowest
> + * priority interrupt delivery mode.
> + *
> + * In particular there was a hyperthreading cpu observed to
> + * deliver interrupts to the wrong hyperthread when only one
> + * hyperthread was specified in the interrupt desitination.
> + */
> + cpumask_clear(retmask);
> + cpumask_bits(retmask)[0] = APIC_ALL_CPUS;
> +}
> +
> +static inline void
> +default_vector_allocation_domain(int cpu, struct cpumask *retmask,
> + const struct cpumask *mask)
> +{
> + cpumask_copy(retmask, cpumask_of(cpu));
> +}
> +
> +static inline unsigned long default_check_apicid_used(physid_mask_t *map, int apicid)
> +{
> + return physid_isset(apicid, *map);
> +}
> +
> +static inline void default_ioapic_phys_id_map(physid_mask_t *phys_map, physid_mask_t *retmap)
> +{
> + *retmap = *phys_map;
> +}
> +
> +static inline int __default_cpu_present_to_apicid(int mps_cpu)
> +{
> + if (mps_cpu < nr_cpu_ids && cpu_present(mps_cpu))
> + return (int)per_cpu(x86_bios_cpu_apicid, mps_cpu);
> + else
> + return BAD_APICID;
> +}
> +
> +static inline int
> +__default_check_phys_apicid_present(int phys_apicid)
> +{
> + return physid_isset(phys_apicid, phys_cpu_present_map);
> +}
> +
> +#ifdef CONFIG_X86_32
> +static inline int default_cpu_present_to_apicid(int mps_cpu)
> +{
> + return __default_cpu_present_to_apicid(mps_cpu);
> +}
> +
> +static inline int
> +default_check_phys_apicid_present(int phys_apicid)
> +{
> + return __default_check_phys_apicid_present(phys_apicid);
> +}
> +#else
> extern int default_cpu_present_to_apicid(int mps_cpu);
> extern int default_check_phys_apicid_present(int phys_apicid);
> +#endif
>
> #endif /* CONFIG_X86_LOCAL_APIC */
> -
> extern void irq_enter(void);
> extern void irq_exit(void);
>
> diff --git a/arch/x86/include/asm/desc.h b/arch/x86/include/asm/desc.h
> index 4011cb03ef08..0a3e808b9123 100644
> --- a/arch/x86/include/asm/desc.h
> +++ b/arch/x86/include/asm/desc.h
> @@ -393,7 +393,7 @@ static inline void set_desc_limit(struct desc_struct *desc, unsigned long limit)
> void update_intr_gate(unsigned int n, const void *addr);
> void alloc_intr_gate(unsigned int n, const void *addr);
>
> -extern unsigned long system_vectors[];
> +extern unsigned long used_vectors[];
>
> #ifdef CONFIG_X86_64
> DECLARE_PER_CPU(u32, debug_idt_ctr);
> diff --git a/arch/x86/include/asm/hw_irq.h b/arch/x86/include/asm/hw_irq.h
> index 2851077b6051..16d48a18c069 100644
> --- a/arch/x86/include/asm/hw_irq.h
> +++ b/arch/x86/include/asm/hw_irq.h
> @@ -16,8 +16,6 @@
>
> #include <asm/irq_vectors.h>
>
> -#define IRQ_MATRIX_BITS NR_VECTORS
> -
> #ifndef __ASSEMBLY__
>
> #include <linux/percpu.h>
> @@ -117,13 +115,15 @@ struct irq_alloc_info {
>
> struct irq_cfg {
> unsigned int dest_apicid;
> - unsigned int vector;
> + u8 vector;
> + u8 old_vector;
> };
>
> extern struct irq_cfg *irq_cfg(unsigned int irq);
> extern struct irq_cfg *irqd_cfg(struct irq_data *irq_data);
> extern void lock_vector_lock(void);
> extern void unlock_vector_lock(void);
> +extern void setup_vector_irq(int cpu);
> #ifdef CONFIG_SMP
> extern void send_cleanup_vector(struct irq_cfg *);
> extern void irq_complete_move(struct irq_cfg *cfg);
> diff --git a/arch/x86/include/asm/io_apic.h b/arch/x86/include/asm/io_apic.h
> index a8834dd546cd..5c27e146a166 100644
> --- a/arch/x86/include/asm/io_apic.h
> +++ b/arch/x86/include/asm/io_apic.h
> @@ -193,6 +193,7 @@ static inline unsigned int io_apic_read(unsigned int apic, unsigned int reg)
> extern void setup_IO_APIC(void);
> extern void enable_IO_APIC(void);
> extern void disable_IO_APIC(void);
> +extern void setup_ioapic_dest(void);
> extern int IO_APIC_get_PCI_irq_vector(int bus, int devfn, int pin);
> extern void print_IO_APICs(void);
> #else /* !CONFIG_X86_IO_APIC */
> @@ -232,6 +233,7 @@ static inline void io_apic_init_mappings(void) { }
>
> static inline void setup_IO_APIC(void) { }
> static inline void enable_IO_APIC(void) { }
> +static inline void setup_ioapic_dest(void) { }
>
> #endif
>
> diff --git a/arch/x86/include/asm/irq.h b/arch/x86/include/asm/irq.h
> index 2395bb794c7b..d8632f8fa17d 100644
> --- a/arch/x86/include/asm/irq.h
> +++ b/arch/x86/include/asm/irq.h
> @@ -26,7 +26,11 @@ extern void irq_ctx_init(int cpu);
>
> struct irq_desc;
>
> +#ifdef CONFIG_HOTPLUG_CPU
> +#include <linux/cpumask.h>
> +extern int check_irq_vectors_for_cpu_disable(void);
> extern void fixup_irqs(void);
> +#endif
>
> #ifdef CONFIG_HAVE_KVM
> extern void kvm_set_posted_intr_wakeup_handler(void (*handler)(void));
> diff --git a/arch/x86/include/asm/irq_vectors.h b/arch/x86/include/asm/irq_vectors.h
> index 67421f649cfa..c20ffca8fef1 100644
> --- a/arch/x86/include/asm/irq_vectors.h
> +++ b/arch/x86/include/asm/irq_vectors.h
> @@ -102,8 +102,12 @@
> #define POSTED_INTR_NESTED_VECTOR 0xf0
> #endif
>
> -#define MANAGED_IRQ_SHUTDOWN_VECTOR 0xef
> -#define LOCAL_TIMER_VECTOR 0xee
> +/*
> + * Local APIC timer IRQ vector is on a different priority level,
> + * to work around the 'lost local interrupt if more than 2 IRQ
> + * sources per level' errata.
> + */
> +#define LOCAL_TIMER_VECTOR 0xef
>
> #define NR_VECTORS 256
>
> diff --git a/arch/x86/include/asm/irqdomain.h b/arch/x86/include/asm/irqdomain.h
> index 139feef467f7..4e5638539846 100644
> --- a/arch/x86/include/asm/irqdomain.h
> +++ b/arch/x86/include/asm/irqdomain.h
> @@ -9,7 +9,6 @@
> enum {
> /* Allocate contiguous CPU vectors */
> X86_IRQ_ALLOC_CONTIGUOUS_VECTORS = 0x1,
> - X86_IRQ_ALLOC_LEGACY = 0x2,
> };
>
> extern struct irq_domain *x86_vector_domain;
> diff --git a/arch/x86/include/asm/kvm_host.h b/arch/x86/include/asm/kvm_host.h
> index 1bfb99770c34..7233445a20bd 100644
> --- a/arch/x86/include/asm/kvm_host.h
> +++ b/arch/x86/include/asm/kvm_host.h
> @@ -1424,7 +1424,7 @@ static inline void kvm_arch_vcpu_block_finish(struct kvm_vcpu *vcpu) {}
> static inline int kvm_cpu_get_apicid(int mps_cpu)
> {
> #ifdef CONFIG_X86_LOCAL_APIC
> - return default_cpu_present_to_apicid(mps_cpu);
> + return __default_cpu_present_to_apicid(mps_cpu);
> #else
> WARN_ON_ONCE(1);
> return BAD_APICID;
> diff --git a/arch/x86/include/asm/trace/irq_vectors.h b/arch/x86/include/asm/trace/irq_vectors.h
> index 84b9ec0c1bc0..8eb139ed1a03 100644
> --- a/arch/x86/include/asm/trace/irq_vectors.h
> +++ b/arch/x86/include/asm/trace/irq_vectors.h
> @@ -138,254 +138,6 @@ DEFINE_IRQ_VECTOR_EVENT(deferred_error_apic);
> DEFINE_IRQ_VECTOR_EVENT(thermal_apic);
> #endif
>
> -TRACE_EVENT(vector_config,
> -
> - TP_PROTO(unsigned int irq, unsigned int vector,
> - unsigned int cpu, unsigned int apicdest),
> -
> - TP_ARGS(irq, vector, cpu, apicdest),
> -
> - TP_STRUCT__entry(
> - __field( unsigned int, irq )
> - __field( unsigned int, vector )
> - __field( unsigned int, cpu )
> - __field( unsigned int, apicdest )
> - ),
> -
> - TP_fast_assign(
> - __entry->irq = irq;
> - __entry->vector = vector;
> - __entry->cpu = cpu;
> - __entry->apicdest = apicdest;
> - ),
> -
> - TP_printk("irq=%u vector=%u cpu=%u apicdest=0x%08x",
> - __entry->irq, __entry->vector, __entry->cpu,
> - __entry->apicdest)
> -);
> -
> -DECLARE_EVENT_CLASS(vector_mod,
> -
> - TP_PROTO(unsigned int irq, unsigned int vector,
> - unsigned int cpu, unsigned int prev_vector,
> - unsigned int prev_cpu),
> -
> - TP_ARGS(irq, vector, cpu, prev_vector, prev_cpu),
> -
> - TP_STRUCT__entry(
> - __field( unsigned int, irq )
> - __field( unsigned int, vector )
> - __field( unsigned int, cpu )
> - __field( unsigned int, prev_vector )
> - __field( unsigned int, prev_cpu )
> - ),
> -
> - TP_fast_assign(
> - __entry->irq = irq;
> - __entry->vector = vector;
> - __entry->cpu = cpu;
> - __entry->prev_vector = prev_vector;
> - __entry->prev_cpu = prev_cpu;
> -
> - ),
> -
> - TP_printk("irq=%u vector=%u cpu=%u prev_vector=%u prev_cpu=%u",
> - __entry->irq, __entry->vector, __entry->cpu,
> - __entry->prev_vector, __entry->prev_cpu)
> -);
> -
> -#define DEFINE_IRQ_VECTOR_MOD_EVENT(name) \
> -DEFINE_EVENT_FN(vector_mod, name, \
> - TP_PROTO(unsigned int irq, unsigned int vector, \
> - unsigned int cpu, unsigned int prev_vector, \
> - unsigned int prev_cpu), \
> - TP_ARGS(irq, vector, cpu, prev_vector, prev_cpu), NULL, NULL); \
> -
> -DEFINE_IRQ_VECTOR_MOD_EVENT(vector_update);
> -DEFINE_IRQ_VECTOR_MOD_EVENT(vector_clear);
> -
> -DECLARE_EVENT_CLASS(vector_reserve,
> -
> - TP_PROTO(unsigned int irq, int ret),
> -
> - TP_ARGS(irq, ret),
> -
> - TP_STRUCT__entry(
> - __field( unsigned int, irq )
> - __field( int, ret )
> - ),
> -
> - TP_fast_assign(
> - __entry->irq = irq;
> - __entry->ret = ret;
> - ),
> -
> - TP_printk("irq=%u ret=%d", __entry->irq, __entry->ret)
> -);
> -
> -#define DEFINE_IRQ_VECTOR_RESERVE_EVENT(name) \
> -DEFINE_EVENT_FN(vector_reserve, name, \
> - TP_PROTO(unsigned int irq, int ret), \
> - TP_ARGS(irq, ret), NULL, NULL); \
> -
> -DEFINE_IRQ_VECTOR_RESERVE_EVENT(vector_reserve_managed);
> -DEFINE_IRQ_VECTOR_RESERVE_EVENT(vector_reserve);
> -
> -TRACE_EVENT(vector_alloc,
> -
> - TP_PROTO(unsigned int irq, unsigned int vector, bool reserved,
> - int ret),
> -
> - TP_ARGS(irq, vector, ret, reserved),
> -
> - TP_STRUCT__entry(
> - __field( unsigned int, irq )
> - __field( unsigned int, vector )
> - __field( bool, reserved )
> - __field( int, ret )
> - ),
> -
> - TP_fast_assign(
> - __entry->irq = irq;
> - __entry->vector = ret < 0 ? 0 : vector;
> - __entry->reserved = reserved;
> - __entry->ret = ret > 0 ? 0 : ret;
> - ),
> -
> - TP_printk("irq=%u vector=%u reserved=%d ret=%d",
> - __entry->irq, __entry->vector,
> - __entry->reserved, __entry->ret)
> -);
> -
> -TRACE_EVENT(vector_alloc_managed,
> -
> - TP_PROTO(unsigned int irq, unsigned int vector,
> - int ret),
> -
> - TP_ARGS(irq, vector, ret),
> -
> - TP_STRUCT__entry(
> - __field( unsigned int, irq )
> - __field( unsigned int, vector )
> - __field( int, ret )
> - ),
> -
> - TP_fast_assign(
> - __entry->irq = irq;
> - __entry->vector = ret < 0 ? 0 : vector;
> - __entry->ret = ret > 0 ? 0 : ret;
> - ),
> -
> - TP_printk("irq=%u vector=%u ret=%d",
> - __entry->irq, __entry->vector, __entry->ret)
> -);
> -
> -DECLARE_EVENT_CLASS(vector_activate,
> -
> - TP_PROTO(unsigned int irq, bool is_managed, bool can_reserve,
> - bool early),
> -
> - TP_ARGS(irq, is_managed, can_reserve, early),
> -
> - TP_STRUCT__entry(
> - __field( unsigned int, irq )
> - __field( bool, is_managed )
> - __field( bool, can_reserve )
> - __field( bool, early )
> - ),
> -
> - TP_fast_assign(
> - __entry->irq = irq;
> - __entry->is_managed = is_managed;
> - __entry->can_reserve = can_reserve;
> - __entry->early = early;
> - ),
> -
> - TP_printk("irq=%u is_managed=%d can_reserve=%d early=%d",
> - __entry->irq, __entry->is_managed, __entry->can_reserve,
> - __entry->early)
> -);
> -
> -#define DEFINE_IRQ_VECTOR_ACTIVATE_EVENT(name) \
> -DEFINE_EVENT_FN(vector_activate, name, \
> - TP_PROTO(unsigned int irq, bool is_managed, \
> - bool can_reserve, bool early), \
> - TP_ARGS(irq, is_managed, can_reserve, early), NULL, NULL); \
> -
> -DEFINE_IRQ_VECTOR_ACTIVATE_EVENT(vector_activate);
> -DEFINE_IRQ_VECTOR_ACTIVATE_EVENT(vector_deactivate);
> -
> -TRACE_EVENT(vector_teardown,
> -
> - TP_PROTO(unsigned int irq, bool is_managed, bool has_reserved),
> -
> - TP_ARGS(irq, is_managed, has_reserved),
> -
> - TP_STRUCT__entry(
> - __field( unsigned int, irq )
> - __field( bool, is_managed )
> - __field( bool, has_reserved )
> - ),
> -
> - TP_fast_assign(
> - __entry->irq = irq;
> - __entry->is_managed = is_managed;
> - __entry->has_reserved = has_reserved;
> - ),
> -
> - TP_printk("irq=%u is_managed=%d has_reserved=%d",
> - __entry->irq, __entry->is_managed, __entry->has_reserved)
> -);
> -
> -TRACE_EVENT(vector_setup,
> -
> - TP_PROTO(unsigned int irq, bool is_legacy, int ret),
> -
> - TP_ARGS(irq, is_legacy, ret),
> -
> - TP_STRUCT__entry(
> - __field( unsigned int, irq )
> - __field( bool, is_legacy )
> - __field( int, ret )
> - ),
> -
> - TP_fast_assign(
> - __entry->irq = irq;
> - __entry->is_legacy = is_legacy;
> - __entry->ret = ret;
> - ),
> -
> - TP_printk("irq=%u is_legacy=%d ret=%d",
> - __entry->irq, __entry->is_legacy, __entry->ret)
> -);
> -
> -TRACE_EVENT(vector_free_moved,
> -
> - TP_PROTO(unsigned int irq, unsigned int cpu, unsigned int vector,
> - bool is_managed),
> -
> - TP_ARGS(irq, cpu, vector, is_managed),
> -
> - TP_STRUCT__entry(
> - __field( unsigned int, irq )
> - __field( unsigned int, cpu )
> - __field( unsigned int, vector )
> - __field( bool, is_managed )
> - ),
> -
> - TP_fast_assign(
> - __entry->irq = irq;
> - __entry->cpu = cpu;
> - __entry->vector = vector;
> - __entry->is_managed = is_managed;
> - ),
> -
> - TP_printk("irq=%u cpu=%u vector=%u is_managed=%d",
> - __entry->irq, __entry->cpu, __entry->vector,
> - __entry->is_managed)
> -);
> -
> -
> #endif /* CONFIG_X86_LOCAL_APIC */
>
> #undef TRACE_INCLUDE_PATH
> diff --git a/arch/x86/include/asm/x2apic.h b/arch/x86/include/asm/x2apic.h
> new file mode 100644
> index 000000000000..78ccf28d17db
> --- /dev/null
> +++ b/arch/x86/include/asm/x2apic.h
> @@ -0,0 +1,50 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +/*
> + * Common bits for X2APIC cluster/physical modes.
> + */
> +
> +#ifndef _ASM_X86_X2APIC_H
> +#define _ASM_X86_X2APIC_H
> +
> +#include <asm/apic.h>
> +#include <asm/ipi.h>
> +#include <linux/cpumask.h>
> +
> +static int x2apic_apic_id_valid(int apicid)
> +{
> + return 1;
> +}
> +
> +static int x2apic_apic_id_registered(void)
> +{
> + return 1;
> +}
> +
> +static void
> +__x2apic_send_IPI_dest(unsigned int apicid, int vector, unsigned int dest)
> +{
> + unsigned long cfg = __prepare_ICR(0, vector, dest);
> + native_x2apic_icr_write(cfg, apicid);
> +}
> +
> +static unsigned int x2apic_get_apic_id(unsigned long id)
> +{
> + return id;
> +}
> +
> +static unsigned long x2apic_set_apic_id(unsigned int id)
> +{
> + return id;
> +}
> +
> +static int x2apic_phys_pkg_id(int initial_apicid, int index_msb)
> +{
> + return initial_apicid >> index_msb;
> +}
> +
> +static void x2apic_send_IPI_self(int vector)
> +{
> + apic_write(APIC_SELF_IPI, vector);
> +}
> +
> +#endif /* _ASM_X86_X2APIC_H */
> diff --git a/arch/x86/include/asm/x86_init.h b/arch/x86/include/asm/x86_init.h
> index aa4747569e23..5dd011a8b560 100644
> --- a/arch/x86/include/asm/x86_init.h
> +++ b/arch/x86/include/asm/x86_init.h
> @@ -51,13 +51,11 @@ struct x86_init_resources {
> * are set up.
> * @intr_init: interrupt init code
> * @trap_init: platform specific trap setup
> - * @intr_mode_init: interrupt delivery mode setup
> */
> struct x86_init_irqs {
> void (*pre_vector_init)(void);
> void (*intr_init)(void);
> void (*trap_init)(void);
> - void (*intr_mode_init)(void);
> };
>
> /**
> diff --git a/arch/x86/kernel/apic/Makefile b/arch/x86/kernel/apic/Makefile
> index a6fcaf16cdbf..e59e341f9921 100644
> --- a/arch/x86/kernel/apic/Makefile
> +++ b/arch/x86/kernel/apic/Makefile
> @@ -7,7 +7,7 @@
> # In particualr, smp_apic_timer_interrupt() is called in random places.
> KCOV_INSTRUMENT := n
>
> -obj-$(CONFIG_X86_LOCAL_APIC) += apic.o apic_common.o apic_noop.o ipi.o vector.o
> +obj-$(CONFIG_X86_LOCAL_APIC) += apic.o apic_noop.o ipi.o vector.o
> obj-y += hw_nmi.o
>
> obj-$(CONFIG_X86_IO_APIC) += io_apic.o
> diff --git a/arch/x86/kernel/apic/apic.c b/arch/x86/kernel/apic/apic.c
> index 6e272f3ea984..f72ecd5c39a7 100644
> --- a/arch/x86/kernel/apic/apic.c
> +++ b/arch/x86/kernel/apic/apic.c
> @@ -211,7 +211,11 @@ static inline int lapic_get_version(void)
> */
> static inline int lapic_is_integrated(void)
> {
> +#ifdef CONFIG_X86_64
> + return 1;
> +#else
> return APIC_INTEGRATED(lapic_get_version());
> +#endif
> }
>
> /*
> @@ -294,11 +298,14 @@ int get_physical_broadcast(void)
> */
> int lapic_get_maxlvt(void)
> {
> + unsigned int v;
> +
> + v = apic_read(APIC_LVR);
> /*
> * - we always have APIC integrated on 64bit mode
> * - 82489DXs do not report # of LVT entries
> */
> - return lapic_is_integrated() ? GET_APIC_MAXLVT(apic_read(APIC_LVR)) : 2;
> + return APIC_INTEGRATED(GET_APIC_VERSION(v)) ? GET_APIC_MAXLVT(v) : 2;
> }
>
> /*
> @@ -1222,100 +1229,53 @@ void __init sync_Arb_IDs(void)
> APIC_INT_LEVELTRIG | APIC_DM_INIT);
> }
>
> -enum apic_intr_mode_id apic_intr_mode;
> -
> -static int __init apic_intr_mode_select(void)
> +/*
> + * An initial setup of the virtual wire mode.
> + */
> +void __init init_bsp_APIC(void)
> {
> - /* Check kernel option */
> - if (disable_apic) {
> - pr_info("APIC disabled via kernel command line\n");
> - return APIC_PIC;
> - }
> -
> - /* Check BIOS */
> -#ifdef CONFIG_X86_64
> - /* On 64-bit, the APIC must be integrated, Check local APIC only */
> - if (!boot_cpu_has(X86_FEATURE_APIC)) {
> - disable_apic = 1;
> - pr_info("APIC disabled by BIOS\n");
> - return APIC_PIC;
> - }
> -#else
> - /* On 32-bit, the APIC may be integrated APIC or 82489DX */
> -
> - /* Neither 82489DX nor integrated APIC ? */
> - if (!boot_cpu_has(X86_FEATURE_APIC) && !smp_found_config) {
> - disable_apic = 1;
> - return APIC_PIC;
> - }
> + unsigned int value;
>
> - /* If the BIOS pretends there is an integrated APIC ? */
> - if (!boot_cpu_has(X86_FEATURE_APIC) &&
> - APIC_INTEGRATED(boot_cpu_apic_version)) {
> - disable_apic = 1;
> - pr_err(FW_BUG "Local APIC %d not detected, force emulation\n",
> - boot_cpu_physical_apicid);
> - return APIC_PIC;
> - }
> -#endif
> + /*
> + * Don't do the setup now if we have a SMP BIOS as the
> + * through-I/O-APIC virtual wire mode might be active.
> + */
> + if (smp_found_config || !boot_cpu_has(X86_FEATURE_APIC))
> + return;
>
> - /* Check MP table or ACPI MADT configuration */
> - if (!smp_found_config) {
> - disable_ioapic_support();
> - if (!acpi_lapic) {
> - pr_info("APIC: ACPI MADT or MP tables are not detected\n");
> - return APIC_VIRTUAL_WIRE_NO_CONFIG;
> - }
> - return APIC_VIRTUAL_WIRE;
> - }
> + /*
> + * Do not trust the local APIC being empty at bootup.
> + */
> + clear_local_APIC();
>
> -#ifdef CONFIG_SMP
> - /* If SMP should be disabled, then really disable it! */
> - if (!setup_max_cpus) {
> - pr_info("APIC: SMP mode deactivated\n");
> - return APIC_SYMMETRIC_IO_NO_ROUTING;
> - }
> + /*
> + * Enable APIC.
> + */
> + value = apic_read(APIC_SPIV);
> + value &= ~APIC_VECTOR_MASK;
> + value |= APIC_SPIV_APIC_ENABLED;
>
> - if (read_apic_id() != boot_cpu_physical_apicid) {
> - panic("Boot APIC ID in local APIC unexpected (%d vs %d)",
> - read_apic_id(), boot_cpu_physical_apicid);
> - /* Or can we switch back to PIC here? */
> - }
> +#ifdef CONFIG_X86_32
> + /* This bit is reserved on P4/Xeon and should be cleared */
> + if ((boot_cpu_data.x86_vendor == X86_VENDOR_INTEL) &&
> + (boot_cpu_data.x86 == 15))
> + value &= ~APIC_SPIV_FOCUS_DISABLED;
> + else
> #endif
> + value |= APIC_SPIV_FOCUS_DISABLED;
> + value |= SPURIOUS_APIC_VECTOR;
> + apic_write(APIC_SPIV, value);
>
> - return APIC_SYMMETRIC_IO;
> -}
> -
> -/* Init the interrupt delivery mode for the BSP */
> -void __init apic_intr_mode_init(void)
> -{
> - bool upmode = IS_ENABLED(CONFIG_UP_LATE_INIT);
> -
> - apic_intr_mode = apic_intr_mode_select();
> -
> - switch (apic_intr_mode) {
> - case APIC_PIC:
> - pr_info("APIC: Keep in PIC mode(8259)\n");
> - return;
> - case APIC_VIRTUAL_WIRE:
> - pr_info("APIC: Switch to virtual wire mode setup\n");
> - default_setup_apic_routing();
> - break;
> - case APIC_VIRTUAL_WIRE_NO_CONFIG:
> - pr_info("APIC: Switch to virtual wire mode setup with no configuration\n");
> - upmode = true;
> - default_setup_apic_routing();
> - break;
> - case APIC_SYMMETRIC_IO:
> - pr_info("APIC: Switch to symmetric I/O mode setup\n");
> - default_setup_apic_routing();
> - break;
> - case APIC_SYMMETRIC_IO_NO_ROUTING:
> - pr_info("APIC: Switch to symmetric I/O mode setup in no SMP routine\n");
> - break;
> - }
> -
> - apic_bsp_setup(upmode);
> + /*
> + * Set up the virtual wire mode.
> + */
> + apic_write(APIC_LVT0, APIC_DM_EXTINT);
> + value = APIC_DM_NMI;
> + if (!lapic_is_integrated()) /* 82489DX */
> + value |= APIC_LVT_LEVEL_TRIGGER;
> + if (apic_extnmi == APIC_EXTNMI_NONE)
> + value |= APIC_LVT_MASKED;
> + apic_write(APIC_LVT1, value);
> }
>
> static void lapic_setup_esr(void)
> @@ -1539,9 +1499,7 @@ void setup_local_APIC(void)
> value = APIC_DM_NMI;
> else
> value = APIC_DM_NMI | APIC_LVT_MASKED;
> -
> - /* Is 82489DX ? */
> - if (!lapic_is_integrated())
> + if (!lapic_is_integrated()) /* 82489DX */
> value |= APIC_LVT_LEVEL_TRIGGER;
> apic_write(APIC_LVT1, value);
>
> @@ -1927,8 +1885,8 @@ void __init init_apic_mappings(void)
> * yeah -- we lie about apic_version
> * in case if apic was disabled via boot option
> * but it's not a problem for SMP compiled kernel
> - * since apic_intr_mode_select is prepared for such
> - * a case and disable smp mode
> + * since smp_sanity_check is prepared for such a case
> + * and disable smp mode
> */
> boot_cpu_apic_version = GET_APIC_VERSION(apic_read(APIC_LVR));
> }
> @@ -2284,6 +2242,44 @@ int hard_smp_processor_id(void)
> return read_apic_id();
> }
>
> +void default_init_apic_ldr(void)
> +{
> + unsigned long val;
> +
> + apic_write(APIC_DFR, APIC_DFR_VALUE);
> + val = apic_read(APIC_LDR) & ~APIC_LDR_MASK;
> + val |= SET_APIC_LOGICAL_ID(1UL << smp_processor_id());
> + apic_write(APIC_LDR, val);
> +}
> +
> +int default_cpu_mask_to_apicid(const struct cpumask *mask,
> + struct irq_data *irqdata,
> + unsigned int *apicid)
> +{
> + unsigned int cpu = cpumask_first(mask);
> +
> + if (cpu >= nr_cpu_ids)
> + return -EINVAL;
> + *apicid = per_cpu(x86_cpu_to_apicid, cpu);
> + irq_data_update_effective_affinity(irqdata, cpumask_of(cpu));
> + return 0;
> +}
> +
> +int flat_cpu_mask_to_apicid(const struct cpumask *mask,
> + struct irq_data *irqdata,
> + unsigned int *apicid)
> +
> +{
> + struct cpumask *effmsk = irq_data_get_effective_affinity_mask(irqdata);
> + unsigned long cpu_mask = cpumask_bits(mask)[0] & APIC_ALL_CPUS;
> +
> + if (!cpu_mask)
> + return -EINVAL;
> + *apicid = (unsigned int)cpu_mask;
> + cpumask_bits(effmsk)[0] = cpu_mask;
> + return 0;
> +}
> +
> /*
> * Override the generic EOI implementation with an optimized version.
> * Only called during early boot when only one CPU is active and with
> @@ -2326,27 +2322,72 @@ static void __init apic_bsp_up_setup(void)
> * Returns:
> * apic_id of BSP APIC
> */
> -void __init apic_bsp_setup(bool upmode)
> +int __init apic_bsp_setup(bool upmode)
> {
> + int id;
> +
> connect_bsp_APIC();
> if (upmode)
> apic_bsp_up_setup();
> setup_local_APIC();
>
> + if (x2apic_mode)
> + id = apic_read(APIC_LDR);
> + else
> + id = GET_APIC_LOGICAL_ID(apic_read(APIC_LDR));
> +
> enable_IO_APIC();
> end_local_APIC_setup();
> irq_remap_enable_fault_handling();
> setup_IO_APIC();
> + /* Setup local timer */
> + x86_init.timers.setup_percpu_clockev();
> + return id;
> +}
> +
> +/*
> + * This initializes the IO-APIC and APIC hardware if this is
> + * a UP kernel.
> + */
> +int __init APIC_init_uniprocessor(void)
> +{
> + if (disable_apic) {
> + pr_info("Apic disabled\n");
> + return -1;
> + }
> +#ifdef CONFIG_X86_64
> + if (!boot_cpu_has(X86_FEATURE_APIC)) {
> + disable_apic = 1;
> + pr_info("Apic disabled by BIOS\n");
> + return -1;
> + }
> +#else
> + if (!smp_found_config && !boot_cpu_has(X86_FEATURE_APIC))
> + return -1;
> +
> + /*
> + * Complain if the BIOS pretends there is one.
> + */
> + if (!boot_cpu_has(X86_FEATURE_APIC) &&
> + APIC_INTEGRATED(boot_cpu_apic_version)) {
> + pr_err("BIOS bug, local APIC 0x%x not detected!...\n",
> + boot_cpu_physical_apicid);
> + return -1;
> + }
> +#endif
> +
> + if (!smp_found_config)
> + disable_ioapic_support();
> +
> + default_setup_apic_routing();
> + apic_bsp_setup(true);
> + return 0;
> }
>
> #ifdef CONFIG_UP_LATE_INIT
> void __init up_late_init(void)
> {
> - if (apic_intr_mode == APIC_PIC)
> - return;
> -
> - /* Setup local timer */
> - x86_init.timers.setup_percpu_clockev();
> + APIC_init_uniprocessor();
> }
> #endif
>
> diff --git a/arch/x86/kernel/apic/apic_common.c b/arch/x86/kernel/apic/apic_common.c
> deleted file mode 100644
> index a360801779ae..000000000000
> --- a/arch/x86/kernel/apic/apic_common.c
> +++ /dev/null
> @@ -1,46 +0,0 @@
> -/*
> - * Common functions shared between the various APIC flavours
> - *
> - * SPDX-License-Identifier: GPL-2.0
> - */
> -#include <linux/irq.h>
> -#include <asm/apic.h>
> -
> -u32 apic_default_calc_apicid(unsigned int cpu)
> -{
> - return per_cpu(x86_cpu_to_apicid, cpu);
> -}
> -
> -u32 apic_flat_calc_apicid(unsigned int cpu)
> -{
> - return 1U << cpu;
> -}
> -
> -bool default_check_apicid_used(physid_mask_t *map, int apicid)
> -{
> - return physid_isset(apicid, *map);
> -}
> -
> -void default_ioapic_phys_id_map(physid_mask_t *phys_map, physid_mask_t *retmap)
> -{
> - *retmap = *phys_map;
> -}
> -
> -int default_cpu_present_to_apicid(int mps_cpu)
> -{
> - if (mps_cpu < nr_cpu_ids && cpu_present(mps_cpu))
> - return (int)per_cpu(x86_bios_cpu_apicid, mps_cpu);
> - else
> - return BAD_APICID;
> -}
> -EXPORT_SYMBOL_GPL(default_cpu_present_to_apicid);
> -
> -int default_check_phys_apicid_present(int phys_apicid)
> -{
> - return physid_isset(phys_apicid, phys_cpu_present_map);
> -}
> -
> -int default_apic_id_valid(int apicid)
> -{
> - return (apicid < 255);
> -}
> diff --git a/arch/x86/kernel/apic/apic_flat_64.c b/arch/x86/kernel/apic/apic_flat_64.c
> index aa85690e9b64..dedd5a41ba48 100644
> --- a/arch/x86/kernel/apic/apic_flat_64.c
> +++ b/arch/x86/kernel/apic/apic_flat_64.c
> @@ -119,7 +119,7 @@ static unsigned int flat_get_apic_id(unsigned long x)
> return (x >> 24) & 0xFF;
> }
>
> -static u32 set_apic_id(unsigned int id)
> +static unsigned long set_apic_id(unsigned int id)
> {
> return (id & 0xFF) << 24;
> }
> @@ -154,10 +154,12 @@ static struct apic apic_flat __ro_after_init = {
> .irq_delivery_mode = dest_LowestPrio,
> .irq_dest_mode = 1, /* logical */
>
> + .target_cpus = online_target_cpus,
> .disable_esr = 0,
> .dest_logical = APIC_DEST_LOGICAL,
> .check_apicid_used = NULL,
>
> + .vector_allocation_domain = flat_vector_allocation_domain,
> .init_apic_ldr = flat_init_apic_ldr,
>
> .ioapic_phys_id_map = NULL,
> @@ -170,7 +172,7 @@ static struct apic apic_flat __ro_after_init = {
> .get_apic_id = flat_get_apic_id,
> .set_apic_id = set_apic_id,
>
> - .calc_dest_apicid = apic_flat_calc_apicid,
> + .cpu_mask_to_apicid = flat_cpu_mask_to_apicid,
>
> .send_IPI = default_send_IPI_single,
> .send_IPI_mask = flat_send_IPI_mask,
> @@ -247,10 +249,12 @@ static struct apic apic_physflat __ro_after_init = {
> .irq_delivery_mode = dest_Fixed,
> .irq_dest_mode = 0, /* physical */
>
> + .target_cpus = online_target_cpus,
> .disable_esr = 0,
> .dest_logical = 0,
> .check_apicid_used = NULL,
>
> + .vector_allocation_domain = default_vector_allocation_domain,
> /* not needed, but shouldn't hurt: */
> .init_apic_ldr = flat_init_apic_ldr,
>
> @@ -264,7 +268,7 @@ static struct apic apic_physflat __ro_after_init = {
> .get_apic_id = flat_get_apic_id,
> .set_apic_id = set_apic_id,
>
> - .calc_dest_apicid = apic_default_calc_apicid,
> + .cpu_mask_to_apicid = default_cpu_mask_to_apicid,
>
> .send_IPI = default_send_IPI_single_phys,
> .send_IPI_mask = default_send_IPI_mask_sequence_phys,
> diff --git a/arch/x86/kernel/apic/apic_noop.c b/arch/x86/kernel/apic/apic_noop.c
> index 7b659c4480c9..c8d211277315 100644
> --- a/arch/x86/kernel/apic/apic_noop.c
> +++ b/arch/x86/kernel/apic/apic_noop.c
> @@ -84,6 +84,20 @@ static int noop_apic_id_registered(void)
> return physid_isset(0, phys_cpu_present_map);
> }
>
> +static const struct cpumask *noop_target_cpus(void)
> +{
> + /* only BSP here */
> + return cpumask_of(0);
> +}
> +
> +static void noop_vector_allocation_domain(int cpu, struct cpumask *retmask,
> + const struct cpumask *mask)
> +{
> + if (cpu != 0)
> + pr_warning("APIC: Vector allocated for non-BSP cpu\n");
> + cpumask_copy(retmask, cpumask_of(cpu));
> +}
> +
> static u32 noop_apic_read(u32 reg)
> {
> WARN_ON_ONCE(boot_cpu_has(X86_FEATURE_APIC) && !disable_apic);
> @@ -95,13 +109,6 @@ static void noop_apic_write(u32 reg, u32 v)
> WARN_ON_ONCE(boot_cpu_has(X86_FEATURE_APIC) && !disable_apic);
> }
>
> -#ifdef CONFIG_X86_32
> -static int noop_x86_32_early_logical_apicid(int cpu)
> -{
> - return BAD_APICID;
> -}
> -#endif
> -
> struct apic apic_noop __ro_after_init = {
> .name = "noop",
> .probe = noop_probe,
> @@ -114,10 +121,12 @@ struct apic apic_noop __ro_after_init = {
> /* logical delivery broadcast to all CPUs: */
> .irq_dest_mode = 1,
>
> + .target_cpus = noop_target_cpus,
> .disable_esr = 0,
> .dest_logical = APIC_DEST_LOGICAL,
> .check_apicid_used = default_check_apicid_used,
>
> + .vector_allocation_domain = noop_vector_allocation_domain,
> .init_apic_ldr = noop_init_apic_ldr,
>
> .ioapic_phys_id_map = default_ioapic_phys_id_map,
> @@ -133,7 +142,7 @@ struct apic apic_noop __ro_after_init = {
> .get_apic_id = noop_get_apic_id,
> .set_apic_id = NULL,
>
> - .calc_dest_apicid = apic_flat_calc_apicid,
> + .cpu_mask_to_apicid = flat_cpu_mask_to_apicid,
>
> .send_IPI = noop_send_IPI,
> .send_IPI_mask = noop_send_IPI_mask,
> diff --git a/arch/x86/kernel/apic/apic_numachip.c b/arch/x86/kernel/apic/apic_numachip.c
> index 134e04506ab4..2fda912219a6 100644
> --- a/arch/x86/kernel/apic/apic_numachip.c
> +++ b/arch/x86/kernel/apic/apic_numachip.c
> @@ -38,7 +38,7 @@ static unsigned int numachip1_get_apic_id(unsigned long x)
> return id;
> }
>
> -static u32 numachip1_set_apic_id(unsigned int id)
> +static unsigned long numachip1_set_apic_id(unsigned int id)
> {
> return (id & 0xff) << 24;
> }
> @@ -51,7 +51,7 @@ static unsigned int numachip2_get_apic_id(unsigned long x)
> return ((mcfg >> (28 - 8)) & 0xfff00) | (x >> 24);
> }
>
> -static u32 numachip2_set_apic_id(unsigned int id)
> +static unsigned long numachip2_set_apic_id(unsigned int id)
> {
> return id << 24;
> }
> @@ -249,10 +249,12 @@ static const struct apic apic_numachip1 __refconst = {
> .irq_delivery_mode = dest_Fixed,
> .irq_dest_mode = 0, /* physical */
>
> + .target_cpus = online_target_cpus,
> .disable_esr = 0,
> .dest_logical = 0,
> .check_apicid_used = NULL,
>
> + .vector_allocation_domain = default_vector_allocation_domain,
> .init_apic_ldr = flat_init_apic_ldr,
>
> .ioapic_phys_id_map = NULL,
> @@ -265,7 +267,7 @@ static const struct apic apic_numachip1 __refconst = {
> .get_apic_id = numachip1_get_apic_id,
> .set_apic_id = numachip1_set_apic_id,
>
> - .calc_dest_apicid = apic_default_calc_apicid,
> + .cpu_mask_to_apicid = default_cpu_mask_to_apicid,
>
> .send_IPI = numachip_send_IPI_one,
> .send_IPI_mask = numachip_send_IPI_mask,
> @@ -298,10 +300,12 @@ static const struct apic apic_numachip2 __refconst = {
> .irq_delivery_mode = dest_Fixed,
> .irq_dest_mode = 0, /* physical */
>
> + .target_cpus = online_target_cpus,
> .disable_esr = 0,
> .dest_logical = 0,
> .check_apicid_used = NULL,
>
> + .vector_allocation_domain = default_vector_allocation_domain,
> .init_apic_ldr = flat_init_apic_ldr,
>
> .ioapic_phys_id_map = NULL,
> @@ -314,7 +318,7 @@ static const struct apic apic_numachip2 __refconst = {
> .get_apic_id = numachip2_get_apic_id,
> .set_apic_id = numachip2_set_apic_id,
>
> - .calc_dest_apicid = apic_default_calc_apicid,
> + .cpu_mask_to_apicid = default_cpu_mask_to_apicid,
>
> .send_IPI = numachip_send_IPI_one,
> .send_IPI_mask = numachip_send_IPI_mask,
> diff --git a/arch/x86/kernel/apic/bigsmp_32.c b/arch/x86/kernel/apic/bigsmp_32.c
> index afee386ff711..e12fbcfc9571 100644
> --- a/arch/x86/kernel/apic/bigsmp_32.c
> +++ b/arch/x86/kernel/apic/bigsmp_32.c
> @@ -27,9 +27,9 @@ static int bigsmp_apic_id_registered(void)
> return 1;
> }
>
> -static bool bigsmp_check_apicid_used(physid_mask_t *map, int apicid)
> +static unsigned long bigsmp_check_apicid_used(physid_mask_t *map, int apicid)
> {
> - return false;
> + return 0;
> }
>
> static int bigsmp_early_logical_apicid(int cpu)
> @@ -155,10 +155,12 @@ static struct apic apic_bigsmp __ro_after_init = {
> /* phys delivery to target CPU: */
> .irq_dest_mode = 0,
>
> + .target_cpus = default_target_cpus,
> .disable_esr = 1,
> .dest_logical = 0,
> .check_apicid_used = bigsmp_check_apicid_used,
>
> + .vector_allocation_domain = default_vector_allocation_domain,
> .init_apic_ldr = bigsmp_init_apic_ldr,
>
> .ioapic_phys_id_map = bigsmp_ioapic_phys_id_map,
> @@ -171,7 +173,7 @@ static struct apic apic_bigsmp __ro_after_init = {
> .get_apic_id = bigsmp_get_apic_id,
> .set_apic_id = NULL,
>
> - .calc_dest_apicid = apic_default_calc_apicid,
> + .cpu_mask_to_apicid = default_cpu_mask_to_apicid,
>
> .send_IPI = default_send_IPI_single_phys,
> .send_IPI_mask = default_send_IPI_mask_sequence_phys,
> diff --git a/arch/x86/kernel/apic/io_apic.c b/arch/x86/kernel/apic/io_apic.c
> index 201579dc5242..18c8aca5bae7 100644
> --- a/arch/x86/kernel/apic/io_apic.c
> +++ b/arch/x86/kernel/apic/io_apic.c
> @@ -1014,7 +1014,6 @@ static int alloc_isa_irq_from_domain(struct irq_domain *domain,
> info->ioapic_pin))
> return -ENOMEM;
> } else {
> - info->flags |= X86_IRQ_ALLOC_LEGACY;
> irq = __irq_domain_alloc_irqs(domain, irq, 1, node, info, true,
> NULL);
> if (irq >= 0) {
> @@ -1587,43 +1586,6 @@ static int __init notimercheck(char *s)
> }
> __setup("no_timer_check", notimercheck);
>
> -static void __init delay_with_tsc(void)
> -{
> - unsigned long long start, now;
> - unsigned long end = jiffies + 4;
> -
> - start = rdtsc();
> -
> - /*
> - * We don't know the TSC frequency yet, but waiting for
> - * 40000000000/HZ TSC cycles is safe:
> - * 4 GHz == 10 jiffies
> - * 1 GHz == 40 jiffies
> - */
> - do {
> - rep_nop();
> - now = rdtsc();
> - } while ((now - start) < 40000000000UL / HZ &&
> - time_before_eq(jiffies, end));
> -}
> -
> -static void __init delay_without_tsc(void)
> -{
> - unsigned long end = jiffies + 4;
> - int band = 1;
> -
> - /*
> - * We don't know any frequency yet, but waiting for
> - * 40940000000/HZ cycles is safe:
> - * 4 GHz == 10 jiffies
> - * 1 GHz == 40 jiffies
> - * 1 << 1 + 1 << 2 +...+ 1 << 11 = 4094
> - */
> - do {
> - __delay(((1U << band++) * 10000000UL) / HZ);
> - } while (band < 12 && time_before_eq(jiffies, end));
> -}
> -
> /*
> * There is a nasty bug in some older SMP boards, their mptable lies
> * about the timer IRQ. We do the following to work around the situation:
> @@ -1642,12 +1604,8 @@ static int __init timer_irq_works(void)
>
> local_save_flags(flags);
> local_irq_enable();
> -
> - if (boot_cpu_has(X86_FEATURE_TSC))
> - delay_with_tsc();
> - else
> - delay_without_tsc();
> -
> + /* Let ten ticks pass... */
> + mdelay((10 * 1000) / HZ);
> local_irq_restore(flags);
>
> /*
> @@ -1863,36 +1821,26 @@ static void ioapic_ir_ack_level(struct irq_data *irq_data)
> eoi_ioapic_pin(data->entry.vector, data);
> }
>
> -static void ioapic_configure_entry(struct irq_data *irqd)
> -{
> - struct mp_chip_data *mpd = irqd->chip_data;
> - struct irq_cfg *cfg = irqd_cfg(irqd);
> - struct irq_pin_list *entry;
> -
> - /*
> - * Only update when the parent is the vector domain, don't touch it
> - * if the parent is the remapping domain. Check the installed
> - * ioapic chip to verify that.
> - */
> - if (irqd->chip == &ioapic_chip) {
> - mpd->entry.dest = cfg->dest_apicid;
> - mpd->entry.vector = cfg->vector;
> - }
> - for_each_irq_pin(entry, mpd->irq_2_pin)
> - __ioapic_write_entry(entry->apic, entry->pin, mpd->entry);
> -}
> -
> static int ioapic_set_affinity(struct irq_data *irq_data,
> const struct cpumask *mask, bool force)
> {
> struct irq_data *parent = irq_data->parent_data;
> + struct mp_chip_data *data = irq_data->chip_data;
> + struct irq_pin_list *entry;
> + struct irq_cfg *cfg;
> unsigned long flags;
> int ret;
>
> ret = parent->chip->irq_set_affinity(parent, mask, force);
> raw_spin_lock_irqsave(&ioapic_lock, flags);
> - if (ret >= 0 && ret != IRQ_SET_MASK_OK_DONE)
> - ioapic_configure_entry(irq_data);
> + if (ret >= 0 && ret != IRQ_SET_MASK_OK_DONE) {
> + cfg = irqd_cfg(irq_data);
> + data->entry.dest = cfg->dest_apicid;
> + data->entry.vector = cfg->vector;
> + for_each_irq_pin(entry, data->irq_2_pin)
> + __ioapic_write_entry(entry->apic, entry->pin,
> + data->entry);
> + }
> raw_spin_unlock_irqrestore(&ioapic_lock, flags);
>
> return ret;
> @@ -2565,9 +2513,52 @@ int acpi_get_override_irq(u32 gsi, int *trigger, int *polarity)
> }
>
> /*
> - * This function updates target affinity of IOAPIC interrupts to include
> - * the CPUs which came online during SMP bringup.
> + * This function currently is only a helper for the i386 smp boot process where
> + * we need to reprogram the ioredtbls to cater for the cpus which have come online
> + * so mask in all cases should simply be apic->target_cpus()
> */
> +#ifdef CONFIG_SMP
> +void __init setup_ioapic_dest(void)
> +{
> + int pin, ioapic, irq, irq_entry;
> + const struct cpumask *mask;
> + struct irq_desc *desc;
> + struct irq_data *idata;
> + struct irq_chip *chip;
> +
> + if (skip_ioapic_setup == 1)
> + return;
> +
> + for_each_ioapic_pin(ioapic, pin) {
> + irq_entry = find_irq_entry(ioapic, pin, mp_INT);
> + if (irq_entry == -1)
> + continue;
> +
> + irq = pin_2_irq(irq_entry, ioapic, pin, 0);
> + if (irq < 0 || !mp_init_irq_at_boot(ioapic, irq))
> + continue;
> +
> + desc = irq_to_desc(irq);
> + raw_spin_lock_irq(&desc->lock);
> + idata = irq_desc_get_irq_data(desc);
> +
> + /*
> + * Honour affinities which have been set in early boot
> + */
> + if (!irqd_can_balance(idata) || irqd_affinity_was_set(idata))
> + mask = irq_data_get_affinity_mask(idata);
> + else
> + mask = apic->target_cpus();
> +
> + chip = irq_data_get_irq_chip(idata);
> + /* Might be lapic_chip for irq 0 */
> + if (chip->irq_set_affinity)
> + chip->irq_set_affinity(idata, mask, false);
> + raw_spin_unlock_irq(&desc->lock);
> + }
> +}
> +#endif
> +
> #define IOAPIC_RESOURCE_NAME_SIZE 11
>
> static struct resource *ioapic_resources;
> @@ -2991,9 +2982,12 @@ int mp_irqdomain_activate(struct irq_domain *domain,
> struct irq_data *irq_data, bool early)
> {
> unsigned long flags;
> + struct irq_pin_list *entry;
> + struct mp_chip_data *data = irq_data->chip_data;
>
> raw_spin_lock_irqsave(&ioapic_lock, flags);
> - ioapic_configure_entry(irq_data);
> + for_each_irq_pin(entry, data->irq_2_pin)
> + __ioapic_write_entry(entry->apic, entry->pin, data->entry);
> raw_spin_unlock_irqrestore(&ioapic_lock, flags);
> return 0;
> }
> diff --git a/arch/x86/kernel/apic/probe_32.c b/arch/x86/kernel/apic/probe_32.c
> index fa22017de806..63287659adb6 100644
> --- a/arch/x86/kernel/apic/probe_32.c
> +++ b/arch/x86/kernel/apic/probe_32.c
> @@ -66,31 +66,6 @@ static void setup_apic_flat_routing(void)
> #endif
> }
>
> -static int default_apic_id_registered(void)
> -{
> - return physid_isset(read_apic_id(), phys_cpu_present_map);
> -}
> -
> -/*
> - * Set up the logical destination ID. Intel recommends to set DFR, LDR and
> - * TPR before enabling an APIC. See e.g. "AP-388 82489DX User's Manual"
> - * (Intel document number 292116).
> - */
> -static void default_init_apic_ldr(void)
> -{
> - unsigned long val;
> -
> - apic_write(APIC_DFR, APIC_DFR_VALUE);
> - val = apic_read(APIC_LDR) & ~APIC_LDR_MASK;
> - val |= SET_APIC_LOGICAL_ID(1UL << smp_processor_id());
> - apic_write(APIC_LDR, val);
> -}
> -
> -static int default_phys_pkg_id(int cpuid_apic, int index_msb)
> -{
> - return cpuid_apic >> index_msb;
> -}
> -
> /* should be called last. */
> static int probe_default(void)
> {
> @@ -109,10 +84,12 @@ static struct apic apic_default __ro_after_init = {
> /* logical delivery broadcast to all CPUs: */
> .irq_dest_mode = 1,
>
> + .target_cpus = default_target_cpus,
> .disable_esr = 0,
> .dest_logical = APIC_DEST_LOGICAL,
> .check_apicid_used = default_check_apicid_used,
>
> + .vector_allocation_domain = flat_vector_allocation_domain,
> .init_apic_ldr = default_init_apic_ldr,
>
> .ioapic_phys_id_map = default_ioapic_phys_id_map,
> @@ -125,7 +102,7 @@ static struct apic apic_default __ro_after_init = {
> .get_apic_id = default_get_apic_id,
> .set_apic_id = NULL,
>
> - .calc_dest_apicid = apic_flat_calc_apicid,
> + .cpu_mask_to_apicid = flat_cpu_mask_to_apicid,
>
> .send_IPI = default_send_IPI_single,
> .send_IPI_mask = default_send_IPI_mask_logical,
> diff --git a/arch/x86/kernel/apic/vector.c b/arch/x86/kernel/apic/vector.c
> index 6a823a25eaff..e42fdd44972f 100644
> --- a/arch/x86/kernel/apic/vector.c
> +++ b/arch/x86/kernel/apic/vector.c
> @@ -11,7 +11,6 @@
> * published by the Free Software Foundation.
> */
> #include <linux/interrupt.h>
> -#include <linux/seq_file.h>
> #include <linux/init.h>
> #include <linux/compiler.h>
> #include <linux/slab.h>
> @@ -22,30 +21,20 @@
> #include <asm/desc.h>
> #include <asm/irq_remapping.h>
>
> -#include <asm/trace/irq_vectors.h>
> -
> struct apic_chip_data {
> - struct irq_cfg hw_irq_cfg;
> - unsigned int vector;
> - unsigned int prev_vector;
> - unsigned int cpu;
> - unsigned int prev_cpu;
> - unsigned int irq;
> - struct hlist_node clist;
> - unsigned int move_in_progress : 1,
> - is_managed : 1,
> - can_reserve : 1,
> - has_reserved : 1;
> + struct irq_cfg cfg;
> + cpumask_var_t domain;
> + cpumask_var_t old_domain;
> + u8 move_in_progress : 1;
> };
>
> struct irq_domain *x86_vector_domain;
> EXPORT_SYMBOL_GPL(x86_vector_domain);
> static DEFINE_RAW_SPINLOCK(vector_lock);
> -static cpumask_var_t vector_searchmask;
> +static cpumask_var_t vector_cpumask, vector_searchmask, searched_cpumask;
> static struct irq_chip lapic_controller;
> -static struct irq_matrix *vector_matrix;
> -#ifdef CONFIG_SMP
> -static DEFINE_PER_CPU(struct hlist_head, cleanup_list);
> +#ifdef CONFIG_X86_IO_APIC
> +static struct apic_chip_data *legacy_irq_data[NR_IRQS_LEGACY];
> #endif
>
> void lock_vector_lock(void)
> @@ -61,37 +50,22 @@ void unlock_vector_lock(void)
> raw_spin_unlock(&vector_lock);
> }
>
> -void init_irq_alloc_info(struct irq_alloc_info *info,
> - const struct cpumask *mask)
> -{
> - memset(info, 0, sizeof(*info));
> - info->mask = mask;
> -}
> -
> -void copy_irq_alloc_info(struct irq_alloc_info *dst, struct irq_alloc_info *src)
> +static struct apic_chip_data *apic_chip_data(struct irq_data *irq_data)
> {
> - if (src)
> - *dst = *src;
> - else
> - memset(dst, 0, sizeof(*dst));
> -}
> -
> -static struct apic_chip_data *apic_chip_data(struct irq_data *irqd)
> -{
> - if (!irqd)
> + if (!irq_data)
> return NULL;
>
> - while (irqd->parent_data)
> - irqd = irqd->parent_data;
> + while (irq_data->parent_data)
> + irq_data = irq_data->parent_data;
>
> - return irqd->chip_data;
> + return irq_data->chip_data;
> }
>
> -struct irq_cfg *irqd_cfg(struct irq_data *irqd)
> +struct irq_cfg *irqd_cfg(struct irq_data *irq_data)
> {
> - struct apic_chip_data *apicd = apic_chip_data(irqd);
> + struct apic_chip_data *data = apic_chip_data(irq_data);
>
> - return apicd ? &apicd->hw_irq_cfg : NULL;
> + return data ? &data->cfg : NULL;
> }
> EXPORT_SYMBOL_GPL(irqd_cfg);
>
> @@ -102,395 +76,270 @@ struct irq_cfg *irq_cfg(unsigned int irq)
>
> static struct apic_chip_data *alloc_apic_chip_data(int node)
> {
> - struct apic_chip_data *apicd;
> -
> - apicd = kzalloc_node(sizeof(*apicd), GFP_KERNEL, node);
> - if (apicd)
> - INIT_HLIST_NODE(&apicd->clist);
> - return apicd;
> -}
> -
> -static void free_apic_chip_data(struct apic_chip_data *apicd)
> -{
> - kfree(apicd);
> -}
> -
> -static void apic_update_irq_cfg(struct irq_data *irqd, unsigned int vector,
> - unsigned int cpu)
> -{
> - struct apic_chip_data *apicd = apic_chip_data(irqd);
> + struct apic_chip_data *data;
>
> - lockdep_assert_held(&vector_lock);
> -
> - apicd->hw_irq_cfg.vector = vector;
> - apicd->hw_irq_cfg.dest_apicid = apic->calc_dest_apicid(cpu);
> - irq_data_update_effective_affinity(irqd, cpumask_of(cpu));
> - trace_vector_config(irqd->irq, vector, cpu,
> - apicd->hw_irq_cfg.dest_apicid);
> -}
> -
> -static void apic_update_vector(struct irq_data *irqd, unsigned int newvec,
> - unsigned int newcpu)
> -{
> - struct apic_chip_data *apicd = apic_chip_data(irqd);
> - struct irq_desc *desc = irq_data_to_desc(irqd);
> -
> - lockdep_assert_held(&vector_lock);
> -
> - trace_vector_update(irqd->irq, newvec, newcpu, apicd->vector,
> - apicd->cpu);
> -
> - /* Setup the vector move, if required */
> - if (apicd->vector && cpu_online(apicd->cpu)) {
> - apicd->move_in_progress = true;
> - apicd->prev_vector = apicd->vector;
> - apicd->prev_cpu = apicd->cpu;
> - } else {
> - apicd->prev_vector = 0;
> + data = kzalloc_node(sizeof(*data), GFP_KERNEL, node);
> + if (!data)
> + return NULL;
> + if (!zalloc_cpumask_var_node(&data->domain, GFP_KERNEL, node))
> + goto out_data;
> + if (!zalloc_cpumask_var_node(&data->old_domain, GFP_KERNEL, node))
> + goto out_domain;
> + return data;
> +out_domain:
> + free_cpumask_var(data->domain);
> +out_data:
> + kfree(data);
> + return NULL;
> +}
> +
> +static void free_apic_chip_data(struct apic_chip_data *data)
> +{
> + if (data) {
> + free_cpumask_var(data->domain);
> + free_cpumask_var(data->old_domain);
> + kfree(data);
> }
> -
> - apicd->vector = newvec;
> - apicd->cpu = newcpu;
> - BUG_ON(!IS_ERR_OR_NULL(per_cpu(vector_irq, newcpu)[newvec]));
> - per_cpu(vector_irq, newcpu)[newvec] = desc;
> }
>
> -static void vector_assign_managed_shutdown(struct irq_data *irqd)
> +static int __assign_irq_vector(int irq, struct apic_chip_data *d,
> + const struct cpumask *mask,
> + struct irq_data *irqdata)
> {
> - unsigned int cpu = cpumask_first(cpu_online_mask);
> -
> - apic_update_irq_cfg(irqd, MANAGED_IRQ_SHUTDOWN_VECTOR, cpu);
> -}
> + /*
> + * NOTE! The local APIC isn't very good at handling
> + * multiple interrupts at the same interrupt level.
> + * As the interrupt level is determined by taking the
> + * vector number and shifting that right by 4, we
> + * want to spread these out a bit so that they don't
> + * all fall in the same interrupt level.
> + *
> + * Also, we've got to be careful not to trash gate
> + * 0x80, because int 0x80 is hm, kind of importantish. ;)
> + */
> + static int current_vector = FIRST_EXTERNAL_VECTOR + VECTOR_OFFSET_START;
> + static int current_offset = VECTOR_OFFSET_START % 16;
> + int cpu, vector;
>
> -static int reserve_managed_vector(struct irq_data *irqd)
> -{
> - const struct cpumask *affmsk = irq_data_get_affinity_mask(irqd);
> - struct apic_chip_data *apicd = apic_chip_data(irqd);
> - unsigned long flags;
> - int ret;
> + /*
> + * If there is still a move in progress or the previous move has not
> + * been cleaned up completely, tell the caller to come back later.
> + */
> + if (d->move_in_progress ||
> + cpumask_intersects(d->old_domain, cpu_online_mask))
> + return -EBUSY;
>
> - raw_spin_lock_irqsave(&vector_lock, flags);
> - apicd->is_managed = true;
> - ret = irq_matrix_reserve_managed(vector_matrix, affmsk);
> - raw_spin_unlock_irqrestore(&vector_lock, flags);
> - trace_vector_reserve_managed(irqd->irq, ret);
> - return ret;
> -}
> + /* Only try and allocate irqs on cpus that are present */
> + cpumask_clear(d->old_domain);
> + cpumask_clear(searched_cpumask);
> + cpu = cpumask_first_and(mask, cpu_online_mask);
> + while (cpu < nr_cpu_ids) {
> + int new_cpu, offset;
>
> -static void reserve_irq_vector_locked(struct irq_data *irqd)
> -{
> - struct apic_chip_data *apicd = apic_chip_data(irqd);
> + /* Get the possible target cpus for @mask/@cpu from the apic */
> + apic->vector_allocation_domain(cpu, vector_cpumask, mask);
>
> - irq_matrix_reserve(vector_matrix);
> - apicd->can_reserve = true;
> - apicd->has_reserved = true;
> - trace_vector_reserve(irqd->irq, 0);
> - vector_assign_managed_shutdown(irqd);
> -}
> + /*
> + * Clear the offline cpus from @vector_cpumask for searching
> + * and verify whether the result overlaps with @mask. If true,
> + * then the call to apic->cpu_mask_to_apicid() will
> + * succeed as well. If not, no point in trying to find a
> + * vector in this mask.
> + */
> + cpumask_and(vector_searchmask, vector_cpumask, cpu_online_mask);
> + if (!cpumask_intersects(vector_searchmask, mask))
> + goto next_cpu;
> +
> + if (cpumask_subset(vector_cpumask, d->domain)) {
> + if (cpumask_equal(vector_cpumask, d->domain))
> + goto success;
> + /*
> + * Mark the cpus which are not longer in the mask for
> + * cleanup.
> + */
> + cpumask_andnot(d->old_domain, d->domain, vector_cpumask);
> + vector = d->cfg.vector;
> + goto update;
> + }
>
> -static int reserve_irq_vector(struct irq_data *irqd)
> -{
> - unsigned long flags;
> + vector = current_vector;
> + offset = current_offset;
> +next:
> + vector += 16;
> + if (vector >= FIRST_SYSTEM_VECTOR) {
> + offset = (offset + 1) % 16;
> + vector = FIRST_EXTERNAL_VECTOR + offset;
> + }
>
> - raw_spin_lock_irqsave(&vector_lock, flags);
> - reserve_irq_vector_locked(irqd);
> - raw_spin_unlock_irqrestore(&vector_lock, flags);
> - return 0;
> -}
> + /* If the search wrapped around, try the next cpu */
> + if (unlikely(current_vector == vector))
> + goto next_cpu;
>
> -static int allocate_vector(struct irq_data *irqd, const struct cpumask *dest)
> -{
> - struct apic_chip_data *apicd = apic_chip_data(irqd);
> - bool resvd = apicd->has_reserved;
> - unsigned int cpu = apicd->cpu;
> - int vector = apicd->vector;
> + if (test_bit(vector, used_vectors))
> + goto next;
>
> - lockdep_assert_held(&vector_lock);
> + for_each_cpu(new_cpu, vector_searchmask) {
> + if (!IS_ERR_OR_NULL(per_cpu(vector_irq, new_cpu)[vector]))
> + goto next;
> + }
> + /* Found one! */
> + current_vector = vector;
> + current_offset = offset;
> + /* Schedule the old vector for cleanup on all cpus */
> + if (d->cfg.vector)
> + cpumask_copy(d->old_domain, d->domain);
> + for_each_cpu(new_cpu, vector_searchmask)
> + per_cpu(vector_irq, new_cpu)[vector] = irq_to_desc(irq);
> + goto update;
> +
> +next_cpu:
> + /*
> + * We exclude the current @vector_cpumask from the requested
> + * @mask and try again with the next online cpu in the
> + * result. We cannot modify @mask, so we use @vector_cpumask
> + * as a temporary buffer here as it will be reassigned when
> + * calling apic->vector_allocation_domain() above.
> + */
> + cpumask_or(searched_cpumask, searched_cpumask, vector_cpumask);
> + cpumask_andnot(vector_cpumask, mask, searched_cpumask);
> + cpu = cpumask_first_and(vector_cpumask, cpu_online_mask);
> + continue;
> + }
> + return -ENOSPC;
>
> +update:
> /*
> - * If the current target CPU is online and in the new requested
> - * affinity mask, there is no point in moving the interrupt from
> - * one CPU to another.
> + * Exclude offline cpus from the cleanup mask and set the
> + * move_in_progress flag when the result is not empty.
> */
> - if (vector && cpu_online(cpu) && cpumask_test_cpu(cpu, dest))
> - return 0;
> -
> - vector = irq_matrix_alloc(vector_matrix, dest, resvd, &cpu);
> - if (vector > 0)
> - apic_update_vector(irqd, vector, cpu);
> - trace_vector_alloc(irqd->irq, vector, resvd, vector);
> - return vector;
> -}
> -
> -static int assign_vector_locked(struct irq_data *irqd,
> - const struct cpumask *dest)
> -{
> - struct apic_chip_data *apicd = apic_chip_data(irqd);
> - int vector = allocate_vector(irqd, dest);
> -
> - if (vector < 0)
> - return vector;
> -
> - apic_update_irq_cfg(irqd, apicd->vector, apicd->cpu);
> + cpumask_and(d->old_domain, d->old_domain, cpu_online_mask);
> + d->move_in_progress = !cpumask_empty(d->old_domain);
> + d->cfg.old_vector = d->move_in_progress ? d->cfg.vector : 0;
> + d->cfg.vector = vector;
> + cpumask_copy(d->domain, vector_cpumask);
> +success:
> + /*
> + * Cache destination APIC IDs into cfg->dest_apicid. This cannot fail
> + * as we already established, that mask & d->domain & cpu_online_mask
> + * is not empty.
> + *
> + * vector_searchmask is a subset of d->domain and has the offline
> + * cpus masked out.
> + */
> + cpumask_and(vector_searchmask, vector_searchmask, mask);
> + BUG_ON(apic->cpu_mask_to_apicid(vector_searchmask, irqdata,
> + &d->cfg.dest_apicid));
> return 0;
> }
>
> -static int assign_irq_vector(struct irq_data *irqd, const struct cpumask *dest)
> +static int assign_irq_vector(int irq, struct apic_chip_data *data,
> + const struct cpumask *mask,
> + struct irq_data *irqdata)
> {
> + int err;
> unsigned long flags;
> - int ret;
>
> raw_spin_lock_irqsave(&vector_lock, flags);
> - cpumask_and(vector_searchmask, dest, cpu_online_mask);
> - ret = assign_vector_locked(irqd, vector_searchmask);
> + err = __assign_irq_vector(irq, data, mask, irqdata);
> raw_spin_unlock_irqrestore(&vector_lock, flags);
> - return ret;
> -}
> -
> -static int assign_irq_vector_any_locked(struct irq_data *irqd)
> -{
> - /* Get the affinity mask - either irq_default_affinity or (user) set */
> - const struct cpumask *affmsk = irq_data_get_affinity_mask(irqd);
> - int node = irq_data_get_node(irqd);
> -
> - if (node == NUMA_NO_NODE)
> - goto all;
> - /* Try the intersection of @affmsk and node mask */
> - cpumask_and(vector_searchmask, cpumask_of_node(node), affmsk);
> - if (!assign_vector_locked(irqd, vector_searchmask))
> - return 0;
> - /* Try the node mask */
> - if (!assign_vector_locked(irqd, cpumask_of_node(node)))
> - return 0;
> -all:
> - /* Try the full affinity mask */
> - cpumask_and(vector_searchmask, affmsk, cpu_online_mask);
> - if (!assign_vector_locked(irqd, vector_searchmask))
> - return 0;
> - /* Try the full online mask */
> - return assign_vector_locked(irqd, cpu_online_mask);
> -}
> -
> -static int
> -assign_irq_vector_policy(struct irq_data *irqd, struct irq_alloc_info *info)
> -{
> - if (irqd_affinity_is_managed(irqd))
> - return reserve_managed_vector(irqd);
> - if (info->mask)
> - return assign_irq_vector(irqd, info->mask);
> - /*
> - * Make only a global reservation with no guarantee. A real vector
> - * is associated at activation time.
> - */
> - return reserve_irq_vector(irqd);
> + return err;
> }
>
> -static int
> -assign_managed_vector(struct irq_data *irqd, const struct cpumask *dest)
> +static int assign_irq_vector_policy(int irq, int node,
> + struct apic_chip_data *data,
> + struct irq_alloc_info *info,
> + struct irq_data *irqdata)
> {
> - const struct cpumask *affmsk = irq_data_get_affinity_mask(irqd);
> - struct apic_chip_data *apicd = apic_chip_data(irqd);
> - int vector, cpu;
> -
> - cpumask_and(vector_searchmask, vector_searchmask, affmsk);
> - cpu = cpumask_first(vector_searchmask);
> - if (cpu >= nr_cpu_ids)
> - return -EINVAL;
> - /* set_affinity might call here for nothing */
> - if (apicd->vector && cpumask_test_cpu(apicd->cpu, vector_searchmask))
> + if (info && info->mask)
> + return assign_irq_vector(irq, data, info->mask, irqdata);
> + if (node != NUMA_NO_NODE &&
> + assign_irq_vector(irq, data, cpumask_of_node(node), irqdata) == 0)
> return 0;
> - vector = irq_matrix_alloc_managed(vector_matrix, cpu);
> - trace_vector_alloc_managed(irqd->irq, vector, vector);
> - if (vector < 0)
> - return vector;
> - apic_update_vector(irqd, vector, cpu);
> - apic_update_irq_cfg(irqd, vector, cpu);
> - return 0;
> -}
> -
> -static void clear_irq_vector(struct irq_data *irqd)
> -{
> - struct apic_chip_data *apicd = apic_chip_data(irqd);
> - bool managed = irqd_affinity_is_managed(irqd);
> - unsigned int vector = apicd->vector;
> -
> - lockdep_assert_held(&vector_lock);
> -
> - if (!vector)
> - return;
> -
> - trace_vector_clear(irqd->irq, vector, apicd->cpu, apicd->prev_vector,
> - apicd->prev_cpu);
> -
> - per_cpu(vector_irq, apicd->cpu)[vector] = VECTOR_UNUSED;
> - irq_matrix_free(vector_matrix, apicd->cpu, vector, managed);
> - apicd->vector = 0;
> -
> - /* Clean up move in progress */
> - vector = apicd->prev_vector;
> - if (!vector)
> - return;
> -
> - per_cpu(vector_irq, apicd->prev_cpu)[vector] = VECTOR_UNUSED;
> - irq_matrix_free(vector_matrix, apicd->prev_cpu, vector, managed);
> - apicd->prev_vector = 0;
> - apicd->move_in_progress = 0;
> - hlist_del_init(&apicd->clist);
> + return assign_irq_vector(irq, data, apic->target_cpus(), irqdata);
> }
>
> -static void x86_vector_deactivate(struct irq_domain *dom, struct irq_data *irqd)
> +static void clear_irq_vector(int irq, struct apic_chip_data *data)
> {
> - struct apic_chip_data *apicd = apic_chip_data(irqd);
> - unsigned long flags;
> + struct irq_desc *desc;
> + int cpu, vector;
>
> - trace_vector_deactivate(irqd->irq, apicd->is_managed,
> - apicd->can_reserve, false);
> -
> - /* Regular fixed assigned interrupt */
> - if (!apicd->is_managed && !apicd->can_reserve)
> - return;
> - /* If the interrupt has a global reservation, nothing to do */
> - if (apicd->has_reserved)
> + if (!data->cfg.vector)
> return;
>
> - raw_spin_lock_irqsave(&vector_lock, flags);
> - clear_irq_vector(irqd);
> - if (apicd->can_reserve)
> - reserve_irq_vector_locked(irqd);
> - else
> - vector_assign_managed_shutdown(irqd);
> - raw_spin_unlock_irqrestore(&vector_lock, flags);
> -}
> -
> -static int activate_reserved(struct irq_data *irqd)
> -{
> - struct apic_chip_data *apicd = apic_chip_data(irqd);
> - int ret;
> -
> - ret = assign_irq_vector_any_locked(irqd);
> - if (!ret)
> - apicd->has_reserved = false;
> - return ret;
> -}
> + vector = data->cfg.vector;
> + for_each_cpu_and(cpu, data->domain, cpu_online_mask)
> + per_cpu(vector_irq, cpu)[vector] = VECTOR_UNUSED;
>
> -static int activate_managed(struct irq_data *irqd)
> -{
> - const struct cpumask *dest = irq_data_get_affinity_mask(irqd);
> - int ret;
> -
> - cpumask_and(vector_searchmask, dest, cpu_online_mask);
> - if (WARN_ON_ONCE(cpumask_empty(vector_searchmask))) {
> - /* Something in the core code broke! Survive gracefully */
> - pr_err("Managed startup for irq %u, but no CPU\n", irqd->irq);
> - return EINVAL;
> - }
> + data->cfg.vector = 0;
> + cpumask_clear(data->domain);
>
> - ret = assign_managed_vector(irqd, vector_searchmask);
> /*
> - * This should not happen. The vector reservation got buggered. Handle
> - * it gracefully.
> + * If move is in progress or the old_domain mask is not empty,
> + * i.e. the cleanup IPI has not been processed yet, we need to remove
> + * the old references to desc from all cpus vector tables.
> */
> - if (WARN_ON_ONCE(ret < 0)) {
> - pr_err("Managed startup irq %u, no vector available\n",
> - irqd->irq);
> + if (!data->move_in_progress && cpumask_empty(data->old_domain))
> + return;
> +
> + desc = irq_to_desc(irq);
> + for_each_cpu_and(cpu, data->old_domain, cpu_online_mask) {
> + for (vector = FIRST_EXTERNAL_VECTOR; vector < NR_VECTORS;
> + vector++) {
> + if (per_cpu(vector_irq, cpu)[vector] != desc)
> + continue;
> + per_cpu(vector_irq, cpu)[vector] = VECTOR_UNUSED;
> + break;
> + }
> }
> - return ret;
> + data->move_in_progress = 0;
> }
>
> -static int x86_vector_activate(struct irq_domain *dom, struct irq_data *irqd,
> - bool early)
> +void init_irq_alloc_info(struct irq_alloc_info *info,
> + const struct cpumask *mask)
> {
> - struct apic_chip_data *apicd = apic_chip_data(irqd);
> - unsigned long flags;
> - int ret = 0;
> -
> - trace_vector_activate(irqd->irq, apicd->is_managed,
> - apicd->can_reserve, early);
> -
> - /* Nothing to do for fixed assigned vectors */
> - if (!apicd->can_reserve && !apicd->is_managed)
> - return 0;
> -
> - raw_spin_lock_irqsave(&vector_lock, flags);
> - if (early || irqd_is_managed_and_shutdown(irqd))
> - vector_assign_managed_shutdown(irqd);
> - else if (apicd->is_managed)
> - ret = activate_managed(irqd);
> - else if (apicd->has_reserved)
> - ret = activate_reserved(irqd);
> - raw_spin_unlock_irqrestore(&vector_lock, flags);
> - return ret;
> + memset(info, 0, sizeof(*info));
> + info->mask = mask;
> }
>
> -static void vector_free_reserved_and_managed(struct irq_data *irqd)
> +void copy_irq_alloc_info(struct irq_alloc_info *dst, struct irq_alloc_info *src)
> {
> - const struct cpumask *dest = irq_data_get_affinity_mask(irqd);
> - struct apic_chip_data *apicd = apic_chip_data(irqd);
> -
> - trace_vector_teardown(irqd->irq, apicd->is_managed,
> - apicd->has_reserved);
> -
> - if (apicd->has_reserved)
> - irq_matrix_remove_reserved(vector_matrix);
> - if (apicd->is_managed)
> - irq_matrix_remove_managed(vector_matrix, dest);
> + if (src)
> + *dst = *src;
> + else
> + memset(dst, 0, sizeof(*dst));
> }
>
> static void x86_vector_free_irqs(struct irq_domain *domain,
> unsigned int virq, unsigned int nr_irqs)
> {
> - struct apic_chip_data *apicd;
> - struct irq_data *irqd;
> + struct apic_chip_data *apic_data;
> + struct irq_data *irq_data;
> unsigned long flags;
> int i;
>
> for (i = 0; i < nr_irqs; i++) {
> - irqd = irq_domain_get_irq_data(x86_vector_domain, virq + i);
> - if (irqd && irqd->chip_data) {
> + irq_data = irq_domain_get_irq_data(x86_vector_domain, virq + i);
> + if (irq_data && irq_data->chip_data) {
> raw_spin_lock_irqsave(&vector_lock, flags);
> - clear_irq_vector(irqd);
> - vector_free_reserved_and_managed(irqd);
> - apicd = irqd->chip_data;
> - irq_domain_reset_irq_data(irqd);
> + clear_irq_vector(virq + i, irq_data->chip_data);
> + apic_data = irq_data->chip_data;
> + irq_domain_reset_irq_data(irq_data);
> raw_spin_unlock_irqrestore(&vector_lock, flags);
> - free_apic_chip_data(apicd);
> + free_apic_chip_data(apic_data);
> +#ifdef CONFIG_X86_IO_APIC
> + if (virq + i < nr_legacy_irqs())
> + legacy_irq_data[virq + i] = NULL;
> +#endif
> }
> }
> }
>
> -static bool vector_configure_legacy(unsigned int virq, struct irq_data *irqd,
> - struct apic_chip_data *apicd)
> -{
> - unsigned long flags;
> - bool realloc = false;
> -
> - apicd->vector = ISA_IRQ_VECTOR(virq);
> - apicd->cpu = 0;
> -
> - raw_spin_lock_irqsave(&vector_lock, flags);
> - /*
> - * If the interrupt is activated, then it must stay at this vector
> - * position. That's usually the timer interrupt (0).
> - */
> - if (irqd_is_activated(irqd)) {
> - trace_vector_setup(virq, true, 0);
> - apic_update_irq_cfg(irqd, apicd->vector, apicd->cpu);
> - } else {
> - /* Release the vector */
> - apicd->can_reserve = true;
> - clear_irq_vector(irqd);
> - realloc = true;
> - }
> - raw_spin_unlock_irqrestore(&vector_lock, flags);
> - return realloc;
> -}
> -
> static int x86_vector_alloc_irqs(struct irq_domain *domain, unsigned int virq,
> unsigned int nr_irqs, void *arg)
> {
> struct irq_alloc_info *info = arg;
> - struct apic_chip_data *apicd;
> - struct irq_data *irqd;
> + struct apic_chip_data *data;
> + struct irq_data *irq_data;
> int i, err, node;
>
> if (disable_apic)
> @@ -501,37 +350,34 @@ static int x86_vector_alloc_irqs(struct irq_domain *domain, unsigned int virq,
> return -ENOSYS;
>
> for (i = 0; i < nr_irqs; i++) {
> - irqd = irq_domain_get_irq_data(domain, virq + i);
> - BUG_ON(!irqd);
> - node = irq_data_get_node(irqd);
> - WARN_ON_ONCE(irqd->chip_data);
> - apicd = alloc_apic_chip_data(node);
> - if (!apicd) {
> + irq_data = irq_domain_get_irq_data(domain, virq + i);
> + BUG_ON(!irq_data);
> + node = irq_data_get_node(irq_data);
> +#ifdef CONFIG_X86_IO_APIC
> + if (virq + i < nr_legacy_irqs() && legacy_irq_data[virq + i])
> + data = legacy_irq_data[virq + i];
> + else
> +#endif
> + data = alloc_apic_chip_data(node);
> + if (!data) {
> err = -ENOMEM;
> goto error;
> }
>
> - apicd->irq = virq + i;
> - irqd->chip = &lapic_controller;
> - irqd->chip_data = apicd;
> - irqd->hwirq = virq + i;
> - irqd_set_single_target(irqd);
> - /*
> - * Legacy vectors are already assigned when the IOAPIC
> - * takes them over. They stay on the same vector. This is
> - * required for check_timer() to work correctly as it might
> - * switch back to legacy mode. Only update the hardware
> - * config.
> - */
> - if (info->flags & X86_IRQ_ALLOC_LEGACY) {
> - if (!vector_configure_legacy(virq + i, irqd, apicd))
> - continue;
> - }
> -
> - err = assign_irq_vector_policy(irqd, info);
> - trace_vector_setup(virq + i, false, err);
> + irq_data->chip = &lapic_controller;
> + irq_data->chip_data = data;
> + irq_data->hwirq = virq + i;
> + err = assign_irq_vector_policy(virq + i, node, data, info,
> + irq_data);
> if (err)
> goto error;
> + /*
> + * If the apic destination mode is physical, then the
> + * effective affinity is restricted to a single target
> + * CPU. Mark the interrupt accordingly.
> + */
> + if (!apic->irq_dest_mode)
> + irqd_set_single_target(irq_data);
> }
>
> return 0;
> @@ -541,56 +387,9 @@ static int x86_vector_alloc_irqs(struct irq_domain *domain, unsigned int virq,
> return err;
> }
>
> -#ifdef CONFIG_GENERIC_IRQ_DEBUGFS
> -void x86_vector_debug_show(struct seq_file *m, struct irq_domain *d,
> - struct irq_data *irqd, int ind)
> -{
> - unsigned int cpu, vector, prev_cpu, prev_vector;
> - struct apic_chip_data *apicd;
> - unsigned long flags;
> - int irq;
> -
> - if (!irqd) {
> - irq_matrix_debug_show(m, vector_matrix, ind);
> - return;
> - }
> -
> - irq = irqd->irq;
> - if (irq < nr_legacy_irqs() && !test_bit(irq, &io_apic_irqs)) {
> - seq_printf(m, "%*sVector: %5d\n", ind, "", ISA_IRQ_VECTOR(irq));
> - seq_printf(m, "%*sTarget: Legacy PIC all CPUs\n", ind, "");
> - return;
> - }
> -
> - apicd = irqd->chip_data;
> - if (!apicd) {
> - seq_printf(m, "%*sVector: Not assigned\n", ind, "");
> - return;
> - }
> -
> - raw_spin_lock_irqsave(&vector_lock, flags);
> - cpu = apicd->cpu;
> - vector = apicd->vector;
> - prev_cpu = apicd->prev_cpu;
> - prev_vector = apicd->prev_vector;
> - raw_spin_unlock_irqrestore(&vector_lock, flags);
> - seq_printf(m, "%*sVector: %5u\n", ind, "", vector);
> - seq_printf(m, "%*sTarget: %5u\n", ind, "", cpu);
> - if (prev_vector) {
> - seq_printf(m, "%*sPrevious vector: %5u\n", ind, "", prev_vector);
> - seq_printf(m, "%*sPrevious target: %5u\n", ind, "", prev_cpu);
> - }
> -}
> -#endif
> -
> static const struct irq_domain_ops x86_vector_domain_ops = {
> - .alloc = x86_vector_alloc_irqs,
> - .free = x86_vector_free_irqs,
> - .activate = x86_vector_activate,
> - .deactivate = x86_vector_deactivate,
> -#ifdef CONFIG_GENERIC_IRQ_DEBUGFS
> - .debug_show = x86_vector_debug_show,
> -#endif
> + .alloc = x86_vector_alloc_irqs,
> + .free = x86_vector_free_irqs,
> };
>
> int __init arch_probe_nr_irqs(void)
> @@ -620,40 +419,35 @@ int __init arch_probe_nr_irqs(void)
> return legacy_pic->probe();
> }
>
> -void lapic_assign_legacy_vector(unsigned int irq, bool replace)
> +#ifdef CONFIG_X86_IO_APIC
> +static void __init init_legacy_irqs(void)
> {
> + int i, node = cpu_to_node(0);
> + struct apic_chip_data *data;
> +
> /*
> - * Use assign system here so it wont get accounted as allocated
> - * and moveable in the cpu hotplug check and it prevents managed
> - * irq reservation from touching it.
> + * For legacy IRQ's, start with assigning irq0 to irq15 to
> + * ISA_IRQ_VECTOR(i) for all cpu's.
> */
> - irq_matrix_assign_system(vector_matrix, ISA_IRQ_VECTOR(irq), replace);
> -}
> -
> -void __init lapic_assign_system_vectors(void)
> -{
> - unsigned int i, vector = 0;
> -
> - for_each_set_bit_from(vector, system_vectors, NR_VECTORS)
> - irq_matrix_assign_system(vector_matrix, vector, false);
> -
> - if (nr_legacy_irqs() > 1)
> - lapic_assign_legacy_vector(PIC_CASCADE_IR, false);
> -
> - /* System vectors are reserved, online it */
> - irq_matrix_online(vector_matrix);
> -
> - /* Mark the preallocated legacy interrupts */
> for (i = 0; i < nr_legacy_irqs(); i++) {
> - if (i != PIC_CASCADE_IR)
> - irq_matrix_assign(vector_matrix, ISA_IRQ_VECTOR(i));
> + data = legacy_irq_data[i] = alloc_apic_chip_data(node);
> + BUG_ON(!data);
> +
> + data->cfg.vector = ISA_IRQ_VECTOR(i);
> + cpumask_setall(data->domain);
> + irq_set_chip_data(i, data);
> }
> }
> +#else
> +static inline void init_legacy_irqs(void) { }
> +#endif
>
> int __init arch_early_irq_init(void)
> {
> struct fwnode_handle *fn;
>
> + init_legacy_irqs();
> +
> fn = irq_domain_alloc_named_fwnode("VECTOR");
> BUG_ON(!fn);
> x86_vector_domain = irq_domain_create_tree(fn, &x86_vector_domain_ops,
> @@ -664,115 +458,100 @@ int __init arch_early_irq_init(void)
>
> arch_init_msi_domain(x86_vector_domain);
>
> + BUG_ON(!alloc_cpumask_var(&vector_cpumask, GFP_KERNEL));
> BUG_ON(!alloc_cpumask_var(&vector_searchmask, GFP_KERNEL));
> -
> - /*
> - * Allocate the vector matrix allocator data structure and limit the
> - * search area.
> - */
> - vector_matrix = irq_alloc_matrix(NR_VECTORS, FIRST_EXTERNAL_VECTOR,
> - FIRST_SYSTEM_VECTOR);
> - BUG_ON(!vector_matrix);
> + BUG_ON(!alloc_cpumask_var(&searched_cpumask, GFP_KERNEL));
>
> return arch_early_ioapic_init();
> }
>
> -#ifdef CONFIG_SMP
> -
> -static struct irq_desc *__setup_vector_irq(int vector)
> +/* Initialize vector_irq on a new cpu */
> +static void __setup_vector_irq(int cpu)
> {
> - int isairq = vector - ISA_IRQ_VECTOR(0);
> -
> - /* Check whether the irq is in the legacy space */
> - if (isairq < 0 || isairq >= nr_legacy_irqs())
> - return VECTOR_UNUSED;
> - /* Check whether the irq is handled by the IOAPIC */
> - if (test_bit(isairq, &io_apic_irqs))
> - return VECTOR_UNUSED;
> - return irq_to_desc(isairq);
> -}
> + struct apic_chip_data *data;
> + struct irq_desc *desc;
> + int irq, vector;
>
> -/* Online the local APIC infrastructure and initialize the vectors */
> -void lapic_online(void)
> -{
> - unsigned int vector;
> + /* Mark the inuse vectors */
> + for_each_irq_desc(irq, desc) {
> + struct irq_data *idata = irq_desc_get_irq_data(desc);
>
> - lockdep_assert_held(&vector_lock);
> -
> - /* Online the vector matrix array for this CPU */
> - irq_matrix_online(vector_matrix);
> -
> - /*
> - * The interrupt affinity logic never targets interrupts to offline
> - * CPUs. The exception are the legacy PIC interrupts. In general
> - * they are only targeted to CPU0, but depending on the platform
> - * they can be distributed to any online CPU in hardware. The
> - * kernel has no influence on that. So all active legacy vectors
> - * must be installed on all CPUs. All non legacy interrupts can be
> - * cleared.
> - */
> - for (vector = 0; vector < NR_VECTORS; vector++)
> - this_cpu_write(vector_irq[vector], __setup_vector_irq(vector));
> -}
> + data = apic_chip_data(idata);
> + if (!data || !cpumask_test_cpu(cpu, data->domain))
> + continue;
> + vector = data->cfg.vector;
> + per_cpu(vector_irq, cpu)[vector] = desc;
> + }
> + /* Mark the free vectors */
> + for (vector = 0; vector < NR_VECTORS; ++vector) {
> + desc = per_cpu(vector_irq, cpu)[vector];
> + if (IS_ERR_OR_NULL(desc))
> + continue;
>
> -void lapic_offline(void)
> -{
> - lock_vector_lock();
> - irq_matrix_offline(vector_matrix);
> - unlock_vector_lock();
> + data = apic_chip_data(irq_desc_get_irq_data(desc));
> + if (!cpumask_test_cpu(cpu, data->domain))
> + per_cpu(vector_irq, cpu)[vector] = VECTOR_UNUSED;
> + }
> }
>
> -static int apic_set_affinity(struct irq_data *irqd,
> - const struct cpumask *dest, bool force)
> +/*
> + * Setup the vector to irq mappings. Must be called with vector_lock held.
> + */
> +void setup_vector_irq(int cpu)
> {
> - struct apic_chip_data *apicd = apic_chip_data(irqd);
> - int err;
> + int irq;
>
> + lockdep_assert_held(&vector_lock);
> /*
> - * Core code can call here for inactive interrupts. For inactive
> - * interrupts which use managed or reservation mode there is no
> - * point in going through the vector assignment right now as the
> - * activation will assign a vector which fits the destination
> - * cpumask. Let the core code store the destination mask and be
> - * done with it.
> + * On most of the platforms, legacy PIC delivers the interrupts on the
> + * boot cpu. But there are certain platforms where PIC interrupts are
> + * delivered to multiple cpu's. If the legacy IRQ is handled by the
> + * legacy PIC, for the new cpu that is coming online, setup the static
> + * legacy vector to irq mapping:
> */
> - if (!irqd_is_activated(irqd) &&
> - (apicd->is_managed || apicd->can_reserve))
> - return IRQ_SET_MASK_OK;
> + for (irq = 0; irq < nr_legacy_irqs(); irq++)
> + per_cpu(vector_irq, cpu)[ISA_IRQ_VECTOR(irq)] = irq_to_desc(irq);
>
> - raw_spin_lock(&vector_lock);
> - cpumask_and(vector_searchmask, dest, cpu_online_mask);
> - if (irqd_affinity_is_managed(irqd))
> - err = assign_managed_vector(irqd, vector_searchmask);
> - else
> - err = assign_vector_locked(irqd, vector_searchmask);
> - raw_spin_unlock(&vector_lock);
> - return err ? err : IRQ_SET_MASK_OK;
> + __setup_vector_irq(cpu);
> }
>
> -#else
> -# define apic_set_affinity NULL
> -#endif
> -
> -static int apic_retrigger_irq(struct irq_data *irqd)
> +static int apic_retrigger_irq(struct irq_data *irq_data)
> {
> - struct apic_chip_data *apicd = apic_chip_data(irqd);
> + struct apic_chip_data *data = apic_chip_data(irq_data);
> unsigned long flags;
> + int cpu;
>
> raw_spin_lock_irqsave(&vector_lock, flags);
> - apic->send_IPI(apicd->cpu, apicd->vector);
> + cpu = cpumask_first_and(data->domain, cpu_online_mask);
> + apic->send_IPI_mask(cpumask_of(cpu), data->cfg.vector);
> raw_spin_unlock_irqrestore(&vector_lock, flags);
>
> return 1;
> }
>
> -void apic_ack_edge(struct irq_data *irqd)
> +void apic_ack_edge(struct irq_data *data)
> {
> - irq_complete_move(irqd_cfg(irqd));
> - irq_move_irq(irqd);
> + irq_complete_move(irqd_cfg(data));
> + irq_move_irq(data);
> ack_APIC_irq();
> }
>
> +static int apic_set_affinity(struct irq_data *irq_data,
> + const struct cpumask *dest, bool force)
> +{
> + struct apic_chip_data *data = irq_data->chip_data;
> + int err, irq = irq_data->irq;
> +
> + if (!IS_ENABLED(CONFIG_SMP))
> + return -EPERM;
> +
> + if (!cpumask_intersects(dest, cpu_online_mask))
> + return -EINVAL;
> +
> + err = assign_irq_vector(irq, data, dest, irq_data);
> + return err ? err : IRQ_SET_MASK_OK;
> +}
> +
> static struct irq_chip lapic_controller = {
> .name = "APIC",
> .irq_ack = apic_ack_edge,
> @@ -781,98 +560,115 @@ static struct irq_chip lapic_controller = {
> };
>
> #ifdef CONFIG_SMP
> +static void __send_cleanup_vector(struct apic_chip_data *data)
> +{
> + raw_spin_lock(&vector_lock);
> + cpumask_and(data->old_domain, data->old_domain, cpu_online_mask);
> + data->move_in_progress = 0;
> + if (!cpumask_empty(data->old_domain))
> + apic->send_IPI_mask(data->old_domain, IRQ_MOVE_CLEANUP_VECTOR);
> + raw_spin_unlock(&vector_lock);
> +}
>
> -static void free_moved_vector(struct apic_chip_data *apicd)
> +void send_cleanup_vector(struct irq_cfg *cfg)
> {
> - unsigned int vector = apicd->prev_vector;
> - unsigned int cpu = apicd->prev_cpu;
> - bool managed = apicd->is_managed;
> + struct apic_chip_data *data;
>
> - /*
> - * This should never happen. Managed interrupts are not
> - * migrated except on CPU down, which does not involve the
> - * cleanup vector. But try to keep the accounting correct
> - * nevertheless.
> - */
> - WARN_ON_ONCE(managed);
> -
> - trace_vector_free_moved(apicd->irq, cpu, vector, managed);
> - irq_matrix_free(vector_matrix, cpu, vector, managed);
> - per_cpu(vector_irq, cpu)[vector] = VECTOR_UNUSED;
> - hlist_del_init(&apicd->clist);
> - apicd->prev_vector = 0;
> - apicd->move_in_progress = 0;
> + data = container_of(cfg, struct apic_chip_data, cfg);
> + if (data->move_in_progress)
> + __send_cleanup_vector(data);
> }
>
> asmlinkage __visible void __irq_entry smp_irq_move_cleanup_interrupt(void)
> {
> - struct hlist_head *clhead = this_cpu_ptr(&cleanup_list);
> - struct apic_chip_data *apicd;
> - struct hlist_node *tmp;
> + unsigned vector, me;
>
> entering_ack_irq();
> +
> /* Prevent vectors vanishing under us */
> raw_spin_lock(&vector_lock);
>
> - hlist_for_each_entry_safe(apicd, tmp, clhead, clist) {
> - unsigned int irr, vector = apicd->prev_vector;
> + me = smp_processor_id();
> + for (vector = FIRST_EXTERNAL_VECTOR; vector < NR_VECTORS; vector++) {
> + struct apic_chip_data *data;
> + struct irq_desc *desc;
> + unsigned int irr;
> +
> + retry:
> + desc = __this_cpu_read(vector_irq[vector]);
> + if (IS_ERR_OR_NULL(desc))
> + continue;
> +
> + if (!raw_spin_trylock(&desc->lock)) {
> + raw_spin_unlock(&vector_lock);
> + cpu_relax();
> + raw_spin_lock(&vector_lock);
> + goto retry;
> + }
> +
> + data = apic_chip_data(irq_desc_get_irq_data(desc));
> + if (!data)
> + goto unlock;
>
> /*
> - * Paranoia: Check if the vector that needs to be cleaned
> - * up is registered at the APICs IRR. If so, then this is
> - * not the best time to clean it up. Clean it up in the
> - * next attempt by sending another IRQ_MOVE_CLEANUP_VECTOR
> - * to this CPU. IRQ_MOVE_CLEANUP_VECTOR is the lowest
> - * priority external vector, so on return from this
> - * interrupt the device interrupt will happen first.
> + * Nothing to cleanup if irq migration is in progress
> + * or this cpu is not set in the cleanup mask.
> + */
> + if (data->move_in_progress ||
> + !cpumask_test_cpu(me, data->old_domain))
> + goto unlock;
> +
> + /*
> + * We have two cases to handle here:
> + * 1) vector is unchanged but the target mask got reduced
> + * 2) vector and the target mask has changed
> + *
> + * #1 is obvious, but in #2 we have two vectors with the same
> + * irq descriptor: the old and the new vector. So we need to
> + * make sure that we only cleanup the old vector. The new
> + * vector has the current @vector number in the config and
> + * this cpu is part of the target mask. We better leave that
> + * one alone.
> */
> + if (vector == data->cfg.vector &&
> + cpumask_test_cpu(me, data->domain))
> + goto unlock;
> +
> irr = apic_read(APIC_IRR + (vector / 32 * 0x10));
> - if (irr & (1U << (vector % 32))) {
> + /*
> + * Check if the vector that needs to be cleanedup is
> + * registered at the cpu's IRR. If so, then this is not
> + * the best time to clean it up. Lets clean it up in the
> + * next attempt by sending another IRQ_MOVE_CLEANUP_VECTOR
> + * to myself.
> + */
> + if (irr & (1 << (vector % 32))) {
> apic->send_IPI_self(IRQ_MOVE_CLEANUP_VECTOR);
> - continue;
> + goto unlock;
> }
> - free_moved_vector(apicd);
> + __this_cpu_write(vector_irq[vector], VECTOR_UNUSED);
> + cpumask_clear_cpu(me, data->old_domain);
> +unlock:
> + raw_spin_unlock(&desc->lock);
> }
>
> raw_spin_unlock(&vector_lock);
> - exiting_irq();
> -}
>
> -static void __send_cleanup_vector(struct apic_chip_data *apicd)
> -{
> - unsigned int cpu;
> -
> - raw_spin_lock(&vector_lock);
> - apicd->move_in_progress = 0;
> - cpu = apicd->prev_cpu;
> - if (cpu_online(cpu)) {
> - hlist_add_head(&apicd->clist, per_cpu_ptr(&cleanup_list, cpu));
> - apic->send_IPI(cpu, IRQ_MOVE_CLEANUP_VECTOR);
> - } else {
> - apicd->prev_vector = 0;
> - }
> - raw_spin_unlock(&vector_lock);
> -}
> -
> -void send_cleanup_vector(struct irq_cfg *cfg)
> -{
> - struct apic_chip_data *apicd;
> -
> - apicd = container_of(cfg, struct apic_chip_data, hw_irq_cfg);
> - if (apicd->move_in_progress)
> - __send_cleanup_vector(apicd);
> + exiting_irq();
> }
>
> static void __irq_complete_move(struct irq_cfg *cfg, unsigned vector)
> {
> - struct apic_chip_data *apicd;
> + unsigned me;
> + struct apic_chip_data *data;
>
> - apicd = container_of(cfg, struct apic_chip_data, hw_irq_cfg);
> - if (likely(!apicd->move_in_progress))
> + data = container_of(cfg, struct apic_chip_data, cfg);
> + if (likely(!data->move_in_progress))
> return;
>
> - if (vector == apicd->vector && apicd->cpu == smp_processor_id())
> - __send_cleanup_vector(apicd);
> + me = smp_processor_id();
> + if (vector == data->cfg.vector && cpumask_test_cpu(me, data->domain))
> + __send_cleanup_vector(data);
> }
>
> void irq_complete_move(struct irq_cfg *cfg)
> @@ -885,9 +681,10 @@ void irq_complete_move(struct irq_cfg *cfg)
> */
> void irq_force_complete_move(struct irq_desc *desc)
> {
> - struct apic_chip_data *apicd;
> - struct irq_data *irqd;
> - unsigned int vector;
> + struct irq_data *irqdata;
> + struct apic_chip_data *data;
> + struct irq_cfg *cfg;
> + unsigned int cpu;
>
> /*
> * The function is called for all descriptors regardless of which
> @@ -898,31 +695,43 @@ void irq_force_complete_move(struct irq_desc *desc)
> * Check first that the chip_data is what we expect
> * (apic_chip_data) before touching it any further.
> */
> - irqd = irq_domain_get_irq_data(x86_vector_domain,
> - irq_desc_get_irq(desc));
> - if (!irqd)
> + irqdata = irq_domain_get_irq_data(x86_vector_domain,
> + irq_desc_get_irq(desc));
> + if (!irqdata)
> return;
>
> - raw_spin_lock(&vector_lock);
> - apicd = apic_chip_data(irqd);
> - if (!apicd)
> - goto unlock;
> + data = apic_chip_data(irqdata);
> + cfg = data ? &data->cfg : NULL;
>
> - /*
> - * If prev_vector is empty, no action required.
> - */
> - vector = apicd->prev_vector;
> - if (!vector)
> - goto unlock;
> + if (!cfg)
> + return;
>
> /*
> - * This is tricky. If the cleanup of the old vector has not been
> + * This is tricky. If the cleanup of @data->old_domain has not been
> * done yet, then the following setaffinity call will fail with
> * -EBUSY. This can leave the interrupt in a stale state.
> *
> * All CPUs are stuck in stop machine with interrupts disabled so
> * calling __irq_complete_move() would be completely pointless.
> - *
> + */
> + raw_spin_lock(&vector_lock);
> + /*
> + * Clean out all offline cpus (including the outgoing one) from the
> + * old_domain mask.
> + */
> + cpumask_and(data->old_domain, data->old_domain, cpu_online_mask);
> +
> + /*
> + * If move_in_progress is cleared and the old_domain mask is empty,
> + * then there is nothing to cleanup. fixup_irqs() will take care of
> + * the stale vectors on the outgoing cpu.
> + */
> + if (!data->move_in_progress && cpumask_empty(data->old_domain)) {
> + raw_spin_unlock(&vector_lock);
> + return;
> + }
> +
> + /*
> * 1) The interrupt is in move_in_progress state. That means that we
> * have not seen an interrupt since the io_apic was reprogrammed to
> * the new vector.
> @@ -930,7 +739,7 @@ void irq_force_complete_move(struct irq_desc *desc)
> * 2) The interrupt has fired on the new vector, but the cleanup IPIs
> * have not been processed yet.
> */
> - if (apicd->move_in_progress) {
> + if (data->move_in_progress) {
> /*
> * In theory there is a race:
> *
> @@ -964,43 +773,21 @@ void irq_force_complete_move(struct irq_desc *desc)
> * area arises.
> */
> pr_warn("IRQ fixup: irq %d move in progress, old vector %d\n",
> - irqd->irq, vector);
> + irqdata->irq, cfg->old_vector);
> }
> - free_moved_vector(apicd);
> -unlock:
> - raw_spin_unlock(&vector_lock);
> -}
> -
> -#ifdef CONFIG_HOTPLUG_CPU
> -/*
> - * Note, this is not accurate accounting, but at least good enough to
> - * prevent that the actual interrupt move will run out of vectors.
> - */
> -int lapic_can_unplug_cpu(void)
> -{
> - unsigned int rsvd, avl, tomove, cpu = smp_processor_id();
> - int ret = 0;
> + /*
> + * If old_domain is not empty, then other cpus still have the irq
> + * descriptor set in their vector array. Clean it up.
> + */
> + for_each_cpu(cpu, data->old_domain)
> + per_cpu(vector_irq, cpu)[cfg->old_vector] = VECTOR_UNUSED;
>
> - raw_spin_lock(&vector_lock);
> - tomove = irq_matrix_allocated(vector_matrix);
> - avl = irq_matrix_available(vector_matrix, true);
> - if (avl < tomove) {
> - pr_warn("CPU %u has %u vectors, %u available. Cannot disable CPU\n",
> - cpu, tomove, avl);
> - ret = -ENOSPC;
> - goto out;
> - }
> - rsvd = irq_matrix_reserved(vector_matrix);
> - if (avl < rsvd) {
> - pr_warn("Reserved vectors %u > available %u. IRQ request may fail\n",
> - rsvd, avl);
> - }
> -out:
> + /* Cleanup the left overs of the (half finished) move */
> + cpumask_clear(data->old_domain);
> + data->move_in_progress = 0;
> raw_spin_unlock(&vector_lock);
> - return ret;
> }
> -#endif /* HOTPLUG_CPU */
> -#endif /* SMP */
> +#endif
>
> static void __init print_APIC_field(int base)
> {
> diff --git a/arch/x86/kernel/apic/x2apic.h b/arch/x86/kernel/apic/x2apic.h
> deleted file mode 100644
> index b107de381cb5..000000000000
> --- a/arch/x86/kernel/apic/x2apic.h
> +++ /dev/null
> @@ -1,9 +0,0 @@
> -/* Common bits for X2APIC cluster/physical modes. */
> -
> -int x2apic_apic_id_valid(int apicid);
> -int x2apic_apic_id_registered(void);
> -void __x2apic_send_IPI_dest(unsigned int apicid, int vector, unsigned int dest);
> -unsigned int x2apic_get_apic_id(unsigned long id);
> -u32 x2apic_set_apic_id(unsigned int id);
> -int x2apic_phys_pkg_id(int initial_apicid, int index_msb);
> -void x2apic_send_IPI_self(int vector);
> diff --git a/arch/x86/kernel/apic/x2apic_cluster.c b/arch/x86/kernel/apic/x2apic_cluster.c
> index 622f13ca8a94..e216cf3d64d2 100644
> --- a/arch/x86/kernel/apic/x2apic_cluster.c
> +++ b/arch/x86/kernel/apic/x2apic_cluster.c
> @@ -9,24 +9,22 @@
> #include <linux/cpu.h>
>
> #include <asm/smp.h>
> -#include "x2apic.h"
> -
> -struct cluster_mask {
> - unsigned int clusterid;
> - int node;
> - struct cpumask mask;
> -};
> +#include <asm/x2apic.h>
>
> static DEFINE_PER_CPU(u32, x86_cpu_to_logical_apicid);
> +static DEFINE_PER_CPU(cpumask_var_t, cpus_in_cluster);
> static DEFINE_PER_CPU(cpumask_var_t, ipi_mask);
> -static DEFINE_PER_CPU(struct cluster_mask *, cluster_masks);
> -static struct cluster_mask *cluster_hotplug_mask;
>
> static int x2apic_acpi_madt_oem_check(char *oem_id, char *oem_table_id)
> {
> return x2apic_enabled();
> }
>
> +static inline u32 x2apic_cluster(int cpu)
> +{
> + return per_cpu(x86_cpu_to_logical_apicid, cpu) >> 16;
> +}
> +
> static void x2apic_send_IPI(int cpu, int vector)
> {
> u32 dest = per_cpu(x86_cpu_to_logical_apicid, cpu);
> @@ -38,34 +36,49 @@ static void x2apic_send_IPI(int cpu, int vector)
> static void
> __x2apic_send_IPI_mask(const struct cpumask *mask, int vector, int apic_dest)
> {
> - unsigned int cpu, clustercpu;
> - struct cpumask *tmpmsk;
> + struct cpumask *cpus_in_cluster_ptr;
> + struct cpumask *ipi_mask_ptr;
> + unsigned int cpu, this_cpu;
> unsigned long flags;
> u32 dest;
>
> x2apic_wrmsr_fence();
> +
> local_irq_save(flags);
>
> - tmpmsk = this_cpu_cpumask_var_ptr(ipi_mask);
> - cpumask_copy(tmpmsk, mask);
> - /* If IPI should not be sent to self, clear current CPU */
> - if (apic_dest != APIC_DEST_ALLINC)
> - cpumask_clear_cpu(smp_processor_id(), tmpmsk);
> + this_cpu = smp_processor_id();
>
> - /* Collapse cpus in a cluster so a single IPI per cluster is sent */
> - for_each_cpu(cpu, tmpmsk) {
> - struct cluster_mask *cmsk = per_cpu(cluster_masks, cpu);
> + /*
> + * We are to modify mask, so we need an own copy
> + * and be sure it's manipulated with irq off.
> + */
> + ipi_mask_ptr = this_cpu_cpumask_var_ptr(ipi_mask);
> + cpumask_copy(ipi_mask_ptr, mask);
> +
> + /*
> + * The idea is to send one IPI per cluster.
> + */
> + for_each_cpu(cpu, ipi_mask_ptr) {
> + unsigned long i;
>
> + cpus_in_cluster_ptr = per_cpu(cpus_in_cluster, cpu);
> dest = 0;
> - for_each_cpu_and(clustercpu, tmpmsk, &cmsk->mask)
> - dest |= per_cpu(x86_cpu_to_logical_apicid, clustercpu);
> +
> + /* Collect cpus in cluster. */
> + for_each_cpu_and(i, ipi_mask_ptr, cpus_in_cluster_ptr) {
> + if (apic_dest == APIC_DEST_ALLINC || i != this_cpu)
> + dest |= per_cpu(x86_cpu_to_logical_apicid, i);
> + }
>
> if (!dest)
> continue;
>
> __x2apic_send_IPI_dest(dest, vector, apic->dest_logical);
> - /* Remove cluster CPUs from tmpmask */
> - cpumask_andnot(tmpmsk, tmpmsk, &cmsk->mask);
> + /*
> + * Cluster sibling cpus should be discared now so
> + * we would not send IPI them second time.
> + */
> + cpumask_andnot(ipi_mask_ptr, ipi_mask_ptr, cpus_in_cluster_ptr);
> }
>
> local_irq_restore(flags);
> @@ -92,90 +105,125 @@ static void x2apic_send_IPI_all(int vector)
> __x2apic_send_IPI_mask(cpu_online_mask, vector, APIC_DEST_ALLINC);
> }
>
> -static u32 x2apic_calc_apicid(unsigned int cpu)
> +static int
> +x2apic_cpu_mask_to_apicid(const struct cpumask *mask, struct irq_data *irqdata,
> + unsigned int *apicid)
> {
> - return per_cpu(x86_cpu_to_logical_apicid, cpu);
> -}
> -
> -static void init_x2apic_ldr(void)
> -{
> - struct cluster_mask *cmsk = this_cpu_read(cluster_masks);
> - u32 cluster, apicid = apic_read(APIC_LDR);
> + struct cpumask *effmsk = irq_data_get_effective_affinity_mask(irqdata);
> unsigned int cpu;
> + u32 dest = 0;
> + u16 cluster;
>
> - this_cpu_write(x86_cpu_to_logical_apicid, apicid);
> + cpu = cpumask_first(mask);
> + if (cpu >= nr_cpu_ids)
> + return -EINVAL;
>
> - if (cmsk)
> - goto update;
> + dest = per_cpu(x86_cpu_to_logical_apicid, cpu);
> + cluster = x2apic_cluster(cpu);
>
> - cluster = apicid >> 16;
> - for_each_online_cpu(cpu) {
> - cmsk = per_cpu(cluster_masks, cpu);
> - /* Matching cluster found. Link and update it. */
> - if (cmsk && cmsk->clusterid == cluster)
> - goto update;
> + cpumask_clear(effmsk);
> + for_each_cpu(cpu, mask) {
> + if (cluster != x2apic_cluster(cpu))
> + continue;
> + dest |= per_cpu(x86_cpu_to_logical_apicid, cpu);
> + cpumask_set_cpu(cpu, effmsk);
> }
> - cmsk = cluster_hotplug_mask;
> - cluster_hotplug_mask = NULL;
> -update:
> - this_cpu_write(cluster_masks, cmsk);
> - cpumask_set_cpu(smp_processor_id(), &cmsk->mask);
> +
> + *apicid = dest;
> + return 0;
> }
>
> -static int alloc_clustermask(unsigned int cpu, int node)
> +static void init_x2apic_ldr(void)
> {
> - if (per_cpu(cluster_masks, cpu))
> - return 0;
> - /*
> - * If a hotplug spare mask exists, check whether it's on the right
> - * node. If not, free it and allocate a new one.
> - */
> - if (cluster_hotplug_mask) {
> - if (cluster_hotplug_mask->node == node)
> - return 0;
> - kfree(cluster_hotplug_mask);
> - }
> + unsigned int this_cpu = smp_processor_id();
> + unsigned int cpu;
>
> - cluster_hotplug_mask = kzalloc_node(sizeof(*cluster_hotplug_mask),
> - GFP_KERNEL, node);
> - if (!cluster_hotplug_mask)
> - return -ENOMEM;
> - cluster_hotplug_mask->node = node;
> - return 0;
> + per_cpu(x86_cpu_to_logical_apicid, this_cpu) = apic_read(APIC_LDR);
> +
> + cpumask_set_cpu(this_cpu, per_cpu(cpus_in_cluster, this_cpu));
> + for_each_online_cpu(cpu) {
> + if (x2apic_cluster(this_cpu) != x2apic_cluster(cpu))
> + continue;
> + cpumask_set_cpu(this_cpu, per_cpu(cpus_in_cluster, cpu));
> + cpumask_set_cpu(cpu, per_cpu(cpus_in_cluster, this_cpu));
> + }
> }
>
> +/*
> + * At CPU state changes, update the x2apic cluster sibling info.
> + */
> static int x2apic_prepare_cpu(unsigned int cpu)
> {
> - if (alloc_clustermask(cpu, cpu_to_node(cpu)) < 0)
> + if (!zalloc_cpumask_var(&per_cpu(cpus_in_cluster, cpu), GFP_KERNEL))
> return -ENOMEM;
> - if (!zalloc_cpumask_var(&per_cpu(ipi_mask, cpu), GFP_KERNEL))
> +
> + if (!zalloc_cpumask_var(&per_cpu(ipi_mask, cpu), GFP_KERNEL)) {
> + free_cpumask_var(per_cpu(cpus_in_cluster, cpu));
> return -ENOMEM;
> + }
> +
> return 0;
> }
>
> -static int x2apic_dead_cpu(unsigned int dead_cpu)
> +static int x2apic_dead_cpu(unsigned int this_cpu)
> {
> - struct cluster_mask *cmsk = per_cpu(cluster_masks, dead_cpu);
> + int cpu;
>
> - cpumask_clear_cpu(dead_cpu, &cmsk->mask);
> - free_cpumask_var(per_cpu(ipi_mask, dead_cpu));
> + for_each_online_cpu(cpu) {
> + if (x2apic_cluster(this_cpu) != x2apic_cluster(cpu))
> + continue;
> + cpumask_clear_cpu(this_cpu, per_cpu(cpus_in_cluster, cpu));
> + cpumask_clear_cpu(cpu, per_cpu(cpus_in_cluster, this_cpu));
> + }
> + free_cpumask_var(per_cpu(cpus_in_cluster, this_cpu));
> + free_cpumask_var(per_cpu(ipi_mask, this_cpu));
> return 0;
> }
>
> static int x2apic_cluster_probe(void)
> {
> + int cpu = smp_processor_id();
> + int ret;
> +
> if (!x2apic_mode)
> return 0;
>
> - if (cpuhp_setup_state(CPUHP_X2APIC_PREPARE, "x86/x2apic:prepare",
> - x2apic_prepare_cpu, x2apic_dead_cpu) < 0) {
> + ret = cpuhp_setup_state(CPUHP_X2APIC_PREPARE, "x86/x2apic:prepare",
> + x2apic_prepare_cpu, x2apic_dead_cpu);
> + if (ret < 0) {
> pr_err("Failed to register X2APIC_PREPARE\n");
> return 0;
> }
> - init_x2apic_ldr();
> + cpumask_set_cpu(cpu, per_cpu(cpus_in_cluster, cpu));
> return 1;
> }
>
> +static const struct cpumask *x2apic_cluster_target_cpus(void)
> +{
> + return cpu_all_mask;
> +}
> +
> +/*
> + * Each x2apic cluster is an allocation domain.
> + */
> +static void cluster_vector_allocation_domain(int cpu, struct cpumask *retmask,
> + const struct cpumask *mask)
> +{
> + /*
> + * To minimize vector pressure, default case of boot, device bringup
> + * etc will use a single cpu for the interrupt destination.
> + *
> + * On explicit migration requests coming from irqbalance etc,
> + * interrupts will be routed to the x2apic cluster (cluster-id
> + * derived from the first cpu in the mask) members specified
> + * in the mask.
> + */
> + if (mask == x2apic_cluster_target_cpus())
> + cpumask_copy(retmask, cpumask_of(cpu));
> + else
> + cpumask_and(retmask, mask, per_cpu(cpus_in_cluster, cpu));
> +}
> +
> static struct apic apic_x2apic_cluster __ro_after_init = {
>
> .name = "cluster x2apic",
> @@ -187,10 +235,12 @@ static struct apic apic_x2apic_cluster __ro_after_init = {
> .irq_delivery_mode = dest_LowestPrio,
> .irq_dest_mode = 1, /* logical */
>
> + .target_cpus = x2apic_cluster_target_cpus,
> .disable_esr = 0,
> .dest_logical = APIC_DEST_LOGICAL,
> .check_apicid_used = NULL,
>
> + .vector_allocation_domain = cluster_vector_allocation_domain,
> .init_apic_ldr = init_x2apic_ldr,
>
> .ioapic_phys_id_map = NULL,
> @@ -203,7 +253,7 @@ static struct apic apic_x2apic_cluster __ro_after_init = {
> .get_apic_id = x2apic_get_apic_id,
> .set_apic_id = x2apic_set_apic_id,
>
> - .calc_dest_apicid = x2apic_calc_apicid,
> + .cpu_mask_to_apicid = x2apic_cpu_mask_to_apicid,
>
> .send_IPI = x2apic_send_IPI,
> .send_IPI_mask = x2apic_send_IPI_mask,
> diff --git a/arch/x86/kernel/apic/x2apic_phys.c b/arch/x86/kernel/apic/x2apic_phys.c
> index f8d9d69994e6..b94d35320f85 100644
> --- a/arch/x86/kernel/apic/x2apic_phys.c
> +++ b/arch/x86/kernel/apic/x2apic_phys.c
> @@ -7,8 +7,7 @@
> #include <linux/dmar.h>
>
> #include <asm/smp.h>
> -#include <asm/ipi.h>
> -#include "x2apic.h"
> +#include <asm/x2apic.h>
>
> int x2apic_phys;
>
> @@ -100,43 +99,6 @@ static int x2apic_phys_probe(void)
> return apic == &apic_x2apic_phys;
> }
>
> -/* Common x2apic functions, also used by x2apic_cluster */
> -int x2apic_apic_id_valid(int apicid)
> -{
> - return 1;
> -}
> -
> -int x2apic_apic_id_registered(void)
> -{
> - return 1;
> -}
> -
> -void __x2apic_send_IPI_dest(unsigned int apicid, int vector, unsigned int dest)
> -{
> - unsigned long cfg = __prepare_ICR(0, vector, dest);
> - native_x2apic_icr_write(cfg, apicid);
> -}
> -
> -unsigned int x2apic_get_apic_id(unsigned long id)
> -{
> - return id;
> -}
> -
> -u32 x2apic_set_apic_id(unsigned int id)
> -{
> - return id;
> -}
> -
> -int x2apic_phys_pkg_id(int initial_apicid, int index_msb)
> -{
> - return initial_apicid >> index_msb;
> -}
> -
> -void x2apic_send_IPI_self(int vector)
> -{
> - apic_write(APIC_SELF_IPI, vector);
> -}
> -
> static struct apic apic_x2apic_phys __ro_after_init = {
>
> .name = "physical x2apic",
> @@ -148,10 +110,12 @@ static struct apic apic_x2apic_phys __ro_after_init = {
> .irq_delivery_mode = dest_Fixed,
> .irq_dest_mode = 0, /* physical */
>
> + .target_cpus = online_target_cpus,
> .disable_esr = 0,
> .dest_logical = 0,
> .check_apicid_used = NULL,
>
> + .vector_allocation_domain = default_vector_allocation_domain,
> .init_apic_ldr = init_x2apic_ldr,
>
> .ioapic_phys_id_map = NULL,
> @@ -164,7 +128,7 @@ static struct apic apic_x2apic_phys __ro_after_init = {
> .get_apic_id = x2apic_get_apic_id,
> .set_apic_id = x2apic_set_apic_id,
>
> - .calc_dest_apicid = apic_default_calc_apicid,
> + .cpu_mask_to_apicid = default_cpu_mask_to_apicid,
>
> .send_IPI = x2apic_send_IPI,
> .send_IPI_mask = x2apic_send_IPI_mask,
> diff --git a/arch/x86/kernel/apic/x2apic_uv_x.c b/arch/x86/kernel/apic/x2apic_uv_x.c
> index e1b8e8bf6b3c..2915c6d06821 100644
> --- a/arch/x86/kernel/apic/x2apic_uv_x.c
> +++ b/arch/x86/kernel/apic/x2apic_uv_x.c
> @@ -568,9 +568,16 @@ static void uv_init_apic_ldr(void)
> {
> }
>
> -static u32 apic_uv_calc_apicid(unsigned int cpu)
> +static int
> +uv_cpu_mask_to_apicid(const struct cpumask *mask, struct irq_data *irqdata,
> + unsigned int *apicid)
> {
> - return apic_default_calc_apicid(cpu) | uv_apicid_hibits;
> + int ret = default_cpu_mask_to_apicid(mask, irqdata, apicid);
> +
> + if (!ret)
> + *apicid |= uv_apicid_hibits;
> +
> + return ret;
> }
>
> static unsigned int x2apic_get_apic_id(unsigned long x)
> @@ -583,7 +590,7 @@ static unsigned int x2apic_get_apic_id(unsigned long x)
> return id;
> }
>
> -static u32 set_apic_id(unsigned int id)
> +static unsigned long set_apic_id(unsigned int id)
> {
> /* CHECKME: Do we need to mask out the xapic extra bits? */
> return id;
> @@ -620,10 +627,12 @@ static struct apic apic_x2apic_uv_x __ro_after_init = {
> .irq_delivery_mode = dest_Fixed,
> .irq_dest_mode = 0, /* Physical */
>
> + .target_cpus = online_target_cpus,
> .disable_esr = 0,
> .dest_logical = APIC_DEST_LOGICAL,
> .check_apicid_used = NULL,
>
> + .vector_allocation_domain = default_vector_allocation_domain,
> .init_apic_ldr = uv_init_apic_ldr,
>
> .ioapic_phys_id_map = NULL,
> @@ -636,7 +645,7 @@ static struct apic apic_x2apic_uv_x __ro_after_init = {
> .get_apic_id = x2apic_get_apic_id,
> .set_apic_id = set_apic_id,
>
> - .calc_dest_apicid = apic_uv_calc_apicid,
> + .cpu_mask_to_apicid = uv_cpu_mask_to_apicid,
>
> .send_IPI = uv_send_IPI_one,
> .send_IPI_mask = uv_send_IPI_mask,
> diff --git a/arch/x86/kernel/i8259.c b/arch/x86/kernel/i8259.c
> index 86c4439f9d74..8f5cb2c7060c 100644
> --- a/arch/x86/kernel/i8259.c
> +++ b/arch/x86/kernel/i8259.c
> @@ -114,7 +114,6 @@ static void make_8259A_irq(unsigned int irq)
> io_apic_irqs &= ~(1<<irq);
> irq_set_chip_and_handler(irq, &i8259A_chip, handle_level_irq);
> enable_irq(irq);
> - lapic_assign_legacy_vector(irq, true);
> }
>
> /*
> diff --git a/arch/x86/kernel/idt.c b/arch/x86/kernel/idt.c
> index d985cef3984f..014cb2fc47ff 100644
> --- a/arch/x86/kernel/idt.c
> +++ b/arch/x86/kernel/idt.c
> @@ -223,7 +223,7 @@ idt_setup_from_table(gate_desc *idt, const struct idt_data *t, int size, bool sy
> idt_init_desc(&desc, t);
> write_idt_entry(idt, t->vector, &desc);
> if (sys)
> - set_bit(t->vector, system_vectors);
> + set_bit(t->vector, used_vectors);
> }
> }
>
> @@ -311,14 +311,14 @@ void __init idt_setup_apic_and_irq_gates(void)
>
> idt_setup_from_table(idt_table, apic_idts, ARRAY_SIZE(apic_idts), true);
>
> - for_each_clear_bit_from(i, system_vectors, FIRST_SYSTEM_VECTOR) {
> + for_each_clear_bit_from(i, used_vectors, FIRST_SYSTEM_VECTOR) {
> entry = irq_entries_start + 8 * (i - FIRST_EXTERNAL_VECTOR);
> set_intr_gate(i, entry);
> }
>
> - for_each_clear_bit_from(i, system_vectors, NR_VECTORS) {
> + for_each_clear_bit_from(i, used_vectors, NR_VECTORS) {
> #ifdef CONFIG_X86_LOCAL_APIC
> - set_bit(i, system_vectors);
> + set_bit(i, used_vectors);
> set_intr_gate(i, spurious_interrupt);
> #else
> entry = irq_entries_start + 8 * (i - FIRST_EXTERNAL_VECTOR);
> @@ -356,7 +356,7 @@ void idt_invalidate(void *addr)
>
> void __init update_intr_gate(unsigned int n, const void *addr)
> {
> - if (WARN_ON_ONCE(!test_bit(n, system_vectors)))
> + if (WARN_ON_ONCE(!test_bit(n, used_vectors)))
> return;
> set_intr_gate(n, addr);
> }
> @@ -364,6 +364,6 @@ void __init update_intr_gate(unsigned int n, const void *addr)
> void alloc_intr_gate(unsigned int n, const void *addr)
> {
> BUG_ON(n < FIRST_SYSTEM_VECTOR);
> - if (!test_and_set_bit(n, system_vectors))
> + if (!test_and_set_bit(n, used_vectors))
> set_intr_gate(n, addr);
> }
> diff --git a/arch/x86/kernel/irq.c b/arch/x86/kernel/irq.c
> index 49cfd9fe7589..52089c043160 100644
> --- a/arch/x86/kernel/irq.c
> +++ b/arch/x86/kernel/irq.c
> @@ -134,7 +134,7 @@ int arch_show_interrupts(struct seq_file *p, int prec)
> seq_puts(p, " Machine check polls\n");
> #endif
> #if IS_ENABLED(CONFIG_HYPERV) || defined(CONFIG_XEN)
> - if (test_bit(HYPERVISOR_CALLBACK_VECTOR, system_vectors)) {
> + if (test_bit(HYPERVISOR_CALLBACK_VECTOR, used_vectors)) {
> seq_printf(p, "%*s: ", prec, "HYP");
> for_each_online_cpu(j)
> seq_printf(p, "%10u ",
> @@ -333,6 +333,105 @@ __visible void smp_kvm_posted_intr_nested_ipi(struct pt_regs *regs)
>
>
> #ifdef CONFIG_HOTPLUG_CPU
> +
> +/* These two declarations are only used in check_irq_vectors_for_cpu_disable()
> + * below, which is protected by stop_machine(). Putting them on the stack
> + * results in a stack frame overflow. Dynamically allocating could result in a
> + * failure so declare these two cpumasks as global.
> + */
> +static struct cpumask affinity_new, online_new;
> +
> +/*
> + * This cpu is going to be removed and its vectors migrated to the remaining
> + * online cpus. Check to see if there are enough vectors in the remaining cpus.
> + * This function is protected by stop_machine().
> + */
> +int check_irq_vectors_for_cpu_disable(void)
> +{
> + unsigned int this_cpu, vector, this_count, count;
> + struct irq_desc *desc;
> + struct irq_data *data;
> + int cpu;
> +
> + this_cpu = smp_processor_id();
> + cpumask_copy(&online_new, cpu_online_mask);
> + cpumask_clear_cpu(this_cpu, &online_new);
> +
> + this_count = 0;
> + for (vector = FIRST_EXTERNAL_VECTOR; vector < NR_VECTORS; vector++) {
> + desc = __this_cpu_read(vector_irq[vector]);
> + if (IS_ERR_OR_NULL(desc))
> + continue;
> + /*
> + * Protect against concurrent action removal, affinity
> + * changes etc.
> + */
> + raw_spin_lock(&desc->lock);
> + data = irq_desc_get_irq_data(desc);
> + cpumask_copy(&affinity_new,
> + irq_data_get_affinity_mask(data));
> + cpumask_clear_cpu(this_cpu, &affinity_new);
> +
> + /* Do not count inactive or per-cpu irqs. */
> + if (!irq_desc_has_action(desc) || irqd_is_per_cpu(data)) {
> + raw_spin_unlock(&desc->lock);
> + continue;
> + }
> +
> + raw_spin_unlock(&desc->lock);
> + /*
> + * A single irq may be mapped to multiple cpu's
> + * vector_irq[] (for example IOAPIC cluster mode). In
> + * this case we have two possibilities:
> + *
> + * 1) the resulting affinity mask is empty; that is
> + * this the down'd cpu is the last cpu in the irq's
> + * affinity mask, or
> + *
> + * 2) the resulting affinity mask is no longer a
> + * subset of the online cpus but the affinity mask is
> + * not zero; that is the down'd cpu is the last online
> + * cpu in a user set affinity mask.
> + */
> + if (cpumask_empty(&affinity_new) ||
> + !cpumask_subset(&affinity_new, &online_new))
> + this_count++;
> + }
> + /* No need to check any further. */
> + if (!this_count)
> + return 0;
> +
> + count = 0;
> + for_each_online_cpu(cpu) {
> + if (cpu == this_cpu)
> + continue;
> + /*
> + * We scan from FIRST_EXTERNAL_VECTOR to first system
> + * vector. If the vector is marked in the used vectors
> + * bitmap or an irq is assigned to it, we don't count
> + * it as available.
> + *
> + * As this is an inaccurate snapshot anyway, we can do
> + * this w/o holding vector_lock.
> + */
> + for (vector = FIRST_EXTERNAL_VECTOR;
> + vector < FIRST_SYSTEM_VECTOR; vector++) {
> + if (!test_bit(vector, used_vectors) &&
> + IS_ERR_OR_NULL(per_cpu(vector_irq, cpu)[vector])) {
> + if (++count == this_count)
> + return 0;
> + }
> + }
> + }
> +
> + if (count < this_count) {
> + pr_warn("CPU %d disable failed: CPU has %u vectors assigned and there are only %u available.\n",
> + this_cpu, this_count, count);
> + return -ERANGE;
> + }
> + return 0;
> +}
> +
> /* A cpu has been removed from cpu_online_mask. Reset irq affinities. */
> void fixup_irqs(void)
> {
> diff --git a/arch/x86/kernel/irqinit.c b/arch/x86/kernel/irqinit.c
> index 8da3e909e967..1e4094eba15e 100644
> --- a/arch/x86/kernel/irqinit.c
> +++ b/arch/x86/kernel/irqinit.c
> @@ -61,6 +61,9 @@ void __init init_ISA_irqs(void)
> struct irq_chip *chip = legacy_pic->chip;
> int i;
>
> +#if defined(CONFIG_X86_64) || defined(CONFIG_X86_LOCAL_APIC)
> + init_bsp_APIC();
> +#endif
> legacy_pic->init(0);
>
> for (i = 0; i < nr_legacy_irqs(); i++)
> @@ -91,7 +94,6 @@ void __init native_init_IRQ(void)
> x86_init.irqs.pre_vector_init();
>
> idt_setup_apic_and_irq_gates();
> - lapic_assign_system_vectors();
>
> if (!acpi_ioapic && !of_ioapic && nr_legacy_irqs())
> setup_irq(2, &irq2);
> diff --git a/arch/x86/kernel/setup.c b/arch/x86/kernel/setup.c
> index 8af2e8d0c0a1..be33a5c63d20 100644
> --- a/arch/x86/kernel/setup.c
> +++ b/arch/x86/kernel/setup.c
> @@ -136,6 +136,18 @@ RESERVE_BRK(dmi_alloc, 65536);
> static __initdata unsigned long _brk_start = (unsigned long)__brk_base;
> unsigned long _brk_end = (unsigned long)__brk_base;
>
> +#ifdef CONFIG_X86_64
> +int default_cpu_present_to_apicid(int mps_cpu)
> +{
> + return __default_cpu_present_to_apicid(mps_cpu);
> +}
> +
> +int default_check_phys_apicid_present(int phys_apicid)
> +{
> + return __default_check_phys_apicid_present(phys_apicid);
> +}
> +#endif
> +
> struct boot_params boot_params;
>
> /*
> diff --git a/arch/x86/kernel/smpboot.c b/arch/x86/kernel/smpboot.c
> index 3d01df7d7cf6..13bd986b7f90 100644
> --- a/arch/x86/kernel/smpboot.c
> +++ b/arch/x86/kernel/smpboot.c
> @@ -253,14 +253,14 @@ static void notrace start_secondary(void *unused)
> check_tsc_sync_target();
>
> /*
> - * Lock vector_lock, set CPU online and bring the vector
> - * allocator online. Online must be set with vector_lock held
> - * to prevent a concurrent irq setup/teardown from seeing a
> - * half valid vector space.
> + * Lock vector_lock and initialize the vectors on this cpu
> + * before setting the cpu online. We must set it online with
> + * vector_lock held to prevent a concurrent setup/teardown
> + * from seeing a half valid vector space.
> */
> lock_vector_lock();
> + setup_vector_irq(smp_processor_id());
> set_cpu_online(smp_processor_id(), true);
> - lapic_online();
> unlock_vector_lock();
> cpu_set_state_online(smp_processor_id());
> x86_platform.nmi_init();
> @@ -1132,10 +1132,17 @@ static __init void disable_smp(void)
> cpumask_set_cpu(0, topology_core_cpumask(0));
> }
>
> +enum {
> + SMP_OK,
> + SMP_NO_CONFIG,
> + SMP_NO_APIC,
> + SMP_FORCE_UP,
> +};
> +
> /*
> * Various sanity checks.
> */
> -static void __init smp_sanity_check(void)
> +static int __init smp_sanity_check(unsigned max_cpus)
> {
> preempt_disable();
>
> @@ -1172,6 +1179,16 @@ static void __init smp_sanity_check(void)
> physid_set(hard_smp_processor_id(), phys_cpu_present_map);
> }
>
> + /*
> + * If we couldn't find an SMP configuration at boot time,
> + * get out of here now!
> + */
> + if (!smp_found_config && !acpi_lapic) {
> + preempt_enable();
> + pr_notice("SMP motherboard not detected\n");
> + return SMP_NO_CONFIG;
> + }
> +
> /*
> * Should not be necessary because the MP table should list the boot
> * CPU too, but we do it for the sake of robustness anyway.
> @@ -1182,6 +1199,29 @@ static void __init smp_sanity_check(void)
> physid_set(hard_smp_processor_id(), phys_cpu_present_map);
> }
> preempt_enable();
> +
> + /*
> + * If we couldn't find a local APIC, then get out of here now!
> + */
> + if (APIC_INTEGRATED(boot_cpu_apic_version) &&
> + !boot_cpu_has(X86_FEATURE_APIC)) {
> + if (!disable_apic) {
> + pr_err("BIOS bug, local APIC #%d not detected!...\n",
> + boot_cpu_physical_apicid);
> + pr_err("... forcing use of dummy APIC emulation (tell your hw vendor)\n");
> + }
> + return SMP_NO_APIC;
> + }
> +
> + /*
> + * If SMP should be disabled, then really disable it!
> + */
> + if (!max_cpus) {
> + pr_info("SMP mode deactivated\n");
> + return SMP_FORCE_UP;
> + }
> +
> + return SMP_OK;
> }
>
> static void __init smp_cpu_index_default(void)
> @@ -1196,18 +1236,9 @@ static void __init smp_cpu_index_default(void)
> }
> }
>
> -static void __init smp_get_logical_apicid(void)
> -{
> - if (x2apic_mode)
> - cpu0_logical_apicid = apic_read(APIC_LDR);
> - else
> - cpu0_logical_apicid = GET_APIC_LOGICAL_ID(apic_read(APIC_LDR));
> -}
> -
> /*
> - * Prepare for SMP bootup.
> - * @max_cpus: configured maximum number of CPUs, It is a legacy parameter
> - * for common interface support.
> + * Prepare for SMP bootup. The MP table or ACPI has been read
> + * earlier. Just do some sanity checking here and enable APIC mode.
> */
> void __init native_smp_prepare_cpus(unsigned int max_cpus)
> {
> @@ -1239,27 +1270,31 @@ void __init native_smp_prepare_cpus(unsigned int max_cpus)
>
> set_cpu_sibling_map(0);
>
> - smp_sanity_check();
> -
> - switch (apic_intr_mode) {
> - case APIC_PIC:
> - case APIC_VIRTUAL_WIRE_NO_CONFIG:
> + switch (smp_sanity_check(max_cpus)) {
> + case SMP_NO_CONFIG:
> disable_smp();
> + if (APIC_init_uniprocessor())
> + pr_notice("Local APIC not detected. Using dummy APIC emulation.\n");
> return;
> - case APIC_SYMMETRIC_IO_NO_ROUTING:
> + case SMP_NO_APIC:
> disable_smp();
> - /* Setup local timer */
> - x86_init.timers.setup_percpu_clockev();
> return;
> - case APIC_VIRTUAL_WIRE:
> - case APIC_SYMMETRIC_IO:
> + case SMP_FORCE_UP:
> + disable_smp();
> + apic_bsp_setup(false);
> + return;
> + case SMP_OK:
> break;
> }
>
> - /* Setup local timer */
> - x86_init.timers.setup_percpu_clockev();
> + if (read_apic_id() != boot_cpu_physical_apicid) {
> + panic("Boot APIC ID in local APIC unexpected (%d vs %d)",
> + read_apic_id(), boot_cpu_physical_apicid);
> + /* Or can we switch back to PIC here? */
> + }
>
> - smp_get_logical_apicid();
> + default_setup_apic_routing();
> + cpu0_logical_apicid = apic_bsp_setup(false);
>
> pr_info("CPU0: ");
> print_cpu_info(&cpu_data(0));
> @@ -1313,6 +1348,7 @@ void __init native_smp_cpus_done(unsigned int max_cpus)
>
> nmi_selftest();
> impress_friends();
> + setup_ioapic_dest();
> mtrr_aps_init();
> }
>
> @@ -1471,14 +1507,13 @@ void cpu_disable_common(void)
> remove_cpu_from_maps(cpu);
> unlock_vector_lock();
> fixup_irqs();
> - lapic_offline();
> }
>
> int native_cpu_disable(void)
> {
> int ret;
>
> - ret = lapic_can_unplug_cpu();
> + ret = check_irq_vectors_for_cpu_disable();
> if (ret)
> return ret;
>
> diff --git a/arch/x86/kernel/time.c b/arch/x86/kernel/time.c
> index 749d189f8cd4..879af864d99a 100644
> --- a/arch/x86/kernel/time.c
> +++ b/arch/x86/kernel/time.c
> @@ -85,11 +85,6 @@ void __init hpet_time_init(void)
> static __init void x86_late_time_init(void)
> {
> x86_init.timers.timer_init();
> - /*
> - * After PIT/HPET timers init, select and setup
> - * the final interrupt mode for delivering IRQs.
> - */
> - x86_init.irqs.intr_mode_init();
> tsc_init();
> }
>
> diff --git a/arch/x86/kernel/traps.c b/arch/x86/kernel/traps.c
> index 989514c94a55..4e2eb01cb3bf 100644
> --- a/arch/x86/kernel/traps.c
> +++ b/arch/x86/kernel/traps.c
> @@ -71,7 +71,7 @@
> #include <asm/proto.h>
> #endif
>
> -DECLARE_BITMAP(system_vectors, NR_VECTORS);
> +DECLARE_BITMAP(used_vectors, NR_VECTORS);
>
> static inline void cond_local_irq_enable(struct pt_regs *regs)
> {
> diff --git a/arch/x86/kernel/vsmp_64.c b/arch/x86/kernel/vsmp_64.c
> index 44685fb2a192..b034b1b14b9c 100644
> --- a/arch/x86/kernel/vsmp_64.c
> +++ b/arch/x86/kernel/vsmp_64.c
> @@ -26,6 +26,9 @@
>
> #define TOPOLOGY_REGISTER_OFFSET 0x10
>
> +/* Flag below is initialized once during vSMP PCI initialization. */
> +static int irq_routing_comply = 1;
> +
> #if defined CONFIG_PCI && defined CONFIG_PARAVIRT
> /*
> * Interrupt control on vSMPowered systems:
> @@ -102,6 +105,9 @@ static void __init set_vsmp_pv_ops(void)
> if (cap & ctl & BIT(8)) {
> ctl &= ~BIT(8);
>
> + /* Interrupt routing set to ignore */
> + irq_routing_comply = 0;
> +
> #ifdef CONFIG_PROC_FS
> /* Don't let users change irq affinity via procfs */
> no_irq_affinity = 1;
> @@ -205,10 +211,23 @@ static int apicid_phys_pkg_id(int initial_apic_id, int index_msb)
> return hard_smp_processor_id() >> index_msb;
> }
>
> +/*
> + * In vSMP, all cpus should be capable of handling interrupts, regardless of
> + * the APIC used.
> + */
> +static void fill_vector_allocation_domain(int cpu, struct cpumask *retmask,
> + const struct cpumask *mask)
> +{
> + cpumask_setall(retmask);
> +}
> +
> static void vsmp_apic_post_init(void)
> {
> /* need to update phys_pkg_id */
> apic->phys_pkg_id = apicid_phys_pkg_id;
> +
> + if (!irq_routing_comply)
> + apic->vector_allocation_domain = fill_vector_allocation_domain;
> }
>
> void __init vsmp_init(void)
> diff --git a/arch/x86/kernel/x86_init.c b/arch/x86/kernel/x86_init.c
> index 1151ccd72ce9..c8fa4cd31903 100644
> --- a/arch/x86/kernel/x86_init.c
> +++ b/arch/x86/kernel/x86_init.c
> @@ -57,7 +57,6 @@ struct x86_init_ops x86_init __initdata = {
> .pre_vector_init = init_ISA_irqs,
> .intr_init = native_init_IRQ,
> .trap_init = x86_init_noop,
> - .intr_mode_init = apic_intr_mode_init
> },
>
> .oem = {
> diff --git a/arch/x86/xen/apic.c b/arch/x86/xen/apic.c
> index 6b830d4cb4c8..30434b8708f2 100644
> --- a/arch/x86/xen/apic.c
> +++ b/arch/x86/xen/apic.c
> @@ -31,7 +31,7 @@ static unsigned int xen_io_apic_read(unsigned apic, unsigned reg)
> return 0xfd;
> }
>
> -static u32 xen_set_apic_id(unsigned int x)
> +static unsigned long xen_set_apic_id(unsigned int x)
> {
> WARN_ON(1);
> return x;
> @@ -161,10 +161,12 @@ static struct apic xen_pv_apic = {
> /* .irq_delivery_mode - used in native_compose_msi_msg only */
> /* .irq_dest_mode - used in native_compose_msi_msg only */
>
> + .target_cpus = default_target_cpus,
> .disable_esr = 0,
> /* .dest_logical - default_send_IPI_ use it but we use our own. */
> .check_apicid_used = default_check_apicid_used, /* Used on 32-bit */
>
> + .vector_allocation_domain = flat_vector_allocation_domain,
> .init_apic_ldr = xen_noop, /* setup_local_APIC calls it */
>
> .ioapic_phys_id_map = default_ioapic_phys_id_map, /* Used on 32-bit */
> @@ -177,7 +179,7 @@ static struct apic xen_pv_apic = {
> .get_apic_id = xen_get_apic_id,
> .set_apic_id = xen_set_apic_id, /* Can be NULL on 32-bit. */
>
> - .calc_dest_apicid = apic_flat_calc_apicid,
> + .cpu_mask_to_apicid = flat_cpu_mask_to_apicid,
>
> #ifdef CONFIG_SMP
> .send_IPI_mask = xen_send_IPI_mask,
> diff --git a/arch/x86/xen/enlighten_pv.c b/arch/x86/xen/enlighten_pv.c
> index 5b2b3f3f6531..fbd054d6ac97 100644
> --- a/arch/x86/xen/enlighten_pv.c
> +++ b/arch/x86/xen/enlighten_pv.c
> @@ -1230,7 +1230,6 @@ asmlinkage __visible void __init xen_start_kernel(void)
> x86_platform.get_nmi_reason = xen_get_nmi_reason;
>
> x86_init.resources.memory_setup = xen_memory_setup;
> - x86_init.irqs.intr_mode_init = x86_init_noop;
> x86_init.oem.arch_setup = xen_arch_setup;
> x86_init.oem.banner = xen_banner;
>
> diff --git a/drivers/iommu/amd_iommu.c b/drivers/iommu/amd_iommu.c
> index 7d5eb004091d..e2a739001c8a 100644
> --- a/drivers/iommu/amd_iommu.c
> +++ b/drivers/iommu/amd_iommu.c
> @@ -4178,25 +4178,16 @@ static void irq_remapping_free(struct irq_domain *domain, unsigned int virq,
> irq_domain_free_irqs_common(domain, virq, nr_irqs);
> }
>
> -static void amd_ir_update_irte(struct irq_data *irqd, struct amd_iommu *iommu,
> - struct amd_ir_data *ir_data,
> - struct irq_2_irte *irte_info,
> - struct irq_cfg *cfg);
> -
> static int irq_remapping_activate(struct irq_domain *domain,
> struct irq_data *irq_data, bool early)
> {
> struct amd_ir_data *data = irq_data->chip_data;
> struct irq_2_irte *irte_info = &data->irq_2_irte;
> struct amd_iommu *iommu = amd_iommu_rlookup_table[irte_info->devid];
> - struct irq_cfg *cfg = irqd_cfg(irq_data);
> -
> - if (!iommu)
> - return 0;
>
> - iommu->irte_ops->activate(data->entry, irte_info->devid,
> - irte_info->index);
> - amd_ir_update_irte(irq_data, iommu, data, irte_info, cfg);
> + if (iommu)
> + iommu->irte_ops->activate(data->entry, irte_info->devid,
> + irte_info->index);
> return 0;
> }
>
> @@ -4284,22 +4275,6 @@ static int amd_ir_set_vcpu_affinity(struct irq_data *data, void *vcpu_info)
> return modify_irte_ga(irte_info->devid, irte_info->index, irte, ir_data);
> }
>
> -
> -static void amd_ir_update_irte(struct irq_data *irqd, struct amd_iommu *iommu,
> - struct amd_ir_data *ir_data,
> - struct irq_2_irte *irte_info,
> - struct irq_cfg *cfg)
> -{
> -
> - /*
> - * Atomically updates the IRTE with the new destination, vector
> - * and flushes the interrupt entry cache.
> - */
> - iommu->irte_ops->set_affinity(ir_data->entry, irte_info->devid,
> - irte_info->index, cfg->vector,
> - cfg->dest_apicid);
> -}
> -
> static int amd_ir_set_affinity(struct irq_data *data,
> const struct cpumask *mask, bool force)
> {
> @@ -4317,7 +4292,13 @@ static int amd_ir_set_affinity(struct irq_data *data,
> if (ret < 0 || ret == IRQ_SET_MASK_OK_DONE)
> return ret;
>
> - amd_ir_update_irte(data, iommu, ir_data, irte_info, cfg);
> + /*
> + * Atomically updates the IRTE with the new destination, vector
> + * and flushes the interrupt entry cache.
> + */
> + iommu->irte_ops->set_affinity(ir_data->entry, irte_info->devid,
> + irte_info->index, cfg->vector, cfg->dest_apicid);
> +
> /*
> * After this point, all the interrupts will start arriving
> * at the new destination. So, time to cleanup the previous
> diff --git a/drivers/iommu/intel_irq_remapping.c b/drivers/iommu/intel_irq_remapping.c
> index 76a193c7fcfc..324163330eaa 100644
> --- a/drivers/iommu/intel_irq_remapping.c
> +++ b/drivers/iommu/intel_irq_remapping.c
> @@ -1122,24 +1122,6 @@ struct irq_remap_ops intel_irq_remap_ops = {
> .get_irq_domain = intel_get_irq_domain,
> };
>
> -static void intel_ir_reconfigure_irte(struct irq_data *irqd, bool force)
> -{
> - struct intel_ir_data *ir_data = irqd->chip_data;
> - struct irte *irte = &ir_data->irte_entry;
> - struct irq_cfg *cfg = irqd_cfg(irqd);
> -
> - /*
> - * Atomically updates the IRTE with the new destination, vector
> - * and flushes the interrupt entry cache.
> - */
> - irte->vector = cfg->vector;
> - irte->dest_id = IRTE_DEST(cfg->dest_apicid);
> -
> - /* Update the hardware only if the interrupt is in remapped mode. */
> - if (!force || ir_data->irq_2_iommu.mode == IRQ_REMAPPING)
> - modify_irte(&ir_data->irq_2_iommu, irte);
> -}
> -
> /*
> * Migrate the IO-APIC irq in the presence of intr-remapping.
> *
> @@ -1158,15 +1140,27 @@ static int
> intel_ir_set_affinity(struct irq_data *data, const struct cpumask *mask,
> bool force)
> {
> - struct irq_data *parent = data->parent_data;
> + struct intel_ir_data *ir_data = data->chip_data;
> + struct irte *irte = &ir_data->irte_entry;
> struct irq_cfg *cfg = irqd_cfg(data);
> + struct irq_data *parent = data->parent_data;
> int ret;
>
> ret = parent->chip->irq_set_affinity(parent, mask, force);
> if (ret < 0 || ret == IRQ_SET_MASK_OK_DONE)
> return ret;
>
> - intel_ir_reconfigure_irte(data, false);
> + /*
> + * Atomically updates the IRTE with the new destination, vector
> + * and flushes the interrupt entry cache.
> + */
> + irte->vector = cfg->vector;
> + irte->dest_id = IRTE_DEST(cfg->dest_apicid);
> +
> + /* Update the hardware only if the interrupt is in remapped mode. */
> + if (ir_data->irq_2_iommu.mode == IRQ_REMAPPING)
> + modify_irte(&ir_data->irq_2_iommu, irte);
> +
> /*
> * After this point, all the interrupts will start arriving
> * at the new destination. So, time to cleanup the previous
> @@ -1399,7 +1393,9 @@ static void intel_irq_remapping_free(struct irq_domain *domain,
> static int intel_irq_remapping_activate(struct irq_domain *domain,
> struct irq_data *irq_data, bool early)
> {
> - intel_ir_reconfigure_irte(irq_data, true);
> + struct intel_ir_data *data = irq_data->chip_data;
> +
> + modify_irte(&data->irq_2_iommu, &data->irte_entry);
> return 0;
> }
>
> diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c
> index e06607167858..496ed9130600 100644
> --- a/drivers/pci/msi.c
> +++ b/drivers/pci/msi.c
> @@ -1441,8 +1441,6 @@ struct irq_domain *pci_msi_create_irq_domain(struct fwnode_handle *fwnode,
> pci_msi_domain_update_chip_ops(info);
>
> info->flags |= MSI_FLAG_ACTIVATE_EARLY;
> - if (IS_ENABLED(CONFIG_GENERIC_IRQ_RESERVATION_MODE))
> - info->flags |= MSI_FLAG_MUST_REACTIVATE;
>
> domain = msi_create_irq_domain(fwnode, info, parent);
> if (!domain)
> diff --git a/init/main.c b/init/main.c
> index dfec3809e740..642b88bd3c9b 100644
> --- a/init/main.c
> +++ b/init/main.c
> @@ -664,12 +664,12 @@ asmlinkage __visible void __init start_kernel(void)
> debug_objects_mem_init();
> setup_per_cpu_pageset();
> numa_policy_init();
> - acpi_early_init();
> if (late_time_init)
> late_time_init();
> calibrate_delay();
> pid_idr_init();
> anon_vma_init();
> + acpi_early_init();
> #ifdef CONFIG_X86
> if (efi_enabled(EFI_RUNTIME_SERVICES))
> efi_enter_virtual_mode();
> diff --git a/kernel/irq/Kconfig b/kernel/irq/Kconfig
> index 89e355866450..ac1a3e29d3b9 100644
> --- a/kernel/irq/Kconfig
> +++ b/kernel/irq/Kconfig
> @@ -100,9 +100,6 @@ config IRQ_TIMINGS
> config GENERIC_IRQ_MATRIX_ALLOCATOR
> bool
>
> -config GENERIC_IRQ_RESERVATION_MODE
> - bool
> -
> config IRQ_DOMAIN_DEBUG
> bool "Expose hardware/virtual IRQ mapping via debugfs"
> depends on IRQ_DOMAIN && DEBUG_FS
> --
> 2.15.0
>
> _______________________________________________
> Intel-gfx mailing list
> Intel-gfx@lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/intel-gfx