1 files changed, 62 insertions, 85 deletions

diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index f24c51653fe2..8c2238c6bf43 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -1,4 +1,4 @@
-/**
+/*
  * litmus/sched_mc.c
  *
  * Implementation of the Mixed Criticality scheduling algorithm.
@@ -270,13 +270,13 @@ static void update_ghost_time(struct task_struct *p)
                 delta = 0;
                 TRACE_MC_TASK(p, "WARNING: negative time delta\n");
         }
-        if (tsk_mc_data(p)->mc_job.ghost_budget <= delta) {
+        if (budget_remaining(p) <= delta) {
                 TRACE_MC_TASK(p, "Ghost job could have ended\n");
-                tsk_mc_data(p)->mc_job.ghost_budget = 0;
+                tsk_rt(p)->job_params.exec_time = get_exec_cost(p);
                 p->se.exec_start = clock;
         } else {
                 TRACE_MC_TASK(p, "Ghost job updated, but didn't finish\n");
-                tsk_mc_data(p)->mc_job.ghost_budget -= delta;
+                tsk_rt(p)->job_params.exec_time += delta;
                 p->se.exec_start = clock;
         }
 }
@@ -302,13 +302,13 @@ static void link_task_to_crit(struct crit_entry *ce,
                 ce->linked->rt_param.linked_on = NO_CPU;
                 if (is_ghost(ce->linked)) {
                         cancel_ghost(ce);
-                        if (tsk_mc_data(ce->linked)->mc_job.ghost_budget > 0) {
+                        if (!budget_exhausted(ce->linked)) {
                                 /* Job isn't finished, so do accounting */
                                 update_ghost_time(ce->linked);
                         }
                 }
-                sched_trace_server_switch_away(sid(ce), 0, ce->linked->pid,
-                                               tsk_rt(ce->linked)->job_params.job_no);
+                sched_trace_server_switch_away(sid(ce), 0, -ce->linked->pid,
+                                               get_rt_job(ce->linked));
         }
 
         /* Actually link task */
@@ -321,15 +321,11 @@ static void link_task_to_crit(struct crit_entry *ce,
                          * tasks. Otherwise reset the budget timer.
                          */
                         task->se.exec_start = litmus_clock();
-                        when_to_fire = task->se.exec_start +
-                                tsk_mc_data(task)->mc_job.ghost_budget;
+                        when_to_fire = task->se.exec_start + budget_remaining(task);
                         arm_ghost(ce, when_to_fire);
-
-                        sched_trace_server_switch_to(sid(ce), 0, 0, 0);
-                } else {
-                        sched_trace_server_switch_to(sid(ce), 0, task->pid,
-                                                     get_rt_job(ce->linked));
                 }
+                sched_trace_server_switch_to(sid(ce), 0, -task->pid,
+                                             get_rt_job(ce->linked));
         }
 }
 
@@ -434,18 +430,19 @@ static void link_task_to_cpu(struct cpu_entry *entry, struct task_struct *task)
 
         if (entry->linked) {
                 sched_trace_server_switch_away(-entry->linked->pid,
-                                               get_server_job(entry->linked),
+                                               get_rt_job(entry->linked),
                                                entry->linked->pid,
-                                               get_rt_job(entry->linked));
+                                               get_user_job(entry->linked));
         }
 
-        if (task){
+        if (task) {
                 set_rt_flags(task, RT_F_RUNNING);
                 sched_trace_server_switch_to(-task->pid,
-                                             get_server_job(task),
+                                             get_rt_job(task),
                                              task->pid,
-                                             get_rt_job(task));
+                                             get_user_job(task));
         }
+
         entry->linked = task;
 
         /* Higher criticality crit entries are now usable */
@@ -480,7 +477,11 @@ static void preempt(struct domain *dom, struct crit_entry *ce)
         }
         update_crit_position(ce);
 
