1 files changed, 190 insertions, 32 deletions

diff --git a/litmus/rsm_lock.c b/litmus/rsm_lock.c
index 3dfd8ae9d221..ae6dd3fb237b 100644
--- a/litmus/rsm_lock.c
+++ b/litmus/rsm_lock.c
@@ -5,6 +5,8 @@
 #include <litmus/sched_plugin.h>
 #include <litmus/rsm_lock.h>
 
+#include <litmus/litmus_proc.h>
+
 //#include <litmus/edf_common.h>
 
 #if defined(CONFIG_LITMUS_AFFINITY_LOCKING) && defined(CONFIG_LITMUS_NVIDIA)
@@ -14,43 +16,43 @@
 
 /* caller is responsible for locking */
 static struct task_struct* rsm_mutex_find_hp_waiter(struct rsm_mutex *mutex,
-                                             struct task_struct* skip)
+                                                                                         struct task_struct* skip)
 {
-    wait_queue_t        *q;
-    struct list_head    *pos;
-    struct task_struct  *queued = NULL, *found = NULL;
+        wait_queue_t            *q;
+        struct list_head        *pos;
+        struct task_struct  *queued = NULL, *found = NULL;
 
 #ifdef CONFIG_LITMUS_DGL_SUPPORT
-    dgl_wait_state_t    *dgl_wait = NULL;
+        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);
+        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;
-        }
+                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;
+                queued = (struct task_struct*) q->private;
 #endif
 
-        /* Compare task prios, find high prio task. */
-        //if (queued && queued != skip && edf_higher_prio(queued, found)) {
+                /* Compare task prios, find high prio task. */
+                //if (queued && queued != skip && edf_higher_prio(queued, found)) {
                 if (queued && queued != skip && litmus->compare(queued, found)) {
-            found = queued;
-        }
-    }
-    return found;
+                        found = queued;
+                }
+        }
+        return found;
 }
 
 
@@ -76,7 +78,8 @@ int rsm_mutex_dgl_lock(struct litmus_lock *l, dgl_wait_state_t* dgl_wait,
         BUG_ON(t != current);
 
         if (mutex->owner) {
-                TRACE_TASK(t, "Enqueuing on lock %d.\n", l->ident);
+                TRACE_TASK(t, "Enqueuing on lock %d (held by %s/%d).\n",
+                                        l->ident, mutex->owner->comm, mutex->owner->pid);
 
                 init_dgl_waitqueue_entry(wq_node, dgl_wait);
 
@@ -205,7 +208,8 @@ int rsm_mutex_lock(struct litmus_lock* l)
         lock_fine_irqsave(&mutex->lock, flags);
 
         if (mutex->owner) {
-                TRACE_TASK(t, "Blocking on lock %d.\n", l->ident);
+                TRACE_TASK(t, "Blocking on lock %d (held by %s/%d).\n",
+                                                l->ident, mutex->owner->comm, mutex->owner->pid);
 
 #if defined(CONFIG_LITMUS_AFFINITY_LOCKING) && defined(CONFIG_LITMUS_NVIDIA)
                 // KLUDGE: don't count this suspension as time in the critical gpu
@@ -358,7 +362,7 @@ int rsm_mutex_unlock(struct litmus_lock* l)
                         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))  )
@@ -402,7 +406,7 @@ int rsm_mutex_unlock(struct litmus_lock* l)
         if (next) {
                 /* next becomes the resouce holder */
                 mutex->owner = next;
-                TRACE_CUR("lock ownership passed to %s/%d\n", next->comm, next->pid);
+                TRACE_CUR("lock %d ownership passed to %s/%d\n", l->ident, next->comm, next->pid);
 
                 /* determine new hp_waiter if necessary */
                 if (next == mutex->hp_waiter) {
@@ -459,7 +463,7 @@ int rsm_mutex_unlock(struct litmus_lock* l)
 #endif
 
                         /* It is possible that 'next' *should* be the hp_waiter, but isn't
-                     * because that update hasn't yet executed (update operation is
+                         * because that update hasn't yet executed (update operation is
                          * probably blocked on mutex->lock). So only inherit if the top of
                          * 'next's top heap node is indeed the effective prio. of hp_waiter.
                          * (We use l->hp_waiter_eff_prio instead of effective_priority(hp_waiter)
@@ -693,7 +697,7 @@ void rsm_mutex_propagate_decrease_inheritance(struct litmus_lock* l,
                                 }
 
                                 // beware: recursion
-                                litmus->nested_decrease_prio(owner, decreased_prio, &mutex->lock, irqflags);    // will unlock mutex->lock
+                                litmus->nested_decrease_prio(owner, decreased_prio, &mutex->lock, irqflags); // will unlock mutex->lock
                         }
                         else {
                                 raw_spin_unlock(&tsk_rt(owner)->hp_blocked_tasks_lock);
@@ -754,8 +758,11 @@ int rsm_mutex_close(struct litmus_lock* l)
         unlock_fine_irqrestore(&mutex->lock, flags);
         unlock_global_irqrestore(dgl_lock, flags);
 
+        /*
+         TODO: Currently panic.  FIX THIS!
         if (owner)
                 rsm_mutex_unlock(l);
+        */
 
         return 0;
 }
@@ -765,6 +772,154 @@ void rsm_mutex_free(struct litmus_lock* lock)
         kfree(rsm_mutex_from_lock(lock));
 }
 
