3 files changed, 163 insertions, 41 deletions

diff --git a/litmus/bank_proc.c b/litmus/bank_proc.c
index 67a5e71c0da7..ed8b6f1df01f 100644
--- a/litmus/bank_proc.c
+++ b/litmus/bank_proc.c
@@ -329,7 +329,7 @@ out_unlock:
 out:
         if( smallest_nr_pages() == 0) {
         //do_add_pages();
-                printk(KERN_ALERT "ERROR(bank_proc.c) = We don't have enough pages in bank_proc.c\n");        
+                //printk(KERN_ALERT "ERROR(bank_proc.c) = We don't have enough pages in bank_proc.c\n");        
         }
 
         return rPage;
diff --git a/litmus/reservation.c b/litmus/reservation.c
index 0d0c4930b872..e3381d631daf 100644
--- a/litmus/reservation.c
+++ b/litmus/reservation.c
@@ -480,6 +480,8 @@ static void gmp_queue_active(
         struct reservation *queued;
         int check_preempt = 1, found = 0;
 
+        TRACE("R%d has been queued on active\n", res->id);
+
         list_for_each(pos, &gmp_env->active_reservations) {
                 queued = list_entry(pos, struct reservation, list);
                 if (queued->priority > res->priority) {
diff --git a/litmus/sched_mc2.c b/litmus/sched_mc2.c
index dabccbc7a0db..3b407bd780d0 100644
--- a/litmus/sched_mc2.c
+++ b/litmus/sched_mc2.c
@@ -90,7 +90,7 @@ struct mc2_cpu_state {
         int cpu;
         struct task_struct* scheduled;
         //struct crit_entry crit_entries[NUM_CRIT_LEVELS];
-        bool spin_flag; //not used on cpu 0
+        //bool spin_flag; //not used on cpu 0
 };
 
 static void mc2_update_timer_and_unlock(struct mc2_cpu_state *state);
@@ -116,12 +116,13 @@ bool cpu_0_spin_flag;
 bool seen_once;
 bool cpu_0_task_exist;
 bool mode_changed;
+bool mode_poll_exited;
 static DEFINE_PER_CPU(unsigned long, mode_counter);
 #define local_mode_counter()    (this_cpu_ptr(&mode_counter))
 #define cpu_0_mode_counter()    (&per_cpu(mode_counter, 0))
 #define in_mode(t, modenum)     (tsk_mc2_data(t)->mode_mask & (1 << modenum))
-#define pending                 mode != requested_mode
-#define ready                   !res_reported
+#define pending                 (mode != requested_mode)
+#define ready                   (!res_reported)
 
 /*
  * To be called from level A task's with period equal to
@@ -135,11 +136,21 @@ asmlinkage long sys_enact_mode(void)
         struct list_head *pos;
         unsigned long flags;
         TRACE_TASK(current, "ENACTING SYSCALL\n");
-        if (state->cpu == 0){
+        if (state->cpu == 0 && !mode_poll_exited){
+                unsigned long *other_cpu_counter;
+                unsigned long cpu0_val = this_cpu_read(mode_counter);
+                int i;
+                for(i = 1; i < NR_CPUS; i++){
+                        other_cpu_counter = &per_cpu(mode_counter, i);
+                        while(cpu0_val == *other_cpu_counter && !mode_poll_exited){
+                                udelay(1);
+                        }
+                }
                 mode_changed = false;
                 local_irq_save(flags);
                 if (pending){ //MCR has entered 
                         raw_spin_lock(&state->lock);
+                        //TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");
                         raw_spin_lock(&global_lock);
                         raw_spin_lock(&mode_lock);
                 
@@ -152,7 +163,7 @@ asmlinkage long sys_enact_mode(void)
                                         res = list_entry(pos, struct reservation, list);
                                         if (tsk_rt(res->tsk)->completed && res->mode == mode && !res->reported){
                                                 res->reported = 1;
-                                                TRACE_CUR("R%d RES_REPORTED_ACTIVE = %d mode %d\n", res->id, res_reported, res->mode);
+                                                TRACE_TASK(res->tsk,"R%d RES_REPORTED_ACTIVE = %d mode %d\n", res->id, res_reported, res->mode);
                                                 res_reported--;
                                         }
                                 }
@@ -160,7 +171,7 @@ asmlinkage long sys_enact_mode(void)
                                         res = list_entry(pos, struct reservation, list);
                                         if (tsk_rt(res->tsk)->completed && res->mode == mode && !res->reported){
                                                 res->reported = 1;
-                                                TRACE_CUR("R%d RES_REPORTED_DEPLETED = %d mode %d\n",res->id, res_reported, res->mode);
+                                                TRACE_TASK(res->tsk,"R%d RES_REPORTED_DEPLETED = %d mode %d\n",res->id, res_reported, res->mode);
                                                 res_reported--;
                                         }
 
@@ -169,12 +180,33 @@ asmlinkage long sys_enact_mode(void)
                                         res = list_entry(pos, struct reservation, list);
                                         if (tsk_rt(res->tsk)->completed && res->mode == mode && !res->reported){
                                                 res->reported = 1;
-                                                TRACE_CUR("R%d RES_REPORTED_INACTIVE = %d mode %d\n", res->id, res_reported, res->mode);
+                                                TRACE_TASK(res->tsk,"R%d RES_REPORTED_INACTIVE = %d mode %d\n", res->id, res_reported, res->mode);
                                                 res_reported--;
                                         }
                                 }
                                 seen_once = true;
                         }
+                        if (seen_once && !(ready)){
+                                TRACE("Mode change waiting on tasks\n");
+                                list_for_each(pos, &_global_env->active_reservations){
+                                        res = list_entry(pos, struct reservation, list);
+                                        if (!res->reported){
+                                                TRACE_TASK(res->tsk, "R%d is ACTIVE LIST with state %d scheduled on %d and hasn't reported\n", res->id, res->state, res->scheduled_on);
+                                        }
+                                }
+                                list_for_each(pos, &_global_env->depleted_reservations){
+                                        res = list_entry(pos, struct reservation, list);
+                                        if (!res->reported){
+                                                TRACE_TASK(res->tsk, "R%d is DEPLETED LIST and hasn't reported\n", res->id);
+                                        }
+                                }
+                                list_for_each(pos, &_global_env->inactive_reservations){
+                                        res = list_entry(pos, struct reservation, list);
+                                        if (!res->reported){
+                                                TRACE_TASK(res->tsk, "R%d is INACTIVE LIST and hasn't reported\n", res->id);
+                                        }
+                                }
+                        }
                         if( ready ){ //C is throttled
                                 lt_t new_mode_basetime = get_release(current);
                                 //TRACE("Timer canceled\n");
@@ -221,6 +253,7 @@ asmlinkage long sys_enact_mode(void)
                                 TRACE("ENACT\n");
                         }
                         raw_spin_unlock(&mode_lock);
+                        //TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");
                         raw_spin_unlock(&global_lock);
                         //raw_spin_unlock(&state->lock);
                         mc2_update_timer_and_unlock(state);
@@ -229,11 +262,15 @@ asmlinkage long sys_enact_mode(void)
                 local_irq_restore(flags);
                 //cpu_0_spin_flag = !cpu_0_spin_flag;
         }
-        else if (cpu_0_task_exist) {
+        else if (!mode_poll_exited) {
+                unsigned long *cpu0_counter = cpu_0_mode_counter();
+                unsigned long my_val;
+                //int timeout = 0;
+                this_cpu_inc(mode_counter);
+                my_val = this_cpu_read(mode_counter);
                 //spin, wait for CPU 0 to stabilize mode decision
                 //before scheduling next hyperperiod
                 //TRACE("CPU%d start spinning. %d\n",state->cpu, mode_changed);
-                unsigned long *cpu0_counter = cpu_0_mode_counter();
 /*
                 if (state->spin_flag) {
                         while(cpu_0_spin_flag)
@@ -245,8 +282,15 @@ asmlinkage long sys_enact_mode(void)
                 }
                 */
                 //TRACE("CPU%d flag check. %d\n",state->cpu, mode_changed);
-                while (*cpu0_counter == this_cpu_read(mode_counter))
+                while (*cpu0_counter < my_val && !mode_poll_exited){
                         udelay(1);
+                        //if (timeout++ > 1000){
+                        //      if (!cpu_0_task_exist){
+                        //              break;
+                        //      }
+                        //      timeout = 0;
+                        //}
+                }
                 TRACE("CPU%d counter check. %d\n",state->cpu, this_cpu_read(mode_counter));
                 local_irq_save(flags);
                 if (mode_changed) {
@@ -275,7 +319,7 @@ asmlinkage long sys_enact_mode(void)
                         //local_irq_restore(flags);
         
                 }
-                this_cpu_write(mode_counter, *cpu0_counter);
+                //this_cpu_write(mode_counter, *cpu0_counter);
                 local_irq_restore(flags);
                 //state->spin_flag = !state->spin_flag;
         }
@@ -301,21 +345,47 @@ asmlinkage long sys_enact_mode(void)
  * Called from non-real time program
  * Protect by exclusive lock to prevent from occuring while mode change is enacted
  */
+
+#define GET_MODE -1
+#define GET_REP -2
+#define GET_SIZE -3
+
 asmlinkage long sys_request_mode(int new_mode){
+        TRACE("Requesting mode %d\n", new_mode);
         preempt_disable();
         raw_spin_lock(&mode_lock);
+        if (new_mode == GET_MODE){
+                int tmp_mode = mode;
+                raw_spin_unlock(&mode_lock);
+                preempt_enable();
+                return tmp_mode;
+        }
+        if (new_mode == GET_REP){
+                int tmp_rep = res_reported;
+                raw_spin_unlock(&mode_lock);
+                preempt_enable();
+                return tmp_rep;
+        }
+        if (new_mode == GET_SIZE){
+                int tmp_size = mode_sizes[mode];
+                raw_spin_unlock(&mode_lock);
+                preempt_enable();
+                return tmp_size;
+        }
         if (pending){
+                TRACE("Request to %d denied due to pending to %d\n", new_mode, requested_mode);
                 raw_spin_unlock(&mode_lock);
                 preempt_enable();
                 return -EAGAIN;
         }
         if (mode == new_mode){
+                TRACE("Request to %d denied becuase I am in that mode already\n", new_mode);
                 raw_spin_unlock(&mode_lock);
                 preempt_enable();
-                return 0;
+                return -EINVAL;
         }
         requested_mode = new_mode;
-        TRACE("MCR received\n");
+        TRACE("MCR received: %d, old:%d\n",requested_mode,mode);
         res_reported = mode_sizes[mode];
         TRACE_CUR("RES_REPORTED = %d\n",res_reported);
         seen_once = false;
@@ -539,6 +609,7 @@ static void mc2_update_timer_and_unlock(struct mc2_cpu_state *state)
          */
         local = local_cpu_state() == state;
 
+        //TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");
         raw_spin_lock(&global_lock);
                 
         list_for_each_entry_safe(event, next, &_global_env->next_events, list) {
@@ -574,6 +645,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. */
+        //TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");
         raw_spin_unlock(&global_lock);
         raw_spin_unlock(&state->lock);
 
@@ -722,8 +794,9 @@ static enum hrtimer_restart on_scheduling_timer(struct hrtimer *timer)
                 restart = HRTIMER_RESTART;
         }
 
+        //TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");
         raw_spin_lock(&global_lock);
-        global_schedule_now = gmp_update_time(_global_env, now);
+        global_schedule_now = gmp_update_time(_global_env, litmus_clock());
         BUG_ON(global_schedule_now < 0 || global_schedule_now > 4);
         
         /* Find the lowest cpu, and call reschedule */
@@ -740,6 +813,7 @@ static enum hrtimer_restart on_scheduling_timer(struct hrtimer *timer)
                                 reschedule[cpu] = 1;
                 }
         } 
+        //TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");
         raw_spin_unlock(&global_lock);
         raw_spin_unlock_irqrestore(&state->lock, flags);
         //raw_spin_unlock(&state->lock);
@@ -808,6 +882,7 @@ static long mc2_complete_job(void)
                         int i;
                         state = local_cpu_state();              
                         raw_spin_lock(&state->lock);
+                        //TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");
                         raw_spin_lock(&global_lock);
                         for (i = 0; i < NR_MODES; i++) {
                                 if (in_mode(current,i) || i == 0) {
@@ -835,9 +910,10 @@ static long mc2_complete_job(void)
                 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);
-                if (lv == CRIT_LEVEL_C)
+                if (lv == CRIT_LEVEL_C){
+                        //TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");
                         raw_spin_unlock(&global_lock);
-                
+                }
                 raw_spin_unlock(&state->lock);
                 local_irq_restore(flags);
         }
@@ -923,6 +999,8 @@ struct task_struct* mc2_dispatch(struct sup_reservation_environment* sup_env, st
                                 } else {
                                         //if (!is_init_finished(tsk)) {
                                         TRACE_TASK(tsk, "num_sync_released = %d, mode = %d\n", num_sync_released, mode);
+                                        if (mode != res->mode)
+                                                TRACE_CUR("Mode does nto match res mode %d\n", res->mode);
 //                                      if (num_sync_released != 0 && mode == 0) {
                                         //ce = &state->crit_entries[lv];
                                         sup_scheduler_update_after(sup_env, res->cur_budget);
@@ -959,6 +1037,7 @@ struct task_struct* mc2_global_dispatch(struct mc2_cpu_state* state)
                 if (res->state == RESERVATION_ACTIVE && res->scheduled_on == NO_CPU) {
                         tsk = res->ops->dispatch_client(res, &time_slice);
                         if (pending && res->reported && !in_mode(tsk, requested_mode)){
+                                TRACE_TASK(tsk, "Rejected because task not in requested mode %d\n", requested_mode);
                                 continue;
                         }
                         if (likely(tsk)) {
@@ -970,7 +1049,8 @@ struct task_struct* mc2_global_dispatch(struct mc2_cpu_state* state)
 #endif
                                 res->event_added = 1;
                                 res->blocked_by_ghost = 0;
-                                res->is_ghost = NO_CPU;
+                                res->is_ghost = NO_CPU; 
+                                TRACE_TASK(res->tsk, "R%d global dispatched on %d\n", res->id, state->cpu);
                                 res->scheduled_on = state->cpu;
                                 raw_spin_unlock(&mode_lock);
                                 return tsk;
@@ -1031,9 +1111,11 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
         
         raw_spin_lock(&state->lock);
 
+        //TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");
         raw_spin_lock(&global_lock);
         preempt = resched_cpu[state->cpu];
         resched_cpu[state->cpu] = 0;
+        //TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");
         raw_spin_unlock(&global_lock);
         
         pre_schedule(prev, state->cpu);
@@ -1073,11 +1155,15 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
                         raw_spin_unlock(&_global_env.lock);
         }*/
         if (is_realtime(current) && blocks) {
-                if (get_task_crit_level(current) == CRIT_LEVEL_C)
+                if (get_task_crit_level(current) == CRIT_LEVEL_C){
+                        //TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");
                         raw_spin_lock(&global_lock);
+                }
                 task_departs(current, is_completed(current));
-                if (get_task_crit_level(current) == CRIT_LEVEL_C)
+                if (get_task_crit_level(current) == CRIT_LEVEL_C){
+                        //TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");
                         raw_spin_unlock(&global_lock);
+                }
         }
         
         /* figure out what to schedule next */
@@ -1085,26 +1171,28 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
                 state->scheduled = mc2_dispatch(state->sup_env, state);
 
         if (!state->scheduled) {
+                //TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");
                 raw_spin_lock(&global_lock);
                 if (is_realtime(prev))
                         gmp_update_time(_global_env, now);
                 state->scheduled = mc2_global_dispatch(state);
+                //TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");
                 raw_spin_unlock(&global_lock);
         }
         
         /*
         if (!state->scheduled) {
-                raw_spin_lock(&global_lock);
+                TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");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_lock);
+                TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");raw_spin_unlock(&global_lock);
         } else {
-                raw_spin_lock(&global_lock);
+                TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");raw_spin_lock(&global_lock);
                 _lowest_prio_cpu.cpu_entries[state->cpu].will_schedule = false;
                 update_cpu_prio(state);
-                raw_spin_unlock(&global_lock);
+                TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");raw_spin_unlock(&global_lock);
         }
         */
         
@@ -1127,13 +1215,14 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
                 struct mc2_task_state* tinfo = get_mc2_state(prev);
                 struct reservation* res = tinfo->res_info[mode].client.reservation;
                 if (res) {
-                        TRACE_TASK(prev, "PREV JOB was scheduled_on = P%d\n", res->scheduled_on);
+                        TRACE_TASK(prev, "PREV JOB of mode %d was scheduled_on = P%d\n", mode, res->scheduled_on);
                         res->scheduled_on = NO_CPU;
                 }
                 TRACE_TASK(prev, "descheduled at %llu.\n", litmus_clock());
                 /* 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;
+                        //TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");
                         raw_spin_lock(&global_lock);
                         cpu = get_lowest_prio_cpu(res?res->priority:LITMUS_NO_PRIORITY);
                         if (cpu != NO_CPU && _lowest_prio_cpu.cpu_entries[cpu].will_schedule == false) {
@@ -1143,13 +1232,14 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
                                 //raw_spin_unlock(&_lowest_prio_cpu.lock);
                                 TRACE("LEVEL-C TASK PREEMPTED!! poking CPU %d to reschedule\n", cpu);
                         }
+                        //TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");
                         raw_spin_unlock(&global_lock);
                 }
         }
 
 /*      
         if (to_schedule != 0) {
-                raw_spin_lock(&global_lock);
+                TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");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) {
@@ -1157,14 +1247,16 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
                                 resched_cpu[cpu] = 1;
                         }
                 }
-                raw_spin_unlock(&global_lock);  
+                TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");raw_spin_unlock(&global_lock);   
         }
 */
         post_schedule(state->scheduled, state->cpu);
 
+        //TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");
         raw_spin_lock(&global_lock);
         _lowest_prio_cpu.cpu_entries[state->cpu].will_schedule = false;
         update_cpu_prio(state);
+        //TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");
         raw_spin_unlock(&global_lock);
         
         raw_spin_unlock(&state->lock);
@@ -1239,8 +1331,10 @@ static void mc2_task_resume(struct task_struct  *tsk)
 */
                         TRACE_TASK(tsk, "INIT_FINISHED is SET\n");
                         tsk_mc2_data(tsk)->init_finished = 1;
+                        //TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");
                         raw_spin_lock(&global_lock);
                         num_sync_released--;
+                        //TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");
                         raw_spin_unlock(&global_lock);
                         TRACE_TASK(tsk, "INIT_FINISHED is SET, num_sync_released decreased to %d\n", num_sync_released);                        
                 }
@@ -1254,9 +1348,11 @@ static void mc2_task_resume(struct task_struct  *tsk)
                         sup_update_time(state->sup_env, litmus_clock());
                         task_arrives(state, tsk);
                 } else {
+                        //TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");
                         raw_spin_lock(&global_lock);
                         gmp_update_time(_global_env, litmus_clock());
                         task_arrives(state, tsk);
+                        //TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");
                         raw_spin_unlock(&global_lock);
                 }
                         
@@ -1363,8 +1459,10 @@ static long mc2_admit_task(struct task_struct *tsk)
                 if (is_mode_poll_task(tsk) && tinfo->cpu == 0) {
                         cpu_0_task_exist = true;
                 }
+                //TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");
                 raw_spin_lock(&global_lock);
                 num_sync_released++;
+                //TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");
                 raw_spin_unlock(&global_lock);
                 local_irq_restore(flags);
                 raw_spin_unlock(&state->lock);
@@ -1390,6 +1488,7 @@ static long mc2_admit_task(struct task_struct *tsk)
                 
 //              TRACE_TASK(tsk, "Mode 0\n");
 
+                //TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");
                 raw_spin_lock(&global_lock);
                 res = gmp_find_by_id(&(_global_env_modes[0]), mp->res_id);
         
@@ -1425,15 +1524,17 @@ static long mc2_admit_task(struct task_struct *tsk)
                         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++){
+                        for(i = 1; i < NR_MODES; i++){
                                 if (in_mode(tsk, i)){
                                         mode_sizes[i]++;
                                 }
                         }
+                        mode_sizes[0]++;
                         raw_spin_unlock(&mode_lock);
 
                 }
                 num_sync_released++;
