1 files changed, 87 insertions, 104 deletions

diff --git a/kernel/sched_rt.c b/kernel/sched_rt.c
index f622880e918f..c2fbb02c1b54 100644
--- a/kernel/sched_rt.c
+++ b/kernel/sched_rt.c
@@ -194,17 +194,20 @@ static inline struct rt_rq *group_rt_rq(struct sched_rt_entity *rt_se)
         return rt_se->my_q;
 }
 
-static void enqueue_rt_entity(struct sched_rt_entity *rt_se);
+static void enqueue_rt_entity(struct sched_rt_entity *rt_se, bool head);
 static void dequeue_rt_entity(struct sched_rt_entity *rt_se);
 
 static void sched_rt_rq_enqueue(struct rt_rq *rt_rq)
 {
+        int this_cpu = smp_processor_id();
         struct task_struct *curr = rq_of_rt_rq(rt_rq)->curr;
-        struct sched_rt_entity *rt_se = rt_rq->rt_se;
+        struct sched_rt_entity *rt_se;
+
+        rt_se = rt_rq->tg->rt_se[this_cpu];
 
         if (rt_rq->rt_nr_running) {
                 if (rt_se && !on_rt_rq(rt_se))
-                        enqueue_rt_entity(rt_se);
+                        enqueue_rt_entity(rt_se, false);
                 if (rt_rq->highest_prio.curr < curr->prio)
                         resched_task(curr);
         }
@@ -212,7 +215,10 @@ static void sched_rt_rq_enqueue(struct rt_rq *rt_rq)
 
 static void sched_rt_rq_dequeue(struct rt_rq *rt_rq)
 {
-        struct sched_rt_entity *rt_se = rt_rq->rt_se;
+        int this_cpu = smp_processor_id();
+        struct sched_rt_entity *rt_se;
+
+        rt_se = rt_rq->tg->rt_se[this_cpu];
 
         if (rt_se && on_rt_rq(rt_se))
                 dequeue_rt_entity(rt_se);
@@ -327,7 +333,7 @@ static int do_balance_runtime(struct rt_rq *rt_rq)
 
         weight = cpumask_weight(rd->span);
 
-        spin_lock(&rt_b->rt_runtime_lock);
+        raw_spin_lock(&rt_b->rt_runtime_lock);
         rt_period = ktime_to_ns(rt_b->rt_period);
         for_each_cpu(i, rd->span) {
                 struct rt_rq *iter = sched_rt_period_rt_rq(rt_b, i);
@@ -336,7 +342,7 @@ static int do_balance_runtime(struct rt_rq *rt_rq)
                 if (iter == rt_rq)
                         continue;
 
-                spin_lock(&iter->rt_runtime_lock);
+                raw_spin_lock(&iter->rt_runtime_lock);
                 /*
                  * Either all rqs have inf runtime and there's nothing to steal
                  * or __disable_runtime() below sets a specific rq to inf to
@@ -358,14 +364,14 @@ static int do_balance_runtime(struct rt_rq *rt_rq)
                         rt_rq->rt_runtime += diff;
                         more = 1;
                         if (rt_rq->rt_runtime == rt_period) {
-                                spin_unlock(&iter->rt_runtime_lock);
+                                raw_spin_unlock(&iter->rt_runtime_lock);
                                 break;
                         }
                 }
 next:
-                spin_unlock(&iter->rt_runtime_lock);
+                raw_spin_unlock(&iter->rt_runtime_lock);
         }
-        spin_unlock(&rt_b->rt_runtime_lock);
+        raw_spin_unlock(&rt_b->rt_runtime_lock);
 
         return more;
 }
@@ -386,8 +392,8 @@ static void __disable_runtime(struct rq *rq)
                 s64 want;
                 int i;
 
-                spin_lock(&rt_b->rt_runtime_lock);
-                spin_lock(&rt_rq->rt_runtime_lock);
+                raw_spin_lock(&rt_b->rt_runtime_lock);
+                raw_spin_lock(&rt_rq->rt_runtime_lock);
                 /*
                  * Either we're all inf and nobody needs to borrow, or we're
                  * already disabled and thus have nothing to do, or we have
@@ -396,7 +402,7 @@ static void __disable_runtime(struct rq *rq)
                 if (rt_rq->rt_runtime == RUNTIME_INF ||
                                 rt_rq->rt_runtime == rt_b->rt_runtime)
                         goto balanced;
-                spin_unlock(&rt_rq->rt_runtime_lock);
+                raw_spin_unlock(&rt_rq->rt_runtime_lock);
 
                 /*
                  * Calculate the difference between what we started out with
@@ -418,7 +424,7 @@ static void __disable_runtime(struct rq *rq)
                         if (iter == rt_rq || iter->rt_runtime == RUNTIME_INF)
                                 continue;
 
-                        spin_lock(&iter->rt_runtime_lock);
+                        raw_spin_lock(&iter->rt_runtime_lock);
                         if (want > 0) {
                                 diff = min_t(s64, iter->rt_runtime, want);
                                 iter->rt_runtime -= diff;
@@ -427,13 +433,13 @@ static void __disable_runtime(struct rq *rq)
                                 iter->rt_runtime -= want;
                                 want -= want;
                         }
-                        spin_unlock(&iter->rt_runtime_lock);
+                        raw_spin_unlock(&iter->rt_runtime_lock);
 
                         if (!want)
                                 break;
                 }
 
-                spin_lock(&rt_rq->rt_runtime_lock);
+                raw_spin_lock(&rt_rq->rt_runtime_lock);
                 /*
                  * We cannot be left wanting - that would mean some runtime
                  * leaked out of the system.
@@ -445,8 +451,8 @@ balanced:
                  * runtime - in which case borrowing doesn't make sense.
                  */
                 rt_rq->rt_runtime = RUNTIME_INF;
-                spin_unlock(&rt_rq->rt_runtime_lock);
-                spin_unlock(&rt_b->rt_runtime_lock);
+                raw_spin_unlock(&rt_rq->rt_runtime_lock);
+                raw_spin_unlock(&rt_b->rt_runtime_lock);
         }
 }
 
@@ -454,9 +460,9 @@ static void disable_runtime(struct rq *rq)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&rq->lock, flags);
+        raw_spin_lock_irqsave(&rq->lock, flags);
         __disable_runtime(rq);
