Merge branch 'linus' into core/iommu

author: Ingo Molnar <mingo@elte.hu> 2009-01-10 18:51:06 -0500
committer: Ingo Molnar <mingo@elte.hu> 2009-01-10 18:51:06 -0500
commit: 0811a433c61e85f895018239c4466a36311cd5de (patch)
tree: 276933e518e5525d24ae37b02df2db9909679260 /arch/x86/kernel
parent: c299030765292434b73572f9bcfe84951ff06614 (diff)
parent: 3d14bdad40315b54470cb7812293d14c8af2bf7d (diff)
43 files changed, 610 insertions, 540 deletions
diff --git a/arch/x86/kernel/acpi/boot.c b/arch/x86/kernel/acpi/boot.c
index 29dc0c89d4a..d37593c2f43 100644
--- a/arch/x86/kernel/acpi/boot.c
+++ b/arch/x86/kernel/acpi/boot.c
@@ -47,7 +47,7 @@
 #endif
 static int __initdata acpi_force = 0;
+u32 acpi_rsdt_forced;
 #ifdef  CONFIG_ACPI
 int acpi_disabled = 0;
 #else
@@ -1374,6 +1374,17 @@ static void __init acpi_process_madt(void)
                               "Invalid BIOS MADT, disabling ACPI\n");
                        disable_acpi();
                }
+        } else {
+                /*
+                 * ACPI found no MADT, and so ACPI wants UP PIC mode.
+                 * In the event an MPS table was found, forget it.
+                 * Boot with "acpi=off" to use MPS on such a system.
+                 */
+                if (smp_found_config) {
+                        printk(KERN_WARNING PREFIX
+                                "No APIC-table, disabling MPS\n");
+                        smp_found_config = 0;
+                }
        }
        /*
@@ -1809,6 +1820,10 @@ static int __init parse_acpi(char *arg)
                        disable_acpi();
                acpi_ht = 1;
        }
+        /* acpi=rsdt use RSDT instead of XSDT */
+        else if (strcmp(arg, "rsdt") == 0) {
+                acpi_rsdt_forced = 1;
+        }
        /* "acpi=noirq" disables ACPI interrupt routing */
        else if (strcmp(arg, "noirq") == 0) {
                acpi_noirq_set();
diff --git a/arch/x86/kernel/acpi/cstate.c b/arch/x86/kernel/acpi/cstate.c
index c2502eb9aa8..bbbe4bbb6f3 100644
--- a/arch/x86/kernel/acpi/cstate.c
+++ b/arch/x86/kernel/acpi/cstate.c
@@ -56,6 +56,7 @@ static struct cstate_entry *cpu_cstate_entry;	/* per CPU ptr */
 static short mwait_supported[ACPI_PROCESSOR_MAX_POWER];
 #define MWAIT_SUBSTATE_MASK     (0xf)
+#define MWAIT_CSTATE_MASK       (0xf)
 #define MWAIT_SUBSTATE_SIZE     (4)
 #define CPUID_MWAIT_LEAF (5)
@@ -66,39 +67,20 @@ static short mwait_supported[ACPI_PROCESSOR_MAX_POWER];
 #define NATIVE_CSTATE_BEYOND_HALT       (2)
-int acpi_processor_ffh_cstate_probe(unsigned int cpu,
+static long acpi_processor_ffh_cstate_probe_cpu(void *_cx)
-                struct acpi_processor_cx *cx, struct acpi_power_register *reg)
 {
-        struct cstate_entry *percpu_entry;
+        struct acpi_processor_cx *cx = _cx;
-        struct cpuinfo_x86 *c = &cpu_data(cpu);
+        long retval;
-        cpumask_t saved_mask;
-        int retval;
        unsigned int eax, ebx, ecx, edx;
        unsigned int edx_part;
        unsigned int cstate_type; /* C-state type and not ACPI C-state type */
        unsigned int num_cstate_subtype;
-        if (!cpu_cstate_entry || c->cpuid_level < CPUID_MWAIT_LEAF )
-                return -1;
-        if (reg->bit_offset != NATIVE_CSTATE_BEYOND_HALT)
-                return -1;
-        percpu_entry = per_cpu_ptr(cpu_cstate_entry, cpu);
-        percpu_entry->states[cx->index].eax = 0;
-        percpu_entry->states[cx->index].ecx = 0;
-        /* Make sure we are running on right CPU */
-        saved_mask = current->cpus_allowed;
-        retval = set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
-        if (retval)
-                return -1;
        cpuid(CPUID_MWAIT_LEAF, &eax, &ebx, &ecx, &edx);
        /* Check whether this particular cx_type (in CST) is supported or not */
-        cstate_type = (cx->address >> MWAIT_SUBSTATE_SIZE) + 1;
+        cstate_type = ((cx->address >> MWAIT_SUBSTATE_SIZE) &
+                        MWAIT_CSTATE_MASK) + 1;
        edx_part = edx >> (cstate_type * MWAIT_SUBSTATE_SIZE);
        num_cstate_subtype = edx_part & MWAIT_SUBSTATE_MASK;
@@ -114,21 +96,45 @@ int acpi_processor_ffh_cstate_probe(unsigned int cpu,
                retval = -1;
                goto out;
        }
-        percpu_entry->states[cx->index].ecx = MWAIT_ECX_INTERRUPT_BREAK;
-        /* Use the hint in CST */
-        percpu_entry->states[cx->index].eax = cx->address;
        if (!mwait_supported[cstate_type]) {
                mwait_supported[cstate_type] = 1;
-                printk(KERN_DEBUG "Monitor-Mwait will be used to enter C-%d "
+                printk(KERN_DEBUG
-                       "state\n", cx->type);
+                        "Monitor-Mwait will be used to enter C-%d "
+                        "state\n", cx->type);
        }
-        snprintf(cx->desc, ACPI_CX_DESC_LEN, "ACPI FFH INTEL MWAIT 0x%x",
+        snprintf(cx->desc,
-                 cx->address);
+                        ACPI_CX_DESC_LEN, "ACPI FFH INTEL MWAIT 0x%x",
+                        cx->address);
 out:
-        set_cpus_allowed_ptr(current, &saved_mask);
+        return retval;
+}
+int acpi_processor_ffh_cstate_probe(unsigned int cpu,
+                struct acpi_processor_cx *cx, struct acpi_power_register *reg)
+{
+        struct cstate_entry *percpu_entry;
+        struct cpuinfo_x86 *c = &cpu_data(cpu);
+        long retval;
+        if (!cpu_cstate_entry || c->cpuid_level < CPUID_MWAIT_LEAF)
+                return -1;
+        if (reg->bit_offset != NATIVE_CSTATE_BEYOND_HALT)
+                return -1;
+        percpu_entry = per_cpu_ptr(cpu_cstate_entry, cpu);
+        percpu_entry->states[cx->index].eax = 0;
+        percpu_entry->states[cx->index].ecx = 0;
+        /* Make sure we are running on right CPU */
+        retval = work_on_cpu(cpu, acpi_processor_ffh_cstate_probe_cpu, cx);
+        if (retval == 0) {
+                /* Use the hint in CST */
+                percpu_entry->states[cx->index].eax = cx->address;
+                percpu_entry->states[cx->index].ecx = MWAIT_ECX_INTERRUPT_BREAK;
+        }
        return retval;
 }
 EXPORT_SYMBOL_GPL(acpi_processor_ffh_cstate_probe);
diff --git a/arch/x86/kernel/acpi/sleep.c b/arch/x86/kernel/acpi/sleep.c
index 806b4e9051b..707c1f6f95f 100644
--- a/arch/x86/kernel/acpi/sleep.c
+++ b/arch/x86/kernel/acpi/sleep.c
@@ -159,6 +159,8 @@ static int __init acpi_sleep_setup(char *str)
 #endif
                if (strncmp(str, "old_ordering", 12) == 0)
                        acpi_old_suspend_ordering();
+                if (strncmp(str, "s4_nonvs", 8) == 0)
+                        acpi_s4_no_nvs();
                str = strchr(str, ',');
                if (str != NULL)
                        str += strspn(str, ", \t");
diff --git a/arch/x86/kernel/apic.c b/arch/x86/kernel/apic.c
index b13d3c4dbd4..566a08466b1 100644
--- a/arch/x86/kernel/apic.c
+++ b/arch/x86/kernel/apic.c
@@ -31,9 +31,11 @@
 #include <linux/dmi.h>
 #include <linux/dmar.h>
 #include <linux/ftrace.h>
+#include <linux/smp.h>
+#include <linux/nmi.h>
+#include <linux/timex.h>
 #include <asm/atomic.h>
-#include <asm/smp.h>
 #include <asm/mtrr.h>
 #include <asm/mpspec.h>
 #include <asm/desc.h>
@@ -41,10 +43,8 @@
 #include <asm/hpet.h>
 #include <asm/pgalloc.h>
 #include <asm/i8253.h>
-#include <asm/nmi.h>
 #include <asm/idle.h>
 #include <asm/proto.h>
-#include <asm/timex.h>
 #include <asm/apic.h>
 #include <asm/i8259.h>
@@ -687,7 +687,7 @@ static int __init calibrate_APIC_clock(void)
                local_irq_enable();
        if (levt->features & CLOCK_EVT_FEAT_DUMMY) {
-                pr_warning("APIC timer disabled due to verification failure.\n");
+                pr_warning("APIC timer disabled due to verification failure\n");
                        return -1;
        }
@@ -2087,14 +2087,12 @@ __cpuinit int apic_is_clustered_box(void)
                /* are we being called early in kernel startup? */
                if (bios_cpu_apicid) {
                        id = bios_cpu_apicid[i];
-                }
+                } else if (i < nr_cpu_ids) {
-                else if (i < nr_cpu_ids) {
                        if (cpu_present(i))
                                id = per_cpu(x86_bios_cpu_apicid, i);
                        else
                                continue;
-                }
+                } else
-                else
                        break;
                if (id != BAD_APICID)
diff --git a/arch/x86/kernel/apm_32.c b/arch/x86/kernel/apm_32.c
index 3a26525a3f3..98807bb095a 100644
--- a/arch/x86/kernel/apm_32.c
+++ b/arch/x86/kernel/apm_32.c
@@ -160,9 +160,9 @@
 *         Work around byte swap bug in one of the Vaio's BIOS's
 *         (Marc Boucher <marc@mbsi.ca>).
 *         Exposed the disable flag to dmi so that we can handle known
- *         broken APM (Alan Cox <alan@redhat.com>).
+ *         broken APM (Alan Cox <alan@lxorguk.ukuu.org.uk>).
 *   1.14ac: If the BIOS says "I slowed the CPU down" then don't spin
- *         calling it - instead idle. (Alan Cox <alan@redhat.com>)
+ *         calling it - instead idle. (Alan Cox <alan@lxorguk.ukuu.org.uk>)
 *         If an APM idle fails log it and idle sensibly
 *   1.15: Don't queue events to clients who open the device O_WRONLY.
 *         Don't expect replies from clients who open the device O_RDONLY.
diff --git a/arch/x86/kernel/cpu/common.c b/arch/x86/kernel/cpu/common.c
index 3f95a40f718..83492b1f93b 100644
--- a/arch/x86/kernel/cpu/common.c
+++ b/arch/x86/kernel/cpu/common.c
@@ -40,6 +40,26 @@
 #include "cpu.h"
+#ifdef CONFIG_X86_64
+/* all of these masks are initialized in setup_cpu_local_masks() */
+cpumask_var_t cpu_callin_mask;
+cpumask_var_t cpu_callout_mask;
+cpumask_var_t cpu_initialized_mask;
+/* representing cpus for which sibling maps can be computed */
+cpumask_var_t cpu_sibling_setup_mask;
+#else /* CONFIG_X86_32 */
+cpumask_t cpu_callin_map;
+cpumask_t cpu_callout_map;
+cpumask_t cpu_initialized;
+cpumask_t cpu_sibling_setup_map;
+#endif /* CONFIG_X86_32 */
 static struct cpu_dev *this_cpu __cpuinitdata;
 #ifdef CONFIG_X86_64
@@ -856,8 +876,6 @@ static __init int setup_disablecpuid(char *arg)
 }
 __setup("clearcpuid=", setup_disablecpuid);
-cpumask_t cpu_initialized __cpuinitdata = CPU_MASK_NONE;
 #ifdef CONFIG_X86_64
 struct x8664_pda **_cpu_pda __read_mostly;
 EXPORT_SYMBOL(_cpu_pda);
@@ -976,7 +994,7 @@ void __cpuinit cpu_init(void)
        me = current;
-        if (cpu_test_and_set(cpu, cpu_initialized))
+        if (cpumask_test_and_set_cpu(cpu, cpu_initialized_mask))
                panic("CPU#%d already initialized!\n", cpu);
        printk(KERN_INFO "Initializing CPU#%d\n", cpu);
@@ -1085,7 +1103,7 @@ void __cpuinit cpu_init(void)
        struct tss_struct *t = &per_cpu(init_tss, cpu);
        struct thread_struct *thread = &curr->thread;