+                //TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");
                 raw_spin_unlock(&global_lock);
                 //raw_spin_unlock_irqrestore(&state->lock, flags);      
                 local_irq_restore(flags);
@@ -1485,6 +1586,7 @@ static void mc2_task_new(struct task_struct *tsk, int on_runqueue,
         raw_spin_lock(&state->lock);
 
         if (lv == CRIT_LEVEL_C) {
+                //TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");
                 raw_spin_lock(&global_lock);
                 res = gmp_find_by_id(_global_env, tinfo->mc2_param.res_id);
         }
@@ -1513,15 +1615,19 @@ static void mc2_task_new(struct task_struct *tsk, int on_runqueue,
                 mc2_update_ghost_state(state);
                 */
                 task_arrives(state, tsk);
-                if (lv == CRIT_LEVEL_C)
+                if (lv == CRIT_LEVEL_C){
+                        //TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");
                         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)
+                if (lv == CRIT_LEVEL_C){
+                        //TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");
                         raw_spin_unlock(&global_lock);
+                }
                 raw_spin_unlock(&state->lock);
                 //raw_spin_unlock(&_global_env.lock);
         }
@@ -1556,6 +1662,7 @@ static long mc2_reservation_destroy(unsigned int reservation_id, int cpu)
         if (cpu == -1) {
                 struct next_timer_event *event, *e_next;
                 local_irq_save(flags);
+                //TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");
                 raw_spin_lock(&global_lock);
 
                 /* if the reservation is global reservation */
@@ -1603,6 +1710,7 @@ static long mc2_reservation_destroy(unsigned int reservation_id, int cpu)
                         }
                 }
                 
