2 files changed, 11 insertions, 15 deletions

diff --git a/litmus/fp_common.c b/litmus/fp_common.c
index 7898955fd991..8536da9ca98a 100644
--- a/litmus/fp_common.c
+++ b/litmus/fp_common.c
@@ -66,13 +66,9 @@ int fp_higher_prio(struct task_struct* first,
 
         return !is_realtime(second_task)  ||
 
-                /* is the deadline of the first task earlier?
-                 * Then it has higher priority.
-                 */
                 get_priority(first_task) < get_priority(second_task) ||
 
-                /* Do we have a deadline tie?
-                 * Then break by PID.
+                /* Break by PID.
                  */
                 (get_priority(first_task) == get_priority(second_task) &&
                 (first_task->pid < second_task->pid ||
@@ -97,18 +93,19 @@ void fp_domain_init(rt_domain_t* rt, check_resched_needed_t resched,
 
 /* need_to_preempt - check whether the task t needs to be preempted
  */
-int fp_preemption_needed(rt_domain_t* rt, struct task_struct *t)
+int fp_preemption_needed(struct fp_prio_queue *q, struct task_struct *t)
 {
-        /* we need the read lock for edf_ready_queue */
-        /* no need to preempt if there is nothing pending */
-        if (!__jobs_pending(rt))
+        struct task_struct *pending;
+
+        pending = fp_prio_peek(q);
+
+        if (!pending)
                 return 0;
-        /* we need to reschedule if t doesn't exist */
         if (!t)
                 return 1;
 
         /* make sure to get non-rt stuff out of the way */
-        return !is_realtime(t) || fp_higher_prio(__next_ready(rt), t);
+        return !is_realtime(t) || fp_higher_prio(pending, t);
 }
 
 void fp_prio_queue_init(struct fp_prio_queue* q)
diff --git a/litmus/sched_pfp.c b/litmus/sched_pfp.c
index 926c391e7c34..cd9c08c236e8 100644
--- a/litmus/sched_pfp.c
+++ b/litmus/sched_pfp.c
@@ -138,7 +138,6 @@ static void pfp_tick(struct task_struct *t)
 static struct task_struct* pfp_schedule(struct task_struct * prev)
 {
         pfp_domain_t*   pfp = local_pfp;
-        rt_domain_t*            dom  = &pfp->domain;
         struct task_struct*     next;
 
         int                     out_of_time, sleep, preempt,
@@ -161,7 +160,7 @@ static struct task_struct* pfp_schedule(struct task_struct * prev)
                                   budget_exhausted(pfp->scheduled);
         np          = exists && is_np(pfp->scheduled);
         sleep       = exists && get_rt_flags(pfp->scheduled) == RT_F_SLEEP;
-        preempt     = fp_preemption_needed(dom, prev);
+        preempt     = fp_preemption_needed(&pfp->ready_queue, prev);
 
         /* If we need to preempt do so.
          * The following checks set resched to 1 in case of special
@@ -347,7 +346,7 @@ static void boost_priority(struct task_struct* t)
                     /* If it is queued, then we need to re-order. */
                     bheap_decrease(fp_ready_order, tsk_rt(t)->heap_node) &&
                     /* If we bubbled to the top, then we need to check for preemptions. */
-                    fp_preemption_needed(&pfp->domain, pfp->scheduled))
+                    fp_preemption_needed(&pfp->ready_queue, pfp->scheduled))
                                 preempt(pfp);
                 raw_spin_unlock(&pfp->domain.release_lock);
         } /* else: nothing to do since the job is not queued while scheduled */
@@ -376,7 +375,7 @@ static void unboost_priority(struct task_struct* t)
         tsk_rt(t)->boost_start_time = 0;
 
         /* check if this changes anything */
-        if (fp_preemption_needed(&pfp->domain, pfp->scheduled))
+        if (fp_preemption_needed(&pfp->ready_queue, pfp->scheduled))
                 preempt(pfp);
 
         raw_spin_unlock_irqrestore(&pfp->slock, flags);