1 files changed, 59 insertions, 13 deletions

diff --git a/mm/migrate.c b/mm/migrate.c
index d3f3f7f81075..09e2471afa0f 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -40,7 +40,8 @@
 
 /*
  * migrate_prep() needs to be called before we start compiling a list of pages
- * to be migrated using isolate_lru_page().
+ * to be migrated using isolate_lru_page(). If scheduling work on other CPUs is
+ * undesirable, use migrate_prep_local()
  */
 int migrate_prep(void)
 {
@@ -55,26 +56,29 @@ int migrate_prep(void)
         return 0;
 }
 
+/* Do the necessary work of migrate_prep but not if it involves other CPUs */
+int migrate_prep_local(void)
+{
+        lru_add_drain();
+
+        return 0;
+}
+
 /*
  * Add isolated pages on the list back to the LRU under page lock
  * to avoid leaking evictable pages back onto unevictable list.
- *
- * returns the number of pages put back.
  */
-int putback_lru_pages(struct list_head *l)
+void putback_lru_pages(struct list_head *l)
 {
         struct page *page;
         struct page *page2;
-        int count = 0;
 
         list_for_each_entry_safe(page, page2, l, lru) {
                 list_del(&page->lru);
                 dec_zone_page_state(page, NR_ISOLATED_ANON +
                                 page_is_file_cache(page));
                 putback_lru_page(page);
-                count++;
         }
-        return count;
 }
 
 /*
@@ -490,7 +494,8 @@ static int fallback_migrate_page(struct address_space *mapping,
  *   < 0 - error code
  *  == 0 - success
  */
-static int move_to_new_page(struct page *newpage, struct page *page)
+static int move_to_new_page(struct page *newpage, struct page *page,
+                                                int remap_swapcache)
 {
         struct address_space *mapping;
         int rc;
@@ -525,10 +530,12 @@ static int move_to_new_page(struct page *newpage, struct page *page)
         else
                 rc = fallback_migrate_page(mapping, newpage, page);
 
-        if (!rc)
-                remove_migration_ptes(page, newpage);
-        else
+        if (rc) {
                 newpage->mapping = NULL;
+        } else {
+                if (remap_swapcache)
+                        remove_migration_ptes(page, newpage);
+        }
 
         unlock_page(newpage);
 
@@ -545,9 +552,11 @@ static int unmap_and_move(new_page_t get_new_page, unsigned long private,
         int rc = 0;
         int *result = NULL;
         struct page *newpage = get_new_page(page, private, &result);
+        int remap_swapcache = 1;
         int rcu_locked = 0;
         int charge = 0;
         struct mem_cgroup *mem = NULL;
+        struct anon_vma *anon_vma = NULL;
 
         if (!newpage)
                 return -ENOMEM;
@@ -604,6 +613,34 @@ static int unmap_and_move(new_page_t get_new_page, unsigned long private,
         if (PageAnon(page)) {
                 rcu_read_lock();
                 rcu_locked = 1;
+
+                /* Determine how to safely use anon_vma */
+                if (!page_mapped(page)) {
+                        if (!PageSwapCache(page))
+                                goto rcu_unlock;
+
+                        /*
+                         * 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
+                         */
+                        remap_swapcache = 0;
+                } else {
+                        /*
+                         * Take a reference count on the anon_vma if the
+                         * page is mapped so that it is guaranteed to
+                         * exist when the page is remapped later
+                         */
+                        anon_vma = page_anon_vma(page);
+                        atomic_inc(&anon_vma->external_refcount);
+                }
         }
 
         /*
@@ -638,11 +675,20 @@ static int unmap_and_move(new_page_t get_new_page, unsigned long private,
 
 skip_unmap:
         if (!page_mapped(page))
-                rc = move_to_new_page(newpage, page);
+                rc = move_to_new_page(newpage, page, remap_swapcache);
 
-        if (rc)
+        if (rc && remap_swapcache)
                 remove_migration_ptes(page, page);
 rcu_unlock:
+
+        /* Drop an anon_vma reference if we took one */
+        if (anon_vma && atomic_dec_and_lock(&anon_vma->external_refcount, &anon_vma->lock)) {
+                int empty = list_empty(&anon_vma->head);
+                spin_unlock(&anon_vma->lock);
+                if (empty)
+                        anon_vma_free(anon_vma);
+        }
+
         if (rcu_locked)
                 rcu_read_unlock();
 uncharge: