Check point commit for merging CE with MC plugin.

Also started to fix typos in Jonathan's code, but there were too many
after I realized that event_group.o was not in the LITMUS Makefile.

1 files changed, 54 insertions, 56 deletions

diff --git a/litmus/sched_mc_ce.c b/litmus/sched_mc_ce.c
index eeee00ab3047..dcb74f4ca67b 100644
--- a/litmus/sched_mc_ce.c
+++ b/litmus/sched_mc_ce.c
@@ -19,52 +19,32 @@
 #include <litmus/sched_plugin.h>
 #include <litmus/rt_domain.h>
 #include <litmus/rt_param.h>
-#include <litmus/sched_mc.h>
 #include <litmus/litmus_proc.h>
 #include <litmus/sched_trace.h>
 #include <litmus/jobs.h>
+#include <litmus/sched_mc.h>
 
 static struct sched_plugin mc_ce_plugin __cacheline_aligned_in_smp;
 
-#define tsk_mc_data(t) (tsk_rt(t)->mc_data)
-#define tsk_mc_crit(t) (tsk_mc_data(t)->mc_task.crit)
 #define is_active_plugin() (litmus == &mc_ce_plugin)
 
 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;
 
-/*
- * Cache the budget along with the struct PID for a task so that we don't need
- * to fetch its task_struct every time we check to see what should be
- * scheduled.
- */
-struct ce_dom_pid_entry {
-        struct pid *pid;
-        lt_t budget;
-        /* accumulated (summed) budgets, including this one */
-        lt_t acc_time;
-        int expected_job;
-};
-
-struct ce_dom_data {
-        int cpu;
-        struct task_struct *scheduled, *should_schedule;
-        /*
-         * Each CPU needs a mapping of level A ID (integer) to struct pid so
-         * that we can get its task struct.
-         */
-        struct ce_dom_pid_entry pid_entries[CONFIG_PLUGIN_MC_LEVEL_A_MAX_TASKS];
-        int num_pid_entries;
-        lt_t cycle_time;
-        struct hrtimer_start_on_info timer_info;
-        struct hrtimer timer;
-};
 
 DEFINE_PER_CPU(domain_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)
+{
+        return &per_cpu(mc_ce_doms, cpu);
+}
+
+
 /*
  * Get the offset into the cycle taking the start time into account.
  */
@@ -237,14 +217,13 @@ static void mc_ce_tick(struct task_struct *ts)
  * 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)
+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;
         struct mc_data *mcd = tsk_mc_data(ts);
         struct pid *pid = NULL;
         long retval = -EINVAL;
-        unsigned long flags;
         const int lvl_a_id = mcd->mc_task.lvl_a_id;
 
         /* check the task has migrated to the right CPU (like in sched_cedf) */
@@ -269,39 +248,46 @@ static long mc_ce_admit_task(struct task_struct *ts)
                 goto out;
         }
 
-        raw_spin_lock_irqsave(dom->lock, flags);
         if (lvl_a_id >= ce_data->num_pid_entries) {
                 printk(KERN_INFO "litmus: level A id greater than expected "
                                 "number of tasks %d for %d cpu %d\n",
                                 ce_data->num_pid_entries, ts->pid,
                                 get_partition(ts));
-                goto out_put_pid_unlock;
+                goto out_put_pid;
         }
         if (ce_data->pid_entries[lvl_a_id].pid) {
                 printk(KERN_INFO "litmus: have saved pid info id: %d cpu: %d\n",
                                 lvl_a_id, get_partition(ts));
-                goto out_put_pid_unlock;
+                goto out_put_pid;
         }
         if (get_exec_cost(ts) >= ce_data->pid_entries[lvl_a_id].budget) {
                 printk(KERN_INFO "litmus: execution cost %llu is larger than "
                                 "the budget %llu\n",
                                 get_exec_cost(ts),
                                 ce_data->pid_entries[lvl_a_id].budget);
-                goto out_put_pid_unlock;
+                goto out_put_pid;
         }
         ce_data->pid_entries[lvl_a_id].pid = pid;
         retval = 0;
         /* don't call put_pid if we are successful */
-        goto out_unlock;
+        goto out;
 
-out_put_pid_unlock:
+out_put_pid:
         put_pid(pid);
-out_unlock:
-        raw_spin_unlock_irqrestore(dom->lock, flags);
 out:
         return retval;
 }
 
