1 files changed, 429 insertions, 305 deletions

diff --git a/kernel/sched.c b/kernel/sched.c
index a455dca884a6..18cceeecce35 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -141,7 +141,7 @@ struct rt_prio_array {
 
 struct rt_bandwidth {
         /* nests inside the rq lock: */
-        spinlock_t              rt_runtime_lock;
+        raw_spinlock_t          rt_runtime_lock;
         ktime_t                 rt_period;
         u64                     rt_runtime;
         struct hrtimer          rt_period_timer;
@@ -178,7 +178,7 @@ 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);
+        raw_spin_lock_init(&rt_b->rt_runtime_lock);
 
         hrtimer_init(&rt_b->rt_period_timer,
                         CLOCK_MONOTONIC, HRTIMER_MODE_REL);
@@ -200,7 +200,7 @@ static void start_rt_bandwidth(struct rt_bandwidth *rt_b)
         if (hrtimer_active(&rt_b->rt_period_timer))
                 return;
 
-        spin_lock(&rt_b->rt_runtime_lock);
+        raw_spin_lock(&rt_b->rt_runtime_lock);
         for (;;) {
                 unsigned long delta;
                 ktime_t soft, hard;
@@ -217,7 +217,7 @@ static void start_rt_bandwidth(struct rt_bandwidth *rt_b)
                 __hrtimer_start_range_ns(&rt_b->rt_period_timer, soft, delta,
                                 HRTIMER_MODE_ABS_PINNED, 0);
         }
-        spin_unlock(&rt_b->rt_runtime_lock);
+        raw_spin_unlock(&rt_b->rt_runtime_lock);
 }
 
 #ifdef CONFIG_RT_GROUP_SCHED
@@ -298,7 +298,7 @@ static DEFINE_PER_CPU_SHARED_ALIGNED(struct cfs_rq, init_tg_cfs_rq);
 
 #ifdef CONFIG_RT_GROUP_SCHED
 static DEFINE_PER_CPU(struct sched_rt_entity, init_sched_rt_entity);
-static DEFINE_PER_CPU_SHARED_ALIGNED(struct rt_rq, init_rt_rq);
+static DEFINE_PER_CPU_SHARED_ALIGNED(struct rt_rq, init_rt_rq_var);
 #endif /* CONFIG_RT_GROUP_SCHED */
 #else /* !CONFIG_USER_SCHED */
 #define root_task_group init_task_group
@@ -309,6 +309,8 @@ static DEFINE_PER_CPU_SHARED_ALIGNED(struct rt_rq, init_rt_rq);
  */
 static DEFINE_SPINLOCK(task_group_lock);
 
+#ifdef CONFIG_FAIR_GROUP_SCHED
+
 #ifdef CONFIG_SMP
 static int root_task_group_empty(void)
 {
@@ -316,7 +318,6 @@ static int root_task_group_empty(void)
 }
 #endif
 
-#ifdef CONFIG_FAIR_GROUP_SCHED
 #ifdef CONFIG_USER_SCHED
 # define INIT_TASK_GROUP_LOAD   (2*NICE_0_LOAD)
 #else /* !CONFIG_USER_SCHED */
@@ -469,7 +470,7 @@ struct rt_rq {
         u64 rt_time;
         u64 rt_runtime;
         /* Nests inside the rq lock: */
-        spinlock_t rt_runtime_lock;
+        raw_spinlock_t rt_runtime_lock;
 
 #ifdef CONFIG_RT_GROUP_SCHED
         unsigned long rt_nr_boosted;
@@ -524,7 +525,7 @@ static struct root_domain def_root_domain;
  */
 struct rq {
         /* runqueue lock: */
-        spinlock_t lock;
+        raw_spinlock_t lock;
 
         /*
          * nr_running and cpu_load should be in the same cacheline because
@@ -534,14 +535,12 @@ struct rq {
         #define CPU_LOAD_IDX_MAX 5
         unsigned long cpu_load[CPU_LOAD_IDX_MAX];
 #ifdef CONFIG_NO_HZ
-        unsigned long last_tick_seen;
         unsigned char in_nohz_recently;
 #endif
         /* capture load from *all* tasks on this cpu: */
         struct load_weight load;
         unsigned long nr_load_updates;
         u64 nr_switches;
-        u64 nr_migrations_in;
 
         struct cfs_rq cfs;
         struct rt_rq rt;
@@ -590,6 +589,8 @@ struct rq {
 
         u64 rt_avg;
         u64 age_stamp;
+        u64 idle_stamp;
+        u64 avg_idle;
 #endif
 
         /* calc_load related fields */
@@ -684,7 +685,7 @@ inline void update_rq_clock(struct rq *rq)
  */
 int runqueue_is_locked(int cpu)
 {
-        return spin_is_locked(&cpu_rq(cpu)->lock);
+        return raw_spin_is_locked(&cpu_rq(cpu)->lock);
 }
 
 /*
@@ -771,7 +772,7 @@ sched_feat_write(struct file *filp, const char __user *ubuf,
         if (!sched_feat_names[i])
                 return -EINVAL;
 
-        filp->f_pos += cnt;
+        *ppos += cnt;
 
         return cnt;
 }
@@ -813,6 +814,7 @@ const_debug unsigned int sysctl_sched_nr_migrate = 32;
  * 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
@@ -891,7 +893,7 @@ static inline void finish_lock_switch(struct rq *rq, struct task_struct *prev)
          */
         spin_acquire(&rq->lock.dep_map, 0, 0, _THIS_IP_);
 
-        spin_unlock_irq(&rq->lock);
+        raw_spin_unlock_irq(&rq->lock);
 }
 
 #else /* __ARCH_WANT_UNLOCKED_CTXSW */
@@ -915,9 +917,9 @@ static inline void prepare_lock_switch(struct rq *rq, struct task_struct *next)
         next->oncpu = 1;
 #endif
 #ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
-        spin_unlock_irq(&rq->lock);
+        raw_spin_unlock_irq(&rq->lock);
 #else
-        spin_unlock(&rq->lock);
+        raw_spin_unlock(&rq->lock);
 #endif
 }
 
@@ -947,10 +949,10 @@ static inline struct rq *__task_rq_lock(struct task_struct *p)
 {
         for (;;) {
                 struct rq *rq = task_rq(p);
-                spin_lock(&rq->lock);
+                raw_spin_lock(&rq->lock);
                 if (likely(rq == task_rq(p)))
                         return rq;
-                spin_unlock(&rq->lock);
+                raw_spin_unlock(&rq->lock);
         }
 }
 
@@ -967,10 +969,10 @@ static struct rq *task_rq_lock(struct task_struct *p, unsigned long *flags)
         for (;;) {
                 local_irq_save(*flags);
                 rq = task_rq(p);
-                spin_lock(&rq->lock);
+                raw_spin_lock(&rq->lock);
                 if (likely(rq == task_rq(p)))
                         return rq;
-                spin_unlock_irqrestore(&rq->lock, *flags);
+                raw_spin_unlock_irqrestore(&rq->lock, *flags);
         }
 }
 
@@ -979,19 +981,19 @@ void task_rq_unlock_wait(struct task_struct *p)
         struct rq *rq = task_rq(p);
 
         smp_mb(); /* spin-unlock-wait is not a full memory barrier */
-        spin_unlock_wait(&rq->lock);
+        raw_spin_unlock_wait(&rq->lock);
 }
 
 static void __task_rq_unlock(struct rq *rq)
         __releases(rq->lock)
 {
-        spin_unlock(&rq->lock);
+        raw_spin_unlock(&rq->lock);
 }
 
 static inline void task_rq_unlock(struct rq *rq, unsigned long *flags)
         __releases(rq->lock)
 {
-        spin_unlock_irqrestore(&rq->lock, *flags);
+        raw_spin_unlock_irqrestore(&rq->lock, *flags);
 }
 
 /*
@@ -1004,7 +1006,7 @@ static struct rq *this_rq_lock(void)
 
         local_irq_disable();
         rq = this_rq();
-        spin_lock(&rq->lock);
+        raw_spin_lock(&rq->lock);
 
         return rq;
 }
@@ -1051,10 +1053,10 @@ static enum hrtimer_restart hrtick(struct hrtimer *timer)
 
         WARN_ON_ONCE(cpu_of(rq) != smp_processor_id());
 
-        spin_lock(&rq->lock);
+        raw_spin_lock(&rq->lock);
         update_rq_clock(rq);
         rq->curr->sched_class->task_tick(rq, rq->curr, 1);
-        spin_unlock(&rq->lock);
+        raw_spin_unlock(&rq->lock);
 
         return HRTIMER_NORESTART;
 }
@@ -1067,10 +1069,10 @@ static void __hrtick_start(void *arg)
 {
         struct rq *rq = arg;
 
-        spin_lock(&rq->lock);
+        raw_spin_lock(&rq->lock);
         hrtimer_restart(&rq->hrtick_timer);
         rq->hrtick_csd_pending = 0;
-        spin_unlock(&rq->lock);
+        raw_spin_unlock(&rq->lock);
 }
 
 /*
@@ -1177,7 +1179,7 @@ static void resched_task(struct task_struct *p)
 {
         int cpu;
 
-        assert_spin_locked(&task_rq(p)->lock);
+        assert_raw_spin_locked(&task_rq(p)->lock);
 
         if (test_tsk_need_resched(p))
                 return;
@@ -1199,10 +1201,10 @@ static void resched_cpu(int cpu)
         struct rq *rq = cpu_rq(cpu);
         unsigned long flags;
 
-        if (!spin_trylock_irqsave(&rq->lock, flags))
+        if (!raw_spin_trylock_irqsave(&rq->lock, flags))
                 return;
         resched_task(cpu_curr(cpu));
-        spin_unlock_irqrestore(&rq->lock, flags);
+        raw_spin_unlock_irqrestore(&rq->lock, flags);
 }
 
 #ifdef CONFIG_NO_HZ
@@ -1271,7 +1273,7 @@ static void sched_rt_avg_update(struct rq *rq, u64 rt_delta)
 #else /* !CONFIG_SMP */
 static void resched_task(struct task_struct *p)
 {
-        assert_spin_locked(&task_rq(p)->lock);
+        assert_raw_spin_locked(&task_rq(p)->lock);
         set_tsk_need_resched(p);
 }
 
