Merge branch 'sched-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
Linus Torvalds [Thu, 6 Jan 2011 18:23:33 +0000 (10:23 -0800)]
* 'sched-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip: (30 commits)
  sched: Change wait_for_completion_*_timeout() to return a signed long
  sched, autogroup: Fix reference leak
  sched, autogroup: Fix potential access to freed memory
  sched: Remove redundant CONFIG_CGROUP_SCHED ifdef
  sched: Fix interactivity bug by charging unaccounted run-time on entity re-weight
  sched: Move periodic share updates to entity_tick()
  printk: Use this_cpu_{read|write} api on printk_pending
  sched: Make pushable_tasks CONFIG_SMP dependant
  sched: Add 'autogroup' scheduling feature: automated per session task groups
  sched: Fix unregister_fair_sched_group()
  sched: Remove unused argument dest_cpu to migrate_task()
  mutexes, sched: Introduce arch_mutex_cpu_relax()
  sched: Add some clock info to sched_debug
  cpu: Remove incorrect BUG_ON
  cpu: Remove unused variable
  sched: Fix UP build breakage
  sched: Make task dump print all 15 chars of proc comm
  sched: Update tg->shares after cpu.shares write
  sched: Allow update_cfs_load() to update global load
  sched: Implement demand based update_cfs_load()
  ...

1  2 
Documentation/kernel-parameters.txt
include/linux/init_task.h
include/linux/sched.h
init/Kconfig
kernel/sched.c
kernel/sysctl.c
kernel/watchdog.c

@@@ -1579,12 -1579,20 +1579,12 @@@ and is between 256 and 4096 characters
  
        nmi_watchdog=   [KNL,BUGS=X86] Debugging features for SMP kernels
                        Format: [panic,][num]
 -                      Valid num: 0,1,2
 +                      Valid num: 0
                        0 - turn nmi_watchdog off
 -                      1 - use the IO-APIC timer for the NMI watchdog
 -                      2 - use the local APIC for the NMI watchdog using
 -                      a performance counter. Note: This will use one
 -                      performance counter and the local APIC's performance
 -                      vector.
                        When panic is specified, panic when an NMI watchdog
                        timeout occurs.
                        This is useful when you use a panic=... timeout and
                        need the box quickly up again.
 -                      Instead of 1 and 2 it is possible to use the following
 -                      symbolic names: lapic and ioapic
 -                      Example: nmi_watchdog=2 or nmi_watchdog=panic,lapic
  
        netpoll.carrier_timeout=
                        [NET] Specifies amount of time (in seconds) that
        noapic          [SMP,APIC] Tells the kernel to not make use of any
                        IOAPICs that may be present in the system.
  
+       noautogroup     Disable scheduler automatic task group creation.
        nobats          [PPC] Do not use BATs for mapping kernel lowmem
                        on "Classic" PPC cores.
  
  #include <linux/securebits.h>
  #include <net/net_namespace.h>
  
+ #ifdef CONFIG_SMP
+ # define INIT_PUSHABLE_TASKS(tsk)                                     \
+       .pushable_tasks = PLIST_NODE_INIT(tsk.pushable_tasks, MAX_PRIO),
+ #else
+ # define INIT_PUSHABLE_TASKS(tsk)
+ #endif
  extern struct files_struct init_files;
  extern struct fs_struct init_fs;
  
@@@ -83,12 -90,6 +90,12 @@@ extern struct group_info init_groups
   */
  # define CAP_INIT_BSET  CAP_FULL_SET
  
 +#ifdef CONFIG_RCU_BOOST
 +#define INIT_TASK_RCU_BOOST()                                         \
 +      .rcu_boost_mutex = NULL,
 +#else
 +#define INIT_TASK_RCU_BOOST()
 +#endif
  #ifdef CONFIG_TREE_PREEMPT_RCU
  #define INIT_TASK_RCU_TREE_PREEMPT()                                  \
        .rcu_blocked_node = NULL,
        .rcu_read_lock_nesting = 0,                                     \
        .rcu_read_unlock_special = 0,                                   \
        .rcu_node_entry = LIST_HEAD_INIT(tsk.rcu_node_entry),           \
 -      INIT_TASK_RCU_TREE_PREEMPT()
 +      INIT_TASK_RCU_TREE_PREEMPT()                                    \
 +      INIT_TASK_RCU_BOOST()
  #else
  #define INIT_TASK_RCU_PREEMPT(tsk)
  #endif
@@@ -144,7 -144,7 +151,7 @@@ extern struct cred init_cred
                .nr_cpus_allowed = NR_CPUS,                             \
        },                                                              \
        .tasks          = LIST_HEAD_INIT(tsk.tasks),                    \
-       .pushable_tasks = PLIST_NODE_INIT(tsk.pushable_tasks, MAX_PRIO), \
+       INIT_PUSHABLE_TASKS(tsk)                                        \
        .ptraced        = LIST_HEAD_INIT(tsk.ptraced),                  \
        .ptrace_entry   = LIST_HEAD_INIT(tsk.ptrace_entry),             \
        .real_parent    = &tsk,                                         \
diff --combined include/linux/sched.h
@@@ -316,7 -316,6 +316,7 @@@ extern int proc_dowatchdog_thresh(struc
                                  size_t *lenp, loff_t *ppos);
  extern unsigned int  softlockup_panic;
  extern int softlockup_thresh;
 +void lockup_detector_init(void);
  #else
  static inline void touch_softlockup_watchdog(void)
  {
@@@ -327,9 -326,6 +327,9 @@@ static inline void touch_softlockup_wat
  static inline void touch_all_softlockup_watchdogs(void)
  {
  }
 +static inline void lockup_detector_init(void)
 +{
 +}
  #endif
  
  #ifdef CONFIG_DETECT_HUNG_TASK
@@@ -513,6 -509,8 +513,8 @@@ struct thread_group_cputimer 
        spinlock_t lock;
  };
  
+ struct autogroup;
  /*
   * NOTE! "signal_struct" does not have it's own
   * locking, because a shared signal_struct always
@@@ -580,6 -578,9 +582,9 @@@ struct signal_struct 
  
        struct tty_struct *tty; /* NULL if no tty */
  
+ #ifdef CONFIG_SCHED_AUTOGROUP
+       struct autogroup *autogroup;
+ #endif
        /*
         * Cumulative resource counters for dead threads in the group,
         * and for reaped dead child processes forked by this group.
@@@ -1233,16 -1234,15 +1238,18 @@@ struct task_struct 
  #ifdef CONFIG_TREE_PREEMPT_RCU
        struct rcu_node *rcu_blocked_node;
  #endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
 +#ifdef CONFIG_RCU_BOOST
 +      struct rt_mutex *rcu_boost_mutex;
 +#endif /* #ifdef CONFIG_RCU_BOOST */
  
  #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
        struct sched_info sched_info;
  #endif
  
        struct list_head tasks;
+ #ifdef CONFIG_SMP
        struct plist_node pushable_tasks;
+ #endif
  
        struct mm_struct *mm, *active_mm;
  #if defined(SPLIT_RSS_COUNTING)
