1 files changed, 378 insertions, 82 deletions

diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index 3d653bdca357..c0316c4a1b35 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -120,6 +120,9 @@ static struct binheap_handle gsnedf_cpu_heap;
 static rt_domain_t gsnedf;
 #define gsnedf_lock (gsnedf.ready_lock)
 
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+static raw_spinlock_t dgl_lock;
+#endif
 
 /* Uncomment this if you want to see all scheduling decisions in the
  * TRACE() log.
@@ -835,6 +838,43 @@ void print_hp_waiters(struct binheap_node* n, int depth)
     if(n->right) print_hp_waiters(n->right, depth+1);
 }
 
+void dump_node_data(struct binheap_node* parent, struct binheap_node* child)
+{
+        struct binheap_node *root = (parent != BINHEAP_POISON) ? parent : child;
+        struct binheap_node *bad_node = (parent == BINHEAP_POISON) ? parent : child;
+        struct nested_info *nest;
+        
+        while(root->parent != NULL) {
+                root = root->parent;
+        }
+        
+        if(parent == BINHEAP_POISON) {
+                TRACE_CUR("parent was bad node.\n");
+        }
+        else {
+                TRACE_CUR("child was bad node.\n");
+        }
+        TRACE_CUR("Bad node info: data = %p, left = %p, right = %p\n", bad_node->data, bad_node->left, bad_node->right);
+        
+        nest = binheap_entry(bad_node, struct nested_info, hp_binheap_node);
+        TRACE_CUR("Lock with bad node: lock = %d\n", (nest->lock) ? nest->lock->ident : -1);
+        
+        print_hp_waiters(root, 1);
+}
+
+void dump_node_data2(struct binheap_handle *handle, struct binheap_node* bad_node)
+{
+        struct binheap_node *root = handle->root;
+        struct nested_info *nest;
+
+        TRACE_CUR("Bad node info: data = %p, left = %p, right = %p\n", bad_node->data, bad_node->left, bad_node->right);
+        
+        nest = binheap_entry(bad_node, struct nested_info, hp_binheap_node);
+        TRACE_CUR("Lock with bad node: lock = %d\n", (nest->lock) ? nest->lock->ident : -1);
+        
+        print_hp_waiters(root, 1);
+}
+
 
 /* called with IRQs off */
 /* preconditions:
@@ -861,12 +901,12 @@ static void nested_increase_priority_inheritance(struct task_struct* t, struct t
                 }
                 else {
                         TRACE_TASK(t, "Inheritor is blocked on lock (%d) that does not support nesting!\n", blocked_lock->ident);
-                        raw_spin_unlock_irqrestore(to_unlock, irqflags);
+                        unlock_fine_irqrestore(to_unlock, irqflags);
                 }
         }
         else {
                 TRACE_TASK(t, "is not blocked.  No propagation.\n");
-                raw_spin_unlock_irqrestore(to_unlock, irqflags);
+                unlock_fine_irqrestore(to_unlock, irqflags);
         }
 }
 
@@ -891,12 +931,12 @@ static void nested_decrease_priority_inheritance(struct task_struct* t, struct t
                 }       
                 else {
                         TRACE_TASK(t, "Inheritor is blocked on lock (%p) that does not support nesting!\n", blocked_lock);
-                        raw_spin_unlock_irqrestore(to_unlock, irqflags);
+                        unlock_fine_irqrestore(to_unlock, irqflags);
                 }
         }
         else {
                 TRACE_TASK(t, "is not blocked.  No propagation.\n");
-                raw_spin_unlock_irqrestore(to_unlock, irqflags);
+                unlock_fine_irqrestore(to_unlock, irqflags);
         }
 }
 
@@ -930,16 +970,38 @@ static inline struct rsm_mutex* rsm_mutex_from_lock(struct litmus_lock* lock)
 struct task_struct* rsm_mutex_find_hp_waiter(struct rsm_mutex *mutex,
                                              struct task_struct* skip)
 {
+        wait_queue_t            *q;
         struct list_head        *pos;
-        struct task_struct      *queued, *found = NULL;
+        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) {
-                queued  = (struct task_struct*) list_entry(pos, wait_queue_t,
-                                                   task_list)->private;
+                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
         
                 /* Compare task prios, find high prio task. */
-                if (queued != skip && edf_higher_prio(queued, found))
+                if (queued && queued != skip && edf_higher_prio(queued, found)) {
                         found = queued;
+                }
         }
         return found;
 }