+
+/* The following may race if DGLs are enabled.  Only examine /proc if things
+   appear to be locked up.  TODO: FIX THIS! Must find an elegant way to transmit
+   DGL lock to function. */
+static int rsm_proc_print(char *page, char **start, off_t off, int count, int *eof, void *data)
+{
+        struct rsm_mutex *mutex = rsm_mutex_from_lock((struct litmus_lock*)data);
+
+        int attempts = 0;
+        const int max_attempts = 10;
+        int locked = 0;
+        unsigned long flags;
+
+        int size = count;
+        char *next = page;
+        int w;
+
+        while(attempts < max_attempts)
+        {
+                locked = raw_spin_trylock_irqsave(&mutex->lock, flags);
+
+                if (unlikely(!locked)) {
+                        ++attempts;
+                        cpu_relax();
+                }
+                else {
+                        break;
+                }
+        }
+
+        if (locked) {
+                w = scnprintf(next, size, "%s:\n", mutex->litmus_lock.name);
+                size -= w;
+                next += w;
+
+                w = scnprintf(next, size,
+                                                "owner: %s/%d (inh: %s/%d)\n",
+                                                        (mutex->owner) ?
+                                                                mutex->owner->comm : "nil",
+                                                        (mutex->owner) ?
+                                                                mutex->owner->pid : -1,
+                                                        (mutex->owner && tsk_rt(mutex->owner)->inh_task) ?
+                                                                tsk_rt(mutex->owner)->inh_task->comm : "nil",
+                                                        (mutex->owner && tsk_rt(mutex->owner)->inh_task) ?
+                                                                tsk_rt(mutex->owner)->inh_task->pid : -1);
+                size -= w;
+                next += w;
+
+                w = scnprintf(next, size,
+                                                "hp waiter: %s/%d (inh: %s/%d)\n",
+                                                        (mutex->hp_waiter) ?
+                                                                mutex->hp_waiter->comm : "nil",
+                                                        (mutex->hp_waiter) ?
+                                                                mutex->hp_waiter->pid : -1,
+                                                        (mutex->hp_waiter && tsk_rt(mutex->hp_waiter)->inh_task) ?
+                                                                tsk_rt(mutex->hp_waiter)->inh_task->comm : "nil",
+                                                        (mutex->hp_waiter && tsk_rt(mutex->hp_waiter)->inh_task) ?
+                                                                tsk_rt(mutex->hp_waiter)->inh_task->pid : -1);
+                size -= w;
+                next += w;
+
+                w = scnprintf(next, size, "\nblocked tasks, front to back:\n");
+                size -= w;
+                next += w;
+
+                if (waitqueue_active(&mutex->wait)) {
+                        wait_queue_t *q;
+                        struct list_head *pos;
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+                        dgl_wait_state_t        *dgl_wait = NULL;
+#endif
+                        list_for_each(pos, &mutex->wait.task_list) {
+                                struct task_struct *blocked_task;
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+                                int enabled = 1;
+#endif
+                                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;
+                                        blocked_task = dgl_wait->task;
+
+                                        if(tsk_rt(blocked_task)->blocked_lock != &mutex->litmus_lock)
+                                                enabled = 0;
+                                }
+                                else {
+                                        blocked_task = (struct task_struct*) q->private;
+                                }
+#else
+                                blocked_task = (struct task_struct*) q->private;
+#endif
+
+                                w = scnprintf(next, size,
+                                                "\t%s/%d (inh: %s/%d)"
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+                                                " DGL enabled: %d"
+#endif
+                                                "\n",
+                                                blocked_task->comm, blocked_task->pid,
+                                                (tsk_rt(blocked_task)->inh_task) ?
+                                                        tsk_rt(blocked_task)->inh_task->comm : "nil",
+                                                (tsk_rt(blocked_task)->inh_task) ?
+                                                        tsk_rt(blocked_task)->inh_task->pid : -1
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+                                                , enabled
+#endif
+                                                );
+                                size -= w;
+                                next += w;
+                        }
+                }
+                else {
+                        w = scnprintf(next, size, "\t<NONE>\n");
+                        size -= w;
+                        next += w;
+                }
+
+                raw_spin_unlock_irqrestore(&mutex->lock, flags);
+        }
+        else {
+                w = scnprintf(next, size, "%s is busy.\n", mutex->litmus_lock.name);
+                size -= w;
+                next += w;
+        }
+
+        return count - size;
+}
+
+static void rsm_proc_add(struct litmus_lock* l)
+{
+        snprintf(l->name, LOCK_NAME_LEN, "rsm-%d", l->ident);
+
+        l->proc_entry = litmus_add_proc_lock(l, rsm_proc_print);
+}
+
+static void rsm_proc_remove(struct litmus_lock* l)
+{
+        litmus_remove_proc_lock(l);
+}
+
+static struct litmus_lock_proc_ops rsm_proc_ops =
+{
+        .add = rsm_proc_add,
+        .remove = rsm_proc_remove
+};
+
+
 struct litmus_lock* rsm_mutex_new(struct litmus_lock_ops* ops)
 {
         struct rsm_mutex* mutex;
@@ -772,6 +927,7 @@ struct litmus_lock* rsm_mutex_new(struct litmus_lock_ops* ops)
         mutex = kmalloc(sizeof(*mutex), GFP_KERNEL);
         if (!mutex)
                 return NULL;
+        memset(mutex, 0, sizeof(*mutex));
 
         mutex->litmus_lock.ops = ops;
         mutex->owner   = NULL;
@@ -791,6 +947,8 @@ struct litmus_lock* rsm_mutex_new(struct litmus_lock_ops* ops)
 
         ((struct litmus_lock*)mutex)->nest.hp_waiter_ptr = &mutex->hp_waiter;
 
+        ((struct litmus_lock*)mutex)->proc = &rsm_proc_ops;
+
         return &mutex->litmus_lock;
 }