1 files changed, 37 insertions, 42 deletions

diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 577e7d36faf5..bce25bc8822e 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -24,25 +24,7 @@
 #include <litmus/bheap.h>
 
 #include <litmus/sched_mc.h>
-
-/**
- * crit_entry_t - State of a CPU within each criticality level system.
- * @level       Criticality level of this entry
- * @linked      Logically running task, ghost or regular
- * @domain      Domain from which to draw tasks
- * @usable      False if a higher criticality task is running
- * @timer       For ghost task budget enforcement
- * @node        Used to sort crit_entries by preemptability in global domains
- */
-typedef struct {
-        enum crit_level         level;
-        struct task_struct*     linked;
-        domain_t*               domain;
-        int                     usable;
-        struct hrtimer          timer;
-        struct bheap_node*      node;
-        atomic_t                dirty;
-} crit_entry_t;
+#include <litmus/ce_domain.h>
 
 /**
  * cpu_entry_t - State of a CPU for the entire MC system
@@ -64,18 +46,6 @@ typedef struct {
 #endif
 } cpu_entry_t;
 
-/**
- * domain_data_t - Wrap domains with related CPU state
- * @domain      A domain for a criticality level
- * @heap        The preemptable heap of crit entries (for global domains)
- * @crit_entry  The crit entry for this domain (for partitioned domains)
- */
-typedef struct {
-        domain_t        domain;
-        struct bheap*   heap;
-        crit_entry_t*   crit_entry;
-} domain_data_t;
-
 static cpu_entry_t* cpus[NR_CPUS];
 #ifdef CONFIG_RELEASE_MASTER
 static int interrupt_cpu;
@@ -213,10 +183,14 @@ static void link_task_to_crit(crit_entry_t *ce,
         ce->linked = task;
         if (task) {
                 task->rt_param.linked_on = crit_cpu(ce)->cpu;
-                if (is_ghost(task)) {
+                if (is_ghost(task) && CRIT_LEVEL_A != tsk_mc_crit(task)) {
+                        /* There is a level-A timer that will force a
+                         * preemption, so we don't set this for level-A
+                         * tasks.
+                         */
                         /* Reset budget timer */
                         task->se.exec_start = litmus_clock();
-                        when_to_fire = litmus_clock() +
+                        when_to_fire = task->se.exec_start +
                                 tsk_mc_data(task)->mc_job.ghost_budget;
                         __hrtimer_start_range_ns(&ce->timer,
                                                  ns_to_ktime(when_to_fire),
@@ -659,6 +633,9 @@ static void mc_task_exit(struct task_struct *task)
                 tsk_rt(task)->scheduled_on = NO_CPU;
         }
 
+        if (CRIT_LEVEL_A == tsk_mc_crit(task))
+                ce_task_exit(get_task_domain(task), task);
+
         local_irq_restore(flags);
 }
 
@@ -797,7 +774,22 @@ static long mc_activate_plugin(void)
         if (interrupt_cpu == NO_CPU)
                 interrupt_cpu = 0;
 #endif
-        return 0;
+        return ce_activate_plugin();
+}
+
+/*
+ * This is the plugin's release at function, called by the release task-set
+ * system call. Other places in the file use the generic LITMUS release_at(),
+ * which is not this.
+ */
+void mc_release_at(struct task_struct *ts, lt_t start)
+{
+        ce_start(ts, start);
+}
+
+long mc_deactivate_plugin(void)
+{
+        return ce_deactivate_plugin();
 }
 
 /* **************************************************************************
@@ -820,11 +812,6 @@ static rt_domain_t _mc_crit_c_rt;
 struct bheap _mc_heap_c;
 struct bheap_node _mc_nodes_c[NR_CPUS];
 
-/*
- * XXX commented out because I think this was an obvious typo
- */
-/* release_at)_ */
-
 static struct sched_plugin mc_plugin __cacheline_aligned_in_smp = {
         .plugin_name            = "MC",
         .task_new               = mc_task_new,
@@ -835,6 +822,8 @@ static struct sched_plugin mc_plugin __cacheline_aligned_in_smp = {
         .task_block             = mc_task_block,
         .admit_task             = mc_admit_task,
         .activate_plugin        = mc_activate_plugin,
+        .release_at             = mc_release_at,
+        .deactivate_plugin      = mc_deactivate_plugin,
 };
 
 static void init_crit_entry(crit_entry_t *ce, enum crit_level level,
@@ -888,12 +877,14 @@ static inline void init_edf_domain(domain_t *dom, rt_domain_t *rt)
                        edf_higher_prio);
 }
 
+domain_data_t *ce_domain_for(int);
 static int __init init_mc(void)
 {
         int cpu;
         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) {
@@ -911,13 +902,17 @@ static int __init init_mc(void)
 #endif
 
                 /* CRIT_LEVEL_A */
-                dom_data = &per_cpu(_mc_crit_a, cpu);
-                rt = &per_cpu(_mc_crit_a_rt, cpu);
+                dom_data = ce_domain_for(cpu);
                 init_local_domain(entry, dom_data, CRIT_LEVEL_A);
-                init_edf_domain(&dom_data->domain, rt);
                 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);