@@ -951,6 +1013,136 @@ static inline struct task_struct* top_priority(struct binheap_handle* handle) {
         return NULL;
 }
 
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+//static void gsnedf_rsm_mutex_reserve(struct litmus_lock *l, unsigned long *irqflags)
+//{
+//      struct rsm_mutex *mutex = rsm_mutex_from_lock(l);
+//      raw_spin_lock_irqsave(&mutex->lock, *irqflags);
+//}
+//
+//static void gsnedf_rsm_mutex_unreserve(struct litmus_lock *l, unsigned long irqflags)
+//{
+//      struct rsm_mutex *mutex = rsm_mutex_from_lock(l);
+//      raw_spin_unlock_irqrestore(&mutex->lock, irqflags);
+//}
+
+static raw_spinlock_t* gsn_edf_get_dgl_spinlock(struct task_struct *t)
+{
+        return(&dgl_lock);
+}
+
+static int gsn_edf_rsm_mutex_is_owner(struct litmus_lock *l, struct task_struct *t)
+{
+        struct rsm_mutex *mutex = rsm_mutex_from_lock(l);
+        return(mutex->owner == t);
+}
+
+
+// return 1 if resource was immediatly acquired.
+// Assumes mutex->lock is held.
+// Must set task state to TASK_UNINTERRUPTIBLE if task blocks.
+static int gsn_edf_rsm_mutex_dgl_lock(struct litmus_lock *l, dgl_wait_state_t* dgl_wait, wait_queue_t* wq_node)
+{
+        struct rsm_mutex *mutex = rsm_mutex_from_lock(l);       
+        struct task_struct *t = dgl_wait->task;
+        
+        int acquired_immediatly = 0;
+        
+        BUG_ON(t != current);
+        
+        if (mutex->owner) {
+                TRACE_TASK(t, "Enqueuing on lock %d.\n", l->ident);
+
+                init_dgl_waitqueue_entry(wq_node, dgl_wait);
+        
+                set_task_state(t, TASK_UNINTERRUPTIBLE);
+                __add_wait_queue_tail_exclusive(&mutex->wait, wq_node);
+        } else {
+                TRACE_TASK(t, "Acquired lock %d with no blocking.\n", l->ident);
+                
+                /* it's ours now */
+                mutex->owner = t;
+                
+                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);
+                
+                acquired_immediatly = 1;
+        }
+    
+        return acquired_immediatly;     
+}
+
+// Assumes mutex->lock is held.
+static void gsn_edf_rsm_enable_priority(struct litmus_lock *l, dgl_wait_state_t* dgl_wait)
+{
+        struct rsm_mutex *mutex = rsm_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
+        
+        BUG_ON(owner == t);
+        
+        tsk_rt(t)->blocked_lock = l;
+        mb();
+        
+        if (edf_higher_prio(t, mutex->hp_waiter)) {
+                
+                struct task_struct *old_max_eff_prio;
+                struct task_struct *new_max_eff_prio;
+                struct task_struct *new_prio = NULL;
+                
+                if(mutex->hp_waiter)
+                        TRACE_TASK(t, "has higher prio than hp_waiter (%s/%d).\n", mutex->hp_waiter->comm, mutex->hp_waiter->pid);
+                else
+                        TRACE_TASK(t, "has higher prio than hp_waiter (NIL).\n");
+                
+                raw_spin_lock(&tsk_rt(owner)->hp_blocked_tasks_lock);
+                
+                //TRACE_TASK(owner, "Heap Before:\n");
+                //print_hp_waiters(tsk_rt(owner)->hp_blocked_tasks.root, 0);
+                
+                old_max_eff_prio = top_priority(&tsk_rt(owner)->hp_blocked_tasks);
+                
+                mutex->hp_waiter = t;
+                l->nest.hp_waiter_eff_prio = effective_priority(mutex->hp_waiter);
+                
+                binheap_decrease(&l->nest.hp_binheap_node, &tsk_rt(owner)->hp_blocked_tasks);
+                
+                //TRACE_TASK(owner, "Heap After:\n");
+                //print_hp_waiters(tsk_rt(owner)->hp_blocked_tasks.root, 0);                    
+                
+                new_max_eff_prio = top_priority(&tsk_rt(owner)->hp_blocked_tasks);
+                
+                if(new_max_eff_prio != old_max_eff_prio) {
+                        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))){
+                                new_prio = new_max_eff_prio;
+                        }
+                }
+                else {
+                        TRACE_TASK(t, "no change in max_eff_prio of heap.\n");
+                }
+                
+                //raw_spin_unlock(&tsk_rt(owner)->hp_blocked_tasks_lock);
+                
+                if(new_prio) {
+                        nested_increase_priority_inheritance(owner, new_prio, &mutex->lock, flags);  // unlocks lock.
+                }
+                else {
+                        raw_spin_unlock(&tsk_rt(owner)->hp_blocked_tasks_lock);
+                        unlock_fine_irqrestore(&mutex->lock, flags);
+                }
+        }
+        else {
+                TRACE_TASK(t, "no change in hp_waiter.\n");
+                unlock_fine_irqrestore(&mutex->lock, flags);
+        }
+}
+#endif
+
 int gsnedf_rsm_mutex_lock(struct litmus_lock* l)
 {
         struct task_struct *t = current;
@@ -962,9 +1154,10 @@ int gsnedf_rsm_mutex_lock(struct litmus_lock* l)
         if (!is_realtime(t))
                 return -EPERM;
 
-        raw_spin_lock_irqsave(&mutex->lock, flags);
-        //raw_spin_lock_irqsave(&rsm_global_lock, flags);
-        
+
+        lock_global_irqsave(&dgl_lock, flags);
+        lock_fine_irqsave(&mutex->lock, flags);
+
         if (mutex->owner) {
                 TRACE_TASK(t, "Blocking on lock %d.\n", l->ident);
                 
@@ -1023,29 +1216,24 @@ int gsnedf_rsm_mutex_lock(struct litmus_lock* l)
                                 TRACE_TASK(t, "no change in max_eff_prio of heap.\n");
                         }
                         
-                        //raw_spin_unlock(&tsk_rt(owner)->hp_blocked_tasks_lock);
-                        
                         if(new_prio) {
                                 nested_increase_priority_inheritance(owner, new_prio, &mutex->lock, flags);  // unlocks lock.
                         }
                         else {
                                 raw_spin_unlock(&tsk_rt(owner)->hp_blocked_tasks_lock);
-                                raw_spin_unlock_irqrestore(&mutex->lock, flags);
+                                unlock_fine_irqrestore(&mutex->lock, flags);            
                         }
-
                 }
                 else {
                         TRACE_TASK(t, "no change in hp_waiter.\n");
-                        raw_spin_unlock_irqrestore(&mutex->lock, flags);
+                        
+                        unlock_fine_irqrestore(&mutex->lock, flags);
                 }
                 
