Deadlock fix

1 files changed, 41 insertions, 47 deletions

diff --git a/litmus/sched_mc2.c b/litmus/sched_mc2.c
index 0c9bb1812367..f8ad5c615e5d 100644
--- a/litmus/sched_mc2.c
+++ b/litmus/sched_mc2.c
@@ -148,8 +148,7 @@ asmlinkage long sys_enact_mode(void)
                 }
                 mode_changed = false;
                 if (pending){ //MCR has entered
-                        local_irq_save(flags);
-                        raw_spin_lock(&state->lock);
+                        raw_spin_lock_irqsave(&state->lock,flags);
                         //TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");
                         raw_spin_lock(&global_lock);
                         raw_spin_lock(&mode_lock);
@@ -256,7 +255,9 @@ asmlinkage long sys_enact_mode(void)
                         //TRACE_CUR("LOCK_MSG: GLOBAL UNLOCK\n");
                         raw_spin_unlock(&global_lock);
                         //raw_spin_unlock(&state->lock);
-                        local_irq_restore(flags);
+                        raw_spin_unlock_irqrestore(&state->lock, flags);
+                        
+                        raw_spin_lock(&state->lock);
                         mc2_update_timer_and_unlock(state);
                 }
                 this_cpu_inc(mode_counter);
@@ -299,8 +300,7 @@ asmlinkage long sys_enact_mode(void)
                         //TRACE("CPU%d mode changed\n",state->cpu);
                         hrtimer_cancel(&state->timer); //stop listening to old mode timers
                         TRACE("Timer is cancelled at %llu. mode-change\n", litmus_clock());
-                        local_irq_save(flags);
-                        raw_spin_lock(&state->lock);
+                        raw_spin_lock_irqsave(&state->lock, flags);
                         state->sup_env = &state->sup_env_modes[mode];
                         list_for_each(pos, &state->sup_env->active_reservations){
                                 res = list_entry(pos, struct reservation, list);
@@ -315,8 +315,9 @@ asmlinkage long sys_enact_mode(void)
                                 release_at(res->tsk, new_mode_basetime);
                         }
                         sup_update_time(state->sup_env, litmus_clock());
-                        //raw_spin_unlock(&state->lock);
-                        local_irq_restore(flags);
+                        raw_spin_unlock_irqrestore(&state->lock, flags);
+                        
+                        raw_spin_lock(&state->lock);
                         mc2_update_timer_and_unlock(state);
                         //local_irq_restore(flags);
         
@@ -1048,7 +1049,7 @@ struct task_struct* mc2_global_dispatch(struct mc2_cpu_state* state)
                 }
         }
         
-        raw_spin_lock(&mode_lock);
+        //raw_spin_lock(&mode_lock);
         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) {
@@ -1069,12 +1070,12 @@ struct task_struct* mc2_global_dispatch(struct mc2_cpu_state* state)
                                 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);
+                                //raw_spin_unlock(&mode_lock);
                                 return tsk;
                         }
                 }
         }
-        raw_spin_unlock(&mode_lock);
+        //raw_spin_unlock(&mode_lock);
         return NULL;
 }
 
@@ -1121,19 +1122,12 @@ static inline void post_schedule(struct task_struct *next, int cpu)
  */
 static struct task_struct* mc2_schedule(struct task_struct * prev)
 {
-        int np, blocks, exists, preempt, to_schedule;
+        int np, blocks, exists, to_schedule;
         /* next == NULL means "schedule background work". */
         lt_t now = litmus_clock();
         struct mc2_cpu_state *state = local_cpu_state();
         
         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);
 
@@ -1273,13 +1267,7 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
         }
 */
         post_schedule(state->scheduled, state->cpu);
