fix

3 files changed, 66 insertions, 82 deletions

diff --git a/litmus/cache_proc.c b/litmus/cache_proc.c
index 4f7fc0043b01..68b451deede1 100644
--- a/litmus/cache_proc.c
+++ b/litmus/cache_proc.c
@@ -192,24 +192,24 @@ static inline void cache_sync(void)
         cache_wait(base + L2X0_CACHE_SYNC, 1);
 }
 
-static void print_lockdown_registers(void)
+static void print_lockdown_registers(int cpu)
 {
         int i;
-
         //for (i = 0; i < nr_lockregs; i++) {
         for (i = 0; i < 4; i++) {
-                printk("Lockdown Data CPU %2d: 0x%04x\n",
+                printk("P%d Lockdown Data CPU %2d: 0x%04x\n", cpu,
                                 i, readl_relaxed(ld_d_reg(i)));
-                printk("Lockdown Inst CPU %2d: 0x%04x\n",
+                printk("P%d Lockdown Inst CPU %2d: 0x%04x\n", cpu,
                                 i, readl_relaxed(ld_i_reg(i)));
         }
 }
 
 static void test_lockdown(void *ignore)
 {
-        int i;
+        int i, cpu;
 
-        printk("Start lockdown test on CPU %d.\n", smp_processor_id());
+        cpu = smp_processor_id();
+        printk("Start lockdown test on CPU %d.\n", cpu);
 
         for (i = 0; i < nr_lockregs; i++) {
                 printk("CPU %2d data reg: 0x%8p\n", i, ld_d_reg(i));
@@ -217,7 +217,7 @@ static void test_lockdown(void *ignore)
         }
 
         printk("Lockdown initial state:\n");
-        print_lockdown_registers();
+        print_lockdown_registers(cpu);
         printk("---\n");
 
         for (i = 0; i < nr_lockregs; i++) {
@@ -225,7 +225,7 @@ static void test_lockdown(void *ignore)
                 writel_relaxed(2, ld_i_reg(i));
         }
         printk("Lockdown all data=1 instr=2:\n");
-        print_lockdown_registers();
+        print_lockdown_registers(cpu);
         printk("---\n");
 
         for (i = 0; i < nr_lockregs; i++) {
@@ -233,7 +233,7 @@ static void test_lockdown(void *ignore)
                 writel_relaxed(((1 << 8) >> i), ld_i_reg(i));
         }
         printk("Lockdown varies:\n");
-        print_lockdown_registers();
+        print_lockdown_registers(cpu);
         printk("---\n");
 
         for (i = 0; i < nr_lockregs; i++) {
@@ -241,7 +241,7 @@ static void test_lockdown(void *ignore)
                 writel_relaxed(UNLOCK_ALL, ld_i_reg(i));
         }
         printk("Lockdown all zero:\n");
-        print_lockdown_registers();
+        print_lockdown_registers(cpu);
 
         printk("End lockdown test.\n");
 }
@@ -273,12 +273,14 @@ int way_partition_handler(struct ctl_table *table, int write, void __user *buffe
                 size_t *lenp, loff_t *ppos)
 {
         int ret = 0, i;
+        unsigned long flags;
         
         mutex_lock(&lockdown_proc);
         
         //flush_cache_all();
         //cache_sync();
-        l2x0_flush_all();
+        //l2x0_flush_all();
+        flush_cache();
         
         ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
         if (ret)
@@ -296,8 +298,10 @@ int way_partition_handler(struct ctl_table *table, int write, void __user *buffe
                                        i * L2X0_LOCKDOWN_STRIDE);
                 }
         }
-        print_lockdown_registers();
-
+        
+        local_irq_save(flags);
+        print_lockdown_registers(smp_processor_id());
+        local_irq_restore(flags);
 out:
         mutex_unlock(&lockdown_proc);
         return ret;
@@ -307,6 +311,7 @@ int lock_all_handler(struct ctl_table *table, int write, void __user *buffer,
                 size_t *lenp, loff_t *ppos)
 {
         int ret = 0, i;
+        unsigned long flags;
         
         mutex_lock(&lockdown_proc);
         
@@ -355,8 +360,9 @@ int lock_all_handler(struct ctl_table *table, int write, void __user *buffer,
 */
         }
         printk("LOCK_ALL HANDLER\n");
-        print_lockdown_registers();
-
+        local_irq_save(flags);
+        print_lockdown_registers(smp_processor_id());
+        local_irq_restore(flags);
 out:
         mutex_unlock(&lockdown_proc);
         return ret;
@@ -383,27 +389,28 @@ void mem_lock(u32 lock_val, int cpu)
 void do_partition(enum crit_level lv, int cpu)
 {
         u32 regs;
-        //unsigned long flags;
+        unsigned long flags;
         
         if (lock_all || !use_part)
                 return;
+        raw_spin_lock_irqsave(&cache_lock, flags);
         switch(lv) {
                 case CRIT_LEVEL_A:
                         regs = ~way_partitions[cpu*2];
-                        regs |= 0xffff0000;
+                        //regs |= 0xffff0000;
                         writel_relaxed(regs, ld_d_reg(cpu));
                         writel_relaxed(regs, ld_i_reg(cpu));
                         break;
                 case CRIT_LEVEL_B:
                         regs = ~way_partitions[cpu*2+1];
-                        regs |= 0xffff0000;
+                        //regs |= 0xffff0000;
                         writel_relaxed(regs, ld_d_reg(cpu));
                         writel_relaxed(regs, ld_i_reg(cpu));
                         break;
                 case CRIT_LEVEL_C:
                 case NUM_CRIT_LEVELS:
                         regs = ~way_partitions[8];
-                        regs |= 0xffff0000;
+                        //regs |= 0xffff0000;
                         writel_relaxed(regs, ld_d_reg(cpu));
                         writel_relaxed(regs, ld_i_reg(cpu));
                         break;
@@ -411,33 +418,16 @@ void do_partition(enum crit_level lv, int cpu)
                         BUG();
 
         }
+/*      
+        printk(KERN_INFO "P%d lockdown on P%d\n", smp_processor_id(), cpu);
+        printk(KERN_INFO "CRIT_LEVEL %d\n", lv);
+        print_lockdown_registers(smp_processor_id());
+*/      
+        raw_spin_unlock_irqrestore(&cache_lock, flags);
         //cache_sync();
 //      barrier();
 //      mem_lock(regs, cpu);
-//      barrier();              
-        //print_lockdown_registers();
-/*
-        if (use_set_partition == 1 && use_way_partition == 1)
-                printk(KERN_ALERT "BOTH SET, WAY ARE SET!!!!\n");
-        
-        if (use_way_partition == 1) {
-                if (lv < CRIT_LEVEL_C) {
-                        writel_relaxed(way_partitions[cpu], ld_d_reg(cpu));
-                        writel_relaxed(way_partitions[cpu], ld_i_reg(cpu));
-                } else {
-                        writel_relaxed(way_partitions[4], ld_d_reg(cpu));
-                        writel_relaxed(way_partitions[4], ld_i_reg(cpu));
-                }
-        } else if (use_set_partition == 1) {
-                if (lv < CRIT_LEVEL_C) {
-                        writel_relaxed(set_partitions[0], ld_d_reg(cpu));
-                        writel_relaxed(set_partitions[0], ld_i_reg(cpu));
-                } else {
-                        writel_relaxed(set_partitions[1], ld_d_reg(cpu));
-                        writel_relaxed(set_partitions[1], ld_i_reg(cpu));
-                }
-        }
-*/
+//      barrier();
 }
 
 int use_part_proc_handler(struct ctl_table *table, int write, void __user *buffer,
@@ -491,21 +481,21 @@ void inline enter_irq_mode(void)
 {
         int cpu = smp_processor_id();
 
-        return;
+        //return;
         prev_lockdown_i_reg[cpu] = readl_relaxed(ld_i_reg(cpu));
         prev_lockdown_d_reg[cpu] = readl_relaxed(ld_d_reg(cpu));
         
         if (os_isolation == 0)
                 return; 
         
-        writel_relaxed(prev_lockdown_i_reg[4], ld_i_reg(cpu));
-        writel_relaxed(prev_lockdown_d_reg[4], ld_d_reg(cpu));
+        writel_relaxed(way_partitions[8], ld_i_reg(cpu));
+        writel_relaxed(way_partitions[8], ld_d_reg(cpu));
 }
 
 void inline exit_irq_mode(void)
 {
         int cpu = smp_processor_id();
-        return;
+        //return;
         if (os_isolation == 0)
                 return;
 
@@ -1011,26 +1001,19 @@ out_free:
 
 void flush_cache(void)
 {
-/*      int *dummy;
-        
-        flush_cache_all();
-        int size = 128, i, t = 0;
-        
-        dummy = kmalloc(PAGE_SIZE*size, GFP_KERNEL);
-        for (i = 0; i<PAGE_SIZE*size/sizeof(int); i++) {
-                dummy[i] = t++;
-        }
-        
-        kfree(dummy);
-*/      
-        int way, color, i;
+        int way, color, cpu;
+        unsigned long flags;
         
-        for (i = 0; i < nr_lockregs; i++) {
-                prev_lbm_i_reg[i] = readl_relaxed(ld_i_reg(i));
-                prev_lbm_d_reg[i] = readl_relaxed(ld_d_reg(i));
-        }
+        raw_spin_lock_irqsave(&cache_lock, flags);
+        cpu = raw_smp_processor_id();
         
+        prev_lbm_i_reg[cpu] = readl_relaxed(ld_i_reg(cpu));
+        prev_lbm_d_reg[cpu] = readl_relaxed(ld_d_reg(cpu));
+        //printk("P%d reg value = 0x%04x\n", cpu, prev_lbm_d_reg[cpu]);
         for (way=0;way<MAX_NR_WAYS;way++) {
+                if ( (0x00000001 << way) & (prev_lbm_d_reg[cpu]) )
+                        continue;
+                //printk("P%d flushes way #%d\n", cpu, way);
                 for (color=0;color<MAX_NR_COLORS;color++) {
                         void *vaddr = flusher_pages[way][color];
                         u32 lvalue  = unlocked_way[way];
@@ -1040,10 +1023,9 @@ void flush_cache(void)
 
         }
 
-        for (i = 0; i < nr_lockregs; i++) {
-                writel_relaxed(prev_lbm_i_reg[i], ld_i_reg(i));
-                writel_relaxed(prev_lbm_d_reg[i], ld_d_reg(i));
-        }       
+        writel_relaxed(prev_lbm_i_reg[cpu], ld_i_reg(cpu));
+        writel_relaxed(prev_lbm_d_reg[cpu], ld_d_reg(cpu));
+        raw_spin_unlock_irqrestore(&cache_lock, flags);
 }
 
 #define TRIALS 1000
@@ -1148,8 +1130,6 @@ static int __init litmus_sysctl_init(void)
                 goto out;
         }
 
-        //setup_flusher_array();
-        printk(KERN_INFO "Setup flush_array.\n");
         way_partition_min = 0x00000000;
         way_partition_max = 0x0000FFFF;
         os_isolation = 0;
diff --git a/litmus/litmus.c b/litmus/litmus.c
index 70342e717fe0..569290545480 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -27,6 +27,7 @@
 #include <litmus/litmus_proc.h>
 #include <litmus/clock.h>
 #include <litmus/cache_proc.h>
+#include <litmus/mc2_common.h>
 
 #include <asm/cacheflush.h>
 
@@ -394,6 +395,8 @@ extern struct page *new_alloc_page(struct page *page, unsigned long node, int **
 
 #endif
 
+//static raw_spinlock_t migrate_lock;
+
 asmlinkage long sys_set_page_color(int cpu)
 {
         long ret = 0;
@@ -401,10 +404,12 @@ asmlinkage long sys_set_page_color(int cpu)
         struct vm_area_struct *vma_itr = NULL;
         int nr_pages = 0, nr_shared_pages = 0, nr_failed = 0;
         unsigned long node;
+        enum crit_level lv;
                 
         LIST_HEAD(pagelist);
         LIST_HEAD(shared_pagelist);
         
+        
         down_read(&current->mm->mmap_sem);
         TRACE_TASK(current, "SYSCALL set_page_color\n");
         vma_itr = current->mm->mmap;
@@ -466,10 +471,11 @@ asmlinkage long sys_set_page_color(int cpu)
 //      }
         
         ret = 0;
+        lv = tsk_rt(current)->mc2_data->crit;
         if (cpu == -1)
                 node = 8;
         else
-                node = cpu;
+                node = cpu*2 + lv;
 
         //node= 0;
         if (!list_empty(&pagelist)) {
@@ -492,13 +498,13 @@ asmlinkage long sys_set_page_color(int cpu)
         }
 
         up_read(&current->mm->mmap_sem);
-
+        
         list_for_each_entry(page_itr, &shared_pagelist, lru) {
                 TRACE("S Anon=%d, pfn = %lu, _mapcount = %d, _count = %d\n", PageAnon(page_itr), __page_to_pfn(page_itr), page_mapcount(page_itr), page_count(page_itr));
         }
         
         TRACE_TASK(current, "nr_pages = %d nr_failed = %d\n", nr_pages, nr_failed);
-        printk(KERN_INFO "nr_pages = %d nr_failed = %d\n", nr_pages, nr_failed);
+        printk(KERN_INFO "node = %ld, nr_pages = %d, nr_failed = %d\n", node, nr_pages, nr_failed);
         flush_cache();
         
         return ret;
@@ -911,6 +917,8 @@ static int __init _init_litmus(void)
         //litmus_pmu_register();
         color_mask = ((cache_info_sets << line_size_log) - 1) ^ (PAGE_SIZE - 1);
         printk("Page color mask %lx\n", color_mask);
+        
+        //raw_spin_lock_init(&migrate_lock);
         return 0;
 }
 
diff --git a/litmus/sched_mc2.c b/litmus/sched_mc2.c
index 1e39362547c0..e59030f298ca 100644
--- a/litmus/sched_mc2.c
+++ b/litmus/sched_mc2.c
@@ -630,7 +630,6 @@ struct task_struct* mc2_dispatch(struct sup_reservation_environment* sup_env, st
         return NULL;
 }
 
-/* not used now */
 static inline void pre_schedule(struct task_struct *prev, int cpu)
 {
         if (!prev || !is_realtime(prev))
@@ -639,16 +638,15 @@ static inline void pre_schedule(struct task_struct *prev, int cpu)
         do_partition(CRIT_LEVEL_C, cpu);
 }
 
-/* not used now */
 static inline void post_schedule(struct task_struct *next, int cpu)
 {
         enum crit_level lev;
-        if (!next) // || !is_realtime(next))
+        if ((!next) || !is_realtime(next))
                 return;
-        if (!is_realtime(next))
+/*      if (!is_realtime(next))
                 lev = NUM_CRIT_LEVELS;
-        else
-                lev = get_task_crit_level(next);
+        else */
+        lev = get_task_crit_level(next);
         do_partition(lev, cpu);
 }
 
@@ -660,7 +658,7 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
         lt_t now;
         struct mc2_cpu_state *state = local_cpu_state();
 
-        //pre_schedule(prev, state->cpu);
+        pre_schedule(prev, state->cpu);
         
         raw_spin_lock(&_global_env.lock);
         raw_spin_lock(&state->lock);
@@ -705,8 +703,6 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
         /* NOTE: drops state->lock */
         mc2_update_timer_and_unlock(state);
 
-
-        
         if (prev != state->scheduled && is_realtime(prev)) {
                 struct mc2_task_state* tinfo = get_mc2_state(prev);
                 struct reservation* res = tinfo->res_info.client.reservation;