-
+                unlock_global_irqrestore(&dgl_lock, flags);
+                
                 TS_LOCK_SUSPEND;
-        
-                /* release lock before sleeping */
-                //raw_spin_unlock_irqrestore(&rsm_global_lock, flags);          
-                //raw_spin_unlock_irqrestore(&mutex->lock, flags);
-        
+                
                 /* We depend on the FIFO order.  Thus, we don't need to recheck
                  * when we wake up; we are guaranteed to have the lock since
                  * there is only one wake up per release.
@@ -1072,32 +1260,56 @@ int gsnedf_rsm_mutex_lock(struct litmus_lock* l)
                 binheap_add(&l->nest.hp_binheap_node, &tsk_rt(t)->hp_blocked_tasks, struct nested_info, hp_binheap_node);
                 raw_spin_unlock(&tsk_rt(mutex->owner)->hp_blocked_tasks_lock);
                 
-                raw_spin_unlock_irqrestore(&mutex->lock, flags);
-                //raw_spin_unlock_irqrestore(&rsm_global_lock, flags);
+                
+                unlock_fine_irqrestore(&mutex->lock, flags);
+                unlock_global_irqrestore(&dgl_lock, flags);
         }
     
         return 0;
 }
 
 
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+void select_next_lock_if_primary(struct litmus_lock *l, dgl_wait_state_t *dgl_wait)
+{
+        if(tsk_rt(dgl_wait->task)->blocked_lock == l) {
+                TRACE_CUR("Lock %d in DGL was primary for %s/%d.\n", l->ident, dgl_wait->task->comm, dgl_wait->task->pid);
+                tsk_rt(dgl_wait->task)->blocked_lock = NULL;
+                mb();
+                select_next_lock(dgl_wait, l);  // pick the next lock to be blocked on
+        }
+        else {
+                TRACE_CUR("Got lock early! Lock %d in DGL was NOT primary for %s/%d.\n", l->ident, dgl_wait->task->comm, dgl_wait->task->pid);
+        }
+}
+#endif
+
+
 int gsnedf_rsm_mutex_unlock(struct litmus_lock* l)
 {
-        struct task_struct *t = current, *next;
+        struct task_struct *t = current, *next = NULL;
         struct rsm_mutex *mutex = rsm_mutex_from_lock(l);
         unsigned long flags;
         
         struct task_struct *old_max_eff_prio;
         
+        int wake_up_task = 1;
+        
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+        dgl_wait_state_t *dgl_wait = NULL;
+#endif
         
         int err = 0;
     
-        raw_spin_lock_irqsave(&mutex->lock, flags);
-        //raw_spin_lock_irqsave(&rsm_global_lock, flags);
+        lock_global_irqsave(&dgl_lock, flags);
+        lock_fine_irqsave(&mutex->lock, flags);
         
     
         if (mutex->owner != t) {
                 err = -EINVAL;
-                goto out;
+                unlock_fine_irqrestore(&mutex->lock, flags);
+                unlock_global_irqrestore(&dgl_lock, flags);
+                return err;
         }
         
         
@@ -1147,16 +1359,25 @@ int gsnedf_rsm_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;
+                //select_next_lock_if_primary(l, dgl_wait);
+        }
+#else
         next = __waitqueue_remove_first(&mutex->wait);
+#endif
         if (next) {
                 /* next becomes the resouce holder */
                 mutex->owner = next;
                 TRACE_CUR("lock ownership passed to %s/%d\n", next->comm, next->pid);
         
