Mode change implementation

1 files changed, 510 insertions, 422 deletions

diff --git a/litmus/sched_mc2.c b/litmus/sched_mc2.c
index a2abda848cbf..31d3019d9fce 100644
--- a/litmus/sched_mc2.c
+++ b/litmus/sched_mc2.c
@@ -9,6 +9,7 @@
  
 #include <linux/percpu.h>
 #include <linux/slab.h>
+#include <linux/rwlock.h>
 #include <asm/uaccess.h>
 
 #include <litmus/sched_plugin.h>
@@ -39,7 +40,10 @@
 extern void do_partition(enum crit_level lv, int cpu);
 
 /* _global_env - reservation container for level-C tasks*/
-struct gmp_reservation_environment _global_env;
+struct gmp_reservation_environment _global_env_modes[NR_MODES];
+struct gmp_reservation_environment *_global_env;
+raw_spinlock_t global_lock;
+
 
 /* cpu_entry - keep track of a running task on a cpu
  * This state is used to decide the lowest priority cpu
@@ -64,19 +68,13 @@ struct cpu_priority _lowest_prio_cpu;
         
 /* mc2_task_state - a task state structure */
 struct mc2_task_state {
-        struct task_client res_info;
+        struct task_client res_info[NR_MODES];
         /* if cpu == -1, this task is a global task (level C) */
         int cpu;
         bool has_departed;
         struct mc2_task mc2_param;
 };
 
