1 files changed, 46 insertions, 18 deletions

diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index baded0d58cb9..da8a82119612 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -477,6 +477,22 @@ static void update_crit_levels(struct cpu_entry *entry)
         }
 }
 
+static inline int cache_next(struct domain *dom)
+{
+        struct task_struct *t;
+        t = dom->peek_ready(dom);
+        return 1;
+        /* if (t && tsk_mc_crit(t) != CRIT_LEVEL_A && budget_exhausted(t)) { */
+        /*      TRACE_TASK(t, "Cached and moved to release\n"); */
+        /*      prepare_for_next_server(t, 1); */
+        /*      dom->take_ready(dom); */
+        /*      dom->requeue(dom, t); */
+        /*      return 0; */
+        /* } else { */
+        /*      return 1; */
+        /* } */
+}
+
 /**
  * check_for_preempt() - Causes a preemption if higher-priority tasks are ready.
  * Caller must hold domain lock.
@@ -495,8 +511,10 @@ static void check_for_preempt(struct domain *dom)
                         entry = crit_cpu(ce);
                         recheck = 1;
 
-                        /* Cache ready task */
-                        dom->peek_ready(dom);
+                        /* Dodge exhausted tasks */
+                        if (!cache_next(dom)) {
+                                continue;
+                        }
 
                         raw_spin_lock(&entry->lock);
                         if (!can_use(ce))
@@ -516,6 +534,7 @@ static void check_for_preempt(struct domain *dom)
                 ce = domain_data(dom)->crit_entry;
                 entry = crit_cpu(ce);
                 raw_spin_lock(&entry->lock);
+                while (!cache_next(dom));
                 if (can_use(ce) && dom->preempt_needed(dom, ce->linked)) {
                         preempt(dom, ce);
                         update_crit_levels(entry);
@@ -570,7 +589,6 @@ static void remove_from_all(struct task_struct* task)
         /* Ensure the task isn't returned by its domain */
         dom->remove(dom, task);
 
-        BUG_ON(is_queued(task));
         raw_spin_unlock(dom->lock);
 }
 
@@ -582,8 +600,15 @@ static void remove_from_all(struct task_struct* task)
 static void job_completion(struct task_struct *task, int forced)
 {
         lt_t now;
-        TRACE_MC_TASK(task, "Completed\n");
-        sched_trace_task_completion(task, forced);
+        int ghost = is_ghost(task);
+        int behind = tsk_mc_crit(task) != CRIT_LEVEL_A && job_behind(task);
+        TRACE_MC_TASK(task, "Completed, ghost %d, forced %d, behind %d\n",
+                      ghost, forced, behind);
+
+        /* if (!is_ghost(task)) { */
+        /* and no more forced!!! */
+                sched_trace_task_completion(task, forced);
+        /* } */
         BUG_ON(!task);
 
         /* Logically stop the task execution */
@@ -592,23 +617,25 @@ static void job_completion(struct task_struct *task, int forced)
 
         now = litmus_clock();
 
-        /* If it's not a ghost job, do ghost job conversion */
-        if (!is_ghost(task) && !job_behind(task)) {
-                TRACE_MC_TASK(task, "is not a ghost task\n");
-                tsk_mc_data(task)->mc_job.ghost_budget = budget_remaining(task);
+
+        if (!forced && !ghost) {
+                task_release(task);
+        }
+
+        if (!forced && !ghost) {
+                tsk_mc_data(task)->mc_job.ghost_budget =
+                        budget_remaining(task);
                 tsk_mc_data(task)->mc_job.is_ghost = 1;
         }
 
-        /* If the task is a ghost job with no budget, it either exhausted
-         * its ghost budget or there was no ghost budget after the job
-         * conversion. Revert back to a normal task and complete the period.
-         */
-        if (tsk_mc_data(task)->mc_job.ghost_budget == 0) {
-                TRACE_MC_TASK(task, "has zero ghost budget\n");
+        if (forced || behind || tsk_mc_data(task)->mc_job.ghost_budget == 0) {
+                TRACE_MC_TASK(task, "making not a ghost\n");
                 tsk_mc_data(task)->mc_job.is_ghost = 0;
-                prepare_for_next_server(task, forced);
-                if (is_released(task, litmus_clock()))
-                        sched_trace_task_release(task);
+                tsk_mc_data(task)->mc_job.ghost_budget = 0;
+        }
+
+        if (forced || (!behind && !is_ghost(task))) {
+                server_release(task);
         }
 
         /* Requeue non-blocking tasks */
@@ -967,6 +994,7 @@ static struct task_struct* mc_schedule(struct task_struct* prev)
                 raw_spin_lock(dom->lock);
 
                 /* Peek at task here to avoid lock use */
+                while (!cache_next(dom));
                 dtask = dom->peek_ready(dom);
 
                 raw_spin_lock(&entry->lock);