-                
-                tsk_rt(next)->blocked_lock = NULL;
+//              if(tsk_rt(next)->blocked_lock == &mutex->litmus_lock) {  // might be false for DGL.
+//                      tsk_rt(next)->blocked_lock = NULL;
+//                      mb();
+//              }
         
-                
                 /* determine new hp_waiter if necessary */
                 if (next == mutex->hp_waiter) {
                         
@@ -1181,10 +1402,19 @@ int gsnedf_rsm_mutex_unlock(struct litmus_lock* l)
                         binheap_add(&l->nest.hp_binheap_node, &tsk_rt(next)->hp_blocked_tasks, struct nested_info, hp_binheap_node);
                         
                         //TRACE_TASK(next, "Heap After:\n");
-                        //print_hp_waiters(tsk_rt(next)->hp_blocked_tasks.root, 0);                     
-                        
+                        //print_hp_waiters(tsk_rt(next)->hp_blocked_tasks.root, 0);
+                        
+#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);
+                        }
+#endif                  
                         raw_spin_unlock(&tsk_rt(next)->hp_blocked_tasks_lock);
-                } else {
+                }
+                else {
                         /* Well, if 'next' is not the highest-priority waiter,
                          * then it (probably) ought to inherit the highest-priority
                          * waiter's priority. */
@@ -1198,6 +1428,16 @@ int gsnedf_rsm_mutex_unlock(struct litmus_lock* l)
                         binheap_add(&l->nest.hp_binheap_node, &tsk_rt(next)->hp_blocked_tasks,
                                                 struct nested_info, hp_binheap_node);
                         
+                        
+#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);                           
+                        }
+#endif
+                        
                         //TRACE_TASK(next, "Heap After:\n");
                         //print_hp_waiters(tsk_rt(next)->hp_blocked_tasks.root, 0);                             
                         
@@ -1209,26 +1449,53 @@ int gsnedf_rsm_mutex_unlock(struct litmus_lock* l)
                          * since the effective priority of hp_waiter can change (and the
                          * update has not made it to this lock).)
                          */
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+                        if((l->nest.hp_waiter_eff_prio != NULL) && (top_priority(&tsk_rt(next)->hp_blocked_tasks) == l->nest.hp_waiter_eff_prio))
+                        {
+                                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)) {
+                                                nested_increase_priority_inheritance(next, l->nest.hp_waiter_eff_prio, &mutex->lock, flags);  // unlocks lock && hp_blocked_tasks_lock.
+                                                goto out;  // all spinlocks are released.  bail out now.
+                                        }
+                                }
+                                else {
+                                        increase_priority_inheritance(next, l->nest.hp_waiter_eff_prio);
+                                }
+                        }
+                        
+                        raw_spin_unlock(&tsk_rt(next)->hp_blocked_tasks_lock);
+#else
                         if(likely(top_priority(&tsk_rt(next)->hp_blocked_tasks) == l->nest.hp_waiter_eff_prio))
                         {
                                 increase_priority_inheritance(next, l->nest.hp_waiter_eff_prio);
                         }
-                        
                         raw_spin_unlock(&tsk_rt(next)->hp_blocked_tasks_lock);
+#endif                  
+                }
+                
+                if(wake_up_task) {
+                        TRACE_TASK(next, "waking up since it is no longer blocked.\n");
+                        
+                        tsk_rt(next)->blocked_lock = NULL;
+                        mb();
+                        
+                        wake_up_process(next);
+                }
+                else {
+                        TRACE_TASK(next, "is still blocked.\n");
                 }
