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.

2 files changed, 14 insertions, 39 deletions

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);