~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/mm/migrate.c

Version: ~ [ linux-5.5-rc7 ] ~ [ linux-5.4.13 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.97 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.166 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.210 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.210 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Memory Migration functionality - linux/mm/migrate.c
  3  *
  4  * Copyright (C) 2006 Silicon Graphics, Inc., Christoph Lameter
  5  *
  6  * Page migration was first developed in the context of the memory hotplug
  7  * project. The main authors of the migration code are:
  8  *
  9  * IWAMOTO Toshihiro <iwamoto@valinux.co.jp>
 10  * Hirokazu Takahashi <taka@valinux.co.jp>
 11  * Dave Hansen <haveblue@us.ibm.com>
 12  * Christoph Lameter
 13  */
 14 
 15 #include <linux/migrate.h>
 16 #include <linux/export.h>
 17 #include <linux/swap.h>
 18 #include <linux/swapops.h>
 19 #include <linux/pagemap.h>
 20 #include <linux/buffer_head.h>
 21 #include <linux/mm_inline.h>
 22 #include <linux/nsproxy.h>
 23 #include <linux/pagevec.h>
 24 #include <linux/ksm.h>
 25 #include <linux/rmap.h>
 26 #include <linux/topology.h>
 27 #include <linux/cpu.h>
 28 #include <linux/cpuset.h>
 29 #include <linux/writeback.h>
 30 #include <linux/mempolicy.h>
 31 #include <linux/vmalloc.h>
 32 #include <linux/security.h>
 33 #include <linux/backing-dev.h>
 34 #include <linux/syscalls.h>
 35 #include <linux/hugetlb.h>
 36 #include <linux/hugetlb_cgroup.h>
 37 #include <linux/gfp.h>
 38 #include <linux/balloon_compaction.h>
 39 #include <linux/mmu_notifier.h>
 40 #include <linux/page_idle.h>
 41 #include <linux/page_owner.h>
 42 
 43 #include <asm/tlbflush.h>
 44 
 45 #define CREATE_TRACE_POINTS
 46 #include <trace/events/migrate.h>
 47 
 48 #include "internal.h"
 49 
 50 /*
 51  * migrate_prep() needs to be called before we start compiling a list of pages
 52  * to be migrated using isolate_lru_page(). If scheduling work on other CPUs is
 53  * undesirable, use migrate_prep_local()
 54  */
 55 int migrate_prep(void)
 56 {
 57         /*
 58          * Clear the LRU lists so pages can be isolated.
 59          * Note that pages may be moved off the LRU after we have
 60          * drained them. Those pages will fail to migrate like other
 61          * pages that may be busy.
 62          */
 63         lru_add_drain_all();
 64 
 65         return 0;
 66 }
 67 
 68 /* Do the necessary work of migrate_prep but not if it involves other CPUs */
 69 int migrate_prep_local(void)
 70 {
 71         lru_add_drain();
 72 
 73         return 0;
 74 }
 75 
 76 /*
 77  * Put previously isolated pages back onto the appropriate lists
 78  * from where they were once taken off for compaction/migration.
 79  *
 80  * This function shall be used whenever the isolated pageset has been
 81  * built from lru, balloon, hugetlbfs page. See isolate_migratepages_range()
 82  * and isolate_huge_page().
 83  */
 84 void putback_movable_pages(struct list_head *l)
 85 {
 86         struct page *page;
 87         struct page *page2;
 88 
 89         list_for_each_entry_safe(page, page2, l, lru) {
 90                 if (unlikely(PageHuge(page))) {
 91                         putback_active_hugepage(page);
 92                         continue;
 93                 }
 94                 list_del(&page->lru);
 95                 dec_zone_page_state(page, NR_ISOLATED_ANON +
 96                                 page_is_file_cache(page));
 97                 if (unlikely(isolated_balloon_page(page)))
 98                         balloon_page_putback(page);
 99                 else
100                         putback_lru_page(page);
101         }
102 }
103 
104 /*
105  * Restore a potential migration pte to a working pte entry
106  */
107 static int remove_migration_pte(struct page *new, struct vm_area_struct *vma,
108                                  unsigned long addr, void *old)
109 {
110         struct mm_struct *mm = vma->vm_mm;
111         swp_entry_t entry;
112         pmd_t *pmd;
113         pte_t *ptep, pte;
114         spinlock_t *ptl;
115 
116         if (unlikely(PageHuge(new))) {
117                 ptep = huge_pte_offset(mm, addr);
118                 if (!ptep)
119                         goto out;
120                 ptl = huge_pte_lockptr(hstate_vma(vma), mm, ptep);
121         } else {
122                 pmd = mm_find_pmd(mm, addr);
123                 if (!pmd)
124                         goto out;
125 
126                 ptep = pte_offset_map(pmd, addr);
127 
128                 /*
129                  * Peek to check is_swap_pte() before taking ptlock?  No, we
130                  * can race mremap's move_ptes(), which skips anon_vma lock.
131                  */
132 
133                 ptl = pte_lockptr(mm, pmd);
134         }
135 
136         spin_lock(ptl);
137         pte = *ptep;
138         if (!is_swap_pte(pte))
139                 goto unlock;
140 
141         entry = pte_to_swp_entry(pte);
142 
143         if (!is_migration_entry(entry) ||
144             migration_entry_to_page(entry) != old)
145                 goto unlock;
146 
147         get_page(new);
148         pte = pte_mkold(mk_pte(new, vma->vm_page_prot));
149         if (pte_swp_soft_dirty(*ptep))
150                 pte = pte_mksoft_dirty(pte);
151 
152         /* Recheck VMA as permissions can change since migration started  */
153         if (is_write_migration_entry(entry))
154                 pte = maybe_mkwrite(pte, vma);
155 
156 #ifdef CONFIG_HUGETLB_PAGE
157         if (PageHuge(new)) {
158                 pte = pte_mkhuge(pte);
159                 pte = arch_make_huge_pte(pte, vma, new, 0);
160         }
161 #endif
162         flush_dcache_page(new);
163         set_pte_at(mm, addr, ptep, pte);
164 
165         if (PageHuge(new)) {
166                 if (PageAnon(new))
167                         hugepage_add_anon_rmap(new, vma, addr);
168                 else
169                         page_dup_rmap(new, true);
170         } else if (PageAnon(new))
171                 page_add_anon_rmap(new, vma, addr, false);
172         else
173                 page_add_file_rmap(new);
174 
175         if (vma->vm_flags & VM_LOCKED && !PageTransCompound(new))
176                 mlock_vma_page(new);
177 
178         /* No need to invalidate - it was non-present before */
179         update_mmu_cache(vma, addr, ptep);
180 unlock:
181         pte_unmap_unlock(ptep, ptl);
182 out:
183         return SWAP_AGAIN;
184 }
185 
186 /*
187  * Get rid of all migration entries and replace them by
188  * references to the indicated page.
189  */
190 void remove_migration_ptes(struct page *old, struct page *new, bool locked)
191 {
192         struct rmap_walk_control rwc = {
193                 .rmap_one = remove_migration_pte,
194                 .arg = old,
195         };
196 
197         if (locked)
198                 rmap_walk_locked(new, &rwc);
199         else
200                 rmap_walk(new, &rwc);
201 }
202 
203 /*
204  * Something used the pte of a page under migration. We need to
205  * get to the page and wait until migration is finished.
206  * When we return from this function the fault will be retried.
207  */
208 void __migration_entry_wait(struct mm_struct *mm, pte_t *ptep,
209                                 spinlock_t *ptl)
210 {
211         pte_t pte;
212         swp_entry_t entry;
213         struct page *page;
214 
215         spin_lock(ptl);
216         pte = *ptep;
217         if (!is_swap_pte(pte))
218                 goto out;
219 
220         entry = pte_to_swp_entry(pte);
221         if (!is_migration_entry(entry))
222                 goto out;
223 
224         page = migration_entry_to_page(entry);
225 
226         /*
227          * Once radix-tree replacement of page migration started, page_count
228          * *must* be zero. And, we don't want to call wait_on_page_locked()
229          * against a page without get_page().
230          * So, we use get_page_unless_zero(), here. Even failed, page fault
231          * will occur again.
232          */
233         if (!get_page_unless_zero(page))
234                 goto out;
235         pte_unmap_unlock(ptep, ptl);
236         wait_on_page_locked(page);
237         put_page(page);
238         return;
239 out:
240         pte_unmap_unlock(ptep, ptl);
241 }
242 
243 void migration_entry_wait(struct mm_struct *mm, pmd_t *pmd,
244                                 unsigned long address)
245 {
246         spinlock_t *ptl = pte_lockptr(mm, pmd);
247         pte_t *ptep = pte_offset_map(pmd, address);
248         __migration_entry_wait(mm, ptep, ptl);
249 }
250 
251 void migration_entry_wait_huge(struct vm_area_struct *vma,
252                 struct mm_struct *mm, pte_t *pte)
253 {
254         spinlock_t *ptl = huge_pte_lockptr(hstate_vma(vma), mm, pte);
255         __migration_entry_wait(mm, pte, ptl);
256 }
257 
258 #ifdef CONFIG_BLOCK
259 /* Returns true if all buffers are successfully locked */
260 static bool buffer_migrate_lock_buffers(struct buffer_head *head,
261                                                         enum migrate_mode mode)
262 {
263         struct buffer_head *bh = head;
264 
265         /* Simple case, sync compaction */
266         if (mode != MIGRATE_ASYNC) {
267                 do {
268                         get_bh(bh);
269                         lock_buffer(bh);
270                         bh = bh->b_this_page;
271 
272                 } while (bh != head);
273 
274                 return true;
275         }
276 
277         /* async case, we cannot block on lock_buffer so use trylock_buffer */
278         do {
279                 get_bh(bh);
280                 if (!trylock_buffer(bh)) {
281                         /*
282                          * We failed to lock the buffer and cannot stall in
283                          * async migration. Release the taken locks
284                          */
285                         struct buffer_head *failed_bh = bh;
286                         put_bh(failed_bh);
287                         bh = head;
288                         while (bh != failed_bh) {
289                                 unlock_buffer(bh);
290                                 put_bh(bh);
291                                 bh = bh->b_this_page;
292                         }
293                         return false;
294                 }
295 
296                 bh = bh->b_this_page;
297         } while (bh != head);
298         return true;
299 }
300 #else
301 static inline bool buffer_migrate_lock_buffers(struct buffer_head *head,
302                                                         enum migrate_mode mode)
303 {
304         return true;
305 }
306 #endif /* CONFIG_BLOCK */
307 
308 /*
309  * Replace the page in the mapping.
310  *
311  * The number of remaining references must be:
312  * 1 for anonymous pages without a mapping
313  * 2 for pages with a mapping
314  * 3 for pages with a mapping and PagePrivate/PagePrivate2 set.
315  */
316 int migrate_page_move_mapping(struct address_space *mapping,
317                 struct page *newpage, struct page *page,
318                 struct buffer_head *head, enum migrate_mode mode,
319                 int extra_count)
320 {
321         struct zone *oldzone, *newzone;
322         int dirty;
323         int expected_count = 1 + extra_count;
324         void **pslot;
325 
326         if (!mapping) {
327                 /* Anonymous page without mapping */
328                 if (page_count(page) != expected_count)
329                         return -EAGAIN;
330 
331                 /* No turning back from here */
332                 newpage->index = page->index;
333                 newpage->mapping = page->mapping;
334                 if (PageSwapBacked(page))
335                         SetPageSwapBacked(newpage);
336 
337                 return MIGRATEPAGE_SUCCESS;
338         }
339 
340         oldzone = page_zone(page);
341         newzone = page_zone(newpage);
342 
343         spin_lock_irq(&mapping->tree_lock);
344 
345         pslot = radix_tree_lookup_slot(&mapping->page_tree,
346                                         page_index(page));
347 
348         expected_count += 1 + page_has_private(page);
349         if (page_count(page) != expected_count ||
350                 radix_tree_deref_slot_protected(pslot, &mapping->tree_lock) != page) {
351                 spin_unlock_irq(&mapping->tree_lock);
352                 return -EAGAIN;
353         }
354 
355         if (!page_ref_freeze(page, expected_count)) {
356                 spin_unlock_irq(&mapping->tree_lock);
357                 return -EAGAIN;
358         }
359 
360         /*
361          * In the async migration case of moving a page with buffers, lock the
362          * buffers using trylock before the mapping is moved. If the mapping
363          * was moved, we later failed to lock the buffers and could not move
364          * the mapping back due to an elevated page count, we would have to
365          * block waiting on other references to be dropped.
366          */
367         if (mode == MIGRATE_ASYNC && head &&
368                         !buffer_migrate_lock_buffers(head, mode)) {
369                 page_ref_unfreeze(page, expected_count);
370                 spin_unlock_irq(&mapping->tree_lock);
371                 return -EAGAIN;
372         }
373 
374         /*
375          * Now we know that no one else is looking at the page:
376          * no turning back from here.
377          */
378         newpage->index = page->index;
379         newpage->mapping = page->mapping;
380         if (PageSwapBacked(page))
381                 SetPageSwapBacked(newpage);
382 
383         get_page(newpage);      /* add cache reference */
384         if (PageSwapCache(page)) {
385                 SetPageSwapCache(newpage);
386                 set_page_private(newpage, page_private(page));
387         }
388 
389         /* Move dirty while page refs frozen and newpage not yet exposed */
390         dirty = PageDirty(page);
391         if (dirty) {
392                 ClearPageDirty(page);
393                 SetPageDirty(newpage);
394         }
395 
396         radix_tree_replace_slot(pslot, newpage);
397 
398         /*
399          * Drop cache reference from old page by unfreezing
400          * to one less reference.
401          * We know this isn't the last reference.
402          */
403         page_ref_unfreeze(page, expected_count - 1);
404 
405         spin_unlock(&mapping->tree_lock);
406         /* Leave irq disabled to prevent preemption while updating stats */
407 
408         /*
409          * If moved to a different zone then also account
410          * the page for that zone. Other VM counters will be
411          * taken care of when we establish references to the
412          * new page and drop references to the old page.
413          *
414          * Note that anonymous pages are accounted for
415          * via NR_FILE_PAGES and NR_ANON_PAGES if they
416          * are mapped to swap space.
417          */
418         if (newzone != oldzone) {
419                 __dec_zone_state(oldzone, NR_FILE_PAGES);
420                 __inc_zone_state(newzone, NR_FILE_PAGES);
421                 if (PageSwapBacked(page) && !PageSwapCache(page)) {
422                         __dec_zone_state(oldzone, NR_SHMEM);
423                         __inc_zone_state(newzone, NR_SHMEM);
424                 }
425                 if (dirty && mapping_cap_account_dirty(mapping)) {
426                         __dec_zone_state(oldzone, NR_FILE_DIRTY);
427                         __inc_zone_state(newzone, NR_FILE_DIRTY);
428                 }
429         }
430         local_irq_enable();
431 
432         return MIGRATEPAGE_SUCCESS;
433 }
434 EXPORT_SYMBOL(migrate_page_move_mapping);
435 
436 /*
437  * The expected number of remaining references is the same as that
438  * of migrate_page_move_mapping().
439  */
440 int migrate_huge_page_move_mapping(struct address_space *mapping,
441                                    struct page *newpage, struct page *page)
442 {
443         int expected_count;
444         void **pslot;
445 
446         spin_lock_irq(&mapping->tree_lock);
447 
448         pslot = radix_tree_lookup_slot(&mapping->page_tree,
449                                         page_index(page));
450 
451         expected_count = 2 + page_has_private(page);
452         if (page_count(page) != expected_count ||
453                 radix_tree_deref_slot_protected(pslot, &mapping->tree_lock) != page) {
454                 spin_unlock_irq(&mapping->tree_lock);
455                 return -EAGAIN;
456         }
457 
458         if (!page_ref_freeze(page, expected_count)) {
459                 spin_unlock_irq(&mapping->tree_lock);
460                 return -EAGAIN;
461         }
462 
463         newpage->index = page->index;
464         newpage->mapping = page->mapping;
465 
466         get_page(newpage);
467 
468         radix_tree_replace_slot(pslot, newpage);
469 
470         page_ref_unfreeze(page, expected_count - 1);
471 
472         spin_unlock_irq(&mapping->tree_lock);
473 
474         return MIGRATEPAGE_SUCCESS;
475 }
476 
477 /*
478  * Gigantic pages are so large that we do not guarantee that page++ pointer
479  * arithmetic will work across the entire page.  We need something more
480  * specialized.
481  */
482 static void __copy_gigantic_page(struct page *dst, struct page *src,
483                                 int nr_pages)
484 {
485         int i;
486         struct page *dst_base = dst;
487         struct page *src_base = src;
488 
489         for (i = 0; i < nr_pages; ) {
490                 cond_resched();
491                 copy_highpage(dst, src);
492 
493                 i++;
494                 dst = mem_map_next(dst, dst_base, i);
495                 src = mem_map_next(src, src_base, i);
496         }
497 }
498 
499 static void copy_huge_page(struct page *dst, struct page *src)
500 {
501         int i;
502         int nr_pages;
503 
504         if (PageHuge(src)) {
505                 /* hugetlbfs page */
506                 struct hstate *h = page_hstate(src);
507                 nr_pages = pages_per_huge_page(h);
508 
509                 if (unlikely(nr_pages > MAX_ORDER_NR_PAGES)) {
510                         __copy_gigantic_page(dst, src, nr_pages);
511                         return;
512                 }
513         } else {
514                 /* thp page */
515                 BUG_ON(!PageTransHuge(src));
516                 nr_pages = hpage_nr_pages(src);
517         }
518 
519         for (i = 0; i < nr_pages; i++) {
520                 cond_resched();
521                 copy_highpage(dst + i, src + i);
522         }
523 }
524 
525 /*
526  * Copy the page to its new location
527  */
528 void migrate_page_copy(struct page *newpage, struct page *page)
529 {
530         int cpupid;
531 
532         if (PageHuge(page) || PageTransHuge(page))
533                 copy_huge_page(newpage, page);
534         else
535                 copy_highpage(newpage, page);
536 
537         if (PageError(page))
538                 SetPageError(newpage);
539         if (PageReferenced(page))
540                 SetPageReferenced(newpage);
541         if (PageUptodate(page))
542                 SetPageUptodate(newpage);
543         if (TestClearPageActive(page)) {
544                 VM_BUG_ON_PAGE(PageUnevictable(page), page);
545                 SetPageActive(newpage);
546         } else if (TestClearPageUnevictable(page))
547                 SetPageUnevictable(newpage);
548         if (PageChecked(page))
549                 SetPageChecked(newpage);
550         if (PageMappedToDisk(page))
551                 SetPageMappedToDisk(newpage);
552 
553         /* Move dirty on pages not done by migrate_page_move_mapping() */
554         if (PageDirty(page))
555                 SetPageDirty(newpage);
556 
557         if (page_is_young(page))
558                 set_page_young(newpage);
559         if (page_is_idle(page))
560                 set_page_idle(newpage);
561 
562         /*
563          * Copy NUMA information to the new page, to prevent over-eager
564          * future migrations of this same page.
565          */
566         cpupid = page_cpupid_xchg_last(page, -1);
567         page_cpupid_xchg_last(newpage, cpupid);
568 
569         ksm_migrate_page(newpage, page);
570         /*
571          * Please do not reorder this without considering how mm/ksm.c's
572          * get_ksm_page() depends upon ksm_migrate_page() and PageSwapCache().
573          */
574         if (PageSwapCache(page))
575                 ClearPageSwapCache(page);
576         ClearPagePrivate(page);
577         set_page_private(page, 0);
578 
579         /*
580          * If any waiters have accumulated on the new page then
581          * wake them up.
582          */
583         if (PageWriteback(newpage))
584                 end_page_writeback(newpage);
585 
586         copy_page_owner(page, newpage);
587 
588         mem_cgroup_migrate(page, newpage);
589 }
590 EXPORT_SYMBOL(migrate_page_copy);
591 
592 /************************************************************
593  *                    Migration functions
594  ***********************************************************/
595 
596 /*
597  * Common logic to directly migrate a single page suitable for
598  * pages that do not use PagePrivate/PagePrivate2.
599  *
600  * Pages are locked upon entry and exit.
601  */
602 int migrate_page(struct address_space *mapping,
603                 struct page *newpage, struct page *page,
604                 enum migrate_mode mode)
605 {
606         int rc;
607 
608         BUG_ON(PageWriteback(page));    /* Writeback must be complete */
609 
610         rc = migrate_page_move_mapping(mapping, newpage, page, NULL, mode, 0);
611 
612         if (rc != MIGRATEPAGE_SUCCESS)
613                 return rc;
614 
615         migrate_page_copy(newpage, page);
616         return MIGRATEPAGE_SUCCESS;
617 }
618 EXPORT_SYMBOL(migrate_page);
619 
620 #ifdef CONFIG_BLOCK
621 /*
622  * Migration function for pages with buffers. This function can only be used
623  * if the underlying filesystem guarantees that no other references to "page"
624  * exist.
625  */
626 int buffer_migrate_page(struct address_space *mapping,
627                 struct page *newpage, struct page *page, enum migrate_mode mode)
628 {
629         struct buffer_head *bh, *head;
630         int rc;
631 
632         if (!page_has_buffers(page))
633                 return migrate_page(mapping, newpage, page, mode);
634 
635         head = page_buffers(page);
636 
637         rc = migrate_page_move_mapping(mapping, newpage, page, head, mode, 0);
638 
639         if (rc != MIGRATEPAGE_SUCCESS)
640                 return rc;
641 
642         /*
643          * In the async case, migrate_page_move_mapping locked the buffers
644          * with an IRQ-safe spinlock held. In the sync case, the buffers
645          * need to be locked now
646          */
647         if (mode != MIGRATE_ASYNC)
648                 BUG_ON(!buffer_migrate_lock_buffers(head, mode));
649 
650         ClearPagePrivate(page);
651         set_page_private(newpage, page_private(page));
652         set_page_private(page, 0);
653         put_page(page);
654         get_page(newpage);
655 
656         bh = head;
657         do {
658                 set_bh_page(bh, newpage, bh_offset(bh));
659                 bh = bh->b_this_page;
660 
661         } while (bh != head);
662 
663         SetPagePrivate(newpage);
664 
665         migrate_page_copy(newpage, page);
666 
667         bh = head;
668         do {
669                 unlock_buffer(bh);
670                 put_bh(bh);
671                 bh = bh->b_this_page;
672 
673         } while (bh != head);
674 
675         return MIGRATEPAGE_SUCCESS;
676 }
677 EXPORT_SYMBOL(buffer_migrate_page);
678 #endif
679 
680 /*
681  * Writeback a page to clean the dirty state
682  */
683 static int writeout(struct address_space *mapping, struct page *page)
684 {
685         struct writeback_control wbc = {
686                 .sync_mode = WB_SYNC_NONE,
687                 .nr_to_write = 1,
688                 .range_start = 0,
689                 .range_end = LLONG_MAX,
690                 .for_reclaim = 1
691         };
692         int rc;
693 
694         if (!mapping->a_ops->writepage)
695                 /* No write method for the address space */
696                 return -EINVAL;
697 
698         if (!clear_page_dirty_for_io(page))
699                 /* Someone else already triggered a write */
700                 return -EAGAIN;
701 
702         /*
703          * A dirty page may imply that the underlying filesystem has
704          * the page on some queue. So the page must be clean for
705          * migration. Writeout may mean we loose the lock and the
706          * page state is no longer what we checked for earlier.
707          * At this point we know that the migration attempt cannot
708          * be successful.
709          */
710         remove_migration_ptes(page, page, false);
711 
712         rc = mapping->a_ops->writepage(page, &wbc);
713 
714         if (rc != AOP_WRITEPAGE_ACTIVATE)
715                 /* unlocked. Relock */
716                 lock_page(page);
717 
718         return (rc < 0) ? -EIO : -EAGAIN;
719 }
720 
721 /*
722  * Default handling if a filesystem does not provide a migration function.
723  */
724 static int fallback_migrate_page(struct address_space *mapping,
725         struct page *newpage, struct page *page, enum migrate_mode mode)
726 {
727         if (PageDirty(page)) {
728                 /* Only writeback pages in full synchronous migration */
729                 if (mode != MIGRATE_SYNC)
730                         return -EBUSY;
731                 return writeout(mapping, page);
732         }
733 
734         /*
735          * Buffers may be managed in a filesystem specific way.
736          * We must have no buffers or drop them.
737          */
738         if (page_has_private(page) &&
739             !try_to_release_page(page, GFP_KERNEL))
740                 return -EAGAIN;
741 
742         return migrate_page(mapping, newpage, page, mode);
743 }
744 
745 /*
746  * Move a page to a newly allocated page
747  * The page is locked and all ptes have been successfully removed.
748  *
749  * The new page will have replaced the old page if this function
750  * is successful.
751  *
752  * Return value:
753  *   < 0 - error code
754  *  MIGRATEPAGE_SUCCESS - success
755  */
756 static int move_to_new_page(struct page *newpage, struct page *page,
757                                 enum migrate_mode mode)
758 {
759         struct address_space *mapping;
760         int rc;
761 
762         VM_BUG_ON_PAGE(!PageLocked(page), page);
763         VM_BUG_ON_PAGE(!PageLocked(newpage), newpage);
764 
765         mapping = page_mapping(page);
766         if (!mapping)
767                 rc = migrate_page(mapping, newpage, page, mode);
768         else if (mapping->a_ops->migratepage)
769                 /*
770                  * Most pages have a mapping and most filesystems provide a
771                  * migratepage callback. Anonymous pages are part of swap
772                  * space which also has its own migratepage callback. This
773                  * is the most common path for page migration.
774                  */
775                 rc = mapping->a_ops->migratepage(mapping, newpage, page, mode);
776         else
777                 rc = fallback_migrate_page(mapping, newpage, page, mode);
778 
779         /*
780          * When successful, old pagecache page->mapping must be cleared before
781          * page is freed; but stats require that PageAnon be left as PageAnon.
782          */
783         if (rc == MIGRATEPAGE_SUCCESS) {
784                 if (!PageAnon(page))
785                         page->mapping = NULL;
786         }
787         return rc;
788 }
789 
790 static int __unmap_and_move(struct page *page, struct page *newpage,
791                                 int force, enum migrate_mode mode)
792 {
793         int rc = -EAGAIN;
794         int page_was_mapped = 0;
795         struct anon_vma *anon_vma = NULL;
796 
797         if (!trylock_page(page)) {
798                 if (!force || mode == MIGRATE_ASYNC)
799                         goto out;
800 
801                 /*
802                  * It's not safe for direct compaction to call lock_page.
803                  * For example, during page readahead pages are added locked
804                  * to the LRU. Later, when the IO completes the pages are
805                  * marked uptodate and unlocked. However, the queueing
806                  * could be merging multiple pages for one bio (e.g.
807                  * mpage_readpages). If an allocation happens for the
808                  * second or third page, the process can end up locking
809                  * the same page twice and deadlocking. Rather than
810                  * trying to be clever about what pages can be locked,
811                  * avoid the use of lock_page for direct compaction
812                  * altogether.
813                  */
814                 if (current->flags & PF_MEMALLOC)
815                         goto out;
816 
817                 lock_page(page);
818         }
819 
820         if (PageWriteback(page)) {
821                 /*
822                  * Only in the case of a full synchronous migration is it
823                  * necessary to wait for PageWriteback. In the async case,
824                  * the retry loop is too short and in the sync-light case,
825                  * the overhead of stalling is too much
826                  */
827                 if (mode != MIGRATE_SYNC) {
828                         rc = -EBUSY;
829                         goto out_unlock;
830                 }
831                 if (!force)
832                         goto out_unlock;
833                 wait_on_page_writeback(page);
834         }
835 
836         /*
837          * By try_to_unmap(), page->mapcount goes down to 0 here. In this case,
838          * we cannot notice that anon_vma is freed while we migrates a page.
839          * This get_anon_vma() delays freeing anon_vma pointer until the end
840          * of migration. File cache pages are no problem because of page_lock()
841          * File Caches may use write_page() or lock_page() in migration, then,
842          * just care Anon page here.
843          *
844          * Only page_get_anon_vma() understands the subtleties of
845          * getting a hold on an anon_vma from outside one of its mms.
846          * But if we cannot get anon_vma, then we won't need it anyway,
847          * because that implies that the anon page is no longer mapped
848          * (and cannot be remapped so long as we hold the page lock).
849          */
850         if (PageAnon(page) && !PageKsm(page))
851                 anon_vma = page_get_anon_vma(page);
852 
853         /*
854          * Block others from accessing the new page when we get around to
855          * establishing additional references. We are usually the only one
856          * holding a reference to newpage at this point. We used to have a BUG
857          * here if trylock_page(newpage) fails, but would like to allow for
858          * cases where there might be a race with the previous use of newpage.
859          * This is much like races on refcount of oldpage: just don't BUG().
860          */
861         if (unlikely(!trylock_page(newpage)))
862                 goto out_unlock;
863 
864         if (unlikely(isolated_balloon_page(page))) {
865                 /*
866                  * A ballooned page does not need any special attention from
867                  * physical to virtual reverse mapping procedures.
868                  * Skip any attempt to unmap PTEs or to remap swap cache,
869                  * in order to avoid burning cycles at rmap level, and perform
870                  * the page migration right away (proteced by page lock).
871                  */
872                 rc = balloon_page_migrate(newpage, page, mode);
873                 goto out_unlock_both;
874         }
875 
876         /*
877          * Corner case handling:
878          * 1. When a new swap-cache page is read into, it is added to the LRU
879          * and treated as swapcache but it has no rmap yet.
880          * Calling try_to_unmap() against a page->mapping==NULL page will
881          * trigger a BUG.  So handle it here.
882          * 2. An orphaned page (see truncate_complete_page) might have
883          * fs-private metadata. The page can be picked up due to memory
884          * offlining.  Everywhere else except page reclaim, the page is
885          * invisible to the vm, so the page can not be migrated.  So try to
886          * free the metadata, so the page can be freed.
887          */
888         if (!page->mapping) {
889                 VM_BUG_ON_PAGE(PageAnon(page), page);
890                 if (page_has_private(page)) {
891                         try_to_free_buffers(page);
892                         goto out_unlock_both;
893                 }
894         } else if (page_mapped(page)) {
895                 /* Establish migration ptes */
896                 VM_BUG_ON_PAGE(PageAnon(page) && !PageKsm(page) && !anon_vma,
897                                 page);
898                 try_to_unmap(page,
899                         TTU_MIGRATION|TTU_IGNORE_MLOCK|TTU_IGNORE_ACCESS);
900                 page_was_mapped = 1;
901         }
902 
903         if (!page_mapped(page))
904                 rc = move_to_new_page(newpage, page, mode);
905 
906         if (page_was_mapped)
907                 remove_migration_ptes(page,
908                         rc == MIGRATEPAGE_SUCCESS ? newpage : page, false);
909 
910 out_unlock_both:
911         unlock_page(newpage);
912 out_unlock:
913         /* Drop an anon_vma reference if we took one */
914         if (anon_vma)
915                 put_anon_vma(anon_vma);
916         unlock_page(page);
917 out:
918         return rc;
919 }
920 
921 /*
922  * gcc 4.7 and 4.8 on arm get an ICEs when inlining unmap_and_move().  Work
923  * around it.
924  */
925 #if (GCC_VERSION >= 40700 && GCC_VERSION < 40900) && defined(CONFIG_ARM)
926 #define ICE_noinline noinline
927 #else
928 #define ICE_noinline
929 #endif
930 
931 /*
932  * Obtain the lock on page, remove all ptes and migrate the page
933  * to the newly allocated page in newpage.
934  */
935 static ICE_noinline int unmap_and_move(new_page_t get_new_page,
936                                    free_page_t put_new_page,
937                                    unsigned long private, struct page *page,
938                                    int force, enum migrate_mode mode,
939                                    enum migrate_reason reason)
940 {
941         int rc = MIGRATEPAGE_SUCCESS;
942         int *result = NULL;
943         struct page *newpage;
944 
945         newpage = get_new_page(page, private, &result);
946         if (!newpage)
947                 return -ENOMEM;
948 
949         if (page_count(page) == 1) {
950                 /* page was freed from under us. So we are done. */
951                 goto out;
952         }
953 
954         if (unlikely(PageTransHuge(page))) {
955                 lock_page(page);
956                 rc = split_huge_page(page);
957                 unlock_page(page);
958                 if (rc)
959                         goto out;
960         }
961 
962         rc = __unmap_and_move(page, newpage, force, mode);
963         if (rc == MIGRATEPAGE_SUCCESS) {
964                 put_new_page = NULL;
965                 set_page_owner_migrate_reason(newpage, reason);
966         }
967 
968 out:
969         if (rc != -EAGAIN) {
970                 /*
971                  * A page that has been migrated has all references
972                  * removed and will be freed. A page that has not been
973                  * migrated will have kepts its references and be
974                  * restored.
975                  */
976                 list_del(&page->lru);
977                 dec_zone_page_state(page, NR_ISOLATED_ANON +
978                                 page_is_file_cache(page));
979                 /* Soft-offlined page shouldn't go through lru cache list */
980                 if (reason == MR_MEMORY_FAILURE && rc == MIGRATEPAGE_SUCCESS) {
981                         /*
982                          * With this release, we free successfully migrated
983                          * page and set PG_HWPoison on just freed page
984                          * intentionally. Although it's rather weird, it's how
985                          * HWPoison flag works at the moment.
986                          */
987                         put_page(page);
988                         if (!test_set_page_hwpoison(page))
989                                 num_poisoned_pages_inc();
990                 } else
991                         putback_lru_page(page);
992         }
993 
994         /*
995          * If migration was not successful and there's a freeing callback, use
996          * it.  Otherwise, putback_lru_page() will drop the reference grabbed
997          * during isolation.
998          */
999         if (put_new_page)
1000                 put_new_page(newpage, private);
1001         else if (unlikely(__is_movable_balloon_page(newpage))) {
1002                 /* drop our reference, page already in the balloon */
1003                 put_page(newpage);
1004         } else
1005                 putback_lru_page(newpage);
1006 
1007         if (result) {
1008                 if (rc)
1009                         *result = rc;
1010                 else
1011                         *result = page_to_nid(newpage);
1012         }
1013         return rc;
1014 }
1015 
1016 /*
1017  * Counterpart of unmap_and_move_page() for hugepage migration.
1018  *
1019  * This function doesn't wait the completion of hugepage I/O
1020  * because there is no race between I/O and migration for hugepage.
1021  * Note that currently hugepage I/O occurs only in direct I/O
1022  * where no lock is held and PG_writeback is irrelevant,
1023  * and writeback status of all subpages are counted in the reference
1024  * count of the head page (i.e. if all subpages of a 2MB hugepage are
1025  * under direct I/O, the reference of the head page is 512 and a bit more.)
1026  * This means that when we try to migrate hugepage whose subpages are
1027  * doing direct I/O, some references remain after try_to_unmap() and
1028  * hugepage migration fails without data corruption.
1029  *
1030  * There is also no race when direct I/O is issued on the page under migration,
1031  * because then pte is replaced with migration swap entry and direct I/O code
1032  * will wait in the page fault for migration to complete.
1033  */
1034 static int unmap_and_move_huge_page(new_page_t get_new_page,
1035                                 free_page_t put_new_page, unsigned long private,
1036                                 struct page *hpage, int force,
1037                                 enum migrate_mode mode, int reason)
1038 {
1039         int rc = -EAGAIN;
1040         int *result = NULL;
1041         int page_was_mapped = 0;
1042         struct page *new_hpage;
1043         struct anon_vma *anon_vma = NULL;
1044 
1045         /*
1046          * Movability of hugepages depends on architectures and hugepage size.
1047          * This check is necessary because some callers of hugepage migration
1048          * like soft offline and memory hotremove don't walk through page
1049          * tables or check whether the hugepage is pmd-based or not before
1050          * kicking migration.
1051          */
1052         if (!hugepage_migration_supported(page_hstate(hpage))) {
1053                 putback_active_hugepage(hpage);
1054                 return -ENOSYS;
1055         }
1056 
1057         new_hpage = get_new_page(hpage, private, &result);
1058         if (!new_hpage)
1059                 return -ENOMEM;
1060 
1061         if (!trylock_page(hpage)) {
1062                 if (!force || mode != MIGRATE_SYNC)
1063                         goto out;
1064                 lock_page(hpage);
1065         }
1066 
1067         if (PageAnon(hpage))
1068                 anon_vma = page_get_anon_vma(hpage);
1069 
1070         if (unlikely(!trylock_page(new_hpage)))
1071                 goto put_anon;
1072 
1073         if (page_mapped(hpage)) {
1074                 try_to_unmap(hpage,
1075                         TTU_MIGRATION|TTU_IGNORE_MLOCK|TTU_IGNORE_ACCESS);
1076                 page_was_mapped = 1;
1077         }
1078 
1079         if (!page_mapped(hpage))
1080                 rc = move_to_new_page(new_hpage, hpage, mode);
1081 
1082         if (page_was_mapped)
1083                 remove_migration_ptes(hpage,
1084                         rc == MIGRATEPAGE_SUCCESS ? new_hpage : hpage, false);
1085 
1086         unlock_page(new_hpage);
1087 
1088 put_anon:
1089         if (anon_vma)
1090                 put_anon_vma(anon_vma);
1091 
1092         if (rc == MIGRATEPAGE_SUCCESS) {
1093                 hugetlb_cgroup_migrate(hpage, new_hpage);
1094                 put_new_page = NULL;
1095                 set_page_owner_migrate_reason(new_hpage, reason);
1096         }
1097 
1098         unlock_page(hpage);
1099 out:
1100         if (rc != -EAGAIN)
1101                 putback_active_hugepage(hpage);
1102 
1103         /*
1104          * If migration was not successful and there's a freeing callback, use
1105          * it.  Otherwise, put_page() will drop the reference grabbed during
1106          * isolation.
1107          */
1108         if (put_new_page)
1109                 put_new_page(new_hpage, private);
1110         else
1111                 putback_active_hugepage(new_hpage);
1112 
1113         if (result) {
1114                 if (rc)
1115                         *result = rc;
1116                 else
1117                         *result = page_to_nid(new_hpage);
1118         }
1119         return rc;
1120 }
1121 
1122 /*
1123  * migrate_pages - migrate the pages specified in a list, to the free pages
1124  *                 supplied as the target for the page migration
1125  *
1126  * @from:               The list of pages to be migrated.
1127  * @get_new_page:       The function used to allocate free pages to be used
1128  *                      as the target of the page migration.
1129  * @put_new_page:       The function used to free target pages if migration
1130  *                      fails, or NULL if no special handling is necessary.
1131  * @private:            Private data to be passed on to get_new_page()
1132  * @mode:               The migration mode that specifies the constraints for
1133  *                      page migration, if any.
1134  * @reason:             The reason for page migration.
1135  *
1136  * The function returns after 10 attempts or if no pages are movable any more
1137  * because the list has become empty or no retryable pages exist any more.
1138  * The caller should call putback_movable_pages() to return pages to the LRU
1139  * or free list only if ret != 0.
1140  *
1141  * Returns the number of pages that were not migrated, or an error code.
1142  */
1143 int migrate_pages(struct list_head *from, new_page_t get_new_page,
1144                 free_page_t put_new_page, unsigned long private,
1145                 enum migrate_mode mode, int reason)
1146 {
1147         int retry = 1;
1148         int nr_failed = 0;
1149         int nr_succeeded = 0;
1150         int pass = 0;
1151         struct page *page;
1152         struct page *page2;
1153         int swapwrite = current->flags & PF_SWAPWRITE;
1154         int rc;
1155 
1156         if (!swapwrite)
1157                 current->flags |= PF_SWAPWRITE;
1158 
1159         for(pass = 0; pass < 10 && retry; pass++) {
1160                 retry = 0;
1161 
1162                 list_for_each_entry_safe(page, page2, from, lru) {
1163                         cond_resched();
1164 
1165                         if (PageHuge(page))
1166                                 rc = unmap_and_move_huge_page(get_new_page,
1167                                                 put_new_page, private, page,
1168                                                 pass > 2, mode, reason);
1169                         else
1170                                 rc = unmap_and_move(get_new_page, put_new_page,
1171                                                 private, page, pass > 2, mode,
1172                                                 reason);
1173 
1174                         switch(rc) {
1175                         case -ENOMEM:
1176                                 goto out;
1177                         case -EAGAIN:
1178                                 retry++;
1179                                 break;
1180                         case MIGRATEPAGE_SUCCESS:
1181                                 nr_succeeded++;
1182                                 break;
1183                         default:
1184                                 /*
1185                                  * Permanent failure (-EBUSY, -ENOSYS, etc.):
1186                                  * unlike -EAGAIN case, the failed page is
1187                                  * removed from migration page list and not
1188                                  * retried in the next outer loop.
1189                                  */
1190                                 nr_failed++;
1191                                 break;
1192                         }
1193                 }
1194         }
1195         nr_failed += retry;
1196         rc = nr_failed;
1197 out:
1198         if (nr_succeeded)
1199                 count_vm_events(PGMIGRATE_SUCCESS, nr_succeeded);
1200         if (nr_failed)
1201                 count_vm_events(PGMIGRATE_FAIL, nr_failed);
1202         trace_mm_migrate_pages(nr_succeeded, nr_failed, mode, reason);
1203 
1204         if (!swapwrite)
1205                 current->flags &= ~PF_SWAPWRITE;
1206 
1207         return rc;
1208 }
1209 
1210 #ifdef CONFIG_NUMA
1211 /*
1212  * Move a list of individual pages
1213  */
1214 struct page_to_node {
1215         unsigned long addr;
1216         struct page *page;
1217         int node;
1218         int status;
1219 };
1220 
1221 static struct page *new_page_node(struct page *p, unsigned long private,
1222                 int **result)
1223 {
1224         struct page_to_node *pm = (struct page_to_node *)private;
1225 
1226         while (pm->node != MAX_NUMNODES && pm->page != p)
1227                 pm++;
1228 
1229         if (pm->node == MAX_NUMNODES)
1230                 return NULL;
1231 
1232         *result = &pm->status;
1233 
1234         if (PageHuge(p))
1235                 return alloc_huge_page_node(page_hstate(compound_head(p)),
1236                                         pm->node);
1237         else
1238                 return __alloc_pages_node(pm->node,
1239                                 GFP_HIGHUSER_MOVABLE | __GFP_THISNODE, 0);
1240 }
1241 
1242 /*
1243  * Move a set of pages as indicated in the pm array. The addr
1244  * field must be set to the virtual address of the page to be moved
1245  * and the node number must contain a valid target node.
1246  * The pm array ends with node = MAX_NUMNODES.
1247  */
1248 static int do_move_page_to_node_array(struct mm_struct *mm,
1249                                       struct page_to_node *pm,
1250                                       int migrate_all)
1251 {
1252         int err;
1253         struct page_to_node *pp;
1254         LIST_HEAD(pagelist);
1255 
1256         down_read(&mm->mmap_sem);
1257 
1258         /*
1259          * Build a list of pages to migrate
1260          */
1261         for (pp = pm; pp->node != MAX_NUMNODES; pp++) {
1262                 struct vm_area_struct *vma;
1263                 struct page *page;
1264 
1265                 err = -EFAULT;
1266                 vma = find_vma(mm, pp->addr);
1267                 if (!vma || pp->addr < vma->vm_start || !vma_migratable(vma))
1268                         goto set_status;
1269 
1270                 /* FOLL_DUMP to ignore special (like zero) pages */
1271                 page = follow_page(vma, pp->addr,
1272                                 FOLL_GET | FOLL_SPLIT | FOLL_DUMP);
1273 
1274                 err = PTR_ERR(page);
1275                 if (IS_ERR(page))
1276                         goto set_status;
1277 
1278                 err = -ENOENT;
1279                 if (!page)
1280                         goto set_status;
1281 
1282                 pp->page = page;
1283                 err = page_to_nid(page);
1284 
1285                 if (err == pp->node)
1286                         /*
1287                          * Node already in the right place
1288                          */
1289                         goto put_and_set;
1290 
1291                 err = -EACCES;
1292                 if (page_mapcount(page) > 1 &&
1293                                 !migrate_all)
1294                         goto put_and_set;
1295 
1296                 if (PageHuge(page)) {
1297                         if (PageHead(page))
1298                                 isolate_huge_page(page, &pagelist);
1299                         goto put_and_set;
1300                 }
1301 
1302                 err = isolate_lru_page(page);
1303                 if (!err) {
1304                         list_add_tail(&page->lru, &pagelist);
1305                         inc_zone_page_state(page, NR_ISOLATED_ANON +
1306                                             page_is_file_cache(page));
1307                 }
1308 put_and_set:
1309                 /*
1310                  * Either remove the duplicate refcount from
1311                  * isolate_lru_page() or drop the page ref if it was
1312                  * not isolated.
1313                  */
1314                 put_page(page);
1315 set_status:
1316                 pp->status = err;
1317         }
1318 
1319         err = 0;
1320         if (!list_empty(&pagelist)) {
1321                 err = migrate_pages(&pagelist, new_page_node, NULL,
1322                                 (unsigned long)pm, MIGRATE_SYNC, MR_SYSCALL);
1323                 if (err)
1324                         putback_movable_pages(&pagelist);
1325         }
1326 
1327         up_read(&mm->mmap_sem);
1328         return err;
1329 }
1330 
1331 /*
1332  * Migrate an array of page address onto an array of nodes and fill
1333  * the corresponding array of status.
1334  */
1335 static int do_pages_move(struct mm_struct *mm, nodemask_t task_nodes,
1336                          unsigned long nr_pages,
1337                          const void __user * __user *pages,
1338                          const int __user *nodes,
1339                          int __user *status, int flags)
1340 {
1341         struct page_to_node *pm;
1342         unsigned long chunk_nr_pages;
1343         unsigned long chunk_start;
1344         int err;
1345 
1346         err = -ENOMEM;
1347         pm = (struct page_to_node *)__get_free_page(GFP_KERNEL);
1348         if (!pm)
1349                 goto out;
1350 
1351         migrate_prep();
1352 
1353         /*
1354          * Store a chunk of page_to_node array in a page,
1355          * but keep the last one as a marker
1356          */
1357         chunk_nr_pages = (PAGE_SIZE / sizeof(struct page_to_node)) - 1;
1358 
1359         for (chunk_start = 0;
1360              chunk_start < nr_pages;
1361              chunk_start += chunk_nr_pages) {
1362                 int j;
1363 
1364                 if (chunk_start + chunk_nr_pages > nr_pages)
1365                         chunk_nr_pages = nr_pages - chunk_start;
1366 
1367                 /* fill the chunk pm with addrs and nodes from user-space */
1368                 for (j = 0; j < chunk_nr_pages; j++) {
1369                         const void __user *p;
1370                         int node;
1371 
1372                         err = -EFAULT;
1373                         if (get_user(p, pages + j + chunk_start))
1374                                 goto out_pm;
1375                         pm[j].addr = (unsigned long) p;
1376 
1377                         if (get_user(node, nodes + j + chunk_start))
1378                                 goto out_pm;
1379 
1380                         err = -ENODEV;
1381                         if (node < 0 || node >= MAX_NUMNODES)
1382                                 goto out_pm;
1383 
1384                         if (!node_state(node, N_MEMORY))
1385                                 goto out_pm;
1386 
1387                         err = -EACCES;
1388                         if (!node_isset(node, task_nodes))
1389                                 goto out_pm;
1390 
1391                         pm[j].node = node;
1392                 }
1393 
1394                 /* End marker for this chunk */
1395                 pm[chunk_nr_pages].node = MAX_NUMNODES;
1396 
1397                 /* Migrate this chunk */
1398                 err = do_move_page_to_node_array(mm, pm,
1399                                                  flags & MPOL_MF_MOVE_ALL);
1400                 if (err < 0)
1401                         goto out_pm;
1402 
1403                 /* Return status information */
1404                 for (j = 0; j < chunk_nr_pages; j++)
1405                         if (put_user(pm[j].status, status + j + chunk_start)) {
1406                                 err = -EFAULT;
1407                                 goto out_pm;
1408                         }
1409         }
1410         err = 0;
1411 
1412 out_pm:
1413         free_page((unsigned long)pm);
1414 out:
1415         return err;
1416 }
1417 
1418 /*
1419  * Determine the nodes of an array of pages and store it in an array of status.
1420  */
1421 static void do_pages_stat_array(struct mm_struct *mm, unsigned long nr_pages,
1422                                 const void __user **pages, int *status)
1423 {
1424         unsigned long i;
1425 
1426         down_read(&mm->mmap_sem);
1427 
1428         for (i = 0; i < nr_pages; i++) {
1429                 unsigned long addr = (unsigned long)(*pages);
1430                 struct vm_area_struct *vma;
1431                 struct page *page;
1432                 int err = -EFAULT;
1433 
1434                 vma = find_vma(mm, addr);
1435                 if (!vma || addr < vma->vm_start)
1436                         goto set_status;
1437 
1438                 /* FOLL_DUMP to ignore special (like zero) pages */
1439                 page = follow_page(vma, addr, FOLL_DUMP);
1440 
1441                 err = PTR_ERR(page);
1442                 if (IS_ERR(page))
1443                         goto set_status;
1444 
1445                 err = page ? page_to_nid(page) : -ENOENT;
1446 set_status:
1447                 *status = err;
1448 
1449                 pages++;
1450                 status++;
1451         }
1452 
1453         up_read(&mm->mmap_sem);
1454 }
1455 
1456 /*
1457  * Determine the nodes of a user array of pages and store it in
1458  * a user array of status.
1459  */
1460 static int do_pages_stat(struct mm_struct *mm, unsigned long nr_pages,
1461                          const void __user * __user *pages,
1462                          int __user *status)
1463 {
1464 #define DO_PAGES_STAT_CHUNK_NR 16
1465         const void __user *chunk_pages[DO_PAGES_STAT_CHUNK_NR];
1466         int chunk_status[DO_PAGES_STAT_CHUNK_NR];
1467 
1468         while (nr_pages) {
1469                 unsigned long chunk_nr;
1470 
1471                 chunk_nr = nr_pages;
1472                 if (chunk_nr > DO_PAGES_STAT_CHUNK_NR)
1473                         chunk_nr = DO_PAGES_STAT_CHUNK_NR;
1474 
1475                 if (copy_from_user(chunk_pages, pages, chunk_nr * sizeof(*chunk_pages)))
1476                         break;
1477 
1478                 do_pages_stat_array(mm, chunk_nr, chunk_pages, chunk_status);
1479 
1480                 if (copy_to_user(status, chunk_status, chunk_nr * sizeof(*status)))
1481                         break;
1482 
1483                 pages += chunk_nr;
1484                 status += chunk_nr;
1485                 nr_pages -= chunk_nr;
1486         }
1487         return nr_pages ? -EFAULT : 0;
1488 }
1489 
1490 /*
1491  * Move a list of pages in the address space of the currently executing
1492  * process.
1493  */
1494 SYSCALL_DEFINE6(move_pages, pid_t, pid, unsigned long, nr_pages,
1495                 const void __user * __user *, pages,
1496                 const int __user *, nodes,
1497                 int __user *, status, int, flags)
1498 {
1499         const struct cred *cred = current_cred(), *tcred;
1500         struct task_struct *task;
1501         struct mm_struct *mm;
1502         int err;
1503         nodemask_t task_nodes;
1504 
1505         /* Check flags */
1506         if (flags & ~(MPOL_MF_MOVE|MPOL_MF_MOVE_ALL))
1507                 return -EINVAL;
1508 
1509         if ((flags & MPOL_MF_MOVE_ALL) && !capable(CAP_SYS_NICE))
1510                 return -EPERM;
1511 
1512         /* Find the mm_struct */
1513         rcu_read_lock();
1514         task = pid ? find_task_by_vpid(pid) : current;
1515         if (!task) {
1516                 rcu_read_unlock();
1517                 return -ESRCH;
1518         }
1519         get_task_struct(task);
1520 
1521         /*
1522          * Check if this process has the right to modify the specified
1523          * process. The right exists if the process has administrative
1524          * capabilities, superuser privileges or the same
1525          * userid as the target process.
1526          */
1527         tcred = __task_cred(task);
1528         if (!uid_eq(cred->euid, tcred->suid) && !uid_eq(cred->euid, tcred->uid) &&
1529             !uid_eq(cred->uid,  tcred->suid) && !uid_eq(cred->uid,  tcred->uid) &&
1530             !capable(CAP_SYS_NICE)) {
1531                 rcu_read_unlock();
1532                 err = -EPERM;
1533                 goto out;
1534         }
1535         rcu_read_unlock();
1536 
1537         err = security_task_movememory(task);
1538         if (err)
1539                 goto out;
1540 
1541         task_nodes = cpuset_mems_allowed(task);
1542         mm = get_task_mm(task);
1543         put_task_struct(task);
1544 
1545         if (!mm)
1546                 return -EINVAL;
1547 
1548         if (nodes)
1549                 err = do_pages_move(mm, task_nodes, nr_pages, pages,
1550                                     nodes, status, flags);
1551         else
1552                 err = do_pages_stat(mm, nr_pages, pages, status);
1553 
1554         mmput(mm);
1555         return err;
1556 
1557 out:
1558         put_task_struct(task);
1559         return err;
1560 }
1561 
1562 #ifdef CONFIG_NUMA_BALANCING
1563 /*
1564  * Returns true if this is a safe migration target node for misplaced NUMA
1565  * pages. Currently it only checks the watermarks which crude
1566  */
1567 static bool migrate_balanced_pgdat(struct pglist_data *pgdat,
1568                                    unsigned long nr_migrate_pages)
1569 {
1570         int z;
1571         for (z = pgdat->nr_zones - 1; z >= 0; z--) {
1572                 struct zone *zone = pgdat->node_zones + z;
1573 
1574                 if (!populated_zone(zone))
1575                         continue;
1576 
1577                 if (!zone_reclaimable(zone))
1578                         continue;
1579 
1580                 /* Avoid waking kswapd by allocating pages_to_migrate pages. */
1581                 if (!zone_watermark_ok(zone, 0,
1582                                        high_wmark_pages(zone) +
1583                                        nr_migrate_pages,
1584                                        0, 0))
1585                         continue;
1586                 return true;
1587         }
1588         return false;
1589 }
1590 
1591 static struct page *alloc_misplaced_dst_page(struct page *page,
1592                                            unsigned long data,
1593                                            int **result)
1594 {
1595         int nid = (int) data;
1596         struct page *newpage;
1597 
1598         newpage = __alloc_pages_node(nid,
1599                                          (GFP_HIGHUSER_MOVABLE |
1600                                           __GFP_THISNODE | __GFP_NOMEMALLOC |
1601                                           __GFP_NORETRY | __GFP_NOWARN) &
1602                                          ~__GFP_RECLAIM, 0);
1603 
1604         return newpage;
1605 }
1606 
1607 /*
1608  * page migration rate limiting control.
1609  * Do not migrate more than @pages_to_migrate in a @migrate_interval_millisecs
1610  * window of time. Default here says do not migrate more than 1280M per second.
1611  */
1612 static unsigned int migrate_interval_millisecs __read_mostly = 100;
1613 static unsigned int ratelimit_pages __read_mostly = 128 << (20 - PAGE_SHIFT);
1614 
1615 /* Returns true if the node is migrate rate-limited after the update */
1616 static bool numamigrate_update_ratelimit(pg_data_t *pgdat,
1617                                         unsigned long nr_pages)
1618 {
1619         /*
1620          * Rate-limit the amount of data that is being migrated to a node.
1621          * Optimal placement is no good if the memory bus is saturated and
1622          * all the time is being spent migrating!
1623          */
1624         if (time_after(jiffies, pgdat->numabalancing_migrate_next_window)) {
1625                 spin_lock(&pgdat->numabalancing_migrate_lock);
1626                 pgdat->numabalancing_migrate_nr_pages = 0;
1627                 pgdat->numabalancing_migrate_next_window = jiffies +
1628                         msecs_to_jiffies(migrate_interval_millisecs);
1629                 spin_unlock(&pgdat->numabalancing_migrate_lock);
1630         }
1631         if (pgdat->numabalancing_migrate_nr_pages > ratelimit_pages) {
1632                 trace_mm_numa_migrate_ratelimit(current, pgdat->node_id,
1633                                                                 nr_pages);
1634                 return true;
1635         }
1636 
1637         /*
1638          * This is an unlocked non-atomic update so errors are possible.
1639          * The consequences are failing to migrate when we potentiall should
1640          * have which is not severe enough to warrant locking. If it is ever
1641          * a problem, it can be converted to a per-cpu counter.
1642          */
1643         pgdat->numabalancing_migrate_nr_pages += nr_pages;
1644         return false;
1645 }
1646 
1647 static int numamigrate_isolate_page(pg_data_t *pgdat, struct page *page)
1648 {
1649         int page_lru;
1650 
1651         VM_BUG_ON_PAGE(compound_order(page) && !PageTransHuge(page), page);
1652 
1653         /* Avoid migrating to a node that is nearly full */
1654         if (!migrate_balanced_pgdat(pgdat, 1UL << compound_order(page)))
1655                 return 0;
1656 
1657         if (isolate_lru_page(page))
1658                 return 0;
1659 
1660         /*
1661          * migrate_misplaced_transhuge_page() skips page migration's usual
1662          * check on page_count(), so we must do it here, now that the page
1663          * has been isolated: a GUP pin, or any other pin, prevents migration.
1664          * The expected page count is 3: 1 for page's mapcount and 1 for the
1665          * caller's pin and 1 for the reference taken by isolate_lru_page().
1666          */
1667         if (PageTransHuge(page) && page_count(page) != 3) {
1668                 putback_lru_page(page);
1669                 return 0;
1670         }
1671 
1672         page_lru = page_is_file_cache(page);
1673         mod_zone_page_state(page_zone(page), NR_ISOLATED_ANON + page_lru,
1674                                 hpage_nr_pages(page));
1675 
1676         /*
1677          * Isolating the page has taken another reference, so the
1678          * caller's reference can be safely dropped without the page
1679          * disappearing underneath us during migration.
1680          */
1681         put_page(page);
1682         return 1;
1683 }
1684 
1685 bool pmd_trans_migrating(pmd_t pmd)
1686 {
1687         struct page *page = pmd_page(pmd);
1688         return PageLocked(page);
1689 }
1690 
1691 /*
1692  * Attempt to migrate a misplaced page to the specified destination
1693  * node. Caller is expected to have an elevated reference count on
1694  * the page that will be dropped by this function before returning.
1695  */
1696 int migrate_misplaced_page(struct page *page, struct vm_area_struct *vma,
1697                            int node)
1698 {
1699         pg_data_t *pgdat = NODE_DATA(node);
1700         int isolated;
1701         int nr_remaining;
1702         LIST_HEAD(migratepages);
1703 
1704         /*
1705          * Don't migrate file pages that are mapped in multiple processes
1706          * with execute permissions as they are probably shared libraries.
1707          */
1708         if (page_mapcount(page) != 1 && page_is_file_cache(page) &&
1709             (vma->vm_flags & VM_EXEC))
1710                 goto out;
1711 
1712         /*
1713          * Rate-limit the amount of data that is being migrated to a node.
1714          * Optimal placement is no good if the memory bus is saturated and
1715          * all the time is being spent migrating!
1716          */
1717         if (numamigrate_update_ratelimit(pgdat, 1))
1718                 goto out;
1719 
1720         isolated = numamigrate_isolate_page(pgdat, page);
1721         if (!isolated)
1722                 goto out;
1723 
1724         list_add(&page->lru, &migratepages);
1725         nr_remaining = migrate_pages(&migratepages, alloc_misplaced_dst_page,
1726                                      NULL, node, MIGRATE_ASYNC,
1727                                      MR_NUMA_MISPLACED);
1728         if (nr_remaining) {
1729                 if (!list_empty(&migratepages)) {
1730                         list_del(&page->lru);
1731                         dec_zone_page_state(page, NR_ISOLATED_ANON +
1732                                         page_is_file_cache(page));
1733                         putback_lru_page(page);
1734                 }
1735                 isolated = 0;
1736         } else
1737                 count_vm_numa_event(NUMA_PAGE_MIGRATE);
1738         BUG_ON(!list_empty(&migratepages));
1739         return isolated;
1740 
1741 out:
1742         put_page(page);
1743         return 0;
1744 }
1745 #endif /* CONFIG_NUMA_BALANCING */
1746 
1747 #if defined(CONFIG_NUMA_BALANCING) && defined(CONFIG_TRANSPARENT_HUGEPAGE)
1748 /*
1749  * Migrates a THP to a given target node. page must be locked and is unlocked
1750  * before returning.
1751  */
1752 int migrate_misplaced_transhuge_page(struct mm_struct *mm,
1753                                 struct vm_area_struct *vma,
1754                                 pmd_t *pmd, pmd_t entry,
1755                                 unsigned long address,
1756                                 struct page *page, int node)
1757 {
1758         spinlock_t *ptl;
1759         pg_data_t *pgdat = NODE_DATA(node);
1760         int isolated = 0;
1761         struct page *new_page = NULL;
1762         int page_lru = page_is_file_cache(page);
1763         unsigned long mmun_start = address & HPAGE_PMD_MASK;
1764         unsigned long mmun_end = mmun_start + HPAGE_PMD_SIZE;
1765         pmd_t orig_entry;
1766 
1767         /*
1768          * Rate-limit the amount of data that is being migrated to a node.
1769          * Optimal placement is no good if the memory bus is saturated and
1770          * all the time is being spent migrating!
1771          */
1772         if (numamigrate_update_ratelimit(pgdat, HPAGE_PMD_NR))
1773                 goto out_dropref;
1774 
1775         new_page = alloc_pages_node(node,
1776                 (GFP_TRANSHUGE | __GFP_THISNODE) & ~__GFP_RECLAIM,
1777                 HPAGE_PMD_ORDER);
1778         if (!new_page)
1779                 goto out_fail;
1780         prep_transhuge_page(new_page);
1781 
1782         isolated = numamigrate_isolate_page(pgdat, page);
1783         if (!isolated) {
1784                 put_page(new_page);
1785                 goto out_fail;
1786         }
1787         /*
1788          * We are not sure a pending tlb flush here is for a huge page
1789          * mapping or not. Hence use the tlb range variant
1790          */
1791         if (mm_tlb_flush_pending(mm))
1792                 flush_tlb_range(vma, mmun_start, mmun_end);
1793 
1794         /* Prepare a page as a migration target */
1795         __SetPageLocked(new_page);
1796         SetPageSwapBacked(new_page);
1797 
1798         /* anon mapping, we can simply copy page->mapping to the new page: */
1799         new_page->mapping = page->mapping;
1800         new_page->index = page->index;
1801         migrate_page_copy(new_page, page);
1802         WARN_ON(PageLRU(new_page));
1803 
1804         /* Recheck the target PMD */
1805         mmu_notifier_invalidate_range_start(mm, mmun_start, mmun_end);
1806         ptl = pmd_lock(mm, pmd);
1807         if (unlikely(!pmd_same(*pmd, entry) || page_count(page) != 2)) {
1808 fail_putback:
1809                 spin_unlock(ptl);
1810                 mmu_notifier_invalidate_range_end(mm, mmun_start, mmun_end);
1811 
1812                 /* Reverse changes made by migrate_page_copy() */
1813                 if (TestClearPageActive(new_page))
1814                         SetPageActive(page);
1815                 if (TestClearPageUnevictable(new_page))
1816                         SetPageUnevictable(page);
1817 
1818                 unlock_page(new_page);
1819                 put_page(new_page);             /* Free it */
1820 
1821                 /* Retake the callers reference and putback on LRU */
1822                 get_page(page);
1823                 putback_lru_page(page);
1824                 mod_zone_page_state(page_zone(page),
1825                          NR_ISOLATED_ANON + page_lru, -HPAGE_PMD_NR);
1826 
1827                 goto out_unlock;
1828         }
1829 
1830         orig_entry = *pmd;
1831         entry = mk_pmd(new_page, vma->vm_page_prot);
1832         entry = pmd_mkhuge(entry);
1833         entry = maybe_pmd_mkwrite(pmd_mkdirty(entry), vma);
1834 
1835         /*
1836          * Clear the old entry under pagetable lock and establish the new PTE.
1837          * Any parallel GUP will either observe the old page blocking on the
1838          * page lock, block on the page table lock or observe the new page.
1839          * The SetPageUptodate on the new page and page_add_new_anon_rmap
1840          * guarantee the copy is visible before the pagetable update.
1841          */
1842         flush_cache_range(vma, mmun_start, mmun_end);
1843         page_add_anon_rmap(new_page, vma, mmun_start, true);
1844         pmdp_huge_clear_flush_notify(vma, mmun_start, pmd);
1845         set_pmd_at(mm, mmun_start, pmd, entry);
1846         update_mmu_cache_pmd(vma, address, &entry);
1847 
1848         if (page_count(page) != 2) {
1849                 set_pmd_at(mm, mmun_start, pmd, orig_entry);
1850                 flush_pmd_tlb_range(vma, mmun_start, mmun_end);
1851                 mmu_notifier_invalidate_range(mm, mmun_start, mmun_end);
1852                 update_mmu_cache_pmd(vma, address, &entry);
1853                 page_remove_rmap(new_page, true);
1854                 goto fail_putback;
1855         }
1856 
1857         mlock_migrate_page(new_page, page);
1858         page_remove_rmap(page, true);
1859         set_page_owner_migrate_reason(new_page, MR_NUMA_MISPLACED);
1860 
1861         spin_unlock(ptl);
1862         mmu_notifier_invalidate_range_end(mm, mmun_start, mmun_end);
1863 
1864         /* Take an "isolate" reference and put new page on the LRU. */
1865         get_page(new_page);
1866         putback_lru_page(new_page);
1867 
1868         unlock_page(new_page);
1869         unlock_page(page);
1870         put_page(page);                 /* Drop the rmap reference */
1871         put_page(page);                 /* Drop the LRU isolation reference */
1872 
1873         count_vm_events(PGMIGRATE_SUCCESS, HPAGE_PMD_NR);
1874         count_vm_numa_events(NUMA_PAGE_MIGRATE, HPAGE_PMD_NR);
1875 
1876         mod_zone_page_state(page_zone(page),
1877                         NR_ISOLATED_ANON + page_lru,
1878                         -HPAGE_PMD_NR);
1879         return isolated;
1880 
1881 out_fail:
1882         count_vm_events(PGMIGRATE_FAIL, HPAGE_PMD_NR);
1883 out_dropref:
1884         ptl = pmd_lock(mm, pmd);
1885         if (pmd_same(*pmd, entry)) {
1886                 entry = pmd_modify(entry, vma->vm_page_prot);
1887                 set_pmd_at(mm, mmun_start, pmd, entry);
1888                 update_mmu_cache_pmd(vma, address, &entry);
1889         }
1890         spin_unlock(ptl);
1891 
1892 out_unlock:
1893         unlock_page(page);
1894         put_page(page);
1895         return 0;
1896 }
1897 #endif /* CONFIG_NUMA_BALANCING */
1898 
1899 #endif /* CONFIG_NUMA */
1900 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp