checkpoint before refactor

4 files changed, 101 insertions, 64 deletions

diff --git a/litmus/ce_domain.c b/litmus/ce_domain.c
index d6f713fbf789..8797c05d9392 100644
--- a/litmus/ce_domain.c
+++ b/litmus/ce_domain.c
@@ -31,14 +31,11 @@ void ce_requeue(domain_t *dom, struct task_struct *ts)
 
         /* When coming from job completion, the task will be asleep. */
         if (asleep && just_finished < expected_job) {
-                /* this job is running behind, so don't put it to sleep */
-                set_rt_flags(ts, RT_F_RUNNING);
-                TRACE_TASK(ts, "appears behind, setting it to running again\n");
+                TRACE_TASK(ts, "appears behind\n");
         } else if (asleep && expected_job < just_finished) {
-                printk(KERN_CRIT "job %d completed in expected job %d which "
+                TRACE_TASK(ts, "job %d completed in expected job %d which "
                                 "seems too early\n", just_finished,
                                 expected_job);
-                BUG();
         }
 }
 
@@ -60,30 +57,53 @@ struct task_struct* ce_peek_and_take_ready(domain_t *dom)
         const struct ce_dom_data *ce_data = dom->data;
         const int exists = NULL != ce_data->should_schedule;
         const int blocked = exists && !is_running(ce_data->should_schedule);
+        const int sleeping = exists && RT_F_SLEEP ==
+                get_rt_flags(ce_data->should_schedule);
 
-        /* Return the task we should schedule if it is not blocked. If it is
-         * asleep, return it anyway, because the MC-scheduler might as about
-         * ghost jobs.
-         */
-        if (exists && !blocked)
+        TRACE("exists: %d    blocked: %d   sleeping: %d\n", exists, blocked,
+                        sleeping);
+
+        /* Return the task we should schedule if it is not blocked or sleeping. */
+        if (exists && !blocked && !sleeping)
                 ret = ce_data->should_schedule;
         return ret;
 }
 
+#define TS "(%s/%d:%d:%s)"
+#define TA(t) (t) ? (is_ghost(t)) ? "ghost" : t->comm : "NULL", (t) ? t->pid : 1, \
+              (t) ? t->rt_param.job_params.job_no : 1,                  \
+              (t && get_task_domain(t)) ? get_task_domain(t)->name : ""
+
 int ce_higher_prio(struct task_struct *_a,
                 struct task_struct *_b)
 {
         const struct task_struct *a = _a;
         const domain_t *dom = get_task_domain(a);
         const struct ce_dom_data *ce_data = dom->data;
+        TRACE("a: 0x%p    b: 0x%p    should_schedule: 0x%p\n", a, _b,
+                        ce_data->should_schedule);
+        TRACE("a: " TS "\n", TA(a));
+        TRACE("b: " TS "\n", TA(_b));
         return (a == ce_data->should_schedule);
 }
 
 void __mc_ce_timer_callback(struct hrtimer *timer);
+domain_data_t *ce_domain_for(int);
+void mc_check_for_preempt(domain_t*);
 static enum hrtimer_restart ce_timer_function(struct hrtimer *timer)
 {
-        /* need to lock? */
+        struct ce_dom_data *ce_data;
+        domain_data_t *dom_data;
+        unsigned long flags;
+
+        TRACE("timer callback\n");
+
+        ce_data = container_of(timer, struct ce_dom_data, timer);
+        dom_data = ce_domain_for(ce_data->cpu);
+        raw_spin_lock_irqsave(dom_data->domain.lock, flags);
         __mc_ce_timer_callback(timer);
+        mc_check_for_preempt(&dom_data->domain);
+        raw_spin_unlock_irqrestore(dom_data->domain.lock, flags);
         return HRTIMER_RESTART;
 }
 
