x86, apic: untangle the send_IPI_*() jungle

Our send_IPI_*() methods and definitions are a twisted mess: the same
symbol is defined to different things depending on .config details,
in a non-transparent way.

 - spread out the quirks into separately named per apic driver methods

 - prefix the standard PC methods with default_

 - get rid of wrapper macro obfuscation

 - clean up various details

Signed-off-by: Ingo Molnar <mingo@elte.hu>

diff --git a/arch/x86/include/asm/bigsmp/ipi.h b/arch/x86/include/asm/bigsmp/ipi.h
index 27fcd01b3ae6054ddf5c1b5c4145b4f9d913576e..a91db69cda6bdc3272bf07bd5276ed81a92bae55 100644 (file)
--- a/arch/x86/include/asm/bigsmp/ipi.h
+++ b/arch/x86/include/asm/bigsmp/ipi.h
@@ -1,22 +1,22 @@
 #ifndef __ASM_MACH_IPI_H
 #define __ASM_MACH_IPI_H
 
-void send_IPI_mask_sequence(const struct cpumask *mask, int vector);
-void send_IPI_mask_allbutself(const struct cpumask *mask, int vector);
+void default_send_IPI_mask_sequence(const struct cpumask *mask, int vector);
+void default_send_IPI_mask_allbutself(const struct cpumask *mask, int vector);
 
-static inline void send_IPI_mask(const struct cpumask *mask, int vector)
+static inline void default_send_IPI_mask(const struct cpumask *mask, int vector)
 {
-       send_IPI_mask_sequence(mask, vector);
+       default_send_IPI_mask_sequence(mask, vector);
 }
 
-static inline void send_IPI_allbutself(int vector)
+static inline void bigsmp_send_IPI_allbutself(int vector)
 {
-       send_IPI_mask_allbutself(cpu_online_mask, vector);
+       default_send_IPI_mask_allbutself(cpu_online_mask, vector);
 }
 
-static inline void send_IPI_all(int vector)
+static inline void bigsmp_send_IPI_all(int vector)
 {
-       send_IPI_mask(cpu_online_mask, vector);
+       default_send_IPI_mask(cpu_online_mask, vector);
 }
 
 #endif /* __ASM_MACH_IPI_H */

diff --git a/arch/x86/include/asm/es7000/ipi.h b/arch/x86/include/asm/es7000/ipi.h
index 7e8ed24d4b8a9895e824c0de34982e8844521827..81e77c812baa76b30e78b59d13a48bb2143993c1 100644 (file)
--- a/arch/x86/include/asm/es7000/ipi.h
+++ b/arch/x86/include/asm/es7000/ipi.h
@@ -1,22 +1,22 @@
 #ifndef __ASM_ES7000_IPI_H
 #define __ASM_ES7000_IPI_H
 
-void send_IPI_mask_sequence(const struct cpumask *mask, int vector);
-void send_IPI_mask_allbutself(const struct cpumask *mask, int vector);
+void default_send_IPI_mask_sequence(const struct cpumask *mask, int vector);
+void default_send_IPI_mask_allbutself(const struct cpumask *mask, int vector);
 
-static inline void send_IPI_mask(const struct cpumask *mask, int vector)
+static inline void es7000_send_IPI_mask(const struct cpumask *mask, int vector)
 {
-       send_IPI_mask_sequence(mask, vector);
+       default_send_IPI_mask_sequence(mask, vector);
 }
 
-static inline void send_IPI_allbutself(int vector)
+static inline void es7000_send_IPI_allbutself(int vector)
 {
-       send_IPI_mask_allbutself(cpu_online_mask, vector);
+       default_send_IPI_mask_allbutself(cpu_online_mask, vector);
 }
 
-static inline void send_IPI_all(int vector)
+static inline void es7000_send_IPI_all(int vector)
 {
-       send_IPI_mask(cpu_online_mask, vector);
+       es7000_send_IPI_mask(cpu_online_mask, vector);
 }
 
 #endif /* __ASM_ES7000_IPI_H */

diff --git a/arch/x86/include/asm/hw_irq.h b/arch/x86/include/asm/hw_irq.h
index 8de644b6b95992deb500f0e2325c77db87e105aa..bfa921fad1338aef86b2e964a03f5e1f19692761 100644 (file)
--- a/arch/x86/include/asm/hw_irq.h
+++ b/arch/x86/include/asm/hw_irq.h
@@ -73,9 +73,9 @@ extern void enable_IO_APIC(void);
 
 /* IPI functions */
 #ifdef CONFIG_X86_32
-extern void send_IPI_self(int vector);
+extern void default_send_IPI_self(int vector);
 #endif
-extern void send_IPI(int dest, int vector);
+extern void default_send_IPI(int dest, int vector);
 
 /* Statistics */
 extern atomic_t irq_err_count;

diff --git a/arch/x86/include/asm/ipi.h b/arch/x86/include/asm/ipi.h
index c745a306f7d3572be1e5baa29a6cba7eca5b03c7..a8d717f2c7e778cb12a207bf2d477b12dc00e8b9 100644 (file)
--- a/arch/x86/include/asm/ipi.h
+++ b/arch/x86/include/asm/ipi.h
@@ -55,8 +55,9 @@ static inline void __xapic_wait_icr_idle(void)
                cpu_relax();
 }
 