-        if (cpu_test_and_set(cpu, cpu_initialized)) {
+        if (cpumask_test_and_set_cpu(cpu, cpu_initialized_mask)) {
                printk(KERN_WARNING "CPU#%d already initialized!\n", cpu);
                for (;;) local_irq_enable();
        }
diff --git a/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c b/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
index 28102ad1a36..06fcd8f9323 100644
--- a/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
+++ b/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
@@ -145,13 +145,14 @@ typedef union {
 struct drv_cmd {
        unsigned int type;
-        cpumask_t mask;
+        cpumask_var_t mask;
        drv_addr_union addr;
        u32 val;
 };
-static void do_drv_read(struct drv_cmd *cmd)
+static long do_drv_read(void *_cmd)
 {
+        struct drv_cmd *cmd = _cmd;
        u32 h;
        switch (cmd->type) {
@@ -166,10 +167,12 @@ static void do_drv_read(struct drv_cmd *cmd)
        default:
                break;
        }
+        return 0;
 }
-static void do_drv_write(struct drv_cmd *cmd)
+static long do_drv_write(void *_cmd)
 {
+        struct drv_cmd *cmd = _cmd;
        u32 lo, hi;
        switch (cmd->type) {
@@ -186,48 +189,41 @@ static void do_drv_write(struct drv_cmd *cmd)
        default:
                break;
        }
+        return 0;
 }
 static void drv_read(struct drv_cmd *cmd)
 {
-        cpumask_t saved_mask = current->cpus_allowed;
        cmd->val = 0;
-        set_cpus_allowed_ptr(current, &cmd->mask);
+        work_on_cpu(cpumask_any(cmd->mask), do_drv_read, cmd);
-        do_drv_read(cmd);
-        set_cpus_allowed_ptr(current, &saved_mask);
 }
 static void drv_write(struct drv_cmd *cmd)
 {
-        cpumask_t saved_mask = current->cpus_allowed;
        unsigned int i;
-        for_each_cpu_mask_nr(i, cmd->mask) {
+        for_each_cpu(i, cmd->mask) {
-                set_cpus_allowed_ptr(current, &cpumask_of_cpu(i));
+                work_on_cpu(i, do_drv_write, cmd);
-                do_drv_write(cmd);
        }
-        set_cpus_allowed_ptr(current, &saved_mask);
-        return;
 }
-static u32 get_cur_val(const cpumask_t *mask)
+static u32 get_cur_val(const struct cpumask *mask)
 {
        struct acpi_processor_performance *perf;
        struct drv_cmd cmd;
-        if (unlikely(cpus_empty(*mask)))
+        if (unlikely(cpumask_empty(mask)))
                return 0;
-        switch (per_cpu(drv_data, first_cpu(*mask))->cpu_feature) {
+        switch (per_cpu(drv_data, cpumask_first(mask))->cpu_feature) {
        case SYSTEM_INTEL_MSR_CAPABLE:
                cmd.type = SYSTEM_INTEL_MSR_CAPABLE;
                cmd.addr.msr.reg = MSR_IA32_PERF_STATUS;
                break;
        case SYSTEM_IO_CAPABLE:
                cmd.type = SYSTEM_IO_CAPABLE;
-                perf = per_cpu(drv_data, first_cpu(*mask))->acpi_data;
+                perf = per_cpu(drv_data, cpumask_first(mask))->acpi_data;
                cmd.addr.io.port = perf->control_register.address;
                cmd.addr.io.bit_width = perf->control_register.bit_width;
                break;
@@ -235,15 +231,44 @@ static u32 get_cur_val(const cpumask_t *mask)
                return 0;
        }
-        cmd.mask = *mask;
+        if (unlikely(!alloc_cpumask_var(&cmd.mask, GFP_KERNEL)))
+                return 0;
+        cpumask_copy(cmd.mask, mask);
        drv_read(&cmd);
+        free_cpumask_var(cmd.mask);
        dprintk("get_cur_val = %u\n", cmd.val);
        return cmd.val;
 }
+struct perf_cur {
+        union {
+                struct {
+                        u32 lo;
+                        u32 hi;
+                } split;
+                u64 whole;
+        } aperf_cur, mperf_cur;
+};
+static long read_measured_perf_ctrs(void *_cur)
+{
+        struct perf_cur *cur = _cur;
+        rdmsr(MSR_IA32_APERF, cur->aperf_cur.split.lo, cur->aperf_cur.split.hi);
+        rdmsr(MSR_IA32_MPERF, cur->mperf_cur.split.lo, cur->mperf_cur.split.hi);
+        wrmsr(MSR_IA32_APERF, 0, 0);
+        wrmsr(MSR_IA32_MPERF, 0, 0);
+        return 0;
+}
 /*
 * Return the measured active (C0) frequency on this CPU since last call
 * to this function.
@@ -260,31 +285,12 @@ static u32 get_cur_val(const cpumask_t *mask)
 static unsigned int get_measured_perf(struct cpufreq_policy *policy,
                                      unsigned int cpu)
 {
-        union {
+        struct perf_cur cur;
-                struct {
-                        u32 lo;
-                        u32 hi;
-                } split;
-                u64 whole;
-        } aperf_cur, mperf_cur;
-        cpumask_t saved_mask;
        unsigned int perf_percent;
        unsigned int retval;
-        saved_mask = current->cpus_allowed;
+        if (!work_on_cpu(cpu, read_measured_perf_ctrs, &cur))
-        set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
-        if (get_cpu() != cpu) {
-                /* We were not able to run on requested processor */
-                put_cpu();
                return 0;
-        }
-        rdmsr(MSR_IA32_APERF, aperf_cur.split.lo, aperf_cur.split.hi);
-        rdmsr(MSR_IA32_MPERF, mperf_cur.split.lo, mperf_cur.split.hi);
-        wrmsr(MSR_IA32_APERF, 0,0);
-        wrmsr(MSR_IA32_MPERF, 0,0);
 #ifdef __i386__
        /*
@@ -292,37 +298,39 @@ static unsigned int get_measured_perf(struct cpufreq_policy *policy,
         * Get an approximate value. Return failure in case we cannot get
         * an approximate value.
         */
-        if (unlikely(aperf_cur.split.hi || mperf_cur.split.hi)) {
+        if (unlikely(cur.aperf_cur.split.hi || cur.mperf_cur.split.hi)) {
                int shift_count;
                u32 h;
-                h = max_t(u32, aperf_cur.split.hi, mperf_cur.split.hi);
+                h = max_t(u32, cur.aperf_cur.split.hi, cur.mperf_cur.split.hi);
                shift_count = fls(h);
-                aperf_cur.whole >>= shift_count;
+                cur.aperf_cur.whole >>= shift_count;
-                mperf_cur.whole >>= shift_count;
+                cur.mperf_cur.whole >>= shift_count;
        }
-        if (((unsigned long)(-1) / 100) < aperf_cur.split.lo) {
+        if (((unsigned long)(-1) / 100) < cur.aperf_cur.split.lo) {
                int shift_count = 7;
-                aperf_cur.split.lo >>= shift_count;
+                cur.aperf_cur.split.lo >>= shift_count;
-                mperf_cur.split.lo >>= shift_count;
+                cur.mperf_cur.split.lo >>= shift_count;
        }
-        if (aperf_cur.split.lo && mperf_cur.split.lo)
+        if (cur.aperf_cur.split.lo && cur.mperf_cur.split.lo)
-                perf_percent = (aperf_cur.split.lo * 100) / mperf_cur.split.lo;
+                perf_percent = (cur.aperf_cur.split.lo * 100) /
+                                cur.mperf_cur.split.lo;
        else
                perf_percent = 0;
 #else
-        if (unlikely(((unsigned long)(-1) / 100) < aperf_cur.whole)) {
+        if (unlikely(((unsigned long)(-1) / 100) < cur.aperf_cur.whole)) {
                int shift_count = 7;
-                aperf_cur.whole >>= shift_count;
+                cur.aperf_cur.whole >>= shift_count;
-                mperf_cur.whole >>= shift_count;
+                cur.mperf_cur.whole >>= shift_count;
        }
-        if (aperf_cur.whole && mperf_cur.whole)
+        if (cur.aperf_cur.whole && cur.mperf_cur.whole)
-                perf_percent = (aperf_cur.whole * 100) / mperf_cur.whole;
+                perf_percent = (cur.aperf_cur.whole * 100) /
+                                cur.mperf_cur.whole;
        else
                perf_percent = 0;
@@ -330,10 +338,6 @@ static unsigned int get_measured_perf(struct cpufreq_policy *policy,
        retval = per_cpu(drv_data, policy->cpu)->max_freq * perf_percent / 100;
-        put_cpu();
-        set_cpus_allowed_ptr(current, &saved_mask);
-        dprintk("cpu %d: performance percent %d\n", cpu, perf_percent);
        return retval;
 }
@@ -351,7 +355,7 @@ static unsigned int get_cur_freq_on_cpu(unsigned int cpu)
        }
        cached_freq = data->freq_table[data->acpi_data->state].frequency;
-        freq = extract_freq(get_cur_val(&cpumask_of_cpu(cpu)), data);
+        freq = extract_freq(get_cur_val(cpumask_of(cpu)), data);
        if (freq != cached_freq) {
                /*
                 * The dreaded BIOS frequency change behind our back.
@@ -386,7 +390,6 @@ static int acpi_cpufreq_target(struct cpufreq_policy *policy,
        struct acpi_cpufreq_data *data = per_cpu(drv_data, policy->cpu);
        struct acpi_processor_performance *perf;
        struct cpufreq_freqs freqs;
-        cpumask_t online_policy_cpus;
        struct drv_cmd cmd;
        unsigned int next_state = 0; /* Index into freq_table */
        unsigned int next_perf_state = 0; /* Index into perf table */
@@ -401,20 +404,18 @@ static int acpi_cpufreq_target(struct cpufreq_policy *policy,
                return -ENODEV;
        }
+        if (unlikely(!alloc_cpumask_var(&cmd.mask, GFP_KERNEL)))
+                return -ENOMEM;
        perf = data->acpi_data;
        result = cpufreq_frequency_table_target(policy,
                                                data->freq_table,
                                                target_freq,
                                                relation, &next_state);
-        if (unlikely(result))
+        if (unlikely(result)) {
-                return -ENODEV;
+                result = -ENODEV;
+                goto out;
-#ifdef CONFIG_HOTPLUG_CPU
+        }
-        /* cpufreq holds the hotplug lock, so we are safe from here on */
-        cpus_and(online_policy_cpus, cpu_online_map, policy->cpus);
-#else
-        online_policy_cpus = policy->cpus;
-#endif
        next_perf_state = data->freq_table[next_state].index;
        if (perf->state == next_perf_state) {
@@ -425,7 +426,7 @@ static int acpi_cpufreq_target(struct cpufreq_policy *policy,
                } else {
                        dprintk("Already at target state (P%d)\n",
                                next_perf_state);
-                        return 0;
+                        goto out;
                }
        }
@@ -444,19 +445,19 @@ static int acpi_cpufreq_target(struct cpufreq_policy *policy,
                cmd.val = (u32) perf->states[next_perf_state].control;
                break;
        default:
-                return -ENODEV;
+                result = -ENODEV;
+                goto out;
        }
-        cpus_clear(cmd.mask);
+        /* cpufreq holds the hotplug lock, so we are safe from here on */
        if (policy->shared_type != CPUFREQ_SHARED_TYPE_ANY)
-                cmd.mask = online_policy_cpus;
+                cpumask_and(cmd.mask, cpu_online_mask, policy->cpus);
        else
-                cpu_set(policy->cpu, cmd.mask);
+                cpumask_copy(cmd.mask, cpumask_of(policy->cpu));
        freqs.old = perf->states[perf->state].core_frequency * 1000;
        freqs.new = data->freq_table[next_state].frequency;
-        for_each_cpu_mask_nr(i, cmd.mask) {
+        for_each_cpu(i, cmd.mask) {
                freqs.cpu = i;
                cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
        }
@@ -464,19 +465,22 @@ static int acpi_cpufreq_target(struct cpufreq_policy *policy,
        drv_write(&cmd);
        if (acpi_pstate_strict) {
-                if (!check_freqs(&cmd.mask, freqs.new, data)) {
+                if (!check_freqs(cmd.mask, freqs.new, data)) {
                        dprintk("acpi_cpufreq_target failed (%d)\n",
                                policy->cpu);
-                        return -EAGAIN;
+                        result = -EAGAIN;
+                        goto out;
                }
        }
-        for_each_cpu_mask_nr(i, cmd.mask) {
+        for_each_cpu(i, cmd.mask) {
                freqs.cpu = i;
                cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
        }
        perf->state = next_perf_state;
+out:
+        free_cpumask_var(cmd.mask);
        return result;
 }
@@ -626,15 +630,15 @@ static int acpi_cpufreq_cpu_init(struct cpufreq_policy *policy)
         */
        if (policy->shared_type == CPUFREQ_SHARED_TYPE_ALL ||
            policy->shared_type == CPUFREQ_SHARED_TYPE_ANY) {
-                cpumask_copy(&policy->cpus, perf->shared_cpu_map);
+                cpumask_copy(policy->cpus, perf->shared_cpu_map);
        }
-        cpumask_copy(&policy->related_cpus, perf->shared_cpu_map);
+        cpumask_copy(policy->related_cpus, perf->shared_cpu_map);
 #ifdef CONFIG_SMP
        dmi_check_system(sw_any_bug_dmi_table);
-        if (bios_with_sw_any_bug && cpus_weight(policy->cpus) == 1) {
+        if (bios_with_sw_any_bug && cpumask_weight(policy->cpus) == 1) {
                policy->shared_type = CPUFREQ_SHARED_TYPE_ALL;
-                policy->cpus = per_cpu(cpu_core_map, cpu);
+                cpumask_copy(policy->cpus, cpu_core_mask(cpu));
        }
 #endif
diff --git a/arch/x86/kernel/cpu/cpufreq/longhaul.c b/arch/x86/kernel/cpu/cpufreq/longhaul.c
index b0461856acf..a4cff5d6e38 100644
--- a/arch/x86/kernel/cpu/cpufreq/longhaul.c
+++ b/arch/x86/kernel/cpu/cpufreq/longhaul.c
@@ -982,7 +982,7 @@ static int __init longhaul_init(void)
        case 10:
                printk(KERN_ERR PFX "Use acpi-cpufreq driver for VIA C7\n");
        default:
-                ;;
+                ;
        }
        return -ENODEV;
diff --git a/arch/x86/kernel/cpu/cpufreq/p4-clockmod.c b/arch/x86/kernel/cpu/cpufreq/p4-clockmod.c
index beea4466b06..b585e04cbc9 100644
--- a/arch/x86/kernel/cpu/cpufreq/p4-clockmod.c
+++ b/arch/x86/kernel/cpu/cpufreq/p4-clockmod.c
@@ -122,7 +122,7 @@ static int cpufreq_p4_target(struct cpufreq_policy *policy,
                return 0;
        /* notifiers */
-        for_each_cpu_mask_nr(i, policy->cpus) {
+        for_each_cpu(i, policy->cpus) {
                freqs.cpu = i;
                cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
        }
@@ -130,11 +130,11 @@ static int cpufreq_p4_target(struct cpufreq_policy *policy,
        /* run on each logical CPU, see section 13.15.3 of IA32 Intel Architecture Software
         * Developer's Manual, Volume 3
         */
-        for_each_cpu_mask_nr(i, policy->cpus)
+        for_each_cpu(i, policy->cpus)
                cpufreq_p4_setdc(i, p4clockmod_table[newstate].index);
        /* notifiers */
-        for_each_cpu_mask_nr(i, policy->cpus) {
+        for_each_cpu(i, policy->cpus) {
                freqs.cpu = i;
                cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
        }
@@ -203,7 +203,7 @@ static int cpufreq_p4_cpu_init(struct cpufreq_policy *policy)
        unsigned int i;
 #ifdef CONFIG_SMP
-        policy->cpus = per_cpu(cpu_sibling_map, policy->cpu);
+        cpumask_copy(policy->cpus, &per_cpu(cpu_sibling_map, policy->cpu));
 #endif
        /* Errata workaround */
diff --git a/arch/x86/kernel/cpu/cpufreq/powernow-k8.c b/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
index c3c9adbaa26..5c28b37dea1 100644
--- a/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
+++ b/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
@@ -1199,10 +1199,10 @@ static int __cpuinit powernowk8_cpu_init(struct cpufreq_policy *pol)
        set_cpus_allowed_ptr(current, &oldmask);
        if (cpu_family == CPU_HW_PSTATE)
-                pol->cpus = cpumask_of_cpu(pol->cpu);
+                cpumask_copy(pol->cpus, cpumask_of(pol->cpu));
        else
-                pol->cpus = per_cpu(cpu_core_map, pol->cpu);
+                cpumask_copy(pol->cpus, &per_cpu(cpu_core_map, pol->cpu));
-        data->available_cores = &(pol->cpus);
+        data->available_cores = pol->cpus;
        /* Take a crude guess here.
         * That guess was in microseconds, so multiply with 1000 */
diff --git a/arch/x86/kernel/cpu/cpufreq/powernow-k8.h b/arch/x86/kernel/cpu/cpufreq/powernow-k8.h
index 65cfb5d7f77..8ecc75b6c7c 100644
--- a/arch/x86/kernel/cpu/cpufreq/powernow-k8.h
+++ b/arch/x86/kernel/cpu/cpufreq/powernow-k8.h
@@ -53,7 +53,7 @@ struct powernow_k8_data {
        /* we need to keep track of associated cores, but let cpufreq
         * handle hotplug events - so just point at cpufreq pol->cpus
         * structure */
-        cpumask_t *available_cores;
+        struct cpumask *available_cores;
 };
diff --git a/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c b/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
index f0ea6fa2f53..f08998278a3 100644
--- a/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
+++ b/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
@@ -458,11 +458,6 @@ static int centrino_verify (struct cpufreq_policy *policy)
 *
 * Sets a new CPUFreq policy.
 */
-struct allmasks {
-        cpumask_t               saved_mask;
-        cpumask_t               covered_cpus;
-};
 static int centrino_target (struct cpufreq_policy *policy,
                            unsigned int target_freq,
                            unsigned int relation)
@@ -472,12 +467,15 @@ static int centrino_target (struct cpufreq_policy *policy,
        struct cpufreq_freqs    freqs;
        int                     retval = 0;
        unsigned int            j, k, first_cpu, tmp;
-        CPUMASK_ALLOC(allmasks);
+        cpumask_var_t saved_mask, covered_cpus;
-        CPUMASK_PTR(saved_mask, allmasks);
-        CPUMASK_PTR(covered_cpus, allmasks);
-        if (unlikely(allmasks == NULL))
+        if (unlikely(!alloc_cpumask_var(&saved_mask, GFP_KERNEL)))
                return -ENOMEM;
+        if (unlikely(!alloc_cpumask_var(&covered_cpus, GFP_KERNEL))) {
+                free_cpumask_var(saved_mask);
+                return -ENOMEM;
+        }
+        cpumask_copy(saved_mask, &current->cpus_allowed);
        if (unlikely(per_cpu(centrino_model, cpu) == NULL)) {
                retval = -ENODEV;
@@ -493,11 +491,9 @@ static int centrino_target (struct cpufreq_policy *policy,
                goto out;
        }
-        *saved_mask = current->cpus_allowed;
        first_cpu = 1;
-        cpus_clear(*covered_cpus);
+        for_each_cpu(j, policy->cpus) {
-        for_each_cpu_mask_nr(j, policy->cpus) {
+                const struct cpumask *mask;
-                const cpumask_t *mask;
                /* cpufreq holds the hotplug lock, so we are safe here */
                if (!cpu_online(j))
@@ -508,9 +504,9 @@ static int centrino_target (struct cpufreq_policy *policy,
                 * Make sure we are running on CPU that wants to change freq
                 */
                if (policy->shared_type == CPUFREQ_SHARED_TYPE_ANY)
-                        mask = &policy->cpus;
+                        mask = policy->cpus;
                else
-                        mask = &cpumask_of_cpu(j);
+                        mask = cpumask_of(j);
                set_cpus_allowed_ptr(current, mask);
                preempt_disable();
@@ -542,7 +538,7 @@ static int centrino_target (struct cpufreq_policy *policy,
                        dprintk("target=%dkHz old=%d new=%d msr=%04x\n",
                                target_freq, freqs.old, freqs.new, msr);
-                        for_each_cpu_mask_nr(k, policy->cpus) {
+                        for_each_cpu(k, policy->cpus) {
                                if (!cpu_online(k))
                                        continue;
                                freqs.cpu = k;
@@ -567,7 +563,7 @@ static int centrino_target (struct cpufreq_policy *policy,
                preempt_enable();
        }
-        for_each_cpu_mask_nr(k, policy->cpus) {
+        for_each_cpu(k, policy->cpus) {
                if (!cpu_online(k))
                        continue;
                freqs.cpu = k;
@@ -590,7 +586,7 @@ static int centrino_target (struct cpufreq_policy *policy,
                tmp = freqs.new;
                freqs.new = freqs.old;
                freqs.old = tmp;
-                for_each_cpu_mask_nr(j, policy->cpus) {
+                for_each_cpu(j, policy->cpus) {
                        if (!cpu_online(j))
                                continue;
                        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
@@ -605,7 +601,8 @@ migrate_end:
        preempt_enable();
        set_cpus_allowed_ptr(current, saved_mask);
 out:
-        CPUMASK_FREE(allmasks);
+        free_cpumask_var(saved_mask);
+        free_cpumask_var(covered_cpus);
        return retval;
 }
diff --git a/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c b/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c
index 04d0376b64b..dedc1e98f16 100644
--- a/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c
+++ b/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c
@@ -229,7 +229,7 @@ static unsigned int speedstep_detect_chipset (void)
        return 0;
 }
-static unsigned int _speedstep_get(const cpumask_t *cpus)
+static unsigned int _speedstep_get(const struct cpumask *cpus)
 {
        unsigned int speed;
        cpumask_t cpus_allowed;
@@ -244,7 +244,7 @@ static unsigned int _speedstep_get(const cpumask_t *cpus)
 static unsigned int speedstep_get(unsigned int cpu)
 {
-        return _speedstep_get(&cpumask_of_cpu(cpu));
+        return _speedstep_get(cpumask_of(cpu));
 }
 /**
@@ -267,7 +267,7 @@ static int speedstep_target (struct cpufreq_policy *policy,
        if (cpufreq_frequency_table_target(policy, &speedstep_freqs[0], target_freq, relation, &newstate))
                return -EINVAL;
-        freqs.old = _speedstep_get(&policy->cpus);
+        freqs.old = _speedstep_get(policy->cpus);
        freqs.new = speedstep_freqs[newstate].frequency;
        freqs.cpu = policy->cpu;
@@ -279,20 +279,20 @@ static int speedstep_target (struct cpufreq_policy *policy,
        cpus_allowed = current->cpus_allowed;
-        for_each_cpu_mask_nr(i, policy->cpus) {
+        for_each_cpu(i, policy->cpus) {
                freqs.cpu = i;
                cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
        }
        /* switch to physical CPU where state is to be changed */
-        set_cpus_allowed_ptr(current, &policy->cpus);
+        set_cpus_allowed_ptr(current, policy->cpus);
        speedstep_set_state(newstate);
        /* allow to be run on all CPUs */
        set_cpus_allowed_ptr(current, &cpus_allowed);
-        for_each_cpu_mask_nr(i, policy->cpus) {
+        for_each_cpu(i, policy->cpus) {
                freqs.cpu = i;
                cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
        }
@@ -322,11 +322,11 @@ static int speedstep_cpu_init(struct cpufreq_policy *policy)
        /* only run on CPU to be set, or on its sibling */
 #ifdef CONFIG_SMP
-        policy->cpus = per_cpu(cpu_sibling_map, policy->cpu);
+        cpumask_copy(policy->cpus, &per_cpu(cpu_sibling_map, policy->cpu));
 #endif
        cpus_allowed = current->cpus_allowed;
-        set_cpus_allowed_ptr(current, &policy->cpus);
+        set_cpus_allowed_ptr(current, policy->cpus);
        /* detect low and high frequency and transition latency */
        result = speedstep_get_freqs(speedstep_processor,
@@ -339,7 +339,7 @@ static int speedstep_cpu_init(struct cpufreq_policy *policy)
                return result;
        /* get current speed setting */
-        speed = _speedstep_get(&policy->cpus);
+        speed = _speedstep_get(policy->cpus);
        if (!speed)
                return -EIO;
diff --git a/arch/x86/kernel/cpu/mcheck/mce_32.c b/arch/x86/kernel/cpu/mcheck/mce_32.c
index 0ebf3fc6a61..dfaebce3633 100644
--- a/arch/x86/kernel/cpu/mcheck/mce_32.c
+++ b/arch/x86/kernel/cpu/mcheck/mce_32.c
@@ -1,6 +1,6 @@
 /*
 * mce.c - x86 Machine Check Exception Reporting
- * (c) 2002 Alan Cox <alan@redhat.com>, Dave Jones <davej@redhat.com>
+ * (c) 2002 Alan Cox <alan@lxorguk.ukuu.org.uk>, Dave Jones <davej@redhat.com>
 */
 #include <linux/init.h>
diff --git a/arch/x86/kernel/cpu/mcheck/mce_amd_64.c b/arch/x86/kernel/cpu/mcheck/mce_amd_64.c
index a5a5e053037..8ae8c4ff094 100644
--- a/arch/x86/kernel/cpu/mcheck/mce_amd_64.c
+++ b/arch/x86/kernel/cpu/mcheck/mce_amd_64.c
@@ -462,7 +462,7 @@ out_free:
        return err;
 }
-static long local_allocate_threshold_blocks(void *_bank)
+static __cpuinit long local_allocate_threshold_blocks(void *_bank)
 {
        unsigned int *bank = _bank;
diff --git a/arch/x86/kernel/cpu/mcheck/p5.c b/arch/x86/kernel/cpu/mcheck/p5.c
index bfa5817afdd..c9f77ea69ed 100644
--- a/arch/x86/kernel/cpu/mcheck/p5.c
+++ b/arch/x86/kernel/cpu/mcheck/p5.c
@@ -1,6 +1,6 @@
 /*
 * P5 specific Machine Check Exception Reporting
- * (C) Copyright 2002 Alan Cox <alan@redhat.com>
+ * (C) Copyright 2002 Alan Cox <alan@lxorguk.ukuu.org.uk>
 */
 #include <linux/init.h>
diff --git a/arch/x86/kernel/cpu/mcheck/p6.c b/arch/x86/kernel/cpu/mcheck/p6.c
index 62efc9c2b3a..2ac52d7b434 100644
--- a/arch/x86/kernel/cpu/mcheck/p6.c
+++ b/arch/x86/kernel/cpu/mcheck/p6.c
@@ -1,6 +1,6 @@
 /*
 * P6 specific Machine Check Exception Reporting
- * (C) Copyright 2002 Alan Cox <alan@redhat.com>
+ * (C) Copyright 2002 Alan Cox <alan@lxorguk.ukuu.org.uk>
 */
 #include <linux/init.h>
diff --git a/arch/x86/kernel/cpu/mcheck/winchip.c b/arch/x86/kernel/cpu/mcheck/winchip.c
index f2be3e190c6..2a043d89811 100644
--- a/arch/x86/kernel/cpu/mcheck/winchip.c
+++ b/arch/x86/kernel/cpu/mcheck/winchip.c
@@ -1,6 +1,6 @@
 /*
 * IDT Winchip specific Machine Check Exception Reporting
- * (C) Copyright 2002 Alan Cox <alan@redhat.com>
+ * (C) Copyright 2002 Alan Cox <alan@lxorguk.ukuu.org.uk>
 */
 #include <linux/init.h>
diff --git a/arch/x86/kernel/e820.c b/arch/x86/kernel/e820.c
index 65a13943e09..e85826829cf 100644
--- a/arch/x86/kernel/e820.c
+++ b/arch/x86/kernel/e820.c
@@ -665,6 +665,27 @@ void __init e820_mark_nosave_regions(unsigned long limit_pfn)
 }
 #endif
+#ifdef CONFIG_HIBERNATION
+/**
+ * Mark ACPI NVS memory region, so that we can save/restore it during
+ * hibernation and the subsequent resume.
+ */
+static int __init e820_mark_nvs_memory(void)
+{
+        int i;
+        for (i = 0; i < e820.nr_map; i++) {
+                struct e820entry *ei = &e820.map[i];
+                if (ei->type == E820_NVS)
+                        hibernate_nvs_register(ei->addr, ei->size);
+        }
+        return 0;
+}
+core_initcall(e820_mark_nvs_memory);
+#endif
 /*
 * Early reserved memory areas.
 */
diff --git a/arch/x86/kernel/early-quirks.c b/arch/x86/kernel/early-quirks.c
index 744aa7fc49d..76b8cd953de 100644
--- a/arch/x86/kernel/early-quirks.c
+++ b/arch/x86/kernel/early-quirks.c
@@ -201,6 +201,12 @@ struct chipset {
        void (*f)(int num, int slot, int func);
 };
+/*
+ * Only works for devices on the root bus. If you add any devices
+ * not on bus 0 readd another loop level in early_quirks(). But
+ * be careful because at least the Nvidia quirk here relies on
+ * only matching on bus 0.
+ */
 static struct chipset early_qrk[] __initdata = {
        { PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID,
          PCI_CLASS_BRIDGE_PCI, PCI_ANY_ID, QFLAG_APPLY_ONCE, nvidia_bugs },
@@ -267,17 +273,17 @@ static int __init check_dev_quirk(int num, int slot, int func)
 void __init early_quirks(void)
 {
-        int num, slot, func;
+        int slot, func;
        if (!early_pci_allowed())
                return;
        /* Poor man's PCI discovery */
-        for (num = 0; num < 32; num++)
+        /* Only scan the root bus */
-                for (slot = 0; slot < 32; slot++)
+        for (slot = 0; slot < 32; slot++)
-                        for (func = 0; func < 8; func++) {
+                for (func = 0; func < 8; func++) {
-                                /* Only probe function 0 on single fn devices */
+                        /* Only probe function 0 on single fn devices */
-                                if (check_dev_quirk(num, slot, func))
+                        if (check_dev_quirk(0, slot, func))
-                                        break;
+                                break;
-                        }
+                }
 }
diff --git a/arch/x86/kernel/head_64.S b/arch/x86/kernel/head_64.S
index 26cfdc1d7c7..0e275d49556 100644
--- a/arch/x86/kernel/head_64.S
+++ b/arch/x86/kernel/head_64.S
@@ -305,7 +305,7 @@ ENTRY(early_idt_handler)
        call dump_stack
 #ifdef CONFIG_KALLSYMS  
        leaq early_idt_ripmsg(%rip),%rdi
-        movq 8(%rsp),%rsi       # get rip again
+        movq 0(%rsp),%rsi       # get rip again
        call __print_symbol
 #endif
 #endif /* EARLY_PRINTK */
diff --git a/arch/x86/kernel/i8259.c b/arch/x86/kernel/i8259.c
index 4b8a53d841f..11d5093eb28 100644
--- a/arch/x86/kernel/i8259.c
+++ b/arch/x86/kernel/i8259.c
@@ -11,15 +11,15 @@
 #include <linux/kernel_stat.h>
 #include <linux/sysdev.h>
 #include <linux/bitops.h>
+#include <linux/acpi.h>
+#include <linux/io.h>
+#include <linux/delay.h>
-#include <asm/acpi.h>
 #include <asm/atomic.h>
 #include <asm/system.h>
-#include <asm/io.h>
 #include <asm/timer.h>
 #include <asm/hw_irq.h>
 #include <asm/pgtable.h>
-#include <asm/delay.h>
 #include <asm/desc.h>
 #include <asm/apic.h>
 #include <asm/arch_hooks.h>
@@ -323,7 +323,7 @@ void init_8259A(int auto_eoi)
        outb_pic(0x11, PIC_MASTER_CMD); /* ICW1: select 8259A-1 init */
        /* ICW2: 8259A-1 IR0-7 mapped to 0x30-0x37 on x86-64,
-                               to 0x20-0x27 on i386 */
+           to 0x20-0x27 on i386 */
        outb_pic(IRQ0_VECTOR, PIC_MASTER_IMR);
        /* 8259A-1 (the master) has a slave on IR2 */
diff --git a/arch/x86/kernel/io_apic.c b/arch/x86/kernel/io_apic.c
index 3639442aa7a..1c4a1302536 100644
--- a/arch/x86/kernel/io_apic.c
+++ b/arch/x86/kernel/io_apic.c
@@ -129,7 +129,6 @@ static struct irq_pin_list *get_one_free_irq_2_pin(int cpu)
        node = cpu_to_node(cpu);
        pin = kzalloc_node(sizeof(*pin), GFP_ATOMIC, node);
-        printk(KERN_DEBUG "  alloc irq_2_pin on cpu %d node %d\n", cpu, node);
        return pin;
 }
@@ -227,7 +226,6 @@ static struct irq_cfg *get_one_free_irq_cfg(int cpu)
                        cpumask_clear(cfg->old_domain);
                }
        }
-        printk(KERN_DEBUG "  alloc irq_cfg on cpu %d node %d\n", cpu, node);
        return cfg;
 }
diff --git a/arch/x86/kernel/ioport.c b/arch/x86/kernel/ioport.c
index 19191430274..b12208f4dfe 100644
--- a/arch/x86/kernel/ioport.c
+++ b/arch/x86/kernel/ioport.c
@@ -35,8 +35,8 @@ static void set_bitmap(unsigned long *bitmap, unsigned int base,
 */
 asmlinkage long sys_ioperm(unsigned long from, unsigned long num, int turn_on)
 {
-        struct thread_struct * t = &current->thread;
+        struct thread_struct *t = &current->thread;
-        struct tss_struct * tss;
+        struct tss_struct *tss;
        unsigned int i, max_long, bytes, bytes_updated;
        if ((from + num <= from) || (from + num > IO_BITMAP_BITS))
diff --git a/arch/x86/kernel/irq.c b/arch/x86/kernel/irq.c
index bce53e1352a..3973e2df7f8 100644
--- a/arch/x86/kernel/irq.c
+++ b/arch/x86/kernel/irq.c
@@ -5,10 +5,10 @@
 #include <linux/interrupt.h>
 #include <linux/kernel_stat.h>
 #include <linux/seq_file.h>
+#include <linux/smp.h>
 #include <asm/apic.h>
 #include <asm/io_apic.h>
-#include <asm/smp.h>
 #include <asm/irq.h>
 atomic_t irq_err_count;
diff --git a/arch/x86/kernel/irq_32.c b/arch/x86/kernel/irq_32.c
index 9dc5588f336..74b9ff7341e 100644
--- a/arch/x86/kernel/irq_32.c
+++ b/arch/x86/kernel/irq_32.c
@@ -15,9 +15,9 @@
 #include <linux/notifier.h>
 #include <linux/cpu.h>
 #include <linux/delay.h>
+#include <linux/uaccess.h>
 #include <asm/apic.h>
-#include <asm/uaccess.h>
 DEFINE_PER_CPU_SHARED_ALIGNED(irq_cpustat_t, irq_stat);
 EXPORT_PER_CPU_SYMBOL(irq_stat);
@@ -93,7 +93,7 @@ execute_on_irq_stack(int overflow, struct irq_desc *desc, int irq)
                return 0;
        /* build the stack frame on the IRQ stack */
-        isp = (u32 *) ((char*)irqctx + sizeof(*irqctx));
+        isp = (u32 *) ((char *)irqctx + sizeof(*irqctx));
        irqctx->tinfo.task = curctx->tinfo.task;
        irqctx->tinfo.previous_esp = current_stack_pointer;
@@ -137,7 +137,7 @@ void __cpuinit irq_ctx_init(int cpu)
        hardirq_ctx[cpu] = irqctx;
-        irqctx = (union irq_ctx*) &softirq_stack[cpu*THREAD_SIZE];
+        irqctx = (union irq_ctx *) &softirq_stack[cpu*THREAD_SIZE];
        irqctx->tinfo.task              = NULL;
        irqctx->tinfo.exec_domain       = NULL;
        irqctx->tinfo.cpu               = cpu;
@@ -147,7 +147,7 @@ void __cpuinit irq_ctx_init(int cpu)
        softirq_ctx[cpu] = irqctx;
        printk(KERN_DEBUG "CPU %u irqstacks, hard=%p soft=%p\n",
-               cpu,hardirq_ctx[cpu],softirq_ctx[cpu]);
+               cpu, hardirq_ctx[cpu], softirq_ctx[cpu]);
 }
 void irq_ctx_exit(int cpu)
@@ -174,7 +174,7 @@ asmlinkage void do_softirq(void)
                irqctx->tinfo.previous_esp = current_stack_pointer;
                /* build the stack frame on the softirq stack */
-                isp = (u32*) ((char*)irqctx + sizeof(*irqctx));
+                isp = (u32 *) ((char *)irqctx + sizeof(*irqctx));
                call_on_stack(__do_softirq, isp);
                /*
diff --git a/arch/x86/kernel/irq_64.c b/arch/x86/kernel/irq_64.c
index 6383d50f82e..63c88e6ec02 100644
--- a/arch/x86/kernel/irq_64.c
+++ b/arch/x86/kernel/irq_64.c
@@ -14,10 +14,10 @@
 #include <linux/module.h>
 #include <linux/delay.h>
 #include <linux/ftrace.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
+#include <linux/smp.h>
 #include <asm/io_apic.h>
 #include <asm/idle.h>
-#include <asm/smp.h>
 /*
 * Probabilistic stack overflow check:
@@ -142,18 +142,18 @@ extern void call_softirq(void);
 asmlinkage void do_softirq(void)
 {
-        __u32 pending;
+        __u32 pending;
-        unsigned long flags;
+        unsigned long flags;
-        if (in_interrupt())
+        if (in_interrupt())
-                return;
+                return;
-        local_irq_save(flags);
+        local_irq_save(flags);
-        pending = local_softirq_pending();
+        pending = local_softirq_pending();
-        /* Switch to interrupt stack */
+        /* Switch to interrupt stack */
-        if (pending) {
+        if (pending) {
                call_softirq();
                WARN_ON_ONCE(softirq_count());
        }
-        local_irq_restore(flags);
+        local_irq_restore(flags);
 }
diff --git a/arch/x86/kernel/irqinit_32.c b/arch/x86/kernel/irqinit_32.c
index 84723295f88..1507ad4e674 100644
--- a/arch/x86/kernel/irqinit_32.c
+++ b/arch/x86/kernel/irqinit_32.c
@@ -9,18 +9,18 @@
 #include <linux/kernel_stat.h>
 #include <linux/sysdev.h>
 #include <linux/bitops.h>
+#include <linux/io.h>
+#include <linux/delay.h>
 #include <asm/atomic.h>
 #include <asm/system.h>
-#include <asm/io.h>
 #include <asm/timer.h>
 #include <asm/pgtable.h>
-#include <asm/delay.h>
 #include <asm/desc.h>
 #include <asm/apic.h>
 #include <asm/arch_hooks.h>
 #include <asm/i8259.h>
+#include <asm/traps.h>
 /*
@@ -34,12 +34,10 @@
 * leads to races. IBM designers who came up with it should
 * be shot.
 */
- 
 static irqreturn_t math_error_irq(int cpl, void *dev_id)
 {
-        extern void math_error(void __user *);
+        outb(0, 0xF0);
-        outb(0,0xF0);
        if (ignore_fpu_irq || !boot_cpu_data.hard_math)
                return IRQ_NONE;
        math_error((void __user *)get_irq_regs()->ip);
@@ -56,7 +54,7 @@ static struct irqaction fpu_irq = {
        .name = "fpu",
 };
-void __init init_ISA_irqs (void)
+void __init init_ISA_irqs(void)
 {
        int i;
diff --git a/arch/x86/kernel/irqinit_64.c b/arch/x86/kernel/irqinit_64.c
index 31ebfe38e96..da481a1e3f3 100644
--- a/arch/x86/kernel/irqinit_64.c
+++ b/arch/x86/kernel/irqinit_64.c
@@ -11,14 +11,14 @@
 #include <linux/kernel_stat.h>
 #include <linux/sysdev.h>
 #include <linux/bitops.h>
+#include <linux/acpi.h>
+#include <linux/io.h>
+#include <linux/delay.h>
-#include <asm/acpi.h>
 #include <asm/atomic.h>
 #include <asm/system.h>
-#include <asm/io.h>
 #include <asm/hw_irq.h>
 #include <asm/pgtable.h>
-#include <asm/delay.h>
 #include <asm/desc.h>
 #include <asm/apic.h>
 #include <asm/i8259.h>
@@ -81,7 +81,7 @@ int vector_used_by_percpu_irq(unsigned int vector)
        return 0;
 }
-void __init init_ISA_irqs(void)
+static void __init init_ISA_irqs(void)
 {
        int i;
diff --git a/arch/x86/kernel/kprobes.c b/arch/x86/kernel/kprobes.c
index 6c27679ec6a..884d985b8b8 100644
--- a/arch/x86/kernel/kprobes.c
+++ b/arch/x86/kernel/kprobes.c
@@ -376,9 +376,10 @@ void __kprobes arch_disarm_kprobe(struct kprobe *p)
 void __kprobes arch_remove_kprobe(struct kprobe *p)
 {
-        mutex_lock(&kprobe_mutex);
+        if (p->ainsn.insn) {
-        free_insn_slot(p->ainsn.insn, (p->ainsn.boostable == 1));
+                free_insn_slot(p->ainsn.insn, (p->ainsn.boostable == 1));
-        mutex_unlock(&kprobe_mutex);
+                p->ainsn.insn = NULL;
+        }
 }
 static void __kprobes save_previous_kprobe(struct kprobe_ctlblk *kcb)
@@ -694,7 +695,7 @@ static __used __kprobes void *trampoline_handler(struct pt_regs *regs)
        /*
         * It is possible to have multiple instances associated with a given
         * task either because multiple functions in the call path have
-         * return probes installed on them, and/or more then one
+         * return probes installed on them, and/or more than one
         * return probe was registered for a target function.
         *
         * We can handle this because:
diff --git a/arch/x86/kernel/mfgpt_32.c b/arch/x86/kernel/mfgpt_32.c
index c12314c9e86..8815f3c7fec 100644
--- a/arch/x86/kernel/mfgpt_32.c
+++ b/arch/x86/kernel/mfgpt_32.c
@@ -252,7 +252,7 @@ EXPORT_SYMBOL_GPL(geode_mfgpt_alloc_timer);
 /*
 * The MFPGT timers on the CS5536 provide us with suitable timers to use
 * as clock event sources - not as good as a HPET or APIC, but certainly
- * better then the PIT.  This isn't a general purpose MFGPT driver, but
+ * better than the PIT.  This isn't a general purpose MFGPT driver, but
 * a simplified one designed specifically to act as a clock event source.
 * For full details about the MFGPT, please consult the CS5536 data sheet.
 */
diff --git a/arch/x86/kernel/mpparse.c b/arch/x86/kernel/mpparse.c
index c5c5b8df1db..c0601c2848a 100644
--- a/arch/x86/kernel/mpparse.c
+++ b/arch/x86/kernel/mpparse.c
@@ -2,7 +2,7 @@
 *      Intel Multiprocessor Specification 1.1 and 1.4
 *      compliant MP-table parsing routines.
 *
- *      (c) 1995 Alan Cox, Building #3 <alan@redhat.com>
+ *      (c) 1995 Alan Cox, Building #3 <alan@lxorguk.ukuu.org.uk>
 *      (c) 1998, 1999, 2000 Ingo Molnar <mingo@redhat.com>
 *      (c) 2008 Alexey Starikovskiy <astarikovskiy@suse.de>
 */
@@ -17,7 +17,6 @@
 #include <linux/acpi.h>
 #include <linux/module.h>
 #include <linux/smp.h>
-#include <linux/acpi.h>
 #include <asm/mtrr.h>
 #include <asm/mpspec.h>
@@ -49,12 +48,12 @@ static int __init mpf_checksum(unsigned char *mp, int len)
        return sum & 0xFF;
 }
-static void __init MP_processor_info(struct mpc_config_processor *m)
+static void __init MP_processor_info(struct mpc_cpu *m)
 {
        int apicid;
        char *bootup_cpu = "";
-        if (!(m->mpc_cpuflag & CPU_ENABLED)) {
+        if (!(m->cpuflag & CPU_ENABLED)) {
                disabled_cpus++;
                return;
        }
@@ -62,54 +61,54 @@ static void __init MP_processor_info(struct mpc_config_processor *m)
        if (x86_quirks->mpc_apic_id)
                apicid = x86_quirks->mpc_apic_id(m);
        else
-                apicid = m->mpc_apicid;
+                apicid = m->apicid;
-        if (m->mpc_cpuflag & CPU_BOOTPROCESSOR) {
+        if (m->cpuflag & CPU_BOOTPROCESSOR) {
                bootup_cpu = " (Bootup-CPU)";
-                boot_cpu_physical_apicid = m->mpc_apicid;
+                boot_cpu_physical_apicid = m->apicid;
        }
-        printk(KERN_INFO "Processor #%d%s\n", m->mpc_apicid, bootup_cpu);
+        printk(KERN_INFO "Processor #%d%s\n", m->apicid, bootup_cpu);
-        generic_processor_info(apicid, m->mpc_apicver);
+        generic_processor_info(apicid, m->apicver);
 }
 #ifdef CONFIG_X86_IO_APIC
-static void __init MP_bus_info(struct mpc_config_bus *m)
+static void __init MP_bus_info(struct mpc_bus *m)
 {
        char str[7];
-        memcpy(str, m->mpc_bustype, 6);
+        memcpy(str, m->bustype, 6);
        str[6] = 0;
        if (x86_quirks->mpc_oem_bus_info)
                x86_quirks->mpc_oem_bus_info(m, str);
        else
-                apic_printk(APIC_VERBOSE, "Bus #%d is %s\n", m->mpc_busid, str);
+                apic_printk(APIC_VERBOSE, "Bus #%d is %s\n", m->busid, str);
 #if MAX_MP_BUSSES < 256
-        if (m->mpc_busid >= MAX_MP_BUSSES) {
+        if (m->busid >= MAX_MP_BUSSES) {
                printk(KERN_WARNING "MP table busid value (%d) for bustype %s "
                       " is too large, max. supported is %d\n",
-                       m->mpc_busid, str, MAX_MP_BUSSES - 1);
+                       m->busid, str, MAX_MP_BUSSES - 1);
                return;
        }
 #endif
        if (strncmp(str, BUSTYPE_ISA, sizeof(BUSTYPE_ISA) - 1) == 0) {
-                set_bit(m->mpc_busid, mp_bus_not_pci);
+                set_bit(m->busid, mp_bus_not_pci);
 #if defined(CONFIG_EISA) || defined(CONFIG_MCA)
-                mp_bus_id_to_type[m->mpc_busid] = MP_BUS_ISA;
+                mp_bus_id_to_type[m->busid] = MP_BUS_ISA;
 #endif
        } else if (strncmp(str, BUSTYPE_PCI, sizeof(BUSTYPE_PCI) - 1) == 0) {
                if (x86_quirks->mpc_oem_pci_bus)
                        x86_quirks->mpc_oem_pci_bus(m);
-                clear_bit(m->mpc_busid, mp_bus_not_pci);
+                clear_bit(m->busid, mp_bus_not_pci);
 #if defined(CONFIG_EISA) || defined(CONFIG_MCA)
-                mp_bus_id_to_type[m->mpc_busid] = MP_BUS_PCI;
+                mp_bus_id_to_type[m->busid] = MP_BUS_PCI;
        } else if (strncmp(str, BUSTYPE_EISA, sizeof(BUSTYPE_EISA) - 1) == 0) {
-                mp_bus_id_to_type[m->mpc_busid] = MP_BUS_EISA;
+                mp_bus_id_to_type[m->busid] = MP_BUS_EISA;
        } else if (strncmp(str, BUSTYPE_MCA, sizeof(BUSTYPE_MCA) - 1) == 0) {
-                mp_bus_id_to_type[m->mpc_busid] = MP_BUS_MCA;
+                mp_bus_id_to_type[m->busid] = MP_BUS_MCA;
 #endif
        } else
                printk(KERN_WARNING "Unknown bustype %s - ignoring\n", str);
@@ -133,32 +132,31 @@ static int bad_ioapic(unsigned long address)
        return 0;
 }
-static void __init MP_ioapic_info(struct mpc_config_ioapic *m)
+static void __init MP_ioapic_info(struct mpc_ioapic *m)
 {
-        if (!(m->mpc_flags & MPC_APIC_USABLE))
+        if (!(m->flags & MPC_APIC_USABLE))
                return;
        printk(KERN_INFO "I/O APIC #%d Version %d at 0x%X.\n",
-               m->mpc_apicid, m->mpc_apicver, m->mpc_apicaddr);
+               m->apicid, m->apicver, m->apicaddr);
-        if (bad_ioapic(m->mpc_apicaddr))
+        if (bad_ioapic(m->apicaddr))
                return;
-        mp_ioapics[nr_ioapics].mp_apicaddr = m->mpc_apicaddr;
+        mp_ioapics[nr_ioapics].mp_apicaddr = m->apicaddr;
-        mp_ioapics[nr_ioapics].mp_apicid = m->mpc_apicid;
+        mp_ioapics[nr_ioapics].mp_apicid = m->apicid;
-        mp_ioapics[nr_ioapics].mp_type = m->mpc_type;
+        mp_ioapics[nr_ioapics].mp_type = m->type;
-        mp_ioapics[nr_ioapics].mp_apicver = m->mpc_apicver;
+        mp_ioapics[nr_ioapics].mp_apicver = m->apicver;
-        mp_ioapics[nr_ioapics].mp_flags = m->mpc_flags;
+        mp_ioapics[nr_ioapics].mp_flags = m->flags;
        nr_ioapics++;
 }
-static void print_MP_intsrc_info(struct mpc_config_intsrc *m)
+static void print_MP_intsrc_info(struct mpc_intsrc *m)
 {
        apic_printk(APIC_VERBOSE, "Int: type %d, pol %d, trig %d, bus %02x,"
                " IRQ %02x, APIC ID %x, APIC INT %02x\n",
-                m->mpc_irqtype, m->mpc_irqflag & 3,
+                m->irqtype, m->irqflag & 3, (m->irqflag >> 2) & 3, m->srcbus,
-                (m->mpc_irqflag >> 2) & 3, m->mpc_srcbus,
+                m->srcbusirq, m->dstapic, m->dstirq);
-                m->mpc_srcbusirq, m->mpc_dstapic, m->mpc_dstirq);
 }
 static void __init print_mp_irq_info(struct mp_config_intsrc *mp_irq)
@@ -170,52 +168,52 @@ static void __init print_mp_irq_info(struct mp_config_intsrc *mp_irq)
                mp_irq->mp_srcbusirq, mp_irq->mp_dstapic, mp_irq->mp_dstirq);
 }
-static void __init assign_to_mp_irq(struct mpc_config_intsrc *m,
+static void __init assign_to_mp_irq(struct mpc_intsrc *m,
                                    struct mp_config_intsrc *mp_irq)
 {
-        mp_irq->mp_dstapic = m->mpc_dstapic;
+        mp_irq->mp_dstapic = m->dstapic;
-        mp_irq->mp_type = m->mpc_type;
+        mp_irq->mp_type = m->type;
-        mp_irq->mp_irqtype = m->mpc_irqtype;
+        mp_irq->mp_irqtype = m->irqtype;
-        mp_irq->mp_irqflag = m->mpc_irqflag;
+        mp_irq->mp_irqflag = m->irqflag;
-        mp_irq->mp_srcbus = m->mpc_srcbus;
+        mp_irq->mp_srcbus = m->srcbus;
-        mp_irq->mp_srcbusirq = m->mpc_srcbusirq;
+        mp_irq->mp_srcbusirq = m->srcbusirq;
-        mp_irq->mp_dstirq = m->mpc_dstirq;
+        mp_irq->mp_dstirq = m->dstirq;
 }
 static void __init assign_to_mpc_intsrc(struct mp_config_intsrc *mp_irq,
-                                        struct mpc_config_intsrc *m)
+                                        struct mpc_intsrc *m)
 {
-        m->mpc_dstapic = mp_irq->mp_dstapic;
+        m->dstapic = mp_irq->mp_dstapic;
-        m->mpc_type = mp_irq->mp_type;
+        m->type = mp_irq->mp_type;
-        m->mpc_irqtype = mp_irq->mp_irqtype;
+        m->irqtype = mp_irq->mp_irqtype;
-        m->mpc_irqflag = mp_irq->mp_irqflag;
+        m->irqflag = mp_irq->mp_irqflag;
-        m->mpc_srcbus = mp_irq->mp_srcbus;
+        m->srcbus = mp_irq->mp_srcbus;
-        m->mpc_srcbusirq = mp_irq->mp_srcbusirq;
+        m->srcbusirq = mp_irq->mp_srcbusirq;
-        m->mpc_dstirq = mp_irq->mp_dstirq;
+        m->dstirq = mp_irq->mp_dstirq;
 }
 static int __init mp_irq_mpc_intsrc_cmp(struct mp_config_intsrc *mp_irq,
-                                        struct mpc_config_intsrc *m)
+                                        struct mpc_intsrc *m)
 {
-        if (mp_irq->mp_dstapic != m->mpc_dstapic)
+        if (mp_irq->mp_dstapic != m->dstapic)
                return 1;
-        if (mp_irq->mp_type != m->mpc_type)
+        if (mp_irq->mp_type != m->type)
                return 2;
-        if (mp_irq->mp_irqtype != m->mpc_irqtype)
+        if (mp_irq->mp_irqtype != m->irqtype)
                return 3;
-        if (mp_irq->mp_irqflag != m->mpc_irqflag)
+        if (mp_irq->mp_irqflag != m->irqflag)
                return 4;
-        if (mp_irq->mp_srcbus != m->mpc_srcbus)
+        if (mp_irq->mp_srcbus != m->srcbus)
                return 5;
-        if (mp_irq->mp_srcbusirq != m->mpc_srcbusirq)
+        if (mp_irq->mp_srcbusirq != m->srcbusirq)
                return 6;
-        if (mp_irq->mp_dstirq != m->mpc_dstirq)
+        if (mp_irq->mp_dstirq != m->dstirq)
                return 7;
        return 0;
 }
-static void __init MP_intsrc_info(struct mpc_config_intsrc *m)
+static void __init MP_intsrc_info(struct mpc_intsrc *m)
 {
        int i;
@@ -233,57 +231,55 @@ static void __init MP_intsrc_info(struct mpc_config_intsrc *m)
 #endif
-static void __init MP_lintsrc_info(struct mpc_config_lintsrc *m)
+static void __init MP_lintsrc_info(struct mpc_lintsrc *m)
 {
        apic_printk(APIC_VERBOSE, "Lint: type %d, pol %d, trig %d, bus %02x,"
                " IRQ %02x, APIC ID %x, APIC LINT %02x\n",
-                m->mpc_irqtype, m->mpc_irqflag & 3,
+                m->irqtype, m->irqflag & 3, (m->irqflag >> 2) & 3, m->srcbusid,
-                (m->mpc_irqflag >> 2) & 3, m->mpc_srcbusid,
+                m->srcbusirq, m->destapic, m->destapiclint);
-                m->mpc_srcbusirq, m->mpc_destapic, m->mpc_destapiclint);
 }
 /*
 * Read/parse the MPC
 */
-static int __init smp_check_mpc(struct mp_config_table *mpc, char *oem,
+static int __init smp_check_mpc(struct mpc_table *mpc, char *oem, char *str)
-                                char *str)
 {
-        if (memcmp(mpc->mpc_signature, MPC_SIGNATURE, 4)) {
+        if (memcmp(mpc->signature, MPC_SIGNATURE, 4)) {
                printk(KERN_ERR "MPTABLE: bad signature [%c%c%c%c]!\n",
-                       mpc->mpc_signature[0], mpc->mpc_signature[1],
+                       mpc->signature[0], mpc->signature[1],
-                       mpc->mpc_signature[2], mpc->mpc_signature[3]);
+                       mpc->signature[2], mpc->signature[3]);
                return 0;
        }
-        if (mpf_checksum((unsigned char *)mpc, mpc->mpc_length)) {
+        if (mpf_checksum((unsigned char *)mpc, mpc->length)) {
                printk(KERN_ERR "MPTABLE: checksum error!\n");
                return 0;
        }
-        if (mpc->mpc_spec != 0x01 && mpc->mpc_spec != 0x04) {
+        if (mpc->spec != 0x01 && mpc->spec != 0x04) {
                printk(KERN_ERR "MPTABLE: bad table version (%d)!!\n",
-                       mpc->mpc_spec);
+                       mpc->spec);
                return 0;
        }
-        if (!mpc->mpc_lapic) {
+        if (!mpc->lapic) {
                printk(KERN_ERR "MPTABLE: null local APIC address!\n");
                return 0;
        }
-        memcpy(oem, mpc->mpc_oem, 8);
+        memcpy(oem, mpc->oem, 8);
        oem[8] = 0;
        printk(KERN_INFO "MPTABLE: OEM ID: %s\n", oem);
-        memcpy(str, mpc->mpc_productid, 12);
+        memcpy(str, mpc->productid, 12);
        str[12] = 0;
        printk(KERN_INFO "MPTABLE: Product ID: %s\n", str);
-        printk(KERN_INFO "MPTABLE: APIC at: 0x%X\n", mpc->mpc_lapic);
+        printk(KERN_INFO "MPTABLE: APIC at: 0x%X\n", mpc->lapic);
        return 1;
 }
-static int __init smp_read_mpc(struct mp_config_table *mpc, unsigned early)
+static int __init smp_read_mpc(struct mpc_table *mpc, unsigned early)
 {
        char str[16];
        char oem[10];
@@ -308,14 +304,14 @@ static int __init smp_read_mpc(struct mp_config_table *mpc, unsigned early)
 #endif
        /* save the local APIC address, it might be non-default */
        if (!acpi_lapic)
-                mp_lapic_addr = mpc->mpc_lapic;
+                mp_lapic_addr = mpc->lapic;
        if (early)
                return 1;
-        if (mpc->mpc_oemptr && x86_quirks->smp_read_mpc_oem) {
+        if (mpc->oemptr && x86_quirks->smp_read_mpc_oem) {
-                struct mp_config_oemtable *oem_table = (struct mp_config_oemtable *)(unsigned long)mpc->mpc_oemptr;
+                struct mpc_oemtable *oem_table = (void *)(long)mpc->oemptr;
-                x86_quirks->smp_read_mpc_oem(oem_table, mpc->mpc_oemsize);
+                x86_quirks->smp_read_mpc_oem(oem_table, mpc->oemsize);
        }
        /*
@@ -324,12 +320,11 @@ static int __init smp_read_mpc(struct mp_config_table *mpc, unsigned early)
        if (x86_quirks->mpc_record)
                *x86_quirks->mpc_record = 0;
-        while (count < mpc->mpc_length) {
+        while (count < mpc->length) {
                switch (*mpt) {
                case MP_PROCESSOR:
                        {
-                                struct mpc_config_processor *m =
+                                struct mpc_cpu *m = (struct mpc_cpu *)mpt;
-                                    (struct mpc_config_processor *)mpt;
                                /* ACPI may have already provided this data */
                                if (!acpi_lapic)
                                        MP_processor_info(m);
@@ -339,8 +334,7 @@ static int __init smp_read_mpc(struct mp_config_table *mpc, unsigned early)
                        }
                case MP_BUS:
                        {
-                                struct mpc_config_bus *m =
+                                struct mpc_bus *m = (struct mpc_bus *)mpt;
-                                    (struct mpc_config_bus *)mpt;
 #ifdef CONFIG_X86_IO_APIC
                                MP_bus_info(m);
 #endif
@@ -351,30 +345,28 @@ static int __init smp_read_mpc(struct mp_config_table *mpc, unsigned early)
                case MP_IOAPIC:
                        {
 #ifdef CONFIG_X86_IO_APIC
-                                struct mpc_config_ioapic *m =
+                                struct mpc_ioapic *m = (struct mpc_ioapic *)mpt;
-                                    (struct mpc_config_ioapic *)mpt;
                                MP_ioapic_info(m);
 #endif
-                                mpt += sizeof(struct mpc_config_ioapic);
+                                mpt += sizeof(struct mpc_ioapic);
-                                count += sizeof(struct mpc_config_ioapic);
+                                count += sizeof(struct mpc_ioapic);
                                break;
                        }
                case MP_INTSRC:
                        {
 #ifdef CONFIG_X86_IO_APIC
-                                struct mpc_config_intsrc *m =
+                                struct mpc_intsrc *m = (struct mpc_intsrc *)mpt;
-                                    (struct mpc_config_intsrc *)mpt;
                                MP_intsrc_info(m);
 #endif
-                                mpt += sizeof(struct mpc_config_intsrc);
+                                mpt += sizeof(struct mpc_intsrc);
-                                count += sizeof(struct mpc_config_intsrc);
+                                count += sizeof(struct mpc_intsrc);
                                break;
                        }
                case MP_LINTSRC:
                        {
-                                struct mpc_config_lintsrc *m =
+                                struct mpc_lintsrc *m =
-                                    (struct mpc_config_lintsrc *)mpt;
+                                    (struct mpc_lintsrc *)mpt;
                                MP_lintsrc_info(m);
                                mpt += sizeof(*m);
                                count += sizeof(*m);
@@ -385,8 +377,8 @@ static int __init smp_read_mpc(struct mp_config_table *mpc, unsigned early)
                        printk(KERN_ERR "Your mptable is wrong, contact your HW vendor!\n");
                        printk(KERN_ERR "type %x\n", *mpt);
                        print_hex_dump(KERN_ERR, "  ", DUMP_PREFIX_ADDRESS, 16,
-                                        1, mpc, mpc->mpc_length, 1);
+                                        1, mpc, mpc->length, 1);
-                        count = mpc->mpc_length;
+                        count = mpc->length;
                        break;
                }
                if (x86_quirks->mpc_record)
@@ -417,16 +409,16 @@ static int __init ELCR_trigger(unsigned int irq)
 static void __init construct_default_ioirq_mptable(int mpc_default_type)
 {
-        struct mpc_config_intsrc intsrc;
+        struct mpc_intsrc intsrc;
        int i;
        int ELCR_fallback = 0;
-        intsrc.mpc_type = MP_INTSRC;
+        intsrc.type = MP_INTSRC;
-        intsrc.mpc_irqflag = 0; /* conforming */
+        intsrc.irqflag = 0;     /* conforming */
-        intsrc.mpc_srcbus = 0;
+        intsrc.srcbus = 0;
-        intsrc.mpc_dstapic = mp_ioapics[0].mp_apicid;
+        intsrc.dstapic = mp_ioapics[0].mp_apicid;
-        intsrc.mpc_irqtype = mp_INT;
+        intsrc.irqtype = mp_INT;
        /*
         *  If true, we have an ISA/PCI system with no IRQ entries
@@ -469,30 +461,30 @@ static void __init construct_default_ioirq_mptable(int mpc_default_type)
                         *  irqflag field (level sensitive, active high polarity).
                         */
                        if (ELCR_trigger(i))
-                                intsrc.mpc_irqflag = 13;
+                                intsrc.irqflag = 13;
                        else
-                                intsrc.mpc_irqflag = 0;
+                                intsrc.irqflag = 0;
                }
-                intsrc.mpc_srcbusirq = i;
+                intsrc.srcbusirq = i;
-                intsrc.mpc_dstirq = i ? i : 2;  /* IRQ0 to INTIN2 */
+                intsrc.dstirq = i ? i : 2;      /* IRQ0 to INTIN2 */
                MP_intsrc_info(&intsrc);
        }
-        intsrc.mpc_irqtype = mp_ExtINT;
+        intsrc.irqtype = mp_ExtINT;
-        intsrc.mpc_srcbusirq = 0;
+        intsrc.srcbusirq = 0;
-        intsrc.mpc_dstirq = 0;  /* 8259A to INTIN0 */
+        intsrc.dstirq = 0;      /* 8259A to INTIN0 */
        MP_intsrc_info(&intsrc);
 }
 static void __init construct_ioapic_table(int mpc_default_type)
 {
-        struct mpc_config_ioapic ioapic;
+        struct mpc_ioapic ioapic;
-        struct mpc_config_bus bus;
+        struct mpc_bus bus;
-        bus.mpc_type = MP_BUS;
+        bus.type = MP_BUS;
-        bus.mpc_busid = 0;
+        bus.busid = 0;
        switch (mpc_default_type) {
        default:
                printk(KERN_ERR "???\nUnknown standard configuration %d\n",
@@ -500,29 +492,29 @@ static void __init construct_ioapic_table(int mpc_default_type)
                /* fall through */
        case 1:
        case 5:
-                memcpy(bus.mpc_bustype, "ISA   ", 6);
+                memcpy(bus.bustype, "ISA   ", 6);
                break;
        case 2:
        case 6:
        case 3:
-                memcpy(bus.mpc_bustype, "EISA  ", 6);
+                memcpy(bus.bustype, "EISA  ", 6);
                break;
        case 4:
        case 7:
-                memcpy(bus.mpc_bustype, "MCA   ", 6);
+                memcpy(bus.bustype, "MCA   ", 6);
        }
        MP_bus_info(&bus);
        if (mpc_default_type > 4) {
-                bus.mpc_busid = 1;
+                bus.busid = 1;
-                memcpy(bus.mpc_bustype, "PCI   ", 6);
+                memcpy(bus.bustype, "PCI   ", 6);
                MP_bus_info(&bus);
        }
-        ioapic.mpc_type = MP_IOAPIC;
+        ioapic.type = MP_IOAPIC;
-        ioapic.mpc_apicid = 2;
+        ioapic.apicid = 2;
-        ioapic.mpc_apicver = mpc_default_type > 4 ? 0x10 : 0x01;
+        ioapic.apicver = mpc_default_type > 4 ? 0x10 : 0x01;
-        ioapic.mpc_flags = MPC_APIC_USABLE;
+        ioapic.flags = MPC_APIC_USABLE;
-        ioapic.mpc_apicaddr = 0xFEC00000;
+        ioapic.apicaddr = 0xFEC00000;
        MP_ioapic_info(&ioapic);
        /*
@@ -536,8 +528,8 @@ static inline void __init construct_ioapic_table(int mpc_default_type) { }
 static inline void __init construct_default_ISA_mptable(int mpc_default_type)
 {
-        struct mpc_config_processor processor;
+        struct mpc_cpu processor;
-        struct mpc_config_lintsrc lintsrc;
+        struct mpc_lintsrc lintsrc;
        int linttypes[2] = { mp_ExtINT, mp_NMI };
        int i;
@@ -549,30 +541,30 @@ static inline void __init construct_default_ISA_mptable(int mpc_default_type)
        /*
         * 2 CPUs, numbered 0 & 1.
         */
-        processor.mpc_type = MP_PROCESSOR;
+        processor.type = MP_PROCESSOR;
        /* Either an integrated APIC or a discrete 82489DX. */
-        processor.mpc_apicver = mpc_default_type > 4 ? 0x10 : 0x01;
+        processor.apicver = mpc_default_type > 4 ? 0x10 : 0x01;
-        processor.mpc_cpuflag = CPU_ENABLED;
+        processor.cpuflag = CPU_ENABLED;
-        processor.mpc_cpufeature = (boot_cpu_data.x86 << 8) |
+        processor.cpufeature = (boot_cpu_data.x86 << 8) |
            (boot_cpu_data.x86_model << 4) | boot_cpu_data.x86_mask;
-        processor.mpc_featureflag = boot_cpu_data.x86_capability[0];
+        processor.featureflag = boot_cpu_data.x86_capability[0];
-        processor.mpc_reserved[0] = 0;
+        processor.reserved[0] = 0;
-        processor.mpc_reserved[1] = 0;
+        processor.reserved[1] = 0;
        for (i = 0; i < 2; i++) {
-                processor.mpc_apicid = i;
+                processor.apicid = i;
                MP_processor_info(&processor);
        }
        construct_ioapic_table(mpc_default_type);
-        lintsrc.mpc_type = MP_LINTSRC;
+        lintsrc.type = MP_LINTSRC;
-        lintsrc.mpc_irqflag = 0;        /* conforming */
+        lintsrc.irqflag = 0;            /* conforming */
-        lintsrc.mpc_srcbusid = 0;
+        lintsrc.srcbusid = 0;
-        lintsrc.mpc_srcbusirq = 0;
+        lintsrc.srcbusirq = 0;
-        lintsrc.mpc_destapic = MP_APIC_ALL;
+        lintsrc.destapic = MP_APIC_ALL;
        for (i = 0; i < 2; i++) {
-                lintsrc.mpc_irqtype = linttypes[i];
+                lintsrc.irqtype = linttypes[i];
-                lintsrc.mpc_destapiclint = i;
+                lintsrc.destapiclint = i;
                MP_lintsrc_info(&lintsrc);
        }
 }
@@ -657,15 +649,15 @@ static void __init __get_smp_config(unsigned int early)
                 * ISA defaults and hope it will work.
                 */
                if (!mp_irq_entries) {
-                        struct mpc_config_bus bus;
+                        struct mpc_bus bus;
                        printk(KERN_ERR "BIOS bug, no explicit IRQ entries, "
                               "using default mptable. "
                               "(tell your hw vendor)\n");
-                        bus.mpc_type = MP_BUS;
+                        bus.type = MP_BUS;
-                        bus.mpc_busid = 0;
+                        bus.busid = 0;
-                        memcpy(bus.mpc_bustype, "ISA   ", 6);
+                        memcpy(bus.bustype, "ISA   ", 6);
                        MP_bus_info(&bus);
                        construct_default_ioirq_mptable(0);
@@ -803,14 +795,14 @@ void __init find_smp_config(void)
 #ifdef CONFIG_X86_IO_APIC
 static u8 __initdata irq_used[MAX_IRQ_SOURCES];
-static int  __init get_MP_intsrc_index(struct mpc_config_intsrc *m)
+static int  __init get_MP_intsrc_index(struct mpc_intsrc *m)
 {
        int i;
-        if (m->mpc_irqtype != mp_INT)
+        if (m->irqtype != mp_INT)
                return 0;
-        if (m->mpc_irqflag != 0x0f)
+        if (m->irqflag != 0x0f)
                return 0;
        /* not legacy */
@@ -822,9 +814,9 @@ static int  __init get_MP_intsrc_index(struct mpc_config_intsrc *m)
                if (mp_irqs[i].mp_irqflag != 0x0f)
                        continue;
-                if (mp_irqs[i].mp_srcbus != m->mpc_srcbus)
+                if (mp_irqs[i].mp_srcbus != m->srcbus)
                        continue;
-                if (mp_irqs[i].mp_srcbusirq != m->mpc_srcbusirq)
+                if (mp_irqs[i].mp_srcbusirq != m->srcbusirq)
                        continue;
                if (irq_used[i]) {
                        /* already claimed */
@@ -840,10 +832,10 @@ static int  __init get_MP_intsrc_index(struct mpc_config_intsrc *m)
 #define SPARE_SLOT_NUM 20
-static struct mpc_config_intsrc __initdata *m_spare[SPARE_SLOT_NUM];
+static struct mpc_intsrc __initdata *m_spare[SPARE_SLOT_NUM];
 #endif
-static int  __init replace_intsrc_all(struct mp_config_table *mpc,
+static int  __init replace_intsrc_all(struct mpc_table *mpc,
                                        unsigned long mpc_new_phys,
                                        unsigned long mpc_new_length)
 {
@@ -855,36 +847,33 @@ static int  __init replace_intsrc_all(struct mp_config_table *mpc,
        int count = sizeof(*mpc);
        unsigned char *mpt = ((unsigned char *)mpc) + count;
-        printk(KERN_INFO "mpc_length %x\n", mpc->mpc_length);
+        printk(KERN_INFO "mpc_length %x\n", mpc->length);
-        while (count < mpc->mpc_length) {
+        while (count < mpc->length) {
                switch (*mpt) {
                case MP_PROCESSOR:
                        {
-                                struct mpc_config_processor *m =
+                                struct mpc_cpu *m = (struct mpc_cpu *)mpt;
-                                    (struct mpc_config_processor *)mpt;
                                mpt += sizeof(*m);
                                count += sizeof(*m);
                                break;
                        }
                case MP_BUS:
                        {
-                                struct mpc_config_bus *m =
+                                struct mpc_bus *m = (struct mpc_bus *)mpt;
-                                    (struct mpc_config_bus *)mpt;
                                mpt += sizeof(*m);
                                count += sizeof(*m);
                                break;
                        }
                case MP_IOAPIC:
                        {
-                                mpt += sizeof(struct mpc_config_ioapic);
+                                mpt += sizeof(struct mpc_ioapic);
-                                count += sizeof(struct mpc_config_ioapic);
+                                count += sizeof(struct mpc_ioapic);
                                break;
                        }
                case MP_INTSRC:
                        {
 #ifdef CONFIG_X86_IO_APIC
-                                struct mpc_config_intsrc *m =
+                                struct mpc_intsrc *m = (struct mpc_intsrc *)mpt;
-                                    (struct mpc_config_intsrc *)mpt;
                                printk(KERN_INFO "OLD ");
                                print_MP_intsrc_info(m);
@@ -905,14 +894,14 @@ static int  __init replace_intsrc_all(struct mp_config_table *mpc,
                                        nr_m_spare++;
                                }
 #endif
-                                mpt += sizeof(struct mpc_config_intsrc);
+                                mpt += sizeof(struct mpc_intsrc);
-                                count += sizeof(struct mpc_config_intsrc);
+                                count += sizeof(struct mpc_intsrc);
                                break;
                        }
                case MP_LINTSRC:
                        {
-                                struct mpc_config_lintsrc *m =
+                                struct mpc_lintsrc *m =
-                                    (struct mpc_config_lintsrc *)mpt;
+                                    (struct mpc_lintsrc *)mpt;
                                mpt += sizeof(*m);
                                count += sizeof(*m);
                                break;
@@ -922,7 +911,7 @@ static int  __init replace_intsrc_all(struct mp_config_table *mpc,
                        printk(KERN_ERR "Your mptable is wrong, contact your HW vendor!\n");
                        printk(KERN_ERR "type %x\n", *mpt);
                        print_hex_dump(KERN_ERR, "  ", DUMP_PREFIX_ADDRESS, 16,
-                                        1, mpc, mpc->mpc_length, 1);
+                                        1, mpc, mpc->length, 1);
                        goto out;
                }
        }
@@ -944,9 +933,8 @@ static int  __init replace_intsrc_all(struct mp_config_table *mpc,
                        assign_to_mpc_intsrc(&mp_irqs[i], m_spare[nr_m_spare]);
                        m_spare[nr_m_spare] = NULL;
                } else {
-                        struct mpc_config_intsrc *m =
+                        struct mpc_intsrc *m = (struct mpc_intsrc *)mpt;
-                            (struct mpc_config_intsrc *)mpt;
+                        count += sizeof(struct mpc_intsrc);
-                        count += sizeof(struct mpc_config_intsrc);
                        if (!mpc_new_phys) {
                                printk(KERN_INFO "No spare slots, try to append...take your risk, new mpc_length %x\n", count);
                        } else {
@@ -958,17 +946,16 @@ static int  __init replace_intsrc_all(struct mp_config_table *mpc,
                                }
                        }
                        assign_to_mpc_intsrc(&mp_irqs[i], m);
-                        mpc->mpc_length = count;
+                        mpc->length = count;
-                        mpt += sizeof(struct mpc_config_intsrc);
+                        mpt += sizeof(struct mpc_intsrc);
                }
                print_mp_irq_info(&mp_irqs[i]);
        }
 #endif
 out:
        /* update checksum */
-        mpc->mpc_checksum = 0;
+        mpc->checksum = 0;
-        mpc->mpc_checksum -= mpf_checksum((unsigned char *)mpc,
+        mpc->checksum -= mpf_checksum((unsigned char *)mpc, mpc->length);
-                                           mpc->mpc_length);
        return 0;
 }
@@ -1014,8 +1001,7 @@ static int __init update_mp_table(void)
        char str[16];
        char oem[10];
        struct intel_mp_floating *mpf;
-        struct mp_config_table *mpc;
+        struct mpc_table *mpc, *mpc_new;
-        struct mp_config_table *mpc_new;
        if (!enable_update_mptable)
                return 0;
@@ -1041,7 +1027,7 @@ static int __init update_mp_table(void)
        printk(KERN_INFO "mpf: %lx\n", virt_to_phys(mpf));
        printk(KERN_INFO "mpf_physptr: %x\n", mpf->mpf_physptr);
-        if (mpc_new_phys && mpc->mpc_length > mpc_new_length) {
+        if (mpc_new_phys && mpc->length > mpc_new_length) {
                mpc_new_phys = 0;
                printk(KERN_INFO "mpc_new_length is %ld, please use alloc_mptable=8k\n",
                         mpc_new_length);
@@ -1050,10 +1036,10 @@ static int __init update_mp_table(void)
        if (!mpc_new_phys) {
                unsigned char old, new;
                /* check if we can change the postion */
-                mpc->mpc_checksum = 0;
+                mpc->checksum = 0;
-                old = mpf_checksum((unsigned char *)mpc, mpc->mpc_length);
+                old = mpf_checksum((unsigned char *)mpc, mpc->length);
-                mpc->mpc_checksum = 0xff;
+                mpc->checksum = 0xff;
-                new = mpf_checksum((unsigned char *)mpc, mpc->mpc_length);
+                new = mpf_checksum((unsigned char *)mpc, mpc->length);
                if (old == new) {
                        printk(KERN_INFO "mpc is readonly, please try alloc_mptable instead\n");
                        return 0;
@@ -1062,7 +1048,7 @@ static int __init update_mp_table(void)
        } else {
                mpf->mpf_physptr = mpc_new_phys;
                mpc_new = phys_to_virt(mpc_new_phys);
-                memcpy(mpc_new, mpc, mpc->mpc_length);
+                memcpy(mpc_new, mpc, mpc->length);
                mpc = mpc_new;
                /* check if we can modify that */
                if (mpc_new_phys - mpf->mpf_physptr) {
diff --git a/arch/x86/kernel/nmi.c b/arch/x86/kernel/nmi.c
index 45a09ccdc21..7228979f1e7 100644
--- a/arch/x86/kernel/nmi.c
+++ b/arch/x86/kernel/nmi.c
@@ -26,7 +26,6 @@
 #include <linux/kernel_stat.h>
 #include <linux/kdebug.h>
 #include <linux/smp.h>
-#include <linux/nmi.h>
 #include <asm/i8259.h>
 #include <asm/io_apic.h>
diff --git a/arch/x86/kernel/numaq_32.c b/arch/x86/kernel/numaq_32.c
index 0deea37a53c..f2191d4f271 100644
--- a/arch/x86/kernel/numaq_32.c
+++ b/arch/x86/kernel/numaq_32.c
@@ -117,16 +117,15 @@ static inline int generate_logical_apicid(int quad, int phys_apicid)
 }
 /* x86_quirks member */
-static int mpc_apic_id(struct mpc_config_processor *m)
+static int mpc_apic_id(struct mpc_cpu *m)
 {
        int quad = translation_table[mpc_record]->trans_quad;
-        int logical_apicid = generate_logical_apicid(quad, m->mpc_apicid);
+        int logical_apicid = generate_logical_apicid(quad, m->apicid);
        printk(KERN_DEBUG "Processor #%d %u:%u APIC version %d (quad %d, apic %d)\n",
-               m->mpc_apicid,
+               m->apicid, (m->cpufeature & CPU_FAMILY_MASK) >> 8,
-               (m->mpc_cpufeature & CPU_FAMILY_MASK) >> 8,
+               (m->cpufeature & CPU_MODEL_MASK) >> 4,
-               (m->mpc_cpufeature & CPU_MODEL_MASK) >> 4,
+               m->apicver, quad, logical_apicid);
-               m->mpc_apicver, quad, logical_apicid);
        return logical_apicid;
 }
@@ -135,26 +134,26 @@ int mp_bus_id_to_node[MAX_MP_BUSSES];
 int mp_bus_id_to_local[MAX_MP_BUSSES];
 /* x86_quirks member */
-static void mpc_oem_bus_info(struct mpc_config_bus *m, char *name)
+static void mpc_oem_bus_info(struct mpc_bus *m, char *name)
 {
        int quad = translation_table[mpc_record]->trans_quad;
        int local = translation_table[mpc_record]->trans_local;
-        mp_bus_id_to_node[m->mpc_busid] = quad;
+        mp_bus_id_to_node[m->busid] = quad;
-        mp_bus_id_to_local[m->mpc_busid] = local;
+        mp_bus_id_to_local[m->busid] = local;
        printk(KERN_INFO "Bus #%d is %s (node %d)\n",
-               m->mpc_busid, name, quad);
+               m->busid, name, quad);
 }
 int quad_local_to_mp_bus_id [NR_CPUS/4][4];
 /* x86_quirks member */
-static void mpc_oem_pci_bus(struct mpc_config_bus *m)
+static void mpc_oem_pci_bus(struct mpc_bus *m)
 {
        int quad = translation_table[mpc_record]->trans_quad;
        int local = translation_table[mpc_record]->trans_local;
-        quad_local_to_mp_bus_id[quad][local] = m->mpc_busid;
+        quad_local_to_mp_bus_id[quad][local] = m->busid;
 }
 static void __init MP_translation_info(struct mpc_config_translation *m)
@@ -186,7 +185,7 @@ static int __init mpf_checksum(unsigned char *mp, int len)
 * Read/parse the MPC oem tables
 */
-static void __init smp_read_mpc_oem(struct mp_config_oemtable *oemtable,
+static void __init smp_read_mpc_oem(struct mpc_oemtable *oemtable,
                                    unsigned short oemsize)
 {
        int count = sizeof(*oemtable);  /* the header size */
@@ -195,18 +194,18 @@ static void __init smp_read_mpc_oem(struct mp_config_oemtable *oemtable,
        mpc_record = 0;
        printk(KERN_INFO "Found an OEM MPC table at %8p - parsing it ... \n",
               oemtable);
-        if (memcmp(oemtable->oem_signature, MPC_OEM_SIGNATURE, 4)) {
+        if (memcmp(oemtable->signature, MPC_OEM_SIGNATURE, 4)) {
                printk(KERN_WARNING
                       "SMP mpc oemtable: bad signature [%c%c%c%c]!\n",
-                       oemtable->oem_signature[0], oemtable->oem_signature[1],
+                       oemtable->signature[0], oemtable->signature[1],
-                       oemtable->oem_signature[2], oemtable->oem_signature[3]);
+                       oemtable->signature[2], oemtable->signature[3]);
                return;
        }
-        if (mpf_checksum((unsigned char *)oemtable, oemtable->oem_length)) {
+        if (mpf_checksum((unsigned char *)oemtable, oemtable->length)) {
                printk(KERN_WARNING "SMP oem mptable: checksum error!\n");
                return;
        }
-        while (count < oemtable->oem_length) {
+        while (count < oemtable->length) {
                switch (*oemptr) {
                case MP_TRANSLATION:
                        {
@@ -260,8 +259,7 @@ static struct x86_quirks numaq_x86_quirks __initdata = {
        .update_genapic         = numaq_update_genapic,
 };
-void numaq_mps_oem_check(struct mp_config_table *mpc, char *oem,
+void numaq_mps_oem_check(struct mpc_table *mpc, char *oem, char *productid)
-                                 char *productid)
 {
        if (strncmp(oem, "IBM NUMA", 8))
                printk("Warning!  Not a NUMA-Q system!\n");
diff --git a/arch/x86/kernel/pci-dma.c b/arch/x86/kernel/pci-dma.c
index 0d75c129b18..f293a8df682 100644
--- a/arch/x86/kernel/pci-dma.c
+++ b/arch/x86/kernel/pci-dma.c
@@ -38,7 +38,7 @@ EXPORT_SYMBOL(bad_dma_address);
   be probably a smaller DMA mask, but this is bug-to-bug compatible
   to older i386. */
 struct device x86_dma_fallback_dev = {
-        .bus_id = "fallback device",
+        .init_name = "fallback device",
        .coherent_dma_mask = DMA_32BIT_MASK,
        .dma_mask = &x86_dma_fallback_dev.coherent_dma_mask,
 };
diff --git a/arch/x86/kernel/process_32.c b/arch/x86/kernel/process_32.c
index 3ba155d2488..a546f55c77b 100644
--- a/arch/x86/kernel/process_32.c
+++ b/arch/x86/kernel/process_32.c
@@ -39,11 +39,12 @@
 #include <linux/prctl.h>
 #include <linux/dmi.h>
 #include <linux/ftrace.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
+#include <linux/kdebug.h>
-#include <asm/uaccess.h>
 #include <asm/pgtable.h>
 #include <asm/system.h>
-#include <asm/io.h>
 #include <asm/ldt.h>
 #include <asm/processor.h>
 #include <asm/i387.h>
@@ -56,10 +57,8 @@
 #include <asm/tlbflush.h>
 #include <asm/cpu.h>
-#include <asm/kdebug.h>
 #include <asm/idle.h>
 #include <asm/syscalls.h>
-#include <asm/smp.h>
 #include <asm/ds.h>
 asmlinkage void ret_from_fork(void) __asm__("ret_from_fork");
@@ -205,7 +204,7 @@ extern void kernel_thread_helper(void);
 /*
 * Create a kernel thread
 */
-int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
+int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
 {
        struct pt_regs regs;
@@ -266,7 +265,7 @@ void flush_thread(void)
        tsk->thread.debugreg3 = 0;
        tsk->thread.debugreg6 = 0;
        tsk->thread.debugreg7 = 0;
-        memset(tsk->thread.tls_array, 0, sizeof(tsk->thread.tls_array));        
+        memset(tsk->thread.tls_array, 0, sizeof(tsk->thread.tls_array));
        clear_tsk_thread_flag(tsk, TIF_DEBUG);
        /*
         * Forget coprocessor state..
@@ -293,9 +292,9 @@ void prepare_to_copy(struct task_struct *tsk)
 int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
        unsigned long unused,
-        struct task_struct * p, struct pt_regs * regs)
+        struct task_struct *p, struct pt_regs *regs)
 {
-        struct pt_regs * childregs;
+        struct pt_regs *childregs;
        struct task_struct *tsk;
        int err;
@@ -347,7 +346,7 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
 void
 start_thread(struct pt_regs *regs, unsigned long new_ip, unsigned long new_sp)
 {
-        __asm__("movl %0, %%gs" :: "r"(0));
+        __asm__("movl %0, %%gs" : : "r"(0));
        regs->fs                = 0;
        set_fs(USER_DS);
        regs->ds                = __USER_DS;
@@ -638,7 +637,7 @@ asmlinkage int sys_vfork(struct pt_regs regs)
 asmlinkage int sys_execve(struct pt_regs regs)
 {
        int error;
-        char * filename;
+        char *filename;
        filename = getname((char __user *) regs.bx);
        error = PTR_ERR(filename);
diff --git a/arch/x86/kernel/setup_percpu.c b/arch/x86/kernel/setup_percpu.c
index a4b619c3310..55c46074eba 100644
--- a/arch/x86/kernel/setup_percpu.c
+++ b/arch/x86/kernel/setup_percpu.c
@@ -5,12 +5,11 @@
 #include <linux/percpu.h>
 #include <linux/kexec.h>
 #include <linux/crash_dump.h>
-#include <asm/smp.h>
+#include <linux/smp.h>
-#include <asm/percpu.h>
+#include <linux/topology.h>
 #include <asm/sections.h>
 #include <asm/processor.h>
 #include <asm/setup.h>
-#include <asm/topology.h>
 #include <asm/mpspec.h>
 #include <asm/apicdef.h>
 #include <asm/highmem.h>
@@ -20,8 +19,8 @@ unsigned int num_processors;
 unsigned disabled_cpus __cpuinitdata;
 /* Processor that is doing the boot up */
 unsigned int boot_cpu_physical_apicid = -1U;
-unsigned int max_physical_apicid;
 EXPORT_SYMBOL(boot_cpu_physical_apicid);
+unsigned int max_physical_apicid;
 /* Bitmask of physically existing CPUs */
 physid_mask_t phys_cpu_present_map;
@@ -131,7 +130,27 @@ static void __init setup_cpu_pda_map(void)
        /* point to new pointer table */
        _cpu_pda = new_cpu_pda;
 }
-#endif
+#endif /* CONFIG_SMP && CONFIG_X86_64 */
+#ifdef CONFIG_X86_64
+/* correctly size the local cpu masks */
+static void setup_cpu_local_masks(void)
+{
+        alloc_bootmem_cpumask_var(&cpu_initialized_mask);
+        alloc_bootmem_cpumask_var(&cpu_callin_mask);
+        alloc_bootmem_cpumask_var(&cpu_callout_mask);
+        alloc_bootmem_cpumask_var(&cpu_sibling_setup_mask);
+}
+#else /* CONFIG_X86_32 */
+static inline void setup_cpu_local_masks(void)
+{
+}
+#endif /* CONFIG_X86_32 */
 /*
 * Great future plan:
@@ -187,6 +206,9 @@ void __init setup_per_cpu_areas(void)
        /* Setup node to cpumask map */
        setup_node_to_cpumask_map();
+        /* Setup cpu initialized, callin, callout masks */
+        setup_cpu_local_masks();
 }
 #endif
@@ -280,8 +302,8 @@ static void __cpuinit numa_set_cpumask(int cpu, int enable)
        cpulist_scnprintf(buf, sizeof(buf), mask);
        printk(KERN_DEBUG "%s cpu %d node %d: mask now %s\n",
-                enable? "numa_add_cpu":"numa_remove_cpu", cpu, node, buf);
+                enable ? "numa_add_cpu" : "numa_remove_cpu", cpu, node, buf);
- }
+}
 void __cpuinit numa_add_cpu(int cpu)
 {
diff --git a/arch/x86/kernel/smp.c b/arch/x86/kernel/smp.c
index beea2649a24..e6faa3316bd 100644
--- a/arch/x86/kernel/smp.c
+++ b/arch/x86/kernel/smp.c
@@ -1,7 +1,7 @@
 /*
 *      Intel SMP support routines.
 *
- *      (c) 1995 Alan Cox, Building #3 <alan@redhat.com>
+ *      (c) 1995 Alan Cox, Building #3 <alan@lxorguk.ukuu.org.uk>
 *      (c) 1998-99, 2000 Ingo Molnar <mingo@redhat.com>
 *      (c) 2002,2003 Andi Kleen, SuSE Labs.
 *
@@ -128,16 +128,23 @@ void native_send_call_func_single_ipi(int cpu)
 void native_send_call_func_ipi(const struct cpumask *mask)
 {
-        cpumask_t allbutself;
+        cpumask_var_t allbutself;
-        allbutself = cpu_online_map;
+        if (!alloc_cpumask_var(&allbutself, GFP_ATOMIC)) {
-        cpu_clear(smp_processor_id(), allbutself);
+                send_IPI_mask(mask, CALL_FUNCTION_VECTOR);
+                return;
+        }
-        if (cpus_equal(*mask, allbutself) &&
+        cpumask_copy(allbutself, cpu_online_mask);
-            cpus_equal(cpu_online_map, cpu_callout_map))
+        cpumask_clear_cpu(smp_processor_id(), allbutself);
+        if (cpumask_equal(mask, allbutself) &&
+            cpumask_equal(cpu_online_mask, cpu_callout_mask))
                send_IPI_allbutself(CALL_FUNCTION_VECTOR);
        else
                send_IPI_mask(mask, CALL_FUNCTION_VECTOR);
+        free_cpumask_var(allbutself);
 }
 /*
diff --git a/arch/x86/kernel/smpboot.c b/arch/x86/kernel/smpboot.c
index 6bd4d9b7387..bb1a3b1fc87 100644
--- a/arch/x86/kernel/smpboot.c
+++ b/arch/x86/kernel/smpboot.c
@@ -1,7 +1,7 @@
 /*
 *      x86 SMP booting functions
 *
- *      (c) 1995 Alan Cox, Building #3 <alan@redhat.com>
+ *      (c) 1995 Alan Cox, Building #3 <alan@lxorguk.ukuu.org.uk>
 *      (c) 1998, 1999, 2000 Ingo Molnar <mingo@redhat.com>
 *      Copyright 2001 Andi Kleen, SuSE Labs.
 *
@@ -102,9 +102,6 @@ EXPORT_SYMBOL(smp_num_siblings);
 /* Last level cache ID of each logical CPU */
 DEFINE_PER_CPU(u16, cpu_llc_id) = BAD_APICID;
-cpumask_t cpu_callin_map;
-cpumask_t cpu_callout_map;
 /* representing HT siblings of each logical CPU */
 DEFINE_PER_CPU(cpumask_t, cpu_sibling_map);
 EXPORT_PER_CPU_SYMBOL(cpu_sibling_map);
@@ -120,9 +117,6 @@ EXPORT_PER_CPU_SYMBOL(cpu_info);
 static atomic_t init_deasserted;
-/* representing cpus for which sibling maps can be computed */
-static cpumask_t cpu_sibling_setup_map;
 /* Set if we find a B stepping CPU */
 static int __cpuinitdata smp_b_stepping;
@@ -140,7 +134,7 @@ EXPORT_SYMBOL(cpu_to_node_map);
 static void map_cpu_to_node(int cpu, int node)
 {
        printk(KERN_INFO "Mapping cpu %d to node %d\n", cpu, node);
-        cpu_set(cpu, node_to_cpumask_map[node]);
+        cpumask_set_cpu(cpu, &node_to_cpumask_map[node]);
        cpu_to_node_map[cpu] = node;
 }
@@ -151,7 +145,7 @@ static void unmap_cpu_to_node(int cpu)
        printk(KERN_INFO "Unmapping cpu %d from all nodes\n", cpu);
        for (node = 0; node < MAX_NUMNODES; node++)
-                cpu_clear(cpu, node_to_cpumask_map[node]);
+                cpumask_clear_cpu(cpu, &node_to_cpumask_map[node]);
        cpu_to_node_map[cpu] = 0;
 }
 #else /* !(CONFIG_NUMA && CONFIG_X86_32) */
@@ -209,7 +203,7 @@ static void __cpuinit smp_callin(void)
         */
        phys_id = read_apic_id();
        cpuid = smp_processor_id();
-        if (cpu_isset(cpuid, cpu_callin_map)) {
+        if (cpumask_test_cpu(cpuid, cpu_callin_mask)) {
                panic("%s: phys CPU#%d, CPU#%d already present??\n", __func__,
                                        phys_id, cpuid);
        }
@@ -231,7 +225,7 @@ static void __cpuinit smp_callin(void)
                /*
                 * Has the boot CPU finished it's STARTUP sequence?
                 */
-                if (cpu_isset(cpuid, cpu_callout_map))
+                if (cpumask_test_cpu(cpuid, cpu_callout_mask))
                        break;
                cpu_relax();
        }
@@ -274,7 +268,7 @@ static void __cpuinit smp_callin(void)
        /*
         * Allow the master to continue.
         */
-        cpu_set(cpuid, cpu_callin_map);
+        cpumask_set_cpu(cpuid, cpu_callin_mask);
 }
 static int __cpuinitdata unsafe_smp;
@@ -332,7 +326,7 @@ notrace static void __cpuinit start_secondary(void *unused)
        ipi_call_lock();
        lock_vector_lock();
        __setup_vector_irq(smp_processor_id());
-        cpu_set(smp_processor_id(), cpu_online_map);
+        set_cpu_online(smp_processor_id(), true);
        unlock_vector_lock();
        ipi_call_unlock();
        per_cpu(cpu_state, smp_processor_id()) = CPU_ONLINE;
@@ -438,50 +432,52 @@ void __cpuinit set_cpu_sibling_map(int cpu)
        int i;
        struct cpuinfo_x86 *c = &cpu_data(cpu);
-        cpu_set(cpu, cpu_sibling_setup_map);
+        cpumask_set_cpu(cpu, cpu_sibling_setup_mask);
        if (smp_num_siblings > 1) {
-                for_each_cpu_mask_nr(i, cpu_sibling_setup_map) {
+                for_each_cpu(i, cpu_sibling_setup_mask) {
-                        if (c->phys_proc_id == cpu_data(i).phys_proc_id &&
+                        struct cpuinfo_x86 *o = &cpu_data(i);
-                            c->cpu_core_id == cpu_data(i).cpu_core_id) {
-                                cpu_set(i, per_cpu(cpu_sibling_map, cpu));
+                        if (c->phys_proc_id == o->phys_proc_id &&
-                                cpu_set(cpu, per_cpu(cpu_sibling_map, i));
+                            c->cpu_core_id == o->cpu_core_id) {
-                                cpu_set(i, per_cpu(cpu_core_map, cpu));
+                                cpumask_set_cpu(i, cpu_sibling_mask(cpu));
-                                cpu_set(cpu, per_cpu(cpu_core_map, i));
+                                cpumask_set_cpu(cpu, cpu_sibling_mask(i));
-                                cpu_set(i, c->llc_shared_map);
+                                cpumask_set_cpu(i, cpu_core_mask(cpu));
-                                cpu_set(cpu, cpu_data(i).llc_shared_map);
+                                cpumask_set_cpu(cpu, cpu_core_mask(i));
+                                cpumask_set_cpu(i, &c->llc_shared_map);
+                                cpumask_set_cpu(cpu, &o->llc_shared_map);
                        }
                }
        } else {
-                cpu_set(cpu, per_cpu(cpu_sibling_map, cpu));
+                cpumask_set_cpu(cpu, cpu_sibling_mask(cpu));
        }
-        cpu_set(cpu, c->llc_shared_map);
+        cpumask_set_cpu(cpu, &c->llc_shared_map);
        if (current_cpu_data.x86_max_cores == 1) {
-                per_cpu(cpu_core_map, cpu) = per_cpu(cpu_sibling_map, cpu);
+                cpumask_copy(cpu_core_mask(cpu), cpu_sibling_mask(cpu));
                c->booted_cores = 1;
                return;
        }
-        for_each_cpu_mask_nr(i, cpu_sibling_setup_map) {
+        for_each_cpu(i, cpu_sibling_setup_mask) {
                if (per_cpu(cpu_llc_id, cpu) != BAD_APICID &&
                    per_cpu(cpu_llc_id, cpu) == per_cpu(cpu_llc_id, i)) {
-                        cpu_set(i, c->llc_shared_map);
+                        cpumask_set_cpu(i, &c->llc_shared_map);
-                        cpu_set(cpu, cpu_data(i).llc_shared_map);
+                        cpumask_set_cpu(cpu, &cpu_data(i).llc_shared_map);
                }
                if (c->phys_proc_id == cpu_data(i).phys_proc_id) {
-                        cpu_set(i, per_cpu(cpu_core_map, cpu));
+                        cpumask_set_cpu(i, cpu_core_mask(cpu));
-                        cpu_set(cpu, per_cpu(cpu_core_map, i));
+                        cpumask_set_cpu(cpu, cpu_core_mask(i));
                        /*
                         *  Does this new cpu bringup a new core?
                         */
-                        if (cpus_weight(per_cpu(cpu_sibling_map, cpu)) == 1) {
+                        if (cpumask_weight(cpu_sibling_mask(cpu)) == 1) {
                                /*
                                 * for each core in package, increment
                                 * the booted_cores for this new cpu
                                 */
-                                if (first_cpu(per_cpu(cpu_sibling_map, i)) == i)
+                                if (cpumask_first(cpu_sibling_mask(i)) == i)
                                        c->booted_cores++;
                                /*
                                 * increment the core count for all
@@ -504,7 +500,7 @@ const struct cpumask *cpu_coregroup_mask(int cpu)
         * And for power savings, we return cpu_core_map
         */
        if (sched_mc_power_savings || sched_smt_power_savings)
-                return &per_cpu(cpu_core_map, cpu);
+                return cpu_core_mask(cpu);
        else
                return &c->llc_shared_map;
 }
@@ -523,7 +519,7 @@ static void impress_friends(void)
         */
        pr_debug("Before bogomips.\n");
        for_each_possible_cpu(cpu)
-                if (cpu_isset(cpu, cpu_callout_map))
+                if (cpumask_test_cpu(cpu, cpu_callout_mask))
                        bogosum += cpu_data(cpu).loops_per_jiffy;
        printk(KERN_INFO
                "Total of %d processors activated (%lu.%02lu BogoMIPS).\n",
@@ -904,19 +900,19 @@ do_rest:
                 * allow APs to start initializing.
                 */
                pr_debug("Before Callout %d.\n", cpu);
-                cpu_set(cpu, cpu_callout_map);
+                cpumask_set_cpu(cpu, cpu_callout_mask);
                pr_debug("After Callout %d.\n", cpu);
                /*
                 * Wait 5s total for a response
                 */
                for (timeout = 0; timeout < 50000; timeout++) {
-                        if (cpu_isset(cpu, cpu_callin_map))
+                        if (cpumask_test_cpu(cpu, cpu_callin_mask))
                                break;  /* It has booted */
                        udelay(100);
                }
-                if (cpu_isset(cpu, cpu_callin_map)) {
+                if (cpumask_test_cpu(cpu, cpu_callin_mask)) {
                        /* number CPUs logically, starting from 1 (BSP is 0) */
                        pr_debug("OK.\n");
                        printk(KERN_INFO "CPU%d: ", cpu);
@@ -941,9 +937,14 @@ restore_state:
        if (boot_error) {
                /* Try to put things back the way they were before ... */
                numa_remove_cpu(cpu); /* was set by numa_add_cpu */
-                cpu_clear(cpu, cpu_callout_map); /* was set by do_boot_cpu() */
-                cpu_clear(cpu, cpu_initialized); /* was set by cpu_init() */
+                /* was set by do_boot_cpu() */
-                cpu_clear(cpu, cpu_present_map);
+                cpumask_clear_cpu(cpu, cpu_callout_mask);
+                /* was set by cpu_init() */
+                cpumask_clear_cpu(cpu, cpu_initialized_mask);
+                set_cpu_present(cpu, false);
                per_cpu(x86_cpu_to_apicid, cpu) = BAD_APICID;
        }
@@ -977,7 +978,7 @@ int __cpuinit native_cpu_up(unsigned int cpu)
        /*
         * Already booted CPU?
         */
-        if (cpu_isset(cpu, cpu_callin_map)) {
+        if (cpumask_test_cpu(cpu, cpu_callin_mask)) {
                pr_debug("do_boot_cpu %d Already started\n", cpu);
                return -ENOSYS;
        }
@@ -1032,8 +1033,9 @@ int __cpuinit native_cpu_up(unsigned int cpu)
 */
 static __init void disable_smp(void)
 {
-        cpu_present_map = cpumask_of_cpu(0);
+        /* use the read/write pointers to the present and possible maps */
-        cpu_possible_map = cpumask_of_cpu(0);
+        cpumask_copy(&cpu_present_map, cpumask_of(0));
+        cpumask_copy(&cpu_possible_map, cpumask_of(0));
        smpboot_clear_io_apic_irqs();
        if (smp_found_config)
@@ -1041,8 +1043,8 @@ static __init void disable_smp(void)
        else
                physid_set_mask_of_physid(0, &phys_cpu_present_map);
        map_cpu_to_logical_apicid();
-        cpu_set(0, per_cpu(cpu_sibling_map, 0));
+        cpumask_set_cpu(0, cpu_sibling_mask(0));
-        cpu_set(0, per_cpu(cpu_core_map, 0));
+        cpumask_set_cpu(0, cpu_core_mask(0));
 }
 /*
@@ -1064,14 +1066,14 @@ static int __init smp_sanity_check(unsigned max_cpus)
                nr = 0;
                for_each_present_cpu(cpu) {
                        if (nr >= 8)
-                                cpu_clear(cpu, cpu_present_map);
+                                set_cpu_present(cpu, false);
                        nr++;
                }
                nr = 0;
                for_each_possible_cpu(cpu) {
                        if (nr >= 8)
-                                cpu_clear(cpu, cpu_possible_map);
+                                set_cpu_possible(cpu, false);
                        nr++;
                }
@@ -1167,7 +1169,7 @@ void __init native_smp_prepare_cpus(unsigned int max_cpus)
        preempt_disable();
        smp_cpu_index_default();
        current_cpu_data = boot_cpu_data;
-        cpu_callin_map = cpumask_of_cpu(0);
+        cpumask_copy(cpu_callin_mask, cpumask_of(0));
        mb();
        /*
         * Setup boot CPU information
@@ -1242,8 +1244,8 @@ void __init native_smp_prepare_boot_cpu(void)
        init_gdt(me);
 #endif
        switch_to_new_gdt();
-        /* already set me in cpu_online_map in boot_cpu_init() */
+        /* already set me in cpu_online_mask in boot_cpu_init() */
-        cpu_set(me, cpu_callout_map);
+        cpumask_set_cpu(me, cpu_callout_mask);
        per_cpu(cpu_state, me) = CPU_ONLINE;
 }
@@ -1311,7 +1313,7 @@ __init void prefill_possible_map(void)
                possible, max_t(int, possible - num_processors, 0));
        for (i = 0; i < possible; i++)
-                cpu_set(i, cpu_possible_map);
+                set_cpu_possible(i, true);
        nr_cpu_ids = possible;
 }
@@ -1323,31 +1325,31 @@ static void remove_siblinginfo(int cpu)
        int sibling;
        struct cpuinfo_x86 *c = &cpu_data(cpu);
-        for_each_cpu_mask_nr(sibling, per_cpu(cpu_core_map, cpu)) {
+        for_each_cpu(sibling, cpu_core_mask(cpu)) {
-                cpu_clear(cpu, per_cpu(cpu_core_map, sibling));
+                cpumask_clear_cpu(cpu, cpu_core_mask(sibling));
                /*/
                 * last thread sibling in this cpu core going down
                 */
-                if (cpus_weight(per_cpu(cpu_sibling_map, cpu)) == 1)
+                if (cpumask_weight(cpu_sibling_mask(cpu)) == 1)
                        cpu_data(sibling).booted_cores--;
        }
-        for_each_cpu_mask_nr(sibling, per_cpu(cpu_sibling_map, cpu))
+        for_each_cpu(sibling, cpu_sibling_mask(cpu))
-                cpu_clear(cpu, per_cpu(cpu_sibling_map, sibling));
+                cpumask_clear_cpu(cpu, cpu_sibling_mask(sibling));
-        cpus_clear(per_cpu(cpu_sibling_map, cpu));
+        cpumask_clear(cpu_sibling_mask(cpu));
-        cpus_clear(per_cpu(cpu_core_map, cpu));
+        cpumask_clear(cpu_core_mask(cpu));
        c->phys_proc_id = 0;
        c->cpu_core_id = 0;
-        cpu_clear(cpu, cpu_sibling_setup_map);
+        cpumask_clear_cpu(cpu, cpu_sibling_setup_mask);
 }
 static void __ref remove_cpu_from_maps(int cpu)
 {
-        cpu_clear(cpu, cpu_online_map);
+        set_cpu_online(cpu, false);
-        cpu_clear(cpu, cpu_callout_map);
+        cpumask_clear_cpu(cpu, cpu_callout_mask);
-        cpu_clear(cpu, cpu_callin_map);
+        cpumask_clear_cpu(cpu, cpu_callin_mask);
        /* was set by cpu_init() */
-        cpu_clear(cpu, cpu_initialized);
+        cpumask_clear_cpu(cpu, cpu_initialized_mask);
        numa_remove_cpu(cpu);
 }
diff --git a/arch/x86/kernel/time_32.c b/arch/x86/kernel/time_32.c
index 65309e4cb1c..3985cac0ed4 100644
--- a/arch/x86/kernel/time_32.c
+++ b/arch/x86/kernel/time_32.c
@@ -105,8 +105,8 @@ irqreturn_t timer_interrupt(int irq, void *dev_id)
                high bit of the PPI port B (0x61).  Note that some PS/2s,
                notably the 55SX, work fine if this is removed.  */
-                u8 irq_v = inb_p( 0x61 );       /* read the current state */
+                u8 irq_v = inb_p(0x61);         /* read the current state */
-                outb_p( irq_v|0x80, 0x61 );     /* reset the IRQ */
+                outb_p(irq_v | 0x80, 0x61);     /* reset the IRQ */
        }
 #endif
diff --git a/arch/x86/kernel/time_64.c b/arch/x86/kernel/time_64.c
index 891e7a7c433..e6e695acd72 100644
--- a/arch/x86/kernel/time_64.c
+++ b/arch/x86/kernel/time_64.c
@@ -17,10 +17,10 @@
 #include <linux/module.h>
 #include <linux/time.h>
 #include <linux/mca.h>
+#include <linux/nmi.h>
 #include <asm/i8253.h>
 #include <asm/hpet.h>
-#include <asm/nmi.h>
 #include <asm/vgtod.h>
 #include <asm/time.h>
 #include <asm/timer.h>
diff --git a/arch/x86/kernel/traps.c b/arch/x86/kernel/traps.c
index ce6650eb64e..98c2d055284 100644
--- a/arch/x86/kernel/traps.c
+++ b/arch/x86/kernel/traps.c
@@ -20,7 +20,6 @@
 #include <linux/module.h>
 #include <linux/ptrace.h>
 #include <linux/string.h>
-#include <linux/unwind.h>
 #include <linux/delay.h>
 #include <linux/errno.h>
 #include <linux/kexec.h>
@@ -51,7 +50,6 @@
 #include <asm/debugreg.h>
 #include <asm/atomic.h>
 #include <asm/system.h>
-#include <asm/unwind.h>
 #include <asm/traps.h>
 #include <asm/desc.h>
 #include <asm/i387.h>
@@ -65,9 +63,6 @@
 #else
 #include <asm/processor-flags.h>
 #include <asm/arch_hooks.h>
-#include <asm/nmi.h>
-#include <asm/smp.h>
-#include <asm/io.h>
 #include <asm/traps.h>
 #include "cpu/mcheck/mce.h"
diff --git a/arch/x86/kernel/visws_quirks.c b/arch/x86/kernel/visws_quirks.c
index 0c9667f0752..d801d06af06 100644
--- a/arch/x86/kernel/visws_quirks.c
+++ b/arch/x86/kernel/visws_quirks.c
@@ -176,33 +176,31 @@ static int __init visws_get_smp_config(unsigned int early)
 * No problem for Linux.
 */
-static void __init MP_processor_info(struct mpc_config_processor *m)
+static void __init MP_processor_info(struct mpc_cpu *m)
 {
        int ver, logical_apicid;
        physid_mask_t apic_cpus;
-        if (!(m->mpc_cpuflag & CPU_ENABLED))
+        if (!(m->cpuflag & CPU_ENABLED))
                return;
-        logical_apicid = m->mpc_apicid;
+        logical_apicid = m->apicid;
        printk(KERN_INFO "%sCPU #%d %u:%u APIC version %d\n",
-               m->mpc_cpuflag & CPU_BOOTPROCESSOR ? "Bootup " : "",
+               m->cpuflag & CPU_BOOTPROCESSOR ? "Bootup " : "",
-               m->mpc_apicid,
+               m->apicid, (m->cpufeature & CPU_FAMILY_MASK) >> 8,
-               (m->mpc_cpufeature & CPU_FAMILY_MASK) >> 8,
+               (m->cpufeature & CPU_MODEL_MASK) >> 4, m->apicver);
-               (m->mpc_cpufeature & CPU_MODEL_MASK) >> 4,
-               m->mpc_apicver);
-        if (m->mpc_cpuflag & CPU_BOOTPROCESSOR)
+        if (m->cpuflag & CPU_BOOTPROCESSOR)
-                boot_cpu_physical_apicid = m->mpc_apicid;
+                boot_cpu_physical_apicid = m->apicid;
-        ver = m->mpc_apicver;
+        ver = m->apicver;
-        if ((ver >= 0x14 && m->mpc_apicid >= 0xff) || m->mpc_apicid >= 0xf) {
+        if ((ver >= 0x14 && m->apicid >= 0xff) || m->apicid >= 0xf) {
                printk(KERN_ERR "Processor #%d INVALID. (Max ID: %d).\n",
-                        m->mpc_apicid, MAX_APICS);
+                        m->apicid, MAX_APICS);
                return;
        }
-        apic_cpus = apicid_to_cpu_present(m->mpc_apicid);
+        apic_cpus = apicid_to_cpu_present(m->apicid);
        physids_or(phys_cpu_present_map, phys_cpu_present_map, apic_cpus);
        /*
         * Validate version
@@ -210,15 +208,15 @@ static void __init MP_processor_info(struct mpc_config_processor *m)
        if (ver == 0x0) {
                printk(KERN_ERR "BIOS bug, APIC version is 0 for CPU#%d! "
                        "fixing up to 0x10. (tell your hw vendor)\n",
-                        m->mpc_apicid);
+                        m->apicid);
                ver = 0x10;
        }
-        apic_version[m->mpc_apicid] = ver;
+        apic_version[m->apicid] = ver;
 }
 static int __init visws_find_smp_config(unsigned int reserve)
 {
-        struct mpc_config_processor *mp = phys_to_virt(CO_CPU_TAB_PHYS);
+        struct mpc_cpu *mp = phys_to_virt(CO_CPU_TAB_PHYS);
        unsigned short ncpus = readw(phys_to_virt(CO_CPU_NUM_PHYS));
        if (ncpus > CO_CPU_MAX) {
author	Ingo Molnar <mingo@elte.hu>	2009-01-10 18:51:06 -0500
committer	Ingo Molnar <mingo@elte.hu>	2009-01-10 18:51:06 -0500
commit	0811a433c61e85f895018239c4466a36311cd5de (patch)
tree	276933e518e5525d24ae37b02df2db9909679260 /arch/x86/kernel
parent	c299030765292434b73572f9bcfe84951ff06614 (diff)
parent	3d14bdad40315b54470cb7812293d14c8af2bf7d (diff)