All of lore.kernel.org
 help / color / mirror / Atom feed
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


  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 an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.