-        spin_unlock_irqrestore(&rq->lock, flags);
+        raw_spin_unlock_irqrestore(&rq->lock, flags);
 }
 
 static void __enable_runtime(struct rq *rq)
@@ -472,13 +478,13 @@ static void __enable_runtime(struct rq *rq)
         for_each_leaf_rt_rq(rt_rq, rq) {
                 struct rt_bandwidth *rt_b = sched_rt_bandwidth(rt_rq);
 
-                spin_lock(&rt_b->rt_runtime_lock);
-                spin_lock(&rt_rq->rt_runtime_lock);
+                raw_spin_lock(&rt_b->rt_runtime_lock);
+                raw_spin_lock(&rt_rq->rt_runtime_lock);
                 rt_rq->rt_runtime = rt_b->rt_runtime;
                 rt_rq->rt_time = 0;
                 rt_rq->rt_throttled = 0;
-                spin_unlock(&rt_rq->rt_runtime_lock);
-                spin_unlock(&rt_b->rt_runtime_lock);
+                raw_spin_unlock(&rt_rq->rt_runtime_lock);
+                raw_spin_unlock(&rt_b->rt_runtime_lock);
         }
 }
 
@@ -486,9 +492,9 @@ static void enable_runtime(struct rq *rq)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&rq->lock, flags);
+        raw_spin_lock_irqsave(&rq->lock, flags);
         __enable_runtime(rq);
-        spin_unlock_irqrestore(&rq->lock, flags);
+        raw_spin_unlock_irqrestore(&rq->lock, flags);
 }
 
 static int balance_runtime(struct rt_rq *rt_rq)
@@ -496,9 +502,9 @@ static int balance_runtime(struct rt_rq *rt_rq)
         int more = 0;
 
         if (rt_rq->rt_time > rt_rq->rt_runtime) {
-                spin_unlock(&rt_rq->rt_runtime_lock);
+                raw_spin_unlock(&rt_rq->rt_runtime_lock);
                 more = do_balance_runtime(rt_rq);
-                spin_lock(&rt_rq->rt_runtime_lock);
+                raw_spin_lock(&rt_rq->rt_runtime_lock);
         }
 
         return more;
