39 files changed, 541 insertions, 142 deletions
diff --git a/arch/x86/.gitignore b/arch/x86/.gitignore
new file mode 100644
index 000000000000..028079065af6
--- /dev/null
+++ b/arch/x86/.gitignore
@@ -0,0 +1,3 @@
+boot/compressed/vmlinux
+tools/test_get_len
diff --git a/arch/x86/boot/compressed/mkpiggy.c b/arch/x86/boot/compressed/mkpiggy.c
index bcbd36c41432..5c228129d175 100644
--- a/arch/x86/boot/compressed/mkpiggy.c
+++ b/arch/x86/boot/compressed/mkpiggy.c
@@ -77,7 +77,7 @@ int main(int argc, char *argv[])
        offs += 32*1024 + 18;   /* Add 32K + 18 bytes slack */
        offs = (offs+4095) & ~4095; /* Round to a 4K boundary */
-        printf(".section \".rodata.compressed\",\"a\",@progbits\n");
+        printf(".section \".rodata..compressed\",\"a\",@progbits\n");
        printf(".globl z_input_len\n");
        printf("z_input_len = %lu\n", ilen);
        printf(".globl z_output_len\n");
diff --git a/arch/x86/boot/compressed/vmlinux.lds.S b/arch/x86/boot/compressed/vmlinux.lds.S
index a6f1a59a5b0c..5ddabceee124 100644
--- a/arch/x86/boot/compressed/vmlinux.lds.S
+++ b/arch/x86/boot/compressed/vmlinux.lds.S
@@ -26,8 +26,8 @@ SECTIONS
                HEAD_TEXT
                _ehead = . ;
        }
