From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.9 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id A34D0C2D0D8 for ; Mon, 9 Dec 2019 22:55:02 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 78CF6207FF for ; Mon, 9 Dec 2019 22:55:02 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=nvidia.com header.i=@nvidia.com header.b="gPAodyMG" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727553AbfLIWyP (ORCPT ); Mon, 9 Dec 2019 17:54:15 -0500 Received: from hqnvemgate26.nvidia.com ([216.228.121.65]:19975 "EHLO hqnvemgate26.nvidia.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727541AbfLIWyP (ORCPT ); Mon, 9 Dec 2019 17:54:15 -0500 Received: from hqpgpgate101.nvidia.com (Not Verified[216.228.121.13]) by hqnvemgate26.nvidia.com (using TLS: TLSv1.2, DES-CBC3-SHA) id ; Mon, 09 Dec 2019 14:54:05 -0800 Received: from hqmail.nvidia.com ([172.20.161.6]) by hqpgpgate101.nvidia.com (PGP Universal service); Mon, 09 Dec 2019 14:54:11 -0800 X-PGP-Universal: processed; by hqpgpgate101.nvidia.com on Mon, 09 Dec 2019 14:54:11 -0800 Received: from HQMAIL107.nvidia.com (172.20.187.13) by HQMAIL107.nvidia.com (172.20.187.13) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Mon, 9 Dec 2019 22:54:10 +0000 Received: from rnnvemgw01.nvidia.com (10.128.109.123) by HQMAIL107.nvidia.com (172.20.187.13) with Microsoft SMTP Server (TLS) id 15.0.1473.3 via Frontend Transport; Mon, 9 Dec 2019 22:54:10 +0000 Received: from blueforge.nvidia.com (Not Verified[10.110.48.28]) by rnnvemgw01.nvidia.com with Trustwave SEG (v7,5,8,10121) id ; Mon, 09 Dec 2019 14:54:10 -0800 From: John Hubbard To: Andrew Morton CC: Al Viro , Alex Williamson , Benjamin Herrenschmidt , =?UTF-8?q?Bj=C3=B6rn=20T=C3=B6pel?= , Christoph Hellwig , Dan Williams , Daniel Vetter , Dave Chinner , David Airlie , "David S . Miller" , Ira Weiny , Jan Kara , Jason Gunthorpe , Jens Axboe , Jonathan Corbet , =?UTF-8?q?J=C3=A9r=C3=B4me=20Glisse?= , Magnus Karlsson , Mauro Carvalho Chehab , Michael Ellerman , Michal Hocko , Mike Kravetz , Paul Mackerras , Shuah Khan , Vlastimil Babka , , , , , , , , , , , , , LKML , John Hubbard Subject: [PATCH v8 24/26] mm/gup: track FOLL_PIN pages Date: Mon, 9 Dec 2019 14:53:42 -0800 Message-ID: <20191209225344.99740-25-jhubbard@nvidia.com> X-Mailer: git-send-email 2.24.0 In-Reply-To: <20191209225344.99740-1-jhubbard@nvidia.com> References: <20191209225344.99740-1-jhubbard@nvidia.com> MIME-Version: 1.0 X-NVConfidentiality: public Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nvidia.com; s=n1; t=1575932045; bh=xw2riX9toxr+y4PZuGyWwXyWjmV1H2jFqabRtOMnAuE=; h=X-PGP-Universal:From:To:CC:Subject:Date:Message-ID:X-Mailer: In-Reply-To:References:MIME-Version:X-NVConfidentiality: Content-Type:Content-Transfer-Encoding; b=gPAodyMGAkREcu16BEXHRFjwOpCYTzjre7lmB9hd1klidPzN05l9hc1+2s6o1W+RO y8H7bQNcMa170TTHoDM+FM61vMBeeorVlxrBX9kinI2pm37s6mvdb2GEABOS5jlHE0 pV+uvleSyFR7cyC/TOrGyG+AQ0QGTP/EsOdfSmHyV6sv9jjsuZs6xfHk7BiYsE5Ks3 AflzjBfOMfhwxBR5hDHtXE9yBEZsOLQ2HbZcSykJNsDMYfEGM/J4Fm2S/co6M3SoOs vcPYx9nDrBuF9FZPXi08viuC1kG3Ewbyx2hxldEDtK0/8SkQgig+S7pWf8FK3gzyJx trWpIqhrldD/A== Sender: bpf-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org Add tracking of pages that were pinned via FOLL_PIN. As mentioned in the FOLL_PIN documentation, callers who effectively set FOLL_PIN are required to ultimately free such pages via unpin_user_page(). The effect is similar to FOLL_GET, and may be thought of as "FOLL_GET for DIO and/or RDMA use". Pages that have been pinned via FOLL_PIN are identifiable via a new function call: bool page_dma_pinned(struct page *page); What to do in response to encountering such a page, is left to later patchsets. There is discussion about this in [1], [2], and [3]. This also changes a BUG_ON(), to a WARN_ON(), in follow_page_mask(). [1] Some slow progress on get_user_pages() (Apr 2, 2019): https://lwn.net/Articles/784574/ [2] DMA and get_user_pages() (LPC: Dec 12, 2018): https://lwn.net/Articles/774411/ [3] The trouble with get_user_pages() (Apr 30, 2018): https://lwn.net/Articles/753027/ Suggested-by: Jan Kara Suggested-by: J=C3=A9r=C3=B4me Glisse Signed-off-by: John Hubbard --- Documentation/core-api/pin_user_pages.rst | 2 +- include/linux/mm.h | 73 ++++- include/linux/mmzone.h | 2 + include/linux/page_ref.h | 10 + mm/gup.c | 338 +++++++++++++++++----- mm/huge_memory.c | 23 +- mm/hugetlb.c | 15 +- mm/vmstat.c | 2 + 8 files changed, 362 insertions(+), 103 deletions(-) diff --git a/Documentation/core-api/pin_user_pages.rst b/Documentation/core= -api/pin_user_pages.rst index bba96428ade7..6d93ef203561 100644 --- a/Documentation/core-api/pin_user_pages.rst +++ b/Documentation/core-api/pin_user_pages.rst @@ -53,7 +53,7 @@ Which flags are set by each wrapper For these pin_user_pages*() functions, FOLL_PIN is OR'd in with whatever g= up flags the caller provides. The caller is required to pass in a non-null st= ruct pages* array, and the function then pin pages by incrementing each by a sp= ecial -value. For now, that value is +1, just like get_user_pages*().:: +value: GUP_PIN_COUNTING_BIAS.:: =20 Function -------- diff --git a/include/linux/mm.h b/include/linux/mm.h index 6a1a357e7d86..9666989d2b9e 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h @@ -1016,6 +1016,8 @@ static inline void get_page(struct page *page) page_ref_inc(page); } =20 +void grab_page(struct page *page, unsigned int flags); + static inline __must_check bool try_get_page(struct page *page) { page =3D compound_head(page); @@ -1044,29 +1046,70 @@ static inline void put_page(struct page *page) __put_page(page); } =20 -/** - * unpin_user_page() - release a gup-pinned page - * @page: pointer to page to be released +/* + * GUP_PIN_COUNTING_BIAS, and the associated functions that use it, overlo= ad + * the page's refcount so that two separate items are tracked: the origina= l page + * reference count, and also a new count of how many pin_user_pages() call= s were + * made against the page. ("gup-pinned" is another term for the latter). + * + * With this scheme, pin_user_pages() becomes special: such pages are mark= ed as + * distinct from normal pages. As such, the unpin_user_page() call (and it= s + * variants) must be used in order to release gup-pinned pages. + * + * Choice of value: * - * Pages that were pinned via pin_user_pages*() must be released via eithe= r - * unpin_user_page(), or one of the unpin_user_pages*() routines. This is = so - * that eventually such pages can be separately tracked and uniquely handl= ed. In - * particular, interactions with RDMA and filesystems need special handlin= g. + * By making GUP_PIN_COUNTING_BIAS a power of two, debugging of page refer= ence + * counts with respect to pin_user_pages() and unpin_user_page() becomes + * simpler, due to the fact that adding an even power of two to the page + * refcount has the effect of using only the upper N bits, for the code th= at + * counts up using the bias value. This means that the lower bits are left= for + * the exclusive use of the original code that increments and decrements b= y one + * (or at least, by much smaller values than the bias value). * - * unpin_user_page() and put_page() are not interchangeable, despite this = early - * implementation that makes them look the same. unpin_user_page() calls m= ust - * be perfectly matched up with pin*() calls. + * Of course, once the lower bits overflow into the upper bits (and this i= s + * OK, because subtraction recovers the original values), then visual insp= ection + * no longer suffices to directly view the separate counts. However, for n= ormal + * applications that don't have huge page reference counts, this won't be = an + * issue. + * + * Locking: the lockless algorithm described in page_cache_get_speculative= () + * and page_cache_gup_pin_speculative() provides safe operation for + * get_user_pages and page_mkclean and other calls that race to set up pag= e + * table entries. */ -static inline void unpin_user_page(struct page *page) -{ - put_page(page); -} +#define GUP_PIN_COUNTING_BIAS (1UL << 10) =20 +void unpin_user_page(struct page *page); void unpin_user_pages_dirty_lock(struct page **pages, unsigned long npages= , bool make_dirty); - void unpin_user_pages(struct page **pages, unsigned long npages); =20 +/** + * page_dma_pinned() - report if a page is pinned for DMA. + * + * This function checks if a page has been pinned via a call to + * pin_user_pages*(). + * + * The return value is partially fuzzy: false is not fuzzy, because it mea= ns + * "definitely not pinned for DMA", but true means "probably pinned for DM= A, but + * possibly a false positive due to having at least GUP_PIN_COUNTING_BIAS = worth + * of normal page references". + * + * False positives are OK, because: a) it's unlikely for a page to get tha= t many + * refcounts, and b) all the callers of this routine are expected to be ab= le to + * deal gracefully with a false positive. + * + * For more information, please see Documentation/vm/pin_user_pages.rst. + * + * @page: pointer to page to be queried. + * @Return: True, if it is likely that the page has been "dma-pinned". + * False, if the page is definitely not dma-pinned. + */ +static inline bool page_dma_pinned(struct page *page) +{ + return (page_ref_count(compound_head(page))) >=3D GUP_PIN_COUNTING_BIAS; +} + #if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP) #define SECTION_IN_PAGE_FLAGS #endif diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h index 89d8ff06c9ce..a7418f7a44da 100644 --- a/include/linux/mmzone.h +++ b/include/linux/mmzone.h @@ -244,6 +244,8 @@ enum node_stat_item { NR_DIRTIED, /* page dirtyings since bootup */ NR_WRITTEN, /* page writings since bootup */ NR_KERNEL_MISC_RECLAIMABLE, /* reclaimable non-slab kernel pages */ + NR_FOLL_PIN_REQUESTED, /* via: pin_user_page(), gup flag: FOLL_PIN */ + NR_FOLL_PIN_RETURNED, /* pages returned via unpin_user_page() */ NR_VM_NODE_STAT_ITEMS }; =20 diff --git a/include/linux/page_ref.h b/include/linux/page_ref.h index 14d14beb1f7f..b9cbe553d1e7 100644 --- a/include/linux/page_ref.h +++ b/include/linux/page_ref.h @@ -102,6 +102,16 @@ static inline void page_ref_sub(struct page *page, int= nr) __page_ref_mod(page, -nr); } =20 +static inline int page_ref_sub_return(struct page *page, int nr) +{ + int ret =3D atomic_sub_return(nr, &page->_refcount); + + if (page_ref_tracepoint_active(__tracepoint_page_ref_mod)) + __page_ref_mod(page, -nr); + + return ret; +} + static inline void page_ref_inc(struct page *page) { atomic_inc(&page->_refcount); diff --git a/mm/gup.c b/mm/gup.c index 687d48506f04..45fe923e28e2 100644 --- a/mm/gup.c +++ b/mm/gup.c @@ -36,6 +36,20 @@ static __always_inline long __gup_longterm_locked(struct= task_struct *tsk, struct page **pages, struct vm_area_struct **vmas, unsigned int flags); + +#ifdef CONFIG_DEBUG_VM +static inline void __update_proc_vmstat(struct page *page, + enum node_stat_item item, int count) +{ + mod_node_page_state(page_pgdat(page), item, count); +} +#else +static inline void __update_proc_vmstat(struct page *page, + enum node_stat_item item, int count) +{ +} +#endif + /* * Return the compound head page with ref appropriately incremented, * or NULL if that failed. @@ -51,6 +65,138 @@ static inline struct page *try_get_compound_head(struct= page *page, int refs) return head; } =20 +/** + * try_pin_compound_head() - mark a compound page as being used by + * pin_user_pages*(). + * + * This is the FOLL_PIN counterpart to try_get_compound_head(). + * + * @page: pointer to page to be marked + * @Return: the compound head page, with ref appropriately incremented, + * or NULL upon failure. + */ +__must_check struct page *try_pin_compound_head(struct page *page, int ref= s) +{ + struct page *head =3D try_get_compound_head(page, + GUP_PIN_COUNTING_BIAS * refs); + if (!head) + return NULL; + + __update_proc_vmstat(page, NR_FOLL_PIN_REQUESTED, refs); + return head; +} + +/* + * try_grab_compound_head() - attempt to elevate a page's refcount, by a + * flags-dependent amount. + * + * This has a default assumption of "use FOLL_GET behavior, if FOLL_PIN is= not + * set". + * + * "grab" names in this file mean, "look at flags to decide with to use FO= LL_PIN + * or FOLL_GET behavior, when incrementing the page's refcount. + */ +static struct page *try_grab_compound_head(struct page *page, int refs, + unsigned int flags) +{ + if (flags & FOLL_PIN) + return try_pin_compound_head(page, refs); + + return try_get_compound_head(page, refs); +} + +/** + * grab_page() - elevate a page's refcount by a flag-dependent amount + * + * This might not do anything at all, depending on the flags argument. + * + * "grab" names in this file mean, "look at flags to decide with to use FO= LL_PIN + * or FOLL_GET behavior, when incrementing the page's refcount. + * + * @page: pointer to page to be grabbed + * @flags: gup flags: these are the FOLL_* flag values. + * + * Either FOLL_PIN or FOLL_GET (or neither) may be set, but not both at th= e same + * time. (That's true throughout the get_user_pages*() and pin_user_pages*= () + * APIs.) Cases: + * + * FOLL_GET: page's refcount will be incremented by 1. + * FOLL_PIN: page's refcount will be incremented by GUP_PIN_COUNTING_BIAS. + */ +void grab_page(struct page *page, unsigned int flags) +{ + if (flags & FOLL_GET) + get_page(page); + else if (flags & FOLL_PIN) { + get_page(page); + WARN_ON_ONCE(flags & FOLL_GET); + /* + * Use get_page(), above, to do the refcount error + * checking. Then just add in the remaining references: + */ + page_ref_add(page, GUP_PIN_COUNTING_BIAS - 1); + __update_proc_vmstat(page, NR_FOLL_PIN_REQUESTED, 1); + } +} + +#ifdef CONFIG_DEV_PAGEMAP_OPS +static bool __unpin_devmap_managed_user_page(struct page *page) +{ + bool is_devmap =3D page_is_devmap_managed(page); + + if (is_devmap) { + int count =3D page_ref_sub_return(page, GUP_PIN_COUNTING_BIAS); + + __update_proc_vmstat(page, NR_FOLL_PIN_RETURNED, 1); + /* + * devmap page refcounts are 1-based, rather than 0-based: if + * refcount is 1, then the page is free and the refcount is + * stable because nobody holds a reference on the page. + */ + if (count =3D=3D 1) + free_devmap_managed_page(page); + else if (!count) + __put_page(page); + } + + return is_devmap; +} +#else +static bool __unpin_devmap_managed_user_page(struct page *page) +{ + return false; +} +#endif /* CONFIG_DEV_PAGEMAP_OPS */ + +/** + * unpin_user_page() - release a dma-pinned page + * @page: pointer to page to be released + * + * Pages that were pinned via pin_user_pages*() must be released via eithe= r + * unpin_user_page(), or one of the unpin_user_pages*() routines. This is = so + * that such pages can be separately tracked and uniquely handled. In + * particular, interactions with RDMA and filesystems need special handlin= g. + */ +void unpin_user_page(struct page *page) +{ + page =3D compound_head(page); + + /* + * For devmap managed pages we need to catch refcount transition from + * GUP_PIN_COUNTING_BIAS to 1, when refcount reach one it means the + * page is free and we need to inform the device driver through + * callback. See include/linux/memremap.h and HMM for details. + */ + if (__unpin_devmap_managed_user_page(page)) + return; + + if (page_ref_sub_and_test(page, GUP_PIN_COUNTING_BIAS)) + __put_page(page); + + __update_proc_vmstat(page, NR_FOLL_PIN_RETURNED, 1); +} +EXPORT_SYMBOL(unpin_user_page); + /** * unpin_user_pages_dirty_lock() - release and optionally dirty gup-pinned= pages * @pages: array of pages to be maybe marked dirty, and definitely releas= ed. @@ -237,10 +383,11 @@ static struct page *follow_page_pte(struct vm_area_st= ruct *vma, } =20 page =3D vm_normal_page(vma, address, pte); - if (!page && pte_devmap(pte) && (flags & FOLL_GET)) { + if (!page && pte_devmap(pte) && (flags & (FOLL_GET | FOLL_PIN))) { /* - * Only return device mapping pages in the FOLL_GET case since - * they are only valid while holding the pgmap reference. + * Only return device mapping pages in the FOLL_GET or FOLL_PIN + * case since they are only valid while holding the pgmap + * reference. */ *pgmap =3D get_dev_pagemap(pte_pfn(pte), *pgmap); if (*pgmap) @@ -278,11 +425,23 @@ static struct page *follow_page_pte(struct vm_area_st= ruct *vma, goto retry; } =20 - if (flags & FOLL_GET) { + if (flags & (FOLL_PIN | FOLL_GET)) { + /* + * Allow try_get_page() to take care of error handling, for + * both cases: FOLL_GET or FOLL_PIN: + */ if (unlikely(!try_get_page(page))) { page =3D ERR_PTR(-ENOMEM); goto out; } + + if (flags & FOLL_PIN) { + WARN_ON_ONCE(flags & FOLL_GET); + + /* We got a +1 refcount from try_get_page(), above. */ + page_ref_add(page, GUP_PIN_COUNTING_BIAS - 1); + __update_proc_vmstat(page, NR_FOLL_PIN_REQUESTED, 1); + } } if (flags & FOLL_TOUCH) { if ((flags & FOLL_WRITE) && @@ -544,8 +703,8 @@ static struct page *follow_page_mask(struct vm_area_str= uct *vma, /* make this handle hugepd */ page =3D follow_huge_addr(mm, address, flags & FOLL_WRITE); if (!IS_ERR(page)) { - BUG_ON(flags & FOLL_GET); - return page; + WARN_ON_ONCE(flags & (FOLL_GET | FOLL_PIN)); + return NULL; } =20 pgd =3D pgd_offset(mm, address); @@ -1131,6 +1290,36 @@ static __always_inline long __get_user_pages_locked(= struct task_struct *tsk, return pages_done; } =20 +static long __get_user_pages_remote(struct task_struct *tsk, + struct mm_struct *mm, + unsigned long start, unsigned long nr_pages, + unsigned int gup_flags, struct page **pages, + struct vm_area_struct **vmas, int *locked) +{ + /* + * Parts of FOLL_LONGTERM behavior are incompatible with + * FAULT_FLAG_ALLOW_RETRY because of the FS DAX check requirement on + * vmas. However, this only comes up if locked is set, and there are + * callers that do request FOLL_LONGTERM, but do not set locked. So, + * allow what we can. + */ + if (gup_flags & FOLL_LONGTERM) { + if (WARN_ON_ONCE(locked)) + return -EINVAL; + /* + * This will check the vmas (even if our vmas arg is NULL) + * and return -ENOTSUPP if DAX isn't allowed in this case: + */ + return __gup_longterm_locked(tsk, mm, start, nr_pages, pages, + vmas, gup_flags | FOLL_TOUCH | + FOLL_REMOTE); + } + + return __get_user_pages_locked(tsk, mm, start, nr_pages, pages, vmas, + locked, + gup_flags | FOLL_TOUCH | FOLL_REMOTE); +} + /* * get_user_pages_remote() - pin user pages in memory * @tsk: the task_struct to use for page fault accounting, or @@ -1205,28 +1394,8 @@ long get_user_pages_remote(struct task_struct *tsk, = struct mm_struct *mm, if (WARN_ON_ONCE(gup_flags & FOLL_PIN)) return -EINVAL; =20 - /* - * Parts of FOLL_LONGTERM behavior are incompatible with - * FAULT_FLAG_ALLOW_RETRY because of the FS DAX check requirement on - * vmas. However, this only comes up if locked is set, and there are - * callers that do request FOLL_LONGTERM, but do not set locked. So, - * allow what we can. - */ - if (gup_flags & FOLL_LONGTERM) { - if (WARN_ON_ONCE(locked)) - return -EINVAL; - /* - * This will check the vmas (even if our vmas arg is NULL) - * and return -ENOTSUPP if DAX isn't allowed in this case: - */ - return __gup_longterm_locked(tsk, mm, start, nr_pages, pages, - vmas, gup_flags | FOLL_TOUCH | - FOLL_REMOTE); - } - - return __get_user_pages_locked(tsk, mm, start, nr_pages, pages, vmas, - locked, - gup_flags | FOLL_TOUCH | FOLL_REMOTE); + return __get_user_pages_remote(tsk, mm, start, nr_pages, gup_flags, + pages, vmas, locked); } EXPORT_SYMBOL(get_user_pages_remote); =20 @@ -1421,10 +1590,11 @@ static long __get_user_pages_locked(struct task_str= uct *tsk, return i ? : -EFAULT; } =20 -long get_user_pages_remote(struct task_struct *tsk, struct mm_struct *mm, - unsigned long start, unsigned long nr_pages, - unsigned int gup_flags, struct page **pages, - struct vm_area_struct **vmas, int *locked) +static long __get_user_pages_remote(struct task_struct *tsk, + struct mm_struct *mm, + unsigned long start, unsigned long nr_pages, + unsigned int gup_flags, struct page **pages, + struct vm_area_struct **vmas, int *locked) { return 0; } @@ -1864,13 +2034,17 @@ static inline pte_t gup_get_pte(pte_t *ptep) #endif /* CONFIG_GUP_GET_PTE_LOW_HIGH */ =20 static void __maybe_unused undo_dev_pagemap(int *nr, int nr_start, + unsigned int flags, struct page **pages) { while ((*nr) - nr_start) { struct page *page =3D pages[--(*nr)]; =20 ClearPageReferenced(page); - put_page(page); + if (flags & FOLL_PIN) + unpin_user_page(page); + else + put_page(page); } } =20 @@ -1903,7 +2077,7 @@ static int gup_pte_range(pmd_t pmd, unsigned long add= r, unsigned long end, =20 pgmap =3D get_dev_pagemap(pte_pfn(pte), pgmap); if (unlikely(!pgmap)) { - undo_dev_pagemap(nr, nr_start, pages); + undo_dev_pagemap(nr, nr_start, flags, pages); goto pte_unmap; } } else if (pte_special(pte)) @@ -1912,7 +2086,7 @@ static int gup_pte_range(pmd_t pmd, unsigned long add= r, unsigned long end, VM_BUG_ON(!pfn_valid(pte_pfn(pte))); page =3D pte_page(pte); =20 - head =3D try_get_compound_head(page, 1); + head =3D try_grab_compound_head(page, 1, flags); if (!head) goto pte_unmap; =20 @@ -1968,12 +2142,12 @@ static int __gup_device_huge(unsigned long pfn, uns= igned long addr, =20 pgmap =3D get_dev_pagemap(pfn, pgmap); if (unlikely(!pgmap)) { - undo_dev_pagemap(nr, nr_start, pages); + undo_dev_pagemap(nr, nr_start, flags, pages); return 0; } SetPageReferenced(page); pages[*nr] =3D page; - get_page(page); + grab_page(page, flags); (*nr)++; pfn++; } while (addr +=3D PAGE_SIZE, addr !=3D end); @@ -1995,7 +2169,7 @@ static int __gup_device_huge_pmd(pmd_t orig, pmd_t *p= mdp, unsigned long addr, return 0; =20 if (unlikely(pmd_val(orig) !=3D pmd_val(*pmdp))) { - undo_dev_pagemap(nr, nr_start, pages); + undo_dev_pagemap(nr, nr_start, flags, pages); return 0; } return 1; @@ -2013,7 +2187,7 @@ static int __gup_device_huge_pud(pud_t orig, pud_t *p= udp, unsigned long addr, return 0; =20 if (unlikely(pud_val(orig) !=3D pud_val(*pudp))) { - undo_dev_pagemap(nr, nr_start, pages); + undo_dev_pagemap(nr, nr_start, flags, pages); return 0; } return 1; @@ -2047,8 +2221,11 @@ static int record_subpages(struct page *page, unsign= ed long addr, return nr; } =20 -static void put_compound_head(struct page *page, int refs) +static void put_compound_head(struct page *page, int refs, unsigned int fl= ags) { + if (flags & FOLL_PIN) + refs *=3D GUP_PIN_COUNTING_BIAS; + /* Do a get_page() first, in case refs =3D=3D page->_refcount */ get_page(page); page_ref_sub(page, refs); @@ -2088,12 +2265,12 @@ static int gup_hugepte(pte_t *ptep, unsigned long s= z, unsigned long addr, page =3D head + ((addr & (sz-1)) >> PAGE_SHIFT); refs =3D record_subpages(page, addr, end, pages + *nr); =20 - head =3D try_get_compound_head(head, refs); + head =3D try_grab_compound_head(head, refs, flags); if (!head) return 0; =20 if (unlikely(pte_val(pte) !=3D pte_val(*ptep))) { - put_compound_head(head, refs); + put_compound_head(head, refs, flags); return 0; } =20 @@ -2148,12 +2325,12 @@ static int gup_huge_pmd(pmd_t orig, pmd_t *pmdp, un= signed long addr, page =3D pmd_page(orig) + ((addr & ~PMD_MASK) >> PAGE_SHIFT); refs =3D record_subpages(page, addr, end, pages + *nr); =20 - head =3D try_get_compound_head(pmd_page(orig), refs); + head =3D try_grab_compound_head(pmd_page(orig), refs, flags); if (!head) return 0; =20 if (unlikely(pmd_val(orig) !=3D pmd_val(*pmdp))) { - put_compound_head(head, refs); + put_compound_head(head, refs, flags); return 0; } =20 @@ -2182,12 +2359,12 @@ static int gup_huge_pud(pud_t orig, pud_t *pudp, un= signed long addr, page =3D pud_page(orig) + ((addr & ~PUD_MASK) >> PAGE_SHIFT); refs =3D record_subpages(page, addr, end, pages + *nr); =20 - head =3D try_get_compound_head(pud_page(orig), refs); + head =3D try_grab_compound_head(pud_page(orig), refs, flags); if (!head) return 0; =20 if (unlikely(pud_val(orig) !=3D pud_val(*pudp))) { - put_compound_head(head, refs); + put_compound_head(head, refs, flags); return 0; } =20 @@ -2211,12 +2388,12 @@ static int gup_huge_pgd(pgd_t orig, pgd_t *pgdp, un= signed long addr, page =3D pgd_page(orig) + ((addr & ~PGDIR_MASK) >> PAGE_SHIFT); refs =3D record_subpages(page, addr, end, pages + *nr); =20 - head =3D try_get_compound_head(pgd_page(orig), refs); + head =3D try_grab_compound_head(pgd_page(orig), refs, flags); if (!head) return 0; =20 if (unlikely(pgd_val(orig) !=3D pgd_val(*pgdp))) { - put_compound_head(head, refs); + put_compound_head(head, refs, flags); return 0; } =20 @@ -2517,9 +2694,12 @@ EXPORT_SYMBOL_GPL(get_user_pages_fast); /** * pin_user_pages_fast() - pin user pages in memory without taking locks * - * For now, this is a placeholder function, until various call sites are - * converted to use the correct get_user_pages*() or pin_user_pages*() API= . So, - * this is identical to get_user_pages_fast(). + * Nearly the same as get_user_pages_fast(), except that FOLL_PIN is set. = See + * get_user_pages_fast() for documentation on the function arguments, beca= use + * the arguments here are identical. + * + * FOLL_PIN means that the pages must be released via unpin_user_page(). P= lease + * see Documentation/vm/pin_user_pages.rst for further details. * * This is intended for Case 1 (DIO) in Documentation/vm/pin_user_pages.rs= t. It * is NOT intended for Case 2 (RDMA: long-term pins). @@ -2527,21 +2707,24 @@ EXPORT_SYMBOL_GPL(get_user_pages_fast); int pin_user_pages_fast(unsigned long start, int nr_pages, unsigned int gup_flags, struct page **pages) { - /* - * This is a placeholder, until the pin functionality is activated. - * Until then, just behave like the corresponding get_user_pages*() - * routine. - */ - return get_user_pages_fast(start, nr_pages, gup_flags, pages); + /* FOLL_GET and FOLL_PIN are mutually exclusive. */ + if (WARN_ON_ONCE(gup_flags & FOLL_GET)) + return -EINVAL; + + gup_flags |=3D FOLL_PIN; + return internal_get_user_pages_fast(start, nr_pages, gup_flags, pages); } EXPORT_SYMBOL_GPL(pin_user_pages_fast); =20 /** * pin_user_pages_remote() - pin pages of a remote process (task !=3D curr= ent) * - * For now, this is a placeholder function, until various call sites are - * converted to use the correct get_user_pages*() or pin_user_pages*() API= . So, - * this is identical to get_user_pages_remote(). + * Nearly the same as get_user_pages_remote(), except that FOLL_PIN is set= . See + * get_user_pages_remote() for documentation on the function arguments, be= cause + * the arguments here are identical. + * + * FOLL_PIN means that the pages must be released via unpin_user_page(). P= lease + * see Documentation/vm/pin_user_pages.rst for details. * * This is intended for Case 1 (DIO) in Documentation/vm/pin_user_pages.rs= t. It * is NOT intended for Case 2 (RDMA: long-term pins). @@ -2551,22 +2734,24 @@ long pin_user_pages_remote(struct task_struct *tsk,= struct mm_struct *mm, unsigned int gup_flags, struct page **pages, struct vm_area_struct **vmas, int *locked) { - /* - * This is a placeholder, until the pin functionality is activated. - * Until then, just behave like the corresponding get_user_pages*() - * routine. - */ - return get_user_pages_remote(tsk, mm, start, nr_pages, gup_flags, pages, - vmas, locked); + /* FOLL_GET and FOLL_PIN are mutually exclusive. */ + if (WARN_ON_ONCE(gup_flags & FOLL_GET)) + return -EINVAL; + + gup_flags |=3D FOLL_PIN; + return __get_user_pages_remote(tsk, mm, start, nr_pages, gup_flags, + pages, vmas, locked); } EXPORT_SYMBOL(pin_user_pages_remote); =20 /** * pin_user_pages() - pin user pages in memory for use by other devices * - * For now, this is a placeholder function, until various call sites are - * converted to use the correct get_user_pages*() or pin_user_pages*() API= . So, - * this is identical to get_user_pages(). + * Nearly the same as get_user_pages(), except that FOLL_TOUCH is not set,= and + * FOLL_PIN is set. + * + * FOLL_PIN means that the pages must be released via unpin_user_page(). P= lease + * see Documentation/vm/pin_user_pages.rst for details. * * This is intended for Case 1 (DIO) in Documentation/vm/pin_user_pages.rs= t. It * is NOT intended for Case 2 (RDMA: long-term pins). @@ -2575,11 +2760,12 @@ long pin_user_pages(unsigned long start, unsigned l= ong nr_pages, unsigned int gup_flags, struct page **pages, struct vm_area_struct **vmas) { - /* - * This is a placeholder, until the pin functionality is activated. - * Until then, just behave like the corresponding get_user_pages*() - * routine. - */ - return get_user_pages(start, nr_pages, gup_flags, pages, vmas); + /* FOLL_GET and FOLL_PIN are mutually exclusive. */ + if (WARN_ON_ONCE(gup_flags & FOLL_GET)) + return -EINVAL; + + gup_flags |=3D FOLL_PIN; + return __gup_longterm_locked(current, current->mm, start, nr_pages, + pages, vmas, gup_flags); } EXPORT_SYMBOL(pin_user_pages); diff --git a/mm/huge_memory.c b/mm/huge_memory.c index 41a0fbddc96b..4e04a6aee8a6 100644 --- a/mm/huge_memory.c +++ b/mm/huge_memory.c @@ -945,6 +945,11 @@ struct page *follow_devmap_pmd(struct vm_area_struct *= vma, unsigned long addr, */ WARN_ONCE(flags & FOLL_COW, "mm: In follow_devmap_pmd with FOLL_COW set")= ; =20 + /* FOLL_GET and FOLL_PIN are mutually exclusive. */ + if (WARN_ON_ONCE((flags & (FOLL_PIN | FOLL_GET)) =3D=3D + (FOLL_PIN | FOLL_GET))) + return NULL; + if (flags & FOLL_WRITE && !pmd_write(*pmd)) return NULL; =20 @@ -960,7 +965,7 @@ struct page *follow_devmap_pmd(struct vm_area_struct *v= ma, unsigned long addr, * device mapped pages can only be returned if the * caller will manage the page reference count. */ - if (!(flags & FOLL_GET)) + if (!(flags & (FOLL_GET | FOLL_PIN))) return ERR_PTR(-EEXIST); =20 pfn +=3D (addr & ~PMD_MASK) >> PAGE_SHIFT; @@ -968,7 +973,7 @@ struct page *follow_devmap_pmd(struct vm_area_struct *v= ma, unsigned long addr, if (!*pgmap) return ERR_PTR(-EFAULT); page =3D pfn_to_page(pfn); - get_page(page); + grab_page(page, flags); =20 return page; } @@ -1088,6 +1093,11 @@ struct page *follow_devmap_pud(struct vm_area_struct= *vma, unsigned long addr, if (flags & FOLL_WRITE && !pud_write(*pud)) return NULL; =20 + /* FOLL_GET and FOLL_PIN are mutually exclusive. */ + if (WARN_ON_ONCE((flags & (FOLL_PIN | FOLL_GET)) =3D=3D + (FOLL_PIN | FOLL_GET))) + return NULL; + if (pud_present(*pud) && pud_devmap(*pud)) /* pass */; else @@ -1099,8 +1109,10 @@ struct page *follow_devmap_pud(struct vm_area_struct= *vma, unsigned long addr, /* * device mapped pages can only be returned if the * caller will manage the page reference count. + * + * At least one of FOLL_GET | FOLL_PIN must be set, so assert that here: */ - if (!(flags & FOLL_GET)) + if (!(flags & (FOLL_GET | FOLL_PIN))) return ERR_PTR(-EEXIST); =20 pfn +=3D (addr & ~PUD_MASK) >> PAGE_SHIFT; @@ -1108,7 +1120,7 @@ struct page *follow_devmap_pud(struct vm_area_struct = *vma, unsigned long addr, if (!*pgmap) return ERR_PTR(-EFAULT); page =3D pfn_to_page(pfn); - get_page(page); + grab_page(page, flags); =20 return page; } @@ -1522,8 +1534,7 @@ struct page *follow_trans_huge_pmd(struct vm_area_str= uct *vma, skip_mlock: page +=3D (addr & ~HPAGE_PMD_MASK) >> PAGE_SHIFT; VM_BUG_ON_PAGE(!PageCompound(page) && !is_zone_device_page(page), page); - if (flags & FOLL_GET) - get_page(page); + grab_page(page, flags); =20 out: return page; diff --git a/mm/hugetlb.c b/mm/hugetlb.c index ac65bb5e38ac..84844ec4ac8b 100644 --- a/mm/hugetlb.c +++ b/mm/hugetlb.c @@ -4356,7 +4356,7 @@ long follow_hugetlb_page(struct mm_struct *mm, struct= vm_area_struct *vma, same_page: if (pages) { pages[i] =3D mem_map_offset(page, pfn_offset); - get_page(pages[i]); + grab_page(pages[i], flags); } =20 if (vmas) @@ -4916,6 +4916,12 @@ follow_huge_pmd(struct mm_struct *mm, unsigned long = address, struct page *page =3D NULL; spinlock_t *ptl; pte_t pte; + + /* FOLL_GET and FOLL_PIN are mutually exclusive. */ + if (WARN_ON_ONCE((flags & (FOLL_PIN | FOLL_GET)) =3D=3D + (FOLL_PIN | FOLL_GET))) + return NULL; + retry: ptl =3D pmd_lockptr(mm, pmd); spin_lock(ptl); @@ -4928,8 +4934,7 @@ follow_huge_pmd(struct mm_struct *mm, unsigned long a= ddress, pte =3D huge_ptep_get((pte_t *)pmd); if (pte_present(pte)) { page =3D pmd_page(*pmd) + ((address & ~PMD_MASK) >> PAGE_SHIFT); - if (flags & FOLL_GET) - get_page(page); + grab_page(page, flags); } else { if (is_hugetlb_entry_migration(pte)) { spin_unlock(ptl); @@ -4950,7 +4955,7 @@ struct page * __weak follow_huge_pud(struct mm_struct *mm, unsigned long address, pud_t *pud, int flags) { - if (flags & FOLL_GET) + if (flags & (FOLL_GET | FOLL_PIN)) return NULL; =20 return pte_page(*(pte_t *)pud) + ((address & ~PUD_MASK) >> PAGE_SHIFT); @@ -4959,7 +4964,7 @@ follow_huge_pud(struct mm_struct *mm, unsigned long a= ddress, struct page * __weak follow_huge_pgd(struct mm_struct *mm, unsigned long address, pgd_t *pgd, i= nt flags) { - if (flags & FOLL_GET) + if (flags & (FOLL_GET | FOLL_PIN)) return NULL; =20 return pte_page(*(pte_t *)pgd) + ((address & ~PGDIR_MASK) >> PAGE_SHIFT); diff --git a/mm/vmstat.c b/mm/vmstat.c index 78d53378db99..b56808bae1b4 100644 --- a/mm/vmstat.c +++ b/mm/vmstat.c @@ -1168,6 +1168,8 @@ const char * const vmstat_text[] =3D { "nr_dirtied", "nr_written", "nr_kernel_misc_reclaimable", + "nr_foll_pin_requested", + "nr_foll_pin_returned", =20 /* enum writeback_stat_item counters */ "nr_dirty_threshold", --=20 2.24.0