Merge branch 'linus' into tracing/mmiotrace-mergefixups

50 files changed, 350 insertions, 191 deletions

diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index fc86c54e791e..b0937c03af3c 100644
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -28,17 +28,10 @@ config X86
         select HAVE_KVM if ((X86_32 && !X86_VOYAGER && !X86_VISWS && !X86_NUMAQ) || X86_64)
         select HAVE_ARCH_KGDB if !X86_VOYAGER
 
-config DEFCONFIG_LIST
+config ARCH_DEFCONFIG
         string
-        depends on X86_32
-        option defconfig_list
-        default "arch/x86/configs/i386_defconfig"
-
-config DEFCONFIG_LIST
-        string
-        depends on X86_64
-        option defconfig_list
-        default "arch/x86/configs/x86_64_defconfig"
+        default "arch/x86/configs/i386_defconfig" if X86_32
+        default "arch/x86/configs/x86_64_defconfig" if X86_64
 
 
 config GENERIC_LOCKBREAK
@@ -1517,13 +1510,13 @@ config PCI_GOMMCONFIG
 config PCI_GODIRECT
         bool "Direct"
 
-config PCI_GOANY
-        bool "Any"
-
 config PCI_GOOLPC
         bool "OLPC"
         depends on OLPC
 
+config PCI_GOANY
+        bool "Any"
+
 endchoice
 
 config PCI_BIOS
@@ -1540,9 +1533,8 @@ config PCI_MMCONFIG
         depends on X86_32 && PCI && ACPI && (PCI_GOMMCONFIG || PCI_GOANY)
 
 config PCI_OLPC
-        bool
-        depends on PCI && PCI_GOOLPC
-        default y
+        def_bool y
+        depends on PCI && OLPC && (PCI_GOOLPC || PCI_GOANY)
 
 config PCI_DOMAINS
         def_bool y
diff --git a/arch/x86/Kconfig.debug b/arch/x86/Kconfig.debug
index 1e53df0ba08c..f7169edfbeab 100644
--- a/arch/x86/Kconfig.debug
+++ b/arch/x86/Kconfig.debug
@@ -6,15 +6,19 @@ config TRACE_IRQFLAGS_SUPPORT
 source "lib/Kconfig.debug"
 
 config NONPROMISC_DEVMEM
-        bool "Disable promiscuous /dev/mem"
+        bool "Filter access to /dev/mem"
         help
-          The /dev/mem file by default only allows userspace access to PCI
-          space and the BIOS code and data regions. This is sufficient for
-          dosemu and X and all common users of /dev/mem. With this config
-          option, you allow userspace access to all of memory, including
-          kernel and userspace memory. Accidental access to this is
-          obviously disasterous, but specific access can be used by people
-          debugging the kernel.
+          If this option is left off, you allow userspace access to all
+          of memory, including kernel and userspace memory. Accidental
+          access to this is obviously disastrous, but specific access can
+          be used by people debugging the kernel.
+
+          If this option is switched on, the /dev/mem file only allows
+          userspace access to PCI space and the BIOS code and data regions.
+          This is sufficient for dosemu and X and all common users of
+          /dev/mem.
+
+          If in doubt, say Y.
 
 config EARLY_PRINTK
         bool "Early printk" if EMBEDDED