-
-                /* wake up next */
-                wake_up_process(next);
         }
         else {
     /* becomes available */
                 mutex->owner = NULL;
         }
-
+        
+        unlock_fine_irqrestore(&mutex->lock, flags);
+        
 out:
-        raw_spin_unlock_irqrestore(&mutex->lock, flags);
-        //raw_spin_unlock_irqrestore(&rsm_global_lock, flags);
-    
+        unlock_global_irqrestore(&dgl_lock, flags);
+        
         return err;
 }
 
@@ -1241,8 +1508,8 @@ void gsnedf_rsm_mutex_propagate_increase_inheritance(struct litmus_lock* l,
         struct rsm_mutex *mutex = rsm_mutex_from_lock(l);
         
         // relay-style locking
-        raw_spin_lock(&mutex->lock);
-        raw_spin_unlock(to_unlock);
+        lock_fine(&mutex->lock);
+        unlock_fine(to_unlock);
         
         if(tsk_rt(t)->blocked_lock == l) {  // prevent race on tsk_rt(t)->blocked
                 struct task_struct *owner = mutex->owner;                       
@@ -1261,6 +1528,10 @@ void gsnedf_rsm_mutex_propagate_increase_inheritance(struct litmus_lock* l,
                 if(t == mutex->hp_waiter) {
                         // reflect the decreased priority in the heap node.
                         l->nest.hp_waiter_eff_prio = effective_priority(mutex->hp_waiter);
+                        
+                        BUG_ON(!binheap_is_in_heap(&l->nest.hp_binheap_node));
+                        BUG_ON(!binheap_is_in_this_heap(&l->nest.hp_binheap_node, &tsk_rt(owner)->hp_blocked_tasks));
+                        
                         binheap_decrease(&l->nest.hp_binheap_node, &tsk_rt(owner)->hp_blocked_tasks);
                 }
                 
@@ -1280,13 +1551,13 @@ void gsnedf_rsm_mutex_propagate_increase_inheritance(struct litmus_lock* l,
                         else {
                                 TRACE_CUR("Lower priority than holder %s/%d.  No propagation.\n", owner->comm, owner->pid);
                                 raw_spin_unlock(&tsk_rt(owner)->hp_blocked_tasks_lock);
-                                raw_spin_unlock_irqrestore(&mutex->lock, irqflags);
+                                unlock_fine_irqrestore(&mutex->lock, irqflags);
                         }
                 }
                 else {
                         TRACE_TASK(mutex->owner, "No change in maxiumum effective priority.\n");                        
                         raw_spin_unlock(&tsk_rt(owner)->hp_blocked_tasks_lock);
-                        raw_spin_unlock_irqrestore(&mutex->lock, irqflags);
+                        unlock_fine_irqrestore(&mutex->lock, irqflags);
                 }
         }
         else {
@@ -1303,11 +1574,11 @@ void gsnedf_rsm_mutex_propagate_increase_inheritance(struct litmus_lock* l,
                         }
                         else {
                                 TRACE_TASK(t, "Inheritor is blocked on lock (%p) that does not support nesting!\n", still_blocked);
-                                raw_spin_unlock_irqrestore(&mutex->lock, irqflags);
+                                unlock_fine_irqrestore(&mutex->lock, irqflags);
                         }
                 }
                 else {
-                        raw_spin_unlock_irqrestore(&mutex->lock, irqflags);
+                        unlock_fine_irqrestore(&mutex->lock, irqflags);
                 }
         }
 }
@@ -1321,8 +1592,8 @@ void gsnedf_rsm_mutex_propagate_decrease_inheritance(struct litmus_lock* l,
         struct rsm_mutex *mutex = rsm_mutex_from_lock(l);
         
         // relay-style locking
-        raw_spin_lock(&mutex->lock);
-        raw_spin_unlock(to_unlock);
+        lock_fine(&mutex->lock);
+        unlock_fine(to_unlock);
         
         if(tsk_rt(t)->blocked_lock == l) {  // prevent race on tsk_rt(t)->blocked
                 if(t == mutex->hp_waiter) {
@@ -1377,12 +1648,12 @@ void gsnedf_rsm_mutex_propagate_decrease_inheritance(struct litmus_lock* l,
                         }
                         else {
                                 raw_spin_unlock(&tsk_rt(owner)->hp_blocked_tasks_lock);
-                                raw_spin_unlock_irqrestore(&mutex->lock, irqflags);
+                                unlock_fine_irqrestore(&mutex->lock, irqflags);
                         }
                 }
                 else {
                         TRACE_TASK(t, "is not hp_waiter.  No propagation.\n");
-                        raw_spin_unlock_irqrestore(&mutex->lock, irqflags);
+                        unlock_fine_irqrestore(&mutex->lock, irqflags);
                 }
         }
         else {
@@ -1399,11 +1670,11 @@ void gsnedf_rsm_mutex_propagate_decrease_inheritance(struct litmus_lock* l,
                         }
                         else {
                                 TRACE_TASK(t, "Inheritor is blocked on lock (%p) that does not support nesting!\n", still_blocked);
-                                raw_spin_unlock_irqrestore(&mutex->lock, irqflags);
+                                unlock_fine_irqrestore(&mutex->lock, irqflags);
                         }
                 }
                 else {
-                        raw_spin_unlock_irqrestore(&mutex->lock, irqflags);
+                        unlock_fine_irqrestore(&mutex->lock, irqflags);
                 }
         }
 }
