Litmus core: add generic locking API

Provide a unified userspace interface for plugin-specific locking
protocols.

4 files changed, 130 insertions, 5 deletions

diff --git a/include/litmus/fdso.h b/include/litmus/fdso.h
index bfab9fdc756c..25a292d68d96 100644
--- a/include/litmus/fdso.h
+++ b/include/litmus/fdso.h
@@ -33,12 +33,13 @@ struct inode_obj_id {
         unsigned int            id;
 };
 
+struct fdso_ops;
 
 struct od_table_entry {
         unsigned int            used;
 
         struct inode_obj_id*    obj;
-        void*                   extra;
+        const struct fdso_ops*  class;
 };
 
 struct fdso_ops {
@@ -51,14 +52,14 @@ struct fdso_ops {
 /* translate a userspace supplied od into the raw table entry
  * returns NULL if od is invalid
  */
-struct od_table_entry* __od_lookup(int od);
+struct od_table_entry* get_entry_for_od(int od);
 
 /* translate a userspace supplied od into the associated object
  * returns NULL if od is invalid
  */
 static inline void* od_lookup(int od, obj_type_t type)
 {
-        struct od_table_entry* e = __od_lookup(od);
+        struct od_table_entry* e = get_entry_for_od(od);
         return e && e->obj->type == type ? e->obj->obj : NULL;
 }
 
diff --git a/litmus/Makefile b/litmus/Makefile
index b7366b530749..4e019d4a6e0c 100644
--- a/litmus/Makefile
+++ b/litmus/Makefile
@@ -11,6 +11,7 @@ obj-y     = sched_plugin.o litmus.o \
             rt_domain.o \
             edf_common.o \
             fdso.o \
+            locking.o \
             srp.o \
             fmlp.o \
             bheap.o \
diff --git a/litmus/fdso.c b/litmus/fdso.c
index 3bb331e471df..faede9bcbbbf 100644
--- a/litmus/fdso.c
+++ b/litmus/fdso.c
@@ -190,7 +190,7 @@ static int do_sys_od_open(struct file* file, obj_type_t type, int id,
                 entry->used = 0;
         } else {
                 entry->obj   = obj;
-                entry->extra = NULL;
+                entry->class = fdso_ops[type];
                 idx = entry - current->od_table;
         }
 
@@ -209,7 +209,7 @@ static int do_sys_od_open(struct file* file, obj_type_t type, int id,
 }
 
 
-struct od_table_entry* __od_lookup(int od)
+struct od_table_entry* get_entry_for_od(int od)
 {
         struct task_struct *t = current;
 
diff --git a/litmus/locking.c b/litmus/locking.c
new file mode 100644
index 000000000000..848407b79b4f
--- /dev/null
+++ b/litmus/locking.c
@@ -0,0 +1,123 @@
+#include <litmus/fdso.h>
+
+#ifdef CONFIG_LITMUS_LOCKING
+
+#include <litmus/sched_plugin.h>
+#include <litmus/trace.h>
+
+static void* create_generic_lock(obj_type_t type);
+static int open_generic_lock(struct od_table_entry* entry, void* __user arg);
+static int close_generic_lock(struct od_table_entry* entry);
+static void destroy_generic_lock(obj_type_t type, void* sem);
+
+struct fdso_ops generic_lock_ops = {
+        .create  = create_generic_lock,
+        .open    = open_generic_lock,
+        .close   = close_generic_lock,
+        .destroy = destroy_generic_lock
+};
+
+static inline bool is_lock(struct od_table_entry* entry)
+{
+        return entry->class == &generic_lock_ops;
+}
+
+static inline struct litmus_lock* get_lock(struct od_table_entry* entry)
+{
+        BUG_ON(!is_lock(entry));
+        return (struct litmus_lock*) entry->obj->obj;
+}
+
+static  void* create_generic_lock(obj_type_t type)
+{
+        struct litmus_lock* lock;
+        int err;
+
+        err = litmus->allocate_lock(&lock, type);
+        if (err == 0)
+                return lock;
+        else
+                return NULL;
+}
+
+static int open_generic_lock(struct od_table_entry* entry, void* __user arg)
+{
+        struct litmus_lock* lock = get_lock(entry);
+        if (lock->ops->open)
+                return lock->ops->open(lock, arg);
+        else
+                return 0; /* default: any task can open it */
+}
+
+static int close_generic_lock(struct od_table_entry* entry)
+{
+        struct litmus_lock* lock = get_lock(entry);
+        if (lock->ops->close)
+                return lock->ops->close(lock);
+        else
+                return 0; /* default: closing succeeds */
+}
+
+static void destroy_generic_lock(obj_type_t type, void* obj)
+{
+        struct litmus_lock* lock = (struct litmus_lock*) obj;
+        lock->ops->deallocate(lock);
+}
+
+asmlinkage long sys_litmus_lock(int lock_od)
+{
+        long err = -EINVAL;
+        struct od_table_entry* entry;
+        struct litmus_lock* l;
+
+        TS_PI_DOWN_START;
+
+        entry = get_entry_for_od(lock_od);
+        if (entry && is_lock(entry)) {
+                l = get_lock(entry);
+                err = l->ops->lock(l);
+        }
+
+        /* Note: task my have been suspended or preempted in between!  Take
+         * this into account when computing overheads. */
+        TS_PI_DOWN_END;
+
+        return err;
+}
+
+asmlinkage long sys_litmus_unlock(int lock_od)
+{
+        long err = -EINVAL;
+        struct od_table_entry* entry;
+        struct litmus_lock* l;
+
+        TS_PI_UP_START;
+
+        entry = get_entry_for_od(lock_od);
+        if (entry && is_lock(entry)) {
+                l = get_lock(entry);
+                err = l->ops->lock(l);
+        }
+
+        /* Note: task my have been preempted in between!  Take this into
+         * account when computing overheads. */
+        TS_PI_UP_END;
+
+        return err;
+}
+
+#else
+
+struct fdso_ops generic_lock_ops = {};
+
+asmlinkage long sys_litmus_lock(int sem_od)
+{
+        return -ENOSYS;
+}
+
+asmlinkage long sys_litmus_unlock(int sem_od)
+{
+        return -ENOSYS;
+}
+
+#endif