IKGLP reject/reissue on budget exhaustion.

Added support to IKGLP to handle budget exhaustion
of blocked waiter.

NOTE: CODE IS UNTESTED...

1 files changed, 241 insertions, 79 deletions

diff --git a/litmus/ikglp_lock.c b/litmus/ikglp_lock.c
index 160998f466ed..6d7ea24ce79b 100644
--- a/litmus/ikglp_lock.c
+++ b/litmus/ikglp_lock.c
@@ -427,7 +427,8 @@ static void ikglp_refresh_owners_prio_increase(struct task_struct *t,
 // hp_waiter has decreased
 static void ikglp_refresh_owners_prio_decrease(struct fifo_queue *fq,
                                                                                            struct ikglp_semaphore *sem,
-                                                                                           unsigned long flags)
+                                                                                           unsigned long flags,
+                                                                                           int budget_triggered)
 {
         struct task_struct *owner = fq->owner;
 
@@ -484,7 +485,7 @@ static void ikglp_refresh_owners_prio_decrease(struct fifo_queue *fq,
                 }
 
                 // beware: recursion
-                litmus->nested_decrease_prio(owner, decreased_prio, &sem->lock, flags, 0);      // will unlock mutex->lock
+                litmus->nested_decrease_prio(owner, decreased_prio, &sem->lock, flags, budget_triggered);       // will unlock mutex->lock
         }
         else {
                 TRACE_TASK(owner, "No need to propagate priority decrease forward.\n");
@@ -623,19 +624,20 @@ static void ikglp_get_immediate(struct task_struct* t,
 
 
 static void __ikglp_enqueue_on_fq(struct ikglp_semaphore *sem,
-                                                                  struct fifo_queue* fq,
-                                                                  struct task_struct* t,
-                                                                  wait_queue_t *wait,
+                                                                  struct fifo_queue *fq,
+                                                                  ikglp_wait_state_t *wait,
                                                                   ikglp_heap_node_t *global_heap_node,
                                                                   ikglp_donee_heap_node_t *donee_heap_node)
 {
+        struct task_struct *t = wait->task;
+
         /* resource is not free => must suspend and wait */
         TRACE_TASK(t, "Enqueuing on fq %d.\n",
                            ikglp_get_idx(sem, fq));
 
-        init_waitqueue_entry(wait, t);
+        init_waitqueue_entry(&wait->fq_node, t);
 
-        __add_wait_queue_tail_exclusive(&fq->wait, wait);
+        __add_wait_queue_tail_exclusive(&fq->wait, &wait->fq_node);
 
         ++(fq->count);
         ++(sem->nr_in_fifos);
@@ -649,29 +651,25 @@ static void __ikglp_enqueue_on_fq(struct ikglp_semaphore *sem,
                 ikglp_add_global_list(sem, t, global_heap_node);
         }
         // update donor eligiblity list.
-        if(likely(donee_heap_node)) {
-//              if(binheap_is_in_heap(&donee_heap_node->node)) {
-//                      WARN_ON(1);
-//              }
+        if(likely(donee_heap_node))
                 ikglp_add_donees(sem, fq, t, donee_heap_node);
-        }
 
-        if(sem->shortest_fifo_queue == fq) {
+        if(sem->shortest_fifo_queue == fq)
                 sem->shortest_fifo_queue = ikglp_find_shortest(sem, fq);
-        }
 
 #ifdef CONFIG_LITMUS_AFFINITY_LOCKING
-        if(sem->aff_obs) {
+        if(sem->aff_obs)
                 sem->aff_obs->ops->notify_enqueue(sem->aff_obs, fq, t);
-        }
 #endif
 
+        wait->cur_q = IKGLP_FQ;
+        wait->fq = fq;
+
         TRACE_TASK(t, "shortest queue is now %d\n", ikglp_get_idx(sem, fq));
 }
 
 
-static void ikglp_enqueue_on_fq(
-                                                                struct ikglp_semaphore *sem,
+static void ikglp_enqueue_on_fq(struct ikglp_semaphore *sem,
                                                                 struct fifo_queue *fq,
                                                                 ikglp_wait_state_t *wait,
                                                                 unsigned long flags)
@@ -683,7 +681,7 @@ static void ikglp_enqueue_on_fq(
         INIT_BINHEAP_NODE(&wait->global_heap_node.node);
         INIT_BINHEAP_NODE(&wait->donee_heap_node.node);
 
-        __ikglp_enqueue_on_fq(sem, fq, wait->task, &wait->fq_node,
+        __ikglp_enqueue_on_fq(sem, fq, wait,
                                                   &wait->global_heap_node, &wait->donee_heap_node);
 
         ikglp_refresh_owners_prio_increase(wait->task, fq, sem, flags);  // unlocks sem->lock
@@ -699,6 +697,8 @@ static void __ikglp_enqueue_on_pq(struct ikglp_semaphore *sem,
 
         binheap_add(&wait->pq_node.node, &sem->priority_queue,
                                 ikglp_heap_node_t, node);
+
+        wait->cur_q = IKGLP_PQ;
 }
 
 static void ikglp_enqueue_on_pq(struct ikglp_semaphore *sem,
@@ -866,16 +866,18 @@ static void ikglp_enqueue_on_donor(struct ikglp_semaphore *sem,
                 unlock_fine_irqrestore(&sem->lock, flags);
         }
 
+        wait->cur_q = IKGLP_DONOR;
 
 //      TRACE_CUR("donors After:\n");
 //      print_donors(sem->donors.root, 1);
 }
 
+
 int ikglp_lock(struct litmus_lock* l)
 {
         struct task_struct* t = current;
         struct ikglp_semaphore *sem = ikglp_from_lock(l);
-        unsigned long flags = 0, real_flags;
+        unsigned long flags = 0, more_flags;
         struct fifo_queue *fq = NULL;
         int replica = -EINVAL;
 
@@ -888,13 +890,14 @@ int ikglp_lock(struct litmus_lock* l)
         if (!is_realtime(t))
                 return -EPERM;
 
+        memset(&wait, 0, sizeof(wait));
+
 #ifdef CONFIG_LITMUS_DGL_SUPPORT
         dgl_lock = litmus->get_dgl_spinlock(t);
 #endif
 
-        raw_spin_lock_irqsave(&sem->real_lock, real_flags);
-
         lock_global_irqsave(dgl_lock, flags);
+        raw_spin_lock_irqsave(&sem->real_lock, more_flags);
         lock_fine_irqsave(&sem->lock, flags);
 
         TRACE_CUR("Requesting a replica from lock %d.\n", l->ident);
@@ -916,8 +919,8 @@ int ikglp_lock(struct litmus_lock* l)
 
                         ikglp_get_immediate(t, fq, sem, flags);  // unlocks sem->lock
 
+                        raw_spin_unlock_irqrestore(&sem->real_lock, more_flags);
                         unlock_global_irqrestore(dgl_lock, flags);
-                        raw_spin_unlock_irqrestore(&sem->real_lock, real_flags);
                         goto acquired;
                 }
                 else {
@@ -959,8 +962,10 @@ int ikglp_lock(struct litmus_lock* l)
                 }
         }
 
+        tsk_rt(t)->blocked_lock_data = (unsigned long)&wait;
+
+        raw_spin_unlock_irqrestore(&sem->real_lock, more_flags);
         unlock_global_irqrestore(dgl_lock, flags);
-        raw_spin_unlock_irqrestore(&sem->real_lock, real_flags);
 
         TRACE_CUR("Suspending for replica.\n");
 
@@ -970,8 +975,11 @@ int ikglp_lock(struct litmus_lock* l)
 
         TS_LOCK_RESUME;
 
-        fq = ikglp_get_queue(sem, t);
-        BUG_ON(!fq);
+        fq = wait.fq;
+
+        BUG_ON(fq != ikglp_get_queue(sem, t));
+
+        tsk_rt(t)->blocked_lock_data = 0;
 
         replica = ikglp_get_idx(sem, fq);
 
@@ -988,6 +996,17 @@ acquired:
         return replica;
 }
 
+static void __drop_from_donor(struct ikglp_semaphore *sem,
+                                                          ikglp_wait_state_t *wait)
+{
+        BUG_ON(wait->cur_q != IKGLP_DONOR);
+
+        TRACE_TASK(wait->task, "is being dropped from donor heap.\n");
+
+        binheap_delete(&wait->node, &sem->donors);
+        wait->cur_q = IKGLP_INVL;
+}
+
 static void ikglp_move_donor_to_fq(struct ikglp_semaphore *sem,
                                                                    struct fifo_queue *fq,
                                                                    ikglp_wait_state_t *donor_info)
@@ -999,17 +1018,24 @@ static void ikglp_move_donor_to_fq(struct ikglp_semaphore *sem,
                           t->pid,
                           ikglp_get_idx(sem, fq));
 
-        binheap_delete(&donor_info->node, &sem->donors);
-
-        __ikglp_enqueue_on_fq(sem, fq, t,
-                                                  &donor_info->fq_node,
+        __drop_from_donor(sem, donor_info);
+        __ikglp_enqueue_on_fq(sem, fq, donor_info,
                                                   NULL, // already in global_list, so pass null to prevent adding 2nd time.
                                                   &donor_info->donee_heap_node);
-
         // warning:
         // ikglp_update_owners_prio(t, fq, sem, flags) has not been called.
 }
 
+static void __drop_from_pq(struct ikglp_semaphore *sem, ikglp_wait_state_t *wait)
+{
+        BUG_ON(wait->cur_q != IKGLP_PQ);
+
+        TRACE_TASK(wait->task, "is being dropped from the PQ.\n");
+
+        binheap_delete(&wait->pq_node.node, &sem->priority_queue);
+        wait->cur_q = IKGLP_INVL;
+}
+
 static void ikglp_move_pq_to_fq(struct ikglp_semaphore *sem,
                                                                 struct fifo_queue *fq,
                                                                 ikglp_wait_state_t *wait)
@@ -1021,10 +1047,8 @@ static void ikglp_move_pq_to_fq(struct ikglp_semaphore *sem,
                           t->pid,
                           ikglp_get_idx(sem, fq));
 
-        binheap_delete(&wait->pq_node.node, &sem->priority_queue);
-
-        __ikglp_enqueue_on_fq(sem, fq, t,
-                                                  &wait->fq_node,
+        __drop_from_pq(sem, wait);
+        __ikglp_enqueue_on_fq(sem, fq, wait,
                                                   &wait->global_heap_node,
                                                   &wait->donee_heap_node);
         // warning:
@@ -1094,48 +1118,51 @@ static ikglp_wait_state_t* ikglp_find_hp_waiter_to_steal(
         return(NULL);
 }
 
-static void ikglp_steal_to_fq(struct ikglp_semaphore *sem,
-                                                          struct fifo_queue *fq,
-                                                          ikglp_wait_state_t *fq_wait)
+static void __drop_from_fq(struct ikglp_semaphore *sem,
+                                                   ikglp_wait_state_t *wait)
 {
-        struct task_struct *t = fq_wait->task;
-        struct fifo_queue *fq_steal = fq_wait->donee_heap_node.fq;
-
-        TRACE_CUR("FQ request %s/%d being moved to fq %d\n",
-                          t->comm,
-                          t->pid,
-                          ikglp_get_idx(sem, fq));
+        struct task_struct *t = wait->task;
+        struct fifo_queue *fq = wait->fq;
 
-        fq_wait->donee_heap_node.fq = fq;  // just to be safe
+        BUG_ON(wait->cur_q != IKGLP_FQ);
+        BUG_ON(!fq);
 
+        TRACE_TASK(t, "is being dropped from fq.\n");
 
-        __remove_wait_queue(&fq_steal->wait, &fq_wait->fq_node);
-        --(fq_steal->count);
+        __remove_wait_queue(&fq->wait, &wait->fq_node);
+        --(fq->count);
 
 #ifdef CONFIG_LITMUS_AFFINITY_LOCKING
         if(sem->aff_obs) {
-                sem->aff_obs->ops->notify_dequeue(sem->aff_obs, fq_steal, t);
+                sem->aff_obs->ops->notify_dequeue(sem->aff_obs, fq, t);
         }
 #endif
 
-        if(t == fq_steal->hp_waiter) {
-                fq_steal->hp_waiter = ikglp_find_hp_waiter(fq_steal, NULL);
+        if(t == fq->hp_waiter) {
+                fq->hp_waiter = ikglp_find_hp_waiter(fq, NULL);
                 TRACE_TASK(t, "New hp_waiter for fq %d is %s/%d!\n",
-                                   ikglp_get_idx(sem, fq_steal),
-                                   (fq_steal->hp_waiter) ? fq_steal->hp_waiter->comm : "null",
-                                   (fq_steal->hp_waiter) ? fq_steal->hp_waiter->pid : 0);
+                                   ikglp_get_idx(sem, fq),
+                                   (fq->hp_waiter) ? fq->hp_waiter->comm : "null",
+                                   (fq->hp_waiter) ? fq->hp_waiter->pid : 0);
         }
 
-
         // Update shortest.
-        if(fq_steal->count < sem->shortest_fifo_queue->count) {
-                sem->shortest_fifo_queue = fq_steal;
-        }
+        if(fq->count < sem->shortest_fifo_queue->count)
+                sem->shortest_fifo_queue = fq;
+
+        wait->cur_q = IKGLP_INVL;
+}
+
+static void ikglp_steal_to_fq(struct ikglp_semaphore *sem,
+                                                          struct fifo_queue *fq,
+                                                          ikglp_wait_state_t *fq_wait)
+{
+        WARN_ON(fq_wait->fq != fq_wait->donee_heap_node.fq);
+//      __drop_from_fq(sem, fq_wait->donee_heap_node.fq, fq_wait);
+        __drop_from_fq(sem, fq_wait);
 
-        __ikglp_enqueue_on_fq(sem, fq, t,
-                                                  &fq_wait->fq_node,
-                                                  NULL,
-                                                  NULL);
+        fq_wait->donee_heap_node.fq = fq;  // just to be safe
+        __ikglp_enqueue_on_fq(sem, fq, fq_wait, NULL, NULL);
 
         // warning: We have not checked the priority inheritance of fq's owner yet.
 }
@@ -1192,7 +1219,7 @@ int ikglp_unlock(struct litmus_lock* l)
         raw_spinlock_t *dgl_lock;
 #endif
 
-        unsigned long flags = 0, real_flags;
+        unsigned long flags = 0, more_flags;
 
         int err = 0;
 
@@ -1203,17 +1230,17 @@ int ikglp_unlock(struct litmus_lock* l)
                 goto out;
         }
 
+        BUG_ON(l != tsk_rt(t)->outermost_lock);
+
 #ifdef CONFIG_LITMUS_DGL_SUPPORT
         dgl_lock = litmus->get_dgl_spinlock(t);
 #endif
-        raw_spin_lock_irqsave(&sem->real_lock, real_flags);
-
-        lock_global_irqsave(dgl_lock, flags);  // TODO: Push this deeper
+        lock_global_irqsave(dgl_lock, flags);
+        raw_spin_lock_irqsave(&sem->real_lock, more_flags);
         lock_fine_irqsave(&sem->lock, flags);
 
         TRACE_TASK(t, "Freeing replica %d.\n", ikglp_get_idx(sem, fq));
 
-
         // Remove 't' from the heaps, but data in nodes will still be good.
         ikglp_del_global_list(sem, t, &fq->global_heap_node);
         binheap_delete(&fq->donee_heap_node.node, &sem->donees);
@@ -1435,7 +1462,7 @@ int ikglp_unlock(struct litmus_lock* l)
                                                    (other_fq->hp_waiter) ? other_fq->hp_waiter->comm : "null",
                                                    (other_fq->hp_waiter) ? other_fq->hp_waiter->pid : 0);
 
-                                ikglp_refresh_owners_prio_decrease(other_fq, sem, flags); // unlocks sem->lock.  reacquire it.
+                                ikglp_refresh_owners_prio_decrease(other_fq, sem, flags, 0); // unlocks sem->lock.  reacquire it.
                                 lock_fine_irqsave(&sem->lock, flags);  // there should be no contention!!!!
                         }
                 }
