static linking coloring

1 files changed, 73 insertions, 21 deletions

diff --git a/litmus/litmus.c b/litmus/litmus.c
index cdffbc617d3a..88cc3e043b0b 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -14,13 +14,16 @@
 #include <linux/sched/rt.h>
 #include <linux/rwsem.h>
 #include <linux/list.h>
+#include <linux/migrate.h>
+#include <linux/mm.h>
+#include <linux/memcontrol.h>
 
 #include <litmus/litmus.h>
 #include <litmus/bheap.h>
 #include <litmus/trace.h>
 #include <litmus/rt_domain.h>
-#include <litmus/litmus_proc.h>
 #include <litmus/sched_trace.h>
+#include <litmus/litmus_proc.h>
 #include <litmus/clock.h>
 
 #include <asm/cacheflush.h>
@@ -342,6 +345,7 @@ 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;
@@ -353,15 +357,18 @@ static struct page *walk_page_table(unsigned long addr)
     struct mm_struct *mm = current->mm;
 
     pgd = pgd_offset(mm, addr);
-    if (pgd_none(*pgd) || pgd_bad(*pgd))
+    //if (pgd_none(*pgd) || pgd_bad(*pgd))
+        if (pgd_none_or_clear_bad(pgd))
         goto out;
     
     pud = pud_offset(pgd, addr);
-    if (pud_none(*pud) || pud_bad(*pud))
+    //if (pud_none(*pud) || pud_bad(*pud))
+        if (pud_none_or_clear_bad(pud))
         goto out;
     
     pmd = pmd_offset(pud, addr);
-    if (pmd_none(*pmd) || pmd_bad(*pmd))
+    //if (pmd_none(*pmd) || pmd_bad(*pmd))
+        if (pmd_none_or_clear_bad(pmd))
         goto out;
     
     ptep = pte_offset_map(pmd, addr);
@@ -370,65 +377,110 @@ static struct page *walk_page_table(unsigned long addr)
     pte = *ptep;
 
     page = pte_page(pte);
-    if (page)
-        printk(KERN_INFO "page frame struct is @ %p\n", page);
+    if (pfn_valid(__page_to_pfn(page))) {
+        ;//printk(KERN_INFO "page frame struct is @ %p\n", page);
+                //printk(KERN_INFO "pfn is %lu\n", __page_to_pfn(page));
+        }
         
         pte_unmap(ptep);
 
  out:
     return page;
 }
+*/
+
+extern int isolate_lru_page(struct page *page);
+extern void putback_lru_page(struct page *page);
+
+static struct page *new_alloc_page(struct page *page, unsigned long node, int **x)
+{
+        return alloc_pages_exact_node(node, GFP_HIGHUSER_MOVABLE, 0);
+}
 
 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 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;
+        //struct task_page *entry = NULL;
+        int nr_pages = 0;
+        LIST_HEAD(pagelist);
         
         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;
+                struct page *new_page = NULL, *old_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;
+                */
+                num_pages = (vma_itr->vm_end - vma_itr->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);
+                //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) {
-                                
+                        printk(KERN_INFO "PAGE_COLOR: %lu\n", page_color(new_page));
+*/
+                        //old_page = walk_page_table(vma_itr->vm_start + PAGE_SIZE*i);
+                        old_page = follow_page(vma_itr, vma_itr->vm_start + PAGE_SIZE*i, FOLL_GET|FOLL_SPLIT);
+                        
+                        if (IS_ERR(old_page))
+                                continue;
+                        if (!old_page)
+                                continue;
+                        if (PageReserved(old_page))
+                                goto put_and_next;
                                 
+                        ret = isolate_lru_page(old_page);
+                        //if (pfn_valid(__page_to_pfn(old_page)))
+                        if (!ret) {
+                                //printk(KERN_INFO "page_mapcount = %d\n", page_mapcount(old_page));
+                                printk(KERN_INFO "addr: %lu, pfn: %lu mapcount: %d\n", vma_itr->vm_start + PAGE_SIZE*i, __page_to_pfn(old_page), page_mapcount(old_page));
+                                list_add_tail(&old_page->lru, &pagelist);
+                                inc_zone_page_state(old_page, NR_ISOLATED_ANON + !PageSwapBacked(old_page));
+                                nr_pages++;
+                        }
+put_and_next:                           
+                                put_page(old_page);
                 }
-                //entry->page = walk_page_table(entry->vm_start);
                 
-                INIT_LIST_HEAD(&entry->list);
-                list_add(&entry->list, &task_page_list);
+                //INIT_LIST_HEAD(&entry->list);
+                //list_add(&entry->list, &task_page_list);
                 
                 vma_itr = vma_itr->vm_next;
         }
+
+        ret = 0;
+        if (!list_empty(&pagelist)) {
+                ret = migrate_pages(&pagelist, new_alloc_page, 0, MIGRATE_ASYNC, MR_SYSCALL);
+                if (ret) {
+                        printk(KERN_INFO "%ld pages not migrated.\n", ret);
+                        putback_lru_pages(&pagelist);
+                }
+        }
         
         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);           
         }
-        
+*/      
+        printk(KERN_INFO "nr_pages = %d\n", nr_pages);
         return ret;
 }