Server tasks stay linked when client tasks release.

1 files changed, 66 insertions, 37 deletions

diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 3fb223255792..33adc860b6ba 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -653,10 +653,7 @@ static void remove_from_all(struct task_struct* task)
                 } else {
                         TRACE_MC_TASK(task, "Unlinked before we got lock!\n");
                 }
-                if (update)
-                        update_crit_levels(entry);
-                else
-                        raw_spin_unlock(&entry->lock);
+                raw_spin_unlock(&entry->lock);
         } else {
                 TRACE_MC_TASK(task, "Not linked to anything\n");
         }
@@ -676,46 +673,64 @@ static void job_completion(struct task_struct *task, int forced)
 {
         lt_t now;
         int release_server;
-        TRACE_MC_TASK(task, "Completed\n");
+        struct cpu_entry *entry;
+        struct crit_entry *ce;
 
-        /* Logically stop the task execution */
-        remove_from_all(task);
-        set_rt_flags(task, RT_F_SLEEP);
+        TRACE_MC_TASK(task, "Completed\n");
 
         if (!forced) {
                 /* Userspace signaled job completion */
                 sched_trace_task_completion(current, 0);
                 setup_user_release(current, get_user_deadline(current));
-
         }
 
-        release_server = budget_exhausted(task);
 #ifndef CONFIG_PLUGIN_MC_LINUX_SLACK_STEALING
         /* Release lowest-criticality task's servers with their userspace tasks,
-         * preventing them from turning into ghost tasks and forcing idleness
+         * preventing them from turning into idle ghost tasks
          */
         if (tsk_mc_crit(task) == NUM_CRIT_LEVELS - 1)
-                release_server |= is_ghost(task);
+                release_server = 1;
+        else
 #endif
+        release_server = budget_exhausted(task);
 
-        /* If server has run out of budget, wait until next release
-         * TODO: Level A does this independently and should not.
-         */
-        if (release_server && CRIT_LEVEL_A != tsk_mc_crit(task)) {
-                sched_trace_server_completion(-task->pid, get_rt_job(task));
-                prepare_for_next_period(task);
+        if (release_server || forced) {
+                /* Only unlink (and release resources) if the current server job
+                 * must stop logically running
+                 */
+                remove_from_all(task);
         }
 
-        now = litmus_clock();
-        if (lt_before(get_user_release(task), now)) {
+        if (lt_before(get_user_release(task), litmus_clock())) {
                 TRACE_TASK(task, "Executable task going back to running\n");
                 set_rt_flags(task, RT_F_RUNNING);
         }
 
+        if (release_server || forced) {
+                /* TODO: Level A does this independently and should not */
+                if (release_server && CRIT_LEVEL_A != tsk_mc_crit(task)) {
+                        sched_trace_server_completion(-task->pid,
+                                                      get_rt_job(task));
+                        prepare_for_next_period(task);
+                }
 
-        if (is_running(task)) {
                 /* Requeue non-blocking tasks */
-                job_arrival(task);
+                if (is_running(task)) {
+                        job_arrival(task);
+                }
+        } else if (is_ghost(task)) {
+                entry = &per_cpu(cpus, tsk_rt(task)->linked_on);
+                ce = &entry->crit_entries[tsk_mc_crit(task)];
+
+                raw_spin_lock(&entry->lock);
+                if (ce->linked == task && is_ghost(task)) {
+                        /* The task went ghost while it was linked to a CPU */
+                        link_task_to_cpu(entry, NULL);
+                        sched_trace_server_switch_away(ce_sid(ce),0,-task->pid,
+                                                       get_rt_job(task));
+                        start_crit(ce);
+                }
+                raw_spin_unlock(&entry->lock);
         }
 }
 
@@ -730,10 +745,26 @@ static void mc_ghost_exhausted(struct rt_event *e)
 static enum hrtimer_restart mc_ghost_exhausted(struct hrtimer *timer)
 {
         struct crit_entry *ce = container_of(timer, struct crit_entry, timer);
+        struct cpu_entry *entry = crit_cpu(ce);
+        struct task_struct *tmp = NULL;
 #endif
         TRACE_CRIT_ENTRY(ce, "Firing here at %llu\n", litmus_clock());
 
-        litmus_reschedule(crit_cpu(ce)->cpu);
+        raw_spin_lock(&entry->lock);
+
+        if (is_ghost(ce->linked)) {
+                update_server_time(ce->linked);
+                if (budget_exhausted(ce->linked)) {
+                        tmp = ce->linked;
+                }
+        } else {
+                litmus_reschedule(crit_cpu(ce)->cpu);
+        }
+
+        raw_spin_unlock(&entry->lock);
+
+        if (tmp)
+                job_completion(tmp, 1);
 
 #ifndef CONFIG_MERGE_TIMERS
         return HRTIMER_NORESTART;
@@ -775,8 +806,8 @@ static lt_t __ce_timer_function(struct ce_dom_data *ce_data)
                 job_completion(old_link, 1);
         } else {
                 STRACE("old_link was null, so will call check for preempt\n");
-                raw_spin_unlock(dom->lock);
                 check_for_preempt(dom);
+                raw_spin_unlock(dom->lock);
         }
         return next_timer_abs;
 }
@@ -863,18 +894,17 @@ static void mc_task_new(struct task_struct *t, int on_rq, int running)
         t->rt_param._domain = entry->crit_entries[level].domain;
 
         /* Userspace and kernelspace view of task state may differ.
-         * Model kernel state as an additional container
+         * Model kernel state as a budget enforced container
          */
         sched_trace_container_param(t->pid, t->comm);
         sched_trace_server_param(-t->pid, t->pid,
                                  get_exec_cost(t), get_rt_period(t));
+        tsk_rt(t)->task_params.budget_policy = PRECISE_ENFORCEMENT;
 
         /* Apply chunking */
-        if (level == CRIT_LEVEL_B) {
-                tsk_rt(t)->task_params.budget_policy = PRECISE_ENFORCEMENT;
-                if (color_chunk && level == CRIT_LEVEL_B &&
-                    lt_after(get_exec_cost(t), color_chunk))
-                        tsk_rt(t)->orig_cost = get_exec_cost(t);
+        if (level == CRIT_LEVEL_B && color_chunk
+            lt_after(get_exec_cost(t), color_chunk)) {
+                tsk_rt(t)->orig_cost = get_exec_cost(t);
         }
 
         /* Setup color request */
@@ -1010,7 +1040,7 @@ void pick_next_task(struct cpu_entry *entry)
                 dom = ce->domain;
 
                 /* Swap locks. We cannot acquire a domain lock while
-                 * holding an entry lock or deadlocks will happen.
+                 * holding an entry lock or deadlocks will happen
                  */
                 raw_spin_unlock(&entry->lock);
                 raw_spin_lock(dom->lock);
@@ -1060,7 +1090,7 @@ static struct task_struct* mc_schedule(struct task_struct* prev)
 
         /* Litmus gave up because it couldn't access the stack of the CPU
          * on which will_schedule was migrating from. Requeue it.
-         * This really only happens in VMs.
+         * This really only happens in VMs
          */
         if (entry->will_schedule && entry->will_schedule != prev) {
                 entry->will_schedule->rt_param.scheduled_on = NO_CPU;
@@ -1106,7 +1136,7 @@ static struct task_struct* mc_schedule(struct task_struct* prev)
          * period completes unless its execution has been forcibly stopped
          */
         else if (out_of_time || sleep)/* && !preempt)*/
-                job_completion(entry->scheduled, !sleep);
+                job_completion(entry->scheduled, !sleep || preempt);
         /* Global scheduled tasks must wait for a deschedule before they
          * can rejoin the global state. Rejoin them here
          */
@@ -1125,7 +1155,9 @@ static struct task_struct* mc_schedule(struct task_struct* prev)
         /* A remote processor unblocked one of our crit levels */
         if (entry->crit_signal != NUM_CRIT_LEVELS) {
                 ce = &entry->crit_entries[entry->crit_signal];
+                raw_spin_lock(&ce->domain->lock);
                 check_for_preempt(ce->domain);
+                raw_spin_unlock(&ce->domain->lock);
                 entry->crit_signal = NUM_CRIT_LEVELS;
         }
 
@@ -1145,12 +1177,9 @@ static struct task_struct* mc_schedule(struct task_struct* prev)
 
         if (next) {
                 tsk_rt(next)->last_exec_time = litmus_clock();
-                BUG_ON(!is_released(next, tsk_rt(next)->last_exec_time));
-                BUG_ON(is_ghost(next));
                 TRACE_MC_TASK(next, "Picked this task\n");
         } else if (exists && !next)
-                STRACE("CPU %d becomes idle at %llu\n",
-                       entry->cpu, litmus_clock());
+                STRACE("CPU %d idles at %llu\n", entry->cpu, litmus_clock());
 
         return next;
 }