mm: remove offlining arg to migrate_pages

No functional change, but the only purpose of the offlining argument to
migrate_pages() etc, was to ensure that __unmap_and_move() could migrate a
KSM page for memory hotremove (which took ksm_thread_mutex) but not for
other callers.  Now all cases are safe, remove the arg.

Signed-off-by: Hugh Dickins <hughd@google.com>
Cc: Rik van Riel <riel@redhat.com>
Cc: Petr Holasek <pholasek@redhat.com>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Izik Eidus <izik.eidus@ravellosystems.com>
Cc: Gerald Schaefer <gerald.schaefer@de.ibm.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

6 files changed, 23 insertions, 38 deletions

diff --git a/mm/compaction.c b/mm/compaction.c
index ef53f352b606..25e75e3e2ac6 100644
--- a/mm/compaction.c
+++ b/mm/compaction.c
@@ -980,7 +980,7 @@ static int compact_zone(struct zone *zone, struct compact_control *cc)
 
                 nr_migrate = cc->nr_migratepages;
                 err = migrate_pages(&cc->migratepages, compaction_alloc,
-                                (unsigned long)cc, false,
+                                (unsigned long)cc,
                                 cc->sync ? MIGRATE_SYNC_LIGHT : MIGRATE_ASYNC,
                                 MR_COMPACTION);
                 update_nr_listpages(cc);
diff --git a/mm/memory-failure.c b/mm/memory-failure.c
index 1a56d63adf9c..e4683459ab26 100644
--- a/mm/memory-failure.c
+++ b/mm/memory-failure.c
@@ -1465,7 +1465,7 @@ static int soft_offline_huge_page(struct page *page, int flags)
         unlock_page(hpage);
 
         /* Keep page count to indicate a given hugepage is isolated. */