@@@ -1766,8 -1766,7 +1773,8 @@@ extern void thread_group_times(struct t
  #ifdef CONFIG_PREEMPT_RCU
  
  #define RCU_READ_UNLOCK_BLOCKED (1 << 0) /* blocked while in RCU read-side. */
 -#define RCU_READ_UNLOCK_NEED_QS (1 << 1) /* RCU core needs CPU response. */
 +#define RCU_READ_UNLOCK_BOOSTED (1 << 1) /* boosted while in RCU read-side. */
 +#define RCU_READ_UNLOCK_NEED_QS (1 << 2) /* RCU core needs CPU response. */
  
  static inline void rcu_copy_process(struct task_struct *p)
  {
        p->rcu_read_unlock_special = 0;
  #ifdef CONFIG_TREE_PREEMPT_RCU
        p->rcu_blocked_node = NULL;
 -#endif
 +#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
 +#ifdef CONFIG_RCU_BOOST
 +      p->rcu_boost_mutex = NULL;
 +#endif /* #ifdef CONFIG_RCU_BOOST */
        INIT_LIST_HEAD(&p->rcu_node_entry);
  }
  
@@@ -1883,14 -1879,11 +1890,11 @@@ extern void sched_clock_idle_sleep_even
  extern void sched_clock_idle_wakeup_event(u64 delta_ns);
  
  #ifdef CONFIG_HOTPLUG_CPU
- extern void move_task_off_dead_cpu(int dead_cpu, struct task_struct *p);
  extern void idle_task_exit(void);
  #else
  static inline void idle_task_exit(void) {}
  #endif
  
- extern void sched_idle_next(void);
  #if defined(CONFIG_NO_HZ) && defined(CONFIG_SMP)
  extern void wake_up_idle_cpu(int cpu);
  #else
@@@ -1900,8 -1893,6 +1904,6 @@@ static inline void wake_up_idle_cpu(in
  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_shares_ratelimit;
- extern unsigned int sysctl_sched_shares_thresh;
  extern unsigned int sysctl_sched_child_runs_first;
  
  enum sched_tunable_scaling {
@@@ -1917,6 -1908,7 +1919,7 @@@ extern unsigned int sysctl_sched_migrat
  extern unsigned int sysctl_sched_nr_migrate;
  extern unsigned int sysctl_sched_time_avg;
  extern unsigned int sysctl_timer_migration;
+ extern unsigned int sysctl_sched_shares_window;
  
  int sched_proc_update_handler(struct ctl_table *table, int write,
                void __user *buffer, size_t *length,
@@@ -1942,6 -1934,24 +1945,24 @@@ int sched_rt_handler(struct ctl_table *
  
  extern unsigned int sysctl_sched_compat_yield;
  
+ #ifdef CONFIG_SCHED_AUTOGROUP
+ extern unsigned int sysctl_sched_autogroup_enabled;
+ extern void sched_autogroup_create_attach(struct task_struct *p);
+ extern void sched_autogroup_detach(struct task_struct *p);
+ extern void sched_autogroup_fork(struct signal_struct *sig);
+ extern void sched_autogroup_exit(struct signal_struct *sig);
+ #ifdef CONFIG_PROC_FS
+ extern void proc_sched_autogroup_show_task(struct task_struct *p, struct seq_file *m);
+ extern int proc_sched_autogroup_set_nice(struct task_struct *p, int *nice);
+ #endif
+ #else
+ static inline void sched_autogroup_create_attach(struct task_struct *p) { }
+ static inline void sched_autogroup_detach(struct task_struct *p) { }
+ static inline void sched_autogroup_fork(struct signal_struct *sig) { }
+ static inline void sched_autogroup_exit(struct signal_struct *sig) { }
+ #endif
  #ifdef CONFIG_RT_MUTEXES
  extern int rt_mutex_getprio(struct task_struct *p);
  extern void rt_mutex_setprio(struct task_struct *p, int prio);
@@@ -1960,9 -1970,10 +1981,10 @@@ extern int task_nice(const struct task_
  extern int can_nice(const struct task_struct *p, const int nice);
  extern int task_curr(const struct task_struct *p);
  extern int idle_cpu(int cpu);
- extern int sched_setscheduler(struct task_struct *, int, struct sched_param *);
+ extern int sched_setscheduler(struct task_struct *, int,
+                             const struct sched_param *);
  extern int sched_setscheduler_nocheck(struct task_struct *, int,
-                                     struct sched_param *);
+                                     const struct sched_param *);
  extern struct task_struct *idle_task(int cpu);
  extern struct task_struct *curr_task(int cpu);
  extern void set_curr_task(int cpu, struct task_struct *p);
diff --combined init/Kconfig
@@@ -393,6 -393,7 +393,6 @@@ config PREEMPT_RC
  
  config RCU_TRACE
        bool "Enable tracing for RCU"
 -      depends on TREE_RCU || TREE_PREEMPT_RCU
        help
          This option provides tracing in RCU which presents stats
          in debugfs for debugging RCU implementation.
@@@ -458,60 -459,6 +458,60 @@@ config TREE_RCU_TRAC
          TREE_PREEMPT_RCU implementations, permitting Makefile to
          trivially select kernel/rcutree_trace.c.
  
 +config RCU_BOOST
 +      bool "Enable RCU priority boosting"
 +      depends on RT_MUTEXES && TINY_PREEMPT_RCU
 +      default n
 +      help
 +        This option boosts the priority of preempted RCU readers that
 +        block the current preemptible RCU grace period for too long.
 +        This option also prevents heavy loads from blocking RCU
 +        callback invocation for all flavors of RCU.
 +
 +        Say Y here if you are working with real-time apps or heavy loads
 +        Say N here if you are unsure.
 +
 +config RCU_BOOST_PRIO
 +      int "Real-time priority to boost RCU readers to"
 +      range 1 99
 +      depends on RCU_BOOST
 +      default 1
 +      help
 +        This option specifies the real-time priority to which preempted
 +        RCU readers are to be boosted.  If you are working with CPU-bound
 +        real-time applications, you should specify a priority higher then
 +        the highest-priority CPU-bound application.
 +
 +        Specify the real-time priority, or take the default if unsure.
 +
 +config RCU_BOOST_DELAY
 +      int "Milliseconds to delay boosting after RCU grace-period start"
 +      range 0 3000
 +      depends on RCU_BOOST
 +      default 500
 +      help
 +        This option specifies the time to wait after the beginning of
 +        a given grace period before priority-boosting preempted RCU
 +        readers blocking that grace period.  Note that any RCU reader
 +        blocking an expedited RCU grace period is boosted immediately.
 +
 +        Accept the default if unsure.
 +
 +config SRCU_SYNCHRONIZE_DELAY
 +      int "Microseconds to delay before waiting for readers"
 +      range 0 20
 +      default 10
 +      help
 +        This option controls how long SRCU delays before entering its
 +        loop waiting on SRCU readers.  The purpose of this loop is
 +        to avoid the unconditional context-switch penalty that would
 +        otherwise be incurred if there was an active SRCU reader,
 +        in a manner similar to adaptive locking schemes.  This should
 +        be set to be a bit longer than the common-case SRCU read-side
 +        critical-section overhead.
 +
 +        Accept the default if unsure.
 +
  endmenu # "RCU Subsystem"
  
  config IKCONFIG
@@@ -794,6 -741,19 +794,19 @@@ config NET_N
  
  endif # NAMESPACES
  
+ config SCHED_AUTOGROUP
+       bool "Automatic process group scheduling"
+       select EVENTFD
+       select CGROUPS
+       select CGROUP_SCHED
+       select FAIR_GROUP_SCHED
+       help
+         This option optimizes the scheduler for common desktop workloads by
+         automatically creating and populating task groups.  This separation
+         of workloads isolates aggressive CPU burners (like build jobs) from
+         desktop applications.  Task group autogeneration is currently based
+         upon task session.
  config MM_OWNER
        bool
  
diff --combined kernel/sched.c
  
  #include <asm/tlb.h>
  #include <asm/irq_regs.h>
+ #include <asm/mutex.h>
  
  #include "sched_cpupri.h"
  #include "workqueue_sched.h"
+ #include "sched_autogroup.h"
  
  #define CREATE_TRACE_POINTS
  #include <trace/events/sched.h>
@@@ -253,6 -255,8 +255,8 @@@ struct task_group 
        /* runqueue "owned" by this group on each cpu */
        struct cfs_rq **cfs_rq;
        unsigned long shares;
+       atomic_t load_weight;
  #endif
  
  #ifdef CONFIG_RT_GROUP_SCHED
        struct task_group *parent;
        struct list_head siblings;
        struct list_head children;
+ #ifdef CONFIG_SCHED_AUTOGROUP
+       struct autogroup *autogroup;
+ #endif
  };
  
  #define root_task_group init_task_group
  
- /* task_group_lock serializes add/remove of task groups and also changes to
-  * a task group's cpu shares.
-  */
+ /* task_group_lock serializes the addition/removal of task groups */
  static DEFINE_SPINLOCK(task_group_lock);
  
  #ifdef CONFIG_FAIR_GROUP_SCHED
  
- #ifdef CONFIG_SMP
- static int root_task_group_empty(void)
- {
-       return list_empty(&root_task_group.children);
- }
- #endif
  # define INIT_TASK_GROUP_LOAD NICE_0_LOAD
  
  /*
@@@ -342,6 -341,7 +341,7 @@@ struct cfs_rq 
         * leaf_cfs_rq_list ties together list of leaf cfs_rq's in a cpu. This
         * list is used during load balance.
         */
+       int on_list;
        struct list_head leaf_cfs_rq_list;
        struct task_group *tg;  /* group that "owns" this runqueue */
  
        unsigned long h_load;
  
        /*
-        * this cpu's part of tg->shares
+        * Maintaining per-cpu shares distribution for group scheduling
+        *
+        * load_stamp is the last time we updated the load average
+        * load_last is the last time we updated the load average and saw load
+        * load_unacc_exec_time is currently unaccounted execution time
         */
-       unsigned long shares;
+       u64 load_avg;
+       u64 load_period;
+       u64 load_stamp, load_last, load_unacc_exec_time;
  
-       /*
-        * load.weight at the time we set shares
-        */
-       unsigned long rq_weight;
+       unsigned long load_contribution;
  #endif
  #endif
  };
@@@ -605,11 -608,14 +608,14 @@@ static inline int cpu_of(struct rq *rq
   */
  static inline struct task_group *task_group(struct task_struct *p)
  {
+       struct task_group *tg;
        struct cgroup_subsys_state *css;
  
        css = task_subsys_state_check(p, cpu_cgroup_subsys_id,
                        lockdep_is_held(&task_rq(p)->lock));
-       return container_of(css, struct task_group, css);
+       tg = container_of(css, struct task_group, css);
+       return autogroup_task_group(p, tg);
  }
  
  /* Change a task's cfs_rq and parent entity if it moves across CPUs/groups */
@@@ -793,20 -799,6 +799,6 @@@ late_initcall(sched_init_debug)
  const_debug unsigned int sysctl_sched_nr_migrate = 32;
  
  /*
-  * ratelimit for updating the group shares.
-  * default: 0.25ms
-  */
- unsigned int sysctl_sched_shares_ratelimit = 250000;
- unsigned int normalized_sysctl_sched_shares_ratelimit = 250000;
- /*
-  * Inject some fuzzyness into changing the per-cpu group shares
-  * this avoids remote rq-locks at the expense of fairness.
-  * default: 4
-  */
- unsigned int sysctl_sched_shares_thresh = 4;
- /*
   * period over which we average the RT time consumption, measured
   * in ms.
   *
@@@ -1355,6 -1347,12 +1347,12 @@@ static inline void update_load_sub(stru
        lw->inv_weight = 0;
  }
  
+ static inline void update_load_set(struct load_weight *lw, unsigned long w)
+ {
+       lw->weight = w;
+       lw->inv_weight = 0;
+ }
  /*
   * To aid in avoiding the subversion of "niceness" due to uneven distribution
   * of tasks with abnormal "nice" values across CPUs the contribution that
@@@ -1543,101 -1541,6 +1541,6 @@@ static unsigned long cpu_avg_load_per_t
  
  #ifdef CONFIG_FAIR_GROUP_SCHED
  
- static __read_mostly unsigned long __percpu *update_shares_data;
- 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, int cpu,
-                                   unsigned long sd_shares,
-                                   unsigned long sd_rq_weight,
-                                   unsigned long *usd_rq_weight)
- {
-       unsigned long shares, rq_weight;
-       int boost = 0;
-       rq_weight = usd_rq_weight[cpu];
-       if (!rq_weight) {
-               boost = 1;
-               rq_weight = NICE_0_LOAD;
-       }
-       /*
-        *             \Sum_j shares_j * rq_weight_i
-        * shares_i =  -----------------------------
-        *                  \Sum_j rq_weight_j
-        */
-       shares = (sd_shares * rq_weight) / sd_rq_weight;
-       shares = clamp_t(unsigned long, shares, MIN_SHARES, MAX_SHARES);
-       if (abs(shares - tg->se[cpu]->load.weight) >
-                       sysctl_sched_shares_thresh) {
-               struct rq *rq = cpu_rq(cpu);
-               unsigned long flags;
-               raw_spin_lock_irqsave(&rq->lock, flags);
-               tg->cfs_rq[cpu]->rq_weight = boost ? 0 : rq_weight;
-               tg->cfs_rq[cpu]->shares = boost ? 0 : shares;
-               __set_se_shares(tg->se[cpu], shares);
-               raw_spin_unlock_irqrestore(&rq->lock, flags);
-       }
- }
- /*
-  * Re-compute the task group their per cpu shares over the given domain.
-  * This needs to be done in a bottom-up fashion because the rq weight of a
-  * parent group depends on the shares of its child groups.
-  */
- static int tg_shares_up(struct task_group *tg, void *data)
- {
-       unsigned long weight, rq_weight = 0, sum_weight = 0, shares = 0;
-       unsigned long *usd_rq_weight;
-       struct sched_domain *sd = data;
-       unsigned long flags;
-       int i;
-       if (!tg->se[0])
-               return 0;
-       local_irq_save(flags);
-       usd_rq_weight = per_cpu_ptr(update_shares_data, smp_processor_id());
-       for_each_cpu(i, sched_domain_span(sd)) {
-               weight = tg->cfs_rq[i]->load.weight;
-               usd_rq_weight[i] = weight;
-               rq_weight += 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 (!weight)
-                       weight = NICE_0_LOAD;
-               sum_weight += weight;
-               shares += tg->cfs_rq[i]->shares;
-       }
-       if (!rq_weight)
-               rq_weight = sum_weight;
-       if ((!shares && rq_weight) || shares > tg->shares)
-               shares = tg->shares;
-       if (!sd->parent || !(sd->parent->flags & SD_LOAD_BALANCE))
-               shares = tg->shares;
-       for_each_cpu(i, sched_domain_span(sd))
-               update_group_shares_cpu(tg, i, shares, rq_weight, usd_rq_weight);
-       local_irq_restore(flags);
-       return 0;
- }
  /*
   * Compute the cpu's hierarchical load factor for each task group.
   * This needs to be done in a top-down fashion because the load of a child
@@@ -1652,7 -1555,7 +1555,7 @@@ static int tg_load_down(struct task_gro
                load = cpu_rq(cpu)->load.weight;
        } else {
                load = tg->parent->cfs_rq[cpu]->h_load;
-               load *= tg->cfs_rq[cpu]->shares;
+               load *= tg->se[cpu]->load.weight;
                load /= tg->parent->cfs_rq[cpu]->load.weight + 1;
        }
  
        return 0;
  }
  
- static void update_shares(struct sched_domain *sd)
- {
-       s64 elapsed;
-       u64 now;
-       if (root_task_group_empty())
-               return;
-       now = local_clock();
-       elapsed = now - sd->last_update;
-       if (elapsed >= (s64)(u64)sysctl_sched_shares_ratelimit) {
-               sd->last_update = now;
-               walk_tg_tree(tg_nop, tg_shares_up, sd);
-       }
- }
  static void update_h_load(long cpu)
  {
        walk_tg_tree(tg_load_down, tg_nop, (void *)cpu);
  }
  
- #else
- static inline void update_shares(struct sched_domain *sd)
- {
- }
  #endif
  
  #ifdef CONFIG_PREEMPT
@@@ -1810,15 -1690,6 +1690,6 @@@ static void double_rq_unlock(struct rq 
  
  #endif
  
- #ifdef CONFIG_FAIR_GROUP_SCHED
- static void cfs_rq_set_shares(struct cfs_rq *cfs_rq, unsigned long shares)
- {
- #ifdef CONFIG_SMP
-       cfs_rq->shares = shares;
- #endif
- }
- #endif
  static void calc_load_account_idle(struct rq *this_rq);
  static void update_sysctl(void);
  static int get_update_sysctl_factor(void);
@@@ -2063,6 -1934,7 +1934,7 @@@ static void update_rq_clock_task(struc
  #include "sched_idletask.c"
  #include "sched_fair.c"
  #include "sched_rt.c"
+ #include "sched_autogroup.c"
  #include "sched_stoptask.c"
  #ifdef CONFIG_SCHED_DEBUG
  # include "sched_debug.c"
@@@ -2255,10 -2127,8 +2127,8 @@@ static int migration_cpu_stop(void *dat
   * The task's runqueue lock must be held.
   * Returns true if you have to wait for migration thread.
   */
- static bool migrate_task(struct task_struct *p, int dest_cpu)
+ static bool migrate_task(struct task_struct *p, struct rq *rq)
  {
-       struct rq *rq = task_rq(p);
        /*
         * If the task is not on a runqueue (and not running), then
         * the next wake-up will properly place the task.
@@@ -2438,18 -2308,15 +2308,15 @@@ static int select_fallback_rq(int cpu, 
                return dest_cpu;
  
        /* No more Mr. Nice Guy. */
-       if (unlikely(dest_cpu >= nr_cpu_ids)) {
-               dest_cpu = cpuset_cpus_allowed_fallback(p);
-               /*
-                * Don't tell them about moving exiting tasks or
-                * kernel threads (both mm NULL), since they never
-                * leave kernel.
-                */
-               if (p->mm && printk_ratelimit()) {
-                       printk(KERN_INFO "process %d (%s) no "
-                              "longer affine to cpu%d\n",
-                              task_pid_nr(p), p->comm, cpu);
-               }
+       dest_cpu = cpuset_cpus_allowed_fallback(p);
+       /*
+        * Don't tell them about moving exiting tasks or
+        * kernel threads (both mm NULL), since they never
+        * leave kernel.
+        */
+       if (p->mm && printk_ratelimit()) {
+               printk(KERN_INFO "process %d (%s) no longer affine to cpu%d\n",
+                               task_pid_nr(p), p->comm, cpu);
        }
  
        return dest_cpu;
@@@ -2785,7 -2652,9 +2652,9 @@@ void sched_fork(struct task_struct *p, 
        /* Want to start with kernel preemption disabled. */
        task_thread_info(p)->preempt_count = 1;
  #endif
+ #ifdef CONFIG_SMP
        plist_node_init(&p->pushable_tasks, MAX_PRIO);
+ #endif
  
        put_cpu();
  }
@@@ -3549,7 -3418,7 +3418,7 @@@ void sched_exec(void
         * select_task_rq() can race against ->cpus_allowed
         */
        if (cpumask_test_cpu(dest_cpu, &p->cpus_allowed) &&
-           likely(cpu_active(dest_cpu)) && migrate_task(p, dest_cpu)) {
+           likely(cpu_active(dest_cpu)) && migrate_task(p, rq)) {
                struct migration_arg arg = { p, dest_cpu };
  
                task_rq_unlock(rq, &flags);
@@@ -4214,7 -4083,7 +4083,7 @@@ int mutex_spin_on_owner(struct mutex *l
                if (task_thread_info(rq->curr) != owner || need_resched())
                        return 0;
  
-               cpu_relax();
+               arch_mutex_cpu_relax();
        }
  
        return 1;
@@@ -4526,7 -4395,7 +4395,7 @@@ EXPORT_SYMBOL(wait_for_completion_inter
   * This waits for either a completion of a specific task to be signaled or for a
   * specified timeout to expire. It is interruptible. The timeout is in jiffies.
   */
- unsigned long __sched
+ long __sched
  wait_for_completion_interruptible_timeout(struct completion *x,
                                          unsigned long timeout)
  {
@@@ -4559,7 -4428,7 +4428,7 @@@ EXPORT_SYMBOL(wait_for_completion_killa
   * signaled or for a specified timeout to expire. It can be
   * interrupted by a kill signal. The timeout is in jiffies.
   */
- unsigned long __sched
+ long __sched
  wait_for_completion_killable_timeout(struct completion *x,
                                     unsigned long timeout)
  {
@@@ -4901,7 -4770,7 +4770,7 @@@ static bool check_same_owner(struct tas
  }
  
  static int __sched_setscheduler(struct task_struct *p, int policy,
-                               struct sched_param *param, bool user)
+                               const struct sched_param *param, bool user)
  {
        int retval, oldprio, oldpolicy = -1, on_rq, running;
        unsigned long flags;
@@@ -5056,7 -4925,7 +4925,7 @@@ recheck
   * NOTE that the task may be already dead.
   */
  int sched_setscheduler(struct task_struct *p, int policy,
-                      struct sched_param *param)
+                      const struct sched_param *param)
  {
        return __sched_setscheduler(p, policy, param, true);
  }
@@@ -5074,7 -4943,7 +4943,7 @@@ EXPORT_SYMBOL_GPL(sched_setscheduler)
   * but our caller might not have that capability.
   */
  int sched_setscheduler_nocheck(struct task_struct *p, int policy,
-                              struct sched_param *param)
+                              const struct sched_param *param)
  {
        return __sched_setscheduler(p, policy, param, false);
  }
@@@ -5590,7 -5459,7 +5459,7 @@@ void sched_show_task(struct task_struc
        unsigned state;
  
        state = p->state ? __ffs(p->state) + 1 : 0;
-       printk(KERN_INFO "%-13.13s %c", p->comm,
+       printk(KERN_INFO "%-15.15s %c", p->comm,
                state < sizeof(stat_nam) - 1 ? stat_nam[state] : '?');
  #if BITS_PER_LONG == 32
        if (state == TASK_RUNNING)
@@@ -5754,7 -5623,6 +5623,6 @@@ static void update_sysctl(void
        SET_SYSCTL(sched_min_granularity);
        SET_SYSCTL(sched_latency);
        SET_SYSCTL(sched_wakeup_granularity);
-       SET_SYSCTL(sched_shares_ratelimit);
  #undef SET_SYSCTL
  }
  
@@@ -5830,7 -5698,7 +5698,7 @@@ again
                goto out;
  
        dest_cpu = cpumask_any_and(cpu_active_mask, new_mask);
-       if (migrate_task(p, dest_cpu)) {
+       if (migrate_task(p, rq)) {
                struct migration_arg arg = { p, dest_cpu };
                /* Need help from migration thread: drop lock and wait. */
                task_rq_unlock(rq, &flags);
@@@ -5912,29 -5780,20 +5780,20 @@@ static int migration_cpu_stop(void *dat
  }
  
  #ifdef CONFIG_HOTPLUG_CPU
  /*
-  * Figure out where task on dead CPU should go, use force if necessary.
+  * Ensures that the idle task is using init_mm right before its cpu goes
+  * offline.
   */
- void move_task_off_dead_cpu(int dead_cpu, struct task_struct *p)
+ void idle_task_exit(void)
  {
-       struct rq *rq = cpu_rq(dead_cpu);
-       int needs_cpu, uninitialized_var(dest_cpu);
-       unsigned long flags;
+       struct mm_struct *mm = current->active_mm;
  
-       local_irq_save(flags);
+       BUG_ON(cpu_online(smp_processor_id()));
  
-       raw_spin_lock(&rq->lock);
-       needs_cpu = (task_cpu(p) == dead_cpu) && (p->state != TASK_WAKING);
-       if (needs_cpu)
-               dest_cpu = select_fallback_rq(dead_cpu, p);
-       raw_spin_unlock(&rq->lock);
-       /*
-        * It can only fail if we race with set_cpus_allowed(),
-        * in the racer should migrate the task anyway.
-        */
-       if (needs_cpu)
-               __migrate_task(p, dead_cpu, dest_cpu);
-       local_irq_restore(flags);
+       if (mm != &init_mm)
+               switch_mm(mm, &init_mm, current);
+       mmdrop(mm);
  }
  
  /*
  static void migrate_nr_uninterruptible(struct rq *rq_src)
  {
        struct rq *rq_dest = cpu_rq(cpumask_any(cpu_active_mask));
-       unsigned long flags;
  
-       local_irq_save(flags);
-       double_rq_lock(rq_src, rq_dest);
        rq_dest->nr_uninterruptible += rq_src->nr_uninterruptible;
        rq_src->nr_uninterruptible = 0;
  }
  
  /*
-  * Schedules idle task to be the next runnable task on current CPU.
-  * It does so by boosting its priority to highest possible.
-  * Used by CPU offline code.
+  * remove the tasks which were accounted by rq from calc_load_tasks.
   */
- void sched_idle_next(void)
+ static void calc_global_load_remove(struct rq *rq)
  {
-       int this_cpu = smp_processor_id();
-       struct rq *rq = cpu_rq(this_cpu);
-       struct task_struct *p = rq->idle;
-       unsigned long flags;
-       /* cpu has to be offline */
-       BUG_ON(cpu_online(this_cpu));
-       /*
-        * Strictly not necessary since rest of the CPUs are stopped by now
-        * and interrupts disabled on the current cpu.
-        */
-       raw_spin_lock_irqsave(&rq->lock, flags);
-       __setscheduler(rq, p, SCHED_FIFO, MAX_RT_PRIO-1);
-       activate_task(rq, p, 0);
-       raw_spin_unlock_irqrestore(&rq->lock, flags);
+       atomic_long_sub(rq->calc_load_active, &calc_load_tasks);
+       rq->calc_load_active = 0;
  }
  
  /*
-  * Ensures that the idle task is using init_mm right before its cpu goes
-  * offline.
+  * Migrate all tasks from the rq, sleeping tasks will be migrated by
+  * try_to_wake_up()->select_task_rq().
+  *
+  * Called with rq->lock held even though we'er in stop_machine() and
+  * there's no concurrency possible, we hold the required locks anyway
+  * because of lock validation efforts.
   */
- void idle_task_exit(void)
- {
-       struct mm_struct *mm = current->active_mm;
-       BUG_ON(cpu_online(smp_processor_id()));
-       if (mm != &init_mm)
-               switch_mm(mm, &init_mm, current);
-       mmdrop(mm);
- }
- /* called under rq->lock with disabled interrupts */
- static void migrate_dead(unsigned int dead_cpu, struct task_struct *p)
+ static void migrate_tasks(unsigned int dead_cpu)
  {
        struct rq *rq = cpu_rq(dead_cpu);
-       /* Must be exiting, otherwise would be on tasklist. */
-       BUG_ON(!p->exit_state);
-       /* Cannot have done final schedule yet: would have vanished. */
-       BUG_ON(p->state == TASK_DEAD);
-       get_task_struct(p);
+       struct task_struct *next, *stop = rq->stop;
+       int dest_cpu;
  
        /*
-        * Drop lock around migration; if someone else moves it,
-        * that's OK. No task can be added to this CPU, so iteration is
-        * fine.
+        * Fudge the rq selection such that the below task selection loop
+        * doesn't get stuck on the currently eligible stop task.
+        *
+        * We're currently inside stop_machine() and the rq is either stuck
+        * in the stop_machine_cpu_stop() loop, or we're executing this code,
+        * either way we should never end up calling schedule() until we're
+        * done here.
         */
-       raw_spin_unlock_irq(&rq->lock);
-       move_task_off_dead_cpu(dead_cpu, p);
-       raw_spin_lock_irq(&rq->lock);
-       put_task_struct(p);
- }
- /* release_task() removes task from tasklist, so we won't find dead tasks. */
- static void migrate_dead_tasks(unsigned int dead_cpu)
- {
-       struct rq *rq = cpu_rq(dead_cpu);
-       struct task_struct *next;
+       rq->stop = NULL;
  
        for ( ; ; ) {
-               if (!rq->nr_running)
+               /*
+                * There's this thread running, bail when that's the only
+                * remaining thread.
+                */
+               if (rq->nr_running == 1)
                        break;
                next = pick_next_task(rq);
-               if (!next)
-                       break;
+               BUG_ON(!next);
                next->sched_class->put_prev_task(rq, next);
-               migrate_dead(dead_cpu, next);
  
+               /* Find suitable destination for @next, with force if needed. */
+               dest_cpu = select_fallback_rq(dead_cpu, next);
+               raw_spin_unlock(&rq->lock);
+               __migrate_task(next, dead_cpu, dest_cpu);
+               raw_spin_lock(&rq->lock);
        }
- }
  
- /*
-  * remove the tasks which were accounted by rq from calc_load_tasks.
-  */
- static void calc_global_load_remove(struct rq *rq)
- {
-       atomic_long_sub(rq->calc_load_active, &calc_load_tasks);
-       rq->calc_load_active = 0;
+       rq->stop = stop;
  }
  #endif /* CONFIG_HOTPLUG_CPU */
  
  #if defined(CONFIG_SCHED_DEBUG) && defined(CONFIG_SYSCTL)
@@@ -6278,15 -6078,13 +6078,13 @@@ migration_call(struct notifier_block *n
        unsigned long flags;
        struct rq *rq = cpu_rq(cpu);
  
-       switch (action) {
+       switch (action & ~CPU_TASKS_FROZEN) {
  
        case CPU_UP_PREPARE:
-       case CPU_UP_PREPARE_FROZEN:
                rq->calc_load_update = calc_load_update;
                break;
  
        case CPU_ONLINE:
-       case CPU_ONLINE_FROZEN:
                /* Update our root-domain */
                raw_spin_lock_irqsave(&rq->lock, flags);
                if (rq->rd) {
                break;
  
  #ifdef CONFIG_HOTPLUG_CPU
-       case CPU_DEAD:
-       case CPU_DEAD_FROZEN:
-               migrate_live_tasks(cpu);
-               /* Idle task back to normal (off runqueue, low prio) */
-               raw_spin_lock_irq(&rq->lock);
-               deactivate_task(rq, rq->idle, 0);
-               __setscheduler(rq, rq->idle, SCHED_NORMAL, 0);
-               rq->idle->sched_class = &idle_sched_class;
-               migrate_dead_tasks(cpu);
-               raw_spin_unlock_irq(&rq->lock);
-               migrate_nr_uninterruptible(rq);
-               BUG_ON(rq->nr_running != 0);
-               calc_global_load_remove(rq);
-               break;
        case CPU_DYING:
-       case CPU_DYING_FROZEN:
                /* Update our root-domain */
                raw_spin_lock_irqsave(&rq->lock, flags);
                if (rq->rd) {
                        BUG_ON(!cpumask_test_cpu(cpu, rq->rd->span));
                        set_rq_offline(rq);
                }
+               migrate_tasks(cpu);
+               BUG_ON(rq->nr_running != 1); /* the migration thread */
                raw_spin_unlock_irqrestore(&rq->lock, flags);
+               migrate_nr_uninterruptible(rq);
+               calc_global_load_remove(rq);
                break;
  #endif
        }
@@@ -8052,15 -7839,13 +7839,13 @@@ static void init_rt_rq(struct rt_rq *rt
  
  #ifdef CONFIG_FAIR_GROUP_SCHED
  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 *se, int cpu,
                                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;
-       if (add)
-               list_add(&cfs_rq->leaf_cfs_rq_list, &rq->leaf_cfs_rq_list);
  
        tg->se[cpu] = se;
        /* se could be NULL for init_task_group */
                se->cfs_rq = parent->my_q;
  
        se->my_q = cfs_rq;
-       se->load.weight = tg->shares;
-       se->load.inv_weight = 0;
+       update_load_set(&se->load, 0);
        se->parent = parent;
  }
  #endif
  
  #ifdef CONFIG_RT_GROUP_SCHED
  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 *rt_se, int cpu,
                struct sched_rt_entity *parent)
  {
        struct rq *rq = cpu_rq(cpu);
        init_rt_rq(rt_rq, rq);
        rt_rq->tg = tg;
        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)
@@@ -8164,13 -7946,9 +7946,9 @@@ void __init sched_init(void
  #ifdef CONFIG_CGROUP_SCHED
        list_add(&init_task_group.list, &task_groups);
        INIT_LIST_HEAD(&init_task_group.children);
+       autogroup_init(&init_task);
  #endif /* CONFIG_CGROUP_SCHED */
  
- #if defined CONFIG_FAIR_GROUP_SCHED && defined CONFIG_SMP
-       update_shares_data = __alloc_percpu(nr_cpu_ids * sizeof(unsigned long),
-                                           __alignof__(unsigned long));
- #endif
        for_each_possible_cpu(i) {
                struct rq *rq;
  
  #ifdef CONFIG_FAIR_GROUP_SCHED
                init_task_group.shares = init_task_group_load;
                INIT_LIST_HEAD(&rq->leaf_cfs_rq_list);
- #ifdef CONFIG_CGROUP_SCHED
                /*
                 * How much cpu bandwidth does init_task_group get?
                 *
                 * 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);
- #endif
+               init_tg_cfs_entry(&init_task_group, &rq->cfs, NULL, i, NULL);
  #endif /* CONFIG_FAIR_GROUP_SCHED */
  
                rq->rt.rt_runtime = def_rt_bandwidth.rt_runtime;
  #ifdef CONFIG_RT_GROUP_SCHED
                INIT_LIST_HEAD(&rq->leaf_rt_rq_list);
- #ifdef CONFIG_CGROUP_SCHED
-               init_tg_rt_entry(&init_task_group, &rq->rt, NULL, i, 1, NULL);
- #endif
+               init_tg_rt_entry(&init_task_group, &rq->rt, NULL, i, NULL);
  #endif
  
                for (j = 0; j < CPU_LOAD_IDX_MAX; j++)
                zalloc_cpumask_var(&cpu_isolated_map, GFP_NOWAIT);
  #endif /* SMP */
  
 -      perf_event_init();
 -
        scheduler_running = 1;
  }
  
@@@ -8486,7 -8262,7 +8260,7 @@@ int alloc_fair_sched_group(struct task_
                if (!se)
                        goto err_free_rq;
  
-               init_tg_cfs_entry(tg, cfs_rq, se, i, 0, parent->se[i]);
+               init_tg_cfs_entry(tg, cfs_rq, se, i, parent->se[i]);
        }
  
        return 1;
        return 0;
  }
  
- static inline void register_fair_sched_group(struct task_group *tg, int cpu)
- {
-       list_add_rcu(&tg->cfs_rq[cpu]->leaf_cfs_rq_list,
-                       &cpu_rq(cpu)->leaf_cfs_rq_list);
- }
  static inline void unregister_fair_sched_group(struct task_group *tg, int cpu)
  {
-       list_del_rcu(&tg->cfs_rq[cpu]->leaf_cfs_rq_list);
+       struct rq *rq = cpu_rq(cpu);
+       unsigned long flags;
+       /*
+       * Only empty task groups can be destroyed; so we can speculatively
+       * check on_list without danger of it being re-added.
+       */
+       if (!tg->cfs_rq[cpu]->on_list)
+               return;
+       raw_spin_lock_irqsave(&rq->lock, flags);
+       list_del_leaf_cfs_rq(tg->cfs_rq[cpu]);
+       raw_spin_unlock_irqrestore(&rq->lock, flags);
  }
  #else /* !CONFG_FAIR_GROUP_SCHED */
  static inline void free_fair_sched_group(struct task_group *tg)
@@@ -8518,10 -8300,6 +8298,6 @@@ int alloc_fair_sched_group(struct task_
        return 1;
  }
  
- static inline void register_fair_sched_group(struct task_group *tg, int cpu)
- {
- }
  static inline void unregister_fair_sched_group(struct task_group *tg, int cpu)
  {
  }
@@@ -8576,7 -8354,7 +8352,7 @@@ int alloc_rt_sched_group(struct task_gr
                if (!rt_se)
                        goto err_free_rq;
  
-               init_tg_rt_entry(tg, rt_rq, rt_se, i, 0, parent->rt_se[i]);
+               init_tg_rt_entry(tg, rt_rq, rt_se, i, parent->rt_se[i]);
        }
  
        return 1;
@@@ -8586,17 -8364,6 +8362,6 @@@ err_free_rq
  err:
        return 0;
  }
- static inline void register_rt_sched_group(struct task_group *tg, int cpu)
- {
-       list_add_rcu(&tg->rt_rq[cpu]->leaf_rt_rq_list,
-                       &cpu_rq(cpu)->leaf_rt_rq_list);
- }
- static inline void unregister_rt_sched_group(struct task_group *tg, int cpu)
- {
-       list_del_rcu(&tg->rt_rq[cpu]->leaf_rt_rq_list);
- }
  #else /* !CONFIG_RT_GROUP_SCHED */
  static inline void free_rt_sched_group(struct task_group *tg)
  {
@@@ -8607,14 -8374,6 +8372,6 @@@ int alloc_rt_sched_group(struct task_gr
  {
        return 1;
  }
- static inline void register_rt_sched_group(struct task_group *tg, int cpu)
- {
- }
- static inline void unregister_rt_sched_group(struct task_group *tg, int cpu)
- {
- }
  #endif /* CONFIG_RT_GROUP_SCHED */
  
  #ifdef CONFIG_CGROUP_SCHED
@@@ -8630,7 -8389,6 +8387,6 @@@ struct task_group *sched_create_group(s
  {
        struct task_group *tg;
        unsigned long flags;
-       int i;
  
        tg = kzalloc(sizeof(*tg), GFP_KERNEL);
        if (!tg)
                goto err;
  
        spin_lock_irqsave(&task_group_lock, flags);
-       for_each_possible_cpu(i) {
-               register_fair_sched_group(tg, i);
-               register_rt_sched_group(tg, i);
-       }
        list_add_rcu(&tg->list, &task_groups);
  
        WARN_ON(!parent); /* root should already exist */
@@@ -8676,11 -8430,11 +8428,11 @@@ void sched_destroy_group(struct task_gr
        unsigned long flags;
        int i;
  
-       spin_lock_irqsave(&task_group_lock, flags);
-       for_each_possible_cpu(i) {
+       /* end participation in shares distribution */
+       for_each_possible_cpu(i)
                unregister_fair_sched_group(tg, i);
-               unregister_rt_sched_group(tg, i);
-       }
+       spin_lock_irqsave(&task_group_lock, flags);
        list_del_rcu(&tg->list);
        list_del_rcu(&tg->siblings);
        spin_unlock_irqrestore(&task_group_lock, flags);
@@@ -8727,33 -8481,6 +8479,6 @@@ void sched_move_task(struct task_struc
  #endif /* CONFIG_CGROUP_SCHED */
  
  #ifdef CONFIG_FAIR_GROUP_SCHED
- static void __set_se_shares(struct sched_entity *se, unsigned long shares)
- {
-       struct cfs_rq *cfs_rq = se->cfs_rq;
-       int on_rq;
-       on_rq = se->on_rq;
-       if (on_rq)
-               dequeue_entity(cfs_rq, se, 0);
-       se->load.weight = shares;
-       se->load.inv_weight = 0;
-       if (on_rq)
-               enqueue_entity(cfs_rq, se, 0);
- }
- 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;
-       raw_spin_lock_irqsave(&rq->lock, flags);
-       __set_se_shares(se, shares);
-       raw_spin_unlock_irqrestore(&rq->lock, flags);
- }
  static DEFINE_MUTEX(shares_mutex);
  
  int sched_group_set_shares(struct task_group *tg, unsigned long shares)
        if (tg->shares == shares)
                goto done;
  
-       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 */
-       synchronize_sched();
-       /*
-        * Now we are free to modify the group's share on each cpu
-        * w/o tripping rebalance_share or load_balance_fair.
-        */
        tg->shares = 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);
+               struct rq *rq = cpu_rq(i);
+               struct sched_entity *se;
+               se = tg->se[i];
+               /* Propagate contribution to hierarchy */
+               raw_spin_lock_irqsave(&rq->lock, flags);
+               for_each_sched_entity(se)
+                       update_cfs_shares(group_cfs_rq(se), 0);
+               raw_spin_unlock_irqrestore(&rq->lock, flags);
        }
  
-       /*
-        * Enable load balance activity on this group, by inserting it back on
-        * each cpu's rq->leaf_cfs_rq_list.
-        */
-       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);
        return 0;
@@@ -9532,3 -9241,72 +9239,3 @@@ struct cgroup_subsys cpuacct_subsys = 
  };
  #endif        /* CONFIG_CGROUP_CPUACCT */
  
 -#ifndef CONFIG_SMP
 -
 -void synchronize_sched_expedited(void)
 -{
 -      barrier();
 -}
 -EXPORT_SYMBOL_GPL(synchronize_sched_expedited);
 -
 -#else /* #ifndef CONFIG_SMP */
 -
 -static atomic_t synchronize_sched_expedited_count = ATOMIC_INIT(0);
 -
 -static int synchronize_sched_expedited_cpu_stop(void *data)
 -{
 -      /*
 -       * There must be a full memory barrier on each affected CPU
 -       * between the time that try_stop_cpus() is called and the
 -       * time that it returns.
 -       *
 -       * In the current initial implementation of cpu_stop, the
 -       * above condition is already met when the control reaches
 -       * this point and the following smp_mb() is not strictly
 -       * necessary.  Do smp_mb() anyway for documentation and
 -       * robustness against future implementation changes.
 -       */
 -      smp_mb(); /* See above comment block. */
 -      return 0;
 -}
 -
 -/*
 - * Wait for an rcu-sched grace period to elapse, but use "big hammer"
 - * approach to force grace period to end quickly.  This consumes
 - * significant time on all CPUs, and is thus not recommended for
 - * any sort of common-case code.
 - *
 - * Note that it is illegal to call this function while holding any
 - * lock that is acquired by a CPU-hotplug notifier.  Failing to
 - * observe this restriction will result in deadlock.
 - */
 -void synchronize_sched_expedited(void)
 -{
 -      int snap, trycount = 0;
 -
 -      smp_mb();  /* ensure prior mod happens before capturing snap. */
 -      snap = atomic_read(&synchronize_sched_expedited_count) + 1;
 -      get_online_cpus();
 -      while (try_stop_cpus(cpu_online_mask,
 -                           synchronize_sched_expedited_cpu_stop,
 -                           NULL) == -EAGAIN) {
 -              put_online_cpus();
 -              if (trycount++ < 10)
 -                      udelay(trycount * num_online_cpus());
 -              else {
 -                      synchronize_sched();
 -                      return;
 -              }
 -              if (atomic_read(&synchronize_sched_expedited_count) - snap > 0) {
 -                      smp_mb(); /* ensure test happens before caller kfree */
 -                      return;
 -              }
 -              get_online_cpus();
 -      }
 -      atomic_inc(&synchronize_sched_expedited_count);
 -      smp_mb__after_atomic_inc(); /* ensure post-GP actions seen after GP. */
 -      put_online_cpus();
 -}
 -EXPORT_SYMBOL_GPL(synchronize_sched_expedited);
 -
 -#endif /* #else #ifndef CONFIG_SMP */
diff --combined kernel/sysctl.c
@@@ -259,8 -259,6 +259,6 @@@ static int min_wakeup_granularity_ns
  static int max_wakeup_granularity_ns = NSEC_PER_SEC;  /* 1 second */
  static int min_sched_tunable_scaling = SCHED_TUNABLESCALING_NONE;
  static int max_sched_tunable_scaling = SCHED_TUNABLESCALING_END-1;
- static int min_sched_shares_ratelimit = 100000; /* 100 usec */
- static int max_sched_shares_ratelimit = NSEC_PER_SEC; /* 1 second */
  #endif
  
  #ifdef CONFIG_COMPACTION
@@@ -305,15 -303,6 +303,6 @@@ static struct ctl_table kern_table[] = 
                .extra2         = &max_wakeup_granularity_ns,
        },
        {
-               .procname       = "sched_shares_ratelimit",
-               .data           = &sysctl_sched_shares_ratelimit,
-               .maxlen         = sizeof(unsigned int),
-               .mode           = 0644,
-               .proc_handler   = sched_proc_update_handler,
-               .extra1         = &min_sched_shares_ratelimit,
-               .extra2         = &max_sched_shares_ratelimit,
-       },
-       {
                .procname       = "sched_tunable_scaling",
                .data           = &sysctl_sched_tunable_scaling,
                .maxlen         = sizeof(enum sched_tunable_scaling),
                .extra2         = &max_sched_tunable_scaling,
        },
        {
-               .procname       = "sched_shares_thresh",
-               .data           = &sysctl_sched_shares_thresh,
-               .maxlen         = sizeof(unsigned int),
-               .mode           = 0644,
-               .proc_handler   = proc_dointvec_minmax,
-               .extra1         = &zero,
-       },
-       {
                .procname       = "sched_migration_cost",
                .data           = &sysctl_sched_migration_cost,
                .maxlen         = sizeof(unsigned int),
                .proc_handler   = proc_dointvec,
        },
        {
+               .procname       = "sched_shares_window",
+               .data           = &sysctl_sched_shares_window,
+               .maxlen         = sizeof(unsigned int),
+               .mode           = 0644,
+               .proc_handler   = proc_dointvec,
+       },
+       {
                .procname       = "timer_migration",
                .data           = &sysctl_timer_migration,
                .maxlen         = sizeof(unsigned int),
                .mode           = 0644,
                .proc_handler   = proc_dointvec,
        },
+ #ifdef CONFIG_SCHED_AUTOGROUP
+       {
+               .procname       = "sched_autogroup_enabled",
+               .data           = &sysctl_sched_autogroup_enabled,
+               .maxlen         = sizeof(unsigned int),
+               .mode           = 0644,
+               .proc_handler   = proc_dointvec,
+               .extra1         = &zero,
+               .extra2         = &one,
+       },
+ #endif
  #ifdef CONFIG_PROVE_LOCKING
        {
                .procname       = "prove_locking",
                .extra1         = &zero,
                .extra2         = &one,
        },
 -#endif
 -#if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86) && !defined(CONFIG_LOCKUP_DETECTOR)
        {
 -              .procname       = "unknown_nmi_panic",
 -              .data           = &unknown_nmi_panic,
 +              .procname       = "nmi_watchdog",
 +              .data           = &watchdog_enabled,
                .maxlen         = sizeof (int),
                .mode           = 0644,
 -              .proc_handler   = proc_dointvec,
 +              .proc_handler   = proc_dowatchdog_enabled,
        },
 +#endif
 +#if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
        {
 -              .procname       = "nmi_watchdog",
 -              .data           = &nmi_watchdog_enabled,
 +              .procname       = "unknown_nmi_panic",
 +              .data           = &unknown_nmi_panic,
                .maxlen         = sizeof (int),
                .mode           = 0644,
 -              .proc_handler   = proc_nmi_enabled,
 +              .proc_handler   = proc_dointvec,
        },
  #endif
  #if defined(CONFIG_X86)
diff --combined kernel/watchdog.c
@@@ -57,8 -57,6 +57,8 @@@ static int __init hardlockup_panic_setu
  {
        if (!strncmp(str, "panic", 5))
                hardlockup_panic = 1;
 +      else if (!strncmp(str, "0", 1))
 +              no_watchdog = 1;
        return 1;
  }
  __setup("nmi_watchdog=", hardlockup_panic_setup);
@@@ -309,7 -307,7 +309,7 @@@ static enum hrtimer_restart watchdog_ti
   */
  static int watchdog(void *unused)
  {
-       struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };
+       static struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };
        struct hrtimer *hrtimer = &__raw_get_cpu_var(watchdog_hrtimer);
  
        sched_setscheduler(current, SCHED_FIFO, &param);
@@@ -550,13 -548,13 +550,13 @@@ static struct notifier_block __cpuinitd
        .notifier_call = cpu_callback
  };
  
 -static int __init spawn_watchdog_task(void)
 +void __init lockup_detector_init(void)
  {
        void *cpu = (void *)(long)smp_processor_id();
        int err;
  
        if (no_watchdog)
 -              return 0;
 +              return;
  
        err = cpu_callback(&cpu_nfb, CPU_UP_PREPARE, cpu);
        WARN_ON(notifier_to_errno(err));
        cpu_callback(&cpu_nfb, CPU_ONLINE, cpu);
        register_cpu_notifier(&cpu_nfb);
  
 -      return 0;
 +      return;
  }
 -early_initcall(spawn_watchdog_task);