15 files changed, 184 insertions, 165 deletions

diff --git a/kernel/cpu.c b/kernel/cpu.c
index 8ea32e8d68b0..2c9f78f3a2fc 100644
--- a/kernel/cpu.c
+++ b/kernel/cpu.c
@@ -15,29 +15,8 @@
 #include <linux/stop_machine.h>
 #include <linux/mutex.h>
 
-/*
- * Represents all cpu's present in the system
- * In systems capable of hotplug, this map could dynamically grow
- * as new cpu's are detected in the system via any platform specific
- * method, such as ACPI for e.g.
- */
-cpumask_t cpu_present_map __read_mostly;
-EXPORT_SYMBOL(cpu_present_map);
-
-#ifndef CONFIG_SMP
-
-/*
- * Represents all cpu's that are currently online.
- */
-cpumask_t cpu_online_map __read_mostly = CPU_MASK_ALL;
-EXPORT_SYMBOL(cpu_online_map);
-
-cpumask_t cpu_possible_map __read_mostly = CPU_MASK_ALL;
-EXPORT_SYMBOL(cpu_possible_map);
-
-#else /* CONFIG_SMP */
-
-/* Serializes the updates to cpu_online_map, cpu_present_map */
+#ifdef CONFIG_SMP
+/* Serializes the updates to cpu_online_mask, cpu_present_mask */
 static DEFINE_MUTEX(cpu_add_remove_lock);
 
 static __cpuinitdata RAW_NOTIFIER_HEAD(cpu_chain);
@@ -64,8 +43,6 @@ void __init cpu_hotplug_init(void)
         cpu_hotplug.refcount = 0;
 }
 
-cpumask_t cpu_active_map;
-
 #ifdef CONFIG_HOTPLUG_CPU
 
 void get_online_cpus(void)
