1 files changed, 17 insertions, 39 deletions

diff --git a/litmus/fifo_lock.c b/litmus/fifo_lock.c
index be49cd3a58d2..cc3e1ab5a965 100644
--- a/litmus/fifo_lock.c
+++ b/litmus/fifo_lock.c
@@ -7,8 +7,6 @@
 
 #include <litmus/litmus_proc.h>
 
-//#include <litmus/edf_common.h>
-
 #if defined(CONFIG_LITMUS_AFFINITY_LOCKING) && defined(CONFIG_LITMUS_NVIDIA)
 #include <litmus/gpu_affinity.h>
 #endif
@@ -22,33 +20,16 @@ static struct task_struct* fifo_mutex_find_hp_waiter(struct fifo_mutex *mutex,
         struct list_head        *pos;
         struct task_struct  *queued = NULL, *found = NULL;
 
-#ifdef CONFIG_LITMUS_DGL_SUPPORT
-        dgl_wait_state_t        *dgl_wait = NULL;
-#endif
-
         list_for_each(pos, &mutex->wait.task_list) {
                 q = list_entry(pos, wait_queue_t, task_list);
 
-#ifdef CONFIG_LITMUS_DGL_SUPPORT
-                if(q->func == dgl_wake_up) {
-                        dgl_wait = (dgl_wait_state_t*) q->private;
-                        if(tsk_rt(dgl_wait->task)->blocked_lock == &mutex->litmus_lock) {
-                                queued = dgl_wait->task;
-                        }
-                        else {
-                                queued = NULL;  // skip it.
-                        }
-                }
-                else {
-                        queued = (struct task_struct*) q->private;
-                }
-#else
-                queued = (struct task_struct*) q->private;
-#endif
+                queued = get_queued_task(q);
 
                 /* Compare task prios, find high prio task. */
-                //if (queued && queued != skip && edf_higher_prio(queued, found)) {
-                if (queued && queued != skip && litmus->compare(queued, found)) {
+                if (queued &&
+                        (queued != skip) &&
+                        (tsk_rt(queued)->blocked_lock == &mutex->litmus_lock) &&
+                        litmus->compare(queued, found)) {
                         found = queued;
                 }
         }
@@ -64,6 +45,12 @@ int fifo_mutex_is_owner(struct litmus_lock *l, struct task_struct *t)
         return(mutex->owner == t);
 }
 
+struct task_struct* fifo_mutex_get_owner(struct litmus_lock *l)
+{
+        struct fifo_mutex *mutex = fifo_mutex_from_lock(l);
+        return(mutex->owner);
+}
+
 // return 1 if resource was immediatly acquired.
 // Assumes mutex->lock is held.
 // Must set task state to TASK_UNINTERRUPTIBLE if task blocks.
@@ -110,12 +97,16 @@ void fifo_mutex_enable_priority(struct litmus_lock *l,
         struct task_struct *owner = mutex->owner;
         unsigned long flags = 0;  // these are unused under DGL coarse-grain locking
 
+        /**************************************
+         * This code looks like it supports fine-grain locking, but it does not!
+         * TODO: Gaurantee that mutex->lock is held by the caller to support fine-grain locking.
+         **************************************/
+
         BUG_ON(owner == t);
 
         tsk_rt(t)->blocked_lock = l;
         mb();
 
-        //if (edf_higher_prio(t, mutex->hp_waiter)) {
         if (litmus->compare(t, mutex->hp_waiter)) {
 
                 struct task_struct *old_max_eff_prio;
@@ -141,7 +132,6 @@ void fifo_mutex_enable_priority(struct litmus_lock *l,
                         TRACE_TASK(t, "is new hp_waiter.\n");
 
                         if ((effective_priority(owner) == old_max_eff_prio) ||
-                                //(__edf_higher_prio(new_max_eff_prio, BASE, owner, EFFECTIVE))){
                                 (litmus->__compare(new_max_eff_prio, BASE, owner, EFFECTIVE))){
                                 new_prio = new_max_eff_prio;
                         }
@@ -234,7 +224,6 @@ int fifo_mutex_lock(struct litmus_lock* l)
                 __add_wait_queue_tail_exclusive(&mutex->wait, &wait);
 
                 /* check if we need to activate priority inheritance */
-                //if (edf_higher_prio(t, mutex->hp_waiter)) {
                 if (litmus->compare(t, mutex->hp_waiter)) {
 
                         struct task_struct *old_max_eff_prio;
@@ -260,7 +249,6 @@ int fifo_mutex_lock(struct litmus_lock* l)
                                 TRACE_TASK(t, "is new hp_waiter.\n");
 
                                 if ((effective_priority(owner) == old_max_eff_prio) ||
-                                        //(__edf_higher_prio(new_max_eff_prio, BASE, owner, EFFECTIVE))){
                                         (litmus->__compare(new_max_eff_prio, BASE, owner, EFFECTIVE))){
                                         new_prio = new_max_eff_prio;
                                 }
@@ -368,8 +356,6 @@ int fifo_mutex_unlock(struct litmus_lock* l)
                           (effective_priority(t) == old_max_eff_prio))  )
                 {
                         // old_max_eff_prio > new_max_eff_prio
-
-                        //if(__edf_higher_prio(new_max_eff_prio, BASE, t, EFFECTIVE)) {
                         if(litmus->__compare(new_max_eff_prio, BASE, t, EFFECTIVE)) {
                                 TRACE_TASK(t, "new_max_eff_prio > task's eff_prio-- new_max_eff_prio: %s/%d   task: %s/%d [%s/%d]\n",
                                                    new_max_eff_prio->comm, new_max_eff_prio->pid,
@@ -395,10 +381,7 @@ int fifo_mutex_unlock(struct litmus_lock* l)
 
         /* check if there are jobs waiting for this resource */
 #ifdef CONFIG_LITMUS_DGL_SUPPORT
-        __waitqueue_dgl_remove_first(&mutex->wait, &dgl_wait, &next);
-        if(dgl_wait) {
-                next = dgl_wait->task;
-        }
+        next = __waitqueue_dgl_remove_first(&mutex->wait, &dgl_wait);
 #else
         next = __waitqueue_remove_first(&mutex->wait);
 #endif
@@ -434,7 +417,6 @@ int fifo_mutex_unlock(struct litmus_lock* l)
 #ifdef CONFIG_LITMUS_DGL_SUPPORT
                         if(dgl_wait) {
                                 select_next_lock_if_primary(l, dgl_wait);
-                                //wake_up_task = atomic_dec_and_test(&dgl_wait->nr_remaining);
                                 --(dgl_wait->nr_remaining);
                                 wake_up_task = (dgl_wait->nr_remaining == 0);
                         }
@@ -476,7 +458,6 @@ int fifo_mutex_unlock(struct litmus_lock* l)
                         {
                                 if(dgl_wait && tsk_rt(next)->blocked_lock) {
                                         BUG_ON(wake_up_task);
-                                        //if(__edf_higher_prio(l->nest.hp_waiter_eff_prio, BASE, next, EFFECTIVE)) {
                                         if(litmus->__compare(l->nest.hp_waiter_eff_prio, BASE, next, EFFECTIVE)) {
                                                 litmus->nested_increase_prio(next,
                                                         l->nest.hp_waiter_eff_prio, &mutex->lock, flags);  // unlocks lock && hp_blocked_tasks_lock.
@@ -557,7 +538,6 @@ void fifo_mutex_propagate_increase_inheritance(struct litmus_lock* l,
 
                 old_max_eff_prio = top_priority(&tsk_rt(owner)->hp_blocked_tasks);
 
-                //if((t != mutex->hp_waiter) && edf_higher_prio(t, mutex->hp_waiter)) {
                 if((t != mutex->hp_waiter) && litmus->compare(t, mutex->hp_waiter)) {
                         TRACE_TASK(t, "is new highest-prio waiter by propagation.\n");
                         mutex->hp_waiter = t;
@@ -580,7 +560,6 @@ void fifo_mutex_propagate_increase_inheritance(struct litmus_lock* l,
                 if(new_max_eff_prio != old_max_eff_prio) {
                         // new_max_eff_prio > old_max_eff_prio holds.
                         if ((effective_priority(owner) == old_max_eff_prio) ||
-                                //(__edf_higher_prio(new_max_eff_prio, BASE, owner, EFFECTIVE))) {
                                 (litmus->__compare(new_max_eff_prio, BASE, owner, EFFECTIVE))) {
                                 TRACE_CUR("Propagating inheritance to holder of lock %d.\n",
                                                   l->ident);
@@ -675,7 +654,6 @@ void fifo_mutex_propagate_decrease_inheritance(struct litmus_lock* l,
                                 TRACE_CUR("Propagating decreased inheritance to holder of lock %d.\n",
                                                   l->ident);
 
-                                //if(__edf_higher_prio(new_max_eff_prio, BASE, owner, BASE)) {
                                 if(litmus->__compare(new_max_eff_prio, BASE, owner, BASE)) {
                                         TRACE_CUR("%s/%d has greater base priority than base priority of owner (%s/%d) of lock %d.\n",
                                                           (new_max_eff_prio) ? new_max_eff_prio->comm : "null",