From: "Lorenzo Stoakes (ARM)" <ljs@kernel.org>
To: Rik van Riel <riel@surriel.com>
Cc: linux-kernel@vger.kernel.org, linux-mm@kvack.org,
David Hildenbrand <david@kernel.org>,
Andrew Morton <akpm@linux-foundation.org>,
Suren Baghdasaryan <surenb@google.com>,
Christoph Hellwig <hch@infradead.org>,
Yuan-Hao Hsu <aa9736195201@gmail.com>,
John Hubbard <jhubbard@nvidia.com>,
Jason Gunthorpe <jgg@ziepe.ca>, Peter Xu <peterx@redhat.com>
Subject: Re: [PATCH v5 5/8] mm/gup: break out gup_lookup_pte() helper
Date: Tue, 17 Nov 2026 13:48:19 +0000 [thread overview]
Message-ID: <avxXgTBaJkPN6XOh@gremlin> (raw)
In-Reply-To: <20261116210127.3837898-6-riel@surriel.com>
On Mon, Nov 16, 2026 at 04:01:24PM -0500, Rik van Riel wrote:
> follow_page_pte() is 92 lines and does two separate things: work out
> which page a PTE maps, if any, and commit to the page it found. The
> first half reaches the second through five exit paths, two of which
> unwind the PTE lock in different ways.
>
> Split the resolve half into gup_lookup_pte(), which returns the page it
> resolved, NULL when the PTE cannot be followed, or the errno the caller
> must report. follow_page_pte() is left with one unlock and one exit.
>
> no_page_table() can look up the page cache, so the case that needs it is
> recorded and the call made after dropping the PTE lock, as before.
>
> A none PTE still returns before any write check runs, so a FOLL_WRITE
> failure can never reach the recorded call: the caller consults
> no_page_table() for exactly the same PTEs the old code did.
>
> No functional changes intended.
>
> Suggested-by: David Hildenbrand <david@kernel.org>
> Signed-off-by: Rik van Riel <riel@surriel.com>
> ---
> mm/gup.c | 100 +++++++++++++++++++++++++++++++------------------------
> 1 file changed, 56 insertions(+), 44 deletions(-)
>
> diff --git a/mm/gup.c b/mm/gup.c
> index efb2ad64be80..3aed0bc1c2b4 100644
> --- a/mm/gup.c
> +++ b/mm/gup.c
> @@ -965,74 +965,86 @@ static long gup_grab_fill_folio_pages(struct folio *folio,
> return 0;
> }
>
> -static long follow_page_pte(struct vm_area_struct *vma,
> - unsigned long address, pmd_t *pmd, unsigned int flags,
> - struct page **pages)
> +/*
> + * Resolve one present PTE to the page it maps. Returns no page and no error
> + * when the PTE cannot be followed but the caller may fault it in, and a
> + * negative errno when the caller must report the failure.
> + */
> +static long gup_lookup_pte(struct vm_area_struct *vma, unsigned long address,
> + pte_t *ptep, pte_t pte, unsigned int flags, struct page **pagep)
> {
> - struct mm_struct *mm = vma->vm_mm;
> - struct folio *folio;
> struct page *page;
> - spinlock_t *ptl;
> - pte_t *ptep, pte;
> - long ret;
>
> - ptep = pte_offset_map_lock(mm, pmd, address, &ptl);
> - if (!ptep)
> - return no_page_table(vma, flags, address);
> - pte = ptep_get(ptep);
> + *pagep = NULL;
> +
> if (!pte_present(pte))
> - goto no_page;
> + return 0;
> if (pte_protnone(pte) && !gup_can_follow_protnone(vma, flags))
> - goto no_page;
> + return 0;
>
> page = vm_normal_page(vma, address, pte);
>
> /*
> * We only care about anon pages in can_follow_write_pte().
> */
> - if ((flags & FOLL_WRITE) &&
> - !can_follow_write_pte(pte, page, vma, flags)) {
> - ret = 0;
> - goto out;
> - }
> + if ((flags & FOLL_WRITE) && !can_follow_write_pte(pte, page, vma, flags))
> + return 0;
>
> if (unlikely(!page)) {
> if (flags & FOLL_DUMP) {
> /* Avoid special (like zero) pages in core dumps */
> - ret = -EFAULT;
> - goto out;
> - }
> -
> - if (is_zero_pfn(pte_pfn(pte))) {
> - page = pte_page(pte);
> - } else {
> - ret = follow_pfn_pte(vma, address, ptep, flags);
> - goto out;
> + return -EFAULT;
> }
> + if (!is_zero_pfn(pte_pfn(pte)))
> + return follow_pfn_pte(vma, address, ptep, flags);
> + page = pte_page(pte);
> }
> - folio = page_folio(page);
>
> - if (!pte_write(pte) && gup_must_unshare(vma, flags, folio, page)) {
> - ret = -EMLINK;
> - goto out;
> - }
> + if (!pte_write(pte) &&
> + gup_must_unshare(vma, flags, page_folio(page), page))
> + return -EMLINK;
>
> VM_WARN_ON_ONCE_PAGE((flags & FOLL_PIN) && PageAnon(page) &&
> !PageAnonExclusive(page), page);
>
> - ret = gup_grab_fill_folio_pages(folio, page, 1,
> - pte_dirty(pte), flags, pages);
> - if (ret)
> - goto out;
> - ret = 1;
> -out:
> + *pagep = page;
> + return 0;
> +}
> +
> +static long follow_page_pte(struct vm_area_struct *vma,
> + unsigned long address, pmd_t *pmd, unsigned int flags,
> + struct page **pages)
> +{
> + struct mm_struct *mm = vma->vm_mm;
> + bool need_no_page_table = false;
> + struct page *page;
> + spinlock_t *ptl;
> + pte_t *ptep, pte;
> + long ret;
> +
> + ptep = pte_offset_map_lock(mm, pmd, address, &ptl);
> + if (!ptep)
OK so this is what happens if there's no PMD entry. Maybe worth a comment?
Especially if you have special handling for the PTE PTL being held below.
> + return no_page_table(vma, flags, address);
> + pte = ptep_get(ptep);
> +
> + ret = gup_lookup_pte(vma, address, ptep, pte, flags, &page);
> + if (!ret && page) {
> + ret = gup_grab_fill_folio_pages(page_folio(page), page,
> + 1, pte_dirty(pte), flags, pages);
> + if (!ret)
> + ret = 1;
> + } else if (!ret && pte_none(pte)) {
> + /*
> + * no_page_table() may look up the page cache, so it cannot run
> + * under the PTE lock. A none PTE returns from gup_lookup_pte()
> + * before any write check runs, so this is the same call the old
> + * code made -- not a new failure mode for FOLL_WRITE.
> + */
This feels -- a little -- schloppy ;)
Why are you referencing 'the old code' in a permanent comment for which what
'the old code' means is super unclear?
That's really just not helpful.
'A none PTE returns from gup_lookup_pte() before any write check runs' also
reads weirdly.
I'm also not sure why you're sending a pte_none() PTE to gup_lookup_pte()
anyway + checking for the error again?
if (pte_none(ptep)) {
... whatever ...
goto blah;
}
It seems silly otherwise.
Also isn't the page cache thing _only_ for hugetlbfs, unless you changed
that? And aren't a number of other callers of no_page_table() also broken?
But in general the comment could be made much clearer:
/*
* If a hugetlb VMA it might access the page cache in no_page_table(),
* which cannot be done under the PTL, so defer until it's dropped.
*/
Or whatever, something human-written like that :)
> + need_no_page_table = true;
This is set true but not used anywhere? This is dead code no? Am I missing
something?
Patches should be incremental but adding completely useless locals incrementally
seems silly?
> + }
> +
> pte_unmap_unlock(ptep, ptl);
> return ret;
I'm guessing you forgot to include the code that works with
need_no_page_table here?
Should it have been:
if (!ret && need_no_page_table)
return no_page_table(vma, flags, address);
Perhaps?
I'm not sure any of this is really a cleanup, I'm finding this quite
confusing, actually...
'need_no_page_table' isn't a great name either. Maybe is_none or something?
> -no_page:
> - pte_unmap_unlock(ptep, ptl);
> - if (!pte_none(pte))
> - return 0;
> - return no_page_table(vma, flags, address);
> }
>
> static long follow_pmd_mask(struct vm_area_struct *vma,
> --
> 2.56.0
>
--
Cheers, Lorenzo
next prev parent reply other threads:[~2026-11-17 13:48 UTC|newest]
Thread overview: 11+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-16 21:01 [PATCH v5 0/8] mm/gup: walk and batch whole PTE tables in slow GUP Rik van Riel
2026-11-16 21:01 ` [PATCH v5 1/8] mm/gup: break out gup_fill_pages() helper Rik van Riel
2026-11-16 21:01 ` [PATCH v5 2/8] mm/gup: break out gup_flush_pages() helper Rik van Riel
2026-11-16 21:01 ` [PATCH v5 3/8] mm/gup: convert follow_page_mask() to return a long Rik van Riel
2026-11-16 21:01 ` [PATCH v5 4/8] mm/gup: split out folio grab-and-store helper Rik van Riel
2026-11-16 21:01 ` [PATCH v5 5/8] mm/gup: break out gup_lookup_pte() helper Rik van Riel
2026-11-17 13:48 ` Lorenzo Stoakes (ARM) [this message]
2026-11-16 21:01 ` [PATCH v5 6/8] mm/gup: return a huge page's full count from follow_page_mask() Rik van Riel
2026-11-16 21:01 ` [PATCH v5 7/8] mm/gup: walk multiple PTEs per follow_page_pte() call Rik van Riel
2026-11-16 21:01 ` [PATCH v5 8/8] mm/gup: batch contiguous same-folio PTEs into one refcount grab Rik van Riel
2026-11-17 13:30 ` [PATCH v5 0/8] mm/gup: walk and batch whole PTE tables in slow GUP Lorenzo Stoakes (ARM)
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=avxXgTBaJkPN6XOh@gremlin \
--to=ljs@kernel.org \
--cc=aa9736195201@gmail.com \
--cc=akpm@linux-foundation.org \
--cc=david@kernel.org \
--cc=hch@infradead.org \
--cc=jgg@ziepe.ca \
--cc=jhubbard@nvidia.com \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-mm@kvack.org \
--cc=peterx@redhat.com \
--cc=riel@surriel.com \
--cc=surenb@google.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®