@@ -524,11 +530,11 @@ static int do_sched_rt_period_timer(struct rt_bandwidth *rt_b, int overrun)
                 struct rt_rq *rt_rq = sched_rt_period_rt_rq(rt_b, i);
                 struct rq *rq = rq_of_rt_rq(rt_rq);
 
-                spin_lock(&rq->lock);
+                raw_spin_lock(&rq->lock);
                 if (rt_rq->rt_time) {
                         u64 runtime;
 
-                        spin_lock(&rt_rq->rt_runtime_lock);
+                        raw_spin_lock(&rt_rq->rt_runtime_lock);
                         if (rt_rq->rt_throttled)
                                 balance_runtime(rt_rq);
                         runtime = rt_rq->rt_runtime;
@@ -539,13 +545,13 @@ static int do_sched_rt_period_timer(struct rt_bandwidth *rt_b, int overrun)
                         }
                         if (rt_rq->rt_time || rt_rq->rt_nr_running)
                                 idle = 0;
-                        spin_unlock(&rt_rq->rt_runtime_lock);
+                        raw_spin_unlock(&rt_rq->rt_runtime_lock);
                 } else if (rt_rq->rt_nr_running)
                         idle = 0;
 
                 if (enqueue)
                         sched_rt_rq_enqueue(rt_rq);
-                spin_unlock(&rq->lock);
+                raw_spin_unlock(&rq->lock);
         }
 
         return idle;
@@ -624,11 +630,11 @@ static void update_curr_rt(struct rq *rq)
                 rt_rq = rt_rq_of_se(rt_se);
 
                 if (sched_rt_runtime(rt_rq) != RUNTIME_INF) {
-                        spin_lock(&rt_rq->rt_runtime_lock);
+                        raw_spin_lock(&rt_rq->rt_runtime_lock);
                         rt_rq->rt_time += delta_exec;
                         if (sched_rt_runtime_exceeded(rt_rq))
                                 resched_task(curr);
-                        spin_unlock(&rt_rq->rt_runtime_lock);
+                        raw_spin_unlock(&rt_rq->rt_runtime_lock);
                 }
         }
 }
@@ -803,7 +809,7 @@ void dec_rt_tasks(struct sched_rt_entity *rt_se, struct rt_rq *rt_rq)
         dec_rt_group(rt_se, rt_rq);
 }
 
-static void __enqueue_rt_entity(struct sched_rt_entity *rt_se)
+static void __enqueue_rt_entity(struct sched_rt_entity *rt_se, bool head)
 {
         struct rt_rq *rt_rq = rt_rq_of_se(rt_se);
         struct rt_prio_array *array = &rt_rq->active;
@@ -819,7 +825,10 @@ static void __enqueue_rt_entity(struct sched_rt_entity *rt_se)
         if (group_rq && (rt_rq_throttled(group_rq) || !group_rq->rt_nr_running))
                 return;
 
-        list_add_tail(&rt_se->run_list, queue);
+        if (head)
+                list_add(&rt_se->run_list, queue);
+        else
+                list_add_tail(&rt_se->run_list, queue);
         __set_bit(rt_se_prio(rt_se), array->bitmap);
 
         inc_rt_tasks(rt_se, rt_rq);
@@ -856,11 +865,11 @@ static void dequeue_rt_stack(struct sched_rt_entity *rt_se)
         }
 }
 
-static void enqueue_rt_entity(struct sched_rt_entity *rt_se)
+static void enqueue_rt_entity(struct sched_rt_entity *rt_se, bool head)
 {
         dequeue_rt_stack(rt_se);
         for_each_sched_rt_entity(rt_se)
-                __enqueue_rt_entity(rt_se);
+                __enqueue_rt_entity(rt_se, head);
 }
 
 static void dequeue_rt_entity(struct sched_rt_entity *rt_se)
