Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mingo/linux-2.6-sched-devel

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mingo/linux-2.6-sched-devel: (62 commits)
  sched: build fix
  sched: better rt-group documentation
  sched: features fix
  sched: /debug/sched_features
  sched: add SCHED_FEAT_DEADLINE
  sched: debug: show a weight tree
  sched: fair: weight calculations
  sched: fair-group: de-couple load-balancing from the rb-trees
  sched: fair-group scheduling vs latency
  sched: rt-group: optimize dequeue_rt_stack
  sched: debug: add some debug code to handle the full hierarchy
  sched: fair-group: SMP-nice for group scheduling
  sched, cpuset: customize sched domains, core
  sched, cpuset: customize sched domains, docs
  sched: prepatory code movement
  sched: rt: multi level group constraints
  sched: task_group hierarchy
  sched: fix the task_group hierarchy for UID grouping
  sched: allow the group scheduler to have multiple levels
  sched: mix tasks and groups
  ...

68 files changed, 3157 insertions, 997 deletions

diff --git a/Documentation/cpusets.txt b/Documentation/cpusets.txt
index ad2bb3b3acc1..aa854b9b18cd 100644
--- a/Documentation/cpusets.txt
+++ b/Documentation/cpusets.txt
@@ -8,6 +8,7 @@ Portions Copyright (c) 2004-2006 Silicon Graphics, Inc.
 Modified by Paul Jackson <pj@sgi.com>
 Modified by Christoph Lameter <clameter@sgi.com>
 Modified by Paul Menage <menage@google.com>
+Modified by Hidetoshi Seto <seto.hidetoshi@jp.fujitsu.com>
 
 CONTENTS:
 =========
@@ -20,7 +21,8 @@ CONTENTS:
   1.5 What is memory_pressure ?
   1.6 What is memory spread ?
   1.7 What is sched_load_balance ?
-  1.8 How do I use cpusets ?
+  1.8 What is sched_relax_domain_level ?
+  1.9 How do I use cpusets ?
 2. Usage Examples and Syntax
   2.1 Basic Usage
   2.2 Adding/removing cpus
@@ -497,7 +499,73 @@ the cpuset code to update these sched domains, it compares the new
 partition requested with the current, and updates its sched domains,
 removing the old and adding the new, for each change.
 
-1.8 How do I use cpusets ?
+
+1.8 What is sched_relax_domain_level ?
+--------------------------------------
+
+In sched domain, the scheduler migrates tasks in 2 ways; periodic load
+balance on tick, and at time of some schedule events.
+
+When a task is woken up, scheduler try to move the task on idle CPU.
+For example, if a task A running on CPU X activates another task B
+on the same CPU X, and if CPU Y is X's sibling and performing idle,
+then scheduler migrate task B to CPU Y so that task B can start on
+CPU Y without waiting task A on CPU X.
+
+And if a CPU run out of tasks in its runqueue, the CPU try to pull
+extra tasks from other busy CPUs to help them before it is going to
+be idle.
+
+Of course it takes some searching cost to find movable tasks and/or
+idle CPUs, the scheduler might not search all CPUs in the domain
+everytime.  In fact, in some architectures, the searching ranges on
+events are limited in the same socket or node where the CPU locates,
+while the load balance on tick searchs all.
+
+For example, assume CPU Z is relatively far from CPU X.  Even if CPU Z
+is idle while CPU X and the siblings are busy, scheduler can't migrate
+woken task B from X to Z since it is out of its searching range.
+As the result, task B on CPU X need to wait task A or wait load balance
+on the next tick.  For some applications in special situation, waiting
+1 tick may be too long.
+
+The 'sched_relax_domain_level' file allows you to request changing
+this searching range as you like.  This file takes int value which
+indicates size of searching range in levels ideally as follows,
+otherwise initial value -1 that indicates the cpuset has no request.
+
+  -1  : no request. use system default or follow request of others.
+   0  : no search.
+   1  : search siblings (hyperthreads in a core).
+   2  : search cores in a package.
+   3  : search cpus in a node [= system wide on non-NUMA system]
+ ( 4  : search nodes in a chunk of node [on NUMA system] )
+ ( 5~ : search system wide [on NUMA system])
+
+This file is per-cpuset and affect the sched domain where the cpuset
+belongs to.  Therefore if the flag 'sched_load_balance' of a cpuset
+is disabled, then 'sched_relax_domain_level' have no effect since
+there is no sched domain belonging the cpuset.
+
+If multiple cpusets are overlapping and hence they form a single sched
+domain, the largest value among those is used.  Be careful, if one
+requests 0 and others are -1 then 0 is used.
+
+Note that modifying this file will have both good and bad effects,
+and whether it is acceptable or not will be depend on your situation.
+Don't modify this file if you are not sure.
+
+If your situation is:
+ - The migration costs between each cpu can be assumed considerably
+   small(for you) due to your special application's behavior or
+   special hardware support for CPU cache etc.
+ - The searching cost doesn't have impact(for you) or you can make
+   the searching cost enough small by managing cpuset to compact etc.
+ - The latency is required even it sacrifices cache hit rate etc.
+then increasing 'sched_relax_domain_level' would benefit you.
+
+
+1.9 How do I use cpusets ?
 --------------------------
 
 In order to minimize the impact of cpusets on critical kernel
diff --git a/Documentation/scheduler/sched-rt-group.txt b/Documentation/scheduler/sched-rt-group.txt
index 1c6332f4543c..14f901f639ee 100644
--- a/Documentation/scheduler/sched-rt-group.txt
+++ b/Documentation/scheduler/sched-rt-group.txt
@@ -1,59 +1,177 @@
+                                Real-Time group scheduling
+                                --------------------------
 
+CONTENTS
+========
 
-Real-Time group scheduling.
+1. Overview
+  1.1 The problem
+  1.2 The solution
+2. The interface
+  2.1 System-wide settings
+  2.2 Default behaviour
+  2.3 Basis for grouping tasks
+3. Future plans
 
-The problem space:
 
-In order to schedule multiple groups of realtime tasks each group must
-be assigned a fixed portion of the CPU time available. Without a minimum
-guarantee a realtime group can obviously fall short. A fuzzy upper limit
-is of no use since it cannot be relied upon. Which leaves us with just
-the single fixed portion.
+1. Overview
+===========
 
-CPU time is divided by means of specifying how much time can be spent
-running in a given period. Say a frame fixed realtime renderer must
-deliver 25 frames a second, which yields a period of 0.04s. Now say
-it will also have to play some music and respond to input, leaving it
-with around 80% for the graphics. We can then give this group a runtime
-of 0.8 * 0.04s = 0.032s.
 
-This way the graphics group will have a 0.04s period with a 0.032s runtime
-limit.
+1.1 The problem
+---------------
 
-Now if the audio thread needs to refill the DMA buffer every 0.005s, but
-needs only about 3% CPU time to do so, it can do with a 0.03 * 0.005s
-= 0.00015s.
+Realtime scheduling is all about determinism, a group has to be able to rely on
+the amount of bandwidth (eg. CPU time) being constant. In order to schedule
+multiple groups of realtime tasks, each group must be assigned a fixed portion
+of the CPU time available.  Without a minimum guarantee a realtime group can
+obviously fall short. A fuzzy upper limit is of no use since it cannot be
+relied upon. Which leaves us with just the single fixed portion.
 
+1.2 The solution
+----------------
 
-The Interface:
+CPU time is divided by means of specifying how much time can be spent running
+in a given period. We allocate this "run time" for each realtime group which
+the other realtime groups will not be permitted to use.
 
-system wide:
+Any time not allocated to a realtime group will be used to run normal priority
+tasks (SCHED_OTHER). Any allocated run time not used will also be picked up by
+SCHED_OTHER.
 
-/proc/sys/kernel/sched_rt_period_ms
-/proc/sys/kernel/sched_rt_runtime_us
+Let's consider an example: a frame fixed realtime renderer must deliver 25
+frames a second, which yields a period of 0.04s per frame. Now say it will also
+have to play some music and respond to input, leaving it with around 80% CPU
+time dedicated for the graphics. We can then give this group a run time of 0.8
+* 0.04s = 0.032s.
 
-CONFIG_FAIR_USER_SCHED
+This way the graphics group will have a 0.04s period with a 0.032s run time
+limit. Now if the audio thread needs to refill the DMA buffer every 0.005s, but
+needs only about 3% CPU time to do so, it can do with a 0.03 * 0.005s =
+0.00015s. So this group can be scheduled with a period of 0.005s and a run time
+of 0.00015s.
 
-/sys/kernel/uids/<uid>/cpu_rt_runtime_us
+The remaining CPU time will be used for user input and other tass. Because
+realtime tasks have explicitly allocated the CPU time they need to perform
+their tasks, buffer underruns in the graphocs or audio can be eliminated.
 
-or
+NOTE: the above example is not fully implemented as of yet (2.6.25). We still
+lack an EDF scheduler to make non-uniform periods usable.
 
-CONFIG_FAIR_CGROUP_SCHED
 
-/cgroup/<cgroup>/cpu.rt_runtime_us
+2. The Interface
+================
 
-[ time is specified in us because the interface is s32; this gives an
-  operating range of ~35m to 1us ]
 
-The period takes values in [ 1, INT_MAX ], runtime in [ -1, INT_MAX - 1 ].
+2.1 System wide settings
+------------------------
 
-A runtime of -1 specifies runtime == period, ie. no limit.
+The system wide settings are configured under the /proc virtual file system:
 
-New groups get the period from /proc/sys/kernel/sched_rt_period_us and
-a runtime of 0.
+/proc/sys/kernel/sched_rt_period_us:
+  The scheduling period that is equivalent to 100% CPU bandwidth
 
-Settings are constrained to:
+/proc/sys/kernel/sched_rt_runtime_us:
+  A global limit on how much time realtime scheduling may use.  Even without
+  CONFIG_RT_GROUP_SCHED enabled, this will limit time reserved to realtime
+  processes. With CONFIG_RT_GROUP_SCHED it signifies the total bandwidth
+  available to all realtime groups.
+
+  * Time is specified in us because the interface is s32. This gives an
+    operating range from 1us to about 35 minutes.
+  * sched_rt_period_us takes values from 1 to INT_MAX.
+  * sched_rt_runtime_us takes values from -1 to (INT_MAX - 1).
+  * A run time of -1 specifies runtime == period, ie. no limit.
+
+
+2.2 Default behaviour
+---------------------
+
+The default values for sched_rt_period_us (1000000 or 1s) and
+sched_rt_runtime_us (950000 or 0.95s).  This gives 0.05s to be used by
+SCHED_OTHER (non-RT tasks). These defaults were chosen so that a run-away
+realtime tasks will not lock up the machine but leave a little time to recover
+it.  By setting runtime to -1 you'd get the old behaviour back.
+
+By default all bandwidth is assigned to the root group and new groups get the
+period from /proc/sys/kernel/sched_rt_period_us and a run time of 0. If you
+want to assign bandwidth to another group, reduce the root group's bandwidth
+and assign some or all of the difference to another group.
+
+Realtime group scheduling means you have to assign a portion of total CPU
+bandwidth to the group before it will accept realtime tasks. Therefore you will
+not be able to run realtime tasks as any user other than root until you have
+done that, even if the user has the rights to run processes with realtime
+priority!
+
+
+2.3 Basis for grouping tasks
+----------------------------
+
+There are two compile-time settings for allocating CPU bandwidth. These are
+configured using the "Basis for grouping tasks" multiple choice menu under
+General setup > Group CPU Scheduler:
+
+a. CONFIG_USER_SCHED (aka "Basis for grouping tasks" =  "user id")
+
+This lets you use the virtual files under
+"/sys/kernel/uids/<uid>/cpu_rt_runtime_us" to control he CPU time reserved for
+each user .
+
+The other option is:
+
+.o CONFIG_CGROUP_SCHED (aka "Basis for grouping tasks" = "Control groups")
+
+This uses the /cgroup virtual file system and "/cgroup/<cgroup>/cpu.rt_runtime_us"
+to control the CPU time reserved for each control group instead.
+
+For more information on working with control groups, you should read
+Documentation/cgroups.txt as well.
+
+Group settings are checked against the following limits in order to keep the configuration
+schedulable:
 
    \Sum_{i} runtime_{i} / global_period <= global_runtime / global_period
 
-in order to keep the configuration schedulable.
+For now, this can be simplified to just the following (but see Future plans):
+
+   \Sum_{i} runtime_{i} <= global_runtime
+
+
+3. Future plans
+===============
+
+There is work in progress to make the scheduling period for each group
+("/sys/kernel/uids/<uid>/cpu_rt_period_us" or
+"/cgroup/<cgroup>/cpu.rt_period_us" respectively) configurable as well.
+
+The constraint on the period is that a subgroup must have a smaller or
+equal period to its parent. But realistically its not very useful _yet_
+as its prone to starvation without deadline scheduling.
+
+Consider two sibling groups A and B; both have 50% bandwidth, but A's
+period is twice the length of B's.
+
+* group A: period=100000us, runtime=10000us
+        - this runs for 0.01s once every 0.1s
+
+* group B: period= 50000us, runtime=10000us
+        - this runs for 0.01s twice every 0.1s (or once every 0.05 sec).
+
+This means that currently a while (1) loop in A will run for the full period of
+B and can starve B's tasks (assuming they are of lower priority) for a whole
+period.
+
+The next project will be SCHED_EDF (Earliest Deadline First scheduling) to bring
+full deadline scheduling to the linux kernel. Deadline scheduling the above
+groups and treating end of the period as a deadline will ensure that they both
+get their allocated time.
+
+Implementing SCHED_EDF might take a while to complete. Priority Inheritance is
+the biggest challenge as the current linux PI infrastructure is geared towards
+the limited static priority levels 0-139. With deadline scheduling you need to
+do deadline inheritance (since priority is inversely proportional to the
+deadline delta (deadline - now).
+
+This means the whole PI machinery will have to be reworked - and that is one of
+the most complex pieces of code we have.
diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index 07cf77113565..87a693cf2bb7 100644
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -117,6 +117,9 @@ config ARCH_HAS_CPU_RELAX
 config HAVE_SETUP_PER_CPU_AREA
         def_bool X86_64 || (X86_SMP && !X86_VOYAGER)
 
+config HAVE_CPUMASK_OF_CPU_MAP
+        def_bool X86_64_SMP
+
 config ARCH_HIBERNATION_POSSIBLE
         def_bool y
         depends on !SMP || !X86_VOYAGER
diff --git a/arch/x86/kernel/acpi/cstate.c b/arch/x86/kernel/acpi/cstate.c
index 9366fb68d8d8..c2502eb9aa83 100644
--- a/arch/x86/kernel/acpi/cstate.c
+++ b/arch/x86/kernel/acpi/cstate.c
@@ -91,7 +91,7 @@ int acpi_processor_ffh_cstate_probe(unsigned int cpu,
 
         /* Make sure we are running on right CPU */
         saved_mask = current->cpus_allowed;
-        retval = set_cpus_allowed(current, cpumask_of_cpu(cpu));
+        retval = set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
         if (retval)
                 return -1;
 
@@ -128,7 +128,7 @@ int acpi_processor_ffh_cstate_probe(unsigned int cpu,
                  cx->address);
 
 out:
-        set_cpus_allowed(current, saved_mask);
+        set_cpus_allowed_ptr(current, &saved_mask);
         return retval;
 }
 EXPORT_SYMBOL_GPL(acpi_processor_ffh_cstate_probe);
diff --git a/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c b/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
index a962dcb9c408..e2d870de837c 100644
--- a/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
+++ b/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
@@ -192,9 +192,9 @@ static void drv_read(struct drv_cmd *cmd)
         cpumask_t saved_mask = current->cpus_allowed;
         cmd->val = 0;
 
-        set_cpus_allowed(current, cmd->mask);
+        set_cpus_allowed_ptr(current, &cmd->mask);
         do_drv_read(cmd);
-        set_cpus_allowed(current, saved_mask);
+        set_cpus_allowed_ptr(current, &saved_mask);
 }
 
 static void drv_write(struct drv_cmd *cmd)
@@ -203,30 +203,30 @@ static void drv_write(struct drv_cmd *cmd)
         unsigned int i;
 
         for_each_cpu_mask(i, cmd->mask) {
-                set_cpus_allowed(current, cpumask_of_cpu(i));
+                set_cpus_allowed_ptr(current, &cpumask_of_cpu(i));
                 do_drv_write(cmd);
         }
 
-        set_cpus_allowed(current, saved_mask);
+        set_cpus_allowed_ptr(current, &saved_mask);
         return;
 }
 
