cpumask: for_each_cpu(): for_each_cpu_mask which takes a pointer We want to wean people off handing around cpumask_t's, and have them pass by pointer instead. This does for_each_cpu_mask(). We immediately convert those files who were doing "for_each_cpu_mask(... *mask)" since this is clearer. Signed-off-by: Rusty Russell --- include/linux/cpumask.h | 15 ++++++++------- kernel/sched.c | 40 ++++++++++++++++++++-------------------- kernel/workqueue.c | 6 +++--- lib/cpumask.c | 2 +- mm/allocpercpu.c | 4 ++-- mm/vmstat.c | 2 +- 6 files changed, 35 insertions(+), 34 deletions(-) diff -r 5e0c063f7022 include/linux/cpumask.h --- a/include/linux/cpumask.h Thu Oct 02 16:08:09 2008 +1000 +++ b/include/linux/cpumask.h Thu Oct 02 16:10:26 2008 +1000 @@ -96,7 +96,7 @@ * void cpumask_onto(dst, orig, relmap) *dst = orig relative to relmap * void cpumask_fold(dst, orig, sz) dst bits = orig bits mod sz * - * for_each_cpu_mask(cpu, mask) for-loop cpu over mask using nr_cpu_ids + * for_each_cpu(cpu, mask) for-loop cpu over mask using nr_cpu_ids * * int num_online_cpus() Number of online CPUs * int num_possible_cpus() Number of all possible CPUs @@ -174,6 +174,7 @@ extern cpumask_t _unused_cpumask_arg_; #define cpus_weight_nr(cpumask) cpus_weight(cpumask) #define for_each_cpu_mask_nr(cpu, mask) for_each_cpu_mask(cpu, mask) #define cpumask_of_cpu(cpu) (*cpumask_of(cpu)) +#define for_each_cpu_mask(cpu, mask) for_each_cpu(cpu, &(mask)) /* End deprecated region. */ #if NR_CPUS <= BITS_PER_LONG @@ -413,7 +414,7 @@ extern const struct cpumask cpu_mask_all #define first_cpu(src) ({ (void)(src); 0; }) #define next_cpu(n, src) ({ (void)(src); 1; }) #define any_online_cpu(mask) 0 -#define for_each_cpu_mask(cpu, mask) \ +#define for_each_cpu(cpu, mask) \ for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask) #else /* NR_CPUS > 1 */ @@ -425,9 +426,9 @@ int __any_online_cpu(const cpumask_t *ma #define first_cpu(src) __first_cpu(&(src)) #define next_cpu(n, src) __next_cpu((n), &(src)) #define any_online_cpu(mask) __any_online_cpu(&(mask)) -#define for_each_cpu_mask(cpu, mask) \ +#define for_each_cpu(cpu, mask) \ for ((cpu) = -1; \ - (cpu) = next_cpu((cpu), (mask)), \ + (cpu) = __next_cpu((cpu), (mask)), \ (cpu) < nr_cpu_ids; ) #endif @@ -557,9 +558,9 @@ extern cpumask_t cpu_active_map; #define cpu_is_offline(cpu) unlikely(!cpu_online(cpu)) -#define for_each_possible_cpu(cpu) for_each_cpu_mask((cpu), cpu_possible_map) -#define for_each_online_cpu(cpu) for_each_cpu_mask((cpu), cpu_online_map) -#define for_each_present_cpu(cpu) for_each_cpu_mask((cpu), cpu_present_map) +#define for_each_possible_cpu(cpu) for_each_cpu((cpu), &cpu_possible_map) +#define for_each_online_cpu(cpu) for_each_cpu((cpu), &cpu_online_map) +#define for_each_present_cpu(cpu) for_each_cpu((cpu), &cpu_present_map) /* Arch-specific code may call this to initialize nr_cpu_ids based on * the cpu_possible_map. */ diff -r 5e0c063f7022 kernel/sched.c --- a/kernel/sched.c Thu Oct 02 16:08:09 2008 +1000 +++ b/kernel/sched.c Thu Oct 02 16:10:26 2008 +1000 @@ -1493,7 +1493,7 @@ tg_shares_up(struct task_group *tg, int unsigned long shares = 0; int i; - for_each_cpu_mask(i, sd->span) { + for_each_cpu(i, &sd->span) { rq_weight += tg->cfs_rq[i]->load.weight; shares += tg->cfs_rq[i]->shares; } @@ -1507,7 +1507,7 @@ tg_shares_up(struct task_group *tg, int if (!rq_weight) rq_weight = cpus_weight(sd->span) * NICE_0_LOAD; - for_each_cpu_mask(i, sd->span) { + for_each_cpu(i, &sd->span) { struct rq *rq = cpu_rq(i); unsigned long flags; @@ -2053,7 +2053,7 @@ find_idlest_group(struct sched_domain *s /* Tally up the load of all CPUs in the group */ avg_load = 0; - for_each_cpu_mask_nr(i, group->cpumask) { + for_each_cpu(i, &group->cpumask) { /* Bias balancing toward cpus of our domain */ if (local_group) load = source_load(i, load_idx); @@ -2095,7 +2095,7 @@ find_idlest_cpu(struct sched_group *grou /* Traverse only the allowed CPUs */ cpus_and(*tmp, group->cpumask, p->cpus_allowed); - for_each_cpu_mask_nr(i, *tmp) { + for_each_cpu(i, tmp) { load = weighted_cpuload(i); if (load < min_load || (load == min_load && i == this_cpu)) { @@ -3120,7 +3120,7 @@ find_busiest_group(struct sched_domain * max_cpu_load = 0; min_cpu_load = ~0UL; - for_each_cpu_mask_nr(i, group->cpumask) { + for_each_cpu(i, &group->cpumask) { struct rq *rq; if (!cpu_isset(i, *cpus)) @@ -3399,7 +3399,7 @@ find_busiest_queue(struct sched_group *g unsigned long max_load = 0; int i; - for_each_cpu_mask_nr(i, group->cpumask) { + for_each_cpu(i, &group->cpumask) { unsigned long wl; if (!cpu_isset(i, *cpus)) @@ -3941,7 +3941,7 @@ static void run_rebalance_domains(struct int balance_cpu; cpu_clear(this_cpu, cpus); - for_each_cpu_mask_nr(balance_cpu, cpus) { + for_each_cpu(balance_cpu, &cpus) { /* * If this cpu gets work to do, stop the load balancing * work being done for other cpus. Next load @@ -6866,7 +6866,7 @@ init_sched_build_groups(const cpumask_t cpus_clear(*covered); - for_each_cpu_mask_nr(i, *span) { + for_each_cpu(i, span) { struct sched_group *sg; int group = group_fn(i, cpu_map, &sg, tmpmask); int j; @@ -6877,7 +6877,7 @@ init_sched_build_groups(const cpumask_t cpus_clear(sg->cpumask); sg->__cpu_power = 0; - for_each_cpu_mask_nr(j, *span) { + for_each_cpu(j, span) { if (group_fn(j, cpu_map, NULL, tmpmask) != group) continue; @@ -7077,7 +7077,7 @@ static void init_numa_sched_groups_power if (!sg) return; do { - for_each_cpu_mask_nr(j, sg->cpumask) { + for_each_cpu(j, &sg->cpumask) { struct sched_domain *sd; sd = &per_cpu(phys_domains, j); @@ -7102,7 +7102,7 @@ static void free_sched_groups(const cpum { int cpu, i; - for_each_cpu_mask_nr(cpu, *cpu_map) { + for_each_cpu(cpu, cpu_map) { struct sched_group **sched_group_nodes = sched_group_nodes_bycpu[cpu]; @@ -7341,7 +7341,7 @@ static int __build_sched_domains(const c /* * Set up domains for cpus specified by the cpu_map. */ - for_each_cpu_mask_nr(i, *cpu_map) { + for_each_cpu(i, cpu_map) { struct sched_domain *sd = NULL, *p; SCHED_CPUMASK_VAR(nodemask, allmasks); @@ -7408,7 +7408,7 @@ static int __build_sched_domains(const c #ifdef CONFIG_SCHED_SMT /* Set up CPU (sibling) groups */ - for_each_cpu_mask_nr(i, *cpu_map) { + for_each_cpu(i, cpu_map) { SCHED_CPUMASK_VAR(this_sibling_map, allmasks); SCHED_CPUMASK_VAR(send_covered, allmasks); @@ -7425,7 +7425,7 @@ static int __build_sched_domains(const c #ifdef CONFIG_SCHED_MC /* Set up multi-core groups */ - for_each_cpu_mask_nr(i, *cpu_map) { + for_each_cpu(i, cpu_map) { SCHED_CPUMASK_VAR(this_core_map, allmasks); SCHED_CPUMASK_VAR(send_covered, allmasks); @@ -7492,7 +7492,7 @@ static int __build_sched_domains(const c goto error; } sched_group_nodes[i] = sg; - for_each_cpu_mask_nr(j, *nodemask) { + for_each_cpu(j, nodemask) { struct sched_domain *sd; sd = &per_cpu(node_domains, j); @@ -7538,21 +7538,21 @@ static int __build_sched_domains(const c /* Calculate CPU power for physical packages and nodes */ #ifdef CONFIG_SCHED_SMT - for_each_cpu_mask_nr(i, *cpu_map) { + for_each_cpu(i, cpu_map) { struct sched_domain *sd = &per_cpu(cpu_domains, i); init_sched_groups_power(i, sd); } #endif #ifdef CONFIG_SCHED_MC - for_each_cpu_mask_nr(i, *cpu_map) { + for_each_cpu(i, cpu_map) { struct sched_domain *sd = &per_cpu(core_domains, i); init_sched_groups_power(i, sd); } #endif - for_each_cpu_mask_nr(i, *cpu_map) { + for_each_cpu(i, cpu_map) { struct sched_domain *sd = &per_cpu(phys_domains, i); init_sched_groups_power(i, sd); @@ -7572,7 +7572,7 @@ static int __build_sched_domains(const c #endif /* Attach the domains */ - for_each_cpu_mask_nr(i, *cpu_map) { + for_each_cpu(i, cpu_map) { struct sched_domain *sd; #ifdef CONFIG_SCHED_SMT sd = &per_cpu(cpu_domains, i); @@ -7655,7 +7655,7 @@ static void detach_destroy_domains(const unregister_sched_domain_sysctl(); - for_each_cpu_mask_nr(i, *cpu_map) + for_each_cpu(i, cpu_map) cpu_attach_domain(NULL, &def_root_domain, i); synchronize_sched(); arch_destroy_sched_domains(cpu_map, &tmpmask); diff -r 5e0c063f7022 kernel/workqueue.c --- a/kernel/workqueue.c Thu Oct 02 16:08:09 2008 +1000 +++ b/kernel/workqueue.c Thu Oct 02 16:10:26 2008 +1000 @@ -415,7 +415,7 @@ void flush_workqueue(struct workqueue_st might_sleep(); lock_map_acquire(&wq->lockdep_map); lock_map_release(&wq->lockdep_map); - for_each_cpu_mask_nr(cpu, *cpu_map) + for_each_cpu(cpu, cpu_map) flush_cpu_workqueue(per_cpu_ptr(wq->cpu_wq, cpu)); } EXPORT_SYMBOL_GPL(flush_workqueue); @@ -546,7 +546,7 @@ static void wait_on_work(struct work_str wq = cwq->wq; cpu_map = wq_cpu_map(wq); - for_each_cpu_mask_nr(cpu, *cpu_map) + for_each_cpu(cpu, cpu_map) wait_on_cpu_work(per_cpu_ptr(wq->cpu_wq, cpu), work); } @@ -906,7 +906,7 @@ void destroy_workqueue(struct workqueue_ list_del(&wq->list); spin_unlock(&workqueue_lock); - for_each_cpu_mask_nr(cpu, *cpu_map) + for_each_cpu(cpu, cpu_map) cleanup_workqueue_thread(per_cpu_ptr(wq->cpu_wq, cpu)); cpu_maps_update_done(); diff -r 5e0c063f7022 lib/cpumask.c --- a/lib/cpumask.c Thu Oct 02 16:08:09 2008 +1000 +++ b/lib/cpumask.c Thu Oct 02 16:10:26 2008 +1000 @@ -19,7 +19,7 @@ int __any_online_cpu(const cpumask_t *ma { int cpu; - for_each_cpu_mask(cpu, *mask) { + for_each_cpu(cpu, mask) { if (cpu_online(cpu)) break; } diff -r 5e0c063f7022 mm/allocpercpu.c --- a/mm/allocpercpu.c Thu Oct 02 16:08:09 2008 +1000 +++ b/mm/allocpercpu.c Thu Oct 02 16:10:26 2008 +1000 @@ -34,7 +34,7 @@ static void __percpu_depopulate_mask(voi static void __percpu_depopulate_mask(void *__pdata, cpumask_t *mask) { int cpu; - for_each_cpu_mask_nr(cpu, *mask) + for_each_cpu(cpu, mask) percpu_depopulate(__pdata, cpu); } @@ -86,7 +86,7 @@ static int __percpu_populate_mask(void * int cpu; cpus_clear(populated); - for_each_cpu_mask_nr(cpu, *mask) + for_each_cpu(cpu, mask) if (unlikely(!percpu_populate(__pdata, size, gfp, cpu))) { __percpu_depopulate_mask(__pdata, &populated); return -ENOMEM; diff -r 5e0c063f7022 mm/vmstat.c --- a/mm/vmstat.c Thu Oct 02 16:08:09 2008 +1000 +++ b/mm/vmstat.c Thu Oct 02 16:10:26 2008 +1000 @@ -27,7 +27,7 @@ static void sum_vm_events(unsigned long memset(ret, 0, NR_VM_EVENT_ITEMS * sizeof(unsigned long)); - for_each_cpu_mask_nr(cpu, *cpumask) { + for_each_cpu(cpu, cpumask) { struct vm_event_state *this = &per_cpu(vm_event_states, cpu); for (i = 0; i < NR_VM_EVENT_ITEMS; i++)