@@ -96,7 +73,7 @@ EXPORT_SYMBOL_GPL(put_online_cpus);
 
 /*
  * The following two API's must be used when attempting
- * to serialize the updates to cpu_online_map, cpu_present_map.
+ * to serialize the updates to cpu_online_mask, cpu_present_mask.
  */
 void cpu_maps_update_begin(void)
 {
@@ -502,3 +479,71 @@ EXPORT_SYMBOL_GPL(cpu_bit_bitmap);
 
 const DECLARE_BITMAP(cpu_all_bits, NR_CPUS) = CPU_BITS_ALL;
 EXPORT_SYMBOL(cpu_all_bits);
+
+#ifdef CONFIG_INIT_ALL_POSSIBLE
+static DECLARE_BITMAP(cpu_possible_bits, CONFIG_NR_CPUS) __read_mostly
+        = CPU_BITS_ALL;
+#else
+static DECLARE_BITMAP(cpu_possible_bits, CONFIG_NR_CPUS) __read_mostly;
+#endif
+const struct cpumask *const cpu_possible_mask = to_cpumask(cpu_possible_bits);
+EXPORT_SYMBOL(cpu_possible_mask);
+
+static DECLARE_BITMAP(cpu_online_bits, CONFIG_NR_CPUS) __read_mostly;
+const struct cpumask *const cpu_online_mask = to_cpumask(cpu_online_bits);
+EXPORT_SYMBOL(cpu_online_mask);
+
+static DECLARE_BITMAP(cpu_present_bits, CONFIG_NR_CPUS) __read_mostly;
+const struct cpumask *const cpu_present_mask = to_cpumask(cpu_present_bits);
+EXPORT_SYMBOL(cpu_present_mask);
+
+static DECLARE_BITMAP(cpu_active_bits, CONFIG_NR_CPUS) __read_mostly;
+const struct cpumask *const cpu_active_mask = to_cpumask(cpu_active_bits);
+EXPORT_SYMBOL(cpu_active_mask);
+
+void set_cpu_possible(unsigned int cpu, bool possible)
+{
+        if (possible)
+                cpumask_set_cpu(cpu, to_cpumask(cpu_possible_bits));
+        else
+                cpumask_clear_cpu(cpu, to_cpumask(cpu_possible_bits));
+}
+
+void set_cpu_present(unsigned int cpu, bool present)
+{
+        if (present)
+                cpumask_set_cpu(cpu, to_cpumask(cpu_present_bits));
+        else
+                cpumask_clear_cpu(cpu, to_cpumask(cpu_present_bits));
+}
+
+void set_cpu_online(unsigned int cpu, bool online)
+{
+        if (online)
+                cpumask_set_cpu(cpu, to_cpumask(cpu_online_bits));
+        else
+                cpumask_clear_cpu(cpu, to_cpumask(cpu_online_bits));
+}
+
+void set_cpu_active(unsigned int cpu, bool active)
+{
+        if (active)
+                cpumask_set_cpu(cpu, to_cpumask(cpu_active_bits));
+        else
+                cpumask_clear_cpu(cpu, to_cpumask(cpu_active_bits));
+}
+
+void init_cpu_present(const struct cpumask *src)
+{
+        cpumask_copy(to_cpumask(cpu_present_bits), src);
+}
+
+void init_cpu_possible(const struct cpumask *src)
+{
+        cpumask_copy(to_cpumask(cpu_possible_bits), src);
+}
+
+void init_cpu_online(const struct cpumask *src)
+{
+        cpumask_copy(to_cpumask(cpu_online_bits), src);
+}
diff --git a/kernel/cpuset.c b/kernel/cpuset.c
index 96c0ba13b8cd..39c1a4c1c5a9 100644
--- a/kernel/cpuset.c
+++ b/kernel/cpuset.c
@@ -896,7 +896,7 @@ static int update_cpumask(struct cpuset *cs, const char *buf)
         if (!*buf) {
                 cpus_clear(trialcs.cpus_allowed);
         } else {
-                retval = cpulist_parse(buf, trialcs.cpus_allowed);
+                retval = cpulist_parse(buf, &trialcs.cpus_allowed);
                 if (retval < 0)
                         return retval;
 
@@ -1482,7 +1482,7 @@ static int cpuset_sprintf_cpulist(char *page, struct cpuset *cs)
         mask = cs->cpus_allowed;
         mutex_unlock(&callback_mutex);
 
-        return cpulist_scnprintf(page, PAGE_SIZE, mask);
+        return cpulist_scnprintf(page, PAGE_SIZE, &mask);
 }
 
 static int cpuset_sprintf_memlist(char *page, struct cpuset *cs)
diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
index 6eb3c7952b64..f63c706d25e1 100644
--- a/kernel/irq/chip.c
+++ b/kernel/irq/chip.c
@@ -46,7 +46,7 @@ void dynamic_irq_init(unsigned int irq)
         desc->irq_count = 0;
         desc->irqs_unhandled = 0;
 #ifdef CONFIG_SMP
-        cpus_setall(desc->affinity);
+        cpumask_setall(&desc->affinity);
 #endif
         spin_unlock_irqrestore(&desc->lock, flags);
 }
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index 540f6c49f3fa..61c4a9b62165 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -79,7 +79,7 @@ int irq_can_set_affinity(unsigned int irq)
  *      @cpumask:       cpumask
  *
  */
