Rename RSM Mutex to FIFO Mutex

8 files changed, 126 insertions, 126 deletions

diff --git a/include/litmus/fdso.h b/include/litmus/fdso.h
index 1469c0fd0460..e1a0ac24b8a2 100644
--- a/include/litmus/fdso.h
+++ b/include/litmus/fdso.h
@@ -26,7 +26,7 @@ typedef enum  {
 
         PCP_SEM     = 5,
 
-        RSM_MUTEX       = 6,
+        FIFO_MUTEX      = 6,
         IKGLP_SEM       = 7,
         KFMLP_SEM       = 8,
 
@@ -83,7 +83,7 @@ static inline void* od_lookup(int od, obj_type_t type)
 #define lookup_srp_sem(od) ((struct srp_semaphore*) od_lookup(od, SRP_SEM))
 #define lookup_ics(od)     ((struct ics*)           od_lookup(od, ICS_ID))
 
-#define lookup_rsm_mutex(od)((struct litmus_lock*)  od_lookup(od, FMLP_SEM))
+#define lookup_fifo_mutex(od)((struct litmus_lock*)  od_lookup(od, FIFO_MUTEX))
 
 
 #endif
diff --git a/include/litmus/fifo_lock.h b/include/litmus/fifo_lock.h
new file mode 100644
index 000000000000..4b970806117f
--- /dev/null
+++ b/include/litmus/fifo_lock.h
@@ -0,0 +1,55 @@
+#ifndef LITMUS_fifo_H
+#define LITMUS_fifo_H
+
+#include <litmus/litmus.h>
+#include <litmus/binheap.h>
+#include <litmus/locking.h>
+
+/* struct for semaphore with priority inheritance */
+struct fifo_mutex {
+        struct litmus_lock litmus_lock;
+
+        /* current resource holder */
+        struct task_struct *owner;
+
+        /* highest-priority waiter */
+        struct task_struct *hp_waiter;
+
+        /* FIFO queue of waiting tasks -- for now.  time stamp in the future. */
+        wait_queue_head_t       wait;
+
+        /* we do some nesting within spinlocks, so we can't use the normal
+         sleeplocks found in wait_queue_head_t. */
+        raw_spinlock_t          lock;
+};
+
+static inline struct fifo_mutex* fifo_mutex_from_lock(struct litmus_lock* lock)
+{
+        return container_of(lock, struct fifo_mutex, litmus_lock);
+}
+
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+int fifo_mutex_is_owner(struct litmus_lock *l, struct task_struct *t);
+int fifo_mutex_dgl_lock(struct litmus_lock *l, dgl_wait_state_t* dgl_wait, wait_queue_t* wq_node);
+void fifo_mutex_enable_priority(struct litmus_lock *l, dgl_wait_state_t* dgl_wait);
+#endif
+
+void fifo_mutex_propagate_increase_inheritance(struct litmus_lock* l,
+                                                                                          struct task_struct* t,
+                                                                                          raw_spinlock_t* to_unlock,
+                                                                                          unsigned long irqflags);
+
+void fifo_mutex_propagate_decrease_inheritance(struct litmus_lock* l,
+                                                                                          struct task_struct* t,
+                                                                                          raw_spinlock_t* to_unlock,
+                                                                                          unsigned long irqflags);
+
+int fifo_mutex_lock(struct litmus_lock* l);
+int fifo_mutex_unlock(struct litmus_lock* l);
+int fifo_mutex_close(struct litmus_lock* l);
+void fifo_mutex_free(struct litmus_lock* l);
+struct litmus_lock* fifo_mutex_new(struct litmus_lock_ops*);
+
+
+#endif
+
diff --git a/include/litmus/rsm_lock.h b/include/litmus/rsm_lock.h
deleted file mode 100644
index f0d263322a69..000000000000
--- a/include/litmus/rsm_lock.h
+++ /dev/null
@@ -1,55 +0,0 @@
-#ifndef LITMUS_RSM_H
-#define LITMUS_RSM_H
-
-#include <litmus/litmus.h>
-#include <litmus/binheap.h>
-#include <litmus/locking.h>
-
-/* struct for semaphore with priority inheritance */
-struct rsm_mutex {
-        struct litmus_lock litmus_lock;
-
-        /* current resource holder */
-        struct task_struct *owner;
-
-        /* highest-priority waiter */
-        struct task_struct *hp_waiter;
-
-        /* FIFO queue of waiting tasks -- for now.  time stamp in the future. */
-        wait_queue_head_t       wait;
-
-        /* we do some nesting within spinlocks, so we can't use the normal
-         sleeplocks found in wait_queue_head_t. */
-        raw_spinlock_t          lock;
-};
-
-static inline struct rsm_mutex* rsm_mutex_from_lock(struct litmus_lock* lock)
-{
-        return container_of(lock, struct rsm_mutex, litmus_lock);
-}
-
-#ifdef CONFIG_LITMUS_DGL_SUPPORT
-int rsm_mutex_is_owner(struct litmus_lock *l, struct task_struct *t);
-int rsm_mutex_dgl_lock(struct litmus_lock *l, dgl_wait_state_t* dgl_wait, wait_queue_t* wq_node);
-void rsm_mutex_enable_priority(struct litmus_lock *l, dgl_wait_state_t* dgl_wait);
-#endif
-
-void rsm_mutex_propagate_increase_inheritance(struct litmus_lock* l,
-                                                                                          struct task_struct* t,
-                                                                                          raw_spinlock_t* to_unlock,
-                                                                                          unsigned long irqflags);
-
-void rsm_mutex_propagate_decrease_inheritance(struct litmus_lock* l,
-                                                                                          struct task_struct* t,
-                                                                                          raw_spinlock_t* to_unlock,
-                                                                                          unsigned long irqflags);
-
-int rsm_mutex_lock(struct litmus_lock* l);
-int rsm_mutex_unlock(struct litmus_lock* l);
-int rsm_mutex_close(struct litmus_lock* l);
-void rsm_mutex_free(struct litmus_lock* l);
-struct litmus_lock* rsm_mutex_new(struct litmus_lock_ops*);
-
-
-#endif
-
diff --git a/litmus/Makefile b/litmus/Makefile
index 67d8b8ee72bc..6ad94f69a347 100644
--- a/litmus/Makefile
+++ b/litmus/Makefile
@@ -33,7 +33,7 @@ obj-$(CONFIG_SCHED_DEBUG_TRACE) += sched_trace.o
 obj-$(CONFIG_SCHED_OVERHEAD_TRACE) += trace.o
 
 obj-$(CONFIG_LITMUS_LOCKING) += kfmlp_lock.o
-obj-$(CONFIG_LITMUS_NESTED_LOCKING) += rsm_lock.o ikglp_lock.o
+obj-$(CONFIG_LITMUS_NESTED_LOCKING) += fifo_lock.o ikglp_lock.o
 obj-$(CONFIG_LITMUS_SOFTIRQD) += litmus_softirq.o
 obj-$(CONFIG_LITMUS_PAI_SOFTIRQD) += litmus_pai_softirq.o
 obj-$(CONFIG_LITMUS_NVIDIA) += nvidia_info.o sched_trace_external.o
diff --git a/litmus/fdso.c b/litmus/fdso.c
index 3749d6beb107..1fcc47a6a62b 100644
--- a/litmus/fdso.c
+++ b/litmus/fdso.c
@@ -33,7 +33,7 @@ static const struct fdso_ops* fdso_ops[] = {
         &generic_lock_ops, /* DPCP_SEM */
         &generic_lock_ops, /* PCP_SEM */
 
-        &generic_lock_ops, /* RSM_MUTEX */
+        &generic_lock_ops, /* FIFO_MUTEX */
         &generic_lock_ops, /* IKGLP_SEM */
         &generic_lock_ops, /* KFMLP_SEM */
 #ifdef CONFIG_LITMUS_AFFINITY_LOCKING
diff --git a/litmus/rsm_lock.c b/litmus/fifo_lock.c
index beb2aa1a4f54..eb42aeee20eb 100644
--- a/litmus/rsm_lock.c
+++ b/litmus/fifo_lock.c
@@ -3,7 +3,7 @@
 
 #include <litmus/trace.h>
 #include <litmus/sched_plugin.h>
-#include <litmus/rsm_lock.h>
+#include <litmus/fifo_lock.h>
 
 #include <litmus/litmus_proc.h>
 
@@ -15,7 +15,7 @@
 
 
 /* caller is responsible for locking */
-static struct task_struct* rsm_mutex_find_hp_waiter(struct rsm_mutex *mutex,
+static struct task_struct* fifo_mutex_find_hp_waiter(struct fifo_mutex *mutex,
                                                                                          struct task_struct* skip)
 {
         wait_queue_t            *q;
@@ -58,19 +58,19 @@ static struct task_struct* rsm_mutex_find_hp_waiter(struct rsm_mutex *mutex,
 
 #ifdef CONFIG_LITMUS_DGL_SUPPORT
 
-int rsm_mutex_is_owner(struct litmus_lock *l, struct task_struct *t)
+int fifo_mutex_is_owner(struct litmus_lock *l, struct task_struct *t)
 {
-        struct rsm_mutex *mutex = rsm_mutex_from_lock(l);
+        struct fifo_mutex *mutex = fifo_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.
-int rsm_mutex_dgl_lock(struct litmus_lock *l, dgl_wait_state_t* dgl_wait,
+int fifo_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 fifo_mutex *mutex = fifo_mutex_from_lock(l);
         struct task_struct *t = dgl_wait->task;
 
         int acquired_immediatly = 0;
@@ -102,10 +102,10 @@ int rsm_mutex_dgl_lock(struct litmus_lock *l, dgl_wait_state_t* dgl_wait,
         return acquired_immediatly;
 }
 
-void rsm_mutex_enable_priority(struct litmus_lock *l,
+void fifo_mutex_enable_priority(struct litmus_lock *l,
                                                            dgl_wait_state_t* dgl_wait)
 {
-        struct rsm_mutex *mutex = rsm_mutex_from_lock(l);
+        struct fifo_mutex *mutex = fifo_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
@@ -185,11 +185,11 @@ static void select_next_lock_if_primary(struct litmus_lock *l,
 
 
 
-int rsm_mutex_lock(struct litmus_lock* l)
+int fifo_mutex_lock(struct litmus_lock* l)
 {
         struct task_struct *t = current;
         struct task_struct *owner;
-        struct rsm_mutex *mutex = rsm_mutex_from_lock(l);
+        struct fifo_mutex *mutex = fifo_mutex_from_lock(l);
         wait_queue_t wait;
         unsigned long flags;
 
@@ -325,10 +325,10 @@ int rsm_mutex_lock(struct litmus_lock* l)
 
 
 
-int rsm_mutex_unlock(struct litmus_lock* l)
+int fifo_mutex_unlock(struct litmus_lock* l)
 {
         struct task_struct *t = current, *next = NULL;
-        struct rsm_mutex *mutex = rsm_mutex_from_lock(l);
+        struct fifo_mutex *mutex = fifo_mutex_from_lock(l);
         unsigned long flags;
 
         struct task_struct *old_max_eff_prio;
@@ -416,7 +416,7 @@ int rsm_mutex_unlock(struct litmus_lock* l)
                          * inherit.  However, we need to make sure that the
                          * next-highest priority in the queue is reflected in
                          * hp_waiter. */
-                        mutex->hp_waiter = rsm_mutex_find_hp_waiter(mutex, next);
+                        mutex->hp_waiter = fifo_mutex_find_hp_waiter(mutex, next);
                         l->nest.hp_waiter_eff_prio = (mutex->hp_waiter) ?
                                 effective_priority(mutex->hp_waiter) :
                                 NULL;
@@ -537,12 +537,12 @@ out:
 }
 
 
-void rsm_mutex_propagate_increase_inheritance(struct litmus_lock* l,
+void fifo_mutex_propagate_increase_inheritance(struct litmus_lock* l,
                                                                                         struct task_struct* t,
                                                                                         raw_spinlock_t* to_unlock,
                                                                                         unsigned long irqflags)
 {
-        struct rsm_mutex *mutex = rsm_mutex_from_lock(l);
+        struct fifo_mutex *mutex = fifo_mutex_from_lock(l);
 
         // relay-style locking
         lock_fine(&mutex->lock);
@@ -634,12 +634,12 @@ void rsm_mutex_propagate_increase_inheritance(struct litmus_lock* l,
 }
 
 
-void rsm_mutex_propagate_decrease_inheritance(struct litmus_lock* l,
+void fifo_mutex_propagate_decrease_inheritance(struct litmus_lock* l,
                                                                                          struct task_struct* t,
                                                                                          raw_spinlock_t* to_unlock,
                                                                                          unsigned long irqflags)
 {
-        struct rsm_mutex *mutex = rsm_mutex_from_lock(l);
+        struct fifo_mutex *mutex = fifo_mutex_from_lock(l);
 
         // relay-style locking
         lock_fine(&mutex->lock);
@@ -657,7 +657,7 @@ void rsm_mutex_propagate_decrease_inheritance(struct litmus_lock* l,
                         old_max_eff_prio = top_priority(&tsk_rt(owner)->hp_blocked_tasks);
 
                         binheap_delete(&l->nest.hp_binheap_node, &tsk_rt(owner)->hp_blocked_tasks);
-                        mutex->hp_waiter = rsm_mutex_find_hp_waiter(mutex, NULL);
+                        mutex->hp_waiter = fifo_mutex_find_hp_waiter(mutex, NULL);
                         l->nest.hp_waiter_eff_prio = (mutex->hp_waiter) ?
                                 effective_priority(mutex->hp_waiter) : NULL;
                         binheap_add(&l->nest.hp_binheap_node,
@@ -740,10 +740,10 @@ void rsm_mutex_propagate_decrease_inheritance(struct litmus_lock* l,
 }
 
 
-int rsm_mutex_close(struct litmus_lock* l)
+int fifo_mutex_close(struct litmus_lock* l)
 {
         struct task_struct *t = current;
-        struct rsm_mutex *mutex = rsm_mutex_from_lock(l);
+        struct fifo_mutex *mutex = fifo_mutex_from_lock(l);
         unsigned long flags;
 
         int owner;
@@ -763,24 +763,24 @@ int rsm_mutex_close(struct litmus_lock* l)
         /*
          TODO: Currently panic.  FIX THIS!
         if (owner)
-                rsm_mutex_unlock(l);
+                fifo_mutex_unlock(l);
         */
 
         return 0;
 }
 
-void rsm_mutex_free(struct litmus_lock* lock)
+void fifo_mutex_free(struct litmus_lock* lock)
 {
-        kfree(rsm_mutex_from_lock(lock));
+        kfree(fifo_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)
+static int fifo_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);
+        struct fifo_mutex *mutex = fifo_mutex_from_lock((struct litmus_lock*)data);
 
         int attempts = 0;
         const int max_attempts = 10;
@@ -903,28 +903,28 @@ static int rsm_proc_print(char *page, char **start, off_t off, int count, int *e
         return count - size;
 }
 
-static void rsm_proc_add(struct litmus_lock* l)
+static void fifo_proc_add(struct litmus_lock* l)
 {
-        snprintf(l->name, LOCK_NAME_LEN, "rsm-%d_%p", l->ident, l);
+        snprintf(l->name, LOCK_NAME_LEN, "fifo-%d", l->ident);
 
-        l->proc_entry = litmus_add_proc_lock(l, rsm_proc_print);
+        l->proc_entry = litmus_add_proc_lock(l, fifo_proc_print);
 }
 
-static void rsm_proc_remove(struct litmus_lock* l)
+static void fifo_proc_remove(struct litmus_lock* l)
 {
         litmus_remove_proc_lock(l);
 }
 
-static struct litmus_lock_proc_ops rsm_proc_ops =
+static struct litmus_lock_proc_ops fifo_proc_ops =
 {
-        .add = rsm_proc_add,
-        .remove = rsm_proc_remove
+        .add = fifo_proc_add,
+        .remove = fifo_proc_remove
 };
 
 
-struct litmus_lock* rsm_mutex_new(struct litmus_lock_ops* ops)
+struct litmus_lock* fifo_mutex_new(struct litmus_lock_ops* ops)
 {
-        struct rsm_mutex* mutex;
+        struct fifo_mutex* mutex;
 
         mutex = kmalloc(sizeof(*mutex), GFP_KERNEL);
         if (!mutex)
@@ -949,7 +949,7 @@ 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;
+        ((struct litmus_lock*)mutex)->proc = &fifo_proc_ops;
 
         return &mutex->litmus_lock;
 }
diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index e2737bafa9b8..2246e9b8754e 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -51,7 +51,7 @@
 #endif
 
 #ifdef CONFIG_LITMUS_NESTED_LOCKING
-#include <litmus/rsm_lock.h>
+#include <litmus/fifo_lock.h>
 #include <litmus/ikglp_lock.h>
 #endif
 
@@ -1523,27 +1523,27 @@ static void nested_decrease_priority_inheritance(struct task_struct* t,
 }
 
 
-/* ******************** RSM MUTEX ********************** */
+/* ******************** FIFO MUTEX ********************** */
 
-static struct litmus_lock_ops cedf_rsm_mutex_lock_ops = {
-        .lock   = rsm_mutex_lock,
-        .unlock = rsm_mutex_unlock,
-        .close  = rsm_mutex_close,
-        .deallocate = rsm_mutex_free,
+static struct litmus_lock_ops cedf_fifo_mutex_lock_ops = {
+        .lock   = fifo_mutex_lock,
+        .unlock = fifo_mutex_unlock,
+        .close  = fifo_mutex_close,
+        .deallocate = fifo_mutex_free,
 
-        .propagate_increase_inheritance = rsm_mutex_propagate_increase_inheritance,
-        .propagate_decrease_inheritance = rsm_mutex_propagate_decrease_inheritance,
+        .propagate_increase_inheritance = fifo_mutex_propagate_increase_inheritance,
+        .propagate_decrease_inheritance = fifo_mutex_propagate_decrease_inheritance,
 
 #ifdef CONFIG_LITMUS_DGL_SUPPORT
-        .dgl_lock = rsm_mutex_dgl_lock,
-        .is_owner = rsm_mutex_is_owner,
-        .enable_priority = rsm_mutex_enable_priority,
+        .dgl_lock = fifo_mutex_dgl_lock,
+        .is_owner = fifo_mutex_is_owner,
+        .enable_priority = fifo_mutex_enable_priority,
 #endif
 };
 
-static struct litmus_lock* cedf_new_rsm_mutex(void)
+static struct litmus_lock* cedf_new_fifo_mutex(void)
 {
-        return rsm_mutex_new(&cedf_rsm_mutex_lock_ops);
+        return fifo_mutex_new(&cedf_fifo_mutex_lock_ops);
 }
 
 /* ******************** IKGLP ********************** */
@@ -1599,8 +1599,8 @@ static long cedf_allocate_lock(struct litmus_lock **lock, int type,
 
         switch (type) {
 #ifdef CONFIG_LITMUS_NESTED_LOCKING
-                case RSM_MUTEX:
-                        *lock = cedf_new_rsm_mutex();
+                case FIFO_MUTEX:
+                        *lock = cedf_new_fifo_mutex();
                         break;
 
                 case IKGLP_SEM:
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index e290aed53d4d..886bd14f677c 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -33,7 +33,7 @@
 #endif
 
 #ifdef CONFIG_LITMUS_NESTED_LOCKING
-#include <litmus/rsm_lock.h>
+#include <litmus/fifo_lock.h>
 #include <litmus/ikglp_lock.h>
 #endif
 
@@ -1457,27 +1457,27 @@ static void nested_decrease_priority_inheritance(struct task_struct* t,
 }
 
 
-/* ******************** RSM MUTEX ********************** */
+/* ******************** FIFO MUTEX ********************** */
 
-static struct litmus_lock_ops gsnedf_rsm_mutex_lock_ops = {
-        .lock   = rsm_mutex_lock,
-        .unlock = rsm_mutex_unlock,
-        .close  = rsm_mutex_close,
-        .deallocate = rsm_mutex_free,
+static struct litmus_lock_ops gsnedf_fifo_mutex_lock_ops = {
+        .lock   = fifo_mutex_lock,
+        .unlock = fifo_mutex_unlock,
+        .close  = fifo_mutex_close,
+        .deallocate = fifo_mutex_free,
 
-        .propagate_increase_inheritance = rsm_mutex_propagate_increase_inheritance,
-        .propagate_decrease_inheritance = rsm_mutex_propagate_decrease_inheritance,
+        .propagate_increase_inheritance = fifo_mutex_propagate_increase_inheritance,
+        .propagate_decrease_inheritance = fifo_mutex_propagate_decrease_inheritance,
 
 #ifdef CONFIG_LITMUS_DGL_SUPPORT
-        .dgl_lock = rsm_mutex_dgl_lock,
-        .is_owner = rsm_mutex_is_owner,
-        .enable_priority = rsm_mutex_enable_priority,
+        .dgl_lock = fifo_mutex_dgl_lock,
+        .is_owner = fifo_mutex_is_owner,
+        .enable_priority = fifo_mutex_enable_priority,
 #endif
 };
 
-static struct litmus_lock* gsnedf_new_rsm_mutex(void)
+static struct litmus_lock* gsnedf_new_fifo_mutex(void)
 {
-        return rsm_mutex_new(&gsnedf_rsm_mutex_lock_ops);
+        return fifo_mutex_new(&gsnedf_fifo_mutex_lock_ops);
 }
 
 /* ******************** IKGLP ********************** */
@@ -1739,8 +1739,8 @@ static long gsnedf_allocate_lock(struct litmus_lock **lock, int type,
                 *lock = gsnedf_new_fmlp();
                 break;
 #ifdef CONFIG_LITMUS_NESTED_LOCKING
-    case RSM_MUTEX:
-                *lock = gsnedf_new_rsm_mutex();
+    case FIFO_MUTEX:
+                *lock = gsnedf_new_fifo_mutex();
                 break;
 
         case IKGLP_SEM: