1 files changed, 76 insertions, 75 deletions

diff --git a/litmus/prioq_lock.c b/litmus/prioq_lock.c
index faf8c15df542..142f56fe9099 100644
--- a/litmus/prioq_lock.c
+++ b/litmus/prioq_lock.c
@@ -165,12 +165,12 @@ static struct task_struct* __prioq_mutex_find_hp_waiter(struct prioq_mutex *mute
         wait_queue_t            *q;
         struct list_head        *pos;
         struct task_struct  *queued = NULL, *found = NULL;
-        
+
         /* list in sorted order.  higher-prio tasks likely at the front. */
         list_for_each(pos, &mutex->wait.task_list) {
                 q = list_entry(pos, wait_queue_t, task_list);
                 queued = get_queued_task(q);
-                
+
                 /* Compare task prios, find high prio task. */
                 if (queued &&
                         (queued != skip) &&
@@ -195,12 +195,12 @@ static int ___prioq_dgl_acquire_via_inheritance(struct prioq_mutex *mutex, struc
         struct litmus_lock *l;
         BUG_ON(mutex->owner != NULL);
         BUG_ON(list_empty(&mutex->wait.task_list));
-        
+
         l = &mutex->litmus_lock;
-        
+
         if (dgl_wait) {
                 BUG_ON(t != dgl_wait->task);
-                
+
                 /* we're a part of a DGL */
                 if(__attempt_atomic_dgl_acquire(NULL, dgl_wait)) {
                         TRACE_CUR("%s/%d cannot take entire DGL via inheritance.\n",
@@ -218,50 +218,50 @@ static int ___prioq_dgl_acquire_via_inheritance(struct prioq_mutex *mutex, struc
                 /* we're a regular singular request. we can always take the lock if
                  * there is no mutex owner. */
                 wait_queue_t *first;
-                
+
                 TRACE_CUR("%s/%d can take it's singular lock via inheritance!\n",
                                   t->comm, t->pid);
-                
+
                 first = list_entry(mutex->wait.task_list.next, wait_queue_t, task_list);
-                
+
                 BUG_ON(get_queued_task(first) != t);
-                
+
                 __remove_wait_queue(&mutex->wait, first); /* remove the blocked task */
-                
+
                 /* update/cleanup the state of the lock */
-                
+
                 mutex->owner = t; /* take ownership!!! */
-                
+
                 mutex->hp_waiter = __prioq_mutex_find_hp_waiter(mutex, t);
                 l->nest.hp_waiter_eff_prio = (mutex->hp_waiter) ?
                         effective_priority(mutex->hp_waiter) : NULL;
-                
+
                 if (mutex->hp_waiter)
                         TRACE_CUR("%s/%d is new highest-prio waiter\n",
                                           mutex->hp_waiter->comm, mutex->hp_waiter->pid);
                 else
                         TRACE_CUR("no further waiters\n");
-                
+
                 raw_spin_lock(&tsk_rt(t)->hp_blocked_tasks_lock);
-                
+
                 binheap_add(&l->nest.hp_binheap_node,
                                         &tsk_rt(t)->hp_blocked_tasks,
                                         struct nested_info, hp_binheap_node);
-                
+
                 raw_spin_unlock(&tsk_rt(t)->hp_blocked_tasks_lock);
         }
-        
+
         if (t) {
                 BUG_ON(mutex->owner != t);
-                
+
                 TRACE_CUR("%s/%d waking up since it is no longer blocked.\n", t->comm, t->pid);
-                
+
                 tsk_rt(t)->blocked_lock = NULL;
                 mb();
-                
+
                 wake_up_for_lock(t);
         }
-        
+
         return (t != NULL);
 }
 
@@ -276,7 +276,7 @@ static int __prioq_dgl_increase_pos(struct prioq_mutex *mutex, struct task_struc
 //      (1) Increase position for 't' for all locks it is waiting.
 //  (2) Check to see if 't' can take the lock, DGL or singular lock.
 //  (3) If it can, do so and wake up 't'.
-        
+
         struct list_head *pos;
         struct task_struct *new_head;
         struct task_struct *cur_head = NULL;
@@ -284,32 +284,32 @@ static int __prioq_dgl_increase_pos(struct prioq_mutex *mutex, struct task_struc
         int woke_up = 0;
         int found = 0;
 
-        
+
         BUG_ON(list_empty(&mutex->wait.task_list));
-        
+
         /* note the task at the head of the queue */
         if(mutex->owner == NULL) {
                 cur_head = get_head_task(mutex);
         }
-        
+
         list_for_each(pos, &mutex->wait.task_list) {
                 dgl_wait_state_t *temp_dgl_state;
                 wait_queue_t *q = list_entry(pos, wait_queue_t, task_list);
                 struct task_struct *queued = get_queued_task_and_dgl_wait(q, &temp_dgl_state);
-                        
+
                 if (queued == t) {
-                        
+
                         TRACE_CUR("found %s/%d in prioq of lock %d\n",
                                           t->comm, t->pid,
                                           mutex->litmus_lock.ident);
-                        
+
                         if(temp_dgl_state) { /* it's a DGL request */
                                 int i;
                                 dgl_wait = temp_dgl_state;
-                                
+
                                 TRACE_CUR("found request for %s/%d is a DGL request of size %d.\n",
                                                   t->comm, t->pid, dgl_wait->size);
-                                
+
                                 // reposition on the other mutexes
                                 for(i = 0; i < dgl_wait->size; ++i) {
                                         // assume they're all PRIOQ_MUTEX
@@ -318,7 +318,7 @@ static int __prioq_dgl_increase_pos(struct prioq_mutex *mutex, struct task_struc
                                                 __prioq_increase_pos(pm, t);
                                 }
                         }
-                        
+
                         // reposition on this mutex
                         __remove_wait_queue(&mutex->wait, q);
                         __add_wait_queue_sorted(&mutex->wait, q);
@@ -326,24 +326,24 @@ static int __prioq_dgl_increase_pos(struct prioq_mutex *mutex, struct task_struc
                         break;
                 }
         }
-        
+
         BUG_ON(!found);
-        
+
         if (mutex->owner == NULL) {
                 /* who is the new head? */
                 new_head = get_head_task(mutex);
-        
+
                 /* is the prioq mutex idle? */
                 if(cur_head != new_head) {
                         /* the new head might be able to take the lock */
-                
+
                         BUG_ON(new_head != t); /* the new head must be this task since our prio increased */
-                
+
                         TRACE_CUR("Change in prioq head on idle prioq mutex %d: old = %s/%d new = %s/%d\n",
                                           mutex->litmus_lock.ident,
                                           cur_head->comm, cur_head->pid,
                                           new_head->comm, new_head->pid);
-                        
+
                         woke_up = ___prioq_dgl_acquire_via_inheritance(mutex, t, dgl_wait);
                 }
         }
@@ -358,9 +358,9 @@ static int ___prioq_dgl_decrease_pos_and_check_acquire(struct prioq_mutex *mutex
         struct task_struct *cur_head = NULL;
         int woke_up = 0;
         int found = 1;
-        
+
         BUG_ON(list_empty(&mutex->wait.task_list));
-        
+
         /* find the position of t in mutex's wait q if it's not provided */
         if (q == NULL) {
                 found = 0;
@@ -375,21 +375,21 @@ static int ___prioq_dgl_decrease_pos_and_check_acquire(struct prioq_mutex *mutex
 
         BUG_ON(!q);
         BUG_ON(!found);
-        
+
         if(mutex->owner == NULL) {
                 cur_head = get_head_task(mutex);
         }
-        
+
         // update the position
         __remove_wait_queue(&mutex->wait, q);
         __add_wait_queue_sorted(&mutex->wait, q);
-        
+
         if(mutex->owner == NULL) {
                 // get a reference to dgl_wait of the new head is a DGL request
                 dgl_wait_state_t *dgl_wait;
                 q = list_entry(mutex->wait.task_list.next, wait_queue_t, task_list);
                 new_head = get_queued_task_and_dgl_wait(q, &dgl_wait);
-                
+
                 /* is the prioq mutex idle and did the head change? */
                 if(cur_head != new_head) {
                         /* the new head might be able to take the lock */
@@ -397,7 +397,7 @@ static int ___prioq_dgl_decrease_pos_and_check_acquire(struct prioq_mutex *mutex
                                           mutex->litmus_lock.ident,
                                           cur_head->comm, cur_head->pid,
                                           new_head->comm, new_head->pid);
-                        
+
                         woke_up = ___prioq_dgl_acquire_via_inheritance(mutex, new_head, dgl_wait);
                 }
         }
@@ -410,28 +410,28 @@ static void __prioq_dgl_decrease_pos(struct prioq_mutex *mutex, struct task_stru
 //  (2) For every lock upon which 't' was the head AND that lock is idle:
 //  (3)    Can the new head take the lock?
 //  (4)    If it can, do so and wake up the new head.
-        
+
         struct list_head        *pos;
-        
+
         BUG_ON(list_empty(&mutex->wait.task_list));
-        
+
         list_for_each(pos, &mutex->wait.task_list) {
                 dgl_wait_state_t *dgl_wait;
                 wait_queue_t *q = list_entry(pos, wait_queue_t, task_list);
                 struct task_struct *queued = get_queued_task_and_dgl_wait(q, &dgl_wait);
-                
+
                 if (queued == t) {
                         TRACE_CUR("found %s/%d in prioq of lock %d\n",
                                           t->comm, t->pid,
-                                          mutex->litmus_lock.ident);                    
-                        
+                                          mutex->litmus_lock.ident);
+
                         if (dgl_wait) {
                                 // reposition on all mutexes and check for wakeup
                                 int i;
-                                
+
                                 TRACE_CUR("found request for %s/%d is a DGL request of size %d.\n",
                                                   t->comm, t->pid, dgl_wait->size);
-                                
+
                                 for(i = 0; i < dgl_wait->size; ++i) {
                                         // assume they're all PRIOQ_MUTEX
                                         struct prioq_mutex *pm = (struct prioq_mutex *) dgl_wait->locks[i];
@@ -442,12 +442,12 @@ static void __prioq_dgl_decrease_pos(struct prioq_mutex *mutex, struct task_stru
                                 }
                         }
                         else {
-                                ___prioq_dgl_decrease_pos_and_check_acquire(mutex, t, q);                               
+                                ___prioq_dgl_decrease_pos_and_check_acquire(mutex, t, q);
                         }
                         return;
                 }
         }
-        
+
         BUG();
 }
 
@@ -481,7 +481,7 @@ int prioq_mutex_dgl_lock(struct litmus_lock *l, dgl_wait_state_t* dgl_wait,
 
         init_dgl_waitqueue_entry(wq_node, dgl_wait);
 
-        set_task_state(t, TASK_UNINTERRUPTIBLE);
+        //set_task_state(t, TASK_UNINTERRUPTIBLE); /* done in do_litmus_dgl_atomic_lock() only if needed */
         __add_wait_queue_sorted_exclusive(&mutex->wait, wq_node);
 
         return acquired_immediatly;
@@ -494,7 +494,8 @@ void prioq_mutex_enable_priority(struct litmus_lock *l,
         struct prioq_mutex *mutex = prioq_mutex_from_lock(l);
         struct task_struct *t = dgl_wait->task;
         struct task_struct *owner = mutex->owner;
-        unsigned long flags = 0;  // these are unused under DGL coarse-grain locking
+        unsigned long flags;
+        local_save_flags(flags);  // needed for coarse-grain DGLs?
 
         /**************************************
         * This code looks like it supports fine-grain locking, but it does not!
@@ -597,7 +598,7 @@ static void select_next_lock_if_primary(struct litmus_lock *l,
                                 effective_priority(mutex->hp_waiter) :
                                 NULL;
 
-                        
+
                         if (mutex->hp_waiter)
                                 TRACE_CUR("%s/%d is new highest-prio waiter\n",
                                                   mutex->hp_waiter->comm, mutex->hp_waiter->pid);
@@ -822,30 +823,32 @@ int prioq_mutex_lock(struct litmus_lock* l)
 }
 
 
-
 int prioq_mutex_unlock(struct litmus_lock* l)
 {
+        int err = 0;
         struct task_struct *t = current, *next = NULL;
+        struct task_struct *old_max_eff_prio;
         struct prioq_mutex *mutex = prioq_mutex_from_lock(l);
         unsigned long flags;
 
-        struct task_struct *old_max_eff_prio;
-
 #ifdef CONFIG_LITMUS_DGL_SUPPORT
+        raw_spinlock_t *dgl_lock;
         dgl_wait_state_t *dgl_wait = NULL;
-        raw_spinlock_t *dgl_lock = litmus->get_dgl_spinlock(t);
 #endif
 
-        int err = 0;
-
         if (mutex->owner != t) {
                 err = -EINVAL;
                 return err;
         }
 
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+        dgl_lock = litmus->get_dgl_spinlock(current);
+#endif
+
         lock_global_irqsave(dgl_lock, flags);
         lock_fine_irqsave(&mutex->lock, flags);
 
+
         raw_spin_lock(&tsk_rt(t)->hp_blocked_tasks_lock);
 
         TRACE_TASK(t, "Freeing lock %d\n", l->ident);
@@ -855,13 +858,13 @@ int prioq_mutex_unlock(struct litmus_lock* l)
 
         if(tsk_rt(t)->inh_task){
                 struct task_struct *new_max_eff_prio =
-                        top_priority(&tsk_rt(t)->hp_blocked_tasks);
+                top_priority(&tsk_rt(t)->hp_blocked_tasks);
 
                 if((new_max_eff_prio == NULL) ||
-                          /* there was a change in eff prio */
+                   /* there was a change in eff prio */
                    (  (new_max_eff_prio != old_max_eff_prio) &&
                         /* and owner had the old eff prio */
-                          (effective_priority(t) == old_max_eff_prio))  )
+                        (effective_priority(t) == old_max_eff_prio))  )
                 {
                         // old_max_eff_prio > new_max_eff_prio
 
@@ -888,8 +891,6 @@ int prioq_mutex_unlock(struct litmus_lock* l)
         raw_spin_unlock(&tsk_rt(t)->hp_blocked_tasks_lock);
 
 
-
-
         mutex->owner = NULL;
 
 #ifdef CONFIG_LITMUS_DGL_SUPPORT
@@ -900,11 +901,11 @@ int prioq_mutex_unlock(struct litmus_lock* l)
                  */
                 wait_queue_t *q = list_entry(mutex->wait.task_list.next, wait_queue_t, task_list);
                 get_queued_task_and_dgl_wait(q, &dgl_wait);
-                
+
                 if (dgl_wait) {
                         TRACE_CUR("Checking to see if DGL waiter %s/%d can take its locks\n",
                                           dgl_wait->task->comm, dgl_wait->task->pid);
-                        
+
                         if(__attempt_atomic_dgl_acquire(l, dgl_wait)) {
                                 /* failed. can't take this lock yet. we remain at head of prioq
                                  * allow hp requests in the future to go ahead of us. */
@@ -919,7 +920,7 @@ int prioq_mutex_unlock(struct litmus_lock* l)
 
                 /* remove the first */
                 next = __waitqueue_dgl_remove_first(&mutex->wait, &dgl_wait);
-                
+
                 BUG_ON(dgl_wait && (next != dgl_wait->task));
         }
 #else
@@ -935,7 +936,7 @@ int prioq_mutex_unlock(struct litmus_lock* l)
                 if (next == mutex->hp_waiter) {
 
                         TRACE_CUR("%s/%d was highest-prio waiter\n", next->comm, next->pid);
-                        
+
                         /* next has the highest priority --- it doesn't need to
                          * inherit.  However, we need to make sure that the
                          * next-highest priority in the queue is reflected in
@@ -945,13 +946,13 @@ int prioq_mutex_unlock(struct litmus_lock* l)
                                 effective_priority(mutex->hp_waiter) :
                                 NULL;
 
-                        
+
                         if (mutex->hp_waiter)
                                 TRACE_CUR("%s/%d is new highest-prio waiter\n",
                                                   mutex->hp_waiter->comm, mutex->hp_waiter->pid);
                         else
                                 TRACE_CUR("no further waiters\n");
-                        
+
 
                         raw_spin_lock(&tsk_rt(next)->hp_blocked_tasks_lock);
 
@@ -1019,8 +1020,8 @@ int prioq_mutex_unlock(struct litmus_lock* l)
 #ifdef CONFIG_LITMUS_DGL_SUPPORT
 out:
 #endif
-        unlock_global_irqrestore(dgl_lock, flags);
 
+        unlock_global_irqrestore(dgl_lock, flags);
         TRACE_TASK(t, "-- Freed lock %d --\n", l->ident);
 
         return err;