mm/shmem, swap: tidy up THP swapin checks

Move all THP swapin related checks under CONFIG_TRANSPARENT_HUGEPAGE, so
they will be trimmed off by the compiler if not needed.

And add a WARN if shmem sees a order > 0 entry when
CONFIG_TRANSPARENT_HUGEPAGE is disabled, that should never happen unless
things went very wrong.

There should be no observable feature change except the new added WARN.

Link: https://lkml.kernel.org/r/20250728075306.12704-4-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 6e00d2ec40a91887e420875951292419ececca65..88058d53ae550ea08152cac0ff044db4b9e0f00b 100644 (file)
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -2017,26 +2017,38 @@ static struct folio *shmem_swap_alloc_folio(struct inode *inode,
                swp_entry_t entry, int order, gfp_t gfp)
 {
        struct shmem_inode_info *info = SHMEM_I(inode);
+       int nr_pages = 1 << order;
        struct folio *new;
        void *shadow;
-       int nr_pages;
 
        /*
         * We have arrived here because our zones are constrained, so don't
         * limit chance of success with further cpuset and node constraints.
         */
        gfp &= ~GFP_CONSTRAINT_MASK;
-       if (IS_ENABLED(CONFIG_TRANSPARENT_HUGEPAGE) && order > 0) {
-               gfp_t huge_gfp = vma_thp_gfp_mask(vma);
+       if (!IS_ENABLED(CONFIG_TRANSPARENT_HUGEPAGE)) {
+               if (WARN_ON_ONCE(order))
+                       return ERR_PTR(-EINVAL);
+       } else if (order) {
+               /*
+                * If uffd is active for the vma, we need per-page fault
+                * fidelity to maintain the uffd semantics, then fallback
+                * to swapin order-0 folio, as well as for zswap case.
+                * Any existing sub folio in the swap cache also blocks
+                * mTHP swapin.
+                */
+               if ((vma && unlikely(userfaultfd_armed(vma))) ||
+                    !zswap_never_enabled() ||
+                    non_swapcache_batch(entry, nr_pages) != nr_pages)
+                       return ERR_PTR(-EINVAL);
 
-               gfp = limit_gfp_mask(huge_gfp, gfp);
+               gfp = limit_gfp_mask(vma_thp_gfp_mask(vma), gfp);
        }
 
        new = shmem_alloc_folio(gfp, order, info, index);
        if (!new)
                return ERR_PTR(-ENOMEM);
 
-       nr_pages = folio_nr_pages(new);
        if (mem_cgroup_swapin_charge_folio(new, vma ? vma->vm_mm : NULL,
                                           gfp, entry)) {
                folio_put(new);
@@ -2320,9 +2332,6 @@ static int shmem_swapin_folio(struct inode *inode, pgoff_t index,
        /* Look it up and read it in.. */
        folio = swap_cache_get_folio(swap, NULL, 0);
        if (!folio) {
-               int nr_pages = 1 << order;
-               bool fallback_order0 = false;
-
                /* Or update major stats only when swapin succeeds?? */
                if (fault_type) {
                        *fault_type |= VM_FAULT_MAJOR;
@@ -2330,20 +2339,8 @@ static int shmem_swapin_folio(struct inode *inode, pgoff_t index,
                        count_memcg_event_mm(fault_mm, PGMAJFAULT);
                }
 
-               /*
-                * If uffd is active for the vma, we need per-page fault
-                * fidelity to maintain the uffd semantics, then fallback
-                * to swapin order-0 folio, as well as for zswap case.
-                * Any existing sub folio in the swap cache also blocks
-                * mTHP swapin.
-                */
-               if (order > 0 && ((vma && unlikely(userfaultfd_armed(vma))) ||
-                                 !zswap_never_enabled() ||
-                                 non_swapcache_batch(swap, nr_pages) != nr_pages))
-                       fallback_order0 = true;
-
                /* Skip swapcache for synchronous device. */
-               if (!fallback_order0 && data_race(si->flags & SWP_SYNCHRONOUS_IO)) {
+               if (data_race(si->flags & SWP_SYNCHRONOUS_IO)) {
                        folio = shmem_swap_alloc_folio(inode, vma, index, swap, order, gfp);
                        if (!IS_ERR(folio)) {
                                skip_swapcache = true;