24 files changed, 77 insertions, 385 deletions

diff --git a/arch/arm/kernel/irq.c b/arch/arm/kernel/irq.c
index 350f188c92d2..720b45e232f2 100644
--- a/arch/arm/kernel/irq.c
+++ b/arch/arm/kernel/irq.c
@@ -44,6 +44,8 @@
 #include <asm/mach/irq.h>
 #include <asm/mach/time.h>
 
+#include <litmus/cache_proc.h>
+
 unsigned long irq_err_count;
 
 int arch_show_interrupts(struct seq_file *p, int prec)
@@ -66,7 +68,9 @@ int arch_show_interrupts(struct seq_file *p, int prec)
  */
 void handle_IRQ(unsigned int irq, struct pt_regs *regs)
 {
+        enter_irq_mode();
         __handle_domain_irq(NULL, irq, false, regs);
+        exit_irq_mode();
 }
 
 /*
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 55df1f8bf4cb..0755b9fd03a7 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -2200,7 +2200,5 @@ void __init setup_nr_node_ids(void);
 static inline void setup_nr_node_ids(void) {}
 #endif
 
-extern void replication_init(void);
-
 #endif /* __KERNEL__ */
 #endif /* _LINUX_MM_H */
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index e8011e019864..8d37e26a1007 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -12,7 +12,6 @@
 #include <linux/cpumask.h>
 #include <linux/uprobes.h>
 #include <linux/page-flags-layout.h>
-#include <linux/radix-tree.h>
 #include <asm/page.h>
 #include <asm/mmu.h>
 
@@ -546,10 +545,4 @@ typedef struct {
         unsigned long val;
 } swp_entry_t;
 
-struct pcache_desc {
-        struct page *master;
-        cpumask_t cpus_present;
-        struct radix_tree_root page_tree;
-};
-
 #endif /* _LINUX_MM_TYPES_H */
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index abc63c255d44..54d74f6eb233 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -126,7 +126,6 @@ enum zone_stat_item {
         NR_FILE_MAPPED, /* pagecache pages mapped into pagetables.
                            only modified from process context */
         NR_FILE_PAGES,
-        NR_REPL_PAGES,
         NR_FILE_DIRTY,
         NR_WRITEBACK,
         NR_SLAB_RECLAIMABLE,
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index 8b0d7723f3c9..f34e040b34e9 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -97,7 +97,6 @@ enum pageflags {
         PG_reclaim,             /* To be reclaimed asap */
         PG_swapbacked,          /* Page is backed by RAM/swap */
         PG_unevictable,         /* Page is "unevictable"  */
-        PG_replicated,          /* Page is replicated pagecache */
 #ifdef CONFIG_MMU
         PG_mlocked,             /* Page is vma mlocked */
 #endif
@@ -290,11 +289,6 @@ PAGEFLAG_FALSE(HWPoison)
 #define __PG_HWPOISON 0
 #endif
 
-#define PageReplicated(page)    test_bit(PG_replicated, &(page)->flags)
-#define __SetPageReplicated(page) do { BUG_ON(PageDirty(page) || PageWriteback(page)); __set_bit(PG_replicated, &(page)->flags); } while (0) 
-#define SetPageReplicated(page) do { BUG_ON(PageDirty(page) || PageWriteback(page)); set_bit(PG_replicated, &(page)->flags); } while (0)
-#define ClearPageReplicated(page) clear_bit(PG_replicated, &(page)->flags)
-
 /*
  * On an anonymous page mapped into a user virtual memory area,
  * page->mapping points to its anon_vma, not to a struct address_space;
diff --git a/include/linux/vm_event_item.h b/include/linux/vm_event_item.h
index 62820318d8ad..9246d32dc973 100644
--- a/include/linux/vm_event_item.h
+++ b/include/linux/vm_event_item.h
@@ -25,7 +25,6 @@ enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT,
                 FOR_ALL_ZONES(PGALLOC),
                 PGFREE, PGACTIVATE, PGDEACTIVATE,
                 PGFAULT, PGMAJFAULT,
-                PGREPLICATED, PGREPLICAZAP,
                 FOR_ALL_ZONES(PGREFILL),
                 FOR_ALL_ZONES(PGSTEAL_KSWAPD),
                 FOR_ALL_ZONES(PGSTEAL_DIRECT),
diff --git a/include/litmus/replicate_lib.h b/include/litmus/replicate_lib.h
index 773468497416..186837be08a5 100644
--- a/include/litmus/replicate_lib.h
+++ b/include/litmus/replicate_lib.h
@@ -5,11 +5,12 @@
 #include <linux/mm_types.h>

 #include <linux/mm_inline.h>

 

+/* Data structure for the "master" list */

 struct shared_lib_page {

         struct page *master_page;

-        struct page *r_page[NR_CPUS];

+        struct page *r_page[NR_CPUS+1];

         unsigned long int master_pfn;

-        unsigned long int r_pfn[NR_CPUS];

+        unsigned long int r_pfn[NR_CPUS+1];

         struct list_head list;

 };

 

diff --git a/init/main.c b/init/main.c
index 88917d93fbe4..2a89545e0a5d 100644
--- a/init/main.c
+++ b/init/main.c
@@ -628,7 +628,6 @@ asmlinkage __visible void __init start_kernel(void)
         kmemleak_init();
         setup_per_cpu_pageset();
         numa_policy_init();
-        replication_init();
         if (late_time_init)
                 late_time_init();
         sched_clock_init();
diff --git a/litmus/bank_proc.c b/litmus/bank_proc.c
index 6103611211ce..df9f5730ed05 100644
--- a/litmus/bank_proc.c
+++ b/litmus/bank_proc.c
@@ -24,10 +24,12 @@
 // This Address Decoding is used in imx6-sabredsd platform
 #define BANK_MASK  0x38000000     
 #define BANK_SHIFT  27
+
 #define CACHE_MASK  0x0000f000      
 #define CACHE_SHIFT 12
 
-#define PAGES_PER_COLOR 1024
+#define PAGES_PER_COLOR 2000
+#define PAGES_PER_COLOR_HALF 1000
 unsigned int NUM_PAGE_LIST;  //8*16
 
 unsigned int number_banks;
@@ -245,7 +247,8 @@ static int do_add_pages(void)
                 counter[color]++;
         //      printk("page(%d) = color %x, bank %x, [color] =%d \n", color, page_color(page), page_bank(page), atomic_read(&color_groups[color].nr_pages));
                 //show_nr_pages();
-                if (atomic_read(&color_groups[color].nr_pages) < PAGES_PER_COLOR && color>=32) {
+                //if (atomic_read(&color_groups[color].nr_pages) < PAGES_PER_COLOR && color>=32) {
+                if (atomic_read(&color_groups[color].nr_pages) < PAGES_PER_COLOR) {
                 //if ( PAGES_PER_COLOR && color>=16*2) {
                         add_page_to_color_list(page);
         //              printk("add page(%d) = color %x, bank %x\n", color, page_color(page), page_bank(page));
diff --git a/litmus/cache_proc.c b/litmus/cache_proc.c
index 49e98f6ed86a..87077d4366dc 100644
--- a/litmus/cache_proc.c
+++ b/litmus/cache_proc.c
@@ -357,17 +357,9 @@ int lock_all_handler(struct ctl_table *table, int write, void __user *buffer,
                         writel_relaxed(0x0, cache_base + L2X0_LOCKDOWN_WAY_I_BASE +

                                        i * L2X0_LOCKDOWN_STRIDE);

                 }

-/*

-                for (i = 0; i < nr_lockregs;  i++) {

-                        barrier();

-                        mem_lock(UNLOCK_ALL, i);

-                        barrier();

-                        //writel_relaxed(nr_unlocked_way[16], ld_d_reg(i));

-                        //writel_relaxed(nr_unlocked_way[16], ld_i_reg(i));

-                }

-*/

+

         }

-        printk("LOCK_ALL HANDLER\n");

+

         local_irq_save(flags);

         print_lockdown_registers(smp_processor_id());

         l2c310_flush_all();

@@ -379,9 +371,6 @@ out:
 

 void cache_lockdown(u32 lock_val, int cpu)

 {

-        //unsigned long flags;

-        //raw_spin_lock_irqsave(&cache_lock, flags);

-

         __asm__ __volatile__ (

 "       str     %[lockval], [%[dcachereg]]\n"

 "       str     %[lockval], [%[icachereg]]\n"

@@ -390,8 +379,6 @@ void cache_lockdown(u32 lock_val, int cpu)
           [icachereg] "r" (ld_i_reg(cpu)),

           [lockval] "r" (lock_val)

         : "cc");

-

-        //raw_spin_unlock_irqrestore(&cache_lock, flags);

 }

 

 void do_partition(enum crit_level lv, int cpu)

@@ -421,14 +408,12 @@ void do_partition(enum crit_level lv, int cpu)
 

         }

         barrier();

-        //cache_lockdown(regs, cpu);

+

         writel_relaxed(regs, cache_base + L2X0_LOCKDOWN_WAY_D_BASE + cpu * L2X0_LOCKDOWN_STRIDE);

         writel_relaxed(regs, cache_base + L2X0_LOCKDOWN_WAY_I_BASE + cpu * L2X0_LOCKDOWN_STRIDE);

         barrier();

 

         raw_spin_unlock_irqrestore(&cache_lock, flags);

-        

-        flush_cache(0);

 }

 

 void lock_cache(int cpu, u32 val)

@@ -544,7 +529,6 @@ void inline enter_irq_mode(void)
 

         if (os_isolation == 0)

                 return; 

-

         prev_lockdown_i_reg[cpu] = readl_relaxed(ld_i_reg(cpu));

         prev_lockdown_d_reg[cpu] = readl_relaxed(ld_d_reg(cpu));

         

@@ -1011,7 +995,6 @@ int setup_flusher_array(void)
                 ret = -EINVAL;

                 goto out;

         }

