49 files changed, 1041 insertions, 879 deletions
diff --git a/Documentation/controllers/cpuacct.txt b/Documentation/controllers/cpuacct.txt
new file mode 100644
index 000000000000..bb775fbe43d7
--- /dev/null
+++ b/Documentation/controllers/cpuacct.txt
@@ -0,0 +1,32 @@
+CPU Accounting Controller
+-------------------------
+The CPU accounting controller is used to group tasks using cgroups and
+account the CPU usage of these groups of tasks.
+The CPU accounting controller supports multi-hierarchy groups. An accounting
+group accumulates the CPU usage of all of its child groups and the tasks
+directly present in its group.
+Accounting groups can be created by first mounting the cgroup filesystem.
+# mkdir /cgroups
+# mount -t cgroup -ocpuacct none /cgroups
+With the above step, the initial or the parent accounting group
+becomes visible at /cgroups. At bootup, this group includes all the
+tasks in the system. /cgroups/tasks lists the tasks in this cgroup.
+/cgroups/cpuacct.usage gives the CPU time (in nanoseconds) obtained by
+this group which is essentially the CPU time obtained by all the tasks
+in the system.
+New accounting groups can be created under the parent group /cgroups.
+# cd /cgroups
+# mkdir g1
+# echo $$ > g1
+The above steps create a new group g1 and move the current shell
+process (bash) into it. CPU time consumed by this bash and its children
+can be obtained from g1/cpuacct.usage and the same is accumulated in
+/cgroups/cpuacct.usage also.
diff --git a/Documentation/lockstat.txt b/Documentation/lockstat.txt
index 4ba4664ce5c3..9cb9138f7a79 100644
--- a/Documentation/lockstat.txt
+++ b/Documentation/lockstat.txt
@@ -71,35 +71,50 @@ Look at the current lock statistics:
 # less /proc/lock_stat
-01 lock_stat version 0.2
+01 lock_stat version 0.3
 02 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 03                               class name    con-bounces    contentions   waittime-min   waittime-max waittime-total    acq-bounces   acquisitions   holdtime-min   holdtime-max holdtime-total
 04 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 05
-06               &inode->i_data.tree_lock-W:            15          21657           0.18     1093295.30 11547131054.85             58          10415           0.16          87.51        6387.60
+06                          &mm->mmap_sem-W:           233            538 18446744073708       22924.27      607243.51           1342          45806           1.71        8595.89     1180582.34
-07               &inode->i_data.tree_lock-R:             0              0           0.00           0.00           0.00          23302         231198           0.25           8.45       98023.38
+07                          &mm->mmap_sem-R:           205            587 18446744073708       28403.36      731975.00           1940         412426           0.58      187825.45     6307502.88
-08               --------------------------
+08                          ---------------
-09                 &inode->i_data.tree_lock              0          [<ffffffff8027c08f>] add_to_page_cache+0x5f/0x190
+09                            &mm->mmap_sem            487          [<ffffffff8053491f>] do_page_fault+0x466/0x928
-10
+10                            &mm->mmap_sem            179          [<ffffffff802a6200>] sys_mprotect+0xcd/0x21d
-11 ...............................................................................................................................................................................................
+11                            &mm->mmap_sem            279          [<ffffffff80210a57>] sys_mmap+0x75/0xce
-12
+12                            &mm->mmap_sem             76          [<ffffffff802a490b>] sys_munmap+0x32/0x59
-13                              dcache_lock:          1037           1161           0.38          45.32         774.51           6611         243371           0.15         306.48       77387.24
+13                          ---------------
-14                              -----------
+14                            &mm->mmap_sem            270          [<ffffffff80210a57>] sys_mmap+0x75/0xce
-15                              dcache_lock            180          [<ffffffff802c0d7e>] sys_getcwd+0x11e/0x230
+15                            &mm->mmap_sem            431          [<ffffffff8053491f>] do_page_fault+0x466/0x928
-16                              dcache_lock            165          [<ffffffff802c002a>] d_alloc+0x15a/0x210
+16                            &mm->mmap_sem            138          [<ffffffff802a490b>] sys_munmap+0x32/0x59
-17                              dcache_lock             33          [<ffffffff8035818d>] _atomic_dec_and_lock+0x4d/0x70
+17                            &mm->mmap_sem            145          [<ffffffff802a6200>] sys_mprotect+0xcd/0x21d
-18                              dcache_lock              1          [<ffffffff802beef8>] shrink_dcache_parent+0x18/0x130
+18
+19 ...............................................................................................................................................................................................
+20
+21                              dcache_lock:           621            623           0.52         118.26        1053.02           6745          91930           0.29         316.29      118423.41
+22                              -----------
+23                              dcache_lock            179          [<ffffffff80378274>] _atomic_dec_and_lock+0x34/0x54
+24                              dcache_lock            113          [<ffffffff802cc17b>] d_alloc+0x19a/0x1eb
+25                              dcache_lock             99          [<ffffffff802ca0dc>] d_rehash+0x1b/0x44
+26                              dcache_lock            104          [<ffffffff802cbca0>] d_instantiate+0x36/0x8a
+27                              -----------
+28                              dcache_lock            192          [<ffffffff80378274>] _atomic_dec_and_lock+0x34/0x54
+29                              dcache_lock             98          [<ffffffff802ca0dc>] d_rehash+0x1b/0x44
+30                              dcache_lock             72          [<ffffffff802cc17b>] d_alloc+0x19a/0x1eb
+31                              dcache_lock            112          [<ffffffff802cbca0>] d_instantiate+0x36/0x8a
 This excerpt shows the first two lock class statistics. Line 01 shows the
 output version - each time the format changes this will be updated. Line 02-04
-show the header with column descriptions. Lines 05-10 and 13-18 show the actual
+show the header with column descriptions. Lines 05-18 and 20-31 show the actual
 statistics. These statistics come in two parts; the actual stats separated by a
-short separator (line 08, 14) from the contention points.
+short separator (line 08, 13) from the contention points.
-The first lock (05-10) is a read/write lock, and shows two lines above the
+The first lock (05-18) is a read/write lock, and shows two lines above the
 short separator. The contention points don't match the column descriptors,
-they have two: contentions and [<IP>] symbol.
+they have two: contentions and [<IP>] symbol. The second set of contention
+points are the points we're contending with.
+The integer part of the time values is in us.
 View the top contending locks:
diff --git a/Documentation/scheduler/sched-arch.txt b/Documentation/scheduler/sched-arch.txt
index 941615a9769b..d43dbcbd163b 100644
--- a/Documentation/scheduler/sched-arch.txt
+++ b/Documentation/scheduler/sched-arch.txt
@@ -8,7 +8,7 @@ Context switch
 By default, the switch_to arch function is called with the runqueue
 locked. This is usually not a problem unless switch_to may need to
 take the runqueue lock. This is usually due to a wake up operation in
-the context switch. See include/asm-ia64/system.h for an example.
+the context switch. See arch/ia64/include/asm/system.h for an example.
 To request the scheduler call switch_to with the runqueue unlocked,
 you must `#define __ARCH_WANT_UNLOCKED_CTXSW` in a header file
@@ -23,7 +23,7 @@ disabled. Interrupts may be enabled over the call if it is likely to
 introduce a significant interrupt latency by adding the line
 `#define __ARCH_WANT_INTERRUPTS_ON_CTXSW` in the same place as for
 unlocked context switches. This define also implies
-`__ARCH_WANT_UNLOCKED_CTXSW`. See include/asm-arm/system.h for an
+`__ARCH_WANT_UNLOCKED_CTXSW`. See arch/arm/include/asm/system.h for an
 example.
diff --git a/arch/ia64/Kconfig b/arch/ia64/Kconfig
index 6bd91ed7cd03..7fa8f615ba6e 100644
--- a/arch/ia64/Kconfig
+++ b/arch/ia64/Kconfig
@@ -99,7 +99,7 @@ config GENERIC_IOMAP
        bool
        default y
-config SCHED_NO_NO_OMIT_FRAME_POINTER
+config SCHED_OMIT_FRAME_POINTER
        bool
        default y
diff --git a/arch/ia64/include/asm/topology.h b/arch/ia64/include/asm/topology.h
index 35bcb641c9e5..a3cc9f65f954 100644
--- a/arch/ia64/include/asm/topology.h
+++ b/arch/ia64/include/asm/topology.h
@@ -55,7 +55,6 @@
 void build_cpu_to_node_map(void);
 #define SD_CPU_INIT (struct sched_domain) {             \
-        .span                   = CPU_MASK_NONE,        \
        .parent                 = NULL,                 \
        .child                  = NULL,                 \
        .groups                 = NULL,                 \
@@ -80,7 +79,6 @@ void build_cpu_to_node_map(void);
 /* sched_domains SD_NODE_INIT for IA64 NUMA machines */
 #define SD_NODE_INIT (struct sched_domain) {            \
-        .span                   = CPU_MASK_NONE,        \
        .parent                 = NULL,                 \
        .child                  = NULL,                 \
        .groups                 = NULL,                 \
diff --git a/arch/m32r/Kconfig b/arch/m32r/Kconfig
index dbaed4a63815..29047d5c259a 100644
--- a/arch/m32r/Kconfig
+++ b/arch/m32r/Kconfig
@@ -273,7 +273,7 @@ config GENERIC_CALIBRATE_DELAY
        bool
        default y
-config SCHED_NO_NO_OMIT_FRAME_POINTER
+config SCHED_OMIT_FRAME_POINTER
        bool
        default y
diff --git a/arch/mips/Kconfig b/arch/mips/Kconfig
index f4af967a6b30..a5255e7c79e0 100644
--- a/arch/mips/Kconfig
+++ b/arch/mips/Kconfig
@@ -653,7 +653,7 @@ config GENERIC_CMOS_UPDATE
        bool
        default y
-config SCHED_NO_NO_OMIT_FRAME_POINTER
+config SCHED_OMIT_FRAME_POINTER
        bool
        default y
diff --git a/arch/mips/include/asm/mach-ip27/topology.h b/arch/mips/include/asm/mach-ip27/topology.h
index 7785bec732f2..1fb959f98982 100644
--- a/arch/mips/include/asm/mach-ip27/topology.h
+++ b/arch/mips/include/asm/mach-ip27/topology.h
@@ -37,7 +37,6 @@ extern unsigned char __node_distances[MAX_COMPACT_NODES][MAX_COMPACT_NODES];
 /* sched_domains SD_NODE_INIT for SGI IP27 machines */
 #define SD_NODE_INIT (struct sched_domain) {            \
-        .span                   = CPU_MASK_NONE,        \
        .parent                 = NULL,                 \
        .child                  = NULL,                 \
        .groups                 = NULL,                 \
diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig
index 525c13a4de93..adb23ea1c1ef 100644
--- a/arch/powerpc/Kconfig
+++ b/arch/powerpc/Kconfig
@@ -141,7 +141,7 @@ config GENERIC_NVRAM
        bool
        default y if PPC32
-config SCHED_NO_NO_OMIT_FRAME_POINTER
+config SCHED_OMIT_FRAME_POINTER
        bool
        default y
diff --git a/arch/powerpc/include/asm/topology.h b/arch/powerpc/include/asm/topology.h
index c32da6f97999..373fca394a54 100644
--- a/arch/powerpc/include/asm/topology.h
+++ b/arch/powerpc/include/asm/topology.h
@@ -48,7 +48,6 @@ static inline int pcibus_to_node(struct pci_bus *bus)
 /* sched_domains SD_NODE_INIT for PPC64 machines */
 #define SD_NODE_INIT (struct sched_domain) {            \
-        .span                   = CPU_MASK_NONE,        \
        .parent                 = NULL,                 \
        .child                  = NULL,                 \
        .groups                 = NULL,                 \
diff --git a/arch/sh/include/asm/topology.h b/arch/sh/include/asm/topology.h
index 95f0085e098a..279d9cc4a007 100644
--- a/arch/sh/include/asm/topology.h
+++ b/arch/sh/include/asm/topology.h
@@ -5,7 +5,6 @@
 /* sched_domains SD_NODE_INIT for sh machines */
 #define SD_NODE_INIT (struct sched_domain) {            \
-        .span                   = CPU_MASK_NONE,        \
        .parent                 = NULL,                 \
        .child                  = NULL,                 \
        .groups                 = NULL,                 \
diff --git a/arch/um/include/asm/system.h b/arch/um/include/asm/system.h
index 753346e2cdfd..ae5f94d6317d 100644
--- a/arch/um/include/asm/system.h
+++ b/arch/um/include/asm/system.h
@@ -11,21 +11,21 @@ extern int get_signals(void);
 extern void block_signals(void);
 extern void unblock_signals(void);
-#define local_save_flags(flags) do { typecheck(unsigned long, flags); \
+#define raw_local_save_flags(flags) do { typecheck(unsigned long, flags); \
                                     (flags) = get_signals(); } while(0)
-#define local_irq_restore(flags) do { typecheck(unsigned long, flags); \
+#define raw_local_irq_restore(flags) do { typecheck(unsigned long, flags); \
                                      set_signals(flags); } while(0)
-#define local_irq_save(flags) do { local_save_flags(flags); \
+#define raw_local_irq_save(flags) do { raw_local_save_flags(flags); \
-                                   local_irq_disable(); } while(0)
+                                   raw_local_irq_disable(); } while(0)
-#define local_irq_enable() unblock_signals()
+#define raw_local_irq_enable() unblock_signals()
-#define local_irq_disable() block_signals()
+#define raw_local_irq_disable() block_signals()
 #define irqs_disabled()                 \
 ({                                      \
        unsigned long flags;            \
-        local_save_flags(flags);        \
+        raw_local_save_flags(flags);        \
        (flags == 0);                   \
 })
diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index 45c86fb94132..c7235e643aff 100644
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -370,10 +370,10 @@ config X86_RDC321X
          as R-8610-(G).
          If you don't have one of these chips, you should say N here.
-config SCHED_NO_NO_OMIT_FRAME_POINTER
+config SCHED_OMIT_FRAME_POINTER
        def_bool y
        prompt "Single-depth WCHAN output"
-        depends on X86_32
+        depends on X86
        help
          Calculate simpler /proc/<PID>/wchan values. If this option
          is disabled then wchan values will recurse back to the
diff --git a/arch/x86/include/asm/uaccess.h b/arch/x86/include/asm/uaccess.h
index 35c54921b2e4..99192bb55a53 100644
--- a/arch/x86/include/asm/uaccess.h
+++ b/arch/x86/include/asm/uaccess.h
@@ -157,6 +157,7 @@ extern int __get_user_bad(void);
        int __ret_gu;                                                   \
        unsigned long __val_gu;                                         \
        __chk_user_ptr(ptr);                                            \
