10 files changed, 20 insertions, 269 deletions

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")