static void push_dl_tasks(struct rq *);
 static void pull_dl_task(struct rq *);
 
-static inline void queue_push_tasks(struct rq *rq)
+static inline void deadline_queue_push_tasks(struct rq *rq)
 {
        if (!has_pushable_dl_tasks(rq))
                return;
        queue_balance_callback(rq, &per_cpu(dl_push_head, rq->cpu), push_dl_tasks);
 }
 
-static inline void queue_pull_task(struct rq *rq)
+static inline void deadline_queue_pull_task(struct rq *rq)
 {
        queue_balance_callback(rq, &per_cpu(dl_pull_head, rq->cpu), pull_dl_task);
 }
 {
 }
 
-static inline void queue_push_tasks(struct rq *rq)
+static inline void deadline_queue_push_tasks(struct rq *rq)
 {
 }
 
-static inline void queue_pull_task(struct rq *rq)
+static inline void deadline_queue_pull_task(struct rq *rq)
 {
 }
 #endif /* CONFIG_SMP */
        if (hrtick_enabled(rq))
                start_hrtick_dl(rq, p);
 
-       queue_push_tasks(rq);
+       deadline_queue_push_tasks(rq);
 
        return p;
 }
        if (!task_on_rq_queued(p) || rq->dl.dl_nr_running)
                return;
 
-       queue_pull_task(rq);
+       deadline_queue_pull_task(rq);
 }
 
 /*
        if (rq->curr != p) {
 #ifdef CONFIG_SMP
                if (p->nr_cpus_allowed > 1 && rq->dl.overloaded)
-                       queue_push_tasks(rq);
+                       deadline_queue_push_tasks(rq);
 #endif
                if (dl_task(rq->curr))
                        check_preempt_curr_dl(rq, p, 0);
                 * or lowering its prio, so...
                 */
                if (!rq->dl.overloaded)
-                       queue_pull_task(rq);
+                       deadline_queue_pull_task(rq);
 
                /*
                 * If we now have a earlier deadline task than p,
 
 static void push_rt_tasks(struct rq *);
 static void pull_rt_task(struct rq *);
 
-static inline void queue_push_tasks(struct rq *rq)
+static inline void rt_queue_push_tasks(struct rq *rq)
 {
        if (!has_pushable_tasks(rq))
                return;
        queue_balance_callback(rq, &per_cpu(rt_push_head, rq->cpu), push_rt_tasks);
 }
 
-static inline void queue_pull_task(struct rq *rq)
+static inline void rt_queue_pull_task(struct rq *rq)
 {
        queue_balance_callback(rq, &per_cpu(rt_pull_head, rq->cpu), pull_rt_task);
 }
 {
 }
 
-static inline void queue_push_tasks(struct rq *rq)
+static inline void rt_queue_push_tasks(struct rq *rq)
 {
 }
 #endif /* CONFIG_SMP */
        /* The running task is never eligible for pushing */
        dequeue_pushable_task(rq, p);
 
-       queue_push_tasks(rq);
+       rt_queue_push_tasks(rq);
 
        return p;
 }
        if (!task_on_rq_queued(p) || rq->rt.rt_nr_running)
                return;
 
-       queue_pull_task(rq);
+       rt_queue_pull_task(rq);
 }
 
 void __init init_sched_rt_class(void)
        if (task_on_rq_queued(p) && rq->curr != p) {
 #ifdef CONFIG_SMP
                if (p->nr_cpus_allowed > 1 && rq->rt.overloaded)
-                       queue_push_tasks(rq);
+                       rt_queue_push_tasks(rq);
 #endif /* CONFIG_SMP */
                if (p->prio < rq->curr->prio && cpu_online(cpu_of(rq)))
                        resched_curr(rq);
                 * may need to pull tasks to this runqueue.
                 */
                if (oldprio < p->prio)
-                       queue_pull_task(rq);
+                       rt_queue_pull_task(rq);
 
                /*
                 * If there's a higher priority task waiting to run