Re: [PATCH v2 01/19] mm, swap: rename __read_swap_cache_async to swap_cache_alloc_folio

[Chris Li <chrisl@kernel.org>]

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

Chris

On Sun, Nov 16, 2025 at 10:12 AM Kairui Song <ryncsn@gmail.com> wrote:
>
> From: Kairui Song <kasong@tencent.com>
>
> __read_swap_cache_async is widely used to allocate and ensure a folio is
> in swapcache, or get the folio if a folio is already there.
>
> It's not async, and it's not doing any read. Rename it to better present
> its usage, and prepare to be reworked as part of new swap cache APIs.
>
> Also, add some comments for the function. Worth noting that the
> skip_if_exists argument is an long existing workaround that will be
> dropped soon.
>
> Reviewed-by: Yosry Ahmed <yosry.ahmed@linux.dev>
> Signed-off-by: Kairui Song <kasong@tencent.com>
> ---
>  mm/swap.h       |  6 +++---
>  mm/swap_state.c | 50 +++++++++++++++++++++++++++++++++-----------------
>  mm/swapfile.c   |  2 +-
>  mm/zswap.c      |  4 ++--
>  4 files changed, 39 insertions(+), 23 deletions(-)
>
> diff --git a/mm/swap.h b/mm/swap.h
> index d034c13d8dd2..0fff92e42cfe 100644
> --- a/mm/swap.h
> +++ b/mm/swap.h
> @@ -249,6 +249,9 @@ struct folio *swap_cache_get_folio(swp_entry_t entry);
>  void *swap_cache_get_shadow(swp_entry_t entry);
>  void swap_cache_add_folio(struct folio *folio, swp_entry_t entry, void **shadow);
>  void swap_cache_del_folio(struct folio *folio);
> +struct folio *swap_cache_alloc_folio(swp_entry_t entry, gfp_t gfp_flags,
> +                                    struct mempolicy *mpol, pgoff_t ilx,
> +                                    bool *alloced, bool skip_if_exists);
>  /* Below helpers require the caller to lock and pass in the swap cluster. */
>  void __swap_cache_del_folio(struct swap_cluster_info *ci,
>                             struct folio *folio, swp_entry_t entry, void *shadow);
> @@ -261,9 +264,6 @@ void swapcache_clear(struct swap_info_struct *si, swp_entry_t entry, int nr);
>  struct folio *read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask,
>                 struct vm_area_struct *vma, unsigned long addr,
>                 struct swap_iocb **plug);
> -struct folio *__read_swap_cache_async(swp_entry_t entry, gfp_t gfp_flags,
> -               struct mempolicy *mpol, pgoff_t ilx, bool *new_page_allocated,
> -               bool skip_if_exists);
>  struct folio *swap_cluster_readahead(swp_entry_t entry, gfp_t flag,
>                 struct mempolicy *mpol, pgoff_t ilx);
>  struct folio *swapin_readahead(swp_entry_t entry, gfp_t flag,
> diff --git a/mm/swap_state.c b/mm/swap_state.c
> index b2230f8a48fc..08252eaef32f 100644
> --- a/mm/swap_state.c
> +++ b/mm/swap_state.c
> @@ -402,9 +402,29 @@ void swap_update_readahead(struct folio *folio, struct vm_area_struct *vma,
>         }
>  }
>
> -struct folio *__read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask,
> -               struct mempolicy *mpol, pgoff_t ilx, bool *new_page_allocated,
> -               bool skip_if_exists)
> +/**
> + * swap_cache_alloc_folio - Allocate folio for swapped out slot in swap cache.
> + * @entry: the swapped out swap entry to be binded to the folio.
> + * @gfp_mask: memory allocation flags
> + * @mpol: NUMA memory allocation policy to be applied
> + * @ilx: NUMA interleave index, for use only when MPOL_INTERLEAVE
> + * @new_page_allocated: sets true if allocation happened, false otherwise
> + * @skip_if_exists: if the slot is a partially cached state, return NULL.
> + *                  This is a workaround that would be removed shortly.
> + *
> + * Allocate a folio in the swap cache for one swap slot, typically before
> + * doing IO (e.g. swap in or zswap writeback). The swap slot indicated by
> + * @entry must have a non-zero swap count (swapped out).
> + * Currently only supports order 0.
> + *
> + * Context: Caller must protect the swap device with reference count or locks.
> + * Return: Returns the existing folio if @entry is cached already. Returns
> + * NULL if failed due to -ENOMEM or @entry have a swap count < 1.
> + */
> +struct folio *swap_cache_alloc_folio(swp_entry_t entry, gfp_t gfp_mask,
> +                                    struct mempolicy *mpol, pgoff_t ilx,
> +                                    bool *new_page_allocated,
> +                                    bool skip_if_exists)
>  {
>         struct swap_info_struct *si = __swap_entry_to_info(entry);
>         struct folio *folio;
> @@ -452,12 +472,12 @@ struct folio *__read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask,
>                         goto put_and_return;
>
>                 /*
> -                * Protect against a recursive call to __read_swap_cache_async()
> +                * Protect against a recursive call to swap_cache_alloc_folio()
>                  * on the same entry waiting forever here because SWAP_HAS_CACHE
>                  * is set but the folio is not the swap cache yet. This can
>                  * happen today if mem_cgroup_swapin_charge_folio() below
>                  * triggers reclaim through zswap, which may call
> -                * __read_swap_cache_async() in the writeback path.
> +                * swap_cache_alloc_folio() in the writeback path.
>                  */
>                 if (skip_if_exists)
>                         goto put_and_return;
> @@ -466,7 +486,7 @@ struct folio *__read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask,
>                  * We might race against __swap_cache_del_folio(), and
>                  * stumble across a swap_map entry whose SWAP_HAS_CACHE
>                  * has not yet been cleared.  Or race against another
> -                * __read_swap_cache_async(), which has set SWAP_HAS_CACHE
> +                * swap_cache_alloc_folio(), which has set SWAP_HAS_CACHE
>                  * in swap_map, but not yet added its folio to swap cache.
>                  */
>                 schedule_timeout_uninterruptible(1);
> @@ -509,10 +529,6 @@ struct folio *__read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask,
>   * and reading the disk if it is not already cached.
>   * A failure return means that either the page allocation failed or that
>   * the swap entry is no longer in use.
> - *
> - * get/put_swap_device() aren't needed to call this function, because
> - * __read_swap_cache_async() call them and swap_read_folio() holds the
> - * swap cache folio lock.
>   */
>  struct folio *read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask,
>                 struct vm_area_struct *vma, unsigned long addr,
> @@ -529,7 +545,7 @@ struct folio *read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask,
>                 return NULL;
>
>         mpol = get_vma_policy(vma, addr, 0, &ilx);
> -       folio = __read_swap_cache_async(entry, gfp_mask, mpol, ilx,
> +       folio = swap_cache_alloc_folio(entry, gfp_mask, mpol, ilx,
>                                         &page_allocated, false);
>         mpol_cond_put(mpol);
>
> @@ -647,9 +663,9 @@ struct folio *swap_cluster_readahead(swp_entry_t entry, gfp_t gfp_mask,
>         blk_start_plug(&plug);
>         for (offset = start_offset; offset <= end_offset ; offset++) {
>                 /* Ok, do the async read-ahead now */
> -               folio = __read_swap_cache_async(
> -                               swp_entry(swp_type(entry), offset),
> -                               gfp_mask, mpol, ilx, &page_allocated, false);
> +               folio = swap_cache_alloc_folio(
> +                       swp_entry(swp_type(entry), offset), gfp_mask, mpol, ilx,
> +                       &page_allocated, false);
>                 if (!folio)
>                         continue;
>                 if (page_allocated) {
> @@ -666,7 +682,7 @@ struct folio *swap_cluster_readahead(swp_entry_t entry, gfp_t gfp_mask,
>         lru_add_drain();        /* Push any new pages onto the LRU now */
>  skip:
>         /* The page was likely read above, so no need for plugging here */
> -       folio = __read_swap_cache_async(entry, gfp_mask, mpol, ilx,
> +       folio = swap_cache_alloc_folio(entry, gfp_mask, mpol, ilx,
>                                         &page_allocated, false);
>         if (unlikely(page_allocated))
>                 swap_read_folio(folio, NULL);
> @@ -771,7 +787,7 @@ static struct folio *swap_vma_readahead(swp_entry_t targ_entry, gfp_t gfp_mask,
>                         if (!si)
>                                 continue;
>                 }
> -               folio = __read_swap_cache_async(entry, gfp_mask, mpol, ilx,
> +               folio = swap_cache_alloc_folio(entry, gfp_mask, mpol, ilx,
>                                                 &page_allocated, false);
>                 if (si)
>                         put_swap_device(si);
> @@ -793,7 +809,7 @@ static struct folio *swap_vma_readahead(swp_entry_t targ_entry, gfp_t gfp_mask,
>         lru_add_drain();
>  skip:
>         /* The folio was likely read above, so no need for plugging here */
> -       folio = __read_swap_cache_async(targ_entry, gfp_mask, mpol, targ_ilx,
> +       folio = swap_cache_alloc_folio(targ_entry, gfp_mask, mpol, targ_ilx,
>                                         &page_allocated, false);
>         if (unlikely(page_allocated))
>                 swap_read_folio(folio, NULL);
> diff --git a/mm/swapfile.c b/mm/swapfile.c
> index 94e0f0c54168..a2bb09867f1e 100644
> --- a/mm/swapfile.c
> +++ b/mm/swapfile.c
> @@ -1573,7 +1573,7 @@ static unsigned char swap_entry_put_locked(struct swap_info_struct *si,
>   *   CPU1                              CPU2
>   *   do_swap_page()
>   *     ...                             swapoff+swapon
> - *     __read_swap_cache_async()
> + *     swap_cache_alloc_folio()
>   *       swapcache_prepare()
>   *         __swap_duplicate()
>   *           // check swap_map
> diff --git a/mm/zswap.c b/mm/zswap.c
> index 5d0f8b13a958..a7a2443912f4 100644
> --- a/mm/zswap.c
> +++ b/mm/zswap.c
> @@ -1014,8 +1014,8 @@ static int zswap_writeback_entry(struct zswap_entry *entry,
>                 return -EEXIST;
>
>         mpol = get_task_policy(current);
> -       folio = __read_swap_cache_async(swpentry, GFP_KERNEL, mpol,
> -                       NO_INTERLEAVE_INDEX, &folio_was_allocated, true);
> +       folio = swap_cache_alloc_folio(swpentry, GFP_KERNEL, mpol,
> +                                      NO_INTERLEAVE_INDEX, &folio_was_allocated, true);
>         put_swap_device(si);
>         if (!folio)
>                 return -ENOMEM;
>
> --
> 2.51.2
>