1 // SPDX-License-Identifier: GPL-2.0-only
2 #include <linux/kernel.h>
3 #include <linux/errno.h>
5 #include <linux/spinlock.h>
8 #include <linux/memremap.h>
9 #include <linux/pagemap.h>
10 #include <linux/rmap.h>
11 #include <linux/swap.h>
12 #include <linux/swapops.h>
13 #include <linux/secretmem.h>
15 #include <linux/sched/signal.h>
16 #include <linux/rwsem.h>
17 #include <linux/hugetlb.h>
18 #include <linux/migrate.h>
19 #include <linux/mm_inline.h>
20 #include <linux/sched/mm.h>
22 #include <asm/mmu_context.h>
23 #include <asm/tlbflush.h>
27 struct follow_page_context {
28 struct dev_pagemap *pgmap;
29 unsigned int page_mask;
33 * Return the folio with ref appropriately incremented,
34 * or NULL if that failed.
36 static inline struct folio *try_get_folio(struct page *page, int refs)
41 folio = page_folio(page);
42 if (WARN_ON_ONCE(folio_ref_count(folio) < 0))
44 if (unlikely(!folio_ref_try_add_rcu(folio, refs)))
48 * At this point we have a stable reference to the folio; but it
49 * could be that between calling page_folio() and the refcount
50 * increment, the folio was split, in which case we'd end up
51 * holding a reference on a folio that has nothing to do with the page
52 * we were given anymore.
53 * So now that the folio is stable, recheck that the page still
54 * belongs to this folio.
56 if (unlikely(page_folio(page) != folio)) {
57 folio_put_refs(folio, refs);
65 * try_grab_folio() - Attempt to get or pin a folio.
66 * @page: pointer to page to be grabbed
67 * @refs: the value to (effectively) add to the folio's refcount
68 * @flags: gup flags: these are the FOLL_* flag values.
70 * "grab" names in this file mean, "look at flags to decide whether to use
71 * FOLL_PIN or FOLL_GET behavior, when incrementing the folio's refcount.
73 * Either FOLL_PIN or FOLL_GET (or neither) must be set, but not both at the
74 * same time. (That's true throughout the get_user_pages*() and
75 * pin_user_pages*() APIs.) Cases:
77 * FOLL_GET: folio's refcount will be incremented by @refs.
79 * FOLL_PIN on large folios: folio's refcount will be incremented by
80 * @refs, and its compound_pincount will be incremented by @refs.
82 * FOLL_PIN on single-page folios: folio's refcount will be incremented by
83 * @refs * GUP_PIN_COUNTING_BIAS.
85 * Return: The folio containing @page (with refcount appropriately
86 * incremented) for success, or NULL upon failure. If neither FOLL_GET
87 * nor FOLL_PIN was set, that's considered failure, and furthermore,
88 * a likely bug in the caller, so a warning is also emitted.
90 struct folio *try_grab_folio(struct page *page, int refs, unsigned int flags)
93 return try_get_folio(page, refs);
94 else if (flags & FOLL_PIN) {
98 * Can't do FOLL_LONGTERM + FOLL_PIN gup fast path if not in a
99 * right zone, so fail and let the caller fall back to the slow
102 if (unlikely((flags & FOLL_LONGTERM) &&
103 !is_pinnable_page(page)))
107 * CAUTION: Don't use compound_head() on the page before this
108 * point, the result won't be stable.
110 folio = try_get_folio(page, refs);
115 * When pinning a large folio, use an exact count to track it.
117 * However, be sure to *also* increment the normal folio
118 * refcount field at least once, so that the folio really
119 * is pinned. That's why the refcount from the earlier
120 * try_get_folio() is left intact.
122 if (folio_test_large(folio))
123 atomic_add(refs, folio_pincount_ptr(folio));
126 refs * (GUP_PIN_COUNTING_BIAS - 1));
127 node_stat_mod_folio(folio, NR_FOLL_PIN_ACQUIRED, refs);
136 static void gup_put_folio(struct folio *folio, int refs, unsigned int flags)
138 if (flags & FOLL_PIN) {
139 node_stat_mod_folio(folio, NR_FOLL_PIN_RELEASED, refs);
140 if (folio_test_large(folio))
141 atomic_sub(refs, folio_pincount_ptr(folio));
143 refs *= GUP_PIN_COUNTING_BIAS;
146 folio_put_refs(folio, refs);
150 * try_grab_page() - elevate a page's refcount by a flag-dependent amount
151 * @page: pointer to page to be grabbed
152 * @flags: gup flags: these are the FOLL_* flag values.
154 * This might not do anything at all, depending on the flags argument.
156 * "grab" names in this file mean, "look at flags to decide whether to use
157 * FOLL_PIN or FOLL_GET behavior, when incrementing the page's refcount.
159 * Either FOLL_PIN or FOLL_GET (or neither) may be set, but not both at the same
160 * time. Cases: please see the try_grab_folio() documentation, with
163 * Return: true for success, or if no action was required (if neither FOLL_PIN
164 * nor FOLL_GET was set, nothing is done). False for failure: FOLL_GET or
165 * FOLL_PIN was set, but the page could not be grabbed.
167 bool __must_check try_grab_page(struct page *page, unsigned int flags)
169 struct folio *folio = page_folio(page);
171 WARN_ON_ONCE((flags & (FOLL_GET | FOLL_PIN)) == (FOLL_GET | FOLL_PIN));
172 if (WARN_ON_ONCE(folio_ref_count(folio) <= 0))
175 if (flags & FOLL_GET)
176 folio_ref_inc(folio);
177 else if (flags & FOLL_PIN) {
179 * Similar to try_grab_folio(): be sure to *also*
180 * increment the normal page refcount field at least once,
181 * so that the page really is pinned.
183 if (folio_test_large(folio)) {
184 folio_ref_add(folio, 1);
185 atomic_add(1, folio_pincount_ptr(folio));
187 folio_ref_add(folio, GUP_PIN_COUNTING_BIAS);
190 node_stat_mod_folio(folio, NR_FOLL_PIN_ACQUIRED, 1);
197 * unpin_user_page() - release a dma-pinned page
198 * @page: pointer to page to be released
200 * Pages that were pinned via pin_user_pages*() must be released via either
201 * unpin_user_page(), or one of the unpin_user_pages*() routines. This is so
202 * that such pages can be separately tracked and uniquely handled. In
203 * particular, interactions with RDMA and filesystems need special handling.
205 void unpin_user_page(struct page *page)
207 gup_put_folio(page_folio(page), 1, FOLL_PIN);
209 EXPORT_SYMBOL(unpin_user_page);
211 static inline struct folio *gup_folio_range_next(struct page *start,
212 unsigned long npages, unsigned long i, unsigned int *ntails)
214 struct page *next = nth_page(start, i);
215 struct folio *folio = page_folio(next);
218 if (folio_test_large(folio))
219 nr = min_t(unsigned int, npages - i,
220 folio_nr_pages(folio) - folio_page_idx(folio, next));
226 static inline struct folio *gup_folio_next(struct page **list,
227 unsigned long npages, unsigned long i, unsigned int *ntails)
229 struct folio *folio = page_folio(list[i]);
232 for (nr = i + 1; nr < npages; nr++) {
233 if (page_folio(list[nr]) != folio)
242 * unpin_user_pages_dirty_lock() - release and optionally dirty gup-pinned pages
243 * @pages: array of pages to be maybe marked dirty, and definitely released.
244 * @npages: number of pages in the @pages array.
245 * @make_dirty: whether to mark the pages dirty
247 * "gup-pinned page" refers to a page that has had one of the get_user_pages()
248 * variants called on that page.
250 * For each page in the @pages array, make that page (or its head page, if a
251 * compound page) dirty, if @make_dirty is true, and if the page was previously
252 * listed as clean. In any case, releases all pages using unpin_user_page(),
253 * possibly via unpin_user_pages(), for the non-dirty case.
255 * Please see the unpin_user_page() documentation for details.
257 * set_page_dirty_lock() is used internally. If instead, set_page_dirty() is
258 * required, then the caller should a) verify that this is really correct,
259 * because _lock() is usually required, and b) hand code it:
260 * set_page_dirty_lock(), unpin_user_page().
263 void unpin_user_pages_dirty_lock(struct page **pages, unsigned long npages,
271 unpin_user_pages(pages, npages);
275 for (i = 0; i < npages; i += nr) {
276 folio = gup_folio_next(pages, npages, i, &nr);
278 * Checking PageDirty at this point may race with
279 * clear_page_dirty_for_io(), but that's OK. Two key
282 * 1) This code sees the page as already dirty, so it
283 * skips the call to set_page_dirty(). That could happen
284 * because clear_page_dirty_for_io() called
285 * page_mkclean(), followed by set_page_dirty().
286 * However, now the page is going to get written back,
287 * which meets the original intention of setting it
288 * dirty, so all is well: clear_page_dirty_for_io() goes
289 * on to call TestClearPageDirty(), and write the page
292 * 2) This code sees the page as clean, so it calls
293 * set_page_dirty(). The page stays dirty, despite being
294 * written back, so it gets written back again in the
295 * next writeback cycle. This is harmless.
297 if (!folio_test_dirty(folio)) {
299 folio_mark_dirty(folio);
302 gup_put_folio(folio, nr, FOLL_PIN);
305 EXPORT_SYMBOL(unpin_user_pages_dirty_lock);
308 * unpin_user_page_range_dirty_lock() - release and optionally dirty
309 * gup-pinned page range
311 * @page: the starting page of a range maybe marked dirty, and definitely released.
312 * @npages: number of consecutive pages to release.
313 * @make_dirty: whether to mark the pages dirty
315 * "gup-pinned page range" refers to a range of pages that has had one of the
316 * pin_user_pages() variants called on that page.
318 * For the page ranges defined by [page .. page+npages], make that range (or
319 * its head pages, if a compound page) dirty, if @make_dirty is true, and if the
320 * page range was previously listed as clean.
322 * set_page_dirty_lock() is used internally. If instead, set_page_dirty() is
323 * required, then the caller should a) verify that this is really correct,
324 * because _lock() is usually required, and b) hand code it:
325 * set_page_dirty_lock(), unpin_user_page().
328 void unpin_user_page_range_dirty_lock(struct page *page, unsigned long npages,
335 for (i = 0; i < npages; i += nr) {
336 folio = gup_folio_range_next(page, npages, i, &nr);
337 if (make_dirty && !folio_test_dirty(folio)) {
339 folio_mark_dirty(folio);
342 gup_put_folio(folio, nr, FOLL_PIN);
345 EXPORT_SYMBOL(unpin_user_page_range_dirty_lock);
348 * unpin_user_pages() - release an array of gup-pinned pages.
349 * @pages: array of pages to be marked dirty and released.
350 * @npages: number of pages in the @pages array.
352 * For each page in the @pages array, release the page using unpin_user_page().
354 * Please see the unpin_user_page() documentation for details.
356 void unpin_user_pages(struct page **pages, unsigned long npages)
363 * If this WARN_ON() fires, then the system *might* be leaking pages (by
364 * leaving them pinned), but probably not. More likely, gup/pup returned
365 * a hard -ERRNO error to the caller, who erroneously passed it here.
367 if (WARN_ON(IS_ERR_VALUE(npages)))
370 for (i = 0; i < npages; i += nr) {
371 folio = gup_folio_next(pages, npages, i, &nr);
372 gup_put_folio(folio, nr, FOLL_PIN);
375 EXPORT_SYMBOL(unpin_user_pages);
378 * Set the MMF_HAS_PINNED if not set yet; after set it'll be there for the mm's
379 * lifecycle. Avoid setting the bit unless necessary, or it might cause write
380 * cache bouncing on large SMP machines for concurrent pinned gups.
382 static inline void mm_set_has_pinned_flag(unsigned long *mm_flags)
384 if (!test_bit(MMF_HAS_PINNED, mm_flags))
385 set_bit(MMF_HAS_PINNED, mm_flags);
389 static struct page *no_page_table(struct vm_area_struct *vma,
393 * When core dumping an enormous anonymous area that nobody
394 * has touched so far, we don't want to allocate unnecessary pages or
395 * page tables. Return error instead of NULL to skip handle_mm_fault,
396 * then get_dump_page() will return NULL to leave a hole in the dump.
397 * But we can only make this optimization where a hole would surely
398 * be zero-filled if handle_mm_fault() actually did handle it.
400 if ((flags & FOLL_DUMP) &&
401 (vma_is_anonymous(vma) || !vma->vm_ops->fault))
402 return ERR_PTR(-EFAULT);
406 static int follow_pfn_pte(struct vm_area_struct *vma, unsigned long address,
407 pte_t *pte, unsigned int flags)
409 if (flags & FOLL_TOUCH) {
412 if (flags & FOLL_WRITE)
413 entry = pte_mkdirty(entry);
414 entry = pte_mkyoung(entry);
416 if (!pte_same(*pte, entry)) {
417 set_pte_at(vma->vm_mm, address, pte, entry);
418 update_mmu_cache(vma, address, pte);
422 /* Proper page table entry exists, but no corresponding struct page */
427 * FOLL_FORCE can write to even unwritable pte's, but only
428 * after we've gone through a COW cycle and they are dirty.
430 static inline bool can_follow_write_pte(pte_t pte, unsigned int flags)
432 return pte_write(pte) ||
433 ((flags & FOLL_FORCE) && (flags & FOLL_COW) && pte_dirty(pte));
436 static struct page *follow_page_pte(struct vm_area_struct *vma,
437 unsigned long address, pmd_t *pmd, unsigned int flags,
438 struct dev_pagemap **pgmap)
440 struct mm_struct *mm = vma->vm_mm;
446 /* FOLL_GET and FOLL_PIN are mutually exclusive. */
447 if (WARN_ON_ONCE((flags & (FOLL_PIN | FOLL_GET)) ==
448 (FOLL_PIN | FOLL_GET)))
449 return ERR_PTR(-EINVAL);
451 if (unlikely(pmd_bad(*pmd)))
452 return no_page_table(vma, flags);
454 ptep = pte_offset_map_lock(mm, pmd, address, &ptl);
456 if (!pte_present(pte)) {
459 * KSM's break_ksm() relies upon recognizing a ksm page
460 * even while it is being migrated, so for that case we
461 * need migration_entry_wait().
463 if (likely(!(flags & FOLL_MIGRATION)))
467 entry = pte_to_swp_entry(pte);
468 if (!is_migration_entry(entry))
470 pte_unmap_unlock(ptep, ptl);
471 migration_entry_wait(mm, pmd, address);
474 if ((flags & FOLL_NUMA) && pte_protnone(pte))
476 if ((flags & FOLL_WRITE) && !can_follow_write_pte(pte, flags)) {
477 pte_unmap_unlock(ptep, ptl);
481 page = vm_normal_page(vma, address, pte);
482 if (!page && pte_devmap(pte) && (flags & (FOLL_GET | FOLL_PIN))) {
484 * Only return device mapping pages in the FOLL_GET or FOLL_PIN
485 * case since they are only valid while holding the pgmap
488 *pgmap = get_dev_pagemap(pte_pfn(pte), *pgmap);
490 page = pte_page(pte);
493 } else if (unlikely(!page)) {
494 if (flags & FOLL_DUMP) {
495 /* Avoid special (like zero) pages in core dumps */
496 page = ERR_PTR(-EFAULT);
500 if (is_zero_pfn(pte_pfn(pte))) {
501 page = pte_page(pte);
503 ret = follow_pfn_pte(vma, address, ptep, flags);
509 /* try_grab_page() does nothing unless FOLL_GET or FOLL_PIN is set. */
510 if (unlikely(!try_grab_page(page, flags))) {
511 page = ERR_PTR(-ENOMEM);
515 * We need to make the page accessible if and only if we are going
516 * to access its content (the FOLL_PIN case). Please see
517 * Documentation/core-api/pin_user_pages.rst for details.
519 if (flags & FOLL_PIN) {
520 ret = arch_make_page_accessible(page);
522 unpin_user_page(page);
527 if (flags & FOLL_TOUCH) {
528 if ((flags & FOLL_WRITE) &&
529 !pte_dirty(pte) && !PageDirty(page))
530 set_page_dirty(page);
532 * pte_mkyoung() would be more correct here, but atomic care
533 * is needed to avoid losing the dirty bit: it is easier to use
534 * mark_page_accessed().
536 mark_page_accessed(page);
539 pte_unmap_unlock(ptep, ptl);
542 pte_unmap_unlock(ptep, ptl);
545 return no_page_table(vma, flags);
548 static struct page *follow_pmd_mask(struct vm_area_struct *vma,
549 unsigned long address, pud_t *pudp,
551 struct follow_page_context *ctx)
556 struct mm_struct *mm = vma->vm_mm;
558 pmd = pmd_offset(pudp, address);
560 * The READ_ONCE() will stabilize the pmdval in a register or
561 * on the stack so that it will stop changing under the code.
563 pmdval = READ_ONCE(*pmd);
564 if (pmd_none(pmdval))
565 return no_page_table(vma, flags);
566 if (pmd_huge(pmdval) && is_vm_hugetlb_page(vma)) {
567 page = follow_huge_pmd(mm, address, pmd, flags);
570 return no_page_table(vma, flags);
572 if (is_hugepd(__hugepd(pmd_val(pmdval)))) {
573 page = follow_huge_pd(vma, address,
574 __hugepd(pmd_val(pmdval)), flags,
578 return no_page_table(vma, flags);
581 if (!pmd_present(pmdval)) {
583 * Should never reach here, if thp migration is not supported;
584 * Otherwise, it must be a thp migration entry.
586 VM_BUG_ON(!thp_migration_supported() ||
587 !is_pmd_migration_entry(pmdval));
589 if (likely(!(flags & FOLL_MIGRATION)))
590 return no_page_table(vma, flags);
592 pmd_migration_entry_wait(mm, pmd);
593 pmdval = READ_ONCE(*pmd);
595 * MADV_DONTNEED may convert the pmd to null because
596 * mmap_lock is held in read mode
598 if (pmd_none(pmdval))
599 return no_page_table(vma, flags);
602 if (pmd_devmap(pmdval)) {
603 ptl = pmd_lock(mm, pmd);
604 page = follow_devmap_pmd(vma, address, pmd, flags, &ctx->pgmap);
609 if (likely(!pmd_trans_huge(pmdval)))
610 return follow_page_pte(vma, address, pmd, flags, &ctx->pgmap);
612 if ((flags & FOLL_NUMA) && pmd_protnone(pmdval))
613 return no_page_table(vma, flags);
616 ptl = pmd_lock(mm, pmd);
617 if (unlikely(pmd_none(*pmd))) {
619 return no_page_table(vma, flags);
621 if (unlikely(!pmd_present(*pmd))) {
623 if (likely(!(flags & FOLL_MIGRATION)))
624 return no_page_table(vma, flags);
625 pmd_migration_entry_wait(mm, pmd);
628 if (unlikely(!pmd_trans_huge(*pmd))) {
630 return follow_page_pte(vma, address, pmd, flags, &ctx->pgmap);
632 if (flags & FOLL_SPLIT_PMD) {
634 page = pmd_page(*pmd);
635 if (is_huge_zero_page(page)) {
638 split_huge_pmd(vma, pmd, address);
639 if (pmd_trans_unstable(pmd))
643 split_huge_pmd(vma, pmd, address);
644 ret = pte_alloc(mm, pmd) ? -ENOMEM : 0;
647 return ret ? ERR_PTR(ret) :
648 follow_page_pte(vma, address, pmd, flags, &ctx->pgmap);
650 page = follow_trans_huge_pmd(vma, address, pmd, flags);
652 ctx->page_mask = HPAGE_PMD_NR - 1;
656 static struct page *follow_pud_mask(struct vm_area_struct *vma,
657 unsigned long address, p4d_t *p4dp,
659 struct follow_page_context *ctx)
664 struct mm_struct *mm = vma->vm_mm;
666 pud = pud_offset(p4dp, address);
668 return no_page_table(vma, flags);
669 if (pud_huge(*pud) && is_vm_hugetlb_page(vma)) {
670 page = follow_huge_pud(mm, address, pud, flags);
673 return no_page_table(vma, flags);
675 if (is_hugepd(__hugepd(pud_val(*pud)))) {
676 page = follow_huge_pd(vma, address,
677 __hugepd(pud_val(*pud)), flags,
681 return no_page_table(vma, flags);
683 if (pud_devmap(*pud)) {
684 ptl = pud_lock(mm, pud);
685 page = follow_devmap_pud(vma, address, pud, flags, &ctx->pgmap);
690 if (unlikely(pud_bad(*pud)))
691 return no_page_table(vma, flags);
693 return follow_pmd_mask(vma, address, pud, flags, ctx);
696 static struct page *follow_p4d_mask(struct vm_area_struct *vma,
697 unsigned long address, pgd_t *pgdp,
699 struct follow_page_context *ctx)
704 p4d = p4d_offset(pgdp, address);
706 return no_page_table(vma, flags);
707 BUILD_BUG_ON(p4d_huge(*p4d));
708 if (unlikely(p4d_bad(*p4d)))
709 return no_page_table(vma, flags);
711 if (is_hugepd(__hugepd(p4d_val(*p4d)))) {
712 page = follow_huge_pd(vma, address,
713 __hugepd(p4d_val(*p4d)), flags,
717 return no_page_table(vma, flags);
719 return follow_pud_mask(vma, address, p4d, flags, ctx);
723 * follow_page_mask - look up a page descriptor from a user-virtual address
724 * @vma: vm_area_struct mapping @address
725 * @address: virtual address to look up
726 * @flags: flags modifying lookup behaviour
727 * @ctx: contains dev_pagemap for %ZONE_DEVICE memory pinning and a
728 * pointer to output page_mask
730 * @flags can have FOLL_ flags set, defined in <linux/mm.h>
732 * When getting pages from ZONE_DEVICE memory, the @ctx->pgmap caches
733 * the device's dev_pagemap metadata to avoid repeating expensive lookups.
735 * On output, the @ctx->page_mask is set according to the size of the page.
737 * Return: the mapped (struct page *), %NULL if no mapping exists, or
738 * an error pointer if there is a mapping to something not represented
739 * by a page descriptor (see also vm_normal_page()).
741 static struct page *follow_page_mask(struct vm_area_struct *vma,
742 unsigned long address, unsigned int flags,
743 struct follow_page_context *ctx)
747 struct mm_struct *mm = vma->vm_mm;
751 /* make this handle hugepd */
752 page = follow_huge_addr(mm, address, flags & FOLL_WRITE);
754 WARN_ON_ONCE(flags & (FOLL_GET | FOLL_PIN));
758 pgd = pgd_offset(mm, address);
760 if (pgd_none(*pgd) || unlikely(pgd_bad(*pgd)))
761 return no_page_table(vma, flags);
763 if (pgd_huge(*pgd)) {
764 page = follow_huge_pgd(mm, address, pgd, flags);
767 return no_page_table(vma, flags);
769 if (is_hugepd(__hugepd(pgd_val(*pgd)))) {
770 page = follow_huge_pd(vma, address,
771 __hugepd(pgd_val(*pgd)), flags,
775 return no_page_table(vma, flags);
778 return follow_p4d_mask(vma, address, pgd, flags, ctx);
781 struct page *follow_page(struct vm_area_struct *vma, unsigned long address,
782 unsigned int foll_flags)
784 struct follow_page_context ctx = { NULL };
787 if (vma_is_secretmem(vma))
790 page = follow_page_mask(vma, address, foll_flags, &ctx);
792 put_dev_pagemap(ctx.pgmap);
796 static int get_gate_page(struct mm_struct *mm, unsigned long address,
797 unsigned int gup_flags, struct vm_area_struct **vma,
807 /* user gate pages are read-only */
808 if (gup_flags & FOLL_WRITE)
810 if (address > TASK_SIZE)
811 pgd = pgd_offset_k(address);
813 pgd = pgd_offset_gate(mm, address);
816 p4d = p4d_offset(pgd, address);
819 pud = pud_offset(p4d, address);
822 pmd = pmd_offset(pud, address);
823 if (!pmd_present(*pmd))
825 VM_BUG_ON(pmd_trans_huge(*pmd));
826 pte = pte_offset_map(pmd, address);
829 *vma = get_gate_vma(mm);
832 *page = vm_normal_page(*vma, address, *pte);
834 if ((gup_flags & FOLL_DUMP) || !is_zero_pfn(pte_pfn(*pte)))
836 *page = pte_page(*pte);
838 if (unlikely(!try_grab_page(*page, gup_flags))) {
850 * mmap_lock must be held on entry. If @locked != NULL and *@flags
851 * does not include FOLL_NOWAIT, the mmap_lock may be released. If it
852 * is, *@locked will be set to 0 and -EBUSY returned.
854 static int faultin_page(struct vm_area_struct *vma,
855 unsigned long address, unsigned int *flags, int *locked)
857 unsigned int fault_flags = 0;
860 if (*flags & FOLL_NOFAULT)
862 if (*flags & FOLL_WRITE)
863 fault_flags |= FAULT_FLAG_WRITE;
864 if (*flags & FOLL_REMOTE)
865 fault_flags |= FAULT_FLAG_REMOTE;
867 fault_flags |= FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;
868 if (*flags & FOLL_NOWAIT)
869 fault_flags |= FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_RETRY_NOWAIT;
870 if (*flags & FOLL_TRIED) {
872 * Note: FAULT_FLAG_ALLOW_RETRY and FAULT_FLAG_TRIED
875 fault_flags |= FAULT_FLAG_TRIED;
878 ret = handle_mm_fault(vma, address, fault_flags, NULL);
879 if (ret & VM_FAULT_ERROR) {
880 int err = vm_fault_to_errno(ret, *flags);
887 if (ret & VM_FAULT_RETRY) {
888 if (locked && !(fault_flags & FAULT_FLAG_RETRY_NOWAIT))
894 * The VM_FAULT_WRITE bit tells us that do_wp_page has broken COW when
895 * necessary, even if maybe_mkwrite decided not to set pte_write. We
896 * can thus safely do subsequent page lookups as if they were reads.
897 * But only do so when looping for pte_write is futile: in some cases
898 * userspace may also be wanting to write to the gotten user page,
899 * which a read fault here might prevent (a readonly page might get
900 * reCOWed by userspace write).
902 if ((ret & VM_FAULT_WRITE) && !(vma->vm_flags & VM_WRITE))
907 static int check_vma_flags(struct vm_area_struct *vma, unsigned long gup_flags)
909 vm_flags_t vm_flags = vma->vm_flags;
910 int write = (gup_flags & FOLL_WRITE);
911 int foreign = (gup_flags & FOLL_REMOTE);
913 if (vm_flags & (VM_IO | VM_PFNMAP))
916 if (gup_flags & FOLL_ANON && !vma_is_anonymous(vma))
919 if ((gup_flags & FOLL_LONGTERM) && vma_is_fsdax(vma))
922 if (vma_is_secretmem(vma))
926 if (!(vm_flags & VM_WRITE)) {
927 if (!(gup_flags & FOLL_FORCE))
930 * We used to let the write,force case do COW in a
931 * VM_MAYWRITE VM_SHARED !VM_WRITE vma, so ptrace could
932 * set a breakpoint in a read-only mapping of an
933 * executable, without corrupting the file (yet only
934 * when that file had been opened for writing!).
935 * Anon pages in shared mappings are surprising: now
938 if (!is_cow_mapping(vm_flags))
941 } else if (!(vm_flags & VM_READ)) {
942 if (!(gup_flags & FOLL_FORCE))
945 * Is there actually any vma we can reach here which does not
946 * have VM_MAYREAD set?
948 if (!(vm_flags & VM_MAYREAD))
952 * gups are always data accesses, not instruction
953 * fetches, so execute=false here
955 if (!arch_vma_access_permitted(vma, write, false, foreign))
961 * __get_user_pages() - pin user pages in memory
962 * @mm: mm_struct of target mm
963 * @start: starting user address
964 * @nr_pages: number of pages from start to pin
965 * @gup_flags: flags modifying pin behaviour
966 * @pages: array that receives pointers to the pages pinned.
967 * Should be at least nr_pages long. Or NULL, if caller
968 * only intends to ensure the pages are faulted in.
969 * @vmas: array of pointers to vmas corresponding to each page.
970 * Or NULL if the caller does not require them.
971 * @locked: whether we're still with the mmap_lock held
973 * Returns either number of pages pinned (which may be less than the
974 * number requested), or an error. Details about the return value:
976 * -- If nr_pages is 0, returns 0.
977 * -- If nr_pages is >0, but no pages were pinned, returns -errno.
978 * -- If nr_pages is >0, and some pages were pinned, returns the number of
979 * pages pinned. Again, this may be less than nr_pages.
980 * -- 0 return value is possible when the fault would need to be retried.
982 * The caller is responsible for releasing returned @pages, via put_page().
984 * @vmas are valid only as long as mmap_lock is held.
986 * Must be called with mmap_lock held. It may be released. See below.
988 * __get_user_pages walks a process's page tables and takes a reference to
989 * each struct page that each user address corresponds to at a given
990 * instant. That is, it takes the page that would be accessed if a user
991 * thread accesses the given user virtual address at that instant.
993 * This does not guarantee that the page exists in the user mappings when
994 * __get_user_pages returns, and there may even be a completely different
995 * page there in some cases (eg. if mmapped pagecache has been invalidated
996 * and subsequently re faulted). However it does guarantee that the page
997 * won't be freed completely. And mostly callers simply care that the page
998 * contains data that was valid *at some point in time*. Typically, an IO
999 * or similar operation cannot guarantee anything stronger anyway because
1000 * locks can't be held over the syscall boundary.
1002 * If @gup_flags & FOLL_WRITE == 0, the page must not be written to. If
1003 * the page is written to, set_page_dirty (or set_page_dirty_lock, as
1004 * appropriate) must be called after the page is finished with, and
1005 * before put_page is called.
1007 * If @locked != NULL, *@locked will be set to 0 when mmap_lock is
1008 * released by an up_read(). That can happen if @gup_flags does not
1011 * A caller using such a combination of @locked and @gup_flags
1012 * must therefore hold the mmap_lock for reading only, and recognize
1013 * when it's been released. Otherwise, it must be held for either
1014 * reading or writing and will not be released.
1016 * In most cases, get_user_pages or get_user_pages_fast should be used
1017 * instead of __get_user_pages. __get_user_pages should be used only if
1018 * you need some special @gup_flags.
1020 static long __get_user_pages(struct mm_struct *mm,
1021 unsigned long start, unsigned long nr_pages,
1022 unsigned int gup_flags, struct page **pages,
1023 struct vm_area_struct **vmas, int *locked)
1025 long ret = 0, i = 0;
1026 struct vm_area_struct *vma = NULL;
1027 struct follow_page_context ctx = { NULL };
1032 start = untagged_addr(start);
1034 VM_BUG_ON(!!pages != !!(gup_flags & (FOLL_GET | FOLL_PIN)));
1037 * If FOLL_FORCE is set then do not force a full fault as the hinting
1038 * fault information is unrelated to the reference behaviour of a task
1039 * using the address space
1041 if (!(gup_flags & FOLL_FORCE))
1042 gup_flags |= FOLL_NUMA;
1046 unsigned int foll_flags = gup_flags;
1047 unsigned int page_increm;
1049 /* first iteration or cross vma bound */
1050 if (!vma || start >= vma->vm_end) {
1051 vma = find_extend_vma(mm, start);
1052 if (!vma && in_gate_area(mm, start)) {
1053 ret = get_gate_page(mm, start & PAGE_MASK,
1055 pages ? &pages[i] : NULL);
1066 ret = check_vma_flags(vma, gup_flags);
1070 if (is_vm_hugetlb_page(vma)) {
1071 i = follow_hugetlb_page(mm, vma, pages, vmas,
1072 &start, &nr_pages, i,
1074 if (locked && *locked == 0) {
1076 * We've got a VM_FAULT_RETRY
1077 * and we've lost mmap_lock.
1078 * We must stop here.
1080 BUG_ON(gup_flags & FOLL_NOWAIT);
1088 * If we have a pending SIGKILL, don't keep faulting pages and
1089 * potentially allocating memory.
1091 if (fatal_signal_pending(current)) {
1097 page = follow_page_mask(vma, start, foll_flags, &ctx);
1099 ret = faultin_page(vma, start, &foll_flags, locked);
1112 } else if (PTR_ERR(page) == -EEXIST) {
1114 * Proper page table entry exists, but no corresponding
1115 * struct page. If the caller expects **pages to be
1116 * filled in, bail out now, because that can't be done
1120 ret = PTR_ERR(page);
1125 } else if (IS_ERR(page)) {
1126 ret = PTR_ERR(page);
1131 flush_anon_page(vma, page, start);
1132 flush_dcache_page(page);
1140 page_increm = 1 + (~(start >> PAGE_SHIFT) & ctx.page_mask);
1141 if (page_increm > nr_pages)
1142 page_increm = nr_pages;
1144 start += page_increm * PAGE_SIZE;
1145 nr_pages -= page_increm;
1149 put_dev_pagemap(ctx.pgmap);
1153 static bool vma_permits_fault(struct vm_area_struct *vma,
1154 unsigned int fault_flags)
1156 bool write = !!(fault_flags & FAULT_FLAG_WRITE);
1157 bool foreign = !!(fault_flags & FAULT_FLAG_REMOTE);
1158 vm_flags_t vm_flags = write ? VM_WRITE : VM_READ;
1160 if (!(vm_flags & vma->vm_flags))
1164 * The architecture might have a hardware protection
1165 * mechanism other than read/write that can deny access.
1167 * gup always represents data access, not instruction
1168 * fetches, so execute=false here:
1170 if (!arch_vma_access_permitted(vma, write, false, foreign))
1177 * fixup_user_fault() - manually resolve a user page fault
1178 * @mm: mm_struct of target mm
1179 * @address: user address
1180 * @fault_flags:flags to pass down to handle_mm_fault()
1181 * @unlocked: did we unlock the mmap_lock while retrying, maybe NULL if caller
1182 * does not allow retry. If NULL, the caller must guarantee
1183 * that fault_flags does not contain FAULT_FLAG_ALLOW_RETRY.
1185 * This is meant to be called in the specific scenario where for locking reasons
1186 * we try to access user memory in atomic context (within a pagefault_disable()
1187 * section), this returns -EFAULT, and we want to resolve the user fault before
1190 * Typically this is meant to be used by the futex code.
1192 * The main difference with get_user_pages() is that this function will
1193 * unconditionally call handle_mm_fault() which will in turn perform all the
1194 * necessary SW fixup of the dirty and young bits in the PTE, while
1195 * get_user_pages() only guarantees to update these in the struct page.
1197 * This is important for some architectures where those bits also gate the
1198 * access permission to the page because they are maintained in software. On
1199 * such architectures, gup() will not be enough to make a subsequent access
1202 * This function will not return with an unlocked mmap_lock. So it has not the
1203 * same semantics wrt the @mm->mmap_lock as does filemap_fault().
1205 int fixup_user_fault(struct mm_struct *mm,
1206 unsigned long address, unsigned int fault_flags,
1209 struct vm_area_struct *vma;
1212 address = untagged_addr(address);
1215 fault_flags |= FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;
1218 vma = find_extend_vma(mm, address);
1219 if (!vma || address < vma->vm_start)
1222 if (!vma_permits_fault(vma, fault_flags))
1225 if ((fault_flags & FAULT_FLAG_KILLABLE) &&
1226 fatal_signal_pending(current))
1229 ret = handle_mm_fault(vma, address, fault_flags, NULL);
1230 if (ret & VM_FAULT_ERROR) {
1231 int err = vm_fault_to_errno(ret, 0);
1238 if (ret & VM_FAULT_RETRY) {
1241 fault_flags |= FAULT_FLAG_TRIED;
1247 EXPORT_SYMBOL_GPL(fixup_user_fault);
1250 * Please note that this function, unlike __get_user_pages will not
1251 * return 0 for nr_pages > 0 without FOLL_NOWAIT
1253 static __always_inline long __get_user_pages_locked(struct mm_struct *mm,
1254 unsigned long start,
1255 unsigned long nr_pages,
1256 struct page **pages,
1257 struct vm_area_struct **vmas,
1261 long ret, pages_done;
1265 /* if VM_FAULT_RETRY can be returned, vmas become invalid */
1267 /* check caller initialized locked */
1268 BUG_ON(*locked != 1);
1271 if (flags & FOLL_PIN)
1272 mm_set_has_pinned_flag(&mm->flags);
1275 * FOLL_PIN and FOLL_GET are mutually exclusive. Traditional behavior
1276 * is to set FOLL_GET if the caller wants pages[] filled in (but has
1277 * carelessly failed to specify FOLL_GET), so keep doing that, but only
1278 * for FOLL_GET, not for the newer FOLL_PIN.
1280 * FOLL_PIN always expects pages to be non-null, but no need to assert
1281 * that here, as any failures will be obvious enough.
1283 if (pages && !(flags & FOLL_PIN))
1287 lock_dropped = false;
1289 ret = __get_user_pages(mm, start, nr_pages, flags, pages,
1292 /* VM_FAULT_RETRY couldn't trigger, bypass */
1295 /* VM_FAULT_RETRY cannot return errors */
1298 BUG_ON(ret >= nr_pages);
1309 * VM_FAULT_RETRY didn't trigger or it was a
1317 * VM_FAULT_RETRY triggered, so seek to the faulting offset.
1318 * For the prefault case (!pages) we only update counts.
1322 start += ret << PAGE_SHIFT;
1323 lock_dropped = true;
1327 * Repeat on the address that fired VM_FAULT_RETRY
1328 * with both FAULT_FLAG_ALLOW_RETRY and
1329 * FAULT_FLAG_TRIED. Note that GUP can be interrupted
1330 * by fatal signals, so we need to check it before we
1331 * start trying again otherwise it can loop forever.
1334 if (fatal_signal_pending(current)) {
1336 pages_done = -EINTR;
1340 ret = mmap_read_lock_killable(mm);
1349 ret = __get_user_pages(mm, start, 1, flags | FOLL_TRIED,
1350 pages, NULL, locked);
1352 /* Continue to retry until we succeeded */
1370 if (lock_dropped && *locked) {
1372 * We must let the caller know we temporarily dropped the lock
1373 * and so the critical section protected by it was lost.
1375 mmap_read_unlock(mm);
1382 * populate_vma_page_range() - populate a range of pages in the vma.
1384 * @start: start address
1386 * @locked: whether the mmap_lock is still held
1388 * This takes care of mlocking the pages too if VM_LOCKED is set.
1390 * Return either number of pages pinned in the vma, or a negative error
1393 * vma->vm_mm->mmap_lock must be held.
1395 * If @locked is NULL, it may be held for read or write and will
1398 * If @locked is non-NULL, it must held for read only and may be
1399 * released. If it's released, *@locked will be set to 0.
1401 long populate_vma_page_range(struct vm_area_struct *vma,
1402 unsigned long start, unsigned long end, int *locked)
1404 struct mm_struct *mm = vma->vm_mm;
1405 unsigned long nr_pages = (end - start) / PAGE_SIZE;
1409 VM_BUG_ON(!PAGE_ALIGNED(start));
1410 VM_BUG_ON(!PAGE_ALIGNED(end));
1411 VM_BUG_ON_VMA(start < vma->vm_start, vma);
1412 VM_BUG_ON_VMA(end > vma->vm_end, vma);
1413 mmap_assert_locked(mm);
1416 * Rightly or wrongly, the VM_LOCKONFAULT case has never used
1417 * faultin_page() to break COW, so it has no work to do here.
1419 if (vma->vm_flags & VM_LOCKONFAULT)
1422 gup_flags = FOLL_TOUCH;
1424 * We want to touch writable mappings with a write fault in order
1425 * to break COW, except for shared mappings because these don't COW
1426 * and we would not want to dirty them for nothing.
1428 if ((vma->vm_flags & (VM_WRITE | VM_SHARED)) == VM_WRITE)
1429 gup_flags |= FOLL_WRITE;
1432 * We want mlock to succeed for regions that have any permissions
1433 * other than PROT_NONE.
1435 if (vma_is_accessible(vma))
1436 gup_flags |= FOLL_FORCE;
1439 * We made sure addr is within a VMA, so the following will
1440 * not result in a stack expansion that recurses back here.
1442 ret = __get_user_pages(mm, start, nr_pages, gup_flags,
1443 NULL, NULL, locked);
1449 * faultin_vma_page_range() - populate (prefault) page tables inside the
1450 * given VMA range readable/writable
1452 * This takes care of mlocking the pages, too, if VM_LOCKED is set.
1455 * @start: start address
1457 * @write: whether to prefault readable or writable
1458 * @locked: whether the mmap_lock is still held
1460 * Returns either number of processed pages in the vma, or a negative error
1461 * code on error (see __get_user_pages()).
1463 * vma->vm_mm->mmap_lock must be held. The range must be page-aligned and
1464 * covered by the VMA.
1466 * If @locked is NULL, it may be held for read or write and will be unperturbed.
1468 * If @locked is non-NULL, it must held for read only and may be released. If
1469 * it's released, *@locked will be set to 0.
1471 long faultin_vma_page_range(struct vm_area_struct *vma, unsigned long start,
1472 unsigned long end, bool write, int *locked)
1474 struct mm_struct *mm = vma->vm_mm;
1475 unsigned long nr_pages = (end - start) / PAGE_SIZE;
1479 VM_BUG_ON(!PAGE_ALIGNED(start));
1480 VM_BUG_ON(!PAGE_ALIGNED(end));
1481 VM_BUG_ON_VMA(start < vma->vm_start, vma);
1482 VM_BUG_ON_VMA(end > vma->vm_end, vma);
1483 mmap_assert_locked(mm);
1486 * FOLL_TOUCH: Mark page accessed and thereby young; will also mark
1487 * the page dirty with FOLL_WRITE -- which doesn't make a
1488 * difference with !FOLL_FORCE, because the page is writable
1489 * in the page table.
1490 * FOLL_HWPOISON: Return -EHWPOISON instead of -EFAULT when we hit
1492 * !FOLL_FORCE: Require proper access permissions.
1494 gup_flags = FOLL_TOUCH | FOLL_HWPOISON;
1496 gup_flags |= FOLL_WRITE;
1499 * We want to report -EINVAL instead of -EFAULT for any permission
1500 * problems or incompatible mappings.
1502 if (check_vma_flags(vma, gup_flags))
1505 ret = __get_user_pages(mm, start, nr_pages, gup_flags,
1506 NULL, NULL, locked);
1512 * __mm_populate - populate and/or mlock pages within a range of address space.
1514 * This is used to implement mlock() and the MAP_POPULATE / MAP_LOCKED mmap
1515 * flags. VMAs must be already marked with the desired vm_flags, and
1516 * mmap_lock must not be held.
1518 int __mm_populate(unsigned long start, unsigned long len, int ignore_errors)
1520 struct mm_struct *mm = current->mm;
1521 unsigned long end, nstart, nend;
1522 struct vm_area_struct *vma = NULL;
1528 for (nstart = start; nstart < end; nstart = nend) {
1530 * We want to fault in pages for [nstart; end) address range.
1531 * Find first corresponding VMA.
1536 vma = find_vma(mm, nstart);
1537 } else if (nstart >= vma->vm_end)
1539 if (!vma || vma->vm_start >= end)
1542 * Set [nstart; nend) to intersection of desired address
1543 * range with the first VMA. Also, skip undesirable VMA types.
1545 nend = min(end, vma->vm_end);
1546 if (vma->vm_flags & (VM_IO | VM_PFNMAP))
1548 if (nstart < vma->vm_start)
1549 nstart = vma->vm_start;
1551 * Now fault in a range of pages. populate_vma_page_range()
1552 * double checks the vma flags, so that it won't mlock pages
1553 * if the vma was already munlocked.
1555 ret = populate_vma_page_range(vma, nstart, nend, &locked);
1557 if (ignore_errors) {
1559 continue; /* continue at next VMA */
1563 nend = nstart + ret * PAGE_SIZE;
1567 mmap_read_unlock(mm);
1568 return ret; /* 0 or negative error code */
1570 #else /* CONFIG_MMU */
1571 static long __get_user_pages_locked(struct mm_struct *mm, unsigned long start,
1572 unsigned long nr_pages, struct page **pages,
1573 struct vm_area_struct **vmas, int *locked,
1574 unsigned int foll_flags)
1576 struct vm_area_struct *vma;
1577 unsigned long vm_flags;
1580 /* calculate required read or write permissions.
1581 * If FOLL_FORCE is set, we only require the "MAY" flags.
1583 vm_flags = (foll_flags & FOLL_WRITE) ?
1584 (VM_WRITE | VM_MAYWRITE) : (VM_READ | VM_MAYREAD);
1585 vm_flags &= (foll_flags & FOLL_FORCE) ?
1586 (VM_MAYREAD | VM_MAYWRITE) : (VM_READ | VM_WRITE);
1588 for (i = 0; i < nr_pages; i++) {
1589 vma = find_vma(mm, start);
1591 goto finish_or_fault;
1593 /* protect what we can, including chardevs */
1594 if ((vma->vm_flags & (VM_IO | VM_PFNMAP)) ||
1595 !(vm_flags & vma->vm_flags))
1596 goto finish_or_fault;
1599 pages[i] = virt_to_page(start);
1605 start = (start + PAGE_SIZE) & PAGE_MASK;
1611 return i ? : -EFAULT;
1613 #endif /* !CONFIG_MMU */
1616 * fault_in_writeable - fault in userspace address range for writing
1617 * @uaddr: start of address range
1618 * @size: size of address range
1620 * Returns the number of bytes not faulted in (like copy_to_user() and
1621 * copy_from_user()).
1623 size_t fault_in_writeable(char __user *uaddr, size_t size)
1625 char __user *start = uaddr, *end;
1627 if (unlikely(size == 0))
1629 if (!user_write_access_begin(uaddr, size))
1631 if (!PAGE_ALIGNED(uaddr)) {
1632 unsafe_put_user(0, uaddr, out);
1633 uaddr = (char __user *)PAGE_ALIGN((unsigned long)uaddr);
1635 end = (char __user *)PAGE_ALIGN((unsigned long)start + size);
1636 if (unlikely(end < start))
1638 while (uaddr != end) {
1639 unsafe_put_user(0, uaddr, out);
1644 user_write_access_end();
1645 if (size > uaddr - start)
1646 return size - (uaddr - start);
1649 EXPORT_SYMBOL(fault_in_writeable);
1652 * fault_in_safe_writeable - fault in an address range for writing
1653 * @uaddr: start of address range
1654 * @size: length of address range
1656 * Faults in an address range for writing. This is primarily useful when we
1657 * already know that some or all of the pages in the address range aren't in
1660 * Unlike fault_in_writeable(), this function is non-destructive.
1662 * Note that we don't pin or otherwise hold the pages referenced that we fault
1663 * in. There's no guarantee that they'll stay in memory for any duration of
1666 * Returns the number of bytes not faulted in, like copy_to_user() and
1669 size_t fault_in_safe_writeable(const char __user *uaddr, size_t size)
1671 unsigned long start = (unsigned long)uaddr, end;
1672 struct mm_struct *mm = current->mm;
1673 bool unlocked = false;
1675 if (unlikely(size == 0))
1677 end = PAGE_ALIGN(start + size);
1683 if (fixup_user_fault(mm, start, FAULT_FLAG_WRITE, &unlocked))
1685 start = (start + PAGE_SIZE) & PAGE_MASK;
1686 } while (start != end);
1687 mmap_read_unlock(mm);
1689 if (size > (unsigned long)uaddr - start)
1690 return size - ((unsigned long)uaddr - start);
1693 EXPORT_SYMBOL(fault_in_safe_writeable);
1696 * fault_in_readable - fault in userspace address range for reading
1697 * @uaddr: start of user address range
1698 * @size: size of user address range
1700 * Returns the number of bytes not faulted in (like copy_to_user() and
1701 * copy_from_user()).
1703 size_t fault_in_readable(const char __user *uaddr, size_t size)
1705 const char __user *start = uaddr, *end;
1708 if (unlikely(size == 0))
1710 if (!user_read_access_begin(uaddr, size))
1712 if (!PAGE_ALIGNED(uaddr)) {
1713 unsafe_get_user(c, uaddr, out);
1714 uaddr = (const char __user *)PAGE_ALIGN((unsigned long)uaddr);
1716 end = (const char __user *)PAGE_ALIGN((unsigned long)start + size);
1717 if (unlikely(end < start))
1719 while (uaddr != end) {
1720 unsafe_get_user(c, uaddr, out);
1725 user_read_access_end();
1727 if (size > uaddr - start)
1728 return size - (uaddr - start);
1731 EXPORT_SYMBOL(fault_in_readable);
1734 * get_dump_page() - pin user page in memory while writing it to core dump
1735 * @addr: user address
1737 * Returns struct page pointer of user page pinned for dump,
1738 * to be freed afterwards by put_page().
1740 * Returns NULL on any kind of failure - a hole must then be inserted into
1741 * the corefile, to preserve alignment with its headers; and also returns
1742 * NULL wherever the ZERO_PAGE, or an anonymous pte_none, has been found -
1743 * allowing a hole to be left in the corefile to save disk space.
1745 * Called without mmap_lock (takes and releases the mmap_lock by itself).
1747 #ifdef CONFIG_ELF_CORE
1748 struct page *get_dump_page(unsigned long addr)
1750 struct mm_struct *mm = current->mm;
1755 if (mmap_read_lock_killable(mm))
1757 ret = __get_user_pages_locked(mm, addr, 1, &page, NULL, &locked,
1758 FOLL_FORCE | FOLL_DUMP | FOLL_GET);
1760 mmap_read_unlock(mm);
1761 return (ret == 1) ? page : NULL;
1763 #endif /* CONFIG_ELF_CORE */
1765 #ifdef CONFIG_MIGRATION
1767 * Check whether all pages are pinnable, if so return number of pages. If some
1768 * pages are not pinnable, migrate them, and unpin all pages. Return zero if
1769 * pages were migrated, or if some pages were not successfully isolated.
1770 * Return negative error if migration fails.
1772 static long check_and_migrate_movable_pages(unsigned long nr_pages,
1773 struct page **pages,
1774 unsigned int gup_flags)
1776 unsigned long isolation_error_count = 0, i;
1777 struct folio *prev_folio = NULL;
1778 LIST_HEAD(movable_page_list);
1779 bool drain_allow = true;
1782 for (i = 0; i < nr_pages; i++) {
1783 struct folio *folio = page_folio(pages[i]);
1785 if (folio == prev_folio)
1789 if (folio_is_pinnable(folio))
1793 * Try to move out any movable page before pinning the range.
1795 if (folio_test_hugetlb(folio)) {
1796 if (!isolate_huge_page(&folio->page,
1797 &movable_page_list))
1798 isolation_error_count++;
1802 if (!folio_test_lru(folio) && drain_allow) {
1803 lru_add_drain_all();
1804 drain_allow = false;
1807 if (folio_isolate_lru(folio)) {
1808 isolation_error_count++;
1811 list_add_tail(&folio->lru, &movable_page_list);
1812 node_stat_mod_folio(folio,
1813 NR_ISOLATED_ANON + folio_is_file_lru(folio),
1814 folio_nr_pages(folio));
1817 if (!list_empty(&movable_page_list) || isolation_error_count)
1821 * If list is empty, and no isolation errors, means that all pages are
1822 * in the correct zone.
1827 if (gup_flags & FOLL_PIN) {
1828 unpin_user_pages(pages, nr_pages);
1830 for (i = 0; i < nr_pages; i++)
1834 if (!list_empty(&movable_page_list)) {
1835 struct migration_target_control mtc = {
1836 .nid = NUMA_NO_NODE,
1837 .gfp_mask = GFP_USER | __GFP_NOWARN,
1840 ret = migrate_pages(&movable_page_list, alloc_migration_target,
1841 NULL, (unsigned long)&mtc, MIGRATE_SYNC,
1842 MR_LONGTERM_PIN, NULL);
1843 if (ret > 0) /* number of pages not migrated */
1847 if (ret && !list_empty(&movable_page_list))
1848 putback_movable_pages(&movable_page_list);
1852 static long check_and_migrate_movable_pages(unsigned long nr_pages,
1853 struct page **pages,
1854 unsigned int gup_flags)
1858 #endif /* CONFIG_MIGRATION */
1861 * __gup_longterm_locked() is a wrapper for __get_user_pages_locked which
1862 * allows us to process the FOLL_LONGTERM flag.
1864 static long __gup_longterm_locked(struct mm_struct *mm,
1865 unsigned long start,
1866 unsigned long nr_pages,
1867 struct page **pages,
1868 struct vm_area_struct **vmas,
1869 unsigned int gup_flags)
1874 if (!(gup_flags & FOLL_LONGTERM))
1875 return __get_user_pages_locked(mm, start, nr_pages, pages, vmas,
1877 flags = memalloc_pin_save();
1879 rc = __get_user_pages_locked(mm, start, nr_pages, pages, vmas,
1883 rc = check_and_migrate_movable_pages(rc, pages, gup_flags);
1885 memalloc_pin_restore(flags);
1890 static bool is_valid_gup_flags(unsigned int gup_flags)
1893 * FOLL_PIN must only be set internally by the pin_user_pages*() APIs,
1894 * never directly by the caller, so enforce that with an assertion:
1896 if (WARN_ON_ONCE(gup_flags & FOLL_PIN))
1899 * FOLL_PIN is a prerequisite to FOLL_LONGTERM. Another way of saying
1900 * that is, FOLL_LONGTERM is a specific case, more restrictive case of
1903 if (WARN_ON_ONCE(gup_flags & FOLL_LONGTERM))
1910 static long __get_user_pages_remote(struct mm_struct *mm,
1911 unsigned long start, unsigned long nr_pages,
1912 unsigned int gup_flags, struct page **pages,
1913 struct vm_area_struct **vmas, int *locked)
1916 * Parts of FOLL_LONGTERM behavior are incompatible with
1917 * FAULT_FLAG_ALLOW_RETRY because of the FS DAX check requirement on
1918 * vmas. However, this only comes up if locked is set, and there are
1919 * callers that do request FOLL_LONGTERM, but do not set locked. So,
1920 * allow what we can.
1922 if (gup_flags & FOLL_LONGTERM) {
1923 if (WARN_ON_ONCE(locked))
1926 * This will check the vmas (even if our vmas arg is NULL)
1927 * and return -ENOTSUPP if DAX isn't allowed in this case:
1929 return __gup_longterm_locked(mm, start, nr_pages, pages,
1930 vmas, gup_flags | FOLL_TOUCH |
1934 return __get_user_pages_locked(mm, start, nr_pages, pages, vmas,
1936 gup_flags | FOLL_TOUCH | FOLL_REMOTE);
1940 * get_user_pages_remote() - pin user pages in memory
1941 * @mm: mm_struct of target mm
1942 * @start: starting user address
1943 * @nr_pages: number of pages from start to pin
1944 * @gup_flags: flags modifying lookup behaviour
1945 * @pages: array that receives pointers to the pages pinned.
1946 * Should be at least nr_pages long. Or NULL, if caller
1947 * only intends to ensure the pages are faulted in.
1948 * @vmas: array of pointers to vmas corresponding to each page.
1949 * Or NULL if the caller does not require them.
1950 * @locked: pointer to lock flag indicating whether lock is held and
1951 * subsequently whether VM_FAULT_RETRY functionality can be
1952 * utilised. Lock must initially be held.
1954 * Returns either number of pages pinned (which may be less than the
1955 * number requested), or an error. Details about the return value:
1957 * -- If nr_pages is 0, returns 0.
1958 * -- If nr_pages is >0, but no pages were pinned, returns -errno.
1959 * -- If nr_pages is >0, and some pages were pinned, returns the number of
1960 * pages pinned. Again, this may be less than nr_pages.
1962 * The caller is responsible for releasing returned @pages, via put_page().
1964 * @vmas are valid only as long as mmap_lock is held.
1966 * Must be called with mmap_lock held for read or write.
1968 * get_user_pages_remote walks a process's page tables and takes a reference
1969 * to each struct page that each user address corresponds to at a given
1970 * instant. That is, it takes the page that would be accessed if a user
1971 * thread accesses the given user virtual address at that instant.
1973 * This does not guarantee that the page exists in the user mappings when
1974 * get_user_pages_remote returns, and there may even be a completely different
1975 * page there in some cases (eg. if mmapped pagecache has been invalidated
1976 * and subsequently re faulted). However it does guarantee that the page
1977 * won't be freed completely. And mostly callers simply care that the page
1978 * contains data that was valid *at some point in time*. Typically, an IO
1979 * or similar operation cannot guarantee anything stronger anyway because
1980 * locks can't be held over the syscall boundary.
1982 * If gup_flags & FOLL_WRITE == 0, the page must not be written to. If the page
1983 * is written to, set_page_dirty (or set_page_dirty_lock, as appropriate) must
1984 * be called after the page is finished with, and before put_page is called.
1986 * get_user_pages_remote is typically used for fewer-copy IO operations,
1987 * to get a handle on the memory by some means other than accesses
1988 * via the user virtual addresses. The pages may be submitted for
1989 * DMA to devices or accessed via their kernel linear mapping (via the
1990 * kmap APIs). Care should be taken to use the correct cache flushing APIs.
1992 * See also get_user_pages_fast, for performance critical applications.
1994 * get_user_pages_remote should be phased out in favor of
1995 * get_user_pages_locked|unlocked or get_user_pages_fast. Nothing
1996 * should use get_user_pages_remote because it cannot pass
1997 * FAULT_FLAG_ALLOW_RETRY to handle_mm_fault.
1999 long get_user_pages_remote(struct mm_struct *mm,
2000 unsigned long start, unsigned long nr_pages,
2001 unsigned int gup_flags, struct page **pages,
2002 struct vm_area_struct **vmas, int *locked)
2004 if (!is_valid_gup_flags(gup_flags))
2007 return __get_user_pages_remote(mm, start, nr_pages, gup_flags,
2008 pages, vmas, locked);
2010 EXPORT_SYMBOL(get_user_pages_remote);
2012 #else /* CONFIG_MMU */
2013 long get_user_pages_remote(struct mm_struct *mm,
2014 unsigned long start, unsigned long nr_pages,
2015 unsigned int gup_flags, struct page **pages,
2016 struct vm_area_struct **vmas, int *locked)
2021 static long __get_user_pages_remote(struct mm_struct *mm,
2022 unsigned long start, unsigned long nr_pages,
2023 unsigned int gup_flags, struct page **pages,
2024 struct vm_area_struct **vmas, int *locked)
2028 #endif /* !CONFIG_MMU */
2031 * get_user_pages() - pin user pages in memory
2032 * @start: starting user address
2033 * @nr_pages: number of pages from start to pin
2034 * @gup_flags: flags modifying lookup behaviour
2035 * @pages: array that receives pointers to the pages pinned.
2036 * Should be at least nr_pages long. Or NULL, if caller
2037 * only intends to ensure the pages are faulted in.
2038 * @vmas: array of pointers to vmas corresponding to each page.
2039 * Or NULL if the caller does not require them.
2041 * This is the same as get_user_pages_remote(), just with a less-flexible
2042 * calling convention where we assume that the mm being operated on belongs to
2043 * the current task, and doesn't allow passing of a locked parameter. We also
2044 * obviously don't pass FOLL_REMOTE in here.
2046 long get_user_pages(unsigned long start, unsigned long nr_pages,
2047 unsigned int gup_flags, struct page **pages,
2048 struct vm_area_struct **vmas)
2050 if (!is_valid_gup_flags(gup_flags))
2053 return __gup_longterm_locked(current->mm, start, nr_pages,
2054 pages, vmas, gup_flags | FOLL_TOUCH);
2056 EXPORT_SYMBOL(get_user_pages);
2059 * get_user_pages_unlocked() is suitable to replace the form:
2061 * mmap_read_lock(mm);
2062 * get_user_pages(mm, ..., pages, NULL);
2063 * mmap_read_unlock(mm);
2067 * get_user_pages_unlocked(mm, ..., pages);
2069 * It is functionally equivalent to get_user_pages_fast so
2070 * get_user_pages_fast should be used instead if specific gup_flags
2071 * (e.g. FOLL_FORCE) are not required.
2073 long get_user_pages_unlocked(unsigned long start, unsigned long nr_pages,
2074 struct page **pages, unsigned int gup_flags)
2076 struct mm_struct *mm = current->mm;
2081 * FIXME: Current FOLL_LONGTERM behavior is incompatible with
2082 * FAULT_FLAG_ALLOW_RETRY because of the FS DAX check requirement on
2083 * vmas. As there are no users of this flag in this call we simply
2084 * disallow this option for now.
2086 if (WARN_ON_ONCE(gup_flags & FOLL_LONGTERM))
2090 ret = __get_user_pages_locked(mm, start, nr_pages, pages, NULL,
2091 &locked, gup_flags | FOLL_TOUCH);
2093 mmap_read_unlock(mm);
2096 EXPORT_SYMBOL(get_user_pages_unlocked);
2101 * get_user_pages_fast attempts to pin user pages by walking the page
2102 * tables directly and avoids taking locks. Thus the walker needs to be
2103 * protected from page table pages being freed from under it, and should
2104 * block any THP splits.
2106 * One way to achieve this is to have the walker disable interrupts, and
2107 * rely on IPIs from the TLB flushing code blocking before the page table
2108 * pages are freed. This is unsuitable for architectures that do not need
2109 * to broadcast an IPI when invalidating TLBs.
2111 * Another way to achieve this is to batch up page table containing pages
2112 * belonging to more than one mm_user, then rcu_sched a callback to free those
2113 * pages. Disabling interrupts will allow the fast_gup walker to both block
2114 * the rcu_sched callback, and an IPI that we broadcast for splitting THPs
2115 * (which is a relatively rare event). The code below adopts this strategy.
2117 * Before activating this code, please be aware that the following assumptions
2118 * are currently made:
2120 * *) Either MMU_GATHER_RCU_TABLE_FREE is enabled, and tlb_remove_table() is used to
2121 * free pages containing page tables or TLB flushing requires IPI broadcast.
2123 * *) ptes can be read atomically by the architecture.
2125 * *) access_ok is sufficient to validate userspace address ranges.
2127 * The last two assumptions can be relaxed by the addition of helper functions.
2129 * This code is based heavily on the PowerPC implementation by Nick Piggin.
2131 #ifdef CONFIG_HAVE_FAST_GUP
2133 static void __maybe_unused undo_dev_pagemap(int *nr, int nr_start,
2135 struct page **pages)
2137 while ((*nr) - nr_start) {
2138 struct page *page = pages[--(*nr)];
2140 ClearPageReferenced(page);
2141 if (flags & FOLL_PIN)
2142 unpin_user_page(page);
2148 #ifdef CONFIG_ARCH_HAS_PTE_SPECIAL
2149 static int gup_pte_range(pmd_t pmd, unsigned long addr, unsigned long end,
2150 unsigned int flags, struct page **pages, int *nr)
2152 struct dev_pagemap *pgmap = NULL;
2153 int nr_start = *nr, ret = 0;
2156 ptem = ptep = pte_offset_map(&pmd, addr);
2158 pte_t pte = ptep_get_lockless(ptep);
2160 struct folio *folio;
2163 * Similar to the PMD case below, NUMA hinting must take slow
2164 * path using the pte_protnone check.
2166 if (pte_protnone(pte))
2169 if (!pte_access_permitted(pte, flags & FOLL_WRITE))
2172 if (pte_devmap(pte)) {
2173 if (unlikely(flags & FOLL_LONGTERM))
2176 pgmap = get_dev_pagemap(pte_pfn(pte), pgmap);
2177 if (unlikely(!pgmap)) {
2178 undo_dev_pagemap(nr, nr_start, flags, pages);
2181 } else if (pte_special(pte))
2184 VM_BUG_ON(!pfn_valid(pte_pfn(pte)));
2185 page = pte_page(pte);
2187 folio = try_grab_folio(page, 1, flags);
2191 if (unlikely(page_is_secretmem(page))) {
2192 gup_put_folio(folio, 1, flags);
2196 if (unlikely(pte_val(pte) != pte_val(*ptep))) {
2197 gup_put_folio(folio, 1, flags);
2202 * We need to make the page accessible if and only if we are
2203 * going to access its content (the FOLL_PIN case). Please
2204 * see Documentation/core-api/pin_user_pages.rst for
2207 if (flags & FOLL_PIN) {
2208 ret = arch_make_page_accessible(page);
2210 gup_put_folio(folio, 1, flags);
2214 folio_set_referenced(folio);
2217 } while (ptep++, addr += PAGE_SIZE, addr != end);
2223 put_dev_pagemap(pgmap);
2230 * If we can't determine whether or not a pte is special, then fail immediately
2231 * for ptes. Note, we can still pin HugeTLB and THP as these are guaranteed not
2234 * For a futex to be placed on a THP tail page, get_futex_key requires a
2235 * get_user_pages_fast_only implementation that can pin pages. Thus it's still
2236 * useful to have gup_huge_pmd even if we can't operate on ptes.
2238 static int gup_pte_range(pmd_t pmd, unsigned long addr, unsigned long end,
2239 unsigned int flags, struct page **pages, int *nr)
2243 #endif /* CONFIG_ARCH_HAS_PTE_SPECIAL */
2245 #if defined(CONFIG_ARCH_HAS_PTE_DEVMAP) && defined(CONFIG_TRANSPARENT_HUGEPAGE)
2246 static int __gup_device_huge(unsigned long pfn, unsigned long addr,
2247 unsigned long end, unsigned int flags,
2248 struct page **pages, int *nr)
2251 struct dev_pagemap *pgmap = NULL;
2254 struct page *page = pfn_to_page(pfn);
2256 pgmap = get_dev_pagemap(pfn, pgmap);
2257 if (unlikely(!pgmap)) {
2258 undo_dev_pagemap(nr, nr_start, flags, pages);
2261 SetPageReferenced(page);
2263 if (unlikely(!try_grab_page(page, flags))) {
2264 undo_dev_pagemap(nr, nr_start, flags, pages);
2269 } while (addr += PAGE_SIZE, addr != end);
2271 put_dev_pagemap(pgmap);
2275 static int __gup_device_huge_pmd(pmd_t orig, pmd_t *pmdp, unsigned long addr,
2276 unsigned long end, unsigned int flags,
2277 struct page **pages, int *nr)
2279 unsigned long fault_pfn;
2282 fault_pfn = pmd_pfn(orig) + ((addr & ~PMD_MASK) >> PAGE_SHIFT);
2283 if (!__gup_device_huge(fault_pfn, addr, end, flags, pages, nr))
2286 if (unlikely(pmd_val(orig) != pmd_val(*pmdp))) {
2287 undo_dev_pagemap(nr, nr_start, flags, pages);
2293 static int __gup_device_huge_pud(pud_t orig, pud_t *pudp, unsigned long addr,
2294 unsigned long end, unsigned int flags,
2295 struct page **pages, int *nr)
2297 unsigned long fault_pfn;
2300 fault_pfn = pud_pfn(orig) + ((addr & ~PUD_MASK) >> PAGE_SHIFT);
2301 if (!__gup_device_huge(fault_pfn, addr, end, flags, pages, nr))
2304 if (unlikely(pud_val(orig) != pud_val(*pudp))) {
2305 undo_dev_pagemap(nr, nr_start, flags, pages);
2311 static int __gup_device_huge_pmd(pmd_t orig, pmd_t *pmdp, unsigned long addr,
2312 unsigned long end, unsigned int flags,
2313 struct page **pages, int *nr)
2319 static int __gup_device_huge_pud(pud_t pud, pud_t *pudp, unsigned long addr,
2320 unsigned long end, unsigned int flags,
2321 struct page **pages, int *nr)
2328 static int record_subpages(struct page *page, unsigned long addr,
2329 unsigned long end, struct page **pages)
2333 for (nr = 0; addr != end; nr++, addr += PAGE_SIZE)
2334 pages[nr] = nth_page(page, nr);
2339 #ifdef CONFIG_ARCH_HAS_HUGEPD
2340 static unsigned long hugepte_addr_end(unsigned long addr, unsigned long end,
2343 unsigned long __boundary = (addr + sz) & ~(sz-1);
2344 return (__boundary - 1 < end - 1) ? __boundary : end;
2347 static int gup_hugepte(pte_t *ptep, unsigned long sz, unsigned long addr,
2348 unsigned long end, unsigned int flags,
2349 struct page **pages, int *nr)
2351 unsigned long pte_end;
2353 struct folio *folio;
2357 pte_end = (addr + sz) & ~(sz-1);
2361 pte = huge_ptep_get(ptep);
2363 if (!pte_access_permitted(pte, flags & FOLL_WRITE))
2366 /* hugepages are never "special" */
2367 VM_BUG_ON(!pfn_valid(pte_pfn(pte)));
2369 page = nth_page(pte_page(pte), (addr & (sz - 1)) >> PAGE_SHIFT);
2370 refs = record_subpages(page, addr, end, pages + *nr);
2372 folio = try_grab_folio(page, refs, flags);
2376 if (unlikely(pte_val(pte) != pte_val(*ptep))) {
2377 gup_put_folio(folio, refs, flags);
2382 folio_set_referenced(folio);
2386 static int gup_huge_pd(hugepd_t hugepd, unsigned long addr,
2387 unsigned int pdshift, unsigned long end, unsigned int flags,
2388 struct page **pages, int *nr)
2391 unsigned long sz = 1UL << hugepd_shift(hugepd);
2394 ptep = hugepte_offset(hugepd, addr, pdshift);
2396 next = hugepte_addr_end(addr, end, sz);
2397 if (!gup_hugepte(ptep, sz, addr, end, flags, pages, nr))
2399 } while (ptep++, addr = next, addr != end);
2404 static inline int gup_huge_pd(hugepd_t hugepd, unsigned long addr,
2405 unsigned int pdshift, unsigned long end, unsigned int flags,
2406 struct page **pages, int *nr)
2410 #endif /* CONFIG_ARCH_HAS_HUGEPD */
2412 static int gup_huge_pmd(pmd_t orig, pmd_t *pmdp, unsigned long addr,
2413 unsigned long end, unsigned int flags,
2414 struct page **pages, int *nr)
2417 struct folio *folio;
2420 if (!pmd_access_permitted(orig, flags & FOLL_WRITE))
2423 if (pmd_devmap(orig)) {
2424 if (unlikely(flags & FOLL_LONGTERM))
2426 return __gup_device_huge_pmd(orig, pmdp, addr, end, flags,
2430 page = nth_page(pmd_page(orig), (addr & ~PMD_MASK) >> PAGE_SHIFT);
2431 refs = record_subpages(page, addr, end, pages + *nr);
2433 folio = try_grab_folio(page, refs, flags);
2437 if (unlikely(pmd_val(orig) != pmd_val(*pmdp))) {
2438 gup_put_folio(folio, refs, flags);
2443 folio_set_referenced(folio);
2447 static int gup_huge_pud(pud_t orig, pud_t *pudp, unsigned long addr,
2448 unsigned long end, unsigned int flags,
2449 struct page **pages, int *nr)
2452 struct folio *folio;
2455 if (!pud_access_permitted(orig, flags & FOLL_WRITE))
2458 if (pud_devmap(orig)) {
2459 if (unlikely(flags & FOLL_LONGTERM))
2461 return __gup_device_huge_pud(orig, pudp, addr, end, flags,
2465 page = nth_page(pud_page(orig), (addr & ~PUD_MASK) >> PAGE_SHIFT);
2466 refs = record_subpages(page, addr, end, pages + *nr);
2468 folio = try_grab_folio(page, refs, flags);
2472 if (unlikely(pud_val(orig) != pud_val(*pudp))) {
2473 gup_put_folio(folio, refs, flags);
2478 folio_set_referenced(folio);
2482 static int gup_huge_pgd(pgd_t orig, pgd_t *pgdp, unsigned long addr,
2483 unsigned long end, unsigned int flags,
2484 struct page **pages, int *nr)
2488 struct folio *folio;
2490 if (!pgd_access_permitted(orig, flags & FOLL_WRITE))
2493 BUILD_BUG_ON(pgd_devmap(orig));
2495 page = nth_page(pgd_page(orig), (addr & ~PGDIR_MASK) >> PAGE_SHIFT);
2496 refs = record_subpages(page, addr, end, pages + *nr);
2498 folio = try_grab_folio(page, refs, flags);
2502 if (unlikely(pgd_val(orig) != pgd_val(*pgdp))) {
2503 gup_put_folio(folio, refs, flags);
2508 folio_set_referenced(folio);
2512 static int gup_pmd_range(pud_t *pudp, pud_t pud, unsigned long addr, unsigned long end,
2513 unsigned int flags, struct page **pages, int *nr)
2518 pmdp = pmd_offset_lockless(pudp, pud, addr);
2520 pmd_t pmd = READ_ONCE(*pmdp);
2522 next = pmd_addr_end(addr, end);
2523 if (!pmd_present(pmd))
2526 if (unlikely(pmd_trans_huge(pmd) || pmd_huge(pmd) ||
2529 * NUMA hinting faults need to be handled in the GUP
2530 * slowpath for accounting purposes and so that they
2531 * can be serialised against THP migration.
2533 if (pmd_protnone(pmd))
2536 if (!gup_huge_pmd(pmd, pmdp, addr, next, flags,
2540 } else if (unlikely(is_hugepd(__hugepd(pmd_val(pmd))))) {
2542 * architecture have different format for hugetlbfs
2543 * pmd format and THP pmd format
2545 if (!gup_huge_pd(__hugepd(pmd_val(pmd)), addr,
2546 PMD_SHIFT, next, flags, pages, nr))
2548 } else if (!gup_pte_range(pmd, addr, next, flags, pages, nr))
2550 } while (pmdp++, addr = next, addr != end);
2555 static int gup_pud_range(p4d_t *p4dp, p4d_t p4d, unsigned long addr, unsigned long end,
2556 unsigned int flags, struct page **pages, int *nr)
2561 pudp = pud_offset_lockless(p4dp, p4d, addr);
2563 pud_t pud = READ_ONCE(*pudp);
2565 next = pud_addr_end(addr, end);
2566 if (unlikely(!pud_present(pud)))
2568 if (unlikely(pud_huge(pud))) {
2569 if (!gup_huge_pud(pud, pudp, addr, next, flags,
2572 } else if (unlikely(is_hugepd(__hugepd(pud_val(pud))))) {
2573 if (!gup_huge_pd(__hugepd(pud_val(pud)), addr,
2574 PUD_SHIFT, next, flags, pages, nr))
2576 } else if (!gup_pmd_range(pudp, pud, addr, next, flags, pages, nr))
2578 } while (pudp++, addr = next, addr != end);
2583 static int gup_p4d_range(pgd_t *pgdp, pgd_t pgd, unsigned long addr, unsigned long end,
2584 unsigned int flags, struct page **pages, int *nr)
2589 p4dp = p4d_offset_lockless(pgdp, pgd, addr);
2591 p4d_t p4d = READ_ONCE(*p4dp);
2593 next = p4d_addr_end(addr, end);
2596 BUILD_BUG_ON(p4d_huge(p4d));
2597 if (unlikely(is_hugepd(__hugepd(p4d_val(p4d))))) {
2598 if (!gup_huge_pd(__hugepd(p4d_val(p4d)), addr,
2599 P4D_SHIFT, next, flags, pages, nr))
2601 } else if (!gup_pud_range(p4dp, p4d, addr, next, flags, pages, nr))
2603 } while (p4dp++, addr = next, addr != end);
2608 static void gup_pgd_range(unsigned long addr, unsigned long end,
2609 unsigned int flags, struct page **pages, int *nr)
2614 pgdp = pgd_offset(current->mm, addr);
2616 pgd_t pgd = READ_ONCE(*pgdp);
2618 next = pgd_addr_end(addr, end);
2621 if (unlikely(pgd_huge(pgd))) {
2622 if (!gup_huge_pgd(pgd, pgdp, addr, next, flags,
2625 } else if (unlikely(is_hugepd(__hugepd(pgd_val(pgd))))) {
2626 if (!gup_huge_pd(__hugepd(pgd_val(pgd)), addr,
2627 PGDIR_SHIFT, next, flags, pages, nr))
2629 } else if (!gup_p4d_range(pgdp, pgd, addr, next, flags, pages, nr))
2631 } while (pgdp++, addr = next, addr != end);
2634 static inline void gup_pgd_range(unsigned long addr, unsigned long end,
2635 unsigned int flags, struct page **pages, int *nr)
2638 #endif /* CONFIG_HAVE_FAST_GUP */
2640 #ifndef gup_fast_permitted
2642 * Check if it's allowed to use get_user_pages_fast_only() for the range, or
2643 * we need to fall back to the slow version:
2645 static bool gup_fast_permitted(unsigned long start, unsigned long end)
2651 static int __gup_longterm_unlocked(unsigned long start, int nr_pages,
2652 unsigned int gup_flags, struct page **pages)
2657 * FIXME: FOLL_LONGTERM does not work with
2658 * get_user_pages_unlocked() (see comments in that function)
2660 if (gup_flags & FOLL_LONGTERM) {
2661 mmap_read_lock(current->mm);
2662 ret = __gup_longterm_locked(current->mm,
2664 pages, NULL, gup_flags);
2665 mmap_read_unlock(current->mm);
2667 ret = get_user_pages_unlocked(start, nr_pages,
2674 static unsigned long lockless_pages_from_mm(unsigned long start,
2676 unsigned int gup_flags,
2677 struct page **pages)
2679 unsigned long flags;
2683 if (!IS_ENABLED(CONFIG_HAVE_FAST_GUP) ||
2684 !gup_fast_permitted(start, end))
2687 if (gup_flags & FOLL_PIN) {
2688 seq = raw_read_seqcount(¤t->mm->write_protect_seq);
2694 * Disable interrupts. The nested form is used, in order to allow full,
2695 * general purpose use of this routine.
2697 * With interrupts disabled, we block page table pages from being freed
2698 * from under us. See struct mmu_table_batch comments in
2699 * include/asm-generic/tlb.h for more details.
2701 * We do not adopt an rcu_read_lock() here as we also want to block IPIs
2702 * that come from THPs splitting.
2704 local_irq_save(flags);
2705 gup_pgd_range(start, end, gup_flags, pages, &nr_pinned);
2706 local_irq_restore(flags);
2709 * When pinning pages for DMA there could be a concurrent write protect
2710 * from fork() via copy_page_range(), in this case always fail fast GUP.
2712 if (gup_flags & FOLL_PIN) {
2713 if (read_seqcount_retry(¤t->mm->write_protect_seq, seq)) {
2714 unpin_user_pages(pages, nr_pinned);
2721 static int internal_get_user_pages_fast(unsigned long start,
2722 unsigned long nr_pages,
2723 unsigned int gup_flags,
2724 struct page **pages)
2726 unsigned long len, end;
2727 unsigned long nr_pinned;
2730 if (WARN_ON_ONCE(gup_flags & ~(FOLL_WRITE | FOLL_LONGTERM |
2731 FOLL_FORCE | FOLL_PIN | FOLL_GET |
2732 FOLL_FAST_ONLY | FOLL_NOFAULT)))
2735 if (gup_flags & FOLL_PIN)
2736 mm_set_has_pinned_flag(¤t->mm->flags);
2738 if (!(gup_flags & FOLL_FAST_ONLY))
2739 might_lock_read(¤t->mm->mmap_lock);
2741 start = untagged_addr(start) & PAGE_MASK;
2742 len = nr_pages << PAGE_SHIFT;
2743 if (check_add_overflow(start, len, &end))
2745 if (unlikely(!access_ok((void __user *)start, len)))
2748 nr_pinned = lockless_pages_from_mm(start, end, gup_flags, pages);
2749 if (nr_pinned == nr_pages || gup_flags & FOLL_FAST_ONLY)
2752 /* Slow path: try to get the remaining pages with get_user_pages */
2753 start += nr_pinned << PAGE_SHIFT;
2755 ret = __gup_longterm_unlocked(start, nr_pages - nr_pinned, gup_flags,
2759 * The caller has to unpin the pages we already pinned so
2760 * returning -errno is not an option
2766 return ret + nr_pinned;
2770 * get_user_pages_fast_only() - pin user pages in memory
2771 * @start: starting user address
2772 * @nr_pages: number of pages from start to pin
2773 * @gup_flags: flags modifying pin behaviour
2774 * @pages: array that receives pointers to the pages pinned.
2775 * Should be at least nr_pages long.
2777 * Like get_user_pages_fast() except it's IRQ-safe in that it won't fall back to
2779 * Note a difference with get_user_pages_fast: this always returns the
2780 * number of pages pinned, 0 if no pages were pinned.
2782 * If the architecture does not support this function, simply return with no
2785 * Careful, careful! COW breaking can go either way, so a non-write
2786 * access can get ambiguous page results. If you call this function without
2787 * 'write' set, you'd better be sure that you're ok with that ambiguity.
2789 int get_user_pages_fast_only(unsigned long start, int nr_pages,
2790 unsigned int gup_flags, struct page **pages)
2794 * Internally (within mm/gup.c), gup fast variants must set FOLL_GET,
2795 * because gup fast is always a "pin with a +1 page refcount" request.
2797 * FOLL_FAST_ONLY is required in order to match the API description of
2798 * this routine: no fall back to regular ("slow") GUP.
2800 gup_flags |= FOLL_GET | FOLL_FAST_ONLY;
2802 nr_pinned = internal_get_user_pages_fast(start, nr_pages, gup_flags,
2806 * As specified in the API description above, this routine is not
2807 * allowed to return negative values. However, the common core
2808 * routine internal_get_user_pages_fast() *can* return -errno.
2809 * Therefore, correct for that here:
2816 EXPORT_SYMBOL_GPL(get_user_pages_fast_only);
2819 * get_user_pages_fast() - pin user pages in memory
2820 * @start: starting user address
2821 * @nr_pages: number of pages from start to pin
2822 * @gup_flags: flags modifying pin behaviour
2823 * @pages: array that receives pointers to the pages pinned.
2824 * Should be at least nr_pages long.
2826 * Attempt to pin user pages in memory without taking mm->mmap_lock.
2827 * If not successful, it will fall back to taking the lock and
2828 * calling get_user_pages().
2830 * Returns number of pages pinned. This may be fewer than the number requested.
2831 * If nr_pages is 0 or negative, returns 0. If no pages were pinned, returns
2834 int get_user_pages_fast(unsigned long start, int nr_pages,
2835 unsigned int gup_flags, struct page **pages)
2837 if (!is_valid_gup_flags(gup_flags))
2841 * The caller may or may not have explicitly set FOLL_GET; either way is
2842 * OK. However, internally (within mm/gup.c), gup fast variants must set
2843 * FOLL_GET, because gup fast is always a "pin with a +1 page refcount"
2846 gup_flags |= FOLL_GET;
2847 return internal_get_user_pages_fast(start, nr_pages, gup_flags, pages);
2849 EXPORT_SYMBOL_GPL(get_user_pages_fast);
2852 * pin_user_pages_fast() - pin user pages in memory without taking locks
2854 * @start: starting user address
2855 * @nr_pages: number of pages from start to pin
2856 * @gup_flags: flags modifying pin behaviour
2857 * @pages: array that receives pointers to the pages pinned.
2858 * Should be at least nr_pages long.
2860 * Nearly the same as get_user_pages_fast(), except that FOLL_PIN is set. See
2861 * get_user_pages_fast() for documentation on the function arguments, because
2862 * the arguments here are identical.
2864 * FOLL_PIN means that the pages must be released via unpin_user_page(). Please
2865 * see Documentation/core-api/pin_user_pages.rst for further details.
2867 int pin_user_pages_fast(unsigned long start, int nr_pages,
2868 unsigned int gup_flags, struct page **pages)
2870 /* FOLL_GET and FOLL_PIN are mutually exclusive. */
2871 if (WARN_ON_ONCE(gup_flags & FOLL_GET))
2874 gup_flags |= FOLL_PIN;
2875 return internal_get_user_pages_fast(start, nr_pages, gup_flags, pages);
2877 EXPORT_SYMBOL_GPL(pin_user_pages_fast);
2880 * This is the FOLL_PIN equivalent of get_user_pages_fast_only(). Behavior
2881 * is the same, except that this one sets FOLL_PIN instead of FOLL_GET.
2883 * The API rules are the same, too: no negative values may be returned.
2885 int pin_user_pages_fast_only(unsigned long start, int nr_pages,
2886 unsigned int gup_flags, struct page **pages)
2891 * FOLL_GET and FOLL_PIN are mutually exclusive. Note that the API
2892 * rules require returning 0, rather than -errno:
2894 if (WARN_ON_ONCE(gup_flags & FOLL_GET))
2897 * FOLL_FAST_ONLY is required in order to match the API description of
2898 * this routine: no fall back to regular ("slow") GUP.
2900 gup_flags |= (FOLL_PIN | FOLL_FAST_ONLY);
2901 nr_pinned = internal_get_user_pages_fast(start, nr_pages, gup_flags,
2904 * This routine is not allowed to return negative values. However,
2905 * internal_get_user_pages_fast() *can* return -errno. Therefore,
2906 * correct for that here:
2913 EXPORT_SYMBOL_GPL(pin_user_pages_fast_only);
2916 * pin_user_pages_remote() - pin pages of a remote process
2918 * @mm: mm_struct of target mm
2919 * @start: starting user address
2920 * @nr_pages: number of pages from start to pin
2921 * @gup_flags: flags modifying lookup behaviour
2922 * @pages: array that receives pointers to the pages pinned.
2923 * Should be at least nr_pages long. Or NULL, if caller
2924 * only intends to ensure the pages are faulted in.
2925 * @vmas: array of pointers to vmas corresponding to each page.
2926 * Or NULL if the caller does not require them.
2927 * @locked: pointer to lock flag indicating whether lock is held and
2928 * subsequently whether VM_FAULT_RETRY functionality can be
2929 * utilised. Lock must initially be held.
2931 * Nearly the same as get_user_pages_remote(), except that FOLL_PIN is set. See
2932 * get_user_pages_remote() for documentation on the function arguments, because
2933 * the arguments here are identical.
2935 * FOLL_PIN means that the pages must be released via unpin_user_page(). Please
2936 * see Documentation/core-api/pin_user_pages.rst for details.
2938 long pin_user_pages_remote(struct mm_struct *mm,
2939 unsigned long start, unsigned long nr_pages,
2940 unsigned int gup_flags, struct page **pages,
2941 struct vm_area_struct **vmas, int *locked)
2943 /* FOLL_GET and FOLL_PIN are mutually exclusive. */
2944 if (WARN_ON_ONCE(gup_flags & FOLL_GET))
2947 gup_flags |= FOLL_PIN;
2948 return __get_user_pages_remote(mm, start, nr_pages, gup_flags,
2949 pages, vmas, locked);
2951 EXPORT_SYMBOL(pin_user_pages_remote);
2954 * pin_user_pages() - pin user pages in memory for use by other devices
2956 * @start: starting user address
2957 * @nr_pages: number of pages from start to pin
2958 * @gup_flags: flags modifying lookup behaviour
2959 * @pages: array that receives pointers to the pages pinned.
2960 * Should be at least nr_pages long. Or NULL, if caller
2961 * only intends to ensure the pages are faulted in.
2962 * @vmas: array of pointers to vmas corresponding to each page.
2963 * Or NULL if the caller does not require them.
2965 * Nearly the same as get_user_pages(), except that FOLL_TOUCH is not set, and
2968 * FOLL_PIN means that the pages must be released via unpin_user_page(). Please
2969 * see Documentation/core-api/pin_user_pages.rst for details.
2971 long pin_user_pages(unsigned long start, unsigned long nr_pages,
2972 unsigned int gup_flags, struct page **pages,
2973 struct vm_area_struct **vmas)
2975 /* FOLL_GET and FOLL_PIN are mutually exclusive. */
2976 if (WARN_ON_ONCE(gup_flags & FOLL_GET))
2979 gup_flags |= FOLL_PIN;
2980 return __gup_longterm_locked(current->mm, start, nr_pages,
2981 pages, vmas, gup_flags);
2983 EXPORT_SYMBOL(pin_user_pages);
2986 * pin_user_pages_unlocked() is the FOLL_PIN variant of
2987 * get_user_pages_unlocked(). Behavior is the same, except that this one sets
2988 * FOLL_PIN and rejects FOLL_GET.
2990 long pin_user_pages_unlocked(unsigned long start, unsigned long nr_pages,
2991 struct page **pages, unsigned int gup_flags)
2993 /* FOLL_GET and FOLL_PIN are mutually exclusive. */
2994 if (WARN_ON_ONCE(gup_flags & FOLL_GET))
2997 gup_flags |= FOLL_PIN;
2998 return get_user_pages_unlocked(start, nr_pages, pages, gup_flags);
3000 EXPORT_SYMBOL(pin_user_pages_unlocked);