26 files changed, 681 insertions, 577 deletions

diff --git a/arch/i386/Kconfig b/arch/i386/Kconfig
index 758044f5e718..3fd2f256f2be 100644
--- a/arch/i386/Kconfig
+++ b/arch/i386/Kconfig
@@ -401,6 +401,7 @@ config X86_REBOOTFIXUPS
 
 config MICROCODE
         tristate "/dev/cpu/microcode - Intel IA32 CPU microcode support"
+        select FW_LOADER
         ---help---
           If you say Y here and also to "/dev file system support" in the
           'File systems' section, you will be able to update the microcode on
@@ -416,6 +417,11 @@ config MICROCODE
           To compile this driver as a module, choose M here: the
           module will be called microcode.
 
+config MICROCODE_OLD_INTERFACE
+        bool
+        depends on MICROCODE
+        default y
+
 config X86_MSR
         tristate "/dev/cpu/*/msr - Model-specific register support"
         help
@@ -598,12 +604,10 @@ config ARCH_SELECT_MEMORY_MODEL
         def_bool y
         depends on ARCH_SPARSEMEM_ENABLE
 
-source "mm/Kconfig"
+config ARCH_POPULATES_NODE_MAP
+        def_bool y
 
-config HAVE_ARCH_EARLY_PFN_TO_NID
-        bool
-        default y
-        depends on NUMA
+source "mm/Kconfig"
 
 config HIGHPTE
         bool "Allocate 3rd-level pagetables from highmem"
diff --git a/arch/i386/boot/video.S b/arch/i386/boot/video.S
index 8c2a6faeeae5..2c5b5cc55f79 100644
--- a/arch/i386/boot/video.S
+++ b/arch/i386/boot/video.S
@@ -11,8 +11,6 @@
  *
  */
 
-#include <linux/config.h> /* for CONFIG_VIDEO_* */
-
 /* Enable autodetection of SVGA adapters and modes. */
 #undef CONFIG_VIDEO_SVGA
 
diff --git a/arch/i386/defconfig b/arch/i386/defconfig
index 1a29bfa26d0c..ee2d79bd8af7 100644
--- a/arch/i386/defconfig
+++ b/arch/i386/defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.18-git5
-# Tue Sep 26 09:30:47 2006
+# Linux kernel version: 2.6.18-git7
+# Wed Sep 27 21:53:10 2006
 #
 CONFIG_X86_32=y
 CONFIG_GENERIC_TIME=y
@@ -210,6 +210,7 @@ CONFIG_ARCH_ENABLE_MEMORY_HOTPLUG=y
 CONFIG_PM=y
 CONFIG_PM_LEGACY=y
 # CONFIG_PM_DEBUG is not set
+CONFIG_PM_SYSFS_DEPRECATED=y
 
 #
 # ACPI (Advanced Configuration and Power Interface) Support
@@ -292,6 +293,7 @@ CONFIG_PCI_DIRECT=y
 CONFIG_PCI_MMCONFIG=y
 # CONFIG_PCIEPORTBUS is not set
 CONFIG_PCI_MSI=y
+# CONFIG_PCI_MULTITHREAD_PROBE is not set
 # CONFIG_PCI_DEBUG is not set
 CONFIG_ISA_DMA_API=y
 # CONFIG_ISA is not set
@@ -1427,6 +1429,7 @@ CONFIG_KPROBES=y
 #
 CONFIG_TRACE_IRQFLAGS_SUPPORT=y
 # CONFIG_PRINTK_TIME is not set
+# CONFIG_ENABLE_MUST_CHECK is not set
 CONFIG_MAGIC_SYSRQ=y
 CONFIG_UNUSED_SYMBOLS=y
 CONFIG_DEBUG_KERNEL=y
diff --git a/arch/i386/kernel/apm.c b/arch/i386/kernel/apm.c
index ff9ce4b5eaa8..b42f2d914af3 100644
--- a/arch/i386/kernel/apm.c
+++ b/arch/i386/kernel/apm.c
@@ -225,6 +225,7 @@
 #include <linux/smp_lock.h>
 #include <linux/dmi.h>
 #include <linux/suspend.h>
+#include <linux/kthread.h>
 
 #include <asm/system.h>
 #include <asm/uaccess.h>
@@ -402,8 +403,6 @@ static int			realmode_power_off = 1;
 #else
 static int                      realmode_power_off;
 #endif
-static int                      exit_kapmd __read_mostly;
-static int                      kapmd_running __read_mostly;
 #ifdef CONFIG_APM_ALLOW_INTS
 static int                      allow_ints = 1;
 #else
@@ -419,6 +418,8 @@ static const struct desc_struct	bad_bios_desc = { 0, 0x00409200 };
 
 static const char               driver_version[] = "1.16ac";    /* no spaces */
 
+static struct task_struct *kapmd_task;
+
 /*
  *      APM event names taken from the APM 1.2 specification. These are
  *      the message codes that the BIOS uses to tell us about events
@@ -1423,7 +1424,7 @@ static void apm_mainloop(void)
         set_current_state(TASK_INTERRUPTIBLE);
         for (;;) {
                 schedule_timeout(APM_CHECK_TIMEOUT);
-                if (exit_kapmd)
+                if (kthread_should_stop())
                         break;
                 /*
                  * Ok, check all events, check for idle (and mark us sleeping
@@ -1706,12 +1707,6 @@ static int apm(void *unused)
         char *          power_stat;
         char *          bat_stat;
 
-        kapmd_running = 1;
-
-        daemonize("kapmd");
-
-        current->flags |= PF_NOFREEZE;
-
 #ifdef CONFIG_SMP
         /* 2002/08/01 - WT
          * This is to avoid random crashes at boot time during initialization
@@ -1821,7 +1816,6 @@ static int apm(void *unused)
                 console_blank_hook = NULL;
 #endif
         }
-        kapmd_running = 0;
 
         return 0;
 }
@@ -2220,7 +2214,7 @@ static int __init apm_init(void)
 {
         struct proc_dir_entry *apm_proc;
         struct desc_struct *gdt;
-        int ret;
+        int err;
 
         dmi_check_system(apm_dmi_table);
 
@@ -2329,12 +2323,17 @@ static int __init apm_init(void)
         if (apm_proc)
                 apm_proc->owner = THIS_MODULE;
 
-        ret = kernel_thread(apm, NULL, CLONE_KERNEL | SIGCHLD);
-        if (ret < 0) {
-                printk(KERN_ERR "apm: disabled - Unable to start kernel thread.\n");
+        kapmd_task = kthread_create(apm, NULL, "kapmd");
+        if (IS_ERR(kapmd_task)) {
+                printk(KERN_ERR "apm: disabled - Unable to start kernel "
+                                "thread.\n");
+                err = PTR_ERR(kapmd_task);
+                kapmd_task = NULL;
                 remove_proc_entry("apm", NULL);
-                return -ENOMEM;
+                return err;
         }
+        kapmd_task->flags |= PF_NOFREEZE;
+        wake_up_process(kapmd_task);
 
         if (num_online_cpus() > 1 && !smp ) {
                 printk(KERN_NOTICE
@@ -2384,9 +2383,10 @@ static void __exit apm_exit(void)
         remove_proc_entry("apm", NULL);
         if (power_off)
                 pm_power_off = NULL;
-        exit_kapmd = 1;
-        while (kapmd_running)
-                schedule();
+        if (kapmd_task) {
+                kthread_stop(kapmd_task);
+                kapmd_task = NULL;
+        }
 #ifdef CONFIG_PM_LEGACY
         pm_active = 0;
 #endif
diff --git a/arch/i386/kernel/crash.c b/arch/i386/kernel/crash.c
index 67d297dc1003..144b43288965 100644
--- a/arch/i386/kernel/crash.c
+++ b/arch/i386/kernel/crash.c
@@ -23,6 +23,7 @@
 #include <asm/hw_irq.h>
 #include <asm/apic.h>
 #include <asm/kdebug.h>
+#include <asm/smp.h>
 
 #include <mach_ipi.h>
 
@@ -88,7 +89,7 @@ static void crash_save_self(struct pt_regs *regs)
 {
         int cpu;
 
-        cpu = smp_processor_id();
+        cpu = safe_smp_processor_id();
         crash_save_this_cpu(regs, cpu);
 }
 
@@ -133,7 +134,10 @@ static int crash_nmi_callback(struct notifier_block *self,
 
 static void smp_send_nmi_allbutself(void)
 {
-        send_IPI_allbutself(NMI_VECTOR);
+        cpumask_t mask = cpu_online_map;
+        cpu_clear(safe_smp_processor_id(), mask);
+        if (!cpus_empty(mask))
+                send_IPI_mask(mask, NMI_VECTOR);
 }
 
 static struct notifier_block crash_nmi_nb = {
@@ -185,7 +189,7 @@ void machine_crash_shutdown(struct pt_regs *regs)
         local_irq_disable();
 
         /* Make a note of crashing cpu. Will be used in NMI callback.*/
-        crashing_cpu = smp_processor_id();
+        crashing_cpu = safe_smp_processor_id();
         nmi_shootdown_cpus();
         lapic_shutdown();
 #if defined(CONFIG_X86_IO_APIC)
diff --git a/arch/i386/kernel/efi.c b/arch/i386/kernel/efi.c
index fe158042110b..f9436989473c 100644
--- a/arch/i386/kernel/efi.c
+++ b/arch/i386/kernel/efi.c
@@ -65,7 +65,7 @@ static unsigned long efi_rt_eflags;
 static DEFINE_SPINLOCK(efi_rt_lock);
 static pgd_t efi_bak_pg_dir_pointer[2];
 
-static void efi_call_phys_prelog(void)
+static void efi_call_phys_prelog(void) __acquires(efi_rt_lock)
 {
         unsigned long cr4;
         unsigned long temp;
@@ -109,7 +109,7 @@ static void efi_call_phys_prelog(void)
         load_gdt(cpu_gdt_descr);
 }
 
