Untested merge of CE and MC plugins

5 files changed, 135 insertions, 103 deletions

diff --git a/include/litmus/sched_mc.h b/include/litmus/sched_mc.h
index 95cd22cd7202..ad5d097b3d61 100644
--- a/include/litmus/sched_mc.h
+++ b/include/litmus/sched_mc.h
@@ -59,6 +59,37 @@ struct ce_dom_data {
         struct hrtimer timer;
 };
 
+/**
+ * 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;
+
+/**
+ * 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;
+
 #endif /* __KERNEL__ */
 
 #endif
diff --git a/litmus/ce_domain.c b/litmus/ce_domain.c
index 5b4fd1cb438f..d6f713fbf789 100644
--- a/litmus/ce_domain.c
+++ b/litmus/ce_domain.c
@@ -7,6 +7,7 @@
 #include <litmus/rt_param.h>
 #include <litmus/domain.h>
 #include <litmus/sched_mc.h>
+#include <litmus/ce_domain.h>
 
 /*
  * Called for:
@@ -41,24 +42,13 @@ void ce_requeue(domain_t *dom, struct task_struct *ts)
         }
 }
 
+void mc_ce_task_exit(struct task_struct*);
 /*
  * Called when a task exits the system.
  */
-void ce_exit(domain_t *dom, struct task_struct *ts)
+void ce_task_exit(domain_t *dom, struct task_struct *ts)
 {
-        struct ce_dom_data *ce_data = dom->data;
-        const int lvl_a_id = tsk_mc_data(ts)->mc_task.lvl_a_id;
-        struct pid *pid;
-
-        BUG_ON(task_cpu(ts) != get_partition(ts));
-        BUG_ON(CRIT_LEVEL_A != tsk_mc_crit(ts));
-        BUG_ON(lvl_a_id >= ce_data->num_pid_entries);
-        pid = ce_data->pid_entries[lvl_a_id].pid;
-        BUG_ON(!pid);
-        put_pid(pid);
-        ce_data->pid_entries[lvl_a_id].pid = NULL;
-        if (ce_data->should_schedule == ts)
-                ce_data->should_schedule = NULL;
+        mc_ce_task_exit(ts);
 }
 
 /*
@@ -80,11 +70,12 @@ struct task_struct* ce_peek_and_take_ready(domain_t *dom)
         return ret;
 }
 
-int ce_higher_prio(domain_t *dom, struct task_struct *_a,
+int ce_higher_prio(struct task_struct *_a,
                 struct task_struct *_b)
 {
         const struct task_struct *a = _a;
-        struct ce_dom_data *ce_data = dom->data;
+        const domain_t *dom = get_task_domain(a);
+        const struct ce_dom_data *ce_data = dom->data;
         return (a == ce_data->should_schedule);
 }
 
@@ -102,18 +93,18 @@ void ce_start(struct task_struct *ts, lt_t start)
         mc_ce_release_at(ts, start);
 }
 
+domain_data_t *ce_domain_for(int);
 long mc_ce_activate_plugin(void);
-domain_t *ce_domain_for(int);
 long ce_activate_plugin(void)
 {
-        domain_t *dom;
+        domain_data_t *dom_data;
         struct ce_dom_data *ce_data;
         int cpu;
 
         /* first change the timer callback function */
         for_each_online_cpu(cpu) {
-                dom = ce_domain_for(cpu);
-                ce_data = dom->data;
+                dom_data = ce_domain_for(cpu);
+                ce_data = dom_data->domain.data;
                 ce_data->timer.function = ce_timer_function;
         }
         /* then run the regular CE activate plugin */
diff --git a/litmus/litmus.c b/litmus/litmus.c
index 3b502d62cb0e..56a47f9834eb 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -641,7 +641,9 @@ static void _exit_litmus(void)
         exit_litmus_proc();
         kmem_cache_destroy(bheap_node_cache);
         kmem_cache_destroy(release_heap_cache);
+#ifdef CONFIG_PLUGIN_MC
         kmem_cache_destroy(event_list_cache);
