sys_enact_mode fix

1 files changed, 74 insertions, 30 deletions

diff --git a/litmus/sched_mc2.c b/litmus/sched_mc2.c
index 0a42497ef9ff..b2259d0310e1 100644
--- a/litmus/sched_mc2.c
+++ b/litmus/sched_mc2.c
@@ -112,6 +112,7 @@ unsigned int mode_sizes[NR_MODES];
 unsigned int res_reported;
 bool cpu_0_spin_flag;
 bool seen_once;
+bool cpu_0_task_exist;
 #define in_mode(t, modenum)     (tsk_mc2_data(t)->mode_mask & (1 << modenum))
 #define pending                 mode != requested_mode
 #define ready                   !res_reported
@@ -165,6 +166,7 @@ asmlinkage long sys_enact_mode(void)
                                 TRACE("Timer canceled\n");
                                 hrtimer_cancel(&state->timer);//stop listening to old mode timers
                                 mode = requested_mode;
+                                TRACE("Mode has been changed.\n");
                                 _global_env = &_global_env_modes[mode];
                                 //set res->reported for new global tasks
                                 list_for_each(pos, &_global_env->active_reservations){
@@ -190,7 +192,7 @@ asmlinkage long sys_enact_mode(void)
                 //release other CPUs
                 cpu_0_spin_flag = !cpu_0_spin_flag;
         }
-        else{
+        else if (cpu_0_task_exist) {
                 //spin, wait for CPU 0 to stabilize mode decision
                 //before scheduling next hyperperiod
                 if (state->spin_flag)
@@ -199,6 +201,8 @@ asmlinkage long sys_enact_mode(void)
                         while(!cpu_0_spin_flag);
                 state->spin_flag = !state->spin_flag;
         }
+        else
+                return 0;
         //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);
@@ -282,14 +286,16 @@ static void task_departs(struct task_struct *tsk, int job_complete)
 
                 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;
-                sched_trace_task_completion(tsk, 0);
         }
+*/
 /* fix end */
 
         tinfo->has_departed = true;
@@ -307,8 +313,6 @@ static void task_arrives(struct mc2_cpu_state *state, struct task_struct *tsk)
         enum crit_level lv = get_task_crit_level(tsk);
         int i;
 
-        tinfo->has_departed = false;
-
         switch(lv) {
                 case CRIT_LEVEL_A:
                 case CRIT_LEVEL_B:
@@ -321,6 +325,8 @@ static void task_arrives(struct mc2_cpu_state *state, struct task_struct *tsk)
                         break;
         }
 
+        tinfo->has_departed = false;
+
         TRACE_TASK(tsk, "CLIENT ARRIVES at %llu\n", litmus_clock());
         
         for(i = 0; i < NR_MODES; i++){
@@ -331,7 +337,7 @@ static void task_arrives(struct mc2_cpu_state *state, struct task_struct *tsk)
 
                 res->ops->client_arrives(res, client);
         }       
-                
+
         switch(lv) {
                 case CRIT_LEVEL_A:
                 case CRIT_LEVEL_B:
@@ -342,7 +348,7 @@ static void task_arrives(struct mc2_cpu_state *state, struct task_struct *tsk)
                         break;
                 default:
                         break;
-        }       
+        }
 }
 
 /* get_lowest_prio_cpu - return the lowest priority cpu
@@ -882,11 +888,16 @@ static inline void post_schedule(struct task_struct *next, int cpu)
                 return;
 
         lev = get_task_crit_level(next);
+        if (is_mode_poll_task(next))  {
+                lev = MODE_POLL_TASK;
+        }
+
         do_partition(lev, cpu);
-        
+
         switch(lev) {
                 case CRIT_LEVEL_A:
                 case CRIT_LEVEL_B:
+                case MODE_POLL_TASK:
                         TS_SCHED_A_END(next);
                         break;
                 case CRIT_LEVEL_C:
@@ -904,35 +915,33 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
 {
         int np, blocks, exists, preempt, to_schedule;
         /* next == NULL means "schedule background work". */
-        lt_t now;
+        lt_t now = litmus_clock();
         struct mc2_cpu_state *state = local_cpu_state();
         
+        raw_spin_lock(&state->lock);
+
+        raw_spin_lock(&global_lock);
+        preempt = resched_cpu[state->cpu];
+        resched_cpu[state->cpu] = 0;
+        raw_spin_unlock(&global_lock);
+        
         pre_schedule(prev, state->cpu);
 
-        raw_spin_lock(&state->lock);
+        BUG_ON(state->scheduled && state->scheduled != prev);
+        BUG_ON(state->scheduled && !is_realtime(prev));
         
