Try and debug the queue.wip-mc

6 files changed, 85 insertions, 35 deletions

diff --git a/litmus/Makefile b/litmus/Makefile
index d63a8eb5128..9ad6260f7ad 100644
--- a/litmus/Makefile
+++ b/litmus/Makefile
@@ -31,10 +31,10 @@ obj-y     = sched_plugin.o litmus.o \
             server.o \
             srp.o \
             sync.o \
-            way_tracker.o
+            way_tracker.o \
+            lockdown.o
 
 obj-$(CONFIG_EXYNOS_MCT) += clock.o
-obj-$(CONFIG_CPU_V7) += lockdown.o
 obj-$(CONFIG_PLUGIN_CEDF) += sched_cedf.o
 obj-$(CONFIG_PLUGIN_PFAIR) += sched_pfair.o
 # obj-$(CONFIG_PLUGIN_COLOR) += sched_color.o
diff --git a/litmus/color_dev.c b/litmus/color_dev.c
index 96e0edc54b2..9edaf0ec7e4 100644
--- a/litmus/color_dev.c
+++ b/litmus/color_dev.c
@@ -93,7 +93,9 @@ static int create_color_page_info(int color, struct page *page)
         }
 
         list_add_tail(&info->list, &tsk_rt(current)->color_page_info_list);
-        TRACE_CUR("Added color_page_info %p to list.\n", info);
+        TRACE_CUR("Added color_page_info %p to list. prev: 0x%p next: 0x%p\n",
+                        info, tsk_rt(current)->color_page_info_list.prev,
+                        tsk_rt(current)->color_page_info_list.next);
 
 out:
         return err;
diff --git a/litmus/color_queue.c b/litmus/color_queue.c
index 6543811fd06..a1030f5dc19 100644
--- a/litmus/color_queue.c
+++ b/litmus/color_queue.c
@@ -99,6 +99,8 @@ static void color_page_info_add_work(struct color_page_info *info, void *vaddr_s
 {
         int i;
 
+        TRACE_CUR("adding work for color_page_info: 0x%p\n", info);
+
         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;
@@ -125,6 +127,10 @@ void color_queue_enqueue_read(struct task_struct *ts)
 {
         struct color_page_info *cur_info;
 
+        TRACE_CUR("enqueue read prev: %p  next: %p\n",
+                        tsk_rt(ts)->color_page_info_list.prev,
+                        tsk_rt(ts)->color_page_info_list.next);
+
         list_for_each_entry(cur_info,
                         &tsk_rt(ts)->color_page_info_list,
                         list)
@@ -218,7 +224,9 @@ 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");
+                        QTRACE(color_queue,
+                                        "cpu->phase: %d advances to a higher phase\n",
+                                        entry->phase);
                         raw_spin_unlock(&color_queue.lock);
                         return;
                 }
@@ -243,9 +251,10 @@ 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");
+                        QTRACE(color_queue, "bumped the phase and way\n");
                         raw_spin_unlock(&color_queue.lock);
-                        return;
+                } if (color_queue.nr_cpus < color_queue.at_barrier) {
+                        BUG();
                 } else {
                         /* Wait for work from the last phase to complete. */
                         QTRACE(color_queue, "still waiting for others\n");
diff --git a/litmus/litmus.c b/litmus/litmus.c
index 070ecefaeac..654815a124b 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -397,6 +397,8 @@ static void reinit_litmus_state(struct task_struct* p, int restore)
         void * ctrl_page_orig = NULL;
 #endif
 
+        TRACE_CUR("restore: %d\n", restore);
+
         if (restore) {
                 /* Safe user-space provided configuration data.
                  * and allocated page. */
@@ -469,8 +471,6 @@ long litmus_admit_task(struct task_struct* tsk)
         tsk_rt(tsk)->heap_node = bheap_node_alloc(GFP_ATOMIC);
         tsk_rt(tsk)->rel_heap = release_heap_alloc(GFP_ATOMIC);
 
-        INIT_LIST_HEAD(&tsk_rt(tsk)->color_page_info_list);
-
         if (!tsk_rt(tsk)->heap_node || !tsk_rt(tsk)->rel_heap) {
                 printk(KERN_WARNING "litmus: no more heap node memory!?\n");
 
diff --git a/litmus/lockdown.c b/litmus/lockdown.c
index f1da7b4145d..bd24b5839bc 100644
--- a/litmus/lockdown.c
+++ b/litmus/lockdown.c
@@ -9,16 +9,70 @@
 #include <linux/math64.h>
 #include <linux/vmalloc.h>
 #include <linux/slab.h>
+#include <linux/sched.h>
 
+#include <litmus/litmus.h>
 #include <litmus/clock.h>
 
+#ifdef CONFIG_CPU_V7
 #include <asm/hardware/cache-l2x0.h>
 #include <asm/cacheflush.h>
+#endif
 
 #include <litmus/color.h>
 #include <litmus/debug_trace.h>
 #include <litmus/lockdown.h>
 
+
+#define MAX_NR_WAYS     16
+
+/*
+ * unlocked_way[i] : allocation can occur in way i
+ *
+ * 0 = allocation can occur in the corresponding way
+ * 1 = allocation cannot occur in the corresponding way
+ */
+u32 unlocked_way[MAX_NR_WAYS]  = {
+        0xFFFFFFFE, /* way 0 unlocked */
+        0xFFFFFFFD,
+        0xFFFFFFFB,
+        0xFFFFFFF7,
+        0xFFFFFFEF, /* way 4 unlocked */
+        0xFFFFFFDF,
+        0xFFFFFFBF,
+        0xFFFFFF7F,
+        0xFFFFFEFF, /* way 8 unlocked */
+        0xFFFFFDFF,
+        0xFFFFFBFF,
+        0xFFFFF7FF,
+        0xFFFFEFFF, /* way 12 unlocked */
+        0xFFFFDFFF,
+        0xFFFFBFFF,
+        0xFFFF7FFF,
+};
+
+#ifndef CONFIG_CPU_V7
+u32 color_read_in_mem(u32 lock_val, u32 unlock_val, void *start, void *end)
+{
+        TRACE_CUR("Dummy read_in_mem: lock_val: 0x%x  unlock_val: 0x%x  "
+                        "start: 0x%p  end: 0x%p\n", lock_val, unlock_val,
+                        start, end);
+        return 0;
+}
+
+void set_lockdown(u32 lockdown_state)
+{
+        TRACE_CUR("Dummy set_lockdown function lockdown_state: 0x%x\n",
+                        lockdown_state);
+}
+
+void litmus_setup_lockdown(void __iomem *base, u32 id)
+{
+        printk("LITMUS^RT Dummy Lockdown\n");
+}
+
+#else
+
 static void __iomem *cache_base;
 static void __iomem *lockreg_d;
 static void __iomem *lockreg_i;
@@ -38,8 +92,6 @@ struct mutex lockdown_proc;
                         void __iomem *__v = cache_base + L2X0_LOCKDOWN_WAY_I_BASE + \
                         __cpu * L2X0_LOCKDOWN_STRIDE; __v; })
 
-#define MAX_NR_WAYS     16
-
 void set_lockdown(u32 lockdown_state)
 {
         writel_relaxed(lockdown_state, lockreg_d);
@@ -91,31 +143,6 @@ void color_flush_page(void *vaddr)
         v7_flush_kern_dcache_area(vaddr, PAGE_SIZE);
 }
 
-/*
- * unlocked_way[i] : allocation can occur in way i
- *
- * 0 = allocation can occur in the corresponding way
- * 1 = allocation cannot occur in the corresponding way
- */
-u32 unlocked_way[MAX_NR_WAYS]  = {
-        0xFFFFFFFE, /* way 0 unlocked */
-        0xFFFFFFFD,
-        0xFFFFFFFB,
-        0xFFFFFFF7,
-        0xFFFFFFEF, /* way 4 unlocked */
-        0xFFFFFFDF,
-        0xFFFFFFBF,
-        0xFFFFFF7F,
-        0xFFFFFEFF, /* way 8 unlocked */
-        0xFFFFFDFF,
-        0xFFFFFBFF,
-        0xFFFFF7FF,
-        0xFFFFEFFF, /* way 12 unlocked */
-        0xFFFFDFFF,
-        0xFFFFBFFF,
-        0xFFFF7FFF,
-};
-
 static void print_lockdown_registers(void)
 {
         int i;
@@ -641,3 +668,5 @@ void litmus_setup_lockdown(void __iomem *base, u32 id)
 
         test_lockdown(NULL);
 }
+
+#endif
diff --git a/litmus/sched_psn_edf.c b/litmus/sched_psn_edf.c
index 4e117be9546..b26a5ff439c 100644
--- a/litmus/sched_psn_edf.c
+++ b/litmus/sched_psn_edf.c
@@ -23,6 +23,8 @@
 #include <litmus/sched_trace.h>
 #include <litmus/trace.h>
 
+#include <litmus/color.h>
+
 typedef struct {
         rt_domain_t             domain;
         int                     cpu;
@@ -271,6 +273,14 @@ static struct task_struct* psnedf_schedule(struct task_struct * prev)
                 TRACE("becoming idle at %llu\n", litmus_clock());
         }
 
+        if (prev && next != prev && is_realtime(prev) && get_rt_job(prev) > 1) {
+                color_sched_out_task(prev);
+        }
+
+        if (next && next != prev && is_realtime(next)) {
+                color_sched_in_task(next);
+        }
+
         pedf->scheduled = next;
         sched_state_task_picked();
         raw_spin_unlock(&pedf->slock);