1 files changed, 72 insertions, 21 deletions

diff --git a/litmus/locking.c b/litmus/locking.c
index c21ec1ae36d7..b7f02f0e6b24 100644
--- a/litmus/locking.c
+++ b/litmus/locking.c
@@ -28,7 +28,7 @@ struct fdso_ops generic_lock_ops = {
         .create  = create_generic_lock,
         .open    = open_generic_lock,
         .close   = close_generic_lock,
-        .destroy = destroy_generic_lock
+        .destroy = destroy_generic_lock,
 };
 
 static atomic_t lock_id_gen = ATOMIC_INIT(0);
@@ -59,12 +59,18 @@ static  int create_generic_lock(void** obj_ref, obj_type_t type, void* __user ar
                 INIT_BINHEAP_NODE(&lock->nest.hp_binheap_node);
                 if(!lock->nest.hp_waiter_ptr) {
                         TRACE_CUR("BEWARE: hp_waiter_ptr should probably not be NULL in "
-                                          "most uses. (exception: IKGLP donors)\n");
+                                          "most cases. (exception: IKGLP donors)\n");
                 }
 #endif
                 lock->type = type;
                 lock->ident = atomic_inc_return(&lock_id_gen);
                 *obj_ref = lock;
+
+                TRACE_CUR("Lock %d created. Type = %d\n.", lock->ident, type);
+
+                if (lock->proc && lock->proc->add) {
+                        lock->proc->add(lock);
+                }
     }
         return err;
 }
@@ -81,8 +87,14 @@ static int open_generic_lock(struct od_table_entry* entry, void* __user arg)
 static int close_generic_lock(struct od_table_entry* entry)
 {
         struct litmus_lock* lock = get_lock(entry);
-        if (lock->ops->close)
+        if (lock->ops->close) {
+
+                if (lock->proc && lock->proc->remove) {
+                        lock->proc->remove(lock);
+                }
+
                 return lock->ops->close(lock);
+        }
         else
                 return 0; /* default: closing succeeds */
 }
