Add debugging to Color Queue and fix a bug in color_info_free.

Signed-off-by: Christopher Kenna <cjk@cs.unc.edu>

2 files changed, 51 insertions, 22 deletions

diff --git a/include/litmus/color_queue.h b/include/litmus/color_queue.h
index 80976c539b1..7386b0f569d 100644
--- a/include/litmus/color_queue.h
+++ b/include/litmus/color_queue.h
@@ -11,26 +11,6 @@
  */
 #define COLOR_QUEUE_REQ_SIZE    2048
 
-struct color_queue {
-        struct list_head queue;
-        /* the queue of work */
-
-        int nr_cpus;
-        /* number of CPUs that have outstanding requests */
-
-        int at_barrier;
-        /* number of CPUs that are currently waiting at the barrier */
-
-        int way;
-        /* which way the queue is currently reading in */
-
-        u64 phase;
-        /* monotonically increasing phase. use 64 bits so it doesn't wrap. */
-
-        raw_spinlock_t lock;
-        /* protects the above members */
-};
-
 enum color_queue_request_type {
         COLOR_QUEUE_IDLE,
         /* Not in the queue. */
diff --git a/litmus/color_queue.c b/litmus/color_queue.c
index c266e3aa0da..6543811fd06 100644
--- a/litmus/color_queue.c
+++ b/litmus/color_queue.c
@@ -8,6 +8,36 @@
 #include <litmus/color.h>
 #include <litmus/litmus.h>
 
+/* Uncomment to debug. */
+#define QTRACE(q, fmt, args...) TRACE_CUR("q.phase: %llu  q.way: %d  " \
+                                "q.nr_cpus: %d  q.at_barrier: %d  " fmt, \
+                                q.phase, q.way, q.nr_cpus, q.at_barrier, \
+                                ## args)
+
+#ifndef QTRACE
+#define QTRACE(q, fmt, args...) do { } while (0)
+#endif
+
+struct color_queue {
+        struct list_head queue;
+        /* the queue of work */
+
+        int nr_cpus;
+        /* number of CPUs that have outstanding requests */
+
+        int at_barrier;
+        /* number of CPUs that are currently waiting at the barrier */
+
+        int way;
+        /* which way the queue is currently reading in */
+
+        u64 phase;
+        /* monotonically increasing phase. use 64 bits so it doesn't wrap. */
+
+        raw_spinlock_t lock;
+        /* protects the above members */
+};
+
 struct cpu_entry {
         int phase;
         /* what phase a CPU is in */
@@ -53,6 +83,8 @@ static void cpu_add_work(struct color_queue_request *req)
         struct list_head *new = &req->list;
         list_add_tail(new, &entry->enqueue);
         entry->nr_work++;
+        TRACE_CUR("cpu->nr_work: %d  added work request pointer %p\n",
+                        entry->nr_work, req);
 }
 
 /*
@@ -154,9 +186,11 @@ static void do_work_son(struct color_queue_request *request)
 
         switch (request->request_type) {
                 case COLOR_QUEUE_IDLE:
+                        TRACE_CUR("idle work in the queue!\n");
                         WARN(1, "Idle work in the queue!\n");
                         break;
                 case COLOR_QUEUE_READ:
+                        TRACE_CUR("doing work for CPU %d\n", request->cpu);
                         do_work_read(request);
                         break;
         }
@@ -165,6 +199,7 @@ static void do_work_son(struct color_queue_request *request)
         entry = &per_cpu(cpu_entries, request->cpu);
         raw_spin_lock(&entry->lock);
         entry->nr_work--;
+        TRACE_CUR("after doing work, cpu->nr_work: %d\n", entry->nr_work);
         raw_spin_unlock(&entry->lock);
 
         /* work is done, set it idle */
@@ -183,6 +218,7 @@ static void wait_next_phase(void)
                          * set up the lockdown value and updated the queue phase.
                          */
                         entry->phase = color_queue.phase;
+                        QTRACE(color_queue, "moving on to next phase\n");
                         raw_spin_unlock(&color_queue.lock);
                         return;
                 }
@@ -190,8 +226,11 @@ static void wait_next_phase(void)
                 if (color_queue.nr_cpus == color_queue.at_barrier) {
                         int next_way;
 
+                        QTRACE(color_queue, "everyone reached the barrier\n");
+
                         /* Ready to start the next phase. */
                         if (unlikely(list_empty(&color_queue.queue))) {
+                                QTRACE(color_queue, "The queue was empty (bad)\n");
                                 /* This should not happen! Will loop forever? */
                                 WARN(1, "color queue list was empty!\n");
                                 raw_spin_unlock(&color_queue.lock);
@@ -204,10 +243,12 @@ static void wait_next_phase(void)
                         color_queue.way = next_way;
                         color_queue.at_barrier = 0;
                         color_queue.phase++;
+                        QTRACE(color_queue, "moving on to start on the next way\n");
                         raw_spin_unlock(&color_queue.lock);
                         return;
                 } else {
                         /* Wait for work from the last phase to complete. */
+                        QTRACE(color_queue, "still waiting for others\n");
                         raw_spin_unlock(&color_queue.lock);
                         cpu_relax();
                 }
@@ -230,9 +271,11 @@ static void color_queue_loop(void)
                         raw_spin_lock(&color_queue.lock);
                         color_queue.nr_cpus--;
                         if (0 == color_queue.nr_cpus) {
-                                /* Queue is going idle. Restore lockdown state. */
+                                /* Queue is going idle. Restore lockdown. */
                                 set_lockdown(lockdown_value_idle);
+                                QTRACE(color_queue, "last CPU in queue.\n");
                         }
+                        QTRACE(color_queue, "just left the queue\n");
                         raw_spin_unlock(&color_queue.lock);
                         return;
                 }
@@ -242,6 +285,7 @@ static void color_queue_loop(void)
                 raw_spin_lock(&color_queue.lock);
                 if (unlikely(list_empty(&color_queue.queue))) {
                         /* can this happen? */
+                        QTRACE(color_queue, "color queue was empty?\n");
                         WARN(1, "color queue list was empty...\n");
                         raw_spin_unlock(&color_queue.lock);
                         continue;
@@ -251,11 +295,13 @@ static void color_queue_loop(void)
                 if (color_queue.way == request->color_page_info->way) {
                         /* we're going to do this work */
                         list_del(&request->list);
+                        QTRACE(color_queue, "found a piece of work to do: %p\n", request);
                         raw_spin_unlock(&color_queue.lock);
                         do_work_son(request);
                 } else {
                         /* we need to wait for the next phase */
                         color_queue.at_barrier++;
+                        QTRACE(color_queue, "begins to wait at barrier...\n");
                         raw_spin_unlock(&color_queue.lock);
                         wait_next_phase();
                 }
@@ -269,10 +315,13 @@ static void color_queue_submit_work(void)
 {
         struct cpu_entry *entry = &__get_cpu_var(cpu_entries);
 
+
         raw_spin_lock(&color_queue.lock);
+        QTRACE(color_queue, "start submit work\n");
         entry->phase = color_queue.phase;
         color_queue.nr_cpus++;
         list_splice_tail_init(&entry->enqueue, &color_queue.queue);
+        QTRACE(color_queue, "end submit work\n");
         raw_spin_unlock(&color_queue.lock);
         color_queue_loop();
 }
@@ -293,7 +342,7 @@ void cleanup_color_page_infos(struct list_head *head)
 
         list_for_each_entry_safe(cur, tmp, head, list) {
                 TRACE_CUR("cleanup color_queue_info %p\n", cur);
-                list_del(cur);
+                list_del(&cur->list);
                 kfree(cur);
         }
 }