-        /* Preempt actual execution if this is a running task */
+        /* Preempt actual execution if this is a running task.
+         * We know that our task is higher priority than what is currently
+         * running on this CPU as otherwise the crit_entry would have
+         * been disabled and a preemption could not have occurred
+         */
         if (!is_ghost(task)) {
                 link_task_to_cpu(entry, task);
                 preempt_if_preemptable(entry->scheduled, entry->cpu);
@@ -564,7 +565,7 @@ static void check_for_preempt(struct domain *dom)
                         if (!can_use(ce))
                                 /* CPU disabled while locking! */
                                 fix_crit_position(ce);
-                        else if (dom->preempt_needed(dom, ce->linked))
+                        else if (mc_preempt_needed(dom, ce->linked))
                                 /* Success! Check for more preemptions */
                                 preempt(dom, ce);
                         else {
@@ -582,7 +583,7 @@ static void check_for_preempt(struct domain *dom)
                 dom->peek_ready(dom);
 
                 raw_spin_lock(&entry->lock);
-                if (can_use(ce) && dom->preempt_needed(dom, ce->linked)) {
+                if (can_use(ce) && mc_preempt_needed(dom, ce->linked)) {
                         preempt(dom, ce);
                         update_crit_levels(entry);
                 } else {
@@ -609,6 +610,7 @@ static void remove_from_all(struct task_struct* task)
 
         /* Remove the task from any CPU state */
         if (task->rt_param.linked_on != NO_CPU) {
+                TRACE_MC_TASK(task, "Linked to something\n");
                 entry = &per_cpu(cpus, task->rt_param.linked_on);
                 raw_spin_lock(&entry->lock);
 
@@ -618,7 +620,7 @@ static void remove_from_all(struct task_struct* task)
                         BUG_ON(ce->linked != task);
                         link_task_to_crit(ce, NULL);
                         update_crit_position(ce);
-                        if (!is_ghost(task) && entry->linked == task) {
+                        if (entry->linked == task) {
                                 update = 1;
                                 link_task_to_cpu(entry, NULL);
                         }
@@ -646,41 +648,25 @@ static void remove_from_all(struct task_struct* task)
  */
 static void job_completion(struct task_struct *task, int forced)
 {
-        int behind;
         TRACE_MC_TASK(task, "Completed\n");
 
         /* Logically stop the task execution */
         set_rt_flags(task, RT_F_SLEEP);
         remove_from_all(task);
 
-        /* Level-A tasks cannot ever get behind */
-        behind = tsk_mc_crit(task) != CRIT_LEVEL_A && behind_server(task);
-
-        if (!forced && !is_ghost(task)) {
-                /* Task voluntarily ceased execution. Move on to next period */
-                task_release(task);
-                sched_trace_task_completion(task, forced);
-
-                /* Convert to ghost job */
-                tsk_mc_data(task)->mc_job.ghost_budget = budget_remaining(task);
-                tsk_mc_data(task)->mc_job.is_ghost = 1;
+        if (!forced) {
+                /* Userspace releases */
+                sched_trace_task_completion(current, 0);
+                setup_user_release(current, get_user_deadline(current));
         }
 
-        /* If the task has no ghost budget, convert back from ghost.
-         * If the task is behind, undo ghost conversion so that it
-         * can catch up.
-         */
-        if (behind || tsk_mc_data(task)->mc_job.ghost_budget == 0) {
-                TRACE_MC_TASK(task, "Not a ghost task\n");
-                tsk_mc_data(task)->mc_job.is_ghost = 0;
-                tsk_mc_data(task)->mc_job.ghost_budget = 0;
-        }
 
-        /* If server has run out of budget, wait until next release */
-        if (budget_exhausted(task)) {
-                sched_trace_server_completion(-task->pid,
-                                              get_server_job(task));
-                server_release(task);
+        /* If server has run out of budget, wait until next release
+         * TODO: Level A does this independently and should not.
+         */
+        if (budget_exhausted(task) && CRIT_LEVEL_A != tsk_mc_crit(task)) {
+                sched_trace_server_completion(-task->pid, get_rt_job(task));
+                prepare_for_next_period(task);
         }
 
         /* Requeue non-blocking tasks */
@@ -706,7 +692,7 @@ static enum hrtimer_restart mc_ghost_exhausted(struct hrtimer *timer)
 
         local_irq_save(flags);
         TRACE("Ghost exhausted\n");
-        TRACE_CRIT_ENTRY(ce, "Firing here\n");
+        TRACE_CRIT_ENTRY(ce, "Firing here at %llu\n", litmus_clock());
 
         /* Due to race conditions, we cannot just set the linked
          * task's budget to 0 as it may no longer be the task
@@ -716,14 +702,14 @@ static enum hrtimer_restart mc_ghost_exhausted(struct hrtimer *timer)
         raw_spin_lock(&crit_cpu(ce)->lock);
         if (ce->linked && is_ghost(ce->linked)) {
                 update_ghost_time(ce->linked);
-                if (tsk_mc_data(ce->linked)->mc_job.ghost_budget == 0) {
+                if (budget_exhausted(ce->linked)) {
                         tmp = ce->linked;
                 }
         }
         raw_spin_unlock(&crit_cpu(ce)->lock);
 
         if (tmp)
-                job_completion(tmp, 0);
+                job_completion(tmp, 1);
 
         local_irq_restore(flags);
 #ifndef CONFIG_MERGE_TIMERS
@@ -748,12 +734,11 @@ static lt_t __ce_timer_function(struct ce_dom_data *ce_data)
 
         raw_spin_lock(&crit_cpu(ce)->lock);
         if (ce->linked &&
-            ce->linked == ce_data->should_schedule &&
-            is_ghost(ce->linked))
+            ce->linked == ce_data->should_schedule)
         {
                 old_link = ce->linked;
-                tsk_mc_data(ce->linked)->mc_job.ghost_budget = 0;
                 link_task_to_crit(ce, NULL);
+                mc_ce_job_completion(dom, old_link);
         }
         raw_spin_unlock(&crit_cpu(ce)->lock);
 
@@ -764,7 +749,7 @@ static lt_t __ce_timer_function(struct ce_dom_data *ce_data)
         if (NULL != old_link) {
                 STRACE("old_link " TS " so will call job completion\n", TA(old_link));
                 raw_spin_unlock(dom->lock);
-                job_completion(old_link, 0);
+                job_completion(old_link, 1);
         } else {
                 STRACE("old_link was null, so will call check for preempt\n");
                 raw_spin_unlock(dom->lock);
@@ -837,12 +822,13 @@ static void mc_task_new(struct task_struct *t, int on_rq, int running)
         unsigned long flags;
         struct cpu_entry* entry;
         enum crit_level level = tsk_mc_crit(t);
-        char name[TASK_COMM_LEN];
-        strcpy(name, "rtspin");
 
         local_irq_save(flags);
         TRACE("New mixed criticality task %d\n", t->pid);
 
+        if (level == CRIT_LEVEL_A)
+                get_rt_relative_deadline(t) = get_exec_cost(t);
+
         /* Assign domain */
         if (level < CRIT_LEVEL_C)
                 entry = &per_cpu(cpus, get_partition(t));
@@ -850,19 +836,15 @@ static void mc_task_new(struct task_struct *t, int on_rq, int running)
                 entry = &per_cpu(cpus, task_cpu(t));
         t->rt_param._domain = entry->crit_entries[level].domain;
 
-        if (budget_enforced(t)) {
-                /* Userspace and kernelspace view of task state may differ.
-                 * Model kernel state as an additional container
-                 */
-                sched_trace_container_param(t->pid, name);
-                sched_trace_server_param(-t->pid, t->pid,
-                                         get_exec_cost(t), get_rt_period(t));
-        }
+        /* Userspace and kernelspace view of task state may differ.
+         * Model kernel state as an additional 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));
 
         /* Setup job params */
         release_at(t, litmus_clock());
-        tsk_mc_data(t)->mc_job.ghost_budget = 0;
-        tsk_mc_data(t)->mc_job.is_ghost = 0;
         if (running) {
                 BUG_ON(entry->scheduled);
                 entry->scheduled = t;
@@ -872,7 +854,6 @@ static void mc_task_new(struct task_struct *t, int on_rq, int running)
         }
         t->rt_param.linked_on = NO_CPU;
 
-
         job_arrival(t);
 
         local_irq_restore(flags);
@@ -1057,12 +1038,14 @@ static struct task_struct* mc_schedule(struct task_struct* prev)
                 raw_spin_lock(&entry->lock);
 
                 if (!entry->linked && !ce->linked && dtask && can_use(ce)) {
+                        /* Pop dtask */
                         dom->take_ready(dom);
+
                         link_task_to_crit(ce, dtask);
                         update_crit_position(ce);
-                        ready_task = (is_ghost(dtask)) ? NULL : dtask;
 
-                        /* Task found! */
+                        /* Actual running task found */
+                        ready_task = (is_ghost(dtask)) ? NULL : dtask;
                         if (ready_task) {
                                 link_task_to_cpu(entry, ready_task);
                                 raw_spin_unlock(dom->lock);
@@ -1084,6 +1067,7 @@ static struct task_struct* mc_schedule(struct task_struct* prev)
         raw_spin_unlock(&entry->lock);
         local_irq_restore(flags);
         if (next) {
+                BUG_ON(!get_rt_job(next));
                 TRACE_MC_TASK(next, "Picked this task\n");
         } else if (exists && !next)
                 TRACE_ENTRY(entry, "Becomes idle at %llu\n", litmus_clock());
@@ -1105,11 +1089,7 @@ void mc_finish_switch(struct task_struct *prev)
  */
 void mc_release_at(struct task_struct *ts, lt_t start)
 {
-        /* hack so that we can have CE timers start at the right time */
-        if (CRIT_LEVEL_A == tsk_mc_crit(ts))
-                mc_ce_release_at_common(ts, start);
-        else
-                release_at(ts, start);
+        release_at(ts, start);
 }
 
 long mc_deactivate_plugin(void)
@@ -1191,7 +1171,7 @@ static void mc_release_ts(lt_t time)
         strcpy(name, "LVL-A");
         for_each_online_cpu(cpu) {
                 entry = &per_cpu(cpus, cpu);
-                trace_litmus_container_param(++cont_id, (const char*)&name);
+                sched_trace_container_param(++cont_id, (const char*)&name);
                 ce = &entry->crit_entries[level];
                 sched_trace_server_param(sid(ce), cont_id, 0, 0);
         }
@@ -1200,22 +1180,21 @@ static void mc_release_ts(lt_t time)
         strcpy(name, "LVL-B");
         for_each_online_cpu(cpu) {
                 entry = &per_cpu(cpus, cpu);
-                trace_litmus_container_param(++cont_id, (const char*)&name);
+                sched_trace_container_param(++cont_id, (const char*)&name);
                 ce = &entry->crit_entries[level];
                 sched_trace_server_param(sid(ce), cont_id, 0, 0);
         }
 
         level = CRIT_LEVEL_C;
         strcpy(name, "LVL-C");
-        trace_litmus_container_param(++cont_id, (const char*)&name);
+        sched_trace_container_param(++cont_id, (const char*)&name);
         for_each_online_cpu(cpu) {
                 entry = &per_cpu(cpus, cpu);
                 ce = &entry->crit_entries[level];
                 sched_trace_server_param(sid(ce), cont_id, 0, 0);
         }
 
-
-
+        mc_ce_release_at_common(NULL, time);
 }
 
 static struct sched_plugin mc_plugin __cacheline_aligned_in_smp = {
@@ -1287,8 +1266,7 @@ static inline void init_edf_domain(struct domain *dom, rt_domain_t *rt,
                                    enum crit_level prio, int is_partitioned, int cpu)
 {
         pd_domain_init(dom, rt, edf_ready_order, NULL,
-                       mc_release_jobs, mc_preempt_needed,
-                       edf_higher_prio);
+                       mc_release_jobs, edf_higher_prio);
         rt->level = prio;
 #if defined(CONFIG_PLUGIN_MC_RELEASE_MASTER) && defined(CONFIG_MERGE_TIMERS)
         /* All timers are on one CPU and release-master is using the event
@@ -1345,8 +1323,7 @@ static int __init init_mc(void)
                 raw_spin_lock_init(a_dom_lock);
                 ce_domain_init(&dom_data->domain,
                                 a_dom_lock, ce_requeue, ce_peek_and_take_ready,
-                                ce_peek_and_take_ready, mc_preempt_needed,
-                                ce_higher_prio, ce_data, cpu,
+                                ce_peek_and_take_ready, ce_higher_prio, ce_data, cpu,
                                 ce_timer_function);
                 init_local_domain(entry, dom_data, CRIT_LEVEL_A);
                 dom_data->domain.name = "LVL-A";