set_page_color syscall

8 files changed, 124 insertions, 4 deletions

diff --git a/arch/arm/include/asm/unistd.h b/arch/arm/include/asm/unistd.h
index 0db825dda11f..f31a912e2c9a 100644
--- a/arch/arm/include/asm/unistd.h
+++ b/arch/arm/include/asm/unistd.h
@@ -15,7 +15,7 @@
 
 #include <uapi/asm/unistd.h>
 /** __NR_syscalls padding */
-#define __NR_syscalls  (380 + NR_litmus_syscalls + 1)
+#define __NR_syscalls  (380 + NR_litmus_syscalls)
 
 #define __ARM_NR_cmpxchg                (__ARM_NR_BASE+0x00fff0)
 
diff --git a/arch/arm/kernel/calls.S b/arch/arm/kernel/calls.S
index 34c5ee7964eb..2fbce68d96d3 100644
--- a/arch/arm/kernel/calls.S
+++ b/arch/arm/kernel/calls.S
@@ -404,7 +404,8 @@
                 CALL(sys_reservation_create)
                 CALL(sys_reservation_destroy)
                 CALL(sys_set_mc2_task_param)
-
+/* 395 */       CALL(sys_set_page_color)
+                
 #ifndef syscalls_counted
 .equ syscalls_padding, ((NR_syscalls + 3) & ~3) - NR_syscalls
 #define syscalls_counted
diff --git a/arch/arm/mm/cache-l2x0.c b/arch/arm/mm/cache-l2x0.c
index 5efe6b6e9d53..cff808e79199 100644
--- a/arch/arm/mm/cache-l2x0.c
+++ b/arch/arm/mm/cache-l2x0.c
@@ -326,6 +326,7 @@ void __init l2x0_init(void __iomem *base, u32 aux_val, u32 aux_mask)
 {
         u32 aux;
         u32 cache_id;
+        u32 cache_type;
         u32 way_size = 0;
         int ways;
         int way_size_shift = L2X0_WAY_SIZE_SHIFT;
@@ -337,6 +338,8 @@ void __init l2x0_init(void __iomem *base, u32 aux_val, u32 aux_mask)
         else
                 cache_id = readl_relaxed(l2x0_base + L2X0_CACHE_ID);
         aux = readl_relaxed(l2x0_base + L2X0_AUX_CTRL);
+        
+        cache_type = readl_relaxed(l2x0_base + L2X0_CACHE_TYPE);
 
         aux &= aux_mask;
         aux |= aux_val;
@@ -424,6 +427,7 @@ void __init l2x0_init(void __iomem *base, u32 aux_val, u32 aux_mask)
         printk(KERN_INFO "%s cache controller enabled\n", type);
         printk(KERN_INFO "l2x0: %d ways, CACHE_ID 0x%08x, AUX_CTRL 0x%08x, Cache size: %d B\n",
                         ways, cache_id, aux, l2x0_size);
+        printk(KERN_INFO "l2x0: CACHE_TYPE 0x%08x\n", cache_type);
 
         litmus_setup_lockdown(l2x0_base, cache_id);
 }
diff --git a/arch/x86/syscalls/syscall_32.tbl b/arch/x86/syscalls/syscall_32.tbl
index 20f6cdcf56dd..401f313f9cdd 100644
--- a/arch/x86/syscalls/syscall_32.tbl
+++ b/arch/x86/syscalls/syscall_32.tbl
@@ -373,3 +373,4 @@
 363     i386    reservation_create      sys_reservation_create
 364     i386    reservation_destroy     sys_reservation_destroy
 365     i386    set_mc2_task_param      sys_set_mc2_task_param
+366     i386    set_page_color          sys_set_page_color
diff --git a/arch/x86/syscalls/syscall_64.tbl b/arch/x86/syscalls/syscall_64.tbl
index f3d142c2a900..77710a93c2a3 100644
--- a/arch/x86/syscalls/syscall_64.tbl
+++ b/arch/x86/syscalls/syscall_64.tbl
@@ -336,6 +336,7 @@
 363     common  reservation_create      sys_reservation_create
 364     common  reservation_destroy     sys_reservation_destroy
 365     common  set_mc2_task_param      sys_set_mc2_task_param
+366     common  set_page_color          sys_set_page_color
 
 #
 # x32-specific system call numbers start at 512 to avoid cache impact
diff --git a/include/litmus/unistd_32.h b/include/litmus/unistd_32.h
index 202f439a62ae..cfffbddd09b7 100644
--- a/include/litmus/unistd_32.h
+++ b/include/litmus/unistd_32.h
@@ -20,5 +20,6 @@
 #define __NR_reservation_create __LSC(12)
 #define __NR_reservation_destroy __LSC(13)
 #define __NR_set_mc2_task_param __LSC(14)
+#define __NR_set_page_color             __LSC(15)
 
-#define NR_litmus_syscalls 15
+#define NR_litmus_syscalls 16
diff --git a/include/litmus/unistd_64.h b/include/litmus/unistd_64.h
index ba2c91c5bf8c..2fb49dc58eb3 100644
--- a/include/litmus/unistd_64.h
+++ b/include/litmus/unistd_64.h
@@ -35,5 +35,7 @@ __SYSCALL(__NR_reservation_create, sys_reservation_create)
 __SYSCALL(__NR_reservation_destroy, sys_reservation_destroy)
 #define __NR_set_mc2_task_param                 __LSC(14)
 __SYSCALL(__NR_set_mc2_task_param, sys_set_mc2_task_param)