-int irq_set_affinity(unsigned int irq, cpumask_t cpumask)
+int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask)
 {
         struct irq_desc *desc = irq_to_desc(irq);
         unsigned long flags;
@@ -91,14 +91,14 @@ int irq_set_affinity(unsigned int irq, cpumask_t cpumask)
 
 #ifdef CONFIG_GENERIC_PENDING_IRQ
         if (desc->status & IRQ_MOVE_PCNTXT || desc->status & IRQ_DISABLED) {
-                desc->affinity = cpumask;
+                cpumask_copy(&desc->affinity, cpumask);
                 desc->chip->set_affinity(irq, cpumask);
         } else {
                 desc->status |= IRQ_MOVE_PENDING;
-                desc->pending_mask = cpumask;
+                cpumask_copy(&desc->pending_mask, cpumask);
         }
 #else
-        desc->affinity = cpumask;
+        cpumask_copy(&desc->affinity, cpumask);
         desc->chip->set_affinity(irq, cpumask);
 #endif
         desc->status |= IRQ_AFFINITY_SET;
@@ -112,26 +112,24 @@ int irq_set_affinity(unsigned int irq, cpumask_t cpumask)
  */
 int do_irq_select_affinity(unsigned int irq, struct irq_desc *desc)
 {
-        cpumask_t mask;
-
         if (!irq_can_set_affinity(irq))
                 return 0;
 
-        cpus_and(mask, cpu_online_map, irq_default_affinity);
-
         /*
          * Preserve an userspace affinity setup, but make sure that
          * one of the targets is online.
          */
         if (desc->status & (IRQ_AFFINITY_SET | IRQ_NO_BALANCING)) {
-                if (cpus_intersects(desc->affinity, cpu_online_map))
-                        mask = desc->affinity;
+                if (cpumask_any_and(&desc->affinity, cpu_online_mask)
+                    < nr_cpu_ids)
+                        goto set_affinity;
                 else
                         desc->status &= ~IRQ_AFFINITY_SET;
         }
 
-        desc->affinity = mask;
-        desc->chip->set_affinity(irq, mask);
+        cpumask_and(&desc->affinity, cpu_online_mask, &irq_default_affinity);
+set_affinity:
+        desc->chip->set_affinity(irq, &desc->affinity);
 
         return 0;
 }
diff --git a/kernel/irq/migration.c b/kernel/irq/migration.c
index 9db681d95814..bd72329e630c 100644
--- a/kernel/irq/migration.c
+++ b/kernel/irq/migration.c
@@ -4,7 +4,6 @@
 void move_masked_irq(int irq)
 {
         struct irq_desc *desc = irq_to_desc(irq);
-        cpumask_t tmp;
 
         if (likely(!(desc->status & IRQ_MOVE_PENDING)))
                 return;
@@ -19,7 +18,7 @@ void move_masked_irq(int irq)
 
         desc->status &= ~IRQ_MOVE_PENDING;
 
-        if (unlikely(cpus_empty(desc->pending_mask)))
+        if (unlikely(cpumask_empty(&desc->pending_mask)))
                 return;
 
         if (!desc->chip->set_affinity)
@@ -27,8 +26,6 @@ void move_masked_irq(int irq)
 
         assert_spin_locked(&desc->lock);
 
-        cpus_and(tmp, desc->pending_mask, cpu_online_map);
-
         /*
          * If there was a valid mask to work with, please
          * do the disable, re-program, enable sequence.
@@ -41,10 +38,13 @@ void move_masked_irq(int irq)
          * For correct operation this depends on the caller
          * masking the irqs.
          */
-        if (likely(!cpus_empty(tmp))) {
-                desc->chip->set_affinity(irq,tmp);
+        if (likely(cpumask_any_and(&desc->pending_mask, cpu_online_mask)
+                   < nr_cpu_ids)) {
+                cpumask_and(&desc->affinity,
+                            &desc->pending_mask, cpu_online_mask);
+                desc->chip->set_affinity(irq, &desc->affinity);
         }
-        cpus_clear(desc->pending_mask);
+        cpumask_clear(&desc->pending_mask);
 }
 
 void move_native_irq(int irq)
diff --git a/kernel/irq/proc.c b/kernel/irq/proc.c
index f6b3440f05bc..d2c0e5ee53c5 100644
--- a/kernel/irq/proc.c
+++ b/kernel/irq/proc.c
@@ -40,33 +40,42 @@ static ssize_t irq_affinity_proc_write(struct file *file,
                 const char __user *buffer, size_t count, loff_t *pos)
 {
         unsigned int irq = (int)(long)PDE(file->f_path.dentry->d_inode)->data;
-        cpumask_t new_value;
+        cpumask_var_t new_value;
         int err;
 
         if (!irq_to_desc(irq)->chip->set_affinity || no_irq_affinity ||
             irq_balancing_disabled(irq))
                 return -EIO;
 
+        if (!alloc_cpumask_var(&new_value, GFP_KERNEL))
+                return -ENOMEM;
+
         err = cpumask_parse_user(buffer, count, new_value);
         if (err)
-                return err;
+                goto free_cpumask;
 
-        if (!is_affinity_mask_valid(new_value))
-                return -EINVAL;
+        if (!is_affinity_mask_valid(*new_value)) {
+                err = -EINVAL;
+                goto free_cpumask;
+        }
 
         /*
          * 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))
+        if (!cpumask_intersects(new_value, cpu_online_mask)) {
                 /* Special case for empty set - allow the architecture
                    code to set default SMP affinity. */
-                return irq_select_affinity_usr(irq) ? -EINVAL : count;
-
-        irq_set_affinity(irq, new_value);
+                err = irq_select_affinity_usr(irq) ? -EINVAL : count;
+        } else {
+                irq_set_affinity(irq, new_value);
+                err = count;
+        }
 
-        return count;
+free_cpumask:
+        free_cpumask_var(new_value);
+        return err;
 }
 
 static int irq_affinity_proc_open(struct inode *inode, struct file *file)
@@ -95,7 +104,7 @@ static ssize_t default_affinity_write(struct file *file,
         cpumask_t new_value;
         int err;
 
-        err = cpumask_parse_user(buffer, count, new_value);
+        err = cpumask_parse_user(buffer, count, &new_value);
         if (err)
                 return err;
 
diff --git a/kernel/profile.c b/kernel/profile.c
index 60adefb59b5e..4cb7d68fed82 100644
--- a/kernel/profile.c
+++ b/kernel/profile.c
@@ -442,7 +442,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, (cpumask_t *)data);
         if (count - len < 2)
                 return -EINVAL;
         len += sprintf(page + len, "\n");
@@ -456,7 +456,7 @@ static int prof_cpu_mask_write_proc(struct file *file,
         unsigned long full_count = count, err;
         cpumask_t new_value;
 
-        err = cpumask_parse_user(buffer, count, new_value);
+        err = cpumask_parse_user(buffer, count, &new_value);
         if (err)
                 return err;
 
diff --git a/kernel/sched.c b/kernel/sched.c
index fff1c4a20b65..f2095660efec 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -6644,7 +6644,7 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
         struct sched_group *group = sd->groups;
         char str[256];
 
-        cpulist_scnprintf(str, sizeof(str), sd->span);
+        cpulist_scnprintf(str, sizeof(str), &sd->span);
         cpus_clear(*groupmask);
 
         printk(KERN_DEBUG "%*s domain %d: ", level, "", level);
@@ -6697,7 +6697,7 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
 
                 cpus_or(*groupmask, *groupmask, group->cpumask);
 
-                cpulist_scnprintf(str, sizeof(str), group->cpumask);
+                cpulist_scnprintf(str, sizeof(str), &group->cpumask);
                 printk(KERN_CONT " %s", str);
 
                 group = group->next;
@@ -7098,7 +7098,7 @@ cpu_to_phys_group(int cpu, const cpumask_t *cpu_map, struct sched_group **sg,
 {
         int group;
 #ifdef CONFIG_SCHED_MC
-        *mask = cpu_coregroup_map(cpu);
+        *mask = *cpu_coregroup_mask(cpu);
         cpus_and(*mask, *mask, *cpu_map);
         group = first_cpu(*mask);
 #elif defined(CONFIG_SCHED_SMT)
@@ -7471,7 +7471,7 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
                 sd = &per_cpu(core_domains, i);
                 SD_INIT(sd, MC);
                 set_domain_attribute(sd, attr);
-                sd->span = cpu_coregroup_map(i);
+                sd->span = *cpu_coregroup_mask(i);
                 cpus_and(sd->span, sd->span, *cpu_map);
                 sd->parent = p;
                 p->child = sd;
@@ -7514,7 +7514,7 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
                 SCHED_CPUMASK_VAR(this_core_map, allmasks);
                 SCHED_CPUMASK_VAR(send_covered, allmasks);
 
-                *this_core_map = cpu_coregroup_map(i);
+                *this_core_map = *cpu_coregroup_mask(i);
                 cpus_and(*this_core_map, *this_core_map, *cpu_map);
                 if (i != first_cpu(*this_core_map))
                         continue;
diff --git a/kernel/sched_stats.h b/kernel/sched_stats.h
index 3b01098164c8..b59fd9cdc1b6 100644
--- a/kernel/sched_stats.h
+++ b/kernel/sched_stats.h
@@ -42,7 +42,7 @@ static int show_schedstat(struct seq_file *seq, void *v)
                 for_each_domain(cpu, sd) {
                         enum cpu_idle_type itype;
 
-                        cpumask_scnprintf(mask_str, mask_len, sd->span);
+                        cpumask_scnprintf(mask_str, mask_len, &sd->span);
                         seq_printf(seq, "domain%d %s", dcount++, mask_str);
                         for (itype = CPU_IDLE; itype < CPU_MAX_IDLE_TYPES;
                                         itype++) {
diff --git a/kernel/smp.c b/kernel/smp.c
index 75c8dde58c55..172b18268909 100644
--- a/kernel/smp.c
+++ b/kernel/smp.c
@@ -24,8 +24,8 @@ struct call_function_data {
         struct call_single_data csd;
         spinlock_t lock;
         unsigned int refs;
-        cpumask_t cpumask;
         struct rcu_head rcu_head;
+        unsigned long cpumask_bits[];
 };
 
 struct call_single_queue {
@@ -110,13 +110,13 @@ void generic_smp_call_function_interrupt(void)
         list_for_each_entry_rcu(data, &call_function_queue, csd.list) {
                 int refs;
 
-                if (!cpu_isset(cpu, data->cpumask))
+                if (!cpumask_test_cpu(cpu, to_cpumask(data->cpumask_bits)))
                         continue;
 
                 data->csd.func(data->csd.info);
 
                 spin_lock(&data->lock);
-                cpu_clear(cpu, data->cpumask);
+                cpumask_clear_cpu(cpu, to_cpumask(data->cpumask_bits));
                 WARN_ON(data->refs == 0);
                 data->refs--;
                 refs = data->refs;
@@ -266,51 +266,19 @@ void __smp_call_function_single(int cpu, struct call_single_data *data)
         generic_exec_single(cpu, data);
 }
 
-/* Dummy function */
-static void quiesce_dummy(void *unused)
-{
-}
-
-/*
- * Ensure stack based data used in call function mask is safe to free.
- *
- * This is needed by smp_call_function_mask when using on-stack data, because
- * a single call function queue is shared by all CPUs, and any CPU may pick up
- * the data item on the queue at any time before it is deleted. So we need to
- * ensure that all CPUs have transitioned through a quiescent state after
- * this call.
- *
- * This is a very slow function, implemented by sending synchronous IPIs to
- * all possible CPUs. For this reason, we have to alloc data rather than use
- * stack based data even in the case of synchronous calls. The stack based
- * data is then just used for deadlock/oom fallback which will be very rare.
- *
- * If a faster scheme can be made, we could go back to preferring stack based
- * data -- the data allocation/free is non-zero cost.
- */
-static void smp_call_function_mask_quiesce_stack(cpumask_t mask)
-{
-        struct call_single_data data;
-        int cpu;
-
-        data.func = quiesce_dummy;
-        data.info = NULL;
-
-        for_each_cpu_mask(cpu, mask) {
-                data.flags = CSD_FLAG_WAIT;
-                generic_exec_single(cpu, &data);
-        }
-}
+/* FIXME: Shim for archs using old arch_send_call_function_ipi API. */
+#ifndef arch_send_call_function_ipi_mask
+#define arch_send_call_function_ipi_mask(maskp) \
+        arch_send_call_function_ipi(*(maskp))
+#endif
 
 /**
- * smp_call_function_mask(): Run a function on a set of other CPUs.
- * @mask: The set of cpus to run on.
+ * smp_call_function_many(): Run a function on a set of other CPUs.
+ * @mask: The set of cpus to run on (only runs on online subset).
  * @func: The function to run. This must be fast and non-blocking.
  * @info: An arbitrary pointer to pass to the function.
  * @wait: If true, wait (atomically) until function has completed on other CPUs.
  *
- * Returns 0 on success, else a negative status code.
- *
  * If @wait is true, then returns once @func has returned. Note that @wait
  * will be implicitly turned on in case of allocation failures, since
  * we fall back to on-stack allocation.
@@ -319,53 +287,57 @@ static void smp_call_function_mask_quiesce_stack(cpumask_t mask)
  * hardware interrupt handler or from a bottom half handler. Preemption
  * must be disabled when calling this function.
  */
-int smp_call_function_mask(cpumask_t mask, void (*func)(void *), void *info,
-                           int wait)
+void smp_call_function_many(const struct cpumask *mask,
+                            void (*func)(void *), void *info,
+                            bool wait)
 {
-        struct call_function_data d;
-        struct call_function_data *data = NULL;
-        cpumask_t allbutself;
+        struct call_function_data *data;
         unsigned long flags;
-        int cpu, num_cpus;
-        int slowpath = 0;
+        int cpu, next_cpu;
 
         /* Can deadlock when called with interrupts disabled */
         WARN_ON(irqs_disabled());
 
-        cpu = smp_processor_id();
-        allbutself = cpu_online_map;
-        cpu_clear(cpu, allbutself);
-        cpus_and(mask, mask, allbutself);
-        num_cpus = cpus_weight(mask);
-
-        /*
-         * If zero CPUs, return. If just a single CPU, turn this request
-         * into a targetted single call instead since it's faster.
-         */
-        if (!num_cpus)
-                return 0;
-        else if (num_cpus == 1) {
-                cpu = first_cpu(mask);
-                return smp_call_function_single(cpu, func, info, wait);
+        /* So, what's a CPU they want?  Ignoring this one. */
+        cpu = cpumask_first_and(mask, cpu_online_mask);
+        if (cpu == smp_processor_id())
+                cpu = cpumask_next_and(cpu, mask, cpu_online_mask);
+        /* No online cpus?  We're done. */
+        if (cpu >= nr_cpu_ids)
+                return;
+
+        /* Do we have another CPU which isn't us? */
+        next_cpu = cpumask_next_and(cpu, mask, cpu_online_mask);
+        if (next_cpu == smp_processor_id())
+                next_cpu = cpumask_next_and(next_cpu, mask, cpu_online_mask);
+
+        /* Fastpath: do that cpu by itself. */
+        if (next_cpu >= nr_cpu_ids) {
+                smp_call_function_single(cpu, func, info, wait);
+                return;
         }
 
-        data = kmalloc(sizeof(*data), GFP_ATOMIC);
-        if (data) {
-                data->csd.flags = CSD_FLAG_ALLOC;
-                if (wait)
-                        data->csd.flags |= CSD_FLAG_WAIT;
-        } else {
-                data = &d;
-                data->csd.flags = CSD_FLAG_WAIT;
-                wait = 1;
-                slowpath = 1;
+        data = kmalloc(sizeof(*data) + cpumask_size(), GFP_ATOMIC);
+        if (unlikely(!data)) {
+                /* Slow path. */
+                for_each_online_cpu(cpu) {
+                        if (cpu == smp_processor_id())
+                                continue;
+                        if (cpumask_test_cpu(cpu, mask))
+                                smp_call_function_single(cpu, func, info, wait);
+                }
+                return;
         }
 
         spin_lock_init(&data->lock);
+        data->csd.flags = CSD_FLAG_ALLOC;
+        if (wait)
+                data->csd.flags |= CSD_FLAG_WAIT;
         data->csd.func = func;
         data->csd.info = info;
-        data->refs = num_cpus;
-        data->cpumask = mask;
+        cpumask_and(to_cpumask(data->cpumask_bits), mask, cpu_online_mask);
+        cpumask_clear_cpu(smp_processor_id(), to_cpumask(data->cpumask_bits));
+        data->refs = cpumask_weight(to_cpumask(data->cpumask_bits));
 
         spin_lock_irqsave(&call_function_lock, flags);
         list_add_tail_rcu(&data->csd.list, &call_function_queue);
@@ -377,18 +349,13 @@ int smp_call_function_mask(cpumask_t mask, void (*func)(void *), void *info,
         smp_mb();
 
         /* Send a message to all CPUs in the map */
-        arch_send_call_function_ipi(mask);
+        arch_send_call_function_ipi_mask(to_cpumask(data->cpumask_bits));
 
         /* optionally wait for the CPUs to complete */
-        if (wait) {
+        if (wait)
                 csd_flag_wait(&data->csd);
-                if (unlikely(slowpath))
-                        smp_call_function_mask_quiesce_stack(mask);
-        }
-
-        return 0;
 }
-EXPORT_SYMBOL(smp_call_function_mask);
+EXPORT_SYMBOL(smp_call_function_many);
 
 /**
  * smp_call_function(): Run a function on all other CPUs.
@@ -396,7 +363,7 @@ EXPORT_SYMBOL(smp_call_function_mask);
  * @info: An arbitrary pointer to pass to the function.
  * @wait: If true, wait (atomically) until function has completed on other CPUs.
  *
- * Returns 0 on success, else a negative status code.
+ * Returns 0.
  *
  * If @wait is true, then returns once @func has returned; otherwise
  * it returns just before the target cpu calls @func. In case of allocation
@@ -407,12 +374,10 @@ EXPORT_SYMBOL(smp_call_function_mask);
  */
 int smp_call_function(void (*func)(void *), void *info, int wait)
 {
-        int ret;
-
         preempt_disable();
-        ret = smp_call_function_mask(cpu_online_map, func, info, wait);
+        smp_call_function_many(cpu_online_mask, func, info, wait);
         preempt_enable();
-        return ret;
+        return 0;
 }
 EXPORT_SYMBOL(smp_call_function);
 
diff --git a/kernel/taskstats.c b/kernel/taskstats.c
index bd6be76303cf..6d7dc4ec4aa5 100644
--- a/kernel/taskstats.c
+++ b/kernel/taskstats.c
@@ -352,7 +352,7 @@ static int parse(struct nlattr *na, cpumask_t *mask)
         if (!data)
                 return -ENOMEM;
         nla_strlcpy(data, na, len);
-        ret = cpulist_parse(data, *mask);
+        ret = cpulist_parse(data, mask);
         kfree(data);
         return ret;
 }
diff --git a/kernel/time/clockevents.c b/kernel/time/clockevents.c
index f8d968063cea..ea2f48af83cf 100644
--- a/kernel/time/clockevents.c
+++ b/kernel/time/clockevents.c
@@ -166,6 +166,8 @@ static void clockevents_notify_released(void)
 void clockevents_register_device(struct clock_event_device *dev)
 {
         BUG_ON(dev->mode != CLOCK_EVT_MODE_UNUSED);
+        BUG_ON(!dev->cpumask);
+
         /*
          * A nsec2cyc multiplicator of 0 is invalid and we'd crash
          * on it, so fix it up and emit a warning:
diff --git a/kernel/time/tick-broadcast.c b/kernel/time/tick-broadcast.c
index f98a1b7b16e9..9590af2327be 100644
--- a/kernel/time/tick-broadcast.c
+++ b/kernel/time/tick-broadcast.c
@@ -150,7 +150,7 @@ static void tick_do_broadcast(cpumask_t mask)
                  */
                 cpu = first_cpu(mask);
                 td = &per_cpu(tick_cpu_device, cpu);
-                td->evtdev->broadcast(mask);
+                td->evtdev->broadcast(&mask);
         }
 }
 
diff --git a/kernel/time/tick-common.c b/kernel/time/tick-common.c
index df12434b43ca..f8372be74122 100644
--- a/kernel/time/tick-common.c
+++ b/kernel/time/tick-common.c
@@ -136,7 +136,7 @@ void tick_setup_periodic(struct clock_event_device *dev, int broadcast)
  */
 static void tick_setup_device(struct tick_device *td,
                               struct clock_event_device *newdev, int cpu,
-                              const cpumask_t *cpumask)
+                              const struct cpumask *cpumask)
 {
         ktime_t next_event;
         void (*handler)(struct clock_event_device *) = NULL;
@@ -171,8 +171,8 @@ static void tick_setup_device(struct tick_device *td,
          * When the device is not per cpu, pin the interrupt to the
          * current cpu:
          */
-        if (!cpus_equal(newdev->cpumask, *cpumask))
-                irq_set_affinity(newdev->irq, *cpumask);
+        if (!cpumask_equal(newdev->cpumask, cpumask))
+                irq_set_affinity(newdev->irq, cpumask);
 
         /*
          * When global broadcasting is active, check if the current
@@ -202,14 +202,14 @@ static int tick_check_new_device(struct clock_event_device *newdev)
         spin_lock_irqsave(&tick_device_lock, flags);
 
         cpu = smp_processor_id();
-        if (!cpu_isset(cpu, newdev->cpumask))
+        if (!cpumask_test_cpu(cpu, newdev->cpumask))
                 goto out_bc;
 
         td = &per_cpu(tick_cpu_device, cpu);
         curdev = td->evtdev;
 
         /* cpu local device ? */
-        if (!cpus_equal(newdev->cpumask, cpumask_of_cpu(cpu))) {
+        if (!cpumask_equal(newdev->cpumask, cpumask_of(cpu))) {
 
                 /*
                  * If the cpu affinity of the device interrupt can not
@@ -222,7 +222,7 @@ static int tick_check_new_device(struct clock_event_device *newdev)
                  * If we have a cpu local device already, do not replace it
                  * by a non cpu local device
                  */
-                if (curdev && cpus_equal(curdev->cpumask, cpumask_of_cpu(cpu)))
+                if (curdev && cpumask_equal(curdev->cpumask, cpumask_of(cpu)))
                         goto out_bc;
         }
 
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 4185d5221633..0e91f43b6baf 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -2674,7 +2674,7 @@ tracing_cpumask_read(struct file *filp, char __user *ubuf,
 
         mutex_lock(&tracing_cpumask_update_lock);
 
-        len = cpumask_scnprintf(mask_str, count, tracing_cpumask);
+        len = cpumask_scnprintf(mask_str, count, &tracing_cpumask);
         if (count - len < 2) {
                 count = -EINVAL;
                 goto out_err;
@@ -2695,7 +2695,7 @@ tracing_cpumask_write(struct file *filp, const char __user *ubuf,
         int err, cpu;
 
         mutex_lock(&tracing_cpumask_update_lock);
-        err = cpumask_parse_user(ubuf, count, tracing_cpumask_new);
+        err = cpumask_parse_user(ubuf, count, &tracing_cpumask_new);
         if (err)
                 goto err_unlock;