Re: [PATCH 5/8] cpumask: convert rest of files in kernel/

Lai Jiangshan
2008-12-20T01:37:43Z

CC: Paul E. McKenney <paulmck@linux.vnet.ibm.com>

Mike Travis wrote:
> Impact: Reduce stack usage, use new cpumask API. ALPHA mod!
>
> A couple of uses of cpumask_any_but() here to avoid temporary cpumasks
> and carry the "const" modifier through the seq_cpumask() function all the
> way to bitmap_scnprintf().
>
> Note that prof_cpu_mask will be difficult to convert to a cpumask_var_t
> since it needs to be ready from the first scheduler tick.
>
> Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
> Signed-off-by: Mike Travis <travis@sgi.com>
> Cc: Dipankar Sarma <dipankar@in.ibm.com>
> Cc: H. Peter Anvin <hpa@zytor.com>
> Cc: Lai Jiangshan <laijs@cn.fujitsu.com>
> Cc: Max Krasnyansky <maxk@qualcomm.com>
> Cc: Richard Henderson <rth@twiddle.net>
> Cc: Thomas Gleixner <tglx@linutronix.de>
> Cc: Yinghai Lu <yinghai@kernel.org>
> ---
> arch/alpha/kernel/irq.c | 3 ++-
> fs/seq_file.c | 3 ++-
> include/linux/interrupt.h | 2 +-
> include/linux/rcuclassic.h | 4 ++--
> include/linux/seq_file.h | 5 +++--
> include/linux/stop_machine.h | 6 +++---
> kernel/cpu.c | 40 +++++++++++++++++++++-------------------
> kernel/irq/manage.c | 11 +++++++++--
> kernel/irq/proc.c | 32 +++++++++++++++++++++-----------
> kernel/power/poweroff.c | 2 +-
> kernel/profile.c | 31 ++++++++++++++++++-------------
> kernel/rcuclassic.c | 32 +++++++++++++++++---------------
> kernel/rcupreempt.c | 19 ++++++++++---------
> kernel/rcutorture.c | 27 +++++++++++++++------------
> kernel/softlockup.c | 6 ++----
> kernel/stop_machine.c | 8 ++++----
> kernel/taskstats.c | 39 ++++++++++++++++++++++++---------------
> 17 files changed, 155 insertions(+), 115 deletions(-)
>
> --- linux-2.6-for-ingo.orig/arch/alpha/kernel/irq.c
> +++ linux-2.6-for-ingo/arch/alpha/kernel/irq.c
> @@ -50,7 +50,8 @@ int irq_select_affinity(unsigned int irq
> if (!irq_desc[irq].chip->set_affinity || irq_user_affinity[irq])
> return 1;
>
> - while (!cpu_possible(cpu) || !cpu_isset(cpu, irq_default_affinity))
> + while (!cpu_possible(cpu) ||
> + !cpumask_test_cpu(cpu, irq_default_affinity))
> cpu = (cpu < (NR_CPUS-1) ? cpu + 1 : 0);
> last_cpu = cpu;
>
> --- linux-2.6-for-ingo.orig/fs/seq_file.c
> +++ linux-2.6-for-ingo/fs/seq_file.c
> @@ -462,7 +462,8 @@ int seq_dentry(struct seq_file *m, struc
> return -1;
> }
>
> -int seq_bitmap(struct seq_file *m, unsigned long *bits, unsigned int nr_bits)
> +int seq_bitmap(struct seq_file *m, const unsigned long *bits,
> + unsigned int nr_bits)
> {
> if (m->count < m->size) {
> int len = bitmap_scnprintf(m->buf + m->count,
> --- linux-2.6-for-ingo.orig/include/linux/interrupt.h
> +++ linux-2.6-for-ingo/include/linux/interrupt.h
> @@ -109,7 +109,7 @@ extern void enable_irq(unsigned int irq)
>
> #if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_HARDIRQS)
>
> -extern cpumask_t irq_default_affinity;
> +extern cpumask_var_t irq_default_affinity;
>
> extern int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask);
> extern int irq_can_set_affinity(unsigned int irq);
> --- linux-2.6-for-ingo.orig/include/linux/rcuclassic.h
> +++ linux-2.6-for-ingo/include/linux/rcuclassic.h
> @@ -59,8 +59,8 @@ struct rcu_ctrlblk {
> int signaled;
>
> spinlock_t lock ____cacheline_internodealigned_in_smp;
> - cpumask_t cpumask; /* CPUs that need to switch in order */
> - /* for current batch to proceed. */
> + DECLARE_BITMAP(cpumask, NR_CPUS); /* CPUs that need to switch for */
> + /* current batch to proceed. */
> } ____cacheline_internodealigned_in_smp;
>
> /* Is batch a before batch b ? */
> --- linux-2.6-for-ingo.orig/include/linux/seq_file.h
> +++ linux-2.6-for-ingo/include/linux/seq_file.h
> @@ -50,8 +50,9 @@ int seq_path(struct seq_file *, struct p
> int seq_dentry(struct seq_file *, struct dentry *, char *);
> int seq_path_root(struct seq_file *m, struct path *path, struct path *root,
> char *esc);
> -int seq_bitmap(struct seq_file *m, unsigned long *bits, unsigned int nr_bits);
> -static inline int seq_cpumask(struct seq_file *m, cpumask_t *mask)
> +int seq_bitmap(struct seq_file *m, const unsigned long *bits,
> + unsigned int nr_bits);
> +static inline int seq_cpumask(struct seq_file *m, const struct cpumask *mask)
> {
> return seq_bitmap(m, mask->bits, NR_CPUS);
> }
> --- linux-2.6-for-ingo.orig/include/linux/stop_machine.h
> +++ linux-2.6-for-ingo/include/linux/stop_machine.h
> @@ -23,7 +23,7 @@
> *
> * This can be thought of as a very heavy write lock, equivalent to
> * grabbing every spinlock in the kernel. */
> -int stop_machine(int (*fn)(void *), void *data, const cpumask_t *cpus);
> +int stop_machine(int (*fn)(void *), void *data, const struct cpumask *cpus);
>
> /**
> * __stop_machine: freeze the machine on all CPUs and run this function
> @@ -34,11 +34,11 @@ int stop_machine(int (*fn)(void *), void
> * Description: This is a special version of the above, which assumes cpus
> * won't come or go while it's being called. Used by hotplug cpu.
> */
> -int __stop_machine(int (*fn)(void *), void *data, const cpumask_t *cpus);
> +int __stop_machine(int (*fn)(void *), void *data, const struct cpumask *cpus);
> #else
>
> static inline int stop_machine(int (*fn)(void *), void *data,
> - const cpumask_t *cpus)
> + const struct cpumask *cpus)
> {
> int ret;
> local_irq_disable();
> --- linux-2.6-for-ingo.orig/kernel/cpu.c
> +++ linux-2.6-for-ingo/kernel/cpu.c
> @@ -218,7 +218,7 @@ static int __ref take_cpu_down(void *_pa
> static int __ref _cpu_down(unsigned int cpu, int tasks_frozen)
> {
> int err, nr_calls = 0;
> - cpumask_t old_allowed, tmp;
> + cpumask_var_t old_allowed;
> void *hcpu = (void *)(long)cpu;
> unsigned long mod = tasks_frozen ? CPU_TASKS_FROZEN : 0;
> struct take_cpu_down_param tcd_param = {
> @@ -232,6 +232,9 @@ static int __ref _cpu_down(unsigned int
> if (!cpu_online(cpu))
> return -EINVAL;
>
> + if (!alloc_cpumask_var(&old_allowed, GFP_KERNEL))
> + return -ENOMEM;
> +
> cpu_hotplug_begin();
> err = __raw_notifier_call_chain(&cpu_chain, CPU_DOWN_PREPARE | mod,
> hcpu, -1, &nr_calls);
> @@ -246,13 +249,11 @@ static int __ref _cpu_down(unsigned int
> }
>
> /* Ensure that we are not runnable on dying cpu */
> - old_allowed = current->cpus_allowed;
> - cpus_setall(tmp);
> - cpu_clear(cpu, tmp);
> - set_cpus_allowed_ptr(current, &tmp);
> - tmp = cpumask_of_cpu(cpu);
> + cpumask_copy(old_allowed, &current->cpus_allowed);
> + set_cpus_allowed_ptr(current,
> + cpumask_of(cpumask_any_but(cpu_online_mask, cpu)));
>
> - err = __stop_machine(take_cpu_down, &tcd_param, &tmp);
> + err = __stop_machine(take_cpu_down, &tcd_param, cpumask_of(cpu));
> if (err) {
> /* CPU didn't die: tell everyone. Can't complain. */
> if (raw_notifier_call_chain(&cpu_chain, CPU_DOWN_FAILED | mod,
> @@ -278,7 +279,7 @@ static int __ref _cpu_down(unsigned int
> check_for_tasks(cpu);
>
> out_allowed:
> - set_cpus_allowed_ptr(current, &old_allowed);
> + set_cpus_allowed_ptr(current, old_allowed);
> out_release:
> cpu_hotplug_done();
> if (!err) {
> @@ -286,6 +287,7 @@ out_release:
> hcpu) == NOTIFY_BAD)
> BUG();
> }
> + free_cpumask_var(old_allowed);
> return err;
> }
>
> @@ -304,7 +306,7 @@ int __ref cpu_down(unsigned int cpu)
>
> /*
> * Make sure the all cpus did the reschedule and are not
> - * using stale version of the cpu_active_map.
> + * using stale version of the cpu_active_mask.
> * This is not strictly necessary becuase stop_machine()
> * that we run down the line already provides the required
> * synchronization. But it's really a side effect and we do not
> @@ -368,7 +370,7 @@ out_notify:
> int __cpuinit cpu_up(unsigned int cpu)
> {
> int err = 0;
> - if (!cpu_isset(cpu, cpu_possible_map)) {
> + if (!cpu_possible(cpu)) {
> printk(KERN_ERR "can't online cpu %d because it is not "
> "configured as may-hotadd at boot time\n", cpu);
> #if defined(CONFIG_IA64) || defined(CONFIG_X86_64)
> @@ -393,25 +395,25 @@ out:
> }
>
> #ifdef CONFIG_PM_SLEEP_SMP
> -static cpumask_t frozen_cpus;
> +static DECLARE_BITMAP(frozen_cpus, CONFIG_NR_CPUS);
>
> int disable_nonboot_cpus(void)
> {
> int cpu, first_cpu, error = 0;
>
> cpu_maps_update_begin();
> - first_cpu = first_cpu(cpu_online_map);
> + first_cpu = cpumask_first(cpu_online_mask);
> /* We take down all of the non-boot CPUs in one shot to avoid races
> * with the userspace trying to use the CPU hotplug at the same time
> */
> - cpus_clear(frozen_cpus);
> + cpumask_clear(to_cpumask(frozen_cpus));
> printk("Disabling non-boot CPUs ...\n");
> for_each_online_cpu(cpu) {
> if (cpu == first_cpu)
> continue;
> error = _cpu_down(cpu, 1);
> if (!error) {
> - cpu_set(cpu, frozen_cpus);
> + cpumask_set_cpu(cpu, to_cpumask(frozen_cpus));
> printk("CPU%d is down\n", cpu);
> } else {
> printk(KERN_ERR "Error taking CPU%d down: %d\n",
> @@ -437,11 +439,11 @@ void __ref enable_nonboot_cpus(void)
> /* Allow everyone to use the CPU hotplug again */
> cpu_maps_update_begin();
> cpu_hotplug_disabled = 0;
> - if (cpus_empty(frozen_cpus))
> + if (cpumask_empty(to_cpumask(frozen_cpus)))
> goto out;
>
> printk("Enabling non-boot CPUs ...\n");
> - for_each_cpu_mask_nr(cpu, frozen_cpus) {
> + for_each_cpu(cpu, to_cpumask(frozen_cpus)) {
> error = _cpu_up(cpu, 1);
> if (!error) {
> printk("CPU%d is up\n", cpu);
> @@ -449,7 +451,7 @@ void __ref enable_nonboot_cpus(void)
> }
> printk(KERN_WARNING "Error taking CPU%d up: %d\n", cpu, error);
> }
> - cpus_clear(frozen_cpus);
> + cpumask_clear(to_cpumask(frozen_cpus));
> out:
> cpu_maps_update_done();
> }
> @@ -468,7 +470,7 @@ void __cpuinit notify_cpu_starting(unsig
> unsigned long val = CPU_STARTING;
>
> #ifdef CONFIG_PM_SLEEP_SMP
> - if (cpu_isset(cpu, frozen_cpus))
> + if (cpumask_test_cpu(cpu, to_cpumask(frozen_cpus)))
> val = CPU_STARTING_FROZEN;
> #endif /* CONFIG_PM_SLEEP_SMP */
> raw_notifier_call_chain(&cpu_chain, val, (void *)(long)cpu);
> @@ -480,7 +482,7 @@ void __cpuinit notify_cpu_starting(unsig
> * cpu_bit_bitmap[] is a special, "compressed" data structure that
> * represents all NR_CPUS bits binary values of 1<<nr.
> *
> - * It is used by cpumask_of_cpu() to get a constant address to a CPU
> + * It is used by cpumask_of() to get a constant address to a CPU
> * mask value that has a single bit set only.
> */
>
> --- linux-2.6-for-ingo.orig/kernel/irq/manage.c
> +++ linux-2.6-for-ingo/kernel/irq/manage.c
> @@ -16,8 +16,15 @@
> #include "internals.h"
>
> #ifdef CONFIG_SMP
> +cpumask_var_t irq_default_affinity;
>
> -cpumask_t irq_default_affinity = CPU_MASK_ALL;
> +static int init_irq_default_affinity(void)
> +{
> + alloc_cpumask_var(&irq_default_affinity, GFP_KERNEL);
> + cpumask_setall(irq_default_affinity);
> + return 0;
> +}
> +core_initcall(init_irq_default_affinity);
>
> /**
> * synchronize_irq - wait for pending IRQ handlers (on other CPUs)
> @@ -127,7 +134,7 @@ int do_irq_select_affinity(unsigned int
> desc->status &= ~IRQ_AFFINITY_SET;
> }
>
> - cpumask_and(&desc->affinity, cpu_online_mask, &irq_default_affinity);
> + cpumask_and(&desc->affinity, cpu_online_mask, irq_default_affinity);
> set_affinity:
> desc->chip->set_affinity(irq, &desc->affinity);
>
> --- linux-2.6-for-ingo.orig/kernel/irq/proc.c
> +++ linux-2.6-for-ingo/kernel/irq/proc.c
> @@ -20,7 +20,7 @@ static struct proc_dir_entry *root_irq_d
> static int irq_affinity_proc_show(struct seq_file *m, void *v)
> {
> struct irq_desc *desc = irq_to_desc((long)m->private);
> - cpumask_t *mask = &desc->affinity;
> + const struct cpumask *mask = &desc->affinity;
>
> #ifdef CONFIG_GENERIC_PENDING_IRQ
> if (desc->status & IRQ_MOVE_PENDING)
> @@ -93,7 +93,7 @@ static const struct file_operations irq_
>
> static int default_affinity_show(struct seq_file *m, void *v)
> {
> - seq_cpumask(m, &irq_default_affinity);
> + seq_cpumask(m, irq_default_affinity);
> seq_putc(m, '\n');
> return 0;
> }
> @@ -101,27 +101,37 @@ static int default_affinity_show(struct
> static ssize_t default_affinity_write(struct file *file,
> const char __user *buffer, size_t count, loff_t *ppos)
> {
> - cpumask_t new_value;
> + cpumask_var_t new_value;
> int err;
>
> - err = cpumask_parse_user(buffer, count, &new_value);
> + if (!alloc_cpumask_var(&new_value, GFP_KERNEL))
> + return -ENOMEM;
> +
> + err = cpumask_parse_user(buffer, count, new_value);
> if (err)
> - return err;
> + goto out;
>
> - if (!is_affinity_mask_valid(new_value))
> - return -EINVAL;
> + if (!is_affinity_mask_valid(new_value)) {
> + err = -EINVAL;
> + goto out;
> + }
>
> /*
> * Do not allow disabling IRQs completely - it's a too easy
> * way to make the system unusable accidentally :-) At least
> * one online CPU still has to be targeted.
> */
> - if (!cpus_intersects(new_value, cpu_online_map))
> - return -EINVAL;
> + if (!cpumask_intersects(new_value, cpu_online_mask)) {
> + err = -EINVAL;
> + goto out;
> + }
>
> - irq_default_affinity = new_value;
> + cpumask_copy(irq_default_affinity, new_value);
> + err = count;
>
> - return count;
> +out:
> + free_cpumask_var(new_value);
> + return err;
> }
>
> static int default_affinity_open(struct inode *inode, struct file *file)
> --- linux-2.6-for-ingo.orig/kernel/power/poweroff.c
> +++ linux-2.6-for-ingo/kernel/power/poweroff.c
> @@ -27,7 +27,7 @@ static DECLARE_WORK(poweroff_work, do_po
> static void handle_poweroff(int key, struct tty_struct *tty)
> {
> /* run sysrq poweroff on boot cpu */
> - schedule_work_on(first_cpu(cpu_online_map), &poweroff_work);
> + schedule_work_on(cpumask_first(cpu_online_mask), &poweroff_work);
> }
>
> static struct sysrq_key_op sysrq_poweroff_op = {
> --- linux-2.6-for-ingo.orig/kernel/profile.c
> +++ linux-2.6-for-ingo/kernel/profile.c
> @@ -45,7 +45,7 @@ static unsigned long prof_len, prof_shif
> int prof_on __read_mostly;
> EXPORT_SYMBOL_GPL(prof_on);
>
> -static cpumask_t prof_cpu_mask = CPU_MASK_ALL;
> +static DECLARE_BITMAP(prof_cpu_mask, CONFIG_NR_CPUS) = CPU_BITS_ALL;
> #ifdef CONFIG_SMP
> static DEFINE_PER_CPU(struct profile_hit *[2], cpu_profile_hits);
> static DEFINE_PER_CPU(int, cpu_profile_flip);
> @@ -386,13 +386,13 @@ out_free:
> return NOTIFY_BAD;
> case CPU_ONLINE:
> case CPU_ONLINE_FROZEN:
> - cpu_set(cpu, prof_cpu_mask);
> + cpumask_set_cpu(cpu, to_cpumask(prof_cpu_mask));
> break;
> case CPU_UP_CANCELED:
> case CPU_UP_CANCELED_FROZEN:
> case CPU_DEAD:
> case CPU_DEAD_FROZEN:
> - cpu_clear(cpu, prof_cpu_mask);
> + cpumask_clear_cpu(cpu, to_cpumask(prof_cpu_mask));
> if (per_cpu(cpu_profile_hits, cpu)[0]) {
> page = virt_to_page(per_cpu(cpu_profile_hits, cpu)[0]);
> per_cpu(cpu_profile_hits, cpu)[0] = NULL;
> @@ -430,7 +430,8 @@ void profile_tick(int type)
>
> if (type == CPU_PROFILING && timer_hook)
> timer_hook(regs);
> - if (!user_mode(regs) && cpu_isset(smp_processor_id(), prof_cpu_mask))
> + if (!user_mode(regs) &&
> + cpumask_test_cpu(smp_processor_id(), to_cpumask(prof_cpu_mask)))
> profile_hit(type, (void *)profile_pc(regs));
> }
>
> @@ -442,7 +443,7 @@ void profile_tick(int type)
> static int prof_cpu_mask_read_proc(char *page, char **start, off_t off,
> int count, int *eof, void *data)
> {
> - int len = cpumask_scnprintf(page, count, (cpumask_t *)data);
> + int len = cpumask_scnprintf(page, count, data);
> if (count - len < 2)
> return -EINVAL;
> len += sprintf(page + len, "\n");
> @@ -452,16 +453,20 @@ static int prof_cpu_mask_read_proc(char
> static int prof_cpu_mask_write_proc(struct file *file,
> const char __user *buffer, unsigned long count, void *data)
> {
> - cpumask_t *mask = (cpumask_t *)data;
> + struct cpumask *mask = data;
> unsigned long full_count = count, err;
> - cpumask_t new_value;
> + cpumask_var_t new_value;
>
> - err = cpumask_parse_user(buffer, count, &new_value);
> - if (err)
> - return err;
> + if (!alloc_cpumask_var(&new_value, GFP_KERNEL))
> + return -ENOMEM;
>
> - *mask = new_value;
> - return full_count;
> + err = cpumask_parse_user(buffer, count, new_value);
> + if (!err) {
> + cpumask_copy(mask, new_value);
> + err = full_count;
> + }
> + free_cpumask_var(new_value);
> + return err;
> }
>
> void create_prof_cpu_mask(struct proc_dir_entry *root_irq_dir)
> @@ -472,7 +477,7 @@ void create_prof_cpu_mask(struct proc_di
> entry = create_proc_entry("prof_cpu_mask", 0600, root_irq_dir);
> if (!entry)
> return;
> - entry->data = (void *)&prof_cpu_mask;
> + entry->data = prof_cpu_mask;
> entry->read_proc = prof_cpu_mask_read_proc;
> entry->write_proc = prof_cpu_mask_write_proc;
> }
> --- linux-2.6-for-ingo.orig/kernel/rcuclassic.c
> +++ linux-2.6-for-ingo/kernel/rcuclassic.c
> @@ -63,14 +63,14 @@ static struct rcu_ctrlblk rcu_ctrlblk =
> .completed = -300,
> .pending = -300,
> .lock = __SPIN_LOCK_UNLOCKED(&rcu_ctrlblk.lock),
> - .cpumask = CPU_MASK_NONE,
> + .cpumask = CPU_BITS_NONE,
> };
> static struct rcu_ctrlblk rcu_bh_ctrlblk = {
> .cur = -300,
> .completed = -300,
> .pending = -300,
> .lock = __SPIN_LOCK_UNLOCKED(&rcu_bh_ctrlblk.lock),
> - .cpumask = CPU_MASK_NONE,
> + .cpumask = CPU_BITS_NONE,
> };
>
> DEFINE_PER_CPU(struct rcu_data, rcu_data) = { 0L };
> @@ -85,7 +85,6 @@ static void force_quiescent_state(struct
> struct rcu_ctrlblk *rcp)
> {
> int cpu;
> - cpumask_t cpumask;
> unsigned long flags;
>
> set_need_resched();
> @@ -96,10 +95,10 @@ static void force_quiescent_state(struct
> * Don't send IPI to itself. With irqs disabled,
> * rdp->cpu is the current cpu.
> *
> - * cpu_online_map is updated by the _cpu_down()
> + * cpu_online_mask is updated by the _cpu_down()
> * using __stop_machine(). Since we're in irqs disabled
> * section, __stop_machine() is not exectuting, hence
> - * the cpu_online_map is stable.
> + * the cpu_online_mask is stable.
> *
> * However, a cpu might have been offlined _just_ before
> * we disabled irqs while entering here.
> @@ -107,13 +106,14 @@ static void force_quiescent_state(struct
> * notification, leading to the offlined cpu's bit
> * being set in the rcp->cpumask.
> *
> - * Hence cpumask = (rcp->cpumask & cpu_online_map) to prevent
> + * Hence cpumask = (rcp->cpumask & cpu_online_mask) to prevent
> * sending smp_reschedule() to an offlined CPU.
> */
> - cpus_and(cpumask, rcp->cpumask, cpu_online_map);
> - cpu_clear(rdp->cpu, cpumask);
> - for_each_cpu_mask_nr(cpu, cpumask)
> - smp_send_reschedule(cpu);
> + for_each_cpu_and(cpu,
> + to_cpumask(rcp->cpumask), cpu_online_mask) {
> + if (cpu != rdp->cpu)
> + smp_send_reschedule(cpu);
> + }
> }
> spin_unlock_irqrestore(&rcp->lock, flags);
> }
> @@ -193,7 +193,7 @@ static void print_other_cpu_stall(struct
>
> printk(KERN_ERR "INFO: RCU detected CPU stalls:");
> for_each_possible_cpu(cpu) {
> - if (cpu_isset(cpu, rcp->cpumask))
> + if (cpumask_test_cpu(cpu, to_cpumask(rcp->cpumask)))
> printk(" %d", cpu);
> }
> printk(" (detected by %d, t=%ld jiffies)\n",
> @@ -221,7 +221,8 @@ static void check_cpu_stall(struct rcu_c
> long delta;
>
> delta = jiffies - rcp->jiffies_stall;
> - if (cpu_isset(smp_processor_id(), rcp->cpumask) && delta >= 0) {
> + if (cpumask_test_cpu(smp_processor_id(), to_cpumask(rcp->cpumask)) &&
> + delta >= 0) {
>
> /* We haven't checked in, so go dump stack. */
> print_cpu_stall(rcp);
> @@ -393,7 +394,8 @@ static void rcu_start_batch(struct rcu_c
> * unnecessarily.
> */
> smp_mb();
> - cpumask_andnot(&rcp->cpumask, cpu_online_mask, nohz_cpu_mask);
> + cpumask_andnot(to_cpumask(rcp->cpumask),
> + cpu_online_mask, nohz_cpu_mask);
>
> rcp->signaled = 0;
> }
> @@ -406,8 +408,8 @@ static void rcu_start_batch(struct rcu_c
> */
> static void cpu_quiet(int cpu, struct rcu_ctrlblk *rcp)
> {
> - cpu_clear(cpu, rcp->cpumask);
> - if (cpus_empty(rcp->cpumask)) {
> + cpumask_clear_cpu(cpu, to_cpumask(rcp->cpumask));
> + if (cpumask_empty(to_cpumask(rcp->cpumask))) {
> /* batch completed ! */
> rcp->completed = rcp->cur;
> rcu_start_batch(rcp);
> --- linux-2.6-for-ingo.orig/kernel/rcupreempt.c
> +++ linux-2.6-for-ingo/kernel/rcupreempt.c
> @@ -164,7 +164,8 @@ static char *rcu_try_flip_state_names[]
> { "idle", "waitack", "waitzero", "waitmb" };
> #endif /* #ifdef CONFIG_RCU_TRACE */
>
> -static cpumask_t rcu_cpu_online_map __read_mostly = CPU_MASK_NONE;
> +static DECLARE_BITMAP(rcu_cpu_online_map, CONFIG_NR_CPUS) __read_mostly
> + = CPU_BITS_NONE;
>
> /*
> * Enum and per-CPU flag to determine when each CPU has seen
> @@ -748,7 +749,7 @@ rcu_try_flip_idle(void)
>
> /* Now ask each CPU for acknowledgement of the flip. */
>
> - for_each_cpu_mask_nr(cpu, rcu_cpu_online_map) {
> + for_each_cpu(cpu, to_cpumask(rcu_cpu_online_map)) {
> per_cpu(rcu_flip_flag, cpu) = rcu_flipped;
> dyntick_save_progress_counter(cpu);
> }
> @@ -766,7 +767,7 @@ rcu_try_flip_waitack(void)
> int cpu;
>
> RCU_TRACE_ME(rcupreempt_trace_try_flip_a1);
> - for_each_cpu_mask_nr(cpu, rcu_cpu_online_map)
> + for_each_cpu(cpu, to_cpumask(rcu_cpu_online_map))
> if (rcu_try_flip_waitack_needed(cpu) &&
> per_cpu(rcu_flip_flag, cpu) != rcu_flip_seen) {
> RCU_TRACE_ME(rcupreempt_trace_try_flip_ae1);
> @@ -798,7 +799,7 @@ rcu_try_flip_waitzero(void)
> /* Check to see if the sum of the "last" counters is zero. */
>
> RCU_TRACE_ME(rcupreempt_trace_try_flip_z1);
> - for_each_cpu_mask_nr(cpu, rcu_cpu_online_map)
> + for_each_cpu(cpu, to_cpumask(rcu_cpu_online_map))
> sum += RCU_DATA_CPU(cpu)->rcu_flipctr[lastidx];
> if (sum != 0) {
> RCU_TRACE_ME(rcupreempt_trace_try_flip_ze1);
> @@ -813,7 +814,7 @@ rcu_try_flip_waitzero(void)
> smp_mb(); /* ^^^^^^^^^^^^ */
>
> /* Call for a memory barrier from each CPU. */
> - for_each_cpu_mask_nr(cpu, rcu_cpu_online_map) {
> + for_each_cpu(cpu, to_cpumask(rcu_cpu_online_map)) {
> per_cpu(rcu_mb_flag, cpu) = rcu_mb_needed;
> dyntick_save_progress_counter(cpu);
> }
> @@ -833,7 +834,7 @@ rcu_try_flip_waitmb(void)
> int cpu;
>
> RCU_TRACE_ME(rcupreempt_trace_try_flip_m1);
> - for_each_cpu_mask_nr(cpu, rcu_cpu_online_map)
> + for_each_cpu(cpu, to_cpumask(rcu_cpu_online_map))
> if (rcu_try_flip_waitmb_needed(cpu) &&
> per_cpu(rcu_mb_flag, cpu) != rcu_mb_done) {
> RCU_TRACE_ME(rcupreempt_trace_try_flip_me1);
> @@ -1022,7 +1023,7 @@ void rcu_offline_cpu(int cpu)
> RCU_DATA_CPU(cpu)->rcu_flipctr[0] = 0;
> RCU_DATA_CPU(cpu)->rcu_flipctr[1] = 0;
>
> - cpu_clear(cpu, rcu_cpu_online_map);
> + cpumask_clear_cpu(cpu, to_cpumask(rcu_cpu_online_map));
>
> spin_unlock_irqrestore(&rcu_ctrlblk.fliplock, flags);
>
> @@ -1062,7 +1063,7 @@ void __cpuinit rcu_online_cpu(int cpu)
> struct rcu_data *rdp;
>
> spin_lock_irqsave(&rcu_ctrlblk.fliplock, flags);
> - cpu_set(cpu, rcu_cpu_online_map);
> + cpumask_set_cpu(cpu, to_cpumask(rcu_cpu_online_map));
> spin_unlock_irqrestore(&rcu_ctrlblk.fliplock, flags);
>
> /*
> @@ -1420,7 +1421,7 @@ void __init __rcu_init(void)
> * We don't need protection against CPU-Hotplug here
> * since
> * a) If a CPU comes online while we are iterating over the
> - * cpu_online_map below, we would only end up making a
> + * cpu_online_mask below, we would only end up making a
> * duplicate call to rcu_online_cpu() which sets the corresponding
> * CPU's mask in the rcu_cpu_online_map.
> *
> --- linux-2.6-for-ingo.orig/kernel/rcutorture.c
> +++ linux-2.6-for-ingo/kernel/rcutorture.c
> @@ -843,49 +843,52 @@ static int rcu_idle_cpu; /* Force all to
> */
> static void rcu_torture_shuffle_tasks(void)
> {
> - cpumask_t tmp_mask;
> + cpumask_var_t tmp_mask;
> int i;
>
> - cpus_setall(tmp_mask);
> + if (!alloc_cpumask_var(&tmp_mask, GFP_KERNEL))
> + BUG();
> +
> + cpumask_setall(tmp_mask);
> get_online_cpus();
>
> /* No point in shuffling if there is only one online CPU (ex: UP) */
> - if (num_online_cpus() == 1) {
> - put_online_cpus();
> - return;
> - }
> + if (num_online_cpus() == 1)
> + goto out;
>
> if (rcu_idle_cpu != -1)
> - cpu_clear(rcu_idle_cpu, tmp_mask);
> + cpumask_clear_cpu(rcu_idle_cpu, tmp_mask);
>
> - set_cpus_allowed_ptr(current, &tmp_mask);
> + set_cpus_allowed_ptr(current, tmp_mask);
>
> if (reader_tasks) {
> for (i = 0; i < nrealreaders; i++)
> if (reader_tasks[i])
> set_cpus_allowed_ptr(reader_tasks[i],
> - &tmp_mask);
> + tmp_mask);
> }
>
> if (fakewriter_tasks) {
> for (i = 0; i < nfakewriters; i++)
> if (fakewriter_tasks[i])
> set_cpus_allowed_ptr(fakewriter_tasks[i],
> - &tmp_mask);
> + tmp_mask);
> }
>
> if (writer_task)
> - set_cpus_allowed_ptr(writer_task, &tmp_mask);
> + set_cpus_allowed_ptr(writer_task, tmp_mask);
>
> if (stats_task)
> - set_cpus_allowed_ptr(stats_task, &tmp_mask);
> + set_cpus_allowed_ptr(stats_task, tmp_mask);
>
> if (rcu_idle_cpu == -1)
> rcu_idle_cpu = num_online_cpus() - 1;
> else
> rcu_idle_cpu--;
>
> +out:
> put_online_cpus();
> + free_cpumask_var(tmp_mask);
> }
>
> /* Shuffle tasks across CPUs, with the intent of allowing each CPU in the
> --- linux-2.6-for-ingo.orig/kernel/softlockup.c
> +++ linux-2.6-for-ingo/kernel/softlockup.c
> @@ -310,10 +310,8 @@ cpu_callback(struct notifier_block *nfb,
> case CPU_DOWN_PREPARE:
> case CPU_DOWN_PREPARE_FROZEN:
> if (hotcpu == check_cpu) {
> - cpumask_t temp_cpu_online_map = cpu_online_map;
> -
> - cpu_clear(hotcpu, temp_cpu_online_map);
> - check_cpu = any_online_cpu(temp_cpu_online_map);
> + /* Pick any other online cpu. */
> + check_cpu = cpumask_any_but(cpu_online_mask, hotcpu);
> }
> break;
>
> --- linux-2.6-for-ingo.orig/kernel/stop_machine.c
> +++ linux-2.6-for-ingo/kernel/stop_machine.c
> @@ -69,10 +69,10 @@ static void stop_cpu(struct work_struct
> int err;
>
> if (!active_cpus) {
> - if (cpu == first_cpu(cpu_online_map))
> + if (cpu == cpumask_first(cpu_online_mask))
> smdata = &active;
> } else {
> - if (cpu_isset(cpu, *active_cpus))
> + if (cpumask_test_cpu(cpu, active_cpus))
> smdata = &active;
> }
> /* Simple state machine */
> @@ -109,7 +109,7 @@ static int chill(void *unused)
> return 0;
> }
>
> -int __stop_machine(int (*fn)(void *), void *data, const cpumask_t *cpus)
> +int __stop_machine(int (*fn)(void *), void *data, const struct cpumask *cpus)
> {
> struct work_struct *sm_work;
> int i, ret;
> @@ -142,7 +142,7 @@ int __stop_machine(int (*fn)(void *), vo
> return ret;
> }
>
> -int stop_machine(int (*fn)(void *), void *data, const cpumask_t *cpus)
> +int stop_machine(int (*fn)(void *), void *data, const struct cpumask *cpus)
> {
> int ret;
>
> --- linux-2.6-for-ingo.orig/kernel/taskstats.c
> +++ linux-2.6-for-ingo/kernel/taskstats.c
> @@ -290,18 +290,17 @@ ret:
> return;
> }
>
> -static int add_del_listener(pid_t pid, cpumask_t *maskp, int isadd)
> +static int add_del_listener(pid_t pid, const struct cpumask *mask, int isadd)
> {
> struct listener_list *listeners;
> struct listener *s, *tmp;
> unsigned int cpu;
> - cpumask_t mask = *maskp;
>
> - if (!cpus_subset(mask, cpu_possible_map))
> + if (!cpumask_subset(mask, cpu_possible_mask))
> return -EINVAL;
>
> if (isadd == REGISTER) {
> - for_each_cpu_mask_nr(cpu, mask) {
> + for_each_cpu(cpu, mask) {
> s = kmalloc_node(sizeof(struct listener), GFP_KERNEL,
> cpu_to_node(cpu));
> if (!s)
> @@ -320,7 +319,7 @@ static int add_del_listener(pid_t pid, c
>
> /* Deregister or cleanup */
> cleanup:
> - for_each_cpu_mask_nr(cpu, mask) {
> + for_each_cpu(cpu, mask) {
> listeners = &per_cpu(listener_array, cpu);
> down_write(&listeners->sem);
> list_for_each_entry_safe(s, tmp, &listeners->list, list) {
> @@ -335,7 +334,7 @@ cleanup:
> return 0;
> }
>
> -static int parse(struct nlattr *na, cpumask_t *mask)
> +static int parse(struct nlattr *na, struct cpumask *mask)
> {
> char *data;
> int len;
> @@ -428,23 +427,33 @@ err:
>
> static int taskstats_user_cmd(struct sk_buff *skb, struct genl_info *info)
> {
> - int rc = 0;
> + int rc;
> struct sk_buff *rep_skb;
> struct taskstats *stats;
> size_t size;
> - cpumask_t mask;
> + cpumask_var_t mask;
> +
> + if (!alloc_cpumask_var(&mask, GFP_KERNEL))
> + return -ENOMEM;
>
> - rc = parse(info->attrs[TASKSTATS_CMD_ATTR_REGISTER_CPUMASK], &mask);
> + rc = parse(info->attrs[TASKSTATS_CMD_ATTR_REGISTER_CPUMASK], mask);
> if (rc < 0)
> - return rc;
> - if (rc == 0)
> - return add_del_listener(info->snd_pid, &mask, REGISTER);
> + goto free_return_rc;
> + if (rc == 0) {
> + rc = add_del_listener(info->snd_pid, mask, REGISTER);
> + goto free_return_rc;
> + }
>
> - rc = parse(info->attrs[TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK], &mask);
> + rc = parse(info->attrs[TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK], mask);
> if (rc < 0)
> + goto free_return_rc;
> + if (rc == 0) {
> + rc = add_del_listener(info->snd_pid, mask, DEREGISTER);
> +free_return_rc:
> + free_cpumask_var(mask);
> return rc;
> - if (rc == 0)
> - return add_del_listener(info->snd_pid, &mask, DEREGISTER);
> + }
> + free_cpumask_var(mask);
>
> /*
> * Size includes space for nested attributes
>