Added lock/unlock logic to global OMLP for EXT-RES, still needs priority inheritance.

1 files changed, 110 insertions, 0 deletions

diff --git a/litmus/reservations/gedf_reservation.c b/litmus/reservations/gedf_reservation.c
index 5f7c97eb980c..6d713d95131b 100644
--- a/litmus/reservations/gedf_reservation.c
+++ b/litmus/reservations/gedf_reservation.c
@@ -11,6 +11,7 @@
 #include <litmus/np.h>
 #include <litmus/sched_trace.h>
 #include <litmus/debug_trace.h>
+#include <litmus/trace.h>
 #include <litmus/reservations/gedf_reservation.h>
 
 // Needed to store context during cross-CPU function calls
@@ -719,6 +720,43 @@ static inline struct omlp_semaphore* omlp_from_lock(struct litmus_lock* lock)
         return container_of(lock, struct omlp_semaphore, litmus_lock);
 }
 
+/* already locked */
+static void omlp_enqueue(struct omlp_semaphore *sem, prio_wait_queue_t* wait)
+{
+        if (sem->num_free) {
+                /* there is space in the FIFO queue */
+                sem->num_free--;
+                __add_wait_queue_tail_exclusive(&sem->fifo_wait, &wait->wq);
+        } else {
+                /* nope, gotta go to the priority queue */
+                __add_wait_queue_prio_exclusive(&sem->prio_wait, wait);
+        }
+}
+
+/* already locked */
+static int omlp_move(struct omlp_semaphore *sem)
+{
+        struct list_head* first;
+
+        if (waitqueue_active(&sem->prio_wait)) {
+                first = sem->prio_wait.task_list.next;
+                list_move_tail(first, &sem->fifo_wait.task_list);
+                return 1;
+        }
+        else
+                return 0;
+}
+
+static struct task_struct* omlp_dequeue(struct omlp_semaphore *sem)
+{
+        struct task_struct* first = __waitqueue_remove_first(&sem->fifo_wait);
+
+        if (first && !omlp_move(sem))
+                sem->num_free++;
+
+        return first;
+}
+
 int gedf_env_omlp_lock(struct litmus_lock* l)
 {
         struct task_struct* t = current;
@@ -726,6 +764,51 @@ int gedf_env_omlp_lock(struct litmus_lock* l)
         prio_wait_queue_t wait;
         unsigned long flags;
 
+        if (!is_realtime(t))
+                return -EPERM;
+
+        /* prevent nested lock acquisition --- not supported by global OMLP
+           by default */
+        if (tsk_rt(t)->num_locks_held)
+                return -EBUSY;
+
+        struct reservation *t_res = (struct reservation *) tsk_rt(t)->plugin_state;
+
+        spin_lock_irqsave(&sem->fifo_wait.lock, flags);
+
+        if (sem->owner) {
+                /* resource is not free => must suspend and wait */
+
+                init_prio_waitqueue_entry(&wait, t, t_res->priority);
+
+                set_task_state(t, TASK_UNINTERRUPTIBLE);
+
+                omlp_enqueue(sem, &wait);
+
+                // TODO tamert: add priority inheritance
+
+                TS_LOCK_SUSPEND;
+
+                /* release lock before sleeping */
+                spin_unlock_irqrestore(&sem->fifo_wait.lock, flags);
+
+                schedule();
+
+                TS_LOCK_RESUME;
+
+                /* Since we hold the lock, no other task will change
+                 * ->owner. We can thus check it without acquiring the spin
+                 * lock. */
+                BUG_ON(sem->owner != t);
+        } else {
+                /* it's ours now */
+                sem->owner = t;
+
+                spin_unlock_irqrestore(&sem->fifo_wait.lock, flags);
+        }
+
+        tsk_rt(t)->num_locks_held++;
+
         return 0;
 }
 
@@ -736,6 +819,33 @@ static int gedf_env_omlp_unlock(struct litmus_lock* l)
         unsigned long flags;
         int err = 0;
 
+        spin_lock_irqsave(&sem->fifo_wait.lock, flags);
+
+        if (sem->owner != t) {
+                err = -EINVAL;
+                goto out;
+        }
+
+        tsk_rt(t)->num_locks_held--;
+
+        /* check if there are jobs waiting for this resource */
+        next = omlp_dequeue(sem);
+        if (next) {
+                /* next becomes the resouce holder */
+                sem->owner = next;
+                TRACE_CUR("lock ownership passed to %s/%d\n", next->comm, next->pid);
+
+                // TODO tamert: add priority inheritance
+
+                /* wake up next */
+                wake_up_process(next);
+        } else
+                /* becomes available */
+                sem->owner = NULL;
+
+out:
+        spin_unlock_irqrestore(&sem->fifo_wait.lock, flags);
+
         return err;
 }