Litmus core: change plugin locking interface to generic 'allocate_lock()'

As the number of supported locking protocols is expected to rise,
hard-coding things like priority inheritance in the plugin interface
doesn't scale. Instead, use a new generic lock-ops approach. With this
approach, each plugin can define its own protocol implementation (or
use a generic one), and plugins can support multiple protocols without
having to change the plugin interface for each protocol.

4 files changed, 51 insertions, 80 deletions

diff --git a/include/litmus/locking.h b/include/litmus/locking.h
new file mode 100644
index 000000000000..4d7b870cb443
--- /dev/null
+++ b/include/litmus/locking.h
@@ -0,0 +1,28 @@
+#ifndef LITMUS_LOCKING_H
+#define LITMUS_LOCKING_H
+
+struct litmus_lock_ops;
+
+/* Generic base struct for LITMUS^RT userspace semaphores.
+ * This structure should be embedded in protocol-specific semaphores.
+ */
+struct litmus_lock {
+        struct litmus_lock_ops *ops;
+        int type;
+};
+
+struct litmus_lock_ops {
+        /* Current task tries to obtain / drop a reference to a lock.
+         * Optional methods, allowed by default. */
+        int (*open)(struct litmus_lock*, void* __user);
+        int (*close)(struct litmus_lock*);
+
+        /* Current tries to lock/unlock this lock (mandatory methods). */
+        int (*lock)(struct litmus_lock*);
+        int (*unlock)(struct litmus_lock*);
+
+        /* The lock is no longer being referenced (mandatory method). */
+        void (*deallocate)(struct litmus_lock*);
+};
+
+#endif
diff --git a/include/litmus/sched_plugin.h b/include/litmus/sched_plugin.h
index 2d856d587041..27b719aebed9 100644
--- a/include/litmus/sched_plugin.h
+++ b/include/litmus/sched_plugin.h
@@ -7,19 +7,9 @@
 
 #include <linux/sched.h>
 
-/* struct for semaphore with priority inheritance */
-struct pi_semaphore {
-        atomic_t count;
-        int sleepers;
-        wait_queue_head_t wait;
-        struct {
-                /* highest-prio holder/waiter */
-                struct task_struct *task;
-                struct task_struct* cpu_task[NR_CPUS];
-        } hp;
-        /* current lock holder */
-        struct task_struct *holder;
-};
+#ifdef CONFIG_LITMUS_LOCKING
+#include <litmus/locking.h>
+#endif
 
 /************************ setup/tear down ********************/
 
@@ -63,24 +53,9 @@ typedef void (*task_block_t)  (struct task_struct *task);
  */
 typedef void (*task_exit_t)    (struct task_struct *);
 
-/* Called when the new_owner is released from the wait queue
- * it should now inherit the priority from sem, _before_ it gets readded
- * to any queue
- */
-typedef long (*inherit_priority_t) (struct pi_semaphore *sem,
-                                    struct task_struct *new_owner);
-
-/* Called when the current task releases a semahpore where it might have
- * inherited a piority from
- */
-typedef long (*return_priority_t) (struct pi_semaphore *sem);
-
-/* Called when a task tries to acquire a semaphore and fails. Check if its
- * priority is higher than that of the current holder.
- */
-typedef long (*pi_block_t) (struct pi_semaphore *sem, struct task_struct *t);
-
-
+/* Called when the current task attempts to create a new lock of a given
+ * protocol type. */
+typedef long (*allocate_lock_t) (struct litmus_lock **lock, int type);
 
 
 /********************* sys call backends  ********************/