-static u32 get_cur_val(cpumask_t mask)
+static u32 get_cur_val(const cpumask_t *mask)
 {
         struct acpi_processor_performance *perf;
         struct drv_cmd cmd;
 
-        if (unlikely(cpus_empty(mask)))
+        if (unlikely(cpus_empty(*mask)))
                 return 0;
 
-        switch (per_cpu(drv_data, first_cpu(mask))->cpu_feature) {
+        switch (per_cpu(drv_data, first_cpu(*mask))->cpu_feature) {
         case SYSTEM_INTEL_MSR_CAPABLE:
                 cmd.type = SYSTEM_INTEL_MSR_CAPABLE;
                 cmd.addr.msr.reg = MSR_IA32_PERF_STATUS;
                 break;
         case SYSTEM_IO_CAPABLE:
                 cmd.type = SYSTEM_IO_CAPABLE;
-                perf = per_cpu(drv_data, first_cpu(mask))->acpi_data;
+                perf = per_cpu(drv_data, first_cpu(*mask))->acpi_data;
                 cmd.addr.io.port = perf->control_register.address;
                 cmd.addr.io.bit_width = perf->control_register.bit_width;
                 break;
@@ -234,7 +234,7 @@ static u32 get_cur_val(cpumask_t mask)
                 return 0;
         }
 
-        cmd.mask = mask;
+        cmd.mask = *mask;
 
         drv_read(&cmd);
 
@@ -271,7 +271,7 @@ static unsigned int get_measured_perf(unsigned int cpu)
         unsigned int retval;
 
         saved_mask = current->cpus_allowed;
-        set_cpus_allowed(current, cpumask_of_cpu(cpu));
+        set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
         if (get_cpu() != cpu) {
                 /* We were not able to run on requested processor */
                 put_cpu();
@@ -329,7 +329,7 @@ static unsigned int get_measured_perf(unsigned int cpu)
         retval = per_cpu(drv_data, cpu)->max_freq * perf_percent / 100;
 
         put_cpu();
-        set_cpus_allowed(current, saved_mask);
+        set_cpus_allowed_ptr(current, &saved_mask);
 
         dprintk("cpu %d: performance percent %d\n", cpu, perf_percent);
         return retval;
@@ -347,13 +347,13 @@ static unsigned int get_cur_freq_on_cpu(unsigned int cpu)
                 return 0;
         }
 
-        freq = extract_freq(get_cur_val(cpumask_of_cpu(cpu)), data);
+        freq = extract_freq(get_cur_val(&cpumask_of_cpu(cpu)), data);
         dprintk("cur freq = %u\n", freq);
 
         return freq;
 }
 
-static unsigned int check_freqs(cpumask_t mask, unsigned int freq,
+static unsigned int check_freqs(const cpumask_t *mask, unsigned int freq,
                                 struct acpi_cpufreq_data *data)
 {
         unsigned int cur_freq;
@@ -449,7 +449,7 @@ static int acpi_cpufreq_target(struct cpufreq_policy *policy,
         drv_write(&cmd);
 
         if (acpi_pstate_strict) {
-                if (!check_freqs(cmd.mask, freqs.new, data)) {
+                if (!check_freqs(&cmd.mask, freqs.new, data)) {
                         dprintk("acpi_cpufreq_target failed (%d)\n",
                                 policy->cpu);
                         return -EAGAIN;
diff --git a/arch/x86/kernel/cpu/cpufreq/powernow-k8.c b/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
index c99d59d8ef2e..46d4034d9f37 100644
--- a/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
+++ b/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
@@ -478,12 +478,12 @@ static int core_voltage_post_transition(struct powernow_k8_data *data, u32 reqvi
 
 static int check_supported_cpu(unsigned int cpu)
 {
-        cpumask_t oldmask = CPU_MASK_ALL;
+        cpumask_t oldmask;
         u32 eax, ebx, ecx, edx;
         unsigned int rc = 0;
 
         oldmask = current->cpus_allowed;
-        set_cpus_allowed(current, cpumask_of_cpu(cpu));
+        set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
 
         if (smp_processor_id() != cpu) {
                 printk(KERN_ERR PFX "limiting to cpu %u failed\n", cpu);
@@ -528,7 +528,7 @@ static int check_supported_cpu(unsigned int cpu)
         rc = 1;
 
 out:
-        set_cpus_allowed(current, oldmask);
+        set_cpus_allowed_ptr(current, &oldmask);
         return rc;
 }
 
@@ -1015,7 +1015,7 @@ static int transition_frequency_pstate(struct powernow_k8_data *data, unsigned i
 /* Driver entry point to switch to the target frequency */
 static int powernowk8_target(struct cpufreq_policy *pol, unsigned targfreq, unsigned relation)
 {
-        cpumask_t oldmask = CPU_MASK_ALL;
+        cpumask_t oldmask;
         struct powernow_k8_data *data = per_cpu(powernow_data, pol->cpu);
         u32 checkfid;
         u32 checkvid;
@@ -1030,7 +1030,7 @@ static int powernowk8_target(struct cpufreq_policy *pol, unsigned targfreq, unsi
 
         /* only run on specific CPU from here on */
         oldmask = current->cpus_allowed;
-        set_cpus_allowed(current, cpumask_of_cpu(pol->cpu));
+        set_cpus_allowed_ptr(current, &cpumask_of_cpu(pol->cpu));
 
         if (smp_processor_id() != pol->cpu) {
                 printk(KERN_ERR PFX "limiting to cpu %u failed\n", pol->cpu);
@@ -1085,7 +1085,7 @@ static int powernowk8_target(struct cpufreq_policy *pol, unsigned targfreq, unsi
         ret = 0;
 
 err_out:
-        set_cpus_allowed(current, oldmask);
+        set_cpus_allowed_ptr(current, &oldmask);
         return ret;
 }
 
@@ -1104,7 +1104,7 @@ static int powernowk8_verify(struct cpufreq_policy *pol)
 static int __cpuinit powernowk8_cpu_init(struct cpufreq_policy *pol)
 {
         struct powernow_k8_data *data;
-        cpumask_t oldmask = CPU_MASK_ALL;
+        cpumask_t oldmask;
         int rc;
 
         if (!cpu_online(pol->cpu))
@@ -1145,7 +1145,7 @@ static int __cpuinit powernowk8_cpu_init(struct cpufreq_policy *pol)
 
         /* only run on specific CPU from here on */
         oldmask = current->cpus_allowed;
-        set_cpus_allowed(current, cpumask_of_cpu(pol->cpu));
+        set_cpus_allowed_ptr(current, &cpumask_of_cpu(pol->cpu));
 
         if (smp_processor_id() != pol->cpu) {
                 printk(KERN_ERR PFX "limiting to cpu %u failed\n", pol->cpu);
@@ -1164,7 +1164,7 @@ static int __cpuinit powernowk8_cpu_init(struct cpufreq_policy *pol)
                 fidvid_msr_init();
 
         /* run on any CPU again */
-        set_cpus_allowed(current, oldmask);
+        set_cpus_allowed_ptr(current, &oldmask);
 
         if (cpu_family == CPU_HW_PSTATE)
                 pol->cpus = cpumask_of_cpu(pol->cpu);
@@ -1205,7 +1205,7 @@ static int __cpuinit powernowk8_cpu_init(struct cpufreq_policy *pol)
         return 0;
 
 err_out:
-        set_cpus_allowed(current, oldmask);
+        set_cpus_allowed_ptr(current, &oldmask);
         powernow_k8_cpu_exit_acpi(data);
 
         kfree(data);
@@ -1242,10 +1242,11 @@ static unsigned int powernowk8_get (unsigned int cpu)
         if (!data)
                 return -EINVAL;
 
-        set_cpus_allowed(current, cpumask_of_cpu(cpu));
+        set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
         if (smp_processor_id() != cpu) {
-                printk(KERN_ERR PFX "limiting to CPU %d failed in powernowk8_get\n", cpu);
-                set_cpus_allowed(current, oldmask);
+                printk(KERN_ERR PFX
+                        "limiting to CPU %d failed in powernowk8_get\n", cpu);
+                set_cpus_allowed_ptr(current, &oldmask);
                 return 0;
         }
 
@@ -1253,13 +1254,14 @@ static unsigned int powernowk8_get (unsigned int cpu)
                 goto out;
 
         if (cpu_family == CPU_HW_PSTATE)
-                khz = find_khz_freq_from_pstate(data->powernow_table, data->currpstate);
+                khz = find_khz_freq_from_pstate(data->powernow_table,
+                                                data->currpstate);
         else
                 khz = find_khz_freq_from_fid(data->currfid);
 
 
 out:
-        set_cpus_allowed(current, oldmask);
+        set_cpus_allowed_ptr(current, &oldmask);
         return khz;
 }
 
diff --git a/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c b/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
index 3031f1196192..908dd347c67e 100644
--- a/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
+++ b/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
@@ -315,7 +315,7 @@ static unsigned int get_cur_freq(unsigned int cpu)
         cpumask_t saved_mask;
 
         saved_mask = current->cpus_allowed;
-        set_cpus_allowed(current, cpumask_of_cpu(cpu));
+        set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
         if (smp_processor_id() != cpu)
                 return 0;
 
@@ -333,7 +333,7 @@ static unsigned int get_cur_freq(unsigned int cpu)
                 clock_freq = extract_clock(l, cpu, 1);
         }
 
-        set_cpus_allowed(current, saved_mask);
+        set_cpus_allowed_ptr(current, &saved_mask);
         return clock_freq;
 }
 
@@ -487,7 +487,7 @@ static int centrino_target (struct cpufreq_policy *policy,
                 else
                         cpu_set(j, set_mask);
 
-                set_cpus_allowed(current, set_mask);
+                set_cpus_allowed_ptr(current, &set_mask);
                 preempt_disable();
                 if (unlikely(!cpu_isset(smp_processor_id(), set_mask))) {
                         dprintk("couldn't limit to CPUs in this domain\n");
@@ -555,7 +555,8 @@ static int centrino_target (struct cpufreq_policy *policy,
 
                 if (!cpus_empty(covered_cpus)) {
                         for_each_cpu_mask(j, covered_cpus) {
-                                set_cpus_allowed(current, cpumask_of_cpu(j));
+                                set_cpus_allowed_ptr(current,
+                                                     &cpumask_of_cpu(j));
                                 wrmsr(MSR_IA32_PERF_CTL, oldmsr, h);
                         }
                 }
@@ -569,12 +570,12 @@ static int centrino_target (struct cpufreq_policy *policy,
                         cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
                 }
         }
-        set_cpus_allowed(current, saved_mask);
+        set_cpus_allowed_ptr(current, &saved_mask);
         return 0;
 
 migrate_end:
         preempt_enable();
-        set_cpus_allowed(current, saved_mask);
+        set_cpus_allowed_ptr(current, &saved_mask);
         return 0;
 }
 
diff --git a/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c b/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c
index 14d68aa301ee..1b50244b1fdf 100644
--- a/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c
+++ b/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c
@@ -229,22 +229,22 @@ static unsigned int speedstep_detect_chipset (void)
         return 0;
 }
 
-static unsigned int _speedstep_get(cpumask_t cpus)
+static unsigned int _speedstep_get(const cpumask_t *cpus)
 {
         unsigned int speed;
         cpumask_t cpus_allowed;
 
         cpus_allowed = current->cpus_allowed;
-        set_cpus_allowed(current, cpus);
+        set_cpus_allowed_ptr(current, cpus);
         speed = speedstep_get_processor_frequency(speedstep_processor);
-        set_cpus_allowed(current, cpus_allowed);
+        set_cpus_allowed_ptr(current, &cpus_allowed);
         dprintk("detected %u kHz as current frequency\n", speed);
         return speed;
 }
 
 static unsigned int speedstep_get(unsigned int cpu)
 {
-        return _speedstep_get(cpumask_of_cpu(cpu));
+        return _speedstep_get(&cpumask_of_cpu(cpu));
 }
 
 /**
@@ -267,7 +267,7 @@ static int speedstep_target (struct cpufreq_policy *policy,
         if (cpufreq_frequency_table_target(policy, &speedstep_freqs[0], target_freq, relation, &newstate))
                 return -EINVAL;
 
-        freqs.old = _speedstep_get(policy->cpus);
+        freqs.old = _speedstep_get(&policy->cpus);
         freqs.new = speedstep_freqs[newstate].frequency;
         freqs.cpu = policy->cpu;
 
@@ -285,12 +285,12 @@ static int speedstep_target (struct cpufreq_policy *policy,
         }
 
         /* switch to physical CPU where state is to be changed */
-        set_cpus_allowed(current, policy->cpus);
+        set_cpus_allowed_ptr(current, &policy->cpus);
 
         speedstep_set_state(newstate);
 
         /* allow to be run on all CPUs */
-        set_cpus_allowed(current, cpus_allowed);
+        set_cpus_allowed_ptr(current, &cpus_allowed);
 
         for_each_cpu_mask(i, policy->cpus) {
                 freqs.cpu = i;
@@ -326,7 +326,7 @@ static int speedstep_cpu_init(struct cpufreq_policy *policy)
 #endif
 
         cpus_allowed = current->cpus_allowed;
-        set_cpus_allowed(current, policy->cpus);
+        set_cpus_allowed_ptr(current, &policy->cpus);
 
         /* detect low and high frequency and transition latency */
         result = speedstep_get_freqs(speedstep_processor,
@@ -334,12 +334,12 @@ static int speedstep_cpu_init(struct cpufreq_policy *policy)
                                      &speedstep_freqs[SPEEDSTEP_HIGH].frequency,
                                      &policy->cpuinfo.transition_latency,
                                      &speedstep_set_state);
-        set_cpus_allowed(current, cpus_allowed);
+        set_cpus_allowed_ptr(current, &cpus_allowed);
         if (result)
                 return result;
 
         /* get current speed setting */
-        speed = _speedstep_get(policy->cpus);
+        speed = _speedstep_get(&policy->cpus);
         if (!speed)
                 return -EIO;
 
diff --git a/arch/x86/kernel/cpu/intel_cacheinfo.c b/arch/x86/kernel/cpu/intel_cacheinfo.c
index 1b889860eb73..26d615dcb149 100644
--- a/arch/x86/kernel/cpu/intel_cacheinfo.c
+++ b/arch/x86/kernel/cpu/intel_cacheinfo.c
@@ -129,7 +129,7 @@ struct _cpuid4_info {
         union _cpuid4_leaf_ebx ebx;
         union _cpuid4_leaf_ecx ecx;
         unsigned long size;
-        cpumask_t shared_cpu_map;
+        cpumask_t shared_cpu_map;       /* future?: only cpus/node is needed */
 };
 
 unsigned short                  num_cache_leaves;
@@ -451,8 +451,8 @@ unsigned int __cpuinit init_intel_cacheinfo(struct cpuinfo_x86 *c)
 }
 
 /* pointer to _cpuid4_info array (for each cache leaf) */
-static struct _cpuid4_info *cpuid4_info[NR_CPUS];
-#define CPUID4_INFO_IDX(x,y)    (&((cpuid4_info[x])[y]))
+static DEFINE_PER_CPU(struct _cpuid4_info *, cpuid4_info);
+#define CPUID4_INFO_IDX(x, y)    (&((per_cpu(cpuid4_info, x))[y]))
 
 #ifdef CONFIG_SMP
 static void __cpuinit cache_shared_cpu_map_setup(unsigned int cpu, int index)
@@ -474,7 +474,7 @@ static void __cpuinit cache_shared_cpu_map_setup(unsigned int cpu, int index)
                         if (cpu_data(i).apicid >> index_msb ==
                             c->apicid >> index_msb) {
                                 cpu_set(i, this_leaf->shared_cpu_map);
-                                if (i != cpu && cpuid4_info[i])  {
+                                if (i != cpu && per_cpu(cpuid4_info, i))  {
                                         sibling_leaf = CPUID4_INFO_IDX(i, index);
                                         cpu_set(cpu, sibling_leaf->shared_cpu_map);
                                 }
@@ -505,8 +505,8 @@ static void __cpuinit free_cache_attributes(unsigned int cpu)
         for (i = 0; i < num_cache_leaves; i++)
                 cache_remove_shared_cpu_map(cpu, i);
 
-        kfree(cpuid4_info[cpu]);
-        cpuid4_info[cpu] = NULL;
+        kfree(per_cpu(cpuid4_info, cpu));
+        per_cpu(cpuid4_info, cpu) = NULL;
 }
 
 static int __cpuinit detect_cache_attributes(unsigned int cpu)
@@ -519,13 +519,13 @@ static int __cpuinit detect_cache_attributes(unsigned int cpu)
         if (num_cache_leaves == 0)
                 return -ENOENT;
 
-        cpuid4_info[cpu] = kzalloc(
+        per_cpu(cpuid4_info, cpu) = kzalloc(
             sizeof(struct _cpuid4_info) * num_cache_leaves, GFP_KERNEL);
-        if (cpuid4_info[cpu] == NULL)
+        if (per_cpu(cpuid4_info, cpu) == NULL)
                 return -ENOMEM;
 
         oldmask = current->cpus_allowed;
-        retval = set_cpus_allowed(current, cpumask_of_cpu(cpu));
+        retval = set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
         if (retval)
                 goto out;
 
@@ -542,12 +542,12 @@ static int __cpuinit detect_cache_attributes(unsigned int cpu)
                 }
                 cache_shared_cpu_map_setup(cpu, j);
         }
-        set_cpus_allowed(current, oldmask);
+        set_cpus_allowed_ptr(current, &oldmask);
 
 out:
         if (retval) {
-                kfree(cpuid4_info[cpu]);
-                cpuid4_info[cpu] = NULL;
+                kfree(per_cpu(cpuid4_info, cpu));
+                per_cpu(cpuid4_info, cpu) = NULL;
         }
 
         return retval;
@@ -561,7 +561,7 @@ out:
 extern struct sysdev_class cpu_sysdev_class; /* from drivers/base/cpu.c */
 
 /* pointer to kobject for cpuX/cache */
-static struct kobject * cache_kobject[NR_CPUS];
+static DEFINE_PER_CPU(struct kobject *, cache_kobject);
 
 struct _index_kobject {
         struct kobject kobj;
@@ -570,8 +570,8 @@ struct _index_kobject {
 };
 
 /* pointer to array of kobjects for cpuX/cache/indexY */
-static struct _index_kobject *index_kobject[NR_CPUS];
-#define INDEX_KOBJECT_PTR(x,y)    (&((index_kobject[x])[y]))
+static DEFINE_PER_CPU(struct _index_kobject *, index_kobject);
+#define INDEX_KOBJECT_PTR(x, y)    (&((per_cpu(index_kobject, x))[y]))
 
 #define show_one_plus(file_name, object, val)                           \
 static ssize_t show_##file_name                                         \
@@ -591,11 +591,32 @@ static ssize_t show_size(struct _cpuid4_info *this_leaf, char *buf)
         return sprintf (buf, "%luK\n", this_leaf->size / 1024);
 }
 
-static ssize_t show_shared_cpu_map(struct _cpuid4_info *this_leaf, char *buf)
+static ssize_t show_shared_cpu_map_func(struct _cpuid4_info *this_leaf,
+                                        int type, char *buf)
 {
-        char mask_str[NR_CPUS];
-        cpumask_scnprintf(mask_str, NR_CPUS, this_leaf->shared_cpu_map);
-        return sprintf(buf, "%s\n", mask_str);
+        ptrdiff_t len = PTR_ALIGN(buf + PAGE_SIZE - 1, PAGE_SIZE) - buf;
+        int n = 0;
+
+        if (len > 1) {
+                cpumask_t *mask = &this_leaf->shared_cpu_map;
+
+                n = type?
+                        cpulist_scnprintf(buf, len-2, *mask):
+                        cpumask_scnprintf(buf, len-2, *mask);
+                buf[n++] = '\n';
+                buf[n] = '\0';
+        }
+        return n;
+}
+
+static inline ssize_t show_shared_cpu_map(struct _cpuid4_info *leaf, char *buf)
+{
+        return show_shared_cpu_map_func(leaf, 0, buf);
+}
+
+static inline ssize_t show_shared_cpu_list(struct _cpuid4_info *leaf, char *buf)
+{
+        return show_shared_cpu_map_func(leaf, 1, buf);
 }
 
 static ssize_t show_type(struct _cpuid4_info *this_leaf, char *buf) {
@@ -633,6 +654,7 @@ define_one_ro(ways_of_associativity);
 define_one_ro(number_of_sets);
 define_one_ro(size);
 define_one_ro(shared_cpu_map);
+define_one_ro(shared_cpu_list);
 
 static struct attribute * default_attrs[] = {
         &type.attr,
@@ -643,6 +665,7 @@ static struct attribute * default_attrs[] = {
         &number_of_sets.attr,
         &size.attr,
         &shared_cpu_map.attr,
+        &shared_cpu_list.attr,
         NULL
 };
 
@@ -684,10 +707,10 @@ static struct kobj_type ktype_percpu_entry = {
 
 static void __cpuinit cpuid4_cache_sysfs_exit(unsigned int cpu)
 {
-        kfree(cache_kobject[cpu]);
-        kfree(index_kobject[cpu]);
-        cache_kobject[cpu] = NULL;
-        index_kobject[cpu] = NULL;
+        kfree(per_cpu(cache_kobject, cpu));
+        kfree(per_cpu(index_kobject, cpu));
+        per_cpu(cache_kobject, cpu) = NULL;
+        per_cpu(index_kobject, cpu) = NULL;
         free_cache_attributes(cpu);
 }
 
@@ -703,13 +726,14 @@ static int __cpuinit cpuid4_cache_sysfs_init(unsigned int cpu)
                 return err;
 
         /* Allocate all required memory */
-        cache_kobject[cpu] = kzalloc(sizeof(struct kobject), GFP_KERNEL);
-        if (unlikely(cache_kobject[cpu] == NULL))
+        per_cpu(cache_kobject, cpu) =
+                kzalloc(sizeof(struct kobject), GFP_KERNEL);
+        if (unlikely(per_cpu(cache_kobject, cpu) == NULL))
                 goto err_out;
 
-        index_kobject[cpu] = kzalloc(
+        per_cpu(index_kobject, cpu) = kzalloc(
             sizeof(struct _index_kobject ) * num_cache_leaves, GFP_KERNEL);
-        if (unlikely(index_kobject[cpu] == NULL))
+        if (unlikely(per_cpu(index_kobject, cpu) == NULL))
                 goto err_out;
 
         return 0;
@@ -733,7 +757,8 @@ static int __cpuinit cache_add_dev(struct sys_device * sys_dev)
         if (unlikely(retval < 0))
                 return retval;
 
-        retval = kobject_init_and_add(cache_kobject[cpu], &ktype_percpu_entry,
+        retval = kobject_init_and_add(per_cpu(cache_kobject, cpu),
+                                      &ktype_percpu_entry,
                                       &sys_dev->kobj, "%s", "cache");
         if (retval < 0) {
                 cpuid4_cache_sysfs_exit(cpu);
@@ -745,13 +770,14 @@ static int __cpuinit cache_add_dev(struct sys_device * sys_dev)
                 this_object->cpu = cpu;
                 this_object->index = i;
                 retval = kobject_init_and_add(&(this_object->kobj),
-                                              &ktype_cache, cache_kobject[cpu],
+                                              &ktype_cache,
+                                              per_cpu(cache_kobject, cpu),
                                               "index%1lu", i);
                 if (unlikely(retval)) {
                         for (j = 0; j < i; j++) {
                                 kobject_put(&(INDEX_KOBJECT_PTR(cpu,j)->kobj));
                         }
-                        kobject_put(cache_kobject[cpu]);
+                        kobject_put(per_cpu(cache_kobject, cpu));
                         cpuid4_cache_sysfs_exit(cpu);
                         break;
                 }
@@ -760,7 +786,7 @@ static int __cpuinit cache_add_dev(struct sys_device * sys_dev)
         if (!retval)
                 cpu_set(cpu, cache_dev_map);
 
-        kobject_uevent(cache_kobject[cpu], KOBJ_ADD);
+        kobject_uevent(per_cpu(cache_kobject, cpu), KOBJ_ADD);
         return retval;
 }
 
@@ -769,7 +795,7 @@ static void __cpuinit cache_remove_dev(struct sys_device * sys_dev)
         unsigned int cpu = sys_dev->id;
         unsigned long i;
 
-        if (cpuid4_info[cpu] == NULL)
+        if (per_cpu(cpuid4_info, cpu) == NULL)
                 return;
         if (!cpu_isset(cpu, cache_dev_map))
                 return;
@@ -777,7 +803,7 @@ static void __cpuinit cache_remove_dev(struct sys_device * sys_dev)
 
         for (i = 0; i < num_cache_leaves; i++)
                 kobject_put(&(INDEX_KOBJECT_PTR(cpu,i)->kobj));
-        kobject_put(cache_kobject[cpu]);
+        kobject_put(per_cpu(cache_kobject, cpu));
         cpuid4_cache_sysfs_exit(cpu);
 }
 
diff --git a/arch/x86/kernel/cpu/mcheck/mce_amd_64.c b/arch/x86/kernel/cpu/mcheck/mce_amd_64.c
index 32671da8184e..7c9a813e1193 100644
--- a/arch/x86/kernel/cpu/mcheck/mce_amd_64.c
+++ b/arch/x86/kernel/cpu/mcheck/mce_amd_64.c
@@ -251,18 +251,18 @@ struct threshold_attr {
         ssize_t(*store) (struct threshold_block *, const char *, size_t count);
 };
 
-static cpumask_t affinity_set(unsigned int cpu)
+static void affinity_set(unsigned int cpu, cpumask_t *oldmask,
+                                           cpumask_t *newmask)
 {
-        cpumask_t oldmask = current->cpus_allowed;
-        cpumask_t newmask = CPU_MASK_NONE;
-        cpu_set(cpu, newmask);
-        set_cpus_allowed(current, newmask);
-        return oldmask;
+        *oldmask = current->cpus_allowed;
+        cpus_clear(*newmask);
+        cpu_set(cpu, *newmask);
+        set_cpus_allowed_ptr(current, newmask);
 }
 
-static void affinity_restore(cpumask_t oldmask)
+static void affinity_restore(const cpumask_t *oldmask)
 {
-        set_cpus_allowed(current, oldmask);
+        set_cpus_allowed_ptr(current, oldmask);
 }
 
 #define SHOW_FIELDS(name)                                           \
@@ -277,15 +277,15 @@ static ssize_t store_interrupt_enable(struct threshold_block *b,
                                       const char *buf, size_t count)
 {
         char *end;
-        cpumask_t oldmask;
+        cpumask_t oldmask, newmask;
         unsigned long new = simple_strtoul(buf, &end, 0);
         if (end == buf)
                 return -EINVAL;
         b->interrupt_enable = !!new;
 
-        oldmask = affinity_set(b->cpu);
+        affinity_set(b->cpu, &oldmask, &newmask);
         threshold_restart_bank(b, 0, 0);
-        affinity_restore(oldmask);
+        affinity_restore(&oldmask);
 
         return end - buf;
 }
@@ -294,7 +294,7 @@ static ssize_t store_threshold_limit(struct threshold_block *b,
                                      const char *buf, size_t count)
 {
         char *end;
-        cpumask_t oldmask;
+        cpumask_t oldmask, newmask;
         u16 old;
         unsigned long new = simple_strtoul(buf, &end, 0);
         if (end == buf)
@@ -306,9 +306,9 @@ static ssize_t store_threshold_limit(struct threshold_block *b,
         old = b->threshold_limit;
         b->threshold_limit = new;
 
-        oldmask = affinity_set(b->cpu);
+        affinity_set(b->cpu, &oldmask, &newmask);
         threshold_restart_bank(b, 0, old);
-        affinity_restore(oldmask);
+        affinity_restore(&oldmask);
 
         return end - buf;
 }
@@ -316,10 +316,10 @@ static ssize_t store_threshold_limit(struct threshold_block *b,
 static ssize_t show_error_count(struct threshold_block *b, char *buf)
 {
         u32 high, low;
-        cpumask_t oldmask;
-        oldmask = affinity_set(b->cpu);
+        cpumask_t oldmask, newmask;
+        affinity_set(b->cpu, &oldmask, &newmask);
         rdmsr(b->address, low, high);
-        affinity_restore(oldmask);
+        affinity_restore(&oldmask);
         return sprintf(buf, "%x\n",
                        (high & 0xFFF) - (THRESHOLD_MAX - b->threshold_limit));
 }
@@ -327,10 +327,10 @@ static ssize_t show_error_count(struct threshold_block *b, char *buf)
 static ssize_t store_error_count(struct threshold_block *b,
                                  const char *buf, size_t count)
 {
-        cpumask_t oldmask;
-        oldmask = affinity_set(b->cpu);
+        cpumask_t oldmask, newmask;
+        affinity_set(b->cpu, &oldmask, &newmask);
         threshold_restart_bank(b, 1, 0);
-        affinity_restore(oldmask);
+        affinity_restore(&oldmask);
         return 1;
 }
 
@@ -468,7 +468,7 @@ static __cpuinit int threshold_create_bank(unsigned int cpu, unsigned int bank)
 {
         int i, err = 0;
         struct threshold_bank *b = NULL;
-        cpumask_t oldmask = CPU_MASK_NONE;
+        cpumask_t oldmask, newmask;
         char name[32];
 
         sprintf(name, "threshold_bank%i", bank);
@@ -519,10 +519,10 @@ static __cpuinit int threshold_create_bank(unsigned int cpu, unsigned int bank)
 
         per_cpu(threshold_banks, cpu)[bank] = b;
 
-        oldmask = affinity_set(cpu);
+        affinity_set(cpu, &oldmask, &newmask);
         err = allocate_threshold_blocks(cpu, bank, 0,
                                         MSR_IA32_MC0_MISC + bank * 4);
-        affinity_restore(oldmask);
+        affinity_restore(&oldmask);
 
         if (err)
                 goto out_free;
diff --git a/arch/x86/kernel/io_apic_64.c b/arch/x86/kernel/io_apic_64.c
index b54464b26658..9ba11d07920f 100644
--- a/arch/x86/kernel/io_apic_64.c
+++ b/arch/x86/kernel/io_apic_64.c
@@ -785,7 +785,7 @@ static void __clear_irq_vector(int irq)
                 per_cpu(vector_irq, cpu)[vector] = -1;
 
         cfg->vector = 0;
-        cfg->domain = CPU_MASK_NONE;
+        cpus_clear(cfg->domain);
 }
 
 void __setup_vector_irq(int cpu)
diff --git a/arch/x86/kernel/microcode.c b/arch/x86/kernel/microcode.c
index 25cf6dee4e56..69729e38b78a 100644
--- a/arch/x86/kernel/microcode.c
+++ b/arch/x86/kernel/microcode.c
@@ -402,7 +402,7 @@ static int do_microcode_update (void)
 
                         if (!uci->valid)
                                 continue;
-                        set_cpus_allowed(current, cpumask_of_cpu(cpu));
+                        set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
                         error = get_maching_microcode(new_mc, cpu);
                         if (error < 0)
                                 goto out;
@@ -416,7 +416,7 @@ out:
                 vfree(new_mc);
         if (cursor < 0)
                 error = cursor;
-        set_cpus_allowed(current, old);
+        set_cpus_allowed_ptr(current, &old);
         return error;
 }
 
@@ -579,7 +579,7 @@ static int apply_microcode_check_cpu(int cpu)
                 return 0;
 
         old = current->cpus_allowed;
-        set_cpus_allowed(current, cpumask_of_cpu(cpu));
+        set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
 
         /* Check if the microcode we have in memory matches the CPU */
         if (c->x86_vendor != X86_VENDOR_INTEL || c->x86 < 6 ||
@@ -610,7 +610,7 @@ static int apply_microcode_check_cpu(int cpu)
                         " sig=0x%x, pf=0x%x, rev=0x%x\n",
                         cpu, uci->sig, uci->pf, uci->rev);
 
-        set_cpus_allowed(current, old);
+        set_cpus_allowed_ptr(current, &old);
         return err;
 }
 
@@ -621,13 +621,13 @@ static void microcode_init_cpu(int cpu, int resume)
 
         old = current->cpus_allowed;
 
-        set_cpus_allowed(current, cpumask_of_cpu(cpu));
+        set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
         mutex_lock(&microcode_mutex);
         collect_cpu_info(cpu);
         if (uci->valid && system_state == SYSTEM_RUNNING && !resume)
                 cpu_request_microcode(cpu);
         mutex_unlock(&microcode_mutex);
-        set_cpus_allowed(current, old);
+        set_cpus_allowed_ptr(current, &old);
 }
 
 static void microcode_fini_cpu(int cpu)
@@ -657,14 +657,14 @@ static ssize_t reload_store(struct sys_device *dev, const char *buf, size_t sz)
                 old = current->cpus_allowed;
 
                 get_online_cpus();
-                set_cpus_allowed(current, cpumask_of_cpu(cpu));
+                set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
 
                 mutex_lock(&microcode_mutex);
                 if (uci->valid)
                         err = cpu_request_microcode(cpu);
                 mutex_unlock(&microcode_mutex);
                 put_online_cpus();
-                set_cpus_allowed(current, old);
+                set_cpus_allowed_ptr(current, &old);
         }
         if (err)
                 return err;
diff --git a/arch/x86/kernel/reboot.c b/arch/x86/kernel/reboot.c
index 9692202d3bfb..19c9386ac118 100644
--- a/arch/x86/kernel/reboot.c
+++ b/arch/x86/kernel/reboot.c
@@ -420,7 +420,7 @@ static void native_machine_shutdown(void)
                 reboot_cpu_id = smp_processor_id();
 
         /* Make certain I only run on the appropriate processor */
-        set_cpus_allowed(current, cpumask_of_cpu(reboot_cpu_id));
+        set_cpus_allowed_ptr(current, &cpumask_of_cpu(reboot_cpu_id));
 
         /* O.K Now that I'm on the appropriate processor,
          * stop all of the others.
diff --git a/arch/x86/kernel/setup.c b/arch/x86/kernel/setup.c
index ed157c90412e..0d1f44ae6eea 100644
--- a/arch/x86/kernel/setup.c
+++ b/arch/x86/kernel/setup.c
@@ -54,6 +54,24 @@ static void __init setup_per_cpu_maps(void)
 #endif
 }
 
+#ifdef CONFIG_HAVE_CPUMASK_OF_CPU_MAP
+cpumask_t *cpumask_of_cpu_map __read_mostly;
+EXPORT_SYMBOL(cpumask_of_cpu_map);
+
+/* requires nr_cpu_ids to be initialized */
+static void __init setup_cpumask_of_cpu(void)
+{
+        int i;
+
+        /* alloc_bootmem zeroes memory */
+        cpumask_of_cpu_map = alloc_bootmem_low(sizeof(cpumask_t) * nr_cpu_ids);
+        for (i = 0; i < nr_cpu_ids; i++)
+                cpu_set(i, cpumask_of_cpu_map[i]);
+}
+#else
+static inline void setup_cpumask_of_cpu(void) { }
+#endif
+
 #ifdef CONFIG_X86_32
 /*
  * Great future not-so-futuristic plan: make i386 and x86_64 do it
@@ -70,7 +88,7 @@ EXPORT_SYMBOL(__per_cpu_offset);
  */
 void __init setup_per_cpu_areas(void)
 {
-        int i;
+        int i, highest_cpu = 0;
         unsigned long size;
 
 #ifdef CONFIG_HOTPLUG_CPU
@@ -104,10 +122,18 @@ void __init setup_per_cpu_areas(void)
                 __per_cpu_offset[i] = ptr - __per_cpu_start;
 #endif
                 memcpy(ptr, __per_cpu_start, __per_cpu_end - __per_cpu_start);
+
+                highest_cpu = i;
         }
 
+        nr_cpu_ids = highest_cpu + 1;
+        printk(KERN_DEBUG "NR_CPUS: %d, nr_cpu_ids: %d\n", NR_CPUS, nr_cpu_ids);
+
         /* Setup percpu data maps */
         setup_per_cpu_maps();
+
+        /* Setup cpumask_of_cpu map */
+        setup_cpumask_of_cpu();
 }
 
 #endif
diff --git a/arch/x86/mm/numa_64.c b/arch/x86/mm/numa_64.c
index cb3170186355..9a6892200b27 100644
--- a/arch/x86/mm/numa_64.c
+++ b/arch/x86/mm/numa_64.c
@@ -386,9 +386,10 @@ static int __init split_nodes_by_size(struct bootnode *nodes, u64 *addr,
  * Sets up the system RAM area from start_pfn to end_pfn according to the
  * numa=fake command-line option.
  */
+static struct bootnode nodes[MAX_NUMNODES] __initdata;
+
 static int __init numa_emulation(unsigned long start_pfn, unsigned long end_pfn)
 {
-        struct bootnode nodes[MAX_NUMNODES];
         u64 size, addr = start_pfn << PAGE_SHIFT;
         u64 max_addr = end_pfn << PAGE_SHIFT;
         int num_nodes = 0, num = 0, coeff_flag, coeff = -1, i;
diff --git a/arch/x86/oprofile/nmi_int.c b/arch/x86/oprofile/nmi_int.c
index 1f11cf0a307f..cc48d3fde545 100644
--- a/arch/x86/oprofile/nmi_int.c
+++ b/arch/x86/oprofile/nmi_int.c
@@ -23,8 +23,8 @@
 #include "op_x86_model.h"
 
 static struct op_x86_model_spec const *model;
-static struct op_msrs cpu_msrs[NR_CPUS];
-static unsigned long saved_lvtpc[NR_CPUS];
+static DEFINE_PER_CPU(struct op_msrs, cpu_msrs);
+static DEFINE_PER_CPU(unsigned long, saved_lvtpc);
 
 static int nmi_start(void);
 static void nmi_stop(void);
@@ -89,7 +89,7 @@ static int profile_exceptions_notify(struct notifier_block *self,
 
         switch (val) {
         case DIE_NMI:
-                if (model->check_ctrs(args->regs, &cpu_msrs[cpu]))
+                if (model->check_ctrs(args->regs, &per_cpu(cpu_msrs, cpu)))
                         ret = NOTIFY_STOP;
                 break;
         default:
@@ -126,7 +126,7 @@ static void nmi_cpu_save_registers(struct op_msrs *msrs)
 static void nmi_save_registers(void *dummy)
 {
         int cpu = smp_processor_id();
-        struct op_msrs *msrs = &cpu_msrs[cpu];
+        struct op_msrs *msrs = &per_cpu(cpu_msrs, cpu);
         nmi_cpu_save_registers(msrs);
 }
 
@@ -134,10 +134,10 @@ static void free_msrs(void)
 {
         int i;
         for_each_possible_cpu(i) {
-                kfree(cpu_msrs[i].counters);
-                cpu_msrs[i].counters = NULL;
-                kfree(cpu_msrs[i].controls);
-                cpu_msrs[i].controls = NULL;
+                kfree(per_cpu(cpu_msrs, i).counters);
+                per_cpu(cpu_msrs, i).counters = NULL;
+                kfree(per_cpu(cpu_msrs, i).controls);
+                per_cpu(cpu_msrs, i).controls = NULL;
         }
 }
 
@@ -149,13 +149,15 @@ static int allocate_msrs(void)
 
         int i;
         for_each_possible_cpu(i) {
-                cpu_msrs[i].counters = kmalloc(counters_size, GFP_KERNEL);
-                if (!cpu_msrs[i].counters) {
+                per_cpu(cpu_msrs, i).counters = kmalloc(counters_size,
+                                                                GFP_KERNEL);
+                if (!per_cpu(cpu_msrs, i).counters) {
                         success = 0;
                         break;
                 }
-                cpu_msrs[i].controls = kmalloc(controls_size, GFP_KERNEL);
-                if (!cpu_msrs[i].controls) {
+                per_cpu(cpu_msrs, i).controls = kmalloc(controls_size,
+                                                                GFP_KERNEL);
+                if (!per_cpu(cpu_msrs, i).controls) {
                         success = 0;
                         break;
                 }
@@ -170,11 +172,11 @@ static int allocate_msrs(void)
 static void nmi_cpu_setup(void *dummy)
 {
         int cpu = smp_processor_id();
-        struct op_msrs *msrs = &cpu_msrs[cpu];
+        struct op_msrs *msrs = &per_cpu(cpu_msrs, cpu);
         spin_lock(&oprofilefs_lock);
         model->setup_ctrs(msrs);
         spin_unlock(&oprofilefs_lock);
-        saved_lvtpc[cpu] = apic_read(APIC_LVTPC);
+        per_cpu(saved_lvtpc, cpu) = apic_read(APIC_LVTPC);
         apic_write(APIC_LVTPC, APIC_DM_NMI);
 }
 
@@ -203,13 +205,15 @@ static int nmi_setup(void)
          */
 
         /* Assume saved/restored counters are the same on all CPUs */
-        model->fill_in_addresses(&cpu_msrs[0]);
+        model->fill_in_addresses(&per_cpu(cpu_msrs, 0));
         for_each_possible_cpu(cpu) {
                 if (cpu != 0) {
-                        memcpy(cpu_msrs[cpu].counters, cpu_msrs[0].counters,
+                        memcpy(per_cpu(cpu_msrs, cpu).counters,
+                                per_cpu(cpu_msrs, 0).counters,
                                 sizeof(struct op_msr) * model->num_counters);
 
-                        memcpy(cpu_msrs[cpu].controls, cpu_msrs[0].controls,
+                        memcpy(per_cpu(cpu_msrs, cpu).controls,
+                                per_cpu(cpu_msrs, 0).controls,
                                 sizeof(struct op_msr) * model->num_controls);
                 }
 
@@ -249,7 +253,7 @@ static void nmi_cpu_shutdown(void *dummy)
 {
         unsigned int v;
         int cpu = smp_processor_id();
-        struct op_msrs *msrs = &cpu_msrs[cpu];
+        struct op_msrs *msrs = &__get_cpu_var(cpu_msrs);
 
         /* restoring APIC_LVTPC can trigger an apic error because the delivery
          * mode and vector nr combination can be illegal. That's by design: on
@@ -258,23 +262,24 @@ static void nmi_cpu_shutdown(void *dummy)
          */
         v = apic_read(APIC_LVTERR);
         apic_write(APIC_LVTERR, v | APIC_LVT_MASKED);
-        apic_write(APIC_LVTPC, saved_lvtpc[cpu]);
+        apic_write(APIC_LVTPC, per_cpu(saved_lvtpc, cpu));
         apic_write(APIC_LVTERR, v);
         nmi_restore_registers(msrs);
 }
 
 static void nmi_shutdown(void)
 {
+        struct op_msrs *msrs = &__get_cpu_var(cpu_msrs);
         nmi_enabled = 0;
         on_each_cpu(nmi_cpu_shutdown, NULL, 0, 1);
         unregister_die_notifier(&profile_exceptions_nb);
-        model->shutdown(cpu_msrs);
+        model->shutdown(msrs);
         free_msrs();
 }
 
 static void nmi_cpu_start(void *dummy)
 {
-        struct op_msrs const *msrs = &cpu_msrs[smp_processor_id()];
+        struct op_msrs const *msrs = &__get_cpu_var(cpu_msrs);
         model->start(msrs);
 }
 
@@ -286,7 +291,7 @@ static int nmi_start(void)
 
 static void nmi_cpu_stop(void *dummy)
 {
-        struct op_msrs const *msrs = &cpu_msrs[smp_processor_id()];
+        struct op_msrs const *msrs = &__get_cpu_var(cpu_msrs);
         model->stop(msrs);
 }
 
diff --git a/drivers/acpi/processor_throttling.c b/drivers/acpi/processor_throttling.c
index 1b8e592a8241..0bba3a914e86 100644
--- a/drivers/acpi/processor_throttling.c
+++ b/drivers/acpi/processor_throttling.c
@@ -838,10 +838,10 @@ static int acpi_processor_get_throttling(struct acpi_processor *pr)
          * Migrate task to the cpu pointed by pr.
          */
         saved_mask = current->cpus_allowed;
-        set_cpus_allowed(current, cpumask_of_cpu(pr->id));
+        set_cpus_allowed_ptr(current, &cpumask_of_cpu(pr->id));
         ret = pr->throttling.acpi_processor_get_throttling(pr);
         /* restore the previous state */
-        set_cpus_allowed(current, saved_mask);
+        set_cpus_allowed_ptr(current, &saved_mask);
 
         return ret;
 }
@@ -1025,7 +1025,7 @@ int acpi_processor_set_throttling(struct acpi_processor *pr, int state)
          * it can be called only for the cpu pointed by pr.
          */
         if (p_throttling->shared_type == DOMAIN_COORD_TYPE_SW_ANY) {
-                set_cpus_allowed(current, cpumask_of_cpu(pr->id));
+                set_cpus_allowed_ptr(current, &cpumask_of_cpu(pr->id));
                 ret = p_throttling->acpi_processor_set_throttling(pr,
                                                 t_state.target_state);
         } else {
@@ -1056,7 +1056,7 @@ int acpi_processor_set_throttling(struct acpi_processor *pr, int state)
                                 continue;
                         }
                         t_state.cpu = i;
-                        set_cpus_allowed(current, cpumask_of_cpu(i));
+                        set_cpus_allowed_ptr(current, &cpumask_of_cpu(i));
                         ret = match_pr->throttling.
                                 acpi_processor_set_throttling(
                                 match_pr, t_state.target_state);
@@ -1074,7 +1074,7 @@ int acpi_processor_set_throttling(struct acpi_processor *pr, int state)
                                                         &t_state);
         }
         /* restore the previous state */
-        set_cpus_allowed(current, saved_mask);
+        set_cpus_allowed_ptr(current, &saved_mask);
         return ret;
 }
 
diff --git a/drivers/base/cpu.c b/drivers/base/cpu.c
index 499b003f9278..2c76afff3b15 100644
--- a/drivers/base/cpu.c
+++ b/drivers/base/cpu.c
@@ -103,6 +103,51 @@ static SYSDEV_ATTR(crash_notes, 0400, show_crash_notes, NULL);
 #endif
 
 /*
+ * Print cpu online, possible, present, and system maps
+ */
+static ssize_t print_cpus_map(char *buf, cpumask_t *map)
+{
+        int n = cpulist_scnprintf(buf, PAGE_SIZE-2, *map);
+
+        buf[n++] = '\n';
+        buf[n] = '\0';
+        return n;
+}
+
+#define print_cpus_func(type) \
+static ssize_t print_cpus_##type(struct sysdev_class *class, char *buf) \
+{                                                                       \
+        return print_cpus_map(buf, &cpu_##type##_map);                  \
+}                                                                       \
+struct sysdev_class_attribute attr_##type##_map =                       \
+        _SYSDEV_CLASS_ATTR(type, 0444, print_cpus_##type, NULL)
+
+print_cpus_func(online);
+print_cpus_func(possible);
+print_cpus_func(present);
+
+struct sysdev_class_attribute *cpu_state_attr[] = {
+        &attr_online_map,
+        &attr_possible_map,
+        &attr_present_map,
+};
+
+static int cpu_states_init(void)
+{
+        int i;
+        int err = 0;
+
+        for (i = 0;  i < ARRAY_SIZE(cpu_state_attr); i++) {
+                int ret;
+                ret = sysdev_class_create_file(&cpu_sysdev_class,
+                                                cpu_state_attr[i]);
+                if (!err)
+                        err = ret;
+        }
+        return err;
+}
+
+/*
  * register_cpu - Setup a sysfs device for a CPU.
  * @cpu - cpu->hotpluggable field set to 1 will generate a control file in
  *        sysfs for this CPU.
@@ -147,6 +192,9 @@ int __init cpu_dev_init(void)
         int err;
 
         err = sysdev_class_register(&cpu_sysdev_class);
+        if (!err)
+                err = cpu_states_init();
+
 #if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
         if (!err)
                 err = sched_create_sysfs_power_savings_entries(&cpu_sysdev_class);
diff --git a/drivers/base/node.c b/drivers/base/node.c
index e59861f18ce5..12fde2d03d69 100644
--- a/drivers/base/node.c
+++ b/drivers/base/node.c
@@ -19,21 +19,34 @@ static struct sysdev_class node_class = {
 };
 
 
-static ssize_t node_read_cpumap(struct sys_device * dev, char * buf)
+static ssize_t node_read_cpumap(struct sys_device *dev, int type, char *buf)
 {
         struct node *node_dev = to_node(dev);
-        cpumask_t mask = node_to_cpumask(node_dev->sysdev.id);
+        node_to_cpumask_ptr(mask, node_dev->sysdev.id);
         int len;
 
-        /* 2004/06/03: buf currently PAGE_SIZE, need > 1 char per 4 bits. */
-        BUILD_BUG_ON(MAX_NUMNODES/4 > PAGE_SIZE/2);
+        /* 2008/04/07: buf currently PAGE_SIZE, need 9 chars per 32 bits. */
+        BUILD_BUG_ON((NR_CPUS/32 * 9) > (PAGE_SIZE-1));
 
-        len = cpumask_scnprintf(buf, PAGE_SIZE-1, mask);
-        len += sprintf(buf + len, "\n");
+        len = type?
+                cpulist_scnprintf(buf, PAGE_SIZE-2, *mask):
+                cpumask_scnprintf(buf, PAGE_SIZE-2, *mask);
+        buf[len++] = '\n';
+        buf[len] = '\0';
         return len;
 }
 
-static SYSDEV_ATTR(cpumap, S_IRUGO, node_read_cpumap, NULL);
+static inline ssize_t node_read_cpumask(struct sys_device *dev, char *buf)
+{
+        return node_read_cpumap(dev, 0, buf);
+}
+static inline ssize_t node_read_cpulist(struct sys_device *dev, char *buf)
+{
+        return node_read_cpumap(dev, 1, buf);
+}
+
+static SYSDEV_ATTR(cpumap,  S_IRUGO, node_read_cpumask, NULL);
+static SYSDEV_ATTR(cpulist, S_IRUGO, node_read_cpulist, NULL);
 
 #define K(x) ((x) << (PAGE_SHIFT - 10))
 static ssize_t node_read_meminfo(struct sys_device * dev, char * buf)
@@ -149,6 +162,7 @@ int register_node(struct node *node, int num, struct node *parent)
 
         if (!error){
                 sysdev_create_file(&node->sysdev, &attr_cpumap);
+                sysdev_create_file(&node->sysdev, &attr_cpulist);
                 sysdev_create_file(&node->sysdev, &attr_meminfo);
                 sysdev_create_file(&node->sysdev, &attr_numastat);
                 sysdev_create_file(&node->sysdev, &attr_distance);
@@ -166,6 +180,7 @@ int register_node(struct node *node, int num, struct node *parent)
 void unregister_node(struct node *node)
 {
         sysdev_remove_file(&node->sysdev, &attr_cpumap);
+        sysdev_remove_file(&node->sysdev, &attr_cpulist);
         sysdev_remove_file(&node->sysdev, &attr_meminfo);
         sysdev_remove_file(&node->sysdev, &attr_numastat);
         sysdev_remove_file(&node->sysdev, &attr_distance);
diff --git a/drivers/base/topology.c b/drivers/base/topology.c
index e1d3ad4db2f0..fdf4044d2e74 100644
--- a/drivers/base/topology.c
+++ b/drivers/base/topology.c
@@ -40,15 +40,38 @@ static ssize_t show_##name(struct sys_device *dev, char *buf)	\
         return sprintf(buf, "%d\n", topology_##name(cpu));      \
 }
 
-#define define_siblings_show_func(name)                                 \
-static ssize_t show_##name(struct sys_device *dev, char *buf)           \
+static ssize_t show_cpumap(int type, cpumask_t *mask, char *buf)
+{
+        ptrdiff_t len = PTR_ALIGN(buf + PAGE_SIZE - 1, PAGE_SIZE) - buf;
+        int n = 0;
+
+        if (len > 1) {
+                n = type?
+                        cpulist_scnprintf(buf, len-2, *mask):
+                        cpumask_scnprintf(buf, len-2, *mask);
+                buf[n++] = '\n';
+                buf[n] = '\0';
+        }
+        return n;
+}
+
+#define define_siblings_show_map(name)                                  \
+static inline ssize_t show_##name(struct sys_device *dev, char *buf)    \
 {                                                                       \
-        ssize_t len = -1;                                               \
         unsigned int cpu = dev->id;                                     \
-        len = cpumask_scnprintf(buf, NR_CPUS+1, topology_##name(cpu));  \
-        return (len + sprintf(buf + len, "\n"));                        \
+        return show_cpumap(0, &(topology_##name(cpu)), buf);            \
 }
 
+#define define_siblings_show_list(name)                                 \
+static inline ssize_t show_##name##_list(struct sys_device *dev, char *buf) \
+{                                                                       \
+        unsigned int cpu = dev->id;                                     \
+        return show_cpumap(1, &(topology_##name(cpu)), buf);            \
+}
+
+#define define_siblings_show_func(name)         \
+        define_siblings_show_map(name); define_siblings_show_list(name)
+
 #ifdef  topology_physical_package_id
 define_id_show_func(physical_package_id);
 define_one_ro(physical_package_id);
@@ -68,7 +91,9 @@ define_one_ro(core_id);
 #ifdef topology_thread_siblings
 define_siblings_show_func(thread_siblings);
 define_one_ro(thread_siblings);
-#define ref_thread_siblings_attr        &attr_thread_siblings.attr,
+define_one_ro(thread_siblings_list);
+#define ref_thread_siblings_attr        \
+                &attr_thread_siblings.attr, &attr_thread_siblings_list.attr,
 #else
 #define ref_thread_siblings_attr
 #endif
@@ -76,7 +101,9 @@ define_one_ro(thread_siblings);
 #ifdef topology_core_siblings
 define_siblings_show_func(core_siblings);
 define_one_ro(core_siblings);
-#define ref_core_siblings_attr          &attr_core_siblings.attr,
+define_one_ro(core_siblings_list);
+#define ref_core_siblings_attr          \
+                &attr_core_siblings.attr, &attr_core_siblings_list.attr,
 #else
 #define ref_core_siblings_attr
 #endif
diff --git a/drivers/firmware/dcdbas.c b/drivers/firmware/dcdbas.c
index 1636806ec55e..0ffef3b7c6ca 100644
--- a/drivers/firmware/dcdbas.c
+++ b/drivers/firmware/dcdbas.c
@@ -265,7 +265,7 @@ static int smi_request(struct smi_cmd *smi_cmd)
 
         /* SMI requires CPU 0 */
         old_mask = current->cpus_allowed;
-        set_cpus_allowed(current, cpumask_of_cpu(0));
+        set_cpus_allowed_ptr(current, &cpumask_of_cpu(0));
         if (smp_processor_id() != 0) {
                 dev_dbg(&dcdbas_pdev->dev, "%s: failed to get CPU 0\n",
                         __FUNCTION__);
@@ -285,7 +285,7 @@ static int smi_request(struct smi_cmd *smi_cmd)
         );
 
 out:
-        set_cpus_allowed(current, old_mask);
+        set_cpus_allowed_ptr(current, &old_mask);
         return ret;
 }
 
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index e571c72e6753..e8d94fafc280 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -182,15 +182,18 @@ static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
         struct mempolicy *oldpol;
         cpumask_t oldmask = current->cpus_allowed;
         int node = pcibus_to_node(dev->bus);
-        if (node >= 0 && node_online(node))
-            set_cpus_allowed(current, node_to_cpumask(node));
+
+        if (node >= 0) {
+                node_to_cpumask_ptr(nodecpumask, node);
+                set_cpus_allowed_ptr(current, nodecpumask);
+        }
         /* And set default memory allocation policy */
         oldpol = current->mempolicy;
         current->mempolicy = NULL;      /* fall back to system default policy */
 #endif
         error = drv->probe(dev, id);
 #ifdef CONFIG_NUMA
-        set_cpus_allowed(current, oldmask);
+        set_cpus_allowed_ptr(current, &oldmask);
         current->mempolicy = oldpol;
 #endif
         return error;
diff --git a/drivers/pci/pci-sysfs.c b/drivers/pci/pci-sysfs.c
index 8dcf1458aa2f..8d9d648daeba 100644
--- a/drivers/pci/pci-sysfs.c
+++ b/drivers/pci/pci-sysfs.c
@@ -73,8 +73,23 @@ static ssize_t local_cpus_show(struct device *dev,
 
         mask = pcibus_to_cpumask(to_pci_dev(dev)->bus);
         len = cpumask_scnprintf(buf, PAGE_SIZE-2, mask);
-        strcat(buf,"\n"); 
-        return 1+len;
+        buf[len++] = '\n';
+        buf[len] = '\0';
+        return len;
+}
+
+
+static ssize_t local_cpulist_show(struct device *dev,
+                        struct device_attribute *attr, char *buf)
+{
+        cpumask_t mask;
+        int len;
+
+        mask = pcibus_to_cpumask(to_pci_dev(dev)->bus);
+        len = cpulist_scnprintf(buf, PAGE_SIZE-2, mask);
+        buf[len++] = '\n';
+        buf[len] = '\0';
+        return len;
 }
 
 /* show resources */
@@ -201,6 +216,7 @@ struct device_attribute pci_dev_attrs[] = {
         __ATTR_RO(class),
         __ATTR_RO(irq),
         __ATTR_RO(local_cpus),
+        __ATTR_RO(local_cpulist),
         __ATTR_RO(modalias),
 #ifdef CONFIG_NUMA
         __ATTR_RO(numa_node),
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index 2db2e4bb0d1e..4b3011a23eff 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -82,6 +82,7 @@ void pci_remove_legacy_files(struct pci_bus *bus) { return; }
  * PCI Bus Class Devices
  */
 static ssize_t pci_bus_show_cpuaffinity(struct device *dev,
+                                        int type,
                                         struct device_attribute *attr,
                                         char *buf)
 {
@@ -89,12 +90,30 @@ static ssize_t pci_bus_show_cpuaffinity(struct device *dev,
         cpumask_t cpumask;
 
         cpumask = pcibus_to_cpumask(to_pci_bus(dev));
-        ret = cpumask_scnprintf(buf, PAGE_SIZE, cpumask);
-        if (ret < PAGE_SIZE)
-                buf[ret++] = '\n';
+        ret = type?
+                cpulist_scnprintf(buf, PAGE_SIZE-2, cpumask):
+                cpumask_scnprintf(buf, PAGE_SIZE-2, cpumask);
+        buf[ret++] = '\n';
+        buf[ret] = '\0';
         return ret;
 }
-DEVICE_ATTR(cpuaffinity, S_IRUGO, pci_bus_show_cpuaffinity, NULL);
+
+static ssize_t inline pci_bus_show_cpumaskaffinity(struct device *dev,
+                                        struct device_attribute *attr,
+                                        char *buf)
+{
+        return pci_bus_show_cpuaffinity(dev, 0, attr, buf);
+}
+
+static ssize_t inline pci_bus_show_cpulistaffinity(struct device *dev,
+                                        struct device_attribute *attr,
+                                        char *buf)
+{
+        return pci_bus_show_cpuaffinity(dev, 1, attr, buf);
+}
+
+DEVICE_ATTR(cpuaffinity,     S_IRUGO, pci_bus_show_cpumaskaffinity, NULL);
+DEVICE_ATTR(cpulistaffinity, S_IRUGO, pci_bus_show_cpulistaffinity, NULL);
 
 /*
  * PCI Bus Class
diff --git a/include/asm-alpha/topology.h b/include/asm-alpha/topology.h
index 420ccde6b916..149532e162c4 100644
--- a/include/asm-alpha/topology.h
+++ b/include/asm-alpha/topology.h
@@ -41,8 +41,7 @@ static inline cpumask_t node_to_cpumask(int node)
 
 #define pcibus_to_cpumask(bus)  (cpu_online_map)
 
-#else /* CONFIG_NUMA */
-# include <asm-generic/topology.h>
 #endif /* !CONFIG_NUMA */
+# include <asm-generic/topology.h>
 
 #endif /* _ASM_ALPHA_TOPOLOGY_H */
diff --git a/include/asm-frv/topology.h b/include/asm-frv/topology.h
index abe7298742ac..942724352705 100644
--- a/include/asm-frv/topology.h
+++ b/include/asm-frv/topology.h
@@ -5,10 +5,8 @@
 
 #error NUMA not supported yet
 
-#else /* !CONFIG_NUMA */
+#endif /* CONFIG_NUMA */
 
 #include <asm-generic/topology.h>
 
-#endif /* CONFIG_NUMA */
-
 #endif /* _ASM_TOPOLOGY_H */
diff --git a/include/asm-generic/topology.h b/include/asm-generic/topology.h
index 342a2a0105c4..a6aea79bca4f 100644
--- a/include/asm-generic/topology.h
+++ b/include/asm-generic/topology.h
@@ -27,6 +27,8 @@
 #ifndef _ASM_GENERIC_TOPOLOGY_H
 #define _ASM_GENERIC_TOPOLOGY_H
 
+#ifndef CONFIG_NUMA
+
 /* Other architectures wishing to use this simple topology API should fill
    in the below functions as appropriate in their own <asm/topology.h> file. */
 #ifndef cpu_to_node
@@ -52,4 +54,16 @@
                                 )
 #endif
 
+#endif  /* CONFIG_NUMA */
+
+/* returns pointer to cpumask for specified node */
+#ifndef node_to_cpumask_ptr
+
+#define node_to_cpumask_ptr(v, node)                                    \
+                cpumask_t _##v = node_to_cpumask(node), *v = &_##v
+
+#define node_to_cpumask_ptr_next(v, node)                               \
+                          _##v = node_to_cpumask(node)
+#endif
+
 #endif /* _ASM_GENERIC_TOPOLOGY_H */
diff --git a/include/asm-ia64/topology.h b/include/asm-ia64/topology.h
index 2d67b72b18d0..f2f72ef2a897 100644
--- a/include/asm-ia64/topology.h
+++ b/include/asm-ia64/topology.h
@@ -93,7 +93,7 @@ void build_cpu_to_node_map(void);
         .cache_nice_tries       = 2,                    \
         .busy_idx               = 3,                    \
         .idle_idx               = 2,                    \
-        .newidle_idx            = 0, /* unused */       \
+        .newidle_idx            = 2,                    \
         .wake_idx               = 1,                    \
         .forkexec_idx           = 1,                    \
         .flags                  = SD_LOAD_BALANCE       \
@@ -116,6 +116,11 @@ void build_cpu_to_node_map(void);
 #define smt_capable()                           (smp_num_siblings > 1)
 #endif
 
+#define pcibus_to_cpumask(bus)  (pcibus_to_node(bus) == -1 ? \
+                                        CPU_MASK_ALL : \
+                                        node_to_cpumask(pcibus_to_node(bus)) \
+                                )
+
 #include <asm-generic/topology.h>
 
 #endif /* _ASM_IA64_TOPOLOGY_H */
diff --git a/include/asm-powerpc/topology.h b/include/asm-powerpc/topology.h
index ca23b681ad05..100c6fbfc587 100644
--- a/include/asm-powerpc/topology.h
+++ b/include/asm-powerpc/topology.h
@@ -96,11 +96,10 @@ static inline void sysfs_remove_device_from_node(struct sys_device *dev,
 {
 }
 
+#endif /* CONFIG_NUMA */
 
 #include <asm-generic/topology.h>
 
-#endif /* CONFIG_NUMA */
-
 #ifdef CONFIG_SMP
 #include <asm/cputable.h>
 #define smt_capable()           (cpu_has_feature(CPU_FTR_SMT))
diff --git a/include/asm-sh/topology.h b/include/asm-sh/topology.h
index f402a3b1cfa4..34cdb28e8f44 100644
--- a/include/asm-sh/topology.h
+++ b/include/asm-sh/topology.h
@@ -16,7 +16,7 @@
         .cache_nice_tries       = 2,                    \
         .busy_idx               = 3,                    \
         .idle_idx               = 2,                    \
-        .newidle_idx            = 0,                    \
+        .newidle_idx            = 2,                    \
         .wake_idx               = 1,                    \
         .forkexec_idx           = 1,                    \
         .flags                  = SD_LOAD_BALANCE       \
diff --git a/include/asm-x86/topology.h b/include/asm-x86/topology.h
index 81a29eb08ac4..22073268b481 100644
--- a/include/asm-x86/topology.h
+++ b/include/asm-x86/topology.h
@@ -88,6 +88,17 @@ static inline int cpu_to_node(int cpu)
 #endif
         return per_cpu(x86_cpu_to_node_map, cpu);
 }
+
+#ifdef  CONFIG_NUMA
+
+/* Returns a pointer to the cpumask of CPUs on Node 'node'. */
+#define node_to_cpumask_ptr(v, node)            \
+                cpumask_t *v = &(node_to_cpumask_map[node])
+
+#define node_to_cpumask_ptr_next(v, node)       \
+                           v = &(node_to_cpumask_map[node])
+#endif
+
 #endif /* CONFIG_X86_64 */
 
 /*
@@ -136,17 +147,13 @@ extern unsigned long node_remap_size[];
 
 # define SD_CACHE_NICE_TRIES    2
 # define SD_IDLE_IDX            2
-# define SD_NEWIDLE_IDX         0
+# define SD_NEWIDLE_IDX         2
 # define SD_FORKEXEC_IDX        1
 
 #endif
 
 /* sched_domains SD_NODE_INIT for NUMAQ machines */
 #define SD_NODE_INIT (struct sched_domain) {            \
-        .span                   = CPU_MASK_NONE,        \
-        .parent                 = NULL,                 \
-        .child                  = NULL,                 \
-        .groups                 = NULL,                 \
         .min_interval           = 8,                    \
         .max_interval           = 32,                   \
         .busy_factor            = 32,                   \
@@ -164,7 +171,6 @@ extern unsigned long node_remap_size[];
                                 | SD_WAKE_BALANCE,      \
         .last_balance           = jiffies,              \
         .balance_interval       = 1,                    \
-        .nr_balance_failed      = 0,                    \
 }
 
 #ifdef CONFIG_X86_64_ACPI_NUMA
@@ -174,10 +180,10 @@ extern int __node_distance(int, int);
 
 #else /* CONFIG_NUMA */
 
-#include <asm-generic/topology.h>
-
 #endif
 
+#include <asm-generic/topology.h>
+
 extern cpumask_t cpu_coregroup_map(int cpu);
 
 #ifdef ENABLE_TOPO_DEFINES
diff --git a/include/linux/bitmap.h b/include/linux/bitmap.h
index acad1105d942..1dbe074f1c64 100644
--- a/include/linux/bitmap.h
+++ b/include/linux/bitmap.h
@@ -108,6 +108,7 @@ extern int __bitmap_weight(const unsigned long *bitmap, int bits);
 
 extern int bitmap_scnprintf(char *buf, unsigned int len,
                         const unsigned long *src, int nbits);
+extern int bitmap_scnprintf_len(unsigned int len);
 extern int __bitmap_parse(const char *buf, unsigned int buflen, int is_user,
                         unsigned long *dst, int nbits);
 extern int bitmap_parse_user(const char __user *ubuf, unsigned int ulen,
diff --git a/include/linux/cpumask.h b/include/linux/cpumask.h
index 7047f58306a7..259c8051155d 100644
--- a/include/linux/cpumask.h
+++ b/include/linux/cpumask.h
@@ -222,8 +222,13 @@ int __next_cpu(int n, const cpumask_t *srcp);
 #define next_cpu(n, src)        ({ (void)(src); 1; })
 #endif
 
+#ifdef CONFIG_HAVE_CPUMASK_OF_CPU_MAP
+extern cpumask_t *cpumask_of_cpu_map;
+#define cpumask_of_cpu(cpu)    (cpumask_of_cpu_map[cpu])
+
+#else
 #define cpumask_of_cpu(cpu)                                             \
-({                                                                      \
+(*({                                                                    \
         typeof(_unused_cpumask_arg_) m;                                 \
         if (sizeof(m) == sizeof(unsigned long)) {                       \
                 m.bits[0] = 1UL<<(cpu);                                 \
@@ -231,8 +236,9 @@ int __next_cpu(int n, const cpumask_t *srcp);
                 cpus_clear(m);                                          \
                 cpu_set((cpu), m);                                      \
         }                                                               \
-        m;                                                              \
-})
+        &m;                                                             \
+}))
+#endif
 
 #define CPU_MASK_LAST_WORD BITMAP_LAST_WORD_MASK(NR_CPUS)
 
@@ -243,6 +249,8 @@ int __next_cpu(int n, const cpumask_t *srcp);
         [BITS_TO_LONGS(NR_CPUS)-1] = CPU_MASK_LAST_WORD                 \
 } }
 
+#define CPU_MASK_ALL_PTR        (&CPU_MASK_ALL)
+
 #else
 
 #define CPU_MASK_ALL                                                    \
@@ -251,6 +259,10 @@ int __next_cpu(int n, const cpumask_t *srcp);
         [BITS_TO_LONGS(NR_CPUS)-1] = CPU_MASK_LAST_WORD                 \
 } }
 
+/* cpu_mask_all is in init/main.c */
+extern cpumask_t cpu_mask_all;
+#define CPU_MASK_ALL_PTR        (&cpu_mask_all)
+
 #endif
 
 #define CPU_MASK_NONE                                                   \
@@ -273,6 +285,13 @@ static inline int __cpumask_scnprintf(char *buf, int len,
         return bitmap_scnprintf(buf, len, srcp->bits, nbits);
 }
 
+#define cpumask_scnprintf_len(len) \
+                        __cpumask_scnprintf_len((len))
+static inline int __cpumask_scnprintf_len(int len)
+{
+        return bitmap_scnprintf_len(len);
+}
+
 #define cpumask_parse_user(ubuf, ulen, dst) \
                         __cpumask_parse_user((ubuf), (ulen), &(dst), NR_CPUS)
 static inline int __cpumask_parse_user(const char __user *buf, int len,
diff --git a/include/linux/cpuset.h b/include/linux/cpuset.h
index 0a26be353cb3..726761e24003 100644
--- a/include/linux/cpuset.h
+++ b/include/linux/cpuset.h
@@ -20,8 +20,8 @@ extern int number_of_cpusets;	/* How many cpusets are defined in system? */
 extern int cpuset_init_early(void);
 extern int cpuset_init(void);
 extern void cpuset_init_smp(void);
-extern cpumask_t cpuset_cpus_allowed(struct task_struct *p);
-extern cpumask_t cpuset_cpus_allowed_locked(struct task_struct *p);
+extern void cpuset_cpus_allowed(struct task_struct *p, cpumask_t *mask);
+extern void cpuset_cpus_allowed_locked(struct task_struct *p, cpumask_t *mask);
 extern nodemask_t cpuset_mems_allowed(struct task_struct *p);
 #define cpuset_current_mems_allowed (current->mems_allowed)
 void cpuset_init_current_mems_allowed(void);
@@ -84,13 +84,14 @@ static inline int cpuset_init_early(void) { return 0; }
 static inline int cpuset_init(void) { return 0; }
 static inline void cpuset_init_smp(void) {}
 
-static inline cpumask_t cpuset_cpus_allowed(struct task_struct *p)
+static inline void cpuset_cpus_allowed(struct task_struct *p, cpumask_t *mask)
 {
-        return cpu_possible_map;
+        *mask = cpu_possible_map;
 }
-static inline cpumask_t cpuset_cpus_allowed_locked(struct task_struct *p)
+static inline void cpuset_cpus_allowed_locked(struct task_struct *p,
+                                                                cpumask_t *mask)
 {
-        return cpu_possible_map;
+        *mask = cpu_possible_map;
 }
 
 static inline nodemask_t cpuset_mems_allowed(struct task_struct *p)
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index 1f74e1d7415f..37a6f5bc4a92 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -151,6 +151,9 @@ extern struct group_info init_groups;
         .cpus_allowed   = CPU_MASK_ALL,                                 \
         .mm             = NULL,                                         \
         .active_mm      = &init_mm,                                     \
+        .se             = {                                             \
+                .group_node     = LIST_HEAD_INIT(tsk.se.group_node),    \
+        },                                                              \
         .rt             = {                                             \
                 .run_list       = LIST_HEAD_INIT(tsk.rt.run_list),      \
                 .time_slice     = HZ,                                   \
diff --git a/include/linux/ktime.h b/include/linux/ktime.h
index 2cd7fa73d1af..ce5983225be4 100644
--- a/include/linux/ktime.h
+++ b/include/linux/ktime.h
@@ -327,4 +327,10 @@ extern void ktime_get_ts(struct timespec *ts);
 /* Get the real (wall-) time in timespec format: */
 #define ktime_get_real_ts(ts)   getnstimeofday(ts)
 
+static inline ktime_t ns_to_ktime(u64 ns)
+{
+        static const ktime_t ktime_zero = { .tv64 = 0 };
+        return ktime_add_ns(ktime_zero, ns);
+}
+
 #endif
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 6a1e7afb099b..be6914014c70 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -704,6 +704,7 @@ enum cpu_idle_type {
 #define SD_POWERSAVINGS_BALANCE 256     /* Balance for power savings */
 #define SD_SHARE_PKG_RESOURCES  512     /* Domain members share cpu pkg resources */
 #define SD_SERIALIZE            1024    /* Only a single load balancing instance */
+#define SD_WAKE_IDLE_FAR        2048    /* Gain latency sacrificing cache hit */
 
 #define BALANCE_FOR_MC_POWER    \
         (sched_smt_power_savings ? SD_POWERSAVINGS_BALANCE : 0)
@@ -733,12 +734,31 @@ struct sched_group {
         u32 reciprocal_cpu_power;
 };
 
+enum sched_domain_level {
+        SD_LV_NONE = 0,
+        SD_LV_SIBLING,
+        SD_LV_MC,
+        SD_LV_CPU,
+        SD_LV_NODE,
+        SD_LV_ALLNODES,
+        SD_LV_MAX
+};
+
+struct sched_domain_attr {
+        int relax_domain_level;
+};
+
+#define SD_ATTR_INIT    (struct sched_domain_attr) {    \
+        .relax_domain_level = -1,                       \
+}
+
 struct sched_domain {
         /* These fields must be setup */
         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 */
+        int first_cpu;                  /* cache of the first cpu 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 */
@@ -750,6 +770,7 @@ struct sched_domain {
         unsigned int wake_idx;
         unsigned int forkexec_idx;
         int flags;                      /* See SD_* */
+        enum sched_domain_level level;
 
         /* Runtime fields. */
         unsigned long last_balance;     /* init to jiffies. units in jiffies */
@@ -789,7 +810,8 @@ struct sched_domain {
 #endif
 };
 
-extern void partition_sched_domains(int ndoms_new, cpumask_t *doms_new);
+extern void partition_sched_domains(int ndoms_new, cpumask_t *doms_new,
+                                    struct sched_domain_attr *dattr_new);
 extern int arch_reinit_sched_domains(void);
 
 #endif  /* CONFIG_SMP */
@@ -889,7 +911,8 @@ struct sched_class {
         void (*set_curr_task) (struct rq *rq);
         void (*task_tick) (struct rq *rq, struct task_struct *p, int queued);
         void (*task_new) (struct rq *rq, struct task_struct *p);
-        void (*set_cpus_allowed)(struct task_struct *p, cpumask_t *newmask);
+        void (*set_cpus_allowed)(struct task_struct *p,
+                                 const cpumask_t *newmask);
 
         void (*join_domain)(struct rq *rq);
         void (*leave_domain)(struct rq *rq);
@@ -923,6 +946,7 @@ struct load_weight {
 struct sched_entity {
         struct load_weight      load;           /* for load-balancing */
         struct rb_node          run_node;
+        struct list_head        group_node;
         unsigned int            on_rq;
 
         u64                     exec_start;
@@ -982,6 +1006,7 @@ struct sched_rt_entity {
         unsigned long timeout;
         int nr_cpus_allowed;
 
+        struct sched_rt_entity *back;
 #ifdef CONFIG_RT_GROUP_SCHED
         struct sched_rt_entity  *parent;
         /* rq on which this entity is (to be) queued: */
@@ -1502,15 +1527,21 @@ static inline void put_task_struct(struct task_struct *t)
 #define used_math() tsk_used_math(current)
 
 #ifdef CONFIG_SMP
-extern int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask);
+extern int set_cpus_allowed_ptr(struct task_struct *p,
+                                const cpumask_t *new_mask);
 #else
-static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
+static inline int set_cpus_allowed_ptr(struct task_struct *p,
+                                       const cpumask_t *new_mask)
 {
-        if (!cpu_isset(0, new_mask))
+        if (!cpu_isset(0, *new_mask))
                 return -EINVAL;
         return 0;
 }
 #endif
+static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
+{
+        return set_cpus_allowed_ptr(p, &new_mask);
+}
 
 extern unsigned long long sched_clock(void);
 
@@ -1551,7 +1582,6 @@ static inline void wake_up_idle_cpu(int cpu) { }
 extern unsigned int sysctl_sched_latency;
 extern unsigned int sysctl_sched_min_granularity;
 extern unsigned int sysctl_sched_wakeup_granularity;
-extern unsigned int sysctl_sched_batch_wakeup_granularity;
 extern unsigned int sysctl_sched_child_runs_first;
 extern unsigned int sysctl_sched_features;
 extern unsigned int sysctl_sched_migration_cost;
@@ -1564,6 +1594,10 @@ int sched_nr_latency_handler(struct ctl_table *table, int write,
 extern unsigned int sysctl_sched_rt_period;
 extern int sysctl_sched_rt_runtime;
 
+int sched_rt_handler(struct ctl_table *table, int write,
+                struct file *filp, void __user *buffer, size_t *lenp,
+                loff_t *ppos);
+
 extern unsigned int sysctl_sched_compat_yield;
 
 #ifdef CONFIG_RT_MUTEXES
@@ -2031,7 +2065,7 @@ static inline void arch_pick_mmap_layout(struct mm_struct *mm)
 }
 #endif
 
-extern long sched_setaffinity(pid_t pid, cpumask_t new_mask);
+extern long sched_setaffinity(pid_t pid, const cpumask_t *new_mask);
 extern long sched_getaffinity(pid_t pid, cpumask_t *mask);
 
 extern int sched_mc_power_savings, sched_smt_power_savings;
@@ -2041,8 +2075,11 @@ extern void normalize_rt_tasks(void);
 #ifdef CONFIG_GROUP_SCHED
 
 extern struct task_group init_task_group;
+#ifdef CONFIG_USER_SCHED
+extern struct task_group root_task_group;
+#endif
 
-extern struct task_group *sched_create_group(void);
+extern struct task_group *sched_create_group(struct task_group *parent);
 extern void sched_destroy_group(struct task_group *tg);
 extern void sched_move_task(struct task_struct *tsk);
 #ifdef CONFIG_FAIR_GROUP_SCHED
@@ -2053,6 +2090,9 @@ extern unsigned long sched_group_shares(struct task_group *tg);
 extern int sched_group_set_rt_runtime(struct task_group *tg,
                                       long rt_runtime_us);
 extern long sched_group_rt_runtime(struct task_group *tg);
+extern int sched_group_set_rt_period(struct task_group *tg,
+                                      long rt_period_us);
+extern long sched_group_rt_period(struct task_group *tg);
 #endif
 #endif
 
diff --git a/include/linux/sysdev.h b/include/linux/sysdev.h
index f752e73bf977..f2767bc6b735 100644
--- a/include/linux/sysdev.h
+++ b/include/linux/sysdev.h
@@ -45,12 +45,16 @@ struct sysdev_class_attribute {
         ssize_t (*store)(struct sysdev_class *, const char *, size_t);
 };
 
-#define SYSDEV_CLASS_ATTR(_name,_mode,_show,_store)             \
-struct sysdev_class_attribute attr_##_name = {                  \
+#define _SYSDEV_CLASS_ATTR(_name,_mode,_show,_store)            \
+{                                                               \
         .attr = {.name = __stringify(_name), .mode = _mode },   \
         .show   = _show,                                        \
         .store  = _store,                                       \
-};
+}
+
+#define SYSDEV_CLASS_ATTR(_name,_mode,_show,_store)             \
+        struct sysdev_class_attribute attr_##_name =            \
+                _SYSDEV_CLASS_ATTR(_name,_mode,_show,_store)
 
 
 extern int sysdev_class_register(struct sysdev_class *);
@@ -100,15 +104,16 @@ struct sysdev_attribute {
 };
 
 
-#define _SYSDEV_ATTR(_name,_mode,_show,_store)                  \
+#define _SYSDEV_ATTR(_name, _mode, _show, _store)               \
 {                                                               \
         .attr = { .name = __stringify(_name), .mode = _mode },  \
         .show   = _show,                                        \
         .store  = _store,                                       \
 }
 
-#define SYSDEV_ATTR(_name,_mode,_show,_store)           \
-struct sysdev_attribute attr_##_name = _SYSDEV_ATTR(_name,_mode,_show,_store);
+#define SYSDEV_ATTR(_name, _mode, _show, _store)                \
+        struct sysdev_attribute attr_##_name =                  \
+                _SYSDEV_ATTR(_name, _mode, _show, _store);
 
 extern int sysdev_create_file(struct sys_device *, struct sysdev_attribute *);
 extern void sysdev_remove_file(struct sys_device *, struct sysdev_attribute *);
diff --git a/include/linux/topology.h b/include/linux/topology.h
index bd14f8b30f09..4bb7074a2c3a 100644
--- a/include/linux/topology.h
+++ b/include/linux/topology.h
@@ -38,16 +38,15 @@
 #endif
 
 #ifndef nr_cpus_node
-#define nr_cpus_node(node)                                                      \
-        ({                                                                      \
-                cpumask_t __tmp__;                                              \
-                __tmp__ = node_to_cpumask(node);                                \
-                cpus_weight(__tmp__);                                           \
+#define nr_cpus_node(node)                              \
+        ({                                              \
+                node_to_cpumask_ptr(__tmp__, node);     \
+                cpus_weight(*__tmp__);                  \
         })
 #endif
 
-#define for_each_node_with_cpus(node)                                           \
-        for_each_online_node(node)                                              \
+#define for_each_node_with_cpus(node)                   \
+        for_each_online_node(node)                      \
                 if (nr_cpus_node(node))
 
 void arch_update_cpu_topology(void);
@@ -80,7 +79,9 @@ void arch_update_cpu_topology(void);
  * by defining their own arch-specific initializer in include/asm/topology.h.
  * A definition there will automagically override these default initializers
  * and allow arch-specific performance tuning of sched_domains.
+ * (Only non-zero and non-null fields need be specified.)
  */
+
 #ifdef CONFIG_SCHED_SMT
 /* MCD - Do we really need this?  It is always on if CONFIG_SCHED_SMT is,
  * so can't we drop this in favor of CONFIG_SCHED_SMT?
@@ -89,20 +90,10 @@ void arch_update_cpu_topology(void);
 /* Common values for SMT siblings */
 #ifndef SD_SIBLING_INIT
 #define SD_SIBLING_INIT (struct sched_domain) {         \
-        .span                   = CPU_MASK_NONE,        \
-        .parent                 = NULL,                 \
-        .child                  = NULL,                 \
-        .groups                 = NULL,                 \
         .min_interval           = 1,                    \
         .max_interval           = 2,                    \
         .busy_factor            = 64,                   \
         .imbalance_pct          = 110,                  \
-        .cache_nice_tries       = 0,                    \
-        .busy_idx               = 0,                    \
-        .idle_idx               = 0,                    \
-        .newidle_idx            = 0,                    \
-        .wake_idx               = 0,                    \
-        .forkexec_idx           = 0,                    \
         .flags                  = SD_LOAD_BALANCE       \
                                 | SD_BALANCE_NEWIDLE    \
                                 | SD_BALANCE_FORK       \
@@ -112,7 +103,6 @@ void arch_update_cpu_topology(void);
                                 | SD_SHARE_CPUPOWER,    \
         .last_balance           = jiffies,              \
         .balance_interval       = 1,                    \
-        .nr_balance_failed      = 0,                    \
 }
 #endif
 #endif /* CONFIG_SCHED_SMT */
@@ -121,18 +111,12 @@ void arch_update_cpu_topology(void);
 /* Common values for MC siblings. for now mostly derived from SD_CPU_INIT */
 #ifndef SD_MC_INIT
 #define SD_MC_INIT (struct sched_domain) {              \
-        .span                   = CPU_MASK_NONE,        \
-        .parent                 = NULL,                 \
-        .child                  = NULL,                 \
-        .groups                 = NULL,                 \
         .min_interval           = 1,                    \
         .max_interval           = 4,                    \
         .busy_factor            = 64,                   \
         .imbalance_pct          = 125,                  \
         .cache_nice_tries       = 1,                    \
         .busy_idx               = 2,                    \
-        .idle_idx               = 0,                    \
-        .newidle_idx            = 0,                    \
         .wake_idx               = 1,                    \
         .forkexec_idx           = 1,                    \
         .flags                  = SD_LOAD_BALANCE       \
@@ -144,7 +128,6 @@ void arch_update_cpu_topology(void);
                                 | BALANCE_FOR_MC_POWER, \
         .last_balance           = jiffies,              \
         .balance_interval       = 1,                    \
-        .nr_balance_failed      = 0,                    \
 }
 #endif
 #endif /* CONFIG_SCHED_MC */
@@ -152,10 +135,6 @@ void arch_update_cpu_topology(void);
 /* Common values for CPUs */
 #ifndef SD_CPU_INIT
 #define SD_CPU_INIT (struct sched_domain) {             \
-        .span                   = CPU_MASK_NONE,        \
-        .parent                 = NULL,                 \
-        .child                  = NULL,                 \
-        .groups                 = NULL,                 \
         .min_interval           = 1,                    \
         .max_interval           = 4,                    \
         .busy_factor            = 64,                   \
@@ -174,16 +153,11 @@ void arch_update_cpu_topology(void);
                                 | BALANCE_FOR_PKG_POWER,\
         .last_balance           = jiffies,              \
         .balance_interval       = 1,                    \
-        .nr_balance_failed      = 0,                    \
 }
 #endif
 
 /* sched_domains SD_ALLNODES_INIT for NUMA machines */
 #define SD_ALLNODES_INIT (struct sched_domain) {        \
-        .span                   = CPU_MASK_NONE,        \
-        .parent                 = NULL,                 \
-        .child                  = NULL,                 \
-        .groups                 = NULL,                 \
         .min_interval           = 64,                   \
         .max_interval           = 64*num_online_cpus(), \
         .busy_factor            = 128,                  \
@@ -191,14 +165,10 @@ void arch_update_cpu_topology(void);
         .cache_nice_tries       = 1,                    \
         .busy_idx               = 3,                    \
         .idle_idx               = 3,                    \
-        .newidle_idx            = 0, /* unused */       \
-        .wake_idx               = 0, /* unused */       \
-        .forkexec_idx           = 0, /* unused */       \
         .flags                  = SD_LOAD_BALANCE       \
                                 | SD_SERIALIZE, \
         .last_balance           = jiffies,              \
         .balance_interval       = 64,                   \
-        .nr_balance_failed      = 0,                    \
 }
 
 #ifdef CONFIG_NUMA
diff --git a/init/Kconfig b/init/Kconfig
index 7fccf09bb95a..ba3a389fab94 100644
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -328,6 +328,13 @@ config RT_GROUP_SCHED
         depends on EXPERIMENTAL
         depends on GROUP_SCHED
         default n
+        help
+          This feature lets you explicitly allocate real CPU bandwidth
+          to users or control groups (depending on the "Basis for grouping tasks"
+          setting below. If enabled, it will also make it impossible to
+          schedule realtime tasks for non-root users until you allocate
+          realtime bandwidth for them.
+          See Documentation/sched-rt-group.txt for more information.
 
 choice
         depends on GROUP_SCHED
diff --git a/init/main.c b/init/main.c
index 99ce94930b09..833a67df1f7e 100644
--- a/init/main.c
+++ b/init/main.c
@@ -359,10 +359,31 @@ static void __init smp_init(void)
 #endif
 
 static inline void setup_per_cpu_areas(void) { }
+static inline void setup_nr_cpu_ids(void) { }
 static inline void smp_prepare_cpus(unsigned int maxcpus) { }
 
 #else
 
+#if NR_CPUS > BITS_PER_LONG
+cpumask_t cpu_mask_all __read_mostly = CPU_MASK_ALL;
+EXPORT_SYMBOL(cpu_mask_all);
+#endif
+
+/* Setup number of possible processor ids */
+int nr_cpu_ids __read_mostly = NR_CPUS;
+EXPORT_SYMBOL(nr_cpu_ids);
+
+/* An arch may set nr_cpu_ids earlier if needed, so this would be redundant */
+static void __init setup_nr_cpu_ids(void)
+{
+        int cpu, highest_cpu = 0;
+
+        for_each_possible_cpu(cpu)
+                highest_cpu = cpu;
+
+        nr_cpu_ids = highest_cpu + 1;
+}
+
 #ifndef CONFIG_HAVE_SETUP_PER_CPU_AREA
 unsigned long __per_cpu_offset[NR_CPUS] __read_mostly;
 
@@ -537,6 +558,7 @@ asmlinkage void __init start_kernel(void)
         setup_command_line(command_line);
         unwind_setup();
         setup_per_cpu_areas();
+        setup_nr_cpu_ids();
         smp_prepare_boot_cpu(); /* arch-specific boot-cpu hooks */
 
         /*
@@ -811,7 +833,7 @@ static int __init kernel_init(void * unused)
         /*
          * init can run on any cpu.
          */
-        set_cpus_allowed(current, CPU_MASK_ALL);
+        set_cpus_allowed_ptr(current, CPU_MASK_ALL_PTR);
         /*
          * Tell the world that we're going to be the grim
          * reaper of innocent orphaned children.
diff --git a/kernel/compat.c b/kernel/compat.c
index 9c48abfcd4a5..e1ef04870c2a 100644
--- a/kernel/compat.c
+++ b/kernel/compat.c
@@ -445,7 +445,7 @@ asmlinkage long compat_sys_sched_setaffinity(compat_pid_t pid,
         if (retval)
                 return retval;
 
-        return sched_setaffinity(pid, new_mask);
+        return sched_setaffinity(pid, &new_mask);
 }
 
 asmlinkage long compat_sys_sched_getaffinity(compat_pid_t pid, unsigned int len,
diff --git a/kernel/cpu.c b/kernel/cpu.c
index 2eff3f63abed..2011ad8d2697 100644
--- a/kernel/cpu.c
+++ b/kernel/cpu.c
@@ -232,9 +232,9 @@ static int _cpu_down(unsigned int cpu, int tasks_frozen)
 
         /* Ensure that we are not runnable on dying cpu */
         old_allowed = current->cpus_allowed;
-        tmp = CPU_MASK_ALL;
+        cpus_setall(tmp);
         cpu_clear(cpu, tmp);
-        set_cpus_allowed(current, tmp);
+        set_cpus_allowed_ptr(current, &tmp);
 
         p = __stop_machine_run(take_cpu_down, &tcd_param, cpu);
 
@@ -268,7 +268,7 @@ static int _cpu_down(unsigned int cpu, int tasks_frozen)
 out_thread:
         err = kthread_stop(p);
 out_allowed:
-        set_cpus_allowed(current, old_allowed);
+        set_cpus_allowed_ptr(current, &old_allowed);
 out_release:
         cpu_hotplug_done();
         return err;
diff --git a/kernel/cpuset.c b/kernel/cpuset.c
index a1b61f414228..8b35fbd8292f 100644
--- a/kernel/cpuset.c
+++ b/kernel/cpuset.c
@@ -98,6 +98,9 @@ struct cpuset {
         /* partition number for rebuild_sched_domains() */
         int pn;
 
+        /* for custom sched domain */
+        int relax_domain_level;
+
         /* used for walking a cpuset heirarchy */
         struct list_head stack_list;
 };
@@ -478,6 +481,16 @@ static int cpusets_overlap(struct cpuset *a, struct cpuset *b)
         return cpus_intersects(a->cpus_allowed, b->cpus_allowed);
 }
 
+static void
+update_domain_attr(struct sched_domain_attr *dattr, struct cpuset *c)
+{
+        if (!dattr)
+                return;
+        if (dattr->relax_domain_level < c->relax_domain_level)
+                dattr->relax_domain_level = c->relax_domain_level;
+        return;
+}
+
 /*
  * rebuild_sched_domains()
  *
@@ -553,12 +566,14 @@ static void rebuild_sched_domains(void)
         int csn;                /* how many cpuset ptrs in csa so far */
         int i, j, k;            /* indices for partition finding loops */
         cpumask_t *doms;        /* resulting partition; i.e. sched domains */
+        struct sched_domain_attr *dattr;  /* attributes for custom domains */
         int ndoms;              /* number of sched domains in result */
         int nslot;              /* next empty doms[] cpumask_t slot */
 
         q = NULL;
         csa = NULL;
         doms = NULL;
+        dattr = NULL;
 
         /* Special case for the 99% of systems with one, full, sched domain */
         if (is_sched_load_balance(&top_cpuset)) {
@@ -566,6 +581,11 @@ static void rebuild_sched_domains(void)
                 doms = kmalloc(sizeof(cpumask_t), GFP_KERNEL);
                 if (!doms)
                         goto rebuild;
+                dattr = kmalloc(sizeof(struct sched_domain_attr), GFP_KERNEL);
+                if (dattr) {
+                        *dattr = SD_ATTR_INIT;
+                        update_domain_attr(dattr, &top_cpuset);
+                }
                 *doms = top_cpuset.cpus_allowed;
                 goto rebuild;
         }
@@ -622,6 +642,7 @@ restart:
         doms = kmalloc(ndoms * sizeof(cpumask_t), GFP_KERNEL);
         if (!doms)
                 goto rebuild;
+        dattr = kmalloc(ndoms * sizeof(struct sched_domain_attr), GFP_KERNEL);
 
         for (nslot = 0, i = 0; i < csn; i++) {
                 struct cpuset *a = csa[i];
@@ -644,12 +665,15 @@ restart:
                         }
 
                         cpus_clear(*dp);
+                        if (dattr)
+                                *(dattr + nslot) = SD_ATTR_INIT;
                         for (j = i; j < csn; j++) {
                                 struct cpuset *b = csa[j];
 
                                 if (apn == b->pn) {
                                         cpus_or(*dp, *dp, b->cpus_allowed);
                                         b->pn = -1;
+                                        update_domain_attr(dattr, b);
                                 }
                         }
                         nslot++;
@@ -660,7 +684,7 @@ restart:
 rebuild:
         /* Have scheduler rebuild sched domains */
         get_online_cpus();
-        partition_sched_domains(ndoms, doms);
+        partition_sched_domains(ndoms, doms, dattr);
         put_online_cpus();
 
 done:
@@ -668,6 +692,7 @@ done:
                 kfifo_free(q);
         kfree(csa);
         /* Don't kfree(doms) -- partition_sched_domains() does that. */
+        /* Don't kfree(dattr) -- partition_sched_domains() does that. */
 }
 
 static inline int started_after_time(struct task_struct *t1,
@@ -729,7 +754,7 @@ int cpuset_test_cpumask(struct task_struct *tsk, struct cgroup_scanner *scan)
  */
 void cpuset_change_cpumask(struct task_struct *tsk, struct cgroup_scanner *scan)
 {
-        set_cpus_allowed(tsk, (cgroup_cs(scan->cg))->cpus_allowed);
+        set_cpus_allowed_ptr(tsk, &((cgroup_cs(scan->cg))->cpus_allowed));
 }
 
 /**
@@ -1011,6 +1036,21 @@ static int update_memory_pressure_enabled(struct cpuset *cs, char *buf)
         return 0;
 }
 
+static int update_relax_domain_level(struct cpuset *cs, char *buf)
+{
+        int val = simple_strtol(buf, NULL, 10);
+
+        if (val < 0)
+                val = -1;
+
+        if (val != cs->relax_domain_level) {
+                cs->relax_domain_level = val;
+                rebuild_sched_domains();
+        }
+
+        return 0;
+}
+
 /*
  * update_flag - read a 0 or a 1 in a file and update associated flag
  * bit: the bit to update (CS_CPU_EXCLUSIVE, CS_MEM_EXCLUSIVE,
@@ -1178,7 +1218,7 @@ static void cpuset_attach(struct cgroup_subsys *ss,
 
         mutex_lock(&callback_mutex);
         guarantee_online_cpus(cs, &cpus);
-        set_cpus_allowed(tsk, cpus);
+        set_cpus_allowed_ptr(tsk, &cpus);
         mutex_unlock(&callback_mutex);
 
         from = oldcs->mems_allowed;
@@ -1202,6 +1242,7 @@ typedef enum {
         FILE_CPU_EXCLUSIVE,
         FILE_MEM_EXCLUSIVE,
         FILE_SCHED_LOAD_BALANCE,
+        FILE_SCHED_RELAX_DOMAIN_LEVEL,
         FILE_MEMORY_PRESSURE_ENABLED,
         FILE_MEMORY_PRESSURE,
         FILE_SPREAD_PAGE,
@@ -1256,6 +1297,9 @@ static ssize_t cpuset_common_file_write(struct cgroup *cont,
         case FILE_SCHED_LOAD_BALANCE:
                 retval = update_flag(CS_SCHED_LOAD_BALANCE, cs, buffer);
                 break;
+        case FILE_SCHED_RELAX_DOMAIN_LEVEL:
+                retval = update_relax_domain_level(cs, buffer);
+                break;
         case FILE_MEMORY_MIGRATE:
                 retval = update_flag(CS_MEMORY_MIGRATE, cs, buffer);
                 break;
@@ -1354,6 +1398,9 @@ static ssize_t cpuset_common_file_read(struct cgroup *cont,
         case FILE_SCHED_LOAD_BALANCE:
                 *s++ = is_sched_load_balance(cs) ? '1' : '0';
                 break;
+        case FILE_SCHED_RELAX_DOMAIN_LEVEL:
+                s += sprintf(s, "%d", cs->relax_domain_level);
+                break;
         case FILE_MEMORY_MIGRATE:
                 *s++ = is_memory_migrate(cs) ? '1' : '0';
                 break;
@@ -1424,6 +1471,13 @@ static struct cftype cft_sched_load_balance = {
         .private = FILE_SCHED_LOAD_BALANCE,
 };
 
+static struct cftype cft_sched_relax_domain_level = {
+        .name = "sched_relax_domain_level",
+        .read = cpuset_common_file_read,
+        .write = cpuset_common_file_write,
+        .private = FILE_SCHED_RELAX_DOMAIN_LEVEL,
+};
+
 static struct cftype cft_memory_migrate = {
         .name = "memory_migrate",
         .read = cpuset_common_file_read,
@@ -1475,6 +1529,9 @@ static int cpuset_populate(struct cgroup_subsys *ss, struct cgroup *cont)
                 return err;
         if ((err = cgroup_add_file(cont, ss, &cft_sched_load_balance)) < 0)
                 return err;
+        if ((err = cgroup_add_file(cont, ss,
+                                        &cft_sched_relax_domain_level)) < 0)
+                return err;
         if ((err = cgroup_add_file(cont, ss, &cft_memory_pressure)) < 0)
                 return err;
         if ((err = cgroup_add_file(cont, ss, &cft_spread_page)) < 0)
@@ -1555,10 +1612,11 @@ static struct cgroup_subsys_state *cpuset_create(
         if (is_spread_slab(parent))
                 set_bit(CS_SPREAD_SLAB, &cs->flags);
         set_bit(CS_SCHED_LOAD_BALANCE, &cs->flags);
-        cs->cpus_allowed = CPU_MASK_NONE;
-        cs->mems_allowed = NODE_MASK_NONE;
+        cpus_clear(cs->cpus_allowed);
+        nodes_clear(cs->mems_allowed);
         cs->mems_generation = cpuset_mems_generation++;
         fmeter_init(&cs->fmeter);
+        cs->relax_domain_level = -1;
 
         cs->parent = parent;
         number_of_cpusets++;
@@ -1625,12 +1683,13 @@ int __init cpuset_init(void)
 {
         int err = 0;
 
-        top_cpuset.cpus_allowed = CPU_MASK_ALL;
-        top_cpuset.mems_allowed = NODE_MASK_ALL;
+        cpus_setall(top_cpuset.cpus_allowed);
+        nodes_setall(top_cpuset.mems_allowed);
 
         fmeter_init(&top_cpuset.fmeter);
         top_cpuset.mems_generation = cpuset_mems_generation++;
         set_bit(CS_SCHED_LOAD_BALANCE, &top_cpuset.flags);
+        top_cpuset.relax_domain_level = -1;
 
         err = register_filesystem(&cpuset_fs_type);
         if (err < 0)
@@ -1844,6 +1903,7 @@ void __init cpuset_init_smp(void)
 
  * cpuset_cpus_allowed - return cpus_allowed mask from a tasks cpuset.
  * @tsk: pointer to task_struct from which to obtain cpuset->cpus_allowed.
+ * @pmask: pointer to cpumask_t variable to receive cpus_allowed set.
  *
  * Description: Returns the cpumask_t cpus_allowed of the cpuset
  * attached to the specified @tsk.  Guaranteed to return some non-empty
@@ -1851,35 +1911,27 @@ void __init cpuset_init_smp(void)
  * tasks cpuset.
  **/
 
-cpumask_t cpuset_cpus_allowed(struct task_struct *tsk)
+void cpuset_cpus_allowed(struct task_struct *tsk, cpumask_t *pmask)
 {
-        cpumask_t mask;
-
         mutex_lock(&callback_mutex);
-        mask = cpuset_cpus_allowed_locked(tsk);
+        cpuset_cpus_allowed_locked(tsk, pmask);
         mutex_unlock(&callback_mutex);
-
-        return mask;
 }
 
 /**
  * cpuset_cpus_allowed_locked - return cpus_allowed mask from a tasks cpuset.
  * Must be called with callback_mutex held.
  **/
-cpumask_t cpuset_cpus_allowed_locked(struct task_struct *tsk)
+void cpuset_cpus_allowed_locked(struct task_struct *tsk, cpumask_t *pmask)
 {
-        cpumask_t mask;
-
         task_lock(tsk);
-        guarantee_online_cpus(task_cs(tsk), &mask);
+        guarantee_online_cpus(task_cs(tsk), pmask);
         task_unlock(tsk);
-
-        return mask;
 }
 
 void cpuset_init_current_mems_allowed(void)
 {
-        current->mems_allowed = NODE_MASK_ALL;
+        nodes_setall(current->mems_allowed);
 }
 
 /**
@@ -2261,8 +2313,16 @@ void cpuset_task_status_allowed(struct seq_file *m, struct task_struct *task)
         m->count += cpumask_scnprintf(m->buf + m->count, m->size - m->count,
                                         task->cpus_allowed);
         seq_printf(m, "\n");
+        seq_printf(m, "Cpus_allowed_list:\t");
+        m->count += cpulist_scnprintf(m->buf + m->count, m->size - m->count,
+                                        task->cpus_allowed);
+        seq_printf(m, "\n");
         seq_printf(m, "Mems_allowed:\t");
         m->count += nodemask_scnprintf(m->buf + m->count, m->size - m->count,
                                         task->mems_allowed);
         seq_printf(m, "\n");
+        seq_printf(m, "Mems_allowed_list:\t");
+        m->count += nodelist_scnprintf(m->buf + m->count, m->size - m->count,
+                                        task->mems_allowed);
+        seq_printf(m, "\n");
 }
diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
index fdb3fbe2b0c4..964964baefa2 100644
--- a/kernel/irq/chip.c
+++ b/kernel/irq/chip.c
@@ -47,7 +47,7 @@ void dynamic_irq_init(unsigned int irq)
         desc->irq_count = 0;
         desc->irqs_unhandled = 0;
 #ifdef CONFIG_SMP
-        desc->affinity = CPU_MASK_ALL;
+        cpus_setall(desc->affinity);
 #endif
         spin_unlock_irqrestore(&desc->lock, flags);
 }
diff --git a/kernel/kmod.c b/kernel/kmod.c
index 22be3ff3f363..e2764047ec03 100644
--- a/kernel/kmod.c
+++ b/kernel/kmod.c
@@ -165,7 +165,7 @@ static int ____call_usermodehelper(void *data)
         }
 
         /* We can run anywhere, unlike our parent keventd(). */
-        set_cpus_allowed(current, CPU_MASK_ALL);
+        set_cpus_allowed_ptr(current, CPU_MASK_ALL_PTR);
 
         /*
          * Our parent is keventd, which runs with elevated scheduling priority.
diff --git a/kernel/kthread.c b/kernel/kthread.c
index 0ac887882f90..25241d6ec8cd 100644
--- a/kernel/kthread.c
+++ b/kernel/kthread.c
@@ -180,6 +180,7 @@ void kthread_bind(struct task_struct *k, unsigned int cpu)
         wait_task_inactive(k);
         set_task_cpu(k, cpu);
         k->cpus_allowed = cpumask_of_cpu(cpu);
+        k->rt.nr_cpus_allowed = 1;
 }
 EXPORT_SYMBOL(kthread_bind);
 
diff --git a/kernel/latencytop.c b/kernel/latencytop.c
index b4e3c85abe74..7c74dab0d21b 100644
--- a/kernel/latencytop.c
+++ b/kernel/latencytop.c
@@ -64,8 +64,8 @@ account_global_scheduler_latency(struct task_struct *tsk, struct latency_record
                 return;
 
         for (i = 0; i < MAXLR; i++) {
-                int q;
-                int same = 1;
+                int q, same = 1;
+
                 /* Nothing stored: */
                 if (!latency_record[i].backtrace[0]) {
                         if (firstnonnull > i)
@@ -73,12 +73,15 @@ account_global_scheduler_latency(struct task_struct *tsk, struct latency_record
                         continue;
                 }
                 for (q = 0 ; q < LT_BACKTRACEDEPTH ; q++) {
-                        if (latency_record[i].backtrace[q] !=
-                                lat->backtrace[q])
+                        unsigned long record = lat->backtrace[q];
+
+                        if (latency_record[i].backtrace[q] != record) {
                                 same = 0;
-                        if (same && lat->backtrace[q] == 0)
                                 break;
-                        if (same && lat->backtrace[q] == ULONG_MAX)
+                        }
+
+                        /* 0 and ULONG_MAX entries mean end of backtrace: */
+                        if (record == 0 || record == ULONG_MAX)
                                 break;
                 }
                 if (same) {
@@ -143,14 +146,18 @@ account_scheduler_latency(struct task_struct *tsk, int usecs, int inter)
         for (i = 0; i < LT_SAVECOUNT ; i++) {
                 struct latency_record *mylat;
                 int same = 1;
+
                 mylat = &tsk->latency_record[i];
                 for (q = 0 ; q < LT_BACKTRACEDEPTH ; q++) {
-                        if (mylat->backtrace[q] !=
-                                lat.backtrace[q])
+                        unsigned long record = lat.backtrace[q];
+
+                        if (mylat->backtrace[q] != record) {
                                 same = 0;
-                        if (same && lat.backtrace[q] == 0)
                                 break;
-                        if (same && lat.backtrace[q] == ULONG_MAX)
+                        }
+
+                        /* 0 and ULONG_MAX entries mean end of backtrace: */
+                        if (record == 0 || record == ULONG_MAX)
                                 break;
                 }
                 if (same) {
diff --git a/kernel/rcupreempt.c b/kernel/rcupreempt.c
index e9517014b57c..e1cdf196a515 100644
--- a/kernel/rcupreempt.c
+++ b/kernel/rcupreempt.c
@@ -1007,10 +1007,10 @@ void __synchronize_sched(void)
         if (sched_getaffinity(0, &oldmask) < 0)
                 oldmask = cpu_possible_map;
         for_each_online_cpu(cpu) {
-                sched_setaffinity(0, cpumask_of_cpu(cpu));
+                sched_setaffinity(0, &cpumask_of_cpu(cpu));
                 schedule();
         }
-        sched_setaffinity(0, oldmask);
+        sched_setaffinity(0, &oldmask);
 }
 EXPORT_SYMBOL_GPL(__synchronize_sched);
 
diff --git a/kernel/rcutorture.c b/kernel/rcutorture.c
index fd599829e72a..47894f919d4e 100644
--- a/kernel/rcutorture.c
+++ b/kernel/rcutorture.c
@@ -723,9 +723,10 @@ static int rcu_idle_cpu;	/* Force all torture tasks off this CPU */
  */
 static void rcu_torture_shuffle_tasks(void)
 {
-        cpumask_t tmp_mask = CPU_MASK_ALL;
+        cpumask_t tmp_mask;
         int i;
 
+        cpus_setall(tmp_mask);
         get_online_cpus();
 
         /* No point in shuffling if there is only one online CPU (ex: UP) */
@@ -737,25 +738,27 @@ static void rcu_torture_shuffle_tasks(void)
         if (rcu_idle_cpu != -1)
                 cpu_clear(rcu_idle_cpu, tmp_mask);
 
-        set_cpus_allowed(current, tmp_mask);
+        set_cpus_allowed_ptr(current, &tmp_mask);
 
         if (reader_tasks) {
                 for (i = 0; i < nrealreaders; i++)
                         if (reader_tasks[i])
-                                set_cpus_allowed(reader_tasks[i], tmp_mask);
+                                set_cpus_allowed_ptr(reader_tasks[i],
+                                                     &tmp_mask);
         }
 
         if (fakewriter_tasks) {
                 for (i = 0; i < nfakewriters; i++)
                         if (fakewriter_tasks[i])
-                                set_cpus_allowed(fakewriter_tasks[i], tmp_mask);
+                                set_cpus_allowed_ptr(fakewriter_tasks[i],
+                                                     &tmp_mask);
         }
 
         if (writer_task)
-                set_cpus_allowed(writer_task, tmp_mask);
+                set_cpus_allowed_ptr(writer_task, &tmp_mask);
 
         if (stats_task)
-                set_cpus_allowed(stats_task, tmp_mask);
+                set_cpus_allowed_ptr(stats_task, &tmp_mask);
 
         if (rcu_idle_cpu == -1)
                 rcu_idle_cpu = num_online_cpus() - 1;
diff --git a/kernel/sched.c b/kernel/sched.c
index 8dcdec6fe0fe..57ba7ea9b744 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -66,6 +66,10 @@
 #include <linux/unistd.h>
 #include <linux/pagemap.h>
 #include <linux/hrtimer.h>
+#include <linux/tick.h>
+#include <linux/bootmem.h>
+#include <linux/debugfs.h>
+#include <linux/ctype.h>
 
 #include <asm/tlb.h>
 #include <asm/irq_regs.h>
@@ -114,6 +118,11 @@ unsigned long long __attribute__((weak)) sched_clock(void)
  */
 #define DEF_TIMESLICE           (100 * HZ / 1000)
 
+/*
+ * single value that denotes runtime == period, ie unlimited time.
+ */
+#define RUNTIME_INF     ((u64)~0ULL)
+
 #ifdef CONFIG_SMP
 /*
  * Divide a load by a sched group cpu_power : (load / sg->__cpu_power)
@@ -155,6 +164,84 @@ struct rt_prio_array {
         struct list_head queue[MAX_RT_PRIO];
 };
 
+struct rt_bandwidth {
+        /* nests inside the rq lock: */
+        spinlock_t              rt_runtime_lock;
+        ktime_t                 rt_period;
+        u64                     rt_runtime;
+        struct hrtimer          rt_period_timer;
+};
+
+static struct rt_bandwidth def_rt_bandwidth;
+
+static int do_sched_rt_period_timer(struct rt_bandwidth *rt_b, int overrun);
+
+static enum hrtimer_restart sched_rt_period_timer(struct hrtimer *timer)
+{
+        struct rt_bandwidth *rt_b =
+                container_of(timer, struct rt_bandwidth, rt_period_timer);
+        ktime_t now;
+        int overrun;
+        int idle = 0;
+
+        for (;;) {
+                now = hrtimer_cb_get_time(timer);
+                overrun = hrtimer_forward(timer, now, rt_b->rt_period);
+
+                if (!overrun)
+                        break;
+
+                idle = do_sched_rt_period_timer(rt_b, overrun);
+        }
+
+        return idle ? HRTIMER_NORESTART : HRTIMER_RESTART;
+}
+
+static
+void init_rt_bandwidth(struct rt_bandwidth *rt_b, u64 period, u64 runtime)
+{
+        rt_b->rt_period = ns_to_ktime(period);
+        rt_b->rt_runtime = runtime;
+
+        spin_lock_init(&rt_b->rt_runtime_lock);
+
+        hrtimer_init(&rt_b->rt_period_timer,
+                        CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+        rt_b->rt_period_timer.function = sched_rt_period_timer;
+        rt_b->rt_period_timer.cb_mode = HRTIMER_CB_IRQSAFE_NO_SOFTIRQ;
+}
+
+static void start_rt_bandwidth(struct rt_bandwidth *rt_b)
+{
+        ktime_t now;
+
+        if (rt_b->rt_runtime == RUNTIME_INF)
+                return;
+
+        if (hrtimer_active(&rt_b->rt_period_timer))
+                return;
+
+        spin_lock(&rt_b->rt_runtime_lock);
+        for (;;) {
+                if (hrtimer_active(&rt_b->rt_period_timer))
+                        break;
+
+                now = hrtimer_cb_get_time(&rt_b->rt_period_timer);
+                hrtimer_forward(&rt_b->rt_period_timer, now, rt_b->rt_period);
+                hrtimer_start(&rt_b->rt_period_timer,
+                              rt_b->rt_period_timer.expires,
+                              HRTIMER_MODE_ABS);
+        }
+        spin_unlock(&rt_b->rt_runtime_lock);
+}
+
+#ifdef CONFIG_RT_GROUP_SCHED
+static void destroy_rt_bandwidth(struct rt_bandwidth *rt_b)
+{
+        hrtimer_cancel(&rt_b->rt_period_timer);
+}
+#endif
+
 #ifdef CONFIG_GROUP_SCHED
 
 #include <linux/cgroup.h>
@@ -181,29 +268,39 @@ struct task_group {
         struct sched_rt_entity **rt_se;
         struct rt_rq **rt_rq;
 
-        u64 rt_runtime;
+        struct rt_bandwidth rt_bandwidth;
 #endif
 
         struct rcu_head rcu;
         struct list_head list;
+
+        struct task_group *parent;
+        struct list_head siblings;
+        struct list_head children;
 };
 
+#ifdef CONFIG_USER_SCHED
+
+/*
+ * Root task group.
+ *      Every UID task group (including init_task_group aka UID-0) will
+ *      be a child to this group.
+ */
+struct task_group root_task_group;
+
 #ifdef CONFIG_FAIR_GROUP_SCHED
 /* Default task group's sched entity on each cpu */
 static DEFINE_PER_CPU(struct sched_entity, init_sched_entity);
 /* Default task group's cfs_rq on each cpu */
 static DEFINE_PER_CPU(struct cfs_rq, init_cfs_rq) ____cacheline_aligned_in_smp;
-
-static struct sched_entity *init_sched_entity_p[NR_CPUS];
-static struct cfs_rq *init_cfs_rq_p[NR_CPUS];
 #endif
 
 #ifdef CONFIG_RT_GROUP_SCHED
 static DEFINE_PER_CPU(struct sched_rt_entity, init_sched_rt_entity);
 static DEFINE_PER_CPU(struct rt_rq, init_rt_rq) ____cacheline_aligned_in_smp;
-
-static struct sched_rt_entity *init_sched_rt_entity_p[NR_CPUS];
-static struct rt_rq *init_rt_rq_p[NR_CPUS];
+#endif
+#else
+#define root_task_group init_task_group
 #endif
 
 /* task_group_lock serializes add/remove of task groups and also changes to
@@ -221,23 +318,15 @@ static DEFINE_MUTEX(doms_cur_mutex);
 # define INIT_TASK_GROUP_LOAD   NICE_0_LOAD
 #endif
 
+#define MIN_SHARES      2
+
 static int init_task_group_load = INIT_TASK_GROUP_LOAD;
 #endif
 
 /* Default task group.
  *      Every task in system belong to this group at bootup.
  */
-struct task_group init_task_group = {
-#ifdef CONFIG_FAIR_GROUP_SCHED
-        .se     = init_sched_entity_p,
-        .cfs_rq = init_cfs_rq_p,
-#endif
-
-#ifdef CONFIG_RT_GROUP_SCHED
-        .rt_se  = init_sched_rt_entity_p,
-        .rt_rq  = init_rt_rq_p,
-#endif
-};
+struct task_group init_task_group;
 
 /* return group to which a task belongs */
 static inline struct task_group *task_group(struct task_struct *p)
@@ -297,8 +386,12 @@ struct cfs_rq {
 
         struct rb_root tasks_timeline;
         struct rb_node *rb_leftmost;
-        struct rb_node *rb_load_balance_curr;
-        /* 'curr' points to currently running entity on this cfs_rq.
+
+        struct list_head tasks;
+        struct list_head *balance_iterator;
+
+        /*
+         * 'curr' points to currently running entity on this cfs_rq.
          * It is set to NULL otherwise (i.e when none are currently running).
          */
         struct sched_entity *curr, *next;
@@ -318,6 +411,43 @@ struct cfs_rq {
          */
         struct list_head leaf_cfs_rq_list;
         struct task_group *tg;  /* group that "owns" this runqueue */
+
+#ifdef CONFIG_SMP
+        unsigned long task_weight;
+        unsigned long shares;
+        /*
+         * We need space to build a sched_domain wide view of the full task
+         * group tree, in order to avoid depending on dynamic memory allocation
+         * during the load balancing we place this in the per cpu task group
+         * hierarchy. This limits the load balancing to one instance per cpu,
+         * but more should not be needed anyway.
+         */
+        struct aggregate_struct {
+                /*
+                 *   load = weight(cpus) * f(tg)
+                 *
+                 * Where f(tg) is the recursive weight fraction assigned to
+                 * this group.
+                 */
+                unsigned long load;
+
+                /*
+                 * part of the group weight distributed to this span.
+                 */
+                unsigned long shares;
+
+                /*
+                 * The sum of all runqueue weights within this span.
+                 */
+                unsigned long rq_weight;
+
+                /*
+                 * Weight contributed by tasks; this is the part we can
+                 * influence by moving tasks around.
+                 */
+                unsigned long task_weight;
+        } aggregate;
+#endif
 #endif
 };
 
@@ -334,6 +464,9 @@ struct rt_rq {
 #endif
         int rt_throttled;
         u64 rt_time;
+        u64 rt_runtime;
+        /* Nests inside the rq lock: */
+        spinlock_t rt_runtime_lock;
 
 #ifdef CONFIG_RT_GROUP_SCHED
         unsigned long rt_nr_boosted;
@@ -396,6 +529,7 @@ struct rq {
         unsigned long cpu_load[CPU_LOAD_IDX_MAX];
         unsigned char idle_at_tick;
 #ifdef CONFIG_NO_HZ
+        unsigned long last_tick_seen;
         unsigned char in_nohz_recently;
 #endif
         /* capture load from *all* tasks on this cpu: */
@@ -405,8 +539,6 @@ struct rq {
 
         struct cfs_rq cfs;
         struct rt_rq rt;
-        u64 rt_period_expire;
-        int rt_throttled;
 
 #ifdef CONFIG_FAIR_GROUP_SCHED
         /* list of leaf cfs_rq on this cpu: */
@@ -499,6 +631,32 @@ static inline int cpu_of(struct rq *rq)
 #endif
 }
 
+#ifdef CONFIG_NO_HZ
+static inline bool nohz_on(int cpu)
+{
+        return tick_get_tick_sched(cpu)->nohz_mode != NOHZ_MODE_INACTIVE;
+}
+
+static inline u64 max_skipped_ticks(struct rq *rq)
+{
+        return nohz_on(cpu_of(rq)) ? jiffies - rq->last_tick_seen + 2 : 1;
+}
+
+static inline void update_last_tick_seen(struct rq *rq)
+{
+        rq->last_tick_seen = jiffies;
+}
+#else
+static inline u64 max_skipped_ticks(struct rq *rq)
+{
+        return 1;
+}
+
+static inline void update_last_tick_seen(struct rq *rq)
+{
+}
+#endif
+
 /*
  * Update the per-runqueue clock, as finegrained as the platform can give
  * us, but without assuming monotonicity, etc.:
@@ -523,9 +681,12 @@ static void __update_rq_clock(struct rq *rq)
                 /*
                  * Catch too large forward jumps too:
                  */
-                if (unlikely(clock + delta > rq->tick_timestamp + TICK_NSEC)) {
-                        if (clock < rq->tick_timestamp + TICK_NSEC)
-                                clock = rq->tick_timestamp + TICK_NSEC;
+                u64 max_jump = max_skipped_ticks(rq) * TICK_NSEC;
+                u64 max_time = rq->tick_timestamp + max_jump;
+
+                if (unlikely(clock + delta > max_time)) {
+                        if (clock < max_time)
+                                clock = max_time;
                         else
                                 clock++;
                         rq->clock_overflows++;
@@ -561,23 +722,6 @@ static void update_rq_clock(struct rq *rq)
 #define task_rq(p)              cpu_rq(task_cpu(p))
 #define cpu_curr(cpu)           (cpu_rq(cpu)->curr)
 
-unsigned long rt_needs_cpu(int cpu)
-{
-        struct rq *rq = cpu_rq(cpu);
-        u64 delta;
-
-        if (!rq->rt_throttled)
-                return 0;
-
-        if (rq->clock > rq->rt_period_expire)
-                return 1;
-
-        delta = rq->rt_period_expire - rq->clock;
-        do_div(delta, NSEC_PER_SEC / HZ);
-
-        return (unsigned long)delta;
-}
-
 /*
  * Tunables that become constants when CONFIG_SCHED_DEBUG is off:
  */
@@ -590,22 +734,137 @@ unsigned long rt_needs_cpu(int cpu)
 /*
  * Debugging: various feature bits
  */
+
+#define SCHED_FEAT(name, enabled)       \
+        __SCHED_FEAT_##name ,
+
 enum {
-        SCHED_FEAT_NEW_FAIR_SLEEPERS    = 1,
-        SCHED_FEAT_WAKEUP_PREEMPT       = 2,
-        SCHED_FEAT_START_DEBIT          = 4,
-        SCHED_FEAT_HRTICK               = 8,
-        SCHED_FEAT_DOUBLE_TICK          = 16,
+#include "sched_features.h"
 };
 
+#undef SCHED_FEAT
+
+#define SCHED_FEAT(name, enabled)       \
+        (1UL << __SCHED_FEAT_##name) * enabled |
+
 const_debug unsigned int sysctl_sched_features =
-                SCHED_FEAT_NEW_FAIR_SLEEPERS    * 1 |
-                SCHED_FEAT_WAKEUP_PREEMPT       * 1 |
-                SCHED_FEAT_START_DEBIT          * 1 |
-                SCHED_FEAT_HRTICK               * 1 |
-                SCHED_FEAT_DOUBLE_TICK          * 0;
+#include "sched_features.h"
+        0;
+
+#undef SCHED_FEAT
+
+#ifdef CONFIG_SCHED_DEBUG
+#define SCHED_FEAT(name, enabled)       \
+        #name ,
+
+__read_mostly char *sched_feat_names[] = {
+#include "sched_features.h"
+        NULL
+};
+
+#undef SCHED_FEAT
+
+int sched_feat_open(struct inode *inode, struct file *filp)
+{
+        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;
 
-#define sched_feat(x) (sysctl_sched_features & SCHED_FEAT_##x)
+        for (i = 0; sched_feat_names[i]; i++) {
+                len += strlen(sched_feat_names[i]);
+                len += 4;
+        }
+
+        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]);
+        }
+
+        r += sprintf(buf + r, "\n");
+        WARN_ON(r >= len + 2);
+
+        r = simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
+
+        kfree(buf);
+
+        return r;
+}
+
+static ssize_t
+sched_feat_write(struct file *filp, const char __user *ubuf,
+                size_t cnt, loff_t *ppos)
+{
+        char buf[64];
+        char *cmp = buf;
+        int neg = 0;
+        int i;
+
+        if (cnt > 63)
+                cnt = 63;
+
+        if (copy_from_user(&buf, ubuf, cnt))
+                return -EFAULT;
+
+        buf[cnt] = 0;
+
+        if (strncmp(buf, "NO_", 3) == 0) {
+                neg = 1;
+                cmp += 3;
+        }
+
+        for (i = 0; sched_feat_names[i]; i++) {
+                int len = strlen(sched_feat_names[i]);
+
+                if (strncmp(cmp, sched_feat_names[i], len) == 0) {
+                        if (neg)
+                                sysctl_sched_features &= ~(1UL << i);
+                        else
+                                sysctl_sched_features |= (1UL << i);
+                        break;
+                }
+        }
+
+        if (!sched_feat_names[i])
+                return -EINVAL;
+
+        filp->f_pos += cnt;
+
+        return cnt;
+}
+
+static struct file_operations sched_feat_fops = {
+        .open   = sched_feat_open,
+        .read   = sched_feat_read,
+        .write  = sched_feat_write,
+};
+
+static __init int sched_init_debug(void)
+{
+        debugfs_create_file("sched_features", 0644, NULL, NULL,
+                        &sched_feat_fops);
+
+        return 0;
+}
+late_initcall(sched_init_debug);
+
+#endif
+
+#define sched_feat(x) (sysctl_sched_features & (1UL << __SCHED_FEAT_##x))
 
 /*
  * Number of tasks to iterate in a single balance run.
@@ -627,16 +886,52 @@ static __read_mostly int scheduler_running;
  */
 int sysctl_sched_rt_runtime = 950000;
 
-/*
- * single value that denotes runtime == period, ie unlimited time.
- */
-#define RUNTIME_INF     ((u64)~0ULL)
+static inline u64 global_rt_period(void)
+{
+        return (u64)sysctl_sched_rt_period * NSEC_PER_USEC;
+}
+
+static inline u64 global_rt_runtime(void)
+{
+        if (sysctl_sched_rt_period < 0)
+                return RUNTIME_INF;
+
+        return (u64)sysctl_sched_rt_runtime * NSEC_PER_USEC;
+}
+
+static const unsigned long long time_sync_thresh = 100000;
+
+static DEFINE_PER_CPU(unsigned long long, time_offset);
+static DEFINE_PER_CPU(unsigned long long, prev_cpu_time);
 
 /*
- * For kernel-internal use: high-speed (but slightly incorrect) per-cpu
- * clock constructed from sched_clock():
+ * Global lock which we take every now and then to synchronize
+ * the CPUs time. This method is not warp-safe, but it's good
+ * enough to synchronize slowly diverging time sources and thus
+ * it's good enough for tracing:
  */
-unsigned long long cpu_clock(int cpu)
+static DEFINE_SPINLOCK(time_sync_lock);
+static unsigned long long prev_global_time;
+
+static unsigned long long __sync_cpu_clock(cycles_t time, int cpu)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&time_sync_lock, flags);
+
+        if (time < prev_global_time) {
+                per_cpu(time_offset, cpu) += prev_global_time - time;
+                time = prev_global_time;
+        } else {
+                prev_global_time = time;
+        }
+
+        spin_unlock_irqrestore(&time_sync_lock, flags);
+
+        return time;
+}
+
+static unsigned long long __cpu_clock(int cpu)
 {
         unsigned long long now;
         unsigned long flags;
@@ -657,6 +952,24 @@ unsigned long long cpu_clock(int cpu)
 
         return now;
 }
+
+/*
+ * For kernel-internal use: high-speed (but slightly incorrect) per-cpu
+ * clock constructed from sched_clock():
+ */
+unsigned long long cpu_clock(int cpu)
+{
+        unsigned long long prev_cpu_time, time, delta_time;
+
+        prev_cpu_time = per_cpu(prev_cpu_time, cpu);
+        time = __cpu_clock(cpu) + per_cpu(time_offset, cpu);
+        delta_time = time-prev_cpu_time;
+
+        if (unlikely(delta_time > time_sync_thresh))
+                time = __sync_cpu_clock(time, cpu);
+
+        return time;
+}
 EXPORT_SYMBOL_GPL(cpu_clock);
 
 #ifndef prepare_arch_switch
@@ -1116,6 +1429,9 @@ static void __resched_task(struct task_struct *p, int tif_bit)
  */
 #define SRR(x, y) (((x) + (1UL << ((y) - 1))) >> (y))
 
+/*
+ * delta *= weight / lw
+ */
 static unsigned long
 calc_delta_mine(unsigned long delta_exec, unsigned long weight,
                 struct load_weight *lw)
@@ -1138,12 +1454,6 @@ calc_delta_mine(unsigned long delta_exec, unsigned long weight,
         return (unsigned long)min(tmp, (u64)(unsigned long)LONG_MAX);
 }
 
-static inline unsigned long
-calc_delta_fair(unsigned long delta_exec, struct load_weight *lw)
-{
-        return calc_delta_mine(delta_exec, NICE_0_LOAD, lw);
-}
-
 static inline void update_load_add(struct load_weight *lw, unsigned long inc)
 {
         lw->weight += inc;
@@ -1241,11 +1551,390 @@ static void cpuacct_charge(struct task_struct *tsk, u64 cputime);
 static inline void cpuacct_charge(struct task_struct *tsk, u64 cputime) {}
 #endif
 
+static inline void inc_cpu_load(struct rq *rq, unsigned long load)
+{
+        update_load_add(&rq->load, load);
+}
+
+static inline void dec_cpu_load(struct rq *rq, unsigned long load)
+{
+        update_load_sub(&rq->load, load);
+}
+
 #ifdef CONFIG_SMP
 static unsigned long source_load(int cpu, int type);
 static unsigned long target_load(int cpu, int type);
 static unsigned long cpu_avg_load_per_task(int cpu);
 static int task_hot(struct task_struct *p, u64 now, struct sched_domain *sd);
+
+#ifdef CONFIG_FAIR_GROUP_SCHED
+
+/*
+ * Group load balancing.
+ *
+ * We calculate a few balance domain wide aggregate numbers; load and weight.
+ * Given the pictures below, and assuming each item has equal weight:
+ *
+ *         root          1 - thread
+ *         / | \         A - group
+ *        A  1  B
+ *       /|\   / \
+ *      C 2 D 3   4
+ *      |   |
+ *      5   6
+ *
+ * load:
+ *    A and B get 1/3-rd of the total load. C and D get 1/3-rd of A's 1/3-rd,
+ *    which equals 1/9-th of the total load.
+ *
+ * shares:
+ *    The weight of this group on the selected cpus.
+ *
+ * rq_weight:
+ *    Direct sum of all the cpu's their rq weight, e.g. A would get 3 while
+ *    B would get 2.
+ *
+ * task_weight:
+ *    Part of the rq_weight contributed by tasks; all groups except B would
+ *    get 1, B gets 2.
+ */
+
+static inline struct aggregate_struct *
+aggregate(struct task_group *tg, struct sched_domain *sd)
+{
+        return &tg->cfs_rq[sd->first_cpu]->aggregate;
+}
+
+typedef void (*aggregate_func)(struct task_group *, struct sched_domain *);
+
+/*
+ * Iterate the full tree, calling @down when first entering a node and @up when
+ * leaving it for the final time.
+ */
+static
+void aggregate_walk_tree(aggregate_func down, aggregate_func up,
+                         struct sched_domain *sd)
+{
+        struct task_group *parent, *child;
+
+        rcu_read_lock();
+        parent = &root_task_group;
+down:
+        (*down)(parent, sd);
+        list_for_each_entry_rcu(child, &parent->children, siblings) {
+                parent = child;
+                goto down;
+
+up:
+                continue;
+        }
+        (*up)(parent, sd);
+
+        child = parent;
+        parent = parent->parent;
+        if (parent)
+                goto up;
+        rcu_read_unlock();
+}
+
+/*
+ * Calculate the aggregate runqueue weight.
+ */
+static
+void aggregate_group_weight(struct task_group *tg, struct sched_domain *sd)
+{
+        unsigned long rq_weight = 0;
+        unsigned long task_weight = 0;
+        int i;
+
+        for_each_cpu_mask(i, sd->span) {
+                rq_weight += tg->cfs_rq[i]->load.weight;
+                task_weight += tg->cfs_rq[i]->task_weight;
+        }
+
+        aggregate(tg, sd)->rq_weight = rq_weight;
+        aggregate(tg, sd)->task_weight = task_weight;
+}
+
+/*
+ * Redistribute tg->shares amongst all tg->cfs_rq[]s.
+ */
+static void __aggregate_redistribute_shares(struct task_group *tg)
+{
+        int i, max_cpu = smp_processor_id();
+        unsigned long rq_weight = 0;
+        unsigned long shares, max_shares = 0, shares_rem = tg->shares;
+
+        for_each_possible_cpu(i)
+                rq_weight += tg->cfs_rq[i]->load.weight;
+
+        for_each_possible_cpu(i) {
+                /*
+                 * divide shares proportional to the rq_weights.
+                 */
+                shares = tg->shares * tg->cfs_rq[i]->load.weight;
+                shares /= rq_weight + 1;
+
+                tg->cfs_rq[i]->shares = shares;
+
+                if (shares > max_shares) {
+                        max_shares = shares;
+                        max_cpu = i;
+                }
+                shares_rem -= shares;
+        }
+
+        /*
+         * Ensure it all adds up to tg->shares; we can loose a few
+         * due to rounding down when computing the per-cpu shares.
+         */
+        if (shares_rem)
+                tg->cfs_rq[max_cpu]->shares += shares_rem;
+}
+
+/*
+ * Compute the weight of this group on the given cpus.
+ */
+static
+void aggregate_group_shares(struct task_group *tg, struct sched_domain *sd)
+{
+        unsigned long shares = 0;
+        int i;
+
+again:
+        for_each_cpu_mask(i, sd->span)
+                shares += tg->cfs_rq[i]->shares;
+
+        /*
+         * When the span doesn't have any shares assigned, but does have
+         * tasks to run do a machine wide rebalance (should be rare).
+         */
+        if (unlikely(!shares && aggregate(tg, sd)->rq_weight)) {
+                __aggregate_redistribute_shares(tg);
+                goto again;
+        }
+
+        aggregate(tg, sd)->shares = shares;
+}
+
+/*
+ * Compute the load fraction assigned to this group, relies on the aggregate
+ * weight and this group's parent's load, i.e. top-down.
+ */
+static
+void aggregate_group_load(struct task_group *tg, struct sched_domain *sd)
+{
+        unsigned long load;
+
+        if (!tg->parent) {
+                int i;
+
+                load = 0;
+                for_each_cpu_mask(i, sd->span)
+                        load += cpu_rq(i)->load.weight;
+
+        } else {
+                load = aggregate(tg->parent, sd)->load;
+
+                /*
+                 * shares is our weight in the parent's rq so
+                 * shares/parent->rq_weight gives our fraction of the load
+                 */
+                load *= aggregate(tg, sd)->shares;
+                load /= aggregate(tg->parent, sd)->rq_weight + 1;
+        }
+
+        aggregate(tg, sd)->load = load;
+}
+
+static void __set_se_shares(struct sched_entity *se, unsigned long shares);
+
+/*
+ * Calculate and set the cpu's group shares.
+ */
+static void
+__update_group_shares_cpu(struct task_group *tg, struct sched_domain *sd,
+                          int tcpu)
+{
+        int boost = 0;
+        unsigned long shares;
+        unsigned long rq_weight;
+
+        if (!tg->se[tcpu])
+                return;
+
+        rq_weight = tg->cfs_rq[tcpu]->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.
+         */
+        if (!rq_weight) {
+                boost = 1;
+                rq_weight = NICE_0_LOAD;
+        }
+
+        /*
+         *           \Sum shares * rq_weight
+         * shares =  -----------------------
+         *               \Sum rq_weight
+         *
+         */
+        shares = aggregate(tg, sd)->shares * rq_weight;
+        shares /= aggregate(tg, sd)->rq_weight + 1;
+
+        /*
+         * record the actual number of shares, not the boosted amount.
+         */
+        tg->cfs_rq[tcpu]->shares = boost ? 0 : shares;
+
+        if (shares < MIN_SHARES)
+                shares = MIN_SHARES;
+
+        __set_se_shares(tg->se[tcpu], shares);
+}
+
+/*
+ * Re-adjust the weights on the cpu the task came from and on the cpu the
+ * task went to.
+ */
+static void
+__move_group_shares(struct task_group *tg, struct sched_domain *sd,
+                    int scpu, int dcpu)
+{
+        unsigned long shares;
+
+        shares = tg->cfs_rq[scpu]->shares + tg->cfs_rq[dcpu]->shares;
+
+        __update_group_shares_cpu(tg, sd, scpu);
+        __update_group_shares_cpu(tg, sd, dcpu);
+
+        /*
+         * ensure we never loose shares due to rounding errors in the
+         * above redistribution.
+         */
+        shares -= tg->cfs_rq[scpu]->shares + tg->cfs_rq[dcpu]->shares;
+        if (shares)
+                tg->cfs_rq[dcpu]->shares += shares;
+}
+
+/*
+ * Because changing a group's shares changes the weight of the super-group
+ * we need to walk up the tree and change all shares until we hit the root.
+ */
+static void
+move_group_shares(struct task_group *tg, struct sched_domain *sd,
+                  int scpu, int dcpu)
+{
+        while (tg) {
+                __move_group_shares(tg, sd, scpu, dcpu);
+                tg = tg->parent;
+        }
+}
+
+static
+void aggregate_group_set_shares(struct task_group *tg, struct sched_domain *sd)
+{
+        unsigned long shares = aggregate(tg, sd)->shares;
+        int i;
+
+        for_each_cpu_mask(i, sd->span) {
+                struct rq *rq = cpu_rq(i);
+                unsigned long flags;
+
+                spin_lock_irqsave(&rq->lock, flags);
+                __update_group_shares_cpu(tg, sd, i);
+                spin_unlock_irqrestore(&rq->lock, flags);
+        }
+
+        aggregate_group_shares(tg, sd);
+
+        /*
+         * ensure we never loose shares due to rounding errors in the
+         * above redistribution.
+         */
+        shares -= aggregate(tg, sd)->shares;
+        if (shares) {
+                tg->cfs_rq[sd->first_cpu]->shares += shares;
+                aggregate(tg, sd)->shares += shares;
+        }
+}
+
+/*
+ * Calculate the accumulative weight and recursive load of each task group
+ * while walking down the tree.
+ */
+static
+void aggregate_get_down(struct task_group *tg, struct sched_domain *sd)
+{
+        aggregate_group_weight(tg, sd);
+        aggregate_group_shares(tg, sd);
+        aggregate_group_load(tg, sd);
+}
+
+/*
+ * Rebalance the cpu shares while walking back up the tree.
+ */
+static
+void aggregate_get_up(struct task_group *tg, struct sched_domain *sd)
+{
+        aggregate_group_set_shares(tg, sd);
+}
+
+static DEFINE_PER_CPU(spinlock_t, aggregate_lock);
+
+static void __init init_aggregate(void)
+{
+        int i;
+
+        for_each_possible_cpu(i)
+                spin_lock_init(&per_cpu(aggregate_lock, i));
+}
+
+static int get_aggregate(struct sched_domain *sd)
+{
+        if (!spin_trylock(&per_cpu(aggregate_lock, sd->first_cpu)))
+                return 0;
+
+        aggregate_walk_tree(aggregate_get_down, aggregate_get_up, sd);
+        return 1;
+}
+
+static void put_aggregate(struct sched_domain *sd)
+{
+        spin_unlock(&per_cpu(aggregate_lock, sd->first_cpu));
+}
+
+static void cfs_rq_set_shares(struct cfs_rq *cfs_rq, unsigned long shares)
+{
+        cfs_rq->shares = shares;
+}
+
+#else
+
+static inline void init_aggregate(void)
+{
+}
+
+static inline int get_aggregate(struct sched_domain *sd)
+{
+        return 0;
+}
+
+static inline void put_aggregate(struct sched_domain *sd)
+{
+}
+#endif
+
+#else /* CONFIG_SMP */
+
+#ifdef CONFIG_FAIR_GROUP_SCHED
+static void cfs_rq_set_shares(struct cfs_rq *cfs_rq, unsigned long shares)
+{
+}
+#endif
+
 #endif /* CONFIG_SMP */
 
 #include "sched_stats.h"
@@ -1258,26 +1947,14 @@ static int task_hot(struct task_struct *p, u64 now, struct sched_domain *sd);
 
 #define sched_class_highest (&rt_sched_class)
 
-static inline void inc_load(struct rq *rq, const struct task_struct *p)
-{
-        update_load_add(&rq->load, p->se.load.weight);
-}
-
-static inline void dec_load(struct rq *rq, const struct task_struct *p)
-{
-        update_load_sub(&rq->load, p->se.load.weight);
-}
-
-static void inc_nr_running(struct task_struct *p, struct rq *rq)
+static void inc_nr_running(struct rq *rq)
 {
         rq->nr_running++;
-        inc_load(rq, p);
 }
 
-static void dec_nr_running(struct task_struct *p, struct rq *rq)
+static void dec_nr_running(struct rq *rq)
 {
         rq->nr_running--;
-        dec_load(rq, p);
 }
 
 static void set_load_weight(struct task_struct *p)
@@ -1369,7 +2046,7 @@ static void activate_task(struct rq *rq, struct task_struct *p, int wakeup)
                 rq->nr_uninterruptible--;
 
         enqueue_task(rq, p, wakeup);
-        inc_nr_running(p, rq);
+        inc_nr_running(rq);
 }
 
 /*
@@ -1381,7 +2058,7 @@ static void deactivate_task(struct rq *rq, struct task_struct *p, int sleep)
                 rq->nr_uninterruptible++;
 
         dequeue_task(rq, p, sleep);
-        dec_nr_running(p, rq);
+        dec_nr_running(rq);
 }
 
 /**
@@ -1438,7 +2115,7 @@ task_hot(struct task_struct *p, u64 now, struct sched_domain *sd)
         /*
          * Buddy candidates are cache hot:
          */
-        if (&p->se == cfs_rq_of(&p->se)->next)
+        if (sched_feat(CACHE_HOT_BUDDY) && (&p->se == cfs_rq_of(&p->se)->next))
                 return 1;
 
         if (p->sched_class != &fair_sched_class)
@@ -1728,17 +2405,17 @@ 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)
 {
-        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);
+        cpus_and(*tmp, group->cpumask, p->cpus_allowed);
 
-        for_each_cpu_mask(i, tmp) {
+        for_each_cpu_mask(i, *tmp) {
                 load = weighted_cpuload(i);
 
                 if (load < min_load || (load == min_load && i == this_cpu)) {
@@ -1777,7 +2454,7 @@ static int sched_balance_self(int cpu, int flag)
         }
 
         while (sd) {
-                cpumask_t span;
+                cpumask_t span, tmpmask;
                 struct sched_group *group;
                 int new_cpu, weight;
 
@@ -1793,7 +2470,7 @@ static int sched_balance_self(int cpu, int flag)
                         continue;
                 }
 
-                new_cpu = find_idlest_cpu(group, t, cpu);
+                new_cpu = find_idlest_cpu(group, t, cpu, &tmpmask);
                 if (new_cpu == -1 || new_cpu == cpu) {
                         /* Now try balancing at a lower domain level of cpu */
                         sd = sd->child;
@@ -1839,6 +2516,9 @@ static int try_to_wake_up(struct task_struct *p, unsigned int state, int sync)
         long old_state;
         struct rq *rq;
 
+        if (!sched_feat(SYNC_WAKEUPS))
+                sync = 0;
+
         smp_wmb();
         rq = task_rq_lock(p, &flags);
         old_state = p->state;
@@ -1955,6 +2635,7 @@ static void __sched_fork(struct task_struct *p)
 
         INIT_LIST_HEAD(&p->rt.run_list);
         p->se.on_rq = 0;
+        INIT_LIST_HEAD(&p->se.group_node);
 
 #ifdef CONFIG_PREEMPT_NOTIFIERS
         INIT_HLIST_HEAD(&p->preempt_notifiers);
@@ -2030,7 +2711,7 @@ void wake_up_new_task(struct task_struct *p, unsigned long clone_flags)
                  * management (if any):
                  */
                 p->sched_class->task_new(rq, p);
-                inc_nr_running(p, rq);
+                inc_nr_running(rq);
         }
         check_preempt_curr(rq, p);
 #ifdef CONFIG_SMP
@@ -2674,7 +3355,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, cpumask_t *cpus, int *balance)
+                   int *sd_idle, const cpumask_t *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;
@@ -2975,7 +3656,7 @@ ret:
  */
 static struct rq *
 find_busiest_queue(struct sched_group *group, enum cpu_idle_type idle,
-                   unsigned long imbalance, cpumask_t *cpus)
+                   unsigned long imbalance, const cpumask_t *cpus)
 {
         struct rq *busiest = NULL, *rq;
         unsigned long max_load = 0;
@@ -3014,14 +3695,18 @@ 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)
+                        int *balance, cpumask_t *cpus)
 {
         int ld_moved, all_pinned = 0, active_balance = 0, sd_idle = 0;
         struct sched_group *group;
         unsigned long imbalance;
         struct rq *busiest;
-        cpumask_t cpus = CPU_MASK_ALL;
         unsigned long flags;
+        int unlock_aggregate;
+
+        cpus_setall(*cpus);
+
+        unlock_aggregate = get_aggregate(sd);
 
         /*
          * When power savings policy is enabled for the parent domain, idle
@@ -3037,7 +3722,7 @@ static int load_balance(int this_cpu, struct rq *this_rq,
 
 redo:
         group = find_busiest_group(sd, this_cpu, &imbalance, idle, &sd_idle,
-                                   &cpus, balance);
+                                   cpus, balance);
 
         if (*balance == 0)
                 goto out_balanced;
@@ -3047,7 +3732,7 @@ redo:
                 goto out_balanced;
         }
 
-        busiest = find_busiest_queue(group, idle, imbalance, &cpus);
+        busiest = find_busiest_queue(group, idle, imbalance, cpus);
         if (!busiest) {
                 schedstat_inc(sd, lb_nobusyq[idle]);
                 goto out_balanced;
@@ -3080,8 +3765,8 @@ redo:
 
                 /* All tasks on this runqueue were pinned by CPU affinity */
                 if (unlikely(all_pinned)) {
-                        cpu_clear(cpu_of(busiest), cpus);
-                        if (!cpus_empty(cpus))
+                        cpu_clear(cpu_of(busiest), *cpus);
+                        if (!cpus_empty(*cpus))
                                 goto redo;
                         goto out_balanced;
                 }
@@ -3138,8 +3823,9 @@ redo:
 
         if (!ld_moved && !sd_idle && sd->flags & SD_SHARE_CPUPOWER &&
             !test_sd_parent(sd, SD_POWERSAVINGS_BALANCE))
-                return -1;
-        return ld_moved;
+                ld_moved = -1;
+
+        goto out;
 
 out_balanced:
         schedstat_inc(sd, lb_balanced[idle]);
@@ -3154,8 +3840,13 @@ out_one_pinned:
 
         if (!sd_idle && sd->flags & SD_SHARE_CPUPOWER &&
             !test_sd_parent(sd, SD_POWERSAVINGS_BALANCE))
-                return -1;
-        return 0;
+                ld_moved = -1;
+        else
+                ld_moved = 0;
+out:
+        if (unlock_aggregate)
+                put_aggregate(sd);
+        return ld_moved;
 }
 
 /*
@@ -3166,7 +3857,8 @@ out_one_pinned:
  * this_rq is locked.
  */
 static int
-load_balance_newidle(int this_cpu, struct rq *this_rq, struct sched_domain *sd)
+load_balance_newidle(int this_cpu, struct rq *this_rq, struct sched_domain *sd,
+                        cpumask_t *cpus)
 {
         struct sched_group *group;
         struct rq *busiest = NULL;
@@ -3174,7 +3866,8 @@ load_balance_newidle(int this_cpu, struct rq *this_rq, struct sched_domain *sd)
         int ld_moved = 0;
         int sd_idle = 0;
         int all_pinned = 0;
-        cpumask_t cpus = CPU_MASK_ALL;
+
+        cpus_setall(*cpus);
 
         /*
          * When power savings policy is enabled for the parent domain, idle
@@ -3189,14 +3882,13 @@ load_balance_newidle(int this_cpu, struct rq *this_rq, struct sched_domain *sd)
         schedstat_inc(sd, lb_count[CPU_NEWLY_IDLE]);
 redo:
         group = find_busiest_group(sd, this_cpu, &imbalance, CPU_NEWLY_IDLE,
-                                   &sd_idle, &cpus, NULL);
+                                   &sd_idle, cpus, NULL);
         if (!group) {
                 schedstat_inc(sd, lb_nobusyg[CPU_NEWLY_IDLE]);
                 goto out_balanced;
         }
 
-        busiest = find_busiest_queue(group, CPU_NEWLY_IDLE, imbalance,
-                                &cpus);
+        busiest = find_busiest_queue(group, CPU_NEWLY_IDLE, imbalance, cpus);
         if (!busiest) {
                 schedstat_inc(sd, lb_nobusyq[CPU_NEWLY_IDLE]);
                 goto out_balanced;
@@ -3218,8 +3910,8 @@ redo:
                 spin_unlock(&busiest->lock);
 
                 if (unlikely(all_pinned)) {
-                        cpu_clear(cpu_of(busiest), cpus);
-                        if (!cpus_empty(cpus))
+                        cpu_clear(cpu_of(busiest), *cpus);
+                        if (!cpus_empty(*cpus))
                                 goto redo;
                 }
         }
@@ -3253,6 +3945,7 @@ 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;
 
         for_each_domain(this_cpu, sd) {
                 unsigned long interval;
@@ -3262,8 +3955,8 @@ 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);
+                        pulled_task = load_balance_newidle(this_cpu, this_rq,
+                                                           sd, &tmpmask);
 
                 interval = msecs_to_jiffies(sd->balance_interval);
                 if (time_after(next_balance, sd->last_balance + interval))
@@ -3422,6 +4115,7 @@ static void rebalance_domains(int cpu, enum cpu_idle_type idle)
         /* Earliest time when we have to do rebalance again */
         unsigned long next_balance = jiffies + 60*HZ;
         int update_next_balance = 0;
+        cpumask_t tmp;
 
         for_each_domain(cpu, sd) {
                 if (!(sd->flags & SD_LOAD_BALANCE))
@@ -3445,7 +4139,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)) {
+                        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
@@ -3561,7 +4255,7 @@ static inline void trigger_load_balance(struct rq *rq, int cpu)
                          */
                         int ilb = first_cpu(nohz.cpu_mask);
 
-                        if (ilb != NR_CPUS)
+                        if (ilb < nr_cpu_ids)
                                 resched_cpu(ilb);
                 }
         }
@@ -3765,9 +4459,9 @@ void scheduler_tick(void)
                 rq->clock_underflows++;
         }
         rq->tick_timestamp = rq->clock;
+        update_last_tick_seen(rq);
         update_cpu_load(rq);
         curr->sched_class->task_tick(rq, curr, 0);
-        update_sched_rt_period(rq);
         spin_unlock(&rq->lock);
 
 #ifdef CONFIG_SMP
@@ -4367,10 +5061,8 @@ void set_user_nice(struct task_struct *p, long nice)
                 goto out_unlock;
         }
         on_rq = p->se.on_rq;
-        if (on_rq) {
+        if (on_rq)
                 dequeue_task(rq, p, 0);
-                dec_load(rq, p);
-        }
 
         p->static_prio = NICE_TO_PRIO(nice);
         set_load_weight(p);
@@ -4380,7 +5072,6 @@ void set_user_nice(struct task_struct *p, long nice)
 
         if (on_rq) {
                 enqueue_task(rq, p, 0);
-                inc_load(rq, p);
                 /*
                  * If the task increased its priority or is running and
                  * lowered its priority, then reschedule its CPU:
@@ -4602,7 +5293,7 @@ recheck:
          * Do not allow realtime tasks into groups that have no runtime
          * assigned.
          */
-        if (rt_policy(policy) && task_group(p)->rt_runtime == 0)
+        if (rt_policy(policy) && task_group(p)->rt_bandwidth.rt_runtime == 0)
                 return -EPERM;
 #endif
 
@@ -4764,9 +5455,10 @@ out_unlock:
         return retval;
 }
 
-long sched_setaffinity(pid_t pid, cpumask_t new_mask)
+long sched_setaffinity(pid_t pid, const cpumask_t *in_mask)
 {
         cpumask_t cpus_allowed;
+        cpumask_t new_mask = *in_mask;
         struct task_struct *p;
         int retval;
 
@@ -4797,13 +5489,13 @@ long sched_setaffinity(pid_t pid, cpumask_t new_mask)
         if (retval)
                 goto out_unlock;
 
-        cpus_allowed = cpuset_cpus_allowed(p);
+        cpuset_cpus_allowed(p, &cpus_allowed);
         cpus_and(new_mask, new_mask, cpus_allowed);
  again:
-        retval = set_cpus_allowed(p, new_mask);
+        retval = set_cpus_allowed_ptr(p, &new_mask);
 
         if (!retval) {
-                cpus_allowed = cpuset_cpus_allowed(p);
+                cpuset_cpus_allowed(p, &cpus_allowed);
                 if (!cpus_subset(new_mask, cpus_allowed)) {
                         /*
                          * We must have raced with a concurrent cpuset
@@ -4847,7 +5539,7 @@ asmlinkage long sys_sched_setaffinity(pid_t pid, unsigned int len,
         if (retval)
                 return retval;
 
-        return sched_setaffinity(pid, new_mask);
+        return sched_setaffinity(pid, &new_mask);
 }
 
 /*
@@ -5309,7 +6001,6 @@ static inline void sched_init_granularity(void)
                 sysctl_sched_latency = limit;
 
         sysctl_sched_wakeup_granularity *= factor;
-        sysctl_sched_batch_wakeup_granularity *= factor;
 }
 
 #ifdef CONFIG_SMP
@@ -5338,7 +6029,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(struct task_struct *p, cpumask_t new_mask)
+int set_cpus_allowed_ptr(struct task_struct *p, const cpumask_t *new_mask)
 {
         struct migration_req req;
         unsigned long flags;
@@ -5346,23 +6037,23 @@ int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
         int ret = 0;
 
         rq = task_rq_lock(p, &flags);
-        if (!cpus_intersects(new_mask, cpu_online_map)) {
+        if (!cpus_intersects(*new_mask, cpu_online_map)) {
                 ret = -EINVAL;
                 goto out;
         }
 
         if (p->sched_class->set_cpus_allowed)
-                p->sched_class->set_cpus_allowed(p, &new_mask);
+                p->sched_class->set_cpus_allowed(p, new_mask);
         else {
-                p->cpus_allowed = new_mask;
-                p->rt.nr_cpus_allowed = cpus_weight(new_mask);
+                p->cpus_allowed = *new_mask;
+                p->rt.nr_cpus_allowed = cpus_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 (cpu_isset(task_cpu(p), *new_mask))
                 goto out;
 
-        if (migrate_task(p, any_online_cpu(new_mask), &req)) {
+        if (migrate_task(p, any_online_cpu(*new_mask), &req)) {
                 /* Need help from migration thread: drop lock and wait. */
                 task_rq_unlock(rq, &flags);
                 wake_up_process(rq->migration_thread);
@@ -5375,7 +6066,7 @@ out:
 
         return ret;
 }
-EXPORT_SYMBOL_GPL(set_cpus_allowed);
+EXPORT_SYMBOL_GPL(set_cpus_allowed_ptr);
 
 /*
  * Move (not current) task off this cpu, onto dest cpu. We're doing
@@ -5513,12 +6204,14 @@ static void move_task_off_dead_cpu(int dead_cpu, struct task_struct *p)
                 dest_cpu = any_online_cpu(mask);
 
                 /* On any allowed CPU? */
-                if (dest_cpu == NR_CPUS)
+                if (dest_cpu >= nr_cpu_ids)
                         dest_cpu = any_online_cpu(p->cpus_allowed);
 
                 /* No more Mr. Nice Guy. */
-                if (dest_cpu == NR_CPUS) {
-                        cpumask_t cpus_allowed = cpuset_cpus_allowed_locked(p);
+                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.
@@ -5554,7 +6247,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));
+        struct rq *rq_dest = cpu_rq(any_online_cpu(*CPU_MASK_ALL_PTR));
         unsigned long flags;
 
         local_irq_save(flags);
@@ -5966,20 +6659,16 @@ void __init migration_init(void)
 
 #ifdef CONFIG_SMP
 
-/* Number of possible processor ids */
-int nr_cpu_ids __read_mostly = NR_CPUS;
-EXPORT_SYMBOL(nr_cpu_ids);
-
 #ifdef CONFIG_SCHED_DEBUG
 
-static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level)
+static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
+                                  cpumask_t *groupmask)
 {
         struct sched_group *group = sd->groups;
-        cpumask_t groupmask;
-        char str[NR_CPUS];
+        char str[256];
 
-        cpumask_scnprintf(str, NR_CPUS, sd->span);
-        cpus_clear(groupmask);
+        cpulist_scnprintf(str, sizeof(str), sd->span);
+        cpus_clear(*groupmask);
 
         printk(KERN_DEBUG "%*s domain %d: ", level, "", level);
 
@@ -6023,25 +6712,25 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level)
                         break;
                 }
 
-                if (cpus_intersects(groupmask, group->cpumask)) {
+                if (cpus_intersects(*groupmask, group->cpumask)) {
                         printk(KERN_CONT "\n");
                         printk(KERN_ERR "ERROR: repeated CPUs\n");
                         break;
                 }
 
-                cpus_or(groupmask, groupmask, group->cpumask);
+                cpus_or(*groupmask, *groupmask, group->cpumask);
 
-                cpumask_scnprintf(str, NR_CPUS, group->cpumask);
+                cpulist_scnprintf(str, sizeof(str), group->cpumask);
                 printk(KERN_CONT " %s", str);
 
                 group = group->next;
         } while (group != sd->groups);
         printk(KERN_CONT "\n");
 
-        if (!cpus_equal(sd->span, groupmask))
+        if (!cpus_equal(sd->span, *groupmask))
                 printk(KERN_ERR "ERROR: groups don't span domain->span\n");
 
-        if (sd->parent && !cpus_subset(groupmask, sd->parent->span))
+        if (sd->parent && !cpus_subset(*groupmask, sd->parent->span))
                 printk(KERN_ERR "ERROR: parent span is not a superset "
                         "of domain->span\n");
         return 0;
@@ -6049,6 +6738,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;
         int level = 0;
 
         if (!sd) {
@@ -6058,14 +6748,21 @@ static void sched_domain_debug(struct sched_domain *sd, int cpu)
 
         printk(KERN_DEBUG "CPU%d attaching sched-domain:\n", cpu);
 
+        groupmask = kmalloc(sizeof(cpumask_t), GFP_KERNEL);
+        if (!groupmask) {
+                printk(KERN_DEBUG "Cannot load-balance (out of memory)\n");
+                return;
+        }
+
         for (;;) {
-                if (sched_domain_debug_one(sd, cpu, level))
+                if (sched_domain_debug_one(sd, cpu, level, groupmask))
                         break;
                 level++;
                 sd = sd->parent;
                 if (!sd)
                         break;
         }
+        kfree(groupmask);
 }
 #else
 # define sched_domain_debug(sd, cpu) do { } while (0)
@@ -6253,30 +6950,33 @@ __setup("isolcpus=", isolated_cpu_setup);
  * and ->cpu_power to 0.
  */
 static void
-init_sched_build_groups(cpumask_t span, const cpumask_t *cpu_map,
+init_sched_build_groups(const cpumask_t *span, const cpumask_t *cpu_map,
                         int (*group_fn)(int cpu, const cpumask_t *cpu_map,
-                                        struct sched_group **sg))
+                                        struct sched_group **sg,
+                                        cpumask_t *tmpmask),
+                        cpumask_t *covered, cpumask_t *tmpmask)
 {
         struct sched_group *first = NULL, *last = NULL;
-        cpumask_t covered = CPU_MASK_NONE;
         int i;
 
-        for_each_cpu_mask(i, span) {
+        cpus_clear(*covered);
+
+        for_each_cpu_mask(i, *span) {
                 struct sched_group *sg;
-                int group = group_fn(i, cpu_map, &sg);
+                int group = group_fn(i, cpu_map, &sg, tmpmask);
                 int j;
 
-                if (cpu_isset(i, covered))
+                if (cpu_isset(i, *covered))
                         continue;
 
-                sg->cpumask = CPU_MASK_NONE;
+                cpus_clear(sg->cpumask);
                 sg->__cpu_power = 0;
 
-                for_each_cpu_mask(j, span) {
-                        if (group_fn(j, cpu_map, NULL) != group)
+                for_each_cpu_mask(j, *span) {
+                        if (group_fn(j, cpu_map, NULL, tmpmask) != group)
                                 continue;
 
-                        cpu_set(j, covered);
+                        cpu_set(j, *covered);
                         cpu_set(j, sg->cpumask);
                 }
                 if (!first)
@@ -6302,7 +7002,7 @@ init_sched_build_groups(cpumask_t span, const cpumask_t *cpu_map,
  *
  * Should use nodemask_t.
  */
-static int find_next_best_node(int node, unsigned long *used_nodes)
+static int find_next_best_node(int node, nodemask_t *used_nodes)
 {
         int i, n, val, min_val, best_node = 0;
 
@@ -6316,7 +7016,7 @@ static int find_next_best_node(int node, unsigned long *used_nodes)
                         continue;
 
                 /* Skip already used nodes */
-                if (test_bit(n, used_nodes))
+                if (node_isset(n, *used_nodes))
                         continue;
 
                 /* Simple min distance search */
@@ -6328,40 +7028,36 @@ static int find_next_best_node(int node, unsigned long *used_nodes)
                 }
         }
 
-        set_bit(best_node, used_nodes);
+        node_set(best_node, *used_nodes);
         return best_node;
 }
 
 /**
  * sched_domain_node_span - get a cpumask for a node's sched_domain
  * @node: node whose cpumask we're constructing
- * @size: number of nodes to include in this span
  *
  * Given a node, construct a good cpumask for its sched_domain to span. It
  * should be one that prevents unnecessary balancing, but also spreads tasks
  * out optimally.
  */
-static cpumask_t sched_domain_node_span(int node)
+static void sched_domain_node_span(int node, cpumask_t *span)
 {
-        DECLARE_BITMAP(used_nodes, MAX_NUMNODES);
-        cpumask_t span, nodemask;
+        nodemask_t used_nodes;
+        node_to_cpumask_ptr(nodemask, node);
         int i;
 
-        cpus_clear(span);
-        bitmap_zero(used_nodes, MAX_NUMNODES);
+        cpus_clear(*span);
+        nodes_clear(used_nodes);
 
-        nodemask = node_to_cpumask(node);
-        cpus_or(span, span, nodemask);
-        set_bit(node, used_nodes);
+        cpus_or(*span, *span, *nodemask);
+        node_set(node, used_nodes);
 
         for (i = 1; i < SD_NODES_PER_DOMAIN; i++) {
-                int next_node = find_next_best_node(node, used_nodes);
+                int next_node = find_next_best_node(node, &used_nodes);
 
-                nodemask = node_to_cpumask(next_node);
-                cpus_or(span, span, nodemask);
+                node_to_cpumask_ptr_next(nodemask, next_node);
+                cpus_or(*span, *span, *nodemask);
         }
-
-        return span;
 }
 #endif
 
@@ -6375,7 +7071,8 @@ static DEFINE_PER_CPU(struct sched_domain, cpu_domains);
 static DEFINE_PER_CPU(struct 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 cpumask_t *cpu_map, struct sched_group **sg,
+                 cpumask_t *unused)
 {
         if (sg)
                 *sg = &per_cpu(sched_group_cpus, cpu);
@@ -6393,19 +7090,22 @@ static DEFINE_PER_CPU(struct sched_group, sched_group_core);
 
 #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 cpumask_t *cpu_map, struct sched_group **sg,
+                  cpumask_t *mask)
 {
         int group;
-        cpumask_t mask = per_cpu(cpu_sibling_map, cpu);
-        cpus_and(mask, mask, *cpu_map);
-        group = first_cpu(mask);
+
+        *mask = per_cpu(cpu_sibling_map, cpu);
+        cpus_and(*mask, *mask, *cpu_map);
+        group = first_cpu(*mask);
         if (sg)
                 *sg = &per_cpu(sched_group_core, group);
         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 cpumask_t *cpu_map, struct sched_group **sg,
+                  cpumask_t *unused)
 {
         if (sg)
                 *sg = &per_cpu(sched_group_core, cpu);
@@ -6417,17 +7117,18 @@ static DEFINE_PER_CPU(struct sched_domain, phys_domains);
 static DEFINE_PER_CPU(struct 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 cpumask_t *cpu_map, struct sched_group **sg,
+                  cpumask_t *mask)
 {
         int group;
 #ifdef CONFIG_SCHED_MC
-        cpumask_t mask = cpu_coregroup_map(cpu);
-        cpus_and(mask, mask, *cpu_map);
-        group = first_cpu(mask);
+        *mask = cpu_coregroup_map(cpu);
+        cpus_and(*mask, *mask, *cpu_map);
+        group = first_cpu(*mask);
 #elif defined(CONFIG_SCHED_SMT)
-        cpumask_t mask = per_cpu(cpu_sibling_map, cpu);
-        cpus_and(mask, mask, *cpu_map);
-        group = first_cpu(mask);
+        *mask = per_cpu(cpu_sibling_map, cpu);
+        cpus_and(*mask, *mask, *cpu_map);
+        group = first_cpu(*mask);
 #else
         group = cpu;
 #endif
@@ -6443,19 +7144,19 @@ cpu_to_phys_group(int cpu, const cpumask_t *cpu_map, struct sched_group **sg)
  * gets dynamically allocated.
  */
 static DEFINE_PER_CPU(struct sched_domain, node_domains);
-static struct sched_group **sched_group_nodes_bycpu[NR_CPUS];
+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 int cpu_to_allnodes_group(int cpu, const cpumask_t *cpu_map,
-                                 struct sched_group **sg)
+                                 struct sched_group **sg, cpumask_t *nodemask)
 {
-        cpumask_t nodemask = node_to_cpumask(cpu_to_node(cpu));
         int group;
 
-        cpus_and(nodemask, nodemask, *cpu_map);
-        group = first_cpu(nodemask);
+        *nodemask = node_to_cpumask(cpu_to_node(cpu));
+        cpus_and(*nodemask, *nodemask, *cpu_map);
+        group = first_cpu(*nodemask);
 
         if (sg)
                 *sg = &per_cpu(sched_group_allnodes, group);
@@ -6491,7 +7192,7 @@ 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)
+static void free_sched_groups(const cpumask_t *cpu_map, cpumask_t *nodemask)
 {
         int cpu, i;
 
@@ -6503,11 +7204,11 @@ static void free_sched_groups(const cpumask_t *cpu_map)
                         continue;
 
                 for (i = 0; i < MAX_NUMNODES; i++) {
-                        cpumask_t nodemask = node_to_cpumask(i);
                         struct sched_group *oldsg, *sg = sched_group_nodes[i];
 
-                        cpus_and(nodemask, nodemask, *cpu_map);
-                        if (cpus_empty(nodemask))
+                        *nodemask = node_to_cpumask(i);
+                        cpus_and(*nodemask, *nodemask, *cpu_map);
+                        if (cpus_empty(*nodemask))
                                 continue;
 
                         if (sg == NULL)
@@ -6525,7 +7226,7 @@ next_sg:
         }
 }
 #else
-static void free_sched_groups(const cpumask_t *cpu_map)
+static void free_sched_groups(const cpumask_t *cpu_map, cpumask_t *nodemask)
 {
 }
 #endif
@@ -6583,13 +7284,106 @@ static void init_sched_groups_power(int cpu, struct sched_domain *sd)
 }
 
 /*
+ * Initializers for schedule domains
+ * Non-inlined to reduce accumulated stack pressure in build_sched_domains()
+ */
+
+#define SD_INIT(sd, type)       sd_init_##type(sd)
+#define SD_INIT_FUNC(type)      \
+static noinline void sd_init_##type(struct sched_domain *sd)    \
+{                                                               \
+        memset(sd, 0, sizeof(*sd));                             \
+        *sd = SD_##type##_INIT;                                 \
+        sd->level = SD_LV_##type;                               \
+}
+
+SD_INIT_FUNC(CPU)
+#ifdef CONFIG_NUMA
+ SD_INIT_FUNC(ALLNODES)
+ SD_INIT_FUNC(NODE)
+#endif
+#ifdef CONFIG_SCHED_SMT
+ SD_INIT_FUNC(SIBLING)
+#endif
+#ifdef CONFIG_SCHED_MC
+ 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)
+{
+        default_relax_domain_level = simple_strtoul(str, NULL, 0);
+        return 1;
+}
+__setup("relax_domain_level=", setup_relax_domain_level);
+
+static void set_domain_attribute(struct sched_domain *sd,
+                                 struct sched_domain_attr *attr)
+{
+        int request;
+
+        if (!attr || attr->relax_domain_level < 0) {
+                if (default_relax_domain_level < 0)
+                        return;
+                else
+                        request = default_relax_domain_level;
+        } else
+                request = attr->relax_domain_level;
+        if (request < sd->level) {
+                /* turn off idle balance on this domain */
+                sd->flags &= ~(SD_WAKE_IDLE|SD_BALANCE_NEWIDLE);
+        } else {
+                /* turn on idle balance on this domain */
+                sd->flags |= (SD_WAKE_IDLE_FAR|SD_BALANCE_NEWIDLE);
+        }
+}
+
+/*
  * 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 cpumask_t *cpu_map,
+                                 struct sched_domain_attr *attr)
 {
         int i;
         struct root_domain *rd;
+        SCHED_CPUMASK_DECLARE(allmasks);
+        cpumask_t *tmpmask;
 #ifdef CONFIG_NUMA
         struct sched_group **sched_group_nodes = NULL;
         int sd_allnodes = 0;
@@ -6603,39 +7397,65 @@ static int build_sched_domains(const cpumask_t *cpu_map)
                 printk(KERN_WARNING "Can not alloc sched group node list\n");
                 return -ENOMEM;
         }
-        sched_group_nodes_bycpu[first_cpu(*cpu_map)] = sched_group_nodes;
 #endif
 
         rd = alloc_rootdomain();
         if (!rd) {
                 printk(KERN_WARNING "Cannot alloc root domain\n");
+#ifdef CONFIG_NUMA
+                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;
+#endif
+
         /*
          * Set up domains for cpus specified by the cpu_map.
          */
         for_each_cpu_mask(i, *cpu_map) {
                 struct sched_domain *sd = NULL, *p;
-                cpumask_t nodemask = node_to_cpumask(cpu_to_node(i));
+                SCHED_CPUMASK_VAR(nodemask, allmasks);
 
-                cpus_and(nodemask, nodemask, *cpu_map);
+                *nodemask = node_to_cpumask(cpu_to_node(i));
+                cpus_and(*nodemask, *nodemask, *cpu_map);
 
 #ifdef CONFIG_NUMA
                 if (cpus_weight(*cpu_map) >
-                                SD_NODES_PER_DOMAIN*cpus_weight(nodemask)) {
+                                SD_NODES_PER_DOMAIN*cpus_weight(*nodemask)) {
                         sd = &per_cpu(allnodes_domains, i);
-                        *sd = SD_ALLNODES_INIT;
+                        SD_INIT(sd, ALLNODES);
+                        set_domain_attribute(sd, attr);
                         sd->span = *cpu_map;
-                        cpu_to_allnodes_group(i, cpu_map, &sd->groups);
+                        sd->first_cpu = first_cpu(sd->span);
+                        cpu_to_allnodes_group(i, cpu_map, &sd->groups, tmpmask);
                         p = sd;
                         sd_allnodes = 1;
                 } else
                         p = NULL;
 
                 sd = &per_cpu(node_domains, i);
-                *sd = SD_NODE_INIT;
-                sd->span = sched_domain_node_span(cpu_to_node(i));
+                SD_INIT(sd, NODE);
+                set_domain_attribute(sd, attr);
+                sched_domain_node_span(cpu_to_node(i), &sd->span);
+                sd->first_cpu = first_cpu(sd->span);
                 sd->parent = p;
                 if (p)
                         p->child = sd;
@@ -6644,94 +7464,120 @@ static int build_sched_domains(const cpumask_t *cpu_map)
 
                 p = sd;
                 sd = &per_cpu(phys_domains, i);
-                *sd = SD_CPU_INIT;
-                sd->span = nodemask;
+                SD_INIT(sd, CPU);
+                set_domain_attribute(sd, attr);
+                sd->span = *nodemask;
+                sd->first_cpu = first_cpu(sd->span);
                 sd->parent = p;
                 if (p)
                         p->child = sd;
-                cpu_to_phys_group(i, cpu_map, &sd->groups);
+                cpu_to_phys_group(i, cpu_map, &sd->groups, tmpmask);
 
 #ifdef CONFIG_SCHED_MC
                 p = sd;
                 sd = &per_cpu(core_domains, i);
-                *sd = SD_MC_INIT;
+                SD_INIT(sd, MC);
+                set_domain_attribute(sd, attr);
                 sd->span = cpu_coregroup_map(i);
+                sd->first_cpu = first_cpu(sd->span);
                 cpus_and(sd->span, sd->span, *cpu_map);
                 sd->parent = p;
                 p->child = sd;
-                cpu_to_core_group(i, cpu_map, &sd->groups);
+                cpu_to_core_group(i, cpu_map, &sd->groups, tmpmask);
 #endif
 
 #ifdef CONFIG_SCHED_SMT
                 p = sd;
                 sd = &per_cpu(cpu_domains, i);
-                *sd = SD_SIBLING_INIT;
+                SD_INIT(sd, SIBLING);
+                set_domain_attribute(sd, attr);
                 sd->span = per_cpu(cpu_sibling_map, i);
+                sd->first_cpu = first_cpu(sd->span);
                 cpus_and(sd->span, sd->span, *cpu_map);
                 sd->parent = p;
                 p->child = sd;
-                cpu_to_cpu_group(i, cpu_map, &sd->groups);
+                cpu_to_cpu_group(i, cpu_map, &sd->groups, tmpmask);
 #endif
         }
 
 #ifdef CONFIG_SCHED_SMT
         /* Set up CPU (sibling) groups */
         for_each_cpu_mask(i, *cpu_map) {
-                cpumask_t 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))
+                SCHED_CPUMASK_VAR(this_sibling_map, allmasks);
+                SCHED_CPUMASK_VAR(send_covered, allmasks);
+
+                *this_sibling_map = per_cpu(cpu_sibling_map, i);
+                cpus_and(*this_sibling_map, *this_sibling_map, *cpu_map);
+                if (i != first_cpu(*this_sibling_map))
                         continue;
 
                 init_sched_build_groups(this_sibling_map, cpu_map,
-                                        &cpu_to_cpu_group);
+                                        &cpu_to_cpu_group,
+                                        send_covered, tmpmask);
         }
 #endif
 
 #ifdef CONFIG_SCHED_MC
         /* Set up multi-core groups */
         for_each_cpu_mask(i, *cpu_map) {
-                cpumask_t this_core_map = cpu_coregroup_map(i);
-                cpus_and(this_core_map, this_core_map, *cpu_map);
-                if (i != first_cpu(this_core_map))
+                SCHED_CPUMASK_VAR(this_core_map, allmasks);
+                SCHED_CPUMASK_VAR(send_covered, allmasks);
+
+                *this_core_map = cpu_coregroup_map(i);
+                cpus_and(*this_core_map, *this_core_map, *cpu_map);
+                if (i != first_cpu(*this_core_map))
                         continue;
+
                 init_sched_build_groups(this_core_map, cpu_map,
-                                        &cpu_to_core_group);
+                                        &cpu_to_core_group,
+                                        send_covered, tmpmask);
         }
 #endif
 
         /* Set up physical groups */
         for (i = 0; i < MAX_NUMNODES; i++) {
-                cpumask_t nodemask = node_to_cpumask(i);
+                SCHED_CPUMASK_VAR(nodemask, allmasks);
+                SCHED_CPUMASK_VAR(send_covered, allmasks);
 
-                cpus_and(nodemask, nodemask, *cpu_map);
-                if (cpus_empty(nodemask))
+                *nodemask = node_to_cpumask(i);
+                cpus_and(*nodemask, *nodemask, *cpu_map);
+                if (cpus_empty(*nodemask))
                         continue;
 
-                init_sched_build_groups(nodemask, cpu_map, &cpu_to_phys_group);
+                init_sched_build_groups(nodemask, cpu_map,
+                                        &cpu_to_phys_group,
+                                        send_covered, tmpmask);
         }
 
 #ifdef CONFIG_NUMA
         /* Set up node groups */
-        if (sd_allnodes)
-                init_sched_build_groups(*cpu_map, cpu_map,
-                                        &cpu_to_allnodes_group);
+        if (sd_allnodes) {
+                SCHED_CPUMASK_VAR(send_covered, allmasks);
+
+                init_sched_build_groups(cpu_map, cpu_map,
+                                        &cpu_to_allnodes_group,
+                                        send_covered, tmpmask);
+        }
 
         for (i = 0; i < MAX_NUMNODES; i++) {
                 /* Set up node groups */
                 struct sched_group *sg, *prev;
-                cpumask_t nodemask = node_to_cpumask(i);
-                cpumask_t domainspan;
-                cpumask_t covered = CPU_MASK_NONE;
+                SCHED_CPUMASK_VAR(nodemask, allmasks);
+                SCHED_CPUMASK_VAR(domainspan, allmasks);
+                SCHED_CPUMASK_VAR(covered, allmasks);
                 int j;
 
-                cpus_and(nodemask, nodemask, *cpu_map);
-                if (cpus_empty(nodemask)) {
+                *nodemask = node_to_cpumask(i);
+                cpus_clear(*covered);
+
+                cpus_and(*nodemask, *nodemask, *cpu_map);
+                if (cpus_empty(*nodemask)) {
                         sched_group_nodes[i] = NULL;
                         continue;
                 }
 
-                domainspan = sched_domain_node_span(i);
-                cpus_and(domainspan, domainspan, *cpu_map);
+                sched_domain_node_span(i, domainspan);
+                cpus_and(*domainspan, *domainspan, *cpu_map);
 
                 sg = kmalloc_node(sizeof(struct sched_group), GFP_KERNEL, i);
                 if (!sg) {
@@ -6740,31 +7586,31 @@ static int build_sched_domains(const cpumask_t *cpu_map)
                         goto error;
                 }
                 sched_group_nodes[i] = sg;
-                for_each_cpu_mask(j, nodemask) {
+                for_each_cpu_mask(j, *nodemask) {
                         struct sched_domain *sd;
 
                         sd = &per_cpu(node_domains, j);
                         sd->groups = sg;
                 }
                 sg->__cpu_power = 0;
-                sg->cpumask = nodemask;
+                sg->cpumask = *nodemask;
                 sg->next = sg;
-                cpus_or(covered, covered, nodemask);
+                cpus_or(*covered, *covered, *nodemask);
                 prev = sg;
 
                 for (j = 0; j < MAX_NUMNODES; j++) {
-                        cpumask_t tmp, notcovered;
+                        SCHED_CPUMASK_VAR(notcovered, allmasks);
                         int n = (i + j) % MAX_NUMNODES;
+                        node_to_cpumask_ptr(pnodemask, n);
 
-                        cpus_complement(notcovered, covered);
-                        cpus_and(tmp, notcovered, *cpu_map);
-                        cpus_and(tmp, tmp, domainspan);
-                        if (cpus_empty(tmp))
+                        cpus_complement(*notcovered, *covered);
+                        cpus_and(*tmpmask, *notcovered, *cpu_map);
+                        cpus_and(*tmpmask, *tmpmask, *domainspan);
+                        if (cpus_empty(*tmpmask))
                                 break;
 
-                        nodemask = node_to_cpumask(n);
-                        cpus_and(tmp, tmp, nodemask);
-                        if (cpus_empty(tmp))
+                        cpus_and(*tmpmask, *tmpmask, *pnodemask);
+                        if (cpus_empty(*tmpmask))
                                 continue;
 
                         sg = kmalloc_node(sizeof(struct sched_group),
@@ -6775,9 +7621,9 @@ static int build_sched_domains(const cpumask_t *cpu_map)
                                 goto error;
                         }
                         sg->__cpu_power = 0;
-                        sg->cpumask = tmp;
+                        sg->cpumask = *tmpmask;
                         sg->next = prev->next;
-                        cpus_or(covered, covered, tmp);
+                        cpus_or(*covered, *covered, *tmpmask);
                         prev->next = sg;
                         prev = sg;
                 }
@@ -6813,7 +7659,8 @@ 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(first_cpu(*cpu_map), cpu_map, &sg,
+                                                                tmpmask);
                 init_numa_sched_groups_power(sg);
         }
 #endif
@@ -6831,17 +7678,26 @@ static int build_sched_domains(const cpumask_t *cpu_map)
                 cpu_attach_domain(sd, rd, i);
         }
 
+        SCHED_CPUMASK_FREE((void *)allmasks);
         return 0;
 
 #ifdef CONFIG_NUMA
 error:
-        free_sched_groups(cpu_map);
+        free_sched_groups(cpu_map, tmpmask);
+        SCHED_CPUMASK_FREE((void *)allmasks);
         return -ENOMEM;
 #endif
 }
 
+static int build_sched_domains(const cpumask_t *cpu_map)
+{
+        return __build_sched_domains(cpu_map, NULL);
+}
+
 static cpumask_t *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
@@ -6869,15 +7725,17 @@ static int arch_init_sched_domains(const cpumask_t *cpu_map)
         if (!doms_cur)
                 doms_cur = &fallback_doms;
         cpus_andnot(*doms_cur, *cpu_map, cpu_isolated_map);
+        dattr_cur = NULL;
         err = build_sched_domains(doms_cur);
         register_sched_domain_sysctl();
 
         return err;
 }
 
-static void arch_destroy_sched_domains(const cpumask_t *cpu_map)
+static void arch_destroy_sched_domains(const cpumask_t *cpu_map,
+                                       cpumask_t *tmpmask)
 {
-        free_sched_groups(cpu_map);
+        free_sched_groups(cpu_map, tmpmask);
 }
 
 /*
@@ -6886,6 +7744,7 @@ static void arch_destroy_sched_domains(const cpumask_t *cpu_map)
  */
 static void detach_destroy_domains(const cpumask_t *cpu_map)
 {
+        cpumask_t tmpmask;
         int i;
 
         unregister_sched_domain_sysctl();
@@ -6893,7 +7752,23 @@ static void detach_destroy_domains(const cpumask_t *cpu_map)
         for_each_cpu_mask(i, *cpu_map)
                 cpu_attach_domain(NULL, &def_root_domain, i);
         synchronize_sched();
-        arch_destroy_sched_domains(cpu_map);
+        arch_destroy_sched_domains(cpu_map, &tmpmask);
+}
+
+/* handle null as "default" */
+static int dattrs_equal(struct sched_domain_attr *cur, int idx_cur,
+                        struct sched_domain_attr *new, int idx_new)
+{
+        struct sched_domain_attr tmp;
+
+        /* fast path */
+        if (!new && !cur)
+                return 1;
+
+        tmp = SD_ATTR_INIT;
+        return !memcmp(cur ? (cur + idx_cur) : &tmp,
+                        new ? (new + idx_new) : &tmp,
+                        sizeof(struct sched_domain_attr));
 }
 
 /*
@@ -6917,7 +7792,8 @@ static void detach_destroy_domains(const cpumask_t *cpu_map)
  *
  * Call with hotplug lock held
  */
-void partition_sched_domains(int ndoms_new, cpumask_t *doms_new)
+void partition_sched_domains(int ndoms_new, cpumask_t *doms_new,
+                             struct sched_domain_attr *dattr_new)
 {
         int i, j;
 
@@ -6930,12 +7806,14 @@ void partition_sched_domains(int ndoms_new, cpumask_t *doms_new)
                 ndoms_new = 1;
                 doms_new = &fallback_doms;
                 cpus_andnot(doms_new[0], cpu_online_map, cpu_isolated_map);
+                dattr_new = NULL;
         }
 
         /* Destroy deleted domains */
         for (i = 0; i < ndoms_cur; i++) {
                 for (j = 0; j < ndoms_new; j++) {
-                        if (cpus_equal(doms_cur[i], doms_new[j]))
+                        if (cpus_equal(doms_cur[i], doms_new[j])
+                            && dattrs_equal(dattr_cur, i, dattr_new, j))
                                 goto match1;
                 }
                 /* no match - a current sched domain not in new doms_new[] */
@@ -6947,11 +7825,13 @@ match1:
         /* 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 (cpus_equal(doms_new[i], doms_cur[j])
+                            && dattrs_equal(dattr_new, i, dattr_cur, j))
                                 goto match2;
                 }
                 /* no match - add a new doms_new */
-                build_sched_domains(doms_new + i);
+                __build_sched_domains(doms_new + i,
+                                        dattr_new ? dattr_new + i : NULL);
 match2:
                 ;
         }
@@ -6959,7 +7839,9 @@ match2:
         /* Remember the new sched domains */
         if (doms_cur != &fallback_doms)
                 kfree(doms_cur);
+        kfree(dattr_cur);       /* kfree(NULL) is safe */
         doms_cur = doms_new;
+        dattr_cur = dattr_new;
         ndoms_cur = ndoms_new;
 
         register_sched_domain_sysctl();
@@ -7086,6 +7968,11 @@ void __init sched_init_smp(void)
 {
         cpumask_t non_isolated_cpus;
 
+#if defined(CONFIG_NUMA)
+        sched_group_nodes_bycpu = kzalloc(nr_cpu_ids * sizeof(void **),
+                                                                GFP_KERNEL);
+        BUG_ON(sched_group_nodes_bycpu == NULL);
+#endif
         get_online_cpus();
         arch_init_sched_domains(&cpu_online_map);
         cpus_andnot(non_isolated_cpus, cpu_possible_map, cpu_isolated_map);
@@ -7096,13 +7983,18 @@ void __init sched_init_smp(void)
         hotcpu_notifier(update_sched_domains, 0);
 
         /* Move init over to a non-isolated CPU */
-        if (set_cpus_allowed(current, non_isolated_cpus) < 0)
+        if (set_cpus_allowed_ptr(current, &non_isolated_cpus) < 0)
                 BUG();
         sched_init_granularity();
 }
 #else
 void __init sched_init_smp(void)
 {
+#if defined(CONFIG_NUMA)
+        sched_group_nodes_bycpu = kzalloc(nr_cpu_ids * sizeof(void **),
+                                                                GFP_KERNEL);
+        BUG_ON(sched_group_nodes_bycpu == NULL);
+#endif
         sched_init_granularity();
 }
 #endif /* CONFIG_SMP */
@@ -7117,6 +8009,7 @@ int in_sched_functions(unsigned long addr)
 static void init_cfs_rq(struct cfs_rq *cfs_rq, struct rq *rq)
 {
         cfs_rq->tasks_timeline = RB_ROOT;
+        INIT_LIST_HEAD(&cfs_rq->tasks);
 #ifdef CONFIG_FAIR_GROUP_SCHED
         cfs_rq->rq = rq;
 #endif
@@ -7146,6 +8039,8 @@ static void init_rt_rq(struct rt_rq *rt_rq, struct rq *rq)
 
         rt_rq->rt_time = 0;
         rt_rq->rt_throttled = 0;
+        rt_rq->rt_runtime = 0;
+        spin_lock_init(&rt_rq->rt_runtime_lock);
 
 #ifdef CONFIG_RT_GROUP_SCHED
         rt_rq->rt_nr_boosted = 0;
@@ -7154,10 +8049,11 @@ static void init_rt_rq(struct rt_rq *rt_rq, struct rq *rq)
 }
 
 #ifdef CONFIG_FAIR_GROUP_SCHED
-static void init_tg_cfs_entry(struct rq *rq, struct task_group *tg,
-                struct cfs_rq *cfs_rq, struct sched_entity *se,
-                int cpu, int add)
+static void init_tg_cfs_entry(struct task_group *tg, struct cfs_rq *cfs_rq,
+                                struct sched_entity *se, int cpu, int add,
+                                struct sched_entity *parent)
 {
+        struct rq *rq = cpu_rq(cpu);
         tg->cfs_rq[cpu] = cfs_rq;
         init_cfs_rq(cfs_rq, rq);
         cfs_rq->tg = tg;
@@ -7165,45 +8061,132 @@ static void init_tg_cfs_entry(struct rq *rq, struct task_group *tg,
                 list_add(&cfs_rq->leaf_cfs_rq_list, &rq->leaf_cfs_rq_list);
 
         tg->se[cpu] = se;
-        se->cfs_rq = &rq->cfs;
+        /* se could be NULL for init_task_group */
+        if (!se)
+                return;
+
+        if (!parent)
+                se->cfs_rq = &rq->cfs;
+        else
+                se->cfs_rq = parent->my_q;
+
         se->my_q = cfs_rq;
         se->load.weight = tg->shares;
         se->load.inv_weight = div64_64(1ULL<<32, se->load.weight);
-        se->parent = NULL;
+        se->parent = parent;
 }
 #endif
 
 #ifdef CONFIG_RT_GROUP_SCHED
-static void init_tg_rt_entry(struct rq *rq, struct task_group *tg,
-                struct rt_rq *rt_rq, struct sched_rt_entity *rt_se,
-                int cpu, int add)
+static void init_tg_rt_entry(struct task_group *tg, struct rt_rq *rt_rq,
+                struct sched_rt_entity *rt_se, int cpu, int add,
+                struct sched_rt_entity *parent)
 {
+        struct rq *rq = cpu_rq(cpu);
+
         tg->rt_rq[cpu] = rt_rq;
         init_rt_rq(rt_rq, rq);
         rt_rq->tg = tg;
         rt_rq->rt_se = rt_se;
+        rt_rq->rt_runtime = tg->rt_bandwidth.rt_runtime;
         if (add)
                 list_add(&rt_rq->leaf_rt_rq_list, &rq->leaf_rt_rq_list);
 
         tg->rt_se[cpu] = rt_se;
+        if (!rt_se)
+                return;
+
+        if (!parent)
+                rt_se->rt_rq = &rq->rt;
+        else
+                rt_se->rt_rq = parent->my_q;
+
         rt_se->rt_rq = &rq->rt;
         rt_se->my_q = rt_rq;
-        rt_se->parent = NULL;
+        rt_se->parent = parent;
         INIT_LIST_HEAD(&rt_se->run_list);
 }
 #endif
 
 void __init sched_init(void)
 {
-        int highest_cpu = 0;
         int i, j;
+        unsigned long alloc_size = 0, ptr;
+
+#ifdef CONFIG_FAIR_GROUP_SCHED
+        alloc_size += 2 * nr_cpu_ids * sizeof(void **);
+#endif
+#ifdef CONFIG_RT_GROUP_SCHED
+        alloc_size += 2 * nr_cpu_ids * sizeof(void **);
+#endif
+#ifdef CONFIG_USER_SCHED
+        alloc_size *= 2;
+#endif
+        /*
+         * As sched_init() is called before page_alloc is setup,
+         * we use alloc_bootmem().
+         */
+        if (alloc_size) {
+                ptr = (unsigned long)alloc_bootmem_low(alloc_size);
+
+#ifdef CONFIG_FAIR_GROUP_SCHED
+                init_task_group.se = (struct sched_entity **)ptr;
+                ptr += nr_cpu_ids * sizeof(void **);
+
+                init_task_group.cfs_rq = (struct cfs_rq **)ptr;
+                ptr += nr_cpu_ids * sizeof(void **);
+
+#ifdef CONFIG_USER_SCHED
+                root_task_group.se = (struct sched_entity **)ptr;
+                ptr += nr_cpu_ids * sizeof(void **);
+
+                root_task_group.cfs_rq = (struct cfs_rq **)ptr;
+                ptr += nr_cpu_ids * sizeof(void **);
+#endif
+#endif
+#ifdef CONFIG_RT_GROUP_SCHED
+                init_task_group.rt_se = (struct sched_rt_entity **)ptr;
+                ptr += nr_cpu_ids * sizeof(void **);
+
+                init_task_group.rt_rq = (struct rt_rq **)ptr;
+                ptr += nr_cpu_ids * sizeof(void **);
+
+#ifdef CONFIG_USER_SCHED
+                root_task_group.rt_se = (struct sched_rt_entity **)ptr;
+                ptr += nr_cpu_ids * sizeof(void **);
+
+                root_task_group.rt_rq = (struct rt_rq **)ptr;
+                ptr += nr_cpu_ids * sizeof(void **);
+#endif
+#endif
+        }
 
 #ifdef CONFIG_SMP
+        init_aggregate();
         init_defrootdomain();
 #endif
 
+        init_rt_bandwidth(&def_rt_bandwidth,
+                        global_rt_period(), global_rt_runtime());
+
+#ifdef CONFIG_RT_GROUP_SCHED
+        init_rt_bandwidth(&init_task_group.rt_bandwidth,
+                        global_rt_period(), global_rt_runtime());
+#ifdef CONFIG_USER_SCHED
+        init_rt_bandwidth(&root_task_group.rt_bandwidth,
+                        global_rt_period(), RUNTIME_INF);
+#endif
+#endif
+
 #ifdef CONFIG_GROUP_SCHED
         list_add(&init_task_group.list, &task_groups);
+        INIT_LIST_HEAD(&init_task_group.children);
+
+#ifdef CONFIG_USER_SCHED
+        INIT_LIST_HEAD(&root_task_group.children);
+        init_task_group.parent = &root_task_group;
+        list_add(&init_task_group.siblings, &root_task_group.children);
+#endif
 #endif
 
         for_each_possible_cpu(i) {
@@ -7214,26 +8197,68 @@ void __init sched_init(void)
                 lockdep_set_class(&rq->lock, &rq->rq_lock_key);
                 rq->nr_running = 0;
                 rq->clock = 1;
+                update_last_tick_seen(rq);
                 init_cfs_rq(&rq->cfs, rq);
                 init_rt_rq(&rq->rt, rq);
 #ifdef CONFIG_FAIR_GROUP_SCHED
                 init_task_group.shares = init_task_group_load;
                 INIT_LIST_HEAD(&rq->leaf_cfs_rq_list);
-                init_tg_cfs_entry(rq, &init_task_group,
+#ifdef CONFIG_CGROUP_SCHED
+                /*
+                 * How much cpu bandwidth does init_task_group get?
+                 *
+                 * In case of task-groups formed thr' the cgroup filesystem, it
+                 * gets 100% of the cpu resources in the system. This overall
+                 * system cpu resource is divided among the tasks of
+                 * init_task_group and its child task-groups in a fair manner,
+                 * based on each entity's (task or task-group's) weight
+                 * (se->load.weight).
+                 *
+                 * In other words, if init_task_group has 10 tasks of weight
+                 * 1024) and two child groups A0 and A1 (of weight 1024 each),
+                 * then A0's share of the cpu resource is:
+                 *
+                 *      A0's bandwidth = 1024 / (10*1024 + 1024 + 1024) = 8.33%
+                 *
+                 * We achieve this by letting init_task_group's tasks sit
+                 * directly in rq->cfs (i.e init_task_group->se[] = NULL).
+                 */
+                init_tg_cfs_entry(&init_task_group, &rq->cfs, NULL, i, 1, NULL);
+#elif defined CONFIG_USER_SCHED
+                root_task_group.shares = NICE_0_LOAD;
+                init_tg_cfs_entry(&root_task_group, &rq->cfs, NULL, i, 0, NULL);
+                /*
+                 * In case of task-groups formed thr' the user id of tasks,
+                 * init_task_group represents tasks belonging to root user.
+                 * Hence it forms a sibling of all subsequent groups formed.
+                 * In this case, init_task_group gets only a fraction of overall
+                 * system cpu resource, based on the weight assigned to root
+                 * user's cpu share (INIT_TASK_GROUP_LOAD). This is accomplished
+                 * by letting tasks of init_task_group sit in a separate cfs_rq
+                 * (init_cfs_rq) and having one entity represent this group of
+                 * tasks in rq->cfs (i.e init_task_group->se[] != NULL).
+                 */
+                init_tg_cfs_entry(&init_task_group,
                                 &per_cpu(init_cfs_rq, i),
-                                &per_cpu(init_sched_entity, i), i, 1);
+                                &per_cpu(init_sched_entity, i), i, 1,
+                                root_task_group.se[i]);
 
 #endif
+#endif /* CONFIG_FAIR_GROUP_SCHED */
+
+                rq->rt.rt_runtime = def_rt_bandwidth.rt_runtime;
 #ifdef CONFIG_RT_GROUP_SCHED
-                init_task_group.rt_runtime =
-                        sysctl_sched_rt_runtime * NSEC_PER_USEC;
                 INIT_LIST_HEAD(&rq->leaf_rt_rq_list);
-                init_tg_rt_entry(rq, &init_task_group,
+#ifdef CONFIG_CGROUP_SCHED
+                init_tg_rt_entry(&init_task_group, &rq->rt, NULL, i, 1, NULL);
+#elif defined CONFIG_USER_SCHED
+                init_tg_rt_entry(&root_task_group, &rq->rt, NULL, i, 0, NULL);
+                init_tg_rt_entry(&init_task_group,
                                 &per_cpu(init_rt_rq, i),
-                                &per_cpu(init_sched_rt_entity, i), i, 1);
+                                &per_cpu(init_sched_rt_entity, i), i, 1,
+                                root_task_group.rt_se[i]);
+#endif
 #endif
-                rq->rt_period_expire = 0;
-                rq->rt_throttled = 0;
 
                 for (j = 0; j < CPU_LOAD_IDX_MAX; j++)
                         rq->cpu_load[j] = 0;
@@ -7250,7 +8275,6 @@ void __init sched_init(void)
 #endif
                 init_rq_hrtick(rq);
                 atomic_set(&rq->nr_iowait, 0);
-                highest_cpu = i;
         }
 
         set_load_weight(&init_task);
@@ -7260,7 +8284,6 @@ void __init sched_init(void)
 #endif
 
 #ifdef CONFIG_SMP
-        nr_cpu_ids = highest_cpu + 1;
         open_softirq(SCHED_SOFTIRQ, run_rebalance_domains, NULL);
 #endif
 
@@ -7419,8 +8442,6 @@ void set_curr_task(int cpu, struct task_struct *p)
 
 #endif
 
-#ifdef CONFIG_GROUP_SCHED
-
 #ifdef CONFIG_FAIR_GROUP_SCHED
 static void free_fair_sched_group(struct task_group *tg)
 {
@@ -7437,17 +8458,18 @@ static void free_fair_sched_group(struct task_group *tg)
         kfree(tg->se);
 }
 
-static int alloc_fair_sched_group(struct task_group *tg)
+static
+int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
 {
         struct cfs_rq *cfs_rq;
-        struct sched_entity *se;
+        struct sched_entity *se, *parent_se;
         struct rq *rq;
         int i;
 
-        tg->cfs_rq = kzalloc(sizeof(cfs_rq) * NR_CPUS, GFP_KERNEL);
+        tg->cfs_rq = kzalloc(sizeof(cfs_rq) * nr_cpu_ids, GFP_KERNEL);
         if (!tg->cfs_rq)
                 goto err;
-        tg->se = kzalloc(sizeof(se) * NR_CPUS, GFP_KERNEL);
+        tg->se = kzalloc(sizeof(se) * nr_cpu_ids, GFP_KERNEL);
         if (!tg->se)
                 goto err;
 
@@ -7466,7 +8488,8 @@ static int alloc_fair_sched_group(struct task_group *tg)
                 if (!se)
                         goto err;
 
-                init_tg_cfs_entry(rq, tg, cfs_rq, se, i, 0);
+                parent_se = parent ? parent->se[i] : NULL;
+                init_tg_cfs_entry(tg, cfs_rq, se, i, 0, parent_se);
         }
 
         return 1;
@@ -7490,7 +8513,8 @@ static inline void free_fair_sched_group(struct task_group *tg)
 {
 }
 
-static inline int alloc_fair_sched_group(struct task_group *tg)
+static inline
+int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
 {
         return 1;
 }
@@ -7509,6 +8533,8 @@ static void free_rt_sched_group(struct task_group *tg)
 {
         int i;
 
+        destroy_rt_bandwidth(&tg->rt_bandwidth);
+
         for_each_possible_cpu(i) {
                 if (tg->rt_rq)
                         kfree(tg->rt_rq[i]);
@@ -7520,21 +8546,23 @@ static void free_rt_sched_group(struct task_group *tg)
         kfree(tg->rt_se);
 }
 
-static int alloc_rt_sched_group(struct task_group *tg)
+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;
+        struct sched_rt_entity *rt_se, *parent_se;
         struct rq *rq;
         int i;
 
-        tg->rt_rq = kzalloc(sizeof(rt_rq) * NR_CPUS, GFP_KERNEL);
+        tg->rt_rq = kzalloc(sizeof(rt_rq) * nr_cpu_ids, GFP_KERNEL);
         if (!tg->rt_rq)
                 goto err;
-        tg->rt_se = kzalloc(sizeof(rt_se) * NR_CPUS, GFP_KERNEL);
+        tg->rt_se = kzalloc(sizeof(rt_se) * nr_cpu_ids, GFP_KERNEL);
         if (!tg->rt_se)
                 goto err;
 
-        tg->rt_runtime = 0;
+        init_rt_bandwidth(&tg->rt_bandwidth,
+                        ktime_to_ns(def_rt_bandwidth.rt_period), 0);
 
         for_each_possible_cpu(i) {
                 rq = cpu_rq(i);
@@ -7549,7 +8577,8 @@ static int alloc_rt_sched_group(struct task_group *tg)
                 if (!rt_se)
                         goto err;
 
-                init_tg_rt_entry(rq, tg, rt_rq, rt_se, i, 0);
+                parent_se = parent ? parent->rt_se[i] : NULL;
+                init_tg_rt_entry(tg, rt_rq, rt_se, i, 0, parent_se);
         }
 
         return 1;
@@ -7573,7 +8602,8 @@ static inline void free_rt_sched_group(struct task_group *tg)
 {
 }
 
-static inline int alloc_rt_sched_group(struct task_group *tg)
+static inline
+int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent)
 {
         return 1;
 }
@@ -7587,6 +8617,7 @@ static inline void unregister_rt_sched_group(struct task_group *tg, int cpu)
 }
 #endif
 
+#ifdef CONFIG_GROUP_SCHED
 static void free_sched_group(struct task_group *tg)
 {
         free_fair_sched_group(tg);
@@ -7595,7 +8626,7 @@ static void free_sched_group(struct task_group *tg)
 }
 
 /* allocate runqueue etc for a new task group */
-struct task_group *sched_create_group(void)
+struct task_group *sched_create_group(struct task_group *parent)
 {
         struct task_group *tg;
         unsigned long flags;
@@ -7605,10 +8636,10 @@ struct task_group *sched_create_group(void)
         if (!tg)
                 return ERR_PTR(-ENOMEM);
 
-        if (!alloc_fair_sched_group(tg))
+        if (!alloc_fair_sched_group(tg, parent))
                 goto err;
 
-        if (!alloc_rt_sched_group(tg))
+        if (!alloc_rt_sched_group(tg, parent))
                 goto err;
 
         spin_lock_irqsave(&task_group_lock, flags);
@@ -7617,6 +8648,12 @@ struct task_group *sched_create_group(void)
                 register_rt_sched_group(tg, i);
         }
         list_add_rcu(&tg->list, &task_groups);
+
+        WARN_ON(!parent); /* root should already exist */
+
+        tg->parent = parent;
+        list_add_rcu(&tg->siblings, &parent->children);
+        INIT_LIST_HEAD(&tg->children);
         spin_unlock_irqrestore(&task_group_lock, flags);
 
         return tg;
@@ -7645,6 +8682,7 @@ void sched_destroy_group(struct task_group *tg)
                 unregister_rt_sched_group(tg, i);
         }
         list_del_rcu(&tg->list);
+        list_del_rcu(&tg->siblings);
         spin_unlock_irqrestore(&task_group_lock, flags);
 
         /* wait for possible concurrent references to cfs_rqs complete */
@@ -7688,16 +8726,14 @@ void sched_move_task(struct task_struct *tsk)
 
         task_rq_unlock(rq, &flags);
 }
+#endif
 
 #ifdef CONFIG_FAIR_GROUP_SCHED
-static void set_se_shares(struct sched_entity *se, unsigned long shares)
+static void __set_se_shares(struct sched_entity *se, unsigned long shares)
 {
         struct cfs_rq *cfs_rq = se->cfs_rq;
-        struct rq *rq = cfs_rq->rq;
         int on_rq;
 
-        spin_lock_irq(&rq->lock);
-
         on_rq = se->on_rq;
         if (on_rq)
                 dequeue_entity(cfs_rq, se, 0);
@@ -7707,8 +8743,17 @@ static void set_se_shares(struct sched_entity *se, unsigned long shares)
 
         if (on_rq)
                 enqueue_entity(cfs_rq, se, 0);
+}
 
-        spin_unlock_irq(&rq->lock);
+static void set_se_shares(struct sched_entity *se, unsigned long shares)
+{
+        struct cfs_rq *cfs_rq = se->cfs_rq;
+        struct rq *rq = cfs_rq->rq;
+        unsigned long flags;
+
+        spin_lock_irqsave(&rq->lock, flags);
+        __set_se_shares(se, shares);
+        spin_unlock_irqrestore(&rq->lock, flags);
 }
 
 static DEFINE_MUTEX(shares_mutex);
@@ -7719,12 +8764,18 @@ int sched_group_set_shares(struct task_group *tg, unsigned long shares)
         unsigned long flags;
 
         /*
+         * We can't change the weight of the root cgroup.
+         */
+        if (!tg->se[0])
+                return -EINVAL;
+
+        /*
          * A weight of 0 or 1 can cause arithmetics problems.
          * (The default weight is 1024 - so there's no practical
          *  limitation from this.)
          */
-        if (shares < 2)
-                shares = 2;
+        if (shares < MIN_SHARES)
+                shares = MIN_SHARES;
 
         mutex_lock(&shares_mutex);
         if (tg->shares == shares)
@@ -7733,6 +8784,7 @@ int sched_group_set_shares(struct task_group *tg, unsigned long shares)
         spin_lock_irqsave(&task_group_lock, flags);
         for_each_possible_cpu(i)
                 unregister_fair_sched_group(tg, i);
+        list_del_rcu(&tg->siblings);
         spin_unlock_irqrestore(&task_group_lock, flags);
 
         /* wait for any ongoing reference to this group to finish */
@@ -7743,8 +8795,13 @@ int sched_group_set_shares(struct task_group *tg, unsigned long shares)
          * w/o tripping rebalance_share or load_balance_fair.
          */
         tg->shares = shares;
-        for_each_possible_cpu(i)
-                set_se_shares(tg->se[i], shares);
+        for_each_possible_cpu(i) {
+                /*
+                 * force a rebalance
+                 */
+                cfs_rq_set_shares(tg->cfs_rq[i], 0);
+                set_se_shares(tg->se[i], shares/nr_cpu_ids);
+        }
 
         /*
          * Enable load balance activity on this group, by inserting it back on
@@ -7753,6 +8810,7 @@ int sched_group_set_shares(struct task_group *tg, unsigned long shares)
         spin_lock_irqsave(&task_group_lock, flags);
         for_each_possible_cpu(i)
                 register_fair_sched_group(tg, i);
+        list_add_rcu(&tg->siblings, &tg->parent->children);
         spin_unlock_irqrestore(&task_group_lock, flags);
 done:
         mutex_unlock(&shares_mutex);
@@ -7779,26 +8837,58 @@ static unsigned long to_ratio(u64 period, u64 runtime)
         return div64_64(runtime << 16, period);
 }
 
+#ifdef CONFIG_CGROUP_SCHED
+static int __rt_schedulable(struct task_group *tg, u64 period, u64 runtime)
+{
+        struct task_group *tgi, *parent = tg->parent;
+        unsigned long total = 0;
+
+        if (!parent) {
+                if (global_rt_period() < period)
+                        return 0;
+
+                return to_ratio(period, runtime) <
+                        to_ratio(global_rt_period(), global_rt_runtime());
+        }
+
+        if (ktime_to_ns(parent->rt_bandwidth.rt_period) < period)
+                return 0;
+
+        rcu_read_lock();
+        list_for_each_entry_rcu(tgi, &parent->children, siblings) {
+                if (tgi == tg)
+                        continue;
+
+                total += to_ratio(ktime_to_ns(tgi->rt_bandwidth.rt_period),
+                                tgi->rt_bandwidth.rt_runtime);
+        }
+        rcu_read_unlock();
+
+        return total + to_ratio(period, runtime) <
+                to_ratio(ktime_to_ns(parent->rt_bandwidth.rt_period),
+                                parent->rt_bandwidth.rt_runtime);
+}
+#elif defined CONFIG_USER_SCHED
 static int __rt_schedulable(struct task_group *tg, u64 period, u64 runtime)
 {
         struct task_group *tgi;
         unsigned long total = 0;
         unsigned long global_ratio =
-                to_ratio(sysctl_sched_rt_period,
-                         sysctl_sched_rt_runtime < 0 ?
-                                RUNTIME_INF : sysctl_sched_rt_runtime);
+                to_ratio(global_rt_period(), global_rt_runtime());
 
         rcu_read_lock();
         list_for_each_entry_rcu(tgi, &task_groups, list) {
                 if (tgi == tg)
                         continue;
 
-                total += to_ratio(period, tgi->rt_runtime);
+                total += to_ratio(ktime_to_ns(tgi->rt_bandwidth.rt_period),
+                                tgi->rt_bandwidth.rt_runtime);
         }
         rcu_read_unlock();
 
         return total + to_ratio(period, runtime) < global_ratio;
 }
+#endif
 
 /* Must be called with tasklist_lock held */
 static inline int tg_has_rt_tasks(struct task_group *tg)
@@ -7811,19 +8901,14 @@ static inline int tg_has_rt_tasks(struct task_group *tg)
         return 0;
 }
 
-int sched_group_set_rt_runtime(struct task_group *tg, long rt_runtime_us)
+static int tg_set_bandwidth(struct task_group *tg,
+                u64 rt_period, u64 rt_runtime)
 {
-        u64 rt_runtime, rt_period;
-        int err = 0;
-
-        rt_period = (u64)sysctl_sched_rt_period * NSEC_PER_USEC;
-        rt_runtime = (u64)rt_runtime_us * NSEC_PER_USEC;
-        if (rt_runtime_us == -1)
-                rt_runtime = RUNTIME_INF;
+        int i, err = 0;
 
         mutex_lock(&rt_constraints_mutex);
         read_lock(&tasklist_lock);
-        if (rt_runtime_us == 0 && tg_has_rt_tasks(tg)) {
+        if (rt_runtime == 0 && tg_has_rt_tasks(tg)) {
                 err = -EBUSY;
                 goto unlock;
         }
@@ -7831,7 +8916,19 @@ int sched_group_set_rt_runtime(struct task_group *tg, long rt_runtime_us)
                 err = -EINVAL;
                 goto unlock;
         }
-        tg->rt_runtime = rt_runtime;
+
+        spin_lock_irq(&tg->rt_bandwidth.rt_runtime_lock);
+        tg->rt_bandwidth.rt_period = ns_to_ktime(rt_period);
+        tg->rt_bandwidth.rt_runtime = rt_runtime;
+
+        for_each_possible_cpu(i) {
+                struct rt_rq *rt_rq = tg->rt_rq[i];
+
+                spin_lock(&rt_rq->rt_runtime_lock);
+                rt_rq->rt_runtime = rt_runtime;
+                spin_unlock(&rt_rq->rt_runtime_lock);
+        }
+        spin_unlock_irq(&tg->rt_bandwidth.rt_runtime_lock);
  unlock:
         read_unlock(&tasklist_lock);
         mutex_unlock(&rt_constraints_mutex);
@@ -7839,19 +8936,109 @@ int sched_group_set_rt_runtime(struct task_group *tg, long rt_runtime_us)
         return err;
 }
 
+int sched_group_set_rt_runtime(struct task_group *tg, long rt_runtime_us)
+{
+        u64 rt_runtime, rt_period;
+
+        rt_period = ktime_to_ns(tg->rt_bandwidth.rt_period);
+        rt_runtime = (u64)rt_runtime_us * NSEC_PER_USEC;
+        if (rt_runtime_us < 0)
+                rt_runtime = RUNTIME_INF;
+
+        return tg_set_bandwidth(tg, rt_period, rt_runtime);
+}
+
 long sched_group_rt_runtime(struct task_group *tg)
 {
         u64 rt_runtime_us;
 
-        if (tg->rt_runtime == RUNTIME_INF)
+        if (tg->rt_bandwidth.rt_runtime == RUNTIME_INF)
                 return -1;
 
-        rt_runtime_us = tg->rt_runtime;
+        rt_runtime_us = tg->rt_bandwidth.rt_runtime;
         do_div(rt_runtime_us, NSEC_PER_USEC);
         return rt_runtime_us;
 }
+
+int sched_group_set_rt_period(struct task_group *tg, long rt_period_us)
+{
+        u64 rt_runtime, rt_period;
+
+        rt_period = (u64)rt_period_us * NSEC_PER_USEC;
+        rt_runtime = tg->rt_bandwidth.rt_runtime;
+
+        return tg_set_bandwidth(tg, rt_period, rt_runtime);
+}
+
+long sched_group_rt_period(struct task_group *tg)
+{
+        u64 rt_period_us;
+
+        rt_period_us = ktime_to_ns(tg->rt_bandwidth.rt_period);
+        do_div(rt_period_us, NSEC_PER_USEC);
+        return rt_period_us;
+}
+
+static int sched_rt_global_constraints(void)
+{
+        int ret = 0;
+
+        mutex_lock(&rt_constraints_mutex);
+        if (!__rt_schedulable(NULL, 1, 0))
+                ret = -EINVAL;
+        mutex_unlock(&rt_constraints_mutex);
+
+        return ret;
+}
+#else
+static int sched_rt_global_constraints(void)
+{
+        unsigned long flags;
+        int i;
+
+        spin_lock_irqsave(&def_rt_bandwidth.rt_runtime_lock, flags);
+        for_each_possible_cpu(i) {
+                struct rt_rq *rt_rq = &cpu_rq(i)->rt;
+
+                spin_lock(&rt_rq->rt_runtime_lock);
+                rt_rq->rt_runtime = global_rt_runtime();
+                spin_unlock(&rt_rq->rt_runtime_lock);
+        }
+        spin_unlock_irqrestore(&def_rt_bandwidth.rt_runtime_lock, flags);
+
+        return 0;
+}
 #endif
-#endif  /* CONFIG_GROUP_SCHED */
+
+int sched_rt_handler(struct ctl_table *table, int write,
+                struct file *filp, void __user *buffer, size_t *lenp,
+                loff_t *ppos)
+{
+        int ret;
+        int old_period, old_runtime;
+        static DEFINE_MUTEX(mutex);
+
+        mutex_lock(&mutex);
+        old_period = sysctl_sched_rt_period;
+        old_runtime = sysctl_sched_rt_runtime;
+
+        ret = proc_dointvec(table, write, filp, buffer, lenp, ppos);
+
+        if (!ret && write) {
+                ret = sched_rt_global_constraints();
+                if (ret) {
+                        sysctl_sched_rt_period = old_period;
+                        sysctl_sched_rt_runtime = old_runtime;
+                } else {
+                        def_rt_bandwidth.rt_runtime = global_rt_runtime();
+                        def_rt_bandwidth.rt_period =
+                                ns_to_ktime(global_rt_period());
+                }
+        }
+        mutex_unlock(&mutex);
+
+        return ret;
+}
 
 #ifdef CONFIG_CGROUP_SCHED
 
@@ -7865,7 +9052,7 @@ static inline struct task_group *cgroup_tg(struct cgroup *cgrp)
 static struct cgroup_subsys_state *
 cpu_cgroup_create(struct cgroup_subsys *ss, struct cgroup *cgrp)
 {
-        struct task_group *tg;
+        struct task_group *tg, *parent;
 
         if (!cgrp->parent) {
                 /* This is early initialization for the top cgroup */
@@ -7873,11 +9060,8 @@ cpu_cgroup_create(struct cgroup_subsys *ss, struct cgroup *cgrp)
                 return &init_task_group.css;
         }
 
-        /* we support only 1-level deep hierarchical scheduler atm */
-        if (cgrp->parent->parent)
-                return ERR_PTR(-EINVAL);
-
-        tg = sched_create_group();
+        parent = cgroup_tg(cgrp->parent);
+        tg = sched_create_group(parent);
         if (IS_ERR(tg))
                 return ERR_PTR(-ENOMEM);
 
@@ -7901,7 +9085,7 @@ cpu_cgroup_can_attach(struct cgroup_subsys *ss, struct cgroup *cgrp,
 {
 #ifdef CONFIG_RT_GROUP_SCHED
         /* Don't accept realtime tasks when there is no way for them to run */
-        if (rt_task(tsk) && cgroup_tg(cgrp)->rt_runtime == 0)
+        if (rt_task(tsk) && cgroup_tg(cgrp)->rt_bandwidth.rt_runtime == 0)
                 return -EINVAL;
 #else
         /* We don't support RT-tasks being in separate groups */
@@ -7935,7 +9119,7 @@ static u64 cpu_shares_read_uint(struct cgroup *cgrp, struct cftype *cft)
 #endif
 
 #ifdef CONFIG_RT_GROUP_SCHED
-static int cpu_rt_runtime_write(struct cgroup *cgrp, struct cftype *cft,
+static ssize_t cpu_rt_runtime_write(struct cgroup *cgrp, struct cftype *cft,
                                 struct file *file,
                                 const char __user *userbuf,
                                 size_t nbytes, loff_t *unused_ppos)
@@ -7979,6 +9163,17 @@ static ssize_t cpu_rt_runtime_read(struct cgroup *cgrp, struct cftype *cft,
 
         return simple_read_from_buffer(buf, nbytes, ppos, tmp, len);
 }
+
+static int cpu_rt_period_write_uint(struct cgroup *cgrp, struct cftype *cftype,
+                u64 rt_period_us)
+{
+        return sched_group_set_rt_period(cgroup_tg(cgrp), rt_period_us);
+}
+
+static u64 cpu_rt_period_read_uint(struct cgroup *cgrp, struct cftype *cft)
+{
+        return sched_group_rt_period(cgroup_tg(cgrp));
+}
 #endif
 
 static struct cftype cpu_files[] = {
@@ -7995,6 +9190,11 @@ static struct cftype cpu_files[] = {
                 .read = cpu_rt_runtime_read,
                 .write = cpu_rt_runtime_write,
         },
+        {
+                .name = "rt_period_us",
+                .read_uint = cpu_rt_period_read_uint,
+                .write_uint = cpu_rt_period_write_uint,
+        },
 #endif
 };
 
@@ -8035,9 +9235,9 @@ struct cpuacct {
 struct cgroup_subsys cpuacct_subsys;
 
 /* return cpu accounting group corresponding to this container */
-static inline struct cpuacct *cgroup_ca(struct cgroup *cont)
+static inline struct cpuacct *cgroup_ca(struct cgroup *cgrp)
 {
-        return container_of(cgroup_subsys_state(cont, cpuacct_subsys_id),
+        return container_of(cgroup_subsys_state(cgrp, cpuacct_subsys_id),
                             struct cpuacct, css);
 }
 
@@ -8050,7 +9250,7 @@ static inline struct cpuacct *task_ca(struct task_struct *tsk)
 
 /* create a new cpu accounting group */
 static struct cgroup_subsys_state *cpuacct_create(
-        struct cgroup_subsys *ss, struct cgroup *cont)
+        struct cgroup_subsys *ss, struct cgroup *cgrp)
 {
         struct cpuacct *ca = kzalloc(sizeof(*ca), GFP_KERNEL);
 
@@ -8068,18 +9268,18 @@ static struct cgroup_subsys_state *cpuacct_create(
 
 /* destroy an existing cpu accounting group */
 static void
-cpuacct_destroy(struct cgroup_subsys *ss, struct cgroup *cont)
+cpuacct_destroy(struct cgroup_subsys *ss, struct cgroup *cgrp)
 {
-        struct cpuacct *ca = cgroup_ca(cont);
+        struct cpuacct *ca = cgroup_ca(cgrp);
 
         free_percpu(ca->cpuusage);
         kfree(ca);
 }
 
 /* return total cpu usage (in nanoseconds) of a group */
-static u64 cpuusage_read(struct cgroup *cont, struct cftype *cft)
+static u64 cpuusage_read(struct cgroup *cgrp, struct cftype *cft)
 {
-        struct cpuacct *ca = cgroup_ca(cont);
+        struct cpuacct *ca = cgroup_ca(cgrp);
         u64 totalcpuusage = 0;
         int i;
 
@@ -8098,16 +9298,40 @@ static u64 cpuusage_read(struct cgroup *cont, struct cftype *cft)
         return totalcpuusage;
 }
 
+static int cpuusage_write(struct cgroup *cgrp, struct cftype *cftype,
+                                                                u64 reset)
+{
+        struct cpuacct *ca = cgroup_ca(cgrp);
+        int err = 0;
+        int i;
+
+        if (reset) {
+                err = -EINVAL;
+                goto out;
+        }
+
+        for_each_possible_cpu(i) {
+                u64 *cpuusage = percpu_ptr(ca->cpuusage, i);
+
+                spin_lock_irq(&cpu_rq(i)->lock);
+                *cpuusage = 0;
+                spin_unlock_irq(&cpu_rq(i)->lock);
+        }
+out:
+        return err;
+}
+
 static struct cftype files[] = {
         {
                 .name = "usage",
                 .read_uint = cpuusage_read,
+                .write_uint = cpuusage_write,
         },
 };
 
-static int cpuacct_populate(struct cgroup_subsys *ss, struct cgroup *cont)
+static int cpuacct_populate(struct cgroup_subsys *ss, struct cgroup *cgrp)
 {
-        return cgroup_add_files(cont, ss, files, ARRAY_SIZE(files));
+        return cgroup_add_files(cgrp, ss, files, ARRAY_SIZE(files));
 }
 
 /*
diff --git a/kernel/sched_debug.c b/kernel/sched_debug.c
index ef358ba07683..f3f4af4b8b0f 100644
--- a/kernel/sched_debug.c
+++ b/kernel/sched_debug.c
@@ -67,14 +67,24 @@ print_task(struct seq_file *m, struct rq *rq, struct task_struct *p)
                 (long long)(p->nvcsw + p->nivcsw),
                 p->prio);
 #ifdef CONFIG_SCHEDSTATS
-        SEQ_printf(m, "%9Ld.%06ld %9Ld.%06ld %9Ld.%06ld\n",
+        SEQ_printf(m, "%9Ld.%06ld %9Ld.%06ld %9Ld.%06ld",
                 SPLIT_NS(p->se.vruntime),
                 SPLIT_NS(p->se.sum_exec_runtime),
                 SPLIT_NS(p->se.sum_sleep_runtime));
 #else
-        SEQ_printf(m, "%15Ld %15Ld %15Ld.%06ld %15Ld.%06ld %15Ld.%06ld\n",
+        SEQ_printf(m, "%15Ld %15Ld %15Ld.%06ld %15Ld.%06ld %15Ld.%06ld",
                 0LL, 0LL, 0LL, 0L, 0LL, 0L, 0LL, 0L);
 #endif
+
+#ifdef CONFIG_CGROUP_SCHED
+        {
+                char path[64];
+
+                cgroup_path(task_group(p)->css.cgroup, path, sizeof(path));
+                SEQ_printf(m, " %s", path);
+        }
+#endif
+        SEQ_printf(m, "\n");
 }
 
 static void print_rq(struct seq_file *m, struct rq *rq, int rq_cpu)
@@ -109,7 +119,21 @@ void print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
         struct sched_entity *last;
         unsigned long flags;
 
-        SEQ_printf(m, "\ncfs_rq\n");
+#if !defined(CONFIG_CGROUP_SCHED) || !defined(CONFIG_USER_SCHED)
+        SEQ_printf(m, "\ncfs_rq[%d]:\n", cpu);
+#else
+        char path[128] = "";
+        struct cgroup *cgroup = NULL;
+        struct task_group *tg = cfs_rq->tg;
+
+        if (tg)
+                cgroup = tg->css.cgroup;
+
+        if (cgroup)
+                cgroup_path(cgroup, path, sizeof(path));
+
+        SEQ_printf(m, "\ncfs_rq[%d]:%s\n", cpu, path);
+#endif
 
         SEQ_printf(m, "  .%-30s: %Ld.%06ld\n", "exec_clock",
                         SPLIT_NS(cfs_rq->exec_clock));
@@ -143,6 +167,11 @@ void print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
 #endif
         SEQ_printf(m, "  .%-30s: %ld\n", "nr_spread_over",
                         cfs_rq->nr_spread_over);
+#ifdef CONFIG_FAIR_GROUP_SCHED
+#ifdef CONFIG_SMP
+        SEQ_printf(m, "  .%-30s: %lu\n", "shares", cfs_rq->shares);
+#endif
+#endif
 }
 
 static void print_cpu(struct seq_file *m, int cpu)
@@ -214,7 +243,6 @@ static int sched_debug_show(struct seq_file *m, void *v)
         PN(sysctl_sched_latency);
         PN(sysctl_sched_min_granularity);
         PN(sysctl_sched_wakeup_granularity);
-        PN(sysctl_sched_batch_wakeup_granularity);
         PN(sysctl_sched_child_runs_first);
         P(sysctl_sched_features);
 #undef PN
diff --git a/kernel/sched_fair.c b/kernel/sched_fair.c
index 0080968d3e4a..89fa32b4edf2 100644
--- a/kernel/sched_fair.c
+++ b/kernel/sched_fair.c
@@ -62,24 +62,14 @@ const_debug unsigned int sysctl_sched_child_runs_first = 1;
 unsigned int __read_mostly sysctl_sched_compat_yield;
 
 /*
- * SCHED_BATCH wake-up granularity.
- * (default: 10 msec * (1 + ilog(ncpus)), units: nanoseconds)
- *
- * This option delays the preemption effects of decoupled workloads
- * and reduces their over-scheduling. Synchronous workloads will still
- * have immediate wakeup/sleep latencies.
- */
-unsigned int sysctl_sched_batch_wakeup_granularity = 10000000UL;
-
-/*
  * SCHED_OTHER wake-up granularity.
- * (default: 5 msec * (1 + ilog(ncpus)), units: nanoseconds)
+ * (default: 10 msec * (1 + ilog(ncpus)), units: nanoseconds)
  *
  * This option delays the preemption effects of decoupled workloads
  * and reduces their over-scheduling. Synchronous workloads will still
  * have immediate wakeup/sleep latencies.
  */
-unsigned int sysctl_sched_wakeup_granularity = 5000000UL;
+unsigned int sysctl_sched_wakeup_granularity = 10000000UL;
 
 const_debug unsigned int sysctl_sched_migration_cost = 500000UL;
 
@@ -87,6 +77,11 @@ const_debug unsigned int sysctl_sched_migration_cost = 500000UL;
  * CFS operations on generic schedulable entities:
  */
 
+static inline struct task_struct *task_of(struct sched_entity *se)
+{
+        return container_of(se, struct task_struct, se);
+}
+
 #ifdef CONFIG_FAIR_GROUP_SCHED
 
 /* cpu runqueue to which this cfs_rq is attached */
@@ -98,6 +93,54 @@ static inline struct rq *rq_of(struct cfs_rq *cfs_rq)
 /* An entity is a task if it doesn't "own" a runqueue */
 #define entity_is_task(se)      (!se->my_q)
 
+/* Walk up scheduling entities hierarchy */
+#define for_each_sched_entity(se) \
+                for (; se; se = se->parent)
+
+static inline struct cfs_rq *task_cfs_rq(struct task_struct *p)
+{
+        return p->se.cfs_rq;
+}
+
+/* runqueue on which this entity is (to be) queued */
+static inline struct cfs_rq *cfs_rq_of(struct sched_entity *se)
+{
+        return se->cfs_rq;
+}
+
+/* runqueue "owned" by this group */
+static inline struct cfs_rq *group_cfs_rq(struct sched_entity *grp)
+{
+        return grp->my_q;
+}
+
+/* Given a group's cfs_rq on one cpu, return its corresponding cfs_rq on
+ * another cpu ('this_cpu')
+ */
+static inline struct cfs_rq *cpu_cfs_rq(struct cfs_rq *cfs_rq, int this_cpu)
+{
+        return cfs_rq->tg->cfs_rq[this_cpu];
+}
+
+/* Iterate thr' all leaf cfs_rq's on a runqueue */
+#define for_each_leaf_cfs_rq(rq, cfs_rq) \
+        list_for_each_entry_rcu(cfs_rq, &rq->leaf_cfs_rq_list, leaf_cfs_rq_list)
+
+/* Do the two (enqueued) entities belong to the same group ? */
+static inline int
+is_same_group(struct sched_entity *se, struct sched_entity *pse)
+{
+        if (se->cfs_rq == pse->cfs_rq)
+                return 1;
+
+        return 0;
+}
+
+static inline struct sched_entity *parent_entity(struct sched_entity *se)
+{
+        return se->parent;
+}
+
 #else   /* CONFIG_FAIR_GROUP_SCHED */
 
 static inline struct rq *rq_of(struct cfs_rq *cfs_rq)
@@ -107,13 +150,49 @@ static inline struct rq *rq_of(struct cfs_rq *cfs_rq)
 
 #define entity_is_task(se)      1
 
-#endif  /* CONFIG_FAIR_GROUP_SCHED */
+#define for_each_sched_entity(se) \
+                for (; se; se = NULL)
 
-static inline struct task_struct *task_of(struct sched_entity *se)
+static inline struct cfs_rq *task_cfs_rq(struct task_struct *p)
 {
-        return container_of(se, struct task_struct, se);
+        return &task_rq(p)->cfs;
+}
+
+static inline struct cfs_rq *cfs_rq_of(struct sched_entity *se)
+{
+        struct task_struct *p = task_of(se);
+        struct rq *rq = task_rq(p);
+
+        return &rq->cfs;
+}
+
+/* runqueue "owned" by this group */
+static inline struct cfs_rq *group_cfs_rq(struct sched_entity *grp)
+{
+        return NULL;
+}
+
+static inline struct cfs_rq *cpu_cfs_rq(struct cfs_rq *cfs_rq, int this_cpu)
+{
+        return &cpu_rq(this_cpu)->cfs;
+}
+
+#define for_each_leaf_cfs_rq(rq, cfs_rq) \
+                for (cfs_rq = &rq->cfs; cfs_rq; cfs_rq = NULL)
+
+static inline int
+is_same_group(struct sched_entity *se, struct sched_entity *pse)
+{
+        return 1;
+}
+
+static inline struct sched_entity *parent_entity(struct sched_entity *se)
+{
+        return NULL;
 }
 
+#endif  /* CONFIG_FAIR_GROUP_SCHED */
+
 
 /**************************************************************
  * Scheduling class tree data structure manipulation methods:
@@ -255,6 +334,34 @@ int sched_nr_latency_handler(struct ctl_table *table, int write,
 #endif
 
 /*
+ * delta *= w / rw
+ */
+static inline unsigned long
+calc_delta_weight(unsigned long delta, struct sched_entity *se)
+{
+        for_each_sched_entity(se) {
+                delta = calc_delta_mine(delta,
+                                se->load.weight, &cfs_rq_of(se)->load);
+        }
+
+        return delta;
+}
+
+/*
+ * delta *= rw / w
+ */
+static inline unsigned long
+calc_delta_fair(unsigned long delta, struct sched_entity *se)
+{
+        for_each_sched_entity(se) {
+                delta = calc_delta_mine(delta,
+                                cfs_rq_of(se)->load.weight, &se->load);
+        }
+
+        return delta;
+}
+
+/*
  * The idea is to set a period in which each task runs once.
  *
  * When there are too many tasks (sysctl_sched_nr_latency) we have to stretch
@@ -283,29 +390,54 @@ static u64 __sched_period(unsigned long nr_running)
  */
 static u64 sched_slice(struct cfs_rq *cfs_rq, struct sched_entity *se)
 {
-        return calc_delta_mine(__sched_period(cfs_rq->nr_running),
-                               se->load.weight, &cfs_rq->load);
+        return calc_delta_weight(__sched_period(cfs_rq->nr_running), se);
 }
 
 /*
- * We calculate the vruntime slice.
+ * We calculate the vruntime slice of a to be inserted task
  *
- * vs = s/w = p/rw
+ * vs = s*rw/w = p
  */
-static u64 __sched_vslice(unsigned long rq_weight, unsigned long nr_running)
+static u64 sched_vslice_add(struct cfs_rq *cfs_rq, struct sched_entity *se)
 {
-        u64 vslice = __sched_period(nr_running);
+        unsigned long nr_running = cfs_rq->nr_running;
 
-        vslice *= NICE_0_LOAD;
-        do_div(vslice, rq_weight);
+        if (!se->on_rq)
+                nr_running++;
 
-        return vslice;
+        return __sched_period(nr_running);
 }
 
-static u64 sched_vslice_add(struct cfs_rq *cfs_rq, struct sched_entity *se)
+/*
+ * The goal of calc_delta_asym() is to be asymmetrically around NICE_0_LOAD, in
+ * that it favours >=0 over <0.
+ *
+ *   -20         |
+ *               |
+ *     0 --------+-------
+ *             .'
+ *    19     .'
+ *
+ */
+static unsigned long
+calc_delta_asym(unsigned long delta, struct sched_entity *se)
 {
-        return __sched_vslice(cfs_rq->load.weight + se->load.weight,
-                        cfs_rq->nr_running + 1);
+        struct load_weight lw = {
+                .weight = NICE_0_LOAD,
+                .inv_weight = 1UL << (WMULT_SHIFT-NICE_0_SHIFT)
+        };
+
+        for_each_sched_entity(se) {
+                struct load_weight *se_lw = &se->load;
+
+                if (se->load.weight < NICE_0_LOAD)
+                        se_lw = &lw;
+
+                delta = calc_delta_mine(delta,
+                                cfs_rq_of(se)->load.weight, se_lw);
+        }
+
+        return delta;
 }
 
 /*
@@ -322,11 +454,7 @@ __update_curr(struct cfs_rq *cfs_rq, struct sched_entity *curr,
 
         curr->sum_exec_runtime += delta_exec;
         schedstat_add(cfs_rq, exec_clock, delta_exec);
-        delta_exec_weighted = delta_exec;
-        if (unlikely(curr->load.weight != NICE_0_LOAD)) {
-                delta_exec_weighted = calc_delta_fair(delta_exec_weighted,
-                                                        &curr->load);
-        }
+        delta_exec_weighted = calc_delta_fair(delta_exec, curr);
         curr->vruntime += delta_exec_weighted;
 }
 
@@ -413,20 +541,43 @@ update_stats_curr_start(struct cfs_rq *cfs_rq, struct sched_entity *se)
  * Scheduling class queueing methods:
  */
 
+#if defined CONFIG_SMP && defined CONFIG_FAIR_GROUP_SCHED
+static void
+add_cfs_task_weight(struct cfs_rq *cfs_rq, unsigned long weight)
+{
+        cfs_rq->task_weight += weight;
+}
+#else
+static inline void
+add_cfs_task_weight(struct cfs_rq *cfs_rq, unsigned long weight)
+{
+}
+#endif
+
 static void
 account_entity_enqueue(struct cfs_rq *cfs_rq, struct sched_entity *se)
 {
         update_load_add(&cfs_rq->load, se->load.weight);
+        if (!parent_entity(se))
+                inc_cpu_load(rq_of(cfs_rq), se->load.weight);
+        if (entity_is_task(se))
+                add_cfs_task_weight(cfs_rq, se->load.weight);
         cfs_rq->nr_running++;
         se->on_rq = 1;
+        list_add(&se->group_node, &cfs_rq->tasks);
 }
 
 static void
 account_entity_dequeue(struct cfs_rq *cfs_rq, struct sched_entity *se)
 {
         update_load_sub(&cfs_rq->load, se->load.weight);
+        if (!parent_entity(se))
+                dec_cpu_load(rq_of(cfs_rq), se->load.weight);
+        if (entity_is_task(se))
+                add_cfs_task_weight(cfs_rq, -se->load.weight);
         cfs_rq->nr_running--;
         se->on_rq = 0;
+        list_del_init(&se->group_node);
 }
 
 static void enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se)
@@ -510,8 +661,12 @@ place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int initial)
 
         if (!initial) {
                 /* sleeps upto a single latency don't count. */
-                if (sched_feat(NEW_FAIR_SLEEPERS))
-                        vruntime -= sysctl_sched_latency;
+                if (sched_feat(NEW_FAIR_SLEEPERS)) {
+                        if (sched_feat(NORMALIZED_SLEEPER))
+                                vruntime -= calc_delta_weight(sysctl_sched_latency, se);
+                        else
+                                vruntime -= sysctl_sched_latency;
+                }
 
                 /* ensure we never gain time by being placed backwards. */
                 vruntime = max_vruntime(se->vruntime, vruntime);
@@ -627,20 +782,16 @@ set_next_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
         se->prev_sum_exec_runtime = se->sum_exec_runtime;
 }
 
+static int
+wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se);
+
 static struct sched_entity *
 pick_next(struct cfs_rq *cfs_rq, struct sched_entity *se)
 {
-        s64 diff, gran;
-
         if (!cfs_rq->next)
                 return se;
 
-        diff = cfs_rq->next->vruntime - se->vruntime;
-        if (diff < 0)
-                return se;
-
-        gran = calc_delta_fair(sysctl_sched_wakeup_granularity, &cfs_rq->load);
-        if (diff > gran)
+        if (wakeup_preempt_entity(cfs_rq->next, se) != 0)
                 return se;
 
         return cfs_rq->next;
@@ -708,101 +859,6 @@ entity_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr, int queued)
  * CFS operations on tasks:
  */
 
-#ifdef CONFIG_FAIR_GROUP_SCHED
-
-/* Walk up scheduling entities hierarchy */
-#define for_each_sched_entity(se) \
-                for (; se; se = se->parent)
-
-static inline struct cfs_rq *task_cfs_rq(struct task_struct *p)
-{
-        return p->se.cfs_rq;
-}
-
-/* runqueue on which this entity is (to be) queued */
-static inline struct cfs_rq *cfs_rq_of(struct sched_entity *se)
-{
-        return se->cfs_rq;
-}
-
-/* runqueue "owned" by this group */
-static inline struct cfs_rq *group_cfs_rq(struct sched_entity *grp)
-{
-        return grp->my_q;
-}
-
-/* Given a group's cfs_rq on one cpu, return its corresponding cfs_rq on
- * another cpu ('this_cpu')
- */
-static inline struct cfs_rq *cpu_cfs_rq(struct cfs_rq *cfs_rq, int this_cpu)
-{
-        return cfs_rq->tg->cfs_rq[this_cpu];
-}
-
-/* Iterate thr' all leaf cfs_rq's on a runqueue */
-#define for_each_leaf_cfs_rq(rq, cfs_rq) \
-        list_for_each_entry_rcu(cfs_rq, &rq->leaf_cfs_rq_list, leaf_cfs_rq_list)
-
-/* Do the two (enqueued) entities belong to the same group ? */
-static inline int
-is_same_group(struct sched_entity *se, struct sched_entity *pse)
-{
-        if (se->cfs_rq == pse->cfs_rq)
-                return 1;
-
-        return 0;
-}
-
-static inline struct sched_entity *parent_entity(struct sched_entity *se)
-{
-        return se->parent;
-}
-
-#else   /* CONFIG_FAIR_GROUP_SCHED */
-
-#define for_each_sched_entity(se) \
-                for (; se; se = NULL)
-
-static inline struct cfs_rq *task_cfs_rq(struct task_struct *p)
-{
-        return &task_rq(p)->cfs;
-}
-
-static inline struct cfs_rq *cfs_rq_of(struct sched_entity *se)
-{
-        struct task_struct *p = task_of(se);
-        struct rq *rq = task_rq(p);
-
-        return &rq->cfs;
-}
-
-/* runqueue "owned" by this group */
-static inline struct cfs_rq *group_cfs_rq(struct sched_entity *grp)
-{
-        return NULL;
-}
-
-static inline struct cfs_rq *cpu_cfs_rq(struct cfs_rq *cfs_rq, int this_cpu)
-{
-        return &cpu_rq(this_cpu)->cfs;
-}
-
-#define for_each_leaf_cfs_rq(rq, cfs_rq) \
-                for (cfs_rq = &rq->cfs; cfs_rq; cfs_rq = NULL)
-
-static inline int
-is_same_group(struct sched_entity *se, struct sched_entity *pse)
-{
-        return 1;
-}
-
-static inline struct sched_entity *parent_entity(struct sched_entity *se)
-{
-        return NULL;
-}
-
-#endif  /* CONFIG_FAIR_GROUP_SCHED */
-
 #ifdef CONFIG_SCHED_HRTICK
 static void hrtick_start_fair(struct rq *rq, struct task_struct *p)
 {
@@ -916,7 +972,7 @@ static void yield_task_fair(struct rq *rq)
         /*
          * Already in the rightmost position?
          */
-        if (unlikely(rightmost->vruntime < se->vruntime))
+        if (unlikely(!rightmost || rightmost->vruntime < se->vruntime))
                 return;
 
         /*
@@ -955,7 +1011,9 @@ static int wake_idle(int cpu, struct task_struct *p)
                 return cpu;
 
         for_each_domain(cpu, sd) {
-                if (sd->flags & SD_WAKE_IDLE) {
+                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_mask(i, tmp) {
                                 if (idle_cpu(i)) {
@@ -1099,6 +1157,58 @@ out:
 }
 #endif /* CONFIG_SMP */
 
+static unsigned long wakeup_gran(struct sched_entity *se)
+{
+        unsigned long gran = sysctl_sched_wakeup_granularity;
+
+        /*
+         * More easily preempt - nice tasks, while not making it harder for
+         * + nice tasks.
+         */
+        gran = calc_delta_asym(sysctl_sched_wakeup_granularity, se);
+
+        return gran;
+}
+
+/*
+ * Should 'se' preempt 'curr'.
+ *
+ *             |s1
+ *        |s2
+ *   |s3
+ *         g
+ *      |<--->|c
+ *
+ *  w(c, s1) = -1
+ *  w(c, s2) =  0
+ *  w(c, s3) =  1
+ *
+ */
+static int
+wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se)
+{
+        s64 gran, vdiff = curr->vruntime - se->vruntime;
+
+        if (vdiff < 0)
+                return -1;
+
+        gran = wakeup_gran(curr);
+        if (vdiff > gran)
+                return 1;
+
+        return 0;
+}
+
+/* return depth at which a sched entity is present in the hierarchy */
+static inline int depth_se(struct sched_entity *se)
+{
+        int depth = 0;
+
+        for_each_sched_entity(se)
+                depth++;
+
+        return depth;
+}
 
 /*
  * Preempt the current task with a newly woken task if needed:
@@ -1108,7 +1218,7 @@ static void check_preempt_wakeup(struct rq *rq, struct task_struct *p)
         struct task_struct *curr = rq->curr;
         struct cfs_rq *cfs_rq = task_cfs_rq(curr);
         struct sched_entity *se = &curr->se, *pse = &p->se;
-        unsigned long gran;
+        int se_depth, pse_depth;
 
         if (unlikely(rt_prio(p->prio))) {
                 update_rq_clock(rq);
@@ -1133,20 +1243,33 @@ static void check_preempt_wakeup(struct rq *rq, struct task_struct *p)
         if (!sched_feat(WAKEUP_PREEMPT))
                 return;
 
-        while (!is_same_group(se, pse)) {
+        /*
+         * preemption test can be made between sibling entities who are in the
+         * same cfs_rq i.e who have a common parent. Walk up the hierarchy of
+         * both tasks until we find their ancestors who are siblings of common
+         * parent.
+         */
+
+        /* First walk up until both entities are at same depth */
+        se_depth = depth_se(se);
+        pse_depth = depth_se(pse);
+
+        while (se_depth > pse_depth) {
+                se_depth--;
                 se = parent_entity(se);
+        }
+
+        while (pse_depth > se_depth) {
+                pse_depth--;
                 pse = parent_entity(pse);
         }
 
-        gran = sysctl_sched_wakeup_granularity;
-        /*
-         * More easily preempt - nice tasks, while not making
-         * it harder for + nice tasks.
-         */
-        if (unlikely(se->load.weight > NICE_0_LOAD))
-                gran = calc_delta_fair(gran, &se->load);
+        while (!is_same_group(se, pse)) {
+                se = parent_entity(se);
+                pse = parent_entity(pse);
+        }
 
-        if (pse->vruntime + gran < se->vruntime)
+        if (wakeup_preempt_entity(se, pse) == 1)
                 resched_task(curr);
 }
 
@@ -1197,15 +1320,27 @@ static void put_prev_task_fair(struct rq *rq, struct task_struct *prev)
  * the current task:
  */
 static struct task_struct *
-__load_balance_iterator(struct cfs_rq *cfs_rq, struct rb_node *curr)
+__load_balance_iterator(struct cfs_rq *cfs_rq, struct list_head *next)
 {
-        struct task_struct *p;
+        struct task_struct *p = NULL;
+        struct sched_entity *se;
+
+        if (next == &cfs_rq->tasks)
+                return NULL;
+
+        /* Skip over entities that are not tasks */
+        do {
+                se = list_entry(next, struct sched_entity, group_node);
+                next = next->next;
+        } while (next != &cfs_rq->tasks && !entity_is_task(se));
 
-        if (!curr)
+        if (next == &cfs_rq->tasks)
                 return NULL;
 
-        p = rb_entry(curr, struct task_struct, se.run_node);
-        cfs_rq->rb_load_balance_curr = rb_next(curr);
+        cfs_rq->balance_iterator = next;
+
+        if (entity_is_task(se))
+                p = task_of(se);
 
         return p;
 }
@@ -1214,85 +1349,100 @@ static struct task_struct *load_balance_start_fair(void *arg)
 {
         struct cfs_rq *cfs_rq = arg;
 
-        return __load_balance_iterator(cfs_rq, first_fair(cfs_rq));
+        return __load_balance_iterator(cfs_rq, cfs_rq->tasks.next);
 }
 
 static struct task_struct *load_balance_next_fair(void *arg)
 {
         struct cfs_rq *cfs_rq = arg;
 
-        return __load_balance_iterator(cfs_rq, cfs_rq->rb_load_balance_curr);
+        return __load_balance_iterator(cfs_rq, cfs_rq->balance_iterator);
 }
 
-#ifdef CONFIG_FAIR_GROUP_SCHED
-static int cfs_rq_best_prio(struct cfs_rq *cfs_rq)
+static unsigned long
+__load_balance_fair(struct rq *this_rq, int this_cpu, struct rq *busiest,
+                unsigned long max_load_move, struct sched_domain *sd,
+                enum cpu_idle_type idle, int *all_pinned, int *this_best_prio,
+                struct cfs_rq *cfs_rq)
 {
-        struct sched_entity *curr;
-        struct task_struct *p;
-
-        if (!cfs_rq->nr_running || !first_fair(cfs_rq))
-                return MAX_PRIO;
-
-        curr = cfs_rq->curr;
-        if (!curr)
-                curr = __pick_next_entity(cfs_rq);
+        struct rq_iterator cfs_rq_iterator;
 
-        p = task_of(curr);
+        cfs_rq_iterator.start = load_balance_start_fair;
+        cfs_rq_iterator.next = load_balance_next_fair;
+        cfs_rq_iterator.arg = cfs_rq;
 
-        return p->prio;
+        return balance_tasks(this_rq, this_cpu, busiest,
+                        max_load_move, sd, idle, all_pinned,
+                        this_best_prio, &cfs_rq_iterator);
 }
-#endif
 
+#ifdef CONFIG_FAIR_GROUP_SCHED
 static unsigned long
 load_balance_fair(struct rq *this_rq, int this_cpu, struct rq *busiest,
                   unsigned long max_load_move,
                   struct sched_domain *sd, enum cpu_idle_type idle,
                   int *all_pinned, int *this_best_prio)
 {
-        struct cfs_rq *busy_cfs_rq;
         long rem_load_move = max_load_move;
-        struct rq_iterator cfs_rq_iterator;
-
-        cfs_rq_iterator.start = load_balance_start_fair;
-        cfs_rq_iterator.next = load_balance_next_fair;
+        int busiest_cpu = cpu_of(busiest);
+        struct task_group *tg;
 
-        for_each_leaf_cfs_rq(busiest, busy_cfs_rq) {
-#ifdef CONFIG_FAIR_GROUP_SCHED
-                struct cfs_rq *this_cfs_rq;
+        rcu_read_lock();
+        list_for_each_entry(tg, &task_groups, list) {
                 long imbalance;
-                unsigned long maxload;
+                unsigned long this_weight, busiest_weight;
+                long rem_load, max_load, moved_load;
+
+                /*
+                 * empty group
+                 */
+                if (!aggregate(tg, sd)->task_weight)
+                        continue;
+
+                rem_load = rem_load_move * aggregate(tg, sd)->rq_weight;
+                rem_load /= aggregate(tg, sd)->load + 1;
+
+                this_weight = tg->cfs_rq[this_cpu]->task_weight;
+                busiest_weight = tg->cfs_rq[busiest_cpu]->task_weight;
+
+                imbalance = (busiest_weight - this_weight) / 2;
 
-                this_cfs_rq = cpu_cfs_rq(busy_cfs_rq, this_cpu);
+                if (imbalance < 0)
+                        imbalance = busiest_weight;
 
-                imbalance = busy_cfs_rq->load.weight - this_cfs_rq->load.weight;
-                /* Don't pull if this_cfs_rq has more load than busy_cfs_rq */
-                if (imbalance <= 0)
+                max_load = max(rem_load, imbalance);
+                moved_load = __load_balance_fair(this_rq, this_cpu, busiest,
+                                max_load, sd, idle, all_pinned, this_best_prio,
+                                tg->cfs_rq[busiest_cpu]);
+
+                if (!moved_load)
                         continue;
 
-                /* Don't pull more than imbalance/2 */
-                imbalance /= 2;
-                maxload = min(rem_load_move, imbalance);
+                move_group_shares(tg, sd, busiest_cpu, this_cpu);
 
-                *this_best_prio = cfs_rq_best_prio(this_cfs_rq);
-#else
-# define maxload rem_load_move
-#endif
-                /*
-                 * pass busy_cfs_rq argument into
-                 * load_balance_[start|next]_fair iterators
-                 */
-                cfs_rq_iterator.arg = busy_cfs_rq;
-                rem_load_move -= balance_tasks(this_rq, this_cpu, busiest,
-                                               maxload, sd, idle, all_pinned,
-                                               this_best_prio,
-                                               &cfs_rq_iterator);
+                moved_load *= aggregate(tg, sd)->load;
+                moved_load /= aggregate(tg, sd)->rq_weight + 1;
 
-                if (rem_load_move <= 0)
+                rem_load_move -= moved_load;
+                if (rem_load_move < 0)
                         break;
         }
+        rcu_read_unlock();
 
         return max_load_move - rem_load_move;
 }
+#else
+static unsigned long
+load_balance_fair(struct rq *this_rq, int this_cpu, struct rq *busiest,
+                  unsigned long max_load_move,
+                  struct sched_domain *sd, enum cpu_idle_type idle,
+                  int *all_pinned, int *this_best_prio)
+{
+        return __load_balance_fair(this_rq, this_cpu, busiest,
+                        max_load_move, sd, idle, all_pinned,
+                        this_best_prio, &busiest->cfs);
+}
+#endif
 
 static int
 move_one_task_fair(struct rq *this_rq, int this_cpu, struct rq *busiest,
@@ -1461,16 +1611,40 @@ static const struct sched_class fair_sched_class = {
 };
 
 #ifdef CONFIG_SCHED_DEBUG
+static void
+print_cfs_rq_tasks(struct seq_file *m, struct cfs_rq *cfs_rq, int depth)
+{
+        struct sched_entity *se;
+
+        if (!cfs_rq)
+                return;
+
+        list_for_each_entry_rcu(se, &cfs_rq->tasks, group_node) {
+                int i;
+
+                for (i = depth; i; i--)
+                        seq_puts(m, "  ");
+
+                seq_printf(m, "%lu %s %lu\n",
+                                se->load.weight,
+                                entity_is_task(se) ? "T" : "G",
+                                calc_delta_weight(SCHED_LOAD_SCALE, se)
+                                );
+                if (!entity_is_task(se))
+                        print_cfs_rq_tasks(m, group_cfs_rq(se), depth + 1);
+        }
+}
+
 static void print_cfs_stats(struct seq_file *m, int cpu)
 {
         struct cfs_rq *cfs_rq;
 
-#ifdef CONFIG_FAIR_GROUP_SCHED
-        print_cfs_rq(m, cpu, &cpu_rq(cpu)->cfs);
-#endif
         rcu_read_lock();
         for_each_leaf_cfs_rq(cpu_rq(cpu), cfs_rq)
                 print_cfs_rq(m, cpu, cfs_rq);
+
+        seq_printf(m, "\nWeight tree:\n");
+        print_cfs_rq_tasks(m, &cpu_rq(cpu)->cfs, 1);
         rcu_read_unlock();
 }
 #endif
diff --git a/kernel/sched_features.h b/kernel/sched_features.h
new file mode 100644
index 000000000000..1c7283cb9581
--- /dev/null
+++ b/kernel/sched_features.h
@@ -0,0 +1,10 @@
+SCHED_FEAT(NEW_FAIR_SLEEPERS, 1)
+SCHED_FEAT(WAKEUP_PREEMPT, 1)
+SCHED_FEAT(START_DEBIT, 1)
+SCHED_FEAT(AFFINE_WAKEUPS, 1)
+SCHED_FEAT(CACHE_HOT_BUDDY, 1)
+SCHED_FEAT(SYNC_WAKEUPS, 1)
+SCHED_FEAT(HRTICK, 1)
+SCHED_FEAT(DOUBLE_TICK, 0)
+SCHED_FEAT(NORMALIZED_SLEEPER, 1)
+SCHED_FEAT(DEADLINE, 1)
diff --git a/kernel/sched_rt.c b/kernel/sched_rt.c
index 0a6d2e516420..c2730a5a4f05 100644
--- a/kernel/sched_rt.c
+++ b/kernel/sched_rt.c
@@ -62,7 +62,12 @@ static inline u64 sched_rt_runtime(struct rt_rq *rt_rq)
         if (!rt_rq->tg)
                 return RUNTIME_INF;
 
-        return rt_rq->tg->rt_runtime;
+        return rt_rq->rt_runtime;
+}
+
+static inline u64 sched_rt_period(struct rt_rq *rt_rq)
+{
+        return ktime_to_ns(rt_rq->tg->rt_bandwidth.rt_period);
 }
 
 #define for_each_leaf_rt_rq(rt_rq, rq) \
@@ -127,14 +132,39 @@ static int rt_se_boosted(struct sched_rt_entity *rt_se)
         return p->prio != p->normal_prio;
 }
 
+#ifdef CONFIG_SMP
+static inline cpumask_t sched_rt_period_mask(void)
+{
+        return cpu_rq(smp_processor_id())->rd->span;
+}
+#else
+static inline cpumask_t sched_rt_period_mask(void)
+{
+        return cpu_online_map;
+}
+#endif
+
+static inline
+struct rt_rq *sched_rt_period_rt_rq(struct rt_bandwidth *rt_b, int cpu)
+{
+        return container_of(rt_b, struct task_group, rt_bandwidth)->rt_rq[cpu];
+}
+
+static inline struct rt_bandwidth *sched_rt_bandwidth(struct rt_rq *rt_rq)
+{
+        return &rt_rq->tg->rt_bandwidth;
+}
+
 #else
 
 static inline u64 sched_rt_runtime(struct rt_rq *rt_rq)
 {
-        if (sysctl_sched_rt_runtime == -1)
-                return RUNTIME_INF;
+        return rt_rq->rt_runtime;
+}
 
-        return (u64)sysctl_sched_rt_runtime * NSEC_PER_USEC;
+static inline u64 sched_rt_period(struct rt_rq *rt_rq)
+{
+        return ktime_to_ns(def_rt_bandwidth.rt_period);
 }
 
 #define for_each_leaf_rt_rq(rt_rq, rq) \
@@ -173,6 +203,102 @@ 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)
+{
+        return cpu_online_map;
+}
+
+static inline
+struct rt_rq *sched_rt_period_rt_rq(struct rt_bandwidth *rt_b, int cpu)
+{
+        return &cpu_rq(cpu)->rt;
+}
+
+static inline struct rt_bandwidth *sched_rt_bandwidth(struct rt_rq *rt_rq)
+{
+        return &def_rt_bandwidth;
+}
+
+#endif
+
+static int do_sched_rt_period_timer(struct rt_bandwidth *rt_b, int overrun)
+{
+        int i, idle = 1;
+        cpumask_t span;
+
+        if (rt_b->rt_runtime == RUNTIME_INF)
+                return 1;
+
+        span = sched_rt_period_mask();
+        for_each_cpu_mask(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);
+
+                spin_lock(&rq->lock);
+                if (rt_rq->rt_time) {
+                        u64 runtime;
+
+                        spin_lock(&rt_rq->rt_runtime_lock);
+                        runtime = rt_rq->rt_runtime;
+                        rt_rq->rt_time -= min(rt_rq->rt_time, overrun*runtime);
+                        if (rt_rq->rt_throttled && rt_rq->rt_time < runtime) {
+                                rt_rq->rt_throttled = 0;
+                                enqueue = 1;
+                        }
+                        if (rt_rq->rt_time || rt_rq->rt_nr_running)
+                                idle = 0;
+                        spin_unlock(&rt_rq->rt_runtime_lock);
+                }
+
+                if (enqueue)
+                        sched_rt_rq_enqueue(rt_rq);
+                spin_unlock(&rq->lock);
+        }
+
+        return idle;
+}
+
+#ifdef CONFIG_SMP
+static int balance_runtime(struct rt_rq *rt_rq)
+{
+        struct rt_bandwidth *rt_b = sched_rt_bandwidth(rt_rq);
+        struct root_domain *rd = cpu_rq(smp_processor_id())->rd;
+        int i, weight, more = 0;
+        u64 rt_period;
+
+        weight = cpus_weight(rd->span);
+
+        spin_lock(&rt_b->rt_runtime_lock);
+        rt_period = ktime_to_ns(rt_b->rt_period);
+        for_each_cpu_mask(i, rd->span) {
+                struct rt_rq *iter = sched_rt_period_rt_rq(rt_b, i);
+                s64 diff;
+
+                if (iter == rt_rq)
+                        continue;
+
+                spin_lock(&iter->rt_runtime_lock);
+                diff = iter->rt_runtime - iter->rt_time;
+                if (diff > 0) {
+                        do_div(diff, weight);
+                        if (rt_rq->rt_runtime + diff > rt_period)
+                                diff = rt_period - rt_rq->rt_runtime;
+                        iter->rt_runtime -= diff;
+                        rt_rq->rt_runtime += diff;
+                        more = 1;
+                        if (rt_rq->rt_runtime == rt_period) {
+                                spin_unlock(&iter->rt_runtime_lock);
+                                break;
+                        }
+                }
+                spin_unlock(&iter->rt_runtime_lock);
+        }
+        spin_unlock(&rt_b->rt_runtime_lock);
+
+        return more;
+}
 #endif
 
 static inline int rt_se_prio(struct sched_rt_entity *rt_se)
@@ -197,12 +323,24 @@ static int sched_rt_runtime_exceeded(struct rt_rq *rt_rq)
         if (rt_rq->rt_throttled)
                 return rt_rq_throttled(rt_rq);
 
+        if (sched_rt_runtime(rt_rq) >= sched_rt_period(rt_rq))
+                return 0;
+
+#ifdef CONFIG_SMP
         if (rt_rq->rt_time > runtime) {
-                struct rq *rq = rq_of_rt_rq(rt_rq);
+                int more;
 
-                rq->rt_throttled = 1;
-                rt_rq->rt_throttled = 1;
+                spin_unlock(&rt_rq->rt_runtime_lock);
+                more = balance_runtime(rt_rq);
+                spin_lock(&rt_rq->rt_runtime_lock);
 
+                if (more)
+                        runtime = sched_rt_runtime(rt_rq);
+        }
+#endif
+
+        if (rt_rq->rt_time > runtime) {
+                rt_rq->rt_throttled = 1;
                 if (rt_rq_throttled(rt_rq)) {
                         sched_rt_rq_dequeue(rt_rq);
                         return 1;
@@ -212,29 +350,6 @@ static int sched_rt_runtime_exceeded(struct rt_rq *rt_rq)
         return 0;
 }
 
-static void update_sched_rt_period(struct rq *rq)
-{
-        struct rt_rq *rt_rq;
-        u64 period;
-
-        while (rq->clock > rq->rt_period_expire) {
-                period = (u64)sysctl_sched_rt_period * NSEC_PER_USEC;
-                rq->rt_period_expire += period;
-
-                for_each_leaf_rt_rq(rt_rq, rq) {
-                        u64 runtime = sched_rt_runtime(rt_rq);
-
-                        rt_rq->rt_time -= min(rt_rq->rt_time, runtime);
-                        if (rt_rq->rt_throttled && rt_rq->rt_time < runtime) {
-                                rt_rq->rt_throttled = 0;
-                                sched_rt_rq_enqueue(rt_rq);
-                        }
-                }
-
-                rq->rt_throttled = 0;
-        }
-}
-
 /*
  * Update the current task's runtime statistics. Skip current tasks that
  * are not in our scheduling class.
@@ -259,9 +374,15 @@ static void update_curr_rt(struct rq *rq)
         curr->se.exec_start = rq->clock;
         cpuacct_charge(curr, delta_exec);
 
-        rt_rq->rt_time += delta_exec;
-        if (sched_rt_runtime_exceeded(rt_rq))
-                resched_task(curr);
+        for_each_sched_rt_entity(rt_se) {
+                rt_rq = rt_rq_of_se(rt_se);
+
+                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);
+        }
 }
 
 static inline
@@ -284,6 +405,11 @@ void inc_rt_tasks(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
 #ifdef CONFIG_RT_GROUP_SCHED
         if (rt_se_boosted(rt_se))
                 rt_rq->rt_nr_boosted++;
+
+        if (rt_rq->tg)
+                start_rt_bandwidth(&rt_rq->tg->rt_bandwidth);
+#else
+        start_rt_bandwidth(&def_rt_bandwidth);
 #endif
 }
 
@@ -353,27 +479,21 @@ static void dequeue_rt_entity(struct sched_rt_entity *rt_se)
 /*
  * Because the prio of an upper entry depends on the lower
  * entries, we must remove entries top - down.
- *
- * XXX: O(1/2 h^2) because we can only walk up, not down the chain.
- *      doesn't matter much for now, as h=2 for GROUP_SCHED.
  */
 static void dequeue_rt_stack(struct task_struct *p)
 {
-        struct sched_rt_entity *rt_se, *top_se;
+        struct sched_rt_entity *rt_se, *back = NULL;
 
-        /*
-         * dequeue all, top - down.
-         */
-        do {
-                rt_se = &p->rt;
-                top_se = NULL;
-                for_each_sched_rt_entity(rt_se) {
-                        if (on_rt_rq(rt_se))
-                                top_se = rt_se;
-                }
-                if (top_se)
-                        dequeue_rt_entity(top_se);
-        } while (top_se);
+        rt_se = &p->rt;
+        for_each_sched_rt_entity(rt_se) {
+                rt_se->back = back;
+                back = rt_se;
+        }
+
+        for (rt_se = back; rt_se; rt_se = rt_se->back) {
+                if (on_rt_rq(rt_se))
+                        dequeue_rt_entity(rt_se);
+        }
 }
 
 /*
@@ -393,6 +513,8 @@ static void enqueue_task_rt(struct rq *rq, struct task_struct *p, int wakeup)
          */
         for_each_sched_rt_entity(rt_se)
                 enqueue_rt_entity(rt_se);
+
+        inc_cpu_load(rq, p->se.load.weight);
 }
 
 static void dequeue_task_rt(struct rq *rq, struct task_struct *p, int sleep)
@@ -412,6 +534,8 @@ static void dequeue_task_rt(struct rq *rq, struct task_struct *p, int sleep)
                 if (rt_rq && rt_rq->rt_nr_running)
                         enqueue_rt_entity(rt_se);
         }
+
+        dec_cpu_load(rq, p->se.load.weight);
 }
 
 /*
@@ -1001,7 +1125,8 @@ move_one_task_rt(struct rq *this_rq, int this_cpu, struct rq *busiest,
         return 0;
 }
 
-static void set_cpus_allowed_rt(struct task_struct *p, cpumask_t *new_mask)
+static void set_cpus_allowed_rt(struct task_struct *p,
+                                const cpumask_t *new_mask)
 {
         int weight = cpus_weight(*new_mask);
 
diff --git a/kernel/sched_stats.h b/kernel/sched_stats.h
index 5b32433e7ee5..5bae2e0c3ff2 100644
--- a/kernel/sched_stats.h
+++ b/kernel/sched_stats.h
@@ -9,6 +9,11 @@
 static int show_schedstat(struct seq_file *seq, void *v)
 {
         int cpu;
+        int mask_len = NR_CPUS/32 * 9;
+        char *mask_str = kmalloc(mask_len, GFP_KERNEL);
+
+        if (mask_str == NULL)
+                return -ENOMEM;
 
         seq_printf(seq, "version %d\n", SCHEDSTAT_VERSION);
         seq_printf(seq, "timestamp %lu\n", jiffies);
@@ -36,9 +41,8 @@ static int show_schedstat(struct seq_file *seq, void *v)
                 preempt_disable();
                 for_each_domain(cpu, sd) {
                         enum cpu_idle_type itype;
-                        char mask_str[NR_CPUS];
 
-                        cpumask_scnprintf(mask_str, NR_CPUS, sd->span);
+                        cpumask_scnprintf(mask_str, mask_len, sd->span);
                         seq_printf(seq, "domain%d %s", dcount++, mask_str);
                         for (itype = CPU_IDLE; itype < CPU_MAX_IDLE_TYPES;
                                         itype++) {
diff --git a/kernel/softirq.c b/kernel/softirq.c
index 31e9f2a47928..3c44956ee7e2 100644
--- a/kernel/softirq.c
+++ b/kernel/softirq.c
@@ -356,7 +356,8 @@ void open_softirq(int nr, void (*action)(struct softirq_action*), void *data)
 /* Tasklets */
 struct tasklet_head
 {
-        struct tasklet_struct *list;
+        struct tasklet_struct *head;
+        struct tasklet_struct **tail;
 };
 
 /* Some compilers disobey section attribute on statics when not
@@ -369,8 +370,9 @@ void __tasklet_schedule(struct tasklet_struct *t)
         unsigned long flags;
 
         local_irq_save(flags);
-        t->next = __get_cpu_var(tasklet_vec).list;
-        __get_cpu_var(tasklet_vec).list = t;
+        t->next = NULL;
+        *__get_cpu_var(tasklet_vec).tail = t;
+        __get_cpu_var(tasklet_vec).tail = &(t->next);
         raise_softirq_irqoff(TASKLET_SOFTIRQ);
         local_irq_restore(flags);
 }
@@ -382,8 +384,9 @@ void __tasklet_hi_schedule(struct tasklet_struct *t)
         unsigned long flags;
 
         local_irq_save(flags);
-        t->next = __get_cpu_var(tasklet_hi_vec).list;
-        __get_cpu_var(tasklet_hi_vec).list = t;
+        t->next = NULL;
+        *__get_cpu_var(tasklet_hi_vec).tail = t;
+        __get_cpu_var(tasklet_hi_vec).tail = &(t->next);
         raise_softirq_irqoff(HI_SOFTIRQ);
         local_irq_restore(flags);
 }
@@ -395,8 +398,9 @@ static void tasklet_action(struct softirq_action *a)
         struct tasklet_struct *list;
 
         local_irq_disable();
-        list = __get_cpu_var(tasklet_vec).list;
-        __get_cpu_var(tasklet_vec).list = NULL;
+        list = __get_cpu_var(tasklet_vec).head;
+        __get_cpu_var(tasklet_vec).head = NULL;
+        __get_cpu_var(tasklet_vec).tail = &__get_cpu_var(tasklet_vec).head;
         local_irq_enable();
 
         while (list) {
@@ -416,8 +420,9 @@ static void tasklet_action(struct softirq_action *a)
                 }
 
                 local_irq_disable();
-                t->next = __get_cpu_var(tasklet_vec).list;
-                __get_cpu_var(tasklet_vec).list = t;
+                t->next = NULL;
+                *__get_cpu_var(tasklet_vec).tail = t;
+                __get_cpu_var(tasklet_vec).tail = &(t->next);
                 __raise_softirq_irqoff(TASKLET_SOFTIRQ);
                 local_irq_enable();
         }
@@ -428,8 +433,9 @@ static void tasklet_hi_action(struct softirq_action *a)
         struct tasklet_struct *list;
 
         local_irq_disable();
-        list = __get_cpu_var(tasklet_hi_vec).list;
-        __get_cpu_var(tasklet_hi_vec).list = NULL;
+        list = __get_cpu_var(tasklet_hi_vec).head;
+        __get_cpu_var(tasklet_hi_vec).head = NULL;
+        __get_cpu_var(tasklet_hi_vec).tail = &__get_cpu_var(tasklet_hi_vec).head;
         local_irq_enable();
 
         while (list) {
@@ -449,8 +455,9 @@ static void tasklet_hi_action(struct softirq_action *a)
                 }
 
                 local_irq_disable();
-                t->next = __get_cpu_var(tasklet_hi_vec).list;
-                __get_cpu_var(tasklet_hi_vec).list = t;
+                t->next = NULL;
+                *__get_cpu_var(tasklet_hi_vec).tail = t;
+                __get_cpu_var(tasklet_hi_vec).tail = &(t->next);
                 __raise_softirq_irqoff(HI_SOFTIRQ);
                 local_irq_enable();
         }
@@ -487,6 +494,15 @@ EXPORT_SYMBOL(tasklet_kill);
 
 void __init softirq_init(void)
 {
+        int cpu;
+
+        for_each_possible_cpu(cpu) {
+                per_cpu(tasklet_vec, cpu).tail =
+                        &per_cpu(tasklet_vec, cpu).head;
+                per_cpu(tasklet_hi_vec, cpu).tail =
+                        &per_cpu(tasklet_hi_vec, cpu).head;
+        }
+
         open_softirq(TASKLET_SOFTIRQ, tasklet_action, NULL);
         open_softirq(HI_SOFTIRQ, tasklet_hi_action, NULL);
 }
@@ -555,9 +571,12 @@ void tasklet_kill_immediate(struct tasklet_struct *t, unsigned int cpu)
                 return;
 
         /* CPU is dead, so no lock needed. */
-        for (i = &per_cpu(tasklet_vec, cpu).list; *i; i = &(*i)->next) {
+        for (i = &per_cpu(tasklet_vec, cpu).head; *i; i = &(*i)->next) {
                 if (*i == t) {
                         *i = t->next;
+                        /* If this was the tail element, move the tail ptr */
+                        if (*i == NULL)
+                                per_cpu(tasklet_vec, cpu).tail = i;
                         return;
                 }
         }
@@ -566,20 +585,20 @@ void tasklet_kill_immediate(struct tasklet_struct *t, unsigned int cpu)
 
 static void takeover_tasklets(unsigned int cpu)
 {
-        struct tasklet_struct **i;
-
         /* CPU is dead, so no lock needed. */
         local_irq_disable();
 
         /* Find end, append list for that CPU. */
-        for (i = &__get_cpu_var(tasklet_vec).list; *i; i = &(*i)->next);
-        *i = per_cpu(tasklet_vec, cpu).list;
-        per_cpu(tasklet_vec, cpu).list = NULL;
+        *__get_cpu_var(tasklet_vec).tail = per_cpu(tasklet_vec, cpu).head;
+        __get_cpu_var(tasklet_vec).tail = per_cpu(tasklet_vec, cpu).tail;
+        per_cpu(tasklet_vec, cpu).head = NULL;
+        per_cpu(tasklet_vec, cpu).tail = &per_cpu(tasklet_vec, cpu).head;
         raise_softirq_irqoff(TASKLET_SOFTIRQ);
 
-        for (i = &__get_cpu_var(tasklet_hi_vec).list; *i; i = &(*i)->next);
-        *i = per_cpu(tasklet_hi_vec, cpu).list;
-        per_cpu(tasklet_hi_vec, cpu).list = NULL;
+        *__get_cpu_var(tasklet_hi_vec).tail = per_cpu(tasklet_hi_vec, cpu).head;
+        __get_cpu_var(tasklet_hi_vec).tail = per_cpu(tasklet_hi_vec, cpu).tail;
+        per_cpu(tasklet_hi_vec, cpu).head = NULL;
+        per_cpu(tasklet_hi_vec, cpu).tail = &per_cpu(tasklet_hi_vec, cpu).head;
         raise_softirq_irqoff(HI_SOFTIRQ);
 
         local_irq_enable();
diff --git a/kernel/stop_machine.c b/kernel/stop_machine.c
index 6f4e0e13f70c..e1b2a5b1b105 100644
--- a/kernel/stop_machine.c
+++ b/kernel/stop_machine.c
@@ -35,7 +35,7 @@ static int stopmachine(void *cpu)
         int irqs_disabled = 0;
         int prepared = 0;
 
-        set_cpus_allowed(current, cpumask_of_cpu((int)(long)cpu));
+        set_cpus_allowed_ptr(current, &cpumask_of_cpu((int)(long)cpu));
 
         /* Ack: we are alive */
         smp_mb(); /* Theoretically the ack = 0 might not be on this CPU yet. */
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index b2a2d6889bab..fd3364827ccf 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -270,17 +270,6 @@ static struct ctl_table kern_table[] = {
         },
         {
                 .ctl_name       = CTL_UNNUMBERED,
-                .procname       = "sched_batch_wakeup_granularity_ns",
-                .data           = &sysctl_sched_batch_wakeup_granularity,
-                .maxlen         = sizeof(unsigned int),
-                .mode           = 0644,
-                .proc_handler   = &proc_dointvec_minmax,
-                .strategy       = &sysctl_intvec,
-                .extra1         = &min_wakeup_granularity_ns,
-                .extra2         = &max_wakeup_granularity_ns,
-        },
-        {
-                .ctl_name       = CTL_UNNUMBERED,
                 .procname       = "sched_child_runs_first",
                 .data           = &sysctl_sched_child_runs_first,
                 .maxlen         = sizeof(unsigned int),
@@ -318,7 +307,7 @@ static struct ctl_table kern_table[] = {
                 .data           = &sysctl_sched_rt_period,
                 .maxlen         = sizeof(unsigned int),
                 .mode           = 0644,
-                .proc_handler   = &proc_dointvec,
+                .proc_handler   = &sched_rt_handler,
         },
         {
                 .ctl_name       = CTL_UNNUMBERED,
@@ -326,7 +315,7 @@ static struct ctl_table kern_table[] = {
                 .data           = &sysctl_sched_rt_runtime,
                 .maxlen         = sizeof(int),
                 .mode           = 0644,
-                .proc_handler   = &proc_dointvec,
+                .proc_handler   = &sched_rt_handler,
         },
         {
                 .ctl_name       = CTL_UNNUMBERED,
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index 69dba0c71727..d358d4e3a958 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -191,7 +191,6 @@ u64 get_cpu_idle_time_us(int cpu, u64 *last_update_time)
 void tick_nohz_stop_sched_tick(void)
 {
         unsigned long seq, last_jiffies, next_jiffies, delta_jiffies, flags;
-        unsigned long rt_jiffies;
         struct tick_sched *ts;
         ktime_t last_update, expires, now;
         struct clock_event_device *dev = __get_cpu_var(tick_cpu_device).evtdev;
@@ -243,10 +242,6 @@ void tick_nohz_stop_sched_tick(void)
         next_jiffies = get_next_timer_interrupt(last_jiffies);
         delta_jiffies = next_jiffies - last_jiffies;
 
-        rt_jiffies = rt_needs_cpu(cpu);
-        if (rt_jiffies && rt_jiffies < delta_jiffies)
-                delta_jiffies = rt_jiffies;
-
         if (rcu_needs_cpu(cpu))
                 delta_jiffies = 1;
         /*
diff --git a/kernel/user.c b/kernel/user.c
index 7132022a040c..debce602bfdd 100644
--- a/kernel/user.c
+++ b/kernel/user.c
@@ -101,7 +101,7 @@ static int sched_create_user(struct user_struct *up)
 {
         int rc = 0;
 
-        up->tg = sched_create_group();
+        up->tg = sched_create_group(&root_task_group);
         if (IS_ERR(up->tg))
                 rc = -ENOMEM;
 
@@ -193,6 +193,33 @@ static ssize_t cpu_rt_runtime_store(struct kobject *kobj,
 
 static struct kobj_attribute cpu_rt_runtime_attr =
         __ATTR(cpu_rt_runtime, 0644, cpu_rt_runtime_show, cpu_rt_runtime_store);
+
+static ssize_t cpu_rt_period_show(struct kobject *kobj,
+                                   struct kobj_attribute *attr,
+                                   char *buf)
+{
+        struct user_struct *up = container_of(kobj, struct user_struct, kobj);
+
+        return sprintf(buf, "%lu\n", sched_group_rt_period(up->tg));
+}
+
+static ssize_t cpu_rt_period_store(struct kobject *kobj,
+                                    struct kobj_attribute *attr,
+                                    const char *buf, size_t size)
+{
+        struct user_struct *up = container_of(kobj, struct user_struct, kobj);
+        unsigned long rt_period;
+        int rc;
+
+        sscanf(buf, "%lu", &rt_period);
+
+        rc = sched_group_set_rt_period(up->tg, rt_period);
+
+        return (rc ? rc : size);
+}
+
+static struct kobj_attribute cpu_rt_period_attr =
+        __ATTR(cpu_rt_period, 0644, cpu_rt_period_show, cpu_rt_period_store);
 #endif
 
 /* default attributes per uid directory */
@@ -202,6 +229,7 @@ static struct attribute *uids_attributes[] = {
 #endif
 #ifdef CONFIG_RT_GROUP_SCHED
         &cpu_rt_runtime_attr.attr,
+        &cpu_rt_period_attr.attr,
 #endif
         NULL
 };
diff --git a/lib/bitmap.c b/lib/bitmap.c
index 2c9242e3fed0..a6939e18d7bb 100644
--- a/lib/bitmap.c
+++ b/lib/bitmap.c
@@ -316,6 +316,22 @@ int bitmap_scnprintf(char *buf, unsigned int buflen,
 EXPORT_SYMBOL(bitmap_scnprintf);
 
 /**
+ * bitmap_scnprintf_len - return buffer length needed to convert
+ * bitmap to an ASCII hex string.
+ * @len: number of bits to be converted
+ */
+int bitmap_scnprintf_len(unsigned int len)
+{
+        /* we need 9 chars per word for 32 bit words (8 hexdigits + sep/null) */
+        int bitslen = ALIGN(len, CHUNKSZ);
+        int wordlen = CHUNKSZ / 4;
+        int buflen = (bitslen / wordlen) * (wordlen + 1) * sizeof(char);
+
+        return buflen;
+}
+EXPORT_SYMBOL(bitmap_scnprintf_len);
+
+/**
  * __bitmap_parse - convert an ASCII hex string into a bitmap.
  * @buf: pointer to buffer containing string.
  * @buflen: buffer size in bytes.  If string is smaller than this
diff --git a/mm/allocpercpu.c b/mm/allocpercpu.c
index b0012e27fea8..f4026bae6eed 100644
--- a/mm/allocpercpu.c
+++ b/mm/allocpercpu.c
@@ -82,9 +82,10 @@ EXPORT_SYMBOL_GPL(percpu_populate);
 int __percpu_populate_mask(void *__pdata, size_t size, gfp_t gfp,
                            cpumask_t *mask)
 {
-        cpumask_t populated = CPU_MASK_NONE;
+        cpumask_t populated;
         int cpu;
 
+        cpus_clear(populated);
         for_each_cpu_mask(cpu, *mask)
                 if (unlikely(!percpu_populate(__pdata, size, gfp, cpu))) {
                         __percpu_depopulate_mask(__pdata, &populated);
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 402a504f1228..32e796af12a1 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -2029,6 +2029,7 @@ static int find_next_best_node(int node, nodemask_t *used_node_mask)
         int n, val;
         int min_val = INT_MAX;
         int best_node = -1;
+        node_to_cpumask_ptr(tmp, 0);
 
         /* Use the local node if we haven't already */
         if (!node_isset(node, *used_node_mask)) {
@@ -2037,7 +2038,6 @@ static int find_next_best_node(int node, nodemask_t *used_node_mask)
         }
 
         for_each_node_state(n, N_HIGH_MEMORY) {
-                cpumask_t tmp;
 
                 /* Don't want a node to appear more than once */
                 if (node_isset(n, *used_node_mask))
@@ -2050,8 +2050,8 @@ static int find_next_best_node(int node, nodemask_t *used_node_mask)
                 val += (n < node);
 
                 /* Give preference to headless and unused nodes */
-                tmp = node_to_cpumask(n);
-                if (!cpus_empty(tmp))
+                node_to_cpumask_ptr_next(tmp, n);
+                if (!cpus_empty(*tmp))
                         val += PENALTY_FOR_NODE_WITH_CPUS;
 
                 /* Slight preference for less loaded node */
diff --git a/mm/pdflush.c b/mm/pdflush.c
index 8f6ee073c0e3..0ceacff56457 100644
--- a/mm/pdflush.c
+++ b/mm/pdflush.c
@@ -187,8 +187,8 @@ static int pdflush(void *dummy)
          * This is needed as pdflush's are dynamically created and destroyed.
          * The boottime pdflush's are easily placed w/o these 2 lines.
          */
-        cpus_allowed = cpuset_cpus_allowed(current);
-        set_cpus_allowed(current, cpus_allowed);
+        cpuset_cpus_allowed(current, &cpus_allowed);
+        set_cpus_allowed_ptr(current, &cpus_allowed);
 
         return __pdflush(&my_work);
 }
diff --git a/mm/slab.c b/mm/slab.c
index 04b308c3bc54..03927cb5ec9e 100644
--- a/mm/slab.c
+++ b/mm/slab.c
@@ -1160,14 +1160,13 @@ static void __cpuinit cpuup_canceled(long cpu)
         struct kmem_cache *cachep;
         struct kmem_list3 *l3 = NULL;
         int node = cpu_to_node(cpu);
+        node_to_cpumask_ptr(mask, node);
 
         list_for_each_entry(cachep, &cache_chain, next) {
                 struct array_cache *nc;
                 struct array_cache *shared;
                 struct array_cache **alien;
-                cpumask_t mask;
 
-                mask = node_to_cpumask(node);
                 /* cpu is dead; no one can alloc from it. */
                 nc = cachep->array[cpu];
                 cachep->array[cpu] = NULL;
@@ -1183,7 +1182,7 @@ static void __cpuinit cpuup_canceled(long cpu)
                 if (nc)
                         free_block(cachep, nc->entry, nc->avail, node);
 
-                if (!cpus_empty(mask)) {
+                if (!cpus_empty(*mask)) {
                         spin_unlock_irq(&l3->list_lock);
                         goto free_array_cache;
                 }
diff --git a/mm/vmscan.c b/mm/vmscan.c
index 4046434046e6..f80a5b7c057f 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -1647,11 +1647,10 @@ static int kswapd(void *p)
         struct reclaim_state reclaim_state = {
                 .reclaimed_slab = 0,
         };
-        cpumask_t cpumask;
+        node_to_cpumask_ptr(cpumask, pgdat->node_id);
 
-        cpumask = node_to_cpumask(pgdat->node_id);
-        if (!cpus_empty(cpumask))
-                set_cpus_allowed(tsk, cpumask);
+        if (!cpus_empty(*cpumask))
+                set_cpus_allowed_ptr(tsk, cpumask);
         current->reclaim_state = &reclaim_state;
 
         /*
@@ -1880,17 +1879,16 @@ out:
 static int __devinit cpu_callback(struct notifier_block *nfb,
                                   unsigned long action, void *hcpu)
 {
-        pg_data_t *pgdat;
-        cpumask_t mask;
         int nid;
 
         if (action == CPU_ONLINE || action == CPU_ONLINE_FROZEN) {
                 for_each_node_state(nid, N_HIGH_MEMORY) {
-                        pgdat = NODE_DATA(nid);
-                        mask = node_to_cpumask(pgdat->node_id);
-                        if (any_online_cpu(mask) != NR_CPUS)
+                        pg_data_t *pgdat = NODE_DATA(nid);
+                        node_to_cpumask_ptr(mask, pgdat->node_id);
+
+                        if (any_online_cpu(*mask) < nr_cpu_ids)
                                 /* One of our CPUs online: restore mask */
-                                set_cpus_allowed(pgdat->kswapd, mask);
+                                set_cpus_allowed_ptr(pgdat->kswapd, mask);
                 }
         }
         return NOTIFY_OK;
diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c
index a290e1523297..090af78d68b5 100644
--- a/net/sunrpc/svc.c
+++ b/net/sunrpc/svc.c
@@ -301,7 +301,6 @@ static inline int
 svc_pool_map_set_cpumask(unsigned int pidx, cpumask_t *oldmask)
 {
         struct svc_pool_map *m = &svc_pool_map;
-        unsigned int node; /* or cpu */
 
         /*
          * The caller checks for sv_nrpools > 1, which
@@ -314,16 +313,23 @@ svc_pool_map_set_cpumask(unsigned int pidx, cpumask_t *oldmask)
         default:
                 return 0;
         case SVC_POOL_PERCPU:
-                node = m->pool_to[pidx];
+        {
+                unsigned int cpu = m->pool_to[pidx];
+
                 *oldmask = current->cpus_allowed;
-                set_cpus_allowed(current, cpumask_of_cpu(node));
+                set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
                 return 1;
+        }
         case SVC_POOL_PERNODE:
-                node = m->pool_to[pidx];
+        {
+                unsigned int node = m->pool_to[pidx];
+                node_to_cpumask_ptr(nodecpumask, node);
+
                 *oldmask = current->cpus_allowed;
-                set_cpus_allowed(current, node_to_cpumask(node));
+                set_cpus_allowed_ptr(current, nodecpumask);
                 return 1;
         }
+        }
 }
 
 /*