+static long mc_ce_admit_task(struct task_struct *ts)
+{
+        domain_t *dom = &per_cpu(mc_ce_doms, get_partition(ts));
+        unsigned long flags, retval;
+        raw_spin_lock_irqsave(dom->lock, flags);
+        retval = __mc_ce_admit_task(ts);
+        raw_spin_unlock_irqrestore(dom->lock, flags);
+        return retval;
+}
+
 /*
  * Called to set up a new real-time task (after the admit_task callback).
  * At this point the task's struct PID is already hooked up on the destination
@@ -386,7 +372,7 @@ static void mc_ce_task_exit(struct task_struct *ts)
         struct ce_dom_data *ce_data = dom->data;
         unsigned long flags;
         struct pid *pid;
-        const int lvl_a_id = tsk_mc_data(ts)->mc_task.lvl_a_id;;
+        const int lvl_a_id = tsk_mc_data(ts)->mc_task.lvl_a_id;
 
         TRACE_TASK(ts, "exited\n");
 
@@ -410,31 +396,23 @@ static void mc_ce_task_exit(struct task_struct *ts)
  * Timer stuff
  **********************************************************/
 
-/*
- * What to do when a timer fires. The timer should only be armed if the number
- * of PID entries is positive.
- */
-static enum hrtimer_restart timer_callback(struct hrtimer *timer)
+void __mc_ce_timer_callback(struct hrtimer *timer)
 {
         /* relative and absolute times for cycles */
         lt_t now, offset_rel, cycle_start_abs, next_timer_abs;
         struct task_struct *should_schedule;
         struct ce_dom_pid_entry *pid_entry;
         struct ce_dom_data *ce_data;
-        unsigned long flags;
         domain_t *dom;
         int idx, budget_overrun;
 
         ce_data = container_of(timer, struct ce_dom_data, timer);
-        dom = &per_cpu(mc_ce_doms, ce_data->cpu);
+        dom = container_of(((void*)ce_data), domain_t, data);
 
-        raw_spin_lock_irqsave(dom->lock, flags);
-
-        now = litmus_clock();
-        TRACE("timer callback at %llu on CPU %d\n", now, ce_data->cpu);
         /* 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.
          */
+        now = litmus_clock();
         offset_rel = get_cycle_offset(now, ce_data->cycle_time);
         cycle_start_abs = now - offset_rel;
         idx = mc_ce_schedule_at(dom, offset_rel);
@@ -443,7 +421,7 @@ static enum hrtimer_restart timer_callback(struct hrtimer *timer)
         next_timer_abs = cycle_start_abs + pid_entry->acc_time;
         hrtimer_set_expires(timer, ns_to_ktime(next_timer_abs));
 
-        TRACE("now: %llu  offset_rel: %llu  cycle_start_abs: %llu  "
+        TRACE("timer: now: %llu  offset_rel: %llu  cycle_start_abs: %llu  "
                         "next_timer_abs: %llu\n", now, offset_rel,
                         cycle_start_abs, next_timer_abs);
 
@@ -478,6 +456,26 @@ static enum hrtimer_restart timer_callback(struct hrtimer *timer)
                 sched_trace_task_release(should_schedule);
                 set_rt_flags(ce_data->should_schedule, RT_F_RUNNING);
         }
+}
+
+/*
+ * What to do when a timer fires. The timer should only be armed if the number
+ * of PID entries is positive.
+ */
+static enum hrtimer_restart mc_ce_timer_callback(struct hrtimer *timer)
+{
+        struct ce_dom_data *ce_data;
+        unsigned long flags;
+        domain_t *dom;
+
+        ce_data = container_of(timer, struct ce_dom_data, timer);
+        dom = container_of(((void*)ce_data), domain_t, data);
+
+        TRACE("timer callback on CPU %d (before lock)\n", ce_data->cpu);
+
+        raw_spin_lock_irqsave(dom->lock, flags);
+        __mc_ce_timer_callback(timer);
+
         if (ce_data->scheduled != ce_data->should_schedule)
                 preempt_if_preemptable(ce_data->scheduled, ce_data->cpu);
 
@@ -542,7 +540,7 @@ static void arm_all_timers(void)
  * call this. We can re-set our notion of the CE period start to make
  * the schedule look pretty.
  */
-static void mc_ce_release_at(struct task_struct *ts, lt_t start)
+void mc_ce_release_at(struct task_struct *ts, lt_t start)
 {
         TRACE_TASK(ts, "release at\n");
         if (atomic_inc_and_test(&start_time_set)) {
@@ -554,7 +552,7 @@ static void mc_ce_release_at(struct task_struct *ts, lt_t start)
                 atomic_dec(&start_time_set);
 }
 
-static long mc_ce_activate_plugin(void)
+long mc_ce_activate_plugin(void)
 {
         struct ce_dom_data *ce_data;
         domain_t *dom;
@@ -598,7 +596,7 @@ static void clear_pid_entries(void)
         }
 }
 
-static long mc_ce_deactivate_plugin(void)
+long mc_ce_deactivate_plugin(void)
 {
         cancel_all_timers();
         return 0;
@@ -638,7 +636,7 @@ static int __init init_sched_mc_ce(void)
                 hrtimer_init(&ce_data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
                 hrtimer_start_on_info_init(&ce_data->timer_info);
                 ce_data->cpu = cpu;
-                ce_data->timer.function = timer_callback;
+                ce_data->timer.function = mc_ce_timer_callback;
         }
         clear_pid_entries();
         err = setup_proc();