18 files changed, 172 insertions, 116 deletions

diff --git a/arch/x86/kernel/acpi/cstate.c b/arch/x86/kernel/acpi/cstate.c
index c2502eb9aa83..9220cf46aa10 100644
--- a/arch/x86/kernel/acpi/cstate.c
+++ b/arch/x86/kernel/acpi/cstate.c
@@ -73,6 +73,7 @@ int acpi_processor_ffh_cstate_probe(unsigned int cpu,
         struct cpuinfo_x86 *c = &cpu_data(cpu);
 
         cpumask_t saved_mask;
+        cpumask_of_cpu_ptr(new_mask, cpu);
         int retval;
         unsigned int eax, ebx, ecx, edx;
         unsigned int edx_part;
@@ -91,7 +92,7 @@ int acpi_processor_ffh_cstate_probe(unsigned int cpu,
 
         /* Make sure we are running on right CPU */
         saved_mask = current->cpus_allowed;
-        retval = set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
+        retval = set_cpus_allowed_ptr(current, new_mask);
         if (retval)
                 return -1;
 
diff --git a/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c b/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
index b0c8208df9fa..ff2fff56f0a8 100644
--- a/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
+++ b/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
@@ -200,10 +200,12 @@ static void drv_read(struct drv_cmd *cmd)
 static void drv_write(struct drv_cmd *cmd)
 {
         cpumask_t saved_mask = current->cpus_allowed;
+        cpumask_of_cpu_ptr_declare(cpu_mask);
         unsigned int i;
 
-        for_each_cpu_mask(i, cmd->mask) {
-                set_cpus_allowed_ptr(current, &cpumask_of_cpu(i));
+        for_each_cpu_mask_nr(i, cmd->mask) {
+                cpumask_of_cpu_ptr_next(cpu_mask, i);
+                set_cpus_allowed_ptr(current, cpu_mask);
                 do_drv_write(cmd);
         }
 
@@ -267,11 +269,12 @@ static unsigned int get_measured_perf(unsigned int cpu)
         } aperf_cur, mperf_cur;
 
         cpumask_t saved_mask;
+        cpumask_of_cpu_ptr(cpu_mask, cpu);
         unsigned int perf_percent;
         unsigned int retval;
 
         saved_mask = current->cpus_allowed;
-        set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
+        set_cpus_allowed_ptr(current, cpu_mask);
         if (get_cpu() != cpu) {
                 /* We were not able to run on requested processor */
                 put_cpu();
@@ -337,6 +340,7 @@ static unsigned int get_measured_perf(unsigned int cpu)
 
 static unsigned int get_cur_freq_on_cpu(unsigned int cpu)
 {
+        cpumask_of_cpu_ptr(cpu_mask, cpu);
         struct acpi_cpufreq_data *data = per_cpu(drv_data, cpu);
         unsigned int freq;
         unsigned int cached_freq;
@@ -349,7 +353,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(cpu_mask), data);
         if (freq != cached_freq) {
                 /*
                  * The dreaded BIOS frequency change behind our back.
@@ -451,7 +455,7 @@ static int acpi_cpufreq_target(struct cpufreq_policy *policy,
 
         freqs.old = perf->states[perf->state].core_frequency * 1000;
         freqs.new = data->freq_table[next_state].frequency;
-        for_each_cpu_mask(i, cmd.mask) {
+        for_each_cpu_mask_nr(i, cmd.mask) {
                 freqs.cpu = i;
                 cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
         }
@@ -466,7 +470,7 @@ static int acpi_cpufreq_target(struct cpufreq_policy *policy,
                 }
         }
 
-        for_each_cpu_mask(i, cmd.mask) {
+        for_each_cpu_mask_nr(i, cmd.mask) {
                 freqs.cpu = i;
                 cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
         }
diff --git a/arch/x86/kernel/cpu/cpufreq/p4-clockmod.c b/arch/x86/kernel/cpu/cpufreq/p4-clockmod.c
index 199e4e05e5dc..f1685fb91fbd 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(i, policy->cpus) {
+        for_each_cpu_mask_nr(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(i, policy->cpus)
+        for_each_cpu_mask_nr(i, policy->cpus)
                 cpufreq_p4_setdc(i, p4clockmod_table[newstate].index);
 
         /* notifiers */
-        for_each_cpu_mask(i, policy->cpus) {
+        for_each_cpu_mask_nr(i, policy->cpus) {
                 freqs.cpu = i;
                 cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
         }
diff --git a/arch/x86/kernel/cpu/cpufreq/powernow-k8.c b/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
index 206791eb46e3..53c7b6936973 100644
--- a/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
+++ b/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
@@ -479,11 +479,12 @@ static int core_voltage_post_transition(struct powernow_k8_data *data, u32 reqvi
 static int check_supported_cpu(unsigned int cpu)
 {
         cpumask_t oldmask;
+        cpumask_of_cpu_ptr(cpu_mask, cpu);
         u32 eax, ebx, ecx, edx;
         unsigned int rc = 0;
 
         oldmask = current->cpus_allowed;
-        set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
+        set_cpus_allowed_ptr(current, cpu_mask);
 
         if (smp_processor_id() != cpu) {
                 printk(KERN_ERR PFX "limiting to cpu %u failed\n", cpu);
@@ -966,7 +967,7 @@ static int transition_frequency_fidvid(struct powernow_k8_data *data, unsigned i
         freqs.old = find_khz_freq_from_fid(data->currfid);
         freqs.new = find_khz_freq_from_fid(fid);
 
-        for_each_cpu_mask(i, *(data->available_cores)) {
+        for_each_cpu_mask_nr(i, *(data->available_cores)) {
                 freqs.cpu = i;
                 cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
         }
@@ -974,7 +975,7 @@ static int transition_frequency_fidvid(struct powernow_k8_data *data, unsigned i
         res = transition_fid_vid(data, fid, vid);
         freqs.new = find_khz_freq_from_fid(data->currfid);
 
-        for_each_cpu_mask(i, *(data->available_cores)) {
+        for_each_cpu_mask_nr(i, *(data->available_cores)) {
                 freqs.cpu = i;
                 cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
         }
@@ -997,7 +998,7 @@ static int transition_frequency_pstate(struct powernow_k8_data *data, unsigned i
         freqs.old = find_khz_freq_from_pstate(data->powernow_table, data->currpstate);
         freqs.new = find_khz_freq_from_pstate(data->powernow_table, pstate);
 
-        for_each_cpu_mask(i, *(data->available_cores)) {
+        for_each_cpu_mask_nr(i, *(data->available_cores)) {
                 freqs.cpu = i;
                 cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
         }
@@ -1005,7 +1006,7 @@ static int transition_frequency_pstate(struct powernow_k8_data *data, unsigned i
         res = transition_pstate(data, pstate);
         freqs.new = find_khz_freq_from_pstate(data->powernow_table, pstate);
 
-        for_each_cpu_mask(i, *(data->available_cores)) {
+        for_each_cpu_mask_nr(i, *(data->available_cores)) {
                 freqs.cpu = i;
                 cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
         }
@@ -1016,6 +1017,7 @@ static int transition_frequency_pstate(struct powernow_k8_data *data, unsigned i
 static int powernowk8_target(struct cpufreq_policy *pol, unsigned targfreq, unsigned relation)
 {
         cpumask_t oldmask;
+        cpumask_of_cpu_ptr(cpu_mask, pol->cpu);
         struct powernow_k8_data *data = per_cpu(powernow_data, pol->cpu);
         u32 checkfid;
         u32 checkvid;
@@ -1030,7 +1032,7 @@ static int powernowk8_target(struct cpufreq_policy *pol, unsigned targfreq, unsi
 
         /* only run on specific CPU from here on */
         oldmask = current->cpus_allowed;
-        set_cpus_allowed_ptr(current, &cpumask_of_cpu(pol->cpu));
+        set_cpus_allowed_ptr(current, cpu_mask);
 
         if (smp_processor_id() != pol->cpu) {
                 printk(KERN_ERR PFX "limiting to cpu %u failed\n", pol->cpu);
@@ -1105,6 +1107,7 @@ static int __cpuinit powernowk8_cpu_init(struct cpufreq_policy *pol)
 {
         struct powernow_k8_data *data;
         cpumask_t oldmask;
+        cpumask_of_cpu_ptr_declare(newmask);
         int rc;
 
         if (!cpu_online(pol->cpu))
@@ -1156,7 +1159,8 @@ static int __cpuinit powernowk8_cpu_init(struct cpufreq_policy *pol)
 
         /* only run on specific CPU from here on */
         oldmask = current->cpus_allowed;
-        set_cpus_allowed_ptr(current, &cpumask_of_cpu(pol->cpu));
+        cpumask_of_cpu_ptr_next(newmask, pol->cpu);
+        set_cpus_allowed_ptr(current, newmask);
 
         if (smp_processor_id() != pol->cpu) {
                 printk(KERN_ERR PFX "limiting to cpu %u failed\n", pol->cpu);
@@ -1178,7 +1182,7 @@ 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);
+                pol->cpus = *newmask;
         else
                 pol->cpus = per_cpu(cpu_core_map, pol->cpu);
         data->available_cores = &(pol->cpus);
@@ -1244,6 +1248,7 @@ static unsigned int powernowk8_get (unsigned int cpu)
 {
         struct powernow_k8_data *data;
         cpumask_t oldmask = current->cpus_allowed;
+        cpumask_of_cpu_ptr(newmask, cpu);
         unsigned int khz = 0;
         unsigned int first;
 
@@ -1253,7 +1258,7 @@ static unsigned int powernowk8_get (unsigned int cpu)
         if (!data)
                 return -EINVAL;
 
-        set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
+        set_cpus_allowed_ptr(current, newmask);
         if (smp_processor_id() != cpu) {
                 printk(KERN_ERR PFX
                         "limiting to CPU %d failed in powernowk8_get\n", cpu);
diff --git a/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c b/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
index 908dd347c67e..ca2ac13b7af2 100644
--- a/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
+++ b/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
@@ -28,7 +28,8 @@
 #define PFX             "speedstep-centrino: "
 #define MAINTAINER      "cpufreq@lists.linux.org.uk"
 
-#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, "speedstep-centrino", msg)
+#define dprintk(msg...) \
+        cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, "speedstep-centrino", msg)
 
 #define INTEL_MSR_RANGE (0xffff)
 
@@ -66,11 +67,12 @@ struct cpu_model
 
         struct cpufreq_frequency_table *op_points; /* clock/voltage pairs */
 };
-static int centrino_verify_cpu_id(const struct cpuinfo_x86 *c, const struct cpu_id *x);
+static int centrino_verify_cpu_id(const struct cpuinfo_x86 *c,
+                                  const struct cpu_id *x);
 
 /* Operating points for current CPU */
-static struct cpu_model *centrino_model[NR_CPUS];
-static const struct cpu_id *centrino_cpu[NR_CPUS];
+static DEFINE_PER_CPU(struct cpu_model *, centrino_model);
+static DEFINE_PER_CPU(const struct cpu_id *, centrino_cpu);
 
 static struct cpufreq_driver centrino_driver;
 
@@ -255,7 +257,7 @@ static int centrino_cpu_init_table(struct cpufreq_policy *policy)
                 return -ENOENT;
         }
 
-        centrino_model[policy->cpu] = model;
+        per_cpu(centrino_model, policy->cpu) = model;
 
         dprintk("found \"%s\": max frequency: %dkHz\n",
                model->model_name, model->max_freq);
@@ -264,10 +266,14 @@ static int centrino_cpu_init_table(struct cpufreq_policy *policy)
 }
 
 #else
-static inline int centrino_cpu_init_table(struct cpufreq_policy *policy) { return -ENODEV; }
+static inline int centrino_cpu_init_table(struct cpufreq_policy *policy)
+{
+        return -ENODEV;
+}
 #endif /* CONFIG_X86_SPEEDSTEP_CENTRINO_TABLE */
 
-static int centrino_verify_cpu_id(const struct cpuinfo_x86 *c, const struct cpu_id *x)
+static int centrino_verify_cpu_id(const struct cpuinfo_x86 *c,
+                                  const struct cpu_id *x)
 {
         if ((c->x86 == x->x86) &&
             (c->x86_model == x->x86_model) &&
@@ -286,23 +292,28 @@ static unsigned extract_clock(unsigned msr, unsigned int cpu, int failsafe)
          * for centrino, as some DSDTs are buggy.
          * Ideally, this can be done using the acpi_data structure.
          */
-        if ((centrino_cpu[cpu] == &cpu_ids[CPU_BANIAS]) ||
-            (centrino_cpu[cpu] == &cpu_ids[CPU_DOTHAN_A1]) ||
-            (centrino_cpu[cpu] == &cpu_ids[CPU_DOTHAN_B0])) {
+        if ((per_cpu(centrino_cpu, cpu) == &cpu_ids[CPU_BANIAS]) ||
+            (per_cpu(centrino_cpu, cpu) == &cpu_ids[CPU_DOTHAN_A1]) ||
+            (per_cpu(centrino_cpu, cpu) == &cpu_ids[CPU_DOTHAN_B0])) {
                 msr = (msr >> 8) & 0xff;
                 return msr * 100000;
         }
 
-        if ((!centrino_model[cpu]) || (!centrino_model[cpu]->op_points))
+        if ((!per_cpu(centrino_model, cpu)) ||
+            (!per_cpu(centrino_model, cpu)->op_points))
                 return 0;
 
         msr &= 0xffff;
-        for (i=0;centrino_model[cpu]->op_points[i].frequency != CPUFREQ_TABLE_END; i++) {
-                if (msr == centrino_model[cpu]->op_points[i].index)
-                        return centrino_model[cpu]->op_points[i].frequency;
+        for (i = 0;
+                per_cpu(centrino_model, cpu)->op_points[i].frequency
+                                                        != CPUFREQ_TABLE_END;
+             i++) {
+                if (msr == per_cpu(centrino_model, cpu)->op_points[i].index)
+                        return per_cpu(centrino_model, cpu)->
+                                                        op_points[i].frequency;
         }
         if (failsafe)
-                return centrino_model[cpu]->op_points[i-1].frequency;
+                return per_cpu(centrino_model, cpu)->op_points[i-1].frequency;
         else
                 return 0;
 }
@@ -313,9 +324,10 @@ static unsigned int get_cur_freq(unsigned int cpu)
         unsigned l, h;
         unsigned clock_freq;
         cpumask_t saved_mask;
+        cpumask_of_cpu_ptr(new_mask, cpu);
 
         saved_mask = current->cpus_allowed;
-        set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
+        set_cpus_allowed_ptr(current, new_mask);
         if (smp_processor_id() != cpu)
                 return 0;
 
@@ -347,7 +359,8 @@ static int centrino_cpu_init(struct cpufreq_policy *policy)
         int i;
 
         /* Only Intel makes Enhanced Speedstep-capable CPUs */
-        if (cpu->x86_vendor != X86_VENDOR_INTEL || !cpu_has(cpu, X86_FEATURE_EST))
+        if (cpu->x86_vendor != X86_VENDOR_INTEL ||
+            !cpu_has(cpu, X86_FEATURE_EST))
                 return -ENODEV;
 
         if (cpu_has(cpu, X86_FEATURE_CONSTANT_TSC))
@@ -361,9 +374,9 @@ static int centrino_cpu_init(struct cpufreq_policy *policy)
                         break;
 
         if (i != N_IDS)
-                centrino_cpu[policy->cpu] = &cpu_ids[i];
+                per_cpu(centrino_cpu, policy->cpu) = &cpu_ids[i];
 
-        if (!centrino_cpu[policy->cpu]) {
+        if (!per_cpu(centrino_cpu, policy->cpu)) {
                 dprintk("found unsupported CPU with "
                 "Enhanced SpeedStep: send /proc/cpuinfo to "
                 MAINTAINER "\n");
@@ -386,23 +399,26 @@ static int centrino_cpu_init(struct cpufreq_policy *policy)
                 /* check to see if it stuck */
                 rdmsr(MSR_IA32_MISC_ENABLE, l, h);
                 if (!(l & (1<<16))) {
-                        printk(KERN_INFO PFX "couldn't enable Enhanced SpeedStep\n");
+                        printk(KERN_INFO PFX
+                                "couldn't enable Enhanced SpeedStep\n");
                         return -ENODEV;
                 }
         }
 
         freq = get_cur_freq(policy->cpu);
-
-        policy->cpuinfo.transition_latency = 10000; /* 10uS transition latency */
+        policy->cpuinfo.transition_latency = 10000;
+                                                /* 10uS transition latency */
         policy->cur = freq;
 
         dprintk("centrino_cpu_init: cur=%dkHz\n", policy->cur);
 
-        ret = cpufreq_frequency_table_cpuinfo(policy, centrino_model[policy->cpu]->op_points);
+        ret = cpufreq_frequency_table_cpuinfo(policy,
+                per_cpu(centrino_model, policy->cpu)->op_points);
         if (ret)
                 return (ret);
 
-        cpufreq_frequency_table_get_attr(centrino_model[policy->cpu]->op_points, policy->cpu);
+        cpufreq_frequency_table_get_attr(
+                per_cpu(centrino_model, policy->cpu)->op_points, policy->cpu);
 
         return 0;
 }
@@ -411,12 +427,12 @@ static int centrino_cpu_exit(struct cpufreq_policy *policy)
 {
         unsigned int cpu = policy->cpu;
 
-        if (!centrino_model[cpu])
+        if (!per_cpu(centrino_model, cpu))
                 return -ENODEV;
 
         cpufreq_frequency_table_put_attr(cpu);
 
-        centrino_model[cpu] = NULL;
+        per_cpu(centrino_model, cpu) = NULL;
 
         return 0;
 }
@@ -430,17 +446,26 @@ static int centrino_cpu_exit(struct cpufreq_policy *policy)
  */
 static int centrino_verify (struct cpufreq_policy *policy)
 {
-        return cpufreq_frequency_table_verify(policy, centrino_model[policy->cpu]->op_points);
+        return cpufreq_frequency_table_verify(policy,
+                        per_cpu(centrino_model, policy->cpu)->op_points);
 }
 
 /**
  * centrino_setpolicy - set a new CPUFreq policy
  * @policy: new policy
  * @target_freq: the target frequency
- * @relation: how that frequency relates to achieved frequency (CPUFREQ_RELATION_L or CPUFREQ_RELATION_H)
+ * @relation: how that frequency relates to achieved frequency
+ *      (CPUFREQ_RELATION_L or CPUFREQ_RELATION_H)
  *
  * Sets a new CPUFreq policy.
  */
+struct allmasks {
+        cpumask_t               online_policy_cpus;
+        cpumask_t               saved_mask;
+        cpumask_t               set_mask;
+        cpumask_t               covered_cpus;
+};
+
 static int centrino_target (struct cpufreq_policy *policy,
                             unsigned int target_freq,
                             unsigned int relation)
@@ -448,48 +473,55 @@ static int centrino_target (struct cpufreq_policy *policy,
         unsigned int    newstate = 0;
         unsigned int    msr, oldmsr = 0, h = 0, cpu = policy->cpu;
         struct cpufreq_freqs    freqs;
-        cpumask_t               online_policy_cpus;
-        cpumask_t               saved_mask;
-        cpumask_t               set_mask;
-        cpumask_t               covered_cpus;
         int                     retval = 0;
         unsigned int            j, k, first_cpu, tmp;
-
-        if (unlikely(centrino_model[cpu] == NULL))
-                return -ENODEV;
+        CPUMASK_ALLOC(allmasks);
+        CPUMASK_PTR(online_policy_cpus, allmasks);
+        CPUMASK_PTR(saved_mask, allmasks);
+        CPUMASK_PTR(set_mask, allmasks);
+        CPUMASK_PTR(covered_cpus, allmasks);
+
+        if (unlikely(allmasks == NULL))
+                return -ENOMEM;
+
+        if (unlikely(per_cpu(centrino_model, cpu) == NULL)) {
+                retval = -ENODEV;
+                goto out;
+        }
 
         if (unlikely(cpufreq_frequency_table_target(policy,
-                        centrino_model[cpu]->op_points,
+                        per_cpu(centrino_model, cpu)->op_points,
                         target_freq,
                         relation,
                         &newstate))) {
-                return -EINVAL;
+                retval = -EINVAL;
+                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);
+        cpus_and(*online_policy_cpus, cpu_online_map, policy->cpus);
 #else
-        online_policy_cpus = policy->cpus;
+        *online_policy_cpus = policy->cpus;
 #endif
 
-        saved_mask = current->cpus_allowed;
+        *saved_mask = current->cpus_allowed;
         first_cpu = 1;
-        cpus_clear(covered_cpus);
-        for_each_cpu_mask(j, online_policy_cpus) {
+        cpus_clear(*covered_cpus);
+        for_each_cpu_mask_nr(j, *online_policy_cpus) {
                 /*
                  * Support for SMP systems.
                  * Make sure we are running on CPU that wants to change freq
                  */
-                cpus_clear(set_mask);
+                cpus_clear(*set_mask);
                 if (policy->shared_type == CPUFREQ_SHARED_TYPE_ANY)
-                        cpus_or(set_mask, set_mask, online_policy_cpus);
+                        cpus_or(*set_mask, *set_mask, *online_policy_cpus);
                 else
-                        cpu_set(j, set_mask);
+                        cpu_set(j, *set_mask);
 
-                set_cpus_allowed_ptr(current, &set_mask);
+                set_cpus_allowed_ptr(current, set_mask);
                 preempt_disable();
-                if (unlikely(!cpu_isset(smp_processor_id(), set_mask))) {
+                if (unlikely(!cpu_isset(smp_processor_id(), *set_mask))) {
                         dprintk("couldn't limit to CPUs in this domain\n");
                         retval = -EAGAIN;
                         if (first_cpu) {
@@ -500,7 +532,7 @@ static int centrino_target (struct cpufreq_policy *policy,
                         break;
                 }
 
-                msr = centrino_model[cpu]->op_points[newstate].index;
+                msr = per_cpu(centrino_model, cpu)->op_points[newstate].index;
 
                 if (first_cpu) {
                         rdmsr(MSR_IA32_PERF_CTL, oldmsr, h);
@@ -517,7 +549,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(k, online_policy_cpus) {
+                        for_each_cpu_mask_nr(k, *online_policy_cpus) {
                                 freqs.cpu = k;
                                 cpufreq_notify_transition(&freqs,
                                         CPUFREQ_PRECHANGE);
@@ -536,11 +568,11 @@ static int centrino_target (struct cpufreq_policy *policy,
                         break;
                 }
 
-                cpu_set(j, covered_cpus);
+                cpu_set(j, *covered_cpus);
                 preempt_enable();
         }
 
-        for_each_cpu_mask(k, online_policy_cpus) {
+        for_each_cpu_mask_nr(k, *online_policy_cpus) {
                 freqs.cpu = k;
                 cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
         }
@@ -553,10 +585,12 @@ static int centrino_target (struct cpufreq_policy *policy,
                  * Best effort undo..
                  */
 
-                if (!cpus_empty(covered_cpus)) {
-                        for_each_cpu_mask(j, covered_cpus) {
-                                set_cpus_allowed_ptr(current,
-                                                     &cpumask_of_cpu(j));
+                if (!cpus_empty(*covered_cpus)) {
+                        cpumask_of_cpu_ptr_declare(new_mask);
+
+                        for_each_cpu_mask_nr(j, *covered_cpus) {
+                                cpumask_of_cpu_ptr_next(new_mask, j);
+                                set_cpus_allowed_ptr(current, new_mask);
                                 wrmsr(MSR_IA32_PERF_CTL, oldmsr, h);
                         }
                 }
@@ -564,19 +598,22 @@ static int centrino_target (struct cpufreq_policy *policy,
                 tmp = freqs.new;
                 freqs.new = freqs.old;
                 freqs.old = tmp;
-                for_each_cpu_mask(j, online_policy_cpus) {
+                for_each_cpu_mask_nr(j, *online_policy_cpus) {
                         freqs.cpu = j;
                         cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
                         cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
                 }
         }
-        set_cpus_allowed_ptr(current, &saved_mask);
-        return 0;
+        set_cpus_allowed_ptr(current, saved_mask);
+        retval = 0;
+        goto out;
 
 migrate_end:
         preempt_enable();
-        set_cpus_allowed_ptr(current, &saved_mask);
-        return 0;
+        set_cpus_allowed_ptr(current, saved_mask);
+out:
+        CPUMASK_FREE(allmasks);
+        return retval;
 }
 
 static struct freq_attr* centrino_attr[] = {
diff --git a/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c b/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c
index 1b50244b1fdf..2f3728dc24f6 100644
--- a/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c
+++ b/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c
@@ -244,7 +244,8 @@ static unsigned int _speedstep_get(const cpumask_t *cpus)
 
 static unsigned int speedstep_get(unsigned int cpu)
 {
-        return _speedstep_get(&cpumask_of_cpu(cpu));
+        cpumask_of_cpu_ptr(newmask, cpu);
+        return _speedstep_get(newmask);
 }
 
 /**
@@ -279,7 +280,7 @@ static int speedstep_target (struct cpufreq_policy *policy,
 
         cpus_allowed = current->cpus_allowed;
 
-        for_each_cpu_mask(i, policy->cpus) {
+        for_each_cpu_mask_nr(i, policy->cpus) {
                 freqs.cpu = i;
                 cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
         }
@@ -292,7 +293,7 @@ static int speedstep_target (struct cpufreq_policy *policy,
         /* allow to be run on all CPUs */
         set_cpus_allowed_ptr(current, &cpus_allowed);
 
-        for_each_cpu_mask(i, policy->cpus) {
+        for_each_cpu_mask_nr(i, policy->cpus) {
                 freqs.cpu = i;
                 cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
         }
diff --git a/arch/x86/kernel/cpu/intel_cacheinfo.c b/arch/x86/kernel/cpu/intel_cacheinfo.c
index ff517f0b8cc4..650d40f7912b 100644
--- a/arch/x86/kernel/cpu/intel_cacheinfo.c
+++ b/arch/x86/kernel/cpu/intel_cacheinfo.c
@@ -489,7 +489,7 @@ static void __cpuinit cache_remove_shared_cpu_map(unsigned int cpu, int index)
         int sibling;
 
         this_leaf = CPUID4_INFO_IDX(cpu, index);
-        for_each_cpu_mask(sibling, this_leaf->shared_cpu_map) {
+        for_each_cpu_mask_nr(sibling, this_leaf->shared_cpu_map) {
                 sibling_leaf = CPUID4_INFO_IDX(sibling, index); 
                 cpu_clear(cpu, sibling_leaf->shared_cpu_map);
         }
@@ -516,6 +516,7 @@ static int __cpuinit detect_cache_attributes(unsigned int cpu)
         unsigned long           j;
         int                     retval;
         cpumask_t               oldmask;
+        cpumask_of_cpu_ptr(newmask, cpu);
 
         if (num_cache_leaves == 0)
                 return -ENOENT;
@@ -526,7 +527,7 @@ static int __cpuinit detect_cache_attributes(unsigned int cpu)
                 return -ENOMEM;
 
         oldmask = current->cpus_allowed;
-        retval = set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
+        retval = set_cpus_allowed_ptr(current, newmask);
         if (retval)
                 goto out;
 
diff --git a/arch/x86/kernel/cpu/mcheck/mce_64.c b/arch/x86/kernel/cpu/mcheck/mce_64.c
index 9ab65be82427..65a339678ece 100644
--- a/arch/x86/kernel/cpu/mcheck/mce_64.c
+++ b/arch/x86/kernel/cpu/mcheck/mce_64.c
@@ -580,7 +580,7 @@ static ssize_t mce_read(struct file *filp, char __user *ubuf, size_t usize,
         char __user *buf = ubuf;
         int i, err;
 
-        cpu_tsc = kmalloc(NR_CPUS * sizeof(long), GFP_KERNEL);
+        cpu_tsc = kmalloc(nr_cpu_ids * sizeof(long), GFP_KERNEL);
         if (!cpu_tsc)
                 return -ENOMEM;
 
diff --git a/arch/x86/kernel/cpu/mcheck/mce_amd_64.c b/arch/x86/kernel/cpu/mcheck/mce_amd_64.c
index 7c9a813e1193..88736cadbaa6 100644
--- a/arch/x86/kernel/cpu/mcheck/mce_amd_64.c
+++ b/arch/x86/kernel/cpu/mcheck/mce_amd_64.c
@@ -527,7 +527,7 @@ static __cpuinit int threshold_create_bank(unsigned int cpu, unsigned int bank)
         if (err)
                 goto out_free;
 
-        for_each_cpu_mask(i, b->cpus) {
+        for_each_cpu_mask_nr(i, b->cpus) {
                 if (i == cpu)
                         continue;
 
@@ -617,7 +617,7 @@ static void threshold_remove_bank(unsigned int cpu, int bank)
 #endif
 
         /* remove all sibling symlinks before unregistering */
-        for_each_cpu_mask(i, b->cpus) {
+        for_each_cpu_mask_nr(i, b->cpus) {
                 if (i == cpu)
                         continue;
 
diff --git a/arch/x86/kernel/cpu/proc.c b/arch/x86/kernel/cpu/proc.c
index 0d0d9057e7c0..a26c480b9491 100644
--- a/arch/x86/kernel/cpu/proc.c
+++ b/arch/x86/kernel/cpu/proc.c
@@ -160,7 +160,7 @@ static void *c_start(struct seq_file *m, loff_t *pos)
 {
         if (*pos == 0)  /* just in case, cpu 0 is not the first */
                 *pos = first_cpu(cpu_online_map);
-        if ((*pos) < NR_CPUS && cpu_online(*pos))
+        if ((*pos) < nr_cpu_ids && cpu_online(*pos))
                 return &cpu_data(*pos);
         return NULL;
 }
diff --git a/arch/x86/kernel/genapic_flat_64.c b/arch/x86/kernel/genapic_flat_64.c
index 1a9c68845ee8..786548a62d38 100644
--- a/arch/x86/kernel/genapic_flat_64.c
+++ b/arch/x86/kernel/genapic_flat_64.c
@@ -168,7 +168,7 @@ static unsigned int physflat_cpu_mask_to_apicid(cpumask_t cpumask)
          * May as well be the first.
          */
         cpu = first_cpu(cpumask);
-        if ((unsigned)cpu < NR_CPUS)
+        if ((unsigned)cpu < nr_cpu_ids)
                 return per_cpu(x86_cpu_to_apicid, cpu);
         else
                 return BAD_APICID;
diff --git a/arch/x86/kernel/genx2apic_uv_x.c b/arch/x86/kernel/genx2apic_uv_x.c
index 3c3929340692..2cfcbded888a 100644
--- a/arch/x86/kernel/genx2apic_uv_x.c
+++ b/arch/x86/kernel/genx2apic_uv_x.c
@@ -98,7 +98,7 @@ static void uv_send_IPI_mask(cpumask_t mask, int vector)
 {
         unsigned int cpu;
 
-        for (cpu = 0; cpu < NR_CPUS; ++cpu)
+        for_each_possible_cpu(cpu)
                 if (cpu_isset(cpu, mask))
                         uv_send_IPI_one(cpu, vector);
 }
@@ -132,7 +132,7 @@ static unsigned int uv_cpu_mask_to_apicid(cpumask_t cpumask)
          * May as well be the first.
          */
         cpu = first_cpu(cpumask);
-        if ((unsigned)cpu < NR_CPUS)
+        if ((unsigned)cpu < nr_cpu_ids)
                 return per_cpu(x86_cpu_to_apicid, cpu);
         else
                 return BAD_APICID;
diff --git a/arch/x86/kernel/io_apic_64.c b/arch/x86/kernel/io_apic_64.c
index 64a46affd858..8269434d1707 100644
--- a/arch/x86/kernel/io_apic_64.c
+++ b/arch/x86/kernel/io_apic_64.c
@@ -732,7 +732,7 @@ static int __assign_irq_vector(int irq, cpumask_t mask)
                         return 0;
         }
 
-        for_each_cpu_mask(cpu, mask) {
+        for_each_cpu_mask_nr(cpu, mask) {
                 cpumask_t domain, new_mask;
                 int new_cpu;
                 int vector, offset;
@@ -753,7 +753,7 @@ next:
                         continue;
                 if (vector == IA32_SYSCALL_VECTOR)
                         goto next;
-                for_each_cpu_mask(new_cpu, new_mask)
+                for_each_cpu_mask_nr(new_cpu, new_mask)
                         if (per_cpu(vector_irq, new_cpu)[vector] != -1)
                                 goto next;
                 /* Found one! */
@@ -763,7 +763,7 @@ next:
                         cfg->move_in_progress = 1;
                         cfg->old_domain = cfg->domain;
                 }
-                for_each_cpu_mask(new_cpu, new_mask)
+                for_each_cpu_mask_nr(new_cpu, new_mask)
                         per_cpu(vector_irq, new_cpu)[vector] = irq;
                 cfg->vector = vector;
                 cfg->domain = domain;
@@ -795,7 +795,7 @@ static void __clear_irq_vector(int irq)
 
         vector = cfg->vector;
         cpus_and(mask, cfg->domain, cpu_online_map);
-        for_each_cpu_mask(cpu, mask)
+        for_each_cpu_mask_nr(cpu, mask)
                 per_cpu(vector_irq, cpu)[vector] = -1;
 
         cfg->vector = 0;
@@ -1373,12 +1373,10 @@ static unsigned int startup_ioapic_irq(unsigned int irq)
 static int ioapic_retrigger_irq(unsigned int irq)
 {
         struct irq_cfg *cfg = &irq_cfg[irq];
-        cpumask_t mask;
         unsigned long flags;
 
         spin_lock_irqsave(&vector_lock, flags);
-        mask = cpumask_of_cpu(first_cpu(cfg->domain));
-        send_IPI_mask(mask, cfg->vector);
+        send_IPI_mask(cpumask_of_cpu(first_cpu(cfg->domain)), cfg->vector);
         spin_unlock_irqrestore(&vector_lock, flags);
 
         return 1;
diff --git a/arch/x86/kernel/ldt.c b/arch/x86/kernel/ldt.c
index a8449571858a..3fee2aa50f3f 100644
--- a/arch/x86/kernel/ldt.c
+++ b/arch/x86/kernel/ldt.c
@@ -62,12 +62,12 @@ static int alloc_ldt(mm_context_t *pc, int mincount, int reload)
 
         if (reload) {
 #ifdef CONFIG_SMP
-                cpumask_t mask;
+                cpumask_of_cpu_ptr_declare(mask);
 
                 preempt_disable();
                 load_LDT(pc);
-                mask = cpumask_of_cpu(smp_processor_id());
-                if (!cpus_equal(current->mm->cpu_vm_mask, mask))
+                cpumask_of_cpu_ptr_next(mask, smp_processor_id());
+                if (!cpus_equal(current->mm->cpu_vm_mask, *mask))
                         smp_call_function(flush_ldt, current->mm, 1);
                 preempt_enable();
 #else
diff --git a/arch/x86/kernel/microcode.c b/arch/x86/kernel/microcode.c
index fc4790638b69..6994c751590e 100644
--- a/arch/x86/kernel/microcode.c
+++ b/arch/x86/kernel/microcode.c
@@ -388,6 +388,7 @@ static int do_microcode_update (void)
         void *new_mc = NULL;
         int cpu;
         cpumask_t old;
+        cpumask_of_cpu_ptr_declare(newmask);
 
         old = current->cpus_allowed;
 
@@ -404,7 +405,8 @@ static int do_microcode_update (void)
 
                         if (!uci->valid)
                                 continue;
-                        set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
+                        cpumask_of_cpu_ptr_next(newmask, cpu);
+                        set_cpus_allowed_ptr(current, newmask);
                         error = get_maching_microcode(new_mc, cpu);
                         if (error < 0)
                                 goto out;
@@ -574,6 +576,7 @@ static int apply_microcode_check_cpu(int cpu)
         struct cpuinfo_x86 *c = &cpu_data(cpu);
         struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
         cpumask_t old;
+        cpumask_of_cpu_ptr(newmask, cpu);
         unsigned int val[2];
         int err = 0;
 
@@ -582,7 +585,7 @@ static int apply_microcode_check_cpu(int cpu)
                 return 0;
 
         old = current->cpus_allowed;
-        set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
+        set_cpus_allowed_ptr(current, newmask);
 
         /* Check if the microcode we have in memory matches the CPU */
         if (c->x86_vendor != X86_VENDOR_INTEL || c->x86 < 6 ||
@@ -620,11 +623,12 @@ static int apply_microcode_check_cpu(int cpu)
 static void microcode_init_cpu(int cpu, int resume)
 {
         cpumask_t old;
+        cpumask_of_cpu_ptr(newmask, cpu);
         struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
 
         old = current->cpus_allowed;
 
-        set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
+        set_cpus_allowed_ptr(current, newmask);
         mutex_lock(&microcode_mutex);
         collect_cpu_info(cpu);
         if (uci->valid && system_state == SYSTEM_RUNNING && !resume)
@@ -658,11 +662,12 @@ static ssize_t reload_store(struct sys_device *dev,
                 return -EINVAL;
         if (val == 1) {
                 cpumask_t old;
+                cpumask_of_cpu_ptr(newmask, cpu);
 
                 old = current->cpus_allowed;
 
                 get_online_cpus();
-                set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
+                set_cpus_allowed_ptr(current, newmask);
 
                 mutex_lock(&microcode_mutex);
                 if (uci->valid)
diff --git a/arch/x86/kernel/reboot.c b/arch/x86/kernel/reboot.c
index 9dcf39c02972..06a9f643817e 100644
--- a/arch/x86/kernel/reboot.c
+++ b/arch/x86/kernel/reboot.c
@@ -411,24 +411,28 @@ void native_machine_shutdown(void)
 {
         /* Stop the cpus and apics */
 #ifdef CONFIG_SMP
-        int reboot_cpu_id;
 
         /* The boot cpu is always logical cpu 0 */
-        reboot_cpu_id = 0;
+        int reboot_cpu_id = 0;
+        cpumask_of_cpu_ptr(newmask, reboot_cpu_id);
 
 #ifdef CONFIG_X86_32
         /* See if there has been given a command line override */
         if ((reboot_cpu != -1) && (reboot_cpu < NR_CPUS) &&
-                cpu_online(reboot_cpu))
+                cpu_online(reboot_cpu)) {
                 reboot_cpu_id = reboot_cpu;
+                cpumask_of_cpu_ptr_next(newmask, reboot_cpu_id);
+        }
 #endif
 
         /* Make certain the cpu I'm about to reboot on is online */
-        if (!cpu_online(reboot_cpu_id))
+        if (!cpu_online(reboot_cpu_id)) {
                 reboot_cpu_id = smp_processor_id();
+                cpumask_of_cpu_ptr_next(newmask, reboot_cpu_id);
+        }
 
         /* Make certain I only run on the appropriate processor */
-        set_cpus_allowed_ptr(current, &cpumask_of_cpu(reboot_cpu_id));
+        set_cpus_allowed_ptr(current, newmask);
 
         /* O.K Now that I'm on the appropriate processor,
          * stop all of the others.
diff --git a/arch/x86/kernel/smpboot.c b/arch/x86/kernel/smpboot.c
index 4b53a647bc0a..332512767f4f 100644
--- a/arch/x86/kernel/smpboot.c
+++ b/arch/x86/kernel/smpboot.c
@@ -438,7 +438,7 @@ void __cpuinit set_cpu_sibling_map(int cpu)
         cpu_set(cpu, cpu_sibling_setup_map);
 
         if (smp_num_siblings > 1) {
-                for_each_cpu_mask(i, cpu_sibling_setup_map) {
+                for_each_cpu_mask_nr(i, cpu_sibling_setup_map) {
                         if (c->phys_proc_id == cpu_data(i).phys_proc_id &&
                             c->cpu_core_id == cpu_data(i).cpu_core_id) {
                                 cpu_set(i, per_cpu(cpu_sibling_map, cpu));
@@ -461,7 +461,7 @@ void __cpuinit set_cpu_sibling_map(int cpu)
                 return;
         }
 
-        for_each_cpu_mask(i, cpu_sibling_setup_map) {
+        for_each_cpu_mask_nr(i, cpu_sibling_setup_map) {
                 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);
@@ -1219,7 +1219,7 @@ static void remove_siblinginfo(int cpu)
         int sibling;
         struct cpuinfo_x86 *c = &cpu_data(cpu);
 
-        for_each_cpu_mask(sibling, per_cpu(cpu_core_map, cpu)) {
+        for_each_cpu_mask_nr(sibling, per_cpu(cpu_core_map, cpu)) {
                 cpu_clear(cpu, per_cpu(cpu_core_map, sibling));
                 /*/
                  * last thread sibling in this cpu core going down
@@ -1228,7 +1228,7 @@ static void remove_siblinginfo(int cpu)
                         cpu_data(sibling).booted_cores--;
         }
 
-        for_each_cpu_mask(sibling, per_cpu(cpu_sibling_map, cpu))
+        for_each_cpu_mask_nr(sibling, per_cpu(cpu_sibling_map, cpu))
                 cpu_clear(cpu, per_cpu(cpu_sibling_map, sibling));
         cpus_clear(per_cpu(cpu_sibling_map, cpu));
         cpus_clear(per_cpu(cpu_core_map, cpu));
diff --git a/arch/x86/xen/smp.c b/arch/x86/xen/smp.c
index e693812ac59a..d8faf79a0a1d 100644
--- a/arch/x86/xen/smp.c
+++ b/arch/x86/xen/smp.c
@@ -367,7 +367,7 @@ static void xen_send_IPI_mask(cpumask_t mask, enum ipi_vector vector)
 
         cpus_and(mask, mask, cpu_online_map);
 
-        for_each_cpu_mask(cpu, mask)
+        for_each_cpu_mask_nr(cpu, mask)
                 xen_send_IPI_one(cpu, vector);
 }
 
@@ -378,7 +378,7 @@ static void xen_smp_send_call_function_ipi(cpumask_t mask)
         xen_send_IPI_mask(mask, XEN_CALL_FUNCTION_VECTOR);
 
         /* Make sure other vcpus get a chance to run if they need to. */
-        for_each_cpu_mask(cpu, mask) {
+        for_each_cpu_mask_nr(cpu, mask) {
                 if (xen_vcpu_stolen(cpu)) {
                         HYPERVISOR_sched_op(SCHEDOP_yield, 0);
                         break;