Merge branch 'linus' into sched/urgent

45 files changed, 1718 insertions, 1577 deletions

diff --git a/kernel/audit.h b/kernel/audit.h
index 9d6717412fec..16f18cac661b 100644
--- a/kernel/audit.h
+++ b/kernel/audit.h
@@ -159,11 +159,8 @@ static inline int audit_signal_info(int sig, struct task_struct *t)
                 return __audit_signal_info(sig, t);
         return 0;
 }
-extern enum audit_state audit_filter_inodes(struct task_struct *,
-                                            struct audit_context *);
-extern void audit_set_auditable(struct audit_context *);
+extern void audit_filter_inodes(struct task_struct *, struct audit_context *);
 #else
 #define audit_signal_info(s,t) AUDIT_DISABLED
 #define audit_filter_inodes(t,c) AUDIT_DISABLED
-#define audit_set_auditable(c)
 #endif
diff --git a/kernel/audit_tree.c b/kernel/audit_tree.c
index 8b509441f49a..8ad9545b8db9 100644
--- a/kernel/audit_tree.c
+++ b/kernel/audit_tree.c
@@ -450,6 +450,7 @@ static void kill_rules(struct audit_tree *tree)
                         audit_log_end(ab);
                         rule->tree = NULL;
                         list_del_rcu(&entry->list);
+                        list_del(&entry->rule.list);
                         call_rcu(&entry->rcu, audit_free_rule_rcu);
                 }
         }
@@ -617,7 +618,7 @@ int audit_make_tree(struct audit_krule *rule, char *pathname, u32 op)
 
         if (pathname[0] != '/' ||
             rule->listnr != AUDIT_FILTER_EXIT ||
-            op & ~AUDIT_EQUAL ||
+            op != Audit_equal ||
             rule->inode_f || rule->watch || rule->tree)
                 return -EINVAL;
         rule->tree = alloc_tree(pathname);
diff --git a/kernel/auditfilter.c b/kernel/auditfilter.c
index 9fd85a4640a0..fbf24d121d97 100644
--- a/kernel/auditfilter.c
+++ b/kernel/auditfilter.c
@@ -86,6 +86,14 @@ struct list_head audit_filter_list[AUDIT_NR_FILTERS] = {
 #error Fix audit_filter_list initialiser
 #endif
 };
+static struct list_head audit_rules_list[AUDIT_NR_FILTERS] = {
+        LIST_HEAD_INIT(audit_rules_list[0]),
+        LIST_HEAD_INIT(audit_rules_list[1]),
+        LIST_HEAD_INIT(audit_rules_list[2]),
+        LIST_HEAD_INIT(audit_rules_list[3]),
+        LIST_HEAD_INIT(audit_rules_list[4]),
+        LIST_HEAD_INIT(audit_rules_list[5]),
+};
 
 DEFINE_MUTEX(audit_filter_mutex);
 
@@ -244,7 +252,8 @@ static inline int audit_to_inode(struct audit_krule *krule,
                                  struct audit_field *f)
 {
         if (krule->listnr != AUDIT_FILTER_EXIT ||
-            krule->watch || krule->inode_f || krule->tree)
+            krule->watch || krule->inode_f || krule->tree ||
+            (f->op != Audit_equal && f->op != Audit_not_equal))
                 return -EINVAL;
 
         krule->inode_f = f;
@@ -262,7 +271,7 @@ static int audit_to_watch(struct audit_krule *krule, char *path, int len,
 
         if (path[0] != '/' || path[len-1] == '/' ||
             krule->listnr != AUDIT_FILTER_EXIT ||
-            op & ~AUDIT_EQUAL ||
+            op != Audit_equal ||
             krule->inode_f || krule->watch || krule->tree)
                 return -EINVAL;
 
@@ -412,12 +421,32 @@ exit_err:
         return ERR_PTR(err);
 }
 