@@ -1418,14 +1689,15 @@ int gsnedf_rsm_mutex_close(struct litmus_lock* l)
     
         int owner;
     
-        raw_spin_lock_irqsave(&mutex->lock, flags);
-        //raw_spin_lock_irqsave(&rsm_global_lock, flags);
+
+        lock_global_irqsave(&dgl_lock, flags);
+        lock_fine_irqsave(&mutex->lock, flags);
     
         owner = (mutex->owner == t);
     
-        raw_spin_unlock_irqrestore(&mutex->lock, flags);
-        //raw_spin_unlock_irqrestore(&rsm_global_lock, flags);
-    
+        unlock_fine_irqrestore(&mutex->lock, flags);
+        unlock_global_irqrestore(&dgl_lock, flags);     
+
         if (owner)
                 gsnedf_rsm_mutex_unlock(l);
     
@@ -1443,7 +1715,15 @@ static struct litmus_lock_ops gsnedf_rsm_mutex_lock_ops = {
         .unlock = gsnedf_rsm_mutex_unlock,
         .deallocate = gsnedf_rsm_mutex_free,
         .propagate_increase_inheritance = gsnedf_rsm_mutex_propagate_increase_inheritance,
-        .propagate_decrease_inheritance = gsnedf_rsm_mutex_propagate_decrease_inheritance       
+        .propagate_decrease_inheritance = gsnedf_rsm_mutex_propagate_decrease_inheritance,
+        
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+//      .reserve = gsnedf_rsm_mutex_reserve,
+//      .unreserve = gsnedf_rsm_mutex_unreserve,
+        .dgl_lock = gsn_edf_rsm_mutex_dgl_lock,
+        .is_owner = gsn_edf_rsm_mutex_is_owner,
+        .enable_priority = gsn_edf_rsm_enable_priority,
+#endif
 };
 
 static struct litmus_lock* gsnedf_new_rsm_mutex(void)
@@ -1928,7 +2208,7 @@ static void ikglp_refresh_owners_prio_increase(struct task_struct *t, struct fif
                                 TRACE_TASK(t, "No change in effective priority (is %s/%d).  Propagation halted.\n",
                                                    new_max_eff_prio->comm, new_max_eff_prio->pid);
                                 raw_spin_unlock(&tsk_rt(owner)->hp_blocked_tasks_lock);
-                                raw_spin_unlock_irqrestore(&sem->lock, flags);
+                                unlock_fine_irqrestore(&sem->lock, flags);
                         }
                 }
                 else {
@@ -1936,12 +2216,12 @@ static void ikglp_refresh_owners_prio_increase(struct task_struct *t, struct fif
                         fq->nest.hp_waiter_eff_prio = effective_priority(fq->hp_waiter);
                         
                         TRACE_TASK(t, "no owner??\n");
-                        raw_spin_unlock_irqrestore(&sem->lock, flags);
+                        unlock_fine_irqrestore(&sem->lock, flags);
                 }
         }
         else {
                 TRACE_TASK(t, "hp_waiter is unaffected.\n");
-                raw_spin_unlock_irqrestore(&sem->lock, flags);
+                unlock_fine_irqrestore(&sem->lock, flags);
         }               
 }
 