@@ -1598,11 +1600,11 @@ static void update_group_shares_cpu(struct task_group *tg, int cpu,
                 struct rq *rq = cpu_rq(cpu);
                 unsigned long flags;
 
-                spin_lock_irqsave(&rq->lock, 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);
-                spin_unlock_irqrestore(&rq->lock, flags);
+                raw_spin_unlock_irqrestore(&rq->lock, flags);
         }
 }
 
@@ -1613,7 +1615,7 @@ static void update_group_shares_cpu(struct task_group *tg, int cpu,
  */
 static int tg_shares_up(struct task_group *tg, void *data)
 {
-        unsigned long weight, rq_weight = 0, shares = 0;
+        unsigned long weight, rq_weight = 0, sum_weight = 0, shares = 0;
         unsigned long *usd_rq_weight;
         struct sched_domain *sd = data;
         unsigned long flags;
@@ -1629,6 +1631,7 @@ static int tg_shares_up(struct task_group *tg, void *data)
                 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
@@ -1637,10 +1640,13 @@ static int tg_shares_up(struct task_group *tg, void *data)
                 if (!weight)
                         weight = NICE_0_LOAD;
 
-                rq_weight += weight;
+                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;
 
@@ -1700,9 +1706,9 @@ static void update_shares_locked(struct rq *rq, struct sched_domain *sd)
         if (root_task_group_empty())
                 return;
 
-        spin_unlock(&rq->lock);
+        raw_spin_unlock(&rq->lock);
         update_shares(sd);
-        spin_lock(&rq->lock);
+        raw_spin_lock(&rq->lock);
 }
 
 static void update_h_load(long cpu)
@@ -1742,7 +1748,7 @@ static inline int _double_lock_balance(struct rq *this_rq, struct rq *busiest)
         __acquires(busiest->lock)
         __acquires(this_rq->lock)
 {
-        spin_unlock(&this_rq->lock);
+        raw_spin_unlock(&this_rq->lock);
         double_rq_lock(this_rq, busiest);
 
         return 1;
@@ -1763,14 +1769,16 @@ static int _double_lock_balance(struct rq *this_rq, struct rq *busiest)
 {
         int ret = 0;
 
-        if (unlikely(!spin_trylock(&busiest->lock))) {
+        if (unlikely(!raw_spin_trylock(&busiest->lock))) {
                 if (busiest < this_rq) {
-                        spin_unlock(&this_rq->lock);
-                        spin_lock(&busiest->lock);
-                        spin_lock_nested(&this_rq->lock, SINGLE_DEPTH_NESTING);
+                        raw_spin_unlock(&this_rq->lock);
+                        raw_spin_lock(&busiest->lock);
+                        raw_spin_lock_nested(&this_rq->lock,
+                                              SINGLE_DEPTH_NESTING);
                         ret = 1;
                 } else
-                        spin_lock_nested(&busiest->lock, SINGLE_DEPTH_NESTING);
+                        raw_spin_lock_nested(&busiest->lock,
+                                              SINGLE_DEPTH_NESTING);
         }
         return ret;
 }
@@ -1784,7 +1792,7 @@ static int double_lock_balance(struct rq *this_rq, struct rq *busiest)
 {
         if (unlikely(!irqs_disabled())) {
                 /* printk() doesn't work good under rq->lock */
-                spin_unlock(&this_rq->lock);
+                raw_spin_unlock(&this_rq->lock);
                 BUG_ON(1);
         }
 
@@ -1794,7 +1802,7 @@ static int double_lock_balance(struct rq *this_rq, struct rq *busiest)
 static inline void double_unlock_balance(struct rq *this_rq, struct rq *busiest)
         __releases(busiest->lock)
 {
-        spin_unlock(&busiest->lock);
+        raw_spin_unlock(&busiest->lock);
         lock_set_subclass(&this_rq->lock.dep_map, 0, _RET_IP_);
 }
 #endif
@@ -1809,6 +1817,22 @@ static void cfs_rq_set_shares(struct cfs_rq *cfs_rq, unsigned long shares)
 #endif
 
 static void calc_load_account_active(struct rq *this_rq);
+static void update_sysctl(void);
+static int get_update_sysctl_factor(void);
+
+static inline void __set_task_cpu(struct task_struct *p, unsigned int cpu)
+{
+        set_task_rq(p, cpu);
+#ifdef CONFIG_SMP
+        /*
+         * After ->cpu is set up to a new value, task_rq_lock(p, ...) can be
+         * successfuly executed on another CPU. We must ensure that updates of
+         * per-task data have been completed by this moment.
+         */
+        smp_wmb();
+        task_thread_info(p)->cpu = cpu;
+#endif
+}
 
 #include "sched_stats.h"
 #include "sched_idletask.c"
@@ -1966,20 +1990,6 @@ inline int task_curr(const struct task_struct *p)
         return cpu_curr(task_cpu(p)) == p;
 }
 
-static inline void __set_task_cpu(struct task_struct *p, unsigned int cpu)
-{
-        set_task_rq(p, cpu);
-#ifdef CONFIG_SMP
-        /*
-         * After ->cpu is set up to a new value, task_rq_lock(p, ...) can be
-         * successfuly executed on another CPU. We must ensure that updates of
-         * per-task data have been completed by this moment.
-         */
-        smp_wmb();
-        task_thread_info(p)->cpu = cpu;
-#endif
-}
-
 static inline void check_class_changed(struct rq *rq, struct task_struct *p,
                                        const struct sched_class *prev_class,
                                        int oldprio, int running)
@@ -1992,6 +2002,39 @@ static inline void check_class_changed(struct rq *rq, struct task_struct *p,
                 p->sched_class->prio_changed(rq, p, oldprio, running);
 }
 
+/**
+ * kthread_bind - bind a just-created kthread to a cpu.
+ * @p: thread created by kthread_create().
+ * @cpu: cpu (might not be online, must be possible) for @k to run on.
+ *
+ * Description: This function is equivalent to set_cpus_allowed(),
+ * except that @cpu doesn't need to be online, and the thread must be
+ * stopped (i.e., just returned from kthread_create()).
+ *
+ * Function lives here instead of kthread.c because it messes with
+ * scheduler internals which require locking.
+ */
+void kthread_bind(struct task_struct *p, unsigned int cpu)
+{
+        struct rq *rq = cpu_rq(cpu);
+        unsigned long flags;
+
+        /* Must have done schedule() in kthread() before we set_task_cpu */
+        if (!wait_task_inactive(p, TASK_UNINTERRUPTIBLE)) {
+                WARN_ON(1);
+                return;
+        }
+
+        raw_spin_lock_irqsave(&rq->lock, flags);
+        update_rq_clock(rq);
+        set_task_cpu(p, cpu);
+        p->cpus_allowed = cpumask_of_cpu(cpu);
+        p->rt.nr_cpus_allowed = 1;
+        p->flags |= PF_THREAD_BOUND;
+        raw_spin_unlock_irqrestore(&rq->lock, flags);
+}
+EXPORT_SYMBOL(kthread_bind);
+
 #ifdef CONFIG_SMP
 /*
  * Is this task likely cache-hot:
@@ -2004,7 +2047,7 @@ task_hot(struct task_struct *p, u64 now, struct sched_domain *sd)
         /*
          * Buddy candidates are cache hot:
          */
-        if (sched_feat(CACHE_HOT_BUDDY) &&
+        if (sched_feat(CACHE_HOT_BUDDY) && this_rq()->nr_running &&
                         (&p->se == cfs_rq_of(&p->se)->next ||
                          &p->se == cfs_rq_of(&p->se)->last))
                 return 1;
@@ -2026,30 +2069,13 @@ task_hot(struct task_struct *p, u64 now, struct sched_domain *sd)
 void set_task_cpu(struct task_struct *p, unsigned int new_cpu)
 {
         int old_cpu = task_cpu(p);
-        struct rq *old_rq = cpu_rq(old_cpu), *new_rq = cpu_rq(new_cpu);
         struct cfs_rq *old_cfsrq = task_cfs_rq(p),
                       *new_cfsrq = cpu_cfs_rq(old_cfsrq, new_cpu);
-        u64 clock_offset;
-
-        clock_offset = old_rq->clock - new_rq->clock;
 
         trace_sched_migrate_task(p, new_cpu);
 
-#ifdef CONFIG_SCHEDSTATS
-        if (p->se.wait_start)
-                p->se.wait_start -= clock_offset;
-        if (p->se.sleep_start)
-                p->se.sleep_start -= clock_offset;
-        if (p->se.block_start)
-                p->se.block_start -= clock_offset;
-#endif
         if (old_cpu != new_cpu) {
                 p->se.nr_migrations++;
-                new_rq->nr_migrations_in++;
-#ifdef CONFIG_SCHEDSTATS
-                if (task_hot(p, old_rq->clock, NULL))
-                        schedstat_inc(p, se.nr_forced2_migrations);
-#endif
                 perf_sw_event(PERF_COUNT_SW_CPU_MIGRATIONS,
                                      1, 1, NULL, 0);
         }
@@ -2082,6 +2108,7 @@ migrate_task(struct task_struct *p, int dest_cpu, struct migration_req *req)
          * it is sufficient to simply update the task's cpu field.
          */
         if (!p->se.on_rq && !task_running(rq, p)) {
+                update_rq_clock(rq);
                 set_task_cpu(p, dest_cpu);
                 return 0;
         }
@@ -2289,6 +2316,14 @@ void task_oncpu_function_call(struct task_struct *p,
         preempt_enable();
 }
 
+#ifdef CONFIG_SMP
+static inline
+int select_task_rq(struct task_struct *p, int sd_flags, int wake_flags)
+{
+        return p->sched_class->select_task_rq(p, sd_flags, wake_flags);
+}
+#endif
+
 /***
  * try_to_wake_up - wake up a thread
  * @p: the to-be-woken-up thread
@@ -2340,16 +2375,14 @@ static int try_to_wake_up(struct task_struct *p, unsigned int state,
         if (task_contributes_to_load(p))
                 rq->nr_uninterruptible--;
         p->state = TASK_WAKING;
-        task_rq_unlock(rq, &flags);
+        __task_rq_unlock(rq);
 
-        cpu = p->sched_class->select_task_rq(p, SD_BALANCE_WAKE, wake_flags);
+        cpu = select_task_rq(p, SD_BALANCE_WAKE, wake_flags);
         if (cpu != orig_cpu)
                 set_task_cpu(p, cpu);
 
-        rq = task_rq_lock(p, &flags);
-
-        if (rq != orig_rq)
-                update_rq_clock(rq);
+        rq = __task_rq_lock(p);
+        update_rq_clock(rq);
 
         WARN_ON(p->state != TASK_WAKING);
         cpu = task_cpu(p);
@@ -2407,6 +2440,17 @@ out_running:
 #ifdef CONFIG_SMP
         if (p->sched_class->task_wake_up)
                 p->sched_class->task_wake_up(rq, p);
+
+        if (unlikely(rq->idle_stamp)) {
+                u64 delta = rq->clock - rq->idle_stamp;
+                u64 max = 2*sysctl_sched_migration_cost;
+
+                if (delta > max)
+                        rq->avg_idle = max;
+                else
+                        update_avg(&rq->avg_idle, delta);
+                rq->idle_stamp = 0;
+        }
 #endif
 out:
         task_rq_unlock(rq, &flags);
@@ -2453,7 +2497,6 @@ static void __sched_fork(struct task_struct *p)
         p->se.avg_overlap               = 0;
         p->se.start_runtime             = 0;
         p->se.avg_wakeup                = sysctl_sched_wakeup_granularity;
-        p->se.avg_running               = 0;
 
 #ifdef CONFIG_SCHEDSTATS
         p->se.wait_start                        = 0;
@@ -2475,7 +2518,6 @@ static void __sched_fork(struct task_struct *p)
         p->se.nr_failed_migrations_running      = 0;
         p->se.nr_failed_migrations_hot          = 0;
         p->se.nr_forced_migrations              = 0;
-        p->se.nr_forced2_migrations             = 0;
 
         p->se.nr_wakeups                        = 0;
         p->se.nr_wakeups_sync                   = 0;
@@ -2545,8 +2587,11 @@ void sched_fork(struct task_struct *p, int clone_flags)
         if (!rt_prio(p->prio))
                 p->sched_class = &fair_sched_class;
 
+        if (p->sched_class->task_fork)
+                p->sched_class->task_fork(p);
+
 #ifdef CONFIG_SMP
-        cpu = p->sched_class->select_task_rq(p, SD_BALANCE_FORK, 0);
+        cpu = select_task_rq(p, SD_BALANCE_FORK, 0);
 #endif
         set_task_cpu(p, cpu);
 
@@ -2581,17 +2626,7 @@ void wake_up_new_task(struct task_struct *p, unsigned long clone_flags)
         rq = task_rq_lock(p, &flags);
         BUG_ON(p->state != TASK_RUNNING);
         update_rq_clock(rq);
-
-        if (!p->sched_class->task_new || !current->se.on_rq) {
-                activate_task(rq, p, 0);
-        } else {
-                /*
-                 * Let the scheduling class do new task startup
-                 * management (if any):
-                 */
-                p->sched_class->task_new(rq, p);
-                inc_nr_running(rq);
-        }
+        activate_task(rq, p, 0);
         trace_sched_wakeup_new(rq, p, 1);
         check_preempt_curr(rq, p, WF_FORK);
 #ifdef CONFIG_SMP
@@ -2748,10 +2783,10 @@ static inline void post_schedule(struct rq *rq)
         if (rq->post_schedule) {
                 unsigned long flags;
 
-                spin_lock_irqsave(&rq->lock, flags);
+                raw_spin_lock_irqsave(&rq->lock, flags);
                 if (rq->curr->sched_class->post_schedule)
                         rq->curr->sched_class->post_schedule(rq);
-                spin_unlock_irqrestore(&rq->lock, flags);
+                raw_spin_unlock_irqrestore(&rq->lock, flags);
 
                 rq->post_schedule = 0;
         }
@@ -2815,14 +2850,14 @@ context_switch(struct rq *rq, struct task_struct *prev,
          */
         arch_start_context_switch(prev);
 
-        if (unlikely(!mm)) {
+        if (likely(!mm)) {
                 next->active_mm = oldmm;
                 atomic_inc(&oldmm->mm_count);
                 enter_lazy_tlb(oldmm, next);
         } else
                 switch_mm(oldmm, mm, next);
 
-        if (unlikely(!prev->mm)) {
+        if (likely(!prev->mm)) {
                 prev->active_mm = NULL;
                 rq->prev_mm = oldmm;
         }
@@ -2985,15 +3020,6 @@ static void calc_load_account_active(struct rq *this_rq)
 }
 
 /*
- * Externally visible per-cpu scheduler statistics:
- * cpu_nr_migrations(cpu) - number of migrations into that cpu
- */
-u64 cpu_nr_migrations(int cpu)
-{
-        return cpu_rq(cpu)->nr_migrations_in;
-}
-
-/*
  * Update rq->cpu_load[] statistics. This function is usually called every
  * scheduler tick (TICK_NSEC).
  */
@@ -3042,15 +3068,15 @@ static void double_rq_lock(struct rq *rq1, struct rq *rq2)
 {
         BUG_ON(!irqs_disabled());
         if (rq1 == rq2) {
-                spin_lock(&rq1->lock);
+                raw_spin_lock(&rq1->lock);
                 __acquire(rq2->lock);   /* Fake it out ;) */
         } else {
                 if (rq1 < rq2) {
-                        spin_lock(&rq1->lock);
-                        spin_lock_nested(&rq2->lock, SINGLE_DEPTH_NESTING);
+                        raw_spin_lock(&rq1->lock);
+                        raw_spin_lock_nested(&rq2->lock, SINGLE_DEPTH_NESTING);
                 } else {
-                        spin_lock(&rq2->lock);
-                        spin_lock_nested(&rq1->lock, SINGLE_DEPTH_NESTING);
+                        raw_spin_lock(&rq2->lock);
+                        raw_spin_lock_nested(&rq1->lock, SINGLE_DEPTH_NESTING);
                 }
         }
         update_rq_clock(rq1);
@@ -3067,9 +3093,9 @@ static void double_rq_unlock(struct rq *rq1, struct rq *rq2)
         __releases(rq1->lock)
         __releases(rq2->lock)
 {
-        spin_unlock(&rq1->lock);
+        raw_spin_unlock(&rq1->lock);
         if (rq1 != rq2)
-                spin_unlock(&rq2->lock);
+                raw_spin_unlock(&rq2->lock);
         else
                 __release(rq2->lock);
 }
@@ -3115,7 +3141,7 @@ out:
 void sched_exec(void)
 {
         int new_cpu, this_cpu = get_cpu();
-        new_cpu = current->sched_class->select_task_rq(current, SD_BALANCE_EXEC, 0);
+        new_cpu = select_task_rq(current, SD_BALANCE_EXEC, 0);
         put_cpu();
         if (new_cpu != this_cpu)
                 sched_migrate_task(current, new_cpu);
@@ -3131,10 +3157,6 @@ static void pull_task(struct rq *src_rq, struct task_struct *p,
         deactivate_task(src_rq, p, 0);
         set_task_cpu(p, this_cpu);
         activate_task(this_rq, p, 0);
-        /*
-         * Note that idle threads have a prio of MAX_PRIO, for this test
-         * to be always true for them.
-         */
         check_preempt_curr(this_rq, p, 0);
 }
 
@@ -4093,7 +4115,7 @@ static int load_balance(int this_cpu, struct rq *this_rq,
         unsigned long flags;
         struct cpumask *cpus = __get_cpu_var(load_balance_tmpmask);
 
-        cpumask_setall(cpus);
+        cpumask_copy(cpus, cpu_active_mask);
 
         /*
          * When power savings policy is enabled for the parent domain, idle
@@ -4166,14 +4188,15 @@ redo:
 
                 if (unlikely(sd->nr_balance_failed > sd->cache_nice_tries+2)) {
 
-                        spin_lock_irqsave(&busiest->lock, flags);
+                        raw_spin_lock_irqsave(&busiest->lock, flags);
 
                         /* don't kick the migration_thread, if the curr
                          * task on busiest cpu can't be moved to this_cpu
                          */
                         if (!cpumask_test_cpu(this_cpu,
                                               &busiest->curr->cpus_allowed)) {
-                                spin_unlock_irqrestore(&busiest->lock, flags);
+                                raw_spin_unlock_irqrestore(&busiest->lock,
+                                                            flags);
                                 all_pinned = 1;
                                 goto out_one_pinned;
                         }
@@ -4183,7 +4206,7 @@ redo:
                                 busiest->push_cpu = this_cpu;
                                 active_balance = 1;
                         }
-                        spin_unlock_irqrestore(&busiest->lock, flags);
+                        raw_spin_unlock_irqrestore(&busiest->lock, flags);
                         if (active_balance)
                                 wake_up_process(busiest->migration_thread);
 
@@ -4256,7 +4279,7 @@ load_balance_newidle(int this_cpu, struct rq *this_rq, struct sched_domain *sd)
         int all_pinned = 0;
         struct cpumask *cpus = __get_cpu_var(load_balance_tmpmask);
 
-        cpumask_setall(cpus);
+        cpumask_copy(cpus, cpu_active_mask);
 
         /*
          * When power savings policy is enabled for the parent domain, idle
@@ -4365,10 +4388,10 @@ redo:
                 /*
                  * Should not call ttwu while holding a rq->lock
                  */
-                spin_unlock(&this_rq->lock);
+                raw_spin_unlock(&this_rq->lock);
                 if (active_balance)
                         wake_up_process(busiest->migration_thread);
-                spin_lock(&this_rq->lock);
+                raw_spin_lock(&this_rq->lock);
 
         } else
                 sd->nr_balance_failed = 0;
@@ -4396,6 +4419,11 @@ static void idle_balance(int this_cpu, struct rq *this_rq)
         int pulled_task = 0;
         unsigned long next_balance = jiffies + HZ;
 
+        this_rq->idle_stamp = this_rq->clock;
+
+        if (this_rq->avg_idle < sysctl_sched_migration_cost)
+                return;
+
         for_each_domain(this_cpu, sd) {
                 unsigned long interval;
 
@@ -4410,8 +4438,10 @@ static void idle_balance(int this_cpu, struct rq *this_rq)
                 interval = msecs_to_jiffies(sd->balance_interval);
                 if (time_after(next_balance, sd->last_balance + interval))
                         next_balance = sd->last_balance + interval;
-                if (pulled_task)
+                if (pulled_task) {
+                        this_rq->idle_stamp = 0;
                         break;
+                }
         }
         if (pulled_task || time_after(jiffies, this_rq->next_balance)) {
                 /*
@@ -4646,7 +4676,7 @@ int select_nohz_load_balancer(int stop_tick)
                 cpumask_set_cpu(cpu, nohz.cpu_mask);
 
                 /* time for ilb owner also to sleep */
-                if (cpumask_weight(nohz.cpu_mask) == num_online_cpus()) {
+                if (cpumask_weight(nohz.cpu_mask) == num_active_cpus()) {
                         if (atomic_read(&nohz.load_balancer) == cpu)
                                 atomic_set(&nohz.load_balancer, -1);
                         return 0;
@@ -5013,8 +5043,13 @@ static void account_guest_time(struct task_struct *p, cputime_t cputime,
         p->gtime = cputime_add(p->gtime, cputime);
 
         /* Add guest time to cpustat. */
-        cpustat->user = cputime64_add(cpustat->user, tmp);
-        cpustat->guest = cputime64_add(cpustat->guest, tmp);
+        if (TASK_NICE(p) > 0) {
+                cpustat->nice = cputime64_add(cpustat->nice, tmp);
+                cpustat->guest_nice = cputime64_add(cpustat->guest_nice, tmp);
+        } else {
+                cpustat->user = cputime64_add(cpustat->user, tmp);
+                cpustat->guest = cputime64_add(cpustat->guest, tmp);
+        }
 }
 
 /*
@@ -5129,60 +5164,86 @@ void account_idle_ticks(unsigned long ticks)
  * Use precise platform statistics if available:
  */
 #ifdef CONFIG_VIRT_CPU_ACCOUNTING
-cputime_t task_utime(struct task_struct *p)
+void task_times(struct task_struct *p, cputime_t *ut, cputime_t *st)
 {
-        return p->utime;
+        *ut = p->utime;
+        *st = p->stime;
 }
 
-cputime_t task_stime(struct task_struct *p)
+void thread_group_times(struct task_struct *p, cputime_t *ut, cputime_t *st)
 {
-        return p->stime;
+        struct task_cputime cputime;
+
+        thread_group_cputime(p, &cputime);
+
+        *ut = cputime.utime;
+        *st = cputime.stime;
 }
 #else
-cputime_t task_utime(struct task_struct *p)
+
+#ifndef nsecs_to_cputime
+# define nsecs_to_cputime(__nsecs)      nsecs_to_jiffies(__nsecs)
+#endif
+
+void task_times(struct task_struct *p, cputime_t *ut, cputime_t *st)
 {
-        clock_t utime = cputime_to_clock_t(p->utime),
-                total = utime + cputime_to_clock_t(p->stime);
-        u64 temp;
+        cputime_t rtime, utime = p->utime, total = cputime_add(utime, p->stime);
 
         /*
          * Use CFS's precise accounting:
          */
-        temp = (u64)nsec_to_clock_t(p->se.sum_exec_runtime);
+        rtime = nsecs_to_cputime(p->se.sum_exec_runtime);
 
         if (total) {
-                temp *= utime;
+                u64 temp;
+
+                temp = (u64)(rtime * utime);
                 do_div(temp, total);
-        }
-        utime = (clock_t)temp;
+                utime = (cputime_t)temp;
+        } else
+                utime = rtime;
+
+        /*
+         * Compare with previous values, to keep monotonicity:
+         */
+        p->prev_utime = max(p->prev_utime, utime);
+        p->prev_stime = max(p->prev_stime, cputime_sub(rtime, p->prev_utime));
 
-        p->prev_utime = max(p->prev_utime, clock_t_to_cputime(utime));
-        return p->prev_utime;
+        *ut = p->prev_utime;
+        *st = p->prev_stime;
 }
 
-cputime_t task_stime(struct task_struct *p)
+/*
+ * Must be called with siglock held.
+ */
+void thread_group_times(struct task_struct *p, cputime_t *ut, cputime_t *st)
 {
-        clock_t stime;
+        struct signal_struct *sig = p->signal;
+        struct task_cputime cputime;
+        cputime_t rtime, utime, total;
 
-        /*
-         * Use CFS's precise accounting. (we subtract utime from
-         * the total, to make sure the total observed by userspace
-         * grows monotonically - apps rely on that):
-         */
-        stime = nsec_to_clock_t(p->se.sum_exec_runtime) -
-                        cputime_to_clock_t(task_utime(p));
+        thread_group_cputime(p, &cputime);
 
-        if (stime >= 0)
-                p->prev_stime = max(p->prev_stime, clock_t_to_cputime(stime));
+        total = cputime_add(cputime.utime, cputime.stime);
+        rtime = nsecs_to_cputime(cputime.sum_exec_runtime);
 
-        return p->prev_stime;
-}
-#endif
+        if (total) {
+                u64 temp;
 
-inline cputime_t task_gtime(struct task_struct *p)
-{
-        return p->gtime;
+                temp = (u64)(rtime * cputime.utime);
+                do_div(temp, total);
+                utime = (cputime_t)temp;
+        } else
+                utime = rtime;
+
+        sig->prev_utime = max(sig->prev_utime, utime);
+        sig->prev_stime = max(sig->prev_stime,
+                              cputime_sub(rtime, sig->prev_utime));
+
+        *ut = sig->prev_utime;
+        *st = sig->prev_stime;
 }
+#endif
 
 /*
  * This function gets called by the timer code, with HZ frequency.
@@ -5199,11 +5260,11 @@ void scheduler_tick(void)
 
         sched_clock_tick();
 
-        spin_lock(&rq->lock);
+        raw_spin_lock(&rq->lock);
         update_rq_clock(rq);
         update_cpu_load(rq);
         curr->sched_class->task_tick(rq, curr, 0);
-        spin_unlock(&rq->lock);
+        raw_spin_unlock(&rq->lock);
 
         perf_event_task_tick(curr, cpu);
 
@@ -5317,13 +5378,14 @@ static inline void schedule_debug(struct task_struct *prev)
 #endif
 }
 
-static void put_prev_task(struct rq *rq, struct task_struct *p)
+static void put_prev_task(struct rq *rq, struct task_struct *prev)
 {
-        u64 runtime = p->se.sum_exec_runtime - p->se.prev_sum_exec_runtime;
+        if (prev->state == TASK_RUNNING) {
+                u64 runtime = prev->se.sum_exec_runtime;
 
-        update_avg(&p->se.avg_running, runtime);
+                runtime -= prev->se.prev_sum_exec_runtime;
+                runtime = min_t(u64, runtime, 2*sysctl_sched_migration_cost);
 
-        if (p->state == TASK_RUNNING) {
                 /*
                  * In order to avoid avg_overlap growing stale when we are
                  * indeed overlapping and hence not getting put to sleep, grow
@@ -5333,12 +5395,9 @@ static void put_prev_task(struct rq *rq, struct task_struct *p)
                  * correlates to the amount of cache footprint a task can
                  * build up.
                  */
-                runtime = min_t(u64, runtime, 2*sysctl_sched_migration_cost);
-                update_avg(&p->se.avg_overlap, runtime);
-        } else {
-                update_avg(&p->se.avg_running, 0);
+                update_avg(&prev->se.avg_overlap, runtime);
         }
-        p->sched_class->put_prev_task(rq, p);
+        prev->sched_class->put_prev_task(rq, prev);
 }
 
 /*
@@ -5399,7 +5458,7 @@ need_resched_nonpreemptible:
         if (sched_feat(HRTICK))
                 hrtick_clear(rq);
 
-        spin_lock_irq(&rq->lock);
+        raw_spin_lock_irq(&rq->lock);
         update_rq_clock(rq);
         clear_tsk_need_resched(prev);
 
@@ -5435,7 +5494,7 @@ need_resched_nonpreemptible:
                 cpu = smp_processor_id();
                 rq = cpu_rq(cpu);
         } else
-                spin_unlock_irq(&rq->lock);
+                raw_spin_unlock_irq(&rq->lock);
 
         post_schedule(rq);
 
@@ -5448,7 +5507,7 @@ need_resched_nonpreemptible:
 }
 EXPORT_SYMBOL(schedule);
 
-#ifdef CONFIG_SMP
+#ifdef CONFIG_MUTEX_SPIN_ON_OWNER
 /*
  * Look out! "owner" is an entirely speculative pointer
  * access and not reliable.
@@ -6142,22 +6201,14 @@ __setscheduler(struct rq *rq, struct task_struct *p, int policy, int prio)
         BUG_ON(p->se.on_rq);
 
         p->policy = policy;
-        switch (p->policy) {
-        case SCHED_NORMAL:
-        case SCHED_BATCH:
-        case SCHED_IDLE:
-                p->sched_class = &fair_sched_class;
-                break;
-        case SCHED_FIFO:
-        case SCHED_RR:
-                p->sched_class = &rt_sched_class;
-                break;
-        }
-
         p->rt_priority = prio;
         p->normal_prio = normal_prio(p);
         /* we are holding p->pi_lock already */
         p->prio = rt_mutex_getprio(p);
+        if (rt_prio(p->prio))
+                p->sched_class = &rt_sched_class;
+        else
+                p->sched_class = &fair_sched_class;
         set_load_weight(p);
 }
 
@@ -6272,7 +6323,7 @@ recheck:
          * make sure no PI-waiters arrive (or leave) while we are
          * changing the priority of the task:
          */
-        spin_lock_irqsave(&p->pi_lock, flags);
+        raw_spin_lock_irqsave(&p->pi_lock, flags);
         /*
          * To be able to change p->policy safely, the apropriate
          * runqueue lock must be held.
@@ -6282,7 +6333,7 @@ recheck:
         if (unlikely(oldpolicy != -1 && oldpolicy != p->policy)) {
                 policy = oldpolicy = -1;
                 __task_rq_unlock(rq);
-                spin_unlock_irqrestore(&p->pi_lock, flags);
+                raw_spin_unlock_irqrestore(&p->pi_lock, flags);
                 goto recheck;
         }
         update_rq_clock(rq);
@@ -6306,7 +6357,7 @@ recheck:
                 check_class_changed(rq, p, prev_class, oldprio, running);
         }
         __task_rq_unlock(rq);
-        spin_unlock_irqrestore(&p->pi_lock, flags);
+        raw_spin_unlock_irqrestore(&p->pi_lock, flags);
 
         rt_mutex_adjust_pi(p);
 
@@ -6560,6 +6611,8 @@ SYSCALL_DEFINE3(sched_setaffinity, pid_t, pid, unsigned int, len,
 long sched_getaffinity(pid_t pid, struct cpumask *mask)
 {
         struct task_struct *p;
+        unsigned long flags;
+        struct rq *rq;
         int retval;
 
         get_online_cpus();
@@ -6574,7 +6627,9 @@ long sched_getaffinity(pid_t pid, struct cpumask *mask)
         if (retval)
                 goto out_unlock;
 
+        rq = task_rq_lock(p, &flags);
         cpumask_and(mask, &p->cpus_allowed, cpu_online_mask);
+        task_rq_unlock(rq, &flags);
 
 out_unlock:
         read_unlock(&tasklist_lock);
@@ -6632,7 +6687,7 @@ SYSCALL_DEFINE0(sched_yield)
          */
         __release(rq->lock);
         spin_release(&rq->lock.dep_map, 1, _THIS_IP_);
-        _raw_spin_unlock(&rq->lock);
+        do_raw_spin_unlock(&rq->lock);
         preempt_enable_no_resched();
 
         schedule();
@@ -6812,6 +6867,8 @@ SYSCALL_DEFINE2(sched_rr_get_interval, pid_t, pid,
 {
         struct task_struct *p;
         unsigned int time_slice;
+        unsigned long flags;
+        struct rq *rq;
         int retval;
         struct timespec t;
 
@@ -6828,7 +6885,9 @@ SYSCALL_DEFINE2(sched_rr_get_interval, pid_t, pid,
         if (retval)
                 goto out_unlock;
 
-        time_slice = p->sched_class->get_rr_interval(p);
+        rq = task_rq_lock(p, &flags);
+        time_slice = p->sched_class->get_rr_interval(rq, p);
+        task_rq_unlock(rq, &flags);
 
         read_unlock(&tasklist_lock);
         jiffies_to_timespec(time_slice, &t);
@@ -6902,7 +6961,7 @@ void show_state_filter(unsigned long state_filter)
         /*
          * Only show locks if all tasks are dumped:
          */
-        if (state_filter == -1)
+        if (!state_filter)
                 debug_show_all_locks();
 }
 
@@ -6924,12 +6983,11 @@ void __cpuinit init_idle(struct task_struct *idle, int cpu)
         struct rq *rq = cpu_rq(cpu);
         unsigned long flags;
 
-        spin_lock_irqsave(&rq->lock, flags);
+        raw_spin_lock_irqsave(&rq->lock, flags);
 
         __sched_fork(idle);
         idle->se.exec_start = sched_clock();
 
-        idle->prio = idle->normal_prio = MAX_PRIO;
         cpumask_copy(&idle->cpus_allowed, cpumask_of(cpu));
         __set_task_cpu(idle, cpu);
 
@@ -6937,7 +6995,7 @@ void __cpuinit init_idle(struct task_struct *idle, int cpu)
 #if defined(CONFIG_SMP) && defined(__ARCH_WANT_UNLOCKED_CTXSW)
         idle->oncpu = 1;
 #endif
-        spin_unlock_irqrestore(&rq->lock, flags);
+        raw_spin_unlock_irqrestore(&rq->lock, flags);
 
         /* Set the preempt count _outside_ the spinlocks! */
 #if defined(CONFIG_PREEMPT)
@@ -6970,22 +7028,43 @@ cpumask_var_t nohz_cpu_mask;
  *
  * This idea comes from the SD scheduler of Con Kolivas:
  */
-static inline void sched_init_granularity(void)
+static int get_update_sysctl_factor(void)
 {
-        unsigned int factor = 1 + ilog2(num_online_cpus());
-        const unsigned long limit = 200000000;
+        unsigned int cpus = min_t(int, num_online_cpus(), 8);
+        unsigned int factor;
+
+        switch (sysctl_sched_tunable_scaling) {
+        case SCHED_TUNABLESCALING_NONE:
+                factor = 1;
+                break;
+        case SCHED_TUNABLESCALING_LINEAR:
+                factor = cpus;
+                break;
+        case SCHED_TUNABLESCALING_LOG:
+        default:
+                factor = 1 + ilog2(cpus);
+                break;
+        }
 
-        sysctl_sched_min_granularity *= factor;
-        if (sysctl_sched_min_granularity > limit)
-                sysctl_sched_min_granularity = limit;
+        return factor;
+}
 
-        sysctl_sched_latency *= factor;
-        if (sysctl_sched_latency > limit)
-                sysctl_sched_latency = limit;
+static void update_sysctl(void)
+{
+        unsigned int factor = get_update_sysctl_factor();
 
-        sysctl_sched_wakeup_granularity *= factor;
+#define SET_SYSCTL(name) \
+        (sysctl_##name = (factor) * normalized_sysctl_##name)
+        SET_SYSCTL(sched_min_granularity);
+        SET_SYSCTL(sched_latency);
+        SET_SYSCTL(sched_wakeup_granularity);
+        SET_SYSCTL(sched_shares_ratelimit);
+#undef SET_SYSCTL
+}
 
-        sysctl_sched_shares_ratelimit *= factor;
+static inline void sched_init_granularity(void)
+{
+        update_sysctl();
 }
 
 #ifdef CONFIG_SMP
@@ -7022,7 +7101,7 @@ int set_cpus_allowed_ptr(struct task_struct *p, const struct cpumask *new_mask)
         int ret = 0;
 
         rq = task_rq_lock(p, &flags);
-        if (!cpumask_intersects(new_mask, cpu_online_mask)) {
+        if (!cpumask_intersects(new_mask, cpu_active_mask)) {
                 ret = -EINVAL;
                 goto out;
         }
@@ -7044,7 +7123,7 @@ int set_cpus_allowed_ptr(struct task_struct *p, const struct cpumask *new_mask)
         if (cpumask_test_cpu(task_cpu(p), new_mask))
                 goto out;
 
-        if (migrate_task(p, cpumask_any_and(cpu_online_mask, new_mask), &req)) {
+        if (migrate_task(p, cpumask_any_and(cpu_active_mask, new_mask), &req)) {
                 /* Need help from migration thread: drop lock and wait. */
                 struct task_struct *mt = rq->migration_thread;
 
@@ -7133,10 +7212,10 @@ static int migration_thread(void *data)
                 struct migration_req *req;
                 struct list_head *head;
 
-                spin_lock_irq(&rq->lock);
+                raw_spin_lock_irq(&rq->lock);
 
                 if (cpu_is_offline(cpu)) {
-                        spin_unlock_irq(&rq->lock);
+                        raw_spin_unlock_irq(&rq->lock);
                         break;
                 }
 
@@ -7148,7 +7227,7 @@ static int migration_thread(void *data)
                 head = &rq->migration_queue;
 
                 if (list_empty(head)) {
-                        spin_unlock_irq(&rq->lock);
+                        raw_spin_unlock_irq(&rq->lock);
                         schedule();
                         set_current_state(TASK_INTERRUPTIBLE);
                         continue;
@@ -7157,14 +7236,14 @@ static int migration_thread(void *data)
                 list_del_init(head->next);
 
                 if (req->task != NULL) {
-                        spin_unlock(&rq->lock);
+                        raw_spin_unlock(&rq->lock);
                         __migrate_task(req->task, cpu, req->dest_cpu);
                 } else if (likely(cpu == (badcpu = smp_processor_id()))) {
                         req->dest_cpu = RCU_MIGRATION_GOT_QS;
-                        spin_unlock(&rq->lock);
+                        raw_spin_unlock(&rq->lock);
                 } else {
                         req->dest_cpu = RCU_MIGRATION_MUST_SYNC;
-                        spin_unlock(&rq->lock);
+                        raw_spin_unlock(&rq->lock);
                         WARN_ONCE(1, "migration_thread() on CPU %d, expected %d\n", badcpu, cpu);
                 }
                 local_irq_enable();
@@ -7198,19 +7277,19 @@ static void move_task_off_dead_cpu(int dead_cpu, struct task_struct *p)
 
 again:
         /* Look for allowed, online CPU in same node. */
-        for_each_cpu_and(dest_cpu, nodemask, cpu_online_mask)
+        for_each_cpu_and(dest_cpu, nodemask, cpu_active_mask)
                 if (cpumask_test_cpu(dest_cpu, &p->cpus_allowed))
                         goto move;
 
         /* Any allowed, online CPU? */
-        dest_cpu = cpumask_any_and(&p->cpus_allowed, cpu_online_mask);
+        dest_cpu = cpumask_any_and(&p->cpus_allowed, cpu_active_mask);
         if (dest_cpu < nr_cpu_ids)
                 goto move;
 
         /* No more Mr. Nice Guy. */
         if (dest_cpu >= nr_cpu_ids) {
                 cpuset_cpus_allowed_locked(p, &p->cpus_allowed);
-                dest_cpu = cpumask_any_and(cpu_online_mask, &p->cpus_allowed);
+                dest_cpu = cpumask_any_and(cpu_active_mask, &p->cpus_allowed);
 
                 /*
                  * Don't tell them about moving exiting tasks or
@@ -7239,7 +7318,7 @@ move:
  */
 static void migrate_nr_uninterruptible(struct rq *rq_src)
 {
-        struct rq *rq_dest = cpu_rq(cpumask_any(cpu_online_mask));
+        struct rq *rq_dest = cpu_rq(cpumask_any(cpu_active_mask));
         unsigned long flags;
 
         local_irq_save(flags);
@@ -7287,14 +7366,14 @@ void sched_idle_next(void)
          * Strictly not necessary since rest of the CPUs are stopped by now
          * and interrupts disabled on the current cpu.
          */
-        spin_lock_irqsave(&rq->lock, flags);
+        raw_spin_lock_irqsave(&rq->lock, flags);
 
         __setscheduler(rq, p, SCHED_FIFO, MAX_RT_PRIO-1);
 
         update_rq_clock(rq);
         activate_task(rq, p, 0);
 
-        spin_unlock_irqrestore(&rq->lock, flags);
+        raw_spin_unlock_irqrestore(&rq->lock, flags);
 }
 
 /*
@@ -7330,9 +7409,9 @@ static void migrate_dead(unsigned int dead_cpu, struct task_struct *p)
          * that's OK. No task can be added to this CPU, so iteration is
          * fine.
          */
-        spin_unlock_irq(&rq->lock);
+        raw_spin_unlock_irq(&rq->lock);
         move_task_off_dead_cpu(dead_cpu, p);
-        spin_lock_irq(&rq->lock);
+        raw_spin_lock_irq(&rq->lock);
 
         put_task_struct(p);
 }
@@ -7373,17 +7452,16 @@ static struct ctl_table sd_ctl_dir[] = {
                 .procname       = "sched_domain",
                 .mode           = 0555,
         },
-        {0, },
+        {}
 };
 
 static struct ctl_table sd_ctl_root[] = {
         {
-                .ctl_name       = CTL_KERN,
                 .procname       = "kernel",
                 .mode           = 0555,
                 .child          = sd_ctl_dir,
         },
-        {0, },
+        {}
 };
 
 static struct ctl_table *sd_alloc_ctl_entry(int n)
@@ -7493,7 +7571,7 @@ static ctl_table *sd_alloc_ctl_cpu_table(int cpu)
 static struct ctl_table_header *sd_sysctl_header;
 static void register_sched_domain_sysctl(void)
 {
-        int i, cpu_num = num_online_cpus();
+        int i, cpu_num = num_possible_cpus();
         struct ctl_table *entry = sd_alloc_ctl_entry(cpu_num + 1);
         char buf[32];
 
@@ -7503,7 +7581,7 @@ static void register_sched_domain_sysctl(void)
         if (entry == NULL)
                 return;
 
-        for_each_online_cpu(i) {
+        for_each_possible_cpu(i) {
                 snprintf(buf, 32, "cpu%d", i);
                 entry->procname = kstrdup(buf, GFP_KERNEL);
                 entry->mode = 0555;
@@ -7599,13 +7677,13 @@ migration_call(struct notifier_block *nfb, unsigned long action, void *hcpu)
 
                 /* Update our root-domain */
                 rq = cpu_rq(cpu);
-                spin_lock_irqsave(&rq->lock, flags);
+                raw_spin_lock_irqsave(&rq->lock, flags);
                 if (rq->rd) {
                         BUG_ON(!cpumask_test_cpu(cpu, rq->rd->span));
 
                         set_rq_online(rq);
                 }
-                spin_unlock_irqrestore(&rq->lock, flags);
+                raw_spin_unlock_irqrestore(&rq->lock, flags);
                 break;
 
 #ifdef CONFIG_HOTPLUG_CPU
@@ -7630,14 +7708,13 @@ migration_call(struct notifier_block *nfb, unsigned long action, void *hcpu)
                 put_task_struct(rq->migration_thread);
                 rq->migration_thread = NULL;
                 /* Idle task back to normal (off runqueue, low prio) */
-                spin_lock_irq(&rq->lock);
+                raw_spin_lock_irq(&rq->lock);
                 update_rq_clock(rq);
                 deactivate_task(rq, rq->idle, 0);
-                rq->idle->static_prio = MAX_PRIO;
                 __setscheduler(rq, rq->idle, SCHED_NORMAL, 0);
                 rq->idle->sched_class = &idle_sched_class;
                 migrate_dead_tasks(cpu);
-                spin_unlock_irq(&rq->lock);
+                raw_spin_unlock_irq(&rq->lock);
                 cpuset_unlock();
                 migrate_nr_uninterruptible(rq);
                 BUG_ON(rq->nr_running != 0);
@@ -7647,30 +7724,30 @@ migration_call(struct notifier_block *nfb, unsigned long action, void *hcpu)
                  * they didn't take sched_hotcpu_mutex. Just wake up
                  * the requestors.
                  */
-                spin_lock_irq(&rq->lock);
+                raw_spin_lock_irq(&rq->lock);
                 while (!list_empty(&rq->migration_queue)) {
                         struct migration_req *req;
 
                         req = list_entry(rq->migration_queue.next,
                                          struct migration_req, list);
                         list_del_init(&req->list);
-                        spin_unlock_irq(&rq->lock);
+                        raw_spin_unlock_irq(&rq->lock);
                         complete(&req->done);
-                        spin_lock_irq(&rq->lock);
+                        raw_spin_lock_irq(&rq->lock);
                 }
-                spin_unlock_irq(&rq->lock);
+                raw_spin_unlock_irq(&rq->lock);
                 break;
 
         case CPU_DYING:
         case CPU_DYING_FROZEN:
                 /* Update our root-domain */
                 rq = cpu_rq(cpu);
-                spin_lock_irqsave(&rq->lock, flags);
+                raw_spin_lock_irqsave(&rq->lock, flags);
                 if (rq->rd) {
                         BUG_ON(!cpumask_test_cpu(cpu, rq->rd->span));
                         set_rq_offline(rq);
                 }
-                spin_unlock_irqrestore(&rq->lock, flags);
+                raw_spin_unlock_irqrestore(&rq->lock, flags);
                 break;
 #endif
         }
@@ -7707,6 +7784,16 @@ early_initcall(migration_init);
 
 #ifdef CONFIG_SCHED_DEBUG
 
+static __read_mostly int sched_domain_debug_enabled;
+
+static int __init sched_domain_debug_setup(char *str)
+{
+        sched_domain_debug_enabled = 1;
+
+        return 0;
+}
+early_param("sched_debug", sched_domain_debug_setup);
+
 static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
                                   struct cpumask *groupmask)
 {
@@ -7793,6 +7880,9 @@ static void sched_domain_debug(struct sched_domain *sd, int cpu)
         cpumask_var_t groupmask;
         int level = 0;
 
+        if (!sched_domain_debug_enabled)
+                return;
+
         if (!sd) {
                 printk(KERN_DEBUG "CPU%d attaching NULL sched-domain.\n", cpu);
                 return;
@@ -7872,6 +7962,8 @@ sd_parent_degenerate(struct sched_domain *sd, struct sched_domain *parent)
 
 static void free_rootdomain(struct root_domain *rd)
 {
+        synchronize_sched();
+
         cpupri_cleanup(&rd->cpupri);
 
         free_cpumask_var(rd->rto_mask);
@@ -7885,7 +7977,7 @@ static void rq_attach_root(struct rq *rq, struct root_domain *rd)
         struct root_domain *old_rd = NULL;
         unsigned long flags;
 
-        spin_lock_irqsave(&rq->lock, flags);
+        raw_spin_lock_irqsave(&rq->lock, flags);
 
         if (rq->rd) {
                 old_rd = rq->rd;
@@ -7911,7 +8003,7 @@ static void rq_attach_root(struct rq *rq, struct root_domain *rd)
         if (cpumask_test_cpu(rq->cpu, cpu_active_mask))
                 set_rq_online(rq);
 
-        spin_unlock_irqrestore(&rq->lock, flags);
+        raw_spin_unlock_irqrestore(&rq->lock, flags);
 
         if (old_rd)
                 free_rootdomain(old_rd);
@@ -8012,6 +8104,7 @@ static cpumask_var_t cpu_isolated_map;
 /* Setup the mask of cpus configured for isolated domains */
 static int __init isolated_cpu_setup(char *str)
 {
+        alloc_bootmem_cpumask_var(&cpu_isolated_map);
         cpulist_parse(str, cpu_isolated_map);
         return 1;
 }
@@ -8196,14 +8289,14 @@ enum s_alloc {
  */
 #ifdef CONFIG_SCHED_SMT
 static DEFINE_PER_CPU(struct static_sched_domain, cpu_domains);
-static DEFINE_PER_CPU(struct static_sched_group, sched_group_cpus);
+static DEFINE_PER_CPU(struct static_sched_group, sched_groups);
 
 static int
 cpu_to_cpu_group(int cpu, const struct cpumask *cpu_map,
                  struct sched_group **sg, struct cpumask *unused)
 {
         if (sg)
-                *sg = &per_cpu(sched_group_cpus, cpu).sg;
+                *sg = &per_cpu(sched_groups, cpu).sg;
         return cpu;
 }
 #endif /* CONFIG_SCHED_SMT */
@@ -8848,7 +8941,7 @@ static int build_sched_domains(const struct cpumask *cpu_map)
         return __build_sched_domains(cpu_map, NULL);
 }
 
-static struct cpumask *doms_cur;        /* current sched domains */
+static cpumask_var_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' */
@@ -8870,6 +8963,31 @@ int __attribute__((weak)) arch_update_cpu_topology(void)
         return 0;
 }
 
+cpumask_var_t *alloc_sched_domains(unsigned int ndoms)
+{
+        int i;
+        cpumask_var_t *doms;
+
+        doms = kmalloc(sizeof(*doms) * ndoms, GFP_KERNEL);
+        if (!doms)
+                return NULL;
+        for (i = 0; i < ndoms; i++) {
+                if (!alloc_cpumask_var(&doms[i], GFP_KERNEL)) {
+                        free_sched_domains(doms, i);
+                        return NULL;
+                }
+        }
+        return doms;
+}
+
+void free_sched_domains(cpumask_var_t doms[], unsigned int ndoms)
+{
+        unsigned int i;
+        for (i = 0; i < ndoms; i++)
+                free_cpumask_var(doms[i]);
+        kfree(doms);
+}
+
 /*
  * Set up scheduler domains and groups. Callers must hold the hotplug lock.
  * For now this just excludes isolated cpus, but could be used to
@@ -8881,12 +8999,12 @@ static int arch_init_sched_domains(const struct cpumask *cpu_map)
 
         arch_update_cpu_topology();
         ndoms_cur = 1;
-        doms_cur = kmalloc(cpumask_size(), GFP_KERNEL);
+        doms_cur = alloc_sched_domains(ndoms_cur);
         if (!doms_cur)
-                doms_cur = fallback_doms;
-        cpumask_andnot(doms_cur, cpu_map, cpu_isolated_map);
+                doms_cur = &fallback_doms;
+        cpumask_andnot(doms_cur[0], cpu_map, cpu_isolated_map);
         dattr_cur = NULL;
-        err = build_sched_domains(doms_cur);
+        err = build_sched_domains(doms_cur[0]);
         register_sched_domain_sysctl();
 
         return err;
@@ -8936,19 +9054,19 @@ static int dattrs_equal(struct sched_domain_attr *cur, int idx_cur,
  * doms_new[] to the current sched domain partitioning, doms_cur[].
  * It destroys each deleted domain and builds each new domain.
  *
- * 'doms_new' is an array of cpumask's of length 'ndoms_new'.
+ * 'doms_new' is an array of cpumask_var_t's of length 'ndoms_new'.
  * The masks don't intersect (don't overlap.) We should setup one
  * sched domain for each mask. CPUs not in any of the cpumasks will
  * not be load balanced. If the same cpumask appears both in the
  * current 'doms_cur' domains and in the new 'doms_new', we can leave
  * it as it is.
  *
- * The passed in 'doms_new' should be kmalloc'd. This routine takes
- * ownership of it and will kfree it when done with it. If the caller
- * failed the kmalloc call, then it can pass in doms_new == NULL &&
- * ndoms_new == 1, and partition_sched_domains() will fallback to
- * the single partition 'fallback_doms', it also forces the domains
- * to be rebuilt.
+ * The passed in 'doms_new' should be allocated using
+ * alloc_sched_domains.  This routine takes ownership of it and will
+ * free_sched_domains it when done with it. If the caller failed the
+ * alloc call, then it can pass in doms_new == NULL && ndoms_new == 1,
+ * and partition_sched_domains() will fallback to the single partition
+ * 'fallback_doms', it also forces the domains to be rebuilt.
  *
  * If doms_new == NULL it will be replaced with cpu_online_mask.
  * ndoms_new == 0 is a special case for destroying existing domains,
@@ -8956,8 +9074,7 @@ static int dattrs_equal(struct sched_domain_attr *cur, int idx_cur,
  *
  * Call with hotplug lock held
  */
-/* FIXME: Change to struct cpumask *doms_new[] */
-void partition_sched_domains(int ndoms_new, struct cpumask *doms_new,
+void partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
                              struct sched_domain_attr *dattr_new)
 {
         int i, j, n;
@@ -8976,40 +9093,40 @@ void partition_sched_domains(int ndoms_new, struct cpumask *doms_new,
         /* Destroy deleted domains */
         for (i = 0; i < ndoms_cur; i++) {
                 for (j = 0; j < n && !new_topology; j++) {
-                        if (cpumask_equal(&doms_cur[i], &doms_new[j])
+                        if (cpumask_equal(doms_cur[i], doms_new[j])
                             && dattrs_equal(dattr_cur, i, dattr_new, j))
                                 goto match1;
                 }
                 /* no match - a current sched domain not in new doms_new[] */
-                detach_destroy_domains(doms_cur + i);
+                detach_destroy_domains(doms_cur[i]);
 match1:
                 ;
         }
 
         if (doms_new == NULL) {
                 ndoms_cur = 0;
-                doms_new = fallback_doms;
-                cpumask_andnot(&doms_new[0], cpu_online_mask, cpu_isolated_map);
+                doms_new = &fallback_doms;
+                cpumask_andnot(doms_new[0], cpu_active_mask, cpu_isolated_map);
                 WARN_ON_ONCE(dattr_new);
         }
 
         /* Build new domains */
         for (i = 0; i < ndoms_new; i++) {
                 for (j = 0; j < ndoms_cur && !new_topology; j++) {
-                        if (cpumask_equal(&doms_new[i], &doms_cur[j])
+                        if (cpumask_equal(doms_new[i], doms_cur[j])
                             && dattrs_equal(dattr_new, i, dattr_cur, j))
                                 goto match2;
                 }
                 /* 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:
                 ;
         }
 
         /* Remember the new sched domains */
-        if (doms_cur != fallback_doms)
-                kfree(doms_cur);
+        if (doms_cur != &fallback_doms)
+                free_sched_domains(doms_cur, ndoms_cur);
         kfree(dattr_cur);       /* kfree(NULL) is safe */
         doms_cur = doms_new;
         dattr_cur = dattr_new;
@@ -9120,8 +9237,10 @@ static int update_sched_domains(struct notifier_block *nfb,
         switch (action) {
         case CPU_ONLINE:
         case CPU_ONLINE_FROZEN:
-        case CPU_DEAD:
-        case CPU_DEAD_FROZEN:
+        case CPU_DOWN_PREPARE:
+        case CPU_DOWN_PREPARE_FROZEN:
+        case CPU_DOWN_FAILED:
+        case CPU_DOWN_FAILED_FROZEN:
                 partition_sched_domains(1, NULL, NULL);
                 return NOTIFY_OK;
 
@@ -9168,7 +9287,7 @@ void __init sched_init_smp(void)
 #endif
         get_online_cpus();
         mutex_lock(&sched_domains_mutex);
-        arch_init_sched_domains(cpu_online_mask);
+        arch_init_sched_domains(cpu_active_mask);
         cpumask_andnot(non_isolated_cpus, cpu_possible_mask, cpu_isolated_map);
         if (cpumask_empty(non_isolated_cpus))
                 cpumask_set_cpu(smp_processor_id(), non_isolated_cpus);
@@ -9241,13 +9360,13 @@ static void init_rt_rq(struct rt_rq *rt_rq, struct rq *rq)
 #ifdef CONFIG_SMP
         rt_rq->rt_nr_migratory = 0;
         rt_rq->overloaded = 0;
-        plist_head_init(&rt_rq->pushable_tasks, &rq->lock);
+        plist_head_init_raw(&rt_rq->pushable_tasks, &rq->lock);
 #endif
 
         rt_rq->rt_time = 0;
         rt_rq->rt_throttled = 0;
         rt_rq->rt_runtime = 0;
-        spin_lock_init(&rt_rq->rt_runtime_lock);
+        raw_spin_lock_init(&rt_rq->rt_runtime_lock);
 
 #ifdef CONFIG_RT_GROUP_SCHED
         rt_rq->rt_nr_boosted = 0;
@@ -9331,10 +9450,6 @@ void __init sched_init(void)
 #ifdef CONFIG_CPUMASK_OFFSTACK
         alloc_size += num_possible_cpus() * cpumask_size();
 #endif
-        /*
-         * As sched_init() is called before page_alloc is setup,
-         * we use alloc_bootmem().
-         */
         if (alloc_size) {
                 ptr = (unsigned long)kzalloc(alloc_size, GFP_NOWAIT);
 
@@ -9411,7 +9526,7 @@ void __init sched_init(void)
                 struct rq *rq;
 
                 rq = cpu_rq(i);
-                spin_lock_init(&rq->lock);
+                raw_spin_lock_init(&rq->lock);
                 rq->nr_running = 0;
                 rq->calc_load_active = 0;
                 rq->calc_load_update = jiffies + LOAD_FREQ;
@@ -9471,7 +9586,7 @@ void __init sched_init(void)
 #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_rt_rq_var, i),
                                 &per_cpu(init_sched_rt_entity, i), i, 1,
                                 root_task_group.rt_se[i]);
 #endif
@@ -9489,6 +9604,8 @@ void __init sched_init(void)
                 rq->cpu = i;
                 rq->online = 0;
                 rq->migration_thread = NULL;
+                rq->idle_stamp = 0;
+                rq->avg_idle = 2*sysctl_sched_migration_cost;
                 INIT_LIST_HEAD(&rq->migration_queue);
                 rq_attach_root(rq, &def_root_domain);
 #endif
@@ -9507,7 +9624,7 @@ void __init sched_init(void)
 #endif
 
 #ifdef CONFIG_RT_MUTEXES
-        plist_head_init(&init_task.pi_waiters, &init_task.pi_lock);
+        plist_head_init_raw(&init_task.pi_waiters, &init_task.pi_lock);
 #endif
 
         /*
@@ -9532,13 +9649,15 @@ void __init sched_init(void)
         current->sched_class = &fair_sched_class;
 
         /* Allocate the nohz_cpu_mask if CONFIG_CPUMASK_OFFSTACK */
-        alloc_cpumask_var(&nohz_cpu_mask, GFP_NOWAIT);
+        zalloc_cpumask_var(&nohz_cpu_mask, GFP_NOWAIT);
 #ifdef CONFIG_SMP
 #ifdef CONFIG_NO_HZ
-        alloc_cpumask_var(&nohz.cpu_mask, GFP_NOWAIT);
+        zalloc_cpumask_var(&nohz.cpu_mask, GFP_NOWAIT);
         alloc_cpumask_var(&nohz.ilb_grp_nohz_mask, GFP_NOWAIT);
 #endif
-        alloc_cpumask_var(&cpu_isolated_map, GFP_NOWAIT);
+        /* May be allocated at isolcpus cmdline parse time */
+        if (cpu_isolated_map == NULL)
+                zalloc_cpumask_var(&cpu_isolated_map, GFP_NOWAIT);
 #endif /* SMP */
 
         perf_event_init();
@@ -9630,13 +9749,13 @@ void normalize_rt_tasks(void)
                         continue;
                 }
 
-                spin_lock(&p->pi_lock);
+                raw_spin_lock(&p->pi_lock);
                 rq = __task_rq_lock(p);
 
                 normalize_task(rq, p);
 
                 __task_rq_unlock(rq);
-                spin_unlock(&p->pi_lock);
+                raw_spin_unlock(&p->pi_lock);
         } while_each_thread(g, p);
 
         read_unlock_irqrestore(&tasklist_lock, flags);
@@ -9732,13 +9851,15 @@ int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
                 se = kzalloc_node(sizeof(struct sched_entity),
                                   GFP_KERNEL, cpu_to_node(i));
                 if (!se)
-                        goto err;
+                        goto err_free_rq;
 
                 init_tg_cfs_entry(tg, cfs_rq, se, i, 0, parent->se[i]);
         }
 
         return 1;
 
+ err_free_rq:
+        kfree(cfs_rq);
  err:
         return 0;
 }
@@ -9820,13 +9941,15 @@ int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent)
                 rt_se = kzalloc_node(sizeof(struct sched_rt_entity),
                                      GFP_KERNEL, cpu_to_node(i));
                 if (!rt_se)
-                        goto err;
+                        goto err_free_rq;
 
                 init_tg_rt_entry(tg, rt_rq, rt_se, i, 0, parent->rt_se[i]);
         }
 
         return 1;
 
+ err_free_rq:
+        kfree(rt_rq);
  err:
         return 0;
 }
@@ -9995,9 +10118,9 @@ static void set_se_shares(struct sched_entity *se, unsigned long shares)
         struct rq *rq = cfs_rq->rq;
         unsigned long flags;
 
-        spin_lock_irqsave(&rq->lock, flags);
+        raw_spin_lock_irqsave(&rq->lock, flags);
         __set_se_shares(se, shares);
-        spin_unlock_irqrestore(&rq->lock, flags);
+        raw_spin_unlock_irqrestore(&rq->lock, flags);
 }
 
 static DEFINE_MUTEX(shares_mutex);
@@ -10182,18 +10305,18 @@ static int tg_set_bandwidth(struct task_group *tg,
         if (err)
                 goto unlock;
 
-        spin_lock_irq(&tg->rt_bandwidth.rt_runtime_lock);
+        raw_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);
+                raw_spin_lock(&rt_rq->rt_runtime_lock);
                 rt_rq->rt_runtime = rt_runtime;
-                spin_unlock(&rt_rq->rt_runtime_lock);
+                raw_spin_unlock(&rt_rq->rt_runtime_lock);
         }
-        spin_unlock_irq(&tg->rt_bandwidth.rt_runtime_lock);
+        raw_spin_unlock_irq(&tg->rt_bandwidth.rt_runtime_lock);
  unlock:
         read_unlock(&tasklist_lock);
         mutex_unlock(&rt_constraints_mutex);
@@ -10298,15 +10421,15 @@ static int sched_rt_global_constraints(void)
         if (sysctl_sched_rt_runtime == 0)
                 return -EBUSY;
 
-        spin_lock_irqsave(&def_rt_bandwidth.rt_runtime_lock, flags);
+        raw_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);
+                raw_spin_lock(&rt_rq->rt_runtime_lock);
                 rt_rq->rt_runtime = global_rt_runtime();
-                spin_unlock(&rt_rq->rt_runtime_lock);
+                raw_spin_unlock(&rt_rq->rt_runtime_lock);
         }
-        spin_unlock_irqrestore(&def_rt_bandwidth.rt_runtime_lock, flags);
+        raw_spin_unlock_irqrestore(&def_rt_bandwidth.rt_runtime_lock, flags);
 
         return 0;
 }
@@ -10597,9 +10720,9 @@ static u64 cpuacct_cpuusage_read(struct cpuacct *ca, int cpu)
         /*
          * Take rq->lock to make 64-bit read safe on 32-bit platforms.
          */
-        spin_lock_irq(&cpu_rq(cpu)->lock);
+        raw_spin_lock_irq(&cpu_rq(cpu)->lock);
         data = *cpuusage;
-        spin_unlock_irq(&cpu_rq(cpu)->lock);
+        raw_spin_unlock_irq(&cpu_rq(cpu)->lock);
 #else
         data = *cpuusage;
 #endif
@@ -10615,9 +10738,9 @@ static void cpuacct_cpuusage_write(struct cpuacct *ca, int cpu, u64 val)
         /*
          * Take rq->lock to make 64-bit write safe on 32-bit platforms.
          */
-        spin_lock_irq(&cpu_rq(cpu)->lock);
+        raw_spin_lock_irq(&cpu_rq(cpu)->lock);
         *cpuusage = val;
-        spin_unlock_irq(&cpu_rq(cpu)->lock);
+        raw_spin_unlock_irq(&cpu_rq(cpu)->lock);
 #else
         *cpuusage = val;
 #endif
@@ -10851,9 +10974,9 @@ void synchronize_sched_expedited(void)
                 init_completion(&req->done);
                 req->task = NULL;
                 req->dest_cpu = RCU_MIGRATION_NEED_QS;
-                spin_lock_irqsave(&rq->lock, flags);
+                raw_spin_lock_irqsave(&rq->lock, flags);
                 list_add(&req->list, &rq->migration_queue);
-                spin_unlock_irqrestore(&rq->lock, flags);
+                raw_spin_unlock_irqrestore(&rq->lock, flags);
                 wake_up_process(rq->migration_thread);
         }
         for_each_online_cpu(cpu) {
@@ -10861,13 +10984,14 @@ void synchronize_sched_expedited(void)
                 req = &per_cpu(rcu_migration_req, cpu);
                 rq = cpu_rq(cpu);
                 wait_for_completion(&req->done);
-                spin_lock_irqsave(&rq->lock, flags);
+                raw_spin_lock_irqsave(&rq->lock, flags);
                 if (unlikely(req->dest_cpu == RCU_MIGRATION_MUST_SYNC))
                         need_full_sync = 1;
                 req->dest_cpu = RCU_MIGRATION_IDLE;
-                spin_unlock_irqrestore(&rq->lock, flags);
+                raw_spin_unlock_irqrestore(&rq->lock, flags);
         }
         rcu_expedited_state = RCU_EXPEDITED_STATE_IDLE;
+        synchronize_sched_expedited_count++;
         mutex_unlock(&rcu_sched_expedited_mutex);
         put_online_cpus();
         if (need_full_sync)