8 files changed, 153 insertions, 41 deletions

diff --git a/litmus/Kconfig b/litmus/Kconfig
index e71f7a332f21..1ba3a1368f68 100644
--- a/litmus/Kconfig
+++ b/litmus/Kconfig
@@ -39,7 +39,7 @@ config PLUGIN_PFAIR
 config MERGE_TIMERS
        bool "Timer-merging Support"
        depends on HIGH_RES_TIMERS
-       default y
+       default n
        help
          Include support for merging timers.
 
diff --git a/litmus/color.c b/litmus/color.c
index 26f800e785ae..c9826dd48ec2 100644
--- a/litmus/color.c
+++ b/litmus/color.c
@@ -16,7 +16,9 @@
 #include <litmus/color.h>
 #include <litmus/litmus.h> /* for in_list(...) */
 #include <litmus/clock.h>
+#ifndef CONFIG_CACHE_PL310
 #include <litmus/color_queue.h>
+#endif
 #include <litmus/way_tracker.h>
 #include <litmus/trace.h>
 
@@ -222,7 +224,13 @@ void reclaim_pages(struct vm_area_struct *vma)
 int color_sched_in_task(struct task_struct *t)
 {
         color_page_info_take_ways(t);
+
+#ifdef CONFIG_CACHE_PL310
+        return color_cache_task(t);
+#else
         return color_queue_enqueue_read(t);
+#endif
+
 }
 
 /*
@@ -231,7 +239,12 @@ int color_sched_in_task(struct task_struct *t)
 int color_sched_out_task(struct task_struct *t)
 {
         color_page_info_release_ways(t);
+
+#ifdef CONFIG_CACHE_PL310
+        return color_uncache_task(t);
+#else
         return color_queue_enqueue_flush(t);
+#endif
 }
 
 asmlinkage long sys_set_color_page_info(struct color_ctrl_page __user *user_color_ctrl)
diff --git a/litmus/color_queue.c b/litmus/color_queue.c
index 0b87217a931a..913b2f317c16 100644
--- a/litmus/color_queue.c
+++ b/litmus/color_queue.c
@@ -456,6 +456,40 @@ out_free:
         return ret;
 }
 
+int color_cache_task(struct task_struct *t)
+{
+        struct color_page_info *info;
+        int npages = 0;
+
+        list_for_each_entry(info, &tsk_rt(t)->color_page_info_list, list) {
+                u32 lvalue = unlocked_way[info->way];
+                color_read_in_mem_lock(lvalue, LOCK_ALL,
+                                       info->vaddr, info->vaddr + PAGE_SIZE);
+                ++npages;
+        }
+
+        return npages;
+}
+
+int color_uncache_task(struct task_struct *t)
+{
+        struct color_page_info *info;
+        int npages = 0;
+
+
+        list_for_each_entry(info, &tsk_rt(t)->color_page_info_list, list) {
+                u32 lvalue  = unlocked_way[info->way];
+                void *vaddr = flusher_pages[info->way][info->color];
+
+                color_read_in_mem_lock(lvalue, LOCK_ALL,
+                                       vaddr, vaddr + PAGE_SIZE);
+
+                ++npages;
+        }
+
+        return npages;
+}
+
 static int __init init_color_queue(void)
 {
         struct cpu_entry *cpu_entry;
diff --git a/litmus/dgl.c b/litmus/dgl.c
index f9cede7ef546..3d6d3201928e 100644
--- a/litmus/dgl.c
+++ b/litmus/dgl.c
@@ -9,12 +9,10 @@
 
 #ifdef DEBUG_DGL
 #define TRACE(fmt, args...) STRACE(fmt, ## args)
-#define STRACE2(fmt, args...) STRACE(fmt, ## args)
 #define TRACE_GREQ(greq, fmt, args...)                                         \
         TRACE("(greq-%s/%llu) " fmt, (greq->task ? greq->task->comm : "greq"), \
               (greq->task ? greq->task->pid : (unsigned long long)greq), ## args)
 #else
-#define STRACE2(fmt, args...) printk(KERN_ERR fmt, ## args)
 #define TRACE(fmt, args...)
 #define TRACE_GREQ(greq, fmt, args...)
 #endif
@@ -72,53 +70,62 @@ static int arr_to_bool(struct dgl *dgl, unsigned long *arr)
         return (ret != 0);
 }
 
-static void print_queue(struct dgl *dgl, struct list_head *list)
+#ifdef DEBUG_DGL
+#define DEBUG_BUF_LEN 10000
+DEFINE_PER_CPU(char *, debug_buf);
+
+static char* print_queue(char *buf, struct dgl *dgl, struct list_head *list)
 {
         struct dgl_req *pos;
         struct dgl_group_req *greq;
 
         list_for_each_entry(pos, list, list) {
                 greq = pos->greq;
-                sched_trace_log_message("(%s-%d:r%d-p%x-b%x)->", greq->task->comm,
+                buf += sprintf(buf, "(%s/%d:r%d-p%x-b%x)->", greq->task->comm,
                                 greq->task->pid, pos->replicas,
-                                greq->need_prio[0],
-                                greq->blocked[0]);
+                                greq->need_prio[0], greq->blocked[0]);
         }
-        sched_trace_log_message("\n");
+        buf += sprintf(buf, "\n");
+
+        return buf;
 }
 
-static void print_resource(struct dgl *dgl, struct dgl_resource *resource)
+static char* print_resource(char *buf, struct dgl *dgl,
+                            struct dgl_resource *resource)
 {
-        STRACE2("\tResource %d, real_free: %d, goal_free: %d\n",
+        buf += sprintf(buf, "\tResource %d, real_free: %d, goal_free: %d\n",
                 resource_id(dgl, resource),
                 resource->real_free,
                 resource->goal_free);
-        STRACE2("\t  acquired: ");
-        print_queue(dgl, &resource->acquired);
-        STRACE2("\t  will_acquire:");
-        print_queue(dgl, &resource->will_acquire);
-        STRACE2("\t  waiting:");
-        print_queue(dgl, &resource->waiting);
-        STRACE2("\t  will_wait:");
-        print_queue(dgl, &resource->will_wait);
+        buf += sprintf(buf, "\t  acquired:");
+        buf  = print_queue(buf, dgl, &resource->acquired);
+        buf += sprintf(buf, "\t  will_acquire:");
+        buf  = print_queue(buf, dgl, &resource->will_acquire);
+        buf += sprintf(buf, "\t  waiting:");
+        buf  = print_queue(buf, dgl, &resource->waiting);
+        buf += sprintf(buf, "\t  will_wait:");
+        buf  = print_queue(buf, dgl, &resource->will_wait);
+        return buf;
 }
 
+
 /*
  * Print stats and queues of every resource to the trace log.
  */
 static void print_state(struct dgl *dgl)
 {
         int i;
+        char *buf, *start;
         struct dgl_resource *resource;
 
-        sched_trace_log_message("\n");
-        STRACE2("\t\tDGL: requests: %d\n", dgl->requests);
+        start = __get_cpu_var(debug_buf);
+        buf   = start + sprintf(start, "\n\t\tDGL: requests: %d\n", dgl->requests);
 
         for (i = 0; i < dgl->num_resources; ++i) {
                 resource = &dgl->resources[i];
 
                 if (!resource) {
-                        STRACE2("\tResource %d is null!\n", i);
+                        buf += sprintf(buf, "\tResource %d is null!\n", i);
                 }
 
                 if (!list_empty(&resource->waiting)    ||
@@ -126,14 +133,16 @@ static void print_state(struct dgl *dgl)
                     !list_empty(&resource->acquired)   ||
                     !list_empty(&resource->will_acquire)) {
 
-                        print_resource(dgl, resource);
+                        buf = print_resource(buf, dgl, resource);
                 }
         }
-        STRACE2("Dump complete\n");
-        sched_trace_log_message("\n");
+
+        buf += sprintf(buf, "Dump complete\n\n");
+
+        BUG_ON(buf - start > DEBUG_BUF_LEN);
+        sched_trace_log_message(start);
 }
 
