Added empty lock functions for OMLP-FZ.

3 files changed, 179 insertions, 1 deletions

diff --git a/include/litmus/reservations/ext_reservation.h b/include/litmus/reservations/ext_reservation.h
index c9ec924fc55b..cc16b036920c 100644
--- a/include/litmus/reservations/ext_reservation.h
+++ b/include/litmus/reservations/ext_reservation.h
@@ -6,6 +6,10 @@
 #include <litmus/debug_trace.h>
 #include <litmus/reservations/budget-notifier.h>
 
+#ifdef CONFIG_LITMUS_LOCKING
+#include <litmus/locking.h>
+#endif
+
 struct reservation_environment;
 struct reservation;
 
@@ -141,6 +145,16 @@ typedef int (*env_is_np_t) (
 typedef void (*env_shutdown_t) (
         struct reservation_environment* env);
 
+#ifdef CONFIG_LITMUS_LOCKING
+/* Called when the current task attempts to create a new lock of a given
+ * protocol type. */
+typedef long (*env_allocate_lock_t) (
+        struct reservation_environment* env,
+        struct litmus_lock **lock,
+        int type,
+        void* __user config);
+#endif
+
 struct reservation_environment_ops {
         env_update_time_t       update_time;
         env_dispatch_t          dispatch;
@@ -151,6 +165,11 @@ struct reservation_environment_ops {
         env_find_res_t          find_res_by_id;
         env_is_np_t                     is_np;
         env_shutdown_t          shutdown;
+
+#ifdef CONFIG_LITMUS_LOCKING
+        /*      locking protocols       */
+        env_allocate_lock_t     allocate_lock;
+#endif
 };
 
 struct reservation_environment {
diff --git a/litmus/reservations/gedf_reservation.c b/litmus/reservations/gedf_reservation.c
index 2ed16575144e..5f7c97eb980c 100644
--- a/litmus/reservations/gedf_reservation.c
+++ b/litmus/reservations/gedf_reservation.c
@@ -688,6 +688,138 @@ static void gedf_env_release_jobs(rt_domain_t* rt, struct bheap* res)
         raw_spin_unlock_irqrestore(&rt->ready_lock, flags);
 }
 
+#ifdef CONFIG_LITMUS_LOCKING
+
+#include <litmus/fdso.h>
+#include <litmus/wait.h>
+
+/* ******************** OMLP support ********************** */
+
+/* struct for semaphore with priority inheritance */
+struct omlp_semaphore {
+        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 */
+        wait_queue_head_t fifo_wait;
+        /* Priority queue of waiting tasks */
+        wait_queue_head_t prio_wait;
+
+        /* How many slots remaining in FIFO queue? */
+        unsigned int num_free;
+};
+
+static inline struct omlp_semaphore* omlp_from_lock(struct litmus_lock* lock)
+{
+        return container_of(lock, struct omlp_semaphore, litmus_lock);
+}
+
+int gedf_env_omlp_lock(struct litmus_lock* l)
+{
+        struct task_struct* t = current;
+        struct omlp_semaphore *sem = omlp_from_lock(l);
+        prio_wait_queue_t wait;
+        unsigned long flags;
+
+        return 0;
+}
+
+static int gedf_env_omlp_unlock(struct litmus_lock* l)
+{
+        struct task_struct *t = current, *next;
+        struct omlp_semaphore *sem = omlp_from_lock(l);
+        unsigned long flags;
+        int err = 0;
+
+        return err;
+}
+
+static int gedf_env_omlp_close(struct litmus_lock* l)
+{
+        struct task_struct *t = current;
+        struct omlp_semaphore *sem = omlp_from_lock(l);
+        unsigned long flags;
+
+        int owner;
+
+        spin_lock_irqsave(&sem->fifo_wait.lock, flags);
+
+        owner = sem->owner == t;
+
+        spin_unlock_irqrestore(&sem->fifo_wait.lock, flags);
+
+        if (owner)
+                gedf_env_omlp_unlock(l);
+
+        return 0;
+}
+
+static void gedf_env_omlp_free(struct litmus_lock* lock)
+{
+        kfree(omlp_from_lock(lock));
+}
+
+static struct litmus_lock_ops gedf_env_omlp_lock_ops = {
+        .close  = gedf_env_omlp_close,
+        .lock   = gedf_env_omlp_lock,
+        .unlock = gedf_env_omlp_unlock,
+        .deallocate = gedf_env_omlp_free,
+};
+
+static struct litmus_lock* gedf_env_new_omlp(void)
+{
+        struct omlp_semaphore* sem;
+
+        sem = kmalloc(sizeof(*sem), GFP_KERNEL);
+        if (!sem)
+                return NULL;
+
+        sem->owner   = NULL;
+        sem->hp_waiter = NULL;
+        init_waitqueue_head(&sem->fifo_wait);
+        init_waitqueue_head(&sem->prio_wait);
+        sem->litmus_lock.ops = &gedf_env_omlp_lock_ops;
+        /* free = cpus -1 since ->owner is the head and also counted */
+        sem->num_free = num_online_cpus() - 1; // TODO tamert: check this
+
+        return &sem->litmus_lock;
+}
+
+/* **** lock constructor **** */
+
+static long gedf_env_allocate_lock(
+        struct reservation_environment* env,
+        struct litmus_lock **lock,
+        int type,
+        void* __user unused)
+{
+        int err = -ENXIO;
+
+        /* EXT-RES currently only supports the OMLP within components
+           for global resources. */
+        switch (type) {
+
+                case OMLP_SEM:
+                        /* O(m) Multiprocessor Locking Protocol */
+                        *lock  = gedf_env_new_omlp();
+                        if (*lock)
+                                err = 0;
+                        else
+                                err = -ENOMEM;
+                        break;
+
+        };
+
+        return err;
+}
+
+#endif
+
 static struct reservation_environment_ops gedf_env_ops = {
         .update_time = gedf_env_update_time,
         .dispatch = gedf_env_dispatch,
@@ -697,7 +829,10 @@ static struct reservation_environment_ops gedf_env_ops = {
         .remove_res = gedf_env_remove_res,
         .find_res_by_id = gedf_find_res_by_id,
         .is_np = gedf_env_is_np,
-        .shutdown = gedf_env_shutdown
+        .shutdown = gedf_env_shutdown,
+#ifdef CONFIG_LITMUS_LOCKING
+        .allocate_lock = gedf_env_allocate_lock,
+#endif
 };
 
 long alloc_gedf_reservation_environment(
diff --git a/litmus/sched_ext_res.c b/litmus/sched_ext_res.c
index 583a2ed9aef0..4bf81cd46c59 100644
--- a/litmus/sched_ext_res.c
+++ b/litmus/sched_ext_res.c
@@ -275,6 +275,27 @@ static bool ext_res_should_wait_for_stack(struct task_struct* t) {
 }
 */
 
+
+#ifdef CONFIG_LITMUS_LOCKING
+
+/* **** lock constructor **** */
+
+static long ext_res_allocate_lock(struct litmus_lock **lock, int type,
+                                 void* __user unused)
+{
+        struct reservation_environment *gedf_env;
+        int err = -ENXIO;
+
+        /* pass the allocate_lock call to the task's component */
+        gedf_env = ((struct reservation*) tsk_rt(current)->plugin_state)->par_env;
+        err = gedf_env->ops->allocate_lock(gedf_env, lock, type, unused);
+
+        return err;
+}
+
+#endif
+
+
 static struct domain_proc_info ext_res_domain_proc_info;
 
 static long ext_res_get_domain_proc_info(struct domain_proc_info **ret)
@@ -361,6 +382,9 @@ static struct sched_plugin ext_res_plugin = {
         .reservation_create     = ext_res_reservation_create,
         //.current_budget         = pres_current_budget,
         //.should_wait_for_stack = ext_res_should_wait_for_stack,
+#ifdef CONFIG_LITMUS_LOCKING
+        .allocate_lock          = ext_res_allocate_lock,
+#endif
 };
 
 static int __init init_ext_res(void)