@@ -1955,7 +2235,7 @@ static void ikglp_refresh_owners_prio_decrease(struct fifo_queue *fq, struct ikg
 
         if(!owner) {
                 TRACE_CUR("No owner.  Returning.\n");
-                raw_spin_unlock_irqrestore(&sem->lock, flags);
+                unlock_fine_irqrestore(&sem->lock, flags);
                 return;
         }
         
@@ -2004,7 +2284,7 @@ static void ikglp_refresh_owners_prio_decrease(struct fifo_queue *fq, struct ikg
         else {
                 TRACE_TASK(owner, "No need to propagate priority decrease forward.\n");
                 raw_spin_unlock(&tsk_rt(owner)->hp_blocked_tasks_lock);
-                raw_spin_unlock_irqrestore(&sem->lock, flags);
+                unlock_fine_irqrestore(&sem->lock, flags);
         }
 }
 
@@ -2049,7 +2329,7 @@ static void ikglp_remove_donation_from_owner(struct binheap_node *n, struct fifo
         else {
                 TRACE_TASK(owner, "No need to propagate priority decrease forward.\n");
                 raw_spin_unlock(&tsk_rt(owner)->hp_blocked_tasks_lock);
-                raw_spin_unlock_irqrestore(&sem->lock, flags);
+                unlock_fine_irqrestore(&sem->lock, flags);
         }
 }
 
@@ -2103,7 +2383,7 @@ static void ikglp_get_immediate(struct task_struct* t, struct fifo_queue *fq, st
         
         sem->shortest_fifo_queue = ikglp_find_shortest(sem, sem->shortest_fifo_queue);
         
-        raw_spin_unlock_irqrestore(&sem->lock, flags);  
+        unlock_fine_irqrestore(&sem->lock, flags);      
 }
 
 
@@ -2136,9 +2416,9 @@ static void __ikglp_enqueue_on_fq(
         }
         // update donor eligiblity list.
         if(likely(donee_heap_node)) {
-                if(binheap_is_in_heap(&donee_heap_node->node)) {
-                        WARN_ON(1);
-                }
+//              if(binheap_is_in_heap(&donee_heap_node->node)) {
+//                      WARN_ON(1);
+//              }
                 ikglp_add_donees(sem, fq, t, donee_heap_node);
         }
         
@@ -2353,7 +2633,7 @@ static void ikglp_enqueue_on_donor(struct ikglp_semaphore *sem, ikglp_wait_state
                 TRACE_TASK(t, "No change in effective priority (it is %d/%s).  BUG?\n",
                                    new_max_eff_prio->comm, new_max_eff_prio->pid);
                 raw_spin_unlock(&tsk_rt(donee)->hp_blocked_tasks_lock);
-                raw_spin_unlock_irqrestore(&sem->lock, flags);
+                unlock_fine_irqrestore(&sem->lock, flags);
         }
         
 
@@ -2366,7 +2646,7 @@ static int gsnedf_ikglp_lock(struct litmus_lock* l)
 {
         struct task_struct* t = current;
         struct ikglp_semaphore *sem = ikglp_from_lock(l);
-        unsigned long flags, real_flags;        
+        unsigned long flags = 0, real_flags;    
         struct fifo_queue *fq = NULL;
         int replica = -EINVAL;
         
@@ -2376,13 +2656,17 @@ static int gsnedf_ikglp_lock(struct litmus_lock* l)
                 return -EPERM;          
         
         raw_spin_lock_irqsave(&sem->real_lock, real_flags);
-        raw_spin_lock_irqsave(&sem->lock, flags);
+        
+        lock_global_irqsave(&dgl_lock, flags);
+        lock_fine_irqsave(&sem->lock, flags);
 
         if(sem->shortest_fifo_queue->count == 0) {
                 // take available resource
                 replica = ikglp_get_idx(sem, sem->shortest_fifo_queue);
                 
                 ikglp_get_immediate(t, sem->shortest_fifo_queue, sem, flags);  // unlocks sem->lock
+                
+                unlock_global_irqrestore(&dgl_lock, flags);
                 raw_spin_unlock_irqrestore(&sem->real_lock, real_flags);
         }
         else
@@ -2410,7 +2694,7 @@ static int gsnedf_ikglp_lock(struct litmus_lock* l)
                         if(__edf_higher_prio(ikglp_mth_highest(sem), BASE, t, BASE)) {
                                 // enqueue on PQ
                                 ikglp_enqueue_on_pq(sem, &wait);
-                                raw_spin_unlock_irqrestore(&sem->lock, flags);
+                                unlock_fine_irqrestore(&sem->lock, flags);
                         }
                         else {
                                 // enqueue as donor
@@ -2418,6 +2702,7 @@ static int gsnedf_ikglp_lock(struct litmus_lock* l)
                         }
                 }
                 
+                unlock_global_irqrestore(&dgl_lock, flags);
                 raw_spin_unlock_irqrestore(&sem->real_lock, real_flags);
                 
                 TS_LOCK_SUSPEND;
@@ -2631,12 +2916,14 @@ static int gsnedf_ikglp_unlock(struct litmus_lock* l)
         struct fifo_queue *to_steal = NULL;
         struct fifo_queue *fq;
         
-        unsigned long flags, real_flags;
+        unsigned long flags = 0, real_flags;
         
         int err = 0;
         
         raw_spin_lock_irqsave(&sem->real_lock, real_flags);
-        raw_spin_lock_irqsave(&sem->lock, flags);
+
+        lock_global_irqsave(&dgl_lock, flags);  // TODO: Push this deeper
+        lock_fine_irqsave(&sem->lock, flags);
         
         fq = ikglp_get_queue(sem, t);  // returns NULL if 't' is not owner.
         
@@ -2781,7 +3068,7 @@ static int gsnedf_ikglp_unlock(struct litmus_lock* l)
                                            ikglp_get_idx(sem, other_fq));
                         
                         ikglp_remove_donation_from_owner(&other_donor_info->prio_donation.hp_binheap_node, other_fq, sem, flags);