+static u32 audit_ops[] =
+{
+        [Audit_equal] = AUDIT_EQUAL,
+        [Audit_not_equal] = AUDIT_NOT_EQUAL,
+        [Audit_bitmask] = AUDIT_BIT_MASK,
+        [Audit_bittest] = AUDIT_BIT_TEST,
+        [Audit_lt] = AUDIT_LESS_THAN,
+        [Audit_gt] = AUDIT_GREATER_THAN,
+        [Audit_le] = AUDIT_LESS_THAN_OR_EQUAL,
+        [Audit_ge] = AUDIT_GREATER_THAN_OR_EQUAL,
+};
+
+static u32 audit_to_op(u32 op)
+{
+        u32 n;
+        for (n = Audit_equal; n < Audit_bad && audit_ops[n] != op; n++)
+                ;
+        return n;
+}
+
+
 /* Translate struct audit_rule to kernel's rule respresentation.
  * Exists for backward compatibility with userspace. */
 static struct audit_entry *audit_rule_to_entry(struct audit_rule *rule)
 {
         struct audit_entry *entry;
-        struct audit_field *ino_f;
         int err = 0;
         int i;
 
@@ -427,12 +456,28 @@ static struct audit_entry *audit_rule_to_entry(struct audit_rule *rule)
 
         for (i = 0; i < rule->field_count; i++) {
                 struct audit_field *f = &entry->rule.fields[i];
+                u32 n;
+
+                n = rule->fields[i] & (AUDIT_NEGATE|AUDIT_OPERATORS);
+
+                /* Support for legacy operators where
+                 * AUDIT_NEGATE bit signifies != and otherwise assumes == */
+                if (n & AUDIT_NEGATE)
+                        f->op = Audit_not_equal;
+                else if (!n)
+                        f->op = Audit_equal;
+                else
+                        f->op = audit_to_op(n);
+
+                entry->rule.vers_ops = (n & AUDIT_OPERATORS) ? 2 : 1;
 
-                f->op = rule->fields[i] & (AUDIT_NEGATE|AUDIT_OPERATORS);
                 f->type = rule->fields[i] & ~(AUDIT_NEGATE|AUDIT_OPERATORS);
                 f->val = rule->values[i];
 
                 err = -EINVAL;
+                if (f->op == Audit_bad)
+                        goto exit_free;
+
                 switch(f->type) {
                 default:
                         goto exit_free;
@@ -454,11 +499,8 @@ static struct audit_entry *audit_rule_to_entry(struct audit_rule *rule)
                 case AUDIT_EXIT:
                 case AUDIT_SUCCESS:
                         /* bit ops are only useful on syscall args */
-                        if (f->op == AUDIT_BIT_MASK ||
-                                                f->op == AUDIT_BIT_TEST) {
-                                err = -EINVAL;
+                        if (f->op == Audit_bitmask || f->op == Audit_bittest)
                                 goto exit_free;
-                        }
                         break;
                 case AUDIT_ARG0:
                 case AUDIT_ARG1:
@@ -467,11 +509,8 @@ static struct audit_entry *audit_rule_to_entry(struct audit_rule *rule)
                         break;
                 /* arch is only allowed to be = or != */
                 case AUDIT_ARCH:
-                        if ((f->op != AUDIT_NOT_EQUAL) && (f->op != AUDIT_EQUAL)
-                                        && (f->op != AUDIT_NEGATE) && (f->op)) {
-                                err = -EINVAL;
+                        if (f->op != Audit_not_equal && f->op != Audit_equal)
                                 goto exit_free;
-                        }
                         entry->rule.arch_f = f;
                         break;
                 case AUDIT_PERM:
@@ -488,33 +527,10 @@ static struct audit_entry *audit_rule_to_entry(struct audit_rule *rule)
                                 goto exit_free;
                         break;
                 }
-
-                entry->rule.vers_ops = (f->op & AUDIT_OPERATORS) ? 2 : 1;
-
-                /* Support for legacy operators where
-                 * AUDIT_NEGATE bit signifies != and otherwise assumes == */
-                if (f->op & AUDIT_NEGATE)
-                        f->op = AUDIT_NOT_EQUAL;
-                else if (!f->op)
-                        f->op = AUDIT_EQUAL;
-                else if (f->op == AUDIT_OPERATORS) {
-                        err = -EINVAL;
-                        goto exit_free;
-                }
         }
 
-        ino_f = entry->rule.inode_f;
-        if (ino_f) {
-                switch(ino_f->op) {
-                case AUDIT_NOT_EQUAL:
-                        entry->rule.inode_f = NULL;
-                case AUDIT_EQUAL:
-                        break;
-                default:
-                        err = -EINVAL;
-                        goto exit_free;
-                }
-        }
+        if (entry->rule.inode_f && entry->rule.inode_f->op == Audit_not_equal)
+                entry->rule.inode_f = NULL;
 
 exit_nofree:
         return entry;
@@ -530,7 +546,6 @@ static struct audit_entry *audit_data_to_entry(struct audit_rule_data *data,
 {
         int err = 0;
         struct audit_entry *entry;
-        struct audit_field *ino_f;
         void *bufp;
         size_t remain = datasz - sizeof(struct audit_rule_data);
         int i;
@@ -546,11 +561,11 @@ static struct audit_entry *audit_data_to_entry(struct audit_rule_data *data,
                 struct audit_field *f = &entry->rule.fields[i];
 
                 err = -EINVAL;
-                if (!(data->fieldflags[i] & AUDIT_OPERATORS) ||
-                    data->fieldflags[i] & ~AUDIT_OPERATORS)
+
+                f->op = audit_to_op(data->fieldflags[i]);
+                if (f->op == Audit_bad)
                         goto exit_free;
 
-                f->op = data->fieldflags[i] & AUDIT_OPERATORS;
                 f->type = data->fields[i];
                 f->val = data->values[i];
                 f->lsm_str = NULL;
@@ -662,18 +677,8 @@ static struct audit_entry *audit_data_to_entry(struct audit_rule_data *data,
                 }
         }
 
-        ino_f = entry->rule.inode_f;
-        if (ino_f) {
-                switch(ino_f->op) {
-                case AUDIT_NOT_EQUAL:
-                        entry->rule.inode_f = NULL;
-                case AUDIT_EQUAL:
-                        break;
-                default:
-                        err = -EINVAL;
-                        goto exit_free;
-                }
-        }
+        if (entry->rule.inode_f && entry->rule.inode_f->op == Audit_not_equal)
+                entry->rule.inode_f = NULL;
 
 exit_nofree:
         return entry;
@@ -713,10 +718,10 @@ static struct audit_rule *audit_krule_to_rule(struct audit_krule *krule)
                 rule->fields[i] = krule->fields[i].type;
 
                 if (krule->vers_ops == 1) {
-                        if (krule->fields[i].op & AUDIT_NOT_EQUAL)
+                        if (krule->fields[i].op == Audit_not_equal)
                                 rule->fields[i] |= AUDIT_NEGATE;
                 } else {
-                        rule->fields[i] |= krule->fields[i].op;
+                        rule->fields[i] |= audit_ops[krule->fields[i].op];
                 }
         }
         for (i = 0; i < AUDIT_BITMASK_SIZE; i++) rule->mask[i] = krule->mask[i];
@@ -744,7 +749,7 @@ static struct audit_rule_data *audit_krule_to_data(struct audit_krule *krule)
                 struct audit_field *f = &krule->fields[i];
 
                 data->fields[i] = f->type;
-                data->fieldflags[i] = f->op;
+                data->fieldflags[i] = audit_ops[f->op];
                 switch(f->type) {
                 case AUDIT_SUBJ_USER:
                 case AUDIT_SUBJ_ROLE:
@@ -919,6 +924,7 @@ static struct audit_entry *audit_dupe_rule(struct audit_krule *old,
         new->action = old->action;
         for (i = 0; i < AUDIT_BITMASK_SIZE; i++)
                 new->mask[i] = old->mask[i];
+        new->prio = old->prio;
         new->buflen = old->buflen;
         new->inode_f = old->inode_f;
         new->watch = NULL;
@@ -987,9 +993,8 @@ static void audit_update_watch(struct audit_parent *parent,
 
                 /* If the update involves invalidating rules, do the inode-based
                  * filtering now, so we don't omit records. */
-                if (invalidating && current->audit_context &&
-                    audit_filter_inodes(current, current->audit_context) == AUDIT_RECORD_CONTEXT)
-                        audit_set_auditable(current->audit_context);
+                if (invalidating && current->audit_context)
+                        audit_filter_inodes(current, current->audit_context);
 
                 nwatch = audit_dupe_watch(owatch);
                 if (IS_ERR(nwatch)) {
@@ -1007,12 +1012,15 @@ static void audit_update_watch(struct audit_parent *parent,
                         list_del_rcu(&oentry->list);
 
                         nentry = audit_dupe_rule(&oentry->rule, nwatch);
-                        if (IS_ERR(nentry))
+                        if (IS_ERR(nentry)) {
+                                list_del(&oentry->rule.list);
                                 audit_panic("error updating watch, removing");
-                        else {
+                        } else {
                                 int h = audit_hash_ino((u32)ino);
                                 list_add(&nentry->rule.rlist, &nwatch->rules);
                                 list_add_rcu(&nentry->list, &audit_inode_hash[h]);
+                                list_replace(&oentry->rule.list,
+                                             &nentry->rule.list);
                         }
 
                         call_rcu(&oentry->rcu, audit_free_rule_rcu);
@@ -1077,6 +1085,7 @@ static void audit_remove_parent_watches(struct audit_parent *parent)
                                 audit_log_end(ab);
                         }
                         list_del(&r->rlist);
+                        list_del(&r->list);
                         list_del_rcu(&e->list);
                         call_rcu(&e->rcu, audit_free_rule_rcu);
                 }
@@ -1102,12 +1111,16 @@ static void audit_inotify_unregister(struct list_head *in_list)
 /* Find an existing audit rule.
  * Caller must hold audit_filter_mutex to prevent stale rule data. */
 static struct audit_entry *audit_find_rule(struct audit_entry *entry,
-                                           struct list_head *list)
+                                           struct list_head **p)
 {
         struct audit_entry *e, *found = NULL;
+        struct list_head *list;
         int h;
 
-        if (entry->rule.watch) {
+        if (entry->rule.inode_f) {
+                h = audit_hash_ino(entry->rule.inode_f->val);
+                *p = list = &audit_inode_hash[h];
+        } else if (entry->rule.watch) {
                 /* we don't know the inode number, so must walk entire hash */
                 for (h = 0; h < AUDIT_INODE_BUCKETS; h++) {
                         list = &audit_inode_hash[h];
@@ -1118,6 +1131,8 @@ static struct audit_entry *audit_find_rule(struct audit_entry *entry,
                                 }
                 }
                 goto out;
+        } else {
+                *p = list = &audit_filter_list[entry->rule.listnr];
         }
 
         list_for_each_entry(e, list, list)
@@ -1258,15 +1273,17 @@ static int audit_add_watch(struct audit_krule *krule, struct nameidata *ndp,
         return ret;
 }
 
+static u64 prio_low = ~0ULL/2;
+static u64 prio_high = ~0ULL/2 - 1;
+
 /* Add rule to given filterlist if not a duplicate. */
-static inline int audit_add_rule(struct audit_entry *entry,
-                                 struct list_head *list)
+static inline int audit_add_rule(struct audit_entry *entry)
 {
         struct audit_entry *e;
-        struct audit_field *inode_f = entry->rule.inode_f;
         struct audit_watch *watch = entry->rule.watch;
         struct audit_tree *tree = entry->rule.tree;
         struct nameidata *ndp = NULL, *ndw = NULL;
+        struct list_head *list;
         int h, err;
 #ifdef CONFIG_AUDITSYSCALL
         int dont_count = 0;
@@ -1277,13 +1294,8 @@ static inline int audit_add_rule(struct audit_entry *entry,
                 dont_count = 1;
 #endif
 
-        if (inode_f) {
-                h = audit_hash_ino(inode_f->val);
-                list = &audit_inode_hash[h];
-        }
-
         mutex_lock(&audit_filter_mutex);
-        e = audit_find_rule(entry, list);
+        e = audit_find_rule(entry, &list);
         mutex_unlock(&audit_filter_mutex);
         if (e) {
                 err = -EEXIST;
@@ -1319,10 +1331,22 @@ static inline int audit_add_rule(struct audit_entry *entry,
                 }
         }
 
+        entry->rule.prio = ~0ULL;
+        if (entry->rule.listnr == AUDIT_FILTER_EXIT) {
+                if (entry->rule.flags & AUDIT_FILTER_PREPEND)
+                        entry->rule.prio = ++prio_high;
+                else
+                        entry->rule.prio = --prio_low;
+        }
+
         if (entry->rule.flags & AUDIT_FILTER_PREPEND) {
+                list_add(&entry->rule.list,
+                         &audit_rules_list[entry->rule.listnr]);
                 list_add_rcu(&entry->list, list);
                 entry->rule.flags &= ~AUDIT_FILTER_PREPEND;
         } else {
+                list_add_tail(&entry->rule.list,
+                              &audit_rules_list[entry->rule.listnr]);
                 list_add_tail_rcu(&entry->list, list);
         }
 #ifdef CONFIG_AUDITSYSCALL
@@ -1345,15 +1369,14 @@ error:
 }
 
 /* Remove an existing rule from filterlist. */
-static inline int audit_del_rule(struct audit_entry *entry,
-                                 struct list_head *list)
+static inline int audit_del_rule(struct audit_entry *entry)
 {
         struct audit_entry  *e;
-        struct audit_field *inode_f = entry->rule.inode_f;
         struct audit_watch *watch, *tmp_watch = entry->rule.watch;
         struct audit_tree *tree = entry->rule.tree;
+        struct list_head *list;
         LIST_HEAD(inotify_list);
-        int h, ret = 0;
+        int ret = 0;
 #ifdef CONFIG_AUDITSYSCALL
         int dont_count = 0;
 
@@ -1363,13 +1386,8 @@ static inline int audit_del_rule(struct audit_entry *entry,
                 dont_count = 1;
 #endif
 
-        if (inode_f) {
-                h = audit_hash_ino(inode_f->val);
-                list = &audit_inode_hash[h];
-        }
-
         mutex_lock(&audit_filter_mutex);
-        e = audit_find_rule(entry, list);
+        e = audit_find_rule(entry, &list);
         if (!e) {
                 mutex_unlock(&audit_filter_mutex);
                 ret = -ENOENT;
@@ -1404,6 +1422,7 @@ static inline int audit_del_rule(struct audit_entry *entry,
                 audit_remove_tree_rule(&e->rule);
 
         list_del_rcu(&e->list);
+        list_del(&e->rule.list);
         call_rcu(&e->rcu, audit_free_rule_rcu);
 
 #ifdef CONFIG_AUDITSYSCALL
@@ -1432,30 +1451,16 @@ out:
 static void audit_list(int pid, int seq, struct sk_buff_head *q)
 {
         struct sk_buff *skb;
-        struct audit_entry *entry;
+        struct audit_krule *r;
         int i;
 
         /* This is a blocking read, so use audit_filter_mutex instead of rcu
          * iterator to sync with list writers. */
         for (i=0; i<AUDIT_NR_FILTERS; i++) {
-                list_for_each_entry(entry, &audit_filter_list[i], list) {
-                        struct audit_rule *rule;
-
-                        rule = audit_krule_to_rule(&entry->rule);
-                        if (unlikely(!rule))
-                                break;
-                        skb = audit_make_reply(pid, seq, AUDIT_LIST, 0, 1,
-                                         rule, sizeof(*rule));
-                        if (skb)
-                                skb_queue_tail(q, skb);
-                        kfree(rule);
-                }
-        }
-        for (i = 0; i < AUDIT_INODE_BUCKETS; i++) {
-                list_for_each_entry(entry, &audit_inode_hash[i], list) {
+                list_for_each_entry(r, &audit_rules_list[i], list) {
                         struct audit_rule *rule;
 
-                        rule = audit_krule_to_rule(&entry->rule);
+                        rule = audit_krule_to_rule(r);
                         if (unlikely(!rule))
                                 break;
                         skb = audit_make_reply(pid, seq, AUDIT_LIST, 0, 1,
@@ -1474,30 +1479,16 @@ static void audit_list(int pid, int seq, struct sk_buff_head *q)
 static void audit_list_rules(int pid, int seq, struct sk_buff_head *q)
 {
         struct sk_buff *skb;
-        struct audit_entry *e;
+        struct audit_krule *r;
         int i;
 
         /* This is a blocking read, so use audit_filter_mutex instead of rcu
          * iterator to sync with list writers. */
         for (i=0; i<AUDIT_NR_FILTERS; i++) {
-                list_for_each_entry(e, &audit_filter_list[i], list) {
-                        struct audit_rule_data *data;
-
-                        data = audit_krule_to_data(&e->rule);
-                        if (unlikely(!data))
-                                break;
-                        skb = audit_make_reply(pid, seq, AUDIT_LIST_RULES, 0, 1,
-                                         data, sizeof(*data) + data->buflen);
-                        if (skb)
-                                skb_queue_tail(q, skb);
-                        kfree(data);
-                }
-        }
-        for (i=0; i< AUDIT_INODE_BUCKETS; i++) {
-                list_for_each_entry(e, &audit_inode_hash[i], list) {
+                list_for_each_entry(r, &audit_rules_list[i], list) {
                         struct audit_rule_data *data;
 
-                        data = audit_krule_to_data(&e->rule);
+                        data = audit_krule_to_data(r);
                         if (unlikely(!data))
                                 break;
                         skb = audit_make_reply(pid, seq, AUDIT_LIST_RULES, 0, 1,
@@ -1603,8 +1594,7 @@ int audit_receive_filter(int type, int pid, int uid, int seq, void *data,
                 if (IS_ERR(entry))
                         return PTR_ERR(entry);
 
-                err = audit_add_rule(entry,
-                                     &audit_filter_list[entry->rule.listnr]);
+                err = audit_add_rule(entry);
                 audit_log_rule_change(loginuid, sessionid, sid, "add",
                                       &entry->rule, !err);
 
@@ -1620,8 +1610,7 @@ int audit_receive_filter(int type, int pid, int uid, int seq, void *data,
                 if (IS_ERR(entry))
                         return PTR_ERR(entry);
 
-                err = audit_del_rule(entry,
-                                     &audit_filter_list[entry->rule.listnr]);
+                err = audit_del_rule(entry);
                 audit_log_rule_change(loginuid, sessionid, sid, "remove",
                                       &entry->rule, !err);
 
@@ -1634,28 +1623,29 @@ int audit_receive_filter(int type, int pid, int uid, int seq, void *data,
         return err;
 }
 
-int audit_comparator(const u32 left, const u32 op, const u32 right)
+int audit_comparator(u32 left, u32 op, u32 right)
 {
         switch (op) {
-        case AUDIT_EQUAL:
+        case Audit_equal:
                 return (left == right);
-        case AUDIT_NOT_EQUAL:
+        case Audit_not_equal:
                 return (left != right);
-        case AUDIT_LESS_THAN:
+        case Audit_lt:
                 return (left < right);
-        case AUDIT_LESS_THAN_OR_EQUAL:
+        case Audit_le:
                 return (left <= right);
-        case AUDIT_GREATER_THAN:
+        case Audit_gt:
                 return (left > right);
-        case AUDIT_GREATER_THAN_OR_EQUAL:
+        case Audit_ge:
                 return (left >= right);
-        case AUDIT_BIT_MASK:
+        case Audit_bitmask:
                 return (left & right);
-        case AUDIT_BIT_TEST:
+        case Audit_bittest:
                 return ((left & right) == right);
+        default:
+                BUG();
+                return 0;
         }
-        BUG();
-        return 0;
 }
 
 /* Compare given dentry name with last component in given path,
@@ -1778,6 +1768,43 @@ unlock_and_return:
         return result;
 }
 
+static int update_lsm_rule(struct audit_krule *r)
+{
+        struct audit_entry *entry = container_of(r, struct audit_entry, rule);
+        struct audit_entry *nentry;
+        struct audit_watch *watch;
+        struct audit_tree *tree;
+        int err = 0;
+
+        if (!security_audit_rule_known(r))
+                return 0;
+
+        watch = r->watch;
+        tree = r->tree;
+        nentry = audit_dupe_rule(r, watch);
+        if (IS_ERR(nentry)) {
+                /* save the first error encountered for the
+                 * return value */
+                err = PTR_ERR(nentry);
+                audit_panic("error updating LSM filters");
+                if (watch)
+                        list_del(&r->rlist);
+                list_del_rcu(&entry->list);
+                list_del(&r->list);
+        } else {
+                if (watch) {
+                        list_add(&nentry->rule.rlist, &watch->rules);
+                        list_del(&r->rlist);
+                } else if (tree)
+                        list_replace_init(&r->rlist, &nentry->rule.rlist);
+                list_replace_rcu(&entry->list, &nentry->list);
+                list_replace(&r->list, &nentry->rule.list);
+        }
+        call_rcu(&entry->rcu, audit_free_rule_rcu);
+
+        return err;
+}
+
 /* This function will re-initialize the lsm_rule field of all applicable rules.
  * It will traverse the filter lists serarching for rules that contain LSM
  * specific filter fields.  When such a rule is found, it is copied, the
@@ -1785,45 +1812,19 @@ unlock_and_return:
  * updated rule. */
 int audit_update_lsm_rules(void)
 {
-        struct audit_entry *entry, *n, *nentry;
-        struct audit_watch *watch;
-        struct audit_tree *tree;
+        struct audit_krule *r, *n;
         int i, err = 0;
 
         /* audit_filter_mutex synchronizes the writers */
         mutex_lock(&audit_filter_mutex);
 
         for (i = 0; i < AUDIT_NR_FILTERS; i++) {
-                list_for_each_entry_safe(entry, n, &audit_filter_list[i], list) {
-                        if (!security_audit_rule_known(&entry->rule))
-                                continue;
-
-                        watch = entry->rule.watch;
-                        tree = entry->rule.tree;
-                        nentry = audit_dupe_rule(&entry->rule, watch);
-                        if (IS_ERR(nentry)) {
-                                /* save the first error encountered for the
-                                 * return value */
-                                if (!err)
-                                        err = PTR_ERR(nentry);
-                                audit_panic("error updating LSM filters");
-                                if (watch)
-                                        list_del(&entry->rule.rlist);
-                                list_del_rcu(&entry->list);
-                        } else {
-                                if (watch) {
-                                        list_add(&nentry->rule.rlist,
-                                                 &watch->rules);
-                                        list_del(&entry->rule.rlist);
-                                } else if (tree)
-                                        list_replace_init(&entry->rule.rlist,
-                                                     &nentry->rule.rlist);
-                                list_replace_rcu(&entry->list, &nentry->list);
-                        }
-                        call_rcu(&entry->rcu, audit_free_rule_rcu);
+                list_for_each_entry_safe(r, n, &audit_rules_list[i], list) {
+                        int res = update_lsm_rule(r);
+                        if (!err)
+                                err = res;
                 }
         }
-
         mutex_unlock(&audit_filter_mutex);
 
         return err;
diff --git a/kernel/auditsc.c b/kernel/auditsc.c
index 4819f3711973..8cbddff6c283 100644
--- a/kernel/auditsc.c
+++ b/kernel/auditsc.c
@@ -124,43 +124,6 @@ struct audit_aux_data {
 /* Number of target pids per aux struct. */
 #define AUDIT_AUX_PIDS  16
 
-struct audit_aux_data_mq_open {
-        struct audit_aux_data   d;
-        int                     oflag;
-        mode_t                  mode;
-        struct mq_attr          attr;
-};
-
-struct audit_aux_data_mq_sendrecv {
-        struct audit_aux_data   d;
-        mqd_t                   mqdes;
-        size_t                  msg_len;
-        unsigned int            msg_prio;
-        struct timespec         abs_timeout;
-};
-
-struct audit_aux_data_mq_notify {
-        struct audit_aux_data   d;
-        mqd_t                   mqdes;
-        struct sigevent         notification;
-};
-
-struct audit_aux_data_mq_getsetattr {
-        struct audit_aux_data   d;
-        mqd_t                   mqdes;
-        struct mq_attr          mqstat;
-};
-
-struct audit_aux_data_ipcctl {
-        struct audit_aux_data   d;
-        struct ipc_perm         p;
-        unsigned long           qbytes;
-        uid_t                   uid;
-        gid_t                   gid;
-        mode_t                  mode;
-        u32                     osid;
-};
-
 struct audit_aux_data_execve {
         struct audit_aux_data   d;
         int argc;
@@ -168,23 +131,6 @@ struct audit_aux_data_execve {
         struct mm_struct *mm;
 };
 
-struct audit_aux_data_socketcall {
-        struct audit_aux_data   d;
-        int                     nargs;
-        unsigned long           args[0];
-};
-
-struct audit_aux_data_sockaddr {
-        struct audit_aux_data   d;
-        int                     len;
-        char                    a[0];
-};
-
-struct audit_aux_data_fd_pair {
-        struct  audit_aux_data d;
-        int     fd[2];
-};
-
 struct audit_aux_data_pids {
         struct audit_aux_data   d;
         pid_t                   target_pid[AUDIT_AUX_PIDS];
@@ -219,14 +165,14 @@ struct audit_tree_refs {
 struct audit_context {
         int                 dummy;      /* must be the first element */
         int                 in_syscall; /* 1 if task is in a syscall */
-        enum audit_state    state;
+        enum audit_state    state, current_state;
         unsigned int        serial;     /* serial number for record */
         struct timespec     ctime;      /* time of syscall entry */
         int                 major;      /* syscall number */
         unsigned long       argv[4];    /* syscall arguments */
         int                 return_valid; /* return code is valid */
         long                return_code;/* syscall return code */
-        int                 auditable;  /* 1 if record should be written */
+        u64                 prio;
         int                 name_count;
         struct audit_names  names[AUDIT_NAMES];
         char *              filterkey;  /* key for rule that triggered record */
@@ -234,7 +180,8 @@ struct audit_context {
         struct audit_context *previous; /* For nested syscalls */
         struct audit_aux_data *aux;
         struct audit_aux_data *aux_pids;
-
+        struct sockaddr_storage *sockaddr;
+        size_t sockaddr_len;
                                 /* Save things to print about task_struct */
         pid_t               pid, ppid;
         uid_t               uid, euid, suid, fsuid;
@@ -252,6 +199,49 @@ struct audit_context {
         struct audit_tree_refs *trees, *first_trees;
         int tree_count;
 
+        int type;
+        union {
+                struct {
+                        int nargs;
+                        long args[6];
+                } socketcall;
+                struct {
+                        uid_t                   uid;
+                        gid_t                   gid;
+                        mode_t                  mode;
+                        u32                     osid;
+                        int                     has_perm;
+                        uid_t                   perm_uid;
+                        gid_t                   perm_gid;
+                        mode_t                  perm_mode;
+                        unsigned long           qbytes;
+                } ipc;
+                struct {
+                        mqd_t                   mqdes;
+                        struct mq_attr          mqstat;
+                } mq_getsetattr;
+                struct {
+                        mqd_t                   mqdes;
+                        int                     sigev_signo;
+                } mq_notify;
+                struct {
+                        mqd_t                   mqdes;
+                        size_t                  msg_len;
+                        unsigned int            msg_prio;
+                        struct timespec         abs_timeout;
+                } mq_sendrecv;
+                struct {
+                        int                     oflag;
+                        mode_t                  mode;
+                        struct mq_attr          attr;
+                } mq_open;
+                struct {
+                        pid_t                   pid;
+                        struct audit_cap_data   cap;
+                } capset;
+        };
+        int fds[2];
+
 #if AUDIT_DEBUG
         int                 put_count;
         int                 ino_count;
@@ -608,19 +598,12 @@ static int audit_filter_rules(struct task_struct *tsk,
                                         }
                                 }
                                 /* Find ipc objects that match */
-                                if (ctx) {
-                                        struct audit_aux_data *aux;
-                                        for (aux = ctx->aux; aux;
-                                             aux = aux->next) {
-                                                if (aux->type == AUDIT_IPC) {
-                                                        struct audit_aux_data_ipcctl *axi = (void *)aux;
-                                                        if (security_audit_rule_match(axi->osid, f->type, f->op, f->lsm_rule, ctx)) {
-                                                                ++result;
-                                                                break;
-                                                        }
-                                                }
-                                        }
-                                }
+                                if (!ctx || ctx->type != AUDIT_IPC)
+                                        break;
+                                if (security_audit_rule_match(ctx->ipc.osid,
+                                                              f->type, f->op,
+                                                              f->lsm_rule, ctx))
+                                        ++result;
                         }
                         break;
                 case AUDIT_ARG0:
@@ -647,8 +630,16 @@ static int audit_filter_rules(struct task_struct *tsk,
                         return 0;
                 }
         }
-        if (rule->filterkey && ctx)
-                ctx->filterkey = kstrdup(rule->filterkey, GFP_ATOMIC);
+
+        if (ctx) {
+                if (rule->prio <= ctx->prio)
+                        return 0;
+                if (rule->filterkey) {
+                        kfree(ctx->filterkey);
+                        ctx->filterkey = kstrdup(rule->filterkey, GFP_ATOMIC);
+                }
+                ctx->prio = rule->prio;
+        }
         switch (rule->action) {
         case AUDIT_NEVER:    *state = AUDIT_DISABLED;       break;
         case AUDIT_ALWAYS:   *state = AUDIT_RECORD_CONTEXT; break;
@@ -661,7 +652,7 @@ static int audit_filter_rules(struct task_struct *tsk,
  * completely disabled for this task.  Since we only have the task
  * structure at this point, we can only check uid and gid.
  */
-static enum audit_state audit_filter_task(struct task_struct *tsk)
+static enum audit_state audit_filter_task(struct task_struct *tsk, char **key)
 {
         struct audit_entry *e;
         enum audit_state   state;
@@ -669,6 +660,8 @@ static enum audit_state audit_filter_task(struct task_struct *tsk)
         rcu_read_lock();
         list_for_each_entry_rcu(e, &audit_filter_list[AUDIT_FILTER_TASK], list) {
                 if (audit_filter_rules(tsk, &e->rule, NULL, NULL, &state)) {
+                        if (state == AUDIT_RECORD_CONTEXT)
+                                *key = kstrdup(e->rule.filterkey, GFP_ATOMIC);
                         rcu_read_unlock();
                         return state;
                 }
@@ -702,6 +695,7 @@ static enum audit_state audit_filter_syscall(struct task_struct *tsk,
                             audit_filter_rules(tsk, &e->rule, ctx, NULL,
                                                &state)) {
                                 rcu_read_unlock();
+                                ctx->current_state = state;
                                 return state;
                         }
                 }
@@ -715,15 +709,14 @@ static enum audit_state audit_filter_syscall(struct task_struct *tsk,
  * buckets applicable to the inode numbers in audit_names[].
  * Regarding audit_state, same rules apply as for audit_filter_syscall().
  */
-enum audit_state audit_filter_inodes(struct task_struct *tsk,
-                                     struct audit_context *ctx)
+void audit_filter_inodes(struct task_struct *tsk, struct audit_context *ctx)
 {
         int i;
         struct audit_entry *e;
         enum audit_state state;
 
         if (audit_pid && tsk->tgid == audit_pid)
-                return AUDIT_DISABLED;
+                return;
 
         rcu_read_lock();
         for (i = 0; i < ctx->name_count; i++) {
@@ -740,17 +733,20 @@ enum audit_state audit_filter_inodes(struct task_struct *tsk,
                         if ((e->rule.mask[word] & bit) == bit &&
                             audit_filter_rules(tsk, &e->rule, ctx, n, &state)) {
                                 rcu_read_unlock();
-                                return state;
+                                ctx->current_state = state;
+                                return;
                         }
                 }
         }
         rcu_read_unlock();
-        return AUDIT_BUILD_CONTEXT;
 }
 
-void audit_set_auditable(struct audit_context *ctx)
+static void audit_set_auditable(struct audit_context *ctx)
 {
-        ctx->auditable = 1;
+        if (!ctx->prio) {
+                ctx->prio = 1;
+                ctx->current_state = AUDIT_RECORD_CONTEXT;
+        }
 }
 
 static inline struct audit_context *audit_get_context(struct task_struct *tsk,
@@ -781,23 +777,11 @@ static inline struct audit_context *audit_get_context(struct task_struct *tsk,
         else
                 context->return_code  = return_code;
 
-        if (context->in_syscall && !context->dummy && !context->auditable) {
-                enum audit_state state;
-
-                state = audit_filter_syscall(tsk, context, &audit_filter_list[AUDIT_FILTER_EXIT]);
-                if (state == AUDIT_RECORD_CONTEXT) {
-                        context->auditable = 1;
-                        goto get_context;
-                }
-
-                state = audit_filter_inodes(tsk, context);
-                if (state == AUDIT_RECORD_CONTEXT)
-                        context->auditable = 1;
-
+        if (context->in_syscall && !context->dummy) {
+                audit_filter_syscall(tsk, context, &audit_filter_list[AUDIT_FILTER_EXIT]);
+                audit_filter_inodes(tsk, context);
         }
 
-get_context:
-
         tsk->audit_context = NULL;
         return context;
 }
@@ -807,8 +791,7 @@ static inline void audit_free_names(struct audit_context *context)
         int i;
 
 #if AUDIT_DEBUG == 2
-        if (context->auditable
-            ||context->put_count + context->ino_count != context->name_count) {
+        if (context->put_count + context->ino_count != context->name_count) {
                 printk(KERN_ERR "%s:%d(:%d): major=%d in_syscall=%d"
                        " name_count=%d put_count=%d"
                        " ino_count=%d [NOT freeing]\n",
@@ -859,6 +842,7 @@ static inline void audit_zero_context(struct audit_context *context,
 {
         memset(context, 0, sizeof(*context));
         context->state      = state;
+        context->prio = state == AUDIT_RECORD_CONTEXT ? ~0ULL : 0;
 }
 
 static inline struct audit_context *audit_alloc_context(enum audit_state state)
@@ -884,18 +868,21 @@ int audit_alloc(struct task_struct *tsk)
 {
         struct audit_context *context;
         enum audit_state     state;
+        char *key = NULL;
 
         if (likely(!audit_ever_enabled))
                 return 0; /* Return if not auditing. */
 
-        state = audit_filter_task(tsk);
+        state = audit_filter_task(tsk, &key);
         if (likely(state == AUDIT_DISABLED))
                 return 0;
 
         if (!(context = audit_alloc_context(state))) {
+                kfree(key);
                 audit_log_lost("out of memory in audit_alloc");
                 return -ENOMEM;
         }
+        context->filterkey = key;
 
         tsk->audit_context  = context;
         set_tsk_thread_flag(tsk, TIF_SYSCALL_AUDIT);
@@ -921,6 +908,7 @@ static inline void audit_free_context(struct audit_context *context)
                 free_tree_refs(context);
                 audit_free_aux(context);
                 kfree(context->filterkey);
+                kfree(context->sockaddr);
                 kfree(context);
                 context  = previous;
         } while (context);
@@ -1230,6 +1218,97 @@ static void audit_log_fcaps(struct audit_buffer *ab, struct audit_names *name)
                 audit_log_format(ab, " cap_fe=%d cap_fver=%x", name->fcap.fE, name->fcap_ver);
 }
 
+static void show_special(struct audit_context *context, int *call_panic)
+{
+        struct audit_buffer *ab;
+        int i;
+
+        ab = audit_log_start(context, GFP_KERNEL, context->type);
+        if (!ab)
+                return;
+
+        switch (context->type) {
+        case AUDIT_SOCKETCALL: {
+                int nargs = context->socketcall.nargs;
+                audit_log_format(ab, "nargs=%d", nargs);
+                for (i = 0; i < nargs; i++)
+                        audit_log_format(ab, " a%d=%lx", i,
+                                context->socketcall.args[i]);
+                break; }
+        case AUDIT_IPC: {
+                u32 osid = context->ipc.osid;
+
+                audit_log_format(ab, "ouid=%u ogid=%u mode=%#o",
+                         context->ipc.uid, context->ipc.gid, context->ipc.mode);
+                if (osid) {
+                        char *ctx = NULL;
+                        u32 len;
+                        if (security_secid_to_secctx(osid, &ctx, &len)) {
+                                audit_log_format(ab, " osid=%u", osid);
+                                *call_panic = 1;
+                        } else {
+                                audit_log_format(ab, " obj=%s", ctx);
+                                security_release_secctx(ctx, len);
+                        }
+                }
+                if (context->ipc.has_perm) {
+                        audit_log_end(ab);
+                        ab = audit_log_start(context, GFP_KERNEL,
+                                             AUDIT_IPC_SET_PERM);
+                        audit_log_format(ab,
+                                "qbytes=%lx ouid=%u ogid=%u mode=%#o",
+                                context->ipc.qbytes,
+                                context->ipc.perm_uid,
+                                context->ipc.perm_gid,
+                                context->ipc.perm_mode);
+                        if (!ab)
+                                return;
+                }
+                break; }
+        case AUDIT_MQ_OPEN: {
+                audit_log_format(ab,
+                        "oflag=0x%x mode=%#o mq_flags=0x%lx mq_maxmsg=%ld "
+                        "mq_msgsize=%ld mq_curmsgs=%ld",
+                        context->mq_open.oflag, context->mq_open.mode,
+                        context->mq_open.attr.mq_flags,
+                        context->mq_open.attr.mq_maxmsg,
+                        context->mq_open.attr.mq_msgsize,
+                        context->mq_open.attr.mq_curmsgs);
+                break; }
+        case AUDIT_MQ_SENDRECV: {
+                audit_log_format(ab,
+                        "mqdes=%d msg_len=%zd msg_prio=%u "
+                        "abs_timeout_sec=%ld abs_timeout_nsec=%ld",
+                        context->mq_sendrecv.mqdes,
+                        context->mq_sendrecv.msg_len,
+                        context->mq_sendrecv.msg_prio,
+                        context->mq_sendrecv.abs_timeout.tv_sec,
+                        context->mq_sendrecv.abs_timeout.tv_nsec);
+                break; }
+        case AUDIT_MQ_NOTIFY: {
+                audit_log_format(ab, "mqdes=%d sigev_signo=%d",
+                                context->mq_notify.mqdes,
+                                context->mq_notify.sigev_signo);
+                break; }
+        case AUDIT_MQ_GETSETATTR: {
+                struct mq_attr *attr = &context->mq_getsetattr.mqstat;
+                audit_log_format(ab,
+                        "mqdes=%d mq_flags=0x%lx mq_maxmsg=%ld mq_msgsize=%ld "
+                        "mq_curmsgs=%ld ",
+                        context->mq_getsetattr.mqdes,
+                        attr->mq_flags, attr->mq_maxmsg,
+                        attr->mq_msgsize, attr->mq_curmsgs);
+                break; }
+        case AUDIT_CAPSET: {
+                audit_log_format(ab, "pid=%d", context->capset.pid);
+                audit_log_cap(ab, "cap_pi", &context->capset.cap.inheritable);
+                audit_log_cap(ab, "cap_pp", &context->capset.cap.permitted);
+                audit_log_cap(ab, "cap_pe", &context->capset.cap.effective);
+                break; }
+        }
+        audit_log_end(ab);
+}
+
 static void audit_log_exit(struct audit_context *context, struct task_struct *tsk)
 {
         const struct cred *cred;
@@ -1307,94 +1386,12 @@ static void audit_log_exit(struct audit_context *context, struct task_struct *ts
                         continue; /* audit_panic has been called */
 
                 switch (aux->type) {
-                case AUDIT_MQ_OPEN: {
-                        struct audit_aux_data_mq_open *axi = (void *)aux;
-                        audit_log_format(ab,
-                                "oflag=0x%x mode=%#o mq_flags=0x%lx mq_maxmsg=%ld "
-                                "mq_msgsize=%ld mq_curmsgs=%ld",
-                                axi->oflag, axi->mode, axi->attr.mq_flags,
-                                axi->attr.mq_maxmsg, axi->attr.mq_msgsize,
-                                axi->attr.mq_curmsgs);
-                        break; }
-
-                case AUDIT_MQ_SENDRECV: {
-                        struct audit_aux_data_mq_sendrecv *axi = (void *)aux;
-                        audit_log_format(ab,
-                                "mqdes=%d msg_len=%zd msg_prio=%u "
-                                "abs_timeout_sec=%ld abs_timeout_nsec=%ld",
-                                axi->mqdes, axi->msg_len, axi->msg_prio,
-                                axi->abs_timeout.tv_sec, axi->abs_timeout.tv_nsec);
-                        break; }
-
-                case AUDIT_MQ_NOTIFY: {
-                        struct audit_aux_data_mq_notify *axi = (void *)aux;
-                        audit_log_format(ab,
-                                "mqdes=%d sigev_signo=%d",
-                                axi->mqdes,
-                                axi->notification.sigev_signo);
-                        break; }
-
-                case AUDIT_MQ_GETSETATTR: {
-                        struct audit_aux_data_mq_getsetattr *axi = (void *)aux;
-                        audit_log_format(ab,
-                                "mqdes=%d mq_flags=0x%lx mq_maxmsg=%ld mq_msgsize=%ld "
-                                "mq_curmsgs=%ld ",
-                                axi->mqdes,
-                                axi->mqstat.mq_flags, axi->mqstat.mq_maxmsg,
-                                axi->mqstat.mq_msgsize, axi->mqstat.mq_curmsgs);
-                        break; }
-
-                case AUDIT_IPC: {
-                        struct audit_aux_data_ipcctl *axi = (void *)aux;
-                        audit_log_format(ab, 
-                                 "ouid=%u ogid=%u mode=%#o",
-                                 axi->uid, axi->gid, axi->mode);
-                        if (axi->osid != 0) {
-                                char *ctx = NULL;
-                                u32 len;
-                                if (security_secid_to_secctx(
-                                                axi->osid, &ctx, &len)) {
-                                        audit_log_format(ab, " osid=%u",
-                                                        axi->osid);
-                                        call_panic = 1;
-                                } else {
-                                        audit_log_format(ab, " obj=%s", ctx);
-                                        security_release_secctx(ctx, len);
-                                }
-                        }
-                        break; }
-
-                case AUDIT_IPC_SET_PERM: {
-                        struct audit_aux_data_ipcctl *axi = (void *)aux;
-                        audit_log_format(ab,
-                                "qbytes=%lx ouid=%u ogid=%u mode=%#o",
-                                axi->qbytes, axi->uid, axi->gid, axi->mode);
-                        break; }
 
                 case AUDIT_EXECVE: {
                         struct audit_aux_data_execve *axi = (void *)aux;
                         audit_log_execve_info(context, &ab, axi);
                         break; }
 
-                case AUDIT_SOCKETCALL: {
-                        struct audit_aux_data_socketcall *axs = (void *)aux;
-                        audit_log_format(ab, "nargs=%d", axs->nargs);
-                        for (i=0; i<axs->nargs; i++)
-                                audit_log_format(ab, " a%d=%lx", i, axs->args[i]);
-                        break; }
-
-                case AUDIT_SOCKADDR: {
-                        struct audit_aux_data_sockaddr *axs = (void *)aux;
-
-                        audit_log_format(ab, "saddr=");
-                        audit_log_n_hex(ab, axs->a, axs->len);
-                        break; }
-
-                case AUDIT_FD_PAIR: {
-                        struct audit_aux_data_fd_pair *axs = (void *)aux;
-                        audit_log_format(ab, "fd0=%d fd1=%d", axs->fd[0], axs->fd[1]);
-                        break; }
-
                 case AUDIT_BPRM_FCAPS: {
                         struct audit_aux_data_bprm_fcaps *axs = (void *)aux;
                         audit_log_format(ab, "fver=%x", axs->fcap_ver);
@@ -1409,18 +1406,32 @@ static void audit_log_exit(struct audit_context *context, struct task_struct *ts
                         audit_log_cap(ab, "new_pe", &axs->new_pcap.effective);
                         break; }
 
-                case AUDIT_CAPSET: {
-                        struct audit_aux_data_capset *axs = (void *)aux;
-                        audit_log_format(ab, "pid=%d", axs->pid);
-                        audit_log_cap(ab, "cap_pi", &axs->cap.inheritable);
-                        audit_log_cap(ab, "cap_pp", &axs->cap.permitted);
-                        audit_log_cap(ab, "cap_pe", &axs->cap.effective);
-                        break; }
-
                 }
                 audit_log_end(ab);
         }
 
+        if (context->type)
+                show_special(context, &call_panic);
+
+        if (context->fds[0] >= 0) {
+                ab = audit_log_start(context, GFP_KERNEL, AUDIT_FD_PAIR);
+                if (ab) {
+                        audit_log_format(ab, "fd0=%d fd1=%d",
+                                        context->fds[0], context->fds[1]);
+                        audit_log_end(ab);
+                }
+        }
+
+        if (context->sockaddr_len) {
+                ab = audit_log_start(context, GFP_KERNEL, AUDIT_SOCKADDR);
+                if (ab) {
+                        audit_log_format(ab, "saddr=");
+                        audit_log_n_hex(ab, (void *)context->sockaddr,
+                                        context->sockaddr_len);
+                        audit_log_end(ab);
+                }
+        }
+
         for (aux = context->aux_pids; aux; aux = aux->next) {
                 struct audit_aux_data_pids *axs = (void *)aux;
 
@@ -1536,7 +1547,7 @@ void audit_free(struct task_struct *tsk)
          * We use GFP_ATOMIC here because we might be doing this
          * in the context of the idle thread */
         /* that can happen only if we are called from do_exit() */
-        if (context->in_syscall && context->auditable)
+        if (context->in_syscall && context->current_state == AUDIT_RECORD_CONTEXT)
                 audit_log_exit(context, tsk);
 
         audit_free_context(context);
@@ -1620,15 +1631,17 @@ void audit_syscall_entry(int arch, int major,
 
         state = context->state;
         context->dummy = !audit_n_rules;
-        if (!context->dummy && (state == AUDIT_SETUP_CONTEXT || state == AUDIT_BUILD_CONTEXT))
+        if (!context->dummy && state == AUDIT_BUILD_CONTEXT) {
+                context->prio = 0;
                 state = audit_filter_syscall(tsk, context, &audit_filter_list[AUDIT_FILTER_ENTRY]);
+        }
         if (likely(state == AUDIT_DISABLED))
                 return;
 
         context->serial     = 0;
         context->ctime      = CURRENT_TIME;
         context->in_syscall = 1;
-        context->auditable  = !!(state == AUDIT_RECORD_CONTEXT);
+        context->current_state  = state;
         context->ppid       = 0;
 }
 
@@ -1636,17 +1649,20 @@ void audit_finish_fork(struct task_struct *child)
 {
         struct audit_context *ctx = current->audit_context;
         struct audit_context *p = child->audit_context;
-        if (!p || !ctx || !ctx->auditable)
+        if (!p || !ctx)
+                return;
+        if (!ctx->in_syscall || ctx->current_state != AUDIT_RECORD_CONTEXT)
                 return;
         p->arch = ctx->arch;
         p->major = ctx->major;
         memcpy(p->argv, ctx->argv, sizeof(ctx->argv));
         p->ctime = ctx->ctime;
         p->dummy = ctx->dummy;
-        p->auditable = ctx->auditable;
         p->in_syscall = ctx->in_syscall;
         p->filterkey = kstrdup(ctx->filterkey, GFP_KERNEL);
         p->ppid = current->pid;
+        p->prio = ctx->prio;
+        p->current_state = ctx->current_state;
 }
 
 /**
@@ -1670,11 +1686,11 @@ void audit_syscall_exit(int valid, long return_code)
         if (likely(!context))
                 return;
 
-        if (context->in_syscall && context->auditable)
+        if (context->in_syscall && context->current_state == AUDIT_RECORD_CONTEXT)
                 audit_log_exit(context, tsk);
 
         context->in_syscall = 0;
-        context->auditable  = 0;
+        context->prio = context->state == AUDIT_RECORD_CONTEXT ? ~0ULL : 0;
 
         if (context->previous) {
                 struct audit_context *new_context = context->previous;
@@ -1689,8 +1705,13 @@ void audit_syscall_exit(int valid, long return_code)
                 context->aux_pids = NULL;
                 context->target_pid = 0;
                 context->target_sid = 0;
-                kfree(context->filterkey);
-                context->filterkey = NULL;
+                context->sockaddr_len = 0;
+                context->type = 0;
+                context->fds[0] = -1;
+                if (context->state != AUDIT_RECORD_CONTEXT) {
+                        kfree(context->filterkey);
+                        context->filterkey = NULL;
+                }
                 tsk->audit_context = context;
         }
 }
@@ -2081,7 +2102,10 @@ int auditsc_get_stamp(struct audit_context *ctx,
         t->tv_sec  = ctx->ctime.tv_sec;
         t->tv_nsec = ctx->ctime.tv_nsec;
         *serial    = ctx->serial;
-        ctx->auditable = 1;
+        if (!ctx->prio) {
+                ctx->prio = 1;
+                ctx->current_state = AUDIT_RECORD_CONTEXT;
+        }
         return 1;
 }
 
@@ -2127,132 +2151,46 @@ int audit_set_loginuid(struct task_struct *task, uid_t loginuid)
  * @mode: mode bits
  * @u_attr: queue attributes
  *
- * Returns 0 for success or NULL context or < 0 on error.
  */
-int __audit_mq_open(int oflag, mode_t mode, struct mq_attr __user *u_attr)
+void __audit_mq_open(int oflag, mode_t mode, struct mq_attr *attr)
 {
-        struct audit_aux_data_mq_open *ax;
         struct audit_context *context = current->audit_context;
 
-        if (!audit_enabled)
-                return 0;
-
-        if (likely(!context))
-                return 0;
-
-        ax = kmalloc(sizeof(*ax), GFP_ATOMIC);
-        if (!ax)
-                return -ENOMEM;
-
-        if (u_attr != NULL) {
-                if (copy_from_user(&ax->attr, u_attr, sizeof(ax->attr))) {
-                        kfree(ax);
-                        return -EFAULT;
-                }
-        } else
-                memset(&ax->attr, 0, sizeof(ax->attr));
+        if (attr)
+                memcpy(&context->mq_open.attr, attr, sizeof(struct mq_attr));
+        else
+                memset(&context->mq_open.attr, 0, sizeof(struct mq_attr));
 
-        ax->oflag = oflag;
-        ax->mode = mode;
+        context->mq_open.oflag = oflag;
+        context->mq_open.mode = mode;
 
-        ax->d.type = AUDIT_MQ_OPEN;
-        ax->d.next = context->aux;
-        context->aux = (void *)ax;
-        return 0;
+        context->type = AUDIT_MQ_OPEN;
 }
 
 /**
- * __audit_mq_timedsend - record audit data for a POSIX MQ timed send
+ * __audit_mq_sendrecv - record audit data for a POSIX MQ timed send/receive
  * @mqdes: MQ descriptor
  * @msg_len: Message length
  * @msg_prio: Message priority
- * @u_abs_timeout: Message timeout in absolute time
+ * @abs_timeout: Message timeout in absolute time
  *
- * Returns 0 for success or NULL context or < 0 on error.
  */
-int __audit_mq_timedsend(mqd_t mqdes, size_t msg_len, unsigned int msg_prio,
-                        const struct timespec __user *u_abs_timeout)
+void __audit_mq_sendrecv(mqd_t mqdes, size_t msg_len, unsigned int msg_prio,
+                        const struct timespec *abs_timeout)
 {
-        struct audit_aux_data_mq_sendrecv *ax;
         struct audit_context *context = current->audit_context;
+        struct timespec *p = &context->mq_sendrecv.abs_timeout;
 
-        if (!audit_enabled)
-                return 0;
-
-        if (likely(!context))
-                return 0;
-
-        ax = kmalloc(sizeof(*ax), GFP_ATOMIC);
-        if (!ax)
-                return -ENOMEM;
-
-        if (u_abs_timeout != NULL) {
-                if (copy_from_user(&ax->abs_timeout, u_abs_timeout, sizeof(ax->abs_timeout))) {
-                        kfree(ax);
-                        return -EFAULT;
-                }
-        } else
-                memset(&ax->abs_timeout, 0, sizeof(ax->abs_timeout));
-
-        ax->mqdes = mqdes;
-        ax->msg_len = msg_len;
-        ax->msg_prio = msg_prio;
-
-        ax->d.type = AUDIT_MQ_SENDRECV;
-        ax->d.next = context->aux;
-        context->aux = (void *)ax;
-        return 0;
-}
-
-/**
- * __audit_mq_timedreceive - record audit data for a POSIX MQ timed receive
- * @mqdes: MQ descriptor
- * @msg_len: Message length
- * @u_msg_prio: Message priority
- * @u_abs_timeout: Message timeout in absolute time
- *
- * Returns 0 for success or NULL context or < 0 on error.
- */
-int __audit_mq_timedreceive(mqd_t mqdes, size_t msg_len,
-                                unsigned int __user *u_msg_prio,
-                                const struct timespec __user *u_abs_timeout)
-{
-        struct audit_aux_data_mq_sendrecv *ax;
-        struct audit_context *context = current->audit_context;
-
-        if (!audit_enabled)
-                return 0;
-
-        if (likely(!context))
-                return 0;
-
-        ax = kmalloc(sizeof(*ax), GFP_ATOMIC);
-        if (!ax)
-                return -ENOMEM;
-
-        if (u_msg_prio != NULL) {
-                if (get_user(ax->msg_prio, u_msg_prio)) {
-                        kfree(ax);
-                        return -EFAULT;
-                }
-        } else
-                ax->msg_prio = 0;
-
-        if (u_abs_timeout != NULL) {
-                if (copy_from_user(&ax->abs_timeout, u_abs_timeout, sizeof(ax->abs_timeout))) {
-                        kfree(ax);
-                        return -EFAULT;
-                }
-        } else
-                memset(&ax->abs_timeout, 0, sizeof(ax->abs_timeout));
+        if (abs_timeout)
+                memcpy(p, abs_timeout, sizeof(struct timespec));
+        else
+                memset(p, 0, sizeof(struct timespec));
 
-        ax->mqdes = mqdes;
-        ax->msg_len = msg_len;
+        context->mq_sendrecv.mqdes = mqdes;
+        context->mq_sendrecv.msg_len = msg_len;
+        context->mq_sendrecv.msg_prio = msg_prio;
 
-        ax->d.type = AUDIT_MQ_SENDRECV;
-        ax->d.next = context->aux;
-        context->aux = (void *)ax;
-        return 0;
+        context->type = AUDIT_MQ_SENDRECV;
 }
 
 /**
@@ -2260,38 +2198,19 @@ int __audit_mq_timedreceive(mqd_t mqdes, size_t msg_len,
  * @mqdes: MQ descriptor
  * @u_notification: Notification event
  *
- * Returns 0 for success or NULL context or < 0 on error.
  */
 
-int __audit_mq_notify(mqd_t mqdes, const struct sigevent __user *u_notification)
+void __audit_mq_notify(mqd_t mqdes, const struct sigevent *notification)
 {
-        struct audit_aux_data_mq_notify *ax;
         struct audit_context *context = current->audit_context;
 
-        if (!audit_enabled)
-                return 0;
-
-        if (likely(!context))
-                return 0;
-
-        ax = kmalloc(sizeof(*ax), GFP_ATOMIC);
-        if (!ax)
-                return -ENOMEM;
-
-        if (u_notification != NULL) {
-                if (copy_from_user(&ax->notification, u_notification, sizeof(ax->notification))) {
-                        kfree(ax);
-                        return -EFAULT;
-                }
-        } else
-                memset(&ax->notification, 0, sizeof(ax->notification));
-
-        ax->mqdes = mqdes;
+        if (notification)
+                context->mq_notify.sigev_signo = notification->sigev_signo;
+        else
+                context->mq_notify.sigev_signo = 0;
 
-        ax->d.type = AUDIT_MQ_NOTIFY;
-        ax->d.next = context->aux;
-        context->aux = (void *)ax;
-        return 0;
+        context->mq_notify.mqdes = mqdes;
+        context->type = AUDIT_MQ_NOTIFY;
 }
 
 /**
@@ -2299,55 +2218,29 @@ int __audit_mq_notify(mqd_t mqdes, const struct sigevent __user *u_notification)
  * @mqdes: MQ descriptor
  * @mqstat: MQ flags
  *
- * Returns 0 for success or NULL context or < 0 on error.
  */
-int __audit_mq_getsetattr(mqd_t mqdes, struct mq_attr *mqstat)
+void __audit_mq_getsetattr(mqd_t mqdes, struct mq_attr *mqstat)
 {
-        struct audit_aux_data_mq_getsetattr *ax;
         struct audit_context *context = current->audit_context;
-
-        if (!audit_enabled)
-                return 0;
-
-        if (likely(!context))
-                return 0;
-
-        ax = kmalloc(sizeof(*ax), GFP_ATOMIC);
-        if (!ax)
-                return -ENOMEM;
-
-        ax->mqdes = mqdes;
-        ax->mqstat = *mqstat;
-
-        ax->d.type = AUDIT_MQ_GETSETATTR;
-        ax->d.next = context->aux;
-        context->aux = (void *)ax;
-        return 0;
+        context->mq_getsetattr.mqdes = mqdes;
+        context->mq_getsetattr.mqstat = *mqstat;
+        context->type = AUDIT_MQ_GETSETATTR;
 }
 
 /**
  * audit_ipc_obj - record audit data for ipc object
  * @ipcp: ipc permissions
  *
- * Returns 0 for success or NULL context or < 0 on error.
  */
-int __audit_ipc_obj(struct kern_ipc_perm *ipcp)
+void __audit_ipc_obj(struct kern_ipc_perm *ipcp)
 {
-        struct audit_aux_data_ipcctl *ax;
         struct audit_context *context = current->audit_context;
-
-        ax = kmalloc(sizeof(*ax), GFP_ATOMIC);
-        if (!ax)
-                return -ENOMEM;
-
-        ax->uid = ipcp->uid;
-        ax->gid = ipcp->gid;
-        ax->mode = ipcp->mode;
-        security_ipc_getsecid(ipcp, &ax->osid);
-        ax->d.type = AUDIT_IPC;
-        ax->d.next = context->aux;
-        context->aux = (void *)ax;
-        return 0;
+        context->ipc.uid = ipcp->uid;
+        context->ipc.gid = ipcp->gid;
+        context->ipc.mode = ipcp->mode;
+        context->ipc.has_perm = 0;
+        security_ipc_getsecid(ipcp, &context->ipc.osid);
+        context->type = AUDIT_IPC;
 }
 
 /**
@@ -2357,26 +2250,17 @@ int __audit_ipc_obj(struct kern_ipc_perm *ipcp)
  * @gid: msgq group id
  * @mode: msgq mode (permissions)
  *
- * Returns 0 for success or NULL context or < 0 on error.
+ * Called only after audit_ipc_obj().
  */
-int __audit_ipc_set_perm(unsigned long qbytes, uid_t uid, gid_t gid, mode_t mode)
+void __audit_ipc_set_perm(unsigned long qbytes, uid_t uid, gid_t gid, mode_t mode)
 {
-        struct audit_aux_data_ipcctl *ax;
         struct audit_context *context = current->audit_context;
 
-        ax = kmalloc(sizeof(*ax), GFP_ATOMIC);
-        if (!ax)
-                return -ENOMEM;
-
-        ax->qbytes = qbytes;
-        ax->uid = uid;
-        ax->gid = gid;
-        ax->mode = mode;
-
-        ax->d.type = AUDIT_IPC_SET_PERM;
-        ax->d.next = context->aux;
-        context->aux = (void *)ax;
-        return 0;
+        context->ipc.qbytes = qbytes;
+        context->ipc.perm_uid = uid;
+        context->ipc.perm_gid = gid;
+        context->ipc.perm_mode = mode;
+        context->ipc.has_perm = 1;
 }
 
 int audit_bprm(struct linux_binprm *bprm)
@@ -2406,27 +2290,17 @@ int audit_bprm(struct linux_binprm *bprm)
  * @nargs: number of args
  * @args: args array
  *
- * Returns 0 for success or NULL context or < 0 on error.
  */
-int audit_socketcall(int nargs, unsigned long *args)
+void audit_socketcall(int nargs, unsigned long *args)
 {
-        struct audit_aux_data_socketcall *ax;
         struct audit_context *context = current->audit_context;
 
         if (likely(!context || context->dummy))
-                return 0;
-
-        ax = kmalloc(sizeof(*ax) + nargs * sizeof(unsigned long), GFP_KERNEL);
-        if (!ax)
-                return -ENOMEM;
-
-        ax->nargs = nargs;
-        memcpy(ax->args, args, nargs * sizeof(unsigned long));
+                return;
 
-        ax->d.type = AUDIT_SOCKETCALL;
-        ax->d.next = context->aux;
-        context->aux = (void *)ax;
-        return 0;
+        context->type = AUDIT_SOCKETCALL;
+        context->socketcall.nargs = nargs;
+        memcpy(context->socketcall.args, args, nargs * sizeof(unsigned long));
 }
 
 /**
@@ -2434,29 +2308,12 @@ int audit_socketcall(int nargs, unsigned long *args)
  * @fd1: the first file descriptor
  * @fd2: the second file descriptor
  *
- * Returns 0 for success or NULL context or < 0 on error.
  */
-int __audit_fd_pair(int fd1, int fd2)
+void __audit_fd_pair(int fd1, int fd2)
 {
         struct audit_context *context = current->audit_context;
-        struct audit_aux_data_fd_pair *ax;
-
-        if (likely(!context)) {
-                return 0;
-        }
-
-        ax = kmalloc(sizeof(*ax), GFP_KERNEL);
-        if (!ax) {
-                return -ENOMEM;
-        }
-
-        ax->fd[0] = fd1;
-        ax->fd[1] = fd2;
-
-        ax->d.type = AUDIT_FD_PAIR;
-        ax->d.next = context->aux;
-        context->aux = (void *)ax;
-        return 0;
+        context->fds[0] = fd1;
+        context->fds[1] = fd2;
 }
 
 /**
@@ -2468,22 +2325,20 @@ int __audit_fd_pair(int fd1, int fd2)
  */
 int audit_sockaddr(int len, void *a)
 {
-        struct audit_aux_data_sockaddr *ax;
         struct audit_context *context = current->audit_context;
 
         if (likely(!context || context->dummy))
                 return 0;
 
-        ax = kmalloc(sizeof(*ax) + len, GFP_KERNEL);
-        if (!ax)
-                return -ENOMEM;
-
-        ax->len = len;
-        memcpy(ax->a, a, len);
+        if (!context->sockaddr) {
+                void *p = kmalloc(sizeof(struct sockaddr_storage), GFP_KERNEL);
+                if (!p)
+                        return -ENOMEM;
+                context->sockaddr = p;
+        }
 
-        ax->d.type = AUDIT_SOCKADDR;
-        ax->d.next = context->aux;
-        context->aux = (void *)ax;
+        context->sockaddr_len = len;
+        memcpy(context->sockaddr, a, len);
         return 0;
 }
 
@@ -2617,29 +2472,15 @@ int __audit_log_bprm_fcaps(struct linux_binprm *bprm,
  * Record the aguments userspace sent to sys_capset for later printing by the
  * audit system if applicable
  */
-int __audit_log_capset(pid_t pid,
+void __audit_log_capset(pid_t pid,
                        const struct cred *new, const struct cred *old)
 {
-        struct audit_aux_data_capset *ax;
         struct audit_context *context = current->audit_context;
-
-        if (likely(!audit_enabled || !context || context->dummy))
-                return 0;
-
-        ax = kmalloc(sizeof(*ax), GFP_KERNEL);
-        if (!ax)
-                return -ENOMEM;
-
-        ax->d.type = AUDIT_CAPSET;
-        ax->d.next = context->aux;
-        context->aux = (void *)ax;
-
-        ax->pid = pid;
-        ax->cap.effective   = new->cap_effective;
-        ax->cap.inheritable = new->cap_effective;
-        ax->cap.permitted   = new->cap_permitted;
-
-        return 0;
+        context->capset.pid = pid;
+        context->capset.cap.effective   = new->cap_effective;
+        context->capset.cap.inheritable = new->cap_effective;
+        context->capset.cap.permitted   = new->cap_permitted;
+        context->type = AUDIT_CAPSET;
 }
 
 /**
diff --git a/kernel/capability.c b/kernel/capability.c
index 36b4b4daebec..c598d9d5be4f 100644
--- a/kernel/capability.c
+++ b/kernel/capability.c
@@ -280,9 +280,7 @@ asmlinkage long sys_capset(cap_user_header_t header, const cap_user_data_t data)
         if (ret < 0)
                 goto error;
 
-        ret = audit_log_capset(pid, new, current_cred());
-        if (ret < 0)
-                return ret;
+        audit_log_capset(pid, new, current_cred());
 
         return commit_creds(new);
 
diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index 48348dde6d81..891a84eb9d30 100644
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -2945,7 +2945,11 @@ int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *subsys,
         parent = task_cgroup(tsk, subsys->subsys_id);
 
         /* Pin the hierarchy */
-        atomic_inc(&parent->root->sb->s_active);
+        if (!atomic_inc_not_zero(&parent->root->sb->s_active)) {
+                /* We race with the final deactivate_super() */
+                mutex_unlock(&cgroup_mutex);
+                return 0;
+        }
 
         /* Keep the cgroup alive */
         get_css_set(cg);
diff --git a/kernel/compat.c b/kernel/compat.c
index 8eafe3eb50d9..d52e2ec1deb5 100644
--- a/kernel/compat.c
+++ b/kernel/compat.c
@@ -454,16 +454,16 @@ asmlinkage long compat_sys_waitid(int which, compat_pid_t pid,
 }
 
 static int compat_get_user_cpu_mask(compat_ulong_t __user *user_mask_ptr,
-                                    unsigned len, cpumask_t *new_mask)
+                                    unsigned len, struct cpumask *new_mask)
 {
         unsigned long *k;
 
-        if (len < sizeof(cpumask_t))
-                memset(new_mask, 0, sizeof(cpumask_t));
-        else if (len > sizeof(cpumask_t))
-                len = sizeof(cpumask_t);
+        if (len < cpumask_size())
+                memset(new_mask, 0, cpumask_size());
+        else if (len > cpumask_size())
+                len = cpumask_size();
 
-        k = cpus_addr(*new_mask);
+        k = cpumask_bits(new_mask);
         return compat_get_bitmap(k, user_mask_ptr, len * 8);
 }
 
@@ -471,40 +471,51 @@ asmlinkage long compat_sys_sched_setaffinity(compat_pid_t pid,
                                              unsigned int len,
                                              compat_ulong_t __user *user_mask_ptr)
 {
-        cpumask_t new_mask;
+        cpumask_var_t new_mask;
         int retval;
 
-        retval = compat_get_user_cpu_mask(user_mask_ptr, len, &new_mask);
+        if (!alloc_cpumask_var(&new_mask, GFP_KERNEL))
+                return -ENOMEM;
+
+        retval = compat_get_user_cpu_mask(user_mask_ptr, len, new_mask);
         if (retval)
-                return retval;
+                goto out;
 
-        return sched_setaffinity(pid, &new_mask);
+        retval = sched_setaffinity(pid, new_mask);
+out:
+        free_cpumask_var(new_mask);
+        return retval;
 }
 
 asmlinkage long compat_sys_sched_getaffinity(compat_pid_t pid, unsigned int len,
                                              compat_ulong_t __user *user_mask_ptr)
 {
         int ret;
-        cpumask_t mask;
+        cpumask_var_t mask;
         unsigned long *k;
-        unsigned int min_length = sizeof(cpumask_t);
+        unsigned int min_length = cpumask_size();
 
-        if (NR_CPUS <= BITS_PER_COMPAT_LONG)
+        if (nr_cpu_ids <= BITS_PER_COMPAT_LONG)
                 min_length = sizeof(compat_ulong_t);
 
         if (len < min_length)
                 return -EINVAL;
 
-        ret = sched_getaffinity(pid, &mask);
+        if (!alloc_cpumask_var(&mask, GFP_KERNEL))
+                return -ENOMEM;
+
+        ret = sched_getaffinity(pid, mask);
         if (ret < 0)
-                return ret;
+                goto out;
 
-        k = cpus_addr(mask);
+        k = cpumask_bits(mask);
         ret = compat_put_bitmap(user_mask_ptr, k, min_length * 8);
-        if (ret)
-                return ret;
+        if (ret == 0)
+                ret = min_length;
 
-        return min_length;
+out:
+        free_cpumask_var(mask);
+        return ret;
 }
 
 int get_compat_itimerspec(struct itimerspec *dst,
diff --git a/kernel/cpu.c b/kernel/cpu.c
index 8ea32e8d68b0..47fff3b63cbf 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)
 {
@@ -217,7 +194,7 @@ static int __ref take_cpu_down(void *_param)
 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 = {
@@ -231,6 +208,9 @@ static int __ref _cpu_down(unsigned int cpu, int tasks_frozen)
         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);
@@ -245,13 +225,11 @@ static int __ref _cpu_down(unsigned int cpu, int tasks_frozen)
         }
 
         /* 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,
@@ -277,7 +255,7 @@ static int __ref _cpu_down(unsigned int cpu, int tasks_frozen)
         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) {
@@ -285,6 +263,7 @@ out_release:
                                             hcpu) == NOTIFY_BAD)
                         BUG();
         }
+        free_cpumask_var(old_allowed);
         return err;
 }
 
@@ -303,7 +282,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
@@ -367,7 +346,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)
@@ -392,25 +371,25 @@ out:
 }
 
 #ifdef CONFIG_PM_SLEEP_SMP
-static cpumask_t frozen_cpus;
+static cpumask_var_t frozen_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(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, frozen_cpus);
                         printk("CPU%d is down\n", cpu);
                 } else {
                         printk(KERN_ERR "Error taking CPU%d down: %d\n",
@@ -436,11 +415,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(frozen_cpus))
                 goto out;
 
         printk("Enabling non-boot CPUs ...\n");
-        for_each_cpu_mask_nr(cpu, frozen_cpus) {
+        for_each_cpu(cpu, frozen_cpus) {
                 error = _cpu_up(cpu, 1);
                 if (!error) {
                         printk("CPU%d is up\n", cpu);
@@ -448,10 +427,18 @@ void __ref enable_nonboot_cpus(void)
                 }
                 printk(KERN_WARNING "Error taking CPU%d up: %d\n", cpu, error);
         }
-        cpus_clear(frozen_cpus);
+        cpumask_clear(frozen_cpus);
 out:
         cpu_maps_update_done();
 }
+
+static int alloc_frozen_cpus(void)
+{
+        if (!alloc_cpumask_var(&frozen_cpus, GFP_KERNEL|__GFP_ZERO))
+                return -ENOMEM;
+        return 0;
+}
+core_initcall(alloc_frozen_cpus);
 #endif /* CONFIG_PM_SLEEP_SMP */
 
 /**
@@ -467,7 +454,7 @@ void __cpuinit notify_cpu_starting(unsigned int cpu)
         unsigned long val = CPU_STARTING;
 
 #ifdef CONFIG_PM_SLEEP_SMP
-        if (cpu_isset(cpu, frozen_cpus))
+        if (frozen_cpus != NULL && cpumask_test_cpu(cpu, frozen_cpus))
                 val = CPU_STARTING_FROZEN;
 #endif /* CONFIG_PM_SLEEP_SMP */
         raw_notifier_call_chain(&cpu_chain, val, (void *)(long)cpu);
@@ -479,7 +466,7 @@ void __cpuinit notify_cpu_starting(unsigned int cpu)
  * 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.
  */
 
@@ -502,3 +489,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..cd0cd8dcb345 100644
--- a/kernel/irq/manage.c
+++ b/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)
@@ -79,7 +86,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 +98,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 +119,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..aae3f742bcec 100644
--- a/kernel/irq/proc.c
+++ b/kernel/irq/proc.c
@@ -20,7 +20,7 @@ static struct proc_dir_entry *root_irq_dir;
 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)
@@ -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)
@@ -84,7 +93,7 @@ static const struct file_operations irq_affinity_proc_fops = {
 
 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;
 }
@@ -92,27 +101,37 @@ static int default_affinity_show(struct seq_file *m, void *v)
 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;
 
+        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)
diff --git a/kernel/kexec.c b/kernel/kexec.c
index ac0fde7b54d0..3fb855ad6aa0 100644
--- a/kernel/kexec.c
+++ b/kernel/kexec.c
@@ -1116,7 +1116,7 @@ void crash_save_cpu(struct pt_regs *regs, int cpu)
         struct elf_prstatus prstatus;
         u32 *buf;
 
-        if ((cpu < 0) || (cpu >= NR_CPUS))
+        if ((cpu < 0) || (cpu >= nr_cpu_ids))
                 return;
 
         /* Using ELF notes here is opportunistic.
diff --git a/kernel/power/poweroff.c b/kernel/power/poweroff.c
index 72016f051477..97890831e1b5 100644
--- a/kernel/power/poweroff.c
+++ b/kernel/power/poweroff.c
@@ -27,7 +27,7 @@ static DECLARE_WORK(poweroff_work, do_poweroff);
 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 = {
diff --git a/kernel/profile.c b/kernel/profile.c
index 60adefb59b5e..d18e2d2654f2 100644
--- a/kernel/profile.c
+++ b/kernel/profile.c
@@ -45,7 +45,7 @@ static unsigned long prof_len, prof_shift;
 int prof_on __read_mostly;
 EXPORT_SYMBOL_GPL(prof_on);
 
-static cpumask_t prof_cpu_mask = CPU_MASK_ALL;
+static cpumask_var_t prof_cpu_mask;
 #ifdef CONFIG_SMP
 static DEFINE_PER_CPU(struct profile_hit *[2], cpu_profile_hits);
 static DEFINE_PER_CPU(int, cpu_profile_flip);
@@ -113,9 +113,13 @@ int __ref profile_init(void)
         buffer_bytes = prof_len*sizeof(atomic_t);
         if (!slab_is_available()) {
                 prof_buffer = alloc_bootmem(buffer_bytes);
+                alloc_bootmem_cpumask_var(&prof_cpu_mask);
                 return 0;
         }
 
+        if (!alloc_cpumask_var(&prof_cpu_mask, GFP_KERNEL))
+                return -ENOMEM;
+
         prof_buffer = kzalloc(buffer_bytes, GFP_KERNEL);
         if (prof_buffer)
                 return 0;
@@ -128,6 +132,7 @@ int __ref profile_init(void)
         if (prof_buffer)
                 return 0;
 
+        free_cpumask_var(prof_cpu_mask);
         return -ENOMEM;
 }
 
@@ -386,13 +391,15 @@ out_free:
                 return NOTIFY_BAD;
         case CPU_ONLINE:
         case CPU_ONLINE_FROZEN:
-                cpu_set(cpu, prof_cpu_mask);
+                if (prof_cpu_mask != NULL)
+                        cpumask_set_cpu(cpu, 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);
+                if (prof_cpu_mask != NULL)
+                        cpumask_clear_cpu(cpu, 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 +437,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) && prof_cpu_mask != NULL &&
+            cpumask_test_cpu(smp_processor_id(), prof_cpu_mask))
                 profile_hit(type, (void *)profile_pc(regs));
 }
 
@@ -442,7 +450,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 +460,20 @@ static int prof_cpu_mask_read_proc(char *page, char **start, off_t off,
 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 +484,7 @@ void create_prof_cpu_mask(struct proc_dir_entry *root_irq_dir)
         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;
 }
diff --git a/kernel/rcuclassic.c b/kernel/rcuclassic.c
index e503a002f330..490934fc7ac3 100644
--- a/kernel/rcuclassic.c
+++ b/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 rcu_data *rdp,
                         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 rcu_data *rdp,
                  * 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 rcu_data *rdp,
                  * 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 rcu_ctrlblk *rcp)
 
         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_ctrlblk *rcp)
         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_ctrlblk *rcp)
                  * unnecessarily.
                  */
                 smp_mb();
-                cpus_andnot(rcp->cpumask, cpu_online_map, 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_ctrlblk *rcp)
  */
 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);
diff --git a/kernel/rcupreempt.c b/kernel/rcupreempt.c
index 04982659875a..f9dc8f3720f6 100644
--- a/kernel/rcupreempt.c
+++ b/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, NR_CPUS) __read_mostly
+        = CPU_BITS_NONE;
 
 /*
  * Enum and per-CPU flag to determine when each CPU has seen
@@ -758,7 +759,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);
         }
@@ -776,7 +777,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);
@@ -808,7 +809,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);
@@ -823,7 +824,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);
         }
@@ -843,7 +844,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);
@@ -1032,7 +1033,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);
 
@@ -1072,7 +1073,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);
 
         /*
@@ -1430,7 +1431,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.
          *
diff --git a/kernel/rcutorture.c b/kernel/rcutorture.c
index b31065522104..3245b40952c6 100644
--- a/kernel/rcutorture.c
+++ b/kernel/rcutorture.c
@@ -868,49 +868,52 @@ static int rcu_idle_cpu;	/* Force all torture tasks off this CPU */
  */
 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
diff --git a/kernel/sched.c b/kernel/sched.c
index fff1c4a20b65..545c6fccd1dc 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -498,18 +498,26 @@ struct rt_rq {
  */
 struct root_domain {
         atomic_t refcount;
-        cpumask_t span;
-        cpumask_t online;
+        cpumask_var_t span;
+        cpumask_var_t online;
 
         /*
          * The "RT overload" flag: it gets set if a CPU has more than
          * one runnable RT task.
          */
-        cpumask_t rto_mask;
+        cpumask_var_t rto_mask;
         atomic_t rto_count;
 #ifdef CONFIG_SMP
         struct cpupri cpupri;
 #endif
+#if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
+        /*
+         * Preferred wake up cpu nominated by sched_mc balance that will be
+         * used when most cpus are idle in the system indicating overall very
+         * low system utilisation. Triggered at POWERSAVINGS_BALANCE_WAKEUP(2)
+         */
+        unsigned int sched_mc_preferred_wakeup_cpu;
+#endif
 };
 
 /*
@@ -1514,7 +1522,7 @@ static int tg_shares_up(struct task_group *tg, void *data)
         struct sched_domain *sd = data;
         int i;
 
-        for_each_cpu_mask(i, sd->span) {
+        for_each_cpu(i, sched_domain_span(sd)) {
                 /*
                  * If there are currently no tasks on the cpu pretend there
                  * is one of average load so that when a new task gets to
@@ -1535,7 +1543,7 @@ static int tg_shares_up(struct task_group *tg, void *data)
         if (!sd->parent || !(sd->parent->flags & SD_LOAD_BALANCE))
                 shares = tg->shares;
 
-        for_each_cpu_mask(i, sd->span)
+        for_each_cpu(i, sched_domain_span(sd))
                 update_group_shares_cpu(tg, i, shares, rq_weight);
 
         return 0;
@@ -2101,15 +2109,17 @@ find_idlest_group(struct sched_domain *sd, struct task_struct *p, int this_cpu)
                 int i;
 
                 /* Skip over this group if it has no CPUs allowed */
-                if (!cpus_intersects(group->cpumask, p->cpus_allowed))
+                if (!cpumask_intersects(sched_group_cpus(group),
+                                        &p->cpus_allowed))
                         continue;
 
-                local_group = cpu_isset(this_cpu, group->cpumask);
+                local_group = cpumask_test_cpu(this_cpu,
+                                               sched_group_cpus(group));
 
                 /* 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, sched_group_cpus(group)) {
                         /* Bias balancing toward cpus of our domain */
                         if (local_group)
                                 load = source_load(i, load_idx);
@@ -2141,17 +2151,14 @@ find_idlest_group(struct sched_domain *sd, struct task_struct *p, int this_cpu)
  * find_idlest_cpu - find the idlest cpu among the cpus in group.
  */
 static int
-find_idlest_cpu(struct sched_group *group, struct task_struct *p, int this_cpu,
-                cpumask_t *tmp)
+find_idlest_cpu(struct sched_group *group, struct task_struct *p, int this_cpu)
 {
         unsigned long load, min_load = ULONG_MAX;
         int idlest = -1;
         int i;
 
         /* Traverse only the allowed CPUs */
-        cpus_and(*tmp, group->cpumask, p->cpus_allowed);
-
-        for_each_cpu_mask_nr(i, *tmp) {
+        for_each_cpu_and(i, sched_group_cpus(group), &p->cpus_allowed) {
                 load = weighted_cpuload(i);
 
                 if (load < min_load || (load == min_load && i == this_cpu)) {
@@ -2193,7 +2200,6 @@ static int sched_balance_self(int cpu, int flag)
                 update_shares(sd);
 
         while (sd) {
-                cpumask_t span, tmpmask;
                 struct sched_group *group;
                 int new_cpu, weight;
 
@@ -2202,14 +2208,13 @@ static int sched_balance_self(int cpu, int flag)
                         continue;
                 }
 
-                span = sd->span;
                 group = find_idlest_group(sd, t, cpu);
                 if (!group) {
                         sd = sd->child;
                         continue;
                 }
 
-                new_cpu = find_idlest_cpu(group, t, cpu, &tmpmask);
+                new_cpu = find_idlest_cpu(group, t, cpu);
                 if (new_cpu == -1 || new_cpu == cpu) {
                         /* Now try balancing at a lower domain level of cpu */
                         sd = sd->child;
@@ -2218,10 +2223,10 @@ static int sched_balance_self(int cpu, int flag)
 
                 /* Now try balancing at a lower domain level of new_cpu */
                 cpu = new_cpu;
+                weight = cpumask_weight(sched_domain_span(sd));
                 sd = NULL;
-                weight = cpus_weight(span);
                 for_each_domain(cpu, tmp) {
-                        if (weight <= cpus_weight(tmp->span))
+                        if (weight <= cpumask_weight(sched_domain_span(tmp)))
                                 break;
                         if (tmp->flags & flag)
                                 sd = tmp;
@@ -2266,7 +2271,7 @@ static int try_to_wake_up(struct task_struct *p, unsigned int state, int sync)
                 cpu = task_cpu(p);
 
                 for_each_domain(this_cpu, sd) {
-                        if (cpu_isset(cpu, sd->span)) {
+                        if (cpumask_test_cpu(cpu, sched_domain_span(sd))) {
                                 update_shares(sd);
                                 break;
                         }
@@ -2315,7 +2320,7 @@ static int try_to_wake_up(struct task_struct *p, unsigned int state, int sync)
         else {
                 struct sched_domain *sd;
                 for_each_domain(this_cpu, sd) {
-                        if (cpu_isset(cpu, sd->span)) {
+                        if (cpumask_test_cpu(cpu, sched_domain_span(sd))) {
                                 schedstat_inc(sd, ttwu_wake_remote);
                                 break;
                         }
@@ -2846,7 +2851,7 @@ static void sched_migrate_task(struct task_struct *p, int dest_cpu)
         struct rq *rq;
 
         rq = task_rq_lock(p, &flags);
-        if (!cpu_isset(dest_cpu, p->cpus_allowed)
+        if (!cpumask_test_cpu(dest_cpu, &p->cpus_allowed)
             || unlikely(!cpu_active(dest_cpu)))
                 goto out;
 
@@ -2911,7 +2916,7 @@ int can_migrate_task(struct task_struct *p, struct rq *rq, int this_cpu,
          * 2) cannot be migrated to this CPU due to cpus_allowed, or
          * 3) are cache-hot on their current CPU.
          */
-        if (!cpu_isset(this_cpu, p->cpus_allowed)) {
+        if (!cpumask_test_cpu(this_cpu, &p->cpus_allowed)) {
                 schedstat_inc(p, se.nr_failed_migrations_affine);
                 return 0;
         }
@@ -3086,7 +3091,7 @@ static int move_one_task(struct rq *this_rq, int this_cpu, struct rq *busiest,
 static struct sched_group *
 find_busiest_group(struct sched_domain *sd, int this_cpu,
                    unsigned long *imbalance, enum cpu_idle_type idle,
-                   int *sd_idle, const cpumask_t *cpus, int *balance)
+                   int *sd_idle, const struct cpumask *cpus, int *balance)
 {
         struct sched_group *busiest = NULL, *this = NULL, *group = sd->groups;
         unsigned long max_load, avg_load, total_load, this_load, total_pwr;
@@ -3122,10 +3127,11 @@ find_busiest_group(struct sched_domain *sd, int this_cpu,
                 unsigned long sum_avg_load_per_task;
                 unsigned long avg_load_per_task;
 
-                local_group = cpu_isset(this_cpu, group->cpumask);
+                local_group = cpumask_test_cpu(this_cpu,
+                                               sched_group_cpus(group));
 
                 if (local_group)
-                        balance_cpu = first_cpu(group->cpumask);
+                        balance_cpu = cpumask_first(sched_group_cpus(group));
 
                 /* Tally up the load of all CPUs in the group */
                 sum_weighted_load = sum_nr_running = avg_load = 0;
@@ -3134,13 +3140,8 @@ find_busiest_group(struct sched_domain *sd, int this_cpu,
                 max_cpu_load = 0;
                 min_cpu_load = ~0UL;
 
-                for_each_cpu_mask_nr(i, group->cpumask) {
-                        struct rq *rq;
-
-                        if (!cpu_isset(i, *cpus))
-                                continue;
-
-                        rq = cpu_rq(i);
+                for_each_cpu_and(i, sched_group_cpus(group), cpus) {
+                        struct rq *rq = cpu_rq(i);
 
                         if (*sd_idle && rq->nr_running)
                                 *sd_idle = 0;
@@ -3251,8 +3252,8 @@ find_busiest_group(struct sched_domain *sd, int this_cpu,
                  */
                 if ((sum_nr_running < min_nr_running) ||
                     (sum_nr_running == min_nr_running &&
-                     first_cpu(group->cpumask) <
-                     first_cpu(group_min->cpumask))) {
+                     cpumask_first(sched_group_cpus(group)) >
+                     cpumask_first(sched_group_cpus(group_min)))) {
                         group_min = group;
                         min_nr_running = sum_nr_running;
                         min_load_per_task = sum_weighted_load /
@@ -3267,8 +3268,8 @@ find_busiest_group(struct sched_domain *sd, int this_cpu,
                 if (sum_nr_running <= group_capacity - 1) {
                         if (sum_nr_running > leader_nr_running ||
                             (sum_nr_running == leader_nr_running &&
-                             first_cpu(group->cpumask) >
-                              first_cpu(group_leader->cpumask))) {
+                             cpumask_first(sched_group_cpus(group)) <
+                             cpumask_first(sched_group_cpus(group_leader)))) {
                                 group_leader = group;
                                 leader_nr_running = sum_nr_running;
                         }
@@ -3394,6 +3395,10 @@ out_balanced:
 
         if (this == group_leader && group_leader != group_min) {
                 *imbalance = min_load_per_task;
+                if (sched_mc_power_savings >= POWERSAVINGS_BALANCE_WAKEUP) {
+                        cpu_rq(this_cpu)->rd->sched_mc_preferred_wakeup_cpu =
+                                cpumask_first(sched_group_cpus(group_leader));
+                }
                 return group_min;
         }
 #endif
@@ -3407,16 +3412,16 @@ ret:
  */
 static struct rq *
 find_busiest_queue(struct sched_group *group, enum cpu_idle_type idle,
-                   unsigned long imbalance, const cpumask_t *cpus)
+                   unsigned long imbalance, const struct cpumask *cpus)
 {
         struct rq *busiest = NULL, *rq;
         unsigned long max_load = 0;
         int i;
 
-        for_each_cpu_mask_nr(i, group->cpumask) {
+        for_each_cpu(i, sched_group_cpus(group)) {
                 unsigned long wl;
 
-                if (!cpu_isset(i, *cpus))
+                if (!cpumask_test_cpu(i, cpus))
                         continue;
 
                 rq = cpu_rq(i);
@@ -3446,7 +3451,7 @@ find_busiest_queue(struct sched_group *group, enum cpu_idle_type idle,
  */
 static int load_balance(int this_cpu, struct rq *this_rq,
                         struct sched_domain *sd, enum cpu_idle_type idle,
-                        int *balance, cpumask_t *cpus)
+                        int *balance, struct cpumask *cpus)
 {
         int ld_moved, all_pinned = 0, active_balance = 0, sd_idle = 0;
         struct sched_group *group;
@@ -3454,7 +3459,7 @@ static int load_balance(int this_cpu, struct rq *this_rq,
         struct rq *busiest;
         unsigned long flags;
 
-        cpus_setall(*cpus);
+        cpumask_setall(cpus);
 
         /*
          * When power savings policy is enabled for the parent domain, idle
@@ -3514,8 +3519,8 @@ redo:
 
                 /* All tasks on this runqueue were pinned by CPU affinity */
                 if (unlikely(all_pinned)) {
-                        cpu_clear(cpu_of(busiest), *cpus);
-                        if (!cpus_empty(*cpus))
+                        cpumask_clear_cpu(cpu_of(busiest), cpus);
+                        if (!cpumask_empty(cpus))
                                 goto redo;
                         goto out_balanced;
                 }
@@ -3532,7 +3537,8 @@ redo:
                         /* don't kick the migration_thread, if the curr
                          * task on busiest cpu can't be moved to this_cpu
                          */
-                        if (!cpu_isset(this_cpu, busiest->curr->cpus_allowed)) {
+                        if (!cpumask_test_cpu(this_cpu,
+                                              &busiest->curr->cpus_allowed)) {
                                 spin_unlock_irqrestore(&busiest->lock, flags);
                                 all_pinned = 1;
                                 goto out_one_pinned;
@@ -3607,7 +3613,7 @@ out:
  */
 static int
 load_balance_newidle(int this_cpu, struct rq *this_rq, struct sched_domain *sd,
-                        cpumask_t *cpus)
+                        struct cpumask *cpus)
 {
         struct sched_group *group;
         struct rq *busiest = NULL;
@@ -3616,7 +3622,7 @@ load_balance_newidle(int this_cpu, struct rq *this_rq, struct sched_domain *sd,
         int sd_idle = 0;
         int all_pinned = 0;
 
-        cpus_setall(*cpus);
+        cpumask_setall(cpus);
 
         /*
          * When power savings policy is enabled for the parent domain, idle
@@ -3660,17 +3666,71 @@ redo:
                 double_unlock_balance(this_rq, busiest);
 
                 if (unlikely(all_pinned)) {
-                        cpu_clear(cpu_of(busiest), *cpus);
-                        if (!cpus_empty(*cpus))
+                        cpumask_clear_cpu(cpu_of(busiest), cpus);
+                        if (!cpumask_empty(cpus))
                                 goto redo;
                 }
         }
 
         if (!ld_moved) {
+                int active_balance = 0;
+
                 schedstat_inc(sd, lb_failed[CPU_NEWLY_IDLE]);
                 if (!sd_idle && sd->flags & SD_SHARE_CPUPOWER &&
                     !test_sd_parent(sd, SD_POWERSAVINGS_BALANCE))
                         return -1;
+
+                if (sched_mc_power_savings < POWERSAVINGS_BALANCE_WAKEUP)
+                        return -1;
+
+                if (sd->nr_balance_failed++ < 2)
+                        return -1;
+
+                /*
+                 * The only task running in a non-idle cpu can be moved to this
+                 * cpu in an attempt to completely freeup the other CPU
+                 * package. The same method used to move task in load_balance()
+                 * have been extended for load_balance_newidle() to speedup
+                 * consolidation at sched_mc=POWERSAVINGS_BALANCE_WAKEUP (2)
+                 *
+                 * The package power saving logic comes from
+                 * find_busiest_group().  If there are no imbalance, then
+                 * f_b_g() will return NULL.  However when sched_mc={1,2} then
+                 * f_b_g() will select a group from which a running task may be
+                 * pulled to this cpu in order to make the other package idle.
+                 * If there is no opportunity to make a package idle and if
+                 * there are no imbalance, then f_b_g() will return NULL and no
+                 * action will be taken in load_balance_newidle().
+                 *
+                 * Under normal task pull operation due to imbalance, there
+                 * will be more than one task in the source run queue and
+                 * move_tasks() will succeed.  ld_moved will be true and this
+                 * active balance code will not be triggered.
+                 */
+
+                /* Lock busiest in correct order while this_rq is held */
+                double_lock_balance(this_rq, busiest);
+
+                /*
+                 * don't kick the migration_thread, if the curr
+                 * task on busiest cpu can't be moved to this_cpu
+                 */
+                if (!cpumask_test_cpu(this_cpu, &busiest->curr->cpus_allowed)) {
+                        double_unlock_balance(this_rq, busiest);
+                        all_pinned = 1;
+                        return ld_moved;
+                }
+
+                if (!busiest->active_balance) {
+                        busiest->active_balance = 1;
+                        busiest->push_cpu = this_cpu;
+                        active_balance = 1;
+                }
+
+                double_unlock_balance(this_rq, busiest);
+                if (active_balance)
+                        wake_up_process(busiest->migration_thread);
+
         } else
                 sd->nr_balance_failed = 0;
 
@@ -3696,7 +3756,10 @@ static void idle_balance(int this_cpu, struct rq *this_rq)
         struct sched_domain *sd;
         int pulled_task = 0;
         unsigned long next_balance = jiffies + HZ;
-        cpumask_t tmpmask;
+        cpumask_var_t tmpmask;
+
+        if (!alloc_cpumask_var(&tmpmask, GFP_ATOMIC))
+                return;
 
         for_each_domain(this_cpu, sd) {
                 unsigned long interval;
@@ -3707,7 +3770,7 @@ static void idle_balance(int this_cpu, struct rq *this_rq)
                 if (sd->flags & SD_BALANCE_NEWIDLE)
                         /* If we've pulled tasks over stop searching: */
                         pulled_task = load_balance_newidle(this_cpu, this_rq,
-                                                           sd, &tmpmask);
+                                                           sd, tmpmask);
 
                 interval = msecs_to_jiffies(sd->balance_interval);
                 if (time_after(next_balance, sd->last_balance + interval))
@@ -3722,6 +3785,7 @@ static void idle_balance(int this_cpu, struct rq *this_rq)
                  */
                 this_rq->next_balance = next_balance;
         }
+        free_cpumask_var(tmpmask);
 }
 
 /*
@@ -3759,7 +3823,7 @@ static void active_load_balance(struct rq *busiest_rq, int busiest_cpu)
         /* Search for an sd spanning us and the target CPU. */
         for_each_domain(target_cpu, sd) {
                 if ((sd->flags & SD_LOAD_BALANCE) &&
-                    cpu_isset(busiest_cpu, sd->span))
+                    cpumask_test_cpu(busiest_cpu, sched_domain_span(sd)))
                                 break;
         }
 
@@ -3778,10 +3842,9 @@ static void active_load_balance(struct rq *busiest_rq, int busiest_cpu)
 #ifdef CONFIG_NO_HZ
 static struct {
         atomic_t load_balancer;
-        cpumask_t cpu_mask;
+        cpumask_var_t cpu_mask;
 } nohz ____cacheline_aligned = {
         .load_balancer = ATOMIC_INIT(-1),
-        .cpu_mask = CPU_MASK_NONE,
 };
 
 /*
@@ -3809,7 +3872,7 @@ int select_nohz_load_balancer(int stop_tick)
         int cpu = smp_processor_id();
 
         if (stop_tick) {
-                cpu_set(cpu, nohz.cpu_mask);
+                cpumask_set_cpu(cpu, nohz.cpu_mask);
                 cpu_rq(cpu)->in_nohz_recently = 1;
 
                 /*
@@ -3823,7 +3886,7 @@ int select_nohz_load_balancer(int stop_tick)
                 }
 
                 /* time for ilb owner also to sleep */
-                if (cpus_weight(nohz.cpu_mask) == num_online_cpus()) {
+                if (cpumask_weight(nohz.cpu_mask) == num_online_cpus()) {
                         if (atomic_read(&nohz.load_balancer) == cpu)
                                 atomic_set(&nohz.load_balancer, -1);
                         return 0;
@@ -3836,10 +3899,10 @@ int select_nohz_load_balancer(int stop_tick)
                 } else if (atomic_read(&nohz.load_balancer) == cpu)
                         return 1;
         } else {
-                if (!cpu_isset(cpu, nohz.cpu_mask))
+                if (!cpumask_test_cpu(cpu, nohz.cpu_mask))
                         return 0;
 
-                cpu_clear(cpu, nohz.cpu_mask);
+                cpumask_clear_cpu(cpu, nohz.cpu_mask);
 
                 if (atomic_read(&nohz.load_balancer) == cpu)
                         if (atomic_cmpxchg(&nohz.load_balancer, cpu, -1) != cpu)
@@ -3867,7 +3930,11 @@ static void rebalance_domains(int cpu, enum cpu_idle_type idle)
         unsigned long next_balance = jiffies + 60*HZ;
         int update_next_balance = 0;
         int need_serialize;
-        cpumask_t tmp;
+        cpumask_var_t tmp;
+
+        /* Fails alloc?  Rebalancing probably not a priority right now. */
+        if (!alloc_cpumask_var(&tmp, GFP_ATOMIC))
+                return;
 
         for_each_domain(cpu, sd) {
                 if (!(sd->flags & SD_LOAD_BALANCE))
@@ -3892,7 +3959,7 @@ static void rebalance_domains(int cpu, enum cpu_idle_type idle)
                 }
 
                 if (time_after_eq(jiffies, sd->last_balance + interval)) {
-                        if (load_balance(cpu, rq, sd, idle, &balance, &tmp)) {
+                        if (load_balance(cpu, rq, sd, idle, &balance, tmp)) {
                                 /*
                                  * We've pulled tasks over so either we're no
                                  * longer idle, or one of our SMT siblings is
@@ -3926,6 +3993,8 @@ out:
          */
         if (likely(update_next_balance))
                 rq->next_balance = next_balance;
+
+        free_cpumask_var(tmp);
 }
 
 /*
@@ -3950,12 +4019,13 @@ static void run_rebalance_domains(struct softirq_action *h)
          */
         if (this_rq->idle_at_tick &&
             atomic_read(&nohz.load_balancer) == this_cpu) {
-                cpumask_t cpus = nohz.cpu_mask;
                 struct rq *rq;
                 int balance_cpu;
 
-                cpu_clear(this_cpu, cpus);
-                for_each_cpu_mask_nr(balance_cpu, cpus) {
+                for_each_cpu(balance_cpu, nohz.cpu_mask) {
+                        if (balance_cpu == this_cpu)
+                                continue;
+
                         /*
                          * If this cpu gets work to do, stop the load balancing
                          * work being done for other cpus. Next load
@@ -3993,7 +4063,7 @@ static inline void trigger_load_balance(struct rq *rq, int cpu)
                 rq->in_nohz_recently = 0;
 
                 if (atomic_read(&nohz.load_balancer) == cpu) {
-                        cpu_clear(cpu, nohz.cpu_mask);
+                        cpumask_clear_cpu(cpu, nohz.cpu_mask);
                         atomic_set(&nohz.load_balancer, -1);
                 }
 
@@ -4006,7 +4076,7 @@ static inline void trigger_load_balance(struct rq *rq, int cpu)
                          * TBD: Traverse the sched domains and nominate
                          * the nearest cpu in the nohz.cpu_mask.
                          */
-                        int ilb = first_cpu(nohz.cpu_mask);
+                        int ilb = cpumask_first(nohz.cpu_mask);
 
                         if (ilb < nr_cpu_ids)
                                 resched_cpu(ilb);
@@ -4018,7 +4088,7 @@ static inline void trigger_load_balance(struct rq *rq, int cpu)
          * cpus with ticks stopped, is it time for that to stop?
          */
         if (rq->idle_at_tick && atomic_read(&nohz.load_balancer) == cpu &&
-            cpus_weight(nohz.cpu_mask) == num_online_cpus()) {
+            cpumask_weight(nohz.cpu_mask) == num_online_cpus()) {
                 resched_cpu(cpu);
                 return;
         }
@@ -4028,7 +4098,7 @@ static inline void trigger_load_balance(struct rq *rq, int cpu)
          * someone else, then no need raise the SCHED_SOFTIRQ
          */
         if (rq->idle_at_tick && atomic_read(&nohz.load_balancer) != cpu &&
-            cpu_isset(cpu, nohz.cpu_mask))
+            cpumask_test_cpu(cpu, nohz.cpu_mask))
                 return;
 #endif
         if (time_after_eq(jiffies, rq->next_balance))
@@ -4080,13 +4150,17 @@ unsigned long long task_delta_exec(struct task_struct *p)
  * Account user cpu time to a process.
  * @p: the process that the cpu time gets accounted to
  * @cputime: the cpu time spent in user space since the last update
+ * @cputime_scaled: cputime scaled by cpu frequency
  */
-void account_user_time(struct task_struct *p, cputime_t cputime)
+void account_user_time(struct task_struct *p, cputime_t cputime,
+                       cputime_t cputime_scaled)
 {
         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
         cputime64_t tmp;
 
+        /* Add user time to process. */
         p->utime = cputime_add(p->utime, cputime);
+        p->utimescaled = cputime_add(p->utimescaled, cputime_scaled);
         account_group_user_time(p, cputime);
 
         /* Add user time to cpustat. */
@@ -4103,51 +4177,48 @@ void account_user_time(struct task_struct *p, cputime_t cputime)
  * Account guest cpu time to a process.
  * @p: the process that the cpu time gets accounted to
  * @cputime: the cpu time spent in virtual machine since the last update
+ * @cputime_scaled: cputime scaled by cpu frequency
  */
-static void account_guest_time(struct task_struct *p, cputime_t cputime)
+static void account_guest_time(struct task_struct *p, cputime_t cputime,
+                               cputime_t cputime_scaled)
 {
         cputime64_t tmp;
         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
 
         tmp = cputime_to_cputime64(cputime);
 
+        /* Add guest time to process. */
         p->utime = cputime_add(p->utime, cputime);
+        p->utimescaled = cputime_add(p->utimescaled, cputime_scaled);
         account_group_user_time(p, cputime);
         p->gtime = cputime_add(p->gtime, cputime);
 
+        /* Add guest time to cpustat. */
         cpustat->user = cputime64_add(cpustat->user, tmp);
         cpustat->guest = cputime64_add(cpustat->guest, tmp);
 }
 
 /*
- * Account scaled user cpu time to a process.
- * @p: the process that the cpu time gets accounted to
- * @cputime: the cpu time spent in user space since the last update
- */
-void account_user_time_scaled(struct task_struct *p, cputime_t cputime)
-{
-        p->utimescaled = cputime_add(p->utimescaled, cputime);
-}
-
-/*
  * Account system cpu time to a process.
  * @p: the process that the cpu time gets accounted to
  * @hardirq_offset: the offset to subtract from hardirq_count()
  * @cputime: the cpu time spent in kernel space since the last update
+ * @cputime_scaled: cputime scaled by cpu frequency
  */
 void account_system_time(struct task_struct *p, int hardirq_offset,
-                         cputime_t cputime)
+                         cputime_t cputime, cputime_t cputime_scaled)
 {
         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
-        struct rq *rq = this_rq();
         cputime64_t tmp;
 
         if ((p->flags & PF_VCPU) && (irq_count() - hardirq_offset == 0)) {
-                account_guest_time(p, cputime);
+                account_guest_time(p, cputime, cputime_scaled);
                 return;
         }
 
+        /* Add system time to process. */
         p->stime = cputime_add(p->stime, cputime);
+        p->stimescaled = cputime_add(p->stimescaled, cputime_scaled);
         account_group_system_time(p, cputime);
 
         /* Add system time to cpustat. */
@@ -4156,48 +4227,84 @@ void account_system_time(struct task_struct *p, int hardirq_offset,
                 cpustat->irq = cputime64_add(cpustat->irq, tmp);
         else if (softirq_count())
                 cpustat->softirq = cputime64_add(cpustat->softirq, tmp);
-        else if (p != rq->idle)
-                cpustat->system = cputime64_add(cpustat->system, tmp);
-        else if (atomic_read(&rq->nr_iowait) > 0)
-                cpustat->iowait = cputime64_add(cpustat->iowait, tmp);
         else
-                cpustat->idle = cputime64_add(cpustat->idle, tmp);
+                cpustat->system = cputime64_add(cpustat->system, tmp);
+
         /* Account for system time used */
         acct_update_integrals(p);
 }
 
 /*
- * Account scaled system cpu time to a process.
- * @p: the process that the cpu time gets accounted to
- * @hardirq_offset: the offset to subtract from hardirq_count()
- * @cputime: the cpu time spent in kernel space since the last update
+ * Account for involuntary wait time.
+ * @steal: the cpu time spent in involuntary wait
  */
-void account_system_time_scaled(struct task_struct *p, cputime_t cputime)
+void account_steal_time(cputime_t cputime)
 {
-        p->stimescaled = cputime_add(p->stimescaled, cputime);
+        struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
+        cputime64_t cputime64 = cputime_to_cputime64(cputime);
+
+        cpustat->steal = cputime64_add(cpustat->steal, cputime64);
 }
 
 /*
- * Account for involuntary wait time.
- * @p: the process from which the cpu time has been stolen
- * @steal: the cpu time spent in involuntary wait
+ * Account for idle time.
+ * @cputime: the cpu time spent in idle wait
  */
-void account_steal_time(struct task_struct *p, cputime_t steal)
+void account_idle_time(cputime_t cputime)
 {
         struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
-        cputime64_t tmp = cputime_to_cputime64(steal);
+        cputime64_t cputime64 = cputime_to_cputime64(cputime);
         struct rq *rq = this_rq();
 
-        if (p == rq->idle) {
-                p->stime = cputime_add(p->stime, steal);
-                if (atomic_read(&rq->nr_iowait) > 0)
-                        cpustat->iowait = cputime64_add(cpustat->iowait, tmp);
-                else
-                        cpustat->idle = cputime64_add(cpustat->idle, tmp);
-        } else
-                cpustat->steal = cputime64_add(cpustat->steal, tmp);
+        if (atomic_read(&rq->nr_iowait) > 0)
+                cpustat->iowait = cputime64_add(cpustat->iowait, cputime64);
+        else
+                cpustat->idle = cputime64_add(cpustat->idle, cputime64);
 }
 
+#ifndef CONFIG_VIRT_CPU_ACCOUNTING
+
+/*
+ * Account a single tick of cpu time.
+ * @p: the process that the cpu time gets accounted to
+ * @user_tick: indicates if the tick is a user or a system tick
+ */
+void account_process_tick(struct task_struct *p, int user_tick)
+{
+        cputime_t one_jiffy = jiffies_to_cputime(1);
+        cputime_t one_jiffy_scaled = cputime_to_scaled(one_jiffy);
+        struct rq *rq = this_rq();
+
+        if (user_tick)
+                account_user_time(p, one_jiffy, one_jiffy_scaled);
+        else if (p != rq->idle)
+                account_system_time(p, HARDIRQ_OFFSET, one_jiffy,
+                                    one_jiffy_scaled);
+        else
+                account_idle_time(one_jiffy);
+}
+
+/*
+ * Account multiple ticks of steal time.
+ * @p: the process from which the cpu time has been stolen
+ * @ticks: number of stolen ticks
+ */
+void account_steal_ticks(unsigned long ticks)
+{
+        account_steal_time(jiffies_to_cputime(ticks));
+}
+
+/*
+ * Account multiple ticks of idle time.
+ * @ticks: number of stolen ticks
+ */
+void account_idle_ticks(unsigned long ticks)
+{
+        account_idle_time(jiffies_to_cputime(ticks));
+}
+
+#endif
+
 /*
  * Use precise platform statistics if available:
  */
@@ -5401,10 +5508,9 @@ out_unlock:
         return retval;
 }
 
-long sched_setaffinity(pid_t pid, const cpumask_t *in_mask)
+long sched_setaffinity(pid_t pid, const struct cpumask *in_mask)
 {
-        cpumask_t cpus_allowed;
-        cpumask_t new_mask = *in_mask;
+        cpumask_var_t cpus_allowed, new_mask;
         struct task_struct *p;
         int retval;
 
@@ -5426,6 +5532,14 @@ long sched_setaffinity(pid_t pid, const cpumask_t *in_mask)
         get_task_struct(p);
         read_unlock(&tasklist_lock);
 
+        if (!alloc_cpumask_var(&cpus_allowed, GFP_KERNEL)) {
+                retval = -ENOMEM;
+                goto out_put_task;
+        }
+        if (!alloc_cpumask_var(&new_mask, GFP_KERNEL)) {
+                retval = -ENOMEM;
+                goto out_free_cpus_allowed;
+        }
         retval = -EPERM;
         if (!check_same_owner(p) && !capable(CAP_SYS_NICE))
                 goto out_unlock;
@@ -5434,37 +5548,41 @@ long sched_setaffinity(pid_t pid, const cpumask_t *in_mask)
         if (retval)
                 goto out_unlock;
 
-        cpuset_cpus_allowed(p, &cpus_allowed);
-        cpus_and(new_mask, new_mask, cpus_allowed);
+        cpuset_cpus_allowed(p, cpus_allowed);
+        cpumask_and(new_mask, in_mask, cpus_allowed);
  again:
-        retval = set_cpus_allowed_ptr(p, &new_mask);
+        retval = set_cpus_allowed_ptr(p, new_mask);
 
         if (!retval) {
-                cpuset_cpus_allowed(p, &cpus_allowed);
-                if (!cpus_subset(new_mask, cpus_allowed)) {
+                cpuset_cpus_allowed(p, cpus_allowed);
+                if (!cpumask_subset(new_mask, cpus_allowed)) {
                         /*
                          * We must have raced with a concurrent cpuset
                          * update. Just reset the cpus_allowed to the
                          * cpuset's cpus_allowed
                          */
-                        new_mask = cpus_allowed;
+                        cpumask_copy(new_mask, cpus_allowed);
                         goto again;
                 }
         }
 out_unlock:
+        free_cpumask_var(new_mask);
+out_free_cpus_allowed:
+        free_cpumask_var(cpus_allowed);
+out_put_task:
         put_task_struct(p);
         put_online_cpus();
         return retval;
 }
 
 static int get_user_cpu_mask(unsigned long __user *user_mask_ptr, unsigned len,
-                             cpumask_t *new_mask)
+                             struct cpumask *new_mask)
 {
-        if (len < sizeof(cpumask_t)) {
-                memset(new_mask, 0, sizeof(cpumask_t));
-        } else if (len > sizeof(cpumask_t)) {
-                len = sizeof(cpumask_t);
-        }
+        if (len < cpumask_size())
+                cpumask_clear(new_mask);
+        else if (len > cpumask_size())
+                len = cpumask_size();
+
         return copy_from_user(new_mask, user_mask_ptr, len) ? -EFAULT : 0;
 }
 
@@ -5477,17 +5595,20 @@ static int get_user_cpu_mask(unsigned long __user *user_mask_ptr, unsigned len,
 asmlinkage long sys_sched_setaffinity(pid_t pid, unsigned int len,
                                       unsigned long __user *user_mask_ptr)
 {
-        cpumask_t new_mask;
+        cpumask_var_t new_mask;
         int retval;
 
-        retval = get_user_cpu_mask(user_mask_ptr, len, &new_mask);
-        if (retval)
-                return retval;
+        if (!alloc_cpumask_var(&new_mask, GFP_KERNEL))
+                return -ENOMEM;
 
-        return sched_setaffinity(pid, &new_mask);
+        retval = get_user_cpu_mask(user_mask_ptr, len, new_mask);
+        if (retval == 0)
+                retval = sched_setaffinity(pid, new_mask);
+        free_cpumask_var(new_mask);
+        return retval;
 }
 
-long sched_getaffinity(pid_t pid, cpumask_t *mask)
+long sched_getaffinity(pid_t pid, struct cpumask *mask)
 {
         struct task_struct *p;
         int retval;
@@ -5504,7 +5625,7 @@ long sched_getaffinity(pid_t pid, cpumask_t *mask)
         if (retval)
                 goto out_unlock;
 
-        cpus_and(*mask, p->cpus_allowed, cpu_online_map);
+        cpumask_and(mask, &p->cpus_allowed, cpu_online_mask);
 
 out_unlock:
         read_unlock(&tasklist_lock);
@@ -5523,19 +5644,24 @@ asmlinkage long sys_sched_getaffinity(pid_t pid, unsigned int len,
                                       unsigned long __user *user_mask_ptr)
 {
         int ret;
-        cpumask_t mask;
+        cpumask_var_t mask;
 
-        if (len < sizeof(cpumask_t))
+        if (len < cpumask_size())
                 return -EINVAL;
 
-        ret = sched_getaffinity(pid, &mask);
-        if (ret < 0)
-                return ret;
+        if (!alloc_cpumask_var(&mask, GFP_KERNEL))
+                return -ENOMEM;
 
-        if (copy_to_user(user_mask_ptr, &mask, sizeof(cpumask_t)))
-                return -EFAULT;
+        ret = sched_getaffinity(pid, mask);
+        if (ret == 0) {
+                if (copy_to_user(user_mask_ptr, mask, cpumask_size()))
+                        ret = -EFAULT;
+                else
+                        ret = cpumask_size();
+        }
+        free_cpumask_var(mask);
 
-        return sizeof(cpumask_t);
+        return ret;
 }
 
 /**
@@ -5877,7 +6003,7 @@ void __cpuinit init_idle(struct task_struct *idle, int cpu)
         idle->se.exec_start = sched_clock();
 
         idle->prio = idle->normal_prio = MAX_PRIO;
-        idle->cpus_allowed = cpumask_of_cpu(cpu);
+        cpumask_copy(&idle->cpus_allowed, cpumask_of(cpu));
         __set_task_cpu(idle, cpu);
 
         rq->curr = rq->idle = idle;
@@ -5904,9 +6030,9 @@ void __cpuinit init_idle(struct task_struct *idle, int cpu)
  * indicates which cpus entered this state. This is used
  * in the rcu update to wait only for active cpus. For system
  * which do not switch off the HZ timer nohz_cpu_mask should
- * always be CPU_MASK_NONE.
+ * always be CPU_BITS_NONE.
  */
-cpumask_t nohz_cpu_mask = CPU_MASK_NONE;
+cpumask_var_t nohz_cpu_mask;
 
 /*
  * Increase the granularity value when there are more CPUs,
@@ -5961,7 +6087,7 @@ static inline void sched_init_granularity(void)
  * task must not exit() & deallocate itself prematurely. The
  * call is not atomic; no spinlocks may be held.
  */
-int set_cpus_allowed_ptr(struct task_struct *p, const cpumask_t *new_mask)
+int set_cpus_allowed_ptr(struct task_struct *p, const struct cpumask *new_mask)
 {
         struct migration_req req;
         unsigned long flags;
@@ -5969,13 +6095,13 @@ int set_cpus_allowed_ptr(struct task_struct *p, const cpumask_t *new_mask)
         int ret = 0;
 
         rq = task_rq_lock(p, &flags);
-        if (!cpus_intersects(*new_mask, cpu_online_map)) {
+        if (!cpumask_intersects(new_mask, cpu_online_mask)) {
                 ret = -EINVAL;
                 goto out;
         }
 
         if (unlikely((p->flags & PF_THREAD_BOUND) && p != current &&
-                     !cpus_equal(p->cpus_allowed, *new_mask))) {
+                     !cpumask_equal(&p->cpus_allowed, new_mask))) {
                 ret = -EINVAL;
                 goto out;
         }
@@ -5983,15 +6109,15 @@ int set_cpus_allowed_ptr(struct task_struct *p, const cpumask_t *new_mask)
         if (p->sched_class->set_cpus_allowed)
                 p->sched_class->set_cpus_allowed(p, new_mask);
         else {
-                p->cpus_allowed = *new_mask;
-                p->rt.nr_cpus_allowed = cpus_weight(*new_mask);
+                cpumask_copy(&p->cpus_allowed, new_mask);
+                p->rt.nr_cpus_allowed = cpumask_weight(new_mask);
         }
 
         /* Can the task run on the task's current CPU? If so, we're done */
-        if (cpu_isset(task_cpu(p), *new_mask))
+        if (cpumask_test_cpu(task_cpu(p), new_mask))
                 goto out;
 
-        if (migrate_task(p, any_online_cpu(*new_mask), &req)) {
+        if (migrate_task(p, cpumask_any_and(cpu_online_mask, new_mask), &req)) {
                 /* Need help from migration thread: drop lock and wait. */
                 task_rq_unlock(rq, &flags);
                 wake_up_process(rq->migration_thread);
@@ -6033,7 +6159,7 @@ static int __migrate_task(struct task_struct *p, int src_cpu, int dest_cpu)
         if (task_cpu(p) != src_cpu)
                 goto done;
         /* Affinity changed (again). */
-        if (!cpu_isset(dest_cpu, p->cpus_allowed))
+        if (!cpumask_test_cpu(dest_cpu, &p->cpus_allowed))
                 goto fail;
 
         on_rq = p->se.on_rq;
@@ -6130,50 +6256,41 @@ static int __migrate_task_irq(struct task_struct *p, int src_cpu, int dest_cpu)
  */
 static void move_task_off_dead_cpu(int dead_cpu, struct task_struct *p)
 {
-        unsigned long flags;
-        cpumask_t mask;
-        struct rq *rq;
         int dest_cpu;
+        const struct cpumask *nodemask = cpumask_of_node(cpu_to_node(dead_cpu));
 
-        do {
-                /* On same node? */
-                mask = node_to_cpumask(cpu_to_node(dead_cpu));
-                cpus_and(mask, mask, p->cpus_allowed);
-                dest_cpu = any_online_cpu(mask);
+again:
+        /* Look for allowed, online CPU in same node. */
+        for_each_cpu_and(dest_cpu, nodemask, cpu_online_mask)
+                if (cpumask_test_cpu(dest_cpu, &p->cpus_allowed))
+                        goto move;
 
-                /* On any allowed CPU? */
-                if (dest_cpu >= nr_cpu_ids)
-                        dest_cpu = any_online_cpu(p->cpus_allowed);
+        /* Any allowed, online CPU? */
+        dest_cpu = cpumask_any_and(&p->cpus_allowed, cpu_online_mask);
+        if (dest_cpu < nr_cpu_ids)
+                goto move;
 
-                /* No more Mr. Nice Guy. */
-                if (dest_cpu >= nr_cpu_ids) {
-                        cpumask_t cpus_allowed;
-
-                        cpuset_cpus_allowed_locked(p, &cpus_allowed);
-                        /*
-                         * Try to stay on the same cpuset, where the
-                         * current cpuset may be a subset of all cpus.
-                         * The cpuset_cpus_allowed_locked() variant of
-                         * cpuset_cpus_allowed() will not block. It must be
-                         * called within calls to cpuset_lock/cpuset_unlock.
-                         */
-                        rq = task_rq_lock(p, &flags);
-                        p->cpus_allowed = cpus_allowed;
-                        dest_cpu = any_online_cpu(p->cpus_allowed);
-                        task_rq_unlock(rq, &flags);
+        /* No more Mr. Nice Guy. */
+        if (dest_cpu >= nr_cpu_ids) {
+                cpuset_cpus_allowed_locked(p, &p->cpus_allowed);
+                dest_cpu = cpumask_any_and(cpu_online_mask, &p->cpus_allowed);
 
-                        /*
-                         * Don't tell them about moving exiting tasks or
-                         * kernel threads (both mm NULL), since they never
-                         * leave kernel.
-                         */
-                        if (p->mm && printk_ratelimit()) {
-                                printk(KERN_INFO "process %d (%s) no "
-                                       "longer affine to cpu%d\n",
-                                        task_pid_nr(p), p->comm, dead_cpu);
-                        }
+                /*
+                 * Don't tell them about moving exiting tasks or
+                 * kernel threads (both mm NULL), since they never
+                 * leave kernel.
+                 */
+                if (p->mm && printk_ratelimit()) {
+                        printk(KERN_INFO "process %d (%s) no "
+                               "longer affine to cpu%d\n",
+                               task_pid_nr(p), p->comm, dead_cpu);
                 }
-        } while (!__migrate_task_irq(p, dead_cpu, dest_cpu));
+        }
+
+move:
+        /* It can have affinity changed while we were choosing. */
+        if (unlikely(!__migrate_task_irq(p, dead_cpu, dest_cpu)))
+                goto again;
 }
 
 /*
@@ -6185,7 +6302,7 @@ static void move_task_off_dead_cpu(int dead_cpu, struct task_struct *p)
  */
 static void migrate_nr_uninterruptible(struct rq *rq_src)
 {
-        struct rq *rq_dest = cpu_rq(any_online_cpu(*CPU_MASK_ALL_PTR));
+        struct rq *rq_dest = cpu_rq(cpumask_any(cpu_online_mask));
         unsigned long flags;
 
         local_irq_save(flags);
@@ -6475,7 +6592,7 @@ static void set_rq_online(struct rq *rq)
         if (!rq->online) {
                 const struct sched_class *class;
 
-                cpu_set(rq->cpu, rq->rd->online);
+                cpumask_set_cpu(rq->cpu, rq->rd->online);
                 rq->online = 1;
 
                 for_each_class(class) {
@@ -6495,7 +6612,7 @@ static void set_rq_offline(struct rq *rq)
                                 class->rq_offline(rq);
                 }
 
-                cpu_clear(rq->cpu, rq->rd->online);
+                cpumask_clear_cpu(rq->cpu, rq->rd->online);
                 rq->online = 0;
         }
 }
@@ -6536,7 +6653,7 @@ migration_call(struct notifier_block *nfb, unsigned long action, void *hcpu)
                 rq = cpu_rq(cpu);
                 spin_lock_irqsave(&rq->lock, flags);
                 if (rq->rd) {
-                        BUG_ON(!cpu_isset(cpu, rq->rd->span));
+                        BUG_ON(!cpumask_test_cpu(cpu, rq->rd->span));
 
                         set_rq_online(rq);
                 }
@@ -6550,7 +6667,7 @@ migration_call(struct notifier_block *nfb, unsigned long action, void *hcpu)
                         break;
                 /* Unbind it from offline cpu so it can run. Fall thru. */
                 kthread_bind(cpu_rq(cpu)->migration_thread,
-                             any_online_cpu(cpu_online_map));
+                             cpumask_any(cpu_online_mask));
                 kthread_stop(cpu_rq(cpu)->migration_thread);
                 cpu_rq(cpu)->migration_thread = NULL;
                 break;
@@ -6600,7 +6717,7 @@ migration_call(struct notifier_block *nfb, unsigned long action, void *hcpu)
                 rq = cpu_rq(cpu);
                 spin_lock_irqsave(&rq->lock, flags);
                 if (rq->rd) {
-                        BUG_ON(!cpu_isset(cpu, rq->rd->span));
+                        BUG_ON(!cpumask_test_cpu(cpu, rq->rd->span));
                         set_rq_offline(rq);
                 }
                 spin_unlock_irqrestore(&rq->lock, flags);
@@ -6639,13 +6756,13 @@ early_initcall(migration_init);
 #ifdef CONFIG_SCHED_DEBUG
 
 static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
-                                  cpumask_t *groupmask)
+                                  struct cpumask *groupmask)
 {
         struct sched_group *group = sd->groups;
         char str[256];
 
-        cpulist_scnprintf(str, sizeof(str), sd->span);
-        cpus_clear(*groupmask);
+        cpulist_scnprintf(str, sizeof(str), sched_domain_span(sd));
+        cpumask_clear(groupmask);
 
         printk(KERN_DEBUG "%*s domain %d: ", level, "", level);
 
@@ -6659,11 +6776,11 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
 
         printk(KERN_CONT "span %s level %s\n", str, sd->name);
 
-        if (!cpu_isset(cpu, sd->span)) {
+        if (!cpumask_test_cpu(cpu, sched_domain_span(sd))) {
                 printk(KERN_ERR "ERROR: domain->span does not contain "
                                 "CPU%d\n", cpu);
         }
-        if (!cpu_isset(cpu, group->cpumask)) {
+        if (!cpumask_test_cpu(cpu, sched_group_cpus(group))) {
                 printk(KERN_ERR "ERROR: domain->groups does not contain"
                                 " CPU%d\n", cpu);
         }
@@ -6683,31 +6800,32 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
                         break;
                 }
 
-                if (!cpus_weight(group->cpumask)) {
+                if (!cpumask_weight(sched_group_cpus(group))) {
                         printk(KERN_CONT "\n");
                         printk(KERN_ERR "ERROR: empty group\n");
                         break;
                 }
 
-                if (cpus_intersects(*groupmask, group->cpumask)) {
+                if (cpumask_intersects(groupmask, sched_group_cpus(group))) {
                         printk(KERN_CONT "\n");
                         printk(KERN_ERR "ERROR: repeated CPUs\n");
                         break;
                 }
 
-                cpus_or(*groupmask, *groupmask, group->cpumask);
+                cpumask_or(groupmask, groupmask, sched_group_cpus(group));
 
-                cpulist_scnprintf(str, sizeof(str), group->cpumask);
+                cpulist_scnprintf(str, sizeof(str), sched_group_cpus(group));
                 printk(KERN_CONT " %s", str);
 
                 group = group->next;
         } while (group != sd->groups);
         printk(KERN_CONT "\n");
 
-        if (!cpus_equal(sd->span, *groupmask))
+        if (!cpumask_equal(sched_domain_span(sd), groupmask))
                 printk(KERN_ERR "ERROR: groups don't span domain->span\n");
 
-        if (sd->parent && !cpus_subset(*groupmask, sd->parent->span))
+        if (sd->parent &&
+            !cpumask_subset(groupmask, sched_domain_span(sd->parent)))
                 printk(KERN_ERR "ERROR: parent span is not a superset "
                         "of domain->span\n");
         return 0;
@@ -6715,7 +6833,7 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
 
 static void sched_domain_debug(struct sched_domain *sd, int cpu)
 {
-        cpumask_t *groupmask;
+        cpumask_var_t groupmask;
         int level = 0;
 
         if (!sd) {
@@ -6725,8 +6843,7 @@ static void sched_domain_debug(struct sched_domain *sd, int cpu)
 
         printk(KERN_DEBUG "CPU%d attaching sched-domain:\n", cpu);
 
-        groupmask = kmalloc(sizeof(cpumask_t), GFP_KERNEL);
-        if (!groupmask) {
+        if (!alloc_cpumask_var(&groupmask, GFP_KERNEL)) {
                 printk(KERN_DEBUG "Cannot load-balance (out of memory)\n");
                 return;
         }
@@ -6739,7 +6856,7 @@ static void sched_domain_debug(struct sched_domain *sd, int cpu)
                 if (!sd)
                         break;
         }
-        kfree(groupmask);
+        free_cpumask_var(groupmask);
 }
 #else /* !CONFIG_SCHED_DEBUG */
 # define sched_domain_debug(sd, cpu) do { } while (0)
@@ -6747,7 +6864,7 @@ static void sched_domain_debug(struct sched_domain *sd, int cpu)
 
 static int sd_degenerate(struct sched_domain *sd)
 {
-        if (cpus_weight(sd->span) == 1)
+        if (cpumask_weight(sched_domain_span(sd)) == 1)
                 return 1;
 
         /* Following flags need at least 2 groups */
@@ -6778,7 +6895,7 @@ sd_parent_degenerate(struct sched_domain *sd, struct sched_domain *parent)
         if (sd_degenerate(parent))
                 return 1;
 
-        if (!cpus_equal(sd->span, parent->span))
+        if (!cpumask_equal(sched_domain_span(sd), sched_domain_span(parent)))
                 return 0;
 
         /* Does parent contain flags not in child? */
@@ -6802,6 +6919,16 @@ sd_parent_degenerate(struct sched_domain *sd, struct sched_domain *parent)
         return 1;
 }
 
+static void free_rootdomain(struct root_domain *rd)
+{
+        cpupri_cleanup(&rd->cpupri);
+
+        free_cpumask_var(rd->rto_mask);
+        free_cpumask_var(rd->online);
+        free_cpumask_var(rd->span);
+        kfree(rd);
+}
+
 static void rq_attach_root(struct rq *rq, struct root_domain *rd)
 {
         unsigned long flags;
@@ -6811,38 +6938,63 @@ static void rq_attach_root(struct rq *rq, struct root_domain *rd)
         if (rq->rd) {
                 struct root_domain *old_rd = rq->rd;
 
-                if (cpu_isset(rq->cpu, old_rd->online))
+                if (cpumask_test_cpu(rq->cpu, old_rd->online))
                         set_rq_offline(rq);
 
-                cpu_clear(rq->cpu, old_rd->span);
+                cpumask_clear_cpu(rq->cpu, old_rd->span);
 
                 if (atomic_dec_and_test(&old_rd->refcount))
-                        kfree(old_rd);
+                        free_rootdomain(old_rd);
         }
 
         atomic_inc(&rd->refcount);
         rq->rd = rd;
 
-        cpu_set(rq->cpu, rd->span);
-        if (cpu_isset(rq->cpu, cpu_online_map))
+        cpumask_set_cpu(rq->cpu, rd->span);
+        if (cpumask_test_cpu(rq->cpu, cpu_online_mask))
                 set_rq_online(rq);
 
         spin_unlock_irqrestore(&rq->lock, flags);
 }
 
-static void init_rootdomain(struct root_domain *rd)
+static int init_rootdomain(struct root_domain *rd, bool bootmem)
 {
         memset(rd, 0, sizeof(*rd));
 
-        cpus_clear(rd->span);
-        cpus_clear(rd->online);
+        if (bootmem) {
+                alloc_bootmem_cpumask_var(&def_root_domain.span);
+                alloc_bootmem_cpumask_var(&def_root_domain.online);
+                alloc_bootmem_cpumask_var(&def_root_domain.rto_mask);
+                cpupri_init(&rd->cpupri, true);
+                return 0;
+        }
+
+        if (!alloc_cpumask_var(&rd->span, GFP_KERNEL))
+                goto free_rd;
+        if (!alloc_cpumask_var(&rd->online, GFP_KERNEL))
+                goto free_span;
+        if (!alloc_cpumask_var(&rd->rto_mask, GFP_KERNEL))
+                goto free_online;
 
-        cpupri_init(&rd->cpupri);
+        if (cpupri_init(&rd->cpupri, false) != 0)
+                goto free_rto_mask;
+        return 0;
+
+free_rto_mask:
+        free_cpumask_var(rd->rto_mask);
+free_online:
+        free_cpumask_var(rd->online);
+free_span:
+        free_cpumask_var(rd->span);
+free_rd:
+        kfree(rd);
+        return -ENOMEM;
 }
 
 static void init_defrootdomain(void)
 {
-        init_rootdomain(&def_root_domain);
+        init_rootdomain(&def_root_domain, true);
+
         atomic_set(&def_root_domain.refcount, 1);
 }
 
@@ -6854,7 +7006,10 @@ static struct root_domain *alloc_rootdomain(void)
         if (!rd)
                 return NULL;
 
-        init_rootdomain(rd);
+        if (init_rootdomain(rd, false) != 0) {
+                kfree(rd);
+                return NULL;
+        }
 
         return rd;
 }
@@ -6896,19 +7051,12 @@ cpu_attach_domain(struct sched_domain *sd, struct root_domain *rd, int cpu)
 }
 
 /* cpus with isolated domains */
-static cpumask_t cpu_isolated_map = CPU_MASK_NONE;
+static cpumask_var_t cpu_isolated_map;
 
 /* Setup the mask of cpus configured for isolated domains */
 static int __init isolated_cpu_setup(char *str)
 {
-        static int __initdata ints[NR_CPUS];
-        int i;
-
-        str = get_options(str, ARRAY_SIZE(ints), ints);
-        cpus_clear(cpu_isolated_map);
-        for (i = 1; i <= ints[0]; i++)
-                if (ints[i] < NR_CPUS)
-                        cpu_set(ints[i], cpu_isolated_map);
+        cpulist_parse(str, cpu_isolated_map);
         return 1;
 }
 
@@ -6917,42 +7065,43 @@ __setup("isolcpus=", isolated_cpu_setup);
 /*
  * init_sched_build_groups takes the cpumask we wish to span, and a pointer
  * to a function which identifies what group(along with sched group) a CPU
- * belongs to. The return value of group_fn must be a >= 0 and < NR_CPUS
- * (due to the fact that we keep track of groups covered with a cpumask_t).
+ * belongs to. The return value of group_fn must be a >= 0 and < nr_cpu_ids
+ * (due to the fact that we keep track of groups covered with a struct cpumask).
  *
  * init_sched_build_groups will build a circular linked list of the groups
  * covered by the given span, and will set each group's ->cpumask correctly,
  * and ->cpu_power to 0.
  */
 static void
-init_sched_build_groups(const cpumask_t *span, const cpumask_t *cpu_map,
-                        int (*group_fn)(int cpu, const cpumask_t *cpu_map,
+init_sched_build_groups(const struct cpumask *span,
+                        const struct cpumask *cpu_map,
+                        int (*group_fn)(int cpu, const struct cpumask *cpu_map,
                                         struct sched_group **sg,
-                                        cpumask_t *tmpmask),
-                        cpumask_t *covered, cpumask_t *tmpmask)
+                                        struct cpumask *tmpmask),
+                        struct cpumask *covered, struct cpumask *tmpmask)
 {
         struct sched_group *first = NULL, *last = NULL;
         int i;
 
-        cpus_clear(*covered);
+        cpumask_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;
 
-                if (cpu_isset(i, *covered))
+                if (cpumask_test_cpu(i, covered))
                         continue;
 
-                cpus_clear(sg->cpumask);
+                cpumask_clear(sched_group_cpus(sg));
                 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;
 
-                        cpu_set(j, *covered);
-                        cpu_set(j, sg->cpumask);
+                        cpumask_set_cpu(j, covered);
+                        cpumask_set_cpu(j, sched_group_cpus(sg));
                 }
                 if (!first)
                         first = sg;
@@ -7016,23 +7165,21 @@ static int find_next_best_node(int node, nodemask_t *used_nodes)
  * should be one that prevents unnecessary balancing, but also spreads tasks
  * out optimally.
  */
-static void sched_domain_node_span(int node, cpumask_t *span)
+static void sched_domain_node_span(int node, struct cpumask *span)
 {
         nodemask_t used_nodes;
-        node_to_cpumask_ptr(nodemask, node);
         int i;
 
-        cpus_clear(*span);
+        cpumask_clear(span);
         nodes_clear(used_nodes);
 
-        cpus_or(*span, *span, *nodemask);
+        cpumask_or(span, span, cpumask_of_node(node));
         node_set(node, used_nodes);
 
         for (i = 1; i < SD_NODES_PER_DOMAIN; i++) {
                 int next_node = find_next_best_node(node, &used_nodes);
 
-                node_to_cpumask_ptr_next(nodemask, next_node);
-                cpus_or(*span, *span, *nodemask);
+                cpumask_or(span, span, cpumask_of_node(next_node));
         }
 }
 #endif /* CONFIG_NUMA */
@@ -7040,18 +7187,33 @@ static void sched_domain_node_span(int node, cpumask_t *span)
 int sched_smt_power_savings = 0, sched_mc_power_savings = 0;
 
 /*
+ * The cpus mask in sched_group and sched_domain hangs off the end.
+ * FIXME: use cpumask_var_t or dynamic percpu alloc to avoid wasting space
+ * for nr_cpu_ids < CONFIG_NR_CPUS.
+ */
+struct static_sched_group {
+        struct sched_group sg;
+        DECLARE_BITMAP(cpus, CONFIG_NR_CPUS);
+};
+
+struct static_sched_domain {
+        struct sched_domain sd;
+        DECLARE_BITMAP(span, CONFIG_NR_CPUS);
+};
+
+/*
  * SMT sched-domains:
  */
 #ifdef CONFIG_SCHED_SMT
-static DEFINE_PER_CPU(struct sched_domain, cpu_domains);
-static DEFINE_PER_CPU(struct sched_group, sched_group_cpus);
+static DEFINE_PER_CPU(struct static_sched_domain, cpu_domains);
+static DEFINE_PER_CPU(struct static_sched_group, sched_group_cpus);
 
 static int
-cpu_to_cpu_group(int cpu, const cpumask_t *cpu_map, struct sched_group **sg,
-                 cpumask_t *unused)
+cpu_to_cpu_group(int cpu, const struct cpumask *cpu_map,
+                 struct sched_group **sg, struct cpumask *unused)
 {
         if (sg)
-                *sg = &per_cpu(sched_group_cpus, cpu);
+                *sg = &per_cpu(sched_group_cpus, cpu).sg;
         return cpu;
 }
 #endif /* CONFIG_SCHED_SMT */
@@ -7060,56 +7222,53 @@ cpu_to_cpu_group(int cpu, const cpumask_t *cpu_map, struct sched_group **sg,
  * multi-core sched-domains:
  */
 #ifdef CONFIG_SCHED_MC
-static DEFINE_PER_CPU(struct sched_domain, core_domains);
-static DEFINE_PER_CPU(struct sched_group, sched_group_core);
+static DEFINE_PER_CPU(struct static_sched_domain, core_domains);
+static DEFINE_PER_CPU(struct static_sched_group, sched_group_core);
 #endif /* CONFIG_SCHED_MC */
 
 #if defined(CONFIG_SCHED_MC) && defined(CONFIG_SCHED_SMT)
 static int
-cpu_to_core_group(int cpu, const cpumask_t *cpu_map, struct sched_group **sg,
-                  cpumask_t *mask)
+cpu_to_core_group(int cpu, const struct cpumask *cpu_map,
+                  struct sched_group **sg, struct cpumask *mask)
 {
         int group;
 
-        *mask = per_cpu(cpu_sibling_map, cpu);
-        cpus_and(*mask, *mask, *cpu_map);
-        group = first_cpu(*mask);
+        cpumask_and(mask, &per_cpu(cpu_sibling_map, cpu), cpu_map);
+        group = cpumask_first(mask);
         if (sg)
-                *sg = &per_cpu(sched_group_core, group);
+                *sg = &per_cpu(sched_group_core, group).sg;
         return group;
 }
 #elif defined(CONFIG_SCHED_MC)
 static int
-cpu_to_core_group(int cpu, const cpumask_t *cpu_map, struct sched_group **sg,
-                  cpumask_t *unused)
+cpu_to_core_group(int cpu, const struct cpumask *cpu_map,
+                  struct sched_group **sg, struct cpumask *unused)
 {
         if (sg)
-                *sg = &per_cpu(sched_group_core, cpu);
+                *sg = &per_cpu(sched_group_core, cpu).sg;
         return cpu;
 }
 #endif
 
-static DEFINE_PER_CPU(struct sched_domain, phys_domains);
-static DEFINE_PER_CPU(struct sched_group, sched_group_phys);
+static DEFINE_PER_CPU(struct static_sched_domain, phys_domains);
+static DEFINE_PER_CPU(struct static_sched_group, sched_group_phys);
 
 static int
-cpu_to_phys_group(int cpu, const cpumask_t *cpu_map, struct sched_group **sg,
-                  cpumask_t *mask)
+cpu_to_phys_group(int cpu, const struct cpumask *cpu_map,
+                  struct sched_group **sg, struct cpumask *mask)
 {
         int group;
 #ifdef CONFIG_SCHED_MC
-        *mask = cpu_coregroup_map(cpu);
-        cpus_and(*mask, *mask, *cpu_map);
-        group = first_cpu(*mask);
+        cpumask_and(mask, cpu_coregroup_mask(cpu), cpu_map);
+        group = cpumask_first(mask);
 #elif defined(CONFIG_SCHED_SMT)
-        *mask = per_cpu(cpu_sibling_map, cpu);
-        cpus_and(*mask, *mask, *cpu_map);
-        group = first_cpu(*mask);
+        cpumask_and(mask, &per_cpu(cpu_sibling_map, cpu), cpu_map);
+        group = cpumask_first(mask);
 #else
         group = cpu;
 #endif
         if (sg)
-                *sg = &per_cpu(sched_group_phys, group);
+                *sg = &per_cpu(sched_group_phys, group).sg;
         return group;
 }
 
@@ -7123,19 +7282,19 @@ static DEFINE_PER_CPU(struct sched_domain, node_domains);
 static struct sched_group ***sched_group_nodes_bycpu;
 
 static DEFINE_PER_CPU(struct sched_domain, allnodes_domains);
-static DEFINE_PER_CPU(struct sched_group, sched_group_allnodes);
+static DEFINE_PER_CPU(struct static_sched_group, sched_group_allnodes);
 
-static int cpu_to_allnodes_group(int cpu, const cpumask_t *cpu_map,
-                                 struct sched_group **sg, cpumask_t *nodemask)
+static int cpu_to_allnodes_group(int cpu, const struct cpumask *cpu_map,
+                                 struct sched_group **sg,
+                                 struct cpumask *nodemask)
 {
         int group;
 
-        *nodemask = node_to_cpumask(cpu_to_node(cpu));
-        cpus_and(*nodemask, *nodemask, *cpu_map);
-        group = first_cpu(*nodemask);
+        cpumask_and(nodemask, cpumask_of_node(cpu_to_node(cpu)), cpu_map);
+        group = cpumask_first(nodemask);
 
         if (sg)
-                *sg = &per_cpu(sched_group_allnodes, group);
+                *sg = &per_cpu(sched_group_allnodes, group).sg;
         return group;
 }
 
@@ -7147,11 +7306,11 @@ static void init_numa_sched_groups_power(struct sched_group *group_head)
         if (!sg)
                 return;
         do {
-                for_each_cpu_mask_nr(j, sg->cpumask) {
+                for_each_cpu(j, sched_group_cpus(sg)) {
                         struct sched_domain *sd;
 
-                        sd = &per_cpu(phys_domains, j);
-                        if (j != first_cpu(sd->groups->cpumask)) {
+                        sd = &per_cpu(phys_domains, j).sd;
+                        if (j != cpumask_first(sched_group_cpus(sd->groups))) {
                                 /*
                                  * Only add "power" once for each
                                  * physical package.
@@ -7168,11 +7327,12 @@ static void init_numa_sched_groups_power(struct sched_group *group_head)
 
 #ifdef CONFIG_NUMA
 /* Free memory allocated for various sched_group structures */
-static void free_sched_groups(const cpumask_t *cpu_map, cpumask_t *nodemask)
+static void free_sched_groups(const struct cpumask *cpu_map,
+                              struct cpumask *nodemask)
 {
         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];
 
@@ -7182,9 +7342,8 @@ static void free_sched_groups(const cpumask_t *cpu_map, cpumask_t *nodemask)
                 for (i = 0; i < nr_node_ids; i++) {
                         struct sched_group *oldsg, *sg = sched_group_nodes[i];
 
-                        *nodemask = node_to_cpumask(i);
-                        cpus_and(*nodemask, *nodemask, *cpu_map);
-                        if (cpus_empty(*nodemask))
+                        cpumask_and(nodemask, cpumask_of_node(i), cpu_map);
+                        if (cpumask_empty(nodemask))
                                 continue;
 
                         if (sg == NULL)
@@ -7202,7 +7361,8 @@ next_sg:
         }
 }
 #else /* !CONFIG_NUMA */
-static void free_sched_groups(const cpumask_t *cpu_map, cpumask_t *nodemask)
+static void free_sched_groups(const struct cpumask *cpu_map,
+                              struct cpumask *nodemask)
 {
 }
 #endif /* CONFIG_NUMA */
@@ -7228,7 +7388,7 @@ static void init_sched_groups_power(int cpu, struct sched_domain *sd)
 
         WARN_ON(!sd || !sd->groups);
 
-        if (cpu != first_cpu(sd->groups->cpumask))
+        if (cpu != cpumask_first(sched_group_cpus(sd->groups)))
                 return;
 
         child = sd->child;
@@ -7293,48 +7453,6 @@ SD_INIT_FUNC(CPU)
  SD_INIT_FUNC(MC)
 #endif
 
-/*
- * To minimize stack usage kmalloc room for cpumasks and share the
- * space as the usage in build_sched_domains() dictates.  Used only
- * if the amount of space is significant.
- */
-struct allmasks {
-        cpumask_t tmpmask;                      /* make this one first */
-        union {
-                cpumask_t nodemask;
-                cpumask_t this_sibling_map;
-                cpumask_t this_core_map;
-        };
-        cpumask_t send_covered;
-
-#ifdef CONFIG_NUMA
-        cpumask_t domainspan;
-        cpumask_t covered;
-        cpumask_t notcovered;
-#endif
-};
-
-#if     NR_CPUS > 128
-#define SCHED_CPUMASK_DECLARE(v)        struct allmasks *v
-static inline void sched_cpumask_alloc(struct allmasks **masks)
-{
-        *masks = kmalloc(sizeof(**masks), GFP_KERNEL);
-}
-static inline void sched_cpumask_free(struct allmasks *masks)
-{
-        kfree(masks);
-}
-#else
-#define SCHED_CPUMASK_DECLARE(v)        struct allmasks _v, *v = &_v
-static inline void sched_cpumask_alloc(struct allmasks **masks)
-{ }
-static inline void sched_cpumask_free(struct allmasks *masks)
-{ }
-#endif
-
-#define SCHED_CPUMASK_VAR(v, a)         cpumask_t *v = (cpumask_t *) \
-                        ((unsigned long)(a) + offsetof(struct allmasks, v))
-
 static int default_relax_domain_level = -1;
 
 static int __init setup_relax_domain_level(char *str)
@@ -7374,17 +7492,38 @@ static void set_domain_attribute(struct sched_domain *sd,
  * Build sched domains for a given set of cpus and attach the sched domains
  * to the individual cpus
  */
-static int __build_sched_domains(const cpumask_t *cpu_map,
+static int __build_sched_domains(const struct cpumask *cpu_map,
                                  struct sched_domain_attr *attr)
 {
-        int i;
+        int i, err = -ENOMEM;
         struct root_domain *rd;
-        SCHED_CPUMASK_DECLARE(allmasks);
-        cpumask_t *tmpmask;
+        cpumask_var_t nodemask, this_sibling_map, this_core_map, send_covered,
+                tmpmask;
 #ifdef CONFIG_NUMA
+        cpumask_var_t domainspan, covered, notcovered;
         struct sched_group **sched_group_nodes = NULL;
         int sd_allnodes = 0;
 
+        if (!alloc_cpumask_var(&domainspan, GFP_KERNEL))
+                goto out;
+        if (!alloc_cpumask_var(&covered, GFP_KERNEL))
+                goto free_domainspan;
+        if (!alloc_cpumask_var(&notcovered, GFP_KERNEL))
+                goto free_covered;
+#endif
+
+        if (!alloc_cpumask_var(&nodemask, GFP_KERNEL))
+                goto free_notcovered;
+        if (!alloc_cpumask_var(&this_sibling_map, GFP_KERNEL))
+                goto free_nodemask;
+        if (!alloc_cpumask_var(&this_core_map, GFP_KERNEL))
+                goto free_this_sibling_map;
+        if (!alloc_cpumask_var(&send_covered, GFP_KERNEL))
+                goto free_this_core_map;
+        if (!alloc_cpumask_var(&tmpmask, GFP_KERNEL))
+                goto free_send_covered;
+
+#ifdef CONFIG_NUMA
         /*
          * Allocate the per-node list of sched groups
          */
@@ -7392,54 +7531,35 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
                                     GFP_KERNEL);
         if (!sched_group_nodes) {
                 printk(KERN_WARNING "Can not alloc sched group node list\n");
-                return -ENOMEM;
+                goto free_tmpmask;
         }
 #endif
 
         rd = alloc_rootdomain();
         if (!rd) {
                 printk(KERN_WARNING "Cannot alloc root domain\n");
-#ifdef CONFIG_NUMA
-                kfree(sched_group_nodes);
-#endif
-                return -ENOMEM;
+                goto free_sched_groups;
         }
 
-        /* get space for all scratch cpumask variables */
-        sched_cpumask_alloc(&allmasks);
-        if (!allmasks) {
-                printk(KERN_WARNING "Cannot alloc cpumask array\n");
-                kfree(rd);
-#ifdef CONFIG_NUMA
-                kfree(sched_group_nodes);
-#endif
-                return -ENOMEM;
-        }
-
-        tmpmask = (cpumask_t *)allmasks;
-
-
 #ifdef CONFIG_NUMA
-        sched_group_nodes_bycpu[first_cpu(*cpu_map)] = sched_group_nodes;
+        sched_group_nodes_bycpu[cpumask_first(cpu_map)] = sched_group_nodes;
 #endif
 
         /*
          * 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);
 
-                *nodemask = node_to_cpumask(cpu_to_node(i));
-                cpus_and(*nodemask, *nodemask, *cpu_map);
+                cpumask_and(nodemask, cpumask_of_node(cpu_to_node(i)), cpu_map);
 
 #ifdef CONFIG_NUMA
-                if (cpus_weight(*cpu_map) >
-                                SD_NODES_PER_DOMAIN*cpus_weight(*nodemask)) {
+                if (cpumask_weight(cpu_map) >
+                                SD_NODES_PER_DOMAIN*cpumask_weight(nodemask)) {
                         sd = &per_cpu(allnodes_domains, i);
                         SD_INIT(sd, ALLNODES);
                         set_domain_attribute(sd, attr);
-                        sd->span = *cpu_map;
+                        cpumask_copy(sched_domain_span(sd), cpu_map);
                         cpu_to_allnodes_group(i, cpu_map, &sd->groups, tmpmask);
                         p = sd;
                         sd_allnodes = 1;
@@ -7449,18 +7569,19 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
                 sd = &per_cpu(node_domains, i);
                 SD_INIT(sd, NODE);
                 set_domain_attribute(sd, attr);
-                sched_domain_node_span(cpu_to_node(i), &sd->span);
+                sched_domain_node_span(cpu_to_node(i), sched_domain_span(sd));
                 sd->parent = p;
                 if (p)
                         p->child = sd;
-                cpus_and(sd->span, sd->span, *cpu_map);
+                cpumask_and(sched_domain_span(sd),
+                            sched_domain_span(sd), cpu_map);
 #endif
 
                 p = sd;
-                sd = &per_cpu(phys_domains, i);
+                sd = &per_cpu(phys_domains, i).sd;
                 SD_INIT(sd, CPU);
                 set_domain_attribute(sd, attr);
-                sd->span = *nodemask;
+                cpumask_copy(sched_domain_span(sd), nodemask);
                 sd->parent = p;
                 if (p)
                         p->child = sd;
@@ -7468,11 +7589,11 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
 
 #ifdef CONFIG_SCHED_MC
                 p = sd;
-                sd = &per_cpu(core_domains, i);
+                sd = &per_cpu(core_domains, i).sd;
                 SD_INIT(sd, MC);
                 set_domain_attribute(sd, attr);
-                sd->span = cpu_coregroup_map(i);
-                cpus_and(sd->span, sd->span, *cpu_map);
+                cpumask_and(sched_domain_span(sd), cpu_map,
+                                                   cpu_coregroup_mask(i));
                 sd->parent = p;
                 p->child = sd;
                 cpu_to_core_group(i, cpu_map, &sd->groups, tmpmask);
@@ -7480,11 +7601,11 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
 
 #ifdef CONFIG_SCHED_SMT
                 p = sd;
-                sd = &per_cpu(cpu_domains, i);
+                sd = &per_cpu(cpu_domains, i).sd;
                 SD_INIT(sd, SIBLING);
                 set_domain_attribute(sd, attr);
-                sd->span = per_cpu(cpu_sibling_map, i);
-                cpus_and(sd->span, sd->span, *cpu_map);
+                cpumask_and(sched_domain_span(sd),
+                            &per_cpu(cpu_sibling_map, i), cpu_map);
                 sd->parent = p;
                 p->child = sd;
                 cpu_to_cpu_group(i, cpu_map, &sd->groups, tmpmask);
@@ -7493,13 +7614,10 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
 
 #ifdef CONFIG_SCHED_SMT
         /* Set up CPU (sibling) groups */
-        for_each_cpu_mask_nr(i, *cpu_map) {
-                SCHED_CPUMASK_VAR(this_sibling_map, allmasks);
-                SCHED_CPUMASK_VAR(send_covered, allmasks);
-
-                *this_sibling_map = per_cpu(cpu_sibling_map, i);
-                cpus_and(*this_sibling_map, *this_sibling_map, *cpu_map);
-                if (i != first_cpu(*this_sibling_map))
+        for_each_cpu(i, cpu_map) {
+                cpumask_and(this_sibling_map,
+                            &per_cpu(cpu_sibling_map, i), cpu_map);
+                if (i != cpumask_first(this_sibling_map))
                         continue;
 
                 init_sched_build_groups(this_sibling_map, cpu_map,
@@ -7510,13 +7628,9 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
 
 #ifdef CONFIG_SCHED_MC
         /* Set up multi-core groups */
-        for_each_cpu_mask_nr(i, *cpu_map) {
-                SCHED_CPUMASK_VAR(this_core_map, allmasks);
-                SCHED_CPUMASK_VAR(send_covered, allmasks);
-
-                *this_core_map = cpu_coregroup_map(i);
-                cpus_and(*this_core_map, *this_core_map, *cpu_map);
-                if (i != first_cpu(*this_core_map))
+        for_each_cpu(i, cpu_map) {
+                cpumask_and(this_core_map, cpu_coregroup_mask(i), cpu_map);
+                if (i != cpumask_first(this_core_map))
                         continue;
 
                 init_sched_build_groups(this_core_map, cpu_map,
@@ -7527,12 +7641,8 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
 
         /* Set up physical groups */
         for (i = 0; i < nr_node_ids; i++) {
-                SCHED_CPUMASK_VAR(nodemask, allmasks);
-                SCHED_CPUMASK_VAR(send_covered, allmasks);
-
-                *nodemask = node_to_cpumask(i);
-                cpus_and(*nodemask, *nodemask, *cpu_map);
-                if (cpus_empty(*nodemask))
+                cpumask_and(nodemask, cpumask_of_node(i), cpu_map);
+                if (cpumask_empty(nodemask))
                         continue;
 
                 init_sched_build_groups(nodemask, cpu_map,
@@ -7543,8 +7653,6 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
 #ifdef CONFIG_NUMA
         /* Set up node groups */
         if (sd_allnodes) {
-                SCHED_CPUMASK_VAR(send_covered, allmasks);
-
                 init_sched_build_groups(cpu_map, cpu_map,
                                         &cpu_to_allnodes_group,
                                         send_covered, tmpmask);
@@ -7553,58 +7661,53 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
         for (i = 0; i < nr_node_ids; i++) {
                 /* Set up node groups */
                 struct sched_group *sg, *prev;
-                SCHED_CPUMASK_VAR(nodemask, allmasks);
-                SCHED_CPUMASK_VAR(domainspan, allmasks);
-                SCHED_CPUMASK_VAR(covered, allmasks);
                 int j;
 
-                *nodemask = node_to_cpumask(i);
-                cpus_clear(*covered);
-
-                cpus_and(*nodemask, *nodemask, *cpu_map);
-                if (cpus_empty(*nodemask)) {
+                cpumask_clear(covered);
+                cpumask_and(nodemask, cpumask_of_node(i), cpu_map);
+                if (cpumask_empty(nodemask)) {
                         sched_group_nodes[i] = NULL;
                         continue;
                 }
 
                 sched_domain_node_span(i, domainspan);
-                cpus_and(*domainspan, *domainspan, *cpu_map);
+                cpumask_and(domainspan, domainspan, cpu_map);
 
-                sg = kmalloc_node(sizeof(struct sched_group), GFP_KERNEL, i);
+                sg = kmalloc_node(sizeof(struct sched_group) + cpumask_size(),
+                                  GFP_KERNEL, i);
                 if (!sg) {
                         printk(KERN_WARNING "Can not alloc domain group for "
                                 "node %d\n", i);
                         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);
                         sd->groups = sg;
                 }
                 sg->__cpu_power = 0;
-                sg->cpumask = *nodemask;
+                cpumask_copy(sched_group_cpus(sg), nodemask);
                 sg->next = sg;
-                cpus_or(*covered, *covered, *nodemask);
+                cpumask_or(covered, covered, nodemask);
                 prev = sg;
 
                 for (j = 0; j < nr_node_ids; j++) {
-                        SCHED_CPUMASK_VAR(notcovered, allmasks);
                         int n = (i + j) % nr_node_ids;
-                        node_to_cpumask_ptr(pnodemask, n);
 
-                        cpus_complement(*notcovered, *covered);
-                        cpus_and(*tmpmask, *notcovered, *cpu_map);
-                        cpus_and(*tmpmask, *tmpmask, *domainspan);
-                        if (cpus_empty(*tmpmask))
+                        cpumask_complement(notcovered, covered);
+                        cpumask_and(tmpmask, notcovered, cpu_map);
+                        cpumask_and(tmpmask, tmpmask, domainspan);
+                        if (cpumask_empty(tmpmask))
                                 break;
 
-                        cpus_and(*tmpmask, *tmpmask, *pnodemask);
-                        if (cpus_empty(*tmpmask))
+                        cpumask_and(tmpmask, tmpmask, cpumask_of_node(n));
+                        if (cpumask_empty(tmpmask))
                                 continue;
 
-                        sg = kmalloc_node(sizeof(struct sched_group),
+                        sg = kmalloc_node(sizeof(struct sched_group) +
+                                          cpumask_size(),
                                           GFP_KERNEL, i);
                         if (!sg) {
                                 printk(KERN_WARNING
@@ -7612,9 +7715,9 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
                                 goto error;
                         }
                         sg->__cpu_power = 0;
-                        sg->cpumask = *tmpmask;
+                        cpumask_copy(sched_group_cpus(sg), tmpmask);
                         sg->next = prev->next;
-                        cpus_or(*covered, *covered, *tmpmask);
+                        cpumask_or(covered, covered, tmpmask);
                         prev->next = sg;
                         prev = sg;
                 }
@@ -7623,22 +7726,22 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
 
         /* Calculate CPU power for physical packages and nodes */
 #ifdef CONFIG_SCHED_SMT
-        for_each_cpu_mask_nr(i, *cpu_map) {
-                struct sched_domain *sd = &per_cpu(cpu_domains, i);
+        for_each_cpu(i, cpu_map) {
+                struct sched_domain *sd = &per_cpu(cpu_domains, i).sd;
 
                 init_sched_groups_power(i, sd);
         }
 #endif
 #ifdef CONFIG_SCHED_MC
-        for_each_cpu_mask_nr(i, *cpu_map) {
-                struct sched_domain *sd = &per_cpu(core_domains, i);
+        for_each_cpu(i, cpu_map) {
+                struct sched_domain *sd = &per_cpu(core_domains, i).sd;
 
                 init_sched_groups_power(i, sd);
         }
 #endif
 
-        for_each_cpu_mask_nr(i, *cpu_map) {
-                struct sched_domain *sd = &per_cpu(phys_domains, i);
+        for_each_cpu(i, cpu_map) {
+                struct sched_domain *sd = &per_cpu(phys_domains, i).sd;
 
                 init_sched_groups_power(i, sd);
         }
@@ -7650,53 +7753,78 @@ static int __build_sched_domains(const cpumask_t *cpu_map,
         if (sd_allnodes) {
                 struct sched_group *sg;
 
-                cpu_to_allnodes_group(first_cpu(*cpu_map), cpu_map, &sg,
+                cpu_to_allnodes_group(cpumask_first(cpu_map), cpu_map, &sg,
                                                                 tmpmask);
                 init_numa_sched_groups_power(sg);
         }
 #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);
+                sd = &per_cpu(cpu_domains, i).sd;
 #elif defined(CONFIG_SCHED_MC)
-                sd = &per_cpu(core_domains, i);
+                sd = &per_cpu(core_domains, i).sd;
 #else
-                sd = &per_cpu(phys_domains, i);
+                sd = &per_cpu(phys_domains, i).sd;
 #endif
                 cpu_attach_domain(sd, rd, i);
         }
 
-        sched_cpumask_free(allmasks);
-        return 0;
+        err = 0;
+
+free_tmpmask:
+        free_cpumask_var(tmpmask);
+free_send_covered:
+        free_cpumask_var(send_covered);
+free_this_core_map:
+        free_cpumask_var(this_core_map);
+free_this_sibling_map:
+        free_cpumask_var(this_sibling_map);
+free_nodemask:
+        free_cpumask_var(nodemask);
+free_notcovered:
+#ifdef CONFIG_NUMA
+        free_cpumask_var(notcovered);
+free_covered:
+        free_cpumask_var(covered);
+free_domainspan:
+        free_cpumask_var(domainspan);
+out:
+#endif
+        return err;
+
+free_sched_groups:
+#ifdef CONFIG_NUMA
+        kfree(sched_group_nodes);
+#endif
+        goto free_tmpmask;
 
 #ifdef CONFIG_NUMA
 error:
         free_sched_groups(cpu_map, tmpmask);
-        sched_cpumask_free(allmasks);
-        kfree(rd);
-        return -ENOMEM;
+        free_rootdomain(rd);
+        goto free_tmpmask;
 #endif
 }
 
-static int build_sched_domains(const cpumask_t *cpu_map)
+static int build_sched_domains(const struct cpumask *cpu_map)
 {
         return __build_sched_domains(cpu_map, NULL);
 }
 
-static cpumask_t *doms_cur;     /* current sched domains */
+static struct cpumask *doms_cur;        /* current sched domains */
 static int ndoms_cur;           /* number of sched domains in 'doms_cur' */
 static struct sched_domain_attr *dattr_cur;
                                 /* attribues of custom domains in 'doms_cur' */
 
 /*
  * Special case: If a kmalloc of a doms_cur partition (array of
- * cpumask_t) fails, then fallback to a single sched domain,
- * as determined by the single cpumask_t fallback_doms.
+ * cpumask) fails, then fallback to a single sched domain,
+ * as determined by the single cpumask fallback_doms.
  */
-static cpumask_t fallback_doms;
+static cpumask_var_t fallback_doms;
 
 /*
  * arch_update_cpu_topology lets virtualized architectures update the
@@ -7713,16 +7841,16 @@ int __attribute__((weak)) arch_update_cpu_topology(void)
  * For now this just excludes isolated cpus, but could be used to
  * exclude other special cases in the future.
  */
-static int arch_init_sched_domains(const cpumask_t *cpu_map)
+static int arch_init_sched_domains(const struct cpumask *cpu_map)
 {
         int err;
 
         arch_update_cpu_topology();
         ndoms_cur = 1;
-        doms_cur = kmalloc(sizeof(cpumask_t), GFP_KERNEL);
+        doms_cur = kmalloc(cpumask_size(), GFP_KERNEL);
         if (!doms_cur)
-                doms_cur = &fallback_doms;
-        cpus_andnot(*doms_cur, *cpu_map, cpu_isolated_map);
+                doms_cur = fallback_doms;
+        cpumask_andnot(doms_cur, cpu_map, cpu_isolated_map);
         dattr_cur = NULL;
         err = build_sched_domains(doms_cur);
         register_sched_domain_sysctl();
@@ -7730,8 +7858,8 @@ static int arch_init_sched_domains(const cpumask_t *cpu_map)
         return err;
 }
 
-static void arch_destroy_sched_domains(const cpumask_t *cpu_map,
-                                       cpumask_t *tmpmask)
+static void arch_destroy_sched_domains(const struct cpumask *cpu_map,
+                                       struct cpumask *tmpmask)
 {
         free_sched_groups(cpu_map, tmpmask);
 }
@@ -7740,15 +7868,16 @@ static void arch_destroy_sched_domains(const cpumask_t *cpu_map,
  * Detach sched domains from a group of cpus specified in cpu_map
  * These cpus will now be attached to the NULL domain
  */
-static void detach_destroy_domains(const cpumask_t *cpu_map)
+static void detach_destroy_domains(const struct cpumask *cpu_map)
 {
-        cpumask_t tmpmask;
+        /* Save because hotplug lock held. */
+        static DECLARE_BITMAP(tmpmask, CONFIG_NR_CPUS);
         int i;
 
-        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);
+        arch_destroy_sched_domains(cpu_map, to_cpumask(tmpmask));
 }
 
 /* handle null as "default" */
@@ -7773,7 +7902,7 @@ static int dattrs_equal(struct sched_domain_attr *cur, int idx_cur,
  * doms_new[] to the current sched domain partitioning, doms_cur[].
  * It destroys each deleted domain and builds each new domain.
  *
- * 'doms_new' is an array of cpumask_t's of length 'ndoms_new'.
+ * 'doms_new' is an array of cpumask's of length 'ndoms_new'.
  * The masks don't intersect (don't overlap.) We should setup one
  * sched domain for each mask. CPUs not in any of the cpumasks will
  * not be load balanced. If the same cpumask appears both in the
@@ -7787,13 +7916,14 @@ static int dattrs_equal(struct sched_domain_attr *cur, int idx_cur,
  * the single partition 'fallback_doms', it also forces the domains
  * to be rebuilt.
  *
- * If doms_new == NULL it will be replaced with cpu_online_map.
+ * If doms_new == NULL it will be replaced with cpu_online_mask.
  * ndoms_new == 0 is a special case for destroying existing domains,
  * and it will not create the default domain.
  *
  * Call with hotplug lock held
  */
-void partition_sched_domains(int ndoms_new, cpumask_t *doms_new,
+/* FIXME: Change to struct cpumask *doms_new[] */
+void partition_sched_domains(int ndoms_new, struct cpumask *doms_new,
                              struct sched_domain_attr *dattr_new)
 {
         int i, j, n;
@@ -7812,7 +7942,7 @@ void partition_sched_domains(int ndoms_new, cpumask_t *doms_new,
         /* Destroy deleted domains */
         for (i = 0; i < ndoms_cur; i++) {
                 for (j = 0; j < n && !new_topology; j++) {
-                        if (cpus_equal(doms_cur[i], doms_new[j])
+                        if (cpumask_equal(&doms_cur[i], &doms_new[j])
                             && dattrs_equal(dattr_cur, i, dattr_new, j))
                                 goto match1;
                 }
@@ -7824,15 +7954,15 @@ match1:
 
         if (doms_new == NULL) {
                 ndoms_cur = 0;
-                doms_new = &fallback_doms;
-                cpus_andnot(doms_new[0], cpu_online_map, cpu_isolated_map);
+                doms_new = fallback_doms;
+                cpumask_andnot(&doms_new[0], cpu_online_mask, cpu_isolated_map);
                 WARN_ON_ONCE(dattr_new);
         }
 
         /* Build new domains */
         for (i = 0; i < ndoms_new; i++) {
                 for (j = 0; j < ndoms_cur && !new_topology; j++) {
-                        if (cpus_equal(doms_new[i], doms_cur[j])
+                        if (cpumask_equal(&doms_new[i], &doms_cur[j])
                             && dattrs_equal(dattr_new, i, dattr_cur, j))
                                 goto match2;
                 }
@@ -7844,7 +7974,7 @@ match2:
         }
 
         /* Remember the new sched domains */
-        if (doms_cur != &fallback_doms)
+        if (doms_cur != fallback_doms)
                 kfree(doms_cur);
         kfree(dattr_cur);       /* kfree(NULL) is safe */
         doms_cur = doms_new;
@@ -7873,14 +8003,25 @@ int arch_reinit_sched_domains(void)
 static ssize_t sched_power_savings_store(const char *buf, size_t count, int smt)
 {
         int ret;
+        unsigned int level = 0;
+
+        if (sscanf(buf, "%u", &level) != 1)
+                return -EINVAL;
+
+        /*
+         * level is always be positive so don't check for
+         * level < POWERSAVINGS_BALANCE_NONE which is 0
+         * What happens on 0 or 1 byte write,
+         * need to check for count as well?
+         */
 
-        if (buf[0] != '0' && buf[0] != '1')
+        if (level >= MAX_POWERSAVINGS_BALANCE_LEVELS)
                 return -EINVAL;
 
         if (smt)
-                sched_smt_power_savings = (buf[0] == '1');
+                sched_smt_power_savings = level;
         else
-                sched_mc_power_savings = (buf[0] == '1');
+                sched_mc_power_savings = level;
 
         ret = arch_reinit_sched_domains();
 
@@ -7984,7 +8125,9 @@ static int update_runtime(struct notifier_block *nfb,
 
 void __init sched_init_smp(void)
 {
-        cpumask_t non_isolated_cpus;
+        cpumask_var_t non_isolated_cpus;
+
+        alloc_cpumask_var(&non_isolated_cpus, GFP_KERNEL);
 
 #if defined(CONFIG_NUMA)
         sched_group_nodes_bycpu = kzalloc(nr_cpu_ids * sizeof(void **),
@@ -7993,10 +8136,10 @@ void __init sched_init_smp(void)
 #endif
         get_online_cpus();
         mutex_lock(&sched_domains_mutex);
-        arch_init_sched_domains(&cpu_online_map);
-        cpus_andnot(non_isolated_cpus, cpu_possible_map, cpu_isolated_map);
-        if (cpus_empty(non_isolated_cpus))
-                cpu_set(smp_processor_id(), non_isolated_cpus);
+        arch_init_sched_domains(cpu_online_mask);
+        cpumask_andnot(non_isolated_cpus, cpu_possible_mask, cpu_isolated_map);
+        if (cpumask_empty(non_isolated_cpus))
+                cpumask_set_cpu(smp_processor_id(), non_isolated_cpus);
         mutex_unlock(&sched_domains_mutex);
         put_online_cpus();
 
@@ -8011,9 +8154,13 @@ void __init sched_init_smp(void)
         init_hrtick();
 
         /* Move init over to a non-isolated CPU */
-        if (set_cpus_allowed_ptr(current, &non_isolated_cpus) < 0)
+        if (set_cpus_allowed_ptr(current, non_isolated_cpus) < 0)
                 BUG();
         sched_init_granularity();
+        free_cpumask_var(non_isolated_cpus);
+
+        alloc_cpumask_var(&fallback_doms, GFP_KERNEL);
+        init_sched_rt_class();
 }
 #else
 void __init sched_init_smp(void)
@@ -8328,6 +8475,15 @@ void __init sched_init(void)
          */
         current->sched_class = &fair_sched_class;
 
+        /* Allocate the nohz_cpu_mask if CONFIG_CPUMASK_OFFSTACK */
+        alloc_bootmem_cpumask_var(&nohz_cpu_mask);
+#ifdef CONFIG_SMP
+#ifdef CONFIG_NO_HZ
+        alloc_bootmem_cpumask_var(&nohz.cpu_mask);
+#endif
+        alloc_bootmem_cpumask_var(&cpu_isolated_map);
+#endif /* SMP */
+
         scheduler_running = 1;
 }
 
diff --git a/kernel/sched_cpupri.c b/kernel/sched_cpupri.c
index 52154fefab7e..018b7be1db2e 100644
--- a/kernel/sched_cpupri.c
+++ b/kernel/sched_cpupri.c
@@ -67,24 +67,21 @@ static int convert_prio(int prio)
  * Returns: (int)bool - CPUs were found
  */
 int cpupri_find(struct cpupri *cp, struct task_struct *p,
-                cpumask_t *lowest_mask)
+                struct cpumask *lowest_mask)
 {
         int                  idx      = 0;
         int                  task_pri = convert_prio(p->prio);
 
         for_each_cpupri_active(cp->pri_active, idx) {
                 struct cpupri_vec *vec  = &cp->pri_to_cpu[idx];
-                cpumask_t mask;
 
                 if (idx >= task_pri)
                         break;
 
-                cpus_and(mask, p->cpus_allowed, vec->mask);
-
-                if (cpus_empty(mask))
+                if (cpumask_any_and(&p->cpus_allowed, vec->mask) >= nr_cpu_ids)
                         continue;
 
-                *lowest_mask = mask;
+                cpumask_and(lowest_mask, &p->cpus_allowed, vec->mask);
                 return 1;
         }
 
@@ -126,7 +123,7 @@ void cpupri_set(struct cpupri *cp, int cpu, int newpri)
                 vec->count--;
                 if (!vec->count)
                         clear_bit(oldpri, cp->pri_active);
-                cpu_clear(cpu, vec->mask);
+                cpumask_clear_cpu(cpu, vec->mask);
 
                 spin_unlock_irqrestore(&vec->lock, flags);
         }
@@ -136,7 +133,7 @@ void cpupri_set(struct cpupri *cp, int cpu, int newpri)
 
                 spin_lock_irqsave(&vec->lock, flags);
 
-                cpu_set(cpu, vec->mask);
+                cpumask_set_cpu(cpu, vec->mask);
                 vec->count++;
                 if (vec->count == 1)
                         set_bit(newpri, cp->pri_active);
@@ -150,10 +147,11 @@ void cpupri_set(struct cpupri *cp, int cpu, int newpri)
 /**
  * cpupri_init - initialize the cpupri structure
  * @cp: The cpupri context
+ * @bootmem: true if allocations need to use bootmem
  *
- * Returns: (void)
+ * Returns: -ENOMEM if memory fails.
  */
-void cpupri_init(struct cpupri *cp)
+int cpupri_init(struct cpupri *cp, bool bootmem)
 {
         int i;
 
@@ -164,11 +162,30 @@ void cpupri_init(struct cpupri *cp)
 
                 spin_lock_init(&vec->lock);
                 vec->count = 0;
-                cpus_clear(vec->mask);
+                if (bootmem)
+                        alloc_bootmem_cpumask_var(&vec->mask);
+                else if (!alloc_cpumask_var(&vec->mask, GFP_KERNEL))
+                        goto cleanup;
         }
 
         for_each_possible_cpu(i)
                 cp->cpu_to_pri[i] = CPUPRI_INVALID;
+        return 0;
+
+cleanup:
+        for (i--; i >= 0; i--)
+                free_cpumask_var(cp->pri_to_cpu[i].mask);
+        return -ENOMEM;
 }
 
+/**
+ * cpupri_cleanup - clean up the cpupri structure
+ * @cp: The cpupri context
+ */
+void cpupri_cleanup(struct cpupri *cp)
+{
+        int i;
 
+        for (i = 0; i < CPUPRI_NR_PRIORITIES; i++)
+                free_cpumask_var(cp->pri_to_cpu[i].mask);
+}
diff --git a/kernel/sched_cpupri.h b/kernel/sched_cpupri.h
index f25811b0f931..642a94ef8a0a 100644
--- a/kernel/sched_cpupri.h
+++ b/kernel/sched_cpupri.h
@@ -14,7 +14,7 @@
 struct cpupri_vec {
         spinlock_t lock;
         int        count;
-        cpumask_t  mask;
+        cpumask_var_t mask;
 };
 
 struct cpupri {
@@ -27,7 +27,8 @@ struct cpupri {
 int  cpupri_find(struct cpupri *cp,
                  struct task_struct *p, cpumask_t *lowest_mask);
 void cpupri_set(struct cpupri *cp, int cpu, int pri);
-void cpupri_init(struct cpupri *cp);
+int cpupri_init(struct cpupri *cp, bool bootmem);
+void cpupri_cleanup(struct cpupri *cp);
 #else
 #define cpupri_set(cp, cpu, pri) do { } while (0)
 #define cpupri_init() do { } while (0)
diff --git a/kernel/sched_fair.c b/kernel/sched_fair.c
index b808563f4f19..e0c0b4bc3f08 100644
--- a/kernel/sched_fair.c
+++ b/kernel/sched_fair.c
@@ -1013,16 +1013,33 @@ static void yield_task_fair(struct rq *rq)
  * search starts with cpus closest then further out as needed,
  * so we always favor a closer, idle cpu.
  * Domains may include CPUs that are not usable for migration,
- * hence we need to mask them out (cpu_active_map)
+ * hence we need to mask them out (cpu_active_mask)
  *
  * Returns the CPU we should wake onto.
  */
 #if defined(ARCH_HAS_SCHED_WAKE_IDLE)
 static int wake_idle(int cpu, struct task_struct *p)
 {
-        cpumask_t tmp;
         struct sched_domain *sd;
         int i;
+        unsigned int chosen_wakeup_cpu;
+        int this_cpu;
+
+        /*
+         * At POWERSAVINGS_BALANCE_WAKEUP level, if both this_cpu and prev_cpu
+         * are idle and this is not a kernel thread and this task's affinity
+         * allows it to be moved to preferred cpu, then just move!
+         */
+
+        this_cpu = smp_processor_id();
+        chosen_wakeup_cpu =
+                cpu_rq(this_cpu)->rd->sched_mc_preferred_wakeup_cpu;
+
+        if (sched_mc_power_savings >= POWERSAVINGS_BALANCE_WAKEUP &&
+                idle_cpu(cpu) && idle_cpu(this_cpu) &&
+                p->mm && !(p->flags & PF_KTHREAD) &&
+                cpu_isset(chosen_wakeup_cpu, p->cpus_allowed))
+                return chosen_wakeup_cpu;
 
         /*
          * If it is idle, then it is the best cpu to run this task.
@@ -1040,10 +1057,9 @@ static int wake_idle(int cpu, struct task_struct *p)
                 if ((sd->flags & SD_WAKE_IDLE)
                     || ((sd->flags & SD_WAKE_IDLE_FAR)
                         && !task_hot(p, task_rq(p)->clock, sd))) {
-                        cpus_and(tmp, sd->span, p->cpus_allowed);
-                        cpus_and(tmp, tmp, cpu_active_map);
-                        for_each_cpu_mask_nr(i, tmp) {
-                                if (idle_cpu(i)) {
+                        for_each_cpu_and(i, sched_domain_span(sd),
+                                         &p->cpus_allowed) {
+                                if (cpu_active(i) && idle_cpu(i)) {
                                         if (i != task_cpu(p)) {
                                                 schedstat_inc(p,
                                                        se.nr_wakeups_idle);
@@ -1236,13 +1252,13 @@ static int select_task_rq_fair(struct task_struct *p, int sync)
          * this_cpu and prev_cpu are present in:
          */
         for_each_domain(this_cpu, sd) {
-                if (cpu_isset(prev_cpu, sd->span)) {
+                if (cpumask_test_cpu(prev_cpu, sched_domain_span(sd))) {
                         this_sd = sd;
                         break;
                 }
         }
 
-        if (unlikely(!cpu_isset(this_cpu, p->cpus_allowed)))
+        if (unlikely(!cpumask_test_cpu(this_cpu, &p->cpus_allowed)))
                 goto out;
 
         /*
diff --git a/kernel/sched_rt.c b/kernel/sched_rt.c
index 51d2af3e6191..954e1a81b796 100644
--- a/kernel/sched_rt.c
+++ b/kernel/sched_rt.c
@@ -15,7 +15,7 @@ static inline void rt_set_overload(struct rq *rq)
         if (!rq->online)
                 return;
 
-        cpu_set(rq->cpu, rq->rd->rto_mask);
+        cpumask_set_cpu(rq->cpu, rq->rd->rto_mask);
         /*
          * Make sure the mask is visible before we set
          * the overload count. That is checked to determine
@@ -34,7 +34,7 @@ static inline void rt_clear_overload(struct rq *rq)
 
         /* the order here really doesn't matter */
         atomic_dec(&rq->rd->rto_count);
-        cpu_clear(rq->cpu, rq->rd->rto_mask);
+        cpumask_clear_cpu(rq->cpu, rq->rd->rto_mask);
 }
 
 static void update_rt_migration(struct rq *rq)
@@ -139,14 +139,14 @@ static int rt_se_boosted(struct sched_rt_entity *rt_se)
 }
 
 #ifdef CONFIG_SMP
-static inline cpumask_t sched_rt_period_mask(void)
+static inline const struct cpumask *sched_rt_period_mask(void)
 {
         return cpu_rq(smp_processor_id())->rd->span;
 }
 #else
-static inline cpumask_t sched_rt_period_mask(void)
+static inline const struct cpumask *sched_rt_period_mask(void)
 {
-        return cpu_online_map;
+        return cpu_online_mask;
 }
 #endif
 
@@ -212,9 +212,9 @@ static inline int rt_rq_throttled(struct rt_rq *rt_rq)
         return rt_rq->rt_throttled;
 }
 
-static inline cpumask_t sched_rt_period_mask(void)
+static inline const struct cpumask *sched_rt_period_mask(void)
 {
-        return cpu_online_map;
+        return cpu_online_mask;
 }
 
 static inline
@@ -241,11 +241,11 @@ static int do_balance_runtime(struct rt_rq *rt_rq)
         int i, weight, more = 0;
         u64 rt_period;
 
-        weight = cpus_weight(rd->span);
+        weight = cpumask_weight(rd->span);
 
         spin_lock(&rt_b->rt_runtime_lock);
         rt_period = ktime_to_ns(rt_b->rt_period);
-        for_each_cpu_mask_nr(i, rd->span) {
+        for_each_cpu(i, rd->span) {
                 struct rt_rq *iter = sched_rt_period_rt_rq(rt_b, i);
                 s64 diff;
 
@@ -324,7 +324,7 @@ static void __disable_runtime(struct rq *rq)
                 /*
                  * Greedy reclaim, take back as much as we can.
                  */
-                for_each_cpu_mask(i, rd->span) {
+                for_each_cpu(i, rd->span) {
                         struct rt_rq *iter = sched_rt_period_rt_rq(rt_b, i);
                         s64 diff;
 
@@ -429,13 +429,13 @@ static inline int balance_runtime(struct rt_rq *rt_rq)
 static int do_sched_rt_period_timer(struct rt_bandwidth *rt_b, int overrun)
 {
         int i, idle = 1;
-        cpumask_t span;
+        const struct cpumask *span;
 
         if (!rt_bandwidth_enabled() || rt_b->rt_runtime == RUNTIME_INF)
                 return 1;
 
         span = sched_rt_period_mask();
-        for_each_cpu_mask(i, span) {
+        for_each_cpu(i, span) {
                 int enqueue = 0;
                 struct rt_rq *rt_rq = sched_rt_period_rt_rq(rt_b, i);
                 struct rq *rq = rq_of_rt_rq(rt_rq);
@@ -805,17 +805,20 @@ static int select_task_rq_rt(struct task_struct *p, int sync)
 
 static void check_preempt_equal_prio(struct rq *rq, struct task_struct *p)
 {
-        cpumask_t mask;
+        cpumask_var_t mask;
 
         if (rq->curr->rt.nr_cpus_allowed == 1)
                 return;
 
-        if (p->rt.nr_cpus_allowed != 1
-            && cpupri_find(&rq->rd->cpupri, p, &mask))
+        if (!alloc_cpumask_var(&mask, GFP_ATOMIC))
                 return;
 
-        if (!cpupri_find(&rq->rd->cpupri, rq->curr, &mask))
-                return;
+        if (p->rt.nr_cpus_allowed != 1
+            && cpupri_find(&rq->rd->cpupri, p, mask))
+                goto free;
+
+        if (!cpupri_find(&rq->rd->cpupri, rq->curr, mask))
+                goto free;
 
         /*
          * There appears to be other cpus that can accept
@@ -824,6 +827,8 @@ static void check_preempt_equal_prio(struct rq *rq, struct task_struct *p)
          */
         requeue_task_rt(rq, p, 1);
         resched_task(rq->curr);
+free:
+        free_cpumask_var(mask);
 }
 
 #endif /* CONFIG_SMP */
@@ -914,7 +919,7 @@ static void deactivate_task(struct rq *rq, struct task_struct *p, int sleep);
 static int pick_rt_task(struct rq *rq, struct task_struct *p, int cpu)
 {
         if (!task_running(rq, p) &&
-            (cpu < 0 || cpu_isset(cpu, p->cpus_allowed)) &&
+            (cpu < 0 || cpumask_test_cpu(cpu, &p->cpus_allowed)) &&
             (p->rt.nr_cpus_allowed > 1))
                 return 1;
         return 0;
@@ -953,7 +958,7 @@ static struct task_struct *pick_next_highest_task_rt(struct rq *rq, int cpu)
         return next;
 }
 
-static DEFINE_PER_CPU(cpumask_t, local_cpu_mask);
+static DEFINE_PER_CPU(cpumask_var_t, local_cpu_mask);
 
 static inline int pick_optimal_cpu(int this_cpu, cpumask_t *mask)
 {
@@ -973,7 +978,7 @@ static inline int pick_optimal_cpu(int this_cpu, cpumask_t *mask)
 static int find_lowest_rq(struct task_struct *task)
 {
         struct sched_domain *sd;
-        cpumask_t *lowest_mask = &__get_cpu_var(local_cpu_mask);
+        struct cpumask *lowest_mask = __get_cpu_var(local_cpu_mask);
         int this_cpu = smp_processor_id();
         int cpu      = task_cpu(task);
 
@@ -988,7 +993,7 @@ static int find_lowest_rq(struct task_struct *task)
          * I guess we might want to change cpupri_find() to ignore those
          * in the first place.
          */
-        cpus_and(*lowest_mask, *lowest_mask, cpu_active_map);
+        cpumask_and(lowest_mask, lowest_mask, cpu_active_mask);
 
         /*
          * At this point we have built a mask of cpus representing the
@@ -998,7 +1003,7 @@ static int find_lowest_rq(struct task_struct *task)
          * We prioritize the last cpu that the task executed on since
          * it is most likely cache-hot in that location.
          */
-        if (cpu_isset(cpu, *lowest_mask))
+        if (cpumask_test_cpu(cpu, lowest_mask))
                 return cpu;
 
         /*
@@ -1013,7 +1018,8 @@ static int find_lowest_rq(struct task_struct *task)
                         cpumask_t domain_mask;
                         int       best_cpu;
 
-                        cpus_and(domain_mask, sd->span, *lowest_mask);
+                        cpumask_and(&domain_mask, sched_domain_span(sd),
+                                    lowest_mask);
 
                         best_cpu = pick_optimal_cpu(this_cpu,
                                                     &domain_mask);
@@ -1054,8 +1060,8 @@ static struct rq *find_lock_lowest_rq(struct task_struct *task, struct rq *rq)
                          * Also make sure that it wasn't scheduled on its rq.
                          */
                         if (unlikely(task_rq(task) != rq ||
-                                     !cpu_isset(lowest_rq->cpu,
-                                                task->cpus_allowed) ||
+                                     !cpumask_test_cpu(lowest_rq->cpu,
+                                                       &task->cpus_allowed) ||
                                      task_running(rq, task) ||
                                      !task->se.on_rq)) {
 
@@ -1176,7 +1182,7 @@ static int pull_rt_task(struct rq *this_rq)
 
         next = pick_next_task_rt(this_rq);
 
-        for_each_cpu_mask_nr(cpu, this_rq->rd->rto_mask) {
+        for_each_cpu(cpu, this_rq->rd->rto_mask) {
                 if (this_cpu == cpu)
                         continue;
 
@@ -1305,9 +1311,9 @@ move_one_task_rt(struct rq *this_rq, int this_cpu, struct rq *busiest,
 }
 
 static void set_cpus_allowed_rt(struct task_struct *p,
-                                const cpumask_t *new_mask)
+                                const struct cpumask *new_mask)
 {
-        int weight = cpus_weight(*new_mask);
+        int weight = cpumask_weight(new_mask);
 
         BUG_ON(!rt_task(p));
 
@@ -1328,7 +1334,7 @@ static void set_cpus_allowed_rt(struct task_struct *p,
                 update_rt_migration(rq);
         }
 
-        p->cpus_allowed    = *new_mask;
+        cpumask_copy(&p->cpus_allowed, new_mask);
         p->rt.nr_cpus_allowed = weight;
 }
 
@@ -1371,6 +1377,15 @@ static void switched_from_rt(struct rq *rq, struct task_struct *p,
         if (!rq->rt.rt_nr_running)
                 pull_rt_task(rq);
 }
+
+static inline void init_sched_rt_class(void)
+{
+        unsigned int i;
+
+        for_each_possible_cpu(i)
+                alloc_cpumask_var_node(&per_cpu(local_cpu_mask, i),
+                                        GFP_KERNEL, cpu_to_node(i));
+}
 #endif /* CONFIG_SMP */
 
 /*
@@ -1541,3 +1556,4 @@ static void print_rt_stats(struct seq_file *m, int cpu)
         rcu_read_unlock();
 }
 #endif /* CONFIG_SCHED_DEBUG */
+
diff --git a/kernel/sched_stats.h b/kernel/sched_stats.h
index 3b01098164c8..f2773b5d1226 100644
--- a/kernel/sched_stats.h
+++ b/kernel/sched_stats.h
@@ -42,7 +42,8 @@ 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,
+                                          sched_domain_span(sd));
                         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..5cfa0e5e3e88 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;
@@ -223,7 +223,7 @@ int smp_call_function_single(int cpu, void (*func) (void *info), void *info,
                 local_irq_save(flags);
                 func(info);
                 local_irq_restore(flags);
-        } else if ((unsigned)cpu < NR_CPUS && cpu_online(cpu)) {
+        } else if ((unsigned)cpu < nr_cpu_ids && cpu_online(cpu)) {
                 struct call_single_data *data = NULL;
 
                 if (!wait) {
@@ -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/softirq.c b/kernel/softirq.c
index 670c1eca47ec..bdbe9de9cd8d 100644
--- a/kernel/softirq.c
+++ b/kernel/softirq.c
@@ -733,7 +733,7 @@ static int __cpuinit cpu_callback(struct notifier_block *nfb,
                         break;
                 /* Unbind so it can run.  Fall thru. */
                 kthread_bind(per_cpu(ksoftirqd, hotcpu),
-                             any_online_cpu(cpu_online_map));
+                             cpumask_any(cpu_online_mask));
         case CPU_DEAD:
         case CPU_DEAD_FROZEN: {
                 struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };
diff --git a/kernel/softlockup.c b/kernel/softlockup.c
index 1ab790c67b17..d9188c66278a 100644
--- a/kernel/softlockup.c
+++ b/kernel/softlockup.c
@@ -303,17 +303,15 @@ cpu_callback(struct notifier_block *nfb, unsigned long action, void *hcpu)
                 break;
         case CPU_ONLINE:
         case CPU_ONLINE_FROZEN:
-                check_cpu = any_online_cpu(cpu_online_map);
+                check_cpu = cpumask_any(cpu_online_mask);
                 wake_up_process(per_cpu(watchdog_task, hotcpu));
                 break;
 #ifdef CONFIG_HOTPLUG_CPU
         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;
 
@@ -323,7 +321,7 @@ cpu_callback(struct notifier_block *nfb, unsigned long action, void *hcpu)
                         break;
                 /* Unbind so it can run.  Fall thru. */
                 kthread_bind(per_cpu(watchdog_task, hotcpu),
-                             any_online_cpu(cpu_online_map));
+                             cpumask_any(cpu_online_mask));
         case CPU_DEAD:
         case CPU_DEAD_FROZEN:
                 p = per_cpu(watchdog_task, hotcpu);
diff --git a/kernel/stop_machine.c b/kernel/stop_machine.c
index 24e8ceacc388..286c41722e8c 100644
--- a/kernel/stop_machine.c
+++ b/kernel/stop_machine.c
@@ -69,10 +69,10 @@ static void stop_cpu(struct work_struct *unused)
         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 *), void *data, const cpumask_t *cpus)
         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;
 
diff --git a/kernel/taskstats.c b/kernel/taskstats.c
index bd6be76303cf..888adbcca30c 100644
--- a/kernel/taskstats.c
+++ b/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, cpumask_t *maskp, int isadd)
 
         /* 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;
@@ -352,7 +351,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;
 }
@@ -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
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/clocksource.c b/kernel/time/clocksource.c
index 9ed2eec97526..ca89e1593f08 100644
--- a/kernel/time/clocksource.c
+++ b/kernel/time/clocksource.c
@@ -145,10 +145,11 @@ static void clocksource_watchdog(unsigned long data)
                  * Cycle through CPUs to check if the CPUs stay
                  * synchronized to each other.
                  */
-                int next_cpu = next_cpu_nr(raw_smp_processor_id(), cpu_online_map);
+                int next_cpu = cpumask_next(raw_smp_processor_id(),
+                                            cpu_online_mask);
 
                 if (next_cpu >= nr_cpu_ids)
-                        next_cpu = first_cpu(cpu_online_map);
+                        next_cpu = cpumask_first(cpu_online_mask);
                 watchdog_timer.expires += WATCHDOG_INTERVAL;
                 add_timer_on(&watchdog_timer, next_cpu);
         }
@@ -173,7 +174,7 @@ static void clocksource_check_watchdog(struct clocksource *cs)
                         watchdog_last = watchdog->read();
                         watchdog_timer.expires = jiffies + WATCHDOG_INTERVAL;
                         add_timer_on(&watchdog_timer,
-                                     first_cpu(cpu_online_map));
+                                     cpumask_first(cpu_online_mask));
                 }
         } else {
                 if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)
@@ -195,7 +196,7 @@ static void clocksource_check_watchdog(struct clocksource *cs)
                                 watchdog_timer.expires =
                                         jiffies + WATCHDOG_INTERVAL;
                                 add_timer_on(&watchdog_timer,
-                                             first_cpu(cpu_online_map));
+                                             cpumask_first(cpu_online_mask));
                         }
                 }
         }
diff --git a/kernel/time/tick-broadcast.c b/kernel/time/tick-broadcast.c
index f98a1b7b16e9..118a3b3b3f9a 100644
--- a/kernel/time/tick-broadcast.c
+++ b/kernel/time/tick-broadcast.c
@@ -28,7 +28,9 @@
  */
 
 struct tick_device tick_broadcast_device;
-static cpumask_t tick_broadcast_mask;
+/* FIXME: Use cpumask_var_t. */
+static DECLARE_BITMAP(tick_broadcast_mask, NR_CPUS);
+static DECLARE_BITMAP(tmpmask, NR_CPUS);
 static DEFINE_SPINLOCK(tick_broadcast_lock);
 static int tick_broadcast_force;
 
@@ -46,9 +48,9 @@ struct tick_device *tick_get_broadcast_device(void)
         return &tick_broadcast_device;
 }
 
-cpumask_t *tick_get_broadcast_mask(void)
+struct cpumask *tick_get_broadcast_mask(void)
 {
-        return &tick_broadcast_mask;
+        return to_cpumask(tick_broadcast_mask);
 }
 
 /*
@@ -72,7 +74,7 @@ int tick_check_broadcast_device(struct clock_event_device *dev)
 
         clockevents_exchange_device(NULL, dev);
         tick_broadcast_device.evtdev = dev;
-        if (!cpus_empty(tick_broadcast_mask))
+        if (!cpumask_empty(tick_get_broadcast_mask()))
                 tick_broadcast_start_periodic(dev);
         return 1;
 }
@@ -104,7 +106,7 @@ int tick_device_uses_broadcast(struct clock_event_device *dev, int cpu)
          */
         if (!tick_device_is_functional(dev)) {
                 dev->event_handler = tick_handle_periodic;
-                cpu_set(cpu, tick_broadcast_mask);
+                cpumask_set_cpu(cpu, tick_get_broadcast_mask());
                 tick_broadcast_start_periodic(tick_broadcast_device.evtdev);
                 ret = 1;
         } else {
@@ -116,7 +118,7 @@ int tick_device_uses_broadcast(struct clock_event_device *dev, int cpu)
                 if (!(dev->features & CLOCK_EVT_FEAT_C3STOP)) {
                         int cpu = smp_processor_id();
 
-                        cpu_clear(cpu, tick_broadcast_mask);
+                        cpumask_clear_cpu(cpu, tick_get_broadcast_mask());
                         tick_broadcast_clear_oneshot(cpu);
                 }
         }
@@ -125,9 +127,9 @@ int tick_device_uses_broadcast(struct clock_event_device *dev, int cpu)
 }
 
 /*
- * Broadcast the event to the cpus, which are set in the mask
+ * Broadcast the event to the cpus, which are set in the mask (mangled).
  */
-static void tick_do_broadcast(cpumask_t mask)
+static void tick_do_broadcast(struct cpumask *mask)
 {
         int cpu = smp_processor_id();
         struct tick_device *td;
@@ -135,21 +137,20 @@ static void tick_do_broadcast(cpumask_t mask)
         /*
          * Check, if the current cpu is in the mask
          */
-        if (cpu_isset(cpu, mask)) {
-                cpu_clear(cpu, mask);
+        if (cpumask_test_cpu(cpu, mask)) {
+                cpumask_clear_cpu(cpu, mask);
                 td = &per_cpu(tick_cpu_device, cpu);
                 td->evtdev->event_handler(td->evtdev);
         }
 
-        if (!cpus_empty(mask)) {
+        if (!cpumask_empty(mask)) {
                 /*
                  * It might be necessary to actually check whether the devices
                  * have different broadcast functions. For now, just use the
                  * one of the first device. This works as long as we have this
                  * misfeature only on x86 (lapic)
                  */
-                cpu = first_cpu(mask);
-                td = &per_cpu(tick_cpu_device, cpu);
+                td = &per_cpu(tick_cpu_device, cpumask_first(mask));
                 td->evtdev->broadcast(mask);
         }
 }
@@ -160,12 +161,11 @@ static void tick_do_broadcast(cpumask_t mask)
  */
 static void tick_do_periodic_broadcast(void)
 {
-        cpumask_t mask;
-
         spin_lock(&tick_broadcast_lock);
 
-        cpus_and(mask, cpu_online_map, tick_broadcast_mask);
-        tick_do_broadcast(mask);
+        cpumask_and(to_cpumask(tmpmask),
+                    cpu_online_mask, tick_get_broadcast_mask());
+        tick_do_broadcast(to_cpumask(tmpmask));
 
         spin_unlock(&tick_broadcast_lock);
 }
@@ -228,13 +228,13 @@ static void tick_do_broadcast_on_off(void *why)
         if (!tick_device_is_functional(dev))
                 goto out;
 
-        bc_stopped = cpus_empty(tick_broadcast_mask);
+        bc_stopped = cpumask_empty(tick_get_broadcast_mask());
 
         switch (*reason) {
         case CLOCK_EVT_NOTIFY_BROADCAST_ON:
         case CLOCK_EVT_NOTIFY_BROADCAST_FORCE:
-                if (!cpu_isset(cpu, tick_broadcast_mask)) {
-                        cpu_set(cpu, tick_broadcast_mask);
+                if (!cpumask_test_cpu(cpu, tick_get_broadcast_mask())) {
+                        cpumask_set_cpu(cpu, tick_get_broadcast_mask());
                         if (tick_broadcast_device.mode ==
                             TICKDEV_MODE_PERIODIC)
                                 clockevents_shutdown(dev);
@@ -244,8 +244,8 @@ static void tick_do_broadcast_on_off(void *why)
                 break;
         case CLOCK_EVT_NOTIFY_BROADCAST_OFF:
                 if (!tick_broadcast_force &&
-                    cpu_isset(cpu, tick_broadcast_mask)) {
-                        cpu_clear(cpu, tick_broadcast_mask);
+                    cpumask_test_cpu(cpu, tick_get_broadcast_mask())) {
+                        cpumask_clear_cpu(cpu, tick_get_broadcast_mask());
                         if (tick_broadcast_device.mode ==
                             TICKDEV_MODE_PERIODIC)
                                 tick_setup_periodic(dev, 0);
@@ -253,7 +253,7 @@ static void tick_do_broadcast_on_off(void *why)
                 break;
         }
 
-        if (cpus_empty(tick_broadcast_mask)) {
+        if (cpumask_empty(tick_get_broadcast_mask())) {
                 if (!bc_stopped)
                         clockevents_shutdown(bc);
         } else if (bc_stopped) {
@@ -272,7 +272,7 @@ out:
  */
 void tick_broadcast_on_off(unsigned long reason, int *oncpu)
 {
-        if (!cpu_isset(*oncpu, cpu_online_map))
+        if (!cpumask_test_cpu(*oncpu, cpu_online_mask))
                 printk(KERN_ERR "tick-broadcast: ignoring broadcast for "
                        "offline CPU #%d\n", *oncpu);
         else
@@ -303,10 +303,10 @@ void tick_shutdown_broadcast(unsigned int *cpup)
         spin_lock_irqsave(&tick_broadcast_lock, flags);
 
         bc = tick_broadcast_device.evtdev;
-        cpu_clear(cpu, tick_broadcast_mask);
+        cpumask_clear_cpu(cpu, tick_get_broadcast_mask());
 
         if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC) {
-                if (bc && cpus_empty(tick_broadcast_mask))
+                if (bc && cpumask_empty(tick_get_broadcast_mask()))
                         clockevents_shutdown(bc);
         }
 
@@ -342,10 +342,10 @@ int tick_resume_broadcast(void)
 
                 switch (tick_broadcast_device.mode) {
                 case TICKDEV_MODE_PERIODIC:
-                        if(!cpus_empty(tick_broadcast_mask))
+                        if (!cpumask_empty(tick_get_broadcast_mask()))
                                 tick_broadcast_start_periodic(bc);
-                        broadcast = cpu_isset(smp_processor_id(),
-                                              tick_broadcast_mask);
+                        broadcast = cpumask_test_cpu(smp_processor_id(),
+                                                     tick_get_broadcast_mask());
                         break;
                 case TICKDEV_MODE_ONESHOT:
                         broadcast = tick_resume_broadcast_oneshot(bc);
@@ -360,14 +360,15 @@ int tick_resume_broadcast(void)
 
 #ifdef CONFIG_TICK_ONESHOT
 
-static cpumask_t tick_broadcast_oneshot_mask;
+/* FIXME: use cpumask_var_t. */
+static DECLARE_BITMAP(tick_broadcast_oneshot_mask, NR_CPUS);
 
 /*
- * Debugging: see timer_list.c
+ * Exposed for debugging: see timer_list.c
  */
-cpumask_t *tick_get_broadcast_oneshot_mask(void)
+struct cpumask *tick_get_broadcast_oneshot_mask(void)
 {
-        return &tick_broadcast_oneshot_mask;
+        return to_cpumask(tick_broadcast_oneshot_mask);
 }
 
 static int tick_broadcast_set_event(ktime_t expires, int force)
@@ -389,7 +390,7 @@ int tick_resume_broadcast_oneshot(struct clock_event_device *bc)
  */
 void tick_check_oneshot_broadcast(int cpu)
 {
-        if (cpu_isset(cpu, tick_broadcast_oneshot_mask)) {
+        if (cpumask_test_cpu(cpu, to_cpumask(tick_broadcast_oneshot_mask))) {
                 struct tick_device *td = &per_cpu(tick_cpu_device, cpu);
 
                 clockevents_set_mode(td->evtdev, CLOCK_EVT_MODE_ONESHOT);
@@ -402,7 +403,6 @@ void tick_check_oneshot_broadcast(int cpu)
 static void tick_handle_oneshot_broadcast(struct clock_event_device *dev)
 {
         struct tick_device *td;
-        cpumask_t mask;
         ktime_t now, next_event;
         int cpu;
 
@@ -410,13 +410,13 @@ static void tick_handle_oneshot_broadcast(struct clock_event_device *dev)
 again:
         dev->next_event.tv64 = KTIME_MAX;
         next_event.tv64 = KTIME_MAX;
-        mask = CPU_MASK_NONE;
+        cpumask_clear(to_cpumask(tmpmask));
         now = ktime_get();
         /* Find all expired events */
-        for_each_cpu_mask_nr(cpu, tick_broadcast_oneshot_mask) {
+        for_each_cpu(cpu, tick_get_broadcast_oneshot_mask()) {
                 td = &per_cpu(tick_cpu_device, cpu);
                 if (td->evtdev->next_event.tv64 <= now.tv64)
-                        cpu_set(cpu, mask);
+                        cpumask_set_cpu(cpu, to_cpumask(tmpmask));
                 else if (td->evtdev->next_event.tv64 < next_event.tv64)
                         next_event.tv64 = td->evtdev->next_event.tv64;
         }
@@ -424,7 +424,7 @@ again:
         /*
          * Wakeup the cpus which have an expired event.
          */
-        tick_do_broadcast(mask);
+        tick_do_broadcast(to_cpumask(tmpmask));
 
         /*
          * Two reasons for reprogram:
@@ -476,15 +476,16 @@ void tick_broadcast_oneshot_control(unsigned long reason)
                 goto out;
 
         if (reason == CLOCK_EVT_NOTIFY_BROADCAST_ENTER) {
-                if (!cpu_isset(cpu, tick_broadcast_oneshot_mask)) {
-                        cpu_set(cpu, tick_broadcast_oneshot_mask);
+                if (!cpumask_test_cpu(cpu, tick_get_broadcast_oneshot_mask())) {
+                        cpumask_set_cpu(cpu, tick_get_broadcast_oneshot_mask());
                         clockevents_set_mode(dev, CLOCK_EVT_MODE_SHUTDOWN);
                         if (dev->next_event.tv64 < bc->next_event.tv64)
                                 tick_broadcast_set_event(dev->next_event, 1);
                 }
         } else {
-                if (cpu_isset(cpu, tick_broadcast_oneshot_mask)) {
-                        cpu_clear(cpu, tick_broadcast_oneshot_mask);
+                if (cpumask_test_cpu(cpu, tick_get_broadcast_oneshot_mask())) {
+                        cpumask_clear_cpu(cpu,
+                                          tick_get_broadcast_oneshot_mask());
                         clockevents_set_mode(dev, CLOCK_EVT_MODE_ONESHOT);
                         if (dev->next_event.tv64 != KTIME_MAX)
                                 tick_program_event(dev->next_event, 1);
@@ -502,15 +503,16 @@ out:
  */
 static void tick_broadcast_clear_oneshot(int cpu)
 {
-        cpu_clear(cpu, tick_broadcast_oneshot_mask);
+        cpumask_clear_cpu(cpu, tick_get_broadcast_oneshot_mask());
 }
 
-static void tick_broadcast_init_next_event(cpumask_t *mask, ktime_t expires)
+static void tick_broadcast_init_next_event(struct cpumask *mask,
+                                           ktime_t expires)
 {
         struct tick_device *td;
         int cpu;
 
-        for_each_cpu_mask_nr(cpu, *mask) {
+        for_each_cpu(cpu, mask) {
                 td = &per_cpu(tick_cpu_device, cpu);
                 if (td->evtdev)
                         td->evtdev->next_event = expires;
@@ -526,7 +528,6 @@ void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
         if (bc->event_handler != tick_handle_oneshot_broadcast) {
                 int was_periodic = bc->mode == CLOCK_EVT_MODE_PERIODIC;
                 int cpu = smp_processor_id();
-                cpumask_t mask;
 
                 bc->event_handler = tick_handle_oneshot_broadcast;
                 clockevents_set_mode(bc, CLOCK_EVT_MODE_ONESHOT);
@@ -540,13 +541,15 @@ void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
                  * oneshot_mask bits for those and program the
                  * broadcast device to fire.
                  */
-                mask = tick_broadcast_mask;
-                cpu_clear(cpu, mask);
-                cpus_or(tick_broadcast_oneshot_mask,
-                        tick_broadcast_oneshot_mask, mask);
-
-                if (was_periodic && !cpus_empty(mask)) {
-                        tick_broadcast_init_next_event(&mask, tick_next_period);
+                cpumask_copy(to_cpumask(tmpmask), tick_get_broadcast_mask());
+                cpumask_clear_cpu(cpu, to_cpumask(tmpmask));
+                cpumask_or(tick_get_broadcast_oneshot_mask(),
+                           tick_get_broadcast_oneshot_mask(),
+                           to_cpumask(tmpmask));
+
+                if (was_periodic && !cpumask_empty(to_cpumask(tmpmask))) {
+                        tick_broadcast_init_next_event(to_cpumask(tmpmask),
+                                                       tick_next_period);
                         tick_broadcast_set_event(tick_next_period, 1);
                 } else
                         bc->next_event.tv64 = KTIME_MAX;
@@ -585,7 +588,7 @@ void tick_shutdown_broadcast_oneshot(unsigned int *cpup)
          * Clear the broadcast mask flag for the dead cpu, but do not
          * stop the broadcast device!
          */
-        cpu_clear(cpu, tick_broadcast_oneshot_mask);
+        cpumask_clear_cpu(cpu, tick_get_broadcast_oneshot_mask());
 
         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
 }
diff --git a/kernel/time/tick-common.c b/kernel/time/tick-common.c
index df12434b43ca..63e05d423a09 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;
         }
 
@@ -254,7 +254,7 @@ static int tick_check_new_device(struct clock_event_device *newdev)
                 curdev = NULL;
         }
         clockevents_exchange_device(curdev, newdev);
-        tick_setup_device(td, newdev, cpu, &cpumask_of_cpu(cpu));
+        tick_setup_device(td, newdev, cpu, cpumask_of(cpu));
         if (newdev->features & CLOCK_EVT_FEAT_ONESHOT)
                 tick_oneshot_notify();
 
@@ -299,9 +299,9 @@ static void tick_shutdown(unsigned int *cpup)
         }
         /* Transfer the do_timer job away from this cpu */
         if (*cpup == tick_do_timer_cpu) {
-                int cpu = first_cpu(cpu_online_map);
+                int cpu = cpumask_first(cpu_online_mask);
 
-                tick_do_timer_cpu = (cpu != NR_CPUS) ? cpu :
+                tick_do_timer_cpu = (cpu < nr_cpu_ids) ? cpu :
                         TICK_DO_TIMER_NONE;
         }
         spin_unlock_irqrestore(&tick_device_lock, flags);
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index 8f3fc2582d38..1b6c05bd0d0a 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -144,7 +144,7 @@ void tick_nohz_update_jiffies(void)
         if (!ts->tick_stopped)
                 return;
 
-        cpu_clear(cpu, nohz_cpu_mask);
+        cpumask_clear_cpu(cpu, nohz_cpu_mask);
         now = ktime_get();
         ts->idle_waketime = now;
 
@@ -301,7 +301,7 @@ void tick_nohz_stop_sched_tick(int inidle)
                         tick_do_timer_cpu = TICK_DO_TIMER_NONE;
 
                 if (delta_jiffies > 1)
-                        cpu_set(cpu, nohz_cpu_mask);
+                        cpumask_set_cpu(cpu, nohz_cpu_mask);
 
                 /* Skip reprogram of event if its not changed */
                 if (ts->tick_stopped && ktime_equal(expires, dev->next_event))
@@ -319,7 +319,7 @@ void tick_nohz_stop_sched_tick(int inidle)
                                 /*
                                  * sched tick not stopped!
                                  */
-                                cpu_clear(cpu, nohz_cpu_mask);
+                                cpumask_clear_cpu(cpu, nohz_cpu_mask);
                                 goto out;
                         }
 
@@ -361,7 +361,7 @@ void tick_nohz_stop_sched_tick(int inidle)
                  * softirq.
                  */
                 tick_do_update_jiffies64(ktime_get());
-                cpu_clear(cpu, nohz_cpu_mask);
+                cpumask_clear_cpu(cpu, nohz_cpu_mask);
         }
         raise_softirq_irqoff(TIMER_SOFTIRQ);
 out:
@@ -419,7 +419,9 @@ void tick_nohz_restart_sched_tick(void)
 {
         int cpu = smp_processor_id();
         struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
+#ifndef CONFIG_VIRT_CPU_ACCOUNTING
         unsigned long ticks;
+#endif
         ktime_t now;
 
         local_irq_disable();
@@ -439,8 +441,9 @@ void tick_nohz_restart_sched_tick(void)
         select_nohz_load_balancer(0);
         now = ktime_get();
         tick_do_update_jiffies64(now);
-        cpu_clear(cpu, nohz_cpu_mask);
+        cpumask_clear_cpu(cpu, nohz_cpu_mask);
 
+#ifndef CONFIG_VIRT_CPU_ACCOUNTING
         /*
          * We stopped the tick in idle. Update process times would miss the
          * time we slept as update_process_times does only a 1 tick
@@ -450,12 +453,9 @@ void tick_nohz_restart_sched_tick(void)
         /*
          * We might be one off. Do not randomly account a huge number of ticks!
          */
-        if (ticks && ticks < LONG_MAX) {
-                add_preempt_count(HARDIRQ_OFFSET);
-                account_system_time(current, HARDIRQ_OFFSET,
-                                    jiffies_to_cputime(ticks));
-                sub_preempt_count(HARDIRQ_OFFSET);
-        }
+        if (ticks && ticks < LONG_MAX)
+                account_idle_ticks(ticks);
+#endif
 
         touch_softlockup_watchdog();
         /*
diff --git a/kernel/timer.c b/kernel/timer.c
index 566257d1dc10..dee3f641a7a7 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -1018,21 +1018,6 @@ unsigned long get_next_timer_interrupt(unsigned long now)
 }
 #endif
 
-#ifndef CONFIG_VIRT_CPU_ACCOUNTING
-void account_process_tick(struct task_struct *p, int user_tick)
-{
-        cputime_t one_jiffy = jiffies_to_cputime(1);
-
-        if (user_tick) {
-                account_user_time(p, one_jiffy);
-                account_user_time_scaled(p, cputime_to_scaled(one_jiffy));
-        } else {
-                account_system_time(p, HARDIRQ_OFFSET, one_jiffy);
-                account_system_time_scaled(p, cputime_to_scaled(one_jiffy));
-        }
-}
-#endif
-
 /*
  * Called from the timer interrupt handler to charge one tick to the current
  * process.  user_tick is 1 if the tick is user time, 0 for system.
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index 1d601a7c4587..a9d9760dc7b6 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -195,7 +195,7 @@ void *ring_buffer_event_data(struct ring_buffer_event *event)
 EXPORT_SYMBOL_GPL(ring_buffer_event_data);
 
 #define for_each_buffer_cpu(buffer, cpu)                \
-        for_each_cpu_mask(cpu, buffer->cpumask)
+        for_each_cpu(cpu, buffer->cpumask)
 
 #define TS_SHIFT        27
 #define TS_MASK         ((1ULL << TS_SHIFT) - 1)
@@ -267,7 +267,7 @@ struct ring_buffer {
         unsigned                        pages;
         unsigned                        flags;
         int                             cpus;
-        cpumask_t                       cpumask;
+        cpumask_var_t                   cpumask;
         atomic_t                        record_disabled;
 
         struct mutex                    mutex;
@@ -458,6 +458,9 @@ struct ring_buffer *ring_buffer_alloc(unsigned long size, unsigned flags)
         if (!buffer)
                 return NULL;
 
+        if (!alloc_cpumask_var(&buffer->cpumask, GFP_KERNEL))
+                goto fail_free_buffer;
+
         buffer->pages = DIV_ROUND_UP(size, BUF_PAGE_SIZE);
         buffer->flags = flags;
 
@@ -465,14 +468,14 @@ struct ring_buffer *ring_buffer_alloc(unsigned long size, unsigned flags)
         if (buffer->pages == 1)
                 buffer->pages++;
 
-        buffer->cpumask = cpu_possible_map;
+        cpumask_copy(buffer->cpumask, cpu_possible_mask);
         buffer->cpus = nr_cpu_ids;
 
         bsize = sizeof(void *) * nr_cpu_ids;
         buffer->buffers = kzalloc(ALIGN(bsize, cache_line_size()),
                                   GFP_KERNEL);
         if (!buffer->buffers)
-                goto fail_free_buffer;
+                goto fail_free_cpumask;
 
         for_each_buffer_cpu(buffer, cpu) {
                 buffer->buffers[cpu] =
@@ -492,6 +495,9 @@ struct ring_buffer *ring_buffer_alloc(unsigned long size, unsigned flags)
         }
         kfree(buffer->buffers);
 
+ fail_free_cpumask:
+        free_cpumask_var(buffer->cpumask);
+
  fail_free_buffer:
         kfree(buffer);
         return NULL;
@@ -510,6 +516,8 @@ ring_buffer_free(struct ring_buffer *buffer)
         for_each_buffer_cpu(buffer, cpu)
                 rb_free_cpu_buffer(buffer->buffers[cpu]);
 
+        free_cpumask_var(buffer->cpumask);
+
         kfree(buffer);
 }
 EXPORT_SYMBOL_GPL(ring_buffer_free);
@@ -1283,7 +1291,7 @@ ring_buffer_lock_reserve(struct ring_buffer *buffer,
 
         cpu = raw_smp_processor_id();
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 goto out;
 
         cpu_buffer = buffer->buffers[cpu];
@@ -1396,7 +1404,7 @@ int ring_buffer_write(struct ring_buffer *buffer,
 
         cpu = raw_smp_processor_id();
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 goto out;
 
         cpu_buffer = buffer->buffers[cpu];
@@ -1478,7 +1486,7 @@ void ring_buffer_record_disable_cpu(struct ring_buffer *buffer, int cpu)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return;
 
         cpu_buffer = buffer->buffers[cpu];
@@ -1498,7 +1506,7 @@ void ring_buffer_record_enable_cpu(struct ring_buffer *buffer, int cpu)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return;
 
         cpu_buffer = buffer->buffers[cpu];
@@ -1515,7 +1523,7 @@ unsigned long ring_buffer_entries_cpu(struct ring_buffer *buffer, int cpu)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return 0;
 
         cpu_buffer = buffer->buffers[cpu];
@@ -1532,7 +1540,7 @@ unsigned long ring_buffer_overrun_cpu(struct ring_buffer *buffer, int cpu)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return 0;
 
         cpu_buffer = buffer->buffers[cpu];
@@ -1850,7 +1858,7 @@ rb_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
         struct buffer_page *reader;
         int nr_loops = 0;
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return NULL;
 
         cpu_buffer = buffer->buffers[cpu];
@@ -2025,7 +2033,7 @@ ring_buffer_consume(struct ring_buffer *buffer, int cpu, u64 *ts)
         struct ring_buffer_event *event;
         unsigned long flags;
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return NULL;
 
         spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
@@ -2062,7 +2070,7 @@ ring_buffer_read_start(struct ring_buffer *buffer, int cpu)
         struct ring_buffer_iter *iter;
         unsigned long flags;
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return NULL;
 
         iter = kmalloc(sizeof(*iter), GFP_KERNEL);
@@ -2172,7 +2180,7 @@ void ring_buffer_reset_cpu(struct ring_buffer *buffer, int cpu)
         struct ring_buffer_per_cpu *cpu_buffer = buffer->buffers[cpu];
         unsigned long flags;
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return;
 
         spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
@@ -2228,7 +2236,7 @@ int ring_buffer_empty_cpu(struct ring_buffer *buffer, int cpu)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
 
-        if (!cpu_isset(cpu, buffer->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return 1;
 
         cpu_buffer = buffer->buffers[cpu];
@@ -2252,8 +2260,8 @@ int ring_buffer_swap_cpu(struct ring_buffer *buffer_a,
         struct ring_buffer_per_cpu *cpu_buffer_a;
         struct ring_buffer_per_cpu *cpu_buffer_b;
 
-        if (!cpu_isset(cpu, buffer_a->cpumask) ||
-            !cpu_isset(cpu, buffer_b->cpumask))
+        if (!cpumask_test_cpu(cpu, buffer_a->cpumask) ||
+            !cpumask_test_cpu(cpu, buffer_b->cpumask))
                 return -EINVAL;
 
         /* At least make sure the two buffers are somewhat the same */
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 4185d5221633..c580233add95 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -89,10 +89,10 @@ static inline void ftrace_enable_cpu(void)
         preempt_enable();
 }
 
-static cpumask_t __read_mostly          tracing_buffer_mask;
+static cpumask_var_t __read_mostly      tracing_buffer_mask;
 
 #define for_each_tracing_cpu(cpu)       \
-        for_each_cpu_mask(cpu, tracing_buffer_mask)
+        for_each_cpu(cpu, tracing_buffer_mask)
 
 /*
  * ftrace_dump_on_oops - variable to dump ftrace buffer on oops
@@ -1811,10 +1811,10 @@ static void test_cpu_buff_start(struct trace_iterator *iter)
         if (!(iter->iter_flags & TRACE_FILE_ANNOTATE))
                 return;
 
-        if (cpu_isset(iter->cpu, iter->started))
+        if (cpumask_test_cpu(iter->cpu, iter->started))
                 return;
 
-        cpu_set(iter->cpu, iter->started);
+        cpumask_set_cpu(iter->cpu, iter->started);
         trace_seq_printf(s, "##### CPU %u buffer started ####\n", iter->cpu);
 }
 
@@ -2646,13 +2646,7 @@ static struct file_operations show_traces_fops = {
 /*
  * Only trace on a CPU if the bitmask is set:
  */
-static cpumask_t tracing_cpumask = CPU_MASK_ALL;
-
-/*
- * When tracing/tracing_cpu_mask is modified then this holds
- * the new bitmask we are about to install:
- */
-static cpumask_t tracing_cpumask_new;
+static cpumask_var_t tracing_cpumask;
 
 /*
  * The tracer itself will not take this lock, but still we want
@@ -2693,6 +2687,10 @@ tracing_cpumask_write(struct file *filp, const char __user *ubuf,
                       size_t count, loff_t *ppos)
 {
         int err, cpu;
+        cpumask_var_t tracing_cpumask_new;
+
+        if (!alloc_cpumask_var(&tracing_cpumask_new, GFP_KERNEL))
+                return -ENOMEM;
 
         mutex_lock(&tracing_cpumask_update_lock);
         err = cpumask_parse_user(ubuf, count, tracing_cpumask_new);
@@ -2706,26 +2704,28 @@ tracing_cpumask_write(struct file *filp, const char __user *ubuf,
                  * Increase/decrease the disabled counter if we are
                  * about to flip a bit in the cpumask:
                  */
-                if (cpu_isset(cpu, tracing_cpumask) &&
-                                !cpu_isset(cpu, tracing_cpumask_new)) {
+                if (cpumask_test_cpu(cpu, tracing_cpumask) &&
+                                !cpumask_test_cpu(cpu, tracing_cpumask_new)) {
                         atomic_inc(&global_trace.data[cpu]->disabled);
                 }
-                if (!cpu_isset(cpu, tracing_cpumask) &&
-                                cpu_isset(cpu, tracing_cpumask_new)) {
+                if (!cpumask_test_cpu(cpu, tracing_cpumask) &&
+                                cpumask_test_cpu(cpu, tracing_cpumask_new)) {
                         atomic_dec(&global_trace.data[cpu]->disabled);
                 }
         }
         __raw_spin_unlock(&ftrace_max_lock);
         local_irq_enable();
 
-        tracing_cpumask = tracing_cpumask_new;
+        cpumask_copy(tracing_cpumask, tracing_cpumask_new);
 
         mutex_unlock(&tracing_cpumask_update_lock);
+        free_cpumask_var(tracing_cpumask_new);
 
         return count;
 
 err_unlock:
         mutex_unlock(&tracing_cpumask_update_lock);
+        free_cpumask_var(tracing_cpumask);
 
         return err;
 }
@@ -3114,10 +3114,15 @@ static int tracing_open_pipe(struct inode *inode, struct file *filp)
         if (!iter)
                 return -ENOMEM;
 
+        if (!alloc_cpumask_var(&iter->started, GFP_KERNEL)) {
+                kfree(iter);
+                return -ENOMEM;
+        }
+
         mutex_lock(&trace_types_lock);
 
         /* trace pipe does not show start of buffer */
-        cpus_setall(iter->started);
+        cpumask_setall(iter->started);
 
         iter->tr = &global_trace;
         iter->trace = current_trace;
@@ -3134,6 +3139,7 @@ static int tracing_release_pipe(struct inode *inode, struct file *file)
 {
         struct trace_iterator *iter = file->private_data;
 
+        free_cpumask_var(iter->started);
         kfree(iter);
         atomic_dec(&tracing_reader);
 
@@ -3752,7 +3758,6 @@ void ftrace_dump(void)
         static DEFINE_SPINLOCK(ftrace_dump_lock);
         /* use static because iter can be a bit big for the stack */
         static struct trace_iterator iter;
-        static cpumask_t mask;
         static int dump_ran;
         unsigned long flags;
         int cnt = 0, cpu;
@@ -3786,8 +3791,6 @@ void ftrace_dump(void)
          * and then release the locks again.
          */
 
-        cpus_clear(mask);
-
         while (!trace_empty(&iter)) {
 
                 if (!cnt)
@@ -3823,19 +3826,28 @@ __init static int tracer_alloc_buffers(void)
 {
         struct trace_array_cpu *data;
         int i;
+        int ret = -ENOMEM;
 
-        /* TODO: make the number of buffers hot pluggable with CPUS */
-        tracing_buffer_mask = cpu_possible_map;
+        if (!alloc_cpumask_var(&tracing_buffer_mask, GFP_KERNEL))
+                goto out;
+
+        if (!alloc_cpumask_var(&tracing_cpumask, GFP_KERNEL))
+                goto out_free_buffer_mask;
+
+        cpumask_copy(tracing_buffer_mask, cpu_possible_mask);
+        cpumask_copy(tracing_cpumask, cpu_all_mask);
 
+        /* TODO: make the number of buffers hot pluggable with CPUS */
         global_trace.buffer = ring_buffer_alloc(trace_buf_size,
                                                    TRACE_BUFFER_FLAGS);
         if (!global_trace.buffer) {
                 printk(KERN_ERR "tracer: failed to allocate ring buffer!\n");
                 WARN_ON(1);
-                return 0;
+                goto out_free_cpumask;
         }
         global_trace.entries = ring_buffer_size(global_trace.buffer);
 
+
 #ifdef CONFIG_TRACER_MAX_TRACE
         max_tr.buffer = ring_buffer_alloc(trace_buf_size,
                                              TRACE_BUFFER_FLAGS);
@@ -3843,7 +3855,7 @@ __init static int tracer_alloc_buffers(void)
                 printk(KERN_ERR "tracer: failed to allocate max ring buffer!\n");
                 WARN_ON(1);
                 ring_buffer_free(global_trace.buffer);
-                return 0;
+                goto out_free_cpumask;
         }
         max_tr.entries = ring_buffer_size(max_tr.buffer);
         WARN_ON(max_tr.entries != global_trace.entries);
@@ -3873,8 +3885,14 @@ __init static int tracer_alloc_buffers(void)
                                        &trace_panic_notifier);
 
         register_die_notifier(&trace_die_notifier);
+        ret = 0;
 
-        return 0;
+out_free_cpumask:
+        free_cpumask_var(tracing_cpumask);
+out_free_buffer_mask:
+        free_cpumask_var(tracing_buffer_mask);
+out:
+        return ret;
 }
 early_initcall(tracer_alloc_buffers);
 fs_initcall(tracer_init_debugfs);
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index cc7a4f864036..4d3d381bfd95 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -368,7 +368,7 @@ struct trace_iterator {
         loff_t                  pos;
         long                    idx;
 
-        cpumask_t               started;
+        cpumask_var_t           started;
 };
 
 int tracing_is_enabled(void);
diff --git a/kernel/trace/trace_boot.c b/kernel/trace/trace_boot.c
index 3ccebde28482..366c8c333e13 100644
--- a/kernel/trace/trace_boot.c
+++ b/kernel/trace/trace_boot.c
@@ -42,7 +42,7 @@ static int boot_trace_init(struct trace_array *tr)
         int cpu;
         boot_trace = tr;
 
-        for_each_cpu_mask(cpu, cpu_possible_map)
+        for_each_cpu(cpu, cpu_possible_mask)
                 tracing_reset(tr, cpu);
 
         tracing_sched_switch_assign_trace(tr);
diff --git a/kernel/trace/trace_functions_graph.c b/kernel/trace/trace_functions_graph.c
index 4bf39fcae97a..930c08e5b38e 100644
--- a/kernel/trace/trace_functions_graph.c
+++ b/kernel/trace/trace_functions_graph.c
@@ -79,7 +79,7 @@ print_graph_cpu(struct trace_seq *s, int cpu)
         int i;
         int ret;
         int log10_this = log10_cpu(cpu);
-        int log10_all = log10_cpu(cpus_weight_nr(cpu_online_map));
+        int log10_all = log10_cpu(cpumask_weight(cpu_online_mask));
 
 
         /*
diff --git a/kernel/trace/trace_hw_branches.c b/kernel/trace/trace_hw_branches.c
index b6a3e20a49a9..649df22d435f 100644
--- a/kernel/trace/trace_hw_branches.c
+++ b/kernel/trace/trace_hw_branches.c
@@ -46,7 +46,7 @@ static void bts_trace_start(struct trace_array *tr)
 
         tracing_reset_online_cpus(tr);
 
-        for_each_cpu_mask(cpu, cpu_possible_map)
+        for_each_cpu(cpu, cpu_possible_mask)
                 smp_call_function_single(cpu, bts_trace_start_cpu, NULL, 1);
 }
 
@@ -62,7 +62,7 @@ static void bts_trace_stop(struct trace_array *tr)
 {
         int cpu;
 
-        for_each_cpu_mask(cpu, cpu_possible_map)
+        for_each_cpu(cpu, cpu_possible_mask)
                 smp_call_function_single(cpu, bts_trace_stop_cpu, NULL, 1);
 }
 
@@ -172,7 +172,7 @@ static void trace_bts_prepare(struct trace_iterator *iter)
 {
         int cpu;
 
-        for_each_cpu_mask(cpu, cpu_possible_map)
+        for_each_cpu(cpu, cpu_possible_mask)
                 smp_call_function_single(cpu, trace_bts_cpu, iter->tr, 1);
 }
 
diff --git a/kernel/trace/trace_power.c b/kernel/trace/trace_power.c
index a7172a352f62..7bda248daf55 100644
--- a/kernel/trace/trace_power.c
+++ b/kernel/trace/trace_power.c
@@ -39,7 +39,7 @@ static int power_trace_init(struct trace_array *tr)
 
         trace_power_enabled = 1;
 
-        for_each_cpu_mask(cpu, cpu_possible_map)
+        for_each_cpu(cpu, cpu_possible_mask)
                 tracing_reset(tr, cpu);
         return 0;
 }
diff --git a/kernel/trace/trace_sysprof.c b/kernel/trace/trace_sysprof.c
index a5779bd975db..eaca5ad803ff 100644
--- a/kernel/trace/trace_sysprof.c
+++ b/kernel/trace/trace_sysprof.c
@@ -196,9 +196,9 @@ static enum hrtimer_restart stack_trace_timer_fn(struct hrtimer *hrtimer)
         return HRTIMER_RESTART;
 }
 
-static void start_stack_timer(int cpu)
+static void start_stack_timer(void *unused)
 {
-        struct hrtimer *hrtimer = &per_cpu(stack_trace_hrtimer, cpu);
+        struct hrtimer *hrtimer = &__get_cpu_var(stack_trace_hrtimer);
 
         hrtimer_init(hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
         hrtimer->function = stack_trace_timer_fn;
@@ -208,14 +208,7 @@ static void start_stack_timer(int cpu)
 
 static void start_stack_timers(void)
 {
-        cpumask_t saved_mask = current->cpus_allowed;
-        int cpu;
-
-        for_each_online_cpu(cpu) {
-                set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
-                start_stack_timer(cpu);
-        }
-        set_cpus_allowed_ptr(current, &saved_mask);
+        on_each_cpu(start_stack_timer, NULL, 1);
 }
 
 static void stop_stack_timer(int cpu)
diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index 4952322cba45..2f445833ae37 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -73,7 +73,7 @@ static DEFINE_SPINLOCK(workqueue_lock);
 static LIST_HEAD(workqueues);
 
 static int singlethread_cpu __read_mostly;
-static cpumask_t cpu_singlethread_map __read_mostly;
+static const struct cpumask *cpu_singlethread_map __read_mostly;
 /*
  * _cpu_down() first removes CPU from cpu_online_map, then CPU_DEAD
  * flushes cwq->worklist. This means that flush_workqueue/wait_on_work
@@ -81,7 +81,7 @@ static cpumask_t cpu_singlethread_map __read_mostly;
  * use cpu_possible_map, the cpumask below is more a documentation
  * than optimization.
  */
-static cpumask_t cpu_populated_map __read_mostly;
+static cpumask_var_t cpu_populated_map __read_mostly;
 
 /* If it's single threaded, it isn't in the list of workqueues. */
 static inline int is_wq_single_threaded(struct workqueue_struct *wq)
@@ -89,10 +89,10 @@ static inline int is_wq_single_threaded(struct workqueue_struct *wq)
         return wq->singlethread;
 }
 
-static const cpumask_t *wq_cpu_map(struct workqueue_struct *wq)
+static const struct cpumask *wq_cpu_map(struct workqueue_struct *wq)
 {
         return is_wq_single_threaded(wq)
-                ? &cpu_singlethread_map : &cpu_populated_map;
+                ? cpu_singlethread_map : cpu_populated_map;
 }
 
 static
@@ -410,7 +410,7 @@ static int flush_cpu_workqueue(struct cpu_workqueue_struct *cwq)
  */
 void flush_workqueue(struct workqueue_struct *wq)
 {
-        const cpumask_t *cpu_map = wq_cpu_map(wq);
+        const struct cpumask *cpu_map = wq_cpu_map(wq);
         int cpu;
 
         might_sleep();
@@ -532,7 +532,7 @@ static void wait_on_work(struct work_struct *work)
 {
         struct cpu_workqueue_struct *cwq;
         struct workqueue_struct *wq;
-        const cpumask_t *cpu_map;
+        const struct cpumask *cpu_map;
         int cpu;
 
         might_sleep();
@@ -903,7 +903,7 @@ static void cleanup_workqueue_thread(struct cpu_workqueue_struct *cwq)
  */
 void destroy_workqueue(struct workqueue_struct *wq)
 {
-        const cpumask_t *cpu_map = wq_cpu_map(wq);
+        const struct cpumask *cpu_map = wq_cpu_map(wq);
         int cpu;
 
         cpu_maps_update_begin();
@@ -933,7 +933,7 @@ static int __devinit workqueue_cpu_callback(struct notifier_block *nfb,
 
         switch (action) {
         case CPU_UP_PREPARE:
-                cpu_set(cpu, cpu_populated_map);
+                cpumask_set_cpu(cpu, cpu_populated_map);
         }
 undo:
         list_for_each_entry(wq, &workqueues, list) {
@@ -964,7 +964,7 @@ undo:
         switch (action) {
         case CPU_UP_CANCELED:
         case CPU_POST_DEAD:
-                cpu_clear(cpu, cpu_populated_map);
+                cpumask_clear_cpu(cpu, cpu_populated_map);
         }
 
         return ret;
@@ -1017,9 +1017,11 @@ EXPORT_SYMBOL_GPL(work_on_cpu);
 
 void __init init_workqueues(void)
 {
-        cpu_populated_map = cpu_online_map;
-        singlethread_cpu = first_cpu(cpu_possible_map);
-        cpu_singlethread_map = cpumask_of_cpu(singlethread_cpu);
+        alloc_cpumask_var(&cpu_populated_map, GFP_KERNEL);
+
+        cpumask_copy(cpu_populated_map, cpu_online_mask);
+        singlethread_cpu = cpumask_first(cpu_possible_mask);
+        cpu_singlethread_map = cpumask_of(singlethread_cpu);
         hotcpu_notifier(workqueue_cpu_callback, 0);
         keventd_wq = create_workqueue("events");
         BUG_ON(!keventd_wq);