-static inline void __send_IPI_shortcut(unsigned int shortcut, int vector,
-                                      unsigned int dest)
+static inline void
+__default_send_IPI_shortcut(unsigned int shortcut,
+                           int vector, unsigned int dest)
 {
        /*
         * Subtle. In the case of the 'never do double writes' workaround
@@ -87,8 +88,8 @@ static inline void __send_IPI_shortcut(unsigned int shortcut, int vector,
  * This is used to send an IPI with no shorthand notation (the destination is
  * specified in bits 56 to 63 of the ICR).
  */
-static inline void __send_IPI_dest_field(unsigned int mask, int vector,
-                                        unsigned int dest)
+static inline void
+ __default_send_IPI_dest_field(unsigned int mask, int vector, unsigned int dest)
 {
        unsigned long cfg;
 
@@ -117,11 +118,11 @@ static inline void __send_IPI_dest_field(unsigned int mask, int vector,
        native_apic_mem_write(APIC_ICR, cfg);
 }
 
-static inline void send_IPI_mask_sequence(const struct cpumask *mask,
-                                         int vector)
+static inline void
+default_send_IPI_mask_sequence(const struct cpumask *mask, int vector)
 {
-       unsigned long flags;
        unsigned long query_cpu;
+       unsigned long flags;
 
        /*
         * Hack. The clustered APIC addressing mode doesn't allow us to send
@@ -130,27 +131,28 @@ static inline void send_IPI_mask_sequence(const struct cpumask *mask,
         */
        local_irq_save(flags);
        for_each_cpu(query_cpu, mask) {
-               __send_IPI_dest_field(per_cpu(x86_cpu_to_apicid, query_cpu),
-                                     vector, APIC_DEST_PHYSICAL);
+               __default_send_IPI_dest_field(per_cpu(x86_cpu_to_apicid,
+                               query_cpu), vector, APIC_DEST_PHYSICAL);
        }
        local_irq_restore(flags);
 }
 
-static inline void send_IPI_mask_allbutself(const struct cpumask *mask,
-                                           int vector)
+static inline void
+default_send_IPI_mask_allbutself(const struct cpumask *mask, int vector)
 {
-       unsigned long flags;
-       unsigned int query_cpu;
        unsigned int this_cpu = smp_processor_id();
+       unsigned int query_cpu;
+       unsigned long flags;
 
        /* See Hack comment above */
 
        local_irq_save(flags);
-       for_each_cpu(query_cpu, mask)
-               if (query_cpu != this_cpu)
-                       __send_IPI_dest_field(
-                               per_cpu(x86_cpu_to_apicid, query_cpu),
-                               vector, APIC_DEST_PHYSICAL);
+       for_each_cpu(query_cpu, mask) {
+               if (query_cpu == this_cpu)
+                       continue;
+               __default_send_IPI_dest_field(per_cpu(x86_cpu_to_apicid,
+                                query_cpu), vector, APIC_DEST_PHYSICAL);
+       }
        local_irq_restore(flags);
 }
 

diff --git a/arch/x86/include/asm/mach-default/mach_apic.h b/arch/x86/include/asm/mach-default/mach_apic.h
index 8972f843414547d087817f6b2c799c5b4e2d5a97..2e4104cf3481fb6415dffe8539eacd55b4fa993f 100644 (file)
--- a/arch/x86/include/asm/mach-default/mach_apic.h
+++ b/arch/x86/include/asm/mach-default/mach_apic.h
@@ -20,7 +20,6 @@ static inline const struct cpumask *default_target_cpus(void)
 #ifdef CONFIG_X86_64
 #include <asm/genapic.h>
 #define read_apic_id()  (apic->get_apic_id(apic_read(APIC_ID)))
-#define send_IPI_self (apic->send_IPI_self)
 #define wakeup_secondary_cpu (apic->wakeup_cpu)
 extern void default_setup_apic_routing(void);
 #else

diff --git a/arch/x86/include/asm/mach-default/mach_ipi.h b/arch/x86/include/asm/mach-default/mach_ipi.h
index 089399643dfac99f97b79f119d76e239b03b94a2..85dec630c69c3e1e0899aade50c4b41c89e7ce36 100644 (file)
--- a/arch/x86/include/asm/mach-default/mach_ipi.h
+++ b/arch/x86/include/asm/mach-default/mach_ipi.h
@@ -4,45 +4,40 @@
 /* Avoid include hell */
 #define NMI_VECTOR 0x02
 
-void send_IPI_mask_bitmask(const struct cpumask *mask, int vector);
-void send_IPI_mask_allbutself(const struct cpumask *mask, int vector);
-void __send_IPI_shortcut(unsigned int shortcut, int vector);
+void default_send_IPI_mask_bitmask(const struct cpumask *mask, int vector);
+void default_send_IPI_mask_allbutself(const struct cpumask *mask, int vector);
+void __default_send_IPI_shortcut(unsigned int shortcut, int vector);
 
 extern int no_broadcast;
 
 #ifdef CONFIG_X86_64
 #include <asm/genapic.h>
-#define send_IPI_mask (apic->send_IPI_mask)
-#define send_IPI_mask_allbutself (apic->send_IPI_mask_allbutself)
 #else
-static inline void send_IPI_mask(const struct cpumask *mask, int vector)
+static inline void default_send_IPI_mask(const struct cpumask *mask, int vector)
 {
-       send_IPI_mask_bitmask(mask, vector);
+       default_send_IPI_mask_bitmask(mask, vector);
 }
-void send_IPI_mask_allbutself(const struct cpumask *mask, int vector);
+void default_send_IPI_mask_allbutself(const struct cpumask *mask, int vector);
 #endif
 
-static inline void __local_send_IPI_allbutself(int vector)
+static inline void __default_local_send_IPI_allbutself(int vector)
 {
        if (no_broadcast || vector == NMI_VECTOR)
-               send_IPI_mask_allbutself(cpu_online_mask, vector);
+               apic->send_IPI_mask_allbutself(cpu_online_mask, vector);
        else
-               __send_IPI_shortcut(APIC_DEST_ALLBUT, vector);
+               __default_send_IPI_shortcut(APIC_DEST_ALLBUT, vector);
 }
 
-static inline void __local_send_IPI_all(int vector)
+static inline void __default_local_send_IPI_all(int vector)
 {
        if (no_broadcast || vector == NMI_VECTOR)
-               send_IPI_mask(cpu_online_mask, vector);
+               apic->send_IPI_mask(cpu_online_mask, vector);
        else
-               __send_IPI_shortcut(APIC_DEST_ALLINC, vector);
+               __default_send_IPI_shortcut(APIC_DEST_ALLINC, vector);
 }
 
-#ifdef CONFIG_X86_64
-#define send_IPI_allbutself (apic->send_IPI_allbutself)
-#define send_IPI_all (apic->send_IPI_all)
-#else
-static inline void send_IPI_allbutself(int vector)
+#ifdef CONFIG_X86_32
+static inline void default_send_IPI_allbutself(int vector)
 {
        /*
         * if there are no other CPUs in the system then we get an APIC send 
@@ -51,13 +46,12 @@ static inline void send_IPI_allbutself(int vector)
        if (!(num_online_cpus() > 1))
                return;
 
-       __local_send_IPI_allbutself(vector);
-       return;
+       __default_local_send_IPI_allbutself(vector);
 }
 
-static inline void send_IPI_all(int vector)
+static inline void default_send_IPI_all(int vector)
 {
-       __local_send_IPI_all(vector);
+       __default_local_send_IPI_all(vector);
 }
 #endif
 

diff --git a/arch/x86/include/asm/mach-generic/mach_ipi.h b/arch/x86/include/asm/mach-generic/mach_ipi.h
index 75e54bd6cbdc2158c0a07f67c9740848bc9dc7b9..5691c09645c5dd30616d547f60215422af3ce646 100644 (file)
--- a/arch/x86/include/asm/mach-generic/mach_ipi.h
+++ b/arch/x86/include/asm/mach-generic/mach_ipi.h
@@ -3,8 +3,4 @@
 
 #include <asm/genapic.h>
 
-#define send_IPI_mask (apic->send_IPI_mask)
-#define send_IPI_allbutself (apic->send_IPI_allbutself)
-#define send_IPI_all (apic->send_IPI_all)
-
 #endif /* _ASM_X86_MACH_GENERIC_MACH_IPI_H */

diff --git a/arch/x86/include/asm/numaq/ipi.h b/arch/x86/include/asm/numaq/ipi.h
index a8374c652778f5c23424b7e82a3f2aee93c1632d..5dbc4b4cd5e5dd0909ec3eadc477a4f763a12e47 100644 (file)
--- a/arch/x86/include/asm/numaq/ipi.h
+++ b/arch/x86/include/asm/numaq/ipi.h
@@ -1,22 +1,22 @@
 #ifndef __ASM_NUMAQ_IPI_H
 #define __ASM_NUMAQ_IPI_H
 
-void send_IPI_mask_sequence(const struct cpumask *mask, int vector);
-void send_IPI_mask_allbutself(const struct cpumask *mask, int vector);
+void default_send_IPI_mask_sequence(const struct cpumask *mask, int vector);
+void default_send_IPI_mask_allbutself(const struct cpumask *mask, int vector);
 
-static inline void send_IPI_mask(const struct cpumask *mask, int vector)
+static inline void numaq_send_IPI_mask(const struct cpumask *mask, int vector)
 {
-       send_IPI_mask_sequence(mask, vector);
+       default_send_IPI_mask_sequence(mask, vector);
 }
 
-static inline void send_IPI_allbutself(int vector)
+static inline void numaq_send_IPI_allbutself(int vector)
 {
-       send_IPI_mask_allbutself(cpu_online_mask, vector);
+       default_send_IPI_mask_allbutself(cpu_online_mask, vector);
 }
 
-static inline void send_IPI_all(int vector)
+static inline void numaq_send_IPI_all(int vector)
 {
-       send_IPI_mask(cpu_online_mask, vector);
+       numaq_send_IPI_mask(cpu_online_mask, vector);
 }
 
 #endif /* __ASM_NUMAQ_IPI_H */

diff --git a/arch/x86/include/asm/summit/ipi.h b/arch/x86/include/asm/summit/ipi.h
index a8a2c24f50ccfd34d8dca98cb399dcafc51a1c29..f87a43fe0aed0aa6a99a592e3c84c0f902a96578 100644 (file)
--- a/arch/x86/include/asm/summit/ipi.h
+++ b/arch/x86/include/asm/summit/ipi.h
@@ -1,26 +1,26 @@
 #ifndef __ASM_SUMMIT_IPI_H
 #define __ASM_SUMMIT_IPI_H
 
-void send_IPI_mask_sequence(const cpumask_t *mask, int vector);
-void send_IPI_mask_allbutself(const cpumask_t *mask, int vector);
+void default_send_IPI_mask_sequence(const cpumask_t *mask, int vector);
+void default_send_IPI_mask_allbutself(const cpumask_t *mask, int vector);
 
-static inline void send_IPI_mask(const cpumask_t *mask, int vector)
+static inline void summit_send_IPI_mask(const cpumask_t *mask, int vector)
 {
-       send_IPI_mask_sequence(mask, vector);
+       default_send_IPI_mask_sequence(mask, vector);
 }
 
-static inline void send_IPI_allbutself(int vector)
+static inline void summit_send_IPI_allbutself(int vector)
 {
        cpumask_t mask = cpu_online_map;
        cpu_clear(smp_processor_id(), mask);
 
        if (!cpus_empty(mask))
-               send_IPI_mask(&mask, vector);
+               summit_send_IPI_mask(&mask, vector);
 }
 
-static inline void send_IPI_all(int vector)
+static inline void summit_send_IPI_all(int vector)
 {
-       send_IPI_mask(&cpu_online_map, vector);
+       summit_send_IPI_mask(&cpu_online_map, vector);
 }
 
 #endif /* __ASM_SUMMIT_IPI_H */

diff --git a/arch/x86/kernel/apic.c b/arch/x86/kernel/apic.c
index 5f7f3a9a47ad11a2ad99f602ebc2aefbfc439c77..84b8e7c57abc6487ab210a763dd1f2e743ab4d2e 100644 (file)
--- a/arch/x86/kernel/apic.c
+++ b/arch/x86/kernel/apic.c
@@ -475,7 +475,7 @@ static void lapic_timer_setup(enum clock_event_mode mode,
 static void lapic_timer_broadcast(const struct cpumask *mask)
 {
 #ifdef CONFIG_SMP
-       send_IPI_mask(mask, LOCAL_TIMER_VECTOR);
+       apic->send_IPI_mask(mask, LOCAL_TIMER_VECTOR);
 #endif
 }
 

diff --git a/arch/x86/kernel/genapic_64.c b/arch/x86/kernel/genapic_64.c
index d57d2138f078c8c45ed7ade6ba786b48b4870970..820dea5d0ebeaef6afc0adf794af4c363f7a8570 100644 (file)
--- a/arch/x86/kernel/genapic_64.c
+++ b/arch/x86/kernel/genapic_64.c
@@ -65,7 +65,7 @@ void __init default_setup_apic_routing(void)
 
 void apic_send_IPI_self(int vector)
 {
-       __send_IPI_shortcut(APIC_DEST_SELF, vector, APIC_DEST_PHYSICAL);
+       __default_send_IPI_shortcut(APIC_DEST_SELF, vector, APIC_DEST_PHYSICAL);
 }
 
 int __init default_acpi_madt_oem_check(char *oem_id, char *oem_table_id)

diff --git a/arch/x86/kernel/genapic_flat_64.c b/arch/x86/kernel/genapic_flat_64.c
index b941b112cafb2982ff97c56a58db684ee9cd6803..7c648ccea514ea1786e582c508534992511c6b78 100644 (file)
--- a/arch/x86/kernel/genapic_flat_64.c
+++ b/arch/x86/kernel/genapic_flat_64.c
@@ -74,7 +74,7 @@ static inline void _flat_send_IPI_mask(unsigned long mask, int vector)
        unsigned long flags;
 
        local_irq_save(flags);
-       __send_IPI_dest_field(mask, vector, apic->dest_logical);
+       __default_send_IPI_dest_field(mask, vector, apic->dest_logical);
        local_irq_restore(flags);
 }
 
@@ -85,14 +85,15 @@ static void flat_send_IPI_mask(const struct cpumask *cpumask, int vector)
        _flat_send_IPI_mask(mask, vector);
 }
 
-static void flat_send_IPI_mask_allbutself(const struct cpumask *cpumask,
-                                         int vector)
+static void
+ flat_send_IPI_mask_allbutself(const struct cpumask *cpumask, int vector)
 {
        unsigned long mask = cpumask_bits(cpumask)[0];
        int cpu = smp_processor_id();
 
        if (cpu < BITS_PER_LONG)
                clear_bit(cpu, &mask);
+
        _flat_send_IPI_mask(mask, vector);
 }
 
@@ -114,16 +115,19 @@ static void flat_send_IPI_allbutself(int vector)
                        _flat_send_IPI_mask(mask, vector);
                }
        } else if (num_online_cpus() > 1) {
-               __send_IPI_shortcut(APIC_DEST_ALLBUT, vector, apic->dest_logical);
+               __default_send_IPI_shortcut(APIC_DEST_ALLBUT,
+                                           vector, apic->dest_logical);
        }
 }
 
 static void flat_send_IPI_all(int vector)
 {
-       if (vector == NMI_VECTOR)
+       if (vector == NMI_VECTOR) {
                flat_send_IPI_mask(cpu_online_mask, vector);
-       else
-               __send_IPI_shortcut(APIC_DEST_ALLINC, vector, apic->dest_logical);
+       } else {
+               __default_send_IPI_shortcut(APIC_DEST_ALLINC,
+                                           vector, apic->dest_logical);
+       }
 }
 
 static unsigned int flat_get_apic_id(unsigned long x)
