Add MC2 plugin

3 files changed, 911 insertions, 0 deletions

diff --git a/include/litmus/mc2_common.h b/include/litmus/mc2_common.h
new file mode 100644
index 000000000000..a1d571f0280f
--- /dev/null
+++ b/include/litmus/mc2_common.h
@@ -0,0 +1,39 @@
+/*
+ * MC^2 common data structures
+ */
+ 
+#ifndef __UNC_MC2_COMMON_H__
+#define __UNC_MC2_COMMON_H__
+
+enum crit_level {
+        CRIT_LEVEL_A = 0,
+        CRIT_LEVEL_B = 1,
+        CRIT_LEVEL_C = 2,
+        NUM_CRIT_LEVELS = 3,
+};
+
+struct mc2_task {
+        enum crit_level crit;
+        pid_t pid;
+        lt_t hyperperiod;
+};
+
+#ifdef __KERNEL__
+
+#include <litmus/reservation.h>
+
+struct mc2_param{
+        struct mc2_task mc2_task;
+};
+
+struct mc2_task_client {
+        struct task_client tc;
+        struct mc2_param mc2;
+};
+
+long mc2_task_client_init(struct mc2_task_client *mtc, struct task_struct *tsk,
+                                                        struct reservation *res);
+        
+#endif /* __KERNEL__ */
+
+#endif
\ No newline at end of file
diff --git a/litmus/mc2_common.c b/litmus/mc2_common.c
new file mode 100644
index 000000000000..56ef6b506a86
--- /dev/null
+++ b/litmus/mc2_common.c
@@ -0,0 +1,30 @@
+/*
+ * litmus/mc2_common.c
+ *
+ * Common functions for MC2 plugin.
+ */
+
+#include <linux/percpu.h>
+#include <linux/sched.h>
+#include <linux/list.h>
+
+#include <litmus/litmus.h>
+#include <litmus/sched_plugin.h>
+#include <litmus/sched_trace.h>
+
+#include <litmus/mc2_common.h>
+
+long mc2_task_client_init(
+        struct mc2_task_client *mtc,
+        struct task_struct *tsk,
+        struct reservation *res
+)
+{
+        task_client_init(&mtc->tc, tsk, res);
+        if ((mtc->mc2.mc2_task.crit < CRIT_LEVEL_A) ||
+                (mtc->mc2.mc2_task.crit > CRIT_LEVEL_C))
+                return -EINVAL;
+        
+        TRACE_TASK(tsk, "mc2_task_client_init: crit_level = %d\n", mtc->mc2.mc2_task.crit);
+        return 0;
+}
\ No newline at end of file
diff --git a/litmus/sched_mc2.c b/litmus/sched_mc2.c
new file mode 100644
index 000000000000..ab35008668d6
--- /dev/null
+++ b/litmus/sched_mc2.c
@@ -0,0 +1,842 @@
+#include <linux/percpu.h>
+#include <linux/slab.h>
+#include <asm/uaccess.h>
+
+#include <litmus/sched_plugin.h>
+#include <litmus/preempt.h>
+#include <litmus/debug_trace.h>
+
+#include <litmus/litmus.h>
+#include <litmus/jobs.h>
+#include <litmus/budget.h>
+#include <litmus/litmus_proc.h>
+
+#include <litmus/mc2_common.h>
+#include <litmus/reservation.h>
+#include <litmus/polling_reservations.h>
+
+struct mc2_task_state {
+        struct mc2_task_client res_info;
+        int cpu;
+        bool has_departed;
+};
+
+struct mc2_cpu_state {
+        raw_spinlock_t lock;
+
+        struct sup_reservation_environment sup_env;
+        struct hrtimer timer;
+
+        int cpu;
+        struct task_struct* scheduled;
+
+#ifdef CONFIG_RELEASE_MASTER
+        int release_master;
+        /* used to delegate releases */
+        struct hrtimer_start_on_info info;
+#endif
+};
+
+static DEFINE_PER_CPU(struct mc2_cpu_state, mc2_cpu_state);
+
+#define cpu_state_for(cpu_id)   (&per_cpu(mc2_cpu_state, cpu_id))
+#define local_cpu_state()       (&__get_cpu_var(mc2_cpu_state))
+
+static struct mc2_task_state* get_mc2_state(struct task_struct *tsk)
+{
+        return (struct mc2_task_state*) tsk_rt(tsk)->plugin_state;
+}
+
+static void task_departs(struct task_struct *tsk, int job_complete)
+{
+        struct mc2_task_state* state = get_mc2_state(tsk);
+        struct reservation* res;
+        struct reservation_client *client;
+
+        res    = state->res_info.tc.client.reservation;
+        client = &state->res_info.tc.client;
+
+        res->ops->client_departs(res, client, job_complete);
+        state->has_departed = true;
+}
+
+static void task_arrives(struct task_struct *tsk)
+{
+        struct mc2_task_state* state = get_mc2_state(tsk);
+        struct reservation* res;
+        struct reservation_client *client;
+
+        res    = state->res_info.tc.client.reservation;
+        client = &state->res_info.tc.client;
+
+        state->has_departed = false;
+        res->ops->client_arrives(res, client);
+}
+
+/* NOTE: drops state->lock */
+static void mc2_update_timer_and_unlock(struct mc2_cpu_state *state)
+{
+        int local;
+        lt_t update, now;
+
+        update = state->sup_env.next_scheduler_update;
+        now = state->sup_env.env.current_time;
+        
+        /* Be sure we're actually running on the right core,
+         * as mc2_update_timer() is also called from mc2_task_resume(),
+         * which might be called on any CPU when a thread resumes.
+         */
+        local = local_cpu_state() == state;
+        
+        /* Must drop state lock before calling into hrtimer_start(), which
+         * may raise a softirq, which in turn may wake ksoftirqd. */
+        raw_spin_unlock(&state->lock);
+
+        if (update <= now) {
+                litmus_reschedule(state->cpu);
+        } else if (likely(local && update != SUP_NO_SCHEDULER_UPDATE)) {
+                /* Reprogram only if not already set correctly. */
+                if (!hrtimer_active(&state->timer) ||
+                    ktime_to_ns(hrtimer_get_expires(&state->timer)) != update) {
+                        TRACE("canceling timer...\n");
+                        hrtimer_cancel(&state->timer);
+                        TRACE("setting scheduler timer for %llu\n", update);
+                        /* We cannot use hrtimer_start() here because the
+                         * wakeup flag must be set to zero. */
+                        __hrtimer_start_range_ns(&state->timer,
+                                        ns_to_ktime(update),
+                                        0 /* timer coalescing slack */,
+                                        HRTIMER_MODE_ABS_PINNED,
+                                        0 /* wakeup */);
+                }
+        } else if (unlikely(!local && update != SUP_NO_SCHEDULER_UPDATE)) {
+                /* Poke remote core only if timer needs to be set earlier than
+                 * it is currently set.
+                 */
+                TRACE("mc2_update_timer for remote CPU %d (update=%llu, "
+                      "active:%d, set:%llu)\n",
+                        state->cpu,
+                        update,
+                        hrtimer_active(&state->timer),
+                        ktime_to_ns(hrtimer_get_expires(&state->timer)));
+                if (!hrtimer_active(&state->timer) ||
+                    ktime_to_ns(hrtimer_get_expires(&state->timer)) > update) {
+                        TRACE("poking CPU %d so that it can update its "
+                               "scheduling timer (active:%d, set:%llu)\n",
+                               state->cpu,
+                               hrtimer_active(&state->timer),
+                               ktime_to_ns(hrtimer_get_expires(&state->timer)));
+                        litmus_reschedule(state->cpu);
+                }
+        }
+}
+
+static enum hrtimer_restart on_scheduling_timer(struct hrtimer *timer)
+{
+        unsigned long flags;
+        enum hrtimer_restart restart = HRTIMER_NORESTART;
+        struct mc2_cpu_state *state;
+        lt_t update, now;
+
+        state = container_of(timer, struct mc2_cpu_state, timer);
+
+        /* The scheduling timer should only fire on the local CPU, because
+         * otherwise deadlocks via timer_cancel() are possible.
+         * Note: this does not interfere with dedicated interrupt handling, as
+         * even under dedicated interrupt handling scheduling timers for
+         * budget enforcement must occur locally on each CPU.
+         */
+        BUG_ON(state->cpu != raw_smp_processor_id());
+
+        raw_spin_lock_irqsave(&state->lock, flags);
+        sup_update_time(&state->sup_env, litmus_clock());
+
+        update = state->sup_env.next_scheduler_update;
+        now = state->sup_env.env.current_time;
+
+        TRACE_CUR("on_scheduling_timer at %llu, upd:%llu (for cpu=%d)\n",
+                now, update, state->cpu);
+
+        if (update <= now) {
+                litmus_reschedule_local();
+        } else if (update != SUP_NO_SCHEDULER_UPDATE) {
+                hrtimer_set_expires(timer, ns_to_ktime(update));
+                restart = HRTIMER_RESTART;
+        }
+
+        raw_spin_unlock_irqrestore(&state->lock, flags);
+
+        return restart;
+}
+
+static long mc2_complete_job(void)
+{
+        ktime_t next_release;
+        long err;
+
+        TRACE_CUR("mc2_complete_job at %llu (deadline: %llu)\n", litmus_clock(),
+                                        get_deadline(current));
+
+        tsk_rt(current)->completed = 1;
+        prepare_for_next_period(current);
+        next_release = ns_to_ktime(get_release(current));
+        preempt_disable();
+        TRACE_CUR("next_release=%llu\n", get_release(current));
+        if (get_release(current) > litmus_clock()) {
+                set_current_state(TASK_INTERRUPTIBLE);
+                preempt_enable_no_resched();
+                err = schedule_hrtimeout(&next_release, HRTIMER_MODE_ABS);
+        } else {
+                err = 0;
+                TRACE_CUR("TARDY: release=%llu now=%llu\n", get_release(current), litmus_clock());
+                preempt_enable();
+        }
+
+        TRACE_CUR("mc2_complete_job returns [%d] at %llu\n", err, litmus_clock());
+        return err;
+}
+
+static struct task_struct* mc2_schedule(struct task_struct * prev)
+{
+        /* next == NULL means "schedule background work". */
+        struct mc2_cpu_state *state = local_cpu_state();
+
+        raw_spin_lock(&state->lock);
+
+        BUG_ON(state->scheduled && state->scheduled != prev);
+        BUG_ON(state->scheduled && !is_realtime(prev));
+
+        /* update time */
+        state->sup_env.will_schedule = true;
+        sup_update_time(&state->sup_env, litmus_clock());
+
+        /* check if prev task complete */
+        if (is_realtime(prev)) {
+                TRACE_TASK(prev, "EXEC_TIME = %llu, EXEC_COST = %llu, REMAINED = %llu\n",
+                        get_exec_time(prev), get_exec_cost(prev), get_exec_cost(prev)-get_exec_time(prev)); 
+        }
+        if (is_realtime(prev) && (get_exec_time(prev) >= get_exec_cost(prev))) {
+                TRACE_TASK(prev, "JOB COMPLETED! but is_completed = %d\n", is_completed(prev));
+//              mc2_complete_job(prev);
+        }
+
+        /* remove task from reservation if it blocks */
+        if (is_realtime(prev) && !is_running(prev))
+                task_departs(prev, is_completed(prev));
+
+        /* figure out what to schedule next */
+        state->scheduled = sup_dispatch(&state->sup_env);
+
+        /* Notify LITMUS^RT core that we've arrived at a scheduling decision. */
+        sched_state_task_picked();
+
+        /* program scheduler timer */
+        state->sup_env.will_schedule = false;
+        /* NOTE: drops state->lock */
+        mc2_update_timer_and_unlock(state);
+        
+        if (prev != state->scheduled && is_realtime(prev))
+                TRACE_TASK(prev, "descheduled.\n");
+        if (state->scheduled)
+                TRACE_TASK(state->scheduled, "scheduled.\n");
+
+        return state->scheduled;
+}
+
+static void resume_legacy_task_model_updates(struct task_struct *tsk)
+{
+        lt_t now;
+        if (is_sporadic(tsk)) {
+                /* If this sporadic task was gone for a "long" time and woke up past
+                 * its deadline, then give it a new budget by triggering a job
+                 * release. This is purely cosmetic and has no effect on the
+                 * P-RES scheduler. */
+
+                now = litmus_clock();
+                if (is_tardy(tsk, now))
+                        release_at(tsk, now);
+        }
+}
+
+/* Called when the state of tsk changes back to TASK_RUNNING.
+ * We need to requeue the task.
+ */
+static void mc2_task_resume(struct task_struct  *tsk)
+{
+        unsigned long flags;
+        struct mc2_task_state* tinfo = get_mc2_state(tsk);
+        struct mc2_cpu_state *state = cpu_state_for(tinfo->cpu);
+
+        TRACE_TASK(tsk, "thread wakes up at %llu\n", litmus_clock());
+
+        raw_spin_lock_irqsave(&state->lock, flags);
+        /* Requeue only if self-suspension was already processed. */
+        if (tinfo->has_departed)
+        {
+                /* Assumption: litmus_clock() is synchronized across cores,
+                 * since we might not actually be executing on tinfo->cpu
+                 * at the moment. */
+                sup_update_time(&state->sup_env, litmus_clock());
+                task_arrives(tsk);
+                /* NOTE: drops state->lock */
+                mc2_update_timer_and_unlock(state);
+                local_irq_restore(flags);
+        } else {
+                TRACE_TASK(tsk, "resume event ignored, still scheduled\n");
+                raw_spin_unlock_irqrestore(&state->lock, flags);
+        }
+
+        resume_legacy_task_model_updates(tsk);
+}
+
+static long mc2_admit_task(struct task_struct *tsk)
+{
+        long err = -ESRCH;
+        unsigned long flags;
+        struct reservation *res;
+        struct mc2_cpu_state *state;
+        struct mc2_task_state *tinfo = kzalloc(sizeof(*tinfo), GFP_ATOMIC);
+        struct mc2_task *mp = tsk_rt(tsk)->plugin_state;
+        
+        if (!tinfo)
+                return -ENOMEM;
+        
+        if (!mp) {
+                printk(KERN_ERR "mc2_admit_task: criticality level has not been set\n");
+                return err;
+        }
+        
+        preempt_disable();
+
+        state = cpu_state_for(task_cpu(tsk));
+        raw_spin_lock_irqsave(&state->lock, flags);
+
+        res = sup_find_by_id(&state->sup_env, mp->pid);
+
+        /* found the appropriate reservation (or vCPU) */
+        if (res) {
+                TRACE_TASK(tsk, "FOUND RES\n");
+                tinfo->res_info.mc2.mc2_task.crit = mp->crit;
+                
+                kfree(tsk_rt(tsk)->plugin_state);
+                tsk_rt(tsk)->plugin_state = NULL;
+        
+                err = mc2_task_client_init(&tinfo->res_info, tsk, res);
+                tinfo->cpu = task_cpu(tsk);
+                tinfo->has_departed = true;
+                tsk_rt(tsk)->plugin_state = tinfo;
+                
+                /* disable LITMUS^RT's per-thread budget enforcement */
+                tsk_rt(tsk)->task_params.budget_policy = NO_ENFORCEMENT;
+        }
+
+        raw_spin_unlock_irqrestore(&state->lock, flags);
+
+        preempt_enable();
+
+        if (err)
+                kfree(tinfo);
+
+        return err;
+}
+
+static void task_new_legacy_task_model_updates(struct task_struct *tsk)
+{
+        lt_t now = litmus_clock();
+
+        /* the first job exists starting as of right now */
+        release_at(tsk, now);
+}
+
+static void mc2_task_new(struct task_struct *tsk, int on_runqueue,
+                          int is_running)
+{
+        unsigned long flags;
+        struct mc2_task_state* tinfo = get_mc2_state(tsk);
+        struct mc2_cpu_state *state = cpu_state_for(tinfo->cpu);
+
+        TRACE_TASK(tsk, "new RT task %llu (on_rq:%d, running:%d)\n",
+                   litmus_clock(), on_runqueue, is_running);
+
+        /* acquire the lock protecting the state and disable interrupts */
+        raw_spin_lock_irqsave(&state->lock, flags);
+
+        if (is_running) {
+                state->scheduled = tsk;
+                /* make sure this task should actually be running */
+                litmus_reschedule_local();
+        }
+
+        if (on_runqueue || is_running) {
+                /* Assumption: litmus_clock() is synchronized across cores
+                 * [see comment in pres_task_resume()] */
+                sup_update_time(&state->sup_env, litmus_clock());
+                task_arrives(tsk);
+                /* NOTE: drops state->lock */
+                mc2_update_timer_and_unlock(state);
+                local_irq_restore(flags);
+        } else
+                raw_spin_unlock_irqrestore(&state->lock, flags);
+
+        task_new_legacy_task_model_updates(tsk);
+}
+
+static void mc2_task_exit(struct task_struct *tsk)
+{
+        unsigned long flags;
+        struct mc2_task_state* tinfo = get_mc2_state(tsk);
+        struct mc2_cpu_state *state = cpu_state_for(tinfo->cpu);
+
+        raw_spin_lock_irqsave(&state->lock, flags);
+
+        if (state->scheduled == tsk)
+                state->scheduled = NULL;
+
+        /* remove from queues */
+        if (is_running(tsk)) {
+                /* Assumption: litmus_clock() is synchronized across cores
+                 * [see comment in pres_task_resume()] */
+                sup_update_time(&state->sup_env, litmus_clock());
+                task_departs(tsk, 0);
+                /* NOTE: drops state->lock */
+                mc2_update_timer_and_unlock(state);
+                local_irq_restore(flags);
+        } else
+                raw_spin_unlock_irqrestore(&state->lock, flags);
+
+        kfree(tsk_rt(tsk)->plugin_state);
+        tsk_rt(tsk)->plugin_state = NULL;
+}
+
+asmlinkage long sys_set_mc2_task_param(pid_t pid, struct mc2_task __user * param)
+{
+        struct task_struct *target;
+        int retval = -EINVAL;
+        struct mc2_task *mp = kzalloc(sizeof(*mp), GFP_KERNEL);
+        
+        if (!mp)
+                return -ENOMEM;
+
+        printk("Setting up mc^2 task parameters for process %d.\n", pid);
+
+        if (pid < 0 || param == 0) {
+                goto out;
+        }
+        if (copy_from_user(mp, param, sizeof(*mp))) {
+                retval = -EFAULT;
+                goto out;
+        }
+
+        /* Task search and manipulation must be protected */
+        read_lock_irq(&tasklist_lock);
+        if (!(target = find_task_by_vpid(pid))) {
+                retval = -ESRCH;
+                goto out_unlock;
+        }
+
+        if (is_realtime(target)) {
+                /* The task is already a real-time task.
+                 * We cannot not allow parameter changes at this point.
+                 */
+                retval = -EBUSY;
+                goto out_unlock;
+        }
+        if (mp->crit < CRIT_LEVEL_A || mp->crit >= NUM_CRIT_LEVELS) {
+                printk(KERN_INFO "litmus: real-time task %d rejected "
+                        "because of invalid criticality level\n", pid);
+                goto out_unlock;
+        }
+        
+        target->rt_param.plugin_state = mp;
+
+        retval = 0;
+      out_unlock:
+        read_unlock_irq(&tasklist_lock);
+      out:
+        return retval;
+}
+
+static long create_polling_reservation(
+        int res_type,
+        struct reservation_config *config)
+{
+        struct mc2_cpu_state *state;
+        struct reservation* res;
+        struct polling_reservation *pres;
+        unsigned long flags;
+        int use_edf  = config->priority == LITMUS_NO_PRIORITY;
+        int periodic =  res_type == PERIODIC_POLLING;
+        long err = -EINVAL;
+
+        if (config->polling_params.budget >
+            config->polling_params.period) {
+                printk(KERN_ERR "invalid polling reservation (%u): "
+                       "budget > period\n", config->id);
+                return -EINVAL;
+        }
+        if (config->polling_params.budget >
+            config->polling_params.relative_deadline
+            && config->polling_params.relative_deadline) {
+                printk(KERN_ERR "invalid polling reservation (%u): "
+                       "budget > deadline\n", config->id);
+                return -EINVAL;
+        }
+        if (config->polling_params.offset >
+            config->polling_params.period) {
+                printk(KERN_ERR "invalid polling reservation (%u): "
+                       "offset > period\n", config->id);
+                return -EINVAL;
+        }
+
+        /* Allocate before we grab a spin lock.
+         * Todo: would be nice to use a core-local allocation.
+         */
+        pres = kzalloc(sizeof(*pres), GFP_KERNEL);
+        if (!pres)
+                return -ENOMEM;
+
+        state = cpu_state_for(config->cpu);
+        raw_spin_lock_irqsave(&state->lock, flags);
+
+        res = sup_find_by_id(&state->sup_env, config->id);
+        if (!res) {
+                polling_reservation_init(pres, use_edf, periodic,
+                        config->polling_params.budget,
+                        config->polling_params.period,
+                        config->polling_params.relative_deadline,
+                        config->polling_params.offset);
+                pres->res.id = config->id;
+                if (!use_edf)
+                        pres->res.priority = config->priority;
+                sup_add_new_reservation(&state->sup_env, &pres->res);
+                err = config->id;
+        } else {
+                err = -EEXIST;
+        }
+
+        raw_spin_unlock_irqrestore(&state->lock, flags);
+
+        if (err < 0)
+                kfree(pres);
+
+        return err;
+}
+
+#define MAX_INTERVALS 1024
+
+static long create_table_driven_reservation(
+        struct reservation_config *config)
+{
+        struct mc2_cpu_state *state;
+        struct reservation* res;
+        struct table_driven_reservation *td_res = NULL;
+        struct lt_interval *slots = NULL;
+        size_t slots_size;
+        unsigned int i, num_slots;
+        unsigned long flags;
+        long err = -EINVAL;
+
+
+        if (!config->table_driven_params.num_intervals) {
+                printk(KERN_ERR "invalid table-driven reservation (%u): "
+                       "no intervals\n", config->id);
+                return -EINVAL;
+        }
+
+        if (config->table_driven_params.num_intervals > MAX_INTERVALS) {
+                printk(KERN_ERR "invalid table-driven reservation (%u): "
+                       "too many intervals (max: %d)\n", config->id, MAX_INTERVALS);
+                return -EINVAL;
+        }
+
+        num_slots = config->table_driven_params.num_intervals;
+        slots_size = sizeof(slots[0]) * num_slots;
+        slots = kzalloc(slots_size, GFP_KERNEL);
+        if (!slots)
+                return -ENOMEM;
+
+        td_res = kzalloc(sizeof(*td_res), GFP_KERNEL);
+        if (!td_res)
+                err = -ENOMEM;
+        else
+                err = copy_from_user(slots,
+                        config->table_driven_params.intervals, slots_size);
+
+        for (i=0; i<num_slots;i++) {
+                TRACE("###### [%llu, %llu]\n", slots[i].start, slots[i].end);
+        }
+        
+        if (!err) {
+                /* sanity checks */
+                for (i = 0; !err && i < num_slots; i++)
+                        if (slots[i].end <= slots[i].start) {
+                                printk(KERN_ERR
+                                       "invalid table-driven reservation (%u): "
+                                       "invalid interval %u => [%llu, %llu]\n",
+                                       config->id, i,
+                                       slots[i].start, slots[i].end);
+                                err = -EINVAL;
+                        }
+
+                for (i = 0; !err && i + 1 < num_slots; i++)
+                        if (slots[i + 1].start <= slots[i].end) {
+                                printk(KERN_ERR
+                                       "invalid table-driven reservation (%u): "
+                                       "overlapping intervals %u, %u\n",
+                                       config->id, i, i + 1);
+                                err = -EINVAL;
+                        }
+
+                if (slots[num_slots - 1].end >
+                        config->table_driven_params.major_cycle_length) {
+                        printk(KERN_ERR
+                                "invalid table-driven reservation (%u): last "
+                                "interval ends past major cycle %llu > %llu\n",
+                                config->id,
+                                slots[num_slots - 1].end,
+                                config->table_driven_params.major_cycle_length);
+                        err = -EINVAL;
+                }
+        }
+
+        if (!err) {
+                state = cpu_state_for(config->cpu);
+                raw_spin_lock_irqsave(&state->lock, flags);
+
+                res = sup_find_by_id(&state->sup_env, config->id);
+                if (!res) {
+                        table_driven_reservation_init(td_res,
+                                config->table_driven_params.major_cycle_length,
+                                slots, num_slots);
+                        td_res->res.id = config->id;
+                        td_res->res.priority = config->priority;
+                        sup_add_new_reservation(&state->sup_env, &td_res->res);
+                        err = config->id;
+                } else {
+                        err = -EEXIST;
+                }
+
+                raw_spin_unlock_irqrestore(&state->lock, flags);
+        }
+
+        if (err < 0) {
+                kfree(slots);
+                kfree(td_res);
+        }
+
+        TRACE("CREATE_TABLE_DRIVEN_RES = %d\n", err);
+        return err;
+}
+
+static long mc2_reservation_create(int res_type, void* __user _config)
+{
+        long ret = -EINVAL;
+        struct reservation_config config;
+
+        TRACE("Attempt to create reservation (%d)\n", res_type);
+
+        if (copy_from_user(&config, _config, sizeof(config)))
+                return -EFAULT;
+
+        if (config.cpu < 0 || !cpu_online(config.cpu)) {
+                printk(KERN_ERR "invalid polling reservation (%u): "
+                       "CPU %d offline\n", config.id, config.cpu);
+                return -EINVAL;
+        }
+
+        switch (res_type) {
+                case PERIODIC_POLLING:
+                case SPORADIC_POLLING:
+                        ret = create_polling_reservation(res_type, &config);
+                        break;
+
+                case TABLE_DRIVEN:
+                        ret = create_table_driven_reservation(&config);
+                        break;
+
+                default:
+                        return -EINVAL;
+        };
+
+        return ret;
+}
+
+static long mc2_reservation_destroy(unsigned int reservation_id, int cpu)
+{
+        long ret = -EINVAL;
+        struct mc2_cpu_state *state;
+        struct reservation *res, *next;
+        struct sup_reservation_environment *sup_env;
+        unsigned long flags;
+        int found = 0;
+        
+        state = cpu_state_for(cpu);
+        raw_spin_lock_irqsave(&state->lock, flags);
+        
+        //res = sup_find_by_id(&state->sup_env, reservation_id);
+        sup_env = &state->sup_env;
+        //if (!res) {
+        list_for_each_entry_safe(res, next, &sup_env->depleted_reservations, list) {
+                if (res->id == reservation_id) {
+                        list_del(&res->list);
+                        found = 1;
+                        ret = 0;
+                }
+        }
+        if (!found) {
+                list_for_each_entry_safe(res, next, &sup_env->inactive_reservations, list) {
+                        if (res->id == reservation_id) {
+                                list_del(&res->list);
+                                found = 1;
+                                ret = 0;
+                        }
+                }
+        }
+        if (!found) {
+                list_for_each_entry_safe(res, next, &sup_env->active_reservations, list) {
+                        if (res->id == reservation_id) {
+                                list_del(&res->list);
+                                found = 1;
+                                ret = 0;
+                        }
+                }
+        }
+        //}
+
+        raw_spin_unlock_irqrestore(&state->lock, flags);
+        
+        TRACE("RESERVATION_DESTROY ret = %d\n", ret);
+        return ret;
+}
+
+static struct domain_proc_info mc2_domain_proc_info;
+
+static long mc2_get_domain_proc_info(struct domain_proc_info **ret)
+{
+        *ret = &mc2_domain_proc_info;
+        return 0;
+}
+
+static void mc2_setup_domain_proc(void)
+{
+        int i, cpu;
+        int num_rt_cpus = num_online_cpus();
+
+        struct cd_mapping *cpu_map, *domain_map;
+
+        memset(&mc2_domain_proc_info, sizeof(mc2_domain_proc_info), 0);
+        init_domain_proc_info(&mc2_domain_proc_info, num_rt_cpus, num_rt_cpus);
+        mc2_domain_proc_info.num_cpus = num_rt_cpus;
+        mc2_domain_proc_info.num_domains = num_rt_cpus;
+
+        i = 0;
+        for_each_online_cpu(cpu) {
+                cpu_map = &mc2_domain_proc_info.cpu_to_domains[i];
+                domain_map = &mc2_domain_proc_info.domain_to_cpus[i];
+
+                cpu_map->id = cpu;
+                domain_map->id = i;
+                cpumask_set_cpu(i, cpu_map->mask);
+                cpumask_set_cpu(cpu, domain_map->mask);
+                ++i;
+        }
+}
+
+static long mc2_activate_plugin(void)
+{
+        int cpu;
+        struct mc2_cpu_state *state;
+
+        for_each_online_cpu(cpu) {
+                TRACE("Initializing CPU%d...\n", cpu);
+
+                state = cpu_state_for(cpu);
+
+#ifdef CONFIG_RELEASE_MASTER
+                state->release_master = atomic_read(&release_master_cpu);
+                hrtimer_start_on_info_init(&state->info);
+#endif
+                
+                raw_spin_lock_init(&state->lock);
+                state->cpu = cpu;
+                state->scheduled = NULL;
+
+                sup_init(&state->sup_env);
+
+                hrtimer_init(&state->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_PINNED);
+                state->timer.function = on_scheduling_timer;
+        }
+
+        mc2_setup_domain_proc();
+
+        return 0;
+}
+
+static long mc2_deactivate_plugin(void)
+{
+        int cpu;
+        struct mc2_cpu_state *state;
+        struct reservation *res;
+
+        for_each_online_cpu(cpu) {
+                state = cpu_state_for(cpu);
+                raw_spin_lock(&state->lock);
+
+                hrtimer_cancel(&state->timer);
+
+                /* Delete all reservations --- assumes struct reservation
+                 * is prefix of containing struct. */
+
+                while (!list_empty(&state->sup_env.active_reservations)) {
+                        res = list_first_entry(
+                                &state->sup_env.active_reservations,
+                                struct reservation, list);
+                        list_del(&res->list);
+                        kfree(res);
+                }
+
+                while (!list_empty(&state->sup_env.inactive_reservations)) {
+                        res = list_first_entry(
+                                &state->sup_env.inactive_reservations,
+                                struct reservation, list);
+                        list_del(&res->list);
+                        kfree(res);
+                }
+
+                while (!list_empty(&state->sup_env.depleted_reservations)) {
+                        res = list_first_entry(
+                                &state->sup_env.depleted_reservations,
+                                struct reservation, list);
+                        list_del(&res->list);
+                        kfree(res);
+                }
+
+                raw_spin_unlock(&state->lock);
+        }
+
+        destroy_domain_proc_info(&mc2_domain_proc_info);
+        return 0;
+}
+
+static struct sched_plugin mc2_plugin = {
+        .plugin_name            = "MC2",
+        .schedule               = mc2_schedule,
+        .task_wake_up           = mc2_task_resume,
+        .admit_task             = mc2_admit_task,
+        .task_new               = mc2_task_new,
+        .task_exit              = mc2_task_exit,
+        .complete_job           = mc2_complete_job,
+        .get_domain_proc_info   = mc2_get_domain_proc_info,
+        .activate_plugin        = mc2_activate_plugin,
+        .deactivate_plugin      = mc2_deactivate_plugin,
+        .reservation_create     = mc2_reservation_create,
+        .reservation_destroy    = mc2_reservation_destroy,
+};
+
+static int __init init_mc2(void)
+{
+        return register_sched_plugin(&mc2_plugin);
+}
+
+module_init(init_mc2);
+