linux-kernel - Re: [PATCH v2] mm/shmem, swap: fix race of truncate and swap entry split

lists.openwall.net		lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC
Open Source and information security mailing list archives
Hash Suite: Windows password security audit tool. GUI, reports in PDF.
[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]
Message-ID: <74fd3fd1-97d0-46a3-b76e-435808efff02@linux.alibaba.com>
Date: Mon, 19 Jan 2026 11:04:02 +0800
From: Baolin Wang <baolin.wang@...ux.alibaba.com>
To: Kairui Song <ryncsn@...il.com>, linux-mm@...ck.org
Cc: Hugh Dickins <hughd@...gle.com>, Andrew Morton
 <akpm@...ux-foundation.org>, Kemeng Shi <shikemeng@...weicloud.com>,
 Nhat Pham <nphamcs@...il.com>, Chris Li <chrisl@...nel.org>,
 Baoquan He <bhe@...hat.com>, Barry Song <baohua@...nel.org>,
 linux-kernel@...r.kernel.org, Kairui Song <kasong@...cent.com>,
 stable@...r.kernel.org
Subject: Re: [PATCH v2] mm/shmem, swap: fix race of truncate and swap entry
 split



On 1/19/26 12:55 AM, Kairui Song wrote:
> From: Kairui Song <kasong@...cent.com>
> 
> The helper for shmem swap freeing is not handling the order of swap
> entries correctly. It uses xa_cmpxchg_irq to erase the swap entry, but
> it gets the entry order before that using xa_get_order without lock
> protection, and it may get an outdated order value if the entry is split
> or changed in other ways after the xa_get_order and before the
> xa_cmpxchg_irq.
> 
> And besides, the order could grow and be larger than expected, and cause
> truncation to erase data beyond the end border. For example, if the
> target entry and following entries are swapped in or freed, then a large
> folio was added in place and swapped out, using the same entry, the
> xa_cmpxchg_irq will still succeed, it's very unlikely to happen though.
> 
> To fix that, open code the Xarray cmpxchg and put the order retrieval
> and value checking in the same critical section. Also, ensure the order
> won't exceed the end border, skip it if the entry goes across the
> border.
> 
> Skipping large swap entries crosses the end border is safe here.
> Shmem truncate iterates the range twice, in the first iteration,
> find_lock_entries already filtered such entries, and shmem will
> swapin the entries that cross the end border and partially truncate the
> folio (split the folio or at least zero part of it). So in the second
> loop here, if we see a swap entry that crosses the end order, it must
> at least have its content erased already.
> 
> I observed random swapoff hangs and kernel panics when stress testing
> ZSWAP with shmem. After applying this patch, all problems are gone.
> 
> Fixes: 809bc86517cc ("mm: shmem: support large folio swap out")
> Cc: stable@...r.kernel.org
> Signed-off-by: Kairui Song <kasong@...cent.com>
> ---
> Changes in v2:
> - Fix a potential retry loop issue and improvement to code style thanks
>    to Baoling Wang. I didn't split the change into two patches because a
>    separate patch doesn't stand well as a fix.
> - Link to v1: https://lore.kernel.org/r/20260112-shmem-swap-fix-v1-1-0f347f4f6952@tencent.com
> ---
>   mm/shmem.c | 45 ++++++++++++++++++++++++++++++++++-----------
>   1 file changed, 34 insertions(+), 11 deletions(-)
> 
> diff --git a/mm/shmem.c b/mm/shmem.c
> index 0b4c8c70d017..fadd5dd33d8b 100644
> --- a/mm/shmem.c
> +++ b/mm/shmem.c
> @@ -962,17 +962,29 @@ static void shmem_delete_from_page_cache(struct folio *folio, void *radswap)
>    * being freed).
>    */
>   static long shmem_free_swap(struct address_space *mapping,
> -			    pgoff_t index, void *radswap)
> +			    pgoff_t index, pgoff_t end, void *radswap)
>   {
> -	int order = xa_get_order(&mapping->i_pages, index);
> -	void *old;
> +	XA_STATE(xas, &mapping->i_pages, index);
> +	unsigned int nr_pages = 0;
> +	pgoff_t base;
> +	void *entry;
>   
> -	old = xa_cmpxchg_irq(&mapping->i_pages, index, radswap, NULL, 0);
> -	if (old != radswap)
> -		return 0;
> -	swap_put_entries_direct(radix_to_swp_entry(radswap), 1 << order);
> +	xas_lock_irq(&xas);
> +	entry = xas_load(&xas);
> +	if (entry == radswap) {
> +		nr_pages = 1 << xas_get_order(&xas);
> +		base = round_down(xas.xa_index, nr_pages);
> +		if (base < index || base + nr_pages - 1 > end)
> +			nr_pages = 0;
> +		else
> +			xas_store(&xas, NULL);
> +	}
> +	xas_unlock_irq(&xas);
> +
> +	if (nr_pages)
> +		swap_put_entries_direct(radix_to_swp_entry(radswap), nr_pages);
>   
> -	return 1 << order;
> +	return nr_pages;
>   }
>   
>   /*
> @@ -1124,8 +1136,8 @@ static void shmem_undo_range(struct inode *inode, loff_t lstart, uoff_t lend,
>   			if (xa_is_value(folio)) {
>   				if (unfalloc)
>   					continue;
> -				nr_swaps_freed += shmem_free_swap(mapping,
> -							indices[i], folio);
> +				nr_swaps_freed += shmem_free_swap(mapping, indices[i],
> +								  end - 1, folio);
>   				continue;
>   			}
>   
> @@ -1191,12 +1203,23 @@ static void shmem_undo_range(struct inode *inode, loff_t lstart, uoff_t lend,
>   			folio = fbatch.folios[i];
>   
>   			if (xa_is_value(folio)) {
> +				int order;
>   				long swaps_freed;
>   
>   				if (unfalloc)
>   					continue;
> -				swaps_freed = shmem_free_swap(mapping, indices[i], folio);
> +				swaps_freed = shmem_free_swap(mapping, indices[i],
> +							      end - 1, folio);
>   				if (!swaps_freed) {
> +					/*
> +					 * If found a large swap entry cross the end border,
> +					 * skip it as the truncate_inode_partial_folio above
> +					 * should have at least zerod its content once.
> +					 */
> +					order = shmem_confirm_swap(mapping, indices[i],
> +								   radix_to_swp_entry(folio));
> +					if (order > 0 && indices[i] + order > end)
> +						continue;

The latter check shoud be 'indices[i] + 1 << order > end', right?