@@ -265,18 +269,18 @@ static void physflat_vector_allocation_domain(int cpu, struct cpumask *retmask)
 
 static void physflat_send_IPI_mask(const struct cpumask *cpumask, int vector)
 {
-       send_IPI_mask_sequence(cpumask, vector);
+       default_send_IPI_mask_sequence(cpumask, vector);
 }
 
 static void physflat_send_IPI_mask_allbutself(const struct cpumask *cpumask,
                                              int vector)
 {
-       send_IPI_mask_allbutself(cpumask, vector);
+       default_send_IPI_mask_allbutself(cpumask, vector);
 }
 
 static void physflat_send_IPI_allbutself(int vector)
 {
-       send_IPI_mask_allbutself(cpu_online_mask, vector);
+       default_send_IPI_mask_allbutself(cpu_online_mask, vector);
 }
 
 static void physflat_send_IPI_all(int vector)

diff --git a/arch/x86/kernel/genx2apic_cluster.c b/arch/x86/kernel/genx2apic_cluster.c
index 62f9fccf01ddf96916b8998373d54f4f3efe0e6e..2d97726a973e3bc36367bf332125458b65062ecb 100644 (file)
--- a/arch/x86/kernel/genx2apic_cluster.c
+++ b/arch/x86/kernel/genx2apic_cluster.c
@@ -36,8 +36,8 @@ static void x2apic_vector_allocation_domain(int cpu, struct cpumask *retmask)
        cpumask_set_cpu(cpu, retmask);
 }
 
