Fixed case where blocked tasks are released.

Fixed bug where AUX tasks were being added to the
ready queue while those AUX tasks were actually blocked.
Bug stems from the fact that the AUX tasks do not
make themselves realtime, but another thread does this
instead. Also fixed minor bugs elsewhere.

NOTE: ONLY FIXES C-EDF.  OTHER PLUGINS REMAIN TO BE FIXED.

1 files changed, 45 insertions, 69 deletions

diff --git a/litmus/edf_common.c b/litmus/edf_common.c
index 441fbfddf0c2..ef22eb93dbf3 100644
--- a/litmus/edf_common.c
+++ b/litmus/edf_common.c
@@ -67,11 +67,14 @@ int edf_higher_prio(struct task_struct* first, struct task_struct* second)
                 return 0;
         }
 
-
         /* check for NULL tasks */
         if (!first || !second) {
                 return first && !second;
         }
+        /* check for non-realtime */
+        if (!is_realtime(first) || !is_realtime(second)) {
+                return is_realtime(first) && !is_realtime(second);
+        }
 
         /* There is some goofy stuff in this code here.  There are three subclasses
          * within the SCHED_LITMUS scheduling class:
@@ -92,49 +95,31 @@ int edf_higher_prio(struct task_struct* first, struct task_struct* second)
 
 #if defined(CONFIG_REALTIME_AUX_TASK_PRIORITY_BOOSTED)
         /* run aux tasks at max priority */
