BUG FIX: Support DGLs with PRIOQ_MUTEXwip-prioq-dgl

First 'working' implementation of DGLs with PRIOQ_MUTEX.
(All other code prior was work-in-progress.)

General approach:
Because of priority queue order, PRIOQ_MUTEX DGLs must be
*acquired* atomically. This means that a task cannot
acquire an available PRIOQ_MUTEX if another PRIOQ_MUTEX
is not available at the same time.  Requests are buffered
in PRIOQ_MUTEX and the resource 'idles'-- that is, the
mutex owner is NULL, but there are waiting tasks for the
resource.

Several notes/side-effects:
1) A high-priority task that idles a resource can
effectively block lower-priority tasks from acquiring
that resource.  This is because the low-prio task
cannot skip ahead of the high-prio task in the priority
queue.
2) Priority inheritance from nesting can cause the
low-prioity task in #1 to jump over the high-priority
task and acquire the resource.  This means that
any task blocked on a DGL that receives an increase
in priority while blocked on the DGL must trigger
a re-eval of the locks it can take.  If the resources
can be acquired, then the task needs to be woken
up!  <<<<< Lock acquisition via inheritance is entirely
new and weird! >>>>>
3) A similar case for #2 exists for priorty decreases
(example: this can happen when a task loses a donor)
while it is blocked on a PRIOQ_MUTEX. The high-priority
task described in #1 can change and become a lower-
priority task.  Every idle lock (mutex owner is NULL)
on which the task losing priority must be revaluated---
it is possible that the (possible) new head on the
priority queue can take the lock.  Note: This affects
BOTH singular and DGL resource requests, while
the case described in #2 only affects DGL requests
(because a singular request at the head of the priority
queue will never idle a resource).

1 files changed, 30 insertions, 10 deletions

diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index 40daf8e16d74..69f30188f3ba 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -1316,6 +1316,14 @@ static int __decrease_priority_inheritance(struct task_struct* t,
 {
         int success = 1;
 
+        if (prio_inh == tsk_rt(t)->inh_task) {
+                /* relationship already established. */
+                TRACE_TASK(t, "already inherits priority from %s/%d\n",
+                                   (prio_inh) ? prio_inh->comm : "(null)",
+                                   (prio_inh) ? prio_inh->pid : 0);
+                goto out;
+        }
+
         if (prio_inh && (effective_priority(prio_inh) != prio_inh)) {
                 TRACE_TASK(t, "Inheriting from %s/%d instead of the eff_prio = %s/%d!\n",
                         prio_inh->comm, prio_inh->pid,
@@ -1337,14 +1345,6 @@ static int __decrease_priority_inheritance(struct task_struct* t,
 #endif
         }
 
-        if (prio_inh == tsk_rt(t)->inh_task) {
-                /* relationship already established. */
-                TRACE_TASK(t, "already inherits priority from %s/%d\n",
-                                   (prio_inh) ? prio_inh->comm : "(null)",
-                                   (prio_inh) ? prio_inh->pid : 0);
-                goto out;
-        }
-
 #ifdef CONFIG_LITMUS_NESTED_LOCKING
         if(__edf_higher_prio(t, EFFECTIVE, prio_inh, BASE)) {
 #endif
@@ -1469,7 +1469,7 @@ static void nested_increase_priority_inheritance(struct task_struct* t,
 
 
         if(blocked_lock) {
-                if(blocked_lock->ops->propagate_increase_inheritance) {
+                if(blocked_lock->ops->supports_nesting) {
                         TRACE_TASK(t, "Inheritor is blocked (...perhaps).  Checking lock %d.\n",
                                            blocked_lock->ident);
 
@@ -1506,7 +1506,7 @@ static void nested_decrease_priority_inheritance(struct task_struct* t,
         raw_spin_unlock(&tsk_rt(t)->hp_blocked_tasks_lock);  // unlock the t's heap.
 
         if(blocked_lock) {
-                if(blocked_lock->ops->propagate_decrease_inheritance) {
+                if(blocked_lock->ops->supports_nesting) {
                         TRACE_TASK(t, "Inheritor is blocked (...perhaps).  Checking lock %d.\n",
                                            blocked_lock->ident);
 
@@ -1547,7 +1547,11 @@ static struct litmus_lock_ops cedf_fifo_mutex_lock_ops = {
 
         .dgl_can_quick_lock = NULL,
         .dgl_quick_lock = NULL,
+
+        .supports_dgl = 1,
+        .requires_atomic_dgl = 0,
 #endif
+        .supports_nesting = 1,
 };
 
 static struct litmus_lock* cedf_new_fifo_mutex(void)
@@ -1574,7 +1578,11 @@ static struct litmus_lock_ops cedf_prioq_mutex_lock_ops = {
 
         .dgl_can_quick_lock = prioq_mutex_dgl_can_quick_lock,
         .dgl_quick_lock = prioq_mutex_dgl_quick_lock,
+
+        .supports_dgl = 1,
+        .requires_atomic_dgl = 1,
 #endif
+        .supports_nesting = 1,
 };
 
 static struct litmus_lock* cedf_new_prioq_mutex(void)
@@ -1593,6 +1601,12 @@ static struct litmus_lock_ops cedf_ikglp_lock_ops = {
         // ikglp can only be an outer-most lock.
         .propagate_increase_inheritance = NULL,
         .propagate_decrease_inheritance = NULL,
+
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+        .supports_dgl = 0,
+        .requires_atomic_dgl = 0,
+#endif
+        .supports_nesting = 0,
 };
 
 static struct litmus_lock* cedf_new_ikglp(void* __user arg)
@@ -1617,6 +1631,12 @@ static struct litmus_lock_ops cedf_kfmlp_lock_ops = {
         // kfmlp can only be an outer-most lock.
         .propagate_increase_inheritance = NULL,
         .propagate_decrease_inheritance = NULL,
+
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+        .supports_dgl = 0,
+        .requires_atomic_dgl = 0,
+#endif
+        .supports_nesting = 0,
 };