+#endif
 }
 
 module_init(_init_litmus);
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);
diff --git a/litmus/sched_mc_ce.c b/litmus/sched_mc_ce.c
index dcb74f4ca67b..8a0f9556640c 100644
--- a/litmus/sched_mc_ce.c
+++ b/litmus/sched_mc_ce.c
@@ -27,19 +27,20 @@
 static struct sched_plugin mc_ce_plugin __cacheline_aligned_in_smp;
 
 #define is_active_plugin() (litmus == &mc_ce_plugin)
+#define get_ce_data(dom_data_ref) (dom_data_ref->domain.data)
 
 static atomic_t start_time_set = ATOMIC_INIT(-1);
 static atomic64_t start_time = ATOMIC64_INIT(0);
 static struct proc_dir_entry *mc_ce_dir = NULL, *ce_file = NULL;
 
 
-DEFINE_PER_CPU(domain_t, mc_ce_doms);
+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);
 
 /* Return the address of the domain_t for this CPU, used by the
  * mixed-criticality plugin. */
-domain_t *ce_domain_for(int cpu)
+domain_data_t *ce_domain_for(int cpu)
 {
         return &per_cpu(mc_ce_doms, cpu);
 }
@@ -65,8 +66,8 @@ static inline lt_t get_cycle_offset(const lt_t when, const lt_t cycle_time)
  */
 static void mc_ce_job_completion(struct task_struct *ts)
 {
-        const domain_t *dom = &per_cpu(mc_ce_doms, smp_processor_id());
-        const struct ce_dom_data *ce_data = dom->data;
+        const domain_data_t *dom_data = &per_cpu(mc_ce_doms, smp_processor_id());
+        const struct ce_dom_data *ce_data = get_ce_data(dom_data);
         const int idx = tsk_mc_data(ts)->mc_task.lvl_a_id;
         const struct ce_dom_pid_entry *pid_entry =
                 &ce_data->pid_entries[idx];
@@ -128,8 +129,9 @@ static int mc_ce_schedule_at(const domain_t *dom, lt_t offset)
 
 static struct task_struct *mc_ce_schedule(struct task_struct *prev)
 {
-        domain_t *dom = &per_cpu(mc_ce_doms, smp_processor_id());
-        struct ce_dom_data *ce_data = dom->data;
+        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 *next = NULL;
         int exists, sleep, should_sched_exists, should_sched_blocked,
             should_sched_asleep;
@@ -178,8 +180,8 @@ static struct task_struct *mc_ce_schedule(struct task_struct *prev)
 
 static void mc_ce_finish_switch(struct task_struct *prev)
 {
-        domain_t *dom = &per_cpu(mc_ce_doms, smp_processor_id());
-        struct ce_dom_data *ce_data = dom->data;
+        domain_data_t *dom_data = &per_cpu(mc_ce_doms, smp_processor_id());
+        struct ce_dom_data *ce_data = get_ce_data(dom_data);
 
         TRACE("finish switch\n");
 
@@ -195,8 +197,9 @@ static void mc_ce_finish_switch(struct task_struct *prev)
  */
 static void mc_ce_tick(struct task_struct *ts)
 {
-        domain_t *dom = &per_cpu(mc_ce_doms, smp_processor_id());
-        struct ce_dom_data *ce_data = dom->data;
+        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)) {
@@ -219,8 +222,8 @@ static void mc_ce_tick(struct task_struct *ts)
  */
 static long __mc_ce_admit_task(struct task_struct *ts)
 {
-        domain_t *dom = &per_cpu(mc_ce_doms, get_partition(ts));
-        struct ce_dom_data *ce_data = dom->data;
+        domain_data_t *dom_data = &per_cpu(mc_ce_doms, get_partition(ts));
+        struct ce_dom_data *ce_data = get_ce_data(dom_data);
         struct mc_data *mcd = tsk_mc_data(ts);
         struct pid *pid = NULL;
         long retval = -EINVAL;
@@ -280,7 +283,8 @@ out:
 
 static long mc_ce_admit_task(struct task_struct *ts)
 {
-        domain_t *dom = &per_cpu(mc_ce_doms, get_partition(ts));
+        domain_data_t *dom_data = &per_cpu(mc_ce_doms, get_partition(ts));
+        domain_t *dom = &dom_data->domain;
         unsigned long flags, retval;
         raw_spin_lock_irqsave(dom->lock, flags);
         retval = __mc_ce_admit_task(ts);
@@ -295,8 +299,9 @@ static long mc_ce_admit_task(struct task_struct *ts)
  */
 static void mc_ce_task_new(struct task_struct *ts, int on_rq, int running)
 {
-        domain_t *dom = &per_cpu(mc_ce_doms, task_cpu(ts));
-        struct ce_dom_data *ce_data = dom->data;
+        domain_data_t *dom_data = &per_cpu(mc_ce_doms, task_cpu(ts));
+        domain_t *dom = &dom_data->domain;
+        struct ce_dom_data *ce_data = get_ce_data(dom_data);
         struct pid *pid_should_be_running;
         struct ce_dom_pid_entry *pid_entry;
         unsigned long flags;
@@ -341,8 +346,9 @@ static void mc_ce_task_new(struct task_struct *ts, int on_rq, int running)
  */
 static void mc_ce_task_wake_up(struct task_struct *ts)
 {
-        domain_t *dom = &per_cpu(mc_ce_doms, smp_processor_id());
-        struct ce_dom_data *ce_data = dom->data;
+        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);
         unsigned long flags;
 
         TRACE_TASK(ts, "wake up\n");
@@ -366,10 +372,11 @@ static void mc_ce_task_block(struct task_struct *ts)
 /*
  * Called when a task switches from RT mode back to normal mode.
  */
-static void mc_ce_task_exit(struct task_struct *ts)
+void mc_ce_task_exit(struct task_struct *ts)
 {
-        domain_t *dom = &per_cpu(mc_ce_doms, get_partition(ts));
-        struct ce_dom_data *ce_data = dom->data;
+        domain_data_t *dom_data = &per_cpu(mc_ce_doms, get_partition(ts));
+        domain_t *dom = &dom_data->domain;
+        struct ce_dom_data *ce_data = get_ce_data(dom_data);
         unsigned long flags;
         struct pid *pid;
         const int lvl_a_id = tsk_mc_data(ts)->mc_task.lvl_a_id;
@@ -403,11 +410,13 @@ void __mc_ce_timer_callback(struct hrtimer *timer)
         struct task_struct *should_schedule;
         struct ce_dom_pid_entry *pid_entry;
         struct ce_dom_data *ce_data;
+        domain_data_t *dom_data;
         domain_t *dom;
         int idx, budget_overrun;
 
         ce_data = container_of(timer, struct ce_dom_data, timer);
-        dom = container_of(((void*)ce_data), domain_t, data);
+        dom_data = &per_cpu(mc_ce_doms, ce_data->cpu);
+        dom = &dom_data->domain;
 
         /* Based off of the current time, figure out the offset into the cycle
          * and the cycle's start time, and determine what should be scheduled.
@@ -466,10 +475,12 @@ static enum hrtimer_restart mc_ce_timer_callback(struct hrtimer *timer)
 {
         struct ce_dom_data *ce_data;
         unsigned long flags;
+        domain_data_t *dom_data;
         domain_t *dom;
 
         ce_data = container_of(timer, struct ce_dom_data, timer);
-        dom = container_of(((void*)ce_data), domain_t, data);
+        dom_data = &per_cpu(mc_ce_doms, ce_data->cpu);
+        dom = &dom_data->domain;
 
         TRACE("timer callback on CPU %d (before lock)\n", ce_data->cpu);
 
@@ -490,14 +501,14 @@ static enum hrtimer_restart mc_ce_timer_callback(struct hrtimer *timer)
 static int cancel_all_timers(void)
 {
         struct ce_dom_data *ce_data;
-        domain_t *dom;
+        domain_data_t *dom_data;
         int cpu, ret = 0, cancel_res;
 
         TRACE("cancel all timers\n");
 
         for_each_online_cpu(cpu) {
-                dom = &per_cpu(mc_ce_doms, cpu);
-                ce_data = dom->data;
+                dom_data = &per_cpu(mc_ce_doms, cpu);
+                ce_data = get_ce_data(dom_data);
                 ce_data->should_schedule = NULL;
                 cancel_res = hrtimer_cancel(&ce_data->timer);
                 atomic_set(&ce_data->timer_info.state,
@@ -515,15 +526,15 @@ static int cancel_all_timers(void)
 static void arm_all_timers(void)
 {
         struct ce_dom_data *ce_data;
-        domain_t *dom;
+        domain_data_t *dom_data;
         int cpu, idx;
         const lt_t start = atomic64_read(&start_time);
 
         TRACE("arm all timers\n");
 
         for_each_online_cpu(cpu) {
-                dom = &per_cpu(mc_ce_doms, cpu);
-                ce_data = dom->data;
+                dom_data = &per_cpu(mc_ce_doms, cpu);
+                ce_data = get_ce_data(dom_data);
                 if (0 == ce_data->num_pid_entries)
                         continue;
                 for (idx = 0; idx < ce_data->num_pid_entries; idx++) {
@@ -555,12 +566,12 @@ void mc_ce_release_at(struct task_struct *ts, lt_t start)
 long mc_ce_activate_plugin(void)
 {
         struct ce_dom_data *ce_data;
-        domain_t *dom;
+        domain_data_t *dom_data;
         int cpu;
 
         for_each_online_cpu(cpu) {
-                dom = &per_cpu(mc_ce_doms, cpu);
-                ce_data = dom->data;
+                dom_data = &per_cpu(mc_ce_doms, cpu);
+                ce_data = get_ce_data(dom_data);
                 ce_data->scheduled = NULL;
                 ce_data->should_schedule = NULL;
         }
@@ -575,12 +586,12 @@ long mc_ce_activate_plugin(void)
 static void clear_pid_entries(void)
 {
         int cpu, entry;
-        domain_t *dom;
+        domain_data_t *dom_data;
         struct ce_dom_data *ce_data;
 
         for_each_online_cpu(cpu) {
-                dom = &per_cpu(mc_ce_doms, cpu);
-                ce_data = dom->data;
+                dom_data = &per_cpu(mc_ce_doms, cpu);
+                ce_data = get_ce_data(dom_data);
                 ce_data->num_pid_entries = 0;
                 ce_data->cycle_time = 0;
                 for (entry = 0; entry < CONFIG_PLUGIN_MC_LEVEL_A_MAX_TASKS;
@@ -623,16 +634,18 @@ static int setup_proc(void);
 static int __init init_sched_mc_ce(void)
 {
         struct ce_dom_data *ce_data;
+        domain_data_t *dom_data;
         domain_t *dom;
         rt_domain_t *rt;
         int cpu, err;
 
         for_each_online_cpu(cpu) {
-                dom = &per_cpu(mc_ce_doms, cpu);
+                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);
                 dom->data = &per_cpu(_mc_ce_dom_data, cpu);
-                ce_data = dom->data;
+                ce_data = get_ce_data(dom_data);
                 hrtimer_init(&ce_data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
                 hrtimer_start_on_info_init(&ce_data->timer_info);
                 ce_data->cpu = cpu;
@@ -736,7 +749,7 @@ static int proc_read_ce_file(char *page, char **start, off_t off, int count,
 {
         int n = 0, err, cpu, t;
         struct ce_dom_data *ce_data;
-        domain_t *dom;
+        domain_data_t *dom_data;
 
         if (off > 0) {
                 printk(KERN_INFO "litmus: MC-CE called read with off > 0\n");
@@ -744,8 +757,8 @@ static int proc_read_ce_file(char *page, char **start, off_t off, int count,
         }
 
         for_each_online_cpu(cpu) {
-                dom = &per_cpu(mc_ce_doms, cpu);
-                ce_data = dom->data;
+                dom_data = &per_cpu(mc_ce_doms, cpu);
+                ce_data = get_ce_data(dom_data);
                 for (t = 0; t < ce_data->num_pid_entries; ++t) {
                         err = write_pid_entry(page + n, count - n,
                                         cpu, t, &ce_data->pid_entries[t]);
@@ -785,8 +798,8 @@ static int skip_comment(const char *buf, const unsigned long max)
 #define BUDGET_THRESHOLD 5000000ULL
 static int setup_pid_entry(const int cpu, const int task, const lt_t budget)
 {
-        domain_t *dom = &per_cpu(mc_ce_doms, cpu);
-        struct ce_dom_data *ce_data = dom->data;
+        domain_data_t *dom_data = &per_cpu(mc_ce_doms, cpu);
+        struct ce_dom_data *ce_data = get_ce_data(dom_data);
         struct ce_dom_pid_entry *new_entry;
         int err = 0;