+        might_fault();                                                  \
        switch (sizeof(*(ptr))) {                                       \
        case 1:                                                         \
                __get_user_x(1, __ret_gu, __val_gu, ptr);               \
@@ -241,6 +242,7 @@ extern void __put_user_8(void);
        int __ret_pu;                                           \
        __typeof__(*(ptr)) __pu_val;                            \
        __chk_user_ptr(ptr);                                    \
+        might_fault();                                          \
        __pu_val = x;                                           \
        switch (sizeof(*(ptr))) {                               \
        case 1:                                                 \
diff --git a/arch/x86/include/asm/uaccess_32.h b/arch/x86/include/asm/uaccess_32.h
index d095a3aeea1b..5e06259e90e5 100644
--- a/arch/x86/include/asm/uaccess_32.h
+++ b/arch/x86/include/asm/uaccess_32.h
@@ -82,8 +82,8 @@ __copy_to_user_inatomic(void __user *to, const void *from, unsigned long n)
 static __always_inline unsigned long __must_check
 __copy_to_user(void __user *to, const void *from, unsigned long n)
 {
-       might_sleep();
+        might_fault();
-       return __copy_to_user_inatomic(to, from, n);
+        return __copy_to_user_inatomic(to, from, n);
 }
 static __always_inline unsigned long
@@ -137,7 +137,7 @@ __copy_from_user_inatomic(void *to, const void __user *from, unsigned long n)
 static __always_inline unsigned long
 __copy_from_user(void *to, const void __user *from, unsigned long n)
 {
-        might_sleep();
+        might_fault();
        if (__builtin_constant_p(n)) {
                unsigned long ret;
@@ -159,7 +159,7 @@ __copy_from_user(void *to, const void __user *from, unsigned long n)
 static __always_inline unsigned long __copy_from_user_nocache(void *to,
                                const void __user *from, unsigned long n)
 {
-        might_sleep();
+        might_fault();
        if (__builtin_constant_p(n)) {
                unsigned long ret;
diff --git a/arch/x86/include/asm/uaccess_64.h b/arch/x86/include/asm/uaccess_64.h
index f8cfd00db450..84210c479fca 100644
--- a/arch/x86/include/asm/uaccess_64.h
+++ b/arch/x86/include/asm/uaccess_64.h
@@ -29,6 +29,8 @@ static __always_inline __must_check
 int __copy_from_user(void *dst, const void __user *src, unsigned size)
 {
        int ret = 0;
+        might_fault();
        if (!__builtin_constant_p(size))
                return copy_user_generic(dst, (__force void *)src, size);
        switch (size) {
@@ -71,6 +73,8 @@ static __always_inline __must_check
 int __copy_to_user(void __user *dst, const void *src, unsigned size)
 {
        int ret = 0;
+        might_fault();
        if (!__builtin_constant_p(size))
                return copy_user_generic((__force void *)dst, src, size);
        switch (size) {
@@ -113,6 +117,8 @@ static __always_inline __must_check
 int __copy_in_user(void __user *dst, const void __user *src, unsigned size)
 {
        int ret = 0;
+        might_fault();
        if (!__builtin_constant_p(size))
                return copy_user_generic((__force void *)dst,
                                         (__force void *)src, size);
diff --git a/arch/x86/lib/usercopy_32.c b/arch/x86/lib/usercopy_32.c
index 9e68075544f6..4a20b2f9a381 100644
--- a/arch/x86/lib/usercopy_32.c
+++ b/arch/x86/lib/usercopy_32.c
@@ -39,7 +39,7 @@ static inline int __movsl_is_ok(unsigned long a1, unsigned long a2, unsigned lon
 #define __do_strncpy_from_user(dst, src, count, res)                       \
 do {                                                                       \
        int __d0, __d1, __d2;                                              \
-        might_sleep();                                                     \
+        might_fault();                                                     \
        __asm__ __volatile__(                                              \
                "       testl %1,%1\n"                                     \
                "       jz 2f\n"                                           \
@@ -126,7 +126,7 @@ EXPORT_SYMBOL(strncpy_from_user);
 #define __do_clear_user(addr,size)                                      \
 do {                                                                    \
        int __d0;                                                       \
-        might_sleep();                                                  \
+        might_fault();                                                  \
        __asm__ __volatile__(                                           \
                "0:     rep; stosl\n"                                   \
                "       movl %2,%0\n"                                   \
@@ -155,7 +155,7 @@ do {									\
 unsigned long
 clear_user(void __user *to, unsigned long n)
 {
-        might_sleep();
+        might_fault();
        if (access_ok(VERIFY_WRITE, to, n))
                __do_clear_user(to, n);
        return n;
@@ -197,7 +197,7 @@ long strnlen_user(const char __user *s, long n)
        unsigned long mask = -__addr_ok(s);
        unsigned long res, tmp;
-        might_sleep();
+        might_fault();
        __asm__ __volatile__(
                "       testl %0, %0\n"
diff --git a/arch/x86/lib/usercopy_64.c b/arch/x86/lib/usercopy_64.c
index f4df6e7c718b..64d6c84e6353 100644
--- a/arch/x86/lib/usercopy_64.c
+++ b/arch/x86/lib/usercopy_64.c
@@ -15,7 +15,7 @@
 #define __do_strncpy_from_user(dst,src,count,res)                          \
 do {                                                                       \
        long __d0, __d1, __d2;                                             \
-        might_sleep();                                                     \
+        might_fault();                                                     \
        __asm__ __volatile__(                                              \
                "       testq %1,%1\n"                                     \
                "       jz 2f\n"                                           \
@@ -64,7 +64,7 @@ EXPORT_SYMBOL(strncpy_from_user);
 unsigned long __clear_user(void __user *addr, unsigned long size)
 {
        long __d0;
-        might_sleep();
+        might_fault();
        /* no memory constraint because it doesn't change any memory gcc knows
           about */
        asm volatile(
diff --git a/include/asm-m32r/system.h b/include/asm-m32r/system.h
index 70a57c8c002b..c980f5ba8de7 100644
--- a/include/asm-m32r/system.h
+++ b/include/asm-m32r/system.h
@@ -23,7 +23,7 @@
 */
 #if defined(CONFIG_FRAME_POINTER) || \
-        !defined(CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER)
+        !defined(CONFIG_SCHED_OMIT_FRAME_POINTER)
 #define M32R_PUSH_FP "  push fp\n"
 #define M32R_POP_FP  "  pop  fp\n"
 #else
diff --git a/include/linux/debug_locks.h b/include/linux/debug_locks.h
index 4aaa4afb1cb9..096476f1fb35 100644
--- a/include/linux/debug_locks.h
+++ b/include/linux/debug_locks.h
@@ -17,7 +17,7 @@ extern int debug_locks_off(void);
 ({                                                                      \
        int __ret = 0;                                                  \
                                                                        \
-        if (unlikely(c)) {                                              \
+        if (!oops_in_progress && unlikely(c)) {                         \
                if (debug_locks_off() && !debug_locks_silent)           \
                        WARN_ON(1);                                     \
                __ret = 1;                                              \
diff --git a/include/linux/futex.h b/include/linux/futex.h
index 586ab56a3ec3..8f627b9ae2b1 100644
--- a/include/linux/futex.h
+++ b/include/linux/futex.h
@@ -164,6 +164,8 @@ union futex_key {
        } both;
 };
+#define FUTEX_KEY_INIT (union futex_key) { .both = { .ptr = NULL } }
 #ifdef CONFIG_FUTEX
 extern void exit_robust_list(struct task_struct *curr);
 extern void exit_pi_state_list(struct task_struct *curr);
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index dc7e0d0a6474..269df5a17b30 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -141,6 +141,15 @@ extern int _cond_resched(void);
                (__x < 0) ? -__x : __x;         \
        })
+#ifdef CONFIG_PROVE_LOCKING
+void might_fault(void);
+#else
+static inline void might_fault(void)
+{
+        might_sleep();
+}
+#endif
 extern struct atomic_notifier_head panic_notifier_list;
 extern long (*panic_blink)(long time);
 NORET_TYPE void panic(const char * fmt, ...)
@@ -188,6 +197,8 @@ extern unsigned long long memparse(const char *ptr, char **retptr);
 extern int core_kernel_text(unsigned long addr);
 extern int __kernel_text_address(unsigned long addr);
 extern int kernel_text_address(unsigned long addr);
+extern int func_ptr_is_kernel_text(void *ptr);
 struct pid;
 extern struct pid *session_of_pgrp(struct pid *pgrp);
diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
index 29aec6e10020..8956daf64abd 100644
--- a/include/linux/lockdep.h
+++ b/include/linux/lockdep.h
@@ -73,6 +73,8 @@ struct lock_class_key {
        struct lockdep_subclass_key     subkeys[MAX_LOCKDEP_SUBCLASSES];
 };
+#define LOCKSTAT_POINTS         4
 /*
 * The lock-class itself:
 */
@@ -119,7 +121,8 @@ struct lock_class {
        int                             name_version;
 #ifdef CONFIG_LOCK_STAT
-        unsigned long                   contention_point[4];
+        unsigned long                   contention_point[LOCKSTAT_POINTS];
+        unsigned long                   contending_point[LOCKSTAT_POINTS];
 #endif
 };
@@ -144,6 +147,7 @@ enum bounce_type {
 struct lock_class_stats {
        unsigned long                   contention_point[4];
+        unsigned long                   contending_point[4];
        struct lock_time                read_waittime;
        struct lock_time                write_waittime;
        struct lock_time                read_holdtime;
@@ -165,6 +169,7 @@ struct lockdep_map {
        const char                      *name;
 #ifdef CONFIG_LOCK_STAT
        int                             cpu;
+        unsigned long                   ip;
 #endif
 };
@@ -356,7 +361,7 @@ struct lock_class_key { };
 #ifdef CONFIG_LOCK_STAT
 extern void lock_contended(struct lockdep_map *lock, unsigned long ip);
-extern void lock_acquired(struct lockdep_map *lock);
+extern void lock_acquired(struct lockdep_map *lock, unsigned long ip);
 #define LOCK_CONTENDED(_lock, try, lock)                        \
 do {                                                            \
@@ -364,13 +369,13 @@ do {								\
                lock_contended(&(_lock)->dep_map, _RET_IP_);    \
                lock(_lock);                                    \
        }                                                       \
-        lock_acquired(&(_lock)->dep_map);                       \
+        lock_acquired(&(_lock)->dep_map, _RET_IP_);                     \
 } while (0)
 #else /* CONFIG_LOCK_STAT */
 #define lock_contended(lockdep_map, ip) do {} while (0)
-#define lock_acquired(lockdep_map) do {} while (0)
+#define lock_acquired(lockdep_map, ip) do {} while (0)
 #define LOCK_CONTENDED(_lock, try, lock) \
        lock(_lock)
@@ -481,4 +486,22 @@ static inline void print_irqtrace_events(struct task_struct *curr)
 # define lock_map_release(l)                    do { } while (0)
 #endif
+#ifdef CONFIG_PROVE_LOCKING
+# define might_lock(lock)                                               \
+do {                                                                    \
+        typecheck(struct lockdep_map *, &(lock)->dep_map);              \
+        lock_acquire(&(lock)->dep_map, 0, 0, 0, 2, NULL, _THIS_IP_);    \
+        lock_release(&(lock)->dep_map, 0, _THIS_IP_);                   \
+} while (0)
+# define might_lock_read(lock)                                          \
+do {                                                                    \
+        typecheck(struct lockdep_map *, &(lock)->dep_map);              \
+        lock_acquire(&(lock)->dep_map, 0, 0, 1, 2, NULL, _THIS_IP_);    \
+        lock_release(&(lock)->dep_map, 0, _THIS_IP_);                   \
+} while (0)
+#else
+# define might_lock(lock) do { } while (0)
+# define might_lock_read(lock) do { } while (0)
+#endif
 #endif /* __LINUX_LOCKDEP_H */
diff --git a/include/linux/mutex.h b/include/linux/mutex.h
index bc6da10ceee0..7a0e5c4f8072 100644
--- a/include/linux/mutex.h
+++ b/include/linux/mutex.h
@@ -144,6 +144,8 @@ extern int __must_check mutex_lock_killable(struct mutex *lock);
 /*
 * NOTE: mutex_trylock() follows the spin_trylock() convention,
 *       not the down_trylock() convention!
+ *
+ * Returns 1 if the mutex has been acquired successfully, and 0 on contention.
 */
 extern int mutex_trylock(struct mutex *lock);
 extern void mutex_unlock(struct mutex *lock);
diff --git a/include/linux/rcuclassic.h b/include/linux/rcuclassic.h
index 5f89b62e6983..301dda829e37 100644
--- a/include/linux/rcuclassic.h
+++ b/include/linux/rcuclassic.h
@@ -41,7 +41,7 @@
 #include <linux/seqlock.h>
 #ifdef CONFIG_RCU_CPU_STALL_DETECTOR
-#define RCU_SECONDS_TILL_STALL_CHECK    ( 3 * HZ) /* for rcp->jiffies_stall */
+#define RCU_SECONDS_TILL_STALL_CHECK    (10 * HZ) /* for rcp->jiffies_stall */
 #define RCU_SECONDS_TILL_STALL_RECHECK  (30 * HZ) /* for rcp->jiffies_stall */
 #endif /* #ifdef CONFIG_RCU_CPU_STALL_DETECTOR */
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 4b81fc5f7731..423830b6e6e9 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -250,7 +250,7 @@ extern void init_idle_bootup_task(struct task_struct *idle);
 extern int runqueue_is_locked(void);
 extern void task_rq_unlock_wait(struct task_struct *p);
-extern cpumask_t nohz_cpu_mask;
+extern cpumask_var_t nohz_cpu_mask;
 #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ)
 extern int select_nohz_load_balancer(int cpu);
 #else
@@ -260,8 +260,6 @@ static inline int select_nohz_load_balancer(int cpu)
 }
 #endif
-extern unsigned long rt_needs_cpu(int cpu);
 /*
 * Only dump TASK_* tasks. (0 for all tasks)
 */
@@ -778,7 +776,6 @@ enum cpu_idle_type {
 struct sched_group {
        struct sched_group *next;       /* Must be a circular list */
-        cpumask_t cpumask;
        /*
         * CPU power of this group, SCHED_LOAD_SCALE being max power for a
@@ -791,8 +788,15 @@ struct sched_group {
         * (see include/linux/reciprocal_div.h)
         */
        u32 reciprocal_cpu_power;
+        unsigned long cpumask[];
 };
+static inline struct cpumask *sched_group_cpus(struct sched_group *sg)
+{
+        return to_cpumask(sg->cpumask);
+}
 enum sched_domain_level {
        SD_LV_NONE = 0,
        SD_LV_SIBLING,
@@ -816,7 +820,6 @@ struct sched_domain {
        struct sched_domain *parent;    /* top domain must be null terminated */
        struct sched_domain *child;     /* bottom domain must be null terminated */
        struct sched_group *groups;     /* the balancing groups of the domain */
-        cpumask_t span;                 /* span of all CPUs in this domain */
        unsigned long min_interval;     /* Minimum balance interval ms */
        unsigned long max_interval;     /* Maximum balance interval ms */
        unsigned int busy_factor;       /* less balancing by factor if busy */
@@ -871,9 +874,17 @@ struct sched_domain {
 #ifdef CONFIG_SCHED_DEBUG
        char *name;
 #endif
+        /* span of all CPUs in this domain */
+        unsigned long span[];
 };
-extern void partition_sched_domains(int ndoms_new, cpumask_t *doms_new,
+static inline struct cpumask *sched_domain_span(struct sched_domain *sd)
+{
+        return to_cpumask(sd->span);
+}
+extern void partition_sched_domains(int ndoms_new, struct cpumask *doms_new,
                                    struct sched_domain_attr *dattr_new);
 extern int arch_reinit_sched_domains(void);
@@ -882,7 +893,7 @@ extern int arch_reinit_sched_domains(void);
 struct sched_domain_attr;
 static inline void
-partition_sched_domains(int ndoms_new, cpumask_t *doms_new,
+partition_sched_domains(int ndoms_new, struct cpumask *doms_new,
                        struct sched_domain_attr *dattr_new)
 {
 }
@@ -964,7 +975,7 @@ struct sched_class {
        void (*task_wake_up) (struct rq *this_rq, struct task_struct *task);
        void (*set_cpus_allowed)(struct task_struct *p,
-                                 const cpumask_t *newmask);
+                                 const struct cpumask *newmask);
        void (*rq_online)(struct rq *rq);
        void (*rq_offline)(struct rq *rq);
@@ -1624,12 +1635,12 @@ extern cputime_t task_gtime(struct task_struct *p);
 #ifdef CONFIG_SMP
 extern int set_cpus_allowed_ptr(struct task_struct *p,
-                                const cpumask_t *new_mask);
+                                const struct cpumask *new_mask);
 #else
 static inline int set_cpus_allowed_ptr(struct task_struct *p,
-                                       const cpumask_t *new_mask)
+                                       const struct cpumask *new_mask)
 {
-        if (!cpu_isset(0, *new_mask))
+        if (!cpumask_test_cpu(0, new_mask))
                return -EINVAL;
        return 0;
 }
@@ -2242,8 +2253,8 @@ __trace_special(void *__tr, void *__data,
 }
 #endif
-extern long sched_setaffinity(pid_t pid, const cpumask_t *new_mask);
+extern long sched_setaffinity(pid_t pid, const struct cpumask *new_mask);
-extern long sched_getaffinity(pid_t pid, cpumask_t *mask);
+extern long sched_getaffinity(pid_t pid, struct cpumask *mask);
 extern int sched_mc_power_savings, sched_smt_power_savings;
diff --git a/include/linux/uaccess.h b/include/linux/uaccess.h
index fec6decfb983..6b58367d145e 100644
--- a/include/linux/uaccess.h
+++ b/include/linux/uaccess.h
@@ -78,7 +78,7 @@ static inline unsigned long __copy_from_user_nocache(void *to,
                                                        \
                set_fs(KERNEL_DS);                      \
                pagefault_disable();                    \
-                ret = __get_user(retval, (__force typeof(retval) __user *)(addr));              \
+                ret = __copy_from_user_inatomic(&(retval), (__force typeof(retval) __user *)(addr), sizeof(retval));            \
                pagefault_enable();                     \
                set_fs(old_fs);                         \
                ret;                                    \
diff --git a/kernel/Makefile b/kernel/Makefile
index 19fad003b19d..6a212b842d86 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -19,7 +19,6 @@ CFLAGS_REMOVE_mutex-debug.o = -pg
 CFLAGS_REMOVE_rtmutex-debug.o = -pg
 CFLAGS_REMOVE_cgroup-debug.o = -pg
 CFLAGS_REMOVE_sched_clock.o = -pg
-CFLAGS_REMOVE_sched.o = -pg
 endif
 obj-$(CONFIG_FREEZER) += freezer.o
@@ -90,7 +89,7 @@ obj-$(CONFIG_FUNCTION_TRACER) += trace/
 obj-$(CONFIG_TRACING) += trace/
 obj-$(CONFIG_SMP) += sched_cpupri.o
-ifneq ($(CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER),y)
+ifneq ($(CONFIG_SCHED_OMIT_FRAME_POINTER),y)
 # According to Alan Modra <alan@linuxcare.com.au>, the -fno-omit-frame-pointer is
 # needed for x86 only.  Why this used to be enabled for all architectures is beyond
 # me.  I suspect most platforms don't need this, but until we know that for sure
diff --git a/kernel/exit.c b/kernel/exit.c
index e5ae36ebe8af..61ba5b4b10cf 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -1324,10 +1324,10 @@ static int wait_task_zombie(struct task_struct *p, int options,
                 * group, which consolidates times for all threads in the
                 * group including the group leader.
                 */
+                thread_group_cputime(p, &cputime);
                spin_lock_irq(&p->parent->sighand->siglock);
                psig = p->parent->signal;
                sig = p->signal;
-                thread_group_cputime(p, &cputime);
                psig->cutime =
                        cputime_add(psig->cutime,
                        cputime_add(cputime.utime,
diff --git a/kernel/extable.c b/kernel/extable.c
index feb0317cf09a..e136ed8d82ba 100644
--- a/kernel/extable.c
+++ b/kernel/extable.c
@@ -67,3 +67,19 @@ int kernel_text_address(unsigned long addr)
                return 1;
        return module_text_address(addr) != NULL;
 }
+/*
+ * On some architectures (PPC64, IA64) function pointers
+ * are actually only tokens to some data that then holds the
+ * real function address. As a result, to find if a function
+ * pointer is part of the kernel text, we need to do some
+ * special dereferencing first.
+ */
+int func_ptr_is_kernel_text(void *ptr)
+{
+        unsigned long addr;
+        addr = (unsigned long) dereference_function_descriptor(ptr);
+        if (core_kernel_text(addr))
+                return 1;
+        return module_text_address(addr) != NULL;
+}
diff --git a/kernel/futex.c b/kernel/futex.c
index 8af10027514b..e10c5c8786a6 100644
--- a/kernel/futex.c
+++ b/kernel/futex.c
@@ -123,24 +123,6 @@ struct futex_hash_bucket {
 static struct futex_hash_bucket futex_queues[1<<FUTEX_HASHBITS];
 /*
- * Take mm->mmap_sem, when futex is shared
- */
-static inline void futex_lock_mm(struct rw_semaphore *fshared)
-{
-        if (fshared)
-                down_read(fshared);
-}
-/*
- * Release mm->mmap_sem, when the futex is shared
- */
-static inline void futex_unlock_mm(struct rw_semaphore *fshared)
-{
-        if (fshared)
-                up_read(fshared);
-}
-/*
 * We hash on the keys returned from get_futex_key (see below).
 */
 static struct futex_hash_bucket *hash_futex(union futex_key *key)
@@ -161,6 +143,45 @@ static inline int match_futex(union futex_key *key1, union futex_key *key2)
                && key1->both.offset == key2->both.offset);
 }
+/*
+ * Take a reference to the resource addressed by a key.
+ * Can be called while holding spinlocks.
+ *
+ */
+static void get_futex_key_refs(union futex_key *key)
+{
+        if (!key->both.ptr)
+                return;
+        switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
+        case FUT_OFF_INODE:
+                atomic_inc(&key->shared.inode->i_count);
+                break;
+        case FUT_OFF_MMSHARED:
+                atomic_inc(&key->private.mm->mm_count);
+                break;
+        }
+}
+/*
+ * Drop a reference to the resource addressed by a key.
+ * The hash bucket spinlock must not be held.
+ */
+static void drop_futex_key_refs(union futex_key *key)
+{
+        if (!key->both.ptr)
+                return;
+        switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
+        case FUT_OFF_INODE:
+                iput(key->shared.inode);
+                break;
+        case FUT_OFF_MMSHARED:
+                mmdrop(key->private.mm);
+                break;
+        }
+}
 /**
 * get_futex_key - Get parameters which are the keys for a futex.
 * @uaddr: virtual address of the futex
@@ -179,12 +200,10 @@ static inline int match_futex(union futex_key *key1, union futex_key *key2)
 * For other futexes, it points to &current->mm->mmap_sem and
 * caller must have taken the reader lock. but NOT any spinlocks.
 */
-static int get_futex_key(u32 __user *uaddr, struct rw_semaphore *fshared,
+static int get_futex_key(u32 __user *uaddr, int fshared, union futex_key *key)
-                         union futex_key *key)
 {
        unsigned long address = (unsigned long)uaddr;
        struct mm_struct *mm = current->mm;
-        struct vm_area_struct *vma;
        struct page *page;
        int err;
@@ -208,100 +227,50 @@ static int get_futex_key(u32 __user *uaddr, struct rw_semaphore *fshared,
                        return -EFAULT;
                key->private.mm = mm;
                key->private.address = address;
+                get_futex_key_refs(key);
                return 0;
        }
-        /*
-         * The futex is hashed differently depending on whether
-         * it's in a shared or private mapping.  So check vma first.
-         */
-        vma = find_extend_vma(mm, address);
-        if (unlikely(!vma))
-                return -EFAULT;
-        /*
+again:
-         * Permissions.
+        err = get_user_pages_fast(address, 1, 0, &page);
-         */
+        if (err < 0)
-        if (unlikely((vma->vm_flags & (VM_IO|VM_READ)) != VM_READ))
+                return err;
-                return (vma->vm_flags & VM_IO) ? -EPERM : -EACCES;
+        lock_page(page);
+        if (!page->mapping) {
+                unlock_page(page);
+                put_page(page);
+                goto again;
+        }
        /*
         * Private mappings are handled in a simple way.
         *
         * NOTE: When userspace waits on a MAP_SHARED mapping, even if
         * it's a read-only handle, it's expected that futexes attach to
-         * the object not the particular process.  Therefore we use
+         * the object not the particular process.
-         * VM_MAYSHARE here, not VM_SHARED which is restricted to shared
-         * mappings of _writable_ handles.
         */
-        if (likely(!(vma->vm_flags & VM_MAYSHARE))) {
+        if (PageAnon(page)) {
-                key->both.offset |= FUT_OFF_MMSHARED; /* reference taken on mm */
+                key->both.offset |= FUT_OFF_MMSHARED; /* ref taken on mm */
                key->private.mm = mm;
                key->private.address = address;
-                return 0;
+        } else {
+                key->both.offset |= FUT_OFF_INODE; /* inode-based key */
+                key->shared.inode = page->mapping->host;
+                key->shared.pgoff = page->index;
        }
-        /*
+        get_futex_key_refs(key);
-         * Linear file mappings are also simple.
-         */
-        key->shared.inode = vma->vm_file->f_path.dentry->d_inode;
-        key->both.offset |= FUT_OFF_INODE; /* inode-based key. */
-        if (likely(!(vma->vm_flags & VM_NONLINEAR))) {
-                key->shared.pgoff = (((address - vma->vm_start) >> PAGE_SHIFT)
-                                     + vma->vm_pgoff);
-                return 0;
-        }
-        /*
+        unlock_page(page);
-         * We could walk the page table to read the non-linear
+        put_page(page);
-         * pte, and get the page index without fetching the page
+        return 0;
-         * from swap.  But that's a lot of code to duplicate here
-         * for a rare case, so we simply fetch the page.
-         */
-        err = get_user_pages(current, mm, address, 1, 0, 0, &page, NULL);
-        if (err >= 0) {
-                key->shared.pgoff =
-                        page->index << (PAGE_CACHE_SHIFT - PAGE_SHIFT);
-                put_page(page);
-                return 0;
-        }
-        return err;
-}
-/*
- * Take a reference to the resource addressed by a key.
- * Can be called while holding spinlocks.
- *
- */
-static void get_futex_key_refs(union futex_key *key)
-{
-        if (key->both.ptr == NULL)
-                return;
-        switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
-                case FUT_OFF_INODE:
-                        atomic_inc(&key->shared.inode->i_count);
-                        break;
-                case FUT_OFF_MMSHARED:
-                        atomic_inc(&key->private.mm->mm_count);
-                        break;
-        }
 }
-/*
+static inline
- * Drop a reference to the resource addressed by a key.
+void put_futex_key(int fshared, union futex_key *key)
- * The hash bucket spinlock must not be held.
- */
-static void drop_futex_key_refs(union futex_key *key)
 {
-        if (!key->both.ptr)
+        drop_futex_key_refs(key);
-                return;
-        switch (key->both.offset & (FUT_OFF_INODE|FUT_OFF_MMSHARED)) {
-                case FUT_OFF_INODE:
-                        iput(key->shared.inode);
-                        break;
-                case FUT_OFF_MMSHARED:
-                        mmdrop(key->private.mm);
-                        break;
-        }
 }
 static u32 cmpxchg_futex_value_locked(u32 __user *uaddr, u32 uval, u32 newval)
@@ -328,10 +297,8 @@ static int get_futex_value_locked(u32 *dest, u32 __user *from)
 /*
 * Fault handling.
- * if fshared is non NULL, current->mm->mmap_sem is already held
 */
-static int futex_handle_fault(unsigned long address,
+static int futex_handle_fault(unsigned long address, int attempt)
-                              struct rw_semaphore *fshared, int attempt)
 {
        struct vm_area_struct * vma;
        struct mm_struct *mm = current->mm;
@@ -340,8 +307,7 @@ static int futex_handle_fault(unsigned long address,
        if (attempt > 2)
                return ret;
-        if (!fshared)
+        down_read(&mm->mmap_sem);
-                down_read(&mm->mmap_sem);
        vma = find_vma(mm, address);
        if (vma && address >= vma->vm_start &&
            (vma->vm_flags & VM_WRITE)) {
@@ -361,8 +327,7 @@ static int futex_handle_fault(unsigned long address,
                                current->min_flt++;
                }
        }
-        if (!fshared)
+        up_read(&mm->mmap_sem);
-                up_read(&mm->mmap_sem);
        return ret;
 }
@@ -385,6 +350,7 @@ static int refill_pi_state_cache(void)
        /* pi_mutex gets initialized later */
        pi_state->owner = NULL;
        atomic_set(&pi_state->refcount, 1);
+        pi_state->key = FUTEX_KEY_INIT;
        current->pi_state_cache = pi_state;
@@ -462,7 +428,7 @@ void exit_pi_state_list(struct task_struct *curr)
        struct list_head *next, *head = &curr->pi_state_list;
        struct futex_pi_state *pi_state;
        struct futex_hash_bucket *hb;
-        union futex_key key;
+        union futex_key key = FUTEX_KEY_INIT;
        if (!futex_cmpxchg_enabled)
                return;
@@ -719,20 +685,17 @@ double_lock_hb(struct futex_hash_bucket *hb1, struct futex_hash_bucket *hb2)
 * Wake up all waiters hashed on the physical page that is mapped
 * to this virtual address:
 */
-static int futex_wake(u32 __user *uaddr, struct rw_semaphore *fshared,
+static int futex_wake(u32 __user *uaddr, int fshared, int nr_wake, u32 bitset)
-                      int nr_wake, u32 bitset)
 {
        struct futex_hash_bucket *hb;
        struct futex_q *this, *next;
        struct plist_head *head;
-        union futex_key key;
+        union futex_key key = FUTEX_KEY_INIT;
        int ret;
        if (!bitset)
                return -EINVAL;
-        futex_lock_mm(fshared);
        ret = get_futex_key(uaddr, fshared, &key);
        if (unlikely(ret != 0))
                goto out;
@@ -760,7 +723,7 @@ static int futex_wake(u32 __user *uaddr, struct rw_semaphore *fshared,
        spin_unlock(&hb->lock);
 out:
-        futex_unlock_mm(fshared);
+        put_futex_key(fshared, &key);
        return ret;
 }
@@ -769,19 +732,16 @@ out:
 * to this virtual address:
 */
 static int
-futex_wake_op(u32 __user *uaddr1, struct rw_semaphore *fshared,
+futex_wake_op(u32 __user *uaddr1, int fshared, u32 __user *uaddr2,
-              u32 __user *uaddr2,
              int nr_wake, int nr_wake2, int op)
 {
-        union futex_key key1, key2;
+        union futex_key key1 = FUTEX_KEY_INIT, key2 = FUTEX_KEY_INIT;
        struct futex_hash_bucket *hb1, *hb2;
        struct plist_head *head;
        struct futex_q *this, *next;
        int ret, op_ret, attempt = 0;
 retryfull:
-        futex_lock_mm(fshared);
        ret = get_futex_key(uaddr1, fshared, &key1);
        if (unlikely(ret != 0))
                goto out;
@@ -826,18 +786,12 @@ retry:
                 */
                if (attempt++) {
                        ret = futex_handle_fault((unsigned long)uaddr2,
-                                                 fshared, attempt);
+                                                 attempt);
                        if (ret)
                                goto out;
                        goto retry;
                }
-                /*
-                 * If we would have faulted, release mmap_sem,
-                 * fault it in and start all over again.
-                 */
-                futex_unlock_mm(fshared);
                ret = get_user(dummy, uaddr2);
                if (ret)
                        return ret;
@@ -873,7 +827,8 @@ retry:
        if (hb1 != hb2)
                spin_unlock(&hb2->lock);
 out:
-        futex_unlock_mm(fshared);
+        put_futex_key(fshared, &key2);
+        put_futex_key(fshared, &key1);
        return ret;
 }
@@ -882,19 +837,16 @@ out:
 * Requeue all waiters hashed on one physical page to another
 * physical page.
 */
-static int futex_requeue(u32 __user *uaddr1, struct rw_semaphore *fshared,
+static int futex_requeue(u32 __user *uaddr1, int fshared, u32 __user *uaddr2,
-                         u32 __user *uaddr2,
                         int nr_wake, int nr_requeue, u32 *cmpval)
 {
-        union futex_key key1, key2;
+        union futex_key key1 = FUTEX_KEY_INIT, key2 = FUTEX_KEY_INIT;
        struct futex_hash_bucket *hb1, *hb2;
        struct plist_head *head1;
        struct futex_q *this, *next;
        int ret, drop_count = 0;
 retry:
-        futex_lock_mm(fshared);
        ret = get_futex_key(uaddr1, fshared, &key1);
        if (unlikely(ret != 0))
                goto out;
@@ -917,12 +869,6 @@ static int futex_requeue(u32 __user *uaddr1, struct rw_semaphore *fshared,
                        if (hb1 != hb2)
                                spin_unlock(&hb2->lock);
-                        /*
-                         * If we would have faulted, release mmap_sem, fault
-                         * it in and start all over again.
-                         */
-                        futex_unlock_mm(fshared);
                        ret = get_user(curval, uaddr1);
                        if (!ret)
@@ -974,7 +920,8 @@ out_unlock:
                drop_futex_key_refs(&key1);
 out:
-        futex_unlock_mm(fshared);
+        put_futex_key(fshared, &key2);
+        put_futex_key(fshared, &key1);
        return ret;
 }
@@ -1096,8 +1043,7 @@ static void unqueue_me_pi(struct futex_q *q)
 * private futexes.
 */
 static int fixup_pi_state_owner(u32 __user *uaddr, struct futex_q *q,
-                                struct task_struct *newowner,
+                                struct task_struct *newowner, int fshared)
-                                struct rw_semaphore *fshared)
 {
        u32 newtid = task_pid_vnr(newowner) | FUTEX_WAITERS;
        struct futex_pi_state *pi_state = q->pi_state;
@@ -1176,7 +1122,7 @@ retry:
 handle_fault:
        spin_unlock(q->lock_ptr);
-        ret = futex_handle_fault((unsigned long)uaddr, fshared, attempt++);
+        ret = futex_handle_fault((unsigned long)uaddr, attempt++);
        spin_lock(q->lock_ptr);
@@ -1200,7 +1146,7 @@ handle_fault:
 static long futex_wait_restart(struct restart_block *restart);
-static int futex_wait(u32 __user *uaddr, struct rw_semaphore *fshared,
+static int futex_wait(u32 __user *uaddr, int fshared,
                      u32 val, ktime_t *abs_time, u32 bitset)
 {
        struct task_struct *curr = current;
@@ -1218,8 +1164,7 @@ static int futex_wait(u32 __user *uaddr, struct rw_semaphore *fshared,
        q.pi_state = NULL;
        q.bitset = bitset;
 retry:
-        futex_lock_mm(fshared);
+        q.key = FUTEX_KEY_INIT;
        ret = get_futex_key(uaddr, fshared, &q.key);
        if (unlikely(ret != 0))
                goto out_release_sem;
@@ -1251,12 +1196,6 @@ static int futex_wait(u32 __user *uaddr, struct rw_semaphore *fshared,
        if (unlikely(ret)) {
                queue_unlock(&q, hb);
-                /*
-                 * If we would have faulted, release mmap_sem, fault it in and
-                 * start all over again.
-                 */
-                futex_unlock_mm(fshared);
                ret = get_user(uval, uaddr);
                if (!ret)
@@ -1271,12 +1210,6 @@ static int futex_wait(u32 __user *uaddr, struct rw_semaphore *fshared,
        queue_me(&q, hb);
        /*
-         * Now the futex is queued and we have checked the data, we
-         * don't want to hold mmap_sem while we sleep.
-         */
-        futex_unlock_mm(fshared);
-        /*
         * There might have been scheduling since the queue_me(), as we
         * cannot hold a spinlock across the get_user() in case it
         * faults, and we cannot just set TASK_INTERRUPTIBLE state when
@@ -1363,7 +1296,7 @@ static int futex_wait(u32 __user *uaddr, struct rw_semaphore *fshared,
        queue_unlock(&q, hb);
 out_release_sem:
-        futex_unlock_mm(fshared);
+        put_futex_key(fshared, &q.key);
        return ret;
 }
@@ -1371,13 +1304,13 @@ static int futex_wait(u32 __user *uaddr, struct rw_semaphore *fshared,
 static long futex_wait_restart(struct restart_block *restart)
 {
        u32 __user *uaddr = (u32 __user *)restart->futex.uaddr;
-        struct rw_semaphore *fshared = NULL;
+        int fshared = 0;
        ktime_t t;
        t.tv64 = restart->futex.time;
        restart->fn = do_no_restart_syscall;
        if (restart->futex.flags & FLAGS_SHARED)
-                fshared = &current->mm->mmap_sem;
+                fshared = 1;
        return (long)futex_wait(uaddr, fshared, restart->futex.val, &t,
                                restart->futex.bitset);
 }
@@ -1389,7 +1322,7 @@ static long futex_wait_restart(struct restart_block *restart)
 * if there are waiters then it will block, it does PI, etc. (Due to
 * races the kernel might see a 0 value of the futex too.)
 */
-static int futex_lock_pi(u32 __user *uaddr, struct rw_semaphore *fshared,
+static int futex_lock_pi(u32 __user *uaddr, int fshared,
                         int detect, ktime_t *time, int trylock)
 {
        struct hrtimer_sleeper timeout, *to = NULL;
@@ -1412,8 +1345,7 @@ static int futex_lock_pi(u32 __user *uaddr, struct rw_semaphore *fshared,
        q.pi_state = NULL;
 retry:
-        futex_lock_mm(fshared);
+        q.key = FUTEX_KEY_INIT;
        ret = get_futex_key(uaddr, fshared, &q.key);
        if (unlikely(ret != 0))
                goto out_release_sem;
@@ -1502,7 +1434,6 @@ static int futex_lock_pi(u32 __user *uaddr, struct rw_semaphore *fshared,
                         * exit to complete.
                         */
                        queue_unlock(&q, hb);
-                        futex_unlock_mm(fshared);
                        cond_resched();
                        goto retry;
@@ -1534,12 +1465,6 @@ static int futex_lock_pi(u32 __user *uaddr, struct rw_semaphore *fshared,
         */
        queue_me(&q, hb);
-        /*
-         * Now the futex is queued and we have checked the data, we
-         * don't want to hold mmap_sem while we sleep.
-         */
-        futex_unlock_mm(fshared);
        WARN_ON(!q.pi_state);
        /*
         * Block on the PI mutex:
@@ -1552,7 +1477,6 @@ static int futex_lock_pi(u32 __user *uaddr, struct rw_semaphore *fshared,
                ret = ret ? 0 : -EWOULDBLOCK;
        }
-        futex_lock_mm(fshared);
        spin_lock(q.lock_ptr);
        if (!ret) {
@@ -1618,7 +1542,6 @@ static int futex_lock_pi(u32 __user *uaddr, struct rw_semaphore *fshared,
        /* Unqueue and drop the lock */
        unqueue_me_pi(&q);
-        futex_unlock_mm(fshared);
        if (to)
                destroy_hrtimer_on_stack(&to->timer);
@@ -1628,7 +1551,7 @@ static int futex_lock_pi(u32 __user *uaddr, struct rw_semaphore *fshared,
        queue_unlock(&q, hb);
 out_release_sem:
-        futex_unlock_mm(fshared);
+        put_futex_key(fshared, &q.key);
        if (to)
                destroy_hrtimer_on_stack(&to->timer);
        return ret;
@@ -1645,15 +1568,12 @@ static int futex_lock_pi(u32 __user *uaddr, struct rw_semaphore *fshared,
        queue_unlock(&q, hb);
        if (attempt++) {
-                ret = futex_handle_fault((unsigned long)uaddr, fshared,
+                ret = futex_handle_fault((unsigned long)uaddr, attempt);
-                                         attempt);
                if (ret)
                        goto out_release_sem;
                goto retry_unlocked;
        }
-        futex_unlock_mm(fshared);
        ret = get_user(uval, uaddr);
        if (!ret && (uval != -EFAULT))
                goto retry;
@@ -1668,13 +1588,13 @@ static int futex_lock_pi(u32 __user *uaddr, struct rw_semaphore *fshared,
 * This is the in-kernel slowpath: we look up the PI state (if any),
 * and do the rt-mutex unlock.
 */
-static int futex_unlock_pi(u32 __user *uaddr, struct rw_semaphore *fshared)
+static int futex_unlock_pi(u32 __user *uaddr, int fshared)
 {
        struct futex_hash_bucket *hb;
        struct futex_q *this, *next;
        u32 uval;
        struct plist_head *head;
-        union futex_key key;
+        union futex_key key = FUTEX_KEY_INIT;
        int ret, attempt = 0;
 retry:
@@ -1685,10 +1605,6 @@ retry:
         */
        if ((uval & FUTEX_TID_MASK) != task_pid_vnr(current))
                return -EPERM;
-        /*
-         * First take all the futex related locks:
-         */
-        futex_lock_mm(fshared);
        ret = get_futex_key(uaddr, fshared, &key);
        if (unlikely(ret != 0))
@@ -1747,7 +1663,7 @@ retry_unlocked:
 out_unlock:
        spin_unlock(&hb->lock);
 out:
-        futex_unlock_mm(fshared);
+        put_futex_key(fshared, &key);
        return ret;
@@ -1763,16 +1679,13 @@ pi_faulted:
        spin_unlock(&hb->lock);
        if (attempt++) {
-                ret = futex_handle_fault((unsigned long)uaddr, fshared,
+                ret = futex_handle_fault((unsigned long)uaddr, attempt);
-                                         attempt);
                if (ret)
                        goto out;
                uval = 0;
                goto retry_unlocked;
        }
-        futex_unlock_mm(fshared);
        ret = get_user(uval, uaddr);
        if (!ret && (uval != -EFAULT))
                goto retry;
@@ -1898,8 +1811,7 @@ retry:
                 * PI futexes happens in exit_pi_state():
                 */
                if (!pi && (uval & FUTEX_WAITERS))
-                        futex_wake(uaddr, &curr->mm->mmap_sem, 1,
+                        futex_wake(uaddr, 1, 1, FUTEX_BITSET_MATCH_ANY);
-                                   FUTEX_BITSET_MATCH_ANY);
        }
        return 0;
 }
@@ -1995,10 +1907,10 @@ long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout,
 {
        int ret = -ENOSYS;
        int cmd = op & FUTEX_CMD_MASK;
-        struct rw_semaphore *fshared = NULL;
+        int fshared = 0;
        if (!(op & FUTEX_PRIVATE_FLAG))
-                fshared = &current->mm->mmap_sem;
+                fshared = 1;
        switch (cmd) {
        case FUTEX_WAIT:
diff --git a/kernel/lockdep.c b/kernel/lockdep.c
index 74b1878b8bb8..c4c7df23f8c7 100644
--- a/kernel/lockdep.c
+++ b/kernel/lockdep.c
@@ -137,16 +137,16 @@ static inline struct lock_class *hlock_class(struct held_lock *hlock)
 #ifdef CONFIG_LOCK_STAT
 static DEFINE_PER_CPU(struct lock_class_stats[MAX_LOCKDEP_KEYS], lock_stats);
-static int lock_contention_point(struct lock_class *class, unsigned long ip)
+static int lock_point(unsigned long points[], unsigned long ip)
 {
        int i;
-        for (i = 0; i < ARRAY_SIZE(class->contention_point); i++) {
+        for (i = 0; i < LOCKSTAT_POINTS; i++) {
-                if (class->contention_point[i] == 0) {
+                if (points[i] == 0) {
-                        class->contention_point[i] = ip;
+                        points[i] = ip;
                        break;
                }
-                if (class->contention_point[i] == ip)
+                if (points[i] == ip)
                        break;
        }
@@ -186,6 +186,9 @@ struct lock_class_stats lock_stats(struct lock_class *class)
                for (i = 0; i < ARRAY_SIZE(stats.contention_point); i++)
                        stats.contention_point[i] += pcs->contention_point[i];
+                for (i = 0; i < ARRAY_SIZE(stats.contending_point); i++)
+                        stats.contending_point[i] += pcs->contending_point[i];
                lock_time_add(&pcs->read_waittime, &stats.read_waittime);
                lock_time_add(&pcs->write_waittime, &stats.write_waittime);
@@ -210,6 +213,7 @@ void clear_lock_stats(struct lock_class *class)
                memset(cpu_stats, 0, sizeof(struct lock_class_stats));
        }
        memset(class->contention_point, 0, sizeof(class->contention_point));
+        memset(class->contending_point, 0, sizeof(class->contending_point));
 }
 static struct lock_class_stats *get_lock_stats(struct lock_class *class)
@@ -3000,7 +3004,7 @@ __lock_contended(struct lockdep_map *lock, unsigned long ip)
        struct held_lock *hlock, *prev_hlock;
        struct lock_class_stats *stats;
        unsigned int depth;
-        int i, point;
+        int i, contention_point, contending_point;
        depth = curr->lockdep_depth;
        if (DEBUG_LOCKS_WARN_ON(!depth))
@@ -3024,18 +3028,22 @@ __lock_contended(struct lockdep_map *lock, unsigned long ip)
 found_it:
        hlock->waittime_stamp = sched_clock();
-        point = lock_contention_point(hlock_class(hlock), ip);
+        contention_point = lock_point(hlock_class(hlock)->contention_point, ip);
+        contending_point = lock_point(hlock_class(hlock)->contending_point,
+                                      lock->ip);
        stats = get_lock_stats(hlock_class(hlock));
-        if (point < ARRAY_SIZE(stats->contention_point))
+        if (contention_point < LOCKSTAT_POINTS)
-                stats->contention_point[point]++;
+                stats->contention_point[contention_point]++;
+        if (contending_point < LOCKSTAT_POINTS)
+                stats->contending_point[contending_point]++;
        if (lock->cpu != smp_processor_id())
                stats->bounces[bounce_contended + !!hlock->read]++;
        put_lock_stats(stats);
 }
 static void
-__lock_acquired(struct lockdep_map *lock)
+__lock_acquired(struct lockdep_map *lock, unsigned long ip)
 {
        struct task_struct *curr = current;
        struct held_lock *hlock, *prev_hlock;
@@ -3084,6 +3092,7 @@ found_it:
        put_lock_stats(stats);
        lock->cpu = cpu;
+        lock->ip = ip;
 }
 void lock_contended(struct lockdep_map *lock, unsigned long ip)
@@ -3105,7 +3114,7 @@ void lock_contended(struct lockdep_map *lock, unsigned long ip)
 }
 EXPORT_SYMBOL_GPL(lock_contended);
-void lock_acquired(struct lockdep_map *lock)
+void lock_acquired(struct lockdep_map *lock, unsigned long ip)
 {
        unsigned long flags;
@@ -3118,7 +3127,7 @@ void lock_acquired(struct lockdep_map *lock)
        raw_local_irq_save(flags);
        check_flags(flags);
        current->lockdep_recursion = 1;
-        __lock_acquired(lock);
+        __lock_acquired(lock, ip);
        current->lockdep_recursion = 0;
        raw_local_irq_restore(flags);
 }
diff --git a/kernel/lockdep_proc.c b/kernel/lockdep_proc.c
index 20dbcbf9c7dd..13716b813896 100644
--- a/kernel/lockdep_proc.c
+++ b/kernel/lockdep_proc.c
@@ -470,11 +470,12 @@ static void seq_line(struct seq_file *m, char c, int offset, int length)
 static void snprint_time(char *buf, size_t bufsiz, s64 nr)
 {
-        unsigned long rem;
+        s64 div;
+        s32 rem;
        nr += 5; /* for display rounding */
-        rem = do_div(nr, 1000); /* XXX: do_div_signed */
+        div = div_s64_rem(nr, 1000, &rem);
-        snprintf(buf, bufsiz, "%lld.%02d", (long long)nr, (int)rem/10);
+        snprintf(buf, bufsiz, "%lld.%02d", (long long)div, (int)rem/10);
 }
 static void seq_time(struct seq_file *m, s64 time)
@@ -556,7 +557,7 @@ static void seq_stats(struct seq_file *m, struct lock_stat_data *data)
        if (stats->read_holdtime.nr)
                namelen += 2;
-        for (i = 0; i < ARRAY_SIZE(class->contention_point); i++) {
+        for (i = 0; i < LOCKSTAT_POINTS; i++) {
                char sym[KSYM_SYMBOL_LEN];
                char ip[32];
@@ -573,6 +574,23 @@ static void seq_stats(struct seq_file *m, struct lock_stat_data *data)
                                stats->contention_point[i],
                                ip, sym);
        }
+        for (i = 0; i < LOCKSTAT_POINTS; i++) {
+                char sym[KSYM_SYMBOL_LEN];
+                char ip[32];
+                if (class->contending_point[i] == 0)
+                        break;
+                if (!i)
+                        seq_line(m, '-', 40-namelen, namelen);
+                sprint_symbol(sym, class->contending_point[i]);
+                snprintf(ip, sizeof(ip), "[<%p>]",
+                                (void *)class->contending_point[i]);
+                seq_printf(m, "%40s %14lu %29s %s\n", name,
+                                stats->contending_point[i],
+                                ip, sym);
+        }
        if (i) {
                seq_puts(m, "\n");
                seq_line(m, '.', 0, 40 + 1 + 10 * (14 + 1));
@@ -582,7 +600,7 @@ static void seq_stats(struct seq_file *m, struct lock_stat_data *data)
 static void seq_header(struct seq_file *m)
 {
-        seq_printf(m, "lock_stat version 0.2\n");
+        seq_printf(m, "lock_stat version 0.3\n");
        seq_line(m, '-', 0, 40 + 1 + 10 * (14 + 1));
        seq_printf(m, "%40s %14s %14s %14s %14s %14s %14s %14s %14s "
                        "%14s %14s\n",
diff --git a/kernel/mutex.c b/kernel/mutex.c
index 12c779dc65d4..4f45d4b658ef 100644
--- a/kernel/mutex.c
+++ b/kernel/mutex.c
@@ -59,7 +59,7 @@ EXPORT_SYMBOL(__mutex_init);
 * We also put the fastpath first in the kernel image, to make sure the
 * branch is predicted by the CPU as default-untaken.
 */
-static void noinline __sched
+static __used noinline void __sched
 __mutex_lock_slowpath(atomic_t *lock_count);
 /***
@@ -96,7 +96,7 @@ void inline __sched mutex_lock(struct mutex *lock)
 EXPORT_SYMBOL(mutex_lock);
 #endif
-static noinline void __sched __mutex_unlock_slowpath(atomic_t *lock_count);
+static __used noinline void __sched __mutex_unlock_slowpath(atomic_t *lock_count);
 /***
 * mutex_unlock - release the mutex
@@ -184,7 +184,7 @@ __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
        }
 done:
-        lock_acquired(&lock->dep_map);
+        lock_acquired(&lock->dep_map, ip);
        /* got the lock - rejoice! */
        mutex_remove_waiter(lock, &waiter, task_thread_info(task));
        debug_mutex_set_owner(lock, task_thread_info(task));
@@ -268,7 +268,7 @@ __mutex_unlock_common_slowpath(atomic_t *lock_count, int nested)
 /*
 * Release the lock, slowpath:
 */
-static noinline void
+static __used noinline void
 __mutex_unlock_slowpath(atomic_t *lock_count)
 {
        __mutex_unlock_common_slowpath(lock_count, 1);
@@ -313,7 +313,7 @@ int __sched mutex_lock_killable(struct mutex *lock)
 }
 EXPORT_SYMBOL(mutex_lock_killable);
-static noinline void __sched
+static __used noinline void __sched
 __mutex_lock_slowpath(atomic_t *lock_count)
 {
        struct mutex *lock = container_of(lock_count, struct mutex, count);
diff --git a/kernel/notifier.c b/kernel/notifier.c
index 4282c0a40a57..61d5aa5eced3 100644
--- a/kernel/notifier.c
+++ b/kernel/notifier.c
@@ -82,6 +82,14 @@ static int __kprobes notifier_call_chain(struct notifier_block **nl,
        while (nb && nr_to_call) {
                next_nb = rcu_dereference(nb->next);
+#ifdef CONFIG_DEBUG_NOTIFIERS
+                if (unlikely(!func_ptr_is_kernel_text(nb->notifier_call))) {
+                        WARN(1, "Invalid notifier called!");
+                        nb = next_nb;
+                        continue;
+                }
+#endif
                ret = nb->notifier_call(nb, val, v);
                if (nr_calls)
diff --git a/kernel/posix-cpu-timers.c b/kernel/posix-cpu-timers.c
index 895337b16a24..3f4377e0aa04 100644
--- a/kernel/posix-cpu-timers.c
+++ b/kernel/posix-cpu-timers.c
@@ -58,21 +58,21 @@ void thread_group_cputime(
        struct task_struct *tsk,
        struct task_cputime *times)
 {
-        struct signal_struct *sig;
+        struct task_cputime *totals, *tot;
        int i;
-        struct task_cputime *tot;
-        sig = tsk->signal;
+        totals = tsk->signal->cputime.totals;
-        if (unlikely(!sig) || !sig->cputime.totals) {
+        if (!totals) {
                times->utime = tsk->utime;
                times->stime = tsk->stime;
                times->sum_exec_runtime = tsk->se.sum_exec_runtime;
                return;
        }
        times->stime = times->utime = cputime_zero;
        times->sum_exec_runtime = 0;
        for_each_possible_cpu(i) {
-                tot = per_cpu_ptr(tsk->signal->cputime.totals, i);
+                tot = per_cpu_ptr(totals, i);
                times->utime = cputime_add(times->utime, tot->utime);
                times->stime = cputime_add(times->stime, tot->stime);
                times->sum_exec_runtime += tot->sum_exec_runtime;
diff --git a/kernel/rcuclassic.c b/kernel/rcuclassic.c
index 37f72e551542..c03ca3e61919 100644
--- a/kernel/rcuclassic.c
+++ b/kernel/rcuclassic.c
@@ -191,7 +191,7 @@ static void print_other_cpu_stall(struct rcu_ctrlblk *rcp)
        /* OK, time to rat on our buddy... */
-        printk(KERN_ERR "RCU detected CPU stalls:");
+        printk(KERN_ERR "INFO: RCU detected CPU stalls:");
        for_each_possible_cpu(cpu) {
                if (cpu_isset(cpu, rcp->cpumask))
                        printk(" %d", cpu);
@@ -204,7 +204,7 @@ static void print_cpu_stall(struct rcu_ctrlblk *rcp)
 {
        unsigned long flags;
-        printk(KERN_ERR "RCU detected CPU %d stall (t=%lu/%lu jiffies)\n",
+        printk(KERN_ERR "INFO: RCU detected CPU %d stall (t=%lu/%lu jiffies)\n",
                        smp_processor_id(), jiffies,
                        jiffies - rcp->gp_start);
        dump_stack();
@@ -393,7 +393,7 @@ static void rcu_start_batch(struct rcu_ctrlblk *rcp)
                 * unnecessarily.
                 */
                smp_mb();
-                cpus_andnot(rcp->cpumask, cpu_online_map, nohz_cpu_mask);
+                cpumask_andnot(&rcp->cpumask, cpu_online_mask, nohz_cpu_mask);
                rcp->signaled = 0;
        }
diff --git a/kernel/sched.c b/kernel/sched.c
index 7729c4bbc8ba..4ed9f588faa6 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -487,14 +487,14 @@ struct rt_rq {
 */
 struct root_domain {
        atomic_t refcount;
-        cpumask_t span;
+        cpumask_var_t span;
-        cpumask_t online;
+        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;
@@ -709,45 +709,18 @@ static __read_mostly char *sched_feat_names[] = {
 #undef SCHED_FEAT
-static int sched_feat_open(struct inode *inode, struct file *filp)
+static int sched_feat_show(struct seq_file *m, void *v)
-{
-        filp->private_data = inode->i_private;
-        return 0;
-}
-static ssize_t
-sched_feat_read(struct file *filp, char __user *ubuf,
-                size_t cnt, loff_t *ppos)
 {
-        char *buf;
-        int r = 0;
-        int len = 0;
        int i;
        for (i = 0; sched_feat_names[i]; i++) {
-                len += strlen(sched_feat_names[i]);
+                if (!(sysctl_sched_features & (1UL << i)))
-                len += 4;
+                        seq_puts(m, "NO_");
-        }
+                seq_printf(m, "%s ", sched_feat_names[i]);
-        buf = kmalloc(len + 2, GFP_KERNEL);
-        if (!buf)
-                return -ENOMEM;
-        for (i = 0; sched_feat_names[i]; i++) {
-                if (sysctl_sched_features & (1UL << i))
-                        r += sprintf(buf + r, "%s ", sched_feat_names[i]);
-                else
-                        r += sprintf(buf + r, "NO_%s ", sched_feat_names[i]);
        }
+        seq_puts(m, "\n");
-        r += sprintf(buf + r, "\n");
+        return 0;
-        WARN_ON(r >= len + 2);
-        r = simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
-        kfree(buf);
-        return r;
 }
 static ssize_t
@@ -792,10 +765,17 @@ sched_feat_write(struct file *filp, const char __user *ubuf,
        return cnt;
 }
+static int sched_feat_open(struct inode *inode, struct file *filp)
+{
+        return single_open(filp, sched_feat_show, NULL);
+}
 static struct file_operations sched_feat_fops = {
-        .open   = sched_feat_open,
+        .open           = sched_feat_open,
-        .read   = sched_feat_read,
+        .write          = sched_feat_write,
-        .write  = sched_feat_write,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
 };
 static __init int sched_init_debug(void)
@@ -1480,27 +1460,13 @@ static void
 update_group_shares_cpu(struct task_group *tg, int cpu,
                        unsigned long sd_shares, unsigned long sd_rq_weight)
 {
-        int boost = 0;
        unsigned long shares;
        unsigned long rq_weight;
        if (!tg->se[cpu])
                return;
-        rq_weight = tg->cfs_rq[cpu]->load.weight;
+        rq_weight = tg->cfs_rq[cpu]->rq_weight;
-        /*
-         * If there are currently no tasks on the cpu pretend there is one of
-         * average load so that when a new task gets to run here it will not
-         * get delayed by group starvation.
-         */
-        if (!rq_weight) {
-                boost = 1;
-                rq_weight = NICE_0_LOAD;
-        }
-        if (unlikely(rq_weight > sd_rq_weight))
-                rq_weight = sd_rq_weight;
        /*
         *           \Sum shares * rq_weight
@@ -1508,7 +1474,7 @@ update_group_shares_cpu(struct task_group *tg, int cpu,
         *               \Sum rq_weight
         *
         */
-        shares = (sd_shares * rq_weight) / (sd_rq_weight + 1);
+        shares = (sd_shares * rq_weight) / sd_rq_weight;
        shares = clamp_t(unsigned long, shares, MIN_SHARES, MAX_SHARES);
        if (abs(shares - tg->se[cpu]->load.weight) >
@@ -1517,11 +1483,7 @@ update_group_shares_cpu(struct task_group *tg, int cpu,
                unsigned long flags;
                spin_lock_irqsave(&rq->lock, flags);
-                /*
+                tg->cfs_rq[cpu]->shares = shares;
-                 * record the actual number of shares, not the boosted amount.
-                 */
-                tg->cfs_rq[cpu]->shares = boost ? 0 : shares;
-                tg->cfs_rq[cpu]->rq_weight = rq_weight;
                __set_se_shares(tg->se[cpu], shares);
                spin_unlock_irqrestore(&rq->lock, flags);
@@ -1535,13 +1497,23 @@ update_group_shares_cpu(struct task_group *tg, int cpu,
 */
 static int tg_shares_up(struct task_group *tg, void *data)
 {
-        unsigned long rq_weight = 0;
+        unsigned long weight, rq_weight = 0;
        unsigned long shares = 0;
        struct sched_domain *sd = data;
        int i;
-        for_each_cpu_mask(i, sd->span) {
+        for_each_cpu(i, sched_domain_span(sd)) {
-                rq_weight += tg->cfs_rq[i]->load.weight;
+                /*
+                 * If there are currently no tasks on the cpu pretend there
+                 * is one of average load so that when a new task gets to
+                 * run here it will not get delayed by group starvation.
+                 */
+                weight = tg->cfs_rq[i]->load.weight;
+                if (!weight)
+                        weight = NICE_0_LOAD;
+                tg->cfs_rq[i]->rq_weight = weight;
+                rq_weight += weight;
                shares += tg->cfs_rq[i]->shares;
        }
@@ -1551,10 +1523,7 @@ static int tg_shares_up(struct task_group *tg, void *data)
        if (!sd->parent || !(sd->parent->flags & SD_LOAD_BALANCE))
                shares = tg->shares;
-        if (!rq_weight)
+        for_each_cpu(i, sched_domain_span(sd))
-                rq_weight = cpus_weight(sd->span) * NICE_0_LOAD;
-        for_each_cpu_mask(i, sd->span)
                update_group_shares_cpu(tg, i, shares, rq_weight);
        return 0;
@@ -2085,15 +2054,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);
@@ -2125,17 +2096,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,
+find_idlest_cpu(struct sched_group *group, struct task_struct *p, int this_cpu)
-                cpumask_t *tmp)
 {
        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_and(i, sched_group_cpus(group), &p->cpus_allowed) {
-        for_each_cpu_mask_nr(i, *tmp) {
                load = weighted_cpuload(i);
                if (load < min_load || (load == min_load && i == this_cpu)) {
@@ -2177,7 +2145,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;
@@ -2186,14 +2153,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;
@@ -2202,10 +2168,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;
@@ -2250,7 +2216,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;
                        }
@@ -2298,7 +2264,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;
                        }
@@ -2844,7 +2810,7 @@ static int double_lock_balance(struct rq *this_rq, struct rq *busiest)
        return ret;
 }
-static void double_unlock_balance(struct rq *this_rq, struct rq *busiest)
+static inline void double_unlock_balance(struct rq *this_rq, struct rq *busiest)
        __releases(busiest->lock)
 {
        spin_unlock(&busiest->lock);
@@ -2864,7 +2830,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;
@@ -2930,7 +2896,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;
        }
@@ -3105,7 +3071,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;
@@ -3141,10 +3107,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;
@@ -3153,13 +3120,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) {
+                for_each_cpu_and(i, sched_group_cpus(group), cpus) {
-                        struct rq *rq;
+                        struct rq *rq = cpu_rq(i);
-                        if (!cpu_isset(i, *cpus))
-                                continue;
-                        rq = cpu_rq(i);
                        if (*sd_idle && rq->nr_running)
                                *sd_idle = 0;
@@ -3270,8 +3232,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) <
+                     cpumask_first(sched_group_cpus(group)) <
-                     first_cpu(group_min->cpumask))) {
+                     cpumask_first(sched_group_cpus(group_min)))) {
                        group_min = group;
                        min_nr_running = sum_nr_running;
                        min_load_per_task = sum_weighted_load /
@@ -3286,8 +3248,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) >
+                             cpumask_first(sched_group_cpus(group)) >
-                              first_cpu(group_leader->cpumask))) {
+                             cpumask_first(sched_group_cpus(group_leader)))) {
                                group_leader = group;
                                leader_nr_running = sum_nr_running;
                        }
@@ -3426,16 +3388,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);
@@ -3465,7 +3427,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;
@@ -3473,7 +3435,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
@@ -3533,8 +3495,8 @@ redo:
                /* All tasks on this runqueue were pinned by CPU affinity */
                if (unlikely(all_pinned)) {
-                        cpu_clear(cpu_of(busiest), *cpus);
+                        cpumask_clear_cpu(cpu_of(busiest), cpus);
-                        if (!cpus_empty(*cpus))
+                        if (!cpumask_empty(cpus))
                                goto redo;
                        goto out_balanced;
                }
@@ -3551,7 +3513,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;
@@ -3626,7 +3589,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;
@@ -3635,7 +3598,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
@@ -3679,8 +3642,8 @@ redo:
                double_unlock_balance(this_rq, busiest);
                if (unlikely(all_pinned)) {
-                        cpu_clear(cpu_of(busiest), *cpus);
+                        cpumask_clear_cpu(cpu_of(busiest), cpus);
-                        if (!cpus_empty(*cpus))
+                        if (!cpumask_empty(cpus))
                                goto redo;
                }
        }
@@ -3715,7 +3678,10 @@ static void idle_balance(int this_cpu, struct rq *this_rq)
        struct sched_domain *sd;
        int pulled_task = -1;
        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;
@@ -3726,7 +3692,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))
@@ -3741,6 +3707,7 @@ static void idle_balance(int this_cpu, struct rq *this_rq)
                 */
                this_rq->next_balance = next_balance;
        }
+        free_cpumask_var(tmpmask);
 }
 /*
@@ -3778,7 +3745,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;
        }
@@ -3797,10 +3764,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,
 };
 /*
@@ -3828,7 +3794,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;
                /*
@@ -3842,7 +3808,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;
@@ -3855,10 +3821,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)
@@ -3886,7 +3852,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))
@@ -3911,7 +3881,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
@@ -3945,6 +3915,8 @@ out:
         */
        if (likely(update_next_balance))
                rq->next_balance = next_balance;
+        free_cpumask_var(tmp);
 }
 /*
@@ -3969,12 +3941,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(balance_cpu, nohz.cpu_mask) {
-                for_each_cpu_mask_nr(balance_cpu, cpus) {
+                        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
@@ -4012,7 +3985,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);
                }
@@ -4025,7 +3998,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);
@@ -4037,7 +4010,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;
        }
@@ -4047,7 +4020,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))
@@ -4209,7 +4182,6 @@ void account_steal_time(struct task_struct *p, cputime_t steal)
        if (p == rq->idle) {
                p->stime = cputime_add(p->stime, steal);
-                account_group_system_time(p, steal);
                if (atomic_read(&rq->nr_iowait) > 0)
                        cpustat->iowait = cputime64_add(cpustat->iowait, tmp);
                else
@@ -4345,7 +4317,7 @@ void __kprobes sub_preempt_count(int val)
        /*
         * Underflow?
         */
-        if (DEBUG_LOCKS_WARN_ON(val > preempt_count()))
+       if (DEBUG_LOCKS_WARN_ON(val > preempt_count() - (!!kernel_locked())))
                return;
        /*
         * Is the spinlock portion underflowing?
@@ -5406,10 +5378,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_var_t cpus_allowed, new_mask;
-        cpumask_t new_mask = *in_mask;
        struct task_struct *p;
        int retval;
@@ -5431,6 +5402,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 ((current->euid != p->euid) && (current->euid != p->uid) &&
                        !capable(CAP_SYS_NICE))
@@ -5440,37 +5419,41 @@ long sched_setaffinity(pid_t pid, const cpumask_t *in_mask)
        if (retval)
                goto out_unlock;
-        cpuset_cpus_allowed(p, &cpus_allowed);
+        cpuset_cpus_allowed(p, cpus_allowed);
-        cpus_and(new_mask, new_mask, 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);
+                cpuset_cpus_allowed(p, cpus_allowed);
-                if (!cpus_subset(new_mask, 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)) {
+        if (len < cpumask_size())
-                memset(new_mask, 0, sizeof(cpumask_t));
+                cpumask_clear(new_mask);
-        } else if (len > sizeof(cpumask_t)) {
+        else if (len > cpumask_size())
-                len = sizeof(cpumask_t);
+                len = cpumask_size();
-        }
        return copy_from_user(new_mask, user_mask_ptr, len) ? -EFAULT : 0;
 }
@@ -5483,17 +5466,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 (!alloc_cpumask_var(&new_mask, GFP_KERNEL))
-        if (retval)
+                return -ENOMEM;
-                return retval;
-        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;
@@ -5510,7 +5496,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);
@@ -5529,19 +5515,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 (!alloc_cpumask_var(&mask, GFP_KERNEL))
-        if (ret < 0)
+                return -ENOMEM;
-                return ret;
-        if (copy_to_user(user_mask_ptr, &mask, sizeof(cpumask_t)))
+        ret = sched_getaffinity(pid, mask);
-                return -EFAULT;
+        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;
 }
 /**
@@ -5883,7 +5874,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;
@@ -5910,9 +5901,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,
@@ -5967,7 +5958,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;
@@ -5975,13 +5966,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;
        }
@@ -5989,15 +5980,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;
+                cpumask_copy(&p->cpus_allowed, new_mask);
-                p->rt.nr_cpus_allowed = cpus_weight(*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);
@@ -6039,7 +6030,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;
@@ -6133,54 +6124,46 @@ static int __migrate_task_irq(struct task_struct *p, int src_cpu, int dest_cpu)
 /*
 * Figure out where task on dead CPU should go, use force if necessary.
- * NOTE: interrupts should be disabled by the caller
 */
 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;
+        /* FIXME: Use cpumask_of_node here. */
+        cpumask_t _nodemask = node_to_cpumask(cpu_to_node(dead_cpu));
+        const struct cpumask *nodemask = &_nodemask;
+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;
+        /* 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) {
+                cpuset_cpus_allowed_locked(p, &p->cpus_allowed);
+                dest_cpu = cpumask_any_and(cpu_online_mask, &p->cpus_allowed);
-        do {
+                /*
-                /* On same node? */
+                 * Don't tell them about moving exiting tasks or
-                mask = node_to_cpumask(cpu_to_node(dead_cpu));
+                 * kernel threads (both mm NULL), since they never
-                cpus_and(mask, mask, p->cpus_allowed);
+                 * leave kernel.
-                dest_cpu = any_online_cpu(mask);
+                 */
+                if (p->mm && printk_ratelimit()) {
-                /* On any allowed CPU? */
+                        printk(KERN_INFO "process %d (%s) no "
-                if (dest_cpu >= nr_cpu_ids)
+                               "longer affine to cpu%d\n",
-                        dest_cpu = any_online_cpu(p->cpus_allowed);
+                               task_pid_nr(p), p->comm, dead_cpu);
-                /* 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);
-                        /*
-                         * 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;
 }
 /*
@@ -6192,7 +6175,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);
@@ -6482,7 +6465,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) {
@@ -6502,7 +6485,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;
        }
 }
@@ -6543,7 +6526,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);
                }
@@ -6557,7 +6540,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;
@@ -6605,7 +6588,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);
@@ -6643,36 +6626,14 @@ early_initcall(migration_init);
 #ifdef CONFIG_SCHED_DEBUG
-static inline const char *sd_level_to_string(enum sched_domain_level lvl)
-{
-        switch (lvl) {
-        case SD_LV_NONE:
-                        return "NONE";
-        case SD_LV_SIBLING:
-                        return "SIBLING";
-        case SD_LV_MC:
-                        return "MC";
-        case SD_LV_CPU:
-                        return "CPU";
-        case SD_LV_NODE:
-                        return "NODE";
-        case SD_LV_ALLNODES:
-                        return "ALLNODES";
-        case SD_LV_MAX:
-                        return "MAX";
-        }
-        return "MAX";
-}
 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);
+        cpulist_scnprintf(str, sizeof(str), *sched_domain_span(sd));
-        cpus_clear(*groupmask);
+        cpumask_clear(groupmask);
        printk(KERN_DEBUG "%*s domain %d: ", level, "", level);
@@ -6684,14 +6645,13 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
                return -1;
        }
-        printk(KERN_CONT "span %s level %s\n",
+        printk(KERN_CONT "span %s level %s\n", str, sd->name);
-                str, sd_level_to_string(sd->level));
-        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);
        }
@@ -6711,31 +6671,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;
@@ -6743,7 +6704,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) {
@@ -6753,8 +6714,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 (!alloc_cpumask_var(&groupmask, GFP_KERNEL)) {
-        if (!groupmask) {
                printk(KERN_DEBUG "Cannot load-balance (out of memory)\n");
                return;
        }
@@ -6767,7 +6727,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)
@@ -6775,7 +6735,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 */
@@ -6806,7 +6766,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? */
@@ -6828,6 +6788,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;
@@ -6837,38 +6807,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);
+        cpumask_set_cpu(rq->cpu, rd->span);
-        if (cpu_isset(rq->cpu, cpu_online_map))
+        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);
+        if (bootmem) {
-        cpus_clear(rd->online);
+                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;
+        if (cpupri_init(&rd->cpupri, false) != 0)
+                goto free_rto_mask;
+        return 0;
-        cpupri_init(&rd->cpupri);
+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);
 }
@@ -6880,7 +6875,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;
 }
@@ -6922,19 +6920,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];
+        cpulist_parse(str, *cpu_isolated_map);
-        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);
        return 1;
 }
@@ -6943,42 +6934,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
+ * 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 cpumask_t).
+ * (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,
+init_sched_build_groups(const struct cpumask *span,
-                        int (*group_fn)(int cpu, const cpumask_t *cpu_map,
+                        const struct cpumask *cpu_map,
+                        int (*group_fn)(int cpu, const struct cpumask *cpu_map,
                                        struct sched_group **sg,
-                                        cpumask_t *tmpmask),
+                                        struct cpumask *tmpmask),
-                        cpumask_t *covered, cpumask_t *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);
+                        cpumask_set_cpu(j, covered);
-                        cpu_set(j, sg->cpumask);
+                        cpumask_set_cpu(j, sched_group_cpus(sg));
                }
                if (!first)
                        first = sg;
@@ -7042,9 +7034,10 @@ 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;
+        /* FIXME: use cpumask_of_node() */
        node_to_cpumask_ptr(nodemask, node);
        int i;
@@ -7066,18 +7059,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 static_sched_domain, cpu_domains);
-static DEFINE_PER_CPU(struct sched_group, sched_group_cpus);
+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,
+cpu_to_cpu_group(int cpu, const struct cpumask *cpu_map,
-                 cpumask_t *unused)
+                 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 */
@@ -7086,56 +7094,55 @@ 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 static_sched_domain, core_domains);
-static DEFINE_PER_CPU(struct sched_group, sched_group_core);
+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,
+cpu_to_core_group(int cpu, const struct cpumask *cpu_map,
-                  cpumask_t *mask)
+                  struct sched_group **sg, struct cpumask *mask)
 {
        int group;
-        *mask = per_cpu(cpu_sibling_map, cpu);
+        cpumask_and(mask, &per_cpu(cpu_sibling_map, cpu), cpu_map);
-        cpus_and(*mask, *mask, *cpu_map);
+        group = cpumask_first(mask);
-        group = first_cpu(*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,
+cpu_to_core_group(int cpu, const struct cpumask *cpu_map,
-                  cpumask_t *unused)
+                  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 static_sched_domain, phys_domains);
-static DEFINE_PER_CPU(struct sched_group, sched_group_phys);
+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,
+cpu_to_phys_group(int cpu, const struct cpumask *cpu_map,
-                  cpumask_t *mask)
+                  struct sched_group **sg, struct cpumask *mask)
 {
        int group;
 #ifdef CONFIG_SCHED_MC
+        /* FIXME: Use cpu_coregroup_mask. */
        *mask = cpu_coregroup_map(cpu);
        cpus_and(*mask, *mask, *cpu_map);
-        group = first_cpu(*mask);
+        group = cpumask_first(mask);
 #elif defined(CONFIG_SCHED_SMT)
-        *mask = per_cpu(cpu_sibling_map, cpu);
+        cpumask_and(mask, &per_cpu(cpu_sibling_map, cpu), cpu_map);
-        cpus_and(*mask, *mask, *cpu_map);
+        group = cpumask_first(mask);
-        group = first_cpu(*mask);
 #else
        group = cpu;
 #endif
        if (sg)
-                *sg = &per_cpu(sched_group_phys, group);
+                *sg = &per_cpu(sched_group_phys, group).sg;
        return group;
 }
@@ -7149,19 +7156,21 @@ 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,
+static int cpu_to_allnodes_group(int cpu, const struct cpumask *cpu_map,
-                                 struct sched_group **sg, cpumask_t *nodemask)
+                                 struct sched_group **sg,
+                                 struct cpumask *nodemask)
 {
        int group;
+        /* FIXME: use cpumask_of_node */
+        node_to_cpumask_ptr(pnodemask, cpu_to_node(cpu));
-        *nodemask = node_to_cpumask(cpu_to_node(cpu));
+        cpumask_and(nodemask, pnodemask, cpu_map);
-        cpus_and(*nodemask, *nodemask, *cpu_map);
+        group = cpumask_first(nodemask);
-        group = first_cpu(*nodemask);
        if (sg)
-                *sg = &per_cpu(sched_group_allnodes, group);
+                *sg = &per_cpu(sched_group_allnodes, group).sg;
        return group;
 }
@@ -7173,11 +7182,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);
+                        sd = &per_cpu(phys_domains, j).sd;
-                        if (j != first_cpu(sd->groups->cpumask)) {
+                        if (j != cpumask_first(sched_group_cpus(sd->groups))) {
                                /*
                                 * Only add "power" once for each
                                 * physical package.
@@ -7194,11 +7203,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];
@@ -7207,10 +7217,11 @@ 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];
+                        /* FIXME: Use cpumask_of_node */
+                        node_to_cpumask_ptr(pnodemask, i);
-                        *nodemask = node_to_cpumask(i);
+                        cpus_and(*nodemask, *pnodemask, *cpu_map);
-                        cpus_and(*nodemask, *nodemask, *cpu_map);
+                        if (cpumask_empty(nodemask))
-                        if (cpus_empty(*nodemask))
                                continue;
                        if (sg == NULL)
@@ -7228,7 +7239,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 */
@@ -7254,7 +7266,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;
@@ -7319,40 +7331,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_ALLOC             1
-#define SCHED_CPUMASK_FREE(v)           kfree(v)
-#define SCHED_CPUMASK_DECLARE(v)        struct allmasks *v
-#else
-#define SCHED_CPUMASK_ALLOC             0
-#define SCHED_CPUMASK_FREE(v)
-#define SCHED_CPUMASK_DECLARE(v)        struct allmasks _v, *v = &_v
-#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)
@@ -7392,17 +7370,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_var_t nodemask, this_sibling_map, this_core_map, send_covered,
-        cpumask_t *tmpmask;
+                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
         */
@@ -7410,55 +7409,37 @@ 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
+                goto free_sched_groups;
-                kfree(sched_group_nodes);
-#endif
-                return -ENOMEM;
-        }
-#if SCHED_CPUMASK_ALLOC
-        /* get space for all scratch cpumask variables */
-        allmasks = kmalloc(sizeof(*allmasks), GFP_KERNEL);
-        if (!allmasks) {
-                printk(KERN_WARNING "Cannot alloc cpumask array\n");
-                kfree(rd);
-#ifdef CONFIG_NUMA
-                kfree(sched_group_nodes);
-#endif
-                return -ENOMEM;
        }
-#endif
-        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);
+                /* FIXME: use cpumask_of_node */
                *nodemask = node_to_cpumask(cpu_to_node(i));
                cpus_and(*nodemask, *nodemask, *cpu_map);
 #ifdef CONFIG_NUMA
-                if (cpus_weight(*cpu_map) >
+                if (cpumask_weight(cpu_map) >
-                                SD_NODES_PER_DOMAIN*cpus_weight(*nodemask)) {
+                                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;
@@ -7468,18 +7449,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;
@@ -7487,11 +7469,12 @@ 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);
+                *sched_domain_span(sd) = cpu_coregroup_map(i);
-                cpus_and(sd->span, sd->span, *cpu_map);
+                cpumask_and(sched_domain_span(sd),
+                            sched_domain_span(sd), cpu_map);
                sd->parent = p;
                p->child = sd;
                cpu_to_core_group(i, cpu_map, &sd->groups, tmpmask);
@@ -7499,11 +7482,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);
+                cpumask_and(sched_domain_span(sd),
-                cpus_and(sd->span, sd->span, *cpu_map);
+                            &per_cpu(cpu_sibling_map, i), cpu_map);
                sd->parent = p;
                p->child = sd;
                cpu_to_cpu_group(i, cpu_map, &sd->groups, tmpmask);
@@ -7512,13 +7495,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) {
+        for_each_cpu(i, cpu_map) {
-                SCHED_CPUMASK_VAR(this_sibling_map, allmasks);
+                cpumask_and(this_sibling_map,
-                SCHED_CPUMASK_VAR(send_covered, allmasks);
+                            &per_cpu(cpu_sibling_map, i), cpu_map);
+                if (i != cpumask_first(this_sibling_map))
-                *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))
                        continue;
                init_sched_build_groups(this_sibling_map, cpu_map,
@@ -7529,13 +7509,11 @@ 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) {
+        for_each_cpu(i, cpu_map) {
-                SCHED_CPUMASK_VAR(this_core_map, allmasks);
+                /* FIXME: Use cpu_coregroup_mask */
-                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))
+                if (i != cpumask_first(this_core_map))
                        continue;
                init_sched_build_groups(this_core_map, cpu_map,
@@ -7546,12 +7524,10 @@ 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);
+                /* FIXME: Use cpumask_of_node */
-                SCHED_CPUMASK_VAR(send_covered, allmasks);
                *nodemask = node_to_cpumask(i);
                cpus_and(*nodemask, *nodemask, *cpu_map);
-                if (cpus_empty(*nodemask))
+                if (cpumask_empty(nodemask))
                        continue;
                init_sched_build_groups(nodemask, cpu_map,
@@ -7562,8 +7538,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);
@@ -7572,58 +7546,58 @@ 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;
+                /* FIXME: Use cpumask_of_node */
                *nodemask = node_to_cpumask(i);
-                cpus_clear(*covered);
+                cpumask_clear(covered);
                cpus_and(*nodemask, *nodemask, *cpu_map);
-                if (cpus_empty(*nodemask)) {
+                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;
+                        /* FIXME: Use cpumask_of_node */
                        node_to_cpumask_ptr(pnodemask, n);
-                        cpus_complement(*notcovered, *covered);
+                        cpumask_complement(notcovered, covered);
-                        cpus_and(*tmpmask, *notcovered, *cpu_map);
+                        cpumask_and(tmpmask, notcovered, cpu_map);
-                        cpus_and(*tmpmask, *tmpmask, *domainspan);
+                        cpumask_and(tmpmask, tmpmask, domainspan);
-                        if (cpus_empty(*tmpmask))
+                        if (cpumask_empty(tmpmask))
                                break;
-                        cpus_and(*tmpmask, *tmpmask, *pnodemask);
+                        cpumask_and(tmpmask, tmpmask, pnodemask);
-                        if (cpus_empty(*tmpmask))
+                        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
@@ -7631,9 +7605,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;
                }
@@ -7642,22 +7616,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) {
+        for_each_cpu(i, cpu_map) {
-                struct sched_domain *sd = &per_cpu(cpu_domains, i);
+                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) {
+        for_each_cpu(i, cpu_map) {
-                struct sched_domain *sd = &per_cpu(core_domains, i);
+                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) {
+        for_each_cpu(i, cpu_map) {
-                struct sched_domain *sd = &per_cpu(phys_domains, i);
+                struct sched_domain *sd = &per_cpu(phys_domains, i).sd;
                init_sched_groups_power(i, sd);
        }
@@ -7669,53 +7643,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((void *)allmasks);
+        err = 0;
-        return 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((void *)allmasks);
+        free_rootdomain(rd);
-        kfree(rd);
+        goto free_tmpmask;
-        return -ENOMEM;
 #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,
+ * cpumask) fails, then fallback to a single sched domain,
- * as determined by the single cpumask_t fallback_doms.
+ * as determined by the single cpumask fallback_doms.
 */
-static cpumask_t fallback_doms;
+static cpumask_var_t fallback_doms;
 void __attribute__((weak)) arch_update_cpu_topology(void)
 {
@@ -7726,16 +7725,16 @@ void __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;
+                doms_cur = fallback_doms;
-        cpus_andnot(*doms_cur, *cpu_map, cpu_isolated_map);
+        cpumask_andnot(doms_cur, cpu_map, cpu_isolated_map);
        dattr_cur = NULL;
        err = build_sched_domains(doms_cur);
        register_sched_domain_sysctl();
@@ -7743,8 +7742,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,
+static void arch_destroy_sched_domains(const struct cpumask *cpu_map,
-                                       cpumask_t *tmpmask)
+                                       struct cpumask *tmpmask)
 {
        free_sched_groups(cpu_map, tmpmask);
 }
@@ -7753,17 +7752,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;
-        unregister_sched_domain_sysctl();
+        for_each_cpu(i, cpu_map)
-        for_each_cpu_mask_nr(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" */
@@ -7788,7 +7786,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
@@ -7802,13 +7800,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;
@@ -7823,7 +7822,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; 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;
                }
@@ -7835,15 +7834,15 @@ match1:
        if (doms_new == NULL) {
                ndoms_cur = 0;
-                doms_new = &fallback_doms;
+                doms_new = fallback_doms;
-                cpus_andnot(doms_new[0], cpu_online_map, cpu_isolated_map);
+                cpumask_andnot(&doms_new[0], cpu_online_mask, cpu_isolated_map);
-                dattr_new = NULL;
+                WARN_ON_ONCE(dattr_new);
        }
        /* Build new domains */
        for (i = 0; i < ndoms_new; i++) {
                for (j = 0; j < ndoms_cur; 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;
                }
@@ -7855,7 +7854,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;
@@ -7995,7 +7994,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 **),
@@ -8004,10 +8005,10 @@ void __init sched_init_smp(void)
 #endif
        get_online_cpus();
        mutex_lock(&sched_domains_mutex);
-        arch_init_sched_domains(&cpu_online_map);
+        arch_init_sched_domains(cpu_online_mask);
-        cpus_andnot(non_isolated_cpus, cpu_possible_map, cpu_isolated_map);
+        cpumask_andnot(non_isolated_cpus, cpu_possible_mask, cpu_isolated_map);
-        if (cpus_empty(non_isolated_cpus))
+        if (cpumask_empty(non_isolated_cpus))
-                cpu_set(smp_processor_id(), non_isolated_cpus);
+                cpumask_set_cpu(smp_processor_id(), non_isolated_cpus);
        mutex_unlock(&sched_domains_mutex);
        put_online_cpus();
@@ -8022,9 +8023,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)
@@ -8339,6 +8344,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;
 }
@@ -8497,7 +8511,7 @@ static
 int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
 {
        struct cfs_rq *cfs_rq;
-        struct sched_entity *se, *parent_se;
+        struct sched_entity *se;
        struct rq *rq;
        int i;
@@ -8513,18 +8527,17 @@ int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
        for_each_possible_cpu(i) {
                rq = cpu_rq(i);
-                cfs_rq = kmalloc_node(sizeof(struct cfs_rq),
+                cfs_rq = kzalloc_node(sizeof(struct cfs_rq),
-                                GFP_KERNEL|__GFP_ZERO, cpu_to_node(i));
+                                      GFP_KERNEL, cpu_to_node(i));
                if (!cfs_rq)
                        goto err;
-                se = kmalloc_node(sizeof(struct sched_entity),
+                se = kzalloc_node(sizeof(struct sched_entity),
-                                GFP_KERNEL|__GFP_ZERO, cpu_to_node(i));
+                                  GFP_KERNEL, cpu_to_node(i));
                if (!se)
                        goto err;
-                parent_se = parent ? parent->se[i] : NULL;
+                init_tg_cfs_entry(tg, cfs_rq, se, i, 0, parent->se[i]);
-                init_tg_cfs_entry(tg, cfs_rq, se, i, 0, parent_se);
        }
        return 1;
@@ -8585,7 +8598,7 @@ static
 int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent)
 {
        struct rt_rq *rt_rq;
-        struct sched_rt_entity *rt_se, *parent_se;
+        struct sched_rt_entity *rt_se;
        struct rq *rq;
        int i;
@@ -8602,18 +8615,17 @@ int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent)
        for_each_possible_cpu(i) {
                rq = cpu_rq(i);
-                rt_rq = kmalloc_node(sizeof(struct rt_rq),
+                rt_rq = kzalloc_node(sizeof(struct rt_rq),
-                                GFP_KERNEL|__GFP_ZERO, cpu_to_node(i));
+                                     GFP_KERNEL, cpu_to_node(i));
                if (!rt_rq)
                        goto err;
-                rt_se = kmalloc_node(sizeof(struct sched_rt_entity),
+                rt_se = kzalloc_node(sizeof(struct sched_rt_entity),
-                                GFP_KERNEL|__GFP_ZERO, cpu_to_node(i));
+                                     GFP_KERNEL, cpu_to_node(i));
                if (!rt_se)
                        goto err;
-                parent_se = parent ? parent->rt_se[i] : NULL;
+                init_tg_rt_entry(tg, rt_rq, rt_se, i, 0, parent->rt_se[i]);
-                init_tg_rt_entry(tg, rt_rq, rt_se, i, 0, parent_se);
        }
        return 1;
@@ -9256,11 +9268,12 @@ struct cgroup_subsys cpu_cgroup_subsys = {
 * (balbir@in.ibm.com).
 */
-/* track cpu usage of a group of tasks */
+/* track cpu usage of a group of tasks and its child groups */
 struct cpuacct {
        struct cgroup_subsys_state css;
        /* cpuusage holds pointer to a u64-type object on every cpu */
        u64 *cpuusage;
+        struct cpuacct *parent;
 };
 struct cgroup_subsys cpuacct_subsys;
@@ -9294,6 +9307,9 @@ static struct cgroup_subsys_state *cpuacct_create(
                return ERR_PTR(-ENOMEM);
        }
+        if (cgrp->parent)
+                ca->parent = cgroup_ca(cgrp->parent);
        return &ca->css;
 }
@@ -9373,14 +9389,16 @@ static int cpuacct_populate(struct cgroup_subsys *ss, struct cgroup *cgrp)
 static void cpuacct_charge(struct task_struct *tsk, u64 cputime)
 {
        struct cpuacct *ca;
+        int cpu;
        if (!cpuacct_subsys.active)
                return;
+        cpu = task_cpu(tsk);
        ca = task_ca(tsk);
-        if (ca) {
-                u64 *cpuusage = percpu_ptr(ca->cpuusage, task_cpu(tsk));
+        for (; ca; ca = ca->parent) {
+                u64 *cpuusage = percpu_ptr(ca->cpuusage, cpu);
                *cpuusage += cputime;
        }
 }
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 (cpumask_any_and(&p->cpus_allowed, vec->mask) >= nr_cpu_ids)
-                if (cpus_empty(mask))
                        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_debug.c b/kernel/sched_debug.c
index 26ed8e3d1c15..baf2f17af462 100644
--- a/kernel/sched_debug.c
+++ b/kernel/sched_debug.c
@@ -53,6 +53,40 @@ static unsigned long nsec_low(unsigned long long nsec)
 #define SPLIT_NS(x) nsec_high(x), nsec_low(x)
+#ifdef CONFIG_FAIR_GROUP_SCHED
+static void print_cfs_group_stats(struct seq_file *m, int cpu,
+                struct task_group *tg)
+{
+        struct sched_entity *se = tg->se[cpu];
+        if (!se)
+                return;
+#define P(F) \
+        SEQ_printf(m, "  .%-30s: %lld\n", #F, (long long)F)
+#define PN(F) \
+        SEQ_printf(m, "  .%-30s: %lld.%06ld\n", #F, SPLIT_NS((long long)F))
+        PN(se->exec_start);
+        PN(se->vruntime);
+        PN(se->sum_exec_runtime);
+#ifdef CONFIG_SCHEDSTATS
+        PN(se->wait_start);
+        PN(se->sleep_start);
+        PN(se->block_start);
+        PN(se->sleep_max);
+        PN(se->block_max);
+        PN(se->exec_max);
+        PN(se->slice_max);
+        PN(se->wait_max);
+        PN(se->wait_sum);
+        P(se->wait_count);
+#endif
+        P(se->load.weight);
+#undef PN
+#undef P
+}
+#endif
 static void
 print_task(struct seq_file *m, struct rq *rq, struct task_struct *p)
 {
@@ -121,14 +155,9 @@ void print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
 #if defined(CONFIG_CGROUP_SCHED) && defined(CONFIG_FAIR_GROUP_SCHED)
        char path[128] = "";
-        struct cgroup *cgroup = NULL;
        struct task_group *tg = cfs_rq->tg;
-        if (tg)
+        cgroup_path(tg->css.cgroup, path, sizeof(path));
-                cgroup = tg->css.cgroup;
-        if (cgroup)
-                cgroup_path(cgroup, path, sizeof(path));
        SEQ_printf(m, "\ncfs_rq[%d]:%s\n", cpu, path);
 #else
@@ -168,6 +197,7 @@ void print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
 #ifdef CONFIG_SMP
        SEQ_printf(m, "  .%-30s: %lu\n", "shares", cfs_rq->shares);
 #endif
+        print_cfs_group_stats(m, cpu, cfs_rq->tg);
 #endif
 }
@@ -175,14 +205,9 @@ void print_rt_rq(struct seq_file *m, int cpu, struct rt_rq *rt_rq)
 {
 #if defined(CONFIG_CGROUP_SCHED) && defined(CONFIG_RT_GROUP_SCHED)
        char path[128] = "";
-        struct cgroup *cgroup = NULL;
        struct task_group *tg = rt_rq->tg;
-        if (tg)
+        cgroup_path(tg->css.cgroup, path, sizeof(path));
-                cgroup = tg->css.cgroup;
-        if (cgroup)
-                cgroup_path(cgroup, path, sizeof(path));
        SEQ_printf(m, "\nrt_rq[%d]:%s\n", cpu, path);
 #else
@@ -272,7 +297,7 @@ static int sched_debug_show(struct seq_file *m, void *v)
        u64 now = ktime_to_ns(ktime_get());
        int cpu;
-        SEQ_printf(m, "Sched Debug Version: v0.07, %s %.*s\n",
+        SEQ_printf(m, "Sched Debug Version: v0.08, %s %.*s\n",
                init_utsname()->release,
                (int)strcspn(init_utsname()->version, " "),
                init_utsname()->version);
diff --git a/kernel/sched_fair.c b/kernel/sched_fair.c
index 98345e45b059..08ffffd4a410 100644
--- a/kernel/sched_fair.c
+++ b/kernel/sched_fair.c
@@ -1017,14 +1017,13 @@ 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;
@@ -1044,10 +1043,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);
+                        for_each_cpu_and(i, sched_domain_span(sd),
-                        cpus_and(tmp, tmp, cpu_active_map);
+                                         &p->cpus_allowed) {
-                        for_each_cpu_mask_nr(i, tmp) {
+                                if (cpu_active(i) && idle_cpu(i)) {
-                                if (idle_cpu(i)) {
                                        if (i != task_cpu(p)) {
                                                schedstat_inc(p,
                                                       se.nr_wakeups_idle);
@@ -1240,13 +1238,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 d9ba9d5f99d6..94aab72f6a02 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);
@@ -537,13 +537,13 @@ static void update_curr_rt(struct rq *rq)
        for_each_sched_rt_entity(rt_se) {
                rt_rq = rt_rq_of_se(rt_se);
-                spin_lock(&rt_rq->rt_runtime_lock);
                if (sched_rt_runtime(rt_rq) != RUNTIME_INF) {
+                        spin_lock(&rt_rq->rt_runtime_lock);
                        rt_rq->rt_time += delta_exec;
                        if (sched_rt_runtime_exceeded(rt_rq))
                                resched_task(curr);
+                        spin_unlock(&rt_rq->rt_runtime_lock);
                }
-                spin_unlock(&rt_rq->rt_runtime_lock);
        }
 }
@@ -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
+        if (!alloc_cpumask_var(&mask, GFP_ATOMIC))
-            && cpupri_find(&rq->rd->cpupri, p, &mask))
                return;
-        if (!cpupri_find(&rq->rd->cpupri, rq->curr, &mask))
+        if (p->rt.nr_cpus_allowed != 1
-                return;
+            && 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 */
@@ -910,14 +915,15 @@ static void put_prev_task_rt(struct rq *rq, struct task_struct *p)
 #define RT_MAX_TRIES 3
 static int double_lock_balance(struct rq *this_rq, struct rq *busiest);
-static void double_unlock_balance(struct rq *this_rq, struct rq *busiest);
+static inline void double_unlock_balance(struct rq *this_rq,
+                                                struct rq *busiest);
 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;
@@ -956,7 +962,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)
 {
@@ -976,7 +982,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);
@@ -991,7 +997,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
@@ -1001,7 +1007,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;
        /*
@@ -1016,7 +1022,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);
@@ -1057,8 +1064,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,
+                                     !cpumask_test_cpu(lowest_rq->cpu,
-                                                task->cpus_allowed) ||
+                                                       &task->cpus_allowed) ||
                                     task_running(rq, task) ||
                                     !task->se.on_rq)) {
@@ -1179,7 +1186,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;
@@ -1308,9 +1315,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));
@@ -1331,7 +1338,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;
 }
@@ -1374,6 +1381,14 @@ 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(&per_cpu(local_cpu_mask, i), GFP_KERNEL);
+}
 #endif /* CONFIG_SMP */
 /*
@@ -1544,3 +1559,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 7dbf72a2b02c..ce340835d055 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/softlockup.c b/kernel/softlockup.c
index 3953e4aed733..884e6cd2769c 100644
--- a/kernel/softlockup.c
+++ b/kernel/softlockup.c
@@ -164,7 +164,7 @@ unsigned long __read_mostly sysctl_hung_task_check_count = 1024;
 /*
 * Zero means infinite timeout - no checking done:
 */
-unsigned long __read_mostly sysctl_hung_task_timeout_secs = 120;
+unsigned long __read_mostly sysctl_hung_task_timeout_secs = 480;
 unsigned long __read_mostly sysctl_hung_task_warnings = 10;
diff --git a/kernel/sys.c b/kernel/sys.c
index 31deba8f7d16..5fc3a0cfb994 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -858,8 +858,8 @@ void do_sys_times(struct tms *tms)
        struct task_cputime cputime;
        cputime_t cutime, cstime;
-        spin_lock_irq(&current->sighand->siglock);
        thread_group_cputime(current, &cputime);
+        spin_lock_irq(&current->sighand->siglock);
        cutime = current->signal->cutime;
        cstime = current->signal->cstime;
        spin_unlock_irq(&current->sighand->siglock);
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index 342fc9ccab46..70f872c71f4e 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;
@@ -283,7 +283,7 @@ void tick_nohz_stop_sched_tick(int inidle)
        if ((long)delta_jiffies >= 1) {
                if (delta_jiffies > 1)
-                        cpu_set(cpu, nohz_cpu_mask);
+                        cpumask_set_cpu(cpu, nohz_cpu_mask);
                /*
                 * nohz_stop_sched_tick can be called several times before
                 * the nohz_restart_sched_tick is called. This happens when
@@ -296,7 +296,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;
                        }
@@ -354,7 +354,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:
@@ -432,7 +432,7 @@ 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);
        /*
         * We stopped the tick in idle. Update process times would miss the
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index b0f239e443bc..1e3fd3e3436a 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -545,6 +545,16 @@ config DEBUG_SG
          If unsure, say N.
+config DEBUG_NOTIFIERS
+        bool "Debug notifier call chains"
+        depends on DEBUG_KERNEL
+        help
+          Enable this to turn on sanity checking for notifier call chains.
+          This is most useful for kernel developers to make sure that
+          modules properly unregister themselves from notifier chains.
+          This is a relatively cheap check but if you care about maximum
+          performance, say N.
 config FRAME_POINTER
        bool "Compile the kernel with frame pointers"
        depends on DEBUG_KERNEL && \
diff --git a/mm/memory.c b/mm/memory.c
index 164951c47305..fc031d68327e 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -3049,3 +3049,18 @@ void print_vma_addr(char *prefix, unsigned long ip)
        }
        up_read(&current->mm->mmap_sem);
 }
+#ifdef CONFIG_PROVE_LOCKING
+void might_fault(void)
+{
+        might_sleep();
+        /*
+         * it would be nicer only to annotate paths which are not under
+         * pagefault_disable, however that requires a larger audit and
+         * providing helpers like get_user_atomic.
+         */
+        if (!in_atomic() && current->mm)
+                might_lock_read(&current->mm->mmap_sem);
+}
+EXPORT_SYMBOL(might_fault);
+#endif