Fix AUX tasks from being dropped by Litmus.

8 files changed, 53 insertions, 73 deletions

diff --git a/include/litmus/rt_domain.h b/include/litmus/rt_domain.h
index ac249292e866..961d7e7c4912 100644
--- a/include/litmus/rt_domain.h
+++ b/include/litmus/rt_domain.h
@@ -85,8 +85,18 @@ void __add_release(rt_domain_t* rt, struct task_struct *task);
 static inline struct task_struct* __take_ready(rt_domain_t* rt)
 {
         struct bheap_node* hn = bheap_take(rt->order, &rt->ready_queue);
-        if (hn)
+        if (hn) {
+                struct task_struct* taken = bheap2task(hn);
+                TRACE("rt: taking %s/%d [inh_task: %s/%d]\n",
+                        (taken) ? taken->comm : "nil",
+                        (taken) ? taken->pid : -1,
+                        (taken && tsk_rt(taken)->inh_task) ?
+                                tsk_rt(taken)->inh_task->comm : "nil",
+                        (taken && tsk_rt(taken)->inh_task) ?
+                                tsk_rt(taken)->inh_task->pid : -1);
+
                 return bheap2task(hn);
+        }
         else
                 return NULL;
 }
diff --git a/include/litmus/sched_plugin.h b/include/litmus/sched_plugin.h
index d0e7d74bb45e..78cec30866ac 100644
--- a/include/litmus/sched_plugin.h
+++ b/include/litmus/sched_plugin.h
@@ -108,7 +108,6 @@ typedef int (*__higher_prio_t)(struct task_struct* a, comparison_mode_t a_mod,
 typedef int (*default_cpu_for_gpu_t)(int gpu);
 #endif
 
-
 /********************* sys call backends  ********************/
 /* This function causes the caller to sleep until the next release */
 typedef long (*complete_job_t) (void);
diff --git a/kernel/sched.c b/kernel/sched.c
index e29a97235f26..51fb72b5af79 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -2708,14 +2708,17 @@ try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags)
         int cpu, success = 0;
 
         if (is_realtime(p)) {
-                //WARN_ON(1);
                 TRACE_TASK(p, "try_to_wake_up() state:%d\n", p->state);
         }
 
         smp_wmb();
         raw_spin_lock_irqsave(&p->pi_lock, flags);
-        if (!(p->state & state))
+        if (!(p->state & state)) {
+                if (is_realtime(p)) {
+                        TRACE_TASK(p, "try_to_wake_up() masked out, mask:%x\n", state);
+                }
                 goto out;
+        }
 
         success = 1; /* we're going to change ->state */
         cpu = task_cpu(p);
diff --git a/litmus/aux_tasks.c b/litmus/aux_tasks.c
index 46217e78b1ec..07907e22bc09 100644
--- a/litmus/aux_tasks.c
+++ b/litmus/aux_tasks.c
@@ -122,7 +122,6 @@ static int aux_tasks_decrease_priority(struct task_struct *leader, struct task_s
 
         return retval;
 }
-
 #endif
 
 int aux_task_owner_increase_priority(struct task_struct *t)
diff --git a/litmus/edf_common.c b/litmus/edf_common.c
index ef22eb93dbf3..32ee5f464ef8 100644
--- a/litmus/edf_common.c
+++ b/litmus/edf_common.c
@@ -259,8 +259,6 @@ klmirqd_tie_break:
                 }
                 pid_break = (fhash == shash);
 #else
-
-
                 /* CONFIG_EDF_PID_TIE_BREAK */
                 pid_break = 1; // fall through to tie-break by pid;
 #endif