-static void __x2apic_send_IPI_dest(unsigned int apicid, int vector,
-                                  unsigned int dest)
+static void
+ __x2apic_send_IPI_dest(unsigned int apicid, int vector, unsigned int dest)
 {
        unsigned long cfg;
 
@@ -57,45 +57,50 @@ static void __x2apic_send_IPI_dest(unsigned int apicid, int vector,
  */
 static void x2apic_send_IPI_mask(const struct cpumask *mask, int vector)
 {
-       unsigned long flags;
        unsigned long query_cpu;
+       unsigned long flags;
 
        local_irq_save(flags);
-       for_each_cpu(query_cpu, mask)
+       for_each_cpu(query_cpu, mask) {
                __x2apic_send_IPI_dest(
                        per_cpu(x86_cpu_to_logical_apicid, query_cpu),
                        vector, apic->dest_logical);
+       }
        local_irq_restore(flags);
 }
 
-static void x2apic_send_IPI_mask_allbutself(const struct cpumask *mask,
-                                           int vector)
+static void
+ x2apic_send_IPI_mask_allbutself(const struct cpumask *mask, int vector)
 {
-       unsigned long flags;
-       unsigned long query_cpu;
        unsigned long this_cpu = smp_processor_id();
+       unsigned long query_cpu;
+       unsigned long flags;
 
        local_irq_save(flags);
-       for_each_cpu(query_cpu, mask)
-               if (query_cpu != this_cpu)
-                       __x2apic_send_IPI_dest(
+       for_each_cpu(query_cpu, mask) {
+               if (query_cpu == this_cpu)
+                       continue;
+               __x2apic_send_IPI_dest(
                                per_cpu(x86_cpu_to_logical_apicid, query_cpu),
                                vector, apic->dest_logical);
+       }
        local_irq_restore(flags);
 }
 
 static void x2apic_send_IPI_allbutself(int vector)
 {
-       unsigned long flags;
-       unsigned long query_cpu;
        unsigned long this_cpu = smp_processor_id();
+       unsigned long query_cpu;
+       unsigned long flags;
 
        local_irq_save(flags);
-       for_each_online_cpu(query_cpu)
-               if (query_cpu != this_cpu)
-                       __x2apic_send_IPI_dest(
+       for_each_online_cpu(query_cpu) {
+               if (query_cpu == this_cpu)
+                       continue;
+               __x2apic_send_IPI_dest(
                                per_cpu(x86_cpu_to_logical_apicid, query_cpu),
                                vector, apic->dest_logical);
+       }
        local_irq_restore(flags);
 }
 
@@ -175,7 +180,6 @@ static void init_x2apic_ldr(void)
        int cpu = smp_processor_id();
 
        per_cpu(x86_cpu_to_logical_apicid, cpu) = apic_read(APIC_LDR);
-       return;
 }
 
 struct genapic apic_x2apic_cluster = {

diff --git a/arch/x86/kernel/genx2apic_phys.c b/arch/x86/kernel/genx2apic_phys.c
index 3da1675b260463a0964bf9b329b51075824902cf..74777c27669321b09f7637c14d4ff1f4d7a3c497 100644 (file)
--- a/arch/x86/kernel/genx2apic_phys.c
+++ b/arch/x86/kernel/genx2apic_phys.c
@@ -55,8 +55,8 @@ static void __x2apic_send_IPI_dest(unsigned int apicid, int vector,
 
 static void x2apic_send_IPI_mask(const struct cpumask *mask, int vector)
 {
-       unsigned long flags;
        unsigned long query_cpu;
+       unsigned long flags;
 
        local_irq_save(flags);
        for_each_cpu(query_cpu, mask) {
@@ -66,12 +66,12 @@ static void x2apic_send_IPI_mask(const struct cpumask *mask, int vector)
        local_irq_restore(flags);
 }
 
-static void x2apic_send_IPI_mask_allbutself(const struct cpumask *mask,
-                                           int vector)
+static void
+ x2apic_send_IPI_mask_allbutself(const struct cpumask *mask, int vector)
 {
-       unsigned long flags;
-       unsigned long query_cpu;
        unsigned long this_cpu = smp_processor_id();
+       unsigned long query_cpu;
+       unsigned long flags;
 
        local_irq_save(flags);
        for_each_cpu(query_cpu, mask) {
@@ -85,16 +85,17 @@ static void x2apic_send_IPI_mask_allbutself(const struct cpumask *mask,
 
 static void x2apic_send_IPI_allbutself(int vector)
 {
-       unsigned long flags;
-       unsigned long query_cpu;
        unsigned long this_cpu = smp_processor_id();
+       unsigned long query_cpu;
+       unsigned long flags;
 
        local_irq_save(flags);
-       for_each_online_cpu(query_cpu)
-               if (query_cpu != this_cpu)
-                       __x2apic_send_IPI_dest(
-                               per_cpu(x86_cpu_to_apicid, query_cpu),
-                               vector, APIC_DEST_PHYSICAL);
+       for_each_online_cpu(query_cpu) {
+               if (query_cpu == this_cpu)
+                       continue;
+               __x2apic_send_IPI_dest(per_cpu(x86_cpu_to_apicid, query_cpu),
+                                      vector, APIC_DEST_PHYSICAL);
+       }
        local_irq_restore(flags);
 }
 
@@ -145,18 +146,12 @@ x2apic_cpu_mask_to_apicid_and(const struct cpumask *cpumask,
 
 static unsigned int x2apic_phys_get_apic_id(unsigned long x)
 {
-       unsigned int id;
-
-       id = x;
-       return id;
+       return x;
 }
 
 static unsigned long set_apic_id(unsigned int id)
 {
-       unsigned long x;
-
-       x = id;
-       return x;
+       return id;
 }
 
 static int x2apic_phys_pkg_id(int initial_apicid, int index_msb)
@@ -171,7 +166,6 @@ static void x2apic_send_IPI_self(int vector)
 
 static void init_x2apic_ldr(void)
 {
-       return;
 }
 
 struct genapic apic_x2apic_phys = {

diff --git a/arch/x86/kernel/genx2apic_uv_x.c b/arch/x86/kernel/genx2apic_uv_x.c
index f957878c21e94272058dd2fe043176031dbfd1d7..24b9f42db9b714ed6a8a99d0c0c4fe25156db043 100644 (file)
--- a/arch/x86/kernel/genx2apic_uv_x.c
+++ b/arch/x86/kernel/genx2apic_uv_x.c
@@ -118,12 +118,13 @@ static void uv_send_IPI_one(int cpu, int vector)
        int pnode;
 
        apicid = per_cpu(x86_cpu_to_apicid, cpu);
-       lapicid = apicid & 0x3f;                /* ZZZ macro needed */
+       lapicid = apicid & 0x3f; /* ZZZ macro needed */
        pnode = uv_apicid_to_pnode(apicid);
-       val =
-           (1UL << UVH_IPI_INT_SEND_SHFT) | (lapicid <<
-                                             UVH_IPI_INT_APIC_ID_SHFT) |
-           (vector << UVH_IPI_INT_VECTOR_SHFT);
+
+       val = (     1UL << UVH_IPI_INT_SEND_SHFT    ) |
+             ( lapicid << UVH_IPI_INT_APIC_ID_SHFT ) |
+             (  vector << UVH_IPI_INT_VECTOR_SHFT  );
+
        uv_write_global_mmr64(pnode, UVH_IPI_INT, val);
 }
 
@@ -137,22 +138,24 @@ static void uv_send_IPI_mask(const struct cpumask *mask, int vector)
 
 static void uv_send_IPI_mask_allbutself(const struct cpumask *mask, int vector)
 {
-       unsigned int cpu;
        unsigned int this_cpu = smp_processor_id();
+       unsigned int cpu;
 
-       for_each_cpu(cpu, mask)
+       for_each_cpu(cpu, mask) {
                if (cpu != this_cpu)
                        uv_send_IPI_one(cpu, vector);
+       }
 }
 
 static void uv_send_IPI_allbutself(int vector)
 {
-       unsigned int cpu;
        unsigned int this_cpu = smp_processor_id();
+       unsigned int cpu;
 
-       for_each_online_cpu(cpu)
+       for_each_online_cpu(cpu) {
                if (cpu != this_cpu)
                        uv_send_IPI_one(cpu, vector);
+       }
 }
 
 static void uv_send_IPI_all(int vector)

diff --git a/arch/x86/kernel/io_apic.c b/arch/x86/kernel/io_apic.c
index 01a2505d72751e3eb3134dba2e42f1f678f8b408..e90970ce21a062a02d5a957f70f2c741e90910f6 100644 (file)
--- a/arch/x86/kernel/io_apic.c
+++ b/arch/x86/kernel/io_apic.c
@@ -514,11 +514,11 @@ static void send_cleanup_vector(struct irq_cfg *cfg)
                for_each_cpu_and(i, cfg->old_domain, cpu_online_mask)
                        cfg->move_cleanup_count++;
                for_each_cpu_and(i, cfg->old_domain, cpu_online_mask)
-                       send_IPI_mask(cpumask_of(i), IRQ_MOVE_CLEANUP_VECTOR);
+                       apic->send_IPI_mask(cpumask_of(i), IRQ_MOVE_CLEANUP_VECTOR);
        } else {
                cpumask_and(cleanup_mask, cfg->old_domain, cpu_online_mask);
                cfg->move_cleanup_count = cpumask_weight(cleanup_mask);
-               send_IPI_mask(cleanup_mask, IRQ_MOVE_CLEANUP_VECTOR);
+               apic->send_IPI_mask(cleanup_mask, IRQ_MOVE_CLEANUP_VECTOR);
                free_cpumask_var(cleanup_mask);
        }
        cfg->move_in_progress = 0;
@@ -800,7 +800,7 @@ static void clear_IO_APIC (void)
 }
 
 #if !defined(CONFIG_SMP) && defined(CONFIG_X86_32)
-void send_IPI_self(int vector)
+void default_send_IPI_self(int vector)
 {
        unsigned int cfg;
 
@@ -2297,7 +2297,7 @@ static int ioapic_retrigger_irq(unsigned int irq)
        unsigned long flags;
 
        spin_lock_irqsave(&vector_lock, flags);
-       send_IPI_mask(cpumask_of(cpumask_first(cfg->domain)), cfg->vector);
+       apic->send_IPI_mask(cpumask_of(cpumask_first(cfg->domain)), cfg->vector);
        spin_unlock_irqrestore(&vector_lock, flags);
 
        return 1;
@@ -2305,7 +2305,7 @@ static int ioapic_retrigger_irq(unsigned int irq)
 #else
 static int ioapic_retrigger_irq(unsigned int irq)
 {
-       send_IPI_self(irq_cfg(irq)->vector);
+       apic->send_IPI_self(irq_cfg(irq)->vector);
 
        return 1;
 }

diff --git a/arch/x86/kernel/ipi.c b/arch/x86/kernel/ipi.c
index 367c5e684fa1209461f0721ed9943f9a6959176d..e16c41b2e4ecd25280d15b7f938705373b1747fb 100644 (file)
--- a/arch/x86/kernel/ipi.c
+++ b/arch/x86/kernel/ipi.c
@@ -48,7 +48,7 @@ static inline int __prepare_ICR2(unsigned int mask)
        return SET_APIC_DEST_FIELD(mask);
 }
 
-void __send_IPI_shortcut(unsigned int shortcut, int vector)
+void __default_send_IPI_shortcut(unsigned int shortcut, int vector)
 {
        /*
         * Subtle. In the case of the 'never do double writes' workaround
@@ -75,16 +75,16 @@ void __send_IPI_shortcut(unsigned int shortcut, int vector)
        apic_write(APIC_ICR, cfg);
 }
 
-void send_IPI_self(int vector)
+void default_send_IPI_self(int vector)
 {
-       __send_IPI_shortcut(APIC_DEST_SELF, vector);
+       __default_send_IPI_shortcut(APIC_DEST_SELF, vector);
 }
 
 /*
  * This is used to send an IPI with no shorthand notation (the destination is
  * specified in bits 56 to 63 of the ICR).
  */
-static inline void __send_IPI_dest_field(unsigned long mask, int vector)
+static inline void __default_send_IPI_dest_field(unsigned long mask, int vector)
 {
        unsigned long cfg;
 
@@ -116,18 +116,18 @@ static inline void __send_IPI_dest_field(unsigned long mask, int vector)
 /*
  * This is only used on smaller machines.
  */
-void send_IPI_mask_bitmask(const struct cpumask *cpumask, int vector)
+void default_send_IPI_mask_bitmask(const struct cpumask *cpumask, int vector)
 {
        unsigned long mask = cpumask_bits(cpumask)[0];
        unsigned long flags;
 
        local_irq_save(flags);
        WARN_ON(mask & ~cpumask_bits(cpu_online_mask)[0]);
-       __send_IPI_dest_field(mask, vector);
+       __default_send_IPI_dest_field(mask, vector);
        local_irq_restore(flags);
 }
 
-void send_IPI_mask_sequence(const struct cpumask *mask, int vector)
+void default_send_IPI_mask_sequence(const struct cpumask *mask, int vector)
 {
        unsigned long flags;
        unsigned int query_cpu;
@@ -140,11 +140,11 @@ void send_IPI_mask_sequence(const struct cpumask *mask, int vector)
 
        local_irq_save(flags);
        for_each_cpu(query_cpu, mask)
-               __send_IPI_dest_field(apic->cpu_to_logical_apicid(query_cpu), vector);
+               __default_send_IPI_dest_field(apic->cpu_to_logical_apicid(query_cpu), vector);
        local_irq_restore(flags);
 }
 
-void send_IPI_mask_allbutself(const struct cpumask *mask, int vector)
+void default_send_IPI_mask_allbutself(const struct cpumask *mask, int vector)
 {
        unsigned long flags;
        unsigned int query_cpu;
@@ -153,10 +153,12 @@ void send_IPI_mask_allbutself(const struct cpumask *mask, int vector)
        /* See Hack comment above */
 
        local_irq_save(flags);
-       for_each_cpu(query_cpu, mask)
-               if (query_cpu != this_cpu)
-                       __send_IPI_dest_field(apic->cpu_to_logical_apicid(query_cpu),
-                                             vector);
+       for_each_cpu(query_cpu, mask) {
+               if (query_cpu == this_cpu)
+                       continue;
+               __default_send_IPI_dest_field(
+                       apic->cpu_to_logical_apicid(query_cpu), vector);
+       }
        local_irq_restore(flags);
 }
 

diff --git a/arch/x86/kernel/kgdb.c b/arch/x86/kernel/kgdb.c
index 10435a120d2227bffd79a3df193f4238049ce2b0..b62a3811e01c8df5fc77e3ca5de9c92de8f87d5c 100644 (file)
--- a/arch/x86/kernel/kgdb.c
+++ b/arch/x86/kernel/kgdb.c
@@ -347,7 +347,7 @@ void kgdb_post_primary_code(struct pt_regs *regs, int e_vector, int err_code)
  */
 void kgdb_roundup_cpus(unsigned long flags)
 {
-       send_IPI_allbutself(APIC_DM_NMI);
+       apic->send_IPI_allbutself(APIC_DM_NMI);
 }
 #endif
 

diff --git a/arch/x86/kernel/reboot.c b/arch/x86/kernel/reboot.c
index f8536fee5c12bb5dd3b1a5b3b9e8382c91622229..38dace28d62536d3db4a55763de0237748aac334 100644 (file)
--- a/arch/x86/kernel/reboot.c
+++ b/arch/x86/kernel/reboot.c
@@ -651,7 +651,7 @@ static int crash_nmi_callback(struct notifier_block *self,
 
 static void smp_send_nmi_allbutself(void)
 {
-       send_IPI_allbutself(NMI_VECTOR);
+       apic->send_IPI_allbutself(NMI_VECTOR);
 }
 
 static struct notifier_block crash_nmi_nb = {

diff --git a/arch/x86/kernel/smp.c b/arch/x86/kernel/smp.c
index e6faa3316bd2e04311313ce4c7c68ef3438ef274..c48ba6cc32aa6fb23a7e7daabde5e1f373f42bfb 100644 (file)
--- a/arch/x86/kernel/smp.c
+++ b/arch/x86/kernel/smp.c
@@ -118,12 +118,12 @@ static void native_smp_send_reschedule(int cpu)
                WARN_ON(1);
                return;
        }
-       send_IPI_mask(cpumask_of(cpu), RESCHEDULE_VECTOR);
+       apic->send_IPI_mask(cpumask_of(cpu), RESCHEDULE_VECTOR);
 }
 
 void native_send_call_func_single_ipi(int cpu)
 {
-       send_IPI_mask(cpumask_of(cpu), CALL_FUNCTION_SINGLE_VECTOR);
+       apic->send_IPI_mask(cpumask_of(cpu), CALL_FUNCTION_SINGLE_VECTOR);
 }
 
 void native_send_call_func_ipi(const struct cpumask *mask)
@@ -131,7 +131,7 @@ void native_send_call_func_ipi(const struct cpumask *mask)
        cpumask_var_t allbutself;
 
        if (!alloc_cpumask_var(&allbutself, GFP_ATOMIC)) {
-               send_IPI_mask(mask, CALL_FUNCTION_VECTOR);
+               apic->send_IPI_mask(mask, CALL_FUNCTION_VECTOR);
                return;
        }
 
@@ -140,9 +140,9 @@ void native_send_call_func_ipi(const struct cpumask *mask)
 
        if (cpumask_equal(mask, allbutself) &&
            cpumask_equal(cpu_online_mask, cpu_callout_mask))
-               send_IPI_allbutself(CALL_FUNCTION_VECTOR);
+               apic->send_IPI_allbutself(CALL_FUNCTION_VECTOR);
        else
-               send_IPI_mask(mask, CALL_FUNCTION_VECTOR);
+               apic->send_IPI_mask(mask, CALL_FUNCTION_VECTOR);
 
        free_cpumask_var(allbutself);
 }

diff --git a/arch/x86/mach-generic/bigsmp.c b/arch/x86/mach-generic/bigsmp.c
index 22c2c7b8e4ab3e7ccb496c28c5e77c68ab282a5f..4782b55478818ca2cf4e1c82cc7806d55c36d7af 100644 (file)
--- a/arch/x86/mach-generic/bigsmp.c
+++ b/arch/x86/mach-generic/bigsmp.c
@@ -97,10 +97,10 @@ struct genapic apic_bigsmp = {
        .cpu_mask_to_apicid             = bigsmp_cpu_mask_to_apicid,
        .cpu_mask_to_apicid_and         = bigsmp_cpu_mask_to_apicid_and,
 
-       .send_IPI_mask                  = send_IPI_mask,
+       .send_IPI_mask                  = default_send_IPI_mask,
        .send_IPI_mask_allbutself       = NULL,
-       .send_IPI_allbutself            = send_IPI_allbutself,
-       .send_IPI_all                   = send_IPI_all,
+       .send_IPI_allbutself            = bigsmp_send_IPI_allbutself,
+       .send_IPI_all                   = bigsmp_send_IPI_all,
        .send_IPI_self                  = NULL,
 
        .wakeup_cpu                     = NULL,

diff --git a/arch/x86/mach-generic/default.c b/arch/x86/mach-generic/default.c
index 477ebec1674981745e9da55ae71f1f6bae5b15de..bf4670db25fe43d698e99a6cbca3837d0505d6d6 100644 (file)
--- a/arch/x86/mach-generic/default.c
+++ b/arch/x86/mach-generic/default.c
@@ -78,10 +78,10 @@ struct genapic apic_default = {
        .cpu_mask_to_apicid             = default_cpu_mask_to_apicid,
        .cpu_mask_to_apicid_and         = default_cpu_mask_to_apicid_and,
 
-       .send_IPI_mask                  = send_IPI_mask,
+       .send_IPI_mask                  = default_send_IPI_mask,
        .send_IPI_mask_allbutself       = NULL,
-       .send_IPI_allbutself            = send_IPI_allbutself,
-       .send_IPI_all                   = send_IPI_all,
+       .send_IPI_allbutself            = default_send_IPI_allbutself,
+       .send_IPI_all                   = default_send_IPI_all,
        .send_IPI_self                  = NULL,
 
        .wakeup_cpu                     = NULL,

diff --git a/arch/x86/mach-generic/es7000.c b/arch/x86/mach-generic/es7000.c
index d758cf65d7366d87426d9b1c7a9193b07dd9c3c0..d36642e6d908c44b15093ee6871aeeb7927be090 100644 (file)
--- a/arch/x86/mach-generic/es7000.c
+++ b/arch/x86/mach-generic/es7000.c
@@ -133,10 +133,10 @@ struct genapic apic_es7000 = {
        .cpu_mask_to_apicid             = es7000_cpu_mask_to_apicid,
        .cpu_mask_to_apicid_and         = es7000_cpu_mask_to_apicid_and,
 
-       .send_IPI_mask                  = send_IPI_mask,
+       .send_IPI_mask                  = es7000_send_IPI_mask,
        .send_IPI_mask_allbutself       = NULL,
-       .send_IPI_allbutself            = send_IPI_allbutself,
-       .send_IPI_all                   = send_IPI_all,
+       .send_IPI_allbutself            = es7000_send_IPI_allbutself,
+       .send_IPI_all                   = es7000_send_IPI_all,
        .send_IPI_self                  = NULL,
 
        .wakeup_cpu                     = NULL,

diff --git a/arch/x86/mach-generic/numaq.c b/arch/x86/mach-generic/numaq.c
index eb7d56a521d4e17ca6d3a3f3243f653160e0164a..135b1832ad80372b00f1909bc4937d20ef95b264 100644 (file)
--- a/arch/x86/mach-generic/numaq.c
+++ b/arch/x86/mach-generic/numaq.c
@@ -97,10 +97,10 @@ struct genapic apic_numaq = {
        .cpu_mask_to_apicid             = numaq_cpu_mask_to_apicid,
        .cpu_mask_to_apicid_and         = numaq_cpu_mask_to_apicid_and,
 
-       .send_IPI_mask                  = send_IPI_mask,
+       .send_IPI_mask                  = numaq_send_IPI_mask,
        .send_IPI_mask_allbutself       = NULL,
-       .send_IPI_allbutself            = send_IPI_allbutself,
-       .send_IPI_all                   = send_IPI_all,
+       .send_IPI_allbutself            = numaq_send_IPI_allbutself,
+       .send_IPI_all                   = numaq_send_IPI_all,
        .send_IPI_self                  = NULL,
 
        .wakeup_cpu                     = NULL,

diff --git a/arch/x86/mach-generic/summit.c b/arch/x86/mach-generic/summit.c
index 8c293055bdf0c739cc2ef49282a8286c9483c3b4..77196a4a9d2b9e03702eefd645abcbfaf4a40eea 100644 (file)
--- a/arch/x86/mach-generic/summit.c
+++ b/arch/x86/mach-generic/summit.c
@@ -77,10 +77,10 @@ struct genapic apic_summit = {
        .cpu_mask_to_apicid             = summit_cpu_mask_to_apicid,
        .cpu_mask_to_apicid_and         = summit_cpu_mask_to_apicid_and,
 
-       .send_IPI_mask                  = send_IPI_mask,
+       .send_IPI_mask                  = summit_send_IPI_mask,
        .send_IPI_mask_allbutself       = NULL,
-       .send_IPI_allbutself            = send_IPI_allbutself,
-       .send_IPI_all                   = send_IPI_all,
+       .send_IPI_allbutself            = summit_send_IPI_allbutself,
+       .send_IPI_all                   = summit_send_IPI_all,
        .send_IPI_self                  = NULL,
 
        .wakeup_cpu                     = NULL,

diff --git a/arch/x86/mm/tlb.c b/arch/x86/mm/tlb.c
index 72a6d4ebe34dd9b2a4441dc422dbcd46ed47bb2f..6348e1146925bb54dfc13e5e2fbd908ab2a630a1 100644 (file)
--- a/arch/x86/mm/tlb.c
+++ b/arch/x86/mm/tlb.c
@@ -196,7 +196,7 @@ static void flush_tlb_others_ipi(const struct cpumask *cpumask,
         * We have to send the IPI only to
         * CPUs affected.
         */
-       send_IPI_mask(to_cpumask(f->flush_cpumask),
+       apic->send_IPI_mask(to_cpumask(f->flush_cpumask),
                      INVALIDATE_TLB_VECTOR_START + sender);
 
        while (!cpumask_empty(to_cpumask(f->flush_cpumask)))