@@ -871,21 +880,22 @@ static void dequeue_rt_entity(struct sched_rt_entity *rt_se)
                 struct rt_rq *rt_rq = group_rt_rq(rt_se);
 
                 if (rt_rq && rt_rq->rt_nr_running)
-                        __enqueue_rt_entity(rt_se);
+                        __enqueue_rt_entity(rt_se, false);
         }
 }
 
 /*
  * Adding/removing a task to/from a priority array:
  */
-static void enqueue_task_rt(struct rq *rq, struct task_struct *p, int wakeup)
+static void
+enqueue_task_rt(struct rq *rq, struct task_struct *p, int wakeup, bool head)
 {
         struct sched_rt_entity *rt_se = &p->rt;
 
         if (wakeup)
                 rt_se->timeout = 0;
 
-        enqueue_rt_entity(rt_se);
+        enqueue_rt_entity(rt_se, head);
 
         if (!task_current(rq, p) && p->rt.nr_cpus_allowed > 1)
                 enqueue_pushable_task(rq, p);
@@ -1136,7 +1146,12 @@ static struct task_struct *pick_next_highest_task_rt(struct rq *rq, int cpu)
                 if (next && next->prio < idx)
                         continue;
                 list_for_each_entry(rt_se, array->queue + idx, run_list) {
-                        struct task_struct *p = rt_task_of(rt_se);
+                        struct task_struct *p;
+
+                        if (!rt_entity_is_task(rt_se))
+                                continue;
+
+                        p = rt_task_of(rt_se);
                         if (pick_rt_task(rq, p, cpu)) {
                                 next = p;
                                 break;
@@ -1153,29 +1168,12 @@ static struct task_struct *pick_next_highest_task_rt(struct rq *rq, int cpu)
 
 static DEFINE_PER_CPU(cpumask_var_t, local_cpu_mask);
 
-static inline int pick_optimal_cpu(int this_cpu,
-                                   const struct cpumask *mask)
-{
-        int first;
-
-        /* "this_cpu" is cheaper to preempt than a remote processor */
-        if ((this_cpu != -1) && cpumask_test_cpu(this_cpu, mask))
-                return this_cpu;
-
-        first = cpumask_first(mask);
-        if (first < nr_cpu_ids)
-                return first;
-
-        return -1;
-}
-
 static int find_lowest_rq(struct task_struct *task)
 {
         struct sched_domain *sd;
         struct cpumask *lowest_mask = __get_cpu_var(local_cpu_mask);
         int this_cpu = smp_processor_id();
         int cpu      = task_cpu(task);
-        cpumask_var_t domain_mask;
 
         if (task->rt.nr_cpus_allowed == 1)
                 return -1; /* No other targets possible */
@@ -1198,28 +1196,26 @@ static int find_lowest_rq(struct task_struct *task)
          * Otherwise, we consult the sched_domains span maps to figure
          * out which cpu is logically closest to our hot cache data.
          */
-        if (this_cpu == cpu)
-                this_cpu = -1; /* Skip this_cpu opt if the same */
-
-        if (alloc_cpumask_var(&domain_mask, GFP_ATOMIC)) {
-                for_each_domain(cpu, sd) {
-                        if (sd->flags & SD_WAKE_AFFINE) {
-                                int best_cpu;
-
-                                cpumask_and(domain_mask,
-                                            sched_domain_span(sd),
-                                            lowest_mask);
+        if (!cpumask_test_cpu(this_cpu, lowest_mask))
+                this_cpu = -1; /* Skip this_cpu opt if not among lowest */
 
-                                best_cpu = pick_optimal_cpu(this_cpu,
-                                                            domain_mask);
+        for_each_domain(cpu, sd) {
+                if (sd->flags & SD_WAKE_AFFINE) {
+                        int best_cpu;
 
-                                if (best_cpu != -1) {
-                                        free_cpumask_var(domain_mask);
-                                        return best_cpu;
-                                }
-                        }
+                        /*
+                         * "this_cpu" is cheaper to preempt than a
+                         * remote processor.
+                         */
+                        if (this_cpu != -1 &&
+                            cpumask_test_cpu(this_cpu, sched_domain_span(sd)))
+                                return this_cpu;
+
+                        best_cpu = cpumask_first_and(lowest_mask,
+                                                     sched_domain_span(sd));
+                        if (best_cpu < nr_cpu_ids)
+                                return best_cpu;
                 }
-                free_cpumask_var(domain_mask);
         }
 
         /*
@@ -1227,7 +1223,13 @@ static int find_lowest_rq(struct task_struct *task)
          * just give the caller *something* to work with from the compatible
          * locations.
          */
-        return pick_optimal_cpu(this_cpu, lowest_mask);
+        if (this_cpu != -1)
+                return this_cpu;
+
+        cpu = cpumask_any(lowest_mask);
+        if (cpu < nr_cpu_ids)
+                return cpu;
+        return -1;
 }
 
 /* Will lock the rq it finds */
@@ -1259,7 +1261,7 @@ static struct rq *find_lock_lowest_rq(struct task_struct *task, struct rq *rq)
                                      task_running(rq, task) ||
                                      !task->se.on_rq)) {
 
-                                spin_unlock(&lowest_rq->lock);
+                                raw_spin_unlock(&lowest_rq->lock);
                                 lowest_rq = NULL;
                                 break;
                         }
@@ -1485,7 +1487,7 @@ static void post_schedule_rt(struct rq *rq)
  * If we are not running and we are not going to reschedule soon, we should
  * try to push tasks away now
  */
-static void task_wake_up_rt(struct rq *rq, struct task_struct *p)
+static void task_woken_rt(struct rq *rq, struct task_struct *p)
 {
         if (!task_running(rq, p) &&
             !test_tsk_need_resched(rq->curr) &&
@@ -1494,24 +1496,6 @@ static void task_wake_up_rt(struct rq *rq, struct task_struct *p)
                 push_rt_tasks(rq);
 }
 
-static unsigned long
-load_balance_rt(struct rq *this_rq, int this_cpu, struct rq *busiest,
-                unsigned long max_load_move,
-                struct sched_domain *sd, enum cpu_idle_type idle,
-                int *all_pinned, int *this_best_prio)
-{
-        /* don't touch RT tasks */
-        return 0;
-}
-
-static int
-move_one_task_rt(struct rq *this_rq, int this_cpu, struct rq *busiest,
-                 struct sched_domain *sd, enum cpu_idle_type idle)
-{
-        /* don't touch RT tasks */
-        return 0;
-}
-
 static void set_cpus_allowed_rt(struct task_struct *p,
                                 const struct cpumask *new_mask)
 {
@@ -1683,8 +1667,9 @@ static void watchdog(struct rq *rq, struct task_struct *p)
         if (!p->signal)
                 return;
 
-        soft = p->signal->rlim[RLIMIT_RTTIME].rlim_cur;
-        hard = p->signal->rlim[RLIMIT_RTTIME].rlim_max;
+        /* max may change after cur was read, this will be fixed next tick */
+        soft = task_rlimit(p, RLIMIT_RTTIME);
+        hard = task_rlimit_max(p, RLIMIT_RTTIME);
 
         if (soft != RLIM_INFINITY) {
                 unsigned long next;
@@ -1734,7 +1719,7 @@ static void set_curr_task_rt(struct rq *rq)
         dequeue_pushable_task(rq, p);
 }
 
-unsigned int get_rr_interval_rt(struct task_struct *task)
+static unsigned int get_rr_interval_rt(struct rq *rq, struct task_struct *task)
 {
         /*
          * Time slice is 0 for SCHED_FIFO tasks
@@ -1759,14 +1744,12 @@ static const struct sched_class rt_sched_class = {
 #ifdef CONFIG_SMP
         .select_task_rq         = select_task_rq_rt,
 
-        .load_balance           = load_balance_rt,
-        .move_one_task          = move_one_task_rt,
         .set_cpus_allowed       = set_cpus_allowed_rt,
         .rq_online              = rq_online_rt,
         .rq_offline             = rq_offline_rt,
         .pre_schedule           = pre_schedule_rt,
         .post_schedule          = post_schedule_rt,
-        .task_wake_up           = task_wake_up_rt,
+        .task_woken             = task_woken_rt,
         .switched_from          = switched_from_rt,
 #endif