-

         for (way = 0; way < MAX_NR_WAYS; way++) {

                 void **flusher_color_arr;

                 flusher_color_arr = (void**) kmalloc(sizeof(**flusher_pages)

@@ -1023,7 +1006,7 @@ int setup_flusher_array(void)
                 }

 

                 flusher_pages[way] = flusher_color_arr;

-

+                /* This is ugly. */

                 for (color = 0; color < MAX_NR_COLORS; color++) {

                         int node;

                         switch (color) {

@@ -1090,6 +1073,7 @@ int setup_flusher_array(void)
                         }

                 }

         }

+

 out:

         return ret;

 out_free:

diff --git a/litmus/litmus.c b/litmus/litmus.c
index 11e4c5da9c10..1f5e49114b2c 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -352,28 +352,32 @@ extern int isolate_lru_page(struct page *page);
 extern void putback_movable_page(struct page *page);
 extern struct page *new_alloc_page(struct page *page, unsigned long node, int **x);
 
-DECLARE_PER_CPU(struct list_head, shared_lib_page_list);
 #define INVALID_PFN                             (0xffffffff)
 LIST_HEAD(shared_lib_pages);
-//struct list_head shared_lib_pages = LIST_HEAD_INIT(shared_lib_pages);
+
 EXPORT_SYMBOL(shared_lib_pages);
 
