Made global OMLP non-preemptive between lock and unlock calls.

Added support for non-preemptivity in EXT-RES.

2 files changed, 21 insertions, 4 deletions

diff --git a/litmus/reservations/ext_reservation.c b/litmus/reservations/ext_reservation.c
index e6685fca20ea..6b4889c40bca 100644
--- a/litmus/reservations/ext_reservation.c
+++ b/litmus/reservations/ext_reservation.c
@@ -24,6 +24,12 @@ int higher_res_prio(struct reservation* first,
 
 #ifdef CONFIG_LITMUS_LOCKING
 
+        // SOMEWHAT HACKY -- guarantee that a non-preemptive reservation
+        // is higher-priority than any other; fall back to regular
+        // priority-checking if both are non-preemptive or both are preemptive
+        if (first->ops->is_np(first, -1) != second->ops->is_np(second, -1))
+                return first->ops->is_np(first, -1);
+
         /* Check for inherited priorities. Change reservation
          * used for comparison in such a case.
          */
diff --git a/litmus/reservations/gedf_reservation.c b/litmus/reservations/gedf_reservation.c
index deb0c9e6e3ef..ef9751542d0a 100644
--- a/litmus/reservations/gedf_reservation.c
+++ b/litmus/reservations/gedf_reservation.c
@@ -438,10 +438,10 @@ static void gedf_env_remove_res(
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
         gedf_res = container_of(res, struct gedf_reservation, res);
 
+        raw_spin_lock_irqsave(&gedf_env->domain.ready_lock, flags);
         gedf_res->will_remove = complete;
         gedf_res->blocked = !complete;
 
-        raw_spin_lock_irqsave(&gedf_env->domain.ready_lock, flags);
         list_del_init(&gedf_res->res.all_list);
         unlink(gedf_env, gedf_res);
         check_for_preemptions(gedf_env);
@@ -469,10 +469,11 @@ static void gedf_env_add_res(
         gedf_res = container_of(res, struct gedf_reservation, res);
 
         res->par_env = env;
+
+        raw_spin_lock_irqsave(&gedf_env->domain.ready_lock, flags);
         gedf_res->will_remove = 0;
         gedf_res->blocked = 0;
 
-        raw_spin_lock_irqsave(&gedf_env->domain.ready_lock, flags);
         list_add_tail(&gedf_res->res.all_list, &env->all_reservations);
         requeue(gedf_env, gedf_res);
         check_for_preemptions(gedf_env);
@@ -529,7 +530,7 @@ static void gedf_env_suspend(
                 goto unlock;
 
         //TODO: More Graceful way to handle forbidden zone violation?
-        BUG_ON(env->ops->is_np(env, cpu));
+        // BUG_ON(env->ops->is_np(env, cpu));
 
         gedf_env->num_cpus--;
         /* on env suspension, we need to preempt scheduled tasks, and unlink linked tasks */
@@ -642,6 +643,7 @@ static struct task_struct* gedf_env_dispatch(
         struct task_struct* next = NULL;
         unsigned long flags;
         int np = 0;
+        int block = 0;
 
         gedf_env = container_of(env, struct gedf_reservation_environment, env);
         entry = &gedf_env->cpu_entries[cpu];
@@ -656,6 +658,9 @@ static struct task_struct* gedf_env_dispatch(
         BUG_ON(!bheap_node_in_heap(entry->hn));
         BUG_ON(bheap_empty(&gedf_env->cpu_heap));
 
+        if (entry->scheduled)
+                block = entry->scheduled->blocked;
+
         /* update linked if linked for this cpu is empty */
         if (!entry->linked)
                 check_for_preemptions(gedf_env);
@@ -663,7 +668,7 @@ static struct task_struct* gedf_env_dispatch(
         BUG_ON(!entry->linked && __peek_ready_res(&gedf_env->domain));
 
         /* if linked and scheduled differ, preempt and schedule accordingly */
-        if (!np && entry->scheduled != entry->linked) {
+        if ((!np || block) && entry->scheduled != entry->linked) {
                 if (entry->scheduled) {
                         if (entry->scheduled->res.ops->on_preempt)
                                 entry->scheduled->res.ops->on_preempt(&entry->scheduled->res, cpu);
@@ -1061,6 +1066,9 @@ int gedf_env_omlp_lock(struct litmus_lock* l)
                 spin_unlock_irqrestore(&sem->fifo_wait.lock, flags);
         }
 
+        // Make the task non-preemptive until the lock is released
+        make_np(t);
+
         tsk_rt(t)->num_locks_held++;
 
         return 0;
@@ -1150,6 +1158,9 @@ static int gedf_env_omlp_unlock(struct litmus_lock* l)
 
         tsk_rt(t)->num_locks_held--;
 
+        // Make the task preemptive again
+        take_np(t);
+
         /* check if there are jobs waiting for this resource */
         next = omlp_dequeue(sem);
         if (next) {