Added license information
[kvmfornfv.git] / kernel / mm / rmap.c
1 /*
2  * mm/rmap.c - physical to virtual reverse mappings
3  *
4  * Copyright 2001, Rik van Riel <riel@conectiva.com.br>
5  * Released under the General Public License (GPL).
6  *
7  * Simple, low overhead reverse mapping scheme.
8  * Please try to keep this thing as modular as possible.
9  *
10  * Provides methods for unmapping each kind of mapped page:
11  * the anon methods track anonymous pages, and
12  * the file methods track pages belonging to an inode.
13  *
14  * Original design by Rik van Riel <riel@conectiva.com.br> 2001
15  * File methods by Dave McCracken <dmccr@us.ibm.com> 2003, 2004
16  * Anonymous methods by Andrea Arcangeli <andrea@suse.de> 2004
17  * Contributions by Hugh Dickins 2003, 2004
18  */
19
20 /*
21  * Lock ordering in mm:
22  *
23  * inode->i_mutex       (while writing or truncating, not reading or faulting)
24  *   mm->mmap_sem
25  *     page->flags PG_locked (lock_page)
26  *       mapping->i_mmap_rwsem
27  *         anon_vma->rwsem
28  *           mm->page_table_lock or pte_lock
29  *             zone->lru_lock (in mark_page_accessed, isolate_lru_page)
30  *             swap_lock (in swap_duplicate, swap_info_get)
31  *               mmlist_lock (in mmput, drain_mmlist and others)
32  *               mapping->private_lock (in __set_page_dirty_buffers)
33  *               inode->i_lock (in set_page_dirty's __mark_inode_dirty)
34  *               bdi.wb->list_lock (in set_page_dirty's __mark_inode_dirty)
35  *                 sb_lock (within inode_lock in fs/fs-writeback.c)
36  *                 mapping->tree_lock (widely used, in set_page_dirty,
37  *                           in arch-dependent flush_dcache_mmap_lock,
38  *                           within bdi.wb->list_lock in __sync_single_inode)
39  *
40  * anon_vma->rwsem,mapping->i_mutex      (memory_failure, collect_procs_anon)
41  *   ->tasklist_lock
42  *     pte map lock
43  */
44
45 #include <linux/mm.h>
46 #include <linux/pagemap.h>
47 #include <linux/swap.h>
48 #include <linux/swapops.h>
49 #include <linux/slab.h>
50 #include <linux/init.h>
51 #include <linux/ksm.h>
52 #include <linux/rmap.h>
53 #include <linux/rcupdate.h>
54 #include <linux/export.h>
55 #include <linux/memcontrol.h>
56 #include <linux/mmu_notifier.h>
57 #include <linux/migrate.h>
58 #include <linux/hugetlb.h>
59 #include <linux/backing-dev.h>
60
61 #include <asm/tlbflush.h>
62
63 #include "internal.h"
64
65 static struct kmem_cache *anon_vma_cachep;
66 static struct kmem_cache *anon_vma_chain_cachep;
67
68 static inline struct anon_vma *anon_vma_alloc(void)
69 {
70         struct anon_vma *anon_vma;
71
72         anon_vma = kmem_cache_alloc(anon_vma_cachep, GFP_KERNEL);
73         if (anon_vma) {
74                 atomic_set(&anon_vma->refcount, 1);
75                 anon_vma->degree = 1;   /* Reference for first vma */
76                 anon_vma->parent = anon_vma;
77                 /*
78                  * Initialise the anon_vma root to point to itself. If called
79                  * from fork, the root will be reset to the parents anon_vma.
80                  */
81                 anon_vma->root = anon_vma;
82         }
83
84         return anon_vma;
85 }
86
87 static inline void anon_vma_free(struct anon_vma *anon_vma)
88 {
89         VM_BUG_ON(atomic_read(&anon_vma->refcount));
90
91         /*
92          * Synchronize against page_lock_anon_vma_read() such that
93          * we can safely hold the lock without the anon_vma getting
94          * freed.
95          *
96          * Relies on the full mb implied by the atomic_dec_and_test() from
97          * put_anon_vma() against the acquire barrier implied by
98          * down_read_trylock() from page_lock_anon_vma_read(). This orders:
99          *
100          * page_lock_anon_vma_read()    VS      put_anon_vma()
101          *   down_read_trylock()                  atomic_dec_and_test()
102          *   LOCK                                 MB
103          *   atomic_read()                        rwsem_is_locked()
104          *
105          * LOCK should suffice since the actual taking of the lock must
106          * happen _before_ what follows.
107          */
108         might_sleep();
109         if (rwsem_is_locked(&anon_vma->root->rwsem)) {
110                 anon_vma_lock_write(anon_vma);
111                 anon_vma_unlock_write(anon_vma);
112         }
113
114         kmem_cache_free(anon_vma_cachep, anon_vma);
115 }
116
117 static inline struct anon_vma_chain *anon_vma_chain_alloc(gfp_t gfp)
118 {
119         return kmem_cache_alloc(anon_vma_chain_cachep, gfp);
120 }
121
122 static void anon_vma_chain_free(struct anon_vma_chain *anon_vma_chain)
123 {
124         kmem_cache_free(anon_vma_chain_cachep, anon_vma_chain);
125 }
126
127 static void anon_vma_chain_link(struct vm_area_struct *vma,
128                                 struct anon_vma_chain *avc,
129                                 struct anon_vma *anon_vma)
130 {
131         avc->vma = vma;
132         avc->anon_vma = anon_vma;
133         list_add(&avc->same_vma, &vma->anon_vma_chain);
134         anon_vma_interval_tree_insert(avc, &anon_vma->rb_root);
135 }
136
137 /**
138  * anon_vma_prepare - attach an anon_vma to a memory region
139  * @vma: the memory region in question
140  *
141  * This makes sure the memory mapping described by 'vma' has
142  * an 'anon_vma' attached to it, so that we can associate the
143  * anonymous pages mapped into it with that anon_vma.
144  *
145  * The common case will be that we already have one, but if
146  * not we either need to find an adjacent mapping that we
147  * can re-use the anon_vma from (very common when the only
148  * reason for splitting a vma has been mprotect()), or we
149  * allocate a new one.
150  *
151  * Anon-vma allocations are very subtle, because we may have
152  * optimistically looked up an anon_vma in page_lock_anon_vma_read()
153  * and that may actually touch the spinlock even in the newly
154  * allocated vma (it depends on RCU to make sure that the
155  * anon_vma isn't actually destroyed).
156  *
157  * As a result, we need to do proper anon_vma locking even
158  * for the new allocation. At the same time, we do not want
159  * to do any locking for the common case of already having
160  * an anon_vma.
161  *
162  * This must be called with the mmap_sem held for reading.
163  */
164 int anon_vma_prepare(struct vm_area_struct *vma)
165 {
166         struct anon_vma *anon_vma = vma->anon_vma;
167         struct anon_vma_chain *avc;
168
169         might_sleep();
170         if (unlikely(!anon_vma)) {
171                 struct mm_struct *mm = vma->vm_mm;
172                 struct anon_vma *allocated;
173
174                 avc = anon_vma_chain_alloc(GFP_KERNEL);
175                 if (!avc)
176                         goto out_enomem;
177
178                 anon_vma = find_mergeable_anon_vma(vma);
179                 allocated = NULL;
180                 if (!anon_vma) {
181                         anon_vma = anon_vma_alloc();
182                         if (unlikely(!anon_vma))
183                                 goto out_enomem_free_avc;
184                         allocated = anon_vma;
185                 }
186
187                 anon_vma_lock_write(anon_vma);
188                 /* page_table_lock to protect against threads */
189                 spin_lock(&mm->page_table_lock);
190                 if (likely(!vma->anon_vma)) {
191                         vma->anon_vma = anon_vma;
192                         anon_vma_chain_link(vma, avc, anon_vma);
193                         /* vma reference or self-parent link for new root */
194                         anon_vma->degree++;
195                         allocated = NULL;
196                         avc = NULL;
197                 }
198                 spin_unlock(&mm->page_table_lock);
199                 anon_vma_unlock_write(anon_vma);
200
201                 if (unlikely(allocated))
202                         put_anon_vma(allocated);
203                 if (unlikely(avc))
204                         anon_vma_chain_free(avc);
205         }
206         return 0;
207
208  out_enomem_free_avc:
209         anon_vma_chain_free(avc);
210  out_enomem:
211         return -ENOMEM;
212 }
213
214 /*
215  * This is a useful helper function for locking the anon_vma root as
216  * we traverse the vma->anon_vma_chain, looping over anon_vma's that
217  * have the same vma.
218  *
219  * Such anon_vma's should have the same root, so you'd expect to see
220  * just a single mutex_lock for the whole traversal.
221  */
222 static inline struct anon_vma *lock_anon_vma_root(struct anon_vma *root, struct anon_vma *anon_vma)
223 {
224         struct anon_vma *new_root = anon_vma->root;
225         if (new_root != root) {
226                 if (WARN_ON_ONCE(root))
227                         up_write(&root->rwsem);
228                 root = new_root;
229                 down_write(&root->rwsem);
230         }
231         return root;
232 }
233
234 static inline void unlock_anon_vma_root(struct anon_vma *root)
235 {
236         if (root)
237                 up_write(&root->rwsem);
238 }
239
240 /*
241  * Attach the anon_vmas from src to dst.
242  * Returns 0 on success, -ENOMEM on failure.
243  *
244  * If dst->anon_vma is NULL this function tries to find and reuse existing
245  * anon_vma which has no vmas and only one child anon_vma. This prevents
246  * degradation of anon_vma hierarchy to endless linear chain in case of
247  * constantly forking task. On the other hand, an anon_vma with more than one
248  * child isn't reused even if there was no alive vma, thus rmap walker has a
249  * good chance of avoiding scanning the whole hierarchy when it searches where
250  * page is mapped.
251  */
252 int anon_vma_clone(struct vm_area_struct *dst, struct vm_area_struct *src)
253 {
254         struct anon_vma_chain *avc, *pavc;
255         struct anon_vma *root = NULL;
256
257         list_for_each_entry_reverse(pavc, &src->anon_vma_chain, same_vma) {
258                 struct anon_vma *anon_vma;
259
260                 avc = anon_vma_chain_alloc(GFP_NOWAIT | __GFP_NOWARN);
261                 if (unlikely(!avc)) {
262                         unlock_anon_vma_root(root);
263                         root = NULL;
264                         avc = anon_vma_chain_alloc(GFP_KERNEL);
265                         if (!avc)
266                                 goto enomem_failure;
267                 }
268                 anon_vma = pavc->anon_vma;
269                 root = lock_anon_vma_root(root, anon_vma);
270                 anon_vma_chain_link(dst, avc, anon_vma);
271
272                 /*
273                  * Reuse existing anon_vma if its degree lower than two,
274                  * that means it has no vma and only one anon_vma child.
275                  *
276                  * Do not chose parent anon_vma, otherwise first child
277                  * will always reuse it. Root anon_vma is never reused:
278                  * it has self-parent reference and at least one child.
279                  */
280                 if (!dst->anon_vma && anon_vma != src->anon_vma &&
281                                 anon_vma->degree < 2)
282                         dst->anon_vma = anon_vma;
283         }
284         if (dst->anon_vma)
285                 dst->anon_vma->degree++;
286         unlock_anon_vma_root(root);
287         return 0;
288
289  enomem_failure:
290         /*
291          * dst->anon_vma is dropped here otherwise its degree can be incorrectly
292          * decremented in unlink_anon_vmas().
293          * We can safely do this because callers of anon_vma_clone() don't care
294          * about dst->anon_vma if anon_vma_clone() failed.
295          */
296         dst->anon_vma = NULL;
297         unlink_anon_vmas(dst);
298         return -ENOMEM;
299 }
300
301 /*
302  * Attach vma to its own anon_vma, as well as to the anon_vmas that
303  * the corresponding VMA in the parent process is attached to.
304  * Returns 0 on success, non-zero on failure.
305  */
306 int anon_vma_fork(struct vm_area_struct *vma, struct vm_area_struct *pvma)
307 {
308         struct anon_vma_chain *avc;
309         struct anon_vma *anon_vma;
310         int error;
311
312         /* Don't bother if the parent process has no anon_vma here. */
313         if (!pvma->anon_vma)
314                 return 0;
315
316         /* Drop inherited anon_vma, we'll reuse existing or allocate new. */
317         vma->anon_vma = NULL;
318
319         /*
320          * First, attach the new VMA to the parent VMA's anon_vmas,
321          * so rmap can find non-COWed pages in child processes.
322          */
323         error = anon_vma_clone(vma, pvma);
324         if (error)
325                 return error;
326
327         /* An existing anon_vma has been reused, all done then. */
328         if (vma->anon_vma)
329                 return 0;
330
331         /* Then add our own anon_vma. */
332         anon_vma = anon_vma_alloc();
333         if (!anon_vma)
334                 goto out_error;
335         avc = anon_vma_chain_alloc(GFP_KERNEL);
336         if (!avc)
337                 goto out_error_free_anon_vma;
338
339         /*
340          * The root anon_vma's spinlock is the lock actually used when we
341          * lock any of the anon_vmas in this anon_vma tree.
342          */
343         anon_vma->root = pvma->anon_vma->root;
344         anon_vma->parent = pvma->anon_vma;
345         /*
346          * With refcounts, an anon_vma can stay around longer than the
347          * process it belongs to. The root anon_vma needs to be pinned until
348          * this anon_vma is freed, because the lock lives in the root.
349          */
350         get_anon_vma(anon_vma->root);
351         /* Mark this anon_vma as the one where our new (COWed) pages go. */
352         vma->anon_vma = anon_vma;
353         anon_vma_lock_write(anon_vma);
354         anon_vma_chain_link(vma, avc, anon_vma);
355         anon_vma->parent->degree++;
356         anon_vma_unlock_write(anon_vma);
357
358         return 0;
359
360  out_error_free_anon_vma:
361         put_anon_vma(anon_vma);
362  out_error:
363         unlink_anon_vmas(vma);
364         return -ENOMEM;
365 }
366
367 void unlink_anon_vmas(struct vm_area_struct *vma)
368 {
369         struct anon_vma_chain *avc, *next;
370         struct anon_vma *root = NULL;
371
372         /*
373          * Unlink each anon_vma chained to the VMA.  This list is ordered
374          * from newest to oldest, ensuring the root anon_vma gets freed last.
375          */
376         list_for_each_entry_safe(avc, next, &vma->anon_vma_chain, same_vma) {
377                 struct anon_vma *anon_vma = avc->anon_vma;
378
379                 root = lock_anon_vma_root(root, anon_vma);
380                 anon_vma_interval_tree_remove(avc, &anon_vma->rb_root);
381
382                 /*
383                  * Leave empty anon_vmas on the list - we'll need
384                  * to free them outside the lock.
385                  */
386                 if (RB_EMPTY_ROOT(&anon_vma->rb_root)) {
387                         anon_vma->parent->degree--;
388                         continue;
389                 }
390
391                 list_del(&avc->same_vma);
392                 anon_vma_chain_free(avc);
393         }
394         if (vma->anon_vma)
395                 vma->anon_vma->degree--;
396         unlock_anon_vma_root(root);
397
398         /*
399          * Iterate the list once more, it now only contains empty and unlinked
400          * anon_vmas, destroy them. Could not do before due to __put_anon_vma()
401          * needing to write-acquire the anon_vma->root->rwsem.
402          */
403         list_for_each_entry_safe(avc, next, &vma->anon_vma_chain, same_vma) {
404                 struct anon_vma *anon_vma = avc->anon_vma;
405
406                 BUG_ON(anon_vma->degree);
407                 put_anon_vma(anon_vma);
408
409                 list_del(&avc->same_vma);
410                 anon_vma_chain_free(avc);
411         }
412 }
413
414 static void anon_vma_ctor(void *data)
415 {
416         struct anon_vma *anon_vma = data;
417
418         init_rwsem(&anon_vma->rwsem);
419         atomic_set(&anon_vma->refcount, 0);
420         anon_vma->rb_root = RB_ROOT;
421 }
422
423 void __init anon_vma_init(void)
424 {
425         anon_vma_cachep = kmem_cache_create("anon_vma", sizeof(struct anon_vma),
426                         0, SLAB_DESTROY_BY_RCU|SLAB_PANIC, anon_vma_ctor);
427         anon_vma_chain_cachep = KMEM_CACHE(anon_vma_chain, SLAB_PANIC);
428 }
429
430 /*
431  * Getting a lock on a stable anon_vma from a page off the LRU is tricky!
432  *
433  * Since there is no serialization what so ever against page_remove_rmap()
434  * the best this function can do is return a locked anon_vma that might
435  * have been relevant to this page.
436  *
437  * The page might have been remapped to a different anon_vma or the anon_vma
438  * returned may already be freed (and even reused).
439  *
440  * In case it was remapped to a different anon_vma, the new anon_vma will be a
441  * child of the old anon_vma, and the anon_vma lifetime rules will therefore
442  * ensure that any anon_vma obtained from the page will still be valid for as
443  * long as we observe page_mapped() [ hence all those page_mapped() tests ].
444  *
445  * All users of this function must be very careful when walking the anon_vma
446  * chain and verify that the page in question is indeed mapped in it
447  * [ something equivalent to page_mapped_in_vma() ].
448  *
449  * Since anon_vma's slab is DESTROY_BY_RCU and we know from page_remove_rmap()
450  * that the anon_vma pointer from page->mapping is valid if there is a
451  * mapcount, we can dereference the anon_vma after observing those.
452  */
453 struct anon_vma *page_get_anon_vma(struct page *page)
454 {
455         struct anon_vma *anon_vma = NULL;
456         unsigned long anon_mapping;
457
458         rcu_read_lock();
459         anon_mapping = (unsigned long)READ_ONCE(page->mapping);
460         if ((anon_mapping & PAGE_MAPPING_FLAGS) != PAGE_MAPPING_ANON)
461                 goto out;
462         if (!page_mapped(page))
463                 goto out;
464
465         anon_vma = (struct anon_vma *) (anon_mapping - PAGE_MAPPING_ANON);
466         if (!atomic_inc_not_zero(&anon_vma->refcount)) {
467                 anon_vma = NULL;
468                 goto out;
469         }
470
471         /*
472          * If this page is still mapped, then its anon_vma cannot have been
473          * freed.  But if it has been unmapped, we have no security against the
474          * anon_vma structure being freed and reused (for another anon_vma:
475          * SLAB_DESTROY_BY_RCU guarantees that - so the atomic_inc_not_zero()
476          * above cannot corrupt).
477          */
478         if (!page_mapped(page)) {
479                 rcu_read_unlock();
480                 put_anon_vma(anon_vma);
481                 return NULL;
482         }
483 out:
484         rcu_read_unlock();
485
486         return anon_vma;
487 }
488
489 /*
490  * Similar to page_get_anon_vma() except it locks the anon_vma.
491  *
492  * Its a little more complex as it tries to keep the fast path to a single
493  * atomic op -- the trylock. If we fail the trylock, we fall back to getting a
494  * reference like with page_get_anon_vma() and then block on the mutex.
495  */
496 struct anon_vma *page_lock_anon_vma_read(struct page *page)
497 {
498         struct anon_vma *anon_vma = NULL;
499         struct anon_vma *root_anon_vma;
500         unsigned long anon_mapping;
501
502         rcu_read_lock();
503         anon_mapping = (unsigned long)READ_ONCE(page->mapping);
504         if ((anon_mapping & PAGE_MAPPING_FLAGS) != PAGE_MAPPING_ANON)
505                 goto out;
506         if (!page_mapped(page))
507                 goto out;
508
509         anon_vma = (struct anon_vma *) (anon_mapping - PAGE_MAPPING_ANON);
510         root_anon_vma = READ_ONCE(anon_vma->root);
511         if (down_read_trylock(&root_anon_vma->rwsem)) {
512                 /*
513                  * If the page is still mapped, then this anon_vma is still
514                  * its anon_vma, and holding the mutex ensures that it will
515                  * not go away, see anon_vma_free().
516                  */
517                 if (!page_mapped(page)) {
518                         up_read(&root_anon_vma->rwsem);
519                         anon_vma = NULL;
520                 }
521                 goto out;
522         }
523
524         /* trylock failed, we got to sleep */
525         if (!atomic_inc_not_zero(&anon_vma->refcount)) {
526                 anon_vma = NULL;
527                 goto out;
528         }
529
530         if (!page_mapped(page)) {
531                 rcu_read_unlock();
532                 put_anon_vma(anon_vma);
533                 return NULL;
534         }
535
536         /* we pinned the anon_vma, its safe to sleep */
537         rcu_read_unlock();
538         anon_vma_lock_read(anon_vma);
539
540         if (atomic_dec_and_test(&anon_vma->refcount)) {
541                 /*
542                  * Oops, we held the last refcount, release the lock
543                  * and bail -- can't simply use put_anon_vma() because
544                  * we'll deadlock on the anon_vma_lock_write() recursion.
545                  */
546                 anon_vma_unlock_read(anon_vma);
547                 __put_anon_vma(anon_vma);
548                 anon_vma = NULL;
549         }
550
551         return anon_vma;
552
553 out:
554         rcu_read_unlock();
555         return anon_vma;
556 }
557
558 void page_unlock_anon_vma_read(struct anon_vma *anon_vma)
559 {
560         anon_vma_unlock_read(anon_vma);
561 }
562
563 /*
564  * At what user virtual address is page expected in @vma?
565  */
566 static inline unsigned long
567 __vma_address(struct page *page, struct vm_area_struct *vma)
568 {
569         pgoff_t pgoff = page_to_pgoff(page);
570         return vma->vm_start + ((pgoff - vma->vm_pgoff) << PAGE_SHIFT);
571 }
572
573 inline unsigned long
574 vma_address(struct page *page, struct vm_area_struct *vma)
575 {
576         unsigned long address = __vma_address(page, vma);
577
578         /* page should be within @vma mapping range */
579         VM_BUG_ON_VMA(address < vma->vm_start || address >= vma->vm_end, vma);
580
581         return address;
582 }
583
584 /*
585  * At what user virtual address is page expected in vma?
586  * Caller should check the page is actually part of the vma.
587  */
588 unsigned long page_address_in_vma(struct page *page, struct vm_area_struct *vma)
589 {
590         unsigned long address;
591         if (PageAnon(page)) {
592                 struct anon_vma *page__anon_vma = page_anon_vma(page);
593                 /*
594                  * Note: swapoff's unuse_vma() is more efficient with this
595                  * check, and needs it to match anon_vma when KSM is active.
596                  */
597                 if (!vma->anon_vma || !page__anon_vma ||
598                     vma->anon_vma->root != page__anon_vma->root)
599                         return -EFAULT;
600         } else if (page->mapping) {
601                 if (!vma->vm_file || vma->vm_file->f_mapping != page->mapping)
602                         return -EFAULT;
603         } else
604                 return -EFAULT;
605         address = __vma_address(page, vma);
606         if (unlikely(address < vma->vm_start || address >= vma->vm_end))
607                 return -EFAULT;
608         return address;
609 }
610
611 pmd_t *mm_find_pmd(struct mm_struct *mm, unsigned long address)
612 {
613         pgd_t *pgd;
614         pud_t *pud;
615         pmd_t *pmd = NULL;
616         pmd_t pmde;
617
618         pgd = pgd_offset(mm, address);
619         if (!pgd_present(*pgd))
620                 goto out;
621
622         pud = pud_offset(pgd, address);
623         if (!pud_present(*pud))
624                 goto out;
625
626         pmd = pmd_offset(pud, address);
627         /*
628          * Some THP functions use the sequence pmdp_clear_flush(), set_pmd_at()
629          * without holding anon_vma lock for write.  So when looking for a
630          * genuine pmde (in which to find pte), test present and !THP together.
631          */
632         pmde = *pmd;
633         barrier();
634         if (!pmd_present(pmde) || pmd_trans_huge(pmde))
635                 pmd = NULL;
636 out:
637         return pmd;
638 }
639
640 /*
641  * Check that @page is mapped at @address into @mm.
642  *
643  * If @sync is false, page_check_address may perform a racy check to avoid
644  * the page table lock when the pte is not present (helpful when reclaiming
645  * highly shared pages).
646  *
647  * On success returns with pte mapped and locked.
648  */
649 pte_t *__page_check_address(struct page *page, struct mm_struct *mm,
650                           unsigned long address, spinlock_t **ptlp, int sync)
651 {
652         pmd_t *pmd;
653         pte_t *pte;
654         spinlock_t *ptl;
655
656         if (unlikely(PageHuge(page))) {
657                 /* when pud is not present, pte will be NULL */
658                 pte = huge_pte_offset(mm, address);
659                 if (!pte)
660                         return NULL;
661
662                 ptl = huge_pte_lockptr(page_hstate(page), mm, pte);
663                 goto check;
664         }
665
666         pmd = mm_find_pmd(mm, address);
667         if (!pmd)
668                 return NULL;
669
670         pte = pte_offset_map(pmd, address);
671         /* Make a quick check before getting the lock */
672         if (!sync && !pte_present(*pte)) {
673                 pte_unmap(pte);
674                 return NULL;
675         }
676
677         ptl = pte_lockptr(mm, pmd);
678 check:
679         spin_lock(ptl);
680         if (pte_present(*pte) && page_to_pfn(page) == pte_pfn(*pte)) {
681                 *ptlp = ptl;
682                 return pte;
683         }
684         pte_unmap_unlock(pte, ptl);
685         return NULL;
686 }
687
688 /**
689  * page_mapped_in_vma - check whether a page is really mapped in a VMA
690  * @page: the page to test
691  * @vma: the VMA to test
692  *
693  * Returns 1 if the page is mapped into the page tables of the VMA, 0
694  * if the page is not mapped into the page tables of this VMA.  Only
695  * valid for normal file or anonymous VMAs.
696  */
697 int page_mapped_in_vma(struct page *page, struct vm_area_struct *vma)
698 {
699         unsigned long address;
700         pte_t *pte;
701         spinlock_t *ptl;
702
703         address = __vma_address(page, vma);
704         if (unlikely(address < vma->vm_start || address >= vma->vm_end))
705                 return 0;
706         pte = page_check_address(page, vma->vm_mm, address, &ptl, 1);
707         if (!pte)                       /* the page is not in this mm */
708                 return 0;
709         pte_unmap_unlock(pte, ptl);
710
711         return 1;
712 }
713
714 struct page_referenced_arg {
715         int mapcount;
716         int referenced;
717         unsigned long vm_flags;
718         struct mem_cgroup *memcg;
719 };
720 /*
721  * arg: page_referenced_arg will be passed
722  */
723 static int page_referenced_one(struct page *page, struct vm_area_struct *vma,
724                         unsigned long address, void *arg)
725 {
726         struct mm_struct *mm = vma->vm_mm;
727         spinlock_t *ptl;
728         int referenced = 0;
729         struct page_referenced_arg *pra = arg;
730
731         if (unlikely(PageTransHuge(page))) {
732                 pmd_t *pmd;
733
734                 /*
735                  * rmap might return false positives; we must filter
736                  * these out using page_check_address_pmd().
737                  */
738                 pmd = page_check_address_pmd(page, mm, address,
739                                              PAGE_CHECK_ADDRESS_PMD_FLAG, &ptl);
740                 if (!pmd)
741                         return SWAP_AGAIN;
742
743                 if (vma->vm_flags & VM_LOCKED) {
744                         spin_unlock(ptl);
745                         pra->vm_flags |= VM_LOCKED;
746                         return SWAP_FAIL; /* To break the loop */
747                 }
748
749                 /* go ahead even if the pmd is pmd_trans_splitting() */
750                 if (pmdp_clear_flush_young_notify(vma, address, pmd))
751                         referenced++;
752                 spin_unlock(ptl);
753         } else {
754                 pte_t *pte;
755
756                 /*
757                  * rmap might return false positives; we must filter
758                  * these out using page_check_address().
759                  */
760                 pte = page_check_address(page, mm, address, &ptl, 0);
761                 if (!pte)
762                         return SWAP_AGAIN;
763
764                 if (vma->vm_flags & VM_LOCKED) {
765                         pte_unmap_unlock(pte, ptl);
766                         pra->vm_flags |= VM_LOCKED;
767                         return SWAP_FAIL; /* To break the loop */
768                 }
769
770                 if (ptep_clear_flush_young_notify(vma, address, pte)) {
771                         /*
772                          * Don't treat a reference through a sequentially read
773                          * mapping as such.  If the page has been used in
774                          * another mapping, we will catch it; if this other
775                          * mapping is already gone, the unmap path will have
776                          * set PG_referenced or activated the page.
777                          */
778                         if (likely(!(vma->vm_flags & VM_SEQ_READ)))
779                                 referenced++;
780                 }
781                 pte_unmap_unlock(pte, ptl);
782         }
783
784         if (referenced) {
785                 pra->referenced++;
786                 pra->vm_flags |= vma->vm_flags;
787         }
788
789         pra->mapcount--;
790         if (!pra->mapcount)
791                 return SWAP_SUCCESS; /* To break the loop */
792
793         return SWAP_AGAIN;
794 }
795
796 static bool invalid_page_referenced_vma(struct vm_area_struct *vma, void *arg)
797 {
798         struct page_referenced_arg *pra = arg;
799         struct mem_cgroup *memcg = pra->memcg;
800
801         if (!mm_match_cgroup(vma->vm_mm, memcg))
802                 return true;
803
804         return false;
805 }
806
807 /**
808  * page_referenced - test if the page was referenced
809  * @page: the page to test
810  * @is_locked: caller holds lock on the page
811  * @memcg: target memory cgroup
812  * @vm_flags: collect encountered vma->vm_flags who actually referenced the page
813  *
814  * Quick test_and_clear_referenced for all mappings to a page,
815  * returns the number of ptes which referenced the page.
816  */
817 int page_referenced(struct page *page,
818                     int is_locked,
819                     struct mem_cgroup *memcg,
820                     unsigned long *vm_flags)
821 {
822         int ret;
823         int we_locked = 0;
824         struct page_referenced_arg pra = {
825                 .mapcount = page_mapcount(page),
826                 .memcg = memcg,
827         };
828         struct rmap_walk_control rwc = {
829                 .rmap_one = page_referenced_one,
830                 .arg = (void *)&pra,
831                 .anon_lock = page_lock_anon_vma_read,
832         };
833
834         *vm_flags = 0;
835         if (!page_mapped(page))
836                 return 0;
837
838         if (!page_rmapping(page))
839                 return 0;
840
841         if (!is_locked && (!PageAnon(page) || PageKsm(page))) {
842                 we_locked = trylock_page(page);
843                 if (!we_locked)
844                         return 1;
845         }
846
847         /*
848          * If we are reclaiming on behalf of a cgroup, skip
849          * counting on behalf of references from different
850          * cgroups
851          */
852         if (memcg) {
853                 rwc.invalid_vma = invalid_page_referenced_vma;
854         }
855
856         ret = rmap_walk(page, &rwc);
857         *vm_flags = pra.vm_flags;
858
859         if (we_locked)
860                 unlock_page(page);
861
862         return pra.referenced;
863 }
864
865 static int page_mkclean_one(struct page *page, struct vm_area_struct *vma,
866                             unsigned long address, void *arg)
867 {
868         struct mm_struct *mm = vma->vm_mm;
869         pte_t *pte;
870         spinlock_t *ptl;
871         int ret = 0;
872         int *cleaned = arg;
873
874         pte = page_check_address(page, mm, address, &ptl, 1);
875         if (!pte)
876                 goto out;
877
878         if (pte_dirty(*pte) || pte_write(*pte)) {
879                 pte_t entry;
880
881                 flush_cache_page(vma, address, pte_pfn(*pte));
882                 entry = ptep_clear_flush(vma, address, pte);
883                 entry = pte_wrprotect(entry);
884                 entry = pte_mkclean(entry);
885                 set_pte_at(mm, address, pte, entry);
886                 ret = 1;
887         }
888
889         pte_unmap_unlock(pte, ptl);
890
891         if (ret) {
892                 mmu_notifier_invalidate_page(mm, address);
893                 (*cleaned)++;
894         }
895 out:
896         return SWAP_AGAIN;
897 }
898
899 static bool invalid_mkclean_vma(struct vm_area_struct *vma, void *arg)
900 {
901         if (vma->vm_flags & VM_SHARED)
902                 return false;
903
904         return true;
905 }
906
907 int page_mkclean(struct page *page)
908 {
909         int cleaned = 0;
910         struct address_space *mapping;
911         struct rmap_walk_control rwc = {
912                 .arg = (void *)&cleaned,
913                 .rmap_one = page_mkclean_one,
914                 .invalid_vma = invalid_mkclean_vma,
915         };
916
917         BUG_ON(!PageLocked(page));
918
919         if (!page_mapped(page))
920                 return 0;
921
922         mapping = page_mapping(page);
923         if (!mapping)
924                 return 0;
925
926         rmap_walk(page, &rwc);
927
928         return cleaned;
929 }
930 EXPORT_SYMBOL_GPL(page_mkclean);
931
932 /**
933  * page_move_anon_rmap - move a page to our anon_vma
934  * @page:       the page to move to our anon_vma
935  * @vma:        the vma the page belongs to
936  * @address:    the user virtual address mapped
937  *
938  * When a page belongs exclusively to one process after a COW event,
939  * that page can be moved into the anon_vma that belongs to just that
940  * process, so the rmap code will not search the parent or sibling
941  * processes.
942  */
943 void page_move_anon_rmap(struct page *page,
944         struct vm_area_struct *vma, unsigned long address)
945 {
946         struct anon_vma *anon_vma = vma->anon_vma;
947
948         VM_BUG_ON_PAGE(!PageLocked(page), page);
949         VM_BUG_ON_VMA(!anon_vma, vma);
950         VM_BUG_ON_PAGE(page->index != linear_page_index(vma, address), page);
951
952         anon_vma = (void *) anon_vma + PAGE_MAPPING_ANON;
953         page->mapping = (struct address_space *) anon_vma;
954 }
955
956 /**
957  * __page_set_anon_rmap - set up new anonymous rmap
958  * @page:       Page to add to rmap     
959  * @vma:        VM area to add page to.
960  * @address:    User virtual address of the mapping     
961  * @exclusive:  the page is exclusively owned by the current process
962  */
963 static void __page_set_anon_rmap(struct page *page,
964         struct vm_area_struct *vma, unsigned long address, int exclusive)
965 {
966         struct anon_vma *anon_vma = vma->anon_vma;
967
968         BUG_ON(!anon_vma);
969
970         if (PageAnon(page))
971                 return;
972
973         /*
974          * If the page isn't exclusively mapped into this vma,
975          * we must use the _oldest_ possible anon_vma for the
976          * page mapping!
977          */
978         if (!exclusive)
979                 anon_vma = anon_vma->root;
980
981         anon_vma = (void *) anon_vma + PAGE_MAPPING_ANON;
982         page->mapping = (struct address_space *) anon_vma;
983         page->index = linear_page_index(vma, address);
984 }
985
986 /**
987  * __page_check_anon_rmap - sanity check anonymous rmap addition
988  * @page:       the page to add the mapping to
989  * @vma:        the vm area in which the mapping is added
990  * @address:    the user virtual address mapped
991  */
992 static void __page_check_anon_rmap(struct page *page,
993         struct vm_area_struct *vma, unsigned long address)
994 {
995 #ifdef CONFIG_DEBUG_VM
996         /*
997          * The page's anon-rmap details (mapping and index) are guaranteed to
998          * be set up correctly at this point.
999          *
1000          * We have exclusion against page_add_anon_rmap because the caller
1001          * always holds the page locked, except if called from page_dup_rmap,
1002          * in which case the page is already known to be setup.
1003          *
1004          * We have exclusion against page_add_new_anon_rmap because those pages
1005          * are initially only visible via the pagetables, and the pte is locked
1006          * over the call to page_add_new_anon_rmap.
1007          */
1008         BUG_ON(page_anon_vma(page)->root != vma->anon_vma->root);
1009         BUG_ON(page->index != linear_page_index(vma, address));
1010 #endif
1011 }
1012
1013 /**
1014  * page_add_anon_rmap - add pte mapping to an anonymous page
1015  * @page:       the page to add the mapping to
1016  * @vma:        the vm area in which the mapping is added
1017  * @address:    the user virtual address mapped
1018  *
1019  * The caller needs to hold the pte lock, and the page must be locked in
1020  * the anon_vma case: to serialize mapping,index checking after setting,
1021  * and to ensure that PageAnon is not being upgraded racily to PageKsm
1022  * (but PageKsm is never downgraded to PageAnon).
1023  */
1024 void page_add_anon_rmap(struct page *page,
1025         struct vm_area_struct *vma, unsigned long address)
1026 {
1027         do_page_add_anon_rmap(page, vma, address, 0);
1028 }
1029
1030 /*
1031  * Special version of the above for do_swap_page, which often runs
1032  * into pages that are exclusively owned by the current process.
1033  * Everybody else should continue to use page_add_anon_rmap above.
1034  */
1035 void do_page_add_anon_rmap(struct page *page,
1036         struct vm_area_struct *vma, unsigned long address, int exclusive)
1037 {
1038         int first = atomic_inc_and_test(&page->_mapcount);
1039         if (first) {
1040                 /*
1041                  * We use the irq-unsafe __{inc|mod}_zone_page_stat because
1042                  * these counters are not modified in interrupt context, and
1043                  * pte lock(a spinlock) is held, which implies preemption
1044                  * disabled.
1045                  */
1046                 if (PageTransHuge(page))
1047                         __inc_zone_page_state(page,
1048                                               NR_ANON_TRANSPARENT_HUGEPAGES);
1049                 __mod_zone_page_state(page_zone(page), NR_ANON_PAGES,
1050                                 hpage_nr_pages(page));
1051         }
1052         if (unlikely(PageKsm(page)))
1053                 return;
1054
1055         VM_BUG_ON_PAGE(!PageLocked(page), page);
1056         /* address might be in next vma when migration races vma_adjust */
1057         if (first)
1058                 __page_set_anon_rmap(page, vma, address, exclusive);
1059         else
1060                 __page_check_anon_rmap(page, vma, address);
1061 }
1062
1063 /**
1064  * page_add_new_anon_rmap - add pte mapping to a new anonymous page
1065  * @page:       the page to add the mapping to
1066  * @vma:        the vm area in which the mapping is added
1067  * @address:    the user virtual address mapped
1068  *
1069  * Same as page_add_anon_rmap but must only be called on *new* pages.
1070  * This means the inc-and-test can be bypassed.
1071  * Page does not have to be locked.
1072  */
1073 void page_add_new_anon_rmap(struct page *page,
1074         struct vm_area_struct *vma, unsigned long address)
1075 {
1076         VM_BUG_ON_VMA(address < vma->vm_start || address >= vma->vm_end, vma);
1077         SetPageSwapBacked(page);
1078         atomic_set(&page->_mapcount, 0); /* increment count (starts at -1) */
1079         if (PageTransHuge(page))
1080                 __inc_zone_page_state(page, NR_ANON_TRANSPARENT_HUGEPAGES);
1081         __mod_zone_page_state(page_zone(page), NR_ANON_PAGES,
1082                         hpage_nr_pages(page));
1083         __page_set_anon_rmap(page, vma, address, 1);
1084 }
1085
1086 /**
1087  * page_add_file_rmap - add pte mapping to a file page
1088  * @page: the page to add the mapping to
1089  *
1090  * The caller needs to hold the pte lock.
1091  */
1092 void page_add_file_rmap(struct page *page)
1093 {
1094         struct mem_cgroup *memcg;
1095
1096         memcg = mem_cgroup_begin_page_stat(page);
1097         if (atomic_inc_and_test(&page->_mapcount)) {
1098                 __inc_zone_page_state(page, NR_FILE_MAPPED);
1099                 mem_cgroup_inc_page_stat(memcg, MEM_CGROUP_STAT_FILE_MAPPED);
1100         }
1101         mem_cgroup_end_page_stat(memcg);
1102 }
1103
1104 static void page_remove_file_rmap(struct page *page)
1105 {
1106         struct mem_cgroup *memcg;
1107
1108         memcg = mem_cgroup_begin_page_stat(page);
1109
1110         /* page still mapped by someone else? */
1111         if (!atomic_add_negative(-1, &page->_mapcount))
1112                 goto out;
1113
1114         /* Hugepages are not counted in NR_FILE_MAPPED for now. */
1115         if (unlikely(PageHuge(page)))
1116                 goto out;
1117
1118         /*
1119          * We use the irq-unsafe __{inc|mod}_zone_page_stat because
1120          * these counters are not modified in interrupt context, and
1121          * pte lock(a spinlock) is held, which implies preemption disabled.
1122          */
1123         __dec_zone_page_state(page, NR_FILE_MAPPED);
1124         mem_cgroup_dec_page_stat(memcg, MEM_CGROUP_STAT_FILE_MAPPED);
1125
1126         if (unlikely(PageMlocked(page)))
1127                 clear_page_mlock(page);
1128 out:
1129         mem_cgroup_end_page_stat(memcg);
1130 }
1131
1132 /**
1133  * page_remove_rmap - take down pte mapping from a page
1134  * @page: page to remove mapping from
1135  *
1136  * The caller needs to hold the pte lock.
1137  */
1138 void page_remove_rmap(struct page *page)
1139 {
1140         if (!PageAnon(page)) {
1141                 page_remove_file_rmap(page);
1142                 return;
1143         }
1144
1145         /* page still mapped by someone else? */
1146         if (!atomic_add_negative(-1, &page->_mapcount))
1147                 return;
1148
1149         /* Hugepages are not counted in NR_ANON_PAGES for now. */
1150         if (unlikely(PageHuge(page)))
1151                 return;
1152
1153         /*
1154          * We use the irq-unsafe __{inc|mod}_zone_page_stat because
1155          * these counters are not modified in interrupt context, and
1156          * pte lock(a spinlock) is held, which implies preemption disabled.
1157          */
1158         if (PageTransHuge(page))
1159                 __dec_zone_page_state(page, NR_ANON_TRANSPARENT_HUGEPAGES);
1160
1161         __mod_zone_page_state(page_zone(page), NR_ANON_PAGES,
1162                               -hpage_nr_pages(page));
1163
1164         if (unlikely(PageMlocked(page)))
1165                 clear_page_mlock(page);
1166
1167         /*
1168          * It would be tidy to reset the PageAnon mapping here,
1169          * but that might overwrite a racing page_add_anon_rmap
1170          * which increments mapcount after us but sets mapping
1171          * before us: so leave the reset to free_hot_cold_page,
1172          * and remember that it's only reliable while mapped.
1173          * Leaving it set also helps swapoff to reinstate ptes
1174          * faster for those pages still in swapcache.
1175          */
1176 }
1177
1178 /*
1179  * @arg: enum ttu_flags will be passed to this argument
1180  */
1181 static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
1182                      unsigned long address, void *arg)
1183 {
1184         struct mm_struct *mm = vma->vm_mm;
1185         pte_t *pte;
1186         pte_t pteval;
1187         spinlock_t *ptl;
1188         int ret = SWAP_AGAIN;
1189         enum ttu_flags flags = (enum ttu_flags)arg;
1190
1191         pte = page_check_address(page, mm, address, &ptl, 0);
1192         if (!pte)
1193                 goto out;
1194
1195         /*
1196          * If the page is mlock()d, we cannot swap it out.
1197          * If it's recently referenced (perhaps page_referenced
1198          * skipped over this mm) then we should reactivate it.
1199          */
1200         if (!(flags & TTU_IGNORE_MLOCK)) {
1201                 if (vma->vm_flags & VM_LOCKED)
1202                         goto out_mlock;
1203
1204                 if (flags & TTU_MUNLOCK)
1205                         goto out_unmap;
1206         }
1207         if (!(flags & TTU_IGNORE_ACCESS)) {
1208                 if (ptep_clear_flush_young_notify(vma, address, pte)) {
1209                         ret = SWAP_FAIL;
1210                         goto out_unmap;
1211                 }
1212         }
1213
1214         /* Nuke the page table entry. */
1215         flush_cache_page(vma, address, page_to_pfn(page));
1216         pteval = ptep_clear_flush(vma, address, pte);
1217
1218         /* Move the dirty bit to the physical page now the pte is gone. */
1219         if (pte_dirty(pteval))
1220                 set_page_dirty(page);
1221
1222         /* Update high watermark before we lower rss */
1223         update_hiwater_rss(mm);
1224
1225         if (PageHWPoison(page) && !(flags & TTU_IGNORE_HWPOISON)) {
1226                 if (!PageHuge(page)) {
1227                         if (PageAnon(page))
1228                                 dec_mm_counter(mm, MM_ANONPAGES);
1229                         else
1230                                 dec_mm_counter(mm, MM_FILEPAGES);
1231                 }
1232                 set_pte_at(mm, address, pte,
1233                            swp_entry_to_pte(make_hwpoison_entry(page)));
1234         } else if (pte_unused(pteval)) {
1235                 /*
1236                  * The guest indicated that the page content is of no
1237                  * interest anymore. Simply discard the pte, vmscan
1238                  * will take care of the rest.
1239                  */
1240                 if (PageAnon(page))
1241                         dec_mm_counter(mm, MM_ANONPAGES);
1242                 else
1243                         dec_mm_counter(mm, MM_FILEPAGES);
1244         } else if (PageAnon(page)) {
1245                 swp_entry_t entry = { .val = page_private(page) };
1246                 pte_t swp_pte;
1247
1248                 if (PageSwapCache(page)) {
1249                         /*
1250                          * Store the swap location in the pte.
1251                          * See handle_pte_fault() ...
1252                          */
1253                         if (swap_duplicate(entry) < 0) {
1254                                 set_pte_at(mm, address, pte, pteval);
1255                                 ret = SWAP_FAIL;
1256                                 goto out_unmap;
1257                         }
1258                         if (list_empty(&mm->mmlist)) {
1259                                 spin_lock(&mmlist_lock);
1260                                 if (list_empty(&mm->mmlist))
1261                                         list_add(&mm->mmlist, &init_mm.mmlist);
1262                                 spin_unlock(&mmlist_lock);
1263                         }
1264                         dec_mm_counter(mm, MM_ANONPAGES);
1265                         inc_mm_counter(mm, MM_SWAPENTS);
1266                 } else if (IS_ENABLED(CONFIG_MIGRATION)) {
1267                         /*
1268                          * Store the pfn of the page in a special migration
1269                          * pte. do_swap_page() will wait until the migration
1270                          * pte is removed and then restart fault handling.
1271                          */
1272                         BUG_ON(!(flags & TTU_MIGRATION));
1273                         entry = make_migration_entry(page, pte_write(pteval));
1274                 }
1275                 swp_pte = swp_entry_to_pte(entry);
1276                 if (pte_soft_dirty(pteval))
1277                         swp_pte = pte_swp_mksoft_dirty(swp_pte);
1278                 set_pte_at(mm, address, pte, swp_pte);
1279         } else if (IS_ENABLED(CONFIG_MIGRATION) &&
1280                    (flags & TTU_MIGRATION)) {
1281                 /* Establish migration entry for a file page */
1282                 swp_entry_t entry;
1283                 entry = make_migration_entry(page, pte_write(pteval));
1284                 set_pte_at(mm, address, pte, swp_entry_to_pte(entry));
1285         } else
1286                 dec_mm_counter(mm, MM_FILEPAGES);
1287
1288         page_remove_rmap(page);
1289         page_cache_release(page);
1290
1291 out_unmap:
1292         pte_unmap_unlock(pte, ptl);
1293         if (ret != SWAP_FAIL && !(flags & TTU_MUNLOCK))
1294                 mmu_notifier_invalidate_page(mm, address);
1295 out:
1296         return ret;
1297
1298 out_mlock:
1299         pte_unmap_unlock(pte, ptl);
1300
1301
1302         /*
1303          * We need mmap_sem locking, Otherwise VM_LOCKED check makes
1304          * unstable result and race. Plus, We can't wait here because
1305          * we now hold anon_vma->rwsem or mapping->i_mmap_rwsem.
1306          * if trylock failed, the page remain in evictable lru and later
1307          * vmscan could retry to move the page to unevictable lru if the
1308          * page is actually mlocked.
1309          */
1310         if (down_read_trylock(&vma->vm_mm->mmap_sem)) {
1311                 if (vma->vm_flags & VM_LOCKED) {
1312                         mlock_vma_page(page);
1313                         ret = SWAP_MLOCK;
1314                 }
1315                 up_read(&vma->vm_mm->mmap_sem);
1316         }
1317         return ret;
1318 }
1319
1320 bool is_vma_temporary_stack(struct vm_area_struct *vma)
1321 {
1322         int maybe_stack = vma->vm_flags & (VM_GROWSDOWN | VM_GROWSUP);
1323
1324         if (!maybe_stack)
1325                 return false;
1326
1327         if ((vma->vm_flags & VM_STACK_INCOMPLETE_SETUP) ==
1328                                                 VM_STACK_INCOMPLETE_SETUP)
1329                 return true;
1330
1331         return false;
1332 }
1333
1334 static bool invalid_migration_vma(struct vm_area_struct *vma, void *arg)
1335 {
1336         return is_vma_temporary_stack(vma);
1337 }
1338
1339 static int page_not_mapped(struct page *page)
1340 {
1341         return !page_mapped(page);
1342 };
1343
1344 /**
1345  * try_to_unmap - try to remove all page table mappings to a page
1346  * @page: the page to get unmapped
1347  * @flags: action and flags
1348  *
1349  * Tries to remove all the page table entries which are mapping this
1350  * page, used in the pageout path.  Caller must hold the page lock.
1351  * Return values are:
1352  *
1353  * SWAP_SUCCESS - we succeeded in removing all mappings
1354  * SWAP_AGAIN   - we missed a mapping, try again later
1355  * SWAP_FAIL    - the page is unswappable
1356  * SWAP_MLOCK   - page is mlocked.
1357  */
1358 int try_to_unmap(struct page *page, enum ttu_flags flags)
1359 {
1360         int ret;
1361         struct rmap_walk_control rwc = {
1362                 .rmap_one = try_to_unmap_one,
1363                 .arg = (void *)flags,
1364                 .done = page_not_mapped,
1365                 .anon_lock = page_lock_anon_vma_read,
1366         };
1367
1368         VM_BUG_ON_PAGE(!PageHuge(page) && PageTransHuge(page), page);
1369
1370         /*
1371          * During exec, a temporary VMA is setup and later moved.
1372          * The VMA is moved under the anon_vma lock but not the
1373          * page tables leading to a race where migration cannot
1374          * find the migration ptes. Rather than increasing the
1375          * locking requirements of exec(), migration skips
1376          * temporary VMAs until after exec() completes.
1377          */
1378         if ((flags & TTU_MIGRATION) && !PageKsm(page) && PageAnon(page))
1379                 rwc.invalid_vma = invalid_migration_vma;
1380
1381         ret = rmap_walk(page, &rwc);
1382
1383         if (ret != SWAP_MLOCK && !page_mapped(page))
1384                 ret = SWAP_SUCCESS;
1385         return ret;
1386 }
1387
1388 /**
1389  * try_to_munlock - try to munlock a page
1390  * @page: the page to be munlocked
1391  *
1392  * Called from munlock code.  Checks all of the VMAs mapping the page
1393  * to make sure nobody else has this page mlocked. The page will be
1394  * returned with PG_mlocked cleared if no other vmas have it mlocked.
1395  *
1396  * Return values are:
1397  *
1398  * SWAP_AGAIN   - no vma is holding page mlocked, or,
1399  * SWAP_AGAIN   - page mapped in mlocked vma -- couldn't acquire mmap sem
1400  * SWAP_FAIL    - page cannot be located at present
1401  * SWAP_MLOCK   - page is now mlocked.
1402  */
1403 int try_to_munlock(struct page *page)
1404 {
1405         int ret;
1406         struct rmap_walk_control rwc = {
1407                 .rmap_one = try_to_unmap_one,
1408                 .arg = (void *)TTU_MUNLOCK,
1409                 .done = page_not_mapped,
1410                 .anon_lock = page_lock_anon_vma_read,
1411
1412         };
1413
1414         VM_BUG_ON_PAGE(!PageLocked(page) || PageLRU(page), page);
1415
1416         ret = rmap_walk(page, &rwc);
1417         return ret;
1418 }
1419
1420 void __put_anon_vma(struct anon_vma *anon_vma)
1421 {
1422         struct anon_vma *root = anon_vma->root;
1423
1424         anon_vma_free(anon_vma);
1425         if (root != anon_vma && atomic_dec_and_test(&root->refcount))
1426                 anon_vma_free(root);
1427 }
1428
1429 static struct anon_vma *rmap_walk_anon_lock(struct page *page,
1430                                         struct rmap_walk_control *rwc)
1431 {
1432         struct anon_vma *anon_vma;
1433
1434         if (rwc->anon_lock)
1435                 return rwc->anon_lock(page);
1436
1437         /*
1438          * Note: remove_migration_ptes() cannot use page_lock_anon_vma_read()
1439          * because that depends on page_mapped(); but not all its usages
1440          * are holding mmap_sem. Users without mmap_sem are required to
1441          * take a reference count to prevent the anon_vma disappearing
1442          */
1443         anon_vma = page_anon_vma(page);
1444         if (!anon_vma)
1445                 return NULL;
1446
1447         anon_vma_lock_read(anon_vma);
1448         return anon_vma;
1449 }
1450
1451 /*
1452  * rmap_walk_anon - do something to anonymous page using the object-based
1453  * rmap method
1454  * @page: the page to be handled
1455  * @rwc: control variable according to each walk type
1456  *
1457  * Find all the mappings of a page using the mapping pointer and the vma chains
1458  * contained in the anon_vma struct it points to.
1459  *
1460  * When called from try_to_munlock(), the mmap_sem of the mm containing the vma
1461  * where the page was found will be held for write.  So, we won't recheck
1462  * vm_flags for that VMA.  That should be OK, because that vma shouldn't be
1463  * LOCKED.
1464  */
1465 static int rmap_walk_anon(struct page *page, struct rmap_walk_control *rwc)
1466 {
1467         struct anon_vma *anon_vma;
1468         pgoff_t pgoff;
1469         struct anon_vma_chain *avc;
1470         int ret = SWAP_AGAIN;
1471
1472         anon_vma = rmap_walk_anon_lock(page, rwc);
1473         if (!anon_vma)
1474                 return ret;
1475
1476         pgoff = page_to_pgoff(page);
1477         anon_vma_interval_tree_foreach(avc, &anon_vma->rb_root, pgoff, pgoff) {
1478                 struct vm_area_struct *vma = avc->vma;
1479                 unsigned long address = vma_address(page, vma);
1480
1481                 if (rwc->invalid_vma && rwc->invalid_vma(vma, rwc->arg))
1482                         continue;
1483
1484                 ret = rwc->rmap_one(page, vma, address, rwc->arg);
1485                 if (ret != SWAP_AGAIN)
1486                         break;
1487                 if (rwc->done && rwc->done(page))
1488                         break;
1489         }
1490         anon_vma_unlock_read(anon_vma);
1491         return ret;
1492 }
1493
1494 /*
1495  * rmap_walk_file - do something to file page using the object-based rmap method
1496  * @page: the page to be handled
1497  * @rwc: control variable according to each walk type
1498  *
1499  * Find all the mappings of a page using the mapping pointer and the vma chains
1500  * contained in the address_space struct it points to.
1501  *
1502  * When called from try_to_munlock(), the mmap_sem of the mm containing the vma
1503  * where the page was found will be held for write.  So, we won't recheck
1504  * vm_flags for that VMA.  That should be OK, because that vma shouldn't be
1505  * LOCKED.
1506  */
1507 static int rmap_walk_file(struct page *page, struct rmap_walk_control *rwc)
1508 {
1509         struct address_space *mapping = page->mapping;
1510         pgoff_t pgoff;
1511         struct vm_area_struct *vma;
1512         int ret = SWAP_AGAIN;
1513
1514         /*
1515          * The page lock not only makes sure that page->mapping cannot
1516          * suddenly be NULLified by truncation, it makes sure that the
1517          * structure at mapping cannot be freed and reused yet,
1518          * so we can safely take mapping->i_mmap_rwsem.
1519          */
1520         VM_BUG_ON_PAGE(!PageLocked(page), page);
1521
1522         if (!mapping)
1523                 return ret;
1524
1525         pgoff = page_to_pgoff(page);
1526         i_mmap_lock_read(mapping);
1527         vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff, pgoff) {
1528                 unsigned long address = vma_address(page, vma);
1529
1530                 if (rwc->invalid_vma && rwc->invalid_vma(vma, rwc->arg))
1531                         continue;
1532
1533                 ret = rwc->rmap_one(page, vma, address, rwc->arg);
1534                 if (ret != SWAP_AGAIN)
1535                         goto done;
1536                 if (rwc->done && rwc->done(page))
1537                         goto done;
1538         }
1539
1540 done:
1541         i_mmap_unlock_read(mapping);
1542         return ret;
1543 }
1544
1545 int rmap_walk(struct page *page, struct rmap_walk_control *rwc)
1546 {
1547         if (unlikely(PageKsm(page)))
1548                 return rmap_walk_ksm(page, rwc);
1549         else if (PageAnon(page))
1550                 return rmap_walk_anon(page, rwc);
1551         else
1552                 return rmap_walk_file(page, rwc);
1553 }
1554
1555 #ifdef CONFIG_HUGETLB_PAGE
1556 /*
1557  * The following three functions are for anonymous (private mapped) hugepages.
1558  * Unlike common anonymous pages, anonymous hugepages have no accounting code
1559  * and no lru code, because we handle hugepages differently from common pages.
1560  */
1561 static void __hugepage_set_anon_rmap(struct page *page,
1562         struct vm_area_struct *vma, unsigned long address, int exclusive)
1563 {
1564         struct anon_vma *anon_vma = vma->anon_vma;
1565
1566         BUG_ON(!anon_vma);
1567
1568         if (PageAnon(page))
1569                 return;
1570         if (!exclusive)
1571                 anon_vma = anon_vma->root;
1572
1573         anon_vma = (void *) anon_vma + PAGE_MAPPING_ANON;
1574         page->mapping = (struct address_space *) anon_vma;
1575         page->index = linear_page_index(vma, address);
1576 }
1577
1578 void hugepage_add_anon_rmap(struct page *page,
1579                             struct vm_area_struct *vma, unsigned long address)
1580 {
1581         struct anon_vma *anon_vma = vma->anon_vma;
1582         int first;
1583
1584         BUG_ON(!PageLocked(page));
1585         BUG_ON(!anon_vma);
1586         /* address might be in next vma when migration races vma_adjust */
1587         first = atomic_inc_and_test(&page->_mapcount);
1588         if (first)
1589                 __hugepage_set_anon_rmap(page, vma, address, 0);
1590 }
1591
1592 void hugepage_add_new_anon_rmap(struct page *page,
1593                         struct vm_area_struct *vma, unsigned long address)
1594 {
1595         BUG_ON(address < vma->vm_start || address >= vma->vm_end);
1596         atomic_set(&page->_mapcount, 0);
1597         __hugepage_set_anon_rmap(page, vma, address, 1);
1598 }
1599 #endif /* CONFIG_HUGETLB_PAGE */