10 files changed, 62 insertions, 48 deletions

diff --git a/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c b/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
index 28102ad1a363..0b31939862d6 100644
--- a/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
+++ b/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
@@ -411,7 +411,7 @@ static int acpi_cpufreq_target(struct cpufreq_policy *policy,
 
 #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);
+        cpumask_and(&online_policy_cpus, cpu_online_mask, policy->cpus);
 #else
         online_policy_cpus = policy->cpus;
 #endif
@@ -626,15 +626,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/p4-clockmod.c b/arch/x86/kernel/cpu/cpufreq/p4-clockmod.c
index beea4466b063..b585e04cbc9e 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 c3c9adbaa26f..5c28b37dea11 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);
-        data->available_cores = &(pol->cpus);
+                cpumask_copy(pol->cpus, &per_cpu(cpu_core_map, pol->cpu));
+        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 65cfb5d7f77f..8ecc75b6c7c3 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 d2cc4991cbaa..f08998278a3a 100644
--- a/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
+++ b/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
@@ -492,8 +492,8 @@ static int centrino_target (struct cpufreq_policy *policy,
         }
 
         first_cpu = 1;
-        for_each_cpu_mask_nr(j, policy->cpus) {
-                const cpumask_t *mask;
+        for_each_cpu(j, policy->cpus) {
+                const struct cpumask *mask;
 
                 /* cpufreq holds the hotplug lock, so we are safe here */
                 if (!cpu_online(j))
@@ -504,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();
@@ -538,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;
@@ -563,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;
@@ -586,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);
diff --git a/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c b/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c
index 04d0376b64b0..dedc1e98f168 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/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 01dde80597f7..b55cb67435bd 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -584,12 +584,12 @@ out:
         return i;
 }
 
-static ssize_t show_cpus(cpumask_t mask, char *buf)
+static ssize_t show_cpus(const struct cpumask *mask, char *buf)
 {
         ssize_t i = 0;
         unsigned int cpu;
 
-        for_each_cpu_mask_nr(cpu, mask) {
+        for_each_cpu(cpu, mask) {
                 if (i)
                         i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), " ");
                 i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), "%u", cpu);
@@ -606,7 +606,7 @@ static ssize_t show_cpus(cpumask_t mask, char *buf)
  */
 static ssize_t show_related_cpus(struct cpufreq_policy *policy, char *buf)
 {
-        if (cpus_empty(policy->related_cpus))
+        if (cpumask_empty(policy->related_cpus))
                 return show_cpus(policy->cpus, buf);
         return show_cpus(policy->related_cpus, buf);
 }
@@ -806,9 +806,20 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
                 ret = -ENOMEM;
                 goto nomem_out;
         }
+        if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL)) {
+                kfree(policy);
+                ret = -ENOMEM;
+                goto nomem_out;
+        }
+        if (!alloc_cpumask_var(&policy->related_cpus, GFP_KERNEL)) {
+                free_cpumask_var(policy->cpus);
+                kfree(policy);
+                ret = -ENOMEM;
+                goto nomem_out;
+        }
 
         policy->cpu = cpu;
-        policy->cpus = cpumask_of_cpu(cpu);
+        cpumask_copy(policy->cpus, cpumask_of(cpu));
 
         /* Initially set CPU itself as the policy_cpu */
         per_cpu(policy_cpu, cpu) = cpu;
@@ -843,7 +854,7 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
         }
 #endif
 
