Re: [PATCH v3] mm/shmem, swap: fix race of truncate and swap entry split

[Chris Li <chrisl@kernel.org>]

On Mon, Jan 19, 2026 at 8:11 AM Kairui Song <ryncsn@gmail.com> wrote:
>
> From: Kairui Song <kasong@tencent.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@vger.kernel.org
> Signed-off-by: Kairui Song <kasong@tencent.com>

Acked-by: Chris Li <chrisl@kernel.org>

For the record the two stage retry loop in shmem_undo_range() is not
easy for me to follow. Thanks for the fix.

Chris

> ---
> Changes in v3:
> - Rebased on top of mainline.
> - Fix nr_pages calculation [ Baolin Wang ]
> - Link to v2: https://lore.kernel.org/r/20260119-shmem-swap-fix-v2-1-034c946fd393@tencent.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 ec6c01378e9d..6c3485d24d66 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;
> -       free_swap_and_cache_nr(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)
> +               free_swap_and_cache_nr(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] + (1 << order) > end)
> +                                               continue;
>                                         /* Swap was replaced by page: retry */
>                                         index = indices[i];
>                                         break;
>
> ---
> base-commit: 24d479d26b25bce5faea3ddd9fa8f3a6c3129ea7
> change-id: 20260111-shmem-swap-fix-8d0e20a14b5d
>
> Best regards,
> --
> Kairui Song <kasong@tencent.com>
>