-/*
-        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);
         if (state->scheduled) {
                 TRACE_TASK(state->scheduled, "scheduled.\n");
@@ -1331,8 +1319,6 @@ static void mc2_task_resume(struct task_struct  *tsk)
         /* Requeue only if self-suspension was already processed. */
         if (tinfo->has_departed)
         {
-                raw_spin_lock(&state->lock);
-                local_irq_save(flags);
                 /* We don't want to consider jobs before synchronous releases */
                 if (tsk_rt(tsk)->job_params.job_no == 2) {
 /*
@@ -1353,7 +1339,7 @@ static void mc2_task_resume(struct task_struct  *tsk)
                         TRACE_TASK(tsk, "INIT_FINISHED is SET\n");
                         tsk_mc2_data(tsk)->init_finished = 1;
                         atomic_dec(&num_sync_released);
-                        //raw_spin_unlock(&global_lock);
+
                         if (atomic_read(&num_sync_released) == 0) {
                                 lt_t start = tsk_rt(tsk)->sporadic_release_time + INIT_PHASE_LENGTH_NS*(tsk_rt(tsk)->job_params.job_no);
                                 TRACE("INIT_PHASE FINISHED. CHANGE TO MODE 1\n");
@@ -1362,9 +1348,8 @@ static void mc2_task_resume(struct task_struct  *tsk)
                         }
                         TRACE_TASK(tsk, "INIT_FINISHED is SET, num_sync_released decreased to %d\n", atomic_read(&num_sync_released));                  
                 }
+                raw_spin_lock_irqsave(&state->lock, flags);
 
-//              raw_spin_lock(&state->lock);
-//              local_irq_save(flags);
                 /* Assumption: litmus_clock() is synchronized across cores,
                  * since we might not actually be executing on tinfo->cpu
                  * at the moment. */
@@ -1386,7 +1371,9 @@ static void mc2_task_resume(struct task_struct  *tsk)
                 //task_arrives(state, tsk);
                 /* NOTE: drops state->lock */
                 TRACE_TASK(tsk, "mc2_resume()\n");
-                local_irq_restore(flags);
+                raw_spin_unlock_irqrestore(&state->lock, flags);
+
+                raw_spin_lock(&state->lock);
                 mc2_update_timer_and_unlock(state);     
         } else {
                 TRACE_TASK(tsk, "resume event ignored, still scheduled\n");
@@ -1426,9 +1413,9 @@ static long mc2_admit_task(struct task_struct *tsk)
 
         if (lv < CRIT_LEVEL_C) {
                 state = cpu_state_for(task_cpu(tsk));
-                raw_spin_lock(&state->lock);
-                local_irq_save(flags);
-                //raw_spin_lock_irqsave(&state->lock, flags);
+                //local_irq_save(flags);
+                //raw_spin_lock(&state->lock);
+                raw_spin_lock_irqsave(&state->lock, flags);
                 
                 tinfo->mc2_param.crit = mp->crit;
                 tinfo->cpu = task_cpu(tsk);
@@ -1484,15 +1471,15 @@ static long mc2_admit_task(struct task_struct *tsk)
                         cpu_0_task_exist = true;
                 }
                 atomic_inc(&num_sync_released);
-                local_irq_restore(flags);
-                raw_spin_unlock(&state->lock);
-                //raw_spin_unlock_irqrestore(&state->lock, flags);
+                //raw_spin_unlock(&state->lock);
+                //local_irq_restore(flags);
+                raw_spin_unlock_irqrestore(&state->lock, flags);
         } else if (lv == CRIT_LEVEL_C) {
 //              TRACE_TASK(tsk, "Task being admitted is Level C\n");
                 state = local_cpu_state();
-                //raw_spin_lock_irqsave(&state->lock, flags);
-                raw_spin_lock(&state->lock);
-                local_irq_save(flags);
+                raw_spin_lock_irqsave(&state->lock, flags);
+                //local_irq_save(flags);
+                //raw_spin_lock(&state->lock);
                 //state = local_cpu_state();
                 
                 //raw_spin_lock(&state->lock);
@@ -1538,6 +1525,7 @@ static long mc2_admit_task(struct task_struct *tsk)
         
                         }
                 }
+                raw_spin_unlock(&global_lock);
                 
                 if (!err){
                         /* disable LITMUS^RT's per-thread budget enforcement */
@@ -1553,11 +1541,11 @@ static long mc2_admit_task(struct task_struct *tsk)
                         raw_spin_unlock(&mode_lock);
 
                 }
+                
                 atomic_inc(&num_sync_released);
-                raw_spin_unlock(&global_lock);
-                //raw_spin_unlock_irqrestore(&state->lock, flags);      
-                local_irq_restore(flags);
-                raw_spin_unlock(&state->lock);
+                raw_spin_unlock_irqrestore(&state->lock, flags);        
+                //raw_spin_unlock(&state->lock);
+                //local_irq_restore(flags);
         }
         
 
@@ -1603,7 +1591,7 @@ static void mc2_task_new(struct task_struct *tsk, int on_runqueue,
         
         local_irq_save(flags);
         raw_spin_lock(&state->lock);
-
+        
         if (lv == CRIT_LEVEL_C) {
                 //TRACE_CUR("LOCK_MSG: GLOBAL LOCK\n");
                 raw_spin_lock(&global_lock);
@@ -1640,7 +1628,10 @@ static void mc2_task_new(struct task_struct *tsk, int on_runqueue,
                 }
                 /* NOTE: drops state->lock */
                 TRACE("mc2_new()\n");
+                raw_spin_unlock(&state->lock);
+                local_irq_restore(flags);
                 
+                raw_spin_lock(&state->lock);
                 mc2_update_timer_and_unlock(state);
         } else {
                 if (lv == CRIT_LEVEL_C){
@@ -1648,10 +1639,11 @@ static void mc2_task_new(struct task_struct *tsk, int on_runqueue,
                         raw_spin_unlock(&global_lock);
                 }
                 raw_spin_unlock(&state->lock);
-                //raw_spin_unlock(&_global_env.lock);
+                local_irq_restore(flags);
         }
         release = res->next_replenishment;
-        local_irq_restore(flags);
+        
+        //local_irq_restore(flags);
         
         if (!release) {
                 /*TRACE_TASK(tsk, "mc2_task_new() next_release = NULL\n");
@@ -2331,6 +2323,7 @@ static long mc2_activate_plugin(void)
                 ce->will_schedule = false;
 
                 raw_spin_lock_init(&state->lock);
+                printk(KERN_ALERT "CPU%d state->lock %p\n", cpu, &state->lock);
                 state->cpu = cpu;
                 state->scheduled = NULL;
                 //for (lv = 0; lv < NUM_CRIT_LEVELS; lv++) {
@@ -2376,6 +2369,7 @@ static void mc2_finish_switch(struct task_struct *prev)
         if (lv == CRIT_LEVEL_C) {
                 for (cpus = 0; cpus<NR_CPUS; cpus++) {
                         if (resched_cpu[cpus]) {
+                                resched_cpu[cpus] = 0;
                                 litmus_reschedule(cpus);
                         }
                 }