-        for_each_cpu_mask_nr(j, policy->cpus) {
+        for_each_cpu(j, policy->cpus) {
                 if (cpu == j)
                         continue;
 
@@ -861,7 +872,7 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
                                 goto err_out_driver_exit;
 
                         spin_lock_irqsave(&cpufreq_driver_lock, flags);
-                        managed_policy->cpus = policy->cpus;
+                        cpumask_copy(managed_policy->cpus, policy->cpus);
                         per_cpu(cpufreq_cpu_data, cpu) = managed_policy;
                         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
 
@@ -916,14 +927,14 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
         }
 
         spin_lock_irqsave(&cpufreq_driver_lock, flags);
-        for_each_cpu_mask_nr(j, policy->cpus) {
+        for_each_cpu(j, policy->cpus) {
                 per_cpu(cpufreq_cpu_data, j) = policy;
                 per_cpu(policy_cpu, j) = policy->cpu;
         }
         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
 
         /* symlink affected CPUs */
-        for_each_cpu_mask_nr(j, policy->cpus) {
+        for_each_cpu(j, policy->cpus) {
                 if (j == cpu)
                         continue;
                 if (!cpu_online(j))
@@ -963,7 +974,7 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
 
 err_out_unregister:
         spin_lock_irqsave(&cpufreq_driver_lock, flags);
-        for_each_cpu_mask_nr(j, policy->cpus)
+        for_each_cpu(j, policy->cpus)
                 per_cpu(cpufreq_cpu_data, j) = NULL;
         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
 
@@ -1024,7 +1035,7 @@ static int __cpufreq_remove_dev(struct sys_device *sys_dev)
          */
         if (unlikely(cpu != data->cpu)) {
                 dprintk("removing link\n");
-                cpu_clear(cpu, data->cpus);
+                cpumask_clear_cpu(cpu, data->cpus);
                 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
                 sysfs_remove_link(&sys_dev->kobj, "cpufreq");
                 cpufreq_cpu_put(data);
@@ -1045,8 +1056,8 @@ static int __cpufreq_remove_dev(struct sys_device *sys_dev)
          * per_cpu(cpufreq_cpu_data) while holding the lock, and remove
          * the sysfs links afterwards.
          */
-        if (unlikely(cpus_weight(data->cpus) > 1)) {
-                for_each_cpu_mask_nr(j, data->cpus) {
+        if (unlikely(cpumask_weight(data->cpus) > 1)) {
+                for_each_cpu(j, data->cpus) {
                         if (j == cpu)
                                 continue;
                         per_cpu(cpufreq_cpu_data, j) = NULL;
@@ -1055,8 +1066,8 @@ static int __cpufreq_remove_dev(struct sys_device *sys_dev)
 
         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
 
-        if (unlikely(cpus_weight(data->cpus) > 1)) {
-                for_each_cpu_mask_nr(j, data->cpus) {
+        if (unlikely(cpumask_weight(data->cpus) > 1)) {
+                for_each_cpu(j, data->cpus) {
                         if (j == cpu)
                                 continue;
                         dprintk("removing link for cpu %u\n", j);
@@ -1090,7 +1101,10 @@ static int __cpufreq_remove_dev(struct sys_device *sys_dev)
         if (cpufreq_driver->exit)
                 cpufreq_driver->exit(data);
 
+        free_cpumask_var(data->related_cpus);
+        free_cpumask_var(data->cpus);
         kfree(data);
+        per_cpu(cpufreq_cpu_data, cpu) = NULL;
 
         cpufreq_debug_enable_ratelimit();
         return 0;
diff --git a/drivers/cpufreq/cpufreq_conservative.c b/drivers/cpufreq/cpufreq_conservative.c
index e2657837d954..0320962c4ec5 100644
--- a/drivers/cpufreq/cpufreq_conservative.c
+++ b/drivers/cpufreq/cpufreq_conservative.c
@@ -498,7 +498,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                         return rc;
                 }
 
-                for_each_cpu_mask_nr(j, policy->cpus) {
+                for_each_cpu(j, policy->cpus) {
                         struct cpu_dbs_info_s *j_dbs_info;
                         j_dbs_info = &per_cpu(cpu_dbs_info, j);
                         j_dbs_info->cur_policy = policy;
diff --git a/drivers/cpufreq/cpufreq_ondemand.c b/drivers/cpufreq/cpufreq_ondemand.c
index 2ab3c12b88af..6a2b036c9389 100644
--- a/drivers/cpufreq/cpufreq_ondemand.c
+++ b/drivers/cpufreq/cpufreq_ondemand.c
@@ -400,7 +400,7 @@ static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info)
         /* Get Absolute Load - in terms of freq */
         max_load_freq = 0;
 
-        for_each_cpu_mask_nr(j, policy->cpus) {
+        for_each_cpu(j, policy->cpus) {
                 struct cpu_dbs_info_s *j_dbs_info;
                 cputime64_t cur_wall_time, cur_idle_time;
                 unsigned int idle_time, wall_time;
@@ -568,7 +568,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                         return rc;
                 }
 
-                for_each_cpu_mask_nr(j, policy->cpus) {
+                for_each_cpu(j, policy->cpus) {
                         struct cpu_dbs_info_s *j_dbs_info;
                         j_dbs_info = &per_cpu(cpu_dbs_info, j);
                         j_dbs_info->cur_policy = policy;
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index 484b3abf61bb..384b38d3e8e2 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -80,8 +80,8 @@ struct cpufreq_real_policy {
 };
 
 struct cpufreq_policy {
-        cpumask_t               cpus;   /* CPUs requiring sw coordination */
-        cpumask_t               related_cpus; /* CPUs with any coordination */
+        cpumask_var_t           cpus;   /* CPUs requiring sw coordination */
+        cpumask_var_t           related_cpus; /* CPUs with any coordination */
         unsigned int            shared_type; /* ANY or ALL affected CPUs
                                                 should set cpufreq */
         unsigned int            cpu;    /* cpu nr of registered CPU */