Fixes some bugs

4 files changed, 39 insertions, 30 deletions

diff --git a/litmus/bank_proc.c b/litmus/bank_proc.c
index 6103611211ce..8ac7e3208a8f 100644
--- a/litmus/bank_proc.c
+++ b/litmus/bank_proc.c
@@ -230,8 +230,8 @@ static int do_add_pages(void)
 
         // until all the page lists contain enough pages 
         //for (i =0; i<5; i++) {
-        for (i=0; i< 1024*100;i++) {
-        //while (smallest_nr_pages() < PAGES_PER_COLOR) {
+        //for (i=0; i< 1024*100;i++) {
+        while (smallest_nr_pages() < PAGES_PER_COLOR) {
        //         printk("smallest = %d\n", smallest_nr_pages());       
                 page = alloc_page(GFP_HIGHUSER_MOVABLE);
             //    page = alloc_pages_exact_node(0, GFP_HIGHUSER_MOVABLE, 0);
diff --git a/litmus/litmus.c b/litmus/litmus.c
index ddb80e1aae12..3cf784b19034 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -474,8 +474,7 @@ asmlinkage long sys_set_page_color(int cpu)
         TRACE_TASK(current, "nr_pages = %d nr_failed = %d\n", nr_pages, nr_failed);
         printk(KERN_INFO "node = %ld, nr_migrated_pages = %d, nr_shared_pages = %d, nr_failed = %d\n", node, nr_pages-nr_not_migrated, nr_failed-2, nr_failed);
         //printk(KERN_INFO "node = %d\n", cpu_to_node(smp_processor_id()));
-        flush_cache(1);
-        
+        //flush_cache(1);
         return ret;
 }
 
diff --git a/litmus/reservation.c b/litmus/reservation.c
index 05cad35e0314..a17343efdbae 100644
--- a/litmus/reservation.c
+++ b/litmus/reservation.c
@@ -625,7 +625,7 @@ int gmp_update_time(
         /* If the time didn't advance, there is nothing to do.
          * This check makes it safe to call sup_advance_time() potentially
          * multiple times (e.g., via different code paths. */
-        //TRACE("(gmp_update_time) now: %llu, current_time: %llu\n", now, gmp_env->env.current_time);
+        TRACE("(gmp_update_time) now: %llu, current_time: %llu\n", now, gmp_env->env.current_time);
         if (unlikely(now <= gmp_env->env.current_time + EPSILON))
                 return 0;
 
diff --git a/litmus/sched_mc2.c b/litmus/sched_mc2.c
index 9949791e2d7a..da91158fc75c 100644
--- a/litmus/sched_mc2.c
+++ b/litmus/sched_mc2.c
@@ -126,13 +126,14 @@ asmlinkage long sys_enact_mode(void)
         struct mc2_cpu_state *state = local_cpu_state();
         struct reservation *res;
         struct list_head *pos;
-        hrtimer_cancel(&state->timer);//stop listening to old mode timers
         //lt_t now = litmus_clock();
+        TRACE_TASK(current, "ENACTING MODE TASK\n");
         if (state->cpu == 0){
                 raw_spin_lock(&global_lock);
                 raw_spin_lock(&mode_lock); 
                 if (pending){ //MCR has entered 
                         if (!seen_once){
+                                TRACE_TASK(current, "NOTICED MCR\n");
                                 sched_trace_request_mode(current);
                                 //clean up jobs that are already done
                                 //after this jobs report themselves
@@ -161,6 +162,8 @@ asmlinkage long sys_enact_mode(void)
                                 seen_once = true;
                         }
                         if( ready ){ //C is throttled
+                                TRACE("Timer canceled\n");
+                                hrtimer_cancel(&state->timer);//stop listening to old mode timers
                                 mode = requested_mode;
                                 _global_env = &_global_env_modes[mode];
                                 //set res->reported for new global tasks
@@ -290,7 +293,7 @@ static void task_departs(struct task_struct *tsk, int job_complete)
 /* fix end */
 
         tinfo->has_departed = true;
-        //TRACE_TASK(tsk, "CLIENT DEPART with budget %llu at %llu\n", res->cur_budget, litmus_clock());
+        TRACE_TASK(tsk, "CLIENT DEPART with budget %llu at %llu\n", res->cur_budget, litmus_clock());
 }
 
 /* task_arrive - put a task into its reservation
@@ -318,7 +321,6 @@ static void task_arrives(struct mc2_cpu_state *state, struct task_struct *tsk)
                         break;
         }
 
-        
         TRACE_TASK(tsk, "CLIENT ARRIVES at %llu\n", litmus_clock());
         
         for(i = 0; i < NR_MODES; i++){
@@ -407,7 +409,7 @@ static void mc2_update_timer_and_unlock(struct mc2_cpu_state *state)
         //enum crit_level lv = get_task_crit_level(state->scheduled);
         struct next_timer_event *event, *next;
         int reschedule[NR_CPUS];
-        
+
         for (cpus = 0; cpus<NR_CPUS; cpus++)
                 reschedule[cpus] = 0;
         
@@ -509,24 +511,21 @@ static void mc2_update_timer_and_unlock(struct mc2_cpu_state *state)
                                hrtimer_active(&state->timer),
                                ktime_to_ns(hrtimer_get_expires(&state->timer)));
                         //litmus_reschedule(state->cpu);
+/*
                         raw_spin_lock(&state->lock);
                         preempt_if_preemptable(state->scheduled, state->cpu);
                         raw_spin_unlock(&state->lock);
                         reschedule[state->cpu] = 0;
+*/                      
                 }
         }
+/*      
         for (cpus = 0; cpus<NR_CPUS; cpus++) {
                 if (reschedule[cpus]) {
                         litmus_reschedule(cpus);
-                        /*
-                        struct mc2_cpu_state *remote_state;
-                        remote_state = cpu_state_for(cpus);
-                        raw_spin_lock(&remote_state->lock);
-                        preempt_if_preemptable(remote_state->scheduled, remote_state->cpu);
-                        raw_spin_unlock(&remote_state->lock);
-                        */
                 }
         }
+*/
 }
 
 /* update_cpu_prio - Update cpu's priority
@@ -606,7 +605,6 @@ static enum hrtimer_restart on_scheduling_timer(struct hrtimer *timer)
 
         raw_spin_lock(&global_lock);
         global_schedule_now = gmp_update_time(_global_env, now);
-        
         BUG_ON(global_schedule_now < 0 || global_schedule_now > 4);
         
         /* Find the lowest cpu, and call reschedule */
@@ -624,7 +622,6 @@ static enum hrtimer_restart on_scheduling_timer(struct hrtimer *timer)
                 }
         } 
         raw_spin_unlock(&global_lock);
-        
         raw_spin_unlock_irqrestore(&state->lock, flags);
         //raw_spin_unlock_irqrestore(&_global_env.lock, flags);
         
@@ -709,7 +706,7 @@ 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);
@@ -911,10 +908,7 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
         struct mc2_cpu_state *state = local_cpu_state();
         
         pre_schedule(prev, state->cpu);
-        
-        /* 9/20/2015 fix
-        raw_spin_lock(&_global_env.lock);
-        */
+
         raw_spin_lock(&state->lock);
         
         //BUG_ON(state->scheduled && state->scheduled != prev);
@@ -938,6 +932,7 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
         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);
@@ -971,7 +966,7 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
 
         if (!state->scheduled) {
                 raw_spin_lock(&global_lock);
-                to_schedule = gmp_update_time(_global_env, now);
+                //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);
@@ -997,12 +992,14 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
         /* NOTE: drops state->lock */
         mc2_update_timer_and_unlock(state);
 
+        raw_spin_lock(&state->lock);
         if (prev != state->scheduled && is_realtime(prev)) {
                 struct mc2_task_state* tinfo = get_mc2_state(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;
-                TRACE_TASK(prev, "descheduled.\n");
+                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;
@@ -1031,6 +1028,7 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
                 raw_spin_unlock(&global_lock);  
         }
 
+        raw_spin_unlock(&state->lock);
         if (state->scheduled) {
                 TRACE_TASK(state->scheduled, "scheduled.\n");
         }
@@ -1051,7 +1049,7 @@ static void resume_legacy_task_model_updates(struct task_struct *tsk)
 
                 now = litmus_clock();
                 if (is_tardy(tsk, now)) {
-                        //release_at(tsk, now);
+                        release_at(tsk, now);
                         //sched_trace_task_release(tsk);
                 }
         }
@@ -1143,17 +1141,20 @@ static long mc2_admit_task(struct task_struct *tsk)
         enum crit_level lv;
         int i;
                 
+        TRACE_TASK(tsk, "MC2 admitting task\n");
         if (!tinfo)
                 return -ENOMEM;
 
         if (!mp) {
                 printk(KERN_ERR "mc2_admit_task: criticality level has not been set\n");
+                TRACE("mc2_admit_task: criticality level has not been set\n");
                 return -ESRCH;
         }
         
         lv = mp->crit;
         preempt_disable();
 
+
         if (lv < CRIT_LEVEL_C) {
                 state = cpu_state_for(task_cpu(tsk));
                 raw_spin_lock_irqsave(&state->lock, flags);
@@ -1162,13 +1163,14 @@ static long mc2_admit_task(struct task_struct *tsk)
                 tinfo->cpu = task_cpu(tsk);
                 tinfo->has_departed = true;
                 tinfo->mc2_param.res_id = mp->res_id;
-                
+                tinfo->mc2_param.mode_mask = mp->mode_mask;
+                TRACE_TASK(tsk, "mode_mask = %x\n", mp->mode_mask);
                 for(i = 0; i < NR_MODES; i++){
                         if (!in_mode(tsk, i)){
                                 //task not present in mode
                                 continue;
                         }
-
+                        TRACE_TASK(tsk, "Mode %d\n",i);
                         res = sup_find_by_id(&(state->sup_env_modes[i]), mp->res_id);
         
                         /* found the appropriate reservation */
@@ -1193,6 +1195,7 @@ static long mc2_admit_task(struct task_struct *tsk)
 
                 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(&global_lock);
@@ -1242,6 +1245,7 @@ static long mc2_admit_task(struct task_struct *tsk)
         if (err)
                 kfree(tinfo);
 
+        TRACE_TASK(tsk, "MC2 task admitted %d\n", err);
         return err;
 }
 
@@ -1258,6 +1262,8 @@ static void mc2_task_new(struct task_struct *tsk, int on_runqueue,
         enum crit_level lv = get_task_crit_level(tsk);
         lt_t release = 0;
 
+        BUG_ON(lv < CRIT_LEVEL_A || lv > CRIT_LEVEL_C);
+
         TRACE_TASK(tsk, "new RT task %llu (on_rq:%d, running:%d)\n",
                    litmus_clock(), on_runqueue, is_running);
 
@@ -1286,6 +1292,9 @@ static void mc2_task_new(struct task_struct *tsk, int on_runqueue,
         else {
                 res = sup_find_by_id(state->sup_env, tinfo->mc2_param.res_id);
         }
+
+        BUG_ON(!res);
+
         //res = res_find_by_id(state, tinfo->mc2_param.res_id);
         release = res->next_replenishment;
         
@@ -1319,7 +1328,7 @@ static void mc2_task_new(struct task_struct *tsk, int on_runqueue,
         
         if (!release) {
                 TRACE_TASK(tsk, "mc2_task_new() next_release = %llu\n", release);
-                //release_at(tsk, release);
+                release_at(tsk, release);
         }
         else
                 TRACE_TASK(tsk, "mc2_task_new() next_release = NULL\n");
@@ -1614,7 +1623,7 @@ static long create_polling_reservation(
                                 pres->res.priority = config->priority;
                         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);
+                        TRACE_CUR("reservation created R%d for mode %d priority : %llu\n", config->id, config->mode, pres->res.priority);
                 } else {
                         err = -EEXIST;
                 }
@@ -1862,6 +1871,7 @@ static long mc2_activate_plugin(void)
         
         raw_spin_lock_init(&_lowest_prio_cpu.lock);
         raw_spin_lock_init(&mode_lock);
+        raw_spin_lock_init(&global_lock);
 
         seen_once = false;