@@ -100,10 +75,6 @@ struct sched_plugin {
         activate_plugin_t       activate_plugin;
         deactivate_plugin_t     deactivate_plugin;
 
-#ifdef CONFIG_SRP
-        unsigned int            srp_active;
-#endif
-
         /*      scheduler invocation    */
         scheduler_tick_t        tick;
         schedule_t              schedule;
@@ -121,12 +92,9 @@ struct sched_plugin {
         task_block_t            task_block;
         task_exit_t             task_exit;
 
-#ifdef CONFIG_FMLP
-        /*     priority inheritance     */
-        unsigned int            fmlp_active;
-        inherit_priority_t      inherit_priority;
-        return_priority_t       return_priority;
-        pi_block_t              pi_block;
+#ifdef CONFIG_LITMUS_LOCKING
+        /*      locking protocols       */
+        allocate_lock_t         allocate_lock;
 #endif
 } __attribute__ ((__aligned__(SMP_CACHE_BYTES)));
 
diff --git a/litmus/Kconfig b/litmus/Kconfig
index a2f267870f29..ad8dc8308cf0 100644
--- a/litmus/Kconfig
+++ b/litmus/Kconfig
@@ -46,28 +46,19 @@ config NP_SECTION
           Note that plugins still need to explicitly support non-preemptivity.
           Currently, only GSN-EDF and PSN-EDF have such support.
 
-          This is required to support the FMLP.
+          This is required to support locking protocols such as the FMLP.
           If disabled, all tasks will be considered preemptable at all times.
 
-config SRP
-        bool "Stack Resource Policy (SRP)"
-        default n
-        help
-          Include support for Baker's Stack Resource Policy.
-
-          Say Yes if you want FMLP local long critical section
-          synchronization support.
-
-config FMLP
-        bool "FMLP support"
+config LITMUS_LOCKING
+        bool "Support for real-time locking protocols"
         depends on NP_SECTION
         default n
         help
-          Include support for deterministic multiprocessor real-time
-          synchronization support.
+          Enable LITMUS^RT's deterministic multiprocessor real-time
+          locking protocols.
 
-          Say Yes if you want FMLP long critical section
-          synchronization support.
+          Say Yes if you want to include locking protocols such as the FMLP and
+          Baker's SRP.
 
 endmenu
 
diff --git a/litmus/sched_plugin.c b/litmus/sched_plugin.c
index d912a6494d20..2f8f399b195f 100644
--- a/litmus/sched_plugin.c
+++ b/litmus/sched_plugin.c
@@ -121,23 +121,11 @@ static long litmus_dummy_deactivate_plugin(void)
         return 0;
 }
 
-#ifdef CONFIG_FMLP
+#ifdef CONFIG_LITMUS_LOCKING
 
-static long litmus_dummy_inherit_priority(struct pi_semaphore *sem,
-                                          struct task_struct *new_owner)
+static long litmus_dummy_allocate_lock(struct litmus_lock **lock, int type)
 {
-        return -ENOSYS;
-}
-
-static long litmus_dummy_return_priority(struct pi_semaphore *sem)
-{
-        return -ENOSYS;
-}
-
-static long litmus_dummy_pi_block(struct pi_semaphore *sem,
-                                  struct task_struct *new_waiter)
-{
-        return -ENOSYS;
+        return -ENXIO;
 }
 
 #endif
@@ -158,10 +146,8 @@ struct sched_plugin linux_sched_plugin = {
         .finish_switch = litmus_dummy_finish_switch,
         .activate_plugin = litmus_dummy_activate_plugin,
         .deactivate_plugin = litmus_dummy_deactivate_plugin,
-#ifdef CONFIG_FMLP
-        .inherit_priority = litmus_dummy_inherit_priority,
-        .return_priority = litmus_dummy_return_priority,
-        .pi_block = litmus_dummy_pi_block,
+#ifdef CONFIG_LITMUS_LOCKING
+        .allocate_lock = litmus_dummy_allocate_lock,
 #endif
         .admit_task = litmus_dummy_admit_task
 };
@@ -198,10 +184,8 @@ int register_sched_plugin(struct sched_plugin* plugin)
         CHECK(complete_job);
         CHECK(activate_plugin);
         CHECK(deactivate_plugin);
-#ifdef CONFIG_FMLP
-        CHECK(inherit_priority);
-        CHECK(return_priority);
-        CHECK(pi_block);
+#ifdef CONFIG_LITMUS_LOCKING
+        CHECK(allocate_lock);
 #endif
         CHECK(admit_task);