-/* crit_entry - maintain the logically running job (ghost job) */
-struct crit_entry {
-        enum crit_level level;
-        struct task_struct *running;
-};
-
 /* mc2_cpu_state - maintain the scheduled state and ghost jobs
  * timer : timer for partitioned tasks (level A and B)
  * g_timer : timer for global tasks (level C)
@@ -84,21 +82,107 @@ struct crit_entry {
 struct mc2_cpu_state {
         raw_spinlock_t lock;
 
-        struct sup_reservation_environment sup_env;
+        struct sup_reservation_environment sup_env_modes[NR_MODES];
+        struct sup_reservation_environment *sup_env;
         struct hrtimer timer;
 
         int cpu;
         struct task_struct* scheduled;
-        struct crit_entry crit_entries[NUM_CRIT_LEVELS];
+        //struct crit_entry crit_entries[NUM_CRIT_LEVELS];
+        bool spin_flag; //not used on cpu 0
 };
 
+
 static int resched_cpu[NR_CPUS];
 static DEFINE_PER_CPU(struct mc2_cpu_state, mc2_cpu_state);
-static int level_a_priorities[NR_CPUS];
+//level_a_priorities unused
+//static int level_a_priorities[NR_CPUS];
 
 #define cpu_state_for(cpu_id)   (&per_cpu(mc2_cpu_state, cpu_id))
 #define local_cpu_state()       (this_cpu_ptr(&mc2_cpu_state))
 
+
+unsigned int mode; //currently executing mode, from 0 to NR_MODES-1
+unsigned int requested_mode; //The pending mode
+/* Prevent multiple requests from entering and prevent request from entering while old
+ * is being enacted */
+raw_spinlock_t mode_lock;
+
+unsigned int mode_sizes[NR_MODES];
+unsigned int res_reported;
+bool cpu_0_spin_flag;
+#define in_mode(t, modenum)     (tsk_mc2_data(t)->mode_mask & (1 << modenum))
+/*
+ * To be called from level A task's with period equal to
+ * A and B hyperperiod
+ */
+
+asmlinkage int sys_enact_mode(void)
+{
+        struct mc2_cpu_state *state = local_cpu_state();
+        struct list_head *pos;
+        struct reservation *res;
+        hrtimer_cancel(&state->timer);//stop listening to old mode timers
+        //lt_t now = litmus_clock();
+        if (state->cpu == 0){
+                raw_spin_lock(&global_lock);
+                raw_spin_lock(&mode_lock); 
+                if (mode != requested_mode //MCR has entered 
+                        && !res_reported){ //and C is throttled
+                        mode = requested_mode;
+                        _global_env = &_global_env_modes[mode];
+                        list_for_each(pos, &_global_env->active_reservations){
+                                res = list_entry(pos, struct reservation, list);
+                                res->reported = 0;
+                        }
+                        list_for_each(pos, &_global_env->depleted_reservations){
+                                res = list_entry(pos, struct reservation, list);
+                                res->reported = 0;
+                        }
+                        list_for_each(pos, &_global_env->inactive_reservations){
+                                res = list_entry(pos, struct reservation, list);
+                                res->reported = 0;
+                        }
+                        //gmp_update_time(_global_env, now);            
+                }
+                raw_spin_unlock(&mode_lock);
+                raw_spin_unlock(&global_lock);
+                //release other CPUs
+                cpu_0_spin_flag = !cpu_0_spin_flag;
+        }
+        else{
+                //spin, wait for CPU 0 to stabilize mode decision
+                //before scheduling next hyperperiod
+                if (state->spin_flag)
+                        while(cpu_0_spin_flag);
+                else
+                        while(!cpu_0_spin_flag);
+                state->spin_flag = !state->spin_flag;
+        }
+        //if mode didn't change this has no effect on what's being scheduled
+        state->sup_env = &state->sup_env_modes[mode];
+        //sup_update_time(state->sup_env, now);
+        return 0;
+}
+
+
+/*
+ * Called from non-real time program
+ * Protect by exclusive lock to prevent from occuring while mode change is enacted
+ */
+asmlinkage int sys_request_mode(int new_mode){
+        raw_spin_lock(&mode_lock);
+        if (mode != requested_mode){
+                raw_spin_unlock(&mode_lock);
+                return -EAGAIN;
+        }
+        requested_mode = new_mode;
+        res_reported = mode_sizes[mode];
+        raw_spin_unlock(&mode_lock);
+        return 0;
+}
+        
+
 /* get_mc2_state - get the task's state */
 static struct mc2_task_state* get_mc2_state(struct task_struct *tsk)
 {
@@ -140,41 +224,31 @@ static void task_departs(struct task_struct *tsk, int job_complete)
         //struct mc2_cpu_state* state = local_cpu_state();
         struct reservation* res = NULL;
         struct reservation_client *client = NULL;
-
+        int i;
         BUG_ON(!is_realtime(tsk));
-        
-        res    = tinfo->res_info.client.reservation;
-        client = &tinfo->res_info.client;
-        BUG_ON(!res);
-        BUG_ON(!client);
 
+        for(i = 0; i < NR_MODES; i++){
+                if (! in_mode(tsk, i) )
+                        continue;       
+                res    = tinfo->res_info[i].client.reservation;
+                client = &tinfo->res_info[i].client;
+                BUG_ON(!res);
+                BUG_ON(!client);
+
+                if (job_complete)
+                        res->cur_budget = 0;
+
+                res->ops->client_departs(res, client, job_complete);
+        }
 /* 9/18/2015 fix start - no ghost job handling, empty remaining budget */
         if (job_complete) {
-                res->cur_budget = 0;
+                //res->cur_budget = 0;
                 sched_trace_task_completion(tsk, 0);
         }
 /* fix end */
 
-        res->ops->client_departs(res, client, job_complete);
         tinfo->has_departed = true;
-        TRACE_TASK(tsk, "CLIENT DEPART with budget %llu at %llu\n", res->cur_budget, litmus_clock());
-/* 9/18/2015 fix start - no remaining budget 
- *      
-        if (job_complete && res->cur_budget) {
-                struct crit_entry* ce;
-                enum crit_level lv = tinfo->mc2_param.crit;
-                
-                ce = &state->crit_entries[lv];
-                ce->running = tsk;
-                res->is_ghost = state->cpu;
-#if BUDGET_ENFORCEMENT_AT_C             
-                gmp_add_event_after(&_global_env, res->cur_budget, res->id, EVENT_DRAIN);
-#endif
-                TRACE_TASK(tsk, "BECOME GHOST at %llu\n", litmus_clock());
-        }
- * fix -end
- */ 
-
+        //TRACE_TASK(tsk, "CLIENT DEPART with budget %llu at %llu\n", res->cur_budget, litmus_clock());
 }
 
 /* task_arrive - put a task into its reservation
@@ -186,9 +260,7 @@ static void task_arrives(struct mc2_cpu_state *state, struct task_struct *tsk)
         struct reservation* res;
         struct reservation_client *client;
         enum crit_level lv = get_task_crit_level(tsk);
-
-        res    = tinfo->res_info.client.reservation;
-        client = &tinfo->res_info.client;
+        int i;
 
         tinfo->has_departed = false;
 
@@ -203,22 +275,19 @@ static void task_arrives(struct mc2_cpu_state *state, struct task_struct *tsk)
                 default:
                         break;
         }
+
         
-        res->ops->client_arrives(res, client);
         TRACE_TASK(tsk, "CLIENT ARRIVES at %llu\n", litmus_clock());
         
-        if (lv != NUM_CRIT_LEVELS) {
-                struct crit_entry *ce;
-                ce = &state->crit_entries[lv];
-                /* if the currrent task is a ghost job, remove it */
-                if (ce->running == tsk)
-                        ce->running = NULL;
-        }
-        /* do we need this??
-        if (resched_cpu[state->cpu]) 
-                litmus_reschedule(state->cpu);
-        */
-        
+        for(i = 0; i < NR_MODES; i++){
+                if (! in_mode(tsk, i) )
+                        continue;       
+                res    = tinfo->res_info[i].client.reservation;
+                client = &tinfo->res_info[i].client;
+
+                res->ops->client_arrives(res, client);
+        }       
+                
         switch(lv) {
                 case CRIT_LEVEL_A:
                 case CRIT_LEVEL_B:
@@ -243,10 +312,8 @@ static int get_lowest_prio_cpu(lt_t priority)
         int cpu, ret = NO_CPU;
         lt_t latest_deadline = 0;
         
-        //raw_spin_lock(&_lowest_prio_cpu.lock);
         ce = &_lowest_prio_cpu.cpu_entries[local_cpu_state()->cpu];
         if (!ce->will_schedule && !ce->scheduled) {
-                //raw_spin_unlock(&_lowest_prio_cpu.lock);
                 TRACE("CPU %d (local) is the lowest!\n", ce->cpu);
                 return ce->cpu;
         } else {
@@ -264,7 +331,6 @@ static int get_lowest_prio_cpu(lt_t priority)
                 if (!ce->will_schedule) {
                         if (!ce->scheduled) {
                                 /* Idle cpu, return this. */
-                                //raw_spin_unlock(&_lowest_prio_cpu.lock);
                                 TRACE("CPU %d is the lowest!\n", ce->cpu);
                                 return ce->cpu;
                         } else if (ce->lv == CRIT_LEVEL_C && 
@@ -275,8 +341,6 @@ static int get_lowest_prio_cpu(lt_t priority)
                 }
         }               
         
-        //raw_spin_unlock(&_lowest_prio_cpu.lock);
-
         if (priority >= latest_deadline)
                 ret = NO_CPU;
         
@@ -285,36 +349,6 @@ static int get_lowest_prio_cpu(lt_t priority)
         return ret;
 }
 
-/* mc2_update_time - update time for a given criticality level. 
- *                   caller must hold a proper lock
- *                   (cpu_state lock or global lock)
- */
-/* 9/24/2015 temporally not using
-static void mc2_update_time(enum crit_level lv, 
-                            struct mc2_cpu_state *state, lt_t time)
-{
-        int global_schedule_now;
-        
-        if (lv < CRIT_LEVEL_C)
-                sup_update_time(&state->sup_env, time);
-        else if (lv == CRIT_LEVEL_C) {
-                global_schedule_now = gmp_update_time(&_global_env, time);
-                while (global_schedule_now--) {
-                        int cpu = get_lowest_prio_cpu(0);
-                        if (cpu != NO_CPU) {
-                                raw_spin_lock(&_lowest_prio_cpu.lock);
-                                _lowest_prio_cpu.cpu_entries[cpu].will_schedule = true;
-                                raw_spin_unlock(&_lowest_prio_cpu.lock);
-                                TRACE("LOWEST CPU = P%d\n", cpu);
-                                litmus_reschedule(cpu);
-                        }
-                } 
-        }
-        else
-                TRACE("update_time(): Criticality level error!!!!\n");
-}
-*/
-
 /* NOTE: drops state->lock */
 /* mc2_update_timer_and_unlock - set a timer and g_timer and unlock 
  *                               Whenever res_env.current_time is updated,
@@ -335,8 +369,8 @@ static void mc2_update_timer_and_unlock(struct mc2_cpu_state *state)
         for (cpus = 0; cpus<NR_CPUS; cpus++)
                 reschedule[cpus] = 0;
         
-        update = state->sup_env.next_scheduler_update;
-        now = state->sup_env.env.current_time;
+        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 pres_update_timer() is also called from pres_task_resume(),
@@ -344,9 +378,9 @@ static void mc2_update_timer_and_unlock(struct mc2_cpu_state *state)
          */
         local = local_cpu_state() == state;
 
-        raw_spin_lock(&_global_env.lock);
+        raw_spin_lock(&global_lock);
                 
-        list_for_each_entry_safe(event, next, &_global_env.next_events, list) {
+        list_for_each_entry_safe(event, next, &_global_env->next_events, list) {
                 /* If the event time is already passed, we call schedule() on
                    the lowest priority cpu */
                 if (event->next_update >= update) {
@@ -355,7 +389,7 @@ static void mc2_update_timer_and_unlock(struct mc2_cpu_state *state)
                 
                 if (event->next_update < litmus_clock()) {
                         if (event->timer_armed_on == NO_CPU) {
-                                struct reservation *res = gmp_find_by_id(&_global_env, event->id);
+                                struct reservation *res = gmp_find_by_id(_global_env, event->id);
                                 int cpu = get_lowest_prio_cpu(res?res->priority:0);
                                 TRACE("GLOBAL EVENT PASSED!! poking CPU %d to reschedule\n", cpu);
                                 list_del(&event->list);
@@ -379,7 +413,7 @@ static void mc2_update_timer_and_unlock(struct mc2_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(&_global_env.lock);
+        raw_spin_unlock(&global_lock);
         raw_spin_unlock(&state->lock);
                 
         if (update <= now || reschedule[state->cpu]) {
@@ -453,74 +487,6 @@ static void mc2_update_timer_and_unlock(struct mc2_cpu_state *state)
         }
 }
 
-/* mc2_update_ghost_state - Update crit_entries[] to track ghost jobs
- *                          If the budget of a ghost is exhausted,
- *                          clear is_ghost and reschedule
- */
-/*
-static lt_t mc2_update_ghost_state(struct mc2_cpu_state *state)
-{
-        int lv = 0;
-        struct crit_entry* ce;
-        struct reservation *res;
-        struct mc2_task_state *tinfo;
-        lt_t ret = ULLONG_MAX;
-        
-        BUG_ON(!state);
-        
-        for (lv = 0; lv < NUM_CRIT_LEVELS; lv++) {
-                ce = &state->crit_entries[lv];
-                if (ce->running != NULL) {
-//printk(KERN_ALERT "P%d ce->running : %s/%d\n", state->cpu,  ce->running ? (ce->running)->comm : "null", ce->running ? (ce->running)->pid : 0);
-                        tinfo = get_mc2_state(ce->running);
-                        if (!tinfo)
-                                continue;
-                        
-                        res = res_find_by_id(state, tinfo->mc2_param.res_id);
-                        //BUG_ON(!res);
-                        if (!res) {
-                                printk(KERN_ALERT "mc2_update_ghost_state(): R%d not found!\n", tinfo->mc2_param.res_id);                       
-                                return 0;
-                        }
-                        
-                        TRACE("LV %d running id %d budget %llu\n", 
-                               lv, tinfo->mc2_param.res_id, res->cur_budget);
-                        // If the budget is exhausted, clear is_ghost and reschedule 
-                        if (!res->cur_budget) {
-                                struct sup_reservation_environment* sup_env = &state->sup_env;
-                                
-                                TRACE("GHOST FINISH id %d at %llu\n", 
-                                      tinfo->mc2_param.res_id, litmus_clock());
-                                ce->running = NULL;
-                                res->is_ghost = NO_CPU;
-                                
-                                if (lv < CRIT_LEVEL_C) {
-                                        res = list_first_entry_or_null(
-                                              &sup_env->active_reservations, 
-                                                  struct reservation, list);
-                                        if (res)
-                                                litmus_reschedule_local();
-                                } else if (lv == CRIT_LEVEL_C) {
-                                        res = list_first_entry_or_null(
-                                              &_global_env.active_reservations,
-                                                  struct reservation, list);
-                                        if (res)
-                                                litmus_reschedule(state->cpu);
-                                }
-                        } else {
-                                //TRACE("GHOST NOT FINISH id %d budget %llu\n", res->id, res->cur_budget);
-                                //gmp_add_event_after(&_global_env, res->cur_budget, res->id, EVENT_DRAIN);
-                                if (ret > res->cur_budget) {
-                                        ret = res->cur_budget;
-                                }
-                        }
-                }
-        }
-        
-        return ret;
-}                       
-*/
-
 /* update_cpu_prio - Update cpu's priority
  *                   When a cpu picks a new task, call this function
  *                   to update cpu priorities.
@@ -580,21 +546,14 @@ static enum hrtimer_restart on_scheduling_timer(struct hrtimer *timer)
         //raw_spin_lock_irqsave(&_global_env.lock, flags);
         raw_spin_lock_irqsave(&state->lock, flags);
         now = litmus_clock();
-        sup_update_time(&state->sup_env, now);
+        sup_update_time(state->sup_env, now);
 
 /* 9/20/2015 fix - no ghost job         
         remain_budget = mc2_update_ghost_state(state);
 */      
-        update = state->sup_env.next_scheduler_update;
-        now = state->sup_env.env.current_time;
+        update = state->sup_env->next_scheduler_update;
+        now = state->sup_env->env.current_time;
 
-/* 9/20/2015 fix - no ghost job 
-        if (remain_budget != ULLONG_MAX && update > now + remain_budget) {
-                update = now + remain_budget;
-        }
-        
-        TRACE_CUR("on_scheduling_timer at %llu, upd:%llu (for cpu=%d) g_schedule_now:%d remain_budget:%llu\n", now, update, state->cpu, global_schedule_now, remain_budget);
-*/      
 
         if (update <= now) {
                 litmus_reschedule_local();
@@ -603,8 +562,8 @@ static enum hrtimer_restart on_scheduling_timer(struct hrtimer *timer)
                 restart = HRTIMER_RESTART;
         }
 
-        raw_spin_lock(&_global_env.lock);
-        global_schedule_now = gmp_update_time(&_global_env, now);
+        raw_spin_lock(&global_lock);
+        global_schedule_now = gmp_update_time(_global_env, now);
         
         BUG_ON(global_schedule_now < 0 || global_schedule_now > 4);
         
@@ -622,7 +581,7 @@ static enum hrtimer_restart on_scheduling_timer(struct hrtimer *timer)
                                 reschedule[cpu] = 1;
                 }
         } 
-        raw_spin_unlock(&_global_env.lock);
+        raw_spin_unlock(&global_lock);
         
         raw_spin_unlock_irqrestore(&state->lock, flags);
         //raw_spin_unlock_irqrestore(&_global_env.lock, flags);
@@ -654,8 +613,12 @@ static long mc2_complete_job(void)
         ktime_t next_release;
         long err;
 
+        enum crit_level lv;
+
         tsk_rt(current)->completed = 1;
         
+        lv = get_task_crit_level(current);
+
         /* If this the first job instance, we need to reset replenish
            time to the next release time */
         if (tsk_rt(current)->sporadic_release) {
@@ -664,27 +627,25 @@ static long mc2_complete_job(void)
                 struct mc2_task_state *tinfo;
                 struct reservation *res = NULL;
                 unsigned long flags;
-                enum crit_level lv;
 
                 preempt_disable();
                 local_irq_save(flags);
                 
                 tinfo = get_mc2_state(current);
-                lv = get_task_crit_level(current);
                 
                 if (lv < CRIT_LEVEL_C) {
                         state = cpu_state_for(tinfo->cpu);
                         raw_spin_lock(&state->lock);
-                        env = &(state->sup_env.env);
-                        res = sup_find_by_id(&state->sup_env, tinfo->mc2_param.res_id);
+                        env = &(state->sup_env->env);
+                        res = sup_find_by_id(state->sup_env, tinfo->mc2_param.res_id[mode]);
                         env->time_zero = tsk_rt(current)->sporadic_release_time;
                 }
                 else if (lv == CRIT_LEVEL_C) {
                         state = local_cpu_state();              
                         raw_spin_lock(&state->lock);
-                        raw_spin_lock(&_global_env.lock);
-                        res = gmp_find_by_id(&_global_env, tinfo->mc2_param.res_id);
-                        _global_env.env.time_zero = tsk_rt(current)->sporadic_release_time;
+                        raw_spin_lock(&global_lock);
+                        res = gmp_find_by_id(_global_env, tinfo->mc2_param.res_id[mode]);
+                        _global_env->env.time_zero = tsk_rt(current)->sporadic_release_time;
                 }
                 else
                         BUG();
@@ -704,13 +665,13 @@ static long mc2_complete_job(void)
                 res->cur_budget = 0;
                 res->env->change_state(res->env, res, RESERVATION_DEPLETED);
                 
-                //TRACE_CUR("CHANGE NEXT_REP = %llu NEXT_UPDATE = %llu\n", res->next_replenishment, state->sup_env.next_scheduler_update);
+                //TRACE_CUR("CHANGE NEXT_REP = %llu NEXT_UPDATE = %llu\n", res->next_replenishment, state->sup_env->next_scheduler_update);
                 
                 //if (lv < CRIT_LEVEL_C)
 //                      raw_spin_unlock(&state->lock);
                 //else 
                 if (lv == CRIT_LEVEL_C)
-                        raw_spin_unlock(&_global_env.lock);
+                        raw_spin_unlock(&global_lock);
                 
                 raw_spin_unlock(&state->lock);
                 local_irq_restore(flags);
@@ -724,6 +685,38 @@ static long mc2_complete_job(void)
         next_release = ns_to_ktime(get_release(current));
         preempt_disable();
         TRACE_CUR("next_release=%llu\n", get_release(current));
+
+        /*
+         * Changed logic for mode switch case
+         * In case of mode switch, do not want to release
+         * new job even if release time has passed
+         */
+
+        raw_spin_lock(&mode_lock);
+        if (lv == CRIT_LEVEL_C && mode != requested_mode){
+                struct reservation *res = NULL;
+                res = gmp_find_by_id(_global_env, tsk_mc2_data(current)->res_id[mode]);
+                if (res && !res->reported){
+                        res_reported--;
+                
+                        res->reported = 1;
+                        //Current task doesn't exist in new mode
+                        if ( !in_mode(current, requested_mode)  ){
+                                res->env->change_state(res->env, res, RESERVATION_INACTIVE);
+                                raw_spin_unlock(&mode_lock);
+                                litmus_reschedule_local();
+                        }
+                        //Otherwise schedule normally
+                        else
+                                raw_spin_unlock(&mode_lock);
+                }
+                else
+                        raw_spin_unlock(&mode_lock);
+                 
+        }
+        else
+                raw_spin_unlock(&mode_lock);
+
         if (get_release(current) > litmus_clock()) {
                 /* sleep until next_release */
                 set_current_state(TASK_INTERRUPTIBLE);
@@ -748,7 +741,7 @@ struct task_struct* mc2_dispatch(struct sup_reservation_environment* sup_env, st
 {
         struct reservation *res, *next;
         struct task_struct *tsk = NULL;
-        struct crit_entry *ce;
+        //struct crit_entry *ce;
         enum crit_level lv;
         lt_t time_slice;
 
@@ -761,22 +754,11 @@ struct task_struct* mc2_dispatch(struct sup_reservation_environment* sup_env, st
                                         sup_scheduler_update_after(sup_env, res->cur_budget);
                                         return tsk;
                                 } else {
-                                        ce = &state->crit_entries[lv];
+                                        //ce = &state->crit_entries[lv];
                                         sup_scheduler_update_after(sup_env, res->cur_budget);
                                         res->blocked_by_ghost = 0;
                                         res->is_ghost = NO_CPU;
                                         return tsk;
-/* no ghost jobs
-                                        if (likely(!ce->running)) {
-                                                sup_scheduler_update_after(sup_env, res->cur_budget);
-                                                res->blocked_by_ghost = 0;
-                                                res->is_ghost = NO_CPU;
-                                                return tsk;
-                                        } else {
-                                                res->blocked_by_ghost = 1;
-                                                TRACE_TASK(ce->running, " is GHOST\n");
-                                        }
-*/
                                 }
                         }
                 }
@@ -793,16 +775,7 @@ struct task_struct* mc2_global_dispatch(struct mc2_cpu_state* state)
         enum crit_level lv;
         lt_t time_slice;
         
-        /* no eligible level A or B tasks exists */
-        /* check the ghost job */
-        /*
-        ce = &state->crit_entries[CRIT_LEVEL_C];
-        if (ce->running) {
-                TRACE_TASK(ce->running," is GHOST\n");
-                return NULL;
-        }
-        */
-        list_for_each_entry_safe(res, next, &_global_env.active_reservations, list) {
+        list_for_each_entry_safe(res, next, &_global_env->active_reservations, list) {
                 BUG_ON(!res);
                 if (res->state == RESERVATION_ACTIVE && res->scheduled_on == NO_CPU) {
                         tsk = res->ops->dispatch_client(res, &time_slice);
@@ -810,7 +783,7 @@ struct task_struct* mc2_global_dispatch(struct mc2_cpu_state* state)
                                 lv = get_task_crit_level(tsk);
                                 if (lv == NUM_CRIT_LEVELS) {
 #if BUDGET_ENFORCEMENT_AT_C                     
-                                        gmp_add_event_after(&_global_env, res->cur_budget, res->id, EVENT_DRAIN);
+                                        gmp_add_event_after(_global_env, res->cur_budget, res->id, EVENT_DRAIN);
 #endif
                                         res->event_added = 1;
                                         res->blocked_by_ghost = 0;
@@ -821,7 +794,7 @@ struct task_struct* mc2_global_dispatch(struct mc2_cpu_state* state)
                                         //ce = &state->crit_entries[lv];
                                         //if (likely(!ce->running)) {
 #if BUDGET_ENFORCEMENT_AT_C
-                                                gmp_add_event_after(&_global_env, res->cur_budget, res->id, EVENT_DRAIN);
+                                                gmp_add_event_after(_global_env, res->cur_budget, res->id, EVENT_DRAIN);
 #endif
                                                 res->event_added = 1;
                                                 res->blocked_by_ghost = 0;
@@ -905,16 +878,16 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
         blocks = exists && !is_current_running();
         np = exists && is_np(state->scheduled);
         
-        raw_spin_lock(&_global_env.lock);
+        raw_spin_lock(&global_lock);
         preempt = resched_cpu[state->cpu];
         resched_cpu[state->cpu] = 0;
-        raw_spin_unlock(&_global_env.lock);
+        raw_spin_unlock(&global_lock);
 
         /* update time */
-        state->sup_env.will_schedule = true;
+        state->sup_env->will_schedule = true;
 
         now = litmus_clock();
-        sup_update_time(&state->sup_env, now);
+        sup_update_time(state->sup_env, now);
         /* 9/20/2015 fix */
         //raw_spin_lock(&_global_env.lock);
         //to_schedule = gmp_update_time(&_global_env, now);
@@ -935,28 +908,28 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
         }*/
         if (is_realtime(current) && blocks) {
                 if (get_task_crit_level(current) == CRIT_LEVEL_C)
-                        raw_spin_lock(&_global_env.lock);
+                        raw_spin_lock(&global_lock);
                 task_departs(current, is_completed(current));
                 if (get_task_crit_level(current) == CRIT_LEVEL_C)
-                        raw_spin_unlock(&_global_env.lock);
+                        raw_spin_unlock(&global_lock);
         }
         
         /* figure out what to schedule next */
         if (!np)
-                state->scheduled = mc2_dispatch(&state->sup_env, state);
+                state->scheduled = mc2_dispatch(state->sup_env, state);
 
         if (!state->scheduled) {
-                raw_spin_lock(&_global_env.lock);
-                to_schedule = gmp_update_time(&_global_env, now);
+                raw_spin_lock(&global_lock);
+                to_schedule = gmp_update_time(_global_env, now);
                 state->scheduled = mc2_global_dispatch(state);
                 _lowest_prio_cpu.cpu_entries[state->cpu].will_schedule = false;
                 update_cpu_prio(state);
-                raw_spin_unlock(&_global_env.lock);
+                raw_spin_unlock(&global_lock);
         } else {
-                raw_spin_lock(&_global_env.lock);
+                raw_spin_lock(&global_lock);
                 _lowest_prio_cpu.cpu_entries[state->cpu].will_schedule = false;
                 update_cpu_prio(state);
-                raw_spin_unlock(&_global_env.lock);
+                raw_spin_unlock(&global_lock);
         }
         
         //raw_spin_lock(&_lowest_prio_cpu.lock);
@@ -968,21 +941,21 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
         sched_state_task_picked();
 
         /* program scheduler timer */
-        state->sup_env.will_schedule = false;
+        state->sup_env->will_schedule = false;
                 
         /* NOTE: drops state->lock */
         mc2_update_timer_and_unlock(state);
 
         if (prev != state->scheduled && is_realtime(prev)) {
                 struct mc2_task_state* tinfo = get_mc2_state(prev);
-                struct reservation* res = tinfo->res_info.client.reservation;
+                struct reservation* res = tinfo->res_info[mode].client.reservation;
                 TRACE_TASK(prev, "PREV JOB scheduled_on = P%d\n", res->scheduled_on);
                 res->scheduled_on = NO_CPU;
                 TRACE_TASK(prev, "descheduled.\n");
                 /* if prev is preempted and a global task, find the lowest cpu and reschedule */
                 if (tinfo->has_departed == false && get_task_crit_level(prev) == CRIT_LEVEL_C) {
                         int cpu;
-                        raw_spin_lock(&_global_env.lock);
+                        raw_spin_lock(&global_lock);
                         cpu = get_lowest_prio_cpu(res?res->priority:0);
                         TRACE("LEVEL-C TASK PREEMPTED!! poking CPU %d to reschedule\n", cpu);
                         if (cpu != NO_CPU && _lowest_prio_cpu.cpu_entries[cpu].will_schedule == false) {
@@ -991,12 +964,12 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
                                 resched_cpu[cpu] = 1;
                                 //raw_spin_unlock(&_lowest_prio_cpu.lock);
                         }
-                        raw_spin_unlock(&_global_env.lock);
+                        raw_spin_unlock(&global_lock);
                 }
         }
         
         if (to_schedule != 0) {
-                raw_spin_lock(&_global_env.lock);
+                raw_spin_lock(&global_lock);
                 while (to_schedule--) {
                         int cpu = get_lowest_prio_cpu(0);
                         if (cpu != NO_CPU && _lowest_prio_cpu.cpu_entries[cpu].will_schedule == false) {
@@ -1004,7 +977,7 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
                                 resched_cpu[cpu] = 1;
                         }
                 }
-                raw_spin_unlock(&_global_env.lock);     
+                raw_spin_unlock(&global_lock);  
         }
 
         if (state->scheduled) {
@@ -1078,13 +1051,13 @@ static void mc2_task_resume(struct task_struct  *tsk)
                  * since we might not actually be executing on tinfo->cpu
                  * at the moment. */
                 if (tinfo->cpu != -1) {
-                        sup_update_time(&state->sup_env, litmus_clock());
+                        sup_update_time(state->sup_env, litmus_clock());
                         task_arrives(state, tsk);
                 } else {
-                        raw_spin_lock(&_global_env.lock);
-                        gmp_update_time(&_global_env, litmus_clock());
+                        raw_spin_lock(&global_lock);
+                        gmp_update_time(_global_env, litmus_clock());
                         task_arrives(state, tsk);
-                        raw_spin_unlock(&_global_env.lock);
+                        raw_spin_unlock(&global_lock);
                 }
                         
                 /* 9/20/2015 fix 
@@ -1110,20 +1083,21 @@ static void mc2_task_resume(struct task_struct  *tsk)
  */
 static long mc2_admit_task(struct task_struct *tsk)
 {
-        long err = -ESRCH;
+        long err = 0;
         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)->mc2_data;
         enum crit_level lv;
-        
+        int i;
+                
         if (!tinfo)
                 return -ENOMEM;
 
         if (!mp) {
                 printk(KERN_ERR "mc2_admit_task: criticality level has not been set\n");
-                return err;
+                return -ESRCH;
         }
         
         lv = mp->crit;
@@ -1132,53 +1106,83 @@ static long mc2_admit_task(struct task_struct *tsk)
         if (lv < CRIT_LEVEL_C) {
                 state = cpu_state_for(task_cpu(tsk));
                 raw_spin_lock_irqsave(&state->lock, flags);
+                
+                tinfo->mc2_param.crit = mp->crit;
+                tinfo->cpu = task_cpu(tsk);
+                tinfo->has_departed = true;
 
-                res = sup_find_by_id(&state->sup_env, mp->res_id);
+                for(i = 0; i < NR_MODES; i++){
+                        if (!in_mode(tsk, i)){
+                                //task not present in mode
+                                continue;
+                        }
 
-                /* found the appropriate reservation */
-                if (res) {
-                        TRACE_TASK(tsk, "SUP FOUND RES ID\n");
-                        tinfo->mc2_param.crit = mp->crit;
-                        tinfo->mc2_param.res_id = mp->res_id;
-                
-                        /* initial values */
-                        err = mc2_task_client_init(&tinfo->res_info, &tinfo->mc2_param, tsk, res);
-                        tinfo->cpu = task_cpu(tsk);
-                        tinfo->has_departed = true;
-                        tsk_rt(tsk)->plugin_state = tinfo;
+                        res = sup_find_by_id(&(state->sup_env_modes[i]), mp->res_id[i]);
+        
+                        /* found the appropriate reservation */
+                        if (res) {
+                                TRACE_TASK(tsk, "SUP FOUND RES ID\n");                  
+                                tinfo->mc2_param.res_id[i] = mp->res_id[i];
+                                
+                                /* initial values */
+                                err = err? err:mc2_task_client_init(&tinfo->res_info[i], &tinfo->mc2_param, tsk, res);
+                        }
+                        else{
+                                //failed to find an expected reservation
+                                err = -ESRCH;
+                        }
+                }
 
+                if (!err){
                         /* disable LITMUS^RT's per-thread budget enforcement */
+                        tsk_rt(tsk)->plugin_state = tinfo;
                         tsk_rt(tsk)->task_params.budget_policy = NO_ENFORCEMENT;
                 }
 
+
                 raw_spin_unlock_irqrestore(&state->lock, flags);
         } else if (lv == CRIT_LEVEL_C) {
                 state = local_cpu_state();
                 raw_spin_lock_irqsave(&state->lock, flags);
-                raw_spin_lock(&_global_env.lock);
+                raw_spin_lock(&global_lock);
                 //state = local_cpu_state();
                 
                 //raw_spin_lock(&state->lock);
+        
+                tinfo->mc2_param.crit = mp->crit;
+                tinfo->cpu = -1;
+                tinfo->has_departed = true;
                 
-                res = gmp_find_by_id(&_global_env, mp->res_id);
-
-                /* found the appropriate reservation (or vCPU) */
-                if (res) {
-                        TRACE_TASK(tsk, "GMP FOUND RES ID\n");
-                        tinfo->mc2_param.crit = mp->crit;
-                        tinfo->mc2_param.res_id = mp->res_id;
-                        
-                        /* initial values */
-                        err = mc2_task_client_init(&tinfo->res_info, &tinfo->mc2_param, tsk, res);
-                        tinfo->cpu = -1;
-                        tinfo->has_departed = true;
-                        tsk_rt(tsk)->plugin_state = tinfo;
-
+                for(i = 0; i < NR_MODES; i++){
+                        if (!in_mode(tsk, i)) continue;
+                        res = gmp_find_by_id(_global_env, mp->res_id[mode]);
+
+                        /* found the appropriate reservation (or vCPU) */
+                        if (res) {
+                                TRACE_TASK(tsk, "GMP FOUND RES ID\n");
+                                tinfo->mc2_param.res_id[i] = mp->res_id[i];
+                                
+                                /* initial values */
+                                err = err? err:mc2_task_client_init(&tinfo->res_info[mode], &tinfo->mc2_param, tsk, res);
+        
+                        }
+                }
+                
+                if (!err){
                         /* disable LITMUS^RT's per-thread budget enforcement */
+                        tsk_rt(tsk)->plugin_state = tinfo;
                         tsk_rt(tsk)->task_params.budget_policy = NO_ENFORCEMENT;
+                        raw_spin_lock(&mode_lock);
+                        for(i = 0; i < NR_MODES; i++){
+                                if (in_mode(tsk, i)){
+                                        mode_sizes[i]++;
+                                }
+                        }
+                        raw_spin_unlock(&mode_lock);
+
                 }
 
-                raw_spin_unlock(&_global_env.lock);
+                raw_spin_unlock(&global_lock);
                 raw_spin_unlock_irqrestore(&state->lock, flags);        
         }
         
@@ -1225,11 +1229,11 @@ static void mc2_task_new(struct task_struct *tsk, int on_runqueue,
         raw_spin_lock(&state->lock);
 
         if (lv == CRIT_LEVEL_C) {
-                raw_spin_lock(&_global_env.lock);
-                res = gmp_find_by_id(&_global_env, tinfo->mc2_param.res_id);
+                raw_spin_lock(&global_lock);
+                res = gmp_find_by_id(_global_env, tinfo->mc2_param.res_id[mode]);
         }
         else {
-                res = sup_find_by_id(&state->sup_env, tinfo->mc2_param.res_id);
+                res = sup_find_by_id(state->sup_env, tinfo->mc2_param.res_id[mode]);
         }
         //res = res_find_by_id(state, tinfo->mc2_param.res_id);
         release = res->next_replenishment;
@@ -1238,25 +1242,25 @@ static void mc2_task_new(struct task_struct *tsk, int on_runqueue,
                 /* Assumption: litmus_clock() is synchronized across cores
                  * [see comment in pres_task_resume()] */
                 if (lv == CRIT_LEVEL_C) {
-                        gmp_update_time(&_global_env, litmus_clock());
+                        gmp_update_time(_global_env, litmus_clock());
                         //raw_spin_unlock(&_global_env.lock);
                 }
                 else
-                        sup_update_time(&state->sup_env, litmus_clock());
+                        sup_update_time(state->sup_env, litmus_clock());
                 //mc2_update_time(lv, state, litmus_clock());
                 /* 9/20/2015 fix 
                 mc2_update_ghost_state(state);
                 */
                 task_arrives(state, tsk);
                 if (lv == CRIT_LEVEL_C)
-                        raw_spin_unlock(&_global_env.lock);
+                        raw_spin_unlock(&global_lock);
                 /* NOTE: drops state->lock */
                 TRACE("mc2_new()\n");
                 
                 mc2_update_timer_and_unlock(state);
         } else {
                 if (lv == CRIT_LEVEL_C)
-                        raw_spin_unlock(&_global_env.lock);
+                        raw_spin_unlock(&global_lock);
                 raw_spin_unlock(&state->lock);
                 //raw_spin_unlock(&_global_env.lock);
         }
@@ -1281,24 +1285,18 @@ static long mc2_reservation_destroy(unsigned int reservation_id, int cpu)
         int found = 0;
         //enum crit_level lv = get_task_crit_level(current);
         unsigned long flags;
+        int i;
         
         if (cpu == -1) {
-                /* if the reservation is global reservation */
                 local_irq_save(flags);
+                raw_spin_lock(&global_lock);
+
+                /* if the reservation is global reservation */
                 //state = local_cpu_state();
-                raw_spin_lock(&_global_env.lock);
-                //raw_spin_lock(&state->lock);
+                for(i = 0; i < NR_MODES; i++){
+                        //raw_spin_lock(&state->lock);
                 
-                list_for_each_entry_safe(res, next, &_global_env.depleted_reservations, list) {
-                        if (res->id == reservation_id) {
-                                list_del(&res->list);
-                                kfree(res);
-                                found = 1;
-                                ret = 0;
-                        }
-                }
-                if (!found) {
-                        list_for_each_entry_safe(res, next, &_global_env.inactive_reservations, list) {
+                        list_for_each_entry_safe(res, next, &_global_env->depleted_reservations, list) {
                                 if (res->id == reservation_id) {
                                         list_del(&res->list);
                                         kfree(res);
@@ -1306,51 +1304,48 @@ static long mc2_reservation_destroy(unsigned int reservation_id, int cpu)
                                         ret = 0;
                                 }
                         }
-                }
-                if (!found) {
-                        list_for_each_entry_safe(res, next, &_global_env.active_reservations, list) {
-                                if (res->id == reservation_id) {
-                                        list_del(&res->list);
-                                        kfree(res);
-                                        found = 1;
-                                        ret = 0;
+                        if (!found) {
+                                list_for_each_entry_safe(res, next, &_global_env->inactive_reservations, list) {
+                                        if (res->id == reservation_id) {
+                                                list_del(&res->list);
+                                                kfree(res);
+                                                found = 1;
+                                                ret = 0;
+                                        }
+                                }
+                        }
+                        if (!found) {
+                                list_for_each_entry_safe(res, next, &_global_env->active_reservations, list) {
+                                        if (res->id == reservation_id) {
+                                                list_del(&res->list);
+                                                kfree(res);
+                                                found = 1;
+                                                ret = 0;
+                                        }
                                 }
                         }
-                }
 
-                //raw_spin_unlock(&state->lock);
-                raw_spin_unlock(&_global_env.lock);
+                        //raw_spin_unlock(&state->lock);
+                        if (found) break;
+                }
+                raw_spin_unlock(&global_lock);
                 local_irq_restore(flags);
         } else {
                 /* if the reservation is partitioned reservation */
                 state = cpu_state_for(cpu);
-                local_irq_save(flags);
-                raw_spin_lock(&state->lock);
-                
-        //      res = sup_find_by_id(&state->sup_env, reservation_id);
-                sup_env = &state->sup_env;
-                list_for_each_entry_safe(res, next, &sup_env->depleted_reservations, list) {
-                        if (res->id == reservation_id) {
-/*
-                        if (lv == CRIT_LEVEL_A) {
-                                        struct table_driven_reservation *tdres;
-                                        tdres = container_of(res, struct table_driven_reservation, res);
-                                        kfree(tdres->intervals);
-                        }
-*/
-                                list_del(&res->list);
-                                kfree(res);
-                                found = 1;
-                                ret = 0;
-                        }
-                }
-                if (!found) {
-                        list_for_each_entry_safe(res, next, &sup_env->inactive_reservations, list) {
+                for (i = 0; i < NR_MODES; i++){
+                        local_irq_save(flags);
+                        raw_spin_lock(&state->lock);
+                        
+        //              res = sup_find_by_id(state->sup_env, reservation_id);
+                        sup_env = state->sup_env;
+                        list_for_each_entry_safe(res, next, &sup_env->depleted_reservations, list) {
                                 if (res->id == reservation_id) {
-/*                                      if (lv == CRIT_LEVEL_A) {
-                                                struct table_driven_reservation *tdres;
-                                                tdres = container_of(res, struct table_driven_reservation, res);
-                                                kfree(tdres->intervals);
+/*
+                                        if (lv == CRIT_LEVEL_A) {
+                                                        struct table_driven_reservation *tdres;
+                                                        tdres = container_of(res, struct table_driven_reservation, res);
+                                                        kfree(tdres->intervals);
                                         }
 */
                                         list_del(&res->list);
@@ -1359,26 +1354,43 @@ static long mc2_reservation_destroy(unsigned int reservation_id, int cpu)
                                         ret = 0;
                                 }
                         }
-                }
-                if (!found) {
-                        list_for_each_entry_safe(res, next, &sup_env->active_reservations, list) {
-                                if (res->id == reservation_id) {
-/*                                      if (lv == CRIT_LEVEL_A) {
-                                                struct table_driven_reservation *tdres;
-                                                tdres = container_of(res, struct table_driven_reservation, res);
-                                                kfree(tdres->intervals);
-                                        }
+                        if (!found) {
+                                list_for_each_entry_safe(res, next, &sup_env->inactive_reservations, list) {
+                                        if (res->id == reservation_id) {
+/*                                              if (lv == CRIT_LEVEL_A) {
+                                                        struct table_driven_reservation *tdres;
+                                                        tdres = container_of(res, struct table_driven_reservation, res);
+                                                        kfree(tdres->intervals);
+                                                }
 */
-                                        list_del(&res->list);
-                                        kfree(res);
-                                        found = 1;
-                                        ret = 0;
+                                                list_del(&res->list);
+                                                kfree(res);
+                                                found = 1;
+                                                ret = 0;
+                                        }
+                                }
+                        }
+                        if (!found) {
+                                list_for_each_entry_safe(res, next, &sup_env->active_reservations, list) {
+                                        if (res->id == reservation_id) {
+/*                                              if (lv == CRIT_LEVEL_A) {
+                                                        struct table_driven_reservation *tdres;
+                                                        tdres = container_of(res, struct table_driven_reservation, res);
+                                                        kfree(tdres->intervals);
+                                                }
+*/              
+                                                list_del(&res->list);
+                                                kfree(res);
+                                                found = 1;
+                                                ret = 0;
+                                        }
                                 }
                         }
-                }
 
-                raw_spin_unlock(&state->lock);
-                local_irq_restore(flags);
+                        raw_spin_unlock(&state->lock);
+                        local_irq_restore(flags);
+                        if (found) break;
+                }
         }
         
         TRACE("Rerservation destroyed ret = %d\n", ret);
@@ -1393,8 +1405,9 @@ static void mc2_task_exit(struct task_struct *tsk)
         struct mc2_task_state* tinfo = get_mc2_state(tsk);
         struct mc2_cpu_state *state;
         enum crit_level lv = tinfo->mc2_param.crit;
-        struct crit_entry* ce;
+        //struct crit_entry* ce;
         int cpu;
+        int i;
 
         local_irq_save(flags);
         if (tinfo->cpu != -1)
@@ -1407,9 +1420,9 @@ static void mc2_task_exit(struct task_struct *tsk)
         if (state->scheduled == tsk)
                 state->scheduled = NULL;
 
-        ce = &state->crit_entries[lv];
-        if (ce->running == tsk)
-                ce->running = NULL;
+        //ce = &state->crit_entries[lv];
+        //if (ce->running == tsk)
+        //      ce->running = NULL;
         
         /* remove from queues */
         if (is_running(tsk)) {
@@ -1418,11 +1431,11 @@ static void mc2_task_exit(struct task_struct *tsk)
                 
                 /* update both global and partitioned */
                 if (lv < CRIT_LEVEL_C) {
-                        sup_update_time(&state->sup_env, litmus_clock());
+                        sup_update_time(state->sup_env, litmus_clock());
                 }
                 else if (lv == CRIT_LEVEL_C) {
-                        raw_spin_lock(&_global_env.lock);
-                        gmp_update_time(&_global_env, litmus_clock());
+                        raw_spin_lock(&global_lock);
+                        gmp_update_time(_global_env, litmus_clock());
                         //raw_spin_unlock(&_global_env.lock);
                 }
                 /* 9/20/2015 fix 
@@ -1430,7 +1443,7 @@ static void mc2_task_exit(struct task_struct *tsk)
                 */
                 task_departs(tsk, 0);
                 if (lv == CRIT_LEVEL_C)
-                        raw_spin_unlock(&_global_env.lock);
+                        raw_spin_unlock(&global_lock);
                 
                 /* NOTE: drops state->lock */
                 TRACE("mc2_exit()\n");
@@ -1442,6 +1455,15 @@ static void mc2_task_exit(struct task_struct *tsk)
         }
 
         if (lv == CRIT_LEVEL_C) {
+
+                raw_spin_lock(&mode_lock);
+                for(i = 0; i < NR_MODES; i++){
+                        if ( !(tsk_mc2_data(tsk)->mode_mask & (1<<i)) )
+                                continue;
+                        mode_sizes[i]--;
+                }
+                raw_spin_unlock(&mode_lock);
+
                 for_each_online_cpu(cpu) {
                         state = cpu_state_for(cpu);
                         if (state == local_cpu_state())
@@ -1451,9 +1473,9 @@ static void mc2_task_exit(struct task_struct *tsk)
                         if (state->scheduled == tsk)
                                 state->scheduled = NULL;
                         
-                        ce = &state->crit_entries[lv];
-                        if (ce->running == tsk)
-                                ce->running = NULL;
+                        //ce = &state->crit_entries[lv];
+                        //if (ce->running == tsk)
+                        //      ce->running = NULL;
                         
                         raw_spin_unlock(&state->lock);
                 }
@@ -1474,12 +1496,14 @@ static long create_polling_reservation(
         struct reservation_config *config)
 {
         struct mc2_cpu_state *state;
-        struct reservation* res;
+        int i;
+        //struct reservation* res = NULL;
         struct polling_reservation *pres;
         unsigned long flags;
         int use_edf  = config->priority == LITMUS_NO_PRIORITY;
         int periodic =  res_type == PERIODIC_POLLING;
         long err = -EINVAL;
+        bool resExist = false;
 
         /* sanity checks */
         if (config->polling_params.budget >
@@ -1501,6 +1525,12 @@ static long create_polling_reservation(
                        "offset > period\n", config->id);
                 return -EINVAL;
         }
+        //Added sanity check for mode
+        if (config->mode < 0 || config->mode >= NR_MODES){
+                printk(KERN_ERR "invalid polling reservation (%u): "
+                       "Mode outside range\n", config->id);
+                return -EINVAL;
+        }
 
         /* Allocate before we grab a spin lock.
          * Todo: would be nice to use a core-local allocation.
@@ -1514,9 +1544,15 @@ static long create_polling_reservation(
                 //raw_spin_lock_irqsave(&_global_env.lock, flags);
                 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) {
+                //for the sake of reservation_destroy format, force id's unique across
+                //all modes
+                for(i = 0; i < NR_MODES; i++){
+                        if( sup_find_by_id(&(state->sup_env_modes[i]), config->id) ){
+                                resExist = true;
+                                break;
+                        }
+                }
+                if (!resExist) {
                         polling_reservation_init(pres, use_edf, periodic,
                                 config->polling_params.budget,
                                 config->polling_params.period,
@@ -1531,7 +1567,7 @@ static long create_polling_reservation(
                         }*/
                         if (!use_edf)
                                 pres->res.priority = config->priority;
-                        sup_add_new_reservation(&state->sup_env, &pres->res);
+                        sup_add_new_reservation(&(state->sup_env_modes[config->mode]), &pres->res);
                         err = config->id;
                         TRACE_CUR("reservation created R%d priority : %llu\n", config->id, pres->res.priority);
                 } else {
@@ -1542,10 +1578,16 @@ static long create_polling_reservation(
                 //raw_spin_unlock_irqrestore(&_global_env.lock, flags);
 
         } else {
-                raw_spin_lock_irqsave(&_global_env.lock, flags);
+                raw_spin_lock_irqsave(&global_lock, flags);
                 
-                res = gmp_find_by_id(&_global_env, config->id);
-                if (!res) {
+                //force id's unique across all modes
+                for(i = 0; i < NR_MODES; i++){
+                        if (gmp_find_by_id(&(_global_env_modes[i]), config->id)){
+                                resExist = true;
+                                break;
+                        }
+                }
+                if (!resExist) {
                         polling_reservation_init(pres, use_edf, periodic,
                                 config->polling_params.budget,
                                 config->polling_params.period,
@@ -1557,14 +1599,18 @@ static long create_polling_reservation(
                         pres->res.is_ghost = NO_CPU;
                         if (!use_edf)
                                 pres->res.priority = config->priority;
-                        gmp_add_new_reservation(&_global_env, &pres->res);
+                        gmp_add_new_reservation(&(_global_env_modes[config->mode]), &pres->res);
                         err = config->id;
                 } else {
                         err = -EEXIST;
                 }
-                raw_spin_unlock_irqrestore(&_global_env.lock, flags);           
+                raw_spin_unlock_irqrestore(&global_lock, flags);                
         }
         
+
+        pres->res.reported = 0;
+        pres->res.tsk = config->tsk;
+
         if (err < 0)
                 kfree(pres);
 
@@ -1579,14 +1625,14 @@ static long create_table_driven_reservation(
         struct reservation_config *config)
 {
         struct mc2_cpu_state *state;
-        struct reservation* res;
+        //struct reservation* res = NULL;
         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;
-
+        bool resExist = false;
 
         if (!config->table_driven_params.num_intervals) {
                 printk(KERN_ERR "invalid table-driven reservation (%u): "
@@ -1600,6 +1646,12 @@ static long create_table_driven_reservation(
                 return -EINVAL;
         }
 
+        if (config->mode >= NR_MODES || config->mode < 0){
+                printk(KERN_ERR "invalid table-driven reservation (%u): "
+                       "mode outside of range\n", config->id);
+                return -EINVAL;
+        }
+
         num_slots = config->table_driven_params.num_intervals;
         slots_size = sizeof(slots[0]) * num_slots;
         slots = kzalloc(slots_size, GFP_KERNEL);
@@ -1649,16 +1701,22 @@ static long create_table_driven_reservation(
         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) {
+                
+                //force unique id's across all modes
+                for(i = 0; i < NR_MODES; i++){
+                        if (sup_find_by_id(&(state->sup_env_modes[i]), config->id)){
+                                resExist = true;
+                                break;
+                        }
+                }
+                if (!resExist) {
                         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;
                         td_res->res.blocked_by_ghost = 0;
-                        sup_add_new_reservation(&state->sup_env, &td_res->res);
+                        sup_add_new_reservation(&(state->sup_env_modes[config->mode]), &td_res->res);
                         err = config->id;
                 } else {
                         err = -EEXIST;
@@ -1667,6 +1725,9 @@ static long create_table_driven_reservation(
                 raw_spin_unlock_irqrestore(&state->lock, flags);
         }
 
+        td_res->res.reported = 0;
+        td_res->res.tsk = config->tsk;
+        
         if (err < 0) {
                 kfree(slots);
                 kfree(td_res);
@@ -1747,18 +1808,24 @@ static void mc2_setup_domain_proc(void)
 
 static long mc2_activate_plugin(void)
 {
-        int cpu, lv;
+        int cpu;//, lv;
         struct mc2_cpu_state *state;
         struct cpu_entry *ce;
-
-        gmp_init(&_global_env);
-        raw_spin_lock_init(&_lowest_prio_cpu.lock);
+        int i;
         
+        for(i = 0; i < NR_MODES; i++){
+                gmp_init(&(_global_env_modes[i]));
+        }
+        _global_env = &_global_env_modes[0];
+        
+        raw_spin_lock_init(&_lowest_prio_cpu.lock);
+        raw_spin_lock_init(&mode_lock);
+
         for_each_online_cpu(cpu) {
                 TRACE("Initializing CPU%d...\n", cpu);
 
                 resched_cpu[cpu] = 0;
-                level_a_priorities[cpu] = 0;
+                //level_a_priorities[cpu] = 0;
                 state = cpu_state_for(cpu);
                 ce = &_lowest_prio_cpu.cpu_entries[cpu];
                 
@@ -1771,19 +1838,34 @@ static long mc2_activate_plugin(void)
                 raw_spin_lock_init(&state->lock);
                 state->cpu = cpu;
                 state->scheduled = NULL;
-                for (lv = 0; lv < NUM_CRIT_LEVELS; lv++) {
-                        struct crit_entry *cr_entry = &state->crit_entries[lv];
-                        cr_entry->level = lv;
-                        cr_entry->running = NULL;
+                //for (lv = 0; lv < NUM_CRIT_LEVELS; lv++) {
+                //      struct crit_entry *cr_entry = &state->crit_entries[lv];
+                //      cr_entry->level = lv;
+                //      cr_entry->running = NULL;
+                //}
+                
+                for(i = 0; i < NR_MODES; i++){
+                        sup_init(&(state->sup_env_modes[i]));
                 }
-                sup_init(&state->sup_env);
+                state->sup_env = &(state->sup_env_modes[0]);
 
                 hrtimer_init(&state->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_PINNED);
                 state->timer.function = on_scheduling_timer;
+                state->spin_flag = false;
         }
 
         mc2_setup_domain_proc();
 
+        mode = 0;
+        requested_mode = 0;
+        raw_spinlock_t mode_lock;
+
+        for(i = 0; i < NR_MODES; i++){
+                mode_sizes[i] = 0;
+        }
+        res_reported = 0;
+        cpu_0_spin_flag = false;
+
         return 0;
 }
 
@@ -1810,7 +1892,8 @@ static long mc2_deactivate_plugin(void)
         struct reservation *res;
         struct next_timer_event *event;
         struct cpu_entry *ce;
-        
+        int i;
+
         for_each_online_cpu(cpu) {
                 state = cpu_state_for(cpu);
                 raw_spin_lock(&state->lock);
@@ -1825,72 +1908,77 @@ static long mc2_deactivate_plugin(void)
                 ce->lv = NUM_CRIT_LEVELS;
                 ce->will_schedule = false;
 
-                /* Delete all reservations --- assumes struct reservation
-                 * is prefix of containing struct. */
 
-                while (!list_empty(&state->sup_env.active_reservations)) {
+                for(i = 0; i < NR_MODES; i++){
+                        /* Delete all reservations --- assumes struct reservation
+                         * is prefix of containing struct. */
+                        state->sup_env = &state->sup_env_modes[i];
+                        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);
+        }
+
+        raw_spin_lock(&global_lock);
+        for(i = 0; i < NR_MODES; i++){
+                _global_env = &_global_env_modes[i];
+                while (!list_empty(&_global_env->active_reservations)) {
                         res = list_first_entry(
-                                &state->sup_env.active_reservations,
-                                struct reservation, list);
+                                &_global_env->active_reservations,
+                                        struct reservation, list);
                         list_del(&res->list);
                         kfree(res);
                 }
-
-                while (!list_empty(&state->sup_env.inactive_reservations)) {
+        
+                while (!list_empty(&_global_env->inactive_reservations)) {
                         res = list_first_entry(
-                                &state->sup_env.inactive_reservations,
-                                struct reservation, list);
+                                &_global_env->inactive_reservations,
+                                        struct reservation, list);
                         list_del(&res->list);
                         kfree(res);
                 }
 
-                while (!list_empty(&state->sup_env.depleted_reservations)) {
+                while (!list_empty(&_global_env->depleted_reservations)) {
                         res = list_first_entry(
-                                &state->sup_env.depleted_reservations,
-                                struct reservation, list);
+                                &_global_env->depleted_reservations,
+                                        struct reservation, list);
                         list_del(&res->list);
                         kfree(res);
                 }
-
-                raw_spin_unlock(&state->lock);
-        }
-
-        raw_spin_lock(&_global_env.lock);
         
-        while (!list_empty(&_global_env.active_reservations)) {
-                res = list_first_entry(
-                        &_global_env.active_reservations,
-                                struct reservation, list);
-                list_del(&res->list);
-                kfree(res);
-        }
-
-        while (!list_empty(&_global_env.inactive_reservations)) {
-                res = list_first_entry(
-                        &_global_env.inactive_reservations,
-                                struct reservation, list);
-                list_del(&res->list);
-                kfree(res);
-        }
-
-        while (!list_empty(&_global_env.depleted_reservations)) {
-                res = list_first_entry(
-                        &_global_env.depleted_reservations,
-                                struct reservation, list);
-                list_del(&res->list);
-                kfree(res);
-        }
+                while (!list_empty(&_global_env->next_events)) {
+                        event = list_first_entry(
+                                &_global_env->next_events,
+                                        struct next_timer_event, list);
+                        list_del(&event->list);
+                        kfree(event);
+                }
         
-        while (!list_empty(&_global_env.next_events)) {
-                event = list_first_entry(
-                        &_global_env.next_events,
-                                struct next_timer_event, list);
-                list_del(&event->list);
-                kfree(event);
         }
-        
-        raw_spin_unlock(&_global_env.lock);
-        
+
+        raw_spin_unlock(&global_lock);
         destroy_domain_proc_info(&mc2_domain_proc_info);
         return 0;
 }