UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

cpumask: convert struct cpufreq_policy to cpumask_var_t 

Impact: use new cpumask API to reduce memory usage

This is part of an effort to reduce structure sizes for machines
configured with large NR_CPUS.  cpumask_t gets replaced by
cpumask_var_t, which is either struct cpumask[1] (small NR_CPUS) or
struct cpumask * (large NR_CPUS).

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Mike Travis <travis@sgi.com>
Acked-by: Dave Jones <davej@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
This commit is contained in:
Rusty Russell 2009-01-04 05:18:06 -08:00 committed by Ingo Molnar
parent 5cb0535f17
commit 835481d9bc
10 changed files with 62 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
View File

@ -411,7 +411,7 @@ static int acpi_cpufreq_target(struct cpufreq_policy *policy,
#ifdef CONFIG_HOTPLUG_CPU #ifdef CONFIG_HOTPLUG_CPU
/* cpufreq holds the hotplug lock, so we are safe from here on */ /* 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 #else
online_policy_cpus = policy->cpus; online_policy_cpus = policy->cpus;
#endif #endif
@ -626,15 +626,15 @@ static int acpi_cpufreq_cpu_init(struct cpufreq_policy *policy)
*/ */
if (policy->shared_type == CPUFREQ_SHARED_TYPE_ALL || if (policy->shared_type == CPUFREQ_SHARED_TYPE_ALL ||
policy->shared_type == CPUFREQ_SHARED_TYPE_ANY) { 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 #ifdef CONFIG_SMP
dmi_check_system(sw_any_bug_dmi_table); 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->shared_type = CPUFREQ_SHARED_TYPE_ALL;
policy->cpus = per_cpu(cpu_core_map, cpu); cpumask_copy(policy->cpus, cpu_core_mask(cpu));
} }
#endif #endif

8
arch/x86/kernel/cpu/cpufreq/p4-clockmod.c
View File

@ -122,7 +122,7 @@ static int cpufreq_p4_target(struct cpufreq_policy *policy,
return 0; return 0;
/* notifiers */ /* notifiers */
for_each_cpu_mask_nr(i, policy->cpus) { for_each_cpu(i, policy->cpus) {
freqs.cpu = i; freqs.cpu = i;
cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE); 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 /* run on each logical CPU, see section 13.15.3 of IA32 Intel Architecture Software
* Developer's Manual, Volume 3 * 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); cpufreq_p4_setdc(i, p4clockmod_table[newstate].index);
/* notifiers */ /* notifiers */
for_each_cpu_mask_nr(i, policy->cpus) { for_each_cpu(i, policy->cpus) {
freqs.cpu = i; freqs.cpu = i;
cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE); cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
} }
@ -203,7 +203,7 @@ static int cpufreq_p4_cpu_init(struct cpufreq_policy *policy)
unsigned int i; unsigned int i;
#ifdef CONFIG_SMP #ifdef CONFIG_SMP
policy->cpus = per_cpu(cpu_sibling_map, policy->cpu); cpumask_copy(policy->cpus, &per_cpu(cpu_sibling_map, policy->cpu));
#endif #endif
/* Errata workaround */ /* Errata workaround */

6
arch/x86/kernel/cpu/cpufreq/powernow-k8.c
View File

@ -1199,10 +1199,10 @@ static int __cpuinit powernowk8_cpu_init(struct cpufreq_policy *pol)
set_cpus_allowed_ptr(current, &oldmask); set_cpus_allowed_ptr(current, &oldmask);
if (cpu_family == CPU_HW_PSTATE) if (cpu_family == CPU_HW_PSTATE)
pol->cpus = cpumask_of_cpu(pol->cpu); cpumask_copy(pol->cpus, cpumask_of(pol->cpu));
else 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. /* Take a crude guess here.
* That guess was in microseconds, so multiply with 1000 */ * That guess was in microseconds, so multiply with 1000 */

2
arch/x86/kernel/cpu/cpufreq/powernow-k8.h
View File

@ -53,7 +53,7 @@ struct powernow_k8_data {
/* we need to keep track of associated cores, but let cpufreq /* we need to keep track of associated cores, but let cpufreq
* handle hotplug events - so just point at cpufreq pol->cpus * handle hotplug events - so just point at cpufreq pol->cpus
* structure */ * structure */
cpumask_t *available_cores; struct cpumask *available_cores;
}; };

14
arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
View File

@ -492,8 +492,8 @@ static int centrino_target (struct cpufreq_policy *policy,
} }
first_cpu = 1; first_cpu = 1;
for_each_cpu_mask_nr(j, policy->cpus) { for_each_cpu(j, policy->cpus) {
const cpumask_t *mask; const struct cpumask *mask;
/* cpufreq holds the hotplug lock, so we are safe here */ /* cpufreq holds the hotplug lock, so we are safe here */
if (!cpu_online(j)) 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 * Make sure we are running on CPU that wants to change freq
*/ */
if (policy->shared_type == CPUFREQ_SHARED_TYPE_ANY) if (policy->shared_type == CPUFREQ_SHARED_TYPE_ANY)
mask = &policy->cpus; mask = policy->cpus;
else else
mask = &cpumask_of_cpu(j); mask = cpumask_of(j);
set_cpus_allowed_ptr(current, mask); set_cpus_allowed_ptr(current, mask);
preempt_disable(); preempt_disable();
@ -538,7 +538,7 @@ static int centrino_target (struct cpufreq_policy *policy,
dprintk("target=%dkHz old=%d new=%d msr=%04x\n", dprintk("target=%dkHz old=%d new=%d msr=%04x\n",
target_freq, freqs.old, freqs.new, msr); 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)) if (!cpu_online(k))
continue; continue;
freqs.cpu = k; freqs.cpu = k;
@ -563,7 +563,7 @@ static int centrino_target (struct cpufreq_policy *policy,
preempt_enable(); preempt_enable();
} }
for_each_cpu_mask_nr(k, policy->cpus) { for_each_cpu(k, policy->cpus) {
if (!cpu_online(k)) if (!cpu_online(k))
continue; continue;
freqs.cpu = k; freqs.cpu = k;
@ -586,7 +586,7 @@ static int centrino_target (struct cpufreq_policy *policy,
tmp = freqs.new; tmp = freqs.new;
freqs.new = freqs.old; freqs.new = freqs.old;
freqs.old = tmp; freqs.old = tmp;
for_each_cpu_mask_nr(j, policy->cpus) { for_each_cpu(j, policy->cpus) {
if (!cpu_online(j)) if (!cpu_online(j))
continue; continue;
cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE); cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);

18
arch/x86/kernel/cpu/cpufreq/speedstep-ich.c
View File

@ -229,7 +229,7 @@ static unsigned int speedstep_detect_chipset (void)
return 0; return 0;
} }
static unsigned int _speedstep_get(const cpumask_t *cpus) static unsigned int _speedstep_get(const struct cpumask *cpus)
{ {
unsigned int speed; unsigned int speed;
cpumask_t cpus_allowed; 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) 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)) if (cpufreq_frequency_table_target(policy, &speedstep_freqs[0], target_freq, relation, &newstate))
return -EINVAL; return -EINVAL;
freqs.old = _speedstep_get(&policy->cpus); freqs.old = _speedstep_get(policy->cpus);
freqs.new = speedstep_freqs[newstate].frequency; freqs.new = speedstep_freqs[newstate].frequency;
freqs.cpu = policy->cpu; freqs.cpu = policy->cpu;
@ -279,20 +279,20 @@ static int speedstep_target (struct cpufreq_policy *policy,
cpus_allowed = current->cpus_allowed; cpus_allowed = current->cpus_allowed;
for_each_cpu_mask_nr(i, policy->cpus) { for_each_cpu(i, policy->cpus) {
freqs.cpu = i; freqs.cpu = i;
cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE); cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
} }
/* switch to physical CPU where state is to be changed */ /* 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); speedstep_set_state(newstate);
/* allow to be run on all CPUs */ /* allow to be run on all CPUs */
set_cpus_allowed_ptr(current, &cpus_allowed); set_cpus_allowed_ptr(current, &cpus_allowed);
for_each_cpu_mask_nr(i, policy->cpus) { for_each_cpu(i, policy->cpus) {
freqs.cpu = i; freqs.cpu = i;
cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE); 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 */ /* only run on CPU to be set, or on its sibling */
#ifdef CONFIG_SMP #ifdef CONFIG_SMP
policy->cpus = per_cpu(cpu_sibling_map, policy->cpu); cpumask_copy(policy->cpus, &per_cpu(cpu_sibling_map, policy->cpu));
#endif #endif
cpus_allowed = current->cpus_allowed; 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 */ /* detect low and high frequency and transition latency */
result = speedstep_get_freqs(speedstep_processor, result = speedstep_get_freqs(speedstep_processor,
@ -339,7 +339,7 @@ static int speedstep_cpu_init(struct cpufreq_policy *policy)
return result; return result;
/* get current speed setting */ /* get current speed setting */
speed = _speedstep_get(&policy->cpus); speed = _speedstep_get(policy->cpus);
if (!speed) if (!speed)
return -EIO; return -EIO;

42
drivers/cpufreq/cpufreq.c
View File

@ -584,12 +584,12 @@ out:
return i; 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; ssize_t i = 0;
unsigned int cpu; unsigned int cpu;
for_each_cpu_mask_nr(cpu, mask) { for_each_cpu(cpu, mask) {
if (i) if (i)
i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), " "); i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), " ");
i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), "%u", cpu); 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) 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->cpus, buf);
return show_cpus(policy->related_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; ret = -ENOMEM;
goto nomem_out; 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->cpu = cpu;
policy->cpus = cpumask_of_cpu(cpu); cpumask_copy(policy->cpus, cpumask_of(cpu));
/* Initially set CPU itself as the policy_cpu */ /* Initially set CPU itself as the policy_cpu */
per_cpu(policy_cpu, cpu) = cpu; per_cpu(policy_cpu, cpu) = cpu;
@ -843,7 +854,7 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
} }
#endif #endif
for_each_cpu_mask_nr(j, policy->cpus) { for_each_cpu(j, policy->cpus) {
if (cpu == j) if (cpu == j)
continue; continue;
@ -861,7 +872,7 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
goto err_out_driver_exit; goto err_out_driver_exit;
spin_lock_irqsave(&cpufreq_driver_lock, flags); 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; per_cpu(cpufreq_cpu_data, cpu) = managed_policy;
spin_unlock_irqrestore(&cpufreq_driver_lock, flags); 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); 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(cpufreq_cpu_data, j) = policy;
per_cpu(policy_cpu, j) = policy->cpu; per_cpu(policy_cpu, j) = policy->cpu;
} }
spin_unlock_irqrestore(&cpufreq_driver_lock, flags); spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
/* symlink affected CPUs */ /* symlink affected CPUs */
for_each_cpu_mask_nr(j, policy->cpus) { for_each_cpu(j, policy->cpus) {
if (j == cpu) if (j == cpu)
continue; continue;
if (!cpu_online(j)) if (!cpu_online(j))
@ -963,7 +974,7 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
err_out_unregister: err_out_unregister:
spin_lock_irqsave(&cpufreq_driver_lock, flags); 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; per_cpu(cpufreq_cpu_data, j) = NULL;
spin_unlock_irqrestore(&cpufreq_driver_lock, flags); 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)) { if (unlikely(cpu != data->cpu)) {
dprintk("removing link\n"); dprintk("removing link\n");
cpu_clear(cpu, data->cpus); cpumask_clear_cpu(cpu, data->cpus);
spin_unlock_irqrestore(&cpufreq_driver_lock, flags); spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
sysfs_remove_link(&sys_dev->kobj, "cpufreq"); sysfs_remove_link(&sys_dev->kobj, "cpufreq");
cpufreq_cpu_put(data); 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 * per_cpu(cpufreq_cpu_data) while holding the lock, and remove
* the sysfs links afterwards. * the sysfs links afterwards.
*/ */
if (unlikely(cpus_weight(data->cpus) > 1)) { if (unlikely(cpumask_weight(data->cpus) > 1)) {
for_each_cpu_mask_nr(j, data->cpus) { for_each_cpu(j, data->cpus) {
if (j == cpu) if (j == cpu)
continue; continue;
per_cpu(cpufreq_cpu_data, j) = NULL; 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); spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
if (unlikely(cpus_weight(data->cpus) > 1)) { if (unlikely(cpumask_weight(data->cpus) > 1)) {
for_each_cpu_mask_nr(j, data->cpus) { for_each_cpu(j, data->cpus) {
if (j == cpu) if (j == cpu)
continue; continue;
dprintk("removing link for cpu %u\n", j); 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) if (cpufreq_driver->exit)
cpufreq_driver->exit(data); cpufreq_driver->exit(data);
free_cpumask_var(data->related_cpus);
free_cpumask_var(data->cpus);
kfree(data); kfree(data);
per_cpu(cpufreq_cpu_data, cpu) = NULL;
cpufreq_debug_enable_ratelimit(); cpufreq_debug_enable_ratelimit();
return 0; return 0;

2
drivers/cpufreq/cpufreq_conservative.c
View File

@ -498,7 +498,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
return rc; return rc;
} }
for_each_cpu_mask_nr(j, policy->cpus) { for_each_cpu(j, policy->cpus) {
struct cpu_dbs_info_s *j_dbs_info; struct cpu_dbs_info_s *j_dbs_info;
j_dbs_info = &per_cpu(cpu_dbs_info, j); j_dbs_info = &per_cpu(cpu_dbs_info, j);
j_dbs_info->cur_policy = policy; j_dbs_info->cur_policy = policy;

4
drivers/cpufreq/cpufreq_ondemand.c
View File

@ -400,7 +400,7 @@ static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info)
/* Get Absolute Load - in terms of freq */ /* Get Absolute Load - in terms of freq */
max_load_freq = 0; 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; struct cpu_dbs_info_s *j_dbs_info;
cputime64_t cur_wall_time, cur_idle_time; cputime64_t cur_wall_time, cur_idle_time;
unsigned int idle_time, wall_time; unsigned int idle_time, wall_time;
@ -568,7 +568,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
return rc; return rc;
} }
for_each_cpu_mask_nr(j, policy->cpus) { for_each_cpu(j, policy->cpus) {
struct cpu_dbs_info_s *j_dbs_info; struct cpu_dbs_info_s *j_dbs_info;
j_dbs_info = &per_cpu(cpu_dbs_info, j); j_dbs_info = &per_cpu(cpu_dbs_info, j);
j_dbs_info->cur_policy = policy; j_dbs_info->cur_policy = policy;

4
include/linux/cpufreq.h
View File

@ -80,8 +80,8 @@ struct cpufreq_real_policy {
}; };
struct cpufreq_policy { struct cpufreq_policy {
cpumask_t cpus; /* CPUs requiring sw coordination */ cpumask_var_t cpus; /* CPUs requiring sw coordination */
cpumask_t related_cpus; /* CPUs with any coordination */ cpumask_var_t related_cpus; /* CPUs with any coordination */
unsigned int shared_type; /* ANY or ALL affected CPUs unsigned int shared_type; /* ANY or ALL affected CPUs
should set cpufreq */ should set cpufreq */
unsigned int cpu; /* cpu nr of registered CPU */ unsigned int cpu; /* cpu nr of registered CPU */