+/* Reallocate pages of a task 
+ * Private pages - Migrate to a new page.
+ * Shared pages - Use a replica. Make a replica if necessary.
+ * @cpu : CPU id of the calling task
+ * returns the number of pages that is not moved.
+ */
 asmlinkage long sys_set_page_color(int cpu)
 {
         long ret = 0;
-        //struct page *page_itr = NULL;
         struct vm_area_struct *vma_itr = NULL;
         int nr_pages = 0, nr_shared_pages = 0, nr_failed = 0, nr_not_migrated = 0;
         unsigned long node;
         enum crit_level lv;
         struct mm_struct *mm;
-        //struct list_head *shared_pagelist = this_cpu_ptr(&shared_lib_page_list);
                 
         LIST_HEAD(pagelist);
         LIST_HEAD(task_shared_pagelist);
 
         migrate_prep();
         
+        /* Find the current mm_struct */
         rcu_read_lock();
         get_task_struct(current);
         rcu_read_unlock();
@@ -383,16 +387,14 @@ asmlinkage long sys_set_page_color(int cpu)
         down_read(&mm->mmap_sem);
         TRACE_TASK(current, "SYSCALL set_page_color\n");
         vma_itr = mm->mmap;
+        /* Iterate all vm_area_struct */
         while (vma_itr != NULL) {
                 unsigned int num_pages = 0, i;
                 struct page *old_page = NULL;
                 int pages_in_vma = 0;
                 
                 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 "vm_page_prot: 0x%lx\n", vma_itr->vm_page_prot);
+                /* Traverse all pages in vm_area_struct */
                 for (i = 0; i < num_pages; i++) {
                         old_page = follow_page(vma_itr, vma_itr->vm_start + PAGE_SIZE*i, FOLL_GET|FOLL_SPLIT);
                         
@@ -410,14 +412,13 @@ asmlinkage long sys_set_page_color(int cpu)
                         TRACE_TASK(current, "addr: %08x, pfn: %05lx, _mapcount: %d, _count: %d flags: %s%s%s\n", vma_itr->vm_start + PAGE_SIZE*i, page_to_pfn(old_page), page_mapcount(old_page), page_count(old_page), vma_itr->vm_flags&VM_READ?"r":"-", vma_itr->vm_flags&VM_WRITE?"w":"-", vma_itr->vm_flags&VM_EXEC?"x":"-");
                         pages_in_vma++;
 
-// for simple debug                     
+                        /* Conditions for replicable pages */
                         if (page_count(old_page) > 2 && vma_itr->vm_file != NULL && !(vma_itr->vm_flags&VM_WRITE)) {
-                        //if (page_count(old_page) < 10 && page_count(old_page) > 3 && vma_itr->vm_file != NULL && !(vma_itr->vm_flags&VM_WRITE)) {
                                 struct shared_lib_page *lib_page;
                                 int is_exist = 0;
 
-                                /* update PSL list */
-                                /* check if this page is in the PSL list */
+                                /* Update PSL (Per-core shared library (master)) list */
+                                /* Check if this page is in the PSL list */
                                 rcu_read_lock();
                                 list_for_each_entry(lib_page, &shared_lib_pages, list)
                                 {
@@ -432,10 +433,8 @@ asmlinkage long sys_set_page_color(int cpu)
                                         int cpu_i;
                                         lib_page = kmalloc(sizeof(struct shared_lib_page), GFP_KERNEL);
                                         lib_page->master_page = old_page;
-                                        //lib_page->r_page = NULL;
                                         lib_page->master_pfn = page_to_pfn(old_page);
-                                        //lib_page->r_pfn = INVALID_PFN;
-                                        for (cpu_i = 0; cpu_i < NR_CPUS; cpu_i++) {
+                                        for (cpu_i = 0; cpu_i < NR_CPUS+1; cpu_i++) {
                                                 lib_page->r_page[cpu_i] = NULL;
                                                 lib_page->r_pfn[cpu_i] = INVALID_PFN;
                                         }
@@ -452,9 +451,8 @@ asmlinkage long sys_set_page_color(int cpu)
                                         list_add_tail(&old_page->lru, &task_shared_pagelist);
                                         inc_zone_page_state(old_page, NR_ISOLATED_ANON + !PageSwapBacked(old_page));
                                         nr_shared_pages++;
-                                        TRACE_TASK(current, "SHARED isolate_lru_page success\n");
                                 } else {
-                                        TRACE_TASK(current, "SHARED isolate_lru_page failed\n");
+                                        TRACE_TASK(current, "isolate_lru_page for a shared page failed\n");
                                         nr_failed++;
                                 }
                                 put_page(old_page);
@@ -466,34 +464,28 @@ asmlinkage long sys_set_page_color(int cpu)
                                         inc_zone_page_state(old_page, NR_ISOLATED_ANON + !PageSwapBacked(old_page));
                                         nr_pages++;
                                 } else {
-                                        TRACE_TASK(current, "isolate_lru_page failed\n");
+                                        TRACE_TASK(current, "isolate_lru_page for a private page failed\n");
                                         nr_failed++;
                                 }
-                                //printk(KERN_INFO "PRIVATE _mapcount = %d, _count = %d\n", page_mapcount(old_page), page_count(old_page));
                                 put_page(old_page);
-                                //TRACE_TASK(current, "PRIVATE\n");
                         }
                 }
                 TRACE_TASK(current, "PAGES_IN_VMA = %d size = %d KB\n", pages_in_vma, pages_in_vma*4);
                 vma_itr = vma_itr->vm_next;
         }
-
-        //list_for_each_entry(page_itr, &pagelist, lru) {
-//              printk(KERN_INFO "B _mapcount = %d, _count = %d\n", page_mapcount(page_itr), page_count(page_itr));
-//      }
         
         ret = 0;
         if (!is_realtime(current))
-                lv = 1;
+                node = 8;
         else {
                 lv = tsk_rt(current)->mc2_data->crit;
+                if (cpu == -1)
+                        node = 8;
+                else
+                        node = cpu*2 + lv;
         }
-        
-        if (cpu == -1)
-                node = 8;
-        else
-                node = cpu*2 + lv;
-                
+
+        /* Migrate private pages */
         if (!list_empty(&pagelist)) {
                 ret = migrate_pages(&pagelist, new_alloc_page, NULL, node, MIGRATE_SYNC, MR_SYSCALL);
                 TRACE_TASK(current, "%ld pages not migrated.\n", ret);
@@ -502,52 +494,24 @@ asmlinkage long sys_set_page_color(int cpu)
                         putback_movable_pages(&pagelist);
                 }
         }
