Fixed three bugs with aux threads and nested locks

Fixes two bugs with nested locks:
1) List of aux threads could become corrupted.
  -- moved modifications to be within scheduler lock.

2) Fixed bad EDF comparison ordering that could lead
to schedule thrashing in an infinite loop.

3) Prevent aux threads from inheriting a priority from
a task that is blocked on a real-time litmus lock.
(since the aux threads can't possibly hold these locks,
we don't have to worry about inheritance.)

1 files changed, 29 insertions, 0 deletions

diff --git a/litmus/locking.c b/litmus/locking.c
index 12a23eb715cc..16c936ba8139 100644
--- a/litmus/locking.c
+++ b/litmus/locking.c
@@ -540,6 +540,35 @@ out:
         return passed;
 }
 
+
+void suspend_for_lock(void)
+{
+#ifdef CONFIG_REALTIME_AUX_TASKS
+        unsigned int restore = 0;
+        struct task_struct *t = current;
+        unsigned int hide;
+
+        if (tsk_rt(t)->has_aux_tasks) {
+                /* hide from aux tasks so they can't inherit our priority when we block
+                 * for a litmus lock. inheritance is already going to a litmus lock
+                 * holder. */
+                hide = tsk_rt(t)->hide_from_aux_tasks;
+                restore = 1;
+                tsk_rt(t)->hide_from_aux_tasks = 1;
+        }
+#endif
+
+        schedule();
+
+#ifdef CONFIG_REALTIME_AUX_TASKS
+        if (restore) {
+                /* restore our state */
+                tsk_rt(t)->hide_from_aux_tasks = hide;
+        }
+#endif
+}
+
+
 #else  // CONFIG_LITMUS_LOCKING
 
 struct fdso_ops generic_lock_ops = {};