-static void efi_call_phys_epilog(void)
+static void efi_call_phys_epilog(void) __releases(efi_rt_lock)
 {
         unsigned long cr4;
         struct Xgt_desc_struct *cpu_gdt_descr = &per_cpu(cpu_gdt_descr, 0);
diff --git a/arch/i386/kernel/i8237.c b/arch/i386/kernel/i8237.c
index c36d1c006c2f..6f508e8d7c57 100644
--- a/arch/i386/kernel/i8237.c
+++ b/arch/i386/kernel/i8237.c
@@ -2,6 +2,11 @@
  * i8237.c: 8237A DMA controller suspend functions.
  *
  * Written by Pierre Ossman, 2005.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
  */
 
 #include <linux/init.h>
diff --git a/arch/i386/kernel/microcode.c b/arch/i386/kernel/microcode.c
index 40b44cc0d14b..9b9479768d5e 100644
--- a/arch/i386/kernel/microcode.c
+++ b/arch/i386/kernel/microcode.c
@@ -2,6 +2,7 @@
  *      Intel CPU Microcode Update Driver for Linux
  *
  *      Copyright (C) 2000-2004 Tigran Aivazian
+ *                    2006      Shaohua Li <shaohua.li@intel.com>
  *
  *      This driver allows to upgrade microcode on Intel processors
  *      belonging to IA-32 family - PentiumPro, Pentium II, 
@@ -82,6 +83,9 @@
 #include <linux/spinlock.h>
 #include <linux/mm.h>
 #include <linux/mutex.h>
+#include <linux/cpu.h>
+#include <linux/firmware.h>
+#include <linux/platform_device.h>
 
 #include <asm/msr.h>
 #include <asm/uaccess.h>
@@ -91,9 +95,6 @@ MODULE_DESCRIPTION("Intel CPU (IA-32) Microcode Update Driver");
 MODULE_AUTHOR("Tigran Aivazian <tigran@veritas.com>");
 MODULE_LICENSE("GPL");
 
-static int verbose;
-module_param(verbose, int, 0644);
-
 #define MICROCODE_VERSION       "1.14a"
 
 #define DEFAULT_UCODE_DATASIZE  (2000)    /* 2000 bytes */
@@ -120,55 +121,40 @@ static DEFINE_SPINLOCK(microcode_update_lock);
 /* no concurrent ->write()s are allowed on /dev/cpu/microcode */
 static DEFINE_MUTEX(microcode_mutex);
 
-static void __user *user_buffer;        /* user area microcode data buffer */
-static unsigned int user_buffer_size;   /* it's size */
-
-typedef enum mc_error_code {
-        MC_SUCCESS      = 0,
-        MC_IGNORED      = 1,
-        MC_NOTFOUND     = 2,
-        MC_MARKED       = 3,
-        MC_ALLOCATED    = 4,
-} mc_error_code_t;
-
 static struct ucode_cpu_info {
+        int valid;
         unsigned int sig;
-        unsigned int pf, orig_pf;
+        unsigned int pf;
         unsigned int rev;
-        unsigned int cksum;
-        mc_error_code_t err;
         microcode_t *mc;
 } ucode_cpu_info[NR_CPUS];
-                                
-static int microcode_open (struct inode *unused1, struct file *unused2)
-{
-        return capable(CAP_SYS_RAWIO) ? 0 : -EPERM;
-}
 
-static void collect_cpu_info (void *unused)
+static void collect_cpu_info(int cpu_num)
 {
-        int cpu_num = smp_processor_id();
         struct cpuinfo_x86 *c = cpu_data + cpu_num;
         struct ucode_cpu_info *uci = ucode_cpu_info + cpu_num;
         unsigned int val[2];
 
-        uci->sig = uci->pf = uci->rev = uci->cksum = 0;
-        uci->err = MC_NOTFOUND; 
+        /* We should bind the task to the CPU */
+        BUG_ON(raw_smp_processor_id() != cpu_num);
+        uci->pf = uci->rev = 0;
         uci->mc = NULL;
+        uci->valid = 1;
 
         if (c->x86_vendor != X86_VENDOR_INTEL || c->x86 < 6 ||
                 cpu_has(c, X86_FEATURE_IA64)) {
-                printk(KERN_ERR "microcode: CPU%d not a capable Intel processor\n", cpu_num);
+                printk(KERN_ERR "microcode: CPU%d not a capable Intel "
+                        "processor\n", cpu_num);
+                uci->valid = 0;
                 return;
-        } else {
-                uci->sig = cpuid_eax(0x00000001);
+        }
 
-                if ((c->x86_model >= 5) || (c->x86 > 6)) {
-                        /* get processor flags from MSR 0x17 */
-                        rdmsr(MSR_IA32_PLATFORM_ID, val[0], val[1]);
-                        uci->pf = 1 << ((val[1] >> 18) & 7);
-                }
-                uci->orig_pf = uci->pf;
+        uci->sig = cpuid_eax(0x00000001);
+
+        if ((c->x86_model >= 5) || (c->x86 > 6)) {
+                /* get processor flags from MSR 0x17 */
+                rdmsr(MSR_IA32_PLATFORM_ID, val[0], val[1]);
+                uci->pf = 1 << ((val[1] >> 18) & 7);
         }
 
         wrmsr(MSR_IA32_UCODE_REV, 0, 0);
@@ -180,218 +166,159 @@ static void collect_cpu_info (void *unused)
                         uci->sig, uci->pf, uci->rev);
 }
 
-static inline void mark_microcode_update (int cpu_num, microcode_header_t *mc_header, int sig, int pf, int cksum)
+static inline int microcode_update_match(int cpu_num,
+        microcode_header_t *mc_header, int sig, int pf)
 {
         struct ucode_cpu_info *uci = ucode_cpu_info + cpu_num;
 
-        pr_debug("Microcode Found.\n");
-        pr_debug("   Header Revision 0x%x\n", mc_header->hdrver);
-        pr_debug("   Loader Revision 0x%x\n", mc_header->ldrver);
-        pr_debug("   Revision 0x%x \n", mc_header->rev);
-        pr_debug("   Date %x/%x/%x\n",
-                ((mc_header->date >> 24 ) & 0xff),
-                ((mc_header->date >> 16 ) & 0xff),
-                (mc_header->date & 0xFFFF));
-        pr_debug("   Signature 0x%x\n", sig);
-        pr_debug("   Type 0x%x Family 0x%x Model 0x%x Stepping 0x%x\n",
-                ((sig >> 12) & 0x3),
-                ((sig >> 8) & 0xf),
-                ((sig >> 4) & 0xf),
-                ((sig & 0xf)));
-        pr_debug("   Processor Flags 0x%x\n", pf);
-        pr_debug("   Checksum 0x%x\n", cksum);
-
-        if (mc_header->rev < uci->rev) {
-                if (uci->err == MC_NOTFOUND) {
-                        uci->err = MC_IGNORED;
-                        uci->cksum = mc_header->rev;
-                } else if (uci->err == MC_IGNORED && uci->cksum < mc_header->rev)
-                        uci->cksum = mc_header->rev;
-        } else if (mc_header->rev == uci->rev) {
-                if (uci->err < MC_MARKED) {
-                        /* notify the caller of success on this cpu */
-                        uci->err = MC_SUCCESS;
-                }
-        } else if (uci->err != MC_ALLOCATED || mc_header->rev > uci->mc->hdr.rev) {
-                pr_debug("microcode: CPU%d found a matching microcode update with "
-                        " revision 0x%x (current=0x%x)\n", cpu_num, mc_header->rev, uci->rev);
-                uci->cksum = cksum;
-                uci->pf = pf; /* keep the original mc pf for cksum calculation */
-                uci->err = MC_MARKED; /* found the match */
-                for_each_online_cpu(cpu_num) {
-                        if (ucode_cpu_info + cpu_num != uci
-                            && ucode_cpu_info[cpu_num].mc == uci->mc) {
-                                uci->mc = NULL;
-                                break;
-                        }
-                }
-                if (uci->mc != NULL) {
-                        vfree(uci->mc);
-                        uci->mc = NULL;
-                }
-        }
-        return;
+        if (!sigmatch(sig, uci->sig, pf, uci->pf)
+                || mc_header->rev <= uci->rev)
+                return 0;
+        return 1;
 }
 