+#define __NR_set_page_color                             __LSC(15)
+__SYSCALL(__NR_set_page_color, sys_set_page_color)
 
-#define NR_litmus_syscalls 15
+#define NR_litmus_syscalls 16
diff --git a/litmus/litmus.c b/litmus/litmus.c
index 8a2446f26f72..cdffbc617d3a 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -13,6 +13,7 @@
 #include <linux/stop_machine.h>
 #include <linux/sched/rt.h>
 #include <linux/rwsem.h>
+#include <linux/list.h>
 
 #include <litmus/litmus.h>
 #include <litmus/bheap.h>
@@ -325,6 +326,112 @@ asmlinkage long sys_reservation_destroy(unsigned int reservation_id, int cpu)
         return litmus->reservation_destroy(reservation_id, cpu);
 }
 
+struct task_page {
+        unsigned long vm_start;
+        unsigned long vm_end;
+        struct page* page;
+        struct list_head list;
+};
+
+LIST_HEAD(task_page_list);
+
+static unsigned long color_mask;
+
+static inline unsigned long page_color(struct page *page)
+{
+        return ((page_to_phys(page) & color_mask) >> PAGE_SHIFT);
+}
+
+static struct page *walk_page_table(unsigned long addr)
+{
+    pgd_t *pgd;
+    pte_t *ptep, pte;
+    pud_t *pud;
+    pmd_t *pmd;
+
+    struct page *page = NULL;
+    struct mm_struct *mm = current->mm;
+
+    pgd = pgd_offset(mm, addr);
+    if (pgd_none(*pgd) || pgd_bad(*pgd))
+        goto out;
+    
+    pud = pud_offset(pgd, addr);
+    if (pud_none(*pud) || pud_bad(*pud))
+        goto out;
+    
+    pmd = pmd_offset(pud, addr);
+    if (pmd_none(*pmd) || pmd_bad(*pmd))
+        goto out;
+    
+    ptep = pte_offset_map(pmd, addr);
+    if (!ptep)
+        goto out;
+    pte = *ptep;
+
+    page = pte_page(pte);
+    if (page)
+        printk(KERN_INFO "page frame struct is @ %p\n", page);
+        
+        pte_unmap(ptep);
+
+ out:
+    return page;
+}
+
+asmlinkage long sys_set_page_color(int cpu)
+{
+        long ret = 0;
+        struct task_page *task_page_itr = NULL;
+        struct task_page *task_page_itr_next = NULL;
+        struct vm_area_struct *vma_itr = NULL;
+        struct task_page *entry = NULL;
+        
+        down_read(&current->mm->mmap_sem);
+        printk(KERN_INFO "SYSCALL set_page_color\n");
+        vma_itr = current->mm->mmap;
+        while (vma_itr != NULL) {
+                unsigned int num_pages = 0, i;
+                struct page *new_page = NULL;
+                entry = kmalloc(sizeof(struct task_page), GFP_ATOMIC);
+                if (entry == NULL) {
+                        return -ENOSPC;
+                }
+                entry->vm_start = vma_itr->vm_start;
+                entry->vm_end = vma_itr->vm_end;
+                num_pages = (entry->vm_end - entry->vm_start) / PAGE_SIZE;
+                // print vma flags
+                printk(KERN_INFO "flags: 0x%lx\n", vma_itr->vm_flags);
+                printk(KERN_INFO "start - end: 0x%lx - 0x%lx (%lu)\n", vma_itr->vm_start, vma_itr->vm_end, (vma_itr->vm_end - vma_itr->vm_start)/PAGE_SIZE);
+                
+                for (i = 0; i < num_pages; i++) {
+alloc:
+                        new_page = alloc_page_vma(GFP_HIGHUSER_MOVABLE, vma_itr, vma_itr->vm_start);
+                        if (!new_page)
+                                return -ENOSPC;
+                        if ( (page_color(new_page)>>2) != cpu) {
+                                
+                                
+                }
+                //entry->page = walk_page_table(entry->vm_start);
+                
+                INIT_LIST_HEAD(&entry->list);
+                list_add(&entry->list, &task_page_list);
+                
+                vma_itr = vma_itr->vm_next;
+        }
+        
+        up_read(&current->mm->mmap_sem);
+        
+        list_for_each_entry_safe(task_page_itr, task_page_itr_next, &task_page_list, list) {
+                //printk(KERN_INFO "start - end: 0x%lx - 0x%lx (%lu)\n", task_page_itr->vm_start, task_page_itr->vm_end, (task_page_itr->vm_end - task_page_itr->vm_start)/PAGE_SIZE);
+                list_del(&task_page_itr->list);
+                kfree(task_page_itr);           
+        }
+        
+        return ret;
+}
+
 /* p is a real-time task. Re-init its state as a best-effort task. */
 static void reinit_litmus_state(struct task_struct* p, int restore)
 {
@@ -662,6 +769,8 @@ static int __init _init_litmus(void)
          *      mode change lock is used to enforce single mode change
          *      operation.
          */
+        unsigned int line_size_log = 5; // 2^5 = 32 byte
+        unsigned int cache_info_sets = 2048; // 64KB (way_size) / 32B (line_size) = 2048
         printk("Starting LITMUS^RT kernel\n");
 
         register_sched_plugin(&linux_sched_plugin);
@@ -689,6 +798,7 @@ static int __init _init_litmus(void)
         litmus_enable_perfcounters();
 #endif
         
+        color_mask = ((cache_info_sets << line_size_log) - 1) ^ (PAGE_SIZE - 1);
         return 0;
 }