Queue bug fixes

7 files changed, 39 insertions, 17 deletions

diff --git a/include/litmus/color_queue.h b/include/litmus/color_queue.h
index 7386b0f569d..62d862c3e2b 100644
--- a/include/litmus/color_queue.h
+++ b/include/litmus/color_queue.h
@@ -9,7 +9,7 @@
  * Size of color queue work in bytes.
  * This should divide the PAGE_SIZE evenly!
  */
-#define COLOR_QUEUE_REQ_SIZE    2048
+#define COLOR_QUEUE_REQ_SIZE    1024
 
 enum color_queue_request_type {
         COLOR_QUEUE_IDLE,
diff --git a/include/litmus/trace.h b/include/litmus/trace.h
index 61332b5f7c5..c0842247ad8 100644
--- a/include/litmus/trace.h
+++ b/include/litmus/trace.h
@@ -129,6 +129,9 @@ feather_callback void save_task_latency(unsigned long event, unsigned long when_
 #define TS_UNLOCK_START                 TIMESTAMP(180)
 #define TS_UNLOCK_END                   TIMESTAMP(181)
 
+/* #define TS_SCHED3_START(t)           TTIMESTAMP(182, t) */
+/* #define TS_SCHED3_END(t)                     TTIMESTAMP(103, t) */
+
 #define TS_SEND_RESCHED_START(c)        CTIMESTAMP(190, c)
 #define TS_SEND_RESCHED_END             DTIMESTAMP(191, TSK_UNKNOWN)
 
diff --git a/litmus/color_queue.c b/litmus/color_queue.c
index a1030f5dc19..78177572da5 100644
--- a/litmus/color_queue.c
+++ b/litmus/color_queue.c
@@ -104,7 +104,7 @@ static void color_page_info_add_work(struct color_page_info *info, void *vaddr_s
         for (i = 0; i < COLOR_REQUESTS_PER_PAGE; i++) {
                 struct color_queue_request *req = &info->requests[i];
                 void *work_vaddr = vaddr_start + i * COLOR_QUEUE_REQ_SIZE;
-                
+
                 WARN(req->request_type != COLOR_QUEUE_IDLE,
                                 "request was not idle!\n");
 
@@ -253,7 +253,7 @@ static void wait_next_phase(void)
                         color_queue.phase++;
                         QTRACE(color_queue, "bumped the phase and way\n");
                         raw_spin_unlock(&color_queue.lock);
-                } if (color_queue.nr_cpus < color_queue.at_barrier) {
+                } else if (color_queue.nr_cpus < color_queue.at_barrier) {
                         BUG();
                 } else {
                         /* Wait for work from the last phase to complete. */
diff --git a/litmus/dgl.c b/litmus/dgl.c
index 983703797ef..7cb13a51e7b 100644
--- a/litmus/dgl.c
+++ b/litmus/dgl.c
@@ -620,8 +620,6 @@ static void will_wait_to_waiting(struct dgl *dgl, struct dgl_group_req *greq)
  */
 static void pull_prio(struct dgl *dgl, struct dgl_resource *resource)
 {
-        int check = 0;
-        unsigned long long check_prio = 0;
         struct dgl_req *next;
         struct dgl_group_req *greq;
         struct list_head *tmp_a, *tmp_b;
@@ -631,8 +629,6 @@ static void pull_prio(struct dgl *dgl, struct dgl_resource *resource)
         while ((next = next_waiting(resource, &tmp_a, &tmp_b, 0))) {
                 greq = next->greq;
 
-                BUG_DUMP(dgl, check_prio && check_prio > greq->priority);
-
                 if (!arr_to_bool(dgl, greq->need_prio)) {
                         if (dgl->acquired[greq->cpu] == greq) {
                                 will_wait_to_acquire(dgl, greq);
@@ -640,9 +636,6 @@ static void pull_prio(struct dgl *dgl, struct dgl_resource *resource)
                                 waiting_to_will_acquire(dgl, greq);
                         }
                 }
-
-                BUG_DUMP(dgl, ++check > dgl->requests);
-                check_prio = greq->priority;
         }
 }
 
@@ -699,6 +692,8 @@ void add_group_req(struct dgl *dgl, struct dgl_group_req *greq, int cpu)
                         }
                 }
         }
+
+        print_state(dgl);
 }
 
 /**
@@ -718,6 +713,7 @@ void update_group_req(struct dgl *dgl, struct dgl_group_req *greq)
 
         BUG_DUMP(dgl, arr_to_bool(dgl, greq->blocked) &&
                  dgl->acquired[greq->cpu] == greq);
+        print_state(dgl);
 }
 
 /**
@@ -775,6 +771,7 @@ void remove_group_req(struct dgl *dgl, struct dgl_group_req *greq)
         }
 
         --dgl->requests;
+        print_state(dgl);
 }
 
 /**
diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 85be5e17ad0..b19d7d208b5 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -28,6 +28,7 @@
 #include <litmus/sched_mc.h>
 #include <litmus/ce_domain.h>
 #include <litmus/dgl.h>
+#include <litmus/color.h>
 
 struct mc_signal {
         int                     update:1;
@@ -983,7 +984,7 @@ static void mc_task_new(struct task_struct *t, int on_rq, int running)
                                  get_exec_cost(t), get_rt_period(t));
         server_init(&tsk_rt(t)->server, -t->pid,
                     &tsk_rt(t)->job_params.job_no,
-                    &tsk_rt(t)->linked_on);
+                    NO_CPU);
         tsk_rt(t)->task_params.budget_policy = PRECISE_ENFORCEMENT;
 
         BUG_ON(!tsk_rt(t)->server.job);
@@ -1071,6 +1072,10 @@ static void mc_task_exit(struct task_struct *task)
         BUG_ON(!is_realtime(task));
         TRACE(TS " RIP\n", TA(task));
 
+        if (tsk_mc_crit(task) == CRIT_LEVEL_B) {
+                color_sched_out_task(task);
+        }
+
         remove_from_all(task);
         if (tsk_rt(task)->scheduled_on != NO_CPU) {
                 per_cpu(cpus, tsk_rt(task)->scheduled_on).scheduled = NULL;
@@ -1275,13 +1280,10 @@ static void process_signals(struct cpu_entry *entry)
  */
 static struct task_struct* mc_schedule(struct task_struct* prev)
 {
-        unsigned long flags;
         int out_of_time, sleep, preempt, exists, blocks, global, lower;
         struct cpu_entry* entry = &__get_cpu_var(cpus);
         struct task_struct *next = NULL;
 
-        local_irq_save(flags);
-
         /* Litmus gave up because it couldn't access the stack of the CPU
          * on which will_schedule was migrating from. Requeue it.
          * This really only happens in VMs
@@ -1302,6 +1304,12 @@ static struct task_struct* mc_schedule(struct task_struct* prev)
                 update_server_time(entry->scheduled);
         }
 
+        if (prev && tsk_mc_crit(prev) == CRIT_LEVEL_B &&
+            is_realtime(prev) && get_rt_job(prev) > 1) {
+                color_sched_out_task(prev);
+        }
+
+
         /* Determine state */
         exists      = entry->scheduled != NULL;
         blocks      = exists && !is_running(entry->scheduled);
@@ -1356,7 +1364,13 @@ static struct task_struct* mc_schedule(struct task_struct* prev)
         }
         entry->will_schedule = next;
 
-        raw_spin_unlock_irqrestore(&entry->lock, flags);
+        raw_spin_unlock(&entry->lock);
+
+        if (next != prev) {
+                if (next && tsk_mc_crit(next) == CRIT_LEVEL_B) {
+                        color_sched_in_task(next);
+                }
+        }
 
         if (next) {
                 tsk_rt(next)->last_exec_time = litmus_clock();
diff --git a/litmus/sched_psn_edf.c b/litmus/sched_psn_edf.c
index b26a5ff439c..05b9a776e2f 100644
--- a/litmus/sched_psn_edf.c
+++ b/litmus/sched_psn_edf.c
@@ -164,6 +164,7 @@ static void job_completion(struct task_struct* t, int forced)
 
         set_rt_flags(t, RT_F_SLEEP);
         prepare_for_next_period(t);
+        setup_user_release(current, get_user_deadline(current));
 }
 
 static void psnedf_tick(struct task_struct *t)
@@ -193,6 +194,7 @@ static void psnedf_tick(struct task_struct *t)
 
 static struct task_struct* psnedf_schedule(struct task_struct * prev)
 {
+        unsigned long flags;
         psnedf_domain_t*        pedf = local_pedf;
         rt_domain_t*            edf  = &pedf->domain;
         struct task_struct*     next;
@@ -273,6 +275,7 @@ static struct task_struct* psnedf_schedule(struct task_struct * prev)
                 TRACE("becoming idle at %llu\n", litmus_clock());
         }
 
+        local_irq_save(flags);
         if (prev && next != prev && is_realtime(prev) && get_rt_job(prev) > 1) {
                 color_sched_out_task(prev);
         }
@@ -280,6 +283,7 @@ static struct task_struct* psnedf_schedule(struct task_struct * prev)
         if (next && next != prev && is_realtime(next)) {
                 color_sched_in_task(next);
         }
+        local_irq_restore(flags);
 
         pedf->scheduled = next;
         sched_state_task_picked();
@@ -366,7 +370,6 @@ static void psnedf_task_block(struct task_struct *t)
 {
         /* only running tasks can block, thus t is in no queue */
         TRACE_TASK(t, "block at %llu, state=%d\n", litmus_clock(), t->state);
-
         BUG_ON(!is_realtime(t));
         BUG_ON(is_queued(t));
 }
@@ -389,7 +392,10 @@ static void psnedf_task_exit(struct task_struct * t)
         TRACE_TASK(t, "RIP, now reschedule\n");
 
         preempt(pedf);
-        raw_spin_unlock_irqrestore(&pedf->slock, flags);
+
+        raw_spin_unlock(&pedf->slock);
+        color_sched_out_task(t);
+        local_irq_restore(flags);
 }
 
 #ifdef CONFIG_LITMUS_LOCKING
diff --git a/litmus/way_tracker.c b/litmus/way_tracker.c
index eb7e1f48d32..6afccc7ea5f 100644
--- a/litmus/way_tracker.c
+++ b/litmus/way_tracker.c
@@ -36,6 +36,7 @@ static int take_next_way(unsigned int color)
         idx = peek_next_way(color);
         if (idx != -1) {
                 clear_bit(idx, &ways[color]);
+                TRACE("Took, now %lu free of color %d\n", hweight_long(ways[color]), color);
         } else {
                 /* Seriously bad. */
                 BUG();
@@ -49,6 +50,7 @@ static void release_way(unsigned int color, int way)
         BUG_ON(way < 0 || way > color_cache_info.ways);
         raw_spin_lock(&lock);
         __set_bit(way, &ways[color]);
+        TRACE("Released, now %lu free of color %d\n", hweight_long(ways[color]), color);
         raw_spin_unlock(&lock);
 }