1 files changed, 9 insertions, 9 deletions

diff --git a/kernel/sched/deadline.c b/kernel/sched/deadline.c
index fc4f98b1258f..255ce138b652 100644
--- a/kernel/sched/deadline.c
+++ b/kernel/sched/deadline.c
@@ -306,7 +306,7 @@ static inline void setup_new_dl_entity(struct sched_dl_entity *dl_se,
  * the overrunning entity can't interfere with other entity in the system and
  * can't make them miss their deadlines. Reasons why this kind of overruns
  * could happen are, typically, a entity voluntarily trying to overcome its
- * runtime, or it just underestimated it during sched_setscheduler_ex().
+ * runtime, or it just underestimated it during sched_setattr().
  */
 static void replenish_dl_entity(struct sched_dl_entity *dl_se,
                                 struct sched_dl_entity *pi_se)
@@ -535,7 +535,7 @@ again:
                 if (task_has_dl_policy(rq->curr))
                         check_preempt_curr_dl(rq, p, 0);
                 else
-                        resched_task(rq->curr);
+                        resched_curr(rq);
 #ifdef CONFIG_SMP
                 /*
                  * Queueing this task back might have overloaded rq,
@@ -634,7 +634,7 @@ static void update_curr_dl(struct rq *rq)
                         enqueue_task_dl(rq, curr, ENQUEUE_REPLENISH);
 
                 if (!is_leftmost(curr, &rq->dl))
-                        resched_task(curr);
+                        resched_curr(rq);
         }
 
         /*
@@ -964,7 +964,7 @@ static void check_preempt_equal_dl(struct rq *rq, struct task_struct *p)
             cpudl_find(&rq->rd->cpudl, p, NULL) != -1)
                 return;
 
-        resched_task(rq->curr);
+        resched_curr(rq);
 }
 
 static int pull_dl_task(struct rq *this_rq);
@@ -979,7 +979,7 @@ static void check_preempt_curr_dl(struct rq *rq, struct task_struct *p,
                                   int flags)
 {
         if (dl_entity_preempt(&p->dl, &rq->curr->dl)) {
-                resched_task(rq->curr);
+                resched_curr(rq);
                 return;
         }
 
@@ -1333,7 +1333,7 @@ retry:
         if (dl_task(rq->curr) &&
             dl_time_before(next_task->dl.deadline, rq->curr->dl.deadline) &&
             rq->curr->nr_cpus_allowed > 1) {
-                resched_task(rq->curr);
+                resched_curr(rq);
                 return 0;
         }
 
@@ -1373,7 +1373,7 @@ retry:
         set_task_cpu(next_task, later_rq->cpu);
         activate_task(later_rq, next_task, 0);
 
-        resched_task(later_rq->curr);
+        resched_curr(later_rq);
 
         double_unlock_balance(rq, later_rq);
 
@@ -1632,14 +1632,14 @@ static void prio_changed_dl(struct rq *rq, struct task_struct *p,
                  */
                 if (dl_time_before(rq->dl.earliest_dl.curr, p->dl.deadline) &&
                     rq->curr == p)
-                        resched_task(p);
+                        resched_curr(rq);
 #else
                 /*
                  * Again, we don't know if p has a earlier
                  * or later deadline, so let's blindly set a
                  * (maybe not needed) rescheduling point.
                  */
-                resched_task(p);
+                resched_curr(rq);
 #endif /* CONFIG_SMP */
         } else
                 switched_to_dl(rq, p);