@@ -271,31 +269,27 @@ klmirqd_tie_break:
                                 return 1;
                         }
                         else if (first_task->pid == second_task->pid) {
+                                /* there is inheritance going on. consider inheritors. */
 #ifdef CONFIG_LITMUS_SOFTIRQD
-                                if (tsk_rt(first_task)->is_interrupt_thread < tsk_rt(second_task)->is_interrupt_thread) {
+                                /* non-interrupt thread gets prio */
+                                if (!tsk_rt(first)->is_interrupt_thread && tsk_rt(second)->is_interrupt_thread) {
                                         return 1;
                                 }
-                                else if (tsk_rt(first_task)->is_interrupt_thread == tsk_rt(second_task)->is_interrupt_thread) {
+                                else if (tsk_rt(first)->is_interrupt_thread == tsk_rt(second)->is_interrupt_thread) {
 #endif
 
 #if defined(CONFIG_REALTIME_AUX_TASK_PRIORITY_INHERITANCE)
-                                if (tsk_rt(first)->is_aux_task < tsk_rt(second)->is_aux_task) {
+                                /* non-aux thread gets prio */
+                                if (!tsk_rt(first)->is_aux_task && tsk_rt(second)->is_aux_task) {
                                         return 1;
                                 }
-                                else if (tsk_rt(first)->is_aux_task == tsk_rt(second)->is_aux_task) {
+                                else if (tsk_rt(first_task)->is_aux_task == tsk_rt(second_task)->is_aux_task) {
 #endif
-
-                                /* Something could be wrong if you get this far. */
-                                if (unlikely(tsk_rt(first)->inh_task == tsk_rt(second)->inh_task)) {
-                                        /* Both tasks have the same inherited priority.
-                                         * Likely in a bug-condition.
-                                     */
-                                        if (first->pid < second->pid) {
-                                                return 1;
-                                        }
-                                        else if (first->pid == second->pid) {
-                                                //WARN_ON(1);
-                                        }
+                                /* if both tasks inherit from the same task */
+                                if (tsk_rt(first)->inh_task == tsk_rt(second)->inh_task) {
+                                        /* TODO: Make a recurive call to edf_higher_prio,
+                                           comparing base priorities. */
+                                        return (first->pid < second->pid);
                                 }
                                 else {
                                         /* At least one task must inherit */
@@ -304,18 +298,6 @@ klmirqd_tie_break:
 
                                         /* The task withOUT the inherited priority wins. */
                                         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,
-                                                        (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,
-                                                        (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;
                                         }
                                 }
diff --git a/litmus/ikglp_lock.c b/litmus/ikglp_lock.c
index 170c43fcc78e..5099f6eae537 100644
--- a/litmus/ikglp_lock.c
+++ b/litmus/ikglp_lock.c
@@ -869,7 +869,7 @@ static void ikglp_enqueue_on_donor(struct ikglp_semaphore *sem,
                 }
         }
         else {
-                TRACE_TASK(t, "No change in effective priority (it is %d/%s).  BUG?\n",
+                TRACE_TASK(t, "No change in effective priority (it is %s/%d).\n",
                                    (new_max_eff_prio) ? new_max_eff_prio->comm : "nil",
                                    (new_max_eff_prio) ? new_max_eff_prio->pid : -1);
                 raw_spin_unlock(&tsk_rt(donee)->hp_blocked_tasks_lock);
diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index 1feb2fbe42bc..dd64211a1402 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -240,26 +240,6 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
                         sched = &per_cpu(cedf_cpu_entries, on_cpu);
 
                         BUG_ON(sched->linked == linked);
-#if 0
-                        /* this should only happen if not linked already */
-                        if (sched->linked == linked) {
-                                printk(KERN_EMERG "%s/%d hit sched bug. is_aux = %d; has_aux = %d\n",
-                                                linked->comm, linked->pid, tsk_rt(linked)->is_aux_task, tsk_rt(linked)->has_aux_tasks);
-                                printk(KERN_EMERG "eCPU: %d, eLinked: %s/%d, sCPU: %d, sched: %s/%d\n",
-                                                entry->cpu,
-                                                (entry->linked) ?
-                                                        entry->linked->comm : "nil",
-                                                (entry->linked) ?
-                                                        entry->linked->pid : -1,
-                                                sched->cpu,
-                                                (sched->linked) ?
-                                                        sched->linked->comm : "nil",
-                                                (sched->linked) ?
-                                                        sched->linked->pid : -1);
-                                TRACE_TASK(linked, "LINK BUG!\n");
-                                unlink(linked);
-                        }
-#endif
 
                         /* If we are already scheduled on the CPU to which we
                          * wanted to link, we don't need to do the swap --
@@ -295,11 +275,9 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
  */
 static noinline void unlink(struct task_struct* t)
 {
-        cpu_entry_t *entry;
-
         if (t->rt_param.linked_on != NO_CPU) {
                 /* unlink */
-                entry = &per_cpu(cedf_cpu_entries, t->rt_param.linked_on);
+                cpu_entry_t *entry = &per_cpu(cedf_cpu_entries, t->rt_param.linked_on);
                 t->rt_param.linked_on = NO_CPU;
                 link_task_to_cpu(NULL, entry);
         } else if (is_queued(t)) {
@@ -338,7 +316,7 @@ static noinline void requeue(struct task_struct* task)
 
         if (is_released(task, litmus_clock()))
 #ifdef CONFIG_REALTIME_AUX_TASKS
-                if (unlikely(tsk_rt(task)->is_aux_task && !is_running(task))) {
+                if (unlikely(tsk_rt(task)->is_aux_task && task->state != TASK_RUNNING)) {
                         /* aux_task probably transitioned to real-time while it was blocked */
                         TRACE_CUR("aux task %s/%d is not ready!\n", task->comm, task->pid);
                         unlink(task); /* really needed? */
@@ -874,6 +852,15 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
                 TRACE_TASK(prev, "will be preempted by %s/%d\n",
                            entry->linked->comm, entry->linked->pid);
 
+        if (tsk_rt(prev)->is_aux_task &&
+                (prev->state == TASK_INTERRUPTIBLE) &&
+                !blocks) {
+                TRACE_TASK(prev, "Deferring descheduling of aux task %s/%d.\n",
+                                                prev->comm, prev->pid);
+                next = prev; /* allow prev to continue. */
+                goto out_set_state;
+        }
+
         /* Send the signal that the budget has been exhausted */
         if (signal_budget)
                 send_sigbudget(entry->scheduled);
@@ -934,12 +921,17 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
                         entry->scheduled->rt_param.scheduled_on = NO_CPU;
                         TRACE_TASK(entry->scheduled, "scheduled_on = NO_CPU\n");
                 }
-        } else
+        }
+        else {
                 /* Only override Linux scheduler if we have a real-time task
                  * scheduled that needs to continue.
                  */
-                if (exists)
+                if (exists) {
                         next = prev;
+                }
+        }
+
+out_set_state:
 
         sched_state_task_picked();
         raw_spin_unlock(&cluster->cluster_lock);
@@ -988,6 +980,8 @@ static void cedf_task_new(struct task_struct * t, int on_rq, int running)
         /* setup job params */
         release_at(t, litmus_clock());
 
+        t->rt_param.linked_on = NO_CPU;
+
         if (running) {
                 entry = &per_cpu(cedf_cpu_entries, task_cpu(t));
                 BUG_ON(entry->scheduled);
@@ -1007,15 +1001,11 @@ static void cedf_task_new(struct task_struct * t, int on_rq, int running)
         } else {
                 t->rt_param.scheduled_on = NO_CPU;
         }
-        t->rt_param.linked_on = NO_CPU;
 
         if (is_running(t)) {
                 cedf_job_arrival(t);
         }
-        else {
-                TRACE("Deferred job arrival because %d is blocked.\n", t->pid);
-                unlink(t); /* needed?? */
-        }
+
         raw_spin_unlock_irqrestore(&(cluster->cluster_lock), flags);
 }
 
@@ -1188,7 +1178,7 @@ static int __increase_priority_inheritance(struct task_struct* t,
 
                 /* If it is scheduled, then we need to reorder the CPU heap. */
                 if (linked_on != NO_CPU) {
-                        TRACE_TASK(t, "%s: linked  on %d\n",
+                        TRACE_TASK(t, "%s: linked on %d\n",
                                            __FUNCTION__, linked_on);
                         /* Holder is scheduled; need to re-order CPUs.
                          * We can't use heap_decrease() here since
diff --git a/litmus/sched_plugin.c b/litmus/sched_plugin.c
index 76ff892122aa..e1654da1ea6c 100644
--- a/litmus/sched_plugin.c
+++ b/litmus/sched_plugin.c
@@ -33,10 +33,10 @@ void preempt_if_preemptable(struct task_struct* t, int cpu)
 
         TRACE_CUR("preempt_if_preemptable: %s/%d\n",
                                 (t) ? t->comm : "(nil)",
-                                (t) ? t->pid : 0);
+                                (t) ? t->pid : -1);
 
         if (!t) {
-                TRACE_CUR("unconditionally reshcedule\n");
+                TRACE_CUR("unconditionally reschedule\n");
                 /* move non-real-time task out of the way */
                 reschedule = 1;
         }
@@ -229,7 +229,6 @@ static int litmus_dummy_map_gpu_to_cpu(int gpu)
 }
 #endif
 
-
 /* The default scheduler plugin. It doesn't do anything and lets Linux do its
  * job.
  */
@@ -272,7 +271,6 @@ struct sched_plugin linux_sched_plugin = {
 #if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_SOFTIRQD)
         .map_gpu_to_cpu = litmus_dummy_map_gpu_to_cpu,
 #endif
-
         .admit_task = litmus_dummy_admit_task
 };
 
@@ -335,7 +333,6 @@ int register_sched_plugin(struct sched_plugin* plugin)
 #if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_SOFTIRQD)
         CHECK(map_gpu_to_cpu);
 #endif
-
         CHECK(admit_task);
 
         if (!plugin->release_at)