vserver 1.9.5.x5

[linux-2.6.git] / arch / x86_64 / kernel / smp.c

diff --git a/arch/x86_64/kernel/smp.c b/arch/x86_64/kernel/smp.c
index 269ef09..b183faf 100644 (file)
--- a/arch/x86_64/kernel/smp.c
+++ b/arch/x86_64/kernel/smp.c
@@ -24,105 +24,8 @@
 #include <asm/mtrr.h>
 #include <asm/pgalloc.h>
 #include <asm/tlbflush.h>
-
-/*
- * the following functions deal with sending IPIs between CPUs.
- *
- * We use 'broadcast', CPU->CPU IPIs and self-IPIs too.
- */
-
-static inline unsigned int __prepare_ICR (unsigned int shortcut, int vector)
-{
-       unsigned int icr =  APIC_DM_FIXED | shortcut | vector | APIC_DEST_LOGICAL;
-       if (vector == KDB_VECTOR) 
-               icr = (icr & (~APIC_VECTOR_MASK)) | APIC_DM_NMI;                
-       return icr;
-}
-
-static inline int __prepare_ICR2 (unsigned int mask)
-{
-       return SET_APIC_DEST_FIELD(mask);
-}
-
-static inline void __send_IPI_shortcut(unsigned int shortcut, int vector)
-{
-       /*
-        * Subtle. In the case of the 'never do double writes' workaround
-        * we have to lock out interrupts to be safe.  As we don't care
-        * of the value read we use an atomic rmw access to avoid costly
-        * cli/sti.  Otherwise we use an even cheaper single atomic write
-        * to the APIC.
-        */
-       unsigned int cfg;
-
-       /*
-        * Wait for idle.
-        */
-       apic_wait_icr_idle();
-
-       /*
-        * No need to touch the target chip field
-        */
-       cfg = __prepare_ICR(shortcut, vector);
-
-       /*
-        * Send the IPI. The write to APIC_ICR fires this off.
-        */
-       apic_write_around(APIC_ICR, cfg);
-}
-
-static inline void send_IPI_allbutself(int vector)
-{
-       /*
-        * if there are no other CPUs in the system then
-        * we get an APIC send error if we try to broadcast.
-        * thus we have to avoid sending IPIs in this case.
-        */
-       if (num_online_cpus() > 1)
-               __send_IPI_shortcut(APIC_DEST_ALLBUT, vector);
-}
-
-static inline void send_IPI_all(int vector)
-{
-       __send_IPI_shortcut(APIC_DEST_ALLINC, vector);
-}
-
-void send_IPI_self(int vector)
-{
-       __send_IPI_shortcut(APIC_DEST_SELF, vector);
-}
-
-static inline void send_IPI_mask(cpumask_t cpumask, int vector)
-{
-       unsigned long mask = cpus_addr(cpumask)[0];
-       unsigned long cfg;
-       unsigned long flags;
-
-       local_save_flags(flags);
-       local_irq_disable();
-
-       /*
-        * Wait for idle.
-        */
-       apic_wait_icr_idle();
-
-       /*
-        * prepare target chip field
-        */
-       cfg = __prepare_ICR2(mask);
-       apic_write_around(APIC_ICR2, cfg);
-
-       /*
-        * program the ICR 
-        */
-       cfg = __prepare_ICR(0, vector);
-       
-       /*
-        * Send the IPI. The write to APIC_ICR fires this off.
-        */
-       apic_write_around(APIC_ICR, cfg);
-       local_irq_restore(flags);
-}
+#include <asm/mach_apic.h>
+#include <asm/proto.h>
 
 /*
  *     Smarter SMP flushing macros. 
@@ -137,7 +40,7 @@ static inline void send_IPI_mask(cpumask_t cpumask, int vector)
 static cpumask_t flush_cpumask;
 static struct mm_struct * flush_mm;
 static unsigned long flush_va;
-static spinlock_t tlbstate_lock = SPIN_LOCK_UNLOCKED;
+static DEFINE_SPINLOCK(tlbstate_lock);
 #define FLUSH_ALL      0xffffffff
 
 /*
@@ -366,7 +269,7 @@ void smp_send_reschedule(int cpu)
  * Structure and data for smp_call_function(). This is designed to minimise
  * static memory requirements. It also looks cleaner.
  */
-static spinlock_t call_lock = SPIN_LOCK_UNLOCKED;
+static DEFINE_SPINLOCK(call_lock);
 
 struct call_data_struct {
        void (*func) (void *info);
@@ -405,11 +308,13 @@ static void __smp_call_function (void (*func) (void *info), void *info,
 
        /* Wait for response */
        while (atomic_read(&data.started) != cpus)
-               barrier();
+               cpu_relax();
 
-       if (wait)
-               while (atomic_read(&data.finished) != cpus)
-                       barrier();
+       if (!wait)
+               return;
+
+       while (atomic_read(&data.finished) != cpus)
+               cpu_relax();
 }
 
 /*
@@ -457,13 +362,14 @@ static void smp_really_stop_cpu(void *dummy)
 void smp_send_stop(void)
 {
        int nolock = 0;
+       if (reboot_force)
+               return;
        /* Don't deadlock on the call lock in panic */
        if (!spin_trylock(&call_lock)) {
-               udelay(100);
                /* ignore locking because we have paniced anyways */
                nolock = 1;
        }
-       __smp_call_function(smp_really_stop_cpu, NULL, 1, 0);
+       __smp_call_function(smp_really_stop_cpu, NULL, 0, 0);
        if (!nolock)
                spin_unlock(&call_lock);
        smp_stop_cpu();