mm/gup.c

   1 #include <linux/kernel.h>
   2 #include <linux/errno.h>
   3 #include <linux/err.h>
   4 #include <linux/spinlock.h>
   5
   6 #include <linux/mm.h>
   7 #include <linux/pagemap.h>
   8 #include <linux/rmap.h>
   9 #include <linux/swap.h>
  10 #include <linux/swapops.h>
  11
  12 #include <linux/sched.h>
  13 #include <linux/rwsem.h>
  14 #include <linux/hugetlb.h>
  15
  16 #include <asm/pgtable.h>
  17 #include <asm/tlbflush.h>
  18
  19 #include "internal.h"
  20
  21 static struct page *no_page_table(struct vm_area_struct *vma,
  22                 unsigned int flags)
  23 {
  24         /*
  25          * When core dumping an enormous anonymous area that nobody
  26          * has touched so far, we don't want to allocate unnecessary pages or
  27          * page tables.  Return error instead of NULL to skip handle_mm_fault,
  28          * then get_dump_page() will return NULL to leave a hole in the dump.
  29          * But we can only make this optimization where a hole would surely
  30          * be zero-filled if handle_mm_fault() actually did handle it.
  31          */
  32         if ((flags & FOLL_DUMP) && (!vma->vm_ops || !vma->vm_ops->fault))
  33                 return ERR_PTR(-EFAULT);
  34         return NULL;
  35 }
  36
  37 static int follow_pfn_pte(struct vm_area_struct *vma, unsigned long address,
  38                 pte_t *pte, unsigned int flags)
  39 {
  40         /* No page to get reference */
  41         if (flags & FOLL_GET)
  42                 return -EFAULT;
  43
  44         if (flags & FOLL_TOUCH) {
  45                 pte_t entry = *pte;
  46
  47                 if (flags & FOLL_WRITE)
  48                         entry = pte_mkdirty(entry);
  49                 entry = pte_mkyoung(entry);
  50
  51                 if (!pte_same(*pte, entry)) {
  52                         set_pte_at(vma->vm_mm, address, pte, entry);
  53                         update_mmu_cache(vma, address, pte);
  54                 }
  55         }
  56
  57         /* Proper page table entry exists, but no corresponding struct page */
  58         return -EEXIST;
  59 }
  60
  61 /*
  62  * FOLL_FORCE can write to even unwritable pte's, but only
  63  * after we've gone through a COW cycle and they are dirty.
  64  */
  65 static inline bool can_follow_write_pte(pte_t pte, unsigned int flags)
  66 {
  67         return pte_write(pte) ||
  68                 ((flags & FOLL_FORCE) && (flags & FOLL_COW) && pte_dirty(pte));
  69 }
  70
  71 static struct page *follow_page_pte(struct vm_area_struct *vma,
  72                 unsigned long address, pmd_t *pmd, unsigned int flags)
  73 {
  74         struct mm_struct *mm = vma->vm_mm;
  75         struct page *page;
  76         spinlock_t *ptl;
  77         pte_t *ptep, pte;
  78
  79 retry:
  80         if (unlikely(pmd_bad(*pmd)))
  81                 return no_page_table(vma, flags);
  82
  83         ptep = pte_offset_map_lock(mm, pmd, address, &ptl);
  84         pte = *ptep;
  85         if (!pte_present(pte)) {
  86                 swp_entry_t entry;
  87                 /*
  88                  * KSM's break_ksm() relies upon recognizing a ksm page
  89                  * even while it is being migrated, so for that case we
  90                  * need migration_entry_wait().
  91                  */
  92                 if (likely(!(flags & FOLL_MIGRATION)))
  93                         goto no_page;
  94                 if (pte_none(pte))
  95                         goto no_page;
  96                 entry = pte_to_swp_entry(pte);
  97                 if (!is_migration_entry(entry))
  98                         goto no_page;
  99                 pte_unmap_unlock(ptep, ptl);
 100                 migration_entry_wait(mm, pmd, address);
 101                 goto retry;
 102         }
 103         if ((flags & FOLL_NUMA) && pte_protnone(pte))
 104                 goto no_page;
 105         if ((flags & FOLL_WRITE) && !can_follow_write_pte(pte, flags)) {
 106                 pte_unmap_unlock(ptep, ptl);
 107                 return NULL;
 108         }
 109
 110         page = vm_normal_page(vma, address, pte);
 111         if (unlikely(!page)) {
 112                 if (flags & FOLL_DUMP) {
 113                         /* Avoid special (like zero) pages in core dumps */
 114                         page = ERR_PTR(-EFAULT);
 115                         goto out;
 116                 }
 117
 118                 if (is_zero_pfn(pte_pfn(pte))) {
 119                         page = pte_page(pte);
 120                 } else {
 121                         int ret;
 122
 123                         ret = follow_pfn_pte(vma, address, ptep, flags);
 124                         page = ERR_PTR(ret);
 125                         goto out;
 126                 }
 127         }
 128
 129         if (flags & FOLL_GET)
 130                 get_page_foll(page);
 131         if (flags & FOLL_TOUCH) {
 132                 if ((flags & FOLL_WRITE) &&
 133                     !pte_dirty(pte) && !PageDirty(page))
 134                         set_page_dirty(page);
 135                 /*
 136                  * pte_mkyoung() would be more correct here, but atomic care
 137                  * is needed to avoid losing the dirty bit: it is easier to use
 138                  * mark_page_accessed().
 139                  */
 140                 mark_page_accessed(page);
 141         }
 142         if ((flags & FOLL_MLOCK) && (vma->vm_flags & VM_LOCKED)) {
 143                 /*
 144                  * The preliminary mapping check is mainly to avoid the
 145                  * pointless overhead of lock_page on the ZERO_PAGE
 146                  * which might bounce very badly if there is contention.
 147                  *
 148                  * If the page is already locked, we don't need to
 149                  * handle it now - vmscan will handle it later if and
 150                  * when it attempts to reclaim the page.
 151                  */
 152                 if (page->mapping && trylock_page(page)) {
 153                         lru_add_drain();  /* push cached pages to LRU */
 154                         /*
 155                          * Because we lock page here, and migration is
 156                          * blocked by the pte's page reference, and we
 157                          * know the page is still mapped, we don't even
 158                          * need to check for file-cache page truncation.
 159                          */
 160                         mlock_vma_page(page);
 161                         unlock_page(page);
 162                 }
 163         }
 164 out:
 165         pte_unmap_unlock(ptep, ptl);
 166         return page;
 167 no_page:
 168         pte_unmap_unlock(ptep, ptl);
 169         if (!pte_none(pte))
 170                 return NULL;
 171         return no_page_table(vma, flags);
 172 }
 173
 174 /**
 175  * follow_page_mask - look up a page descriptor from a user-virtual address
 176  * @vma: vm_area_struct mapping @address
 177  * @address: virtual address to look up
 178  * @flags: flags modifying lookup behaviour
 179  * @page_mask: on output, *page_mask is set according to the size of the page
 180  *
 181  * @flags can have FOLL_ flags set, defined in <linux/mm.h>
 182  *
 183  * Returns the mapped (struct page *), %NULL if no mapping exists, or
 184  * an error pointer if there is a mapping to something not represented
 185  * by a page descriptor (see also vm_normal_page()).
 186  */
 187 struct page *follow_page_mask(struct vm_area_struct *vma,
 188                               unsigned long address, unsigned int flags,
 189                               unsigned int *page_mask)
 190 {
 191         pgd_t *pgd;
 192         pud_t *pud;
 193         pmd_t *pmd;
 194         spinlock_t *ptl;
 195         struct page *page;
 196         struct mm_struct *mm = vma->vm_mm;
 197
 198         *page_mask = 0;
 199
 200         page = follow_huge_addr(mm, address, flags & FOLL_WRITE);
 201         if (!IS_ERR(page)) {
 202                 BUG_ON(flags & FOLL_GET);
 203                 return page;
 204         }
 205
 206         pgd = pgd_offset(mm, address);
 207         if (pgd_none(*pgd) || unlikely(pgd_bad(*pgd)))
 208                 return no_page_table(vma, flags);
 209
 210         pud = pud_offset(pgd, address);
 211         if (pud_none(*pud))
 212                 return no_page_table(vma, flags);
 213         if (pud_huge(*pud) && vma->vm_flags & VM_HUGETLB) {
 214                 page = follow_huge_pud(mm, address, pud, flags);
 215                 if (page)
 216                         return page;
 217                 return no_page_table(vma, flags);
 218         }
 219         if (unlikely(pud_bad(*pud)))
 220                 return no_page_table(vma, flags);
 221
 222         pmd = pmd_offset(pud, address);
 223         if (pmd_none(*pmd))
 224                 return no_page_table(vma, flags);
 225         if (pmd_huge(*pmd) && vma->vm_flags & VM_HUGETLB) {
 226                 page = follow_huge_pmd(mm, address, pmd, flags);
 227                 if (page)
 228                         return page;
 229                 return no_page_table(vma, flags);
 230         }
 231         if ((flags & FOLL_NUMA) && pmd_protnone(*pmd))
 232                 return no_page_table(vma, flags);
 233         if (pmd_trans_huge(*pmd)) {
 234                 if (flags & FOLL_SPLIT) {
 235                         split_huge_page_pmd(vma, address, pmd);
 236                         return follow_page_pte(vma, address, pmd, flags);
 237                 }
 238                 ptl = pmd_lock(mm, pmd);
 239                 if (likely(pmd_trans_huge(*pmd))) {
 240                         if (unlikely(pmd_trans_splitting(*pmd))) {
 241                                 spin_unlock(ptl);
 242                                 wait_split_huge_page(vma->anon_vma, pmd);
 243                         } else {
 244                                 page = follow_trans_huge_pmd(vma, address,
 245                                                              pmd, flags);
 246                                 spin_unlock(ptl);
 247                                 *page_mask = HPAGE_PMD_NR - 1;
 248                                 return page;
 249                         }
 250                 } else
 251                         spin_unlock(ptl);
 252         }
 253         return follow_page_pte(vma, address, pmd, flags);
 254 }
 255
 256 static int get_gate_page(struct mm_struct *mm, unsigned long address,
 257                 unsigned int gup_flags, struct vm_area_struct **vma,
 258                 struct page **page)
 259 {
 260         pgd_t *pgd;
 261         pud_t *pud;
 262         pmd_t *pmd;
 263         pte_t *pte;
 264         int ret = -EFAULT;
 265
 266         /* user gate pages are read-only */
 267         if (gup_flags & FOLL_WRITE)
 268                 return -EFAULT;
 269         if (address > TASK_SIZE)
 270                 pgd = pgd_offset_k(address);
 271         else
 272                 pgd = pgd_offset_gate(mm, address);
 273         BUG_ON(pgd_none(*pgd));
 274         pud = pud_offset(pgd, address);
 275         BUG_ON(pud_none(*pud));
 276         pmd = pmd_offset(pud, address);
 277         if (pmd_none(*pmd))
 278                 return -EFAULT;
 279         VM_BUG_ON(pmd_trans_huge(*pmd));
 280         pte = pte_offset_map(pmd, address);
 281         if (pte_none(*pte))
 282                 goto unmap;
 283         *vma = get_gate_vma(mm);
 284         if (!page)
 285                 goto out;
 286         *page = vm_normal_page(*vma, address, *pte);
 287         if (!*page) {
 288                 if ((gup_flags & FOLL_DUMP) || !is_zero_pfn(pte_pfn(*pte)))
 289                         goto unmap;
 290                 *page = pte_page(*pte);
 291         }
 292         get_page(*page);
 293 out:
 294         ret = 0;
 295 unmap:
 296         pte_unmap(pte);
 297         return ret;
 298 }
 299
 300 /*
 301  * mmap_sem must be held on entry.  If @nonblocking != NULL and
 302  * *@flags does not include FOLL_NOWAIT, the mmap_sem may be released.
 303  * If it is, *@nonblocking will be set to 0 and -EBUSY returned.
 304  */
 305 static int faultin_page(struct task_struct *tsk, struct vm_area_struct *vma,
 306                 unsigned long address, unsigned int *flags, int *nonblocking)
 307 {
 308         struct mm_struct *mm = vma->vm_mm;
 309         unsigned int fault_flags = 0;
 310         int ret;
 311
 312         /* mlock all present pages, but do not fault in new pages */
 313         if ((*flags & (FOLL_POPULATE | FOLL_MLOCK)) == FOLL_MLOCK)
 314                 return -ENOENT;
 315         if (*flags & FOLL_WRITE)
 316                 fault_flags |= FAULT_FLAG_WRITE;
 317         if (nonblocking)
 318                 fault_flags |= FAULT_FLAG_ALLOW_RETRY;
 319         if (*flags & FOLL_NOWAIT)
 320                 fault_flags |= FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_RETRY_NOWAIT;
 321         if (*flags & FOLL_TRIED) {
 322                 VM_WARN_ON_ONCE(fault_flags & FAULT_FLAG_ALLOW_RETRY);
 323                 fault_flags |= FAULT_FLAG_TRIED;
 324         }
 325
 326         ret = handle_mm_fault(mm, vma, address, fault_flags);
 327         if (ret & VM_FAULT_ERROR) {
 328                 if (ret & VM_FAULT_OOM)
 329                         return -ENOMEM;
 330                 if (ret & (VM_FAULT_HWPOISON | VM_FAULT_HWPOISON_LARGE))
 331                         return *flags & FOLL_HWPOISON ? -EHWPOISON : -EFAULT;
 332                 if (ret & (VM_FAULT_SIGBUS | VM_FAULT_SIGSEGV))
 333                         return -EFAULT;
 334                 BUG();
 335         }
 336
 337         if (tsk) {
 338                 if (ret & VM_FAULT_MAJOR)
 339                         tsk->maj_flt++;
 340                 else
 341                         tsk->min_flt++;
 342         }
 343
 344         if (ret & VM_FAULT_RETRY) {
 345                 if (nonblocking)
 346                         *nonblocking = 0;
 347                 return -EBUSY;
 348         }
 349
 350         /*
 351          * The VM_FAULT_WRITE bit tells us that do_wp_page has broken COW when
 352          * necessary, even if maybe_mkwrite decided not to set pte_write. We
 353          * can thus safely do subsequent page lookups as if they were reads.
 354          * But only do so when looping for pte_write is futile: in some cases
 355          * userspace may also be wanting to write to the gotten user page,
 356          * which a read fault here might prevent (a readonly page might get
 357          * reCOWed by userspace write).
 358          */
 359         if ((ret & VM_FAULT_WRITE) && !(vma->vm_flags & VM_WRITE))
 360                 *flags |= FOLL_COW;
 361         return 0;
 362 }
 363
 364 static int check_vma_flags(struct vm_area_struct *vma, unsigned long gup_flags)
 365 {
 366         vm_flags_t vm_flags = vma->vm_flags;
 367
 368         if (vm_flags & (VM_IO | VM_PFNMAP))
 369                 return -EFAULT;
 370
 371         if (gup_flags & FOLL_ANON && !vma_is_anonymous(vma))
 372                 return -EFAULT;
 373
 374         if (gup_flags & FOLL_WRITE) {
 375                 if (!(vm_flags & VM_WRITE)) {
 376                         if (!(gup_flags & FOLL_FORCE))
 377                                 return -EFAULT;
 378                         /*
 379                          * We used to let the write,force case do COW in a
 380                          * VM_MAYWRITE VM_SHARED !VM_WRITE vma, so ptrace could
 381                          * set a breakpoint in a read-only mapping of an
 382                          * executable, without corrupting the file (yet only
 383                          * when that file had been opened for writing!).
 384                          * Anon pages in shared mappings are surprising: now
 385                          * just reject it.
 386                          */
 387                         if (!is_cow_mapping(vm_flags)) {
 388                                 WARN_ON_ONCE(vm_flags & VM_MAYWRITE);
 389                                 return -EFAULT;
 390                         }
 391                 }
 392         } else if (!(vm_flags & VM_READ)) {
 393                 if (!(gup_flags & FOLL_FORCE))
 394                         return -EFAULT;
 395                 /*
 396                  * Is there actually any vma we can reach here which does not
 397                  * have VM_MAYREAD set?
 398                  */
 399                 if (!(vm_flags & VM_MAYREAD))
 400                         return -EFAULT;
 401         }
 402         return 0;
 403 }
 404
 405 /**
 406  * __get_user_pages() - pin user pages in memory
 407  * @tsk:        task_struct of target task
 408  * @mm:         mm_struct of target mm
 409  * @start:      starting user address
 410  * @nr_pages:   number of pages from start to pin
 411  * @gup_flags:  flags modifying pin behaviour
 412  * @pages:      array that receives pointers to the pages pinned.
 413  *              Should be at least nr_pages long. Or NULL, if caller
 414  *              only intends to ensure the pages are faulted in.
 415  * @vmas:       array of pointers to vmas corresponding to each page.
 416  *              Or NULL if the caller does not require them.
 417  * @nonblocking: whether waiting for disk IO or mmap_sem contention
 418  *
 419  * Returns number of pages pinned. This may be fewer than the number
 420  * requested. If nr_pages is 0 or negative, returns 0. If no pages
 421  * were pinned, returns -errno. Each page returned must be released
 422  * with a put_page() call when it is finished with. vmas will only
 423  * remain valid while mmap_sem is held.
 424  *
 425  * Must be called with mmap_sem held.  It may be released.  See below.
 426  *
 427  * __get_user_pages walks a process's page tables and takes a reference to
 428  * each struct page that each user address corresponds to at a given
 429  * instant. That is, it takes the page that would be accessed if a user
 430  * thread accesses the given user virtual address at that instant.
 431  *
 432  * This does not guarantee that the page exists in the user mappings when
 433  * __get_user_pages returns, and there may even be a completely different
 434  * page there in some cases (eg. if mmapped pagecache has been invalidated
 435  * and subsequently re faulted). However it does guarantee that the page
 436  * won't be freed completely. And mostly callers simply care that the page
 437  * contains data that was valid *at some point in time*. Typically, an IO
 438  * or similar operation cannot guarantee anything stronger anyway because
 439  * locks can't be held over the syscall boundary.
 440  *
 441  * If @gup_flags & FOLL_WRITE == 0, the page must not be written to. If
 442  * the page is written to, set_page_dirty (or set_page_dirty_lock, as
 443  * appropriate) must be called after the page is finished with, and
 444  * before put_page is called.
 445  *
 446  * If @nonblocking != NULL, __get_user_pages will not wait for disk IO
 447  * or mmap_sem contention, and if waiting is needed to pin all pages,
 448  * *@nonblocking will be set to 0.  Further, if @gup_flags does not
 449  * include FOLL_NOWAIT, the mmap_sem will be released via up_read() in
 450  * this case.
 451  *
 452  * A caller using such a combination of @nonblocking and @gup_flags
 453  * must therefore hold the mmap_sem for reading only, and recognize
 454  * when it's been released.  Otherwise, it must be held for either
 455  * reading or writing and will not be released.
 456  *
 457  * In most cases, get_user_pages or get_user_pages_fast should be used
 458  * instead of __get_user_pages. __get_user_pages should be used only if
 459  * you need some special @gup_flags.
 460  */
 461 long __get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
 462                 unsigned long start, unsigned long nr_pages,
 463                 unsigned int gup_flags, struct page **pages,
 464                 struct vm_area_struct **vmas, int *nonblocking)
 465 {
 466         long i = 0;
 467         unsigned int page_mask;
 468         struct vm_area_struct *vma = NULL;
 469
 470         if (!nr_pages)
 471                 return 0;
 472
 473         VM_BUG_ON(!!pages != !!(gup_flags & FOLL_GET));
 474
 475         /*
 476          * If FOLL_FORCE is set then do not force a full fault as the hinting
 477          * fault information is unrelated to the reference behaviour of a task
 478          * using the address space
 479          */
 480         if (!(gup_flags & FOLL_FORCE))
 481                 gup_flags |= FOLL_NUMA;
 482
 483         do {
 484                 struct page *page;
 485                 unsigned int foll_flags = gup_flags;
 486                 unsigned int page_increm;
 487
 488                 /* first iteration or cross vma bound */
 489                 if (!vma || start >= vma->vm_end) {
 490                         vma = find_extend_vma(mm, start);
 491                         if (!vma && in_gate_area(mm, start)) {
 492                                 int ret;
 493                                 ret = get_gate_page(mm, start & PAGE_MASK,
 494                                                 gup_flags, &vma,
 495                                                 pages ? &pages[i] : NULL);
 496                                 if (ret)
 497                                         return i ? : ret;
 498                                 page_mask = 0;
 499                                 goto next_page;
 500                         }
 501
 502                         if (!vma || check_vma_flags(vma, gup_flags))
 503                                 return i ? : -EFAULT;
 504                         if (is_vm_hugetlb_page(vma)) {
 505                                 i = follow_hugetlb_page(mm, vma, pages, vmas,
 506                                                 &start, &nr_pages, i,
 507                                                 gup_flags);
 508                                 continue;
 509                         }
 510                 }
 511 retry:
 512                 /*
 513                  * If we have a pending SIGKILL, don't keep faulting pages and
 514                  * potentially allocating memory.
 515                  */
 516                 if (unlikely(fatal_signal_pending(current)))
 517                         return i ? i : -ERESTARTSYS;
 518                 cond_resched();
 519                 page = follow_page_mask(vma, start, foll_flags, &page_mask);
 520                 if (!page) {
 521                         int ret;
 522                         ret = faultin_page(tsk, vma, start, &foll_flags,
 523                                         nonblocking);
 524                         switch (ret) {
 525                         case 0:
 526                                 goto retry;
 527                         case -EFAULT:
 528                         case -ENOMEM:
 529                         case -EHWPOISON:
 530                                 return i ? i : ret;
 531                         case -EBUSY:
 532                                 return i;
 533                         case -ENOENT:
 534                                 goto next_page;
 535                         }
 536                         BUG();
 537                 } else if (PTR_ERR(page) == -EEXIST) {
 538                         /*
 539                          * Proper page table entry exists, but no corresponding
 540                          * struct page.
 541                          */
 542                         goto next_page;
 543                 } else if (IS_ERR(page)) {
 544                         return i ? i : PTR_ERR(page);
 545                 }
 546                 if (pages) {
 547                         pages[i] = page;
 548                         flush_anon_page(vma, page, start);
 549                         flush_dcache_page(page);
 550                         page_mask = 0;
 551                 }
 552 next_page:
 553                 if (vmas) {
 554                         vmas[i] = vma;
 555                         page_mask = 0;
 556                 }
 557                 page_increm = 1 + (~(start >> PAGE_SHIFT) & page_mask);
 558                 if (page_increm > nr_pages)
 559                         page_increm = nr_pages;
 560                 i += page_increm;
 561                 start += page_increm * PAGE_SIZE;
 562                 nr_pages -= page_increm;
 563         } while (nr_pages);
 564         return i;
 565 }
 566 EXPORT_SYMBOL(__get_user_pages);
 567
 568 /*
 569  * fixup_user_fault() - manually resolve a user page fault
 570  * @tsk:        the task_struct to use for page fault accounting, or
 571  *              NULL if faults are not to be recorded.
 572  * @mm:         mm_struct of target mm
 573  * @address:    user address
 574  * @fault_flags:flags to pass down to handle_mm_fault()
 575  *
 576  * This is meant to be called in the specific scenario where for locking reasons
 577  * we try to access user memory in atomic context (within a pagefault_disable()
 578  * section), this returns -EFAULT, and we want to resolve the user fault before
 579  * trying again.
 580  *
 581  * Typically this is meant to be used by the futex code.
 582  *
 583  * The main difference with get_user_pages() is that this function will
 584  * unconditionally call handle_mm_fault() which will in turn perform all the
 585  * necessary SW fixup of the dirty and young bits in the PTE, while
 586  * handle_mm_fault() only guarantees to update these in the struct page.
 587  *
 588  * This is important for some architectures where those bits also gate the
 589  * access permission to the page because they are maintained in software.  On
 590  * such architectures, gup() will not be enough to make a subsequent access
 591  * succeed.
 592  *
 593  * This has the same semantics wrt the @mm->mmap_sem as does filemap_fault().
 594  */
 595 int fixup_user_fault(struct task_struct *tsk, struct mm_struct *mm,
 596                      unsigned long address, unsigned int fault_flags)
 597 {
 598         struct vm_area_struct *vma;
 599         vm_flags_t vm_flags;
 600         int ret;
 601
 602         vma = find_extend_vma(mm, address);
 603         if (!vma || address < vma->vm_start)
 604                 return -EFAULT;
 605
 606         vm_flags = (fault_flags & FAULT_FLAG_WRITE) ? VM_WRITE : VM_READ;
 607         if (!(vm_flags & vma->vm_flags))
 608                 return -EFAULT;
 609
 610         ret = handle_mm_fault(mm, vma, address, fault_flags);
 611         if (ret & VM_FAULT_ERROR) {
 612                 if (ret & VM_FAULT_OOM)
 613                         return -ENOMEM;
 614                 if (ret & (VM_FAULT_HWPOISON | VM_FAULT_HWPOISON_LARGE))
 615                         return -EHWPOISON;
 616                 if (ret & (VM_FAULT_SIGBUS | VM_FAULT_SIGSEGV))
 617                         return -EFAULT;
 618                 BUG();
 619         }
 620         if (tsk) {
 621                 if (ret & VM_FAULT_MAJOR)
 622                         tsk->maj_flt++;
 623                 else
 624                         tsk->min_flt++;
 625         }
 626         return 0;
 627 }
 628
 629 static __always_inline long __get_user_pages_locked(struct task_struct *tsk,
 630                                                 struct mm_struct *mm,
 631                                                 unsigned long start,
 632                                                 unsigned long nr_pages,
 633                                                 struct page **pages,
 634                                                 struct vm_area_struct **vmas,
 635                                                 int *locked, bool notify_drop,
 636                                                 unsigned int flags)
 637 {
 638         long ret, pages_done;
 639         bool lock_dropped;
 640
 641         if (locked) {
 642                 /* if VM_FAULT_RETRY can be returned, vmas become invalid */
 643                 BUG_ON(vmas);
 644                 /* check caller initialized locked */
 645                 BUG_ON(*locked != 1);
 646         }
 647
 648         if (pages)
 649                 flags |= FOLL_GET;
 650
 651         pages_done = 0;
 652         lock_dropped = false;
 653         for (;;) {
 654                 ret = __get_user_pages(tsk, mm, start, nr_pages, flags, pages,
 655                                        vmas, locked);
 656                 if (!locked)
 657                         /* VM_FAULT_RETRY couldn't trigger, bypass */
 658                         return ret;
 659
 660                 /* VM_FAULT_RETRY cannot return errors */
 661                 if (!*locked) {
 662                         BUG_ON(ret < 0);
 663                         BUG_ON(ret >= nr_pages);
 664                 }
 665
 666                 if (!pages)
 667                         /* If it's a prefault don't insist harder */
 668                         return ret;
 669
 670                 if (ret > 0) {
 671                         nr_pages -= ret;
 672                         pages_done += ret;
 673                         if (!nr_pages)
 674                                 break;
 675                 }
 676                 if (*locked) {
 677                         /* VM_FAULT_RETRY didn't trigger */
 678                         if (!pages_done)
 679                                 pages_done = ret;
 680                         break;
 681                 }
 682                 /* VM_FAULT_RETRY triggered, so seek to the faulting offset */
 683                 pages += ret;
 684                 start += ret << PAGE_SHIFT;
 685
 686                 /*
 687                  * Repeat on the address that fired VM_FAULT_RETRY
 688                  * without FAULT_FLAG_ALLOW_RETRY but with
 689                  * FAULT_FLAG_TRIED.
 690                  */
 691                 *locked = 1;
 692                 lock_dropped = true;
 693                 down_read(&mm->mmap_sem);
 694                 ret = __get_user_pages(tsk, mm, start, 1, flags | FOLL_TRIED,
 695                                        pages, NULL, NULL);
 696                 if (ret != 1) {
 697                         BUG_ON(ret > 1);
 698                         if (!pages_done)
 699                                 pages_done = ret;
 700                         break;
 701                 }
 702                 nr_pages--;
 703                 pages_done++;
 704                 if (!nr_pages)
 705                         break;
 706                 pages++;
 707                 start += PAGE_SIZE;
 708         }
 709         if (notify_drop && lock_dropped && *locked) {
 710                 /*
 711                  * We must let the caller know we temporarily dropped the lock
 712                  * and so the critical section protected by it was lost.
 713                  */
 714                 up_read(&mm->mmap_sem);
 715                 *locked = 0;
 716         }
 717         return pages_done;
 718 }
 719
 720 /*
 721  * We can leverage the VM_FAULT_RETRY functionality in the page fault
 722  * paths better by using either get_user_pages_locked() or
 723  * get_user_pages_unlocked().
 724  *
 725  * get_user_pages_locked() is suitable to replace the form:
 726  *
 727  *      down_read(&mm->mmap_sem);
 728  *      do_something()
 729  *      get_user_pages(tsk, mm, ..., pages, NULL);
 730  *      up_read(&mm->mmap_sem);
 731  *
 732  *  to:
 733  *
 734  *      int locked = 1;
 735  *      down_read(&mm->mmap_sem);
 736  *      do_something()
 737  *      get_user_pages_locked(tsk, mm, ..., pages, &locked);
 738  *      if (locked)
 739  *          up_read(&mm->mmap_sem);
 740  */
 741 long get_user_pages_locked(struct task_struct *tsk, struct mm_struct *mm,
 742                            unsigned long start, unsigned long nr_pages,
 743                            unsigned int gup_flags, struct page **pages,
 744                            int *locked)
 745 {
 746         return __get_user_pages_locked(tsk, mm, start, nr_pages,
 747                                        pages, NULL, locked, true,
 748                                        gup_flags | FOLL_TOUCH);
 749 }
 750 EXPORT_SYMBOL(get_user_pages_locked);
 751
 752 /*
 753  * Same as get_user_pages_unlocked(...., FOLL_TOUCH) but it allows to
 754  * pass additional gup_flags as last parameter (like FOLL_HWPOISON).
 755  *
 756  * NOTE: here FOLL_TOUCH is not set implicitly and must be set by the
 757  * caller if required (just like with __get_user_pages). "FOLL_GET",
 758  * "FOLL_WRITE" and "FOLL_FORCE" are set implicitly as needed
 759  * according to the parameters "pages", "write", "force"
 760  * respectively.
 761  */
 762 __always_inline long __get_user_pages_unlocked(struct task_struct *tsk, struct mm_struct *mm,
 763                                                unsigned long start, unsigned long nr_pages,
 764                                                struct page **pages, unsigned int gup_flags)
 765 {
 766         long ret;
 767         int locked = 1;
 768
 769         down_read(&mm->mmap_sem);
 770         ret = __get_user_pages_locked(tsk, mm, start, nr_pages, pages, NULL,
 771                                       &locked, false, gup_flags);
 772         if (locked)
 773                 up_read(&mm->mmap_sem);
 774         return ret;
 775 }
 776 EXPORT_SYMBOL(__get_user_pages_unlocked);
 777
 778 /*
 779  * get_user_pages_unlocked() is suitable to replace the form:
 780  *
 781  *      down_read(&mm->mmap_sem);
 782  *      get_user_pages(tsk, mm, ..., pages, NULL);
 783  *      up_read(&mm->mmap_sem);
 784  *
 785  *  with:
 786  *
 787  *      get_user_pages_unlocked(tsk, mm, ..., pages);
 788  *
 789  * It is functionally equivalent to get_user_pages_fast so
 790  * get_user_pages_fast should be used instead, if the two parameters
 791  * "tsk" and "mm" are respectively equal to current and current->mm,
 792  * or if "force" shall be set to 1 (get_user_pages_fast misses the
 793  * "force" parameter).
 794  */
 795 long get_user_pages_unlocked(struct task_struct *tsk, struct mm_struct *mm,
 796                              unsigned long start, unsigned long nr_pages,
 797                              struct page **pages, unsigned int gup_flags)
 798 {
 799         return __get_user_pages_unlocked(tsk, mm, start, nr_pages,
 800                                          pages, gup_flags | FOLL_TOUCH);
 801 }
 802 EXPORT_SYMBOL(get_user_pages_unlocked);
 803
 804 /*
 805  * get_user_pages() - pin user pages in memory
 806  * @tsk:        the task_struct to use for page fault accounting, or
 807  *              NULL if faults are not to be recorded.
 808  * @mm:         mm_struct of target mm
 809  * @start:      starting user address
 810  * @nr_pages:   number of pages from start to pin
 811  * @write:      whether pages will be written to by the caller
 812  * @force:      whether to force access even when user mapping is currently
 813  *              protected (but never forces write access to shared mapping).
 814  * @pages:      array that receives pointers to the pages pinned.
 815  *              Should be at least nr_pages long. Or NULL, if caller
 816  *              only intends to ensure the pages are faulted in.
 817  * @vmas:       array of pointers to vmas corresponding to each page.
 818  *              Or NULL if the caller does not require them.
 819  *
 820  * Returns number of pages pinned. This may be fewer than the number
 821  * requested. If nr_pages is 0 or negative, returns 0. If no pages
 822  * were pinned, returns -errno. Each page returned must be released
 823  * with a put_page() call when it is finished with. vmas will only
 824  * remain valid while mmap_sem is held.
 825  *
 826  * Must be called with mmap_sem held for read or write.
 827  *
 828  * get_user_pages walks a process's page tables and takes a reference to
 829  * each struct page that each user address corresponds to at a given
 830  * instant. That is, it takes the page that would be accessed if a user
 831  * thread accesses the given user virtual address at that instant.
 832  *
 833  * This does not guarantee that the page exists in the user mappings when
 834  * get_user_pages returns, and there may even be a completely different
 835  * page there in some cases (eg. if mmapped pagecache has been invalidated
 836  * and subsequently re faulted). However it does guarantee that the page
 837  * won't be freed completely. And mostly callers simply care that the page
 838  * contains data that was valid *at some point in time*. Typically, an IO
 839  * or similar operation cannot guarantee anything stronger anyway because
 840  * locks can't be held over the syscall boundary.
 841  *
 842  * If write=0, the page must not be written to. If the page is written to,
 843  * set_page_dirty (or set_page_dirty_lock, as appropriate) must be called
 844  * after the page is finished with, and before put_page is called.
 845  *
 846  * get_user_pages is typically used for fewer-copy IO operations, to get a
 847  * handle on the memory by some means other than accesses via the user virtual
 848  * addresses. The pages may be submitted for DMA to devices or accessed via
 849  * their kernel linear mapping (via the kmap APIs). Care should be taken to
 850  * use the correct cache flushing APIs.
 851  *
 852  * See also get_user_pages_fast, for performance critical applications.
 853  *
 854  * get_user_pages should be phased out in favor of
 855  * get_user_pages_locked|unlocked or get_user_pages_fast. Nothing
 856  * should use get_user_pages because it cannot pass
 857  * FAULT_FLAG_ALLOW_RETRY to handle_mm_fault.
 858  */
 859 long get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
 860                 unsigned long start, unsigned long nr_pages,
 861                 unsigned int gup_flags, struct page **pages,
 862                 struct vm_area_struct **vmas)
 863 {
 864         return __get_user_pages_locked(tsk, mm, start, nr_pages,
 865                                        pages, vmas, NULL, false,
 866                                        gup_flags | FOLL_TOUCH);
 867 }
 868 EXPORT_SYMBOL(get_user_pages);
 869
 870 /**
 871  * populate_vma_page_range() -  populate a range of pages in the vma.
 872  * @vma:   target vma
 873  * @start: start address
 874  * @end:   end address
 875  * @nonblocking:
 876  *
 877  * This takes care of mlocking the pages too if VM_LOCKED is set.
 878  *
 879  * return 0 on success, negative error code on error.
 880  *
 881  * vma->vm_mm->mmap_sem must be held.
 882  *
 883  * If @nonblocking is NULL, it may be held for read or write and will
 884  * be unperturbed.
 885  *
 886  * If @nonblocking is non-NULL, it must held for read only and may be
 887  * released.  If it's released, *@nonblocking will be set to 0.
 888  */
 889 long populate_vma_page_range(struct vm_area_struct *vma,
 890                 unsigned long start, unsigned long end, int *nonblocking)
 891 {
 892         struct mm_struct *mm = vma->vm_mm;
 893         unsigned long nr_pages = (end - start) / PAGE_SIZE;
 894         int gup_flags;
 895
 896         VM_BUG_ON(start & ~PAGE_MASK);
 897         VM_BUG_ON(end   & ~PAGE_MASK);
 898         VM_BUG_ON_VMA(start < vma->vm_start, vma);
 899         VM_BUG_ON_VMA(end   > vma->vm_end, vma);
 900         VM_BUG_ON_MM(!rwsem_is_locked(&mm->mmap_sem), mm);
 901
 902         gup_flags = FOLL_TOUCH | FOLL_POPULATE | FOLL_MLOCK;
 903         if (vma->vm_flags & VM_LOCKONFAULT)
 904                 gup_flags &= ~FOLL_POPULATE;
 905
 906         /*
 907          * We want to touch writable mappings with a write fault in order
 908          * to break COW, except for shared mappings because these don't COW
 909          * and we would not want to dirty them for nothing.
 910          */
 911         if ((vma->vm_flags & (VM_WRITE | VM_SHARED)) == VM_WRITE)
 912                 gup_flags |= FOLL_WRITE;
 913
 914         /*
 915          * We want mlock to succeed for regions that have any permissions
 916          * other than PROT_NONE.
 917          */
 918         if (vma->vm_flags & (VM_READ | VM_WRITE | VM_EXEC))
 919                 gup_flags |= FOLL_FORCE;
 920
 921         /*
 922          * We made sure addr is within a VMA, so the following will
 923          * not result in a stack expansion that recurses back here.
 924          */
 925         return __get_user_pages(current, mm, start, nr_pages, gup_flags,
 926                                 NULL, NULL, nonblocking);
 927 }
 928
 929 /*
 930  * __mm_populate - populate and/or mlock pages within a range of address space.
 931  *
 932  * This is used to implement mlock() and the MAP_POPULATE / MAP_LOCKED mmap
 933  * flags. VMAs must be already marked with the desired vm_flags, and
 934  * mmap_sem must not be held.
 935  */
 936 int __mm_populate(unsigned long start, unsigned long len, int ignore_errors)
 937 {
 938         struct mm_struct *mm = current->mm;
 939         unsigned long end, nstart, nend;
 940         struct vm_area_struct *vma = NULL;
 941         int locked = 0;
 942         long ret = 0;
 943
 944         end = start + len;
 945
 946         for (nstart = start; nstart < end; nstart = nend) {
 947                 /*
 948                  * We want to fault in pages for [nstart; end) address range.
 949                  * Find first corresponding VMA.
 950                  */
 951                 if (!locked) {
 952                         locked = 1;
 953                         down_read(&mm->mmap_sem);
 954                         vma = find_vma(mm, nstart);
 955                 } else if (nstart >= vma->vm_end)
 956                         vma = vma->vm_next;
 957                 if (!vma || vma->vm_start >= end)
 958                         break;
 959                 /*
 960                  * Set [nstart; nend) to intersection of desired address
 961                  * range with the first VMA. Also, skip undesirable VMA types.
 962                  */
 963                 nend = min(end, vma->vm_end);
 964                 if (vma->vm_flags & (VM_IO | VM_PFNMAP))
 965                         continue;
 966                 if (nstart < vma->vm_start)
 967                         nstart = vma->vm_start;
 968                 /*
 969                  * Now fault in a range of pages. populate_vma_page_range()
 970                  * double checks the vma flags, so that it won't mlock pages
 971                  * if the vma was already munlocked.
 972                  */
 973                 ret = populate_vma_page_range(vma, nstart, nend, &locked);
 974                 if (ret < 0) {
 975                         if (ignore_errors) {
 976                                 ret = 0;
 977                                 continue;       /* continue at next VMA */
 978                         }
 979                         break;
 980                 }
 981                 nend = nstart + ret * PAGE_SIZE;
 982                 ret = 0;
 983         }
 984         if (locked)
 985                 up_read(&mm->mmap_sem);
 986         return ret;     /* 0 or negative error code */
 987 }
 988
 989 /**
 990  * get_dump_page() - pin user page in memory while writing it to core dump
 991  * @addr: user address
 992  *
 993  * Returns struct page pointer of user page pinned for dump,
 994  * to be freed afterwards by page_cache_release() or put_page().
 995  *
 996  * Returns NULL on any kind of failure - a hole must then be inserted into
 997  * the corefile, to preserve alignment with its headers; and also returns
 998  * NULL wherever the ZERO_PAGE, or an anonymous pte_none, has been found -
 999  * allowing a hole to be left in the corefile to save diskspace.
1000  *
1001  * Called without mmap_sem, but after all other threads have been killed.
1002  */
1003 #ifdef CONFIG_ELF_CORE
1004 struct page *get_dump_page(unsigned long addr)
1005 {
1006         struct vm_area_struct *vma;
1007         struct page *page;
1008
1009         if (__get_user_pages(current, current->mm, addr, 1,
1010                              FOLL_FORCE | FOLL_DUMP | FOLL_GET, &page, &vma,
1011                              NULL) < 1)
1012                 return NULL;
1013         flush_cache_page(vma, addr, page_to_pfn(page));
1014         return page;
1015 }
1016 #endif /* CONFIG_ELF_CORE */
1017
1018 /*
1019  * Generic RCU Fast GUP
1020  *
1021  * get_user_pages_fast attempts to pin user pages by walking the page
1022  * tables directly and avoids taking locks. Thus the walker needs to be
1023  * protected from page table pages being freed from under it, and should
1024  * block any THP splits.
1025  *
1026  * One way to achieve this is to have the walker disable interrupts, and
1027  * rely on IPIs from the TLB flushing code blocking before the page table
1028  * pages are freed. This is unsuitable for architectures that do not need
1029  * to broadcast an IPI when invalidating TLBs.
1030  *
1031  * Another way to achieve this is to batch up page table containing pages
1032  * belonging to more than one mm_user, then rcu_sched a callback to free those
1033  * pages. Disabling interrupts will allow the fast_gup walker to both block
1034  * the rcu_sched callback, and an IPI that we broadcast for splitting THPs
1035  * (which is a relatively rare event). The code below adopts this strategy.
1036  *
1037  * Before activating this code, please be aware that the following assumptions
1038  * are currently made:
1039  *
1040  *  *) HAVE_RCU_TABLE_FREE is enabled, and tlb_remove_table is used to free
1041  *      pages containing page tables.
1042  *
1043  *  *) THP splits will broadcast an IPI, this can be achieved by overriding
1044  *      pmdp_splitting_flush.
1045  *
1046  *  *) ptes can be read atomically by the architecture.
1047  *
1048  *  *) access_ok is sufficient to validate userspace address ranges.
1049  *
1050  * The last two assumptions can be relaxed by the addition of helper functions.
1051  *
1052  * This code is based heavily on the PowerPC implementation by Nick Piggin.
1053  */
1054 #ifdef CONFIG_HAVE_GENERIC_RCU_GUP
1055
1056 #ifdef __HAVE_ARCH_PTE_SPECIAL
1057 static int gup_pte_range(pmd_t pmd, unsigned long addr, unsigned long end,
1058                          int write, struct page **pages, int *nr)
1059 {
1060         pte_t *ptep, *ptem;
1061         int ret = 0;
1062
1063         ptem = ptep = pte_offset_map(&pmd, addr);
1064         do {
1065                 /*
1066                  * In the line below we are assuming that the pte can be read
1067                  * atomically. If this is not the case for your architecture,
1068                  * please wrap this in a helper function!
1069                  *
1070                  * for an example see gup_get_pte in arch/x86/mm/gup.c
1071                  */
1072                 pte_t pte = READ_ONCE(*ptep);
1073                 struct page *page;
1074
1075                 /*
1076                  * Similar to the PMD case below, NUMA hinting must take slow
1077                  * path using the pte_protnone check.
1078                  */
1079                 if (!pte_present(pte) || pte_special(pte) ||
1080                         pte_protnone(pte) || (write && !pte_write(pte)))
1081                         goto pte_unmap;
1082
1083                 VM_BUG_ON(!pfn_valid(pte_pfn(pte)));
1084                 page = pte_page(pte);
1085
1086                 if (!page_cache_get_speculative(page))
1087                         goto pte_unmap;
1088
1089                 if (unlikely(pte_val(pte) != pte_val(*ptep))) {
1090                         put_page(page);
1091                         goto pte_unmap;
1092                 }
1093
1094                 pages[*nr] = page;
1095                 (*nr)++;
1096
1097         } while (ptep++, addr += PAGE_SIZE, addr != end);
1098
1099         ret = 1;
1100
1101 pte_unmap:
1102         pte_unmap(ptem);
1103         return ret;
1104 }
1105 #else
1106
1107 /*
1108  * If we can't determine whether or not a pte is special, then fail immediately
1109  * for ptes. Note, we can still pin HugeTLB and THP as these are guaranteed not
1110  * to be special.
1111  *
1112  * For a futex to be placed on a THP tail page, get_futex_key requires a
1113  * __get_user_pages_fast implementation that can pin pages. Thus it's still
1114  * useful to have gup_huge_pmd even if we can't operate on ptes.
1115  */
1116 static int gup_pte_range(pmd_t pmd, unsigned long addr, unsigned long end,
1117                          int write, struct page **pages, int *nr)
1118 {
1119         return 0;
1120 }
1121 #endif /* __HAVE_ARCH_PTE_SPECIAL */
1122
1123 static int gup_huge_pmd(pmd_t orig, pmd_t *pmdp, unsigned long addr,
1124                 unsigned long end, int write, struct page **pages, int *nr)
1125 {
1126         struct page *head, *page, *tail;
1127         int refs;
1128
1129         if (write && !pmd_write(orig))
1130                 return 0;
1131
1132         refs = 0;
1133         head = pmd_page(orig);
1134         page = head + ((addr & ~PMD_MASK) >> PAGE_SHIFT);
1135         tail = page;
1136         do {
1137                 VM_BUG_ON_PAGE(compound_head(page) != head, page);
1138                 pages[*nr] = page;
1139                 (*nr)++;
1140                 page++;
1141                 refs++;
1142         } while (addr += PAGE_SIZE, addr != end);
1143
1144         if (!page_cache_add_speculative(head, refs)) {
1145                 *nr -= refs;
1146                 return 0;
1147         }
1148
1149         if (unlikely(pmd_val(orig) != pmd_val(*pmdp))) {
1150                 *nr -= refs;
1151                 while (refs--)
1152                         put_page(head);
1153                 return 0;
1154         }
1155
1156         /*
1157          * Any tail pages need their mapcount reference taken before we
1158          * return. (This allows the THP code to bump their ref count when
1159          * they are split into base pages).
1160          */
1161         while (refs--) {
1162                 if (PageTail(tail))
1163                         get_huge_page_tail(tail);
1164                 tail++;
1165         }
1166
1167         return 1;
1168 }
1169
1170 static int gup_huge_pud(pud_t orig, pud_t *pudp, unsigned long addr,
1171                 unsigned long end, int write, struct page **pages, int *nr)
1172 {
1173         struct page *head, *page, *tail;
1174         int refs;
1175
1176         if (write && !pud_write(orig))
1177                 return 0;
1178
1179         refs = 0;
1180         head = pud_page(orig);
1181         page = head + ((addr & ~PUD_MASK) >> PAGE_SHIFT);
1182         tail = page;
1183         do {
1184                 VM_BUG_ON_PAGE(compound_head(page) != head, page);
1185                 pages[*nr] = page;
1186                 (*nr)++;
1187                 page++;
1188                 refs++;
1189         } while (addr += PAGE_SIZE, addr != end);
1190
1191         if (!page_cache_add_speculative(head, refs)) {
1192                 *nr -= refs;
1193                 return 0;
1194         }
1195
1196         if (unlikely(pud_val(orig) != pud_val(*pudp))) {
1197                 *nr -= refs;
1198                 while (refs--)
1199                         put_page(head);
1200                 return 0;
1201         }
1202
1203         while (refs--) {
1204                 if (PageTail(tail))
1205                         get_huge_page_tail(tail);
1206                 tail++;
1207         }
1208
1209         return 1;
1210 }
1211
1212 static int gup_huge_pgd(pgd_t orig, pgd_t *pgdp, unsigned long addr,
1213                         unsigned long end, int write,
1214                         struct page **pages, int *nr)
1215 {
1216         int refs;
1217         struct page *head, *page, *tail;
1218
1219         if (write && !pgd_write(orig))
1220                 return 0;
1221
1222         refs = 0;
1223         head = pgd_page(orig);
1224         page = head + ((addr & ~PGDIR_MASK) >> PAGE_SHIFT);
1225         tail = page;
1226         do {
1227                 VM_BUG_ON_PAGE(compound_head(page) != head, page);
1228                 pages[*nr] = page;
1229                 (*nr)++;
1230                 page++;
1231                 refs++;
1232         } while (addr += PAGE_SIZE, addr != end);
1233
1234         if (!page_cache_add_speculative(head, refs)) {
1235                 *nr -= refs;
1236                 return 0;
1237         }
1238
1239         if (unlikely(pgd_val(orig) != pgd_val(*pgdp))) {
1240                 *nr -= refs;
1241                 while (refs--)
1242                         put_page(head);
1243                 return 0;
1244         }
1245
1246         while (refs--) {
1247                 if (PageTail(tail))
1248                         get_huge_page_tail(tail);
1249                 tail++;
1250         }
1251
1252         return 1;
1253 }
1254
1255 static int gup_pmd_range(pud_t pud, unsigned long addr, unsigned long end,
1256                 int write, struct page **pages, int *nr)
1257 {
1258         unsigned long next;
1259         pmd_t *pmdp;
1260
1261         pmdp = pmd_offset(&pud, addr);
1262         do {
1263                 pmd_t pmd = READ_ONCE(*pmdp);
1264
1265                 next = pmd_addr_end(addr, end);
1266                 if (pmd_none(pmd) || pmd_trans_splitting(pmd))
1267                         return 0;
1268
1269                 if (unlikely(pmd_trans_huge(pmd) || pmd_huge(pmd))) {
1270                         /*
1271                          * NUMA hinting faults need to be handled in the GUP
1272                          * slowpath for accounting purposes and so that they
1273                          * can be serialised against THP migration.
1274                          */
1275                         if (pmd_protnone(pmd))
1276                                 return 0;
1277
1278                         if (!gup_huge_pmd(pmd, pmdp, addr, next, write,
1279                                 pages, nr))
1280                                 return 0;
1281
1282                 } else if (unlikely(is_hugepd(__hugepd(pmd_val(pmd))))) {
1283                         /*
1284                          * architecture have different format for hugetlbfs
1285                          * pmd format and THP pmd format
1286                          */
1287                         if (!gup_huge_pd(__hugepd(pmd_val(pmd)), addr,
1288                                          PMD_SHIFT, next, write, pages, nr))
1289                                 return 0;
1290                 } else if (!gup_pte_range(pmd, addr, next, write, pages, nr))
1291                                 return 0;
1292         } while (pmdp++, addr = next, addr != end);
1293
1294         return 1;
1295 }
1296
1297 static int gup_pud_range(pgd_t pgd, unsigned long addr, unsigned long end,
1298                          int write, struct page **pages, int *nr)
1299 {
1300         unsigned long next;
1301         pud_t *pudp;
1302
1303         pudp = pud_offset(&pgd, addr);
1304         do {
1305                 pud_t pud = READ_ONCE(*pudp);
1306
1307                 next = pud_addr_end(addr, end);
1308                 if (pud_none(pud))
1309                         return 0;
1310                 if (unlikely(pud_huge(pud))) {
1311                         if (!gup_huge_pud(pud, pudp, addr, next, write,
1312                                           pages, nr))
1313                                 return 0;
1314                 } else if (unlikely(is_hugepd(__hugepd(pud_val(pud))))) {
1315                         if (!gup_huge_pd(__hugepd(pud_val(pud)), addr,
1316                                          PUD_SHIFT, next, write, pages, nr))
1317                                 return 0;
1318                 } else if (!gup_pmd_range(pud, addr, next, write, pages, nr))
1319                         return 0;
1320         } while (pudp++, addr = next, addr != end);
1321
1322         return 1;
1323 }
1324
1325 /*
1326  * Like get_user_pages_fast() except it's IRQ-safe in that it won't fall back to
1327  * the regular GUP. It will only return non-negative values.
1328  */
1329 int __get_user_pages_fast(unsigned long start, int nr_pages, int write,
1330                           struct page **pages)
1331 {
1332         struct mm_struct *mm = current->mm;
1333         unsigned long addr, len, end;
1334         unsigned long next, flags;
1335         pgd_t *pgdp;
1336         int nr = 0;
1337
1338         start &= PAGE_MASK;
1339         addr = start;
1340         len = (unsigned long) nr_pages << PAGE_SHIFT;
1341         end = start + len;
1342
1343         if (unlikely(!access_ok(write ? VERIFY_WRITE : VERIFY_READ,
1344                                         start, len)))
1345                 return 0;
1346
1347         /*
1348          * Disable interrupts.  We use the nested form as we can already have
1349          * interrupts disabled by get_futex_key.
1350          *
1351          * With interrupts disabled, we block page table pages from being
1352          * freed from under us. See mmu_gather_tlb in asm-generic/tlb.h
1353          * for more details.
1354          *
1355          * We do not adopt an rcu_read_lock(.) here as we also want to
1356          * block IPIs that come from THPs splitting.
1357          */
1358
1359         local_irq_save(flags);
1360         pgdp = pgd_offset(mm, addr);
1361         do {
1362                 pgd_t pgd = READ_ONCE(*pgdp);
1363
1364                 next = pgd_addr_end(addr, end);
1365                 if (pgd_none(pgd))
1366                         break;
1367                 if (unlikely(pgd_huge(pgd))) {
1368                         if (!gup_huge_pgd(pgd, pgdp, addr, next, write,
1369                                           pages, &nr))
1370                                 break;
1371                 } else if (unlikely(is_hugepd(__hugepd(pgd_val(pgd))))) {
1372                         if (!gup_huge_pd(__hugepd(pgd_val(pgd)), addr,
1373                                          PGDIR_SHIFT, next, write, pages, &nr))
1374                                 break;
1375                 } else if (!gup_pud_range(pgd, addr, next, write, pages, &nr))
1376                         break;
1377         } while (pgdp++, addr = next, addr != end);
1378         local_irq_restore(flags);
1379
1380         return nr;
1381 }
1382
1383 /**
1384  * get_user_pages_fast() - pin user pages in memory
1385  * @start:      starting user address
1386  * @nr_pages:   number of pages from start to pin
1387  * @write:      whether pages will be written to
1388  * @pages:      array that receives pointers to the pages pinned.
1389  *              Should be at least nr_pages long.
1390  *
1391  * Attempt to pin user pages in memory without taking mm->mmap_sem.
1392  * If not successful, it will fall back to taking the lock and
1393  * calling get_user_pages().
1394  *
1395  * Returns number of pages pinned. This may be fewer than the number
1396  * requested. If nr_pages is 0 or negative, returns 0. If no pages
1397  * were pinned, returns -errno.
1398  */
1399 int get_user_pages_fast(unsigned long start, int nr_pages, int write,
1400                         struct page **pages)
1401 {
1402         struct mm_struct *mm = current->mm;
1403         int nr, ret;
1404
1405         start &= PAGE_MASK;
1406         nr = __get_user_pages_fast(start, nr_pages, write, pages);
1407         ret = nr;
1408
1409         if (nr < nr_pages) {
1410                 /* Try to get the remaining pages with get_user_pages */
1411                 start += nr << PAGE_SHIFT;
1412                 pages += nr;
1413
1414                 ret = get_user_pages_unlocked(current, mm, start,
1415                                               nr_pages - nr, pages,
1416                                               write ? FOLL_WRITE : 0);
1417
1418                 /* Have to be a bit careful with return values */
1419                 if (nr > 0) {
1420                         if (ret < 0)
1421                                 ret = nr;
1422                         else
1423                                 ret += nr;
1424                 }
1425         }
1426
1427         return ret;
1428 }
1429
1430 #endif /* CONFIG_HAVE_GENERIC_RCU_GUP */