-        /* TODO: Actually use prio-boosting. */
-        if (first->rt_param.is_aux_task != second->rt_param.is_aux_task)
-        {
-                return (first->rt_param.is_aux_task > second->rt_param.is_aux_task);
-        }
-        else if(first->rt_param.is_aux_task && second->rt_param.is_aux_task)
-        {
-                if(first->group_leader == second->group_leader) {
-                        TRACE_CUR("aux tie break!\n");  // tie-break by BASE priority of the aux tasks
-                        goto aux_tie_break;
-                }
-                first = first->group_leader;
-                second = second->group_leader;
+        if (tsk_rt(first)->is_aux_task != tsk_rt(second)->is_aux_task) {
+                return (tsk_rt(first)->is_aux_task > tsk_rt(second)->is_aux_task);
         }
 #elif defined(CONFIG_REALTIME_AUX_TASK_PRIORITY_INHERITANCE)
         {
-                int first_lo_aux = first->rt_param.is_aux_task && !first->rt_param.inh_task;
-                int second_lo_aux = second->rt_param.is_aux_task && !second->rt_param.inh_task;
+                int first_lo_aux = tsk_rt(first)->is_aux_task && !tsk_rt(first)->inh_task;
+                int second_lo_aux = tsk_rt(second)->is_aux_task && !tsk_rt(second)->inh_task;
 
                 /* prioritize aux tasks without inheritance below real-time tasks */
                 if (first_lo_aux || second_lo_aux) {
                         // one of these is an aux task without inheritance.
-                        if(first_lo_aux && second_lo_aux) {
-                                TRACE_CUR("aux tie break!\n");  // tie-break by BASE priority of the aux tasks
-                                goto aux_tie_break;
-                        }
-                        else {
-
-                                // make the aux thread lowest priority real-time task
-                                int temp = 0;
-                                if (first_lo_aux && is_realtime(second)) {
-//                                      temp = 0;
-                                }
-                                else if(second_lo_aux && is_realtime(first)) {
-                                        temp = 1;
-                                }
+                        if (first_lo_aux != second_lo_aux) {
+                                int temp = (first_lo_aux < second_lo_aux);  // non-lo-aux has higher priority.
                                 TRACE_CUR("%s/%d >> %s/%d --- %d\n", first->comm, first->pid, second->comm, second->pid, temp);
                                 return temp;
                         }
+                        else {
+                                /* both MUST be lo_aux. tie-break. */
+                                TRACE_CUR("aux tie break!\n");
+                                goto aux_tie_break;
+                        }
                 }
 
-                if (first->rt_param.is_aux_task && second->rt_param.is_aux_task &&
-                        first->rt_param.inh_task == second->rt_param.inh_task) {
+                if (tsk_rt(first)->is_aux_task && tsk_rt(second)->is_aux_task &&
+                        tsk_rt(first)->inh_task == tsk_rt(second)->inh_task) {
                         // inh_task is !NULL for both tasks since neither was a lo_aux task.
                         // Both aux tasks inherit from the same task, so tie-break
                         // by base priority of the aux tasks.
@@ -146,33 +131,26 @@ int edf_higher_prio(struct task_struct* first, struct task_struct* second)
 
 #ifdef CONFIG_LITMUS_SOFTIRQD
         {
-                int first_lo_klmirqd = first->rt_param.is_interrupt_thread && !first->rt_param.inh_task;
-                int second_lo_klmirqd = second->rt_param.is_interrupt_thread && !second->rt_param.inh_task;
+                int first_lo_klmirqd = tsk_rt(first)->is_interrupt_thread && !tsk_rt(first)->inh_task;
+                int second_lo_klmirqd = tsk_rt(second)->is_interrupt_thread && !tsk_rt(second)->inh_task;
 
                 /* prioritize aux tasks without inheritance below real-time tasks */
                 if (first_lo_klmirqd || second_lo_klmirqd) {
                         // one of these is an klmirqd thread without inheritance.
-                        if(first_lo_klmirqd && second_lo_klmirqd) {
-                                TRACE_CUR("klmirqd tie break!\n");  // tie-break by BASE priority of the aux tasks
-                                goto klmirqd_tie_break;
-                        }
-                        else {
-                                // make the klmirqd thread the lowest-priority real-time task
-                                // but (above low-prio aux tasks and Linux tasks)
-                                int temp = 0;
-                                if (first_lo_klmirqd && is_realtime(second)) {
-//                                      temp = 0;
-                                }
-                                else if(second_lo_klmirqd && is_realtime(first)) {
-                                        temp = 1;
-                                }
+                        if (first_lo_klmirqd != second_lo_klmirqd) {
+                                int temp = (first_lo_klmirqd < second_lo_klmirqd);  // non-klmirqd has higher priority
                                 TRACE_CUR("%s/%d >> %s/%d --- %d\n", first->comm, first->pid, second->comm, second->pid, temp);
                                 return temp;
                         }
+                        else {
+                                /* both MUST be klmirqd. tie-break. */
+                                TRACE_CUR("klmirqd tie break!\n");
+                                goto klmirqd_tie_break;
+                        }
                 }
 
-                if (first->rt_param.is_interrupt_thread && second->rt_param.is_interrupt_thread &&
-                        first->rt_param.inh_task == second->rt_param.inh_task) {
+                if (tsk_rt(first)->is_interrupt_thread && tsk_rt(second)->is_interrupt_thread &&
+                        tsk_rt(first)->inh_task == tsk_rt(second)->inh_task) {
                         // inh_task is !NULL for both tasks since neither was a lo_klmirqd task.
                         // Both klmirqd tasks inherit from the same task, so tie-break
                         // by base priority of the klmirqd tasks.
@@ -187,19 +165,19 @@ int edf_higher_prio(struct task_struct* first, struct task_struct* second)
         /* Check for EFFECTIVE priorities. Change task
          * used for comparison in such a case.
          */
-        if (unlikely(first->rt_param.inh_task)
+        if (unlikely(tsk_rt(first)->inh_task)
 #ifdef CONFIG_LITMUS_NESTED_LOCKING
                 && (first_mode == EFFECTIVE)
 #endif
                 ) {
-                first_task = first->rt_param.inh_task;
+                first_task = tsk_rt(first)->inh_task;
         }
-        if (unlikely(second->rt_param.inh_task)
+        if (unlikely(tsk_rt(second)->inh_task)
 #ifdef CONFIG_LITMUS_NESTED_LOCKING
                 && (second_mode == EFFECTIVE)
 #endif
                 ) {
-                second_task = second->rt_param.inh_task;
+                second_task = tsk_rt(second)->inh_task;
         }
 
         /* Check for priority boosting. Tie-break by start of boosting.
@@ -222,17 +200,14 @@ int edf_higher_prio(struct task_struct* first, struct task_struct* second)
 
 #endif
 
-#ifdef CONFIG_REALTIME_AUX_TASKS
+#ifdef CONFIG_REALTIME_AUX_TASK_PRIORITY_INHERITANCE
 aux_tie_break:
 #endif
 #ifdef CONFIG_LITMUS_SOFTIRQD
 klmirqd_tie_break:
 #endif
 
-        if (!is_realtime(second_task)) {
-                return 1;
-        }
-        else if (earlier_deadline(first_task, second_task)) {
+        if (earlier_deadline(first_task, second_task)) {
                 return 1;
         }
         else if (get_deadline(first_task) == get_deadline(second_task)) {
@@ -297,10 +272,10 @@ klmirqd_tie_break:
                         }
                         else if (first_task->pid == second_task->pid) {
 #ifdef CONFIG_LITMUS_SOFTIRQD
-                                if (first_task->rt_param.is_interrupt_thread < second_task->rt_param.is_interrupt_thread) {
+                                if (tsk_rt(first_task)->is_interrupt_thread < tsk_rt(second_task)->is_interrupt_thread) {
                                         return 1;
                                 }
-                                else if (first_task->rt_param.is_interrupt_thread == second_task->rt_param.is_interrupt_thread) {
+                                else if (tsk_rt(first_task)->is_interrupt_thread == tsk_rt(second_task)->is_interrupt_thread) {
 #endif
 
 #if defined(CONFIG_REALTIME_AUX_TASK_PRIORITY_INHERITANCE)
@@ -311,7 +286,7 @@ klmirqd_tie_break:
 #endif
 
                                 /* Something could be wrong if you get this far. */
-                                if (unlikely(first->rt_param.inh_task == second->rt_param.inh_task)) {
+                                if (unlikely(tsk_rt(first)->inh_task == tsk_rt(second)->inh_task)) {
                                         /* Both tasks have the same inherited priority.
                                          * Likely in a bug-condition.
                                      */
@@ -324,22 +299,22 @@ klmirqd_tie_break:
                                 }
                                 else {
                                         /* At least one task must inherit */
-                                        BUG_ON(!first->rt_param.inh_task &&
-                                                   !second->rt_param.inh_task);
+                                        BUG_ON(!tsk_rt(first)->inh_task &&
+                                                   !tsk_rt(second)->inh_task);
 
                                         /* The task withOUT the inherited priority wins. */
-                                        if (second->rt_param.inh_task) {
+                                        if (tsk_rt(second)->inh_task) {
                                                 /*
                                                  * common with aux tasks.
                                                 TRACE_CUR("unusual comparison: "
                                                         "first = %s/%d  first_task = %s/%d  "
                                                         "second = %s/%d  second_task = %s/%d\n",
                                                         first->comm, first->pid,
-                                                        (first->rt_param.inh_task) ? first->rt_param.inh_task->comm : "(nil)",
-                                                        (first->rt_param.inh_task) ? first->rt_param.inh_task->pid : 0,
+                                                        (tsk_rt(first)->inh_task) ? tsk_rt(first)->inh_task->comm : "(nil)",
+                                                        (tsk_rt(first)->inh_task) ? tsk_rt(first)->inh_task->pid : 0,
                                                         second->comm, second->pid,
-                                                        (second->rt_param.inh_task) ? second->rt_param.inh_task->comm : "(nil)",
-                                                        (second->rt_param.inh_task) ? second->rt_param.inh_task->pid : 0);
+                                                        (tsk_rt(second)->inh_task) ? tsk_rt(second)->inh_task->comm : "(nil)",
+                                                        (tsk_rt(second)->inh_task) ? tsk_rt(second)->inh_task->pid : 0);
                                                  */
                                                 return 1;
                                         }
@@ -426,3 +401,4 @@ int edf_preemption_needed(rt_domain_t* rt, struct task_struct *t)
         /* make sure to get non-rt stuff out of the way */
         return !is_realtime(t) || edf_higher_prio(__next_ready(rt), t);
 }
+