Nested inheritance with fine-grained locking.

Minor hack to lockdep was required too allow
the inheritance propagation locking logic to
work.

1 files changed, 62 insertions, 9 deletions

diff --git a/litmus/edf_common.c b/litmus/edf_common.c
index 54cfada586be..7a3a9a02a703 100644
--- a/litmus/edf_common.c
+++ b/litmus/edf_common.c
@@ -12,15 +12,25 @@
 #include <litmus/sched_plugin.h>
 #include <litmus/sched_trace.h>
 
+#ifdef CONFIG_LITMUS_NESTED_LOCKING
+#include <litmus/locking.h>
+#endif
+
 #include <litmus/edf_common.h>
 
+
 /* edf_higher_prio -  returns true if first has a higher EDF priority
  *                    than second. Deadline ties are broken by PID.
  *
  * both first and second may be NULL
  */
-int edf_higher_prio(struct task_struct* first,
-                    struct task_struct* second)
+#ifdef CONFIG_LITMUS_NESTED_LOCKING
+int __edf_higher_prio(
+        struct task_struct* first, comparison_mode_t first_mode,
+        struct task_struct* second, comparison_mode_t second_mode)
+#else
+int edf_higher_prio(struct task_struct* first, struct task_struct* second)
+#endif
 {
         struct task_struct *first_task = first;
         struct task_struct *second_task = second;
@@ -38,14 +48,23 @@ int edf_higher_prio(struct task_struct* first,
                 return first && !second;
 
 #ifdef CONFIG_LITMUS_LOCKING
-
         /* Check for inherited priorities. Change task
          * used for comparison in such a case.
          */
-        if (unlikely(first->rt_param.eff_prio))
-                first_task = first->rt_param.eff_prio;
-        if (unlikely(second->rt_param.eff_prio))
-                second_task = second->rt_param.eff_prio;
+        if (unlikely(first->rt_param.inh_task)
+#ifdef CONFIG_LITMUS_NESTED_LOCKING
+                && (first_mode == INHERITED)
+#endif
+                ) {
+                first_task = first->rt_param.inh_task;
+        }
+        if (unlikely(second->rt_param.inh_task)
+#ifdef CONFIG_LITMUS_NESTED_LOCKING             
+                && (second_mode == INHERITED)
+#endif
+                ) {
+                second_task = second->rt_param.inh_task;
+        }
 
         /* Check for priority boosting. Tie-break by start of boosting.
          */
@@ -63,7 +82,6 @@ int edf_higher_prio(struct task_struct* first,
 
 #endif
 
-
         return !is_realtime(second_task)  ||
 
                 /* is the deadline of the first task earlier?
@@ -81,9 +99,44 @@ int edf_higher_prio(struct task_struct* first,
                  * priority wins.
                  */
                 (first_task->pid == second_task->pid &&
-                 !second->rt_param.eff_prio)));
+                 !second->rt_param.inh_task)));
+}
+
+
+#ifdef CONFIG_LITMUS_NESTED_LOCKING
+int edf_higher_prio(struct task_struct* first, struct task_struct* second)
+{
+        return __edf_higher_prio(first, INHERITED, second, INHERITED);
 }
 
+int edf_max_heap_order(struct binheap_node *a, struct binheap_node *b)
+{
+        struct litmus_lock *l_a = (struct litmus_lock *)binheap_entry(a, struct litmus_lock, hp_binheap_node);
+        struct litmus_lock *l_b = (struct litmus_lock *)binheap_entry(b, struct litmus_lock, hp_binheap_node);
+        
+        return __edf_higher_prio(l_a->hp_waiter_eff_prio, INHERITED, l_b->hp_waiter_eff_prio, INHERITED);
+}
+
+int edf_min_heap_order(struct binheap_node *a, struct binheap_node *b)
+{
+        return edf_max_heap_order(b, a);  // swap comparison
+}
+
+int edf_max_heap_base_priority_order(struct binheap_node *a, struct binheap_node *b)
+{
+        struct litmus_lock *l_a = (struct litmus_lock *)binheap_entry(a, struct litmus_lock, hp_binheap_node);
+        struct litmus_lock *l_b = (struct litmus_lock *)binheap_entry(b, struct litmus_lock, hp_binheap_node);
+        
+        return __edf_higher_prio(l_a->hp_waiter_eff_prio, BASE, l_b->hp_waiter_eff_prio, BASE);
+}
+
+int edf_min_heap_base_priority_order(struct binheap_node *a, struct binheap_node *b)
+{
+        return edf_max_heap_base_priority_order(b, a);  // swap comparison
+}
+#endif
+
+
 int edf_ready_order(struct bheap_node* a, struct bheap_node* b)
 {
         return edf_higher_prio(bheap2task(a), bheap2task(b));