-/*      
-        {
-                struct list_head *pos, *q;
-                list_for_each_safe(pos, q, &task_shared_pagelist) {
-                        struct page *p_entry = NULL;
-                        struct shared_lib_page *lib_desc = NULL;
-                
-                        p_entry = list_entry(pos, struct page, lru);
-                        list_for_each_entry(lib_desc, &shared_lib_pages, list) {
-                                if (p_entry == lib_desc->r_page) {
-                                        list_del(pos);
-                                }
-                        }
-                }
-        }
-*/      
+
+        /* Replicate shared pages */
         if (!list_empty(&task_shared_pagelist)) {
-                if (node != 8)
-                        ret = replicate_pages(&task_shared_pagelist, new_alloc_page, NULL, node, MIGRATE_SYNC, MR_SYSCALL);
-                else
-                        ret = nr_shared_pages;
+                ret = replicate_pages(&task_shared_pagelist, new_alloc_page, NULL, node, MIGRATE_SYNC, MR_SYSCALL);
                 TRACE_TASK(current, "%ld shared pages not migrated.\n", ret);
                 nr_not_migrated += ret;
                 if (ret) {
                         putback_movable_pages(&task_shared_pagelist);
                 }
         }
-        
-        /* handle sigpage and litmus ctrl_page */
-/*      vma_itr = current->mm->mmap;
-        while (vma_itr != NULL) {
-                if (vma_itr->vm_start == tsk_rt(current)->addr_ctrl_page) {
-                        TRACE("litmus ctrl_page = %08x\n", vma_itr->vm_start);
-                        vma_itr->vm_page_prot = PAGE_SHARED;
-                        break;
-                }
-                vma_itr = vma_itr->vm_next;
-        }
-*/
+
         up_read(&mm->mmap_sem);
 
-        
-        TRACE_TASK(current, "nr_pages = %d nr_failed = %d\n", nr_pages, nr_failed);
+        TRACE_TASK(current, "nr_pages = %d nr_failed = %d nr_not_migrated = %d\n", nr_pages, nr_failed, nr_not_migrated);
         printk(KERN_INFO "node = %ld, nr_private_pages = %d, nr_shared_pages = %d, nr_failed_to_isolate_lru = %d, nr_not_migrated = %d\n", node, nr_pages, nr_shared_pages, nr_failed, nr_not_migrated);
 
         flush_cache(1);
+
 /* for debug START */
         TRACE_TASK(current, "PSL PAGES\n");
         {
@@ -556,11 +520,11 @@ asmlinkage long sys_set_page_color(int cpu)
                 rcu_read_lock();
                 list_for_each_entry(lpage, &shared_lib_pages, list)
                 {
-                        TRACE_TASK(current, "master_PFN = %05lx r_PFN = %05lx, %05lx, %05lx, %05lx\n", lpage->master_pfn, lpage->r_pfn[0], lpage->r_pfn[1], lpage->r_pfn[2], lpage->r_pfn[3]);
+                        TRACE_TASK(current, "master_PFN = %05lx r_PFN = %05lx, %05lx, %05lx, %05lx, %05lx\n", lpage->master_pfn, lpage->r_pfn[0], lpage->r_pfn[1], lpage->r_pfn[2], lpage->r_pfn[3], lpage->r_pfn[4]);
                 }
                 rcu_read_unlock();
         }
-        
+#if 0   
         TRACE_TASK(current, "AFTER migration\n");
         down_read(&mm->mmap_sem);
         vma_itr = mm->mmap;
@@ -595,8 +559,9 @@ asmlinkage long sys_set_page_color(int cpu)
         }
         up_read(&mm->mmap_sem);
 /* for debug FIN. */
+#endif
         
-        return ret;
+        return nr_not_migrated;
 }
 
 /* sys_test_call() is a test system call for developing */
@@ -644,7 +609,7 @@ asmlinkage long sys_test_call(unsigned int param)
                                         continue;
                                 }
                                 
-                                TRACE_TASK(current, "addr: %08x, pfn: %05lx, _mapcount: %d, _count: %d flags: %s%s%s\n", vma_itr->vm_start + PAGE_SIZE*i, page_to_pfn(old_page), page_mapcount(old_page), page_count(old_page), vma_itr->vm_flags&VM_READ?"r":"-", vma_itr->vm_flags&VM_WRITE?"w":"-", vma_itr->vm_flags&VM_EXEC?"x":"-");
+                                TRACE_TASK(current, "addr: %08x, pfn: %05lx, _mapcount: %d, _count: %d flags: %s%s%s mapping: %p\n", vma_itr->vm_start + PAGE_SIZE*i, page_to_pfn(old_page), page_mapcount(old_page), page_count(old_page), vma_itr->vm_flags&VM_READ?"r":"-", vma_itr->vm_flags&VM_WRITE?"w":"-", vma_itr->vm_flags&VM_EXEC?"x":"-", &(old_page->mapping));
                                 put_page(old_page);
                         }
                         vma_itr = vma_itr->vm_next;
diff --git a/litmus/polling_reservations.c b/litmus/polling_reservations.c
index 4a2fee575127..06bc1f5b9267 100644
--- a/litmus/polling_reservations.c
+++ b/litmus/polling_reservations.c
@@ -4,6 +4,8 @@
 #include <litmus/reservation.h>
 #include <litmus/polling_reservations.h>
 
