Merge branch 'linus' into perfcounters/core
Ingo Molnar [Fri, 13 Feb 2009 08:34:07 +0000 (09:34 +0100)]
Conflicts:
arch/x86/kernel/acpi/boot.c

15 files changed:
1  2 
arch/x86/Kconfig
arch/x86/Kconfig.cpu
arch/x86/include/asm/paravirt.h
arch/x86/include/asm/processor.h
arch/x86/kernel/acpi/boot.c
arch/x86/kernel/io_apic.c
arch/x86/kernel/process_64.c
arch/x86/kernel/setup.c
arch/x86/kernel/traps.c
include/linux/init_task.h
include/linux/sched.h
include/linux/syscalls.h
kernel/exit.c
kernel/fork.c
kernel/sched.c

diff --combined arch/x86/Kconfig
@@@ -391,13 -391,6 +391,13 @@@ config X86_RDC321
          as R-8610-(G).
          If you don't have one of these chips, you should say N here.
  
 +config X86_UV
 +      bool "SGI Ultraviolet"
 +      depends on X86_64
 +      help
 +        This option is needed in order to support SGI Ultraviolet systems.
 +        If you don't have one of these, you should say N here.
 +
  config SCHED_OMIT_FRAME_POINTER
        def_bool y
        prompt "Single-depth WCHAN output"
@@@ -692,7 -685,6 +692,7 @@@ config X86_UP_IOAPI
  config X86_LOCAL_APIC
        def_bool y
        depends on X86_64 || (X86_32 && (X86_UP_APIC || (SMP && !X86_VOYAGER) || X86_GENERICARCH))
 +      select HAVE_PERF_COUNTERS if (!M386 && !M486)
  
  config X86_IO_APIC
        def_bool y
@@@ -1348,17 -1340,13 +1348,17 @@@ config SECCOM
  
          If unsure, say Y. Only embedded should say N here.
  
 +config CC_STACKPROTECTOR_ALL
 +      bool
 +
  config CC_STACKPROTECTOR
        bool "Enable -fstack-protector buffer overflow detection (EXPERIMENTAL)"
 -      depends on X86_64 && EXPERIMENTAL && BROKEN
 +      depends on X86_64
 +      select CC_STACKPROTECTOR_ALL
        help
 -         This option turns on the -fstack-protector GCC feature. This
 -        feature puts, at the beginning of critical functions, a canary
 -        value on the stack just before the return address, and validates
 +          This option turns on the -fstack-protector GCC feature. This
 +        feature puts, at the beginning of functions, a canary value on
 +        the stack just before the return address, and validates
          the value just before actually returning.  Stack based buffer
          overflows (that need to overwrite this return address) now also
          overwrite the canary, which gets detected and the attack is then
  
          This feature requires gcc version 4.2 or above, or a distribution
          gcc with the feature backported. Older versions are automatically
 -        detected and for those versions, this configuration option is ignored.
 -
 -config CC_STACKPROTECTOR_ALL
 -      bool "Use stack-protector for all functions"
 -      depends on CC_STACKPROTECTOR
 -      help
 -        Normally, GCC only inserts the canary value protection for
 -        functions that use large-ish on-stack buffers. By enabling
 -        this option, GCC will be asked to do this for ALL functions.
 +        detected and for those versions, this configuration option is
 +        ignored. (and a warning is printed during bootup)
  
  source kernel/Kconfig.hz
  
@@@ -1807,6 -1802,17 +1807,17 @@@ config DMA
          and include PCI device scope covered by these DMA
          remapping devices.
  
+ config DMAR_DEFAULT_ON
+       def_bool n
+       prompt "Enable DMA Remapping Devices by default"
+       depends on DMAR
+       help
+         Selecting this option will enable a DMAR device at boot time if
+         one is found. If this option is not selected, DMAR support can
+         be enabled by passing intel_iommu=on to the kernel. It is
+         recommended you say N here while the DMAR code remains
+         experimental.
  config DMAR_GFX_WA
        def_bool y
        prompt "Support for Graphics workaround"
diff --combined arch/x86/Kconfig.cpu
@@@ -167,9 -167,9 +167,9 @@@ config MK
  config MK8
        bool "Opteron/Athlon64/Hammer/K8"
        help
-         Select this for an AMD Opteron or Athlon64 Hammer-family processor.  Enables
-         use of some extended instructions, and passes appropriate optimization
-         flags to GCC.
+         Select this for an AMD Opteron or Athlon64 Hammer-family processor.
+         Enables use of some extended instructions, and passes appropriate
+         optimization flags to GCC.
  
  config MCRUSOE
        bool "Crusoe"
@@@ -256,9 -256,11 +256,11 @@@ config MPS
  config MCORE2
        bool "Core 2/newer Xeon"
        help
-         Select this for Intel Core 2 and newer Core 2 Xeons (Xeon 51xx and 53xx)
-         CPUs. You can distinguish newer from older Xeons by the CPU family
-         in /proc/cpuinfo. Newer ones have 6 and older ones 15 (not a typo)
+         Select this for Intel Core 2 and newer Core 2 Xeons (Xeon 51xx and
+         53xx) CPUs. You can distinguish newer from older Xeons by the CPU
+         family in /proc/cpuinfo. Newer ones have 6 and older ones 15
+         (not a typo)
  
  config GENERIC_CPU
        bool "Generic-x86-64"
@@@ -292,23 -294,25 +294,23 @@@ config X86_CP
  # Define implied options from the CPU selection here
  config X86_L1_CACHE_BYTES
        int
 -      default "128" if GENERIC_CPU || MPSC
 -      default "64" if MK8 || MCORE2
 -      depends on X86_64
 +      default "128" if MPSC
 +      default "64" if GENERIC_CPU || MK8 || MCORE2 || X86_32
  
  config X86_INTERNODE_CACHE_BYTES
        int
        default "4096" if X86_VSMP
        default X86_L1_CACHE_BYTES if !X86_VSMP
 -      depends on X86_64
  
  config X86_CMPXCHG
        def_bool X86_64 || (X86_32 && !M386)
  
  config X86_L1_CACHE_SHIFT
        int
 -      default "7" if MPENTIUM4 || X86_GENERIC || GENERIC_CPU || MPSC
 +      default "7" if MPENTIUM4 || MPSC
        default "4" if X86_ELAN || M486 || M386 || MGEODEGX1
        default "5" if MWINCHIP3D || MWINCHIPC6 || MCRUSOE || MEFFICEON || MCYRIXIII || MK6 || MPENTIUMIII || MPENTIUMII || M686 || M586MMX || M586TSC || M586 || MVIAC3_2 || MGEODE_LX
 -      default "6" if MK7 || MK8 || MPENTIUMM || MCORE2 || MVIAC7
 +      default "6" if MK7 || MK8 || MPENTIUMM || MCORE2 || MVIAC7 || X86_GENERIC || GENERIC_CPU
  
  config X86_XADD
        def_bool y
@@@ -318,14 -322,14 +320,14 @@@ config X86_PPRO_FENC
        bool "PentiumPro memory ordering errata workaround"
        depends on M686 || M586MMX || M586TSC || M586 || M486 || M386 || MGEODEGX1
        help
-         Old PentiumPro multiprocessor systems had errata that could cause memory
-         operations to violate the x86 ordering standard in rare cases. Enabling this
-         option will attempt to work around some (but not all) occurances of
-         this problem, at the cost of much heavier spinlock and memory barrier
-         operations.
-         If unsure, say n here. Even distro kernels should think twice before enabling
-         this: there are few systems, and an unlikely bug.
+         Old PentiumPro multiprocessor systems had errata that could cause
+         memory operations to violate the x86 ordering standard in rare cases.
+         Enabling this option will attempt to work around some (but not all)
+         occurances of this problem, at the cost of much heavier spinlock and
+         memory barrier operations.
+         If unsure, say n here. Even distro kernels should think twice before
+         enabling this: there are few systems, and an unlikely bug.
  
  config X86_F00F_BUG
        def_bool y