diff --git a/litmus/event_group.c b/litmus/event_group.c
index 22c74a19d1d6..e285b5465761 100644
--- a/litmus/event_group.c
+++ b/litmus/event_group.c
@@ -122,7 +122,7 @@ void add_event(struct event_group *group, struct rt_event *e, lt_t fire)
 {
         struct event_list *el;
 
-        TRACE("Adding event with prio %d @ %llu\n", event->prio, fire);
+        TRACE("Adding event with prio %d @ %llu\n", e->prio, fire);
 
         raw_spin_lock(&group->queue_lock);
         el = get_event_list(group, e, fire, 0);
diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index bce25bc8822e..3b98a93511ab 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -104,7 +104,7 @@ static int cpu_lower_prio(struct bheap_node *a, struct bheap_node *b)
  * Return true if the domain has a higher priority ready task. The curr
  * task must belong to the domain.
  */
-static noinline int mc_preempt_needed(domain_t *dom, struct task_struct* curr)
+noinline int mc_preempt_needed(domain_t *dom, struct task_struct* curr)
 {
         struct task_struct *next = dom->peek_ready(dom);
         if (!next || !curr) {
@@ -208,7 +208,7 @@ static void link_task_to_crit(crit_entry_t *ce,
         }
 }
 
-static void check_for_preempt(domain_t*);
+void mc_check_for_preempt(domain_t*);
 /**
  * job_arrival() - Called when a task re-enters the system.
  * Caller must hold no locks.
@@ -222,7 +222,7 @@ static void job_arrival(struct task_struct *task)
         if (can_requeue(task)) {
                 raw_spin_lock(dom->lock);
                 dom->requeue(dom, task);
-                check_for_preempt(dom);
+                mc_check_for_preempt(dom);
                 raw_spin_unlock(dom->lock);
         } else {
                 /* If a global task is scheduled on one cpu, it CANNOT
@@ -374,18 +374,19 @@ static void update_crit_levels(cpu_entry_t *entry)
 }
 
 /**
- * check_for_preempt() - Causes a preemption if higher-priority tasks are ready.
+ * mc_check_for_preempt() - Causes a preemption if higher-priority tasks are ready.
  * Caller must hold domain lock.
  * Makes gigantic nasty assumption that there is 1 global criticality level,
  * and it is the last one in each list, so it doesn't call update_crit..
  */
-static void check_for_preempt(domain_t *dom)
+void mc_check_for_preempt(domain_t *dom)
 {
         int preempted = 1;
         cpu_entry_t *entry;
         crit_entry_t *ce;
 
         if (is_global(dom)) {
+                TRACE("domain: %s is global\n", dom->name);
                 /* Loop until we find a non-preemptable CPU */
                 while ((ce = lowest_prio_cpu(dom)) && preempted) {
                         entry = crit_cpu(ce);
@@ -398,6 +399,7 @@ static void check_for_preempt(domain_t *dom)
                         raw_spin_unlock(&entry->lock);
                 }
         } else /* Partitioned */ {
+                TRACE("domain: %s is partitioned\n", dom->name);
                 ce = domain_data(dom)->crit_entry;
                 entry = crit_cpu(ce);
                 raw_spin_lock(&entry->lock);
@@ -476,6 +478,7 @@ static void job_completion(struct task_struct *task, int forced)
 
         /* If it's not a ghost job, do ghost job conversion */
         if (!is_ghost(task)) {
+                TRACE_TASK(task, "is not a ghost task\n");
                 tsk_mc_data(task)->mc_job.ghost_budget = budget_remaining(task);
                 tsk_mc_data(task)->mc_job.is_ghost = 1;
         }
@@ -485,6 +488,7 @@ static void job_completion(struct task_struct *task, int forced)
          * conversion. Revert back to a normal task and complete the period.
          */
         if (tsk_mc_data(task)->mc_job.ghost_budget == 0) {
+                TRACE_TASK(task, "has zero ghost budget\n");
                 tsk_mc_data(task)->mc_job.is_ghost = 0;
                 prepare_for_next_period(task);
                 if (is_released(task, litmus_clock()))
@@ -530,6 +534,26 @@ static enum hrtimer_restart mc_ghost_exhausted(struct hrtimer *timer)
         return HRTIMER_NORESTART;
 }
 
+void __mc_ce_timer_callback(struct hrtimer *timer);
+domain_data_t *ce_domain_for(int);
+static enum hrtimer_restart ce_timer_function(struct hrtimer *timer)
+{
+        struct ce_dom_data *ce_data;
+        domain_data_t *dom_data;
+        unsigned long flags;
+
+        TRACE("timer callback\n");
+
+        ce_data = container_of(timer, struct ce_dom_data, timer);
+        dom_data = ce_domain_for(ce_data->cpu);
+        raw_spin_lock_irqsave(dom_data->domain.lock, flags);
+        __mc_ce_timer_callback(timer);
+        mc_check_for_preempt(&dom_data->domain);
+        raw_spin_unlock_irqrestore(dom_data->domain.lock, flags);
+        return HRTIMER_RESTART;
+}
+
+
 /**
  * mc_release_jobs() - Add heap of tasks to the system, check for preemptions.
  */
@@ -542,7 +566,7 @@ static void mc_release_jobs(rt_domain_t* rt, struct bheap* tasks)
         raw_spin_lock_irqsave(dom->lock, flags);
         TRACE_TASK(first, "Jobs released");
         __merge_ready(rt, tasks);
-        check_for_preempt(dom);
+        mc_check_for_preempt(dom);
         raw_spin_unlock_irqrestore(dom->lock, flags);
 }
 
@@ -639,25 +663,37 @@ static void mc_task_exit(struct task_struct *task)
         local_irq_restore(flags);
 }
 
+long __mc_ce_admit_task(struct task_struct*);
 /**
  * mc_admit_task() - Return true if the task is valid.
  * Assumes there are no partitioned levels after level B.
  */
 static long mc_admit_task(struct task_struct* task)
 {
+        const enum crit_level crit = tsk_mc_crit(task);
+        long ret;
         if (!tsk_mc_data(task)) {
                 printk(KERN_WARNING "Tried to admit task with no criticality "
                         "level\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto out;
         }
-        if (tsk_mc_crit(task) < CRIT_LEVEL_C && get_partition(task) == NO_CPU) {
+        if (crit < CRIT_LEVEL_C && get_partition(task) == NO_CPU) {
                 printk(KERN_WARNING "Tried to admit partitioned task with no "
                        "partition\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto out;
+        }
+        if (crit == CRIT_LEVEL_A) {
+                ret = __mc_ce_admit_task(task);
+                if (ret)
+                        goto out;
         }
         printk(KERN_INFO "Admitted task with criticality level %d\n",
                 tsk_mc_crit(task));
-        return 0;
+        ret = 0;
+out:
+        return ret;
 }
 
 /**
@@ -746,6 +782,7 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
                                 raw_spin_unlock(dom->lock);
                                 update_crit_levels(entry);
                                 raw_spin_lock(&entry->lock);
+                                continue;
                         }
                 }
                 raw_spin_unlock(dom->lock);
@@ -784,7 +821,11 @@ static long mc_activate_plugin(void)
  */
 void mc_release_at(struct task_struct *ts, lt_t start)
 {
-        ce_start(ts, start);
+        /* hack so that we can have CE timers start at the right time */
+        if (CRIT_LEVEL_A == tsk_mc_crit(ts))
+                ce_start(ts, start);
+        else
+                release_at(ts, start);
 }
 
 long mc_deactivate_plugin(void)
@@ -884,7 +925,6 @@ static int __init init_mc(void)
         cpu_entry_t *entry;
         rt_domain_t *rt;
         domain_data_t *dom_data;
-        domain_t *dom;
         raw_spinlock_t *a_dom, *b_dom, *c_dom; /* For lock debugger */
 
         for_each_online_cpu(cpu) {
@@ -903,16 +943,10 @@ static int __init init_mc(void)
 
                 /* CRIT_LEVEL_A */
                 dom_data = ce_domain_for(cpu);
+                ce_domain_init(/* TODO */);
                 init_local_domain(entry, dom_data, CRIT_LEVEL_A);
                 a_dom = dom_data->domain.lock;
-                raw_spin_lock_init(a_dom);
                 dom_data->domain.name = "LVL-A";
-                /* Hook up the level A functions */
-                dom = &dom_data->domain;
-                dom->requeue = ce_requeue;
-                dom->peek_ready = dom->take_ready = ce_peek_and_take_ready;
-                dom->higher_prio = ce_higher_prio;
-                dom->preempt_needed = mc_preempt_needed;
 
                 /* CRIT_LEVEL_B */
                 dom_data = &per_cpu(_mc_crit_b, cpu);
diff --git a/litmus/sched_mc_ce.c b/litmus/sched_mc_ce.c
index 8a0f9556640c..77acc67d05bd 100644
--- a/litmus/sched_mc_ce.c
+++ b/litmus/sched_mc_ce.c
@@ -23,6 +23,7 @@
 #include <litmus/sched_trace.h>
 #include <litmus/jobs.h>
 #include <litmus/sched_mc.h>
+#include <litmus/ce_domain.h>
 
 static struct sched_plugin mc_ce_plugin __cacheline_aligned_in_smp;
 
@@ -35,8 +36,8 @@ static struct proc_dir_entry *mc_ce_dir = NULL, *ce_file = NULL;
 
 
 DEFINE_PER_CPU(domain_data_t, mc_ce_doms);
-DEFINE_PER_CPU(rt_domain_t, mc_ce_rts);
 DEFINE_PER_CPU(struct ce_dom_data, _mc_ce_dom_data);
+DEFINE_PER_CPU(raw_spinlock_t, _dom_locks);
 
 /* Return the address of the domain_t for this CPU, used by the
  * mixed-criticality plugin. */
@@ -192,35 +193,11 @@ static void mc_ce_finish_switch(struct task_struct *prev)
 }
 
 /*
- * Called for every local timer interrupt.
- * Linux calls this with interrupts disabled, AFAIK.
- */
-static void mc_ce_tick(struct task_struct *ts)
-{
-        domain_data_t *dom_data = &per_cpu(mc_ce_doms, smp_processor_id());
-        domain_t *dom = &dom_data->domain;
-        struct ce_dom_data *ce_data = get_ce_data(dom_data);
-        struct task_struct *should_schedule;
-
-        if (is_realtime(ts) && CRIT_LEVEL_A == tsk_mc_crit(ts)) {
-                raw_spin_lock(dom->lock);
-                should_schedule = ce_data->should_schedule;
-                raw_spin_unlock(dom->lock);
-
-                if (!is_np(ts) && ts != should_schedule) {
-                        litmus_reschedule_local();
-                } else if (is_user_np(ts)) {
-                        request_exit_np(ts);
-                }
-        }
-}
-
-/*
  * Admit task called to see if this task is permitted to enter the system.
  * Here we look up the task's PID structure and save it in the proper slot on
  * the CPU this task will run on.
  */
-static long __mc_ce_admit_task(struct task_struct *ts)
+long __mc_ce_admit_task(struct task_struct *ts)
 {
         domain_data_t *dom_data = &per_cpu(mc_ce_doms, get_partition(ts));
         struct ce_dom_data *ce_data = get_ce_data(dom_data);
@@ -315,7 +292,7 @@ static void mc_ce_task_new(struct task_struct *ts, int on_rq, int running)
         pid_entry = &ce_data->pid_entries[tsk_mc_data(ts)->mc_task.lvl_a_id];
         /* initialize some task state */
         set_rt_flags(ts, RT_F_RUNNING);
-        tsk_rt(ts)->job_params.job_no = 0;
+        tsk_rt(ts)->job_params.job_no = 1;
 
         offset = get_cycle_offset(litmus_clock(), ce_data->cycle_time);
         idx = mc_ce_schedule_at(dom, offset);
@@ -538,7 +515,7 @@ static void arm_all_timers(void)
                 if (0 == ce_data->num_pid_entries)
                         continue;
                 for (idx = 0; idx < ce_data->num_pid_entries; idx++) {
-                        ce_data->pid_entries[idx].expected_job = -1;
+                        ce_data->pid_entries[idx].expected_job = 0;
                 }
                 TRACE("arming timer for CPU %d\n", cpu);
                 hrtimer_start_on(cpu, &ce_data->timer_info, &ce_data->timer,
@@ -602,7 +579,7 @@ static void clear_pid_entries(void)
                         }
                         ce_data->pid_entries[entry].budget = 0;
                         ce_data->pid_entries[entry].acc_time = 0;
-                        ce_data->pid_entries[entry].expected_job = -1;
+                        ce_data->pid_entries[entry].expected_job = 0;
                 }
         }
 }
@@ -623,27 +600,33 @@ static struct sched_plugin mc_ce_plugin __cacheline_aligned_in_smp = {
         .task_exit              = mc_ce_task_exit,
         .schedule               = mc_ce_schedule,
         .finish_switch          = mc_ce_finish_switch,
-        .tick                   = mc_ce_tick,
         .task_wake_up           = mc_ce_task_wake_up,
         .task_block             = mc_ce_task_block,
         .activate_plugin        = mc_ce_activate_plugin,
         .deactivate_plugin      = mc_ce_deactivate_plugin,
 };
 
+int mc_preempt_needed(domain_t*, struct task_struct*);
 static int setup_proc(void);
 static int __init init_sched_mc_ce(void)
 {
         struct ce_dom_data *ce_data;
+        raw_spinlock_t *ce_lock;
         domain_data_t *dom_data;
         domain_t *dom;
-        rt_domain_t *rt;
         int cpu, err;
 
         for_each_online_cpu(cpu) {
+                ce_lock = &per_cpu(_dom_locks, cpu);
+                raw_spin_lock_init(ce_lock);
                 dom_data = &per_cpu(mc_ce_doms, cpu);
                 dom = &dom_data->domain;
-                rt = &per_cpu(mc_ce_rts, cpu);
-                pd_domain_init(dom, rt, NULL, NULL, NULL, NULL, NULL);
+                /* initialize the domain. the ce_ functions are for the MC
+                 * plugin */
+                /* move into ce_domain_init */
+                domain_init(dom, ce_lock, ce_requeue, ce_peek_and_take_ready,
+                                ce_peek_and_take_ready, mc_preempt_needed,
+                                ce_higher_prio);
                 dom->data = &per_cpu(_mc_ce_dom_data, cpu);
                 ce_data = get_ce_data(dom_data);
                 hrtimer_init(&ce_data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);