@@ -1445,7 +1472,7 @@ int ikglp_unlock(struct litmus_lock* l)
                                    ikglp_get_idx(sem, to_steal));
 
                 if(need_steal_prio_reeval) {
-                        ikglp_refresh_owners_prio_decrease(to_steal, sem, flags); // unlocks sem->lock.  reacquire it.
+                        ikglp_refresh_owners_prio_decrease(to_steal, sem, flags, 0); // unlocks sem->lock.  reacquire it.
                         lock_fine_irqsave(&sem->lock, flags);  // there should be no contention!!!!
                 }
         }
@@ -1481,6 +1508,7 @@ int ikglp_unlock(struct litmus_lock* l)
                 }
         }
 
+
 wake_kludge:
         if(waitqueue_active(&fq->wait))
         {
@@ -1509,7 +1537,6 @@ wake_kludge:
 
                 /* determine new hp_waiter if necessary */
                 if (next == fq->hp_waiter) {
-
                         TRACE_TASK(next, "was highest-prio waiter\n");
                         /* next has the highest priority --- it doesn't need to
                          * inherit.  However, we need to make sure that the
@@ -1595,10 +1622,9 @@ wake_kludge:
         }
 
         unlock_fine_irqrestore(&sem->lock, flags);
+        raw_spin_unlock_irqrestore(&sem->real_lock, more_flags);
         unlock_global_irqrestore(dgl_lock, flags);
 
-        raw_spin_unlock_irqrestore(&sem->real_lock, real_flags);
-
         TRACE_CUR("done with freeing replica.\n");
 
 out:
@@ -1608,7 +1634,145 @@ out:
 
 void ikglp_budget_exhausted(struct litmus_lock* l, struct task_struct* t)
 {
-        TRACE_TASK(t, "TODO!\n");
+        /*
+         * PRE: (1) Our deadline has already been postponed.
+         *      (2) DLG lock is already held of DGLs are supported.
+         *
+         * Exhaustion Response: Remove request from locks and re-issue it.
+         *
+         * step 1: first check that we are actually blocked.
+         * step 2: remove our request from ANY data structure:
+         *              - donor heap
+         *              - pq
+         *              - fq
+         * step 3: reissue the request
+         */
+
+        struct ikglp_semaphore *sem = ikglp_from_lock(l);
+        struct litmus_lock* blocked_lock;
+        unsigned long flags = 0, more_flags;
+
+        raw_spin_lock_irqsave(&sem->real_lock, more_flags);
+        lock_fine_irqsave(&sem->lock, flags);
+
+        blocked_lock = tsk_rt(t)->blocked_lock;
+        if (blocked_lock == l) {
+                ikglp_wait_state_t      *wait = (ikglp_wait_state_t*)tsk_rt(t)->blocked_lock_data;
+                ikglp_donee_heap_node_t *donee_info;
+                struct task_struct      *donee;
+                struct fifo_queue       *donee_fq;
+                BUG_ON(!wait);
+
+                /* drop the request from the proper IKGLP data structure and re-eval
+                 * priority relations */
+                switch(wait->cur_q)
+                {
+                        case IKGLP_PQ:
+                                // No one inherits from waiters in PQ. Just drop the request.
+                                __drop_from_pq(sem, wait);
+                                break;
+                        case IKGLP_FQ:
+                                __drop_from_fq(sem, wait);
+                                ikglp_refresh_owners_prio_decrease(wait->donee_heap_node.fq, sem, flags, 1); // unlocks sem->lock.  reacquire it.
+                                lock_fine_irqsave(&sem->lock, flags);  // there should be no contention!!!!
+                                break;
+                        case IKGLP_DONOR:
+                                __drop_from_donor(sem, wait);
+                                /* update donee */
+                                donee_info = wait->donee_info;
+                                donee_info->donor_info = NULL;  // clear the cross-link
+                                binheap_decrease(&donee_info->node, &sem->donees);
+
+                                donee = donee_info->task;
+                                donee_fq = donee_info->fq;
+                                if (donee == donee_fq->owner) {
+                                        TRACE_TASK(t, "Donee %s/%d is an owner of fq %d.\n",
+                                                           donee->comm, donee->pid,
+                                                           ikglp_get_idx(sem, donee_fq));
+                                        ikglp_remove_donation_from_owner(&wait->prio_donation.hp_binheap_node, donee_fq, sem, flags);   // unlocks sem->lock.  reacquire it.
+                                        lock_fine_irqsave(&sem->lock, flags);  // there should be no contention!!!!
+                                }
+                                else {
+                                        TRACE_TASK(t, "Donee %s/%d is blocked in of fq %d.\n",
+                                                           donee->comm, donee->pid,
+                                                           ikglp_get_idx(sem, donee_fq));
+
+                                        ikglp_remove_donation_from_fq_waiter(donee, &wait->prio_donation.hp_binheap_node);
+                                        if(donee == donee_fq->hp_waiter) {
+                                                TRACE_TASK(t, "Donee %s/%d was an hp_waiter of fq %d. Rechecking hp_waiter.\n",
+                                                                   donee->comm, donee->pid,
+                                                                   ikglp_get_idx(sem, donee_fq));
+
+                                                donee_fq->hp_waiter = ikglp_find_hp_waiter(donee_fq, NULL);
+                                                TRACE_TASK(t, "New hp_waiter for fq %d is %s/%d!\n",
+                                                                   ikglp_get_idx(sem, donee_fq),
+                                                                   (donee_fq->hp_waiter) ? donee_fq->hp_waiter->comm : "null",
+                                                                   (donee_fq->hp_waiter) ? donee_fq->hp_waiter->pid : 0);
+
+                                                ikglp_refresh_owners_prio_decrease(donee_fq, sem, flags, 1); // unlocks sem->lock.  reacquire it.
+                                                lock_fine_irqsave(&sem->lock, flags);  // there should be no contention!!!!
+                                        }
+                                }
+
+                                break;
+                        default:
+                                BUG();
+                }
+
+                BUG_ON(wait->cur_q != IKGLP_INVL); /* state should now be invalid */
+
+                /* now re-issue the request */
+
+                TRACE_TASK(t, "Reissuing a request for replica from lock %d.\n", l->ident);
+
+                if(sem->nr_in_fifos < sem->max_in_fifos) {
+                        struct fifo_queue *fq;
+
+                        // enqueue somwhere
+#ifdef CONFIG_LITMUS_AFFINITY_LOCKING
+                        fq = (sem->aff_obs) ?
+                                sem->aff_obs->ops->advise_enqueue(sem->aff_obs, t) :
+                                sem->shortest_fifo_queue;
+#else
+                        fq = sem->shortest_fifo_queue;
+#endif
+                        TRACE_TASK(t, "is going to an FQ.\n");
+                        /* if this were true, then we should have been blocked */
+                        BUG_ON(fq->count == 0);
+                        ikglp_enqueue_on_fq(sem, fq, wait, flags);  // unlocks sem->lock
+                }
+                else if(litmus->__compare(ikglp_mth_highest(sem), BASE, t, BASE)) {
+                        TRACE_TASK(t, "is going to PQ.\n");
+                        // enqueue on PQ
+                        ikglp_enqueue_on_pq(sem, wait);
+                        unlock_fine_irqrestore(&sem->lock, flags);
+                }
+                else {
+                        // enqueue as donor
+                        TRACE_TASK(t, "is going to donor heap.\n");
+                        ikglp_enqueue_on_donor(sem, wait, flags);        // unlocks sem->lock
+                }
+
+                raw_spin_unlock_irqrestore(&sem->real_lock, more_flags);
+        }
+        else if (blocked_lock) {
+                unlock_fine_irqrestore(&sem->lock, flags);
+                raw_spin_unlock_irqrestore(&sem->real_lock, more_flags);
+
+                TRACE_TASK(t, "is blocked, but not on IKGLP. Redirecting...\n");
+                if(blocked_lock->ops->supports_budget_exhaustion) {
+                        TRACE_TASK(t, "Lock %d supports budget exhaustion.\n",
+                                           blocked_lock->ident);
+                        blocked_lock->ops->budget_exhausted(blocked_lock, t);
+                }
+        }
+        else {
+                TRACE_TASK(t, "appears to be no longer blocked.\n");
+                unlock_fine_irqrestore(&sem->lock, flags);
+                raw_spin_unlock_irqrestore(&sem->real_lock, more_flags);
+        }
+
+        return;
 }
 
 void ikglp_virtual_unlock(struct litmus_lock* l, struct task_struct* t)
@@ -2593,19 +2757,17 @@ void gpu_ikglp_notify_dequeue(struct ikglp_affinity* aff, struct fifo_queue* fq,
 int gpu_ikglp_notify_exit(struct ikglp_affinity* aff, struct task_struct* t)
 {
         struct ikglp_semaphore *sem = ikglp_from_lock(aff->obs.lock);
-        unsigned long flags = 0, real_flags;
+        unsigned long flags = 0, more_flags;
         int aff_rsrc;
 #ifdef CONFIG_LITMUS_DGL_SUPPORT
-        raw_spinlock_t *dgl_lock;
-
-        dgl_lock = litmus->get_dgl_spinlock(t);
+        raw_spinlock_t *dgl_lock = litmus->get_dgl_spinlock(t);
 #endif
 
         if (tsk_rt(t)->last_gpu < 0)
                 return 0;
 
-        raw_spin_lock_irqsave(&sem->real_lock, real_flags);
         lock_global_irqsave(dgl_lock, flags);
+        raw_spin_lock_irqsave(&sem->real_lock, more_flags);
         lock_fine_irqsave(&sem->lock, flags);
 
         // decrement affinity count on old GPU
@@ -2618,8 +2780,8 @@ int gpu_ikglp_notify_exit(struct ikglp_affinity* aff, struct task_struct* t)
         }
 
         unlock_fine_irqrestore(&sem->lock, flags);
+        raw_spin_unlock_irqrestore(&sem->real_lock, more_flags);
         unlock_global_irqrestore(dgl_lock, flags);
-        raw_spin_unlock_irqrestore(&sem->real_lock, real_flags);
 
         return 0;
 }