diff --git a/arch/x86/boot/a20.c b/arch/x86/boot/a20.c
index 90943f83e84d..e01aafd03bde 100644
--- a/arch/x86/boot/a20.c
+++ b/arch/x86/boot/a20.c
@@ -115,8 +115,6 @@ static void enable_a20_fast(void)
 
 int enable_a20(void)
 {
-        int loops = A20_ENABLE_LOOPS;
-
 #if defined(CONFIG_X86_ELAN)
         /* Elan croaks if we try to touch the KBC */
         enable_a20_fast();
@@ -128,6 +126,7 @@ int enable_a20(void)
         enable_a20_kbc();
         return 0;
 #else
+       int loops = A20_ENABLE_LOOPS;
         while (loops--) {
                 /* First, check to see if A20 is already enabled
                    (legacy free, etc.) */
diff --git a/arch/x86/boot/printf.c b/arch/x86/boot/printf.c
index c1d00c0274c4..50e47cdbdddd 100644
--- a/arch/x86/boot/printf.c
+++ b/arch/x86/boot/printf.c
@@ -56,7 +56,7 @@ static char *number(char *str, long num, int base, int size, int precision,
         if (type & LEFT)
                 type &= ~ZEROPAD;
         if (base < 2 || base > 36)
-                return 0;
+                return NULL;
         c = (type & ZEROPAD) ? '0' : ' ';
         sign = 0;
         if (type & SIGN) {
diff --git a/arch/x86/kernel/acpi/boot.c b/arch/x86/kernel/acpi/boot.c
index c49ebcc6c41e..33c5216fd3e1 100644
--- a/arch/x86/kernel/acpi/boot.c
+++ b/arch/x86/kernel/acpi/boot.c
@@ -242,12 +242,19 @@ static int __init acpi_parse_madt(struct acpi_table_header *table)
 
 static void __cpuinit acpi_register_lapic(int id, u8 enabled)
 {
+        unsigned int ver = 0;
+
         if (!enabled) {
                 ++disabled_cpus;
                 return;
         }
 
-        generic_processor_info(id, 0);
+#ifdef CONFIG_X86_32
+        if (boot_cpu_physical_apicid != -1U)
+                ver = apic_version[boot_cpu_physical_apicid];
+#endif
+
+        generic_processor_info(id, ver);
 }
 
 static int __init
@@ -767,8 +774,13 @@ static void __init acpi_register_lapic_address(unsigned long address)
         mp_lapic_addr = address;
 
         set_fixmap_nocache(FIX_APIC_BASE, address);
-        if (boot_cpu_physical_apicid == -1U)
+        if (boot_cpu_physical_apicid == -1U) {
                 boot_cpu_physical_apicid  = GET_APIC_ID(read_apic_id());
+#ifdef CONFIG_X86_32
+                apic_version[boot_cpu_physical_apicid] =
+                         GET_APIC_VERSION(apic_read(APIC_LVR));
+#endif
+        }
 }
 
 static int __init early_acpi_parse_madt_lapic_addr_ovr(void)
diff --git a/arch/x86/kernel/apic_64.c b/arch/x86/kernel/apic_64.c
index 5910020c3f24..0633cfd0dc29 100644
--- a/arch/x86/kernel/apic_64.c
+++ b/arch/x86/kernel/apic_64.c
@@ -534,7 +534,7 @@ int setup_profiling_timer(unsigned int multiplier)
  */
 void clear_local_APIC(void)
 {
-        int maxlvt = lapic_get_maxlvt();
+        int maxlvt;
         u32 v;
 
         /* APIC hasn't been mapped yet */
diff --git a/arch/x86/kernel/cpu/cpufreq/longrun.c b/arch/x86/kernel/cpu/cpufreq/longrun.c
index af4a867a097c..777a7ff075de 100644
--- a/arch/x86/kernel/cpu/cpufreq/longrun.c
+++ b/arch/x86/kernel/cpu/cpufreq/longrun.c
@@ -245,7 +245,7 @@ static unsigned int __init longrun_determine_freqs(unsigned int *low_freq,
         if ((ecx > 95) || (ecx == 0) || (eax < ebx))
                 return -EIO;
 
-        edx = (eax - ebx) / (100 - ecx);
+        edx = ((eax - ebx) * 100) / (100 - ecx);
         *low_freq = edx * 1000; /* back to kHz */
 
         dprintk("low frequency is %u kHz\n", *low_freq);
diff --git a/arch/x86/kernel/cpu/cpufreq/powernow-k8.c b/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
index 46d4034d9f37..206791eb46e3 100644
--- a/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
+++ b/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
@@ -1127,12 +1127,23 @@ static int __cpuinit powernowk8_cpu_init(struct cpufreq_policy *pol)
                  * an UP version, and is deprecated by AMD.
                  */
                 if (num_online_cpus() != 1) {
-                        printk(KERN_ERR PFX "MP systems not supported by PSB BIOS structure\n");
+#ifndef CONFIG_ACPI_PROCESSOR
+                        printk(KERN_ERR PFX "ACPI Processor support is required "
+                               "for SMP systems but is absent. Please load the "
+                               "ACPI Processor module before starting this "
+                               "driver.\n");
+#else
+                        printk(KERN_ERR PFX "Your BIOS does not provide ACPI "
+                               "_PSS objects in a way that Linux understands. "
+                               "Please report this to the Linux ACPI maintainers"
+                               " and complain to your BIOS vendor.\n");
+#endif
                         kfree(data);
                         return -ENODEV;
                 }
                 if (pol->cpu != 0) {
-                        printk(KERN_ERR PFX "No _PSS objects for CPU other than CPU0\n");
+                        printk(KERN_ERR PFX "No ACPI _PSS objects for CPU other than "
+                               "CPU0. Complain to your BIOS vendor.\n");
                         kfree(data);
                         return -ENODEV;
                 }
diff --git a/arch/x86/kernel/entry_32.S b/arch/x86/kernel/entry_32.S
index e6517ce0b824..04ea83ccb979 100644
--- a/arch/x86/kernel/entry_32.S
+++ b/arch/x86/kernel/entry_32.S
@@ -248,6 +248,7 @@ ENTRY(resume_userspace)
         DISABLE_INTERRUPTS(CLBR_ANY)    # make sure we don't miss an interrupt
                                         # setting need_resched or sigpending
                                         # between sampling and the iret
+        TRACE_IRQS_OFF
         movl TI_flags(%ebp), %ecx
         andl $_TIF_WORK_MASK, %ecx      # is there any work to be done on
                                         # int/exception return?
diff --git a/arch/x86/kernel/head_32.S b/arch/x86/kernel/head_32.S
index b2cc73768a9d..f7357cc0162c 100644
--- a/arch/x86/kernel/head_32.S
+++ b/arch/x86/kernel/head_32.S
@@ -189,7 +189,7 @@ default_entry:
          * this stage.
          */
 
-#define KPMDS ((0x100000000-__PAGE_OFFSET) >> 30) /* Number of kernel PMDs */
+#define KPMDS (((-__PAGE_OFFSET) >> 30) & 3) /* Number of kernel PMDs */
 
         xorl %ebx,%ebx                          /* %ebx is kept at zero */
 
diff --git a/arch/x86/kernel/i387.c b/arch/x86/kernel/i387.c
index e03cc952f233..eb9ddd8efb82 100644
--- a/arch/x86/kernel/i387.c
+++ b/arch/x86/kernel/i387.c
@@ -56,6 +56,11 @@ void __cpuinit mxcsr_feature_mask_init(void)
 
 void __init init_thread_xstate(void)
 {
+        if (!HAVE_HWFP) {
+                xstate_size = sizeof(struct i387_soft_struct);
+                return;
+        }
+
         if (cpu_has_fxsr)
                 xstate_size = sizeof(struct i387_fxsave_struct);
 #ifdef CONFIG_X86_32
@@ -94,7 +99,7 @@ void __cpuinit fpu_init(void)
 int init_fpu(struct task_struct *tsk)
 {
         if (tsk_used_math(tsk)) {
-                if (tsk == current)
+                if (HAVE_HWFP && tsk == current)
                         unlazy_fpu(tsk);
                 return 0;
         }
@@ -109,6 +114,15 @@ int init_fpu(struct task_struct *tsk)
                         return -ENOMEM;
         }
 
+#ifdef CONFIG_X86_32
+        if (!HAVE_HWFP) {
+                memset(tsk->thread.xstate, 0, xstate_size);
+                finit();
+                set_stopped_child_used_math(tsk);
+                return 0;
+        }
+#endif
+
         if (cpu_has_fxsr) {
                 struct i387_fxsave_struct *fx = &tsk->thread.xstate->fxsave;
 
@@ -330,13 +344,13 @@ int fpregs_get(struct task_struct *target, const struct user_regset *regset,
         struct user_i387_ia32_struct env;
         int ret;
 
-        if (!HAVE_HWFP)
-                return fpregs_soft_get(target, regset, pos, count, kbuf, ubuf);
-
         ret = init_fpu(target);
         if (ret)
                 return ret;
 
+        if (!HAVE_HWFP)
+                return fpregs_soft_get(target, regset, pos, count, kbuf, ubuf);
+
         if (!cpu_has_fxsr) {
                 return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
                                            &target->thread.xstate->fsave, 0,
@@ -360,15 +374,15 @@ int fpregs_set(struct task_struct *target, const struct user_regset *regset,
         struct user_i387_ia32_struct env;
         int ret;
 
-        if (!HAVE_HWFP)
-                return fpregs_soft_set(target, regset, pos, count, kbuf, ubuf);
-
         ret = init_fpu(target);
         if (ret)
                 return ret;
 
         set_stopped_child_used_math(target);
 
+        if (!HAVE_HWFP)
+                return fpregs_soft_set(target, regset, pos, count, kbuf, ubuf);
+
         if (!cpu_has_fxsr) {
                 return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
                                           &target->thread.xstate->fsave, 0, -1);
@@ -474,18 +488,18 @@ static int restore_i387_fxsave(struct _fpstate_ia32 __user *buf)
 int restore_i387_ia32(struct _fpstate_ia32 __user *buf)
 {
         int err;
+        struct task_struct *tsk = current;
 
-        if (HAVE_HWFP) {
-                struct task_struct *tsk = current;
-
+        if (HAVE_HWFP)
                 clear_fpu(tsk);
 
-                if (!used_math()) {
-                        err = init_fpu(tsk);
-                        if (err)
-                                return err;
-                }
+        if (!used_math()) {
+                err = init_fpu(tsk);
+                if (err)
+                        return err;
+        }
 
+        if (HAVE_HWFP) {
                 if (cpu_has_fxsr)
                         err = restore_i387_fxsave(buf);
                 else
diff --git a/arch/x86/kernel/io_apic_32.c b/arch/x86/kernel/io_apic_32.c
index a40d54fc1fdd..4dc8600d9d20 100644
--- a/arch/x86/kernel/io_apic_32.c
+++ b/arch/x86/kernel/io_apic_32.c
@@ -2130,14 +2130,10 @@ static inline void __init check_timer(void)
 {
         int apic1, pin1, apic2, pin2;
         int vector;
-        unsigned int ver;
         unsigned long flags;
 
         local_irq_save(flags);
 
-        ver = apic_read(APIC_LVR);
-        ver = GET_APIC_VERSION(ver);
-
         /*
          * get/set the timer IRQ vector:
          */
@@ -2150,15 +2146,11 @@ static inline void __init check_timer(void)
          * mode for the 8259A whenever interrupts are routed
          * through I/O APICs.  Also IRQ0 has to be enabled in
          * the 8259A which implies the virtual wire has to be
-         * disabled in the local APIC.  Finally timer interrupts
-         * need to be acknowledged manually in the 8259A for
-         * timer_interrupt() and for the i82489DX when using
-         * the NMI watchdog.
+         * disabled in the local APIC.
          */
         apic_write_around(APIC_LVT0, APIC_LVT_MASKED | APIC_DM_EXTINT);
         init_8259A(1);
-        timer_ack = !cpu_has_tsc;
-        timer_ack |= (nmi_watchdog == NMI_IO_APIC && !APIC_INTEGRATED(ver));
+        timer_ack = 1;
         if (timer_over_8254 > 0)
                 enable_8259A_irq(0);
 
diff --git a/arch/x86/kernel/kvmclock.c b/arch/x86/kernel/kvmclock.c
index 4bc1be5d5472..08a30986d472 100644
--- a/arch/x86/kernel/kvmclock.c
+++ b/arch/x86/kernel/kvmclock.c
@@ -53,7 +53,7 @@ static cycle_t kvm_clock_read(void);
  * have elapsed since the hypervisor wrote the data. So we try to account for
  * that with system time
  */
-unsigned long kvm_get_wallclock(void)
+static unsigned long kvm_get_wallclock(void)
 {
         u32 wc_sec, wc_nsec;
         u64 delta;
@@ -86,7 +86,7 @@ unsigned long kvm_get_wallclock(void)
         return ts.tv_sec + 1;
 }
 
-int kvm_set_wallclock(unsigned long now)
+static int kvm_set_wallclock(unsigned long now)
 {
         return 0;
 }
diff --git a/arch/x86/kernel/mfgpt_32.c b/arch/x86/kernel/mfgpt_32.c
index 3cad17fe026b..07c0f828f488 100644
--- a/arch/x86/kernel/mfgpt_32.c
+++ b/arch/x86/kernel/mfgpt_32.c
@@ -155,6 +155,7 @@ int geode_mfgpt_toggle_event(int timer, int cmp, int event, int enable)
         wrmsr(msr, value, dummy);
         return 0;
 }
+EXPORT_SYMBOL_GPL(geode_mfgpt_toggle_event);
 
 int geode_mfgpt_set_irq(int timer, int cmp, int irq, int enable)
 {
@@ -222,6 +223,7 @@ int geode_mfgpt_alloc_timer(int timer, int domain)
         /* No timers available - too bad */
         return -1;
 }
+EXPORT_SYMBOL_GPL(geode_mfgpt_alloc_timer);
 
 
 #ifdef CONFIG_GEODE_MFGPT_TIMER
diff --git a/arch/x86/kernel/nmi_32.c b/arch/x86/kernel/nmi_32.c
index 11b14bbaa61e..84160f74eeb0 100644
--- a/arch/x86/kernel/nmi_32.c
+++ b/arch/x86/kernel/nmi_32.c
@@ -26,7 +26,6 @@
 
 #include <asm/smp.h>
 #include <asm/nmi.h>
-#include <asm/timer.h>
 
 #include "mach_traps.h"
 
@@ -82,7 +81,7 @@ int __init check_nmi_watchdog(void)
 
         prev_nmi_count = kmalloc(NR_CPUS * sizeof(int), GFP_KERNEL);
         if (!prev_nmi_count)
-                goto error;
+                return -1;
 
         printk(KERN_INFO "Testing NMI watchdog ... ");
 
@@ -119,7 +118,7 @@ int __init check_nmi_watchdog(void)
         if (!atomic_read(&nmi_active)) {
                 kfree(prev_nmi_count);
                 atomic_set(&nmi_active, -1);
-                goto error;
+                return -1;
         }
         printk("OK.\n");
 
@@ -130,10 +129,6 @@ int __init check_nmi_watchdog(void)
 
         kfree(prev_nmi_count);
         return 0;
-error:
-        timer_ack = !cpu_has_tsc;
-
-        return -1;
 }
 
 static int __init setup_nmi_watchdog(char *str)
diff --git a/arch/x86/kernel/pci-dma.c b/arch/x86/kernel/pci-dma.c
index c5ef1af8e79d..dc00a1331ace 100644
--- a/arch/x86/kernel/pci-dma.c
+++ b/arch/x86/kernel/pci-dma.c
@@ -378,6 +378,7 @@ dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
         struct page *page;
         unsigned long dma_mask = 0;
         dma_addr_t bus;
+        int noretry = 0;
 
         /* ignore region specifiers */
         gfp &= ~(__GFP_DMA | __GFP_HIGHMEM | __GFP_DMA32);
@@ -397,20 +398,25 @@ dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
         if (dev->dma_mask == NULL)
                 return NULL;
 
-        /* Don't invoke OOM killer */
-        gfp |= __GFP_NORETRY;
+        /* Don't invoke OOM killer or retry in lower 16MB DMA zone */
+        if (gfp & __GFP_DMA)
+                noretry = 1;
 
 #ifdef CONFIG_X86_64
         /* Why <=? Even when the mask is smaller than 4GB it is often
            larger than 16MB and in this case we have a chance of
            finding fitting memory in the next higher zone first. If
            not retry with true GFP_DMA. -AK */
-        if (dma_mask <= DMA_32BIT_MASK && !(gfp & GFP_DMA))
+        if (dma_mask <= DMA_32BIT_MASK && !(gfp & GFP_DMA)) {
                 gfp |= GFP_DMA32;
+                if (dma_mask < DMA_32BIT_MASK)
+                        noretry = 1;
+        }
 #endif
 
  again:
-        page = dma_alloc_pages(dev, gfp, get_order(size));
+        page = dma_alloc_pages(dev,
+                noretry ? gfp | __GFP_NORETRY : gfp, get_order(size));
         if (page == NULL)
                 return NULL;
 
diff --git a/arch/x86/kernel/pci-gart_64.c b/arch/x86/kernel/pci-gart_64.c
index c07455d1695f..aa8ec928caa8 100644
--- a/arch/x86/kernel/pci-gart_64.c
+++ b/arch/x86/kernel/pci-gart_64.c
@@ -26,6 +26,7 @@
 #include <linux/kdebug.h>
 #include <linux/scatterlist.h>
 #include <linux/iommu-helper.h>
+#include <linux/sysdev.h>
 #include <asm/atomic.h>
 #include <asm/io.h>
 #include <asm/mtrr.h>
@@ -548,6 +549,28 @@ static __init unsigned read_aperture(struct pci_dev *dev, u32 *size)
         return aper_base;
 }
 
+static int gart_resume(struct sys_device *dev)
+{
+        return 0;
+}
+
+static int gart_suspend(struct sys_device *dev, pm_message_t state)
+{
+        return -EINVAL;
+}
+
+static struct sysdev_class gart_sysdev_class = {
+        .name = "gart",
+        .suspend = gart_suspend,
+        .resume = gart_resume,
+
+};
+
+static struct sys_device device_gart = {
+        .id     = 0,
+        .cls    = &gart_sysdev_class,
+};
+
 /*
  * Private Northbridge GATT initialization in case we cannot use the
  * AGP driver for some reason.
@@ -558,7 +581,7 @@ static __init int init_k8_gatt(struct agp_kern_info *info)
         unsigned aper_base, new_aper_base;
         struct pci_dev *dev;
         void *gatt;
-        int i;
+        int i, error;
 
         printk(KERN_INFO "PCI-DMA: Disabling AGP.\n");
         aper_size = aper_base = info->aper_size = 0;
@@ -606,6 +629,12 @@ static __init int init_k8_gatt(struct agp_kern_info *info)
 
                 pci_write_config_dword(dev, 0x90, ctl);
         }
+
+        error = sysdev_class_register(&gart_sysdev_class);
+        if (!error)
+                error = sysdev_register(&device_gart);
+        if (error)
+                panic("Could not register gart_sysdev -- would corrupt data on next suspend");
         flush_gart();
 
         printk(KERN_INFO "PCI-DMA: aperture base @ %x size %u KB\n",
diff --git a/arch/x86/kernel/process_32.c b/arch/x86/kernel/process_32.c
index a30aa1f2607a..61f7481c31dd 100644
--- a/arch/x86/kernel/process_32.c
+++ b/arch/x86/kernel/process_32.c
@@ -652,8 +652,11 @@ struct task_struct * __switch_to(struct task_struct *prev_p, struct task_struct
         /* If the task has used fpu the last 5 timeslices, just do a full
          * restore of the math state immediately to avoid the trap; the
          * chances of needing FPU soon are obviously high now
+         *
+         * tsk_used_math() checks prevent calling math_state_restore(),
+         * which can sleep in the case of !tsk_used_math()
          */
-        if (next_p->fpu_counter > 5)
+        if (tsk_used_math(next_p) && next_p->fpu_counter > 5)
                 math_state_restore();
 
         /*
diff --git a/arch/x86/kernel/process_64.c b/arch/x86/kernel/process_64.c
index dd349c92f051..dc534f40c8d3 100644
--- a/arch/x86/kernel/process_64.c
+++ b/arch/x86/kernel/process_64.c
@@ -661,8 +661,11 @@ __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
         /* If the task has used fpu the last 5 timeslices, just do a full
          * restore of the math state immediately to avoid the trap; the
          * chances of needing FPU soon are obviously high now
+         *
+         * tsk_used_math() checks prevent calling math_state_restore(),
+         * which can sleep in the case of !tsk_used_math()
          */
-        if (next_p->fpu_counter>5)
+        if (tsk_used_math(next_p) && next_p->fpu_counter > 5)
                 math_state_restore();
         return prev_p;
 }
diff --git a/arch/x86/kernel/rtc.c b/arch/x86/kernel/rtc.c
index 9615eee9b775..05191bbc68b8 100644
--- a/arch/x86/kernel/rtc.c
+++ b/arch/x86/kernel/rtc.c
@@ -4,6 +4,8 @@
 #include <linux/acpi.h>
 #include <linux/bcd.h>
 #include <linux/mc146818rtc.h>
+#include <linux/platform_device.h>
+#include <linux/pnp.h>
 
 #include <asm/time.h>
 #include <asm/vsyscall.h>
@@ -197,3 +199,35 @@ unsigned long long native_read_tsc(void)
 }
 EXPORT_SYMBOL(native_read_tsc);
 
+
+static struct resource rtc_resources[] = {
+        [0] = {
+                .start  = RTC_PORT(0),
+                .end    = RTC_PORT(1),
+                .flags  = IORESOURCE_IO,
+        },
+        [1] = {
+                .start  = RTC_IRQ,
+                .end    = RTC_IRQ,
+                .flags  = IORESOURCE_IRQ,
+        }
+};
+
+static struct platform_device rtc_device = {
+        .name           = "rtc_cmos",
+        .id             = -1,
+        .resource       = rtc_resources,
+        .num_resources  = ARRAY_SIZE(rtc_resources),
+};
+
+static __init int add_rtc_cmos(void)
+{
+#ifdef CONFIG_PNP
+        if (!pnp_platform_devices)
+                platform_device_register(&rtc_device);
+#else
+        platform_device_register(&rtc_device);
+#endif /* CONFIG_PNP */
+        return 0;
+}
+device_initcall(add_rtc_cmos);
diff --git a/arch/x86/kernel/smpboot.c b/arch/x86/kernel/smpboot.c
index 38988491c622..56078d61c793 100644
--- a/arch/x86/kernel/smpboot.c
+++ b/arch/x86/kernel/smpboot.c
@@ -1190,6 +1190,7 @@ static void __init smp_cpu_index_default(void)
  */
 void __init native_smp_prepare_cpus(unsigned int max_cpus)
 {
+        preempt_disable();
         nmi_watchdog_default();
         smp_cpu_index_default();
         current_cpu_data = boot_cpu_data;
@@ -1206,7 +1207,7 @@ void __init native_smp_prepare_cpus(unsigned int max_cpus)
         if (smp_sanity_check(max_cpus) < 0) {
                 printk(KERN_INFO "SMP disabled\n");
                 disable_smp();
-                return;
+                goto out;
         }
 
         preempt_disable();
@@ -1246,6 +1247,8 @@ void __init native_smp_prepare_cpus(unsigned int max_cpus)
         printk(KERN_INFO "CPU%d: ", 0);
         print_cpu_info(&cpu_data(0));
         setup_boot_clock();
+out:
+        preempt_enable();
 }
 /*
  * Early setup to make printk work.
diff --git a/arch/x86/kernel/traps_32.c b/arch/x86/kernel/traps_32.c
index bde6f63e15d5..08d752de4eee 100644
--- a/arch/x86/kernel/traps_32.c
+++ b/arch/x86/kernel/traps_32.c
@@ -544,6 +544,7 @@ vm86_trap:
 #define DO_ERROR(trapnr, signr, str, name)                              \
 void do_##name(struct pt_regs *regs, long error_code)                   \
 {                                                                       \
+        trace_hardirqs_fixup();                                         \
         if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr)  \
                                                 == NOTIFY_STOP)         \
                 return;                                                 \
diff --git a/arch/x86/kernel/tsc_32.c b/arch/x86/kernel/tsc_32.c
index e4790728b224..068759db63dd 100644
--- a/arch/x86/kernel/tsc_32.c
+++ b/arch/x86/kernel/tsc_32.c
@@ -14,7 +14,7 @@
 
 #include "mach_timer.h"
 
-static int tsc_enabled;
+static int tsc_disabled;
 
 /*
  * On some systems the TSC frequency does not
@@ -28,8 +28,8 @@ EXPORT_SYMBOL_GPL(tsc_khz);
 static int __init tsc_setup(char *str)
 {
         printk(KERN_WARNING "notsc: Kernel compiled with CONFIG_X86_TSC, "
-                                "cannot disable TSC completely.\n");
-        mark_tsc_unstable("user disabled TSC");
+               "cannot disable TSC completely.\n");
+        tsc_disabled = 1;
         return 1;
 }
 #else
@@ -120,7 +120,7 @@ unsigned long long native_sched_clock(void)
          *   very important for it to be as fast as the platform
          *   can achive it. )
          */
-        if (unlikely(!tsc_enabled && !tsc_unstable))
+        if (unlikely(tsc_disabled))
                 /* No locking but a rare wrong value is not a big deal: */
                 return (jiffies_64 - INITIAL_JIFFIES) * (1000000000 / HZ);
 
@@ -322,7 +322,6 @@ void mark_tsc_unstable(char *reason)
 {
         if (!tsc_unstable) {
                 tsc_unstable = 1;
-                tsc_enabled = 0;
                 printk("Marking TSC unstable due to: %s.\n", reason);
                 /* Can be called before registration */
                 if (clocksource_tsc.mult)
@@ -336,7 +335,7 @@ EXPORT_SYMBOL_GPL(mark_tsc_unstable);
 static int __init dmi_mark_tsc_unstable(const struct dmi_system_id *d)
 {
         printk(KERN_NOTICE "%s detected: marking TSC unstable.\n",
-                       d->ident);
+               d->ident);
         tsc_unstable = 1;
         return 0;
 }
@@ -403,14 +402,22 @@ void __init tsc_init(void)
 {
         int cpu;
 
-        if (!cpu_has_tsc)
+        if (!cpu_has_tsc || tsc_disabled) {
+                /* Disable the TSC in case of !cpu_has_tsc */
+                tsc_disabled = 1;
                 return;
+        }
 
         cpu_khz = calculate_cpu_khz();
         tsc_khz = cpu_khz;
 
         if (!cpu_khz) {
                 mark_tsc_unstable("could not calculate TSC khz");
+                /*
+                 * We need to disable the TSC completely in this case
+                 * to prevent sched_clock() from using it.
+                 */
+                tsc_disabled = 1;
                 return;
         }
 
@@ -441,8 +448,6 @@ void __init tsc_init(void)
         if (check_tsc_unstable()) {
                 clocksource_tsc.rating = 0;
                 clocksource_tsc.flags &= ~CLOCK_SOURCE_IS_CONTINUOUS;
-        } else
-                tsc_enabled = 1;
-
+        }
         clocksource_register(&clocksource_tsc);
 }
diff --git a/arch/x86/kernel/tsc_64.c b/arch/x86/kernel/tsc_64.c
index fcc16e58609e..1784b8077a12 100644
--- a/arch/x86/kernel/tsc_64.c
+++ b/arch/x86/kernel/tsc_64.c
@@ -227,14 +227,14 @@ void __init tsc_calibrate(void)
         /* hpet or pmtimer available ? */
         if (!hpet && !pm1 && !pm2) {
                 printk(KERN_INFO "TSC calibrated against PIT\n");
-                return;
+                goto out;
         }
 
         /* Check, whether the sampling was disturbed by an SMI */
         if (tsc1 == ULONG_MAX || tsc2 == ULONG_MAX) {
                 printk(KERN_WARNING "TSC calibration disturbed by SMI, "
                        "using PIT calibration result\n");
-                return;
+                goto out;
         }
 
         tsc2 = (tsc2 - tsc1) * 1000000L;
@@ -255,6 +255,7 @@ void __init tsc_calibrate(void)
 
         tsc_khz = tsc2 / tsc1;
 
+out:
         for_each_possible_cpu(cpu)
                 set_cyc2ns_scale(tsc_khz, cpu);
 }
diff --git a/arch/x86/kvm/i8254.c b/arch/x86/kvm/i8254.c
index 7c077a9d9777..f2f5d260874e 100644
--- a/arch/x86/kvm/i8254.c
+++ b/arch/x86/kvm/i8254.c
@@ -200,7 +200,6 @@ int __pit_timer_fn(struct kvm_kpit_state *ps)
 
         atomic_inc(&pt->pending);
         smp_mb__after_atomic_inc();
-        /* FIXME: handle case where the guest is in guest mode */
         if (vcpu0 && waitqueue_active(&vcpu0->wq)) {
                 vcpu0->arch.mp_state = KVM_MP_STATE_RUNNABLE;
                 wake_up_interruptible(&vcpu0->wq);
@@ -237,6 +236,19 @@ static enum hrtimer_restart pit_timer_fn(struct hrtimer *data)
                 return HRTIMER_NORESTART;
 }
 
+void __kvm_migrate_pit_timer(struct kvm_vcpu *vcpu)
+{
+        struct kvm_pit *pit = vcpu->kvm->arch.vpit;
+        struct hrtimer *timer;
+
+        if (vcpu->vcpu_id != 0 || !pit)
+                return;
+
+        timer = &pit->pit_state.pit_timer.timer;
+        if (hrtimer_cancel(timer))
+                hrtimer_start(timer, timer->expires, HRTIMER_MODE_ABS);
+}
+
 static void destroy_pit_timer(struct kvm_kpit_timer *pt)
 {
         pr_debug("pit: execute del timer!\n");
diff --git a/arch/x86/kvm/irq.c b/arch/x86/kvm/irq.c
index ce1f583459b1..76d736b5f664 100644
--- a/arch/x86/kvm/irq.c
+++ b/arch/x86/kvm/irq.c
@@ -94,3 +94,9 @@ void kvm_timer_intr_post(struct kvm_vcpu *vcpu, int vec)
         /* TODO: PIT, RTC etc. */
 }
 EXPORT_SYMBOL_GPL(kvm_timer_intr_post);
+
+void __kvm_migrate_timers(struct kvm_vcpu *vcpu)
+{
+        __kvm_migrate_apic_timer(vcpu);
+        __kvm_migrate_pit_timer(vcpu);
+}
diff --git a/arch/x86/kvm/irq.h b/arch/x86/kvm/irq.h
index 1802134b836f..2a15be2275c0 100644
--- a/arch/x86/kvm/irq.h
+++ b/arch/x86/kvm/irq.h
@@ -84,6 +84,8 @@ void kvm_timer_intr_post(struct kvm_vcpu *vcpu, int vec);
 void kvm_inject_pending_timer_irqs(struct kvm_vcpu *vcpu);
 void kvm_inject_apic_timer_irqs(struct kvm_vcpu *vcpu);
 void __kvm_migrate_apic_timer(struct kvm_vcpu *vcpu);
+void __kvm_migrate_pit_timer(struct kvm_vcpu *vcpu);
+void __kvm_migrate_timers(struct kvm_vcpu *vcpu);
 
 int pit_has_pending_timer(struct kvm_vcpu *vcpu);
 int apic_has_pending_timer(struct kvm_vcpu *vcpu);
diff --git a/arch/x86/kvm/mmu.c b/arch/x86/kvm/mmu.c
index 36c5406b1813..ee3f53098f0c 100644
--- a/arch/x86/kvm/mmu.c
+++ b/arch/x86/kvm/mmu.c
@@ -658,7 +658,7 @@ static int is_empty_shadow_page(u64 *spt)
         u64 *end;
 
         for (pos = spt, end = pos + PAGE_SIZE / sizeof(u64); pos != end; pos++)
-                if (*pos != shadow_trap_nonpresent_pte) {
+                if (is_shadow_present_pte(*pos)) {
                         printk(KERN_ERR "%s: %p %llx\n", __func__,
                                pos, *pos);
                         return 0;
@@ -1858,6 +1858,7 @@ static void free_mmu_pages(struct kvm_vcpu *vcpu)
                 sp = container_of(vcpu->kvm->arch.active_mmu_pages.next,
                                   struct kvm_mmu_page, link);
                 kvm_mmu_zap_page(vcpu->kvm, sp);
+                cond_resched();
         }
         free_page((unsigned long)vcpu->arch.mmu.pae_root);
 }
@@ -1996,7 +1997,7 @@ static struct shrinker mmu_shrinker = {
         .seeks = DEFAULT_SEEKS * 10,
 };
 
-void mmu_destroy_caches(void)
+static void mmu_destroy_caches(void)
 {
         if (pte_chain_cache)
                 kmem_cache_destroy(pte_chain_cache);
diff --git a/arch/x86/kvm/paging_tmpl.h b/arch/x86/kvm/paging_tmpl.h
index 156fe10288ae..934c7b619396 100644
--- a/arch/x86/kvm/paging_tmpl.h
+++ b/arch/x86/kvm/paging_tmpl.h
@@ -418,7 +418,7 @@ static int FNAME(page_fault)(struct kvm_vcpu *vcpu, gva_t addr,
 
         /* mmio */
         if (is_error_pfn(pfn)) {
-                pgprintk("gfn %x is mmio\n", walker.gfn);
+                pgprintk("gfn %lx is mmio\n", walker.gfn);
                 kvm_release_pfn_clean(pfn);
                 return 1;
         }
diff --git a/arch/x86/kvm/svm.c b/arch/x86/kvm/svm.c
index ab22615eee89..6b0d5fa5bab3 100644
--- a/arch/x86/kvm/svm.c
+++ b/arch/x86/kvm/svm.c
@@ -688,7 +688,7 @@ static void svm_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
                 delta = vcpu->arch.host_tsc - tsc_this;
                 svm->vmcb->control.tsc_offset += delta;
                 vcpu->cpu = cpu;
-                kvm_migrate_apic_timer(vcpu);
+                kvm_migrate_timers(vcpu);
         }
 
         for (i = 0; i < NR_HOST_SAVE_USER_MSRS; i++)
diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c
index bfe4db11989c..02efbe75f317 100644
--- a/arch/x86/kvm/vmx.c
+++ b/arch/x86/kvm/vmx.c
@@ -608,7 +608,7 @@ static void vmx_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
 
         if (vcpu->cpu != cpu) {
                 vcpu_clear(vmx);
-                kvm_migrate_apic_timer(vcpu);
+                kvm_migrate_timers(vcpu);
                 vpid_sync_vcpu_all(vmx);
         }
 
@@ -1036,6 +1036,7 @@ static void hardware_enable(void *garbage)
 static void hardware_disable(void *garbage)
 {
         asm volatile (ASM_VMX_VMXOFF : : : "cc");
+        write_cr4(read_cr4() & ~X86_CR4_VMXE);
 }
 
 static __init int adjust_vmx_controls(u32 ctl_min, u32 ctl_opt,
diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
index 21338bdb28ff..00acf1301a15 100644
--- a/arch/x86/kvm/x86.c
+++ b/arch/x86/kvm/x86.c
@@ -2758,7 +2758,7 @@ again:
 
         if (vcpu->requests) {
                 if (test_and_clear_bit(KVM_REQ_MIGRATE_TIMER, &vcpu->requests))
-                        __kvm_migrate_apic_timer(vcpu);
+                        __kvm_migrate_timers(vcpu);
                 if (test_and_clear_bit(KVM_REQ_REPORT_TPR_ACCESS,
                                        &vcpu->requests)) {
                         kvm_run->exit_reason = KVM_EXIT_TPR_ACCESS;
diff --git a/arch/x86/kvm/x86_emulate.c b/arch/x86/kvm/x86_emulate.c
index 8a96320ab071..932f216d890c 100644
--- a/arch/x86/kvm/x86_emulate.c
+++ b/arch/x86/kvm/x86_emulate.c
@@ -1727,7 +1727,8 @@ twobyte_insn:
                         if (rc)
                                 goto done;
 
-                        kvm_emulate_hypercall(ctxt->vcpu);
+                        /* Let the processor re-execute the fixed hypercall */
+                        c->eip = ctxt->vcpu->arch.rip;
                         /* Disable writeback. */
                         c->dst.type = OP_NONE;
                         break;
diff --git a/arch/x86/lguest/boot.c b/arch/x86/lguest/boot.c
index af65b2da3ba0..5c7e2fd52075 100644
--- a/arch/x86/lguest/boot.c
+++ b/arch/x86/lguest/boot.c
@@ -582,8 +582,9 @@ static void __init lguest_init_IRQ(void)
                 int vector = FIRST_EXTERNAL_VECTOR + i;
                 if (vector != SYSCALL_VECTOR) {
                         set_intr_gate(vector, interrupt[i]);
-                        set_irq_chip_and_handler(i, &lguest_irq_controller,
-                                                 handle_level_irq);
+                        set_irq_chip_and_handler_name(i, &lguest_irq_controller,
+                                                      handle_level_irq,
+                                                      "level");
                 }
         }
         /* This call is required to set up for 4k stacks, where we have
diff --git a/arch/x86/lib/delay_32.c b/arch/x86/lib/delay_32.c
index 4535e6d147ad..d710f2d167bb 100644
--- a/arch/x86/lib/delay_32.c
+++ b/arch/x86/lib/delay_32.c
@@ -44,13 +44,36 @@ static void delay_loop(unsigned long loops)
 static void delay_tsc(unsigned long loops)
 {
         unsigned long bclock, now;
+        int cpu;
 
-        preempt_disable();              /* TSC's are per-cpu */
+        preempt_disable();
+        cpu = smp_processor_id();
         rdtscl(bclock);
-        do {
-                rep_nop();
+        for (;;) {
                 rdtscl(now);
-        } while ((now-bclock) < loops);
+                if ((now - bclock) >= loops)
+                        break;
+
+                /* Allow RT tasks to run */
+                preempt_enable();
+                rep_nop();
+                preempt_disable();
+
+                /*
+                 * It is possible that we moved to another CPU, and
+                 * since TSC's are per-cpu we need to calculate
+                 * that. The delay must guarantee that we wait "at
+                 * least" the amount of time. Being moved to another
+                 * CPU could make the wait longer but we just need to
+                 * make sure we waited long enough. Rebalance the
+                 * counter for this CPU.
+                 */
+                if (unlikely(cpu != smp_processor_id())) {
+                        loops -= (now - bclock);
+                        cpu = smp_processor_id();
+                        rdtscl(bclock);
+                }
+        }
         preempt_enable();
 }
 
diff --git a/arch/x86/lib/delay_64.c b/arch/x86/lib/delay_64.c
index bbc610518516..4c441be92641 100644
--- a/arch/x86/lib/delay_64.c
+++ b/arch/x86/lib/delay_64.c
@@ -31,14 +31,36 @@ int __devinit read_current_timer(unsigned long *timer_value)
 void __delay(unsigned long loops)
 {
         unsigned bclock, now;
+        int cpu;
 
-        preempt_disable();              /* TSC's are pre-cpu */
+        preempt_disable();
+        cpu = smp_processor_id();
         rdtscl(bclock);
-        do {
-                rep_nop(); 
+        for (;;) {
                 rdtscl(now);
+                if ((now - bclock) >= loops)
+                        break;
+
+                /* Allow RT tasks to run */
+                preempt_enable();
+                rep_nop();
+                preempt_disable();
+
+                /*
+                 * It is possible that we moved to another CPU, and
+                 * since TSC's are per-cpu we need to calculate
+                 * that. The delay must guarantee that we wait "at
+                 * least" the amount of time. Being moved to another
+                 * CPU could make the wait longer but we just need to
+                 * make sure we waited long enough. Rebalance the
+                 * counter for this CPU.
+                 */
+                if (unlikely(cpu != smp_processor_id())) {
+                        loops -= (now - bclock);
+                        cpu = smp_processor_id();
+                        rdtscl(bclock);
+                }
         }
-        while ((now-bclock) < loops);
         preempt_enable();
 }
 EXPORT_SYMBOL(__delay);
diff --git a/arch/x86/math-emu/fpu_entry.c b/arch/x86/math-emu/fpu_entry.c
index 6e38d877ea77..c7b06feb139b 100644
--- a/arch/x86/math-emu/fpu_entry.c
+++ b/arch/x86/math-emu/fpu_entry.c
@@ -30,6 +30,7 @@
 #include <asm/uaccess.h>
 #include <asm/desc.h>
 #include <asm/user.h>
+#include <asm/i387.h>
 
 #include "fpu_system.h"
 #include "fpu_emu.h"
@@ -146,6 +147,13 @@ asmlinkage void math_emulate(long arg)
         unsigned long code_limit = 0;   /* Initialized to stop compiler warnings */
         struct desc_struct code_descriptor;
 
+        if (!used_math()) {
+                if (init_fpu(current)) {
+                        do_group_exit(SIGKILL);
+                        return;
+                }
+        }
+
 #ifdef RE_ENTRANT_CHECKING
         if (emulating) {
                 printk("ERROR: wm-FPU-emu is not RE-ENTRANT!\n");
@@ -153,11 +161,6 @@ asmlinkage void math_emulate(long arg)
         RE_ENTRANT_CHECK_ON;
 #endif /* RE_ENTRANT_CHECKING */
 
-        if (!used_math()) {
-                finit();
-                set_used_math();
-        }
-
         SETUP_DATA_AREA(arg);
 
         FPU_ORIG_EIP = FPU_EIP;
diff --git a/arch/x86/mm/fault.c b/arch/x86/mm/fault.c
index 8c828a68d3b6..0a778e3c43ee 100644
--- a/arch/x86/mm/fault.c
+++ b/arch/x86/mm/fault.c
@@ -508,6 +508,11 @@ static int vmalloc_fault(unsigned long address)
         unsigned long pgd_paddr;
         pmd_t *pmd_k;
         pte_t *pte_k;
+
+        /* Make sure we are in vmalloc area */
+        if (!(address >= VMALLOC_START && address < VMALLOC_END))
+                return -1;
+
         /*
          * Synchronize this task's top level page-table
          * with the 'reference' page table.
diff --git a/arch/x86/mm/init_64.c b/arch/x86/mm/init_64.c
index 295be1d07b82..a5fd2e06f5c9 100644
--- a/arch/x86/mm/init_64.c
+++ b/arch/x86/mm/init_64.c
@@ -206,7 +206,7 @@ void __init cleanup_highmap(void)
         pmd_t *last_pmd = pmd + PTRS_PER_PMD;
 
         for (; pmd < last_pmd; pmd++, vaddr += PMD_SIZE) {
-                if (!pmd_present(*pmd))
+                if (pmd_none(*pmd))
                         continue;
                 if (vaddr < (unsigned long) _text || vaddr > end)
                         set_pmd(pmd, __pmd(0));
@@ -506,7 +506,7 @@ early_param("memtest", parse_memtest);
 
 static void __init early_memtest(unsigned long start, unsigned long end)
 {
-        unsigned long t_start, t_size;
+        u64 t_start, t_size;
         unsigned pattern;
 
         if (!memtest_pattern)
@@ -525,7 +525,7 @@ static void __init early_memtest(unsigned long start, unsigned long end)
                         if (t_start + t_size > end)
                                 t_size = end - t_start;
 
-                        printk(KERN_CONT "\n  %016lx - %016lx pattern %d",
+                        printk(KERN_CONT "\n  %016llx - %016llx pattern %d",
                                 t_start, t_start + t_size, pattern);
 
                         memtest(t_start, t_size, pattern);
diff --git a/arch/x86/mm/ioremap.c b/arch/x86/mm/ioremap.c
index a7c80a6e8622..e92aa461f4d6 100644
--- a/arch/x86/mm/ioremap.c
+++ b/arch/x86/mm/ioremap.c
@@ -602,10 +602,11 @@ void __init early_iounmap(void *addr, unsigned long size)
         unsigned long offset;
         unsigned int nrpages;
         enum fixed_addresses idx;
-        unsigned int nesting;
+        int nesting;
 
         nesting = --early_ioremap_nested;
-        WARN_ON(nesting < 0);
+        if (WARN_ON(nesting < 0))
+                return;
 
         if (early_ioremap_debug) {
                 printk(KERN_INFO "early_iounmap(%p, %08lx) [%d]\n", addr,
diff --git a/arch/x86/mm/pat.c b/arch/x86/mm/pat.c
index de3a99812450..06b7a1c90fb8 100644
--- a/arch/x86/mm/pat.c
+++ b/arch/x86/mm/pat.c
@@ -34,7 +34,7 @@ void __cpuinit pat_disable(char *reason)
         printk(KERN_INFO "%s\n", reason);
 }
 
-static int nopat(char *str)
+static int __init nopat(char *str)
 {
         pat_disable("PAT support disabled.");
         return 0;
@@ -151,32 +151,33 @@ static int pat_x_mtrr_type(u64 start, u64 end, unsigned long prot,
         unsigned long pat_type;
         u8 mtrr_type;
 
-        mtrr_type = mtrr_type_lookup(start, end);
-        if (mtrr_type == 0xFF) {                /* MTRR not enabled */
-                *ret_prot = prot;
-                return 0;
-        }
-        if (mtrr_type == 0xFE) {                /* MTRR match error */
-                *ret_prot = _PAGE_CACHE_UC;
-                return -1;
-        }
-        if (mtrr_type != MTRR_TYPE_UNCACHABLE &&
-            mtrr_type != MTRR_TYPE_WRBACK &&
-            mtrr_type != MTRR_TYPE_WRCOMB) {    /* MTRR type unhandled */
-                *ret_prot = _PAGE_CACHE_UC;
-                return -1;
-        }
-
         pat_type = prot & _PAGE_CACHE_MASK;
         prot &= (~_PAGE_CACHE_MASK);
 
-        /* Currently doing intersection by hand. Optimize it later. */
+        /*
+         * We return the PAT request directly for types where PAT takes
+         * precedence with respect to MTRR and for UC_MINUS.
+         * Consistency checks with other PAT requests is done later
+         * while going through memtype list.
+         */
         if (pat_type == _PAGE_CACHE_WC) {
                 *ret_prot = prot | _PAGE_CACHE_WC;
+                return 0;
         } else if (pat_type == _PAGE_CACHE_UC_MINUS) {
                 *ret_prot = prot | _PAGE_CACHE_UC_MINUS;
-        } else if (pat_type == _PAGE_CACHE_UC ||
-                   mtrr_type == MTRR_TYPE_UNCACHABLE) {
+                return 0;
+        } else if (pat_type == _PAGE_CACHE_UC) {
+                *ret_prot = prot | _PAGE_CACHE_UC;
+                return 0;
+        }
+
+        /*
+         * Look for MTRR hint to get the effective type in case where PAT
+         * request is for WB.
+         */
+        mtrr_type = mtrr_type_lookup(start, end);
+
+        if (mtrr_type == MTRR_TYPE_UNCACHABLE) {
                 *ret_prot = prot | _PAGE_CACHE_UC;
         } else if (mtrr_type == MTRR_TYPE_WRCOMB) {
                 *ret_prot = prot | _PAGE_CACHE_WC;
@@ -233,14 +234,12 @@ int reserve_memtype(u64 start, u64 end, unsigned long req_type,
 
         if (req_type == -1) {
                 /*
-                 * Special case where caller wants to inherit from mtrr or
-                 * existing pat mapping, defaulting to UC_MINUS in case of
-                 * no match.
+                 * Call mtrr_lookup to get the type hint. This is an
+                 * optimization for /dev/mem mmap'ers into WB memory (BIOS
+                 * tools and ACPI tools). Use WB request for WB memory and use
+                 * UC_MINUS otherwise.
                  */
                 u8 mtrr_type = mtrr_type_lookup(start, end);
-                if (mtrr_type == 0xFE) { /* MTRR match error */
-                        err = -1;
-                }
 
                 if (mtrr_type == MTRR_TYPE_WRBACK) {
                         req_type = _PAGE_CACHE_WB;
diff --git a/arch/x86/mm/srat_64.c b/arch/x86/mm/srat_64.c
index 3890234e5b26..99649dccad28 100644
--- a/arch/x86/mm/srat_64.c
+++ b/arch/x86/mm/srat_64.c
@@ -97,36 +97,9 @@ static __init inline int srat_disabled(void)
         return numa_off || acpi_numa < 0;
 }
 
-/*
- * A lot of BIOS fill in 10 (= no distance) everywhere. This messes
- * up the NUMA heuristics which wants the local node to have a smaller
- * distance than the others.
- * Do some quick checks here and only use the SLIT if it passes.
- */
-static __init int slit_valid(struct acpi_table_slit *slit)
-{
-        int i, j;
-        int d = slit->locality_count;
-        for (i = 0; i < d; i++) {
-                for (j = 0; j < d; j++)  {
-                        u8 val = slit->entry[d*i + j];
-                        if (i == j) {
-                                if (val != LOCAL_DISTANCE)
-                                        return 0;
-                        } else if (val <= LOCAL_DISTANCE)
-                                return 0;
-                }
-        }
-        return 1;
-}
-
 /* Callback for SLIT parsing */
 void __init acpi_numa_slit_init(struct acpi_table_slit *slit)
 {
-        if (!slit_valid(slit)) {
-                printk(KERN_INFO "ACPI: SLIT table looks invalid. Not used.\n");
-                return;
-        }
         acpi_slit = slit;
 }
 
diff --git a/arch/x86/pci/common.c b/arch/x86/pci/common.c
index 6e64aaf00d1d..940185ecaeda 100644
--- a/arch/x86/pci/common.c
+++ b/arch/x86/pci/common.c
@@ -328,18 +328,18 @@ static struct dmi_system_id __devinitdata pciprobe_dmi_table[] = {
 #endif
         {
                 .callback = set_bf_sort,
-                .ident = "HP ProLiant DL385 G2",
+                .ident = "HP ProLiant DL360",
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL385 G2"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL360"),
                 },
         },
         {
                 .callback = set_bf_sort,
-                .ident = "HP ProLiant DL585 G2",
+                .ident = "HP ProLiant DL380",
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL585 G2"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL380"),
                 },
         },
         {}
diff --git a/arch/x86/pci/init.c b/arch/x86/pci/init.c
index e70b9c57b88e..b821f4462d99 100644
--- a/arch/x86/pci/init.c
+++ b/arch/x86/pci/init.c
@@ -15,7 +15,8 @@ static __init int pci_access_init(void)
         pci_mmcfg_early_init();
 
 #ifdef CONFIG_PCI_OLPC
-        pci_olpc_init();
+        if (!pci_olpc_init())
+                return 0;       /* skip additional checks if it's an XO */
 #endif
 #ifdef CONFIG_PCI_BIOS
         pci_pcbios_init();
diff --git a/arch/x86/pci/irq.c b/arch/x86/pci/irq.c
index 0908fca901bf..ca8df9c260bc 100644
--- a/arch/x86/pci/irq.c
+++ b/arch/x86/pci/irq.c
@@ -621,6 +621,13 @@ static __init int via_router_probe(struct irq_router *r,
                          */
                         device = PCI_DEVICE_ID_VIA_8235;
                         break;
+                case PCI_DEVICE_ID_VIA_8237:
+                        /**
+                         * Asus a7v600 bios wrongly reports 8237
+                         * as 586-compatible
+                         */
+                        device = PCI_DEVICE_ID_VIA_8237;
+                        break;
                 }
         }
 
diff --git a/arch/x86/pci/olpc.c b/arch/x86/pci/olpc.c
index 5e7636558c02..e11e9e803d5f 100644
--- a/arch/x86/pci/olpc.c
+++ b/arch/x86/pci/olpc.c
@@ -302,12 +302,13 @@ static struct pci_raw_ops pci_olpc_conf = {
         .write = pci_olpc_write,
 };
 
-void __init pci_olpc_init(void)
+int __init pci_olpc_init(void)
 {
         if (!machine_is_olpc() || olpc_has_vsa())
-                return;
+                return -ENODEV;
 
         printk(KERN_INFO "PCI: Using configuration type OLPC\n");
         raw_pci_ops = &pci_olpc_conf;
         is_lx = is_geode_lx();
+        return 0;
 }
diff --git a/arch/x86/pci/pci.h b/arch/x86/pci/pci.h
index f3972b12c60a..720c4c554534 100644
--- a/arch/x86/pci/pci.h
+++ b/arch/x86/pci/pci.h
@@ -101,7 +101,7 @@ extern struct pci_raw_ops pci_direct_conf1;
 extern int pci_direct_probe(void);
 extern void pci_direct_init(int type);
 extern void pci_pcbios_init(void);
-extern void pci_olpc_init(void);
+extern int pci_olpc_init(void);
 
 /* pci-mmconfig.c */
 
diff --git a/arch/x86/vdso/vclock_gettime.c b/arch/x86/vdso/vclock_gettime.c
index 5cb8f754c52d..1ef0f90813d6 100644
--- a/arch/x86/vdso/vclock_gettime.c
+++ b/arch/x86/vdso/vclock_gettime.c
@@ -107,9 +107,9 @@ notrace int __vdso_gettimeofday(struct timeval *tv, struct timezone *tz)
                 do_realtime((struct timespec *)tv);
                 tv->tv_usec /= 1000;
                 if (unlikely(tz != NULL)) {
-                        /* This relies on gcc inlining the memcpy. We'll notice
-                           if it ever fails to do so. */
-                        memcpy(tz, &gtod->sys_tz, sizeof(struct timezone));
+                        /* Avoid memcpy. Some old compilers fail to inline it */
+                        tz->tz_minuteswest = gtod->sys_tz.tz_minuteswest;
+                        tz->tz_dsttime = gtod->sys_tz.tz_dsttime;
                 }
                 return 0;
         }
diff --git a/arch/x86/xen/mmu.c b/arch/x86/xen/mmu.c
index 126766d43aea..3525ef523a74 100644
--- a/arch/x86/xen/mmu.c
+++ b/arch/x86/xen/mmu.c
@@ -60,7 +60,7 @@ xmaddr_t arbitrary_virt_to_machine(unsigned long address)
 {
         unsigned int level;
         pte_t *pte = lookup_address(address, &level);
-        unsigned offset = address & PAGE_MASK;
+        unsigned offset = address & ~PAGE_MASK;
 
         BUG_ON(pte == NULL);
 
diff --git a/arch/x86/xen/time.c b/arch/x86/xen/time.c
index c39e1a5aa241..52b2e3856980 100644
--- a/arch/x86/xen/time.c
+++ b/arch/x86/xen/time.c
@@ -12,6 +12,7 @@
 #include <linux/clocksource.h>
 #include <linux/clockchips.h>
 #include <linux/kernel_stat.h>
+#include <linux/math64.h>
 
 #include <asm/xen/hypervisor.h>
 #include <asm/xen/hypercall.h>
@@ -150,11 +151,7 @@ static void do_stolen_accounting(void)
         if (stolen < 0)
                 stolen = 0;
 
-        ticks = 0;
-        while (stolen >= NS_PER_TICK) {
-                ticks++;
-                stolen -= NS_PER_TICK;
-        }
+        ticks = iter_div_u64_rem(stolen, NS_PER_TICK, &stolen);
         __get_cpu_var(residual_stolen) = stolen;
         account_steal_time(NULL, ticks);
 
@@ -166,11 +163,7 @@ static void do_stolen_accounting(void)
         if (blocked < 0)
                 blocked = 0;
 
-        ticks = 0;
-        while (blocked >= NS_PER_TICK) {
-                ticks++;
-                blocked -= NS_PER_TICK;
-        }
+        ticks = iter_div_u64_rem(blocked, NS_PER_TICK, &blocked);
         __get_cpu_var(residual_blocked) = blocked;
         account_steal_time(idle_task(smp_processor_id()), ticks);
 }