-        //BUG_ON(state->scheduled && state->scheduled != prev);
-        //BUG_ON(state->scheduled && !is_realtime(prev));
-        if (state->scheduled && state->scheduled != prev)
-                printk(KERN_ALERT "BUG1!!!!!!!! %s %s\n", state->scheduled ? (state->scheduled)->comm : "null", prev ? (prev)->comm : "null");
-        if (state->scheduled && !is_realtime(prev))
-                printk(KERN_ALERT "BUG2!!!!!!!! \n");
+        //if (state->scheduled && state->scheduled != prev)
+        //      printk(KERN_ALERT "BUG1!!!!!!!! %s %s\n", state->scheduled ? (state->scheduled)->comm : "null", prev ? (prev)->comm : "null");
+        //if (state->scheduled && !is_realtime(prev))
+        //      printk(KERN_ALERT "BUG2!!!!!!!! \n");
 
         /* (0) Determine state */
         exists = state->scheduled != NULL;
         blocks = exists && !is_current_running();
         np = exists && is_np(state->scheduled);
-        
-        raw_spin_lock(&global_lock);
-        preempt = resched_cpu[state->cpu];
-        resched_cpu[state->cpu] = 0;
-        raw_spin_unlock(&global_lock);
 
         /* update time */
         state->sup_env->will_schedule = true;
-
-        now = litmus_clock();
-
         sup_update_time(state->sup_env, now);
         /* 9/20/2015 fix */
         //raw_spin_lock(&_global_env.lock);
@@ -966,6 +975,13 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
 
         if (!state->scheduled) {
                 raw_spin_lock(&global_lock);
+                state->scheduled = mc2_global_dispatch(state);
+                raw_spin_unlock(&global_lock);
+        }
+        
+        /*
+        if (!state->scheduled) {
+                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;
@@ -977,6 +993,7 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
                 update_cpu_prio(state);
                 raw_spin_unlock(&global_lock);
         }
+        */
         
         //raw_spin_lock(&_lowest_prio_cpu.lock);
         //_lowest_prio_cpu.cpu_entries[state->cpu].will_schedule = false;
@@ -998,7 +1015,8 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
                 struct reservation* res = tinfo->res_info[mode].client.reservation;
                 TRACE_TASK(prev, "PREV JOB scheduled_on = P%d\n", res->scheduled_on);
                 TRACE_TASK(prev, "PREEPT_COUNT %d\n", preempt_count());
-                res->scheduled_on = NO_CPU;
+                if (res)
+                        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) {
@@ -1015,6 +1033,7 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
                         raw_spin_unlock(&global_lock);
                 }
         }
+
         
         if (to_schedule != 0) {
                 raw_spin_lock(&global_lock);
@@ -1028,12 +1047,18 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
                 raw_spin_unlock(&global_lock);  
         }
 
+        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);
+        raw_spin_unlock(&global_lock);
+        
         raw_spin_unlock(&state->lock);
-        if (state->scheduled) {
+/*      if (state->scheduled) {
                 TRACE_TASK(state->scheduled, "scheduled.\n");
         }
-        
-        post_schedule(state->scheduled, state->cpu);
+*/      
         
         return state->scheduled;
 }
@@ -1191,7 +1216,8 @@ static long mc2_admit_task(struct task_struct *tsk)
                         tsk_rt(tsk)->plugin_state = tinfo;
                         tsk_rt(tsk)->task_params.budget_policy = NO_ENFORCEMENT;
                 }
-
+                if (is_mode_poll_task(tsk) && tinfo->cpu == 0)
+                        cpu_0_task_exist = true;
 
                 raw_spin_unlock_irqrestore(&state->lock, flags);
         } else if (lv == CRIT_LEVEL_C) {
@@ -1294,7 +1320,16 @@ static void mc2_task_new(struct task_struct *tsk, int on_runqueue,
                 res = sup_find_by_id(state->sup_env, tinfo->mc2_param.res_id);
         }
 
-        BUG_ON(!res);
+        //BUG_ON(!res);
+        // the current mode doesn't have this task.
+        // do not update timer and set the next release time.
+        if (!res) {
+                task_departs(tsk, 0);
+                if (lv == CRIT_LEVEL_C)
+                        raw_spin_unlock(&global_lock);
+                raw_spin_unlock(&state->lock);
+                return;
+        }
 
         //res = res_find_by_id(state, tinfo->mc2_param.res_id);
         release = res->next_replenishment;
@@ -1492,6 +1527,9 @@ 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);
+                        gmp_update_time(_global_env, litmus_clock());
+                        raw_spin_unlock(&global_lock);
                 }
                 else if (lv == CRIT_LEVEL_C) {
                         raw_spin_lock(&global_lock);
@@ -1542,6 +1580,11 @@ 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;
+        }
         
         kfree(tsk_rt(tsk)->plugin_state);
         tsk_rt(tsk)->plugin_state = NULL;
@@ -1919,6 +1962,7 @@ static long mc2_activate_plugin(void)
         }
         res_reported = 0;
         cpu_0_spin_flag = false;
+        cpu_0_task_exist = false;
 
         return 0;
 }