@@@ -244,8 -244,7 +244,8 @@@ struct pv_mmu_ops 
        void (*flush_tlb_user)(void);
        void (*flush_tlb_kernel)(void);
        void (*flush_tlb_single)(unsigned long addr);
 -      void (*flush_tlb_others)(const cpumask_t *cpus, struct mm_struct *mm,
 +      void (*flush_tlb_others)(const struct cpumask *cpus,
 +                               struct mm_struct *mm,
                                 unsigned long va);
  
        /* Hooks for allocating and freeing a pagetable top-level */
@@@ -985,11 -984,10 +985,11 @@@ static inline void __flush_tlb_single(u
        PVOP_VCALL1(pv_mmu_ops.flush_tlb_single, addr);
  }
  
 -static inline void flush_tlb_others(cpumask_t cpumask, struct mm_struct *mm,
 +static inline void flush_tlb_others(const struct cpumask *cpumask,
 +                                  struct mm_struct *mm,
                                    unsigned long va)
  {
 -      PVOP_VCALL3(pv_mmu_ops.flush_tlb_others, &cpumask, mm, va);
 +      PVOP_VCALL3(pv_mmu_ops.flush_tlb_others, cpumask, mm, va);
  }
  
  static inline int paravirt_pgd_alloc(struct mm_struct *mm)
@@@ -1404,6 -1402,7 +1404,7 @@@ static inline int __raw_spin_is_contend
  {
        return PVOP_CALL1(int, pv_lock_ops.spin_is_contended, lock);
  }
+ #define __raw_spin_is_contended       __raw_spin_is_contended
  
  static __always_inline void __raw_spin_lock(struct raw_spinlock *lock)
  {
@@@ -353,7 -353,7 +353,7 @@@ struct i387_soft_struct 
        u8                      no_update;
        u8                      rm;
        u8                      alimit;
-       struct info             *info;
+       struct math_emu_info    *info;
        u32                     entry_eip;
  };
  
@@@ -378,30 -378,6 +378,30 @@@ union thread_xstate 
  
  #ifdef CONFIG_X86_64
  DECLARE_PER_CPU(struct orig_ist, orig_ist);
 +
 +union irq_stack_union {
 +      char irq_stack[IRQ_STACK_SIZE];
 +      /*
 +       * GCC hardcodes the stack canary as %gs:40.  Since the
 +       * irq_stack is the object at %gs:0, we reserve the bottom
 +       * 48 bytes of the irq stack for the canary.
 +       */
 +      struct {
 +              char gs_base[40];
 +              unsigned long stack_canary;
 +      };
 +};
 +
 +DECLARE_PER_CPU(union irq_stack_union, irq_stack_union);
 +DECLARE_PER_CPU(char *, irq_stack_ptr);
 +
 +static inline void load_gs_base(int cpu)
 +{
 +      /* Memory clobbers used to order pda/percpu accesses */
 +      mb();
 +      wrmsrl(MSR_GS_BASE, (unsigned long)per_cpu(irq_stack_union.gs_base, cpu));
 +      mb();
 +}
  #endif
  
  extern void print_cpu_info(struct cpuinfo_x86 *);
@@@ -912,8 -912,8 +912,8 @@@ static u8 __init uniq_ioapic_id(u8 id
        DECLARE_BITMAP(used, 256);
        bitmap_zero(used, 256);
        for (i = 0; i < nr_ioapics; i++) {
 -              struct mp_config_ioapic *ia = &mp_ioapics[i];
 -              __set_bit(ia->mp_apicid, used);
 +              struct mpc_ioapic *ia = &mp_ioapics[i];
 +              __set_bit(ia->apicid, used);
        }
        if (!test_bit(id, used))
                return id;
@@@ -945,47 -945,70 +945,70 @@@ void __init mp_register_ioapic(int id, 
  
        idx = nr_ioapics;
  
 -      mp_ioapics[idx].mp_type = MP_IOAPIC;
 -      mp_ioapics[idx].mp_flags = MPC_APIC_USABLE;
 -      mp_ioapics[idx].mp_apicaddr = address;
 +      mp_ioapics[idx].type = MP_IOAPIC;
 +      mp_ioapics[idx].flags = MPC_APIC_USABLE;
 +      mp_ioapics[idx].apicaddr = address;
  
        set_fixmap_nocache(FIX_IO_APIC_BASE_0 + idx, address);
 -      mp_ioapics[idx].mp_apicid = uniq_ioapic_id(id);
 +      mp_ioapics[idx].apicid = uniq_ioapic_id(id);
  #ifdef CONFIG_X86_32
 -      mp_ioapics[idx].mp_apicver = io_apic_get_version(idx);
 +      mp_ioapics[idx].apicver = io_apic_get_version(idx);
  #else
 -      mp_ioapics[idx].mp_apicver = 0;
 +      mp_ioapics[idx].apicver = 0;
  #endif
        /*
         * Build basic GSI lookup table to facilitate gsi->io_apic lookups
         * and to prevent reprogramming of IOAPIC pins (PCI GSIs).
         */
 -      mp_ioapic_routing[idx].apic_id = mp_ioapics[idx].mp_apicid;
 +      mp_ioapic_routing[idx].apic_id = mp_ioapics[idx].apicid;
        mp_ioapic_routing[idx].gsi_base = gsi_base;
        mp_ioapic_routing[idx].gsi_end = gsi_base +
            io_apic_get_redir_entries(idx);
  
 -      printk(KERN_INFO "IOAPIC[%d]: apic_id %d, version %d, address 0x%lx, "
 -             "GSI %d-%d\n", idx, mp_ioapics[idx].mp_apicid,
 -             mp_ioapics[idx].mp_apicver, mp_ioapics[idx].mp_apicaddr,
 +      printk(KERN_INFO "IOAPIC[%d]: apic_id %d, version %d, address 0x%x, "
 +             "GSI %d-%d\n", idx, mp_ioapics[idx].apicid,
 +             mp_ioapics[idx].apicver, mp_ioapics[idx].apicaddr,
               mp_ioapic_routing[idx].gsi_base, mp_ioapic_routing[idx].gsi_end);
  
        nr_ioapics++;
  }
  
+ int __init acpi_probe_gsi(void)
+ {
+       int idx;
+       int gsi;
+       int max_gsi = 0;
+       if (acpi_disabled)
+               return 0;
+       if (!acpi_ioapic)
+               return 0;
+       max_gsi = 0;
+       for (idx = 0; idx < nr_ioapics; idx++) {
+               gsi = mp_ioapic_routing[idx].gsi_end;
+               if (gsi > max_gsi)
+                       max_gsi = gsi;
+       }
+       return max_gsi + 1;
+ }
 -static void assign_to_mp_irq(struct mp_config_intsrc *m,
 -                                  struct mp_config_intsrc *mp_irq)
 +static void assign_to_mp_irq(struct mpc_intsrc *m,
 +                                  struct mpc_intsrc *mp_irq)
  {
 -      memcpy(mp_irq, m, sizeof(struct mp_config_intsrc));
 +      memcpy(mp_irq, m, sizeof(struct mpc_intsrc));
  }
  
 -static int mp_irq_cmp(struct mp_config_intsrc *mp_irq,
 -                              struct mp_config_intsrc *m)
 +static int mp_irq_cmp(struct mpc_intsrc *mp_irq,
 +                              struct mpc_intsrc *m)
  {
 -      return memcmp(mp_irq, m, sizeof(struct mp_config_intsrc));
 +      return memcmp(mp_irq, m, sizeof(struct mpc_intsrc));
  }
  
 -static void save_mp_irq(struct mp_config_intsrc *m)
 +static void save_mp_irq(struct mpc_intsrc *m)
  {
        int i;
  
@@@ -1003,7 -1026,7 +1026,7 @@@ void __init mp_override_legacy_irq(u8 b
  {
        int ioapic;
        int pin;
 -      struct mp_config_intsrc mp_irq;
 +      struct mpc_intsrc mp_irq;
  
        /*
         * Convert 'gsi' to 'ioapic.pin'.
        if ((bus_irq == 0) && (trigger == 3))
                trigger = 1;
  
 -      mp_irq.mp_type = MP_INTSRC;
 -      mp_irq.mp_irqtype = mp_INT;
 -      mp_irq.mp_irqflag = (trigger << 2) | polarity;
 -      mp_irq.mp_srcbus = MP_ISA_BUS;
 -      mp_irq.mp_srcbusirq = bus_irq;  /* IRQ */
 -      mp_irq.mp_dstapic = mp_ioapics[ioapic].mp_apicid; /* APIC ID */
 -      mp_irq.mp_dstirq = pin; /* INTIN# */
 +      mp_irq.type = MP_INTSRC;
 +      mp_irq.irqtype = mp_INT;
 +      mp_irq.irqflag = (trigger << 2) | polarity;
 +      mp_irq.srcbus = MP_ISA_BUS;
 +      mp_irq.srcbusirq = bus_irq;     /* IRQ */
 +      mp_irq.dstapic = mp_ioapics[ioapic].apicid; /* APIC ID */
 +      mp_irq.dstirq = pin;    /* INTIN# */
  
        save_mp_irq(&mp_irq);
  }
@@@ -1037,7 -1060,7 +1060,7 @@@ void __init mp_config_acpi_legacy_irqs(
        int i;
        int ioapic;
        unsigned int dstapic;
 -      struct mp_config_intsrc mp_irq;
 +      struct mpc_intsrc mp_irq;
  
  #if defined (CONFIG_MCA) || defined (CONFIG_EISA)
        /*
        ioapic = mp_find_ioapic(0);
        if (ioapic < 0)
                return;
 -      dstapic = mp_ioapics[ioapic].mp_apicid;
 +      dstapic = mp_ioapics[ioapic].apicid;
  
        /*
         * Use the default configuration for the IRQs 0-15.  Unless
                int idx;
  
                for (idx = 0; idx < mp_irq_entries; idx++) {
 -                      struct mp_config_intsrc *irq = mp_irqs + idx;
 +                      struct mpc_intsrc *irq = mp_irqs + idx;
  
                        /* Do we already have a mapping for this ISA IRQ? */
 -                      if (irq->mp_srcbus == MP_ISA_BUS
 -                          && irq->mp_srcbusirq == i)
 +                      if (irq->srcbus == MP_ISA_BUS && irq->srcbusirq == i)
                                break;
  
                        /* Do we already have a mapping for this IOAPIC pin */
 -                      if (irq->mp_dstapic == dstapic &&
 -                          irq->mp_dstirq == i)
 +                      if (irq->dstapic == dstapic && irq->dstirq == i)
                                break;
                }
  
                        continue;       /* IRQ already used */
                }
  
 -              mp_irq.mp_type = MP_INTSRC;
 -              mp_irq.mp_irqflag = 0;  /* Conforming */
 -              mp_irq.mp_srcbus = MP_ISA_BUS;
 -              mp_irq.mp_dstapic = dstapic;
 -              mp_irq.mp_irqtype = mp_INT;
 -              mp_irq.mp_srcbusirq = i; /* Identity mapped */
 -              mp_irq.mp_dstirq = i;
 +              mp_irq.type = MP_INTSRC;
 +              mp_irq.irqflag = 0;     /* Conforming */
 +              mp_irq.srcbus = MP_ISA_BUS;
 +              mp_irq.dstapic = dstapic;
 +              mp_irq.irqtype = mp_INT;
 +              mp_irq.srcbusirq = i; /* Identity mapped */
 +              mp_irq.dstirq = i;
  
                save_mp_irq(&mp_irq);
        }
@@@ -1205,22 -1230,22 +1228,22 @@@ int mp_config_acpi_gsi(unsigned char nu
                        u32 gsi, int triggering, int polarity)
  {
  #ifdef CONFIG_X86_MPPARSE
 -      struct mp_config_intsrc mp_irq;
 +      struct mpc_intsrc mp_irq;
        int ioapic;
  
        if (!acpi_ioapic)
                return 0;
  
        /* print the entry should happen on mptable identically */
 -      mp_irq.mp_type = MP_INTSRC;
 -      mp_irq.mp_irqtype = mp_INT;
 -      mp_irq.mp_irqflag = (triggering == ACPI_EDGE_SENSITIVE ? 4 : 0x0c) |
 +      mp_irq.type = MP_INTSRC;
 +      mp_irq.irqtype = mp_INT;
 +      mp_irq.irqflag = (triggering == ACPI_EDGE_SENSITIVE ? 4 : 0x0c) |
                                (polarity == ACPI_ACTIVE_HIGH ? 1 : 3);
 -      mp_irq.mp_srcbus = number;
 -      mp_irq.mp_srcbusirq = (((devfn >> 3) & 0x1f) << 2) | ((pin - 1) & 3);
 +      mp_irq.srcbus = number;
 +      mp_irq.srcbusirq = (((devfn >> 3) & 0x1f) << 2) | ((pin - 1) & 3);
        ioapic = mp_find_ioapic(gsi);
 -      mp_irq.mp_dstapic = mp_ioapic_routing[ioapic].apic_id;
 -      mp_irq.mp_dstirq = gsi - mp_ioapic_routing[ioapic].gsi_base;
 +      mp_irq.dstapic = mp_ioapic_routing[ioapic].apic_id;
 +      mp_irq.dstirq = gsi - mp_ioapic_routing[ioapic].gsi_base;
  
        save_mp_irq(&mp_irq);
  #endif
@@@ -46,7 -46,6 +46,7 @@@
  #include <asm/idle.h>
  #include <asm/io.h>
  #include <asm/smp.h>
 +#include <asm/cpu.h>
  #include <asm/desc.h>
  #include <asm/proto.h>
  #include <asm/acpi.h>
@@@ -83,11 -82,11 +83,11 @@@ static DEFINE_SPINLOCK(vector_lock)
  int nr_ioapic_registers[MAX_IO_APICS];
  
  /* I/O APIC entries */
 -struct mp_config_ioapic mp_ioapics[MAX_IO_APICS];
 +struct mpc_ioapic mp_ioapics[MAX_IO_APICS];
  int nr_ioapics;
  
  /* MP IRQ source entries */
 -struct mp_config_intsrc mp_irqs[MAX_IRQ_SOURCES];
 +struct mpc_intsrc mp_irqs[MAX_IRQ_SOURCES];
  
  /* # of MP IRQ source entries */
  int mp_irq_entries;
@@@ -357,7 -356,7 +357,7 @@@ set_extra_move_desc(struct irq_desc *de
  
        if (!cfg->move_in_progress) {
                /* it means that domain is not changed */
 -              if (!cpumask_intersects(&desc->affinity, mask))
 +              if (!cpumask_intersects(desc->affinity, mask))
                        cfg->move_desc_pending = 1;
        }
  }
@@@ -387,7 -386,7 +387,7 @@@ struct io_apic 
  static __attribute_const__ struct io_apic __iomem *io_apic_base(int idx)
  {
        return (void __iomem *) __fix_to_virt(FIX_IO_APIC_BASE_0 + idx)
 -              + (mp_ioapics[idx].mp_apicaddr & ~PAGE_MASK);
 +              + (mp_ioapics[idx].apicaddr & ~PAGE_MASK);
  }
  
  static inline unsigned int io_apic_read(unsigned int apic, unsigned int reg)
@@@ -580,9 -579,9 +580,9 @@@ set_desc_affinity(struct irq_desc *desc
        if (assign_irq_vector(irq, cfg, mask))
                return BAD_APICID;
  
 -      cpumask_and(&desc->affinity, cfg->domain, mask);
 +      cpumask_and(desc->affinity, cfg->domain, mask);
        set_extra_move_desc(desc, mask);
 -      return cpu_mask_to_apicid_and(&desc->affinity, cpu_online_mask);
 +      return cpu_mask_to_apicid_and(desc->affinity, cpu_online_mask);
  }
  
  static void
@@@ -945,10 -944,10 +945,10 @@@ static int find_irq_entry(int apic, in
        int i;
  
        for (i = 0; i < mp_irq_entries; i++)
 -              if (mp_irqs[i].mp_irqtype == type &&
 -                  (mp_irqs[i].mp_dstapic == mp_ioapics[apic].mp_apicid ||
 -                   mp_irqs[i].mp_dstapic == MP_APIC_ALL) &&
 -                  mp_irqs[i].mp_dstirq == pin)
 +              if (mp_irqs[i].irqtype == type &&
 +                  (mp_irqs[i].dstapic == mp_ioapics[apic].apicid ||
 +                   mp_irqs[i].dstapic == MP_APIC_ALL) &&
 +                  mp_irqs[i].dstirq == pin)
                        return i;
  
        return -1;
@@@ -962,13 -961,13 +962,13 @@@ static int __init find_isa_irq_pin(int 
        int i;
  
        for (i = 0; i < mp_irq_entries; i++) {
 -              int lbus = mp_irqs[i].mp_srcbus;
 +              int lbus = mp_irqs[i].srcbus;
  
                if (test_bit(lbus, mp_bus_not_pci) &&
 -                  (mp_irqs[i].mp_irqtype == type) &&
 -                  (mp_irqs[i].mp_srcbusirq == irq))
 +                  (mp_irqs[i].irqtype == type) &&
 +                  (mp_irqs[i].srcbusirq == irq))
  
 -                      return mp_irqs[i].mp_dstirq;
 +                      return mp_irqs[i].dstirq;
        }
        return -1;
  }
@@@ -978,17 -977,17 +978,17 @@@ static int __init find_isa_irq_apic(in
        int i;
  
        for (i = 0; i < mp_irq_entries; i++) {
 -              int lbus = mp_irqs[i].mp_srcbus;
 +              int lbus = mp_irqs[i].srcbus;
  
                if (test_bit(lbus, mp_bus_not_pci) &&
 -                  (mp_irqs[i].mp_irqtype == type) &&
 -                  (mp_irqs[i].mp_srcbusirq == irq))
 +                  (mp_irqs[i].irqtype == type) &&
 +                  (mp_irqs[i].srcbusirq == irq))
                        break;
        }
        if (i < mp_irq_entries) {
                int apic;
                for(apic = 0; apic < nr_ioapics; apic++) {
 -                      if (mp_ioapics[apic].mp_apicid == mp_irqs[i].mp_dstapic)
 +                      if (mp_ioapics[apic].apicid == mp_irqs[i].dstapic)
                                return apic;
                }
        }
@@@ -1013,23 -1012,23 +1013,23 @@@ int IO_APIC_get_PCI_irq_vector(int bus
                return -1;
        }
        for (i = 0; i < mp_irq_entries; i++) {
 -              int lbus = mp_irqs[i].mp_srcbus;
 +              int lbus = mp_irqs[i].srcbus;
  
                for (apic = 0; apic < nr_ioapics; apic++)
 -                      if (mp_ioapics[apic].mp_apicid == mp_irqs[i].mp_dstapic ||
 -                          mp_irqs[i].mp_dstapic == MP_APIC_ALL)
 +                      if (mp_ioapics[apic].apicid == mp_irqs[i].dstapic ||
 +                          mp_irqs[i].dstapic == MP_APIC_ALL)
                                break;
  
                if (!test_bit(lbus, mp_bus_not_pci) &&
 -                  !mp_irqs[i].mp_irqtype &&
 +                  !mp_irqs[i].irqtype &&
                    (bus == lbus) &&
 -                  (slot == ((mp_irqs[i].mp_srcbusirq >> 2) & 0x1f))) {
 -                      int irq = pin_2_irq(i,apic,mp_irqs[i].mp_dstirq);
 +                  (slot == ((mp_irqs[i].srcbusirq >> 2) & 0x1f))) {
 +                      int irq = pin_2_irq(i, apic, mp_irqs[i].dstirq);
  
                        if (!(apic || IO_APIC_IRQ(irq)))
                                continue;
  
 -                      if (pin == (mp_irqs[i].mp_srcbusirq & 3))
 +                      if (pin == (mp_irqs[i].srcbusirq & 3))
                                return irq;
                        /*
                         * Use the first all-but-pin matching entry as a
@@@ -1072,7 -1071,7 +1072,7 @@@ static int EISA_ELCR(unsigned int irq
   * EISA conforming in the MP table, that means its trigger type must
   * be read in from the ELCR */
  
 -#define default_EISA_trigger(idx)     (EISA_ELCR(mp_irqs[idx].mp_srcbusirq))
 +#define default_EISA_trigger(idx)     (EISA_ELCR(mp_irqs[idx].srcbusirq))
  #define default_EISA_polarity(idx)    default_ISA_polarity(idx)
  
  /* PCI interrupts are always polarity one level triggered,
  
  static int MPBIOS_polarity(int idx)
  {
 -      int bus = mp_irqs[idx].mp_srcbus;
 +      int bus = mp_irqs[idx].srcbus;
        int polarity;
  
        /*
         * Determine IRQ line polarity (high active or low active):
         */
 -      switch (mp_irqs[idx].mp_irqflag & 3)
 +      switch (mp_irqs[idx].irqflag & 3)
        {
                case 0: /* conforms, ie. bus-type dependent polarity */
                        if (test_bit(bus, mp_bus_not_pci))
  
  static int MPBIOS_trigger(int idx)
  {
 -      int bus = mp_irqs[idx].mp_srcbus;
 +      int bus = mp_irqs[idx].srcbus;
        int trigger;
  
        /*
         * Determine IRQ trigger mode (edge or level sensitive):
         */
 -      switch ((mp_irqs[idx].mp_irqflag>>2) & 3)
 +      switch ((mp_irqs[idx].irqflag>>2) & 3)
        {
                case 0: /* conforms, ie. bus-type dependent */
                        if (test_bit(bus, mp_bus_not_pci))
@@@ -1215,16 -1214,16 +1215,16 @@@ int (*ioapic_renumber_irq)(int ioapic, 
  static int pin_2_irq(int idx, int apic, int pin)
  {
        int irq, i;
 -      int bus = mp_irqs[idx].mp_srcbus;
 +      int bus = mp_irqs[idx].srcbus;
  
        /*
         * Debugging check, we are in big trouble if this message pops up!
         */
 -      if (mp_irqs[idx].mp_dstirq != pin)
 +      if (mp_irqs[idx].dstirq != pin)
                printk(KERN_ERR "broken BIOS or MPTABLE parser, ayiee!!\n");
  
        if (test_bit(bus, mp_bus_not_pci)) {
 -              irq = mp_irqs[idx].mp_srcbusirq;
 +              irq = mp_irqs[idx].srcbusirq;
        } else {
                /*
                 * PCI IRQs are mapped in order
@@@ -1567,14 -1566,14 +1567,14 @@@ static void setup_IO_APIC_irq(int apic
        apic_printk(APIC_VERBOSE,KERN_DEBUG
                    "IOAPIC[%d]: Set routing entry (%d-%d -> 0x%x -> "
                    "IRQ %d Mode:%i Active:%i)\n",
 -                  apic, mp_ioapics[apic].mp_apicid, pin, cfg->vector,
 +                  apic, mp_ioapics[apic].apicid, pin, cfg->vector,
                    irq, trigger, polarity);
  
  
 -      if (setup_ioapic_entry(mp_ioapics[apic].mp_apicid, irq, &entry,
 +      if (setup_ioapic_entry(mp_ioapics[apic].apicid, irq, &entry,
                               dest, trigger, polarity, cfg->vector)) {
                printk("Failed to setup ioapic entry for ioapic  %d, pin %d\n",
 -                     mp_ioapics[apic].mp_apicid, pin);
 +                     mp_ioapics[apic].apicid, pin);
                __clear_irq_vector(irq, cfg);
                return;
        }
@@@ -1605,10 -1604,12 +1605,10 @@@ static void __init setup_IO_APIC_irqs(v
                                        notcon = 1;
                                        apic_printk(APIC_VERBOSE,
                                                KERN_DEBUG " %d-%d",
 -                                              mp_ioapics[apic].mp_apicid,
 -                                              pin);
 +                                              mp_ioapics[apic].apicid, pin);
                                } else
                                        apic_printk(APIC_VERBOSE, " %d-%d",
 -                                              mp_ioapics[apic].mp_apicid,
 -                                              pin);
 +                                              mp_ioapics[apic].apicid, pin);
                                continue;
                        }
                        if (notcon) {
@@@ -1698,7 -1699,7 +1698,7 @@@ __apicdebuginit(void) print_IO_APIC(voi
        printk(KERN_DEBUG "number of MP IRQ sources: %d.\n", mp_irq_entries);
        for (i = 0; i < nr_ioapics; i++)
                printk(KERN_DEBUG "number of IO-APIC #%d registers: %d.\n",
 -                     mp_ioapics[i].mp_apicid, nr_ioapic_registers[i]);
 +                     mp_ioapics[i].apicid, nr_ioapic_registers[i]);
  
        /*
         * We are a bit conservative about what we expect.  We have to
        spin_unlock_irqrestore(&ioapic_lock, flags);
  
        printk("\n");
 -      printk(KERN_DEBUG "IO APIC #%d......\n", mp_ioapics[apic].mp_apicid);
 +      printk(KERN_DEBUG "IO APIC #%d......\n", mp_ioapics[apic].apicid);
        printk(KERN_DEBUG ".... register #00: %08X\n", reg_00.raw);
        printk(KERN_DEBUG ".......    : physical APIC id: %02X\n", reg_00.bits.ID);
        printk(KERN_DEBUG ".......    : Delivery Type: %X\n", reg_00.bits.delivery_type);
@@@ -2120,14 -2121,14 +2120,14 @@@ static void __init setup_ioapic_ids_fro
                reg_00.raw = io_apic_read(apic, 0);
                spin_unlock_irqrestore(&ioapic_lock, flags);
  
 -              old_id = mp_ioapics[apic].mp_apicid;
 +              old_id = mp_ioapics[apic].apicid;
  
 -              if (mp_ioapics[apic].mp_apicid >= get_physical_broadcast()) {
 +              if (mp_ioapics[apic].apicid >= get_physical_broadcast()) {
                        printk(KERN_ERR "BIOS bug, IO-APIC#%d ID is %d in the MPC table!...\n",
 -                              apic, mp_ioapics[apic].mp_apicid);
 +                              apic, mp_ioapics[apic].apicid);
                        printk(KERN_ERR "... fixing up to %d. (tell your hw vendor)\n",
                                reg_00.bits.ID);
 -                      mp_ioapics[apic].mp_apicid = reg_00.bits.ID;
 +                      mp_ioapics[apic].apicid = reg_00.bits.ID;
                }
  
                /*
                 * 'stuck on smp_invalidate_needed IPI wait' messages.
                 */
                if (check_apicid_used(phys_id_present_map,
 -                                      mp_ioapics[apic].mp_apicid)) {
 +                                      mp_ioapics[apic].apicid)) {
                        printk(KERN_ERR "BIOS bug, IO-APIC#%d ID %d is already used!...\n",
 -                              apic, mp_ioapics[apic].mp_apicid);
 +                              apic, mp_ioapics[apic].apicid);
                        for (i = 0; i < get_physical_broadcast(); i++)
                                if (!physid_isset(i, phys_id_present_map))
                                        break;
                        printk(KERN_ERR "... fixing up to %d. (tell your hw vendor)\n",
                                i);
                        physid_set(i, phys_id_present_map);
 -                      mp_ioapics[apic].mp_apicid = i;
 +                      mp_ioapics[apic].apicid = i;
                } else {
                        physid_mask_t tmp;
 -                      tmp = apicid_to_cpu_present(mp_ioapics[apic].mp_apicid);
 +                      tmp = apicid_to_cpu_present(mp_ioapics[apic].apicid);
                        apic_printk(APIC_VERBOSE, "Setting %d in the "
                                        "phys_id_present_map\n",
 -                                      mp_ioapics[apic].mp_apicid);
 +                                      mp_ioapics[apic].apicid);
                        physids_or(phys_id_present_map, phys_id_present_map, tmp);
                }
  
                 * We need to adjust the IRQ routing table
                 * if the ID changed.
                 */
 -              if (old_id != mp_ioapics[apic].mp_apicid)
 +              if (old_id != mp_ioapics[apic].apicid)
                        for (i = 0; i < mp_irq_entries; i++)
 -                              if (mp_irqs[i].mp_dstapic == old_id)
 -                                      mp_irqs[i].mp_dstapic
 -                                              = mp_ioapics[apic].mp_apicid;
 +                              if (mp_irqs[i].dstapic == old_id)
 +                                      mp_irqs[i].dstapic
 +                                              = mp_ioapics[apic].apicid;
  
                /*
                 * Read the right value from the MPC table and
                 */
                apic_printk(APIC_VERBOSE, KERN_INFO
                        "...changing IO-APIC physical APIC ID to %d ...",
 -                      mp_ioapics[apic].mp_apicid);
 +                      mp_ioapics[apic].apicid);
  
 -              reg_00.bits.ID = mp_ioapics[apic].mp_apicid;
 +              reg_00.bits.ID = mp_ioapics[apic].apicid;
                spin_lock_irqsave(&ioapic_lock, flags);
                io_apic_write(apic, 0, reg_00.raw);
                spin_unlock_irqrestore(&ioapic_lock, flags);
                spin_lock_irqsave(&ioapic_lock, flags);
                reg_00.raw = io_apic_read(apic, 0);
                spin_unlock_irqrestore(&ioapic_lock, flags);
 -              if (reg_00.bits.ID != mp_ioapics[apic].mp_apicid)
 +              if (reg_00.bits.ID != mp_ioapics[apic].apicid)
                        printk("could not set ID!\n");
                else
                        apic_printk(APIC_VERBOSE, " ok.\n");
@@@ -2382,7 -2383,7 +2382,7 @@@ migrate_ioapic_irq_desc(struct irq_des
        if (cfg->move_in_progress)
                send_cleanup_vector(cfg);
  
 -      cpumask_copy(&desc->affinity, mask);
 +      cpumask_copy(desc->affinity, mask);
  }
  
  static int migrate_irq_remapped_level_desc(struct irq_desc *desc)
        }
  
        /* everthing is clear. we have right of way */
 -      migrate_ioapic_irq_desc(desc, &desc->pending_mask);
 +      migrate_ioapic_irq_desc(desc, desc->pending_mask);
  
        ret = 0;
        desc->status &= ~IRQ_MOVE_PENDING;
 -      cpumask_clear(&desc->pending_mask);
 +      cpumask_clear(desc->pending_mask);
  
  unmask:
        unmask_IO_APIC_irq_desc(desc);
@@@ -2433,7 -2434,7 +2433,7 @@@ static void ir_irq_migration(struct wor
                                continue;
                        }
  
 -                      desc->chip->set_affinity(irq, &desc->pending_mask);
 +                      desc->chip->set_affinity(irq, desc->pending_mask);
                        spin_unlock_irqrestore(&desc->lock, flags);
                }
        }
@@@ -2447,7 -2448,7 +2447,7 @@@ static void set_ir_ioapic_affinity_irq_
  {
        if (desc->status & IRQ_LEVEL) {
                desc->status |= IRQ_MOVE_PENDING;
 -              cpumask_copy(&desc->pending_mask, mask);
 +              cpumask_copy(desc->pending_mask, mask);
                migrate_irq_remapped_level_desc(desc);
                return;
        }
@@@ -2515,7 -2516,7 +2515,7 @@@ static void irq_complete_move(struct ir
  
                /* domain has not changed, but affinity did */
                me = smp_processor_id();
 -              if (cpu_isset(me, desc->affinity)) {
 +              if (cpumask_test_cpu(me, desc->affinity)) {
                        *descp = desc = move_irq_desc(desc, me);
                        /* get the new one */
                        cfg = desc->chip_data;
@@@ -3117,8 -3118,8 +3117,8 @@@ static int ioapic_resume(struct sys_dev
  
        spin_lock_irqsave(&ioapic_lock, flags);
        reg_00.raw = io_apic_read(dev->id, 0);
 -      if (reg_00.bits.ID != mp_ioapics[dev->id].mp_apicid) {
 -              reg_00.bits.ID = mp_ioapics[dev->id].mp_apicid;
 +      if (reg_00.bits.ID != mp_ioapics[dev->id].apicid) {
 +              reg_00.bits.ID = mp_ioapics[dev->id].apicid;
                io_apic_write(dev->id, 0, reg_00.raw);
        }
        spin_unlock_irqrestore(&ioapic_lock, flags);
@@@ -3183,7 -3184,7 +3183,7 @@@ unsigned int create_irq_nr(unsigned in
  
        irq = 0;
        spin_lock_irqsave(&vector_lock, flags);
 -      for (new = irq_want; new < NR_IRQS; new++) {
 +      for (new = irq_want; new < nr_irqs; new++) {
                if (platform_legacy_irq(new))
                        continue;
  
@@@ -3258,9 -3259,6 +3258,9 @@@ static int msi_compose_msg(struct pci_d
        int err;
        unsigned dest;
  
 +      if (disable_apic)
 +              return -ENXIO;
 +
        cfg = irq_cfg(irq);
        err = assign_irq_vector(irq, cfg, TARGET_CPUS);
        if (err)
@@@ -3729,9 -3727,6 +3729,9 @@@ int arch_setup_ht_irq(unsigned int irq
        struct irq_cfg *cfg;
        int err;
  
 +      if (disable_apic)
 +              return -ENXIO;
 +
        cfg = irq_cfg(irq);
        err = assign_irq_vector(irq, cfg, TARGET_CPUS);
        if (!err) {
  }
  #endif /* CONFIG_HT_IRQ */
  
 -#ifdef CONFIG_X86_64
 +#ifdef CONFIG_X86_UV
  /*
   * Re-target the irq to the specified CPU and enable the specified MMR located
   * on the specified blade to allow the sending of MSIs to the specified CPU.
@@@ -3846,32 -3841,26 +3846,42 @@@ int __init io_apic_get_redir_entries (i
  
  void __init probe_nr_irqs_gsi(void)
  {
-       int idx;
        int nr = 0;
  
-       for (idx = 0; idx < nr_ioapics; idx++)
-               nr += io_apic_get_redir_entries(idx) + 1;
-       if (nr > nr_irqs_gsi)
+       nr = acpi_probe_gsi();
+       if (nr > nr_irqs_gsi) {
                nr_irqs_gsi = nr;
+       } else {
+               /* for acpi=off or acpi is not compiled in */
+               int idx;
+               nr = 0;
+               for (idx = 0; idx < nr_ioapics; idx++)
+                       nr += io_apic_get_redir_entries(idx) + 1;
+               if (nr > nr_irqs_gsi)
+                       nr_irqs_gsi = nr;
+       }
+       printk(KERN_DEBUG "nr_irqs_gsi: %d\n", nr_irqs_gsi);
  }
  
 +#ifdef CONFIG_SPARSE_IRQ
 +int __init arch_probe_nr_irqs(void)
 +{
 +      int nr;
 +
 +      nr = ((8 * nr_cpu_ids) > (32 * nr_ioapics) ?
 +              (NR_VECTORS + (8 * nr_cpu_ids)) :
 +              (NR_VECTORS + (32 * nr_ioapics)));
 +
 +      if (nr < nr_irqs && nr > nr_irqs_gsi)
 +              nr_irqs = nr;
 +
 +      return 0;
 +}
 +#endif
 +
  /* --------------------------------------------------------------------------
                            ACPI-based IOAPIC Configuration
     -------------------------------------------------------------------------- */
@@@ -4006,8 -3995,8 +4016,8 @@@ int acpi_get_override_irq(int bus_irq, 
                return -1;
  
        for (i = 0; i < mp_irq_entries; i++)
 -              if (mp_irqs[i].mp_irqtype == mp_INT &&
 -                  mp_irqs[i].mp_srcbusirq == bus_irq)
 +              if (mp_irqs[i].irqtype == mp_INT &&
 +                  mp_irqs[i].srcbusirq == bus_irq)
                        break;
        if (i >= mp_irq_entries)
                return -1;
@@@ -4061,7 -4050,7 +4071,7 @@@ void __init setup_ioapic_dest(void
                         */
                        if (desc->status &
                            (IRQ_NO_BALANCING | IRQ_AFFINITY_SET))
 -                              mask = &desc->affinity;
 +                              mask = desc->affinity;
                        else
                                mask = TARGET_CPUS;
  
@@@ -4122,7 -4111,7 +4132,7 @@@ void __init ioapic_init_mappings(void
        ioapic_res = ioapic_setup_resources();
        for (i = 0; i < nr_ioapics; i++) {
                if (smp_found_config) {
 -                      ioapic_phys = mp_ioapics[i].mp_apicaddr;
 +                      ioapic_phys = mp_ioapics[i].apicaddr;
  #ifdef CONFIG_X86_32
                        if (!ioapic_phys) {
                                printk(KERN_ERR
@@@ -16,7 -16,6 +16,7 @@@
  
  #include <stdarg.h>
  
 +#include <linux/stackprotector.h>
  #include <linux/cpu.h>
  #include <linux/errno.h>
  #include <linux/sched.h>
  #include <linux/uaccess.h>
  #include <linux/io.h>
  #include <linux/ftrace.h>
+ #include <linux/dmi.h>
  
  #include <asm/pgtable.h>
  #include <asm/system.h>
  #include <asm/processor.h>
  #include <asm/i387.h>
  #include <asm/mmu_context.h>
 -#include <asm/pda.h>
  #include <asm/prctl.h>
  #include <asm/desc.h>
  #include <asm/proto.h>
  
  asmlinkage extern void ret_from_fork(void);
  
 +DEFINE_PER_CPU(struct task_struct *, current_task) = &init_task;
 +EXPORT_PER_CPU_SYMBOL(current_task);
 +
 +DEFINE_PER_CPU(unsigned long, old_rsp);
 +static DEFINE_PER_CPU(unsigned char, is_idle);
 +
  unsigned long kernel_thread_flags = CLONE_VM | CLONE_UNTRACED;
  
  static ATOMIC_NOTIFIER_HEAD(idle_notifier);
@@@ -81,13 -76,13 +82,13 @@@ EXPORT_SYMBOL_GPL(idle_notifier_unregis
  
  void enter_idle(void)
  {
 -      write_pda(isidle, 1);
 +      percpu_write(is_idle, 1);
        atomic_notifier_call_chain(&idle_notifier, IDLE_START, NULL);
  }
  
  static void __exit_idle(void)
  {
 -      if (test_and_clear_bit_pda(0, isidle) == 0)
 +      if (x86_test_and_clear_bit_percpu(0, is_idle) == 0)
                return;
        atomic_notifier_call_chain(&idle_notifier, IDLE_END, NULL);
  }
@@@ -117,17 -112,6 +118,17 @@@ static inline void play_dead(void
  void cpu_idle(void)
  {
        current_thread_info()->status |= TS_POLLING;
 +
 +      /*
 +       * If we're the non-boot CPU, nothing set the PDA stack
 +       * canary up for us - and if we are the boot CPU we have
 +       * a 0 stack canary. This is a good place for updating
 +       * it, as we wont ever return from this function (so the
 +       * invalid canaries already on the stack wont ever
 +       * trigger):
 +       */
 +      boot_init_stack_canary();
 +
        /* endless idle loop with no priority at all */
        while (1) {
                tick_nohz_stop_sched_tick(1);
@@@ -168,14 -152,18 +169,18 @@@ void __show_regs(struct pt_regs *regs, 
        unsigned long d0, d1, d2, d3, d6, d7;
        unsigned int fsindex, gsindex;
        unsigned int ds, cs, es;
+       const char *board;
  
        printk("\n");
        print_modules();
-       printk(KERN_INFO "Pid: %d, comm: %.20s %s %s %.*s\n",
+       board = dmi_get_system_info(DMI_PRODUCT_NAME);
+       if (!board)
+               board = "";
+       printk(KERN_INFO "Pid: %d, comm: %.20s %s %s %.*s %s\n",
                current->pid, current->comm, print_tainted(),
                init_utsname()->release,
                (int)strcspn(init_utsname()->version, " "),
-               init_utsname()->version);
+               init_utsname()->version, board);
        printk(KERN_INFO "RIP: %04lx:[<%016lx>] ", regs->cs & 0xffff, regs->ip);
        printk_address(regs->ip, 1);
        printk(KERN_INFO "RSP: %04lx:%016lx  EFLAGS: %08lx\n", regs->ss,
@@@ -409,7 -397,7 +414,7 @@@ start_thread(struct pt_regs *regs, unsi
        load_gs_index(0);
        regs->ip                = new_ip;
        regs->sp                = new_sp;
 -      write_pda(oldrsp, new_sp);
 +      percpu_write(old_rsp, new_sp);
        regs->cs                = __USER_CS;
        regs->ss                = __USER_DS;
        regs->flags             = 0x200;
@@@ -630,13 -618,21 +635,13 @@@ __switch_to(struct task_struct *prev_p
        /*
         * Switch the PDA and FPU contexts.
         */
 -      prev->usersp = read_pda(oldrsp);
 -      write_pda(oldrsp, next->usersp);
 -      write_pda(pcurrent, next_p);
 +      prev->usersp = percpu_read(old_rsp);
 +      percpu_write(old_rsp, next->usersp);
 +      percpu_write(current_task, next_p);
  
 -      write_pda(kernelstack,
 +      percpu_write(kernel_stack,
                  (unsigned long)task_stack_page(next_p) +
 -                THREAD_SIZE - PDA_STACKOFFSET);
 -#ifdef CONFIG_CC_STACKPROTECTOR
 -      write_pda(stack_canary, next_p->stack_canary);
 -      /*
 -       * Build time only check to make sure the stack_canary is at
 -       * offset 40 in the pda; this is a gcc ABI requirement
 -       */
 -      BUILD_BUG_ON(offsetof(struct x8664_pda, stack_canary) != 40);
 -#endif
 +                THREAD_SIZE - KERNEL_STACK_OFFSET);
  
        /*
         * Now maybe reload the debug registers and handle I/O bitmaps
diff --combined arch/x86/kernel/setup.c
@@@ -89,7 -89,7 +89,7 @@@
  
  #include <asm/system.h>
  #include <asm/vsyscall.h>
 -#include <asm/smp.h>
 +#include <asm/cpu.h>
  #include <asm/desc.h>
  #include <asm/dma.h>
  #include <asm/iommu.h>
@@@ -607,7 -607,7 +607,7 @@@ struct x86_quirks *x86_quirks __initdat
  static int __init dmi_low_memory_corruption(const struct dmi_system_id *d)
  {
        printk(KERN_NOTICE
-               "%s detected: BIOS may corrupt low RAM, working it around.\n",
+               "%s detected: BIOS may corrupt low RAM, working around it.\n",
                d->ident);
  
        e820_update_range(0, 0x10000, E820_RAM, E820_RESERVED);
diff --combined arch/x86/kernel/traps.c
@@@ -59,6 -59,7 +59,6 @@@
  #ifdef CONFIG_X86_64
  #include <asm/pgalloc.h>
  #include <asm/proto.h>
 -#include <asm/pda.h>
  #else
  #include <asm/processor-flags.h>
  #include <asm/arch_hooks.h>
@@@ -895,7 -896,7 +895,7 @@@ asmlinkage void math_state_restore(void
  EXPORT_SYMBOL_GPL(math_state_restore);
  
  #ifndef CONFIG_MATH_EMULATION
- asmlinkage void math_emulate(long arg)
+ void math_emulate(struct math_emu_info *info)
  {
        printk(KERN_EMERG
                "math-emulation not enabled and no coprocessor found.\n");
  }
  #endif /* CONFIG_MATH_EMULATION */
  
- dotraplinkage void __kprobes
- do_device_not_available(struct pt_regs *regs, long error)
+ dotraplinkage void __kprobes do_device_not_available(struct pt_regs regs)
  {
  #ifdef CONFIG_X86_32
        if (read_cr0() & X86_CR0_EM) {
-               conditional_sti(regs);
-               math_emulate(0);
+               struct math_emu_info info = { };
+               conditional_sti(&regs);
+               info.regs = &regs;
+               math_emulate(&info);
        } else {
                math_state_restore(); /* interrupts still off */
-               conditional_sti(regs);
+               conditional_sti(&regs);
        }
  #else
        math_state_restore();
@@@ -979,13 -983,8 +982,13 @@@ void __init trap_init(void
  #endif
        set_intr_gate(19, &simd_coprocessor_error);
  
 +      /* Reserve all the builtin and the syscall vector: */
 +      for (i = 0; i < FIRST_EXTERNAL_VECTOR; i++)
 +              set_bit(i, used_vectors);
 +
  #ifdef CONFIG_IA32_EMULATION
        set_system_intr_gate(IA32_SYSCALL_VECTOR, ia32_syscall);
 +      set_bit(IA32_SYSCALL_VECTOR, used_vectors);
  #endif
  
  #ifdef CONFIG_X86_32
        }
  
        set_system_trap_gate(SYSCALL_VECTOR, &system_call);
 -#endif
 -
 -      /* Reserve all the builtin and the syscall vector: */
 -      for (i = 0; i < FIRST_EXTERNAL_VECTOR; i++)
 -              set_bit(i, used_vectors);
 -
 -#ifdef CONFIG_X86_64
 -      set_bit(IA32_SYSCALL_VECTOR, used_vectors);
 -#else
        set_bit(SYSCALL_VECTOR, used_vectors);
  #endif
 +
        /*
         * Should be a barrier for any external CPU state:
         */
@@@ -48,12 -48,11 +48,11 @@@ extern struct fs_struct init_fs
        .posix_timers    = LIST_HEAD_INIT(sig.posix_timers),            \
        .cpu_timers     = INIT_CPU_TIMERS(sig.cpu_timers),              \
        .rlim           = INIT_RLIMITS,                                 \
-       .cputime        = { .totals = {                                 \
-               .utime = cputime_zero,                                  \
-               .stime = cputime_zero,                                  \
-               .sum_exec_runtime = 0,                                  \
-               .lock = __SPIN_LOCK_UNLOCKED(sig.cputime.totals.lock),  \
-       }, },                                                           \
+       .cputimer       = {                                             \
+               .cputime = INIT_CPUTIME,                                \
+               .running = 0,                                           \
+               .lock = __SPIN_LOCK_UNLOCKED(sig.cputimer.lock),        \
+       },                                                              \
  }
  
  extern struct nsproxy init_nsproxy;
@@@ -121,16 -120,6 +120,16 @@@ extern struct group_info init_groups
  
  extern struct cred init_cred;
  
 +#ifdef CONFIG_PERF_COUNTERS
 +# define INIT_PERF_COUNTERS(tsk)                                      \
 +      .perf_counter_ctx.counter_list =                                \
 +              LIST_HEAD_INIT(tsk.perf_counter_ctx.counter_list),      \
 +      .perf_counter_ctx.lock =                                        \
 +              __SPIN_LOCK_UNLOCKED(tsk.perf_counter_ctx.lock),
 +#else
 +# define INIT_PERF_COUNTERS(tsk)
 +#endif
 +
  /*
   *  INIT_TASK is used to set up the first task table, touch at
   * your own risk!. Base=0, limit=0x1fffff (=2MB)
        INIT_IDS                                                        \
        INIT_TRACE_IRQFLAGS                                             \
        INIT_LOCKDEP                                                    \
 +      INIT_PERF_COUNTERS(tsk)                                         \
  }
  
  
diff --combined include/linux/sched.h
@@@ -71,7 -71,6 +71,7 @@@ struct sched_param 
  #include <linux/fs_struct.h>
  #include <linux/compiler.h>
  #include <linux/completion.h>
 +#include <linux/perf_counter.h>
  #include <linux/pid.h>
  #include <linux/percpu.h>
  #include <linux/topology.h>
@@@ -137,8 -136,6 +137,8 @@@ extern unsigned long nr_running(void)
  extern unsigned long nr_uninterruptible(void);
  extern unsigned long nr_active(void);
  extern unsigned long nr_iowait(void);
 +extern u64 cpu_nr_switches(int cpu);
 +extern u64 cpu_nr_migrations(int cpu);
  
  struct seq_file;
  struct cfs_rq;
@@@ -446,7 -443,6 +446,6 @@@ struct pacct_struct 
   * @utime:            time spent in user mode, in &cputime_t units
   * @stime:            time spent in kernel mode, in &cputime_t units
   * @sum_exec_runtime: total time spent on the CPU, in nanoseconds
-  * @lock:             lock for fields in this struct
   *
   * This structure groups together three kinds of CPU time that are
   * tracked for threads and thread groups.  Most things considering
@@@ -457,23 -453,33 +456,33 @@@ struct task_cputime 
        cputime_t utime;
        cputime_t stime;
        unsigned long long sum_exec_runtime;
-       spinlock_t lock;
  };
  /* Alternate field names when used to cache expirations. */
  #define prof_exp      stime
  #define virt_exp      utime
  #define sched_exp     sum_exec_runtime
  
+ #define INIT_CPUTIME  \
+       (struct task_cputime) {                                 \
+               .utime = cputime_zero,                          \
+               .stime = cputime_zero,                          \
+               .sum_exec_runtime = 0,                          \
+       }
  /**
-  * struct thread_group_cputime - thread group interval timer counts
-  * @totals:           thread group interval timers; substructure for
-  *                    uniprocessor kernel, per-cpu for SMP kernel.
+  * struct thread_group_cputimer - thread group interval timer counts
+  * @cputime:          thread group interval timers.
+  * @running:          non-zero when there are timers running and
+  *                    @cputime receives updates.
+  * @lock:             lock for fields in this struct.
   *
   * This structure contains the version of task_cputime, above, that is
-  * used for thread group CPU clock calculations.
+  * used for thread group CPU timer calculations.
   */
- struct thread_group_cputime {
-       struct task_cputime totals;
+ struct thread_group_cputimer {
+       struct task_cputime cputime;
+       int running;
+       spinlock_t lock;
  };
  
  /*
@@@ -522,10 -528,10 +531,10 @@@ struct signal_struct 
        cputime_t it_prof_incr, it_virt_incr;
  
        /*
-        * Thread group totals for process CPU clocks.
-        * See thread_group_cputime(), et al, for details.
+        * Thread group totals for process CPU timers.
+        * See thread_group_cputimer(), et al, for details.
         */
-       struct thread_group_cputime cputime;
+       struct thread_group_cputimer cputimer;
  
        /* Earliest-expiration cache. */
        struct task_cputime cputime_expires;
         * Live threads maintain their own counters and add to these
         * in __exit_signal, except for the group leader.
         */
-       cputime_t cutime, cstime;
+       cputime_t utime, stime, cutime, cstime;
        cputime_t gtime;
        cputime_t cgtime;
        unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
        struct task_io_accounting ioac;
  
        /*
+        * Cumulative ns of schedule CPU time fo dead threads in the
+        * group, not including a zombie group leader, (This only differs
+        * from jiffies_to_ns(utime + stime) if sched_clock uses something
+        * other than jiffies.)
+        */
+       unsigned long long sum_sched_runtime;
+       /*
         * We don't bother to synchronize most readers of this at all,
         * because there is no reader checking a limit that actually needs
         * to get both rlim_cur and rlim_max atomically, and either one
@@@ -1038,8 -1052,6 +1055,8 @@@ struct sched_entity 
        u64                     last_wakeup;
        u64                     avg_overlap;
  
 +      u64                     nr_migrations;
 +
  #ifdef CONFIG_SCHEDSTATS
        u64                     wait_start;
        u64                     wait_max;
        u64                     exec_max;
        u64                     slice_max;
  
 -      u64                     nr_migrations;
        u64                     nr_migrations_cold;
        u64                     nr_failed_migrations_affine;
        u64                     nr_failed_migrations_running;
@@@ -1165,9 -1178,10 +1182,9 @@@ struct task_struct 
        pid_t pid;
        pid_t tgid;
  
 -#ifdef CONFIG_CC_STACKPROTECTOR
        /* Canary value for the -fstack-protector gcc feature */
        unsigned long stack_canary;
 -#endif
 +
        /* 
         * pointers to (original) parent process, youngest child, younger sibling,
         * older sibling, respectively.  (p->father can be replaced with 
        struct list_head pi_state_list;
        struct futex_pi_state *pi_state_cache;
  #endif
 +      struct perf_counter_context perf_counter_ctx;
  #ifdef CONFIG_NUMA
        struct mempolicy *mempolicy;
        short il_next;
@@@ -2074,19 -2087,6 +2091,19 @@@ static inline int object_is_on_stack(vo
  
  extern void thread_info_cache_init(void);
  
 +#ifdef CONFIG_DEBUG_STACK_USAGE
 +static inline unsigned long stack_not_used(struct task_struct *p)
 +{
 +      unsigned long *n = end_of_stack(p);
 +
 +      do {    /* Skip over canary */
 +              n++;
 +      } while (!*n);
 +
 +      return (unsigned long)n - (unsigned long)end_of_stack(p);
 +}
 +#endif
 +
  /* set thread flags in other task's structures
   * - see asm/thread_info.h for TIF_xxxx flags available
   */
@@@ -2200,27 -2200,14 +2217,14 @@@ static inline int spin_needbreak(spinlo
  /*
   * Thread group CPU time accounting.
   */
- static inline
- void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times)
- {
-       struct task_cputime *totals = &tsk->signal->cputime.totals;
-       unsigned long flags;
-       spin_lock_irqsave(&totals->lock, flags);
-       *times = *totals;
-       spin_unlock_irqrestore(&totals->lock, flags);
- }
+ void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times);
+ void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times);
  
  static inline void thread_group_cputime_init(struct signal_struct *sig)
  {
-       sig->cputime.totals = (struct task_cputime){
-               .utime = cputime_zero,
-               .stime = cputime_zero,
-               .sum_exec_runtime = 0,
-       };
-       spin_lock_init(&sig->cputime.totals.lock);
+       sig->cputimer.cputime = INIT_CPUTIME;
+       spin_lock_init(&sig->cputimer.lock);
+       sig->cputimer.running = 0;
  }
  
  static inline void thread_group_cputime_free(struct signal_struct *sig)
@@@ -2349,13 -2336,6 +2353,13 @@@ static inline void inc_syscw(struct tas
  #define TASK_SIZE_OF(tsk)     TASK_SIZE
  #endif
  
 +/*
 + * Call the function if the target task is executing on a CPU right now:
 + */
 +extern void task_oncpu_function_call(struct task_struct *p,
 +                                   void (*func) (void *info), void *info);
 +
 +
  #ifdef CONFIG_MM_OWNER
  extern void mm_update_next_owner(struct mm_struct *mm);
  extern void mm_init_owner(struct mm_struct *mm, struct task_struct *p);
diff --combined include/linux/syscalls.h
@@@ -55,7 -55,6 +55,7 @@@ struct compat_timeval
  struct robust_list_head;
  struct getcpu_cache;
  struct old_linux_dirent;
 +struct perf_counter_hw_event;
  
  #include <linux/types.h>
  #include <linux/aio_abi.h>
  #define __SC_TEST5(t5, a5, ...)       __SC_TEST(t5); __SC_TEST4(__VA_ARGS__)
  #define __SC_TEST6(t6, a6, ...)       __SC_TEST(t6); __SC_TEST5(__VA_ARGS__)
  
- #define SYSCALL_DEFINE0(name)   asmlinkage long sys_##name(void)
- #define SYSCALL_DEFINE1(...)    SYSCALL_DEFINEx(1, __VA_ARGS__)
- #define SYSCALL_DEFINE2(...)    SYSCALL_DEFINEx(2, __VA_ARGS__)
- #define SYSCALL_DEFINE3(...)    SYSCALL_DEFINEx(3, __VA_ARGS__)
- #define SYSCALL_DEFINE4(...)    SYSCALL_DEFINEx(4, __VA_ARGS__)
- #define SYSCALL_DEFINE5(...)    SYSCALL_DEFINEx(5, __VA_ARGS__)
- #define SYSCALL_DEFINE6(...)    SYSCALL_DEFINEx(6, __VA_ARGS__)
+ #define SYSCALL_DEFINE0(name)    asmlinkage long sys_##name(void)
+ #define SYSCALL_DEFINE1(name, ...) SYSCALL_DEFINEx(1, _##name, __VA_ARGS__)
+ #define SYSCALL_DEFINE2(name, ...) SYSCALL_DEFINEx(2, _##name, __VA_ARGS__)
+ #define SYSCALL_DEFINE3(name, ...) SYSCALL_DEFINEx(3, _##name, __VA_ARGS__)
+ #define SYSCALL_DEFINE4(name, ...) SYSCALL_DEFINEx(4, _##name, __VA_ARGS__)
+ #define SYSCALL_DEFINE5(name, ...) SYSCALL_DEFINEx(5, _##name, __VA_ARGS__)
+ #define SYSCALL_DEFINE6(name, ...) SYSCALL_DEFINEx(6, _##name, __VA_ARGS__)
  
  #ifdef CONFIG_PPC64
  #define SYSCALL_ALIAS(alias, name)                                    \
  
  #define SYSCALL_DEFINE(name) static inline long SYSC_##name
  #define SYSCALL_DEFINEx(x, name, ...)                                 \
-       asmlinkage long sys_##name(__SC_DECL##x(__VA_ARGS__));          \
-       static inline long SYSC_##name(__SC_DECL##x(__VA_ARGS__));      \
-       asmlinkage long SyS_##name(__SC_LONG##x(__VA_ARGS__))           \
+       asmlinkage long sys##name(__SC_DECL##x(__VA_ARGS__));           \
+       static inline long SYSC##name(__SC_DECL##x(__VA_ARGS__));       \
+       asmlinkage long SyS##name(__SC_LONG##x(__VA_ARGS__))            \
        {                                                               \
                __SC_TEST##x(__VA_ARGS__);                              \
-               return (long) SYSC_##name(__SC_CAST##x(__VA_ARGS__));   \
+               return (long) SYSC##name(__SC_CAST##x(__VA_ARGS__));    \
        }                                                               \
-       SYSCALL_ALIAS(sys_##name, SyS_##name);                          \
-       static inline long SYSC_##name(__SC_DECL##x(__VA_ARGS__))
+       SYSCALL_ALIAS(sys##name, SyS##name);                            \
+       static inline long SYSC##name(__SC_DECL##x(__VA_ARGS__))
  
  #else /* CONFIG_HAVE_SYSCALL_WRAPPERS */
  
  #define SYSCALL_DEFINE(name) asmlinkage long sys_##name
  #define SYSCALL_DEFINEx(x, name, ...)                                 \
-       asmlinkage long sys_##name(__SC_DECL##x(__VA_ARGS__))
+       asmlinkage long sys##name(__SC_DECL##x(__VA_ARGS__))
  
  #endif /* CONFIG_HAVE_SYSCALL_WRAPPERS */
  
@@@ -695,11 -694,4 +695,11 @@@ asmlinkage long sys_pipe(int __user *)
  
  int kernel_execve(const char *filename, char *const argv[], char *const envp[]);
  
 +
 +asmlinkage int sys_perf_counter_open(
 +
 +      struct perf_counter_hw_event    *hw_event_uptr          __user,
 +      pid_t                           pid,
 +      int                             cpu,
 +      int                             group_fd);
  #endif
diff --combined kernel/exit.c
@@@ -118,6 -118,8 +118,8 @@@ static void __exit_signal(struct task_s
                 * We won't ever get here for the group leader, since it
                 * will have been the last reference on the signal_struct.
                 */
+               sig->utime = cputime_add(sig->utime, task_utime(tsk));
+               sig->stime = cputime_add(sig->stime, task_stime(tsk));
                sig->gtime = cputime_add(sig->gtime, task_gtime(tsk));
                sig->min_flt += tsk->min_flt;
                sig->maj_flt += tsk->maj_flt;
                sig->inblock += task_io_get_inblock(tsk);
                sig->oublock += task_io_get_oublock(tsk);
                task_io_accounting_add(&sig->ioac, &tsk->ioac);
+               sig->sum_sched_runtime += tsk->se.sum_exec_runtime;
                sig = NULL; /* Marker for below. */
        }
  
@@@ -159,9 -162,6 +162,9 @@@ static void delayed_put_task_struct(str
  {
        struct task_struct *tsk = container_of(rhp, struct task_struct, rcu);
  
 +#ifdef CONFIG_PERF_COUNTERS
 +      WARN_ON_ONCE(!list_empty(&tsk->perf_counter_ctx.counter_list));
 +#endif
        trace_sched_process_free(tsk);
        put_task_struct(tsk);
  }
@@@ -980,9 -980,12 +983,9 @@@ static void check_stack_usage(void
  {
        static DEFINE_SPINLOCK(low_water_lock);
        static int lowest_to_date = THREAD_SIZE;
 -      unsigned long *n = end_of_stack(current);
        unsigned long free;
  
 -      while (*n == 0)
 -              n++;
 -      free = (unsigned long)n - (unsigned long)end_of_stack(current);
 +      free = stack_not_used(current);
  
        if (free >= lowest_to_date)
                return;
@@@ -1093,6 -1096,10 +1096,6 @@@ NORET_TYPE void do_exit(long code
        tsk->mempolicy = NULL;
  #endif
  #ifdef CONFIG_FUTEX
 -      /*
 -       * This must happen late, after the PID is not
 -       * hashed anymore:
 -       */
        if (unlikely(!list_empty(&tsk->pi_state_list)))
                exit_pi_state_list(tsk);
        if (unlikely(current->pi_state_cache))
@@@ -1359,12 -1366,6 +1362,12 @@@ static int wait_task_zombie(struct task
         */
        read_unlock(&tasklist_lock);
  
 +      /*
 +       * Flush inherited counters to the parent - before the parent
 +       * gets woken up by child-exit notifications.
 +       */
 +      perf_counter_exit_task(p);
 +
        retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0;
        status = (p->signal->flags & SIGNAL_GROUP_EXIT)
                ? p->signal->group_exit_code : p->exit_code;
diff --combined kernel/fork.c
@@@ -61,7 -61,6 +61,7 @@@
  #include <linux/proc_fs.h>
  #include <linux/blkdev.h>
  #include <trace/sched.h>
 +#include <linux/magic.h>
  
  #include <asm/pgtable.h>
  #include <asm/pgalloc.h>
@@@ -213,8 -212,6 +213,8 @@@ static struct task_struct *dup_task_str
  {
        struct task_struct *tsk;
        struct thread_info *ti;
 +      unsigned long *stackend;
 +
        int err;
  
        prepare_to_copy(orig);
                goto out;
  
        setup_thread_stack(tsk, orig);
 +      stackend = end_of_stack(tsk);
 +      *stackend = STACK_END_MAGIC;    /* for overflow detection */
  
  #ifdef CONFIG_CC_STACKPROTECTOR
        tsk->stack_canary = get_random_int();
@@@ -856,13 -851,14 +856,14 @@@ static int copy_signal(unsigned long cl
        sig->tty_old_pgrp = NULL;
        sig->tty = NULL;
  
-       sig->cutime = sig->cstime = cputime_zero;
+       sig->utime = sig->stime = sig->cutime = sig->cstime = cputime_zero;
        sig->gtime = cputime_zero;
        sig->cgtime = cputime_zero;
        sig->nvcsw = sig->nivcsw = sig->cnvcsw = sig->cnivcsw = 0;
        sig->min_flt = sig->maj_flt = sig->cmin_flt = sig->cmaj_flt = 0;
        sig->inblock = sig->oublock = sig->cinblock = sig->coublock = 0;
        task_io_accounting_init(&sig->ioac);
+       sig->sum_sched_runtime = 0;
        taskstats_tgid_init(sig);
  
        task_lock(current->group_leader);
@@@ -988,7 -984,6 +989,7 @@@ static struct task_struct *copy_process
                goto fork_out;
  
        rt_mutex_init_task(p);
 +      perf_counter_init_task(p);
  
  #ifdef CONFIG_PROVE_LOCKING
        DEBUG_LOCKS_WARN_ON(!p->hardirqs_enabled);
  #ifdef CONFIG_DEBUG_MUTEXES
        p->blocked_on = NULL; /* not blocked yet */
  #endif
-       if (unlikely(ptrace_reparented(current)))
+       if (unlikely(current->ptrace))
                ptrace_fork(p, clone_flags);
  
        /* Perform scheduler related setup. Assign this task to a CPU. */
diff --combined kernel/sched.c
@@@ -558,7 -558,6 +558,7 @@@ struct rq 
        struct load_weight load;
        unsigned long nr_load_updates;
        u64 nr_switches;
 +      u64 nr_migrations_in;
  
        struct cfs_rq cfs;
        struct rt_rq rt;
@@@ -669,7 -668,7 +669,7 @@@ static inline int cpu_of(struct rq *rq
  #define task_rq(p)            cpu_rq(task_cpu(p))
  #define cpu_curr(cpu)         (cpu_rq(cpu)->curr)
  
 -static inline void update_rq_clock(struct rq *rq)
 +inline void update_rq_clock(struct rq *rq)
  {
        rq->clock = sched_clock_cpu(cpu_of(rq));
  }
@@@ -980,26 -979,6 +980,26 @@@ static struct rq *task_rq_lock(struct t
        }
  }
  
 +void curr_rq_lock_irq_save(unsigned long *flags)
 +      __acquires(rq->lock)
 +{
 +      struct rq *rq;
 +
 +      local_irq_save(*flags);
 +      rq = cpu_rq(smp_processor_id());
 +      spin_lock(&rq->lock);
 +}
 +
 +void curr_rq_unlock_irq_restore(unsigned long *flags)
 +      __releases(rq->lock)
 +{
 +      struct rq *rq;
 +
 +      rq = cpu_rq(smp_processor_id());
 +      spin_unlock(&rq->lock);
 +      local_irq_restore(*flags);
 +}
 +
  void task_rq_unlock_wait(struct task_struct *p)
  {
        struct rq *rq = task_rq(p);
@@@ -1906,15 -1885,12 +1906,15 @@@ void set_task_cpu(struct task_struct *p
                p->se.sleep_start -= clock_offset;
        if (p->se.block_start)
                p->se.block_start -= clock_offset;
 +#endif
        if (old_cpu != new_cpu) {
 -              schedstat_inc(p, se.nr_migrations);
 +              p->se.nr_migrations++;
 +              new_rq->nr_migrations_in++;
 +#ifdef CONFIG_SCHEDSTATS
                if (task_hot(p, old_rq->clock, NULL))
                        schedstat_inc(p, se.nr_forced2_migrations);
 -      }
  #endif
 +      }
        p->se.vruntime -= old_cfsrq->min_vruntime -
                                         new_cfsrq->min_vruntime;
  
@@@ -2266,27 -2242,6 +2266,27 @@@ static int sched_balance_self(int cpu, 
  
  #endif /* CONFIG_SMP */
  
 +/**
 + * task_oncpu_function_call - call a function on the cpu on which a task runs
 + * @p:                the task to evaluate
 + * @func:     the function to be called
 + * @info:     the function call argument
 + *
 + * Calls the function @func when the task is currently running. This might
 + * be on the current CPU, which just calls the function directly
 + */
 +void task_oncpu_function_call(struct task_struct *p,
 +                            void (*func) (void *info), void *info)
 +{
 +      int cpu;
 +
 +      preempt_disable();
 +      cpu = task_cpu(p);
 +      if (task_curr(p))
 +              smp_call_function_single(cpu, func, info, 1);
 +      preempt_enable();
 +}
 +
  /***
   * try_to_wake_up - wake up a thread
   * @p: the to-be-woken-up thread
@@@ -2311,16 -2266,6 +2311,6 @@@ static int try_to_wake_up(struct task_s
        if (!sched_feat(SYNC_WAKEUPS))
                sync = 0;
  
-       if (!sync) {
-               if (current->se.avg_overlap < sysctl_sched_migration_cost &&
-                         p->se.avg_overlap < sysctl_sched_migration_cost)
-                       sync = 1;
-       } else {
-               if (current->se.avg_overlap >= sysctl_sched_migration_cost ||
-                         p->se.avg_overlap >= sysctl_sched_migration_cost)
-                       sync = 0;
-       }
  #ifdef CONFIG_SMP
        if (sched_feat(LB_WAKEUP_UPDATE)) {
                struct sched_domain *sd;
@@@ -2439,7 -2384,6 +2429,7 @@@ static void __sched_fork(struct task_st
        p->se.exec_start                = 0;
        p->se.sum_exec_runtime          = 0;
        p->se.prev_sum_exec_runtime     = 0;
 +      p->se.nr_migrations             = 0;
        p->se.last_wakeup               = 0;
        p->se.avg_overlap               = 0;
  
@@@ -2660,7 -2604,6 +2650,7 @@@ static void finish_task_switch(struct r
         */
        prev_state = prev->state;
        finish_arch_switch(prev);
 +      perf_counter_task_sched_in(current, cpu_of(rq));
        finish_lock_switch(rq, prev);
  #ifdef CONFIG_SMP
        if (current->sched_class->post_schedule)
@@@ -2823,21 -2766,6 +2813,21 @@@ unsigned long nr_active(void
  }
  
  /*
 + * Externally visible per-cpu scheduler statistics:
 + * cpu_nr_switches(cpu) - number of context switches on that cpu
 + * cpu_nr_migrations(cpu) - number of migrations into that cpu
 + */
 +u64 cpu_nr_switches(int cpu)
 +{
 +      return cpu_rq(cpu)->nr_switches;
 +}
 +
 +u64 cpu_nr_migrations(int cpu)
 +{
 +      return cpu_rq(cpu)->nr_migrations_in;
 +}
 +
 +/*
   * Update rq->cpu_load[] statistics. This function is usually called every
   * scheduler tick (TICK_NSEC).
   */
@@@ -3952,19 -3880,24 +3942,24 @@@ int select_nohz_load_balancer(int stop_
        int cpu = smp_processor_id();
  
        if (stop_tick) {
-               cpumask_set_cpu(cpu, nohz.cpu_mask);
                cpu_rq(cpu)->in_nohz_recently = 1;
  
-               /*
-                * If we are going offline and still the leader, give up!
-                */
-               if (!cpu_active(cpu) &&
-                   atomic_read(&nohz.load_balancer) == cpu) {
+               if (!cpu_active(cpu)) {
+                       if (atomic_read(&nohz.load_balancer) != cpu)
+                               return 0;
+                       /*
+                        * If we are going offline and still the leader,
+                        * give up!
+                        */
                        if (atomic_cmpxchg(&nohz.load_balancer, cpu, -1) != cpu)
                                BUG();
                        return 0;
                }
  
+               cpumask_set_cpu(cpu, nohz.cpu_mask);
                /* time for ilb owner also to sleep */
                if (cpumask_weight(nohz.cpu_mask) == num_online_cpus()) {
                        if (atomic_read(&nohz.load_balancer) == cpu)
@@@ -4204,29 -4137,6 +4199,29 @@@ EXPORT_PER_CPU_SYMBOL(kstat)
   * Return any ns on the sched_clock that have not yet been banked in
   * @p in case that task is currently running.
   */
 +unsigned long long __task_delta_exec(struct task_struct *p, int update)
 +{
 +      s64 delta_exec;
 +      struct rq *rq;
 +
 +      rq = task_rq(p);
 +      WARN_ON_ONCE(!runqueue_is_locked());
 +      WARN_ON_ONCE(!task_current(rq, p));
 +
 +      if (update)
 +              update_rq_clock(rq);
 +
 +      delta_exec = rq->clock - p->se.exec_start;
 +
 +      WARN_ON_ONCE(delta_exec < 0);
 +
 +      return delta_exec;
 +}
 +
 +/*
 + * Return any ns on the sched_clock that have not yet been banked in
 + * @p in case that task is currently running.
 + */
  unsigned long long task_delta_exec(struct task_struct *p)
  {
        unsigned long flags;
@@@ -4486,7 -4396,6 +4481,7 @@@ void scheduler_tick(void
        update_rq_clock(rq);
        update_cpu_load(rq);
        curr->sched_class->task_tick(rq, curr, 0);
 +      perf_counter_task_tick(curr, cpu);
        spin_unlock(&rq->lock);
  
  #ifdef CONFIG_SMP
@@@ -4682,7 -4591,6 +4677,7 @@@ need_resched_nonpreemptible
  
        if (likely(prev != next)) {
                sched_info_switch(prev, next);
 +              perf_counter_task_sched_out(prev, cpu);
  
                rq->nr_switches++;
                rq->curr = next;
@@@ -6036,7 -5944,12 +6031,7 @@@ void sched_show_task(struct task_struc
                printk(KERN_CONT " %016lx ", thread_saved_pc(p));
  #endif
  #ifdef CONFIG_DEBUG_STACK_USAGE
 -      {
 -              unsigned long *n = end_of_stack(p);
 -              while (!*n)
 -                      n++;
 -              free = (unsigned long)n - (unsigned long)end_of_stack(p);
 -      }
 +      free = stack_not_used(p);
  #endif
        printk(KERN_CONT "%5lu %5d %6d\n", free,
                task_pid_nr(p), task_pid_nr(p->real_parent));