-        .rodata.compressed : {
+        .rodata..compressed : {
-                *(.rodata.compressed)
+                *(.rodata..compressed)
        }
        .text : {
                _text = .;      /* Text */
diff --git a/arch/x86/include/asm/acpi.h b/arch/x86/include/asm/acpi.h
index 56f462cf22d2..aa2c39d968fc 100644
--- a/arch/x86/include/asm/acpi.h
+++ b/arch/x86/include/asm/acpi.h
@@ -85,7 +85,6 @@ extern int acpi_ioapic;
 extern int acpi_noirq;
 extern int acpi_strict;
 extern int acpi_disabled;
-extern int acpi_ht;
 extern int acpi_pci_disabled;
 extern int acpi_skip_timer_override;
 extern int acpi_use_timer_override;
@@ -97,7 +96,6 @@ void acpi_pic_sci_set_trigger(unsigned int, u16);
 static inline void disable_acpi(void)
 {
        acpi_disabled = 1;
-        acpi_ht = 0;
        acpi_pci_disabled = 1;
        acpi_noirq = 1;
 }
diff --git a/arch/x86/include/asm/cache.h b/arch/x86/include/asm/cache.h
index 2f9047cfaaca..48f99f15452e 100644
--- a/arch/x86/include/asm/cache.h
+++ b/arch/x86/include/asm/cache.h
@@ -7,7 +7,7 @@
 #define L1_CACHE_SHIFT  (CONFIG_X86_L1_CACHE_SHIFT)
 #define L1_CACHE_BYTES  (1 << L1_CACHE_SHIFT)
-#define __read_mostly __attribute__((__section__(".data.read_mostly")))
+#define __read_mostly __attribute__((__section__(".data..read_mostly")))
 #define INTERNODE_CACHE_SHIFT CONFIG_X86_INTERNODE_CACHE_SHIFT
 #define INTERNODE_CACHE_BYTES (1 << INTERNODE_CACHE_SHIFT)
diff --git a/arch/x86/include/asm/cpufeature.h b/arch/x86/include/asm/cpufeature.h
index dca9c545f44e..468145914389 100644
--- a/arch/x86/include/asm/cpufeature.h
+++ b/arch/x86/include/asm/cpufeature.h
@@ -332,6 +332,7 @@ static __always_inline __pure bool __static_cpu_has(u8 bit)
 #endif
 }
+#if __GNUC__ >= 4
 #define static_cpu_has(bit)                                     \
 (                                                               \
        __builtin_constant_p(boot_cpu_has(bit)) ?               \
@@ -340,6 +341,12 @@ static __always_inline __pure bool __static_cpu_has(u8 bit)
                __static_cpu_has(bit) :                         \
                boot_cpu_has(bit)                               \
 )
+#else
+/*
+ * gcc 3.x is too stupid to do the static test; fall back to dynamic.
+ */
+#define static_cpu_has(bit) boot_cpu_has(bit)
+#endif
 #endif /* defined(__KERNEL__) && !defined(__ASSEMBLY__) */
diff --git a/arch/x86/include/asm/mce.h b/arch/x86/include/asm/mce.h
index 6c3fdd631ed3..f32a4301c4d4 100644
--- a/arch/x86/include/asm/mce.h
+++ b/arch/x86/include/asm/mce.h
@@ -225,5 +225,13 @@ extern void mcheck_intel_therm_init(void);
 static inline void mcheck_intel_therm_init(void) { }
 #endif
+/*
+ * Used by APEI to report memory error via /dev/mcelog
+ */
+struct cper_sec_mem_err;
+extern void apei_mce_report_mem_error(int corrected,
+                                      struct cper_sec_mem_err *mem_err);
 #endif /* __KERNEL__ */
 #endif /* _ASM_X86_MCE_H */
diff --git a/arch/x86/include/asm/msr-index.h b/arch/x86/include/asm/msr-index.h
index b49d8ca228f6..8c7ae4318629 100644
--- a/arch/x86/include/asm/msr-index.h
+++ b/arch/x86/include/asm/msr-index.h
@@ -110,6 +110,7 @@
 #define MSR_AMD64_PATCH_LOADER          0xc0010020
 #define MSR_AMD64_OSVW_ID_LENGTH        0xc0010140
 #define MSR_AMD64_OSVW_STATUS           0xc0010141
+#define MSR_AMD64_DC_CFG                0xc0011022
 #define MSR_AMD64_IBSFETCHCTL           0xc0011030
 #define MSR_AMD64_IBSFETCHLINAD         0xc0011031
 #define MSR_AMD64_IBSFETCHPHYSAD        0xc0011032
diff --git a/arch/x86/include/asm/pci_x86.h b/arch/x86/include/asm/pci_x86.h
index 8d8797eae5d7..cd2a31dc5fb8 100644
--- a/arch/x86/include/asm/pci_x86.h
+++ b/arch/x86/include/asm/pci_x86.h
@@ -53,6 +53,8 @@ extern int pcibios_last_bus;
 extern struct pci_bus *pci_root_bus;
 extern struct pci_ops pci_root_ops;
+void pcibios_scan_specific_bus(int busn);
 /* pci-irq.c */
 struct irq_info {
diff --git a/arch/x86/include/asm/rdc321x_defs.h b/arch/x86/include/asm/rdc321x_defs.h
deleted file mode 100644
index c8e9c8bed3d0..000000000000
--- a/arch/x86/include/asm/rdc321x_defs.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#define PFX     "rdc321x: "
-/* General purpose configuration and data registers */
-#define RDC3210_CFGREG_ADDR     0x0CF8
-#define RDC3210_CFGREG_DATA     0x0CFC
-#define RDC321X_GPIO_CTRL_REG1  0x48
-#define RDC321X_GPIO_CTRL_REG2  0x84
-#define RDC321X_GPIO_DATA_REG1  0x4c
-#define RDC321X_GPIO_DATA_REG2  0x88
-#define RDC321X_MAX_GPIO        58
diff --git a/arch/x86/include/asm/thread_info.h b/arch/x86/include/asm/thread_info.h
index 62ba9400cc43..f0b6e5dbc5a0 100644
--- a/arch/x86/include/asm/thread_info.h
+++ b/arch/x86/include/asm/thread_info.h
@@ -239,8 +239,8 @@ static inline struct thread_info *current_thread_info(void)
 #define TS_USEDFPU              0x0001  /* FPU was used by this task
                                           this quantum (SMP) */
 #define TS_COMPAT               0x0002  /* 32bit syscall active (64BIT)*/
-#define TS_POLLING              0x0004  /* true if in idle loop
+#define TS_POLLING              0x0004  /* idle task polling need_resched,
-                                           and not sleeping */
+                                           skip sending interrupt */
 #define TS_RESTORE_SIGMASK      0x0008  /* restore signal mask in do_signal() */
 #define tsk_is_polling(t) (task_thread_info(t)->status & TS_POLLING)
diff --git a/arch/x86/kernel/acpi/boot.c b/arch/x86/kernel/acpi/boot.c
index 488be461a380..60cc4058ed5f 100644
--- a/arch/x86/kernel/acpi/boot.c
+++ b/arch/x86/kernel/acpi/boot.c
@@ -63,7 +63,6 @@ EXPORT_SYMBOL(acpi_disabled);
 int acpi_noirq;                         /* skip ACPI IRQ initialization */
 int acpi_pci_disabled;          /* skip ACPI PCI scan and IRQ initialization */
 EXPORT_SYMBOL(acpi_pci_disabled);
-int acpi_ht __initdata = 1;     /* enable HT */
 int acpi_lapic;
 int acpi_ioapic;
@@ -1501,9 +1500,8 @@ void __init acpi_boot_table_init(void)
        /*
         * If acpi_disabled, bail out
-         * One exception: acpi=ht continues far enough to enumerate LAPICs
         */
-        if (acpi_disabled && !acpi_ht)
+        if (acpi_disabled)
                return; 
        /*
@@ -1534,9 +1532,8 @@ int __init early_acpi_boot_init(void)
 {
        /*
         * If acpi_disabled, bail out
-         * One exception: acpi=ht continues far enough to enumerate LAPICs
         */
-        if (acpi_disabled && !acpi_ht)
+        if (acpi_disabled)
                return 1;
        /*
@@ -1554,9 +1551,8 @@ int __init acpi_boot_init(void)
        /*
         * If acpi_disabled, bail out
-         * One exception: acpi=ht continues far enough to enumerate LAPICs
         */
-        if (acpi_disabled && !acpi_ht)
+        if (acpi_disabled)
                return 1;
        acpi_table_parse(ACPI_SIG_BOOT, acpi_parse_sbf);
@@ -1591,21 +1587,12 @@ static int __init parse_acpi(char *arg)
        /* acpi=force to over-ride black-list */
        else if (strcmp(arg, "force") == 0) {
                acpi_force = 1;
-                acpi_ht = 1;
                acpi_disabled = 0;
        }
        /* acpi=strict disables out-of-spec workarounds */
        else if (strcmp(arg, "strict") == 0) {
                acpi_strict = 1;
        }
-        /* Limit ACPI just to boot-time to enable HT */
-        else if (strcmp(arg, "ht") == 0) {
-                if (!acpi_force) {
-                        printk(KERN_WARNING "acpi=ht will be removed in Linux-2.6.35\n");
-                        disable_acpi();
-                }
-                acpi_ht = 1;
-        }
        /* acpi=rsdt use RSDT instead of XSDT */
        else if (strcmp(arg, "rsdt") == 0) {
                acpi_rsdt_forced = 1;
diff --git a/arch/x86/kernel/acpi/sleep.c b/arch/x86/kernel/acpi/sleep.c
index f9961034e557..82e508677b91 100644
--- a/arch/x86/kernel/acpi/sleep.c
+++ b/arch/x86/kernel/acpi/sleep.c
@@ -162,8 +162,6 @@ static int __init acpi_sleep_setup(char *str)
 #endif
                if (strncmp(str, "old_ordering", 12) == 0)
                        acpi_old_suspend_ordering();
-                if (strncmp(str, "sci_force_enable", 16) == 0)
-                        acpi_set_sci_en_on_resume();
                str = strchr(str, ',');
                if (str != NULL)
                        str += strspn(str, ", \t");
diff --git a/arch/x86/kernel/acpi/wakeup_32.S b/arch/x86/kernel/acpi/wakeup_32.S
index 8ded418b0593..13ab720573e3 100644
--- a/arch/x86/kernel/acpi/wakeup_32.S
+++ b/arch/x86/kernel/acpi/wakeup_32.S
@@ -1,4 +1,4 @@
-        .section .text.page_aligned
+        .section .text..page_aligned
 #include <linux/linkage.h>
 #include <asm/segment.h>
 #include <asm/page_types.h>
diff --git a/arch/x86/kernel/amd_iommu.c b/arch/x86/kernel/amd_iommu.c
index fa5a1474cd18..0d20286d78c6 100644
--- a/arch/x86/kernel/amd_iommu.c
+++ b/arch/x86/kernel/amd_iommu.c
@@ -1487,6 +1487,7 @@ static int __attach_device(struct device *dev,
                           struct protection_domain *domain)
 {
        struct iommu_dev_data *dev_data, *alias_data;
+        int ret;
        dev_data   = get_dev_data(dev);
        alias_data = get_dev_data(dev_data->alias);
@@ -1498,13 +1499,14 @@ static int __attach_device(struct device *dev,
        spin_lock(&domain->lock);
        /* Some sanity checks */
+        ret = -EBUSY;
        if (alias_data->domain != NULL &&
            alias_data->domain != domain)
-                return -EBUSY;
+                goto out_unlock;
        if (dev_data->domain != NULL &&
            dev_data->domain != domain)
-                return -EBUSY;
+                goto out_unlock;
        /* Do real assignment */
        if (dev_data->alias != dev) {
@@ -1520,10 +1522,14 @@ static int __attach_device(struct device *dev,
        atomic_inc(&dev_data->bind);
+        ret = 0;
+out_unlock:
        /* ready */
        spin_unlock(&domain->lock);
-        return 0;
+        return ret;
 }
 /*
@@ -2324,10 +2330,6 @@ int __init amd_iommu_init_dma_ops(void)
        iommu_detected = 1;
        swiotlb = 0;
-#ifdef CONFIG_GART_IOMMU
-        gart_iommu_aperture_disabled = 1;
-        gart_iommu_aperture = 0;
-#endif
        /* Make the driver finally visible to the drivers */
        dma_ops = &amd_iommu_dma_ops;
diff --git a/arch/x86/kernel/amd_iommu_init.c b/arch/x86/kernel/amd_iommu_init.c
index 3bacb4d0844c..3cc63e2b8dd4 100644
--- a/arch/x86/kernel/amd_iommu_init.c
+++ b/arch/x86/kernel/amd_iommu_init.c
@@ -287,8 +287,12 @@ static u8 * __init iommu_map_mmio_space(u64 address)
 {
        u8 *ret;
-        if (!request_mem_region(address, MMIO_REGION_LENGTH, "amd_iommu"))
+        if (!request_mem_region(address, MMIO_REGION_LENGTH, "amd_iommu")) {
+                pr_err("AMD-Vi: Can not reserve memory region %llx for mmio\n",
+                        address);
+                pr_err("AMD-Vi: This is a BIOS bug. Please contact your hardware vendor\n");
                return NULL;
+        }
        ret = ioremap_nocache(address, MMIO_REGION_LENGTH);
        if (ret != NULL)
@@ -1314,7 +1318,7 @@ static int __init amd_iommu_init(void)
                ret = amd_iommu_init_dma_ops();
        if (ret)
-                goto free;
+                goto free_disable;
        amd_iommu_init_api();
@@ -1332,9 +1336,10 @@ static int __init amd_iommu_init(void)
 out:
        return ret;
-free:
+free_disable:
        disable_iommus();
+free:
        amd_iommu_uninit_devices();
        free_pages((unsigned long)amd_iommu_pd_alloc_bitmap,
@@ -1353,6 +1358,15 @@ free:
        free_unity_maps();
+#ifdef CONFIG_GART_IOMMU
+        /*
+         * We failed to initialize the AMD IOMMU - try fallback to GART
+         * if possible.
+         */
+        gart_iommu_init();
+#endif
        goto out;
 }
diff --git a/arch/x86/kernel/apic/apic.c b/arch/x86/kernel/apic/apic.c
index e5a4a1e01618..c02cc692985c 100644
--- a/arch/x86/kernel/apic/apic.c
+++ b/arch/x86/kernel/apic/apic.c
@@ -51,6 +51,7 @@
 #include <asm/smp.h>
 #include <asm/mce.h>
 #include <asm/kvm_para.h>
+#include <asm/tsc.h>
 unsigned int num_processors;
@@ -1151,8 +1152,13 @@ static void __cpuinit lapic_setup_esr(void)
 */
 void __cpuinit setup_local_APIC(void)
 {
-        unsigned int value;
+        unsigned int value, queued;
-        int i, j;
+        int i, j, acked = 0;
+        unsigned long long tsc = 0, ntsc;
+        long long max_loops = cpu_khz;
+        if (cpu_has_tsc)
+                rdtscll(tsc);
        if (disable_apic) {
                arch_disable_smp_support();
@@ -1204,13 +1210,32 @@ void __cpuinit setup_local_APIC(void)
         * the interrupt. Hence a vector might get locked. It was noticed
         * for timer irq (vector 0x31). Issue an extra EOI to clear ISR.
         */
-        for (i = APIC_ISR_NR - 1; i >= 0; i--) {
+        do {
-                value = apic_read(APIC_ISR + i*0x10);
+                queued = 0;
-                for (j = 31; j >= 0; j--) {
+                for (i = APIC_ISR_NR - 1; i >= 0; i--)
-                        if (value & (1<<j))
+                        queued |= apic_read(APIC_IRR + i*0x10);
-                                ack_APIC_irq();
+                for (i = APIC_ISR_NR - 1; i >= 0; i--) {
+                        value = apic_read(APIC_ISR + i*0x10);
+                        for (j = 31; j >= 0; j--) {
+                                if (value & (1<<j)) {
+                                        ack_APIC_irq();
+                                        acked++;
+                                }
+                        }
                }
-        }
+                if (acked > 256) {
+                        printk(KERN_ERR "LAPIC pending interrupts after %d EOI\n",
+                               acked);
+                        break;
+                }
+                if (cpu_has_tsc) {
+                        rdtscll(ntsc);
+                        max_loops = (cpu_khz << 10) - (ntsc - tsc);
+                } else
+                        max_loops--;
+        } while (queued && max_loops > 0);
+        WARN_ON(max_loops <= 0);
        /*
         * Now that we are all set up, enable the APIC
diff --git a/arch/x86/kernel/cpu/cpufreq/powernow-k8.c b/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
index 6f3dc8fbbfdc..7ec2123838e6 100644
--- a/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
+++ b/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
@@ -1497,8 +1497,8 @@ static struct cpufreq_driver cpufreq_amd64_driver = {
 * simply keep the boost-disable flag in sync with the current global
 * state.
 */
-static int __cpuinit cpb_notify(struct notifier_block *nb, unsigned long action,
+static int cpb_notify(struct notifier_block *nb, unsigned long action,
-                                void *hcpu)
+                      void *hcpu)
 {
        unsigned cpu = (long)hcpu;
        u32 lo, hi;
@@ -1528,7 +1528,7 @@ static int __cpuinit cpb_notify(struct notifier_block *nb, unsigned long action,
        return NOTIFY_OK;
 }
-static struct notifier_block __cpuinitdata cpb_nb = {
+static struct notifier_block cpb_nb = {
        .notifier_call          = cpb_notify,
 };
diff --git a/arch/x86/kernel/cpu/mcheck/Makefile b/arch/x86/kernel/cpu/mcheck/Makefile
index 4ac6d48fe11b..bb34b03af252 100644
--- a/arch/x86/kernel/cpu/mcheck/Makefile
+++ b/arch/x86/kernel/cpu/mcheck/Makefile
@@ -7,3 +7,5 @@ obj-$(CONFIG_X86_MCE_THRESHOLD) += threshold.o
 obj-$(CONFIG_X86_MCE_INJECT)    += mce-inject.o
 obj-$(CONFIG_X86_THERMAL_VECTOR) += therm_throt.o
+obj-$(CONFIG_ACPI_APEI)         += mce-apei.o
diff --git a/arch/x86/kernel/cpu/mcheck/mce-apei.c b/arch/x86/kernel/cpu/mcheck/mce-apei.c
new file mode 100644
index 000000000000..745b54f9be89
--- /dev/null
+++ b/arch/x86/kernel/cpu/mcheck/mce-apei.c
@@ -0,0 +1,138 @@
+/*
+ * Bridge between MCE and APEI
+ *
+ * On some machine, corrected memory errors are reported via APEI
+ * generic hardware error source (GHES) instead of corrected Machine
+ * Check. These corrected memory errors can be reported to user space
+ * through /dev/mcelog via faking a corrected Machine Check, so that
+ * the error memory page can be offlined by /sbin/mcelog if the error
+ * count for one page is beyond the threshold.
+ *
+ * For fatal MCE, save MCE record into persistent storage via ERST, so
+ * that the MCE record can be logged after reboot via ERST.
+ *
+ * Copyright 2010 Intel Corp.
+ *   Author: Huang Ying <ying.huang@intel.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version
+ * 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#include <linux/kernel.h>
+#include <linux/acpi.h>
+#include <linux/cper.h>
+#include <acpi/apei.h>
+#include <asm/mce.h>
+#include "mce-internal.h"
+void apei_mce_report_mem_error(int corrected, struct cper_sec_mem_err *mem_err)
+{
+        struct mce m;
+        /* Only corrected MC is reported */
+        if (!corrected)
+                return;
+        mce_setup(&m);
+        m.bank = 1;
+        /* Fake a memory read corrected error with unknown channel */
+        m.status = MCI_STATUS_VAL | MCI_STATUS_EN | MCI_STATUS_ADDRV | 0x9f;
+        m.addr = mem_err->physical_addr;
+        mce_log(&m);
+        mce_notify_irq();
+}
+EXPORT_SYMBOL_GPL(apei_mce_report_mem_error);
+#define CPER_CREATOR_MCE                                                \
+        UUID_LE(0x75a574e3, 0x5052, 0x4b29, 0x8a, 0x8e, 0xbe, 0x2c,     \
+                0x64, 0x90, 0xb8, 0x9d)
+#define CPER_SECTION_TYPE_MCE                                           \
+        UUID_LE(0xfe08ffbe, 0x95e4, 0x4be7, 0xbc, 0x73, 0x40, 0x96,     \
+                0x04, 0x4a, 0x38, 0xfc)
+/*
+ * CPER specification (in UEFI specification 2.3 appendix N) requires
+ * byte-packed.
+ */
+struct cper_mce_record {
+        struct cper_record_header hdr;
+        struct cper_section_descriptor sec_hdr;
+        struct mce mce;
+} __packed;
+int apei_write_mce(struct mce *m)
+{
+        struct cper_mce_record rcd;
+        memset(&rcd, 0, sizeof(rcd));
+        memcpy(rcd.hdr.signature, CPER_SIG_RECORD, CPER_SIG_SIZE);
+        rcd.hdr.revision = CPER_RECORD_REV;
+        rcd.hdr.signature_end = CPER_SIG_END;
+        rcd.hdr.section_count = 1;
+        rcd.hdr.error_severity = CPER_SER_FATAL;
+        /* timestamp, platform_id, partition_id are all invalid */
+        rcd.hdr.validation_bits = 0;
+        rcd.hdr.record_length = sizeof(rcd);
+        rcd.hdr.creator_id = CPER_CREATOR_MCE;
+        rcd.hdr.notification_type = CPER_NOTIFY_MCE;
+        rcd.hdr.record_id = cper_next_record_id();
+        rcd.hdr.flags = CPER_HW_ERROR_FLAGS_PREVERR;
+        rcd.sec_hdr.section_offset = (void *)&rcd.mce - (void *)&rcd;
+        rcd.sec_hdr.section_length = sizeof(rcd.mce);
+        rcd.sec_hdr.revision = CPER_SEC_REV;
+        /* fru_id and fru_text is invalid */
+        rcd.sec_hdr.validation_bits = 0;
+        rcd.sec_hdr.flags = CPER_SEC_PRIMARY;
+        rcd.sec_hdr.section_type = CPER_SECTION_TYPE_MCE;
+        rcd.sec_hdr.section_severity = CPER_SER_FATAL;
+        memcpy(&rcd.mce, m, sizeof(*m));
+        return erst_write(&rcd.hdr);
+}
+ssize_t apei_read_mce(struct mce *m, u64 *record_id)
+{
+        struct cper_mce_record rcd;
+        ssize_t len;
+        len = erst_read_next(&rcd.hdr, sizeof(rcd));
+        if (len <= 0)
+                return len;
+        /* Can not skip other records in storage via ERST unless clear them */
+        else if (len != sizeof(rcd) ||
+                 uuid_le_cmp(rcd.hdr.creator_id, CPER_CREATOR_MCE)) {
+                if (printk_ratelimit())
+                        pr_warning(
+                        "MCE-APEI: Can not skip the unknown record in ERST");
+                return -EIO;
+        }
+        memcpy(m, &rcd.mce, sizeof(*m));
+        *record_id = rcd.hdr.record_id;
+        return sizeof(*m);
+}
+/* Check whether there is record in ERST */
+int apei_check_mce(void)
+{
+        return erst_get_record_count();
+}
+int apei_clear_mce(u64 record_id)
+{
+        return erst_clear(record_id);
+}
diff --git a/arch/x86/kernel/cpu/mcheck/mce-internal.h b/arch/x86/kernel/cpu/mcheck/mce-internal.h
index 32996f9fab67..fefcc69ee8b5 100644
--- a/arch/x86/kernel/cpu/mcheck/mce-internal.h
+++ b/arch/x86/kernel/cpu/mcheck/mce-internal.h
@@ -28,3 +28,26 @@ extern int mce_ser;
 extern struct mce_bank *mce_banks;
+#ifdef CONFIG_ACPI_APEI
+int apei_write_mce(struct mce *m);
+ssize_t apei_read_mce(struct mce *m, u64 *record_id);
+int apei_check_mce(void);
+int apei_clear_mce(u64 record_id);
+#else
+static inline int apei_write_mce(struct mce *m)
+{
+        return -EINVAL;
+}
+static inline ssize_t apei_read_mce(struct mce *m, u64 *record_id)
+{
+        return 0;
+}
+static inline int apei_check_mce(void)
+{
+        return 0;
+}
+static inline int apei_clear_mce(u64 record_id)
+{
+        return -EINVAL;
+}
+#endif
diff --git a/arch/x86/kernel/cpu/mcheck/mce.c b/arch/x86/kernel/cpu/mcheck/mce.c
index 7a355ddcc64b..18cc42562250 100644
--- a/arch/x86/kernel/cpu/mcheck/mce.c
+++ b/arch/x86/kernel/cpu/mcheck/mce.c
@@ -36,6 +36,7 @@
 #include <linux/fs.h>
 #include <linux/mm.h>
 #include <linux/debugfs.h>
+#include <linux/edac_mce.h>
 #include <asm/processor.h>
 #include <asm/hw_irq.h>
@@ -169,6 +170,15 @@ void mce_log(struct mce *mce)
                entry = rcu_dereference_check_mce(mcelog.next);
                for (;;) {
                        /*
+                         * If edac_mce is enabled, it will check the error type
+                         * and will process it, if it is a known error.
+                         * Otherwise, the error will be sent through mcelog
+                         * interface
+                         */
+                        if (edac_mce_parse(mce))
+                                return;
+                        /*
                         * When the buffer fills up discard new entries.
                         * Assume that the earlier errors are the more
                         * interesting ones:
@@ -264,7 +274,7 @@ static void wait_for_panic(void)
 static void mce_panic(char *msg, struct mce *final, char *exp)
 {
-        int i;
+        int i, apei_err = 0;
        if (!fake_panic) {
                /*
@@ -287,8 +297,11 @@ static void mce_panic(char *msg, struct mce *final, char *exp)
                struct mce *m = &mcelog.entry[i];
                if (!(m->status & MCI_STATUS_VAL))
                        continue;
-                if (!(m->status & MCI_STATUS_UC))
+                if (!(m->status & MCI_STATUS_UC)) {
                        print_mce(m);
+                        if (!apei_err)
+                                apei_err = apei_write_mce(m);
+                }
        }
        /* Now print uncorrected but with the final one last */
        for (i = 0; i < MCE_LOG_LEN; i++) {
@@ -297,11 +310,17 @@ static void mce_panic(char *msg, struct mce *final, char *exp)
                        continue;
                if (!(m->status & MCI_STATUS_UC))
                        continue;
-                if (!final || memcmp(m, final, sizeof(struct mce)))
+                if (!final || memcmp(m, final, sizeof(struct mce))) {
                        print_mce(m);
+                        if (!apei_err)
+                                apei_err = apei_write_mce(m);
+                }
        }
-        if (final)
+        if (final) {
                print_mce(final);
+                if (!apei_err)
+                        apei_err = apei_write_mce(final);
+        }
        if (cpu_missing)
                printk(KERN_EMERG "Some CPUs didn't answer in synchronization\n");
        print_mce_tail();
@@ -1493,6 +1512,43 @@ static void collect_tscs(void *data)
        rdtscll(cpu_tsc[smp_processor_id()]);
 }
+static int mce_apei_read_done;
+/* Collect MCE record of previous boot in persistent storage via APEI ERST. */
+static int __mce_read_apei(char __user **ubuf, size_t usize)
+{
+        int rc;
+        u64 record_id;
+        struct mce m;
+        if (usize < sizeof(struct mce))
+                return -EINVAL;
+        rc = apei_read_mce(&m, &record_id);
+        /* Error or no more MCE record */
+        if (rc <= 0) {
+                mce_apei_read_done = 1;
+                return rc;
+        }
+        rc = -EFAULT;
+        if (copy_to_user(*ubuf, &m, sizeof(struct mce)))
+                return rc;
+        /*
+         * In fact, we should have cleared the record after that has
+         * been flushed to the disk or sent to network in
+         * /sbin/mcelog, but we have no interface to support that now,
+         * so just clear it to avoid duplication.
+         */
+        rc = apei_clear_mce(record_id);
+        if (rc) {
+                mce_apei_read_done = 1;
+                return rc;
+        }
+        *ubuf += sizeof(struct mce);
+        return 0;
+}
 static ssize_t mce_read(struct file *filp, char __user *ubuf, size_t usize,
                        loff_t *off)
 {
@@ -1506,15 +1562,19 @@ static ssize_t mce_read(struct file *filp, char __user *ubuf, size_t usize,
                return -ENOMEM;
        mutex_lock(&mce_read_mutex);
+        if (!mce_apei_read_done) {
+                err = __mce_read_apei(&buf, usize);
+                if (err || buf != ubuf)
+                        goto out;
+        }
        next = rcu_dereference_check_mce(mcelog.next);
        /* Only supports full reads right now */
-        if (*off != 0 || usize < MCE_LOG_LEN*sizeof(struct mce)) {
+        err = -EINVAL;
-                mutex_unlock(&mce_read_mutex);
+        if (*off != 0 || usize < MCE_LOG_LEN*sizeof(struct mce))
-                kfree(cpu_tsc);
+                goto out;
-                return -EINVAL;
-        }
        err = 0;
        prev = 0;
@@ -1562,10 +1622,15 @@ timeout:
                        memset(&mcelog.entry[i], 0, sizeof(struct mce));
                }
        }
+        if (err)
+                err = -EFAULT;
+out:
        mutex_unlock(&mce_read_mutex);
        kfree(cpu_tsc);
-        return err ? -EFAULT : buf - ubuf;
+        return err ? err : buf - ubuf;
 }
 static unsigned int mce_poll(struct file *file, poll_table *wait)
@@ -1573,6 +1638,8 @@ static unsigned int mce_poll(struct file *file, poll_table *wait)
        poll_wait(file, &mce_wait, wait);
        if (rcu_dereference_check_mce(mcelog.next))
                return POLLIN | POLLRDNORM;
+        if (!mce_apei_read_done && apei_check_mce())
+                return POLLIN | POLLRDNORM;
        return 0;
 }
diff --git a/arch/x86/kernel/cpu/perf_event.c b/arch/x86/kernel/cpu/perf_event.c
index c77586061bcb..5db5b7d65a18 100644
--- a/arch/x86/kernel/cpu/perf_event.c
+++ b/arch/x86/kernel/cpu/perf_event.c
@@ -106,6 +106,7 @@ struct cpu_hw_events {
        int                     n_events;
        int                     n_added;
+        int                     n_txn;
        int                     assign[X86_PMC_IDX_MAX]; /* event to counter assignment */
        u64                     tags[X86_PMC_IDX_MAX];
        struct perf_event       *event_list[X86_PMC_IDX_MAX]; /* in enabled order */
@@ -983,6 +984,7 @@ static int x86_pmu_enable(struct perf_event *event)
 out:
        cpuc->n_events = n;
        cpuc->n_added += n - n0;
+        cpuc->n_txn += n - n0;
        return 0;
 }
@@ -1089,6 +1091,14 @@ static void x86_pmu_disable(struct perf_event *event)
        struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
        int i;
+        /*
+         * If we're called during a txn, we don't need to do anything.
+         * The events never got scheduled and ->cancel_txn will truncate
+         * the event_list.
+         */
+        if (cpuc->group_flag & PERF_EVENT_TXN_STARTED)
+                return;
        x86_pmu_stop(event);
        for (i = 0; i < cpuc->n_events; i++) {
@@ -1379,6 +1389,7 @@ static void x86_pmu_start_txn(const struct pmu *pmu)
        struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
        cpuc->group_flag |= PERF_EVENT_TXN_STARTED;
+        cpuc->n_txn = 0;
 }
 /*
@@ -1391,6 +1402,11 @@ static void x86_pmu_cancel_txn(const struct pmu *pmu)
        struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
        cpuc->group_flag &= ~PERF_EVENT_TXN_STARTED;
+        /*
+         * Truncate the collected events.
+         */
+        cpuc->n_added -= cpuc->n_txn;
+        cpuc->n_events -= cpuc->n_txn;
 }
 /*
@@ -1419,6 +1435,12 @@ static int x86_pmu_commit_txn(const struct pmu *pmu)
         */
        memcpy(cpuc->assign, assign, n*sizeof(int));
+        /*
+         * Clear out the txn count so that ->cancel_txn() which gets
+         * run after ->commit_txn() doesn't undo things.
+         */
+        cpuc->n_txn = 0;
        return 0;
 }
diff --git a/arch/x86/kernel/init_task.c b/arch/x86/kernel/init_task.c
index 3a54dcb9cd0e..43e9ccf44947 100644
--- a/arch/x86/kernel/init_task.c
+++ b/arch/x86/kernel/init_task.c
@@ -34,7 +34,7 @@ EXPORT_SYMBOL(init_task);
 /*
 * per-CPU TSS segments. Threads are completely 'soft' on Linux,
 * no more per-task TSS's. The TSS size is kept cacheline-aligned
- * so they are allowed to end up in the .data.cacheline_aligned
+ * so they are allowed to end up in the .data..cacheline_aligned
 * section. Since TSS's are completely CPU-local, we want them
 * on exact cacheline boundaries, to eliminate cacheline ping-pong.
 */
diff --git a/arch/x86/kernel/setup.c b/arch/x86/kernel/setup.c
index e8029896309a..b4ae4acbd031 100644
--- a/arch/x86/kernel/setup.c
+++ b/arch/x86/kernel/setup.c
@@ -676,6 +676,17 @@ static struct dmi_system_id __initdata bad_bios_dmi_table[] = {
                        DMI_MATCH(DMI_BOARD_NAME, "DG45FC"),
                },
        },
+        /*
+         * The Dell Inspiron Mini 1012 has DMI_BIOS_VENDOR = "Dell Inc.", so
+         * match on the product name.
+         */
+        {
+                .callback = dmi_low_memory_corruption,
+                .ident = "Phoenix BIOS",
+                .matches = {
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 1012"),
+                },
+        },
 #endif
        {}
 };
diff --git a/arch/x86/kernel/setup_percpu.c b/arch/x86/kernel/setup_percpu.c
index a867940a6dfc..de3b63ae3da2 100644
--- a/arch/x86/kernel/setup_percpu.c
+++ b/arch/x86/kernel/setup_percpu.c
@@ -21,12 +21,6 @@
 #include <asm/cpu.h>
 #include <asm/stackprotector.h>
-#ifdef CONFIG_DEBUG_PER_CPU_MAPS
-# define DBG(fmt, ...) pr_dbg(fmt, ##__VA_ARGS__)
-#else
-# define DBG(fmt, ...) do { if (0) pr_dbg(fmt, ##__VA_ARGS__); } while (0)
-#endif
 DEFINE_PER_CPU(int, cpu_number);
 EXPORT_PER_CPU_SYMBOL(cpu_number);
@@ -247,7 +241,7 @@ void __init setup_per_cpu_areas(void)
 #endif
 #endif
                /*
-                 * Up to this point, the boot CPU has been using .data.init
+                 * Up to this point, the boot CPU has been using .init.data
                 * area.  Reload any changed state for the boot CPU.
                 */
                if (cpu == boot_cpu_id)
diff --git a/arch/x86/kernel/smpboot.c b/arch/x86/kernel/smpboot.c
index 763d815e27a0..c4f33b2e77d6 100644
--- a/arch/x86/kernel/smpboot.c
+++ b/arch/x86/kernel/smpboot.c
@@ -686,7 +686,7 @@ static void __cpuinit do_fork_idle(struct work_struct *work)
 static void __cpuinit announce_cpu(int cpu, int apicid)
 {
        static int current_node = -1;
-        int node = cpu_to_node(cpu);
+        int node = early_cpu_to_node(cpu);
        if (system_state == SYSTEM_BOOTING) {
                if (node != current_node) {
@@ -1215,9 +1215,17 @@ __init void prefill_possible_map(void)
        if (!num_processors)
                num_processors = 1;
-        if (setup_possible_cpus == -1)
+        i = setup_max_cpus ?: 1;
-                possible = num_processors + disabled_cpus;
+        if (setup_possible_cpus == -1) {
-        else
+                possible = num_processors;
+#ifdef CONFIG_HOTPLUG_CPU
+                if (setup_max_cpus)
+                        possible += disabled_cpus;
+#else
+                if (possible > i)
+                        possible = i;
+#endif
+        } else
                possible = setup_possible_cpus;
        total_cpus = max_t(int, possible, num_processors + disabled_cpus);
@@ -1230,11 +1238,23 @@ __init void prefill_possible_map(void)
                possible = nr_cpu_ids;
        }
+#ifdef CONFIG_HOTPLUG_CPU
+        if (!setup_max_cpus)
+#endif
+        if (possible > i) {
+                printk(KERN_WARNING
+                        "%d Processors exceeds max_cpus limit of %u\n",
+                        possible, setup_max_cpus);
+                possible = i;
+        }
        printk(KERN_INFO "SMP: Allowing %d CPUs, %d hotplug CPUs\n",
                possible, max_t(int, possible - num_processors, 0));
        for (i = 0; i < possible; i++)
                set_cpu_possible(i, true);
+        for (; i < NR_CPUS; i++)
+                set_cpu_possible(i, false);
        nr_cpu_ids = possible;
 }
diff --git a/arch/x86/kernel/vmlinux.lds.S b/arch/x86/kernel/vmlinux.lds.S
index 2cc249718c46..d0bb52296fa3 100644
--- a/arch/x86/kernel/vmlinux.lds.S
+++ b/arch/x86/kernel/vmlinux.lds.S
@@ -97,7 +97,7 @@ SECTIONS
                HEAD_TEXT
 #ifdef CONFIG_X86_32
                . = ALIGN(PAGE_SIZE);
-                *(.text.page_aligned)
+                *(.text..page_aligned)
 #endif
                . = ALIGN(8);
                _stext = .;
@@ -305,7 +305,7 @@ SECTIONS
        . = ALIGN(PAGE_SIZE);
        .bss : AT(ADDR(.bss) - LOAD_OFFSET) {
                __bss_start = .;
-                *(.bss.page_aligned)
+                *(.bss..page_aligned)
                *(.bss)
                . = ALIGN(4);
                __bss_stop = .;
diff --git a/arch/x86/kvm/mmu.c b/arch/x86/kvm/mmu.c
index 81563e76e28f..a6f695d76928 100644
--- a/arch/x86/kvm/mmu.c
+++ b/arch/x86/kvm/mmu.c
@@ -1815,6 +1815,9 @@ static int set_spte(struct kvm_vcpu *vcpu, u64 *sptep,
                spte |= PT_WRITABLE_MASK;
+                if (!tdp_enabled && !(pte_access & ACC_WRITE_MASK))
+                        spte &= ~PT_USER_MASK;
                /*
                 * Optimization: for pte sync, if spte was writable the hash
                 * lookup is unnecessary (and expensive). Write protection
@@ -1870,6 +1873,8 @@ static void mmu_set_spte(struct kvm_vcpu *vcpu, u64 *sptep,
                        child = page_header(pte & PT64_BASE_ADDR_MASK);
                        mmu_page_remove_parent_pte(child, sptep);
+                        __set_spte(sptep, shadow_trap_nonpresent_pte);
+                        kvm_flush_remote_tlbs(vcpu->kvm);
                } else if (pfn != spte_to_pfn(*sptep)) {
                        pgprintk("hfn old %lx new %lx\n",
                                 spte_to_pfn(*sptep), pfn);
diff --git a/arch/x86/kvm/svm.c b/arch/x86/kvm/svm.c
index 96dc232bfc56..ce438e0fdd26 100644
--- a/arch/x86/kvm/svm.c
+++ b/arch/x86/kvm/svm.c
@@ -28,6 +28,7 @@
 #include <linux/ftrace_event.h>
 #include <linux/slab.h>
+#include <asm/tlbflush.h>
 #include <asm/desc.h>
 #include <asm/virtext.h>
@@ -56,6 +57,8 @@ MODULE_LICENSE("GPL");
 #define DEBUGCTL_RESERVED_BITS (~(0x3fULL))
+static bool erratum_383_found __read_mostly;
 static const u32 host_save_user_msrs[] = {
 #ifdef CONFIG_X86_64
        MSR_STAR, MSR_LSTAR, MSR_CSTAR, MSR_SYSCALL_MASK, MSR_KERNEL_GS_BASE,
@@ -374,6 +377,31 @@ static void svm_queue_exception(struct kvm_vcpu *vcpu, unsigned nr,
        svm->vmcb->control.event_inj_err = error_code;
 }
+static void svm_init_erratum_383(void)
+{
+        u32 low, high;
+        int err;
+        u64 val;
+        /* Only Fam10h is affected */
+        if (boot_cpu_data.x86 != 0x10)
+                return;
+        /* Use _safe variants to not break nested virtualization */
+        val = native_read_msr_safe(MSR_AMD64_DC_CFG, &err);
+        if (err)
+                return;
+        val |= (1ULL << 47);
+        low  = lower_32_bits(val);
+        high = upper_32_bits(val);
+        native_write_msr_safe(MSR_AMD64_DC_CFG, low, high);
+        erratum_383_found = true;
+}
 static int has_svm(void)
 {
        const char *msg;
@@ -429,6 +457,8 @@ static int svm_hardware_enable(void *garbage)
        wrmsrl(MSR_VM_HSAVE_PA, page_to_pfn(sd->save_area) << PAGE_SHIFT);
+        svm_init_erratum_383();
        return 0;
 }
@@ -1410,8 +1440,59 @@ static int nm_interception(struct vcpu_svm *svm)
        return 1;
 }
-static int mc_interception(struct vcpu_svm *svm)
+static bool is_erratum_383(void)
 {
+        int err, i;
+        u64 value;
+        if (!erratum_383_found)
+                return false;
+        value = native_read_msr_safe(MSR_IA32_MC0_STATUS, &err);
+        if (err)
+                return false;
+        /* Bit 62 may or may not be set for this mce */
+        value &= ~(1ULL << 62);
+        if (value != 0xb600000000010015ULL)
+                return false;
+        /* Clear MCi_STATUS registers */
+        for (i = 0; i < 6; ++i)
+                native_write_msr_safe(MSR_IA32_MCx_STATUS(i), 0, 0);
+        value = native_read_msr_safe(MSR_IA32_MCG_STATUS, &err);
+        if (!err) {
+                u32 low, high;
+                value &= ~(1ULL << 2);
+                low    = lower_32_bits(value);
+                high   = upper_32_bits(value);
+                native_write_msr_safe(MSR_IA32_MCG_STATUS, low, high);
+        }
+        /* Flush tlb to evict multi-match entries */
+        __flush_tlb_all();
+        return true;
+}
+static void svm_handle_mce(struct vcpu_svm *svm)
+{
+        if (is_erratum_383()) {
+                /*
+                 * Erratum 383 triggered. Guest state is corrupt so kill the
+                 * guest.
+                 */
+                pr_err("KVM: Guest triggered AMD Erratum 383\n");
+                set_bit(KVM_REQ_TRIPLE_FAULT, &svm->vcpu.requests);
+                return;
+        }
        /*
         * On an #MC intercept the MCE handler is not called automatically in
         * the host. So do it by hand here.
@@ -1420,6 +1501,11 @@ static int mc_interception(struct vcpu_svm *svm)
                "int $0x12\n");
        /* not sure if we ever come back to this point */
+        return;
+}
+static int mc_interception(struct vcpu_svm *svm)
+{
        return 1;
 }
@@ -3088,6 +3174,14 @@ static void svm_vcpu_run(struct kvm_vcpu *vcpu)
                vcpu->arch.regs_avail &= ~(1 << VCPU_EXREG_PDPTR);
                vcpu->arch.regs_dirty &= ~(1 << VCPU_EXREG_PDPTR);
        }
+        /*
+         * We need to handle MC intercepts here before the vcpu has a chance to
+         * change the physical cpu
+         */
+        if (unlikely(svm->vmcb->control.exit_code ==
+                     SVM_EXIT_EXCP_BASE + MC_VECTOR))
+                svm_handle_mce(svm);
 }
 #undef R
diff --git a/arch/x86/lguest/boot.c b/arch/x86/lguest/boot.c
index 2bdf628066bd..9257510b4836 100644
--- a/arch/x86/lguest/boot.c
+++ b/arch/x86/lguest/boot.c
@@ -1390,7 +1390,6 @@ __init void lguest_init(void)
 #endif
 #ifdef CONFIG_ACPI
        acpi_disabled = 1;
-        acpi_ht = 0;
 #endif
        /*
diff --git a/arch/x86/mm/numa.c b/arch/x86/mm/numa.c
index 10c27bb1e95f..787c52ca49c3 100644
--- a/arch/x86/mm/numa.c
+++ b/arch/x86/mm/numa.c
@@ -2,13 +2,6 @@
 #include <linux/topology.h>
 #include <linux/module.h>
 #include <linux/bootmem.h>
-#include <linux/random.h>
-#ifdef CONFIG_DEBUG_PER_CPU_MAPS
-# define DBG(x...) printk(KERN_DEBUG x)
-#else
-# define DBG(x...)
-#endif
 /*
 * Which logical CPUs are on which nodes
@@ -66,19 +59,3 @@ const struct cpumask *cpumask_of_node(int node)
 }
 EXPORT_SYMBOL(cpumask_of_node);
 #endif
-/*
- * Return the bit number of a random bit set in the nodemask.
- *   (returns -1 if nodemask is empty)
- */
-int __node_random(const nodemask_t *maskp)
-{
-        int w, bit = -1;
-        w = nodes_weight(*maskp);
-        if (w)
-                bit = bitmap_ord_to_pos(maskp->bits,
-                        get_random_int() % w, MAX_NUMNODES);
-        return bit;
-}
-EXPORT_SYMBOL(__node_random);
diff --git a/arch/x86/mm/pat.c b/arch/x86/mm/pat.c
index bbe5502ee1cb..acc15b23b743 100644
--- a/arch/x86/mm/pat.c
+++ b/arch/x86/mm/pat.c
@@ -336,6 +336,7 @@ int free_memtype(u64 start, u64 end)
 {
        int err = -EINVAL;
        int is_range_ram;
+        struct memtype *entry;
        if (!pat_enabled)
                return 0;
@@ -355,17 +356,20 @@ int free_memtype(u64 start, u64 end)
        }
        spin_lock(&memtype_lock);
-        err = rbt_memtype_erase(start, end);
+        entry = rbt_memtype_erase(start, end);
        spin_unlock(&memtype_lock);
-        if (err) {
+        if (!entry) {
                printk(KERN_INFO "%s:%d freeing invalid memtype %Lx-%Lx\n",
                        current->comm, current->pid, start, end);
+                return -EINVAL;
        }
+        kfree(entry);
        dprintk("free_memtype request 0x%Lx-0x%Lx\n", start, end);
-        return err;
+        return 0;
 }
diff --git a/arch/x86/mm/pat_internal.h b/arch/x86/mm/pat_internal.h
index 4f39eefa3e61..77e5ba153fac 100644
--- a/arch/x86/mm/pat_internal.h
+++ b/arch/x86/mm/pat_internal.h
@@ -28,15 +28,15 @@ static inline char *cattr_name(unsigned long flags)
 #ifdef CONFIG_X86_PAT
 extern int rbt_memtype_check_insert(struct memtype *new,
                                        unsigned long *new_type);
-extern int rbt_memtype_erase(u64 start, u64 end);
+extern struct memtype *rbt_memtype_erase(u64 start, u64 end);
 extern struct memtype *rbt_memtype_lookup(u64 addr);
 extern int rbt_memtype_copy_nth_element(struct memtype *out, loff_t pos);
 #else
 static inline int rbt_memtype_check_insert(struct memtype *new,
                                        unsigned long *new_type)
 { return 0; }
-static inline int rbt_memtype_erase(u64 start, u64 end)
+static inline struct memtype *rbt_memtype_erase(u64 start, u64 end)
-{ return 0; }
+{ return NULL; }
 static inline struct memtype *rbt_memtype_lookup(u64 addr)
 { return NULL; }
 static inline int rbt_memtype_copy_nth_element(struct memtype *out, loff_t pos)
diff --git a/arch/x86/mm/pat_rbtree.c b/arch/x86/mm/pat_rbtree.c
index 07de4cb8cc30..f537087bb740 100644
--- a/arch/x86/mm/pat_rbtree.c
+++ b/arch/x86/mm/pat_rbtree.c
@@ -231,16 +231,17 @@ int rbt_memtype_check_insert(struct memtype *new, unsigned long *ret_type)
        return err;
 }
-int rbt_memtype_erase(u64 start, u64 end)
+struct memtype *rbt_memtype_erase(u64 start, u64 end)
 {
        struct memtype *data;
        data = memtype_rb_exact_match(&memtype_rbroot, start, end);
        if (!data)
-                return -EINVAL;
+                goto out;
        rb_erase(&data->rb, &memtype_rbroot);
-        return 0;
+out:
+        return data;
 }
 struct memtype *rbt_memtype_lookup(u64 addr)
diff --git a/arch/x86/mm/pgtable_32.c b/arch/x86/mm/pgtable_32.c
index 792854003ed3..cac718499256 100644
--- a/arch/x86/mm/pgtable_32.c
+++ b/arch/x86/mm/pgtable_32.c
@@ -9,7 +9,6 @@
 #include <linux/pagemap.h>
 #include <linux/spinlock.h>
 #include <linux/module.h>
-#include <linux/quicklist.h>
 #include <asm/system.h>
 #include <asm/pgtable.h>
diff --git a/arch/x86/pci/acpi.c b/arch/x86/pci/acpi.c
index 31930fd30ea9..2ec04c424a62 100644
--- a/arch/x86/pci/acpi.c
+++ b/arch/x86/pci/acpi.c
@@ -207,10 +207,9 @@ get_current_resources(struct acpi_device *device, int busnum,
        if (!info.res)
                goto res_alloc_fail;
-        info.name = kmalloc(16, GFP_KERNEL);
+        info.name = kasprintf(GFP_KERNEL, "PCI Bus %04x:%02x", domain, busnum);
        if (!info.name)
                goto name_alloc_fail;
-        sprintf(info.name, "PCI Bus %04x:%02x", domain, busnum);
        info.res_num = 0;
        acpi_walk_resources(device->handle, METHOD_NAME__CRS, setup_resource,
@@ -224,8 +223,11 @@ res_alloc_fail:
        return;
 }
-struct pci_bus * __devinit pci_acpi_scan_root(struct acpi_device *device, int domain, int busnum)
+struct pci_bus * __devinit pci_acpi_scan_root(struct acpi_pci_root *root)
 {
+        struct acpi_device *device = root->device;
+        int domain = root->segment;
+        int busnum = root->secondary.start;
        struct pci_bus *bus;
        struct pci_sysdata *sd;
        int node;
diff --git a/arch/x86/pci/legacy.c b/arch/x86/pci/legacy.c
index 0db5eaf54560..8d460eaf524f 100644
--- a/arch/x86/pci/legacy.c
+++ b/arch/x86/pci/legacy.c
@@ -11,28 +11,14 @@
 */
 static void __devinit pcibios_fixup_peer_bridges(void)
 {
-        int n, devfn;
+        int n;
-        long node;
        if (pcibios_last_bus <= 0 || pcibios_last_bus > 0xff)
                return;
        DBG("PCI: Peer bridge fixup\n");
-        for (n=0; n <= pcibios_last_bus; n++) {
+        for (n=0; n <= pcibios_last_bus; n++)
-                u32 l;
+                pcibios_scan_specific_bus(n);
-                if (pci_find_bus(0, n))
-                        continue;
-                node = get_mp_bus_to_node(n);
-                for (devfn = 0; devfn < 256; devfn += 8) {
-                        if (!raw_pci_read(0, n, devfn, PCI_VENDOR_ID, 2, &l) &&
-                            l != 0x0000 && l != 0xffff) {
-                                DBG("Found device at %02x:%02x [%04x]\n", n, devfn, l);
-                                printk(KERN_INFO "PCI: Discovered peer bus %02x\n", n);
-                                pci_scan_bus_on_node(n, &pci_root_ops, node);
-                                break;
-                        }
-                }
-        }
 }
 int __init pci_legacy_init(void)
@@ -50,6 +36,28 @@ int __init pci_legacy_init(void)
        return 0;
 }
+void pcibios_scan_specific_bus(int busn)
+{
+        int devfn;
+        long node;
+        u32 l;
+        if (pci_find_bus(0, busn))
+                return;
+        node = get_mp_bus_to_node(busn);
+        for (devfn = 0; devfn < 256; devfn += 8) {
+                if (!raw_pci_read(0, busn, devfn, PCI_VENDOR_ID, 2, &l) &&
+                    l != 0x0000 && l != 0xffff) {
+                        DBG("Found device at %02x:%02x [%04x]\n", busn, devfn, l);
+                        printk(KERN_INFO "PCI: Discovered peer bus %02x\n", busn);
+                        pci_scan_bus_on_node(busn, &pci_root_ops, node);
+                        return;
+                }
+        }
+}
+EXPORT_SYMBOL_GPL(pcibios_scan_specific_bus);
 int __init pci_subsys_init(void)
 {
        /*
diff --git a/arch/x86/xen/suspend.c b/arch/x86/xen/suspend.c
index 987267f79bf5..a9c661108034 100644
--- a/arch/x86/xen/suspend.c
+++ b/arch/x86/xen/suspend.c
@@ -60,6 +60,6 @@ static void xen_vcpu_notify_restore(void *data)
 void xen_arch_resume(void)
 {
-        smp_call_function(xen_vcpu_notify_restore,
+        on_each_cpu(xen_vcpu_notify_restore,
-                               (void *)CLOCK_EVT_NOTIFY_RESUME, 1);
+                    (void *)CLOCK_EVT_NOTIFY_RESUME, 1);
 }