@@ -109,8 +121,11 @@ asmlinkage long sys_litmus_lock(int lock_od)
         if (entry && is_lock(entry)) {
                 l = get_lock(entry);
                 //TRACE_CUR("attempts to lock 0x%p\n", l);
-                TRACE_CUR("attempts to lock %d\n", l->ident);
+                TRACE_CUR("Attempts to lock %d\n", l->ident);
                 err = l->ops->lock(l);
+                if (!err) {
+                        TRACE_CUR("Got lock %d\n", l->ident);
+                }
         }
 
         /* Note: task my have been suspended or preempted in between!  Take
@@ -138,8 +153,11 @@ asmlinkage long sys_litmus_unlock(int lock_od)
         if (entry && is_lock(entry)) {
                 l = get_lock(entry);
                 //TRACE_CUR("attempts to unlock 0x%p\n", l);
-                TRACE_CUR("attempts to unlock %d\n", l->ident);
+                TRACE_CUR("Attempts to unlock %d\n", l->ident);
                 err = l->ops->unlock(l);
+                if (!err) {
+                        TRACE_CUR("Unlocked %d\n", l->ident);
+                }
         }
 
         /* Note: task my have been preempted in between!  Take this into
@@ -285,22 +303,50 @@ void init_dgl_waitqueue_entry(wait_queue_t *wq_node, dgl_wait_state_t* dgl_wait)
         wq_node->func = dgl_wake_up;
 }
 
+#ifdef CONFIG_SCHED_DEBUG_TRACE
+static void snprintf_dgl(char* buf, size_t bsz, struct litmus_lock* dgl_locks[], int sz)
+{
+        int i;
+        char* ptr;
+
+        ptr = buf;
+        for(i = 0; i < sz && ptr < buf+bsz; ++i)
+        {
+                struct litmus_lock *l = dgl_locks[i];
+                int remaining = bsz - (ptr-buf);
+                int written;
+
+                if(i == 0)
+                        written = snprintf(ptr, remaining, "%d ", l->ident);
+                else if(i == sz - 1)
+                        written = snprintf(ptr, remaining, " %d", l->ident);
+                else
+                        written = snprintf(ptr, remaining, " %d ", l->ident);
+                ptr += written;
+        }
+}
+#endif
 
 static long do_litmus_dgl_lock(dgl_wait_state_t *dgl_wait)
 {
         int i;
         unsigned long irqflags; //, dummyflags;
-        raw_spinlock_t *dgl_lock = litmus->get_dgl_spinlock(dgl_wait->task);
+        raw_spinlock_t *dgl_lock;
+
+#ifdef CONFIG_SCHED_DEBUG_TRACE
+        char dglstr[CONFIG_LITMUS_MAX_DGL_SIZE*5];
+        snprintf_dgl(dglstr, sizeof(dglstr), dgl_wait->locks, dgl_wait->size);
+        TRACE_CUR("Locking DGL with size %d: %s\n", dgl_wait->size, dglstr);
+#endif
+
+        dgl_lock = litmus->get_dgl_spinlock(dgl_wait->task);
 
         BUG_ON(dgl_wait->task != current);
 
         raw_spin_lock_irqsave(dgl_lock, irqflags);
 
-
         dgl_wait->nr_remaining = dgl_wait->size;
 
-        TRACE_CUR("Locking DGL with size %d\n", dgl_wait->size);
-
         // try to acquire each lock.  enqueue (non-blocking) if it is unavailable.
         for(i = 0; i < dgl_wait->size; ++i) {
                 struct litmus_lock *l = dgl_wait->locks[i];
@@ -347,7 +393,8 @@ static long do_litmus_dgl_lock(dgl_wait_state_t *dgl_wait)
 
                                 raw_spin_unlock_irqrestore(dgl_lock, irqflags);  // free dgl_lock before suspending
 
-                                schedule();  // suspend!!!
+                                suspend_for_lock(); // suspend!!!
+                                //schedule();  // suspend!!!
 
                                 TS_DGL_LOCK_RESUME;
 
@@ -443,7 +490,11 @@ static long do_litmus_dgl_unlock(struct litmus_lock* dgl_locks[], int dgl_size)
         int i;
         long err = 0;
 
-        TRACE_CUR("Unlocking a DGL of %d size\n", dgl_size);
+#ifdef CONFIG_SCHED_DEBUG_TRACE
+        char dglstr[CONFIG_LITMUS_MAX_DGL_SIZE*5];
+        snprintf_dgl(dglstr, sizeof(dglstr), dgl_locks, dgl_size);
+        TRACE_CUR("Unlocking a DGL with size %d: %s\n", dgl_size, dglstr);
+#endif
 
         for(i = dgl_size - 1; i >= 0; --i) {  // unlock in reverse order
 
@@ -573,16 +624,16 @@ void suspend_for_lock(void)
         unsigned int gpu_hide;
 #endif
 
-//#ifdef CONFIG_REALTIME_AUX_TASKS
-//      if (tsk_rt(t)->has_aux_tasks) {
-//              /* hide from aux tasks so they can't inherit our priority when we block
-//               * for a litmus lock. inheritance is already going to a litmus lock
-//               * holder. */
-//              aux_hide = tsk_rt(t)->hide_from_aux_tasks;
-//              aux_restore = 1;
-//              tsk_rt(t)->hide_from_aux_tasks = 1;
-//      }
-//#endif
+#ifdef CONFIG_REALTIME_AUX_TASKS
+        if (tsk_rt(t)->has_aux_tasks) {
+                /* hide from aux tasks so they can't inherit our priority when we block
+                 * for a litmus lock. inheritance is already going to a litmus lock
+                 * holder. */
+                aux_hide = tsk_rt(t)->hide_from_aux_tasks;
+                aux_restore = 1;
+                tsk_rt(t)->hide_from_aux_tasks = 1;
+        }
+#endif
 
 #ifdef CONFIG_LITMUS_NVIDIA
         if (tsk_rt(t)->held_gpus) {