Re: [PATCH v3] mm/migrate_device: consolidate compound folio handling

["David Hildenbrand (Arm)" <david@kernel.org>]

On 9/23/26 13:20, Hui Su wrote:
> Commit dc41e961a269 ("mm/migrate_device: avoid out-of-bounds writes for
> compound folios") added handling for compound folios that do not fit in
> the remaining PFN array.
> 
> migrate_device_range() and migrate_device_pfns() duplicate the logic for
> locking device PFNs, encoding compound folios, and handling this boundary
> condition.
> 
> A compound folio cannot be represented partially for migration. Use
> VM_WARN_ON_ONCE() when one does not fit in the remaining PFN array, while
> retaining the existing defensive handling: release any lock and reference
> acquired for the current folio, clear the remaining entries, and stop
> collecting.
> 
> Move the shared collection and encoding logic into a helper so both
> interfaces handle compound folios consistently. Also use memset() for the
> compound-folio tail entries instead of open-coding the clearing loop.
> 
> If locking a folio fails, leave its source entry zero while still consuming
> and clearing the slots belonging to the whole folio. This prevents a tail
> page from being treated as a new source PFN by the caller's next iteration.
> 
> Document that an encountered compound folio must fit entirely in the
> remaining range or PFN array.
> 
> Link: https://lore.kernel.org/r/c99ca53a-73ef-4a0c-8738-eba1cc89bea2@kernel.org
> Suggested-by: David Hildenbrand <david@kernel.org>
> Acked-by: Balbir Singh <balbirs@nvidia.com>
> Signed-off-by: Hui Su <sh_def@163.com>
> ---
> 
> Changes in v3:
> - Keep the source entry zero when migrate_device_pfn_lock() fails instead
>   of setting MIGRATE_PFN_COMPOUND, while still consuming and clearing all
>   slots belonging to the compound folio.
> - Use VM_WARN_ON_ONCE() for the truncated compound-folio invariant while
>   keeping the defensive clear-and-stop path independent of CONFIG_DEBUG_VM,
>   as suggested by Balbir Singh.
> 
> Changes in v2:
> - Fix the helper parameter indentation and keep the declaration to two
>   lines, as suggested by David Hildenbrand.
> 
>  mm/migrate_device.c | 91 +++++++++++++++++++++++++--------------------
>  1 file changed, 50 insertions(+), 41 deletions(-)
> 
> diff --git a/mm/migrate_device.c b/mm/migrate_device.c
> index 009bfa8b212d..68b787bdc8be 100644
> --- a/mm/migrate_device.c
> +++ b/mm/migrate_device.c
> @@ -1392,6 +1392,40 @@ static unsigned long migrate_device_pfn_lock(unsigned long pfn)
>  	return migrate_pfn(pfn) | MIGRATE_PFN_MIGRATE;
>  }
>  
> +/*
> + * Collect a device folio into the page-granular PFN array.
> + *
> + * Return the number of entries consumed, or 0 if the folio does not fit in
> + * the remaining array.
> + */
> +static unsigned int migrate_device_collect_folio(unsigned long *src_pfn,
> +		unsigned long pfn, unsigned long remaining)
> +{
> +	struct folio *folio = page_folio(pfn_to_page(pfn));
> +	unsigned int nr;
> +
> +	*src_pfn = migrate_device_pfn_lock(pfn);

Let's rant about migrate_device_pfn_lock().

It looks up a folio (which we do as well !?) to then get+lock that folio, but
doesn't tell us about the folio, but we're supposed to magically unlock and put
that folio on the backout path?.

And if it fails (e.g., folio_get_nontail_page() failed) we simply go ahead and
work on that folio (folio_nr_pages() etc)?

What?!

Now that we have a single caller of migrate_device_pfn_lock(), can we please get
rid of this abomination and figure out what to do when migrate_device_pfn_lock()
would have returned 0?


> +	nr = folio_nr_pages(folio);
> +
> +	VM_WARN_ON_ONCE(nr > remaining);
> +	if (nr > remaining) {

It's odd to add recovery paths for something that is mostly an internal
assertion. The pattern is odd.

I'd either

if (WARN_ON_ONCE(nr > remaining)) {
	...
}

Or only do the VM_WARN_ON_ONCE() and drop recovery, expecting this to be found
early during testing.


> +		if (*src_pfn & MIGRATE_PFN_MIGRATE) {
> +			folio_unlock(folio);
> +			folio_put(folio);
> +		}
> +		memset(src_pfn, 0, remaining * sizeof(*src_pfn));
> +		return 0;
> +	}
> +
> +	if (nr > 1) {
> +		if (*src_pfn)
> +			*src_pfn |= MIGRATE_PFN_COMPOUND;
> +		memset(src_pfn + 1, 0, (nr - 1) * sizeof(*src_pfn));
> +	}
> +
> +	return nr;
> +}

-- 
Cheers,

David