-#ifdef DEBUG_DGL
 #define BUG_DUMP(dgl, cond)                     \
         do {                                    \
         if (cond) {                             \
@@ -142,10 +151,9 @@ static void print_state(struct dgl *dgl)
                 BUG();                          \
         }} while(0)
 #else
-#define BUG_DUMP(dgl, cond)
+#define BUG_DUMP(dgl, cond) BUG_ON(cond)
 #endif
 
-
 static int higher_prio(struct dgl_group_req *a, struct dgl_group_req *b)
 {
         return (a->priority < b->priority ||
@@ -223,14 +231,14 @@ static int get_lp_replicas(struct dgl *dgl, struct dgl_group_req *greq,
  * Add @req to @list in priority order.
  * @reverse  Reverse priority
  */
-static void add_request(struct list_head *list, struct dgl_req *req,
-                        int reverse)
+static void add_request(struct dgl *dgl, struct list_head *list,
+                        struct dgl_req *req, int reverse)
 {
         struct list_head *last;
         struct dgl_req *acquired;
         struct dgl_group_req *greqa, *greqb;
 
-        BUG_ON(in_list(&req->list));
+        BUG_DUMP(dgl, in_list(&req->list));
 
         last = list;
         list_for_each_entry(acquired, list, list) {
@@ -255,7 +263,7 @@ static void add_request(struct list_head *list, struct dgl_req *req,
 static void add_waiting(struct dgl *dgl, struct list_head *list, struct dgl_req *req)
 {
         BUG_DUMP(dgl, !arr_to_bool(dgl, req->greq->need_prio));
-        add_request(list, req, 0);
+        add_request(dgl, list, req, 0);
 }
 
 /*
@@ -264,7 +272,7 @@ static void add_waiting(struct dgl *dgl, struct list_head *list, struct dgl_req
 static void add_acquired(struct dgl *dgl, struct list_head *list, struct dgl_req *req)
 {
         BUG_DUMP(dgl, arr_to_bool(dgl, req->greq->need_prio));
-        add_request(list, req, 1);
+        add_request(dgl, list, req, 1);
 }
 
 /*
@@ -888,3 +896,21 @@ void dgl_group_req_free(struct dgl_group_req *greq)
         kfree(greq->need_prio);
         kfree(greq->requests);
 }
+
+#ifdef DEBUG_DGL
+static int __init init_dgl_debug(void)
+{
+        int cpu;
+        char **buf;
+
+        for_each_online_cpu(cpu) {
+                buf = &per_cpu(debug_buf, cpu);
+                *buf = kmalloc(DEBUG_BUF_LEN * sizeof(char), GFP_ATOMIC);
+        }
+
+        return 0;
+}
+
+module_init(init_dgl_debug);
+
+#endif
diff --git a/litmus/lockdown.c b/litmus/lockdown.c
index bb93690c00c9..09712554c5b9 100644
--- a/litmus/lockdown.c
+++ b/litmus/lockdown.c
@@ -77,6 +77,7 @@ void litmus_setup_lockdown(void __iomem *base, u32 id)
 #else
 
 static void __iomem *cache_base;
+
 static void __iomem *lockreg_d;
 static void __iomem *lockreg_i;
 static raw_spinlock_t prefetch_lock;
@@ -113,7 +114,11 @@ u32 color_read_in_mem(u32 lock_val, u32 unlock_val, void *start, void *end)
         : [addr] "+r" (start),
           [val] "+r" (v)
         : [end] "r" (end),
+#ifdef CONFIG_CACHE_PL310
+          [cachereg] "r" (ld_d_reg(raw_smp_processor_id())),
+#else
           [cachereg] "r" (lockreg_d),
+#endif
           [lockval] "r" (lock_val)
         : "cc");
 
@@ -137,7 +142,10 @@ u32 color_read_in_mem_lock(u32 lock_val, u32 unlock_val, void *start, void *end)
         unsigned long flags;
         u32 v = 0;
 
+#ifndef CONFIG_CACHE_PL310
         raw_spin_lock_irqsave(&prefetch_lock, flags);
+#endif
+
         __asm__ __volatile__ (
 "       .align 5\n"
 "       str     %[lockval], [%[cachereg]]\n"
@@ -148,11 +156,18 @@ u32 color_read_in_mem_lock(u32 lock_val, u32 unlock_val, void *start, void *end)
         : [addr] "+r" (start),
           [val] "+r" (v)
         : [end] "r" (end),
+#ifdef CONFIG_CACHE_PL310
+          [cachereg] "r" (ld_d_reg(raw_smp_processor_id())),
+#else
           [cachereg] "r" (lockreg_d),
+#endif
           [lockval] "r" (lock_val),
           [unlockval] "r" (unlock_val)
         : "cc");
+
+#ifndef CONFIG_CACHE_PL310
         raw_spin_unlock_irqrestore(&prefetch_lock, flags);
+#endif
 
         return v;
 }
@@ -330,9 +345,16 @@ int litmus_lockdown_proc_handler(struct ctl_table *table, int write,
 
 #define TRIALS 1000
 
+static void sleep_ns(int ns)
+{
+        int i;
+        lt_t start = litmus_clock();
+        for (i = 0; litmus_clock() - start < ns;i++);
+}
+
 static int test_get_cycles_overhead(void)
 {
-        u64 sum = 0, min = (u64)-1, max = 0;
+        u64 avg = 0, min = (u64)-1, max = 0;
         unsigned long flags;
         cycles_t a, b;
         int i;
@@ -342,6 +364,7 @@ static int test_get_cycles_overhead(void)
                 local_irq_save(flags);
                 preempt_disable();
                 a = litmus_get_cycles();
+                sleep_ns(15000);
                 b = litmus_get_cycles();
                 preempt_enable();
                 local_irq_restore(flags);
@@ -350,10 +373,11 @@ static int test_get_cycles_overhead(void)
                         max = diff;
                 if (diff < min)
                         min = diff;
-                sum += diff;
+                avg += div64_u64(diff, TRIALS);
         }
-        printk("cycle test: avg: %llu  min: %llu  max: %llu\n",
-                        div64_u64(sum, TRIALS), min, max);
+        printk("cycle test 15us: avg: %llu  min: %llu  max: %llu\n",
+               avg, min, max);
+
         return 0;
 }
 
@@ -661,7 +685,7 @@ int litmus_test_prefetch_proc_handler(struct ctl_table *table, int write,
 
         free_page((unsigned long)vaddr);
 
-        //test_get_cycles_overhead();
+        test_get_cycles_overhead();
         test_read_in();
 
         return 0;
diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 64de4ef9c466..6edf86935a29 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -30,7 +30,7 @@
 #include <litmus/dgl.h>
 #include <litmus/color.h>
 #include <litmus/way_tracker.h>
-
+#warning "MUST ADD CHECK FOR MAX WAYS"
 struct mc_signal {
         int                     update:1;
         int                     preempt:1;
@@ -58,6 +58,10 @@ struct cpu_entry {
 #endif
 };
 
+#ifndef CONFIG_NP_SECTION
+#error "Need NP section for coloring!"
+#endif
+
 static struct dgl group_lock;
 static raw_spinlock_t dgl_lock;
 
@@ -97,7 +101,6 @@ static int acquire_resources(struct task_struct *t)
 
         BUG_ON(tsk_rt(t)->linked_on == NO_CPU);
 
-
         raw_spin_lock(&dgl_lock);
 
         cpu = tsk_rt(t)->linked_on;
diff --git a/litmus/sched_trace.c b/litmus/sched_trace.c
index f4171fddbbb1..5acb4a48fb6b 100644
--- a/litmus/sched_trace.c
+++ b/litmus/sched_trace.c
@@ -26,7 +26,7 @@
 
 /* Max length for one write --- by TRACE() --- to the buffer. This is used to
  * allocate a per-cpu buffer for printf() formatting. */
-#define MSG_SIZE 255
+#define MSG_SIZE 10000
 
 
 static DEFINE_MUTEX(reader_mutex);
@@ -35,7 +35,7 @@ static DEFINE_KFIFO(debug_buffer, char, LITMUS_TRACE_BUF_SIZE);
 
 
 static DEFINE_RAW_SPINLOCK(log_buffer_lock);
-static DEFINE_PER_CPU(char[MSG_SIZE], fmt_buffer);
+static DEFINE_PER_CPU(char*, fmt_buffer);
 
 /*
  * sched_trace_log_message - Write to the trace buffer (log_buffer)
@@ -230,8 +230,17 @@ static struct sysrq_key_op sysrq_dump_trace_buffer_op = {
 
 static int __init init_sched_trace(void)
 {
+        int cpu;
+        char **buf;
+
+
         printk("Initializing TRACE() device\n");
 
+        for_each_online_cpu(cpu) {
+                buf = &per_cpu(fmt_buffer, cpu);
+                *buf = kmalloc(MSG_SIZE * sizeof(char), GFP_ATOMIC);
+        }
+
 #ifdef CONFIG_MAGIC_SYSRQ
         /* offer some debugging help */
         if (!register_sysrq_key('y', &sysrq_dump_trace_buffer_op))
diff --git a/litmus/way_tracker.c b/litmus/way_tracker.c
index a9e8ef62f37e..ff392ab09c4d 100644
--- a/litmus/way_tracker.c
+++ b/litmus/way_tracker.c
@@ -6,6 +6,7 @@
 #include <linux/bitops.h>
 #include <linux/slab.h>
 #include <linux/list.h>
+#include <linux/kgdb.h>
 
 #include <litmus/litmus.h>
 #include <litmus/color.h>
@@ -38,7 +39,9 @@ static int take_next_way(unsigned int color)
                 clear_bit(idx, &ways[color]);
                 TRACE("Took, now %lu free of color %d\n", hweight_long(ways[color]), color);
         } else {
+                printk(KERN_WARNING "Vury bad\n");
                 /* Seriously bad. */
+                kgdb_breakpoint();
                 BUG();
         }
         raw_spin_unlock(&lock);