Fix double requeueing problems

1 files changed, 29 insertions, 20 deletions

diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 0f11683cdd9f..9fc7abaeaed4 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -346,9 +346,13 @@ static void update_ghost_time(struct task_struct *p)
                 TRACE_TASK(p, "WARNING: negative time delta.\n");
         }
         if (p->rt_param.job_params.ghost_budget <= delta) {
-                TRACE_TASK(p, "Ghost job ended in update_ghost_time\n");
+                /*Currently will just set ghost budget to zero since
+                 * task has already been queued.  Could probably do
+                 * more efficiently with significant reworking.
+                 */
+                TRACE_TASK(p, "Ghost job could have ended\n");
                 p->rt_param.job_params.ghost_budget = 0;
-                job_completion(p, 0);
+                p->se.exec_start = clock;
         }
         else{
                 TRACE_TASK(p, "Ghost jub updated, but didn't finish\n");
@@ -370,8 +374,16 @@ static void cancel_watchdog_timer(struct watchdog_timer* wt)
                 ret = hrtimer_try_to_cancel(&wt->timer);
                 /*Should never be inactive.*/
                 BUG_ON(ret == 0);
-                /*Should never be running concurrently. */
-                BUG_ON(ret == -1);
+                /*Running concurrently is an unusual situation - log it. */
+                /*TODO: is there a way to prevent this?  This probably means
+                 * the timer task is waiting to acquire the lock while the
+                 * cancellation attempt is happening.
+                 *
+                 * And are we even in a correct state when this happens?
+                 */
+                if (ret == -1)
+                        TRACE_TASK(wt->task, "Timer cancellation "
+                                "attempted while task completing\n");
 
                 wt->task = NULL;
         }
@@ -543,21 +555,17 @@ static noinline void unlink(struct task_struct* t)
                         if (t->rt_param.job_params.ghost_budget > 0){
                                 /* Job isn't finished, so do accounting. */
                                 update_ghost_time(t);
-                                /* Need to check again since accounting might
-                                 * change value.
+                                /* Just remove from CPU, even in the rare case
+                                 * of zero time left - it will be scheduled
+                                 * with an immediate timer fire.
                                  */
-                                if (t->rt_param.job_params.ghost_budget > 0) {
-                                        /* Still have budget, so just remove
-                                         * from CPU
-                                         */
-                                        entry->ghost_tasks[
-                                                t->rt_param.task_params.crit]
-                                                = NULL;
-                                        /*TODO: maybe make more efficient by
-                                         * only updating on C/D completion?
-                                         */
-                                        update_cpu_position(entry);
-                                }
+                                entry->ghost_tasks[
+                                        t->rt_param.task_params.crit]
+                                        = NULL;
+                                /*TODO: maybe make more efficient by
+                                 * only updating on C/D completion?
+                                 */
+                                update_cpu_position(entry);
                         }
                         else{
                                 /* Job finished, so just remove */
@@ -740,7 +748,6 @@ static void mc_release_jobs(rt_domain_t* rt, struct bheap* tasks)
 static noinline void job_completion(struct task_struct *t, int forced)
 {
         cpu_entry_t *cpu;
-        int already_unlinked = 0;
         BUG_ON(!t);
 
         sched_trace_task_completion(t, forced);
@@ -1135,7 +1142,9 @@ static void mc_task_wake_up(struct task_struct *task)
                         }
                 }
         }
-        mc_job_arrival(task);
+        /*Delay job arrival if we still have an active ghost job*/
+        if (!is_ghost(task))
+                mc_job_arrival(task);
         raw_spin_unlock_irqrestore(&global_lock, flags);
 }