-static int find_matching_ucodes (void) 
+static int microcode_sanity_check(void *mc)
 {
-        int cursor = 0;
-        int error = 0;
-
-        while (cursor + MC_HEADER_SIZE < user_buffer_size) {
-                microcode_header_t mc_header;
-                void *newmc = NULL;
-                int i, sum, cpu_num, allocated_flag, total_size, data_size, ext_table_size;
+        microcode_header_t *mc_header = mc;
+        struct extended_sigtable *ext_header = NULL;
+        struct extended_signature *ext_sig;
+        unsigned long total_size, data_size, ext_table_size;
+        int sum, orig_sum, ext_sigcount = 0, i;
+
+        total_size = get_totalsize(mc_header);
+        data_size = get_datasize(mc_header);
+        if (data_size + MC_HEADER_SIZE > total_size) {
+                printk(KERN_ERR "microcode: error! "
+                        "Bad data size in microcode data file\n");
+                return -EINVAL;
+        }
 
-                if (copy_from_user(&mc_header, user_buffer + cursor, MC_HEADER_SIZE)) {
-                        printk(KERN_ERR "microcode: error! Can not read user data\n");
-                        error = -EFAULT;
-                        goto out;
+        if (mc_header->ldrver != 1 || mc_header->hdrver != 1) {
+                printk(KERN_ERR "microcode: error! "
+                        "Unknown microcode update format\n");
+                return -EINVAL;
+        }
+        ext_table_size = total_size - (MC_HEADER_SIZE + data_size);
+        if (ext_table_size) {
+                if ((ext_table_size < EXT_HEADER_SIZE)
+                 || ((ext_table_size - EXT_HEADER_SIZE) % EXT_SIGNATURE_SIZE)) {
+                        printk(KERN_ERR "microcode: error! "
+                                "Small exttable size in microcode data file\n");
+                        return -EINVAL;
                 }
-
-                total_size = get_totalsize(&mc_header);
-                if ((cursor + total_size > user_buffer_size) || (total_size < DEFAULT_UCODE_TOTALSIZE)) {
-                        printk(KERN_ERR "microcode: error! Bad data in microcode data file\n");
-                        error = -EINVAL;
-                        goto out;
+                ext_header = mc + MC_HEADER_SIZE + data_size;
+                if (ext_table_size != exttable_size(ext_header)) {
+                        printk(KERN_ERR "microcode: error! "
+                                "Bad exttable size in microcode data file\n");
+                        return -EFAULT;
                 }
+                ext_sigcount = ext_header->count;
+        }
 
-                data_size = get_datasize(&mc_header);
-                if ((data_size + MC_HEADER_SIZE > total_size) || (data_size < DEFAULT_UCODE_DATASIZE)) {
-                        printk(KERN_ERR "microcode: error! Bad data in microcode data file\n");
-                        error = -EINVAL;
-                        goto out;
+        /* check extended table checksum */
+        if (ext_table_size) {
+                int ext_table_sum = 0;
+                int *ext_tablep = (int *)ext_header;
+
+                i = ext_table_size / DWSIZE;
+                while (i--)
+                        ext_table_sum += ext_tablep[i];
+                if (ext_table_sum) {
+                        printk(KERN_WARNING "microcode: aborting, "
+                                "bad extended signature table checksum\n");
+                        return -EINVAL;
                 }
+        }
 
-                if (mc_header.ldrver != 1 || mc_header.hdrver != 1) {
-                        printk(KERN_ERR "microcode: error! Unknown microcode update format\n");
-                        error = -EINVAL;
-                        goto out;
+        /* calculate the checksum */
+        orig_sum = 0;
+        i = (MC_HEADER_SIZE + data_size) / DWSIZE;
+        while (i--)
+                orig_sum += ((int *)mc)[i];
+        if (orig_sum) {
+                printk(KERN_ERR "microcode: aborting, bad checksum\n");
+                return -EINVAL;
+        }
+        if (!ext_table_size)
+                return 0;
+        /* check extended signature checksum */
+        for (i = 0; i < ext_sigcount; i++) {
+                ext_sig = (struct extended_signature *)((void *)ext_header
+                        + EXT_HEADER_SIZE + EXT_SIGNATURE_SIZE * i);
+                sum = orig_sum
+                        - (mc_header->sig + mc_header->pf + mc_header->cksum)
+                        + (ext_sig->sig + ext_sig->pf + ext_sig->cksum);
+                if (sum) {
+                        printk(KERN_ERR "microcode: aborting, bad checksum\n");
+                        return -EINVAL;
                 }
+        }
+        return 0;
+}
 
-                for_each_online_cpu(cpu_num) {
-                        struct ucode_cpu_info *uci = ucode_cpu_info + cpu_num;
-
-                        if (sigmatch(mc_header.sig, uci->sig, mc_header.pf, uci->orig_pf))
-                                mark_microcode_update(cpu_num, &mc_header, mc_header.sig, mc_header.pf, mc_header.cksum);
-                }
+/*
+ * return 0 - no update found
+ * return 1 - found update
+ * return < 0 - error
+ */
+static int get_maching_microcode(void *mc, int cpu)
+{
+        struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
+        microcode_header_t *mc_header = mc;
+        struct extended_sigtable *ext_header;
+        unsigned long total_size = get_totalsize(mc_header);
+        int ext_sigcount, i;
+        struct extended_signature *ext_sig;
+        void *new_mc;
+
+        if (microcode_update_match(cpu, mc_header,
+                        mc_header->sig, mc_header->pf))
+                goto find;
+
+        if (total_size <= get_datasize(mc_header) + MC_HEADER_SIZE)
+                return 0;
+
+        ext_header = (struct extended_sigtable *)(mc +
+                        get_datasize(mc_header) + MC_HEADER_SIZE);
+        ext_sigcount = ext_header->count;
+        ext_sig = (struct extended_signature *)((void *)ext_header
+                        + EXT_HEADER_SIZE);
+        for (i = 0; i < ext_sigcount; i++) {
+                if (microcode_update_match(cpu, mc_header,
+                                ext_sig->sig, ext_sig->pf))
+                        goto find;
+                ext_sig++;
+        }
+        return 0;
+find:
+        pr_debug("microcode: CPU %d found a matching microcode update with"
+                " version 0x%x (current=0x%x)\n", cpu, mc_header->rev,uci->rev);
+        new_mc = vmalloc(total_size);
+        if (!new_mc) {
+                printk(KERN_ERR "microcode: error! Can not allocate memory\n");
+                return -ENOMEM;
+        }
 
-                ext_table_size = total_size - (MC_HEADER_SIZE + data_size);
-                if (ext_table_size) {
-                        struct extended_sigtable ext_header;
-                        struct extended_signature ext_sig;
-                        int ext_sigcount;
+        /* free previous update file */
+        vfree(uci->mc);
 
-                        if ((ext_table_size < EXT_HEADER_SIZE) 
-                                        || ((ext_table_size - EXT_HEADER_SIZE) % EXT_SIGNATURE_SIZE)) {
-                                printk(KERN_ERR "microcode: error! Bad data in microcode data file\n");
-                                error = -EINVAL;
-                                goto out;
-                        }
-                        if (copy_from_user(&ext_header, user_buffer + cursor 
-                                        + MC_HEADER_SIZE + data_size, EXT_HEADER_SIZE)) {
-                                printk(KERN_ERR "microcode: error! Can not read user data\n");
-                                error = -EFAULT;
-                                goto out;
-                        }
-                        if (ext_table_size != exttable_size(&ext_header)) {
-                                printk(KERN_ERR "microcode: error! Bad data in microcode data file\n");
-                                error = -EFAULT;
-                                goto out;
-                        }
-
-                        ext_sigcount = ext_header.count;
-                        
-                        for (i = 0; i < ext_sigcount; i++) {
-                                if (copy_from_user(&ext_sig, user_buffer + cursor + MC_HEADER_SIZE + data_size + EXT_HEADER_SIZE 
-                                                + EXT_SIGNATURE_SIZE * i, EXT_SIGNATURE_SIZE)) {
-                                        printk(KERN_ERR "microcode: error! Can not read user data\n");
-                                        error = -EFAULT;
-                                        goto out;
-                                }
-                                for_each_online_cpu(cpu_num) {
-                                        struct ucode_cpu_info *uci = ucode_cpu_info + cpu_num;
-
-                                        if (sigmatch(ext_sig.sig, uci->sig, ext_sig.pf, uci->orig_pf)) {
-                                                mark_microcode_update(cpu_num, &mc_header, ext_sig.sig, ext_sig.pf, ext_sig.cksum);
-                                        }
-                                }
-                        }
-                }
-                /* now check if any cpu has matched */
-                allocated_flag = 0;
-                sum = 0;
-                for_each_online_cpu(cpu_num) {
-                        if (ucode_cpu_info[cpu_num].err == MC_MARKED) { 
-                                struct ucode_cpu_info *uci = ucode_cpu_info + cpu_num;
-                                if (!allocated_flag) {
-                                        allocated_flag = 1;
-                                        newmc = vmalloc(total_size);
-                                        if (!newmc) {
-                                                printk(KERN_ERR "microcode: error! Can not allocate memory\n");
-                                                error = -ENOMEM;
-                                                goto out;
-                                        }
-                                        if (copy_from_user(newmc + MC_HEADER_SIZE, 
-                                                                user_buffer + cursor + MC_HEADER_SIZE, 
-                                                                total_size - MC_HEADER_SIZE)) {
-                                                printk(KERN_ERR "microcode: error! Can not read user data\n");
-                                                vfree(newmc);
-                                                error = -EFAULT;
-                                                goto out;
-                                        }
-                                        memcpy(newmc, &mc_header, MC_HEADER_SIZE);
-                                        /* check extended table checksum */
-                                        if (ext_table_size) {
-                                                int ext_table_sum = 0;
-                                                int * ext_tablep = (((void *) newmc) + MC_HEADER_SIZE + data_size);
-                                                i = ext_table_size / DWSIZE;
-                                                while (i--) ext_table_sum += ext_tablep[i];
-                                                if (ext_table_sum) {
-                                                        printk(KERN_WARNING "microcode: aborting, bad extended signature table checksum\n");
-                                                        vfree(newmc);
-                                                        error = -EINVAL;
-                                                        goto out;
-                                                }
-                                        }
-
-                                        /* calculate the checksum */
-                                        i = (MC_HEADER_SIZE + data_size) / DWSIZE;
-                                        while (i--) sum += ((int *)newmc)[i];
-                                        sum -= (mc_header.sig + mc_header.pf + mc_header.cksum);
-                                }
-                                ucode_cpu_info[cpu_num].mc = newmc;
-                                ucode_cpu_info[cpu_num].err = MC_ALLOCATED; /* mc updated */
-                                if (sum + uci->sig + uci->pf + uci->cksum != 0) {
-                                        printk(KERN_ERR "microcode: CPU%d aborting, bad checksum\n", cpu_num);
-                                        error = -EINVAL;
-                                        goto out;
-                                }
-                        }
-                }
-                cursor += total_size; /* goto the next update patch */
-        } /* end of while */
-out:
-        return error;
+        memcpy(new_mc, mc, total_size);
+        uci->mc = new_mc;
+        return 1;
 }
 
-static void do_update_one (void * unused)
+static void apply_microcode(int cpu)
 {
         unsigned long flags;
         unsigned int val[2];
-        int cpu_num = smp_processor_id();
+        int cpu_num = raw_smp_processor_id();
         struct ucode_cpu_info *uci = ucode_cpu_info + cpu_num;
 
-        if (uci->mc == NULL) {
-                if (verbose) {
-                        if (uci->err == MC_SUCCESS)
-                                printk(KERN_INFO "microcode: CPU%d already at revision 0x%x\n",
-                                        cpu_num, uci->rev);
-                        else
-                                printk(KERN_INFO "microcode: No new microcode data for CPU%d\n", cpu_num);
-                }
+        /* We should bind the task to the CPU */
+        BUG_ON(cpu_num != cpu);
+
+        if (uci->mc == NULL)
                 return;
-        }
 
         /* serialize access to the physical write to MSR 0x79 */
         spin_lock_irqsave(&microcode_update_lock, flags);          
@@ -408,68 +335,107 @@ static void do_update_one (void * unused)
         /* get the current revision from MSR 0x8B */
         rdmsr(MSR_IA32_UCODE_REV, val[0], val[1]);
 
-        /* notify the caller of success on this cpu */
-        uci->err = MC_SUCCESS;
         spin_unlock_irqrestore(&microcode_update_lock, flags);
-        printk(KERN_INFO "microcode: CPU%d updated from revision "
+        if (val[1] != uci->mc->hdr.rev) {
+                printk(KERN_ERR "microcode: CPU%d updated from revision "
+                        "0x%x to 0x%x failed\n", cpu_num, uci->rev, val[1]);
+                return;
+        }
+        pr_debug("microcode: CPU%d updated from revision "
                "0x%x to 0x%x, date = %08x \n", 
                cpu_num, uci->rev, val[1], uci->mc->hdr.date);
-        return;
+        uci->rev = val[1];
 }
 
-static int do_microcode_update (void)
-{
-        int i, error;
+#ifdef CONFIG_MICROCODE_OLD_INTERFACE
+static void __user *user_buffer;        /* user area microcode data buffer */
+static unsigned int user_buffer_size;   /* it's size */
 
-        if (on_each_cpu(collect_cpu_info, NULL, 1, 1) != 0) {
-                printk(KERN_ERR "microcode: Error! Could not run on all processors\n");
-                error = -EIO;
-                goto out;
+static long get_next_ucode(void **mc, long offset)
+{
+        microcode_header_t mc_header;
+        unsigned long total_size;
+
+        /* No more data */
+        if (offset >= user_buffer_size)
+                return 0;
+        if (copy_from_user(&mc_header, user_buffer + offset, MC_HEADER_SIZE)) {
+                printk(KERN_ERR "microcode: error! Can not read user data\n");
+                return -EFAULT;
         }
-
-        if ((error = find_matching_ucodes())) {
-                printk(KERN_ERR "microcode: Error in the microcode data\n");
-                goto out_free;
+        total_size = get_totalsize(&mc_header);
+        if (offset + total_size > user_buffer_size) {
+                printk(KERN_ERR "microcode: error! Bad total size in microcode "
+                                "data file\n");
+                return -EINVAL;
         }
-
-        if (on_each_cpu(do_update_one, NULL, 1, 1) != 0) {
-                printk(KERN_ERR "microcode: Error! Could not run on all processors\n");
-                error = -EIO;
+        *mc = vmalloc(total_size);
+        if (!*mc)
+                return -ENOMEM;
+        if (copy_from_user(*mc, user_buffer + offset, total_size)) {
+                printk(KERN_ERR "microcode: error! Can not read user data\n");
+                vfree(*mc);
+                return -EFAULT;
         }
+        return offset + total_size;
+}
+
+static int do_microcode_update (void)
+{
+        long cursor = 0;
+        int error = 0;
+        void *new_mc;
+        int cpu;
+        cpumask_t old;
+
+        old = current->cpus_allowed;
 
-out_free:
-        for_each_online_cpu(i) {
-                if (ucode_cpu_info[i].mc) {
-                        int j;
-                        void *tmp = ucode_cpu_info[i].mc;
-                        vfree(tmp);
-                        for_each_online_cpu(j) {
-                                if (ucode_cpu_info[j].mc == tmp)
-                                        ucode_cpu_info[j].mc = NULL;
-                        }
+        while ((cursor = get_next_ucode(&new_mc, cursor)) > 0) {
+                error = microcode_sanity_check(new_mc);
+                if (error)
+                        goto out;
+                /*
+                 * It's possible the data file has multiple matching ucode,
+                 * lets keep searching till the latest version
+                 */
+                for_each_online_cpu(cpu) {
+                        struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
+
+                        if (!uci->valid)
+                                continue;
+                        set_cpus_allowed(current, cpumask_of_cpu(cpu));
+                        error = get_maching_microcode(new_mc, cpu);
+                        if (error < 0)
+                                goto out;
+                        if (error == 1)
+                                apply_microcode(cpu);
                 }
-                if (ucode_cpu_info[i].err == MC_IGNORED && verbose)
-                        printk(KERN_WARNING "microcode: CPU%d not 'upgrading' to earlier revision"
-                               " 0x%x (current=0x%x)\n", i, ucode_cpu_info[i].cksum, ucode_cpu_info[i].rev);
+                vfree(new_mc);
         }
 out:
+        if (cursor > 0)
+                vfree(new_mc);
+        if (cursor < 0)
+                error = cursor;
+        set_cpus_allowed(current, old);
         return error;
 }
 
+static int microcode_open (struct inode *unused1, struct file *unused2)
+{
+        return capable(CAP_SYS_RAWIO) ? 0 : -EPERM;
+}
+
 static ssize_t microcode_write (struct file *file, const char __user *buf, size_t len, loff_t *ppos)
 {
         ssize_t ret;
 
-        if (len < DEFAULT_UCODE_TOTALSIZE) {
-                printk(KERN_ERR "microcode: not enough data\n"); 
-                return -EINVAL;
-        }
-
         if ((len >> PAGE_SHIFT) > num_physpages) {
                 printk(KERN_ERR "microcode: too much data (max %ld pages)\n", num_physpages);
                 return -EINVAL;
         }
 
+        lock_cpu_hotplug();
         mutex_lock(&microcode_mutex);
 
         user_buffer = (void __user *) buf;
@@ -480,6 +446,7 @@ static ssize_t microcode_write (struct file *file, const char __user *buf, size_
                 ret = (ssize_t)len;
 
         mutex_unlock(&microcode_mutex);
+        unlock_cpu_hotplug();
 
         return ret;
 }
@@ -496,7 +463,7 @@ static struct miscdevice microcode_dev = {
         .fops           = &microcode_fops,
 };
 
-static int __init microcode_init (void)
+static int __init microcode_dev_init (void)
 {
         int error;
 
@@ -508,6 +475,280 @@ static int __init microcode_init (void)
                 return error;
         }
 
+        return 0;
+}
+
+static void __exit microcode_dev_exit (void)
+{
+        misc_deregister(&microcode_dev);
+}
+
+MODULE_ALIAS_MISCDEV(MICROCODE_MINOR);
+#else
+#define microcode_dev_init() 0
+#define microcode_dev_exit() do { } while(0)
+#endif
+
+static long get_next_ucode_from_buffer(void **mc, void *buf,
+        unsigned long size, long offset)
+{
+        microcode_header_t *mc_header;
+        unsigned long total_size;
+
+        /* No more data */
+        if (offset >= size)
+                return 0;
+        mc_header = (microcode_header_t *)(buf + offset);
+        total_size = get_totalsize(mc_header);
+
+        if (offset + total_size > size) {
+                printk(KERN_ERR "microcode: error! Bad data in microcode data file\n");
+                return -EINVAL;
+        }
+
+        *mc = vmalloc(total_size);
+        if (!*mc) {
+                printk(KERN_ERR "microcode: error! Can not allocate memory\n");
+                return -ENOMEM;
+        }
+        memcpy(*mc, buf + offset, total_size);
+        return offset + total_size;
+}
+
+/* fake device for request_firmware */
+static struct platform_device *microcode_pdev;
+
+static int cpu_request_microcode(int cpu)
+{
+        char name[30];
+        struct cpuinfo_x86 *c = cpu_data + cpu;
+        const struct firmware *firmware;
+        void *buf;
+        unsigned long size;
+        long offset = 0;
+        int error;
+        void *mc;
+
+        /* We should bind the task to the CPU */
+        BUG_ON(cpu != raw_smp_processor_id());
+        sprintf(name,"intel-ucode/%02x-%02x-%02x",
+                c->x86, c->x86_model, c->x86_mask);
+        error = request_firmware(&firmware, name, &microcode_pdev->dev);
+        if (error) {
+                pr_debug("ucode data file %s load failed\n", name);
+                return error;
+        }
+        buf = (void *)firmware->data;
+        size = firmware->size;
+        while ((offset = get_next_ucode_from_buffer(&mc, buf, size, offset))
+                        > 0) {
+                error = microcode_sanity_check(mc);
+                if (error)
+                        break;
+                error = get_maching_microcode(mc, cpu);
+                if (error < 0)
+                        break;
+                /*
+                 * It's possible the data file has multiple matching ucode,
+                 * lets keep searching till the latest version
+                 */
+                if (error == 1) {
+                        apply_microcode(cpu);
+                        error = 0;
+                }
+                vfree(mc);
+        }
+        if (offset > 0)
+                vfree(mc);
+        if (offset < 0)
+                error = offset;
+        release_firmware(firmware);
+
+        return error;
+}
+
+static void microcode_init_cpu(int cpu)
+{
+        cpumask_t old;
+        struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
+
+        old = current->cpus_allowed;
+
+        set_cpus_allowed(current, cpumask_of_cpu(cpu));
+        mutex_lock(&microcode_mutex);
+        collect_cpu_info(cpu);
+        if (uci->valid)
+                cpu_request_microcode(cpu);
+        mutex_unlock(&microcode_mutex);
+        set_cpus_allowed(current, old);
+}
+
+static void microcode_fini_cpu(int cpu)
+{
+        struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
+
+        mutex_lock(&microcode_mutex);
+        uci->valid = 0;
+        vfree(uci->mc);
+        uci->mc = NULL;
+        mutex_unlock(&microcode_mutex);
+}
+
+static ssize_t reload_store(struct sys_device *dev, const char *buf, size_t sz)
+{
+        struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
+        char *end;
+        unsigned long val = simple_strtoul(buf, &end, 0);
+        int err = 0;
+        int cpu = dev->id;
+
+        if (end == buf)
+                return -EINVAL;
+        if (val == 1) {
+                cpumask_t old;
+
+                old = current->cpus_allowed;
+
+                lock_cpu_hotplug();
+                set_cpus_allowed(current, cpumask_of_cpu(cpu));
+
+                mutex_lock(&microcode_mutex);
+                if (uci->valid)
+                        err = cpu_request_microcode(cpu);
+                mutex_unlock(&microcode_mutex);
+                unlock_cpu_hotplug();
+                set_cpus_allowed(current, old);
+        }
+        if (err)
+                return err;
+        return sz;
+}
+
+static ssize_t version_show(struct sys_device *dev, char *buf)
+{
+        struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
+
+        return sprintf(buf, "0x%x\n", uci->rev);
+}
+
+static ssize_t pf_show(struct sys_device *dev, char *buf)
+{
+        struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;
+
+        return sprintf(buf, "0x%x\n", uci->pf);
+}
+
+static SYSDEV_ATTR(reload, 0200, NULL, reload_store);
+static SYSDEV_ATTR(version, 0400, version_show, NULL);
+static SYSDEV_ATTR(processor_flags, 0400, pf_show, NULL);
+
+static struct attribute *mc_default_attrs[] = {
+        &attr_reload.attr,
+        &attr_version.attr,
+        &attr_processor_flags.attr,
+        NULL
+};
+
+static struct attribute_group mc_attr_group = {
+        .attrs = mc_default_attrs,
+        .name = "microcode",
+};
+
+static int mc_sysdev_add(struct sys_device *sys_dev)
+{
+        int cpu = sys_dev->id;
+        struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
+
+        if (!cpu_online(cpu))
+                return 0;
+        pr_debug("Microcode:CPU %d added\n", cpu);
+        memset(uci, 0, sizeof(*uci));
+        sysfs_create_group(&sys_dev->kobj, &mc_attr_group);
+
+        microcode_init_cpu(cpu);
+        return 0;
+}
+
+static int mc_sysdev_remove(struct sys_device *sys_dev)
+{
+        int cpu = sys_dev->id;
+
+        if (!cpu_online(cpu))
+                return 0;
+        pr_debug("Microcode:CPU %d removed\n", cpu);
+        microcode_fini_cpu(cpu);
+        sysfs_remove_group(&sys_dev->kobj, &mc_attr_group);
+        return 0;
+}
+
+static int mc_sysdev_resume(struct sys_device *dev)
+{
+        int cpu = dev->id;
+
+        if (!cpu_online(cpu))
+                return 0;
+        pr_debug("Microcode:CPU %d resumed\n", cpu);
+        /* only CPU 0 will apply ucode here */
+        apply_microcode(0);
+        return 0;
+}
+
+static struct sysdev_driver mc_sysdev_driver = {
+        .add = mc_sysdev_add,
+        .remove = mc_sysdev_remove,
+        .resume = mc_sysdev_resume,
+};
+
+#ifdef CONFIG_HOTPLUG_CPU
+static __cpuinit int
+mc_cpu_callback(struct notifier_block *nb, unsigned long action, void *hcpu)
+{
+        unsigned int cpu = (unsigned long)hcpu;
+        struct sys_device *sys_dev;
+
+        sys_dev = get_cpu_sysdev(cpu);
+        switch (action) {
+        case CPU_ONLINE:
+        case CPU_DOWN_FAILED:
+                mc_sysdev_add(sys_dev);
+                break;
+        case CPU_DOWN_PREPARE:
+                mc_sysdev_remove(sys_dev);
+                break;
+        }
+        return NOTIFY_OK;
+}
+
+static struct notifier_block mc_cpu_notifier = {
+        .notifier_call = mc_cpu_callback,
+};
+#endif
+
+static int __init microcode_init (void)
+{
+        int error;
+
+        error = microcode_dev_init();
+        if (error)
+                return error;
+        microcode_pdev = platform_device_register_simple("microcode", -1,
+                                                         NULL, 0);
+        if (IS_ERR(microcode_pdev)) {
+                microcode_dev_exit();
+                return PTR_ERR(microcode_pdev);
+        }
+
+        lock_cpu_hotplug();
+        error = sysdev_driver_register(&cpu_sysdev_class, &mc_sysdev_driver);
+        unlock_cpu_hotplug();
+        if (error) {
+                microcode_dev_exit();
+                platform_device_unregister(microcode_pdev);
+                return error;
+        }
+
+        register_hotcpu_notifier(&mc_cpu_notifier);
+
         printk(KERN_INFO 
                 "IA-32 Microcode Update Driver: v" MICROCODE_VERSION " <tigran@veritas.com>\n");
         return 0;
@@ -515,9 +756,16 @@ static int __init microcode_init (void)
 
 static void __exit microcode_exit (void)
 {
-        misc_deregister(&microcode_dev);
+        microcode_dev_exit();
+
+        unregister_hotcpu_notifier(&mc_cpu_notifier);
+
+        lock_cpu_hotplug();
+        sysdev_driver_unregister(&cpu_sysdev_class, &mc_sysdev_driver);
+        unlock_cpu_hotplug();
+
+        platform_device_unregister(microcode_pdev);
 }
 
 module_init(microcode_init)
 module_exit(microcode_exit)
-MODULE_ALIAS_MISCDEV(MICROCODE_MINOR);
diff --git a/arch/i386/kernel/nmi.c b/arch/i386/kernel/nmi.c
index dbda706fdd14..3e8e3adb0489 100644
--- a/arch/i386/kernel/nmi.c
+++ b/arch/i386/kernel/nmi.c
@@ -13,7 +13,6 @@
  *  Mikael Pettersson   : PM converted to driver model. Disable/enable API.
  */
 
-#include <linux/config.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/module.h>
@@ -31,6 +30,9 @@
 
 #include "mach_traps.h"
 
+int unknown_nmi_panic;
+int nmi_watchdog_enabled;
+
 /* perfctr_nmi_owner tracks the ownership of the perfctr registers:
  * evtsel_nmi_owner tracks the ownership of the event selection
  * - different performance counters/ event selection may be reserved for
diff --git a/arch/i386/kernel/process.c b/arch/i386/kernel/process.c
index 8c190ca7ae44..96cd0232e1e0 100644
--- a/arch/i386/kernel/process.c
+++ b/arch/i386/kernel/process.c
@@ -425,13 +425,12 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long esp,
 
         tsk = current;
         if (unlikely(test_tsk_thread_flag(tsk, TIF_IO_BITMAP))) {
-                p->thread.io_bitmap_ptr = kmalloc(IO_BITMAP_BYTES, GFP_KERNEL);
+                p->thread.io_bitmap_ptr = kmemdup(tsk->thread.io_bitmap_ptr,
+                                                IO_BITMAP_BYTES, GFP_KERNEL);
                 if (!p->thread.io_bitmap_ptr) {
                         p->thread.io_bitmap_max = 0;
                         return -ENOMEM;
                 }
-                memcpy(p->thread.io_bitmap_ptr, tsk->thread.io_bitmap_ptr,
-                        IO_BITMAP_BYTES);
                 set_tsk_thread_flag(p, TIF_IO_BITMAP);
         }
 
diff --git a/arch/i386/kernel/setup.c b/arch/i386/kernel/setup.c
index 76a524b4c90f..000cf03751fe 100644
--- a/arch/i386/kernel/setup.c
+++ b/arch/i386/kernel/setup.c
@@ -209,9 +209,6 @@ static struct resource adapter_rom_resources[] = { {
         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
 } };
 
-#define ADAPTER_ROM_RESOURCES \
-        (sizeof adapter_rom_resources / sizeof adapter_rom_resources[0])
-
 static struct resource video_rom_resource = {
         .name   = "Video ROM",
         .start  = 0xc0000,
@@ -273,9 +270,6 @@ static struct resource standard_io_resources[] = { {
         .flags  = IORESOURCE_BUSY | IORESOURCE_IO
 } };
 
-#define STANDARD_IO_RESOURCES \
-        (sizeof standard_io_resources / sizeof standard_io_resources[0])
-
 #define romsignature(x) (*(unsigned short *)(x) == 0xaa55)
 
 static int __init romchecksum(unsigned char *rom, unsigned long length)
@@ -332,7 +326,7 @@ static void __init probe_roms(void)
         }
 
         /* check for adapter roms on 2k boundaries */
-        for (i = 0; i < ADAPTER_ROM_RESOURCES && start < upper; start += 2048) {
+        for (i = 0; i < ARRAY_SIZE(adapter_rom_resources) && start < upper; start += 2048) {
                 rom = isa_bus_to_virt(start);
                 if (!romsignature(rom))
                         continue;
@@ -1089,22 +1083,20 @@ static unsigned long __init setup_memory(void)
 
 void __init zone_sizes_init(void)
 {
-        unsigned long zones_size[MAX_NR_ZONES] = { 0, };
-        unsigned int max_dma, low;
-
-        max_dma = virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
-        low = max_low_pfn;
-
-        if (low < max_dma)
-                zones_size[ZONE_DMA] = low;
-        else {
-                zones_size[ZONE_DMA] = max_dma;
-                zones_size[ZONE_NORMAL] = low - max_dma;
 #ifdef CONFIG_HIGHMEM
-                zones_size[ZONE_HIGHMEM] = highend_pfn - low;
+        unsigned long max_zone_pfns[MAX_NR_ZONES] = {
+                        virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT,
+                        max_low_pfn,
+                        highend_pfn};
+        add_active_range(0, 0, highend_pfn);
+#else
+        unsigned long max_zone_pfns[MAX_NR_ZONES] = {
+                        virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT,
+                        max_low_pfn};
+        add_active_range(0, 0, max_low_pfn);
 #endif
-        }
-        free_area_init(zones_size);
+
+        free_area_init_nodes(max_zone_pfns);
 }
 #else
 extern unsigned long __init setup_memory(void);
@@ -1274,7 +1266,7 @@ static int __init request_standard_resources(void)
         request_resource(&iomem_resource, &video_ram_resource);
 
         /* request I/O space for devices used on all i[345]86 PCs */
-        for (i = 0; i < STANDARD_IO_RESOURCES; i++)
+        for (i = 0; i < ARRAY_SIZE(standard_io_resources); i++)
                 request_resource(&ioport_resource, &standard_io_resources[i]);
         return 0;
 }
diff --git a/arch/i386/kernel/smp.c b/arch/i386/kernel/smp.c
index 465188e2d701..1b080ab8a49f 100644
--- a/arch/i386/kernel/smp.c
+++ b/arch/i386/kernel/smp.c
@@ -700,3 +700,30 @@ int smp_call_function_single(int cpu, void (*func) (void *info), void *info,
         return 0;
 }
 EXPORT_SYMBOL(smp_call_function_single);
+
+static int convert_apicid_to_cpu(int apic_id)
+{
+        int i;
+
+        for (i = 0; i < NR_CPUS; i++) {
+                if (x86_cpu_to_apicid[i] == apic_id)
+                        return i;
+        }
+        return -1;
+}
+
+int safe_smp_processor_id(void)
+{
+        int apicid, cpuid;
+
+        if (!boot_cpu_has(X86_FEATURE_APIC))
+                return 0;
+
+        apicid = hard_smp_processor_id();
+        if (apicid == BAD_APICID)
+                return 0;
+
+        cpuid = convert_apicid_to_cpu(apicid);
+
+        return cpuid >= 0 ? cpuid : 0;
+}
diff --git a/arch/i386/kernel/smpboot.c b/arch/i386/kernel/smpboot.c
index 020d873b7d21..0831f709f777 100644
--- a/arch/i386/kernel/smpboot.c
+++ b/arch/i386/kernel/smpboot.c
@@ -102,6 +102,8 @@ u8 x86_cpu_to_apicid[NR_CPUS] __read_mostly =
                         { [0 ... NR_CPUS-1] = 0xff };
 EXPORT_SYMBOL(x86_cpu_to_apicid);
 
+u8 apicid_2_node[MAX_APICID];
+
 /*
  * Trampoline 80x86 program as an array.
  */
@@ -645,7 +647,7 @@ static void map_cpu_to_logical_apicid(void)
 {
         int cpu = smp_processor_id();
         int apicid = logical_smp_processor_id();
-        int node = apicid_to_node(apicid);
+        int node = apicid_to_node(hard_smp_processor_id());
 
         if (!node_online(node))
                 node = first_online_node;
@@ -954,6 +956,7 @@ static int __devinit do_boot_cpu(int apicid, int cpu)
 
         irq_ctx_init(cpu);
 
+        x86_cpu_to_apicid[cpu] = apicid;
         /*
          * This grunge runs the startup process for
          * the targeted processor.
@@ -1058,7 +1061,7 @@ static void __cpuinit do_warm_boot_cpu(void *p)
 
 static int __cpuinit __smp_prepare_cpu(int cpu)
 {
-        DECLARE_COMPLETION(done);
+        DECLARE_COMPLETION_ONSTACK(done);
         struct warm_boot_cpu_info info;
         struct work_struct task;
         int     apicid, ret;
diff --git a/arch/i386/kernel/srat.c b/arch/i386/kernel/srat.c
index 83db411b3aa7..f7e735c077c3 100644
--- a/arch/i386/kernel/srat.c
+++ b/arch/i386/kernel/srat.c
@@ -30,6 +30,7 @@
 #include <linux/nodemask.h>
 #include <asm/srat.h>
 #include <asm/topology.h>
+#include <asm/smp.h>
 
 /*
  * proximity macros and definitions
@@ -54,8 +55,7 @@ struct node_memory_chunk_s {
 static struct node_memory_chunk_s node_memory_chunk[MAXCHUNKS];
 
 static int num_memory_chunks;           /* total number of memory chunks */
-static int zholes_size_init;
-static unsigned long zholes_size[MAX_NUMNODES * MAX_NR_ZONES];
+static u8 __initdata apicid_to_pxm[MAX_APICID];
 
 extern void * boot_ioremap(unsigned long, unsigned long);
 
@@ -71,6 +71,8 @@ static void __init parse_cpu_affinity_structure(char *p)
         /* mark this node as "seen" in node bitmap */
         BMAP_SET(pxm_bitmap, cpu_affinity->proximity_domain);
 
+        apicid_to_pxm[cpu_affinity->apic_id] = cpu_affinity->proximity_domain;
+
         printk("CPU 0x%02X in proximity domain 0x%02X\n",
                 cpu_affinity->apic_id, cpu_affinity->proximity_domain);
 }
@@ -135,47 +137,6 @@ static void __init parse_memory_affinity_structure (char *sratp)
                  "enabled and removable" : "enabled" ) );
 }
 
-/* Take a chunk of pages from page frame cstart to cend and count the number
- * of pages in each zone, returned via zones[].
- */
-static __init void chunk_to_zones(unsigned long cstart, unsigned long cend, 
-                unsigned long *zones)
-{
-        unsigned long max_dma;
-        extern unsigned long max_low_pfn;
-
-        int z;
-        unsigned long rend;
-
-        /* FIXME: MAX_DMA_ADDRESS and max_low_pfn are trying to provide
-         * similarly scoped information and should be handled in a consistant
-         * manner.
-         */
-        max_dma = virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
-
-        /* Split the hole into the zones in which it falls.  Repeatedly
-         * take the segment in which the remaining hole starts, round it
-         * to the end of that zone.
-         */
-        memset(zones, 0, MAX_NR_ZONES * sizeof(long));
-        while (cstart < cend) {
-                if (cstart < max_dma) {
-                        z = ZONE_DMA;
-                        rend = (cend < max_dma)? cend : max_dma;
-
-                } else if (cstart < max_low_pfn) {
-                        z = ZONE_NORMAL;
-                        rend = (cend < max_low_pfn)? cend : max_low_pfn;
-
-                } else {
-                        z = ZONE_HIGHMEM;
-                        rend = cend;
-                }
-                zones[z] += rend - cstart;
-                cstart = rend;
-        }
-}
-
 /*
  * The SRAT table always lists ascending addresses, so can always
  * assume that the first "start" address that you see is the real
@@ -220,7 +181,6 @@ static int __init acpi20_parse_srat(struct acpi_table_srat *sratp)
 
         memset(pxm_bitmap, 0, sizeof(pxm_bitmap));      /* init proximity domain bitmap */
         memset(node_memory_chunk, 0, sizeof(node_memory_chunk));
-        memset(zholes_size, 0, sizeof(zholes_size));
 
         num_memory_chunks = 0;
         while (p < end) {
@@ -279,11 +239,15 @@ static int __init acpi20_parse_srat(struct acpi_table_srat *sratp)
         printk("Number of logical nodes in system = %d\n", num_online_nodes());
         printk("Number of memory chunks in system = %d\n", num_memory_chunks);
 
+        for (i = 0; i < MAX_APICID; i++)
+                apicid_2_node[i] = pxm_to_node(apicid_to_pxm[i]);
+
         for (j = 0; j < num_memory_chunks; j++){
                 struct node_memory_chunk_s * chunk = &node_memory_chunk[j];
                 printk("chunk %d nid %d start_pfn %08lx end_pfn %08lx\n",
                        j, chunk->nid, chunk->start_pfn, chunk->end_pfn);
                 node_read_chunk(chunk->nid, chunk);
+                add_active_range(chunk->nid, chunk->start_pfn, chunk->end_pfn);
         }
  
         for_each_online_node(nid) {
@@ -392,57 +356,7 @@ int __init get_memcfg_from_srat(void)
                 return acpi20_parse_srat((struct acpi_table_srat *)header);
         }
 out_err:
+        remove_all_active_ranges();
         printk("failed to get NUMA memory information from SRAT table\n");
         return 0;
 }
-
-/* For each node run the memory list to determine whether there are
- * any memory holes.  For each hole determine which ZONE they fall
- * into.
- *
- * NOTE#1: this requires knowledge of the zone boundries and so
- * _cannot_ be performed before those are calculated in setup_memory.
- * 
- * NOTE#2: we rely on the fact that the memory chunks are ordered by
- * start pfn number during setup.
- */
-static void __init get_zholes_init(void)
-{
-        int nid;
-        int c;
-        int first;
-        unsigned long end = 0;
-
-        for_each_online_node(nid) {
-                first = 1;
-                for (c = 0; c < num_memory_chunks; c++){
-                        if (node_memory_chunk[c].nid == nid) {
-                                if (first) {
-                                        end = node_memory_chunk[c].end_pfn;
-                                        first = 0;
-
-                                } else {
-                                        /* Record any gap between this chunk
-                                         * and the previous chunk on this node
-                                         * against the zones it spans.
-                                         */
-                                        chunk_to_zones(end,
-                                                node_memory_chunk[c].start_pfn,
-                                                &zholes_size[nid * MAX_NR_ZONES]);
-                                }
-                        }
-                }
-        }
-}
-
-unsigned long * __init get_zholes_size(int nid)
-{
-        if (!zholes_size_init) {
-                zholes_size_init++;
-                get_zholes_init();
-        }
-        if (nid >= MAX_NUMNODES || !node_online(nid))
-                printk("%s: nid = %d is invalid/offline. num_online_nodes = %d",
-                       __FUNCTION__, nid, num_online_nodes());
-        return &zholes_size[nid * MAX_NR_ZONES];
-}
diff --git a/arch/i386/kernel/time.c b/arch/i386/kernel/time.c
index 86944acfb647..58a2d5582419 100644
--- a/arch/i386/kernel/time.c
+++ b/arch/i386/kernel/time.c
@@ -76,8 +76,6 @@ int pit_latch_buggy;              /* extern */
 unsigned int cpu_khz;   /* Detected as we calibrate the TSC */
 EXPORT_SYMBOL(cpu_khz);
 
-extern unsigned long wall_jiffies;
-
 DEFINE_SPINLOCK(rtc_lock);
 EXPORT_SYMBOL(rtc_lock);
 
@@ -329,7 +327,6 @@ static int timer_resume(struct sys_device *dev)
         do_settimeofday(&ts);
         write_seqlock_irqsave(&xtime_lock, flags);
         jiffies_64 += sleep_length;
-        wall_jiffies += sleep_length;
         write_sequnlock_irqrestore(&xtime_lock, flags);
         touch_softlockup_watchdog();
         return 0;
diff --git a/arch/i386/kernel/traps.c b/arch/i386/kernel/traps.c
index 21aa1cd57773..6820b8d643c7 100644
--- a/arch/i386/kernel/traps.c
+++ b/arch/i386/kernel/traps.c
@@ -28,6 +28,7 @@
 #include <linux/kprobes.h>
 #include <linux/kexec.h>
 #include <linux/unwind.h>
+#include <linux/uaccess.h>
 
 #ifdef CONFIG_EISA
 #include <linux/ioport.h>
@@ -40,7 +41,6 @@
 
 #include <asm/processor.h>
 #include <asm/system.h>
-#include <asm/uaccess.h>
 #include <asm/io.h>
 #include <asm/atomic.h>
 #include <asm/debugreg.h>
@@ -57,6 +57,8 @@
 
 #include "mach_traps.h"
 
+int panic_on_unrecovered_nmi;
+
 asmlinkage int system_call(void);
 
 struct desc_struct default_ldt[] = { { 0, 0 }, { 0, 0 }, { 0, 0 },
@@ -409,7 +411,7 @@ static void handle_BUG(struct pt_regs *regs)
 
         if (eip < PAGE_OFFSET)
                 return;
-        if (__get_user(ud2, (unsigned short __user *)eip))
+        if (probe_kernel_address((unsigned short __user *)eip, ud2))
                 return;
         if (ud2 != 0x0b0f)
                 return;
@@ -422,7 +424,8 @@ static void handle_BUG(struct pt_regs *regs)
                 char *file;
                 char c;
 
-                if (__get_user(line, (unsigned short __user *)(eip + 2)))
+                if (probe_kernel_address((unsigned short __user *)(eip + 2),
+                                        line))
                         break;
                 if (__get_user(file, (char * __user *)(eip + 4)) ||
                     (unsigned long)file < PAGE_OFFSET || __get_user(c, file))
diff --git a/arch/i386/lib/delay.c b/arch/i386/lib/delay.c
index 3c0714c4b669..f6edb11364df 100644
--- a/arch/i386/lib/delay.c
+++ b/arch/i386/lib/delay.c
@@ -11,7 +11,6 @@
  */
 
 #include <linux/module.h>
-#include <linux/config.h>
 #include <linux/sched.h>
 #include <linux/delay.h>
 
diff --git a/arch/i386/lib/usercopy.c b/arch/i386/lib/usercopy.c
index efc7e7d5f4d0..08502fc6d0cb 100644
--- a/arch/i386/lib/usercopy.c
+++ b/arch/i386/lib/usercopy.c
@@ -739,7 +739,7 @@ survive:
                         retval = get_user_pages(current, current->mm,
                                         (unsigned long )to, 1, 1, 0, &pg, NULL);
 
-                        if (retval == -ENOMEM && current->pid == 1) {
+                        if (retval == -ENOMEM && is_init(current)) {
                                 up_read(&current->mm->mmap_sem);
                                 blk_congestion_wait(WRITE, HZ/50);
                                 goto survive;
diff --git a/arch/i386/mach-voyager/voyager_smp.c b/arch/i386/mach-voyager/voyager_smp.c
index 6c86575ffdcb..856c73fcb7e7 100644
--- a/arch/i386/mach-voyager/voyager_smp.c
+++ b/arch/i386/mach-voyager/voyager_smp.c
@@ -99,6 +99,7 @@ static void do_boot_cpu(__u8 cpuid);
 static void do_quad_bootstrap(void);
 
 int hard_smp_processor_id(void);
+int safe_smp_processor_id(void);
 
 /* Inline functions */
 static inline void
@@ -1247,6 +1248,12 @@ hard_smp_processor_id(void)
         return 0;
 }
 
+int
+safe_smp_processor_id(void)
+{
+        return hard_smp_processor_id();
+}
+
 /* broadcast a halt to all other CPUs */
 void
 smp_send_stop(void)
diff --git a/arch/i386/mm/discontig.c b/arch/i386/mm/discontig.c
index 941d1a5ebabb..51e3739dd227 100644
--- a/arch/i386/mm/discontig.c
+++ b/arch/i386/mm/discontig.c
@@ -157,21 +157,6 @@ static void __init find_max_pfn_node(int nid)
                 BUG();
 }
 
-/* Find the owning node for a pfn. */
-int early_pfn_to_nid(unsigned long pfn)
-{
-        int nid;
-
-        for_each_node(nid) {
-                if (node_end_pfn[nid] == 0)
-                        break;
-                if (node_start_pfn[nid] <= pfn && node_end_pfn[nid] >= pfn)
-                        return nid;
-        }
-
-        return 0;
-}
-
 /* 
  * Allocate memory for the pg_data_t for this node via a crude pre-bootmem
  * method.  For node zero take this from the bottom of memory, for
@@ -227,6 +212,8 @@ static unsigned long calculate_numa_remap_pages(void)
         unsigned long pfn;
 
         for_each_online_node(nid) {
+                unsigned old_end_pfn = node_end_pfn[nid];
+
                 /*
                  * The acpi/srat node info can show hot-add memroy zones
                  * where memory could be added but not currently present.
@@ -276,6 +263,7 @@ static unsigned long calculate_numa_remap_pages(void)
 
                 node_end_pfn[nid] -= size;
                 node_remap_start_pfn[nid] = node_end_pfn[nid];
+                shrink_active_range(nid, old_end_pfn, node_end_pfn[nid]);
         }
         printk("Reserving total of %ld pages for numa KVA remap\n",
                         reserve_pages);
@@ -369,45 +357,22 @@ void __init numa_kva_reserve(void)
 void __init zone_sizes_init(void)
 {
         int nid;
-
-
-        for_each_online_node(nid) {
-                unsigned long zones_size[MAX_NR_ZONES] = {0, };
-                unsigned long *zholes_size;
-                unsigned int max_dma;
-
-                unsigned long low = max_low_pfn;
-                unsigned long start = node_start_pfn[nid];
-                unsigned long high = node_end_pfn[nid];
-
-                max_dma = virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
-
-                if (node_has_online_mem(nid)){
-                        if (start > low) {
-#ifdef CONFIG_HIGHMEM
-                                BUG_ON(start > high);
-                                zones_size[ZONE_HIGHMEM] = high - start;
-#endif
-                        } else {
-                                if (low < max_dma)
-                                        zones_size[ZONE_DMA] = low;
-                                else {
-                                        BUG_ON(max_dma > low);
-                                        BUG_ON(low > high);
-                                        zones_size[ZONE_DMA] = max_dma;
-                                        zones_size[ZONE_NORMAL] = low - max_dma;
-#ifdef CONFIG_HIGHMEM
-                                        zones_size[ZONE_HIGHMEM] = high - low;
-#endif
-                                }
-                        }
+        unsigned long max_zone_pfns[MAX_NR_ZONES] = {
+                virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT,
+                max_low_pfn,
+                highend_pfn
+        };
+
+        /* If SRAT has not registered memory, register it now */
+        if (find_max_pfn_with_active_regions() == 0) {
+                for_each_online_node(nid) {
+                        if (node_has_online_mem(nid))
+                                add_active_range(nid, node_start_pfn[nid],
+                                                        node_end_pfn[nid]);
                 }
-
-                zholes_size = get_zholes_size(nid);
-
-                free_area_init_node(nid, NODE_DATA(nid), zones_size, start,
-                                zholes_size);
         }
+
+        free_area_init_nodes(max_zone_pfns);
         return;
 }
 
diff --git a/arch/i386/mm/fault.c b/arch/i386/mm/fault.c
index 5e17a3f43b41..2581575786c1 100644
--- a/arch/i386/mm/fault.c
+++ b/arch/i386/mm/fault.c
@@ -440,7 +440,7 @@ good_area:
                 case 1:         /* read, present */
                         goto bad_area;
                 case 0:         /* read, not present */
-                        if (!(vma->vm_flags & (VM_READ | VM_EXEC)))
+                        if (!(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE)))
                                 goto bad_area;
         }
 
@@ -589,7 +589,7 @@ no_context:
  */
 out_of_memory:
         up_read(&mm->mmap_sem);
-        if (tsk->pid == 1) {
+        if (is_init(tsk)) {
                 yield();
                 down_read(&mm->mmap_sem);
                 goto survive;
diff --git a/arch/i386/mm/highmem.c b/arch/i386/mm/highmem.c
index ba44000b9069..f9f647cdbc7b 100644
--- a/arch/i386/mm/highmem.c
+++ b/arch/i386/mm/highmem.c
@@ -38,22 +38,19 @@ void *kmap_atomic(struct page *page, enum km_type type)
 
         idx = type + KM_TYPE_NR*smp_processor_id();
         vaddr = __fix_to_virt(FIX_KMAP_BEGIN + idx);
-#ifdef CONFIG_DEBUG_HIGHMEM
         if (!pte_none(*(kmap_pte-idx)))
                 BUG();
-#endif
         set_pte(kmap_pte-idx, mk_pte(page, kmap_prot));
-        __flush_tlb_one(vaddr);
 
         return (void*) vaddr;
 }
 
 void kunmap_atomic(void *kvaddr, enum km_type type)
 {
-#ifdef CONFIG_DEBUG_HIGHMEM
         unsigned long vaddr = (unsigned long) kvaddr & PAGE_MASK;
         enum fixed_addresses idx = type + KM_TYPE_NR*smp_processor_id();
 
+#ifdef CONFIG_DEBUG_HIGHMEM
         if (vaddr >= PAGE_OFFSET && vaddr < (unsigned long)high_memory) {
                 dec_preempt_count();
                 preempt_check_resched();
@@ -62,14 +59,14 @@ void kunmap_atomic(void *kvaddr, enum km_type type)
 
         if (vaddr != __fix_to_virt(FIX_KMAP_BEGIN+idx))
                 BUG();
-
+#endif
         /*
-         * force other mappings to Oops if they'll try to access
-         * this pte without first remap it
+         * Force other mappings to Oops if they'll try to access this pte
+         * without first remap it.  Keeping stale mappings around is a bad idea
+         * also, in case the page changes cacheability attributes or becomes
+         * a protected page in a hypervisor.
          */
-        pte_clear(&init_mm, vaddr, kmap_pte-idx);
-        __flush_tlb_one(vaddr);
-#endif
+        kpte_clear_flush(kmap_pte-idx, vaddr);
 
         dec_preempt_count();
         preempt_check_resched();
@@ -88,7 +85,6 @@ void *kmap_atomic_pfn(unsigned long pfn, enum km_type type)
         idx = type + KM_TYPE_NR*smp_processor_id();
         vaddr = __fix_to_virt(FIX_KMAP_BEGIN + idx);
         set_pte(kmap_pte-idx, pfn_pte(pfn, kmap_prot));
-        __flush_tlb_one(vaddr);
 
         return (void*) vaddr;
 }
diff --git a/arch/i386/mm/init.c b/arch/i386/mm/init.c
index 4a5a914b3432..90089c14c23d 100644
--- a/arch/i386/mm/init.c
+++ b/arch/i386/mm/init.c
@@ -493,6 +493,7 @@ int __init set_kernel_exec(unsigned long vaddr, int enable)
                 pte->pte_high &= ~(1 << (_PAGE_BIT_NX - 32));
         else
                 pte->pte_high |= 1 << (_PAGE_BIT_NX - 32);
+        pte_update_defer(&init_mm, vaddr, pte);
         __flush_tlb_all();
 out:
         return ret;
diff --git a/arch/i386/mm/ioremap.c b/arch/i386/mm/ioremap.c
index 247fde76aaed..fff08ae7b5ed 100644
--- a/arch/i386/mm/ioremap.c
+++ b/arch/i386/mm/ioremap.c
@@ -12,7 +12,7 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/module.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <asm/fixmap.h>
 #include <asm/cacheflush.h>
 #include <asm/tlbflush.h>
@@ -21,82 +21,6 @@
 #define ISA_START_ADDRESS       0xa0000
 #define ISA_END_ADDRESS         0x100000
 
-static int ioremap_pte_range(pmd_t *pmd, unsigned long addr,
-                unsigned long end, unsigned long phys_addr, unsigned long flags)
-{
-        pte_t *pte;
-        unsigned long pfn;
-
-        pfn = phys_addr >> PAGE_SHIFT;
-        pte = pte_alloc_kernel(pmd, addr);
-        if (!pte)
-                return -ENOMEM;
-        do {
-                BUG_ON(!pte_none(*pte));
-                set_pte(pte, pfn_pte(pfn, __pgprot(_PAGE_PRESENT | _PAGE_RW | 
-                                        _PAGE_DIRTY | _PAGE_ACCESSED | flags)));
-                pfn++;
-        } while (pte++, addr += PAGE_SIZE, addr != end);
-        return 0;
-}
-
-static inline int ioremap_pmd_range(pud_t *pud, unsigned long addr,
-                unsigned long end, unsigned long phys_addr, unsigned long flags)
-{
-        pmd_t *pmd;
-        unsigned long next;
-
-        phys_addr -= addr;
-        pmd = pmd_alloc(&init_mm, pud, addr);
-        if (!pmd)
-                return -ENOMEM;
-        do {
-                next = pmd_addr_end(addr, end);
-                if (ioremap_pte_range(pmd, addr, next, phys_addr + addr, flags))
-                        return -ENOMEM;
-        } while (pmd++, addr = next, addr != end);
-        return 0;
-}
-
-static inline int ioremap_pud_range(pgd_t *pgd, unsigned long addr,
-                unsigned long end, unsigned long phys_addr, unsigned long flags)
-{
-        pud_t *pud;
-        unsigned long next;
-
-        phys_addr -= addr;
-        pud = pud_alloc(&init_mm, pgd, addr);
-        if (!pud)
-                return -ENOMEM;
-        do {
-                next = pud_addr_end(addr, end);
-                if (ioremap_pmd_range(pud, addr, next, phys_addr + addr, flags))
-                        return -ENOMEM;
-        } while (pud++, addr = next, addr != end);
-        return 0;
-}
-
-static int ioremap_page_range(unsigned long addr,
-                unsigned long end, unsigned long phys_addr, unsigned long flags)
-{
-        pgd_t *pgd;
-        unsigned long next;
-        int err;
-
-        BUG_ON(addr >= end);
-        flush_cache_all();
-        phys_addr -= addr;
-        pgd = pgd_offset_k(addr);
-        do {
-                next = pgd_addr_end(addr, end);
-                err = ioremap_pud_range(pgd, addr, next, phys_addr+addr, flags);
-                if (err)
-                        break;
-        } while (pgd++, addr = next, addr != end);
-        flush_tlb_all();
-        return err;
-}
-
 /*
  * Generic mapping function (not visible outside):
  */
@@ -115,6 +39,7 @@ void __iomem * __ioremap(unsigned long phys_addr, unsigned long size, unsigned l
         void __iomem * addr;
         struct vm_struct * area;
         unsigned long offset, last_addr;
+        pgprot_t prot;
 
         /* Don't allow wraparound or zero size */
         last_addr = phys_addr + size - 1;
@@ -142,6 +67,9 @@ void __iomem * __ioremap(unsigned long phys_addr, unsigned long size, unsigned l
                                 return NULL;
         }
 
+        prot = __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY
+                        | _PAGE_ACCESSED | flags);
+
         /*
          * Mappings have to be page-aligned
          */
@@ -158,7 +86,7 @@ void __iomem * __ioremap(unsigned long phys_addr, unsigned long size, unsigned l
         area->phys_addr = phys_addr;
         addr = (void __iomem *) area->addr;
         if (ioremap_page_range((unsigned long) addr,
-                        (unsigned long) addr + size, phys_addr, flags)) {
+                        (unsigned long) addr + size, phys_addr, prot)) {
                 vunmap((void __force *) addr);
                 return NULL;
         }
diff --git a/arch/i386/oprofile/op_model_ppro.c b/arch/i386/oprofile/op_model_ppro.c
index f88e05ba8eb3..ca2447e05e15 100644
--- a/arch/i386/oprofile/op_model_ppro.c
+++ b/arch/i386/oprofile/op_model_ppro.c
@@ -138,11 +138,14 @@ static int ppro_check_ctrs(struct pt_regs * const regs,
 static void ppro_start(struct op_msrs const * const msrs)
 {
         unsigned int low,high;
+        int i;
 
-        if (reset_value[0]) {
-                CTRL_READ(low, high, msrs, 0);
-                CTRL_SET_ACTIVE(low);
-                CTRL_WRITE(low, high, msrs, 0);
+        for (i = 0; i < NUM_COUNTERS; ++i) {
+                if (reset_value[i]) {
+                        CTRL_READ(low, high, msrs, i);
+                        CTRL_SET_ACTIVE(low);
+                        CTRL_WRITE(low, high, msrs, i);
+                }
         }
 }
 
@@ -150,11 +153,14 @@ static void ppro_start(struct op_msrs const * const msrs)
 static void ppro_stop(struct op_msrs const * const msrs)
 {
         unsigned int low,high;
+        int i;
 
-        if (reset_value[0]) {
-                CTRL_READ(low, high, msrs, 0);
+        for (i = 0; i < NUM_COUNTERS; ++i) {
+                if (!reset_value[i])
+                        continue;
+                CTRL_READ(low, high, msrs, i);
                 CTRL_SET_INACTIVE(low);
-                CTRL_WRITE(low, high, msrs, 0);
+                CTRL_WRITE(low, high, msrs, i);
         }
 }
 
diff --git a/arch/i386/pci/mmconfig.c b/arch/i386/pci/mmconfig.c
index 05be8db58a8c..d0c3da3aa2aa 100644
--- a/arch/i386/pci/mmconfig.c
+++ b/arch/i386/pci/mmconfig.c
@@ -67,7 +67,10 @@ static u32 get_base_addr(unsigned int seg, int bus, unsigned devfn)
         return 0;
 }
 
-static inline void pci_exp_set_dev_base(unsigned int base, int bus, int devfn)
+/*
+ * This is always called under pci_config_lock
+ */
+static void pci_exp_set_dev_base(unsigned int base, int bus, int devfn)
 {
         u32 dev_base = base | (bus << 20) | (devfn << 12);
         if (dev_base != mmcfg_last_accessed_device) {