-        ret = migrate_huge_page(hpage, new_page, MPOL_MF_MOVE_ALL, false,
+        ret = migrate_huge_page(hpage, new_page, MPOL_MF_MOVE_ALL,
                                 MIGRATE_SYNC);
         put_page(hpage);
         if (ret) {
@@ -1597,11 +1597,10 @@ static int __soft_offline_page(struct page *page, int flags)
         if (!ret) {
                 LIST_HEAD(pagelist);
                 inc_zone_page_state(page, NR_ISOLATED_ANON +
-                                            page_is_file_cache(page));
+                                        page_is_file_cache(page));
                 list_add(&page->lru, &pagelist);
                 ret = migrate_pages(&pagelist, new_page, MPOL_MF_MOVE_ALL,
-                                                        false, MIGRATE_SYNC,
-                                                        MR_MEMORY_FAILURE);
+                                        MIGRATE_SYNC, MR_MEMORY_FAILURE);
                 if (ret) {
                         putback_lru_pages(&pagelist);
                         pr_info("soft offline: %#lx: migration failed %d, type %lx\n",
diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
index 77a6abfe3291..dda1ca695a08 100644
--- a/mm/memory_hotplug.c
+++ b/mm/memory_hotplug.c
@@ -1286,8 +1286,7 @@ do_migrate_range(unsigned long start_pfn, unsigned long end_pfn)
                  * migrate_pages returns # of failed pages.
                  */
                 ret = migrate_pages(&source, alloc_migrate_target, 0,
-                                                        true, MIGRATE_SYNC,
-                                                        MR_MEMORY_HOTPLUG);
+                                        MIGRATE_SYNC, MR_MEMORY_HOTPLUG);
                 if (ret)
                         putback_lru_pages(&source);
         }
diff --git a/mm/mempolicy.c b/mm/mempolicy.c
index d344c36db63f..e2661d1c5c33 100644
--- a/mm/mempolicy.c
+++ b/mm/mempolicy.c
@@ -1014,8 +1014,7 @@ static int migrate_to_node(struct mm_struct *mm, int source, int dest,
 
         if (!list_empty(&pagelist)) {
                 err = migrate_pages(&pagelist, new_node_page, dest,
-                                                        false, MIGRATE_SYNC,
-                                                        MR_SYSCALL);
+                                        MIGRATE_SYNC, MR_SYSCALL);
                 if (err)
                         putback_lru_pages(&pagelist);
         }
@@ -1259,9 +1258,8 @@ static long do_mbind(unsigned long start, unsigned long len,
                 if (!list_empty(&pagelist)) {
                         WARN_ON_ONCE(flags & MPOL_MF_LAZY);
                         nr_failed = migrate_pages(&pagelist, new_vma_page,
-                                                (unsigned long)vma,
-                                                false, MIGRATE_SYNC,
-                                                MR_MEMPOLICY_MBIND);
+                                        (unsigned long)vma,
+                                        MIGRATE_SYNC, MR_MEMPOLICY_MBIND);
                         if (nr_failed)
                                 putback_lru_pages(&pagelist);
                 }
diff --git a/mm/migrate.c b/mm/migrate.c
index 20a03eb0667f..3bbaf5d230b0 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -701,7 +701,7 @@ static int move_to_new_page(struct page *newpage, struct page *page,
 }
 
 static int __unmap_and_move(struct page *page, struct page *newpage,
-                        int force, bool offlining, enum migrate_mode mode)
+                                int force, enum migrate_mode mode)
 {
         int rc = -EAGAIN;
         int remap_swapcache = 1;
@@ -847,8 +847,7 @@ out:
  * to the newly allocated page in newpage.
  */
 static int unmap_and_move(new_page_t get_new_page, unsigned long private,
-                        struct page *page, int force, bool offlining,
-                        enum migrate_mode mode)
+                        struct page *page, int force, enum migrate_mode mode)
 {
         int rc = 0;
         int *result = NULL;
@@ -866,7 +865,7 @@ static int unmap_and_move(new_page_t get_new_page, unsigned long private,
                 if (unlikely(split_huge_page(page)))
                         goto out;
 
-        rc = __unmap_and_move(page, newpage, force, offlining, mode);
+        rc = __unmap_and_move(page, newpage, force, mode);
 
         if (unlikely(rc == MIGRATEPAGE_BALLOON_SUCCESS)) {
                 /*
@@ -926,8 +925,7 @@ out:
  */
 static int unmap_and_move_huge_page(new_page_t get_new_page,
                                 unsigned long private, struct page *hpage,
-                                int force, bool offlining,
-                                enum migrate_mode mode)
+                                int force, enum migrate_mode mode)
 {
         int rc = 0;
         int *result = NULL;
@@ -989,9 +987,8 @@ out:
  *
  * Return: Number of pages not migrated or error code.
  */
-int migrate_pages(struct list_head *from,
-                new_page_t get_new_page, unsigned long private, bool offlining,
-                enum migrate_mode mode, int reason)
+int migrate_pages(struct list_head *from, new_page_t get_new_page,
+                unsigned long private, enum migrate_mode mode, int reason)
 {
         int retry = 1;
         int nr_failed = 0;
@@ -1012,8 +1009,7 @@ int migrate_pages(struct list_head *from,
                         cond_resched();
 
                         rc = unmap_and_move(get_new_page, private,
-                                                page, pass > 2, offlining,
-                                                mode);
+                                                page, pass > 2, mode);
 
                         switch(rc) {
                         case -ENOMEM:
@@ -1046,15 +1042,13 @@ out:
 }
 
 int migrate_huge_page(struct page *hpage, new_page_t get_new_page,
-                      unsigned long private, bool offlining,
-                      enum migrate_mode mode)
+                      unsigned long private, enum migrate_mode mode)
 {
         int pass, rc;
 
         for (pass = 0; pass < 10; pass++) {
-                rc = unmap_and_move_huge_page(get_new_page,
-                                              private, hpage, pass > 2, offlining,
-                                              mode);
+                rc = unmap_and_move_huge_page(get_new_page, private,
+                                                hpage, pass > 2, mode);
                 switch (rc) {
                 case -ENOMEM:
                         goto out;
@@ -1177,8 +1171,7 @@ set_status:
         err = 0;
         if (!list_empty(&pagelist)) {
                 err = migrate_pages(&pagelist, new_page_node,
-                                (unsigned long)pm, 0, MIGRATE_SYNC,
-                                MR_SYSCALL);
+                                (unsigned long)pm, MIGRATE_SYNC, MR_SYSCALL);
                 if (err)
                         putback_lru_pages(&pagelist);
         }
@@ -1613,10 +1606,8 @@ int migrate_misplaced_page(struct page *page, int node)
                 goto out;
 
         list_add(&page->lru, &migratepages);
-        nr_remaining = migrate_pages(&migratepages,
-                        alloc_misplaced_dst_page,
-                        node, false, MIGRATE_ASYNC,
-                        MR_NUMA_MISPLACED);
+        nr_remaining = migrate_pages(&migratepages, alloc_misplaced_dst_page,
+                                     node, MIGRATE_ASYNC, MR_NUMA_MISPLACED);
         if (nr_remaining) {
                 putback_lru_pages(&migratepages);
                 isolated = 0;
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 445718b328b6..64c83a8c3220 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -6084,10 +6084,8 @@ static int __alloc_contig_migrate_range(struct compact_control *cc,
                                                         &cc->migratepages);
                 cc->nr_migratepages -= nr_reclaimed;
 
-                ret = migrate_pages(&cc->migratepages,
-                                    alloc_migrate_target,
-                                    0, false, MIGRATE_SYNC,
-                                    MR_CMA);
+                ret = migrate_pages(&cc->migratepages, alloc_migrate_target,
+                                    0, MIGRATE_SYNC, MR_CMA);
         }
         if (ret < 0) {
                 putback_movable_pages(&cc->migratepages);