-                        raw_spin_lock_irqsave(&sem->lock, flags);  // there should be no contention!!!!
+                        lock_fine_irqsave(&sem->lock, flags);  // there should be no contention!!!!
                 }
                 else {
                         TRACE_TASK(t, "Donee %s/%d is an blocked in of fq %d.\n",
@@ -2801,7 +3088,7 @@ static int gsnedf_ikglp_unlock(struct litmus_lock* l)
                                                    (other_fq->hp_waiter) ? other_fq->hp_waiter->pid : -1);                              
                                 
                                 ikglp_refresh_owners_prio_decrease(other_fq, sem, flags); // unlocks sem->lock.  reacquire it.
-                                raw_spin_lock_irqsave(&sem->lock, flags);  // there should be no contention!!!!                         
+                                lock_fine_irqsave(&sem->lock, flags);  // there should be no contention!!!!                             
                         }
                 }
         }
@@ -2810,7 +3097,7 @@ static int gsnedf_ikglp_unlock(struct litmus_lock* l)
                                    ikglp_get_idx(sem, to_steal));               
                 
                 ikglp_refresh_owners_prio_decrease(to_steal, sem, flags); // unlocks sem->lock.  reacquire it.
-                raw_spin_lock_irqsave(&sem->lock, flags);  // there should be no contention!!!!
+                lock_fine_irqsave(&sem->lock, flags);  // there should be no contention!!!!
         }
         
         // check for new HP waiter.
@@ -2930,7 +3217,8 @@ static int gsnedf_ikglp_unlock(struct litmus_lock* l)
         }
 
 out:
-        raw_spin_unlock_irqrestore(&sem->lock, flags);
+        unlock_fine_irqrestore(&sem->lock, flags);
+        unlock_global_irqrestore(&dgl_lock, flags);
         
         raw_spin_unlock_irqrestore(&sem->real_lock, real_flags);
         
@@ -2947,7 +3235,7 @@ static int gsnedf_ikglp_close(struct litmus_lock* l)
         int owner = 0;
         int i;
     
-        raw_spin_lock_irqsave(&sem->lock, flags);
+        raw_spin_lock_irqsave(&sem->real_lock, flags);
     
         for(i = 0; i < sem->nr_replicas; ++i) {
                 if(sem->fifo_queues[i].owner == t) {
@@ -2956,7 +3244,7 @@ static int gsnedf_ikglp_close(struct litmus_lock* l)
                 }
         }
     
-        raw_spin_unlock_irqrestore(&sem->lock, flags);
+        raw_spin_unlock_irqrestore(&sem->real_lock, flags);
     
         if (owner)
                 gsnedf_ikglp_unlock(l);
@@ -3384,6 +3672,9 @@ static struct sched_plugin gsn_edf_plugin __cacheline_aligned_in_smp = {
 #ifdef CONFIG_LITMUS_LOCKING
         .allocate_lock          = gsnedf_allocate_lock,
 #endif
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+        .get_dgl_spinlock = gsn_edf_get_dgl_spinlock,
+#endif
 };
 
 
@@ -3401,6 +3692,11 @@ static int __init init_gsn_edf(void)
 
                 INIT_BINHEAP_NODE(&entry->hn);
         }
+        
+#ifdef CONFIG_LITMUS_DGL_SUPPORT        
+        raw_spin_lock_init(&dgl_lock);
+#endif
+        
         edf_domain_init(&gsnedf, NULL, gsnedf_release_jobs);
         return register_sched_plugin(&gsn_edf_plugin);
 }