+                //TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");
                 raw_spin_unlock(&global_lock);
                 local_irq_restore(flags);
         } else {
@@ -1709,11 +1817,12 @@ 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());
-/*                      raw_spin_lock(&global_lock);
+/*                      TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");raw_spin_lock(&global_lock);
                         gmp_update_time(_global_env, litmus_clock());
-                        raw_spin_unlock(&global_lock);
+                        TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");raw_spin_unlock(&global_lock);
 */              }
                 else if (lv == CRIT_LEVEL_C) {
+                        //TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");
                         raw_spin_lock(&global_lock);
                         gmp_update_time(_global_env, litmus_clock());
                         //raw_spin_unlock(&_global_env.lock);
@@ -1722,14 +1831,17 @@ static void mc2_task_exit(struct task_struct *tsk)
                 mc2_update_ghost_state(state);
                 */
                 task_departs(tsk, 0);
-                if (lv == CRIT_LEVEL_C)
+                if (lv == CRIT_LEVEL_C){
+                        //TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");
                         raw_spin_unlock(&global_lock);
-                
+                }
                 /* NOTE: drops state->lock */
                 TRACE("mc2_exit()\n");
 
+                //TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");
                 raw_spin_lock(&global_lock);
                 num_sync_released--;
+                //TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");
                 raw_spin_unlock(&global_lock);
                 mc2_update_timer_and_unlock(state);     
         } else {
@@ -1738,6 +1850,7 @@ static void mc2_task_exit(struct task_struct *tsk)
         }
 
         if (lv == CRIT_LEVEL_C) {
+                //TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");
                 raw_spin_lock(&global_lock);
                 raw_spin_lock(&mode_lock);
                 for(i = 0; i < NR_MODES; i++){
@@ -1746,6 +1859,7 @@ static void mc2_task_exit(struct task_struct *tsk)
                         mode_sizes[i]--;
                 }
                 raw_spin_unlock(&mode_lock);
+                //TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");
                 raw_spin_unlock(&global_lock);
 
                 for_each_online_cpu(cpu) {
@@ -1767,9 +1881,10 @@ static void mc2_task_exit(struct task_struct *tsk)
         
         local_irq_restore(flags);
 
-        if (is_mode_poll_task(tsk) && (tinfo->cpu == 0))  {
-                cpu_0_spin_flag = !cpu_0_spin_flag; // release other cpu before exit.
-                cpu_0_task_exist = false;
+        if (is_mode_poll_task(tsk)){// && (tinfo->cpu == 0))  {
+                //cpu_0_spin_flag = !cpu_0_spin_flag; // release other cpu before exit.
+                //cpu_0_task_exist = false;
+                mode_poll_exited = true;
         }
         
         kfree(tsk_rt(tsk)->plugin_state);
@@ -2171,6 +2286,7 @@ static long mc2_activate_plugin(void)
         struct mc2_cpu_state *state;
         struct cpu_entry *ce;
         int i;
+        //unsigned long *cpu_counter;
         
         for(i = 0; i < NR_MODES; i++){
                 gmp_init(&(_global_env_modes[i]));
@@ -2214,11 +2330,14 @@ static long mc2_activate_plugin(void)
 
                 hrtimer_init(&state->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_PINNED);
                 state->timer.function = on_scheduling_timer;
-                state->spin_flag = false;
+                //state->spin_flag = false;
+                this_cpu_write(mode_counter, 0);
         }
 
         mc2_setup_domain_proc();
 
+        mode_poll_exited = false;
+
         mode = 0;
         requested_mode = 0;
 
@@ -2226,8 +2345,8 @@ static long mc2_activate_plugin(void)
                 mode_sizes[i] = 0;
         }
         res_reported = 0;
-        cpu_0_spin_flag = false;
-        cpu_0_task_exist = false;
+        //cpu_0_spin_flag = false;
+        //cpu_0_task_exist = false;
 
         return 0;
 }
@@ -2304,6 +2423,7 @@ static long mc2_deactivate_plugin(void)
                 raw_spin_unlock(&state->lock);
         }
 
+        //TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");
         raw_spin_lock(&global_lock);
         for(i = 0; i < NR_MODES; i++){
                 _global_env = &_global_env_modes[i];
@@ -2341,6 +2461,7 @@ static long mc2_deactivate_plugin(void)
         
         }
         num_sync_released = 0;
+        //TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");
         raw_spin_unlock(&global_lock);
         destroy_domain_proc_info(&mc2_domain_proc_info);
         return 0;
@@ -2368,4 +2489,3 @@ static int __init init_mc2(void)
 }
 
 module_init(init_mc2);
->>>>>>> c0d86034b5c4983e2a142e5f2b1cbde69661db3f