+#define TRACE(fmt, args...) do {} while (false)
+#define TRACE_TASK(fmt, args...) do {} while (false)
 
 static void periodic_polling_client_arrives(
         struct reservation* res,
diff --git a/litmus/reservation.c b/litmus/reservation.c
index 07e38cb7d138..cdda89d4208f 100644
--- a/litmus/reservation.c
+++ b/litmus/reservation.c
@@ -4,8 +4,8 @@
 #include <litmus/litmus.h>
 #include <litmus/reservation.h>
 
-//#define TRACE(fmt, args...) do {} while (false)
-//#define TRACE_TASK(fmt, args...) do {} while (false)
+#define TRACE(fmt, args...) do {} while (false)
+#define TRACE_TASK(fmt, args...) do {} while (false)
 
 #define BUDGET_ENFORCEMENT_AT_C 0
         
diff --git a/litmus/sched_mc2.c b/litmus/sched_mc2.c
index 5c88a36aacec..588f78e2107f 100644
--- a/litmus/sched_mc2.c
+++ b/litmus/sched_mc2.c
@@ -27,8 +27,8 @@
 #include <litmus/reservation.h>
 #include <litmus/polling_reservations.h>
 
-//#define TRACE(fmt, args...) do {} while (false)
-//#define TRACE_TASK(fmt, args...) do {} while (false)
+#define TRACE(fmt, args...) do {} while (false)
+#define TRACE_TASK(fmt, args...) do {} while (false)
 
 #define BUDGET_ENFORCEMENT_AT_C 0
 
diff --git a/mm/Makefile b/mm/Makefile
index 98d28edd36a5..98c4eaeabdcb 100644
--- a/mm/Makefile
+++ b/mm/Makefile
@@ -56,7 +56,7 @@ obj-$(CONFIG_KASAN)	+= kasan/
 obj-$(CONFIG_FAILSLAB) += failslab.o
 obj-$(CONFIG_MEMORY_HOTPLUG) += memory_hotplug.o
 obj-$(CONFIG_MEMTEST)           += memtest.o
-obj-$(CONFIG_MIGRATION) += migrate.o replication.o
+obj-$(CONFIG_MIGRATION) += migrate.o
 obj-$(CONFIG_QUICKLIST) += quicklist.o
 obj-$(CONFIG_TRANSPARENT_HUGEPAGE) += huge_memory.o
 obj-$(CONFIG_PAGE_COUNTER) += page_counter.o
diff --git a/mm/debug.c b/mm/debug.c
index dbc3ea81dde7..3eb3ac2fcee7 100644
--- a/mm/debug.c
+++ b/mm/debug.c
@@ -36,7 +36,6 @@ static const struct trace_print_flags pageflag_names[] = {
         {1UL << PG_reclaim,             "reclaim"       },
         {1UL << PG_swapbacked,          "swapbacked"    },
         {1UL << PG_unevictable,         "unevictable"   },
-        {1UL << PG_replicated,          "replicated"    },
 #ifdef CONFIG_MMU
         {1UL << PG_mlocked,             "mlocked"       },
 #endif
diff --git a/mm/filemap.c b/mm/filemap.c
index 93853e337f07..6bf5e42d560a 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -36,9 +36,6 @@
 #include <linux/rmap.h>
 #include "internal.h"
 
-#include <litmus/litmus.h>
-#include <litmus/mc2_common.h>
-
 #define CREATE_TRACE_POINTS
 #include <trace/events/filemap.h>
 
@@ -976,18 +973,6 @@ repeat:
                 page = radix_tree_deref_slot(pagep);
                 if (unlikely(!page))
                         goto out;
-                if (is_pcache_desc(page)) {
-                        struct pcache_desc *pcd;
-printk(KERN_INFO "PCACHE_DESC\n");
-                        pcd = ptr_to_pcache_desc(page);
-                        page = pcd->master;
-                        page_cache_get_speculative(page);
-                        
-                        unreplicate_pcache(mapping, page->index, 0);
-                        
-                        goto out;
-                }
-                
                 if (radix_tree_exception(page)) {
                         if (radix_tree_deref_retry(page))
                                 goto repeat;
@@ -1186,20 +1171,6 @@ repeat:
                 page = radix_tree_deref_slot(slot);
                 if (unlikely(!page))
                         continue;
-                
-                if (is_pcache_desc(page)) {
-                        struct pcache_desc *pcd;
-                        printk(KERN_INFO "PCACHE_DESC\n");
-                        
-                        pcd = ptr_to_pcache_desc(page);
-                        page = pcd->master;
-                        page_cache_get_speculative(page);
-                        
-                        unreplicate_pcache(mapping, page->index, 0);
-                        
-                        goto export;
-                }
-                
                 if (radix_tree_exception(page)) {
                         if (radix_tree_deref_retry(page))
                                 goto restart;
@@ -1263,20 +1234,6 @@ repeat:
                 if (unlikely(!page))
                         continue;
 
-                if (is_pcache_desc(page)) {
-                        struct pcache_desc *pcd;
-
-                        printk(KERN_INFO "PCACHE_DESC\n");
-
-                        pcd = ptr_to_pcache_desc(page);
-                        page = pcd->master;
-                        page_cache_get_speculative(page);
-
-                        unreplicate_pcache(mapping, page->index, 0);
-
-                        goto export;
-                }
-
                 if (radix_tree_exception(page)) {
                         if (radix_tree_deref_retry(page)) {
                                 /*
@@ -1304,7 +1261,6 @@ repeat:
                         goto repeat;
                 }
 
-export:
                 pages[ret] = page;
                 if (++ret == nr_pages)
                         break;
@@ -1346,20 +1302,6 @@ repeat:
                 if (unlikely(!page))
                         break;
 
-                if (is_pcache_desc(page)) {
-                        struct pcache_desc *pcd;
-
-                        printk(KERN_INFO "PCACHE_DESC\n");
-
-                        pcd = ptr_to_pcache_desc(page);
-                        page = pcd->master;
-                        page_cache_get_speculative(page);
-
-                        unreplicate_pcache(mapping, page->index, 0);
-
-                        goto export;
-                }
-                
                 if (radix_tree_exception(page)) {
                         if (radix_tree_deref_retry(page)) {
                                 /*
@@ -1385,7 +1327,7 @@ repeat:
                         page_cache_release(page);
                         goto repeat;
                 }
-export:
+
                 /*
                  * must check mapping and index after taking the ref.
                  * otherwise we can get both false positives and false
@@ -1436,20 +1378,6 @@ repeat:
                 if (unlikely(!page))
                         continue;
 
-                if (is_pcache_desc(page)) {
-                        struct pcache_desc *pcd;
-
-                        printk(KERN_INFO "PCACHE_DESC BUG!!!!!!!!!!\n");
-
-                        pcd = ptr_to_pcache_desc(page);
-                        page = pcd->master;
-                        page_cache_get_speculative(page);
-
-                        unreplicate_pcache(mapping, page->index, 0);
-
-                        goto export;
-                }
-                
                 if (radix_tree_exception(page)) {
                         if (radix_tree_deref_retry(page)) {
                                 /*
@@ -1481,7 +1409,7 @@ repeat:
                         page_cache_release(page);
                         goto repeat;
                 }
-export:
+
                 pages[ret] = page;
                 if (++ret == nr_pages)
                         break;
@@ -1557,11 +1485,7 @@ static ssize_t do_generic_file_read(struct file *filp, loff_t *ppos,
 
                 cond_resched();
 find_page:
-                if (is_realtime(current))
-                        page = find_get_page_readonly(mapping, index);
-                else
-                        page = find_get_page(mapping, index);
-                
+                page = find_get_page(mapping, index);
                 if (!page) {
                         page_cache_sync_readahead(mapping,
                                         ra, filp,
@@ -1713,8 +1637,7 @@ readpage:
                         unlock_page(page);
                 }
 
-                page_cache_release(page);
-                goto find_page;
+                goto page_ok;
 
 readpage_error:
                 /* UHHUH! A synchronous read error occurred. Report it */
@@ -1958,11 +1881,7 @@ int filemap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
         /*
          * Do we have something in the page cache already?
          */
-        if ((vmf->flags & FAULT_FLAG_WRITE) || !is_realtime(current))
-                page = find_get_page(mapping, offset);
-        else
-                page = find_get_page_readonly(mapping, offset);
-        
+        page = find_get_page(mapping, offset);
         if (likely(page) && !(vmf->flags & FAULT_FLAG_TRIED)) {
                 /*
                  * We found the page, so try async readahead before
@@ -1976,10 +1895,7 @@ int filemap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
                 mem_cgroup_count_vm_event(vma->vm_mm, PGMAJFAULT);
                 ret = VM_FAULT_MAJOR;
 retry_find:
-                if ((vmf->flags & FAULT_FLAG_WRITE) || !is_realtime(current))
-                        page = find_get_page(mapping, offset);
-                else
-                        page = find_get_page_readonly(mapping, offset);
+                page = find_get_page(mapping, offset);
                 if (!page)
                         goto no_cached_page;
         }
@@ -2087,22 +2003,6 @@ repeat:
                 page = radix_tree_deref_slot(slot);
                 if (unlikely(!page))
                         goto next;
-                
-                if (is_pcache_desc(page)) {
-                        struct pcache_desc *pcd;
-
-printk(KERN_INFO "PCACHE_DESC FILE_MAP_PAGES\n");
-
-                        pcd = ptr_to_pcache_desc(page);
-                        page = pcd->master;
-                        if (!page_cache_get_speculative(page))
-                                goto repeat;
-                        
-                        //unreplicate_pcache(mapping, page->index, 0);
-
-                        goto export;
-                }
-                
                 if (radix_tree_exception(page)) {
                         if (radix_tree_deref_retry(page))
                                 break;
@@ -2118,7 +2018,7 @@ printk(KERN_INFO "PCACHE_DESC FILE_MAP_PAGES\n");
                         page_cache_release(page);
                         goto repeat;
                 }
-export:
+
                 if (!PageUptodate(page) ||
                                 PageReadahead(page) ||
                                 PageHWPoison(page))
diff --git a/mm/internal.h b/mm/internal.h
index ccc349b59d00..a25e359a4039 100644
--- a/mm/internal.h
+++ b/mm/internal.h
@@ -433,14 +433,4 @@ unsigned long reclaim_clean_pages_from_list(struct zone *zone,
 #define ALLOC_CMA               0x80 /* allow allocations from CMA areas */
 #define ALLOC_FAIR              0x100 /* fair zone allocation */
 
-extern int reclaim_replicated_page(struct address_space *mapping,
-                struct page *page);
-extern struct page *find_get_page_readonly(struct address_space *mapping,
-                                                unsigned long offset);
-extern int is_pcache_desc(void *ptr);
-extern struct pcache_desc *ptr_to_pcache_desc(void *ptr);
-extern void *pcache_desc_to_ptr(struct pcache_desc *pcd);
-extern void unreplicate_pcache(struct address_space *mapping, unsigned long offset, int locked);
-int page_write_fault_retry(struct page *page);
-
 #endif  /* __MM_INTERNAL_H */
diff --git a/mm/memory.c b/mm/memory.c
index 1fc358bec6d5..22e037e3364e 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -2231,24 +2231,15 @@ static int wp_page_shared(struct mm_struct *mm, struct vm_area_struct *vma,
          * read-only shared pages can get COWed by
          * get_user_pages(.write=1, .force=1).
          */
-//      if (vma->vm_ops && vma->vm_ops->page_mkwrite) {
-        {
+        if (vma->vm_ops && vma->vm_ops->page_mkwrite) {
                 int tmp;
 
                 pte_unmap_unlock(page_table, ptl);
-                
-                if (page_write_fault_retry(old_page)) {
+                tmp = do_page_mkwrite(vma, old_page, address);
+                if (unlikely(!tmp || (tmp &
+                                      (VM_FAULT_ERROR | VM_FAULT_NOPAGE)))) {
                         page_cache_release(old_page);
-                        return 0;
-                }
-                
-                if (vma->vm_ops && vma->vm_ops->page_mkwrite) {
-                        tmp = do_page_mkwrite(vma, old_page, address);
-                        if (unlikely(!tmp || (tmp &
-                                                  (VM_FAULT_ERROR | VM_FAULT_NOPAGE)))) {
-                                page_cache_release(old_page);
-                                return tmp;
-                        }
+                        return tmp;
                 }
                 /*
                  * Since we dropped the lock we need to revalidate
diff --git a/mm/migrate.c b/mm/migrate.c
index d25cc2c2736d..a2e9cad083d5 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -405,7 +405,6 @@ int replicate_page_move_mapping(struct address_space *mapping,
                 struct buffer_head *head, enum migrate_mode mode,
                 int extra_count)
 {
-        int expected_count = 1 + extra_count;
         int prev_count = page_count(page);
         void **pslot;
 
@@ -415,38 +414,6 @@ int replicate_page_move_mapping(struct address_space *mapping,
 
         pslot = radix_tree_lookup_slot(&mapping->page_tree, page_index(page));
 
-        expected_count += 1 + page_has_private(page);
-        
-        TRACE_TASK(current, "page_count(page) = %d, expected_count = %d, page_has_private? %d\n", page_count(page), expected_count, page_has_private(page));
-/*      
-        if (page_count(page) != expected_count ||
-                radix_tree_deref_slot_protected(pslot, &mapping->tree_lock) != page) {
-                spin_unlock_irq(&mapping->tree_lock);
-                TRACE_TASK(current, "1\n");
-                return -EAGAIN;
-        }
-
-        if (!page_freeze_refs(page, expected_count)) { // if page_count(page) == expected_count, then set page_count = 0
-                spin_unlock_irq(&mapping->tree_lock);
-                TRACE_TASK(current, "2\n");
-                return -EAGAIN;
-        }
-*/
-        /*
-         * In the async migration case of moving a page with buffers, lock the
-         * buffers using trylock before the mapping is moved. If the mapping
-         * was moved, we later failed to lock the buffers and could not move
-         * the mapping back due to an elevated page count, we would have to
-         * block waiting on other references to be dropped.
-         */
-/*      if (mode == MIGRATE_ASYNC && head &&
-                        !buffer_migrate_lock_buffers(head, mode)) {
-                page_unfreeze_refs(page, expected_count);
-                spin_unlock_irq(&mapping->tree_lock);
-                TRACE_TASK(current, "3\n");
-                return -EAGAIN;
-        }
-*/
         /*
          * Now we know that no one else is looking at the page.
          */
@@ -456,15 +423,11 @@ int replicate_page_move_mapping(struct address_space *mapping,
                 set_page_private(newpage, page_private(page));
         }
 
-        //radix_tree_replace_slot(pslot, newpage);
-        //radix_tree_replace_slot(pslot, page);
-
         /*
          * Drop cache reference from old page by unfreezing
-         * to one less reference.
+         * to the previous reference.
          * We know this isn't the last reference.
          */
-        //page_unfreeze_refs(page, expected_count - 1);
         page_unfreeze_refs(page, prev_count);
         
         /*
@@ -702,7 +665,6 @@ void replicate_page_copy(struct page *newpage, struct page *page)
          */
         if (PageWriteback(newpage))
                 end_page_writeback(newpage);
-        TRACE_TASK(current, "replicate_page_copy done!\n");
 }
 
 /************************************************************
@@ -742,7 +704,6 @@ int replicate_page(struct address_space *mapping,
         BUG_ON(PageWriteback(page));    /* Writeback must be complete */
 
         rc = replicate_page_move_mapping(mapping, newpage, page, NULL, mode, extra_count);
-        TRACE_TASK(current, "replicate_page_move_mapping returned %d\n", rc);
         if (rc != MIGRATEPAGE_SUCCESS)
                 return rc;
 
@@ -975,19 +936,9 @@ static int copy_to_new_page(struct page *newpage, struct page *page,
                 rc = migrate_page(mapping, newpage, page, mode);
         }
         else if (mapping->a_ops->migratepage) {
-                TRACE_TASK(current, "ops migration callback\n");
-                /*
-                 * Most pages have a mapping and most filesystems provide a
-                 * migratepage callback. Anonymous pages are part of swap
-                 * space which also has its own migratepage callback. This
-                 * is the most common path for page migration.
-                 */
-                //rc = mapping->a_ops->migratepage(mapping,
-                //                              newpage, page, mode);
                 rc = replicate_page(mapping, newpage, page, mode, has_replica);
         }
         else {
-                TRACE_TASK(current, "fallback function\n");
                 rc = fallback_migrate_page(mapping, newpage, page, mode);
         }
 
@@ -995,10 +946,8 @@ static int copy_to_new_page(struct page *newpage, struct page *page,
                 newpage->mapping = NULL;
         } else {
                 if (page_was_mapped) {
-                        TRACE_TASK(current, "PAGE_WAS_MAPPED = 1\n");
                         remove_migration_ptes(page, newpage);
                 }
-                //page->mapping = NULL;
         }
 
         unlock_page(newpage);
@@ -1178,76 +1127,18 @@ static int __unmap_and_copy(struct page *page, struct page *newpage,
 
         if (PageWriteback(page)) {
                 /*
-                 * Only in the case of a full synchronous migration is it
-                 * necessary to wait for PageWriteback. In the async case,
-                 * the retry loop is too short and in the sync-light case,
-                 * the overhead of stalling is too much
+                 * The code of shared library cannot be written.
                  */
                 BUG();
-                /*
-                if (mode != MIGRATE_SYNC) {
-                        rc = -EBUSY;
-                        goto out_unlock;
-                }
-                if (!force)
-                        goto out_unlock;
-                wait_on_page_writeback(page);
-                */
         }
-        /*
-         * By try_to_unmap(), page->mapcount goes down to 0 here. In this case,
-         * we cannot notice that anon_vma is freed while we migrates a page.
-         * This get_anon_vma() delays freeing anon_vma pointer until the end
-         * of migration. File cache pages are no problem because of page_lock()
-         * File Caches may use write_page() or lock_page() in migration, then,
-         * just care Anon page here.
-         */
+
         if (PageAnon(page) && !PageKsm(page)) {
-                printk(KERN_INFO "ANON but not KSM\n");
+                /* The shared library pages must be backed by a file. */
                 BUG();
-                /*
-                 * Only page_lock_anon_vma_read() understands the subtleties of
-                 * getting a hold on an anon_vma from outside one of its mms.
-                 */
-/*
-                anon_vma = page_get_anon_vma(page);
-                if (anon_vma) {
-*/
-                        /*
-                         * Anon page
-                         */
-/*
-                } else if (PageSwapCache(page)) {
-*/
-                        /*
-                         * We cannot be sure that the anon_vma of an unmapped
-                         * swapcache page is safe to use because we don't
-                         * know in advance if the VMA that this page belonged
-                         * to still exists. If the VMA and others sharing the
-                         * data have been freed, then the anon_vma could
-                         * already be invalid.
-                         *
-                         * To avoid this possibility, swapcache pages get
-                         * migrated but are not remapped when migration
-                         * completes
-                         */
-/*              } else {
-                        goto out_unlock;
-                }
-*/              
         }
 
         if (unlikely(isolated_balloon_page(page))) {
                 BUG();
-                /*
-                 * A ballooned page does not need any special attention from
-                 * physical to virtual reverse mapping procedures.
-                 * Skip any attempt to unmap PTEs or to remap swap cache,
-                 * in order to avoid burning cycles at rmap level, and perform
-                 * the page migration right away (proteced by page lock).
-                 */
-                rc = balloon_page_migrate(newpage, page, mode);
-                goto out_unlock;
         }
 
         /*
@@ -1273,22 +1164,17 @@ static int __unmap_and_copy(struct page *page, struct page *newpage,
 
         /* Establish migration ptes or remove ptes */
         if (page_mapped(page)) {
-                // ttu_ret = try_to_unmap(page, TTU_MIGRATION|TTU_IGNORE_MLOCK|TTU_IGNORE_ACCESS);
                 struct rmap_walk_control rwc = {
                         .rmap_one = try_to_unmap_one_only,
                         .arg = (void *)(TTU_MIGRATION|TTU_IGNORE_MLOCK|TTU_IGNORE_ACCESS),
                 };
-                
                 ttu_ret = rmap_walk(page, &rwc);
                 
                 page_was_mapped = 1;
-                TRACE_TASK(current, "Page %d unmapped from all PTEs\n", page_to_pfn(page));
         }
 
 skip_unmap:
-        //if (!page_mapped(page)) {
         if (ttu_ret == SWAP_SUCCESS) {
-                TRACE_TASK(current, "Call copy_to_new_page\n");
                 rc = copy_to_new_page(newpage, page, page_was_mapped, mode, has_replica);
         } else if (ttu_ret == SWAP_AGAIN)
                 printk(KERN_ERR "rmap_walk returned SWAP_AGAIN\n");
@@ -1418,16 +1304,13 @@ static ICE_noinline int unmap_and_copy(new_page_t get_new_page,
                 newpage = get_new_page(page, private, &result);
                 if (!newpage)
                         return -ENOMEM;
-                //printk(KERN_ERR "Page %lx allocated\n", page_to_pfn(newpage));
         } else {
                 newpage = lib_page->r_page[cpu];
                 has_replica = 1;
-                //printk(KERN_ERR "Page %lx found\n", page_to_pfn(newpage));
         }
 
         if (page_count(page) == 1) {
                 /* page was freed from under us. So we are done. */
-                TRACE_TASK(current, "page %x _count == 1\n", page_to_pfn(page));
                 goto out;
         }
 
@@ -1443,7 +1326,6 @@ static ICE_noinline int unmap_and_copy(new_page_t get_new_page,
         }
         
 out:
-TRACE_TASK(current, "__unmap_and_copy returned %s\n", rc==MIGRATEPAGE_SUCCESS?"SUCCESS":"FAIL");
         if (rc != -EAGAIN) {
                 /*
                  * A page that has been migrated has all references
@@ -1457,7 +1339,6 @@ TRACE_TASK(current, "__unmap_and_copy returned %s\n", rc==MIGRATEPAGE_SUCCESS?"S
                 putback_lru_page(page);
         }
         
-//TRACE_TASK(current, "old page freed\n");
         /*
          * If migration was not successful and there's a freeing callback, use
          * it.  Otherwise, putback_lru_page() will drop the reference grabbed
diff --git a/mm/page-writeback.c b/mm/page-writeback.c
index 161af608b7e2..7e39ffceb566 100644
--- a/mm/page-writeback.c
+++ b/mm/page-writeback.c
@@ -2287,8 +2287,7 @@ int clear_page_dirty_for_io(struct page *page)
 
         BUG_ON(!PageLocked(page));
 
-        //if (mapping && mapping_cap_account_dirty(mapping)) {
-        if (mapping) {
+        if (mapping && mapping_cap_account_dirty(mapping)) {
                 /*
                  * Yes, Virginia, this is indeed insane.
                  *
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 3ffde2a09765..950c002bbb45 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -662,7 +662,7 @@ static inline int free_pages_check(struct page *page)
         if (unlikely(page_mapcount(page)))
                 bad_reason = "nonzero mapcount";
         if (unlikely(page->mapping != NULL))
-                bad_reason = "non-NULL mapping free_check";
+                bad_reason = "non-NULL mapping";
         if (unlikely(atomic_read(&page->_count) != 0))
                 bad_reason = "nonzero _count";
         if (unlikely(page->flags & PAGE_FLAGS_CHECK_AT_FREE)) {
diff --git a/mm/vmscan.c b/mm/vmscan.c
index b9b6bef90169..5e8eadd71bac 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -582,7 +582,6 @@ static int __remove_mapping(struct address_space *mapping, struct page *page,
         BUG_ON(!PageLocked(page));
         BUG_ON(mapping != page_mapping(page));
 
-again:
         spin_lock_irq(&mapping->tree_lock);
         /*
          * The non racy check for a busy page.
@@ -641,11 +640,7 @@ again:
                 if (reclaimed && page_is_file_cache(page) &&
                     !mapping_exiting(mapping))
                         shadow = workingset_eviction(mapping, page);
-                if (PageReplicated(page)) {
-                        if (reclaim_replicated_page(mapping, page))
-                                goto again;
-                } else
-                        __delete_from_page_cache(page, shadow);
+                __delete_from_page_cache(page, shadow);
                 spin_unlock_irq(&mapping->tree_lock);
 
                 if (freepage != NULL)
diff --git a/mm/vmstat.c b/mm/vmstat.c
index 6af8ea00cbef..4f5cd974e11a 100644
--- a/mm/vmstat.c
+++ b/mm/vmstat.c
@@ -708,7 +708,6 @@ const char * const vmstat_text[] = {
         "nr_anon_pages",
         "nr_mapped",
         "nr_file_pages",
-        "nr_repl_pages",
         "nr_dirty",
         "nr_writeback",
         "nr_slab_reclaimable",
@@ -761,9 +760,6 @@ const char * const vmstat_text[] = {
         "pgfault",
         "pgmajfault",
 
-        "pgreplicated",
-        "pgreplicazap",
-        
         TEXTS_FOR_ZONES("pgrefill")
         TEXTS_FOR_ZONES("pgsteal_kswapd")
         TEXTS_FOR_ZONES("pgsteal_direct")