Nested inheritance with fine-grained locking.

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

1 files changed, 23 insertions, 8 deletions

diff --git a/litmus/litmus.c b/litmus/litmus.c
index 40340dfa9d67..9d4fbd2f8a65 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -291,7 +291,12 @@ static void reinit_litmus_state(struct task_struct* p, int restore)
 {
         struct rt_task  user_config = {};
         void*  ctrl_page     = NULL;
-
+        
+#ifdef CONFIG_LITMUS_NESTED_LOCKING     
+        binheap_order_t prio_order = NULL;
+#endif
+        
+        
         if (restore) {
                 /* Safe user-space provided configuration data.
                  * and allocated page. */
@@ -299,24 +304,33 @@ static void reinit_litmus_state(struct task_struct* p, int restore)
                 ctrl_page   = p->rt_param.ctrl_page;
         }
 
+#ifdef CONFIG_LITMUS_NESTED_LOCKING             
+        prio_order = p->rt_param.hp_blocked_tasks.compare;
+#endif  
+        
         /* We probably should not be inheriting any task's priority
          * at this point in time.
          */
-        WARN_ON(p->rt_param.eff_prio);
+        WARN_ON(p->rt_param.inh_task);
     
 #ifdef CONFIG_LITMUS_NESTED_LOCKING
-    WARN_ON(p->rt_param.local_prio);
-    WARN_ON(p->rt_param.trans_prio);
+        WARN_ON(p->rt_param.blocked_lock);
+    WARN_ON(!binheap_empty(&p->rt_param.hp_blocked_tasks));
 #endif
 
         /* Cleanup everything else. */
         memset(&p->rt_param, 0, sizeof(p->rt_param));
-
+        
         /* Restore preserved fields. */
         if (restore) {
                 p->rt_param.task_params = user_config;
                 p->rt_param.ctrl_page   = ctrl_page;
         }
+        
+#ifdef CONFIG_LITMUS_NESTED_LOCKING
+        INIT_BINHEAP_HANDLE(&p->rt_param.hp_blocked_tasks, prio_order);
+        raw_spin_lock_init(&p->rt_param.hp_blocked_tasks_lock);
+#endif  
 }
 
 long litmus_admit_task(struct task_struct* tsk)
@@ -363,6 +377,9 @@ long litmus_admit_task(struct task_struct* tsk)
                 bheap_node_init(&tsk_rt(tsk)->heap_node, tsk);
         }
 
+        tsk_rt(tsk)->blocked_lock = NULL;
+        raw_spin_lock_init(&tsk_rt(tsk)->hp_blocked_tasks_lock);
+        
         retval = litmus->admit_task(tsk);
 
         if (!retval) {
@@ -473,9 +490,7 @@ void litmus_exec(void)
         struct task_struct* p = current;
 
         if (is_realtime(p)) {
-                WARN_ON(p->rt_param.eff_prio);
-        WARN_ON(p->rt_param.local_prio);
-        WARN_ON(p->rt_param.trans_prio);
+                WARN_ON(p->rt_param.inh_task);
                 if (tsk_rt(p)->ctrl_page) {
                         free_page((unsigned long) tsk_rt(p)->ctrl_page);
                         tsk_rt(p)->ctrl_page = NULL;