mm/shmem, swap: never use swap cache and readahead for SWP_SYNCHRONOUS_IO

For SWP_SYNCHRONOUS_IO devices, if a cache bypassing THP swapin failed due
to reasons like memory pressure, partially conflicting swap cache or ZSWAP
enabled, shmem will fallback to cached order 0 swapin.

Right now the swap cache still has a non-trivial overhead, and readahead
is not helpful for SWP_SYNCHRONOUS_IO devices, so we should always skip
the readahead and swap cache even if the swapin falls back to order 0.

So handle the fallback logic without falling back to the cached read.

Link: https://lkml.kernel.org/r/20250728075306.12704-6-ryncsn@gmail.com
Signed-off-by: Kairui Song <kasong@tencent.com>
Reviewed-by: Baolin Wang <baolin.wang@linux.alibaba.com>
Cc: Baoquan He <bhe@redhat.com>
Cc: Barry Song <baohua@kernel.org>
Cc: Chris Li <chrisl@kernel.org>
Cc: Dev Jain <dev.jain@arm.com>
Cc: Hugh Dickins <hughd@google.com>
Cc: Kemeng Shi <shikemeng@huaweicloud.com>
Cc: Matthew Wilcox (Oracle) <willy@infradead.org>
Cc: Nhat Pham <nphamcs@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/mm/shmem.c b/mm/shmem.c
index 5e10e27e8b73a3fb67089326feae997e2197eb07..e6207ad6f2f108fc2dd703023ce1d9db428ac980 100644 (file)
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -2019,6 +2019,7 @@ static struct folio *shmem_swap_alloc_folio(struct inode *inode,
        struct shmem_inode_info *info = SHMEM_I(inode);
        int nr_pages = 1 << order;
        struct folio *new;
+       gfp_t alloc_gfp;
        void *shadow;
 
        /*
@@ -2026,6 +2027,7 @@ static struct folio *shmem_swap_alloc_folio(struct inode *inode,
         * limit chance of success with further cpuset and node constraints.
         */
        gfp &= ~GFP_CONSTRAINT_MASK;
+       alloc_gfp = gfp;
        if (!IS_ENABLED(CONFIG_TRANSPARENT_HUGEPAGE)) {
                if (WARN_ON_ONCE(order))
                        return ERR_PTR(-EINVAL);
@@ -2040,19 +2042,22 @@ static struct folio *shmem_swap_alloc_folio(struct inode *inode,
                if ((vma && unlikely(userfaultfd_armed(vma))) ||
                     !zswap_never_enabled() ||
                     non_swapcache_batch(entry, nr_pages) != nr_pages)
-                       return ERR_PTR(-EINVAL);
+                       goto fallback;
 
-               gfp = limit_gfp_mask(vma_thp_gfp_mask(vma), gfp);
+               alloc_gfp = limit_gfp_mask(vma_thp_gfp_mask(vma), gfp);
+       }
+retry:
+       new = shmem_alloc_folio(alloc_gfp, order, info, index);
+       if (!new) {
+               new = ERR_PTR(-ENOMEM);
+               goto fallback;
        }
-
-       new = shmem_alloc_folio(gfp, order, info, index);
-       if (!new)
-               return ERR_PTR(-ENOMEM);
 
        if (mem_cgroup_swapin_charge_folio(new, vma ? vma->vm_mm : NULL,
-                                          gfp, entry)) {
+                                          alloc_gfp, entry)) {
                folio_put(new);
-               return ERR_PTR(-ENOMEM);
+               new = ERR_PTR(-ENOMEM);
+               goto fallback;
        }
 
        /*
@@ -2067,7 +2072,9 @@ static struct folio *shmem_swap_alloc_folio(struct inode *inode,
         */
        if (swapcache_prepare(entry, nr_pages)) {
                folio_put(new);
-               return ERR_PTR(-EEXIST);
+               new = ERR_PTR(-EEXIST);
+               /* Try smaller folio to avoid cache conflict */
+               goto fallback;
        }
 
        __folio_set_locked(new);
@@ -2081,6 +2088,15 @@ static struct folio *shmem_swap_alloc_folio(struct inode *inode,
        folio_add_lru(new);
        swap_read_folio(new, NULL);
        return new;
+fallback:
+       /* Order 0 swapin failed, nothing to fallback to, abort */
+       if (!order)
+               return new;
+       entry.val += index - round_down(index, nr_pages);
+       alloc_gfp = gfp;
+       nr_pages = 1;
+       order = 0;
+       goto retry;
 }
 
 /*
@@ -2350,13 +2366,12 @@ static int shmem_swapin_folio(struct inode *inode, pgoff_t index,
                        }
 
                        /*
-                        * Fallback to swapin order-0 folio unless the swap entry
-                        * already exists.
+                        * Direct swapin handled order 0 fallback already,
+                        * if it failed, abort.
                         */
                        error = PTR_ERR(folio);
                        folio = NULL;
-                       if (error == -EEXIST)
-                               goto failed;
+                       goto failed;
                }
 
                /*