Re: [PATCH 2/2] mm: memfd_luo: always dirty all folios

[Mike Rapoport <rppt@kernel.org>]

On Mon, Feb 23, 2026 at 06:39:29PM +0100, Pratyush Yadav wrote:
> From: "Pratyush Yadav (Google)" <pratyush@kernel.org>
> 
> A dirty folio is one which has been written to. A clean folio is its
> opposite. Since a clean folio has no user data, it can be freed under
> memory pressure.
> 
> memfd preservation with LUO saves the flag at preserve(). This is
> problematic. The folio might get dirtied later. Saving it at freeze()
> also doesn't work, since the dirty bit from PTE is normally synced at
> unmap and there might still be mappings of the file at freeze().
> 
> To see why this is a problem, say a folio is clean at preserve, but gets
> dirtied later. The serialized state of the folio will mark it as clean.
> After retrieve, the next kernel will see the folio as clean and might
> try to reclaim it under memory pressure. This will result in losing user
> data.
> 
> Mark all folios of the file as dirty, and always set the
> MEMFD_LUO_FOLIO_DIRTY flag. This comes with the side effect of making
> all clean folios un-reclaimable. This is a cost that has to be paid for
> participants of live update. It is not expected to be a common use case
> to preserve a lot of clean folios anyway.
> 
> Since the value of pfolio->flags is a constant now, drop the flags
> variable and set it directly.
> 
> Fixes: b3749f174d68 ("mm: memfd_luo: allow preserving memfd")
> Cc: stable@vger.kernel.org
> Signed-off-by: Pratyush Yadav (Google) <pratyush@kernel.org>

Reviewed-by: Mike Rapoport (Microsoft) <rppt@kernel.org>

> ---
>  mm/memfd_luo.c | 26 +++++++++++++++++++++-----
>  1 file changed, 21 insertions(+), 5 deletions(-)
> 
> diff --git a/mm/memfd_luo.c b/mm/memfd_luo.c
> index ccbf1337f650..9eac02d06b5a 100644
> --- a/mm/memfd_luo.c
> +++ b/mm/memfd_luo.c
> @@ -146,7 +146,6 @@ static int memfd_luo_preserve_folios(struct file *file,
>  	for (i = 0; i < nr_folios; i++) {
>  		struct memfd_luo_folio_ser *pfolio = &folios_ser[i];
>  		struct folio *folio = folios[i];
> -		unsigned int flags = 0;
>  
>  		err = kho_preserve_folio(folio);
>  		if (err)
> @@ -154,8 +153,26 @@ static int memfd_luo_preserve_folios(struct file *file,
>  
>  		folio_lock(folio);
>  
> -		if (folio_test_dirty(folio))
> -			flags |= MEMFD_LUO_FOLIO_DIRTY;
> +		/*
> +		 * A dirty folio is one which has been written to. A clean folio
> +		 * is its opposite. Since a clean folio does not carry user
> +		 * data, it can be freed by page reclaim under memory pressure.
> +		 *
> +		 * Saving the dirty flag at prepare() time doesn't work since it
> +		 * can change later. Saving it at freeze() also won't work
> +		 * because the dirty bit is normally synced at unmap and there
> +		 * might still be a mapping of the file at freeze().
> +		 *
> +		 * To see why this is a problem, say a folio is clean at
> +		 * preserve, but gets dirtied later. The pfolio flags will mark
> +		 * it as clean. After retrieve, the next kernel might try to
> +		 * reclaim this folio under memory pressure, losing user data.
> +		 *
> +		 * Unconditionally mark it dirty to avoid this problem. This
> +		 * comes at the cost of making clean folios un-reclaimable after
> +		 * live update.
> +		 */

Can we make the comment here shorter to only contain the gist of the issue?

> +		folio_mark_dirty(folio);
>  
>  		/*
>  		 * If the folio is not uptodate, it was fallocated but never
> @@ -174,12 +191,11 @@ static int memfd_luo_preserve_folios(struct file *file,
>  			flush_dcache_folio(folio);
>  			folio_mark_uptodate(folio);
>  		}
> -		flags |= MEMFD_LUO_FOLIO_UPTODATE;
>  
>  		folio_unlock(folio);
>  
>  		pfolio->pfn = folio_pfn(folio);
> -		pfolio->flags = flags;
> +		pfolio->flags = MEMFD_LUO_FOLIO_DIRTY | MEMFD_LUO_FOLIO_UPTODATE;
>  		pfolio->index = folio->index;
>  	}
>  
> -- 
> 2.53.0.371.g1d285c8824-goog
> 

-- 
Sincerely yours,
Mike.