Merge tag 'mm-hotfixes-stable-2025-02-01-03-56' of git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm

Pull misc fixes from Andrew Morton:
"21 hotfixes. 8 are cc:stable and the remainder address post-6.13
issues. 13 are for MM and 8 are for non-MM.

All are singletons, please see the changelogs for details"

* tag 'mm-hotfixes-stable-2025-02-01-03-56' of git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm: (21 commits)
MAINTAINERS: include linux-mm for xarray maintenance
revert "xarray: port tests to kunit"
MAINTAINERS: add lib/test_xarray.c
mailmap, MAINTAINERS, docs: update Carlos's email address
mm/hugetlb: fix hugepage allocation for interleaved memory nodes
mm: gup: fix infinite loop within __get_longterm_locked
mm, swap: fix reclaim offset calculation error during allocation
.mailmap: update email address for Christopher Obbard
kfence: skip __GFP_THISNODE allocations on NUMA systems
nilfs2: fix possible int overflows in nilfs_fiemap()
mm: compaction: use the proper flag to determine watermarks
kernel: be more careful about dup_mmap() failures and uprobe registering
mm/fake-numa: handle cases with no SRAT info
mm: kmemleak: fix upper boundary check for physical address objects
mailmap: add an entry for Hamza Mahfooz
MAINTAINERS: mailmap: update Yosry Ahmed's email address
scripts/gdb: fix aarch64 userspace detection in get_current_task
mm/vmscan: accumulate nr_demoted for accurate demotion statistics
ocfs2: fix incorrect CPU endianness conversion causing mount failure
mm/zsmalloc: add __maybe_unused attribute for is_first_zpdesc()
...

.mailmap

···
 Cai Huoqing <[e-mail]> <[e-mail]>
 Can Guo <[e-mail]> <[e-mail]>
 Carl Huang <[e-mail]> <[e-mail]>
-Carlos Bilbao <[e-mail]> <[e-mail]>
+Carlos Bilbao <[e-mail]> <[e-mail]>
+Carlos Bilbao <[e-mail]> <[e-mail]>
+Carlos Bilbao <[e-mail]> <[e-mail]>
 Changbin Du <[e-mail]> <[e-mail]>
 Changbin Du <[e-mail]> <[e-mail]>
 Chao Yu <[e-mail]> <[e-mail]>
···
 Christian Brauner <[e-mail]> <[e-mail]>
 Christian Marangi <[e-mail]>
 Christophe Ricard <[e-mail]>
+Christopher Obbard <[e-mail]> <[e-mail]>
 Christoph Hellwig <[e-mail]>
 Chuck Lever <[e-mail]> <[e-mail]>
 Chuck Lever <[e-mail]> <[e-mail]>
···
 Guru Das Srinagesh <[e-mail]> <[e-mail]>
 Gustavo Padovan <[e-mail]>
 Gustavo Padovan <[e-mail]>
+Hamza Mahfooz <[e-mail]> <[e-mail]>
 Hanjun Guo <[e-mail]> <[e-mail]>
 Hans Verkuil <[e-mail]> <[e-mail]>
 Hans Verkuil <[e-mail]> <[e-mail]>
···
 Yakir Yang <[e-mail]> <[e-mail]>
 Yanteng Si <[e-mail]> <[e-mail]>
 Ying Huang <[e-mail]> <[e-mail]>
+Yosry Ahmed <[e-mail]> <[e-mail]>
 Yusuke Goda <[e-mail]>
 Zack Rusin <[e-mail]> <[e-mail]>
 Zhu Yanjun <[e-mail]> <[e-mail]>

Documentation/translations/sp_SP/index.rst

···
 
 	\kerneldocCJKoff
 
-:maintainer: Carlos Bilbao <[e-mail]>
+:maintainer: Carlos Bilbao <[e-mail]>
 
 .. _sp_disclaimer:
 

MAINTAINERS

···
 
 AMD HSMP DRIVER
 M:	Naveen Krishna Chatradhi <[e-mail]>
-R:	Carlos Bilbao <[e-mail]>
+R:	Carlos Bilbao <[e-mail]>
 L:	[e-mail]
 S:	Maintained
 F:	Documentation/arch/x86/amd_hsmp.rst
···
 
 CONFIDENTIAL COMPUTING THREAT MODEL FOR X86 VIRTUALIZATION (SNP/TDX)
 M:	Elena Reshetova <[e-mail]>
-M:	Carlos Bilbao <[e-mail]>
+M:	Carlos Bilbao <[e-mail]>
 S:	Maintained
 F:	Documentation/security/snp-tdx-threat-model.rst
 
···
 F:	drivers/video/fbdev/imsttfb.c
 
 INDEX OF FURTHER KERNEL DOCUMENTATION
-M:	Carlos Bilbao <[e-mail]>
+M:	Carlos Bilbao <[e-mail]>
 S:	Maintained
 F:	Documentation/process/kernel-docs.rst
 
···
 F:	drivers/media/dvb-frontends/sp2*
 
 SPANISH DOCUMENTATION
-M:	Carlos Bilbao <[e-mail]>
+M:	Carlos Bilbao <[e-mail]>
 R:	Avadhut Naik <[e-mail]>
 S:	Maintained
 F:	Documentation/translations/sp_SP/
···
 XARRAY
 M:	Matthew Wilcox <[e-mail]>
 L:	[e-mail]
+L:	[e-mail]
 S:	Supported
 F:	Documentation/core-api/xarray.rst
 F:	include/linux/idr.h
 F:	include/linux/xarray.h
 F:	lib/idr.c
+F:	lib/test_xarray.c
 F:	lib/xarray.c
 F:	tools/testing/radix-tree
 
···
 
 ZSWAP COMPRESSED SWAP CACHING
 M:	Johannes Weiner <[e-mail]>
-M:	Yosry Ahmed <[e-mail]>
+M:	Yosry Ahmed <[e-mail]>
 M:	Nhat Pham <[e-mail]>
 R:	Chengming Zhou <[e-mail]>
 L:	[e-mail]

arch/m68k/configs/amiga_defconfig

···
 CONFIG_TEST_SCANF=m
 CONFIG_TEST_BITMAP=m
 CONFIG_TEST_UUID=m
+CONFIG_TEST_XARRAY=m
 CONFIG_TEST_MAPLE_TREE=m
 CONFIG_TEST_RHASHTABLE=m
 CONFIG_TEST_IDA=m

arch/m68k/configs/apollo_defconfig

···
 CONFIG_TEST_SCANF=m
 CONFIG_TEST_BITMAP=m
 CONFIG_TEST_UUID=m
+CONFIG_TEST_XARRAY=m
 CONFIG_TEST_MAPLE_TREE=m
 CONFIG_TEST_RHASHTABLE=m
 CONFIG_TEST_IDA=m

arch/m68k/configs/atari_defconfig

···
 CONFIG_TEST_SCANF=m
 CONFIG_TEST_BITMAP=m
 CONFIG_TEST_UUID=m
+CONFIG_TEST_XARRAY=m
 CONFIG_TEST_MAPLE_TREE=m
 CONFIG_TEST_RHASHTABLE=m
 CONFIG_TEST_IDA=m

arch/m68k/configs/bvme6000_defconfig

···
 CONFIG_TEST_SCANF=m
 CONFIG_TEST_BITMAP=m
 CONFIG_TEST_UUID=m
+CONFIG_TEST_XARRAY=m
 CONFIG_TEST_MAPLE_TREE=m
 CONFIG_TEST_RHASHTABLE=m
 CONFIG_TEST_IDA=m

arch/m68k/configs/hp300_defconfig

···
 CONFIG_TEST_SCANF=m
 CONFIG_TEST_BITMAP=m
 CONFIG_TEST_UUID=m
+CONFIG_TEST_XARRAY=m
 CONFIG_TEST_MAPLE_TREE=m
 CONFIG_TEST_RHASHTABLE=m
 CONFIG_TEST_IDA=m

arch/m68k/configs/mac_defconfig

···
 CONFIG_TEST_SCANF=m
 CONFIG_TEST_BITMAP=m
 CONFIG_TEST_UUID=m
+CONFIG_TEST_XARRAY=m
 CONFIG_TEST_MAPLE_TREE=m
 CONFIG_TEST_RHASHTABLE=m
 CONFIG_TEST_IDA=m

arch/m68k/configs/multi_defconfig

···
 CONFIG_TEST_SCANF=m
 CONFIG_TEST_BITMAP=m
 CONFIG_TEST_UUID=m
+CONFIG_TEST_XARRAY=m
 CONFIG_TEST_MAPLE_TREE=m
 CONFIG_TEST_RHASHTABLE=m
 CONFIG_TEST_IDA=m

arch/m68k/configs/mvme147_defconfig

···
 CONFIG_TEST_SCANF=m
 CONFIG_TEST_BITMAP=m
 CONFIG_TEST_UUID=m
+CONFIG_TEST_XARRAY=m
 CONFIG_TEST_MAPLE_TREE=m
 CONFIG_TEST_RHASHTABLE=m
 CONFIG_TEST_IDA=m

arch/m68k/configs/mvme16x_defconfig

···
 CONFIG_TEST_SCANF=m
 CONFIG_TEST_BITMAP=m
 CONFIG_TEST_UUID=m
+CONFIG_TEST_XARRAY=m
 CONFIG_TEST_MAPLE_TREE=m
 CONFIG_TEST_RHASHTABLE=m
 CONFIG_TEST_IDA=m

arch/m68k/configs/q40_defconfig

···
 CONFIG_TEST_SCANF=m
 CONFIG_TEST_BITMAP=m
 CONFIG_TEST_UUID=m
+CONFIG_TEST_XARRAY=m
 CONFIG_TEST_MAPLE_TREE=m
 CONFIG_TEST_RHASHTABLE=m
 CONFIG_TEST_IDA=m

arch/m68k/configs/sun3_defconfig

···
 CONFIG_TEST_SCANF=m
 CONFIG_TEST_BITMAP=m
 CONFIG_TEST_UUID=m
+CONFIG_TEST_XARRAY=m
 CONFIG_TEST_MAPLE_TREE=m
 CONFIG_TEST_RHASHTABLE=m
 CONFIG_TEST_IDA=m

arch/m68k/configs/sun3x_defconfig

···
 CONFIG_TEST_SCANF=m
 CONFIG_TEST_BITMAP=m
 CONFIG_TEST_UUID=m
+CONFIG_TEST_XARRAY=m
 CONFIG_TEST_MAPLE_TREE=m
 CONFIG_TEST_RHASHTABLE=m
 CONFIG_TEST_IDA=m

arch/powerpc/configs/ppc64_defconfig

···
 CONFIG_TEST_SCANF=m
 CONFIG_TEST_BITMAP=m
 CONFIG_TEST_UUID=m
+CONFIG_TEST_XARRAY=m
 CONFIG_TEST_MAPLE_TREE=m
 CONFIG_TEST_RHASHTABLE=m
 CONFIG_TEST_IDA=m

drivers/acpi/numa/srat.c

···
 	int i, j, index = -1, count = 0;
 	nodemask_t nodes_to_enable;
 
-	if (numa_off || srat_disabled())
+	if (numa_off)
 		return -1;
+
+	/* no or incomplete node/PXM mapping set, nothing to do */
+	if (srat_disabled())
+		return 0;
 
 	/* find fake nodes PXM mapping */
 	for (i = 0; i < MAX_NUMNODES; i++) {
···
 				}
 			}
 		}
+	}
+	if (index == -1) {
+		pr_debug("No node/PXM mapping has been set\n");
+		/* nothing more to be done */
+		return 0;
 	}
 	if (WARN(index != max_nid, "%d max nid  when expected %d\n",
 		      index, max_nid))

fs/nilfs2/inode.c

···
 			if (size) {
 				if (phys && blkphy << blkbits == phys + size) {
 					/* The current extent goes on */
-					size += n << blkbits;
+					size += (u64)n << blkbits;
 				} else {
 					/* Terminate the current extent */
 					ret = fiemap_fill_next_extent(
···
 					flags = FIEMAP_EXTENT_MERGED;
 					logical = blkoff << blkbits;
 					phys = blkphy << blkbits;
-					size = n << blkbits;
+					size = (u64)n << blkbits;
 				}
 			} else {
 				/* Start a new extent */
 				flags = FIEMAP_EXTENT_MERGED;
 				logical = blkoff << blkbits;
 				phys = blkphy << blkbits;
-				size = n << blkbits;
+				size = (u64)n << blkbits;
 			}
 			blkoff += n;
 		}

fs/ocfs2/super.c

···
 			mlog(ML_ERROR, "found superblock with incorrect block "
 			     "size bits: found %u, should be 9, 10, 11, or 12\n",
 			     blksz_bits);
-		} else if ((1 << le32_to_cpu(blksz_bits)) != blksz) {
+		} else if ((1 << blksz_bits) != blksz) {
 			mlog(ML_ERROR, "found superblock with incorrect block "
 			     "size: found %u, should be %u\n", 1 << blksz_bits, blksz);
 		} else if (le16_to_cpu(di->id2.i_super.s_major_rev_level) !=

include/linux/swap.h

···
 };
 
 #define SWAP_CLUSTER_MAX 32UL
+#define SWAP_CLUSTER_MAX_SKIPPED (SWAP_CLUSTER_MAX << 10)
 #define COMPACT_CLUSTER_MAX SWAP_CLUSTER_MAX
 
 /* Bit flag in swap_map */

kernel/events/uprobes.c

···
 #include <linux/rcupdate_trace.h>
 #include <linux/workqueue.h>
 #include <linux/srcu.h>
+#include <linux/oom.h>          /* check_stable_address_space */
 
 #include <linux/uprobes.h>
 
···
 		 * returns NULL in find_active_uprobe_rcu().
 		 */
 		mmap_write_lock(mm);
+		if (check_stable_address_space(mm))
+			goto unlock;
+
 		vma = find_vma(mm, info->vaddr);
 		if (!vma || !valid_vma(vma, is_register) ||
 		    file_inode(vma->vm_file) != uprobe->inode)

kernel/fork.c

···
 		mt_set_in_rcu(vmi.mas.tree);
 		ksm_fork(mm, oldmm);
 		khugepaged_fork(mm, oldmm);
-	} else if (mpnt) {
+	} else {
+
 		/*
 		 * The entire maple tree has already been duplicated. If the
 		 * mmap duplication fails, mark the failure point with
···
 		 * stop releasing VMAs that have not been duplicated after this
 		 * point.
 		 */
-		mas_set_range(&vmi.mas, mpnt->vm_start, mpnt->vm_end - 1);
-		mas_store(&vmi.mas, XA_ZERO_ENTRY);
+		if (mpnt) {
+			mas_set_range(&vmi.mas, mpnt->vm_start, mpnt->vm_end - 1);
+			mas_store(&vmi.mas, XA_ZERO_ENTRY);
+			/* Avoid OOM iterating a broken tree */
+			set_bit(MMF_OOM_SKIP, &mm->flags);
+		}
+		/*
+		 * The mm_struct is going to exit, but the locks will be dropped
+		 * first.  Set the mm_struct as unstable is advisable as it is
+		 * not fully initialised.
+		 */
+		set_bit(MMF_UNSTABLE, &mm->flags);
 	}
 out:
 	mmap_write_unlock(mm);

lib/Kconfig.debug

···
 config TEST_UUID
 	tristate "Test functions located in the uuid module at runtime"
 
-config XARRAY_KUNIT
-	tristate "KUnit test XArray code at runtime" if !KUNIT_ALL_TESTS
-	depends on KUNIT
-	default KUNIT_ALL_TESTS
-	help
-	  Enable this option to test the Xarray code at boot.
-
-	  KUnit tests run during boot and output the results to the debug log
-	  in TAP format (http://testanything.org/). Only useful for kernel devs
-	  running the KUnit test harness, and not intended for inclusion into a
-	  production build.
-
-	  For more information on KUnit and unit tests in general please refer
-	  to the KUnit documentation in Documentation/dev-tools/kunit/.
-
-	  If unsure, say N.
+config TEST_XARRAY
+	tristate "Test the XArray code at runtime"
 
 config TEST_MAPLE_TREE
 	tristate "Test the Maple Tree code at runtime or module load"

lib/Makefile

···
 endif
 
 obj-$(CONFIG_TEST_UUID) += test_uuid.o
+obj-$(CONFIG_TEST_XARRAY) += test_xarray.o
 obj-$(CONFIG_TEST_MAPLE_TREE) += test_maple_tree.o
 obj-$(CONFIG_TEST_PARMAN) += test_parman.o
 obj-$(CONFIG_TEST_KMOD) += test_kmod.o
···
 obj-$(CONFIG_BITFIELD_KUNIT) += bitfield_kunit.o
 obj-$(CONFIG_CHECKSUM_KUNIT) += checksum_kunit.o
 obj-$(CONFIG_UTIL_MACROS_KUNIT) += util_macros_kunit.o
-obj-$(CONFIG_XARRAY_KUNIT) += test_xarray.o
 obj-$(CONFIG_LIST_KUNIT_TEST) += list-test.o
 obj-$(CONFIG_HASHTABLE_KUNIT_TEST) += hashtable_test.o
 obj-$(CONFIG_LINEAR_RANGES_TEST) += test_linear_ranges.o

lib/test_xarray.c

···
  * Author: Matthew Wilcox <[e-mail]>
  */
 
-#include <kunit/test.h>
-
-#include <linux/module.h>
 #include <linux/xarray.h>
+#include <linux/module.h>
+
+static unsigned int tests_run;
+static unsigned int tests_passed;
 
 static const unsigned int order_limit =
 		IS_ENABLED(CONFIG_XARRAY_MULTI) ? BITS_PER_LONG : 1;
···
 void xa_dump(const struct xarray *xa) { }
 # endif
 #undef XA_BUG_ON
-#define XA_BUG_ON(xa, x) do {		\
-	if (x) {			\
-		KUNIT_FAIL(test, #x);	\
-		xa_dump(xa);		\
-		dump_stack();		\
-	}				\
+#define XA_BUG_ON(xa, x) do {					\
+	tests_run++;						\
+	if (x) {						\
+		printk("BUG at %s:%d\n", __func__, __LINE__);	\
+		xa_dump(xa);					\
+		dump_stack();					\
+	} else {						\
+		tests_passed++;					\
+	}							\
 } while (0)
 #endif
 
···
 	return xa_store(xa, index, xa_mk_index(index), gfp);
 }
 
-static void xa_insert_index(struct kunit *test, struct xarray *xa, unsigned long index)
+static void xa_insert_index(struct xarray *xa, unsigned long index)
 {
 	XA_BUG_ON(xa, xa_insert(xa, index, xa_mk_index(index),
 				GFP_KERNEL) != 0);
 }
 
-static void xa_alloc_index(struct kunit *test, struct xarray *xa, unsigned long index, gfp_t gfp)
+static void xa_alloc_index(struct xarray *xa, unsigned long index, gfp_t gfp)
 {
 	u32 id;
 
···
 	XA_BUG_ON(xa, id != index);
 }
 
-static void xa_erase_index(struct kunit *test, struct xarray *xa, unsigned long index)
+static void xa_erase_index(struct xarray *xa, unsigned long index)
 {
 	XA_BUG_ON(xa, xa_erase(xa, index) != xa_mk_index(index));
 	XA_BUG_ON(xa, xa_load(xa, index) != NULL);
···
 	return curr;
 }
 
-static inline struct xarray *xa_param(struct kunit *test)
+static noinline void check_xa_err(struct xarray *xa)
 {
-	return *(struct xarray **)test->param_value;
-}
-
-static noinline void check_xa_err(struct kunit *test)
-{
-	struct xarray *xa = xa_param(test);
-
 	XA_BUG_ON(xa, xa_err(xa_store_index(xa, 0, GFP_NOWAIT)) != 0);
 	XA_BUG_ON(xa, xa_err(xa_erase(xa, 0)) != 0);
 #ifndef __KERNEL__
···
 //	XA_BUG_ON(xa, xa_err(xa_store(xa, 0, xa_mk_internal(0), 0)) != -EINVAL);
 }
 
-static noinline void check_xas_retry(struct kunit *test)
+static noinline void check_xas_retry(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE(xas, xa, 0);
 	void *entry;
 
···
 
 	rcu_read_lock();
 	XA_BUG_ON(xa, xas_find(&xas, ULONG_MAX) != xa_mk_value(0));
-	xa_erase_index(test, xa, 1);
+	xa_erase_index(xa, 1);
 	XA_BUG_ON(xa, !xa_is_retry(xas_reload(&xas)));
 	XA_BUG_ON(xa, xas_retry(&xas, NULL));
 	XA_BUG_ON(xa, xas_retry(&xas, xa_mk_value(0)));
···
 	}
 	xas_unlock(&xas);
 
-	xa_erase_index(test, xa, 0);
-	xa_erase_index(test, xa, 1);
+	xa_erase_index(xa, 0);
+	xa_erase_index(xa, 1);
 }
 
-static noinline void check_xa_load(struct kunit *test)
+static noinline void check_xa_load(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	unsigned long i, j;
 
 	for (i = 0; i < 1024; i++) {
···
 			else
 				XA_BUG_ON(xa, entry);
 		}
-		xa_erase_index(test, xa, i);
+		xa_erase_index(xa, i);
 	}
 	XA_BUG_ON(xa, !xa_empty(xa));
 }
 
-static noinline void check_xa_mark_1(struct kunit *test, unsigned long index)
+static noinline void check_xa_mark_1(struct xarray *xa, unsigned long index)
 {
-	struct xarray *xa = xa_param(test);
-
 	unsigned int order;
 	unsigned int max_order = IS_ENABLED(CONFIG_XARRAY_MULTI) ? 8 : 1;
 
···
 	XA_BUG_ON(xa, xa_get_mark(xa, index, XA_MARK_1));
 
 	/* Storing NULL clears marks, and they can't be set again */
-	xa_erase_index(test, xa, index);
+	xa_erase_index(xa, index);
 	XA_BUG_ON(xa, !xa_empty(xa));
 	XA_BUG_ON(xa, xa_get_mark(xa, index, XA_MARK_0));
 	xa_set_mark(xa, index, XA_MARK_0);
···
 		XA_BUG_ON(xa, xa_get_mark(xa, next, XA_MARK_0));
 		XA_BUG_ON(xa, xa_get_mark(xa, next, XA_MARK_1));
 		XA_BUG_ON(xa, xa_get_mark(xa, next, XA_MARK_2));
-		xa_erase_index(test, xa, index);
-		xa_erase_index(test, xa, next);
+		xa_erase_index(xa, index);
+		xa_erase_index(xa, next);
 		XA_BUG_ON(xa, !xa_empty(xa));
 	}
 	XA_BUG_ON(xa, !xa_empty(xa));
 }
 
-static noinline void check_xa_mark_2(struct kunit *test)
+static noinline void check_xa_mark_2(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE(xas, xa, 0);
 	unsigned long index;
 	unsigned int count = 0;
···
 	xa_destroy(xa);
 }
 
-static noinline void check_xa_mark_3(struct kunit *test)
+static noinline void check_xa_mark_3(struct xarray *xa)
 {
 #ifdef CONFIG_XARRAY_MULTI
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE(xas, xa, 0x41);
 	void *entry;
 	int count = 0;
···
 #endif
 }
 
-static noinline void check_xa_mark(struct kunit *test)
+static noinline void check_xa_mark(struct xarray *xa)
 {
 	unsigned long index;
 
 	for (index = 0; index < 16384; index += 4)
-		check_xa_mark_1(test, index);
+		check_xa_mark_1(xa, index);
 
-	check_xa_mark_2(test);
-	check_xa_mark_3(test);
+	check_xa_mark_2(xa);
+	check_xa_mark_3(xa);
 }
 
-static noinline void check_xa_shrink(struct kunit *test)
+static noinline void check_xa_shrink(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE(xas, xa, 1);
 	struct xa_node *node;
 	unsigned int order;
···
 	XA_BUG_ON(xa, xas_load(&xas) != NULL);
 	xas_unlock(&xas);
 	XA_BUG_ON(xa, xa_load(xa, 0) != xa_mk_value(0));
-	xa_erase_index(test, xa, 0);
+	xa_erase_index(xa, 0);
 	XA_BUG_ON(xa, !xa_empty(xa));
 
 	for (order = 0; order < max_order; order++) {
···
 		XA_BUG_ON(xa, xa_head(xa) == node);
 		rcu_read_unlock();
 		XA_BUG_ON(xa, xa_load(xa, max + 1) != NULL);
-		xa_erase_index(test, xa, ULONG_MAX);
+		xa_erase_index(xa, ULONG_MAX);
 		XA_BUG_ON(xa, xa->xa_head != node);
-		xa_erase_index(test, xa, 0);
+		xa_erase_index(xa, 0);
 	}
 }
 
-static noinline void check_insert(struct kunit *test)
+static noinline void check_insert(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	unsigned long i;
 
 	for (i = 0; i < 1024; i++) {
-		xa_insert_index(test, xa, i);
+		xa_insert_index(xa, i);
 		XA_BUG_ON(xa, xa_load(xa, i - 1) != NULL);
 		XA_BUG_ON(xa, xa_load(xa, i + 1) != NULL);
-		xa_erase_index(test, xa, i);
+		xa_erase_index(xa, i);
 	}
 
 	for (i = 10; i < BITS_PER_LONG; i++) {
-		xa_insert_index(test, xa, 1UL << i);
+		xa_insert_index(xa, 1UL << i);
 		XA_BUG_ON(xa, xa_load(xa, (1UL << i) - 1) != NULL);
 		XA_BUG_ON(xa, xa_load(xa, (1UL << i) + 1) != NULL);
-		xa_erase_index(test, xa, 1UL << i);
+		xa_erase_index(xa, 1UL << i);
 
-		xa_insert_index(test, xa, (1UL << i) - 1);
+		xa_insert_index(xa, (1UL << i) - 1);
 		XA_BUG_ON(xa, xa_load(xa, (1UL << i) - 2) != NULL);
 		XA_BUG_ON(xa, xa_load(xa, 1UL << i) != NULL);
-		xa_erase_index(test, xa, (1UL << i) - 1);
+		xa_erase_index(xa, (1UL << i) - 1);
 	}
 
-	xa_insert_index(test, xa, ~0UL);
+	xa_insert_index(xa, ~0UL);
 	XA_BUG_ON(xa, xa_load(xa, 0UL) != NULL);
 	XA_BUG_ON(xa, xa_load(xa, ~1UL) != NULL);
-	xa_erase_index(test, xa, ~0UL);
+	xa_erase_index(xa, ~0UL);
 
 	XA_BUG_ON(xa, !xa_empty(xa));
 }
 
-static noinline void check_cmpxchg(struct kunit *test)
+static noinline void check_cmpxchg(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	void *FIVE = xa_mk_value(5);
 	void *SIX = xa_mk_value(6);
 	void *LOTS = xa_mk_value(12345678);
···
 	XA_BUG_ON(xa, xa_insert(xa, 5, FIVE, GFP_KERNEL) != -EBUSY);
 	XA_BUG_ON(xa, xa_cmpxchg(xa, 5, FIVE, NULL, GFP_KERNEL) != FIVE);
 	XA_BUG_ON(xa, xa_insert(xa, 5, FIVE, GFP_KERNEL) == -EBUSY);
-	xa_erase_index(test, xa, 12345678);
-	xa_erase_index(test, xa, 5);
+	xa_erase_index(xa, 12345678);
+	xa_erase_index(xa, 5);
 	XA_BUG_ON(xa, !xa_empty(xa));
 }
 
-static noinline void check_cmpxchg_order(struct kunit *test)
+static noinline void check_cmpxchg_order(struct xarray *xa)
 {
 #ifdef CONFIG_XARRAY_MULTI
-	struct xarray *xa = xa_param(test);
-
 	void *FIVE = xa_mk_value(5);
 	unsigned int i, order = 3;
 
···
 #endif
 }
 
-static noinline void check_reserve(struct kunit *test)
+static noinline void check_reserve(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	void *entry;
 	unsigned long index;
 	int count;
···
 	XA_BUG_ON(xa, xa_reserve(xa, 12345678, GFP_KERNEL) != 0);
 	XA_BUG_ON(xa, xa_store_index(xa, 12345678, GFP_NOWAIT) != NULL);
 	xa_release(xa, 12345678);
-	xa_erase_index(test, xa, 12345678);
+	xa_erase_index(xa, 12345678);
 	XA_BUG_ON(xa, !xa_empty(xa));
 
 	/* cmpxchg sees a reserved entry as ZERO */
···
 	XA_BUG_ON(xa, xa_cmpxchg(xa, 12345678, XA_ZERO_ENTRY,
 				xa_mk_value(12345678), GFP_NOWAIT) != NULL);
 	xa_release(xa, 12345678);
-	xa_erase_index(test, xa, 12345678);
+	xa_erase_index(xa, 12345678);
 	XA_BUG_ON(xa, !xa_empty(xa));
 
 	/* xa_insert treats it as busy */
···
 	xa_destroy(xa);
 }
 
-static noinline void check_xas_erase(struct kunit *test)
+static noinline void check_xas_erase(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE(xas, xa, 0);
 	void *entry;
 	unsigned long i, j;
···
 }
 
 #ifdef CONFIG_XARRAY_MULTI
-static noinline void check_multi_store_1(struct kunit *test, unsigned long index,
+static noinline void check_multi_store_1(struct xarray *xa, unsigned long index,
 		unsigned int order)
 {
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE(xas, xa, index);
 	unsigned long min = index & ~((1UL << order) - 1);
 	unsigned long max = min + (1UL << order);
···
 	XA_BUG_ON(xa, xa_load(xa, max) != NULL);
 	XA_BUG_ON(xa, xa_load(xa, min - 1) != NULL);
 
-	xa_erase_index(test, xa, min);
+	xa_erase_index(xa, min);
 	XA_BUG_ON(xa, !xa_empty(xa));
 }
 
-static noinline void check_multi_store_2(struct kunit *test, unsigned long index,
+static noinline void check_multi_store_2(struct xarray *xa, unsigned long index,
 		unsigned int order)
 {
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE(xas, xa, index);
 	xa_store_order(xa, index, order, xa_mk_value(0), GFP_KERNEL);
 
···
 	XA_BUG_ON(xa, !xa_empty(xa));
 }
 
-static noinline void check_multi_store_3(struct kunit *test, unsigned long index,
+static noinline void check_multi_store_3(struct xarray *xa, unsigned long index,
 		unsigned int order)
 {
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE(xas, xa, 0);
 	void *entry;
 	int n = 0;
···
 }
 #endif
 
-static noinline void check_multi_store(struct kunit *test)
+static noinline void check_multi_store(struct xarray *xa)
 {
 #ifdef CONFIG_XARRAY_MULTI
-	struct xarray *xa = xa_param(test);
-
 	unsigned long i, j, k;
 	unsigned int max_order = (sizeof(long) == 4) ? 30 : 60;
 
···
 	}
 
 	for (i = 0; i < 20; i++) {
-		check_multi_store_1(test, 200, i);
-		check_multi_store_1(test, 0, i);
-		check_multi_store_1(test, (1UL << i) + 1, i);
+		check_multi_store_1(xa, 200, i);
+		check_multi_store_1(xa, 0, i);
+		check_multi_store_1(xa, (1UL << i) + 1, i);
 	}
-	check_multi_store_2(test, 4095, 9);
+	check_multi_store_2(xa, 4095, 9);
 
 	for (i = 1; i < 20; i++) {
-		check_multi_store_3(test, 0, i);
-		check_multi_store_3(test, 1UL << i, i);
+		check_multi_store_3(xa, 0, i);
+		check_multi_store_3(xa, 1UL << i, i);
 	}
 #endif
 }
 
 #ifdef CONFIG_XARRAY_MULTI
 /* mimics page cache __filemap_add_folio() */
-static noinline void check_xa_multi_store_adv_add(struct kunit *test,
+static noinline void check_xa_multi_store_adv_add(struct xarray *xa,
 						  unsigned long index,
 						  unsigned int order,
 						  void *p)
 {
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE(xas, xa, index);
 	unsigned int nrpages = 1UL << order;
 
···
 }
 
 /* mimics page_cache_delete() */
-static noinline void check_xa_multi_store_adv_del_entry(struct kunit *test,
+static noinline void check_xa_multi_store_adv_del_entry(struct xarray *xa,
 							unsigned long index,
 							unsigned int order)
 {
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE(xas, xa, index);
 
 	xas_set_order(&xas, index, order);
···
 	xas_init_marks(&xas);
 }
 
-static noinline void check_xa_multi_store_adv_delete(struct kunit *test,
+static noinline void check_xa_multi_store_adv_delete(struct xarray *xa,
 						     unsigned long index,
 						     unsigned int order)
 {
-	struct xarray *xa = xa_param(test);
-
 	xa_lock_irq(xa);
-	check_xa_multi_store_adv_del_entry(test, index, order);
+	check_xa_multi_store_adv_del_entry(xa, index, order);
 	xa_unlock_irq(xa);
 }
 
···
 static unsigned long some_val_2 = 0xdeaddead;
 
 /* mimics the page cache usage */
-static noinline void check_xa_multi_store_adv(struct kunit *test,
+static noinline void check_xa_multi_store_adv(struct xarray *xa,
 					      unsigned long pos,
 					      unsigned int order)
 {
-	struct xarray *xa = xa_param(test);
-
 	unsigned int nrpages = 1UL << order;
 	unsigned long index, base, next_index, next_next_index;
 	unsigned int i;
···
 	next_index = round_down(base + nrpages, nrpages);
 	next_next_index = round_down(next_index + nrpages, nrpages);
 
-	check_xa_multi_store_adv_add(test, base, order, &some_val);
+	check_xa_multi_store_adv_add(xa, base, order, &some_val);
 
 	for (i = 0; i < nrpages; i++)
 		XA_BUG_ON(xa, test_get_entry(xa, base + i) != &some_val);
···
 	XA_BUG_ON(xa, test_get_entry(xa, next_index) != NULL);
 
 	/* Use order 0 for the next item */
-	check_xa_multi_store_adv_add(test, next_index, 0, &some_val_2);
+	check_xa_multi_store_adv_add(xa, next_index, 0, &some_val_2);
 	XA_BUG_ON(xa, test_get_entry(xa, next_index) != &some_val_2);
 
 	/* Remove the next item */
-	check_xa_multi_store_adv_delete(test, next_index, 0);
+	check_xa_multi_store_adv_delete(xa, next_index, 0);
 
 	/* Now use order for a new pointer */
-	check_xa_multi_store_adv_add(test, next_index, order, &some_val_2);
+	check_xa_multi_store_adv_add(xa, next_index, order, &some_val_2);
 
 	for (i = 0; i < nrpages; i++)
 		XA_BUG_ON(xa, test_get_entry(xa, next_index + i) != &some_val_2);
 
-	check_xa_multi_store_adv_delete(test, next_index, order);
-	check_xa_multi_store_adv_delete(test, base, order);
+	check_xa_multi_store_adv_delete(xa, next_index, order);
+	check_xa_multi_store_adv_delete(xa, base, order);
 	XA_BUG_ON(xa, !xa_empty(xa));
 
 	/* starting fresh again */
···
 	/* let's test some holes now */
 
 	/* hole at base and next_next */
-	check_xa_multi_store_adv_add(test, next_index, order, &some_val_2);
+	check_xa_multi_store_adv_add(xa, next_index, order, &some_val_2);
 
 	for (i = 0; i < nrpages; i++)
 		XA_BUG_ON(xa, test_get_entry(xa, base + i) != NULL);
···
 	for (i = 0; i < nrpages; i++)
 		XA_BUG_ON(xa, test_get_entry(xa, next_next_index + i) != NULL);
 
-	check_xa_multi_store_adv_delete(test, next_index, order);
+	check_xa_multi_store_adv_delete(xa, next_index, order);
 	XA_BUG_ON(xa, !xa_empty(xa));
 
 	/* hole at base and next */
 
-	check_xa_multi_store_adv_add(test, next_next_index, order, &some_val_2);
+	check_xa_multi_store_adv_add(xa, next_next_index, order, &some_val_2);
 
 	for (i = 0; i < nrpages; i++)
 		XA_BUG_ON(xa, test_get_entry(xa, base + i) != NULL);
···
 	for (i = 0; i < nrpages; i++)
 		XA_BUG_ON(xa, test_get_entry(xa, next_next_index + i) != &some_val_2);
 
-	check_xa_multi_store_adv_delete(test, next_next_index, order);
+	check_xa_multi_store_adv_delete(xa, next_next_index, order);
 	XA_BUG_ON(xa, !xa_empty(xa));
 }
 #endif
 
-static noinline void check_multi_store_advanced(struct kunit *test)
+static noinline void check_multi_store_advanced(struct xarray *xa)
 {
 #ifdef CONFIG_XARRAY_MULTI
 	unsigned int max_order = IS_ENABLED(CONFIG_XARRAY_MULTI) ? 20 : 1;
···
 	 */
 	for (pos = 7; pos < end; pos = (pos * pos) + 564) {
 		for (i = 0; i < max_order; i++) {
-			check_xa_multi_store_adv(test, pos, i);
-			check_xa_multi_store_adv(test, pos + 157, i);
+			check_xa_multi_store_adv(xa, pos, i);
+			check_xa_multi_store_adv(xa, pos + 157, i);
 		}
 	}
 #endif
 }
 
-static noinline void check_xa_alloc_1(struct kunit *test, struct xarray *xa, unsigned int base)
+static noinline void check_xa_alloc_1(struct xarray *xa, unsigned int base)
 {
 	int i;
 	u32 id;
 
 	XA_BUG_ON(xa, !xa_empty(xa));
 	/* An empty array should assign %base to the first alloc */
-	xa_alloc_index(test, xa, base, GFP_KERNEL);
+	xa_alloc_index(xa, base, GFP_KERNEL);
 
 	/* Erasing it should make the array empty again */
-	xa_erase_index(test, xa, base);
+	xa_erase_index(xa, base);
 	XA_BUG_ON(xa, !xa_empty(xa));
 
 	/* And it should assign %base again */
-	xa_alloc_index(test, xa, base, GFP_KERNEL);
+	xa_alloc_index(xa, base, GFP_KERNEL);
 
 	/* Allocating and then erasing a lot should not lose base */
 	for (i = base + 1; i < 2 * XA_CHUNK_SIZE; i++)
-		xa_alloc_index(test, xa, i, GFP_KERNEL);
+		xa_alloc_index(xa, i, GFP_KERNEL);
 	for (i = base; i < 2 * XA_CHUNK_SIZE; i++)
-		xa_erase_index(test, xa, i);
-	xa_alloc_index(test, xa, base, GFP_KERNEL);
+		xa_erase_index(xa, i);
+	xa_alloc_index(xa, base, GFP_KERNEL);
 
 	/* Destroying the array should do the same as erasing */
 	xa_destroy(xa);
 
 	/* And it should assign %base again */
-	xa_alloc_index(test, xa, base, GFP_KERNEL);
+	xa_alloc_index(xa, base, GFP_KERNEL);
 
 	/* The next assigned ID should be base+1 */
-	xa_alloc_index(test, xa, base + 1, GFP_KERNEL);
-	xa_erase_index(test, xa, base + 1);
+	xa_alloc_index(xa, base + 1, GFP_KERNEL);
+	xa_erase_index(xa, base + 1);
 
 	/* Storing a value should mark it used */
 	xa_store_index(xa, base + 1, GFP_KERNEL);
-	xa_alloc_index(test, xa, base + 2, GFP_KERNEL);
+	xa_alloc_index(xa, base + 2, GFP_KERNEL);
 
 	/* If we then erase base, it should be free */
-	xa_erase_index(test, xa, base);
-	xa_alloc_index(test, xa, base, GFP_KERNEL);
+	xa_erase_index(xa, base);
+	xa_alloc_index(xa, base, GFP_KERNEL);
 
-	xa_erase_index(test, xa, base + 1);
-	xa_erase_index(test, xa, base + 2);
+	xa_erase_index(xa, base + 1);
+	xa_erase_index(xa, base + 2);
 
 	for (i = 1; i < 5000; i++) {
-		xa_alloc_index(test, xa, base + i, GFP_KERNEL);
+		xa_alloc_index(xa, base + i, GFP_KERNEL);
 	}
 
 	xa_destroy(xa);
···
 
 	XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(10), XA_LIMIT(10, 5),
 				GFP_KERNEL) != -EBUSY);
-	XA_BUG_ON(xa, xa_store_index(xa, 3, GFP_KERNEL) != NULL);
+	XA_BUG_ON(xa, xa_store_index(xa, 3, GFP_KERNEL) != 0);
 	XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(10), XA_LIMIT(10, 5),
 				GFP_KERNEL) != -EBUSY);
-	xa_erase_index(test, xa, 3);
+	xa_erase_index(xa, 3);
 	XA_BUG_ON(xa, !xa_empty(xa));
 }
 
-static noinline void check_xa_alloc_2(struct kunit *test, struct xarray *xa, unsigned int base)
+static noinline void check_xa_alloc_2(struct xarray *xa, unsigned int base)
 {
 	unsigned int i, id;
 	unsigned long index;
···
 	XA_BUG_ON(xa, id != 5);
 
 	xa_for_each(xa, index, entry) {
-		xa_erase_index(test, xa, index);
+		xa_erase_index(xa, index);
 	}
 
 	for (i = base; i < base + 9; i++) {
···
 	xa_destroy(xa);
 }
 
-static noinline void check_xa_alloc_3(struct kunit *test, struct xarray *xa, unsigned int base)
+static noinline void check_xa_alloc_3(struct xarray *xa, unsigned int base)
 {
 	struct xa_limit limit = XA_LIMIT(1, 0x3fff);
 	u32 next = 0;
···
 	XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(0x3ffd), limit,
 				&next, GFP_KERNEL) != 0);
 	XA_BUG_ON(xa, id != 0x3ffd);
-	xa_erase_index(test, xa, 0x3ffd);
-	xa_erase_index(test, xa, 1);
+	xa_erase_index(xa, 0x3ffd);
+	xa_erase_index(xa, 1);
 	XA_BUG_ON(xa, !xa_empty(xa));
 
 	for (i = 0x3ffe; i < 0x4003; i++) {
···
 
 	/* Check wrap-around is handled correctly */
 	if (base != 0)
-		xa_erase_index(test, xa, base);
-	xa_erase_index(test, xa, base + 1);
+		xa_erase_index(xa, base);
+	xa_erase_index(xa, base + 1);
 	next = UINT_MAX;
 	XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(UINT_MAX),
 				xa_limit_32b, &next, GFP_KERNEL) != 0);
···
 	XA_BUG_ON(xa, id != base + 1);
 
 	xa_for_each(xa, index, entry)
-		xa_erase_index(test, xa, index);
+		xa_erase_index(xa, index);
 
 	XA_BUG_ON(xa, !xa_empty(xa));
 }
···
 static DEFINE_XARRAY_ALLOC(xa0);
 static DEFINE_XARRAY_ALLOC1(xa1);
 
-static noinline void check_xa_alloc(struct kunit *test)
+static noinline void check_xa_alloc(void)
 {
-	check_xa_alloc_1(test, &xa0, 0);
-	check_xa_alloc_1(test, &xa1, 1);
-	check_xa_alloc_2(test, &xa0, 0);
-	check_xa_alloc_2(test, &xa1, 1);
-	check_xa_alloc_3(test, &xa0, 0);
-	check_xa_alloc_3(test, &xa1, 1);
+	check_xa_alloc_1(&xa0, 0);
+	check_xa_alloc_1(&xa1, 1);
+	check_xa_alloc_2(&xa0, 0);
+	check_xa_alloc_2(&xa1, 1);
+	check_xa_alloc_3(&xa0, 0);
+	check_xa_alloc_3(&xa1, 1);
 }
 
-static noinline void __check_store_iter(struct kunit *test, unsigned long start,
+static noinline void __check_store_iter(struct xarray *xa, unsigned long start,
 			unsigned int order, unsigned int present)
 {
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE_ORDER(xas, xa, start, order);
 	void *entry;
 	unsigned int count = 0;
···
 	XA_BUG_ON(xa, xa_load(xa, start) != xa_mk_index(start));
 	XA_BUG_ON(xa, xa_load(xa, start + (1UL << order) - 1) !=
 			xa_mk_index(start));
-	xa_erase_index(test, xa, start);
+	xa_erase_index(xa, start);
 }
 
-static noinline void check_store_iter(struct kunit *test)
+static noinline void check_store_iter(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	unsigned int i, j;
 	unsigned int max_order = IS_ENABLED(CONFIG_XARRAY_MULTI) ? 20 : 1;
 
 	for (i = 0; i < max_order; i++) {
 		unsigned int min = 1 << i;
 		unsigned int max = (2 << i) - 1;
-		__check_store_iter(test, 0, i, 0);
+		__check_store_iter(xa, 0, i, 0);
 		XA_BUG_ON(xa, !xa_empty(xa));
-		__check_store_iter(test, min, i, 0);
+		__check_store_iter(xa, min, i, 0);
 		XA_BUG_ON(xa, !xa_empty(xa));
 
 		xa_store_index(xa, min, GFP_KERNEL);
-		__check_store_iter(test, min, i, 1);
+		__check_store_iter(xa, min, i, 1);
 		XA_BUG_ON(xa, !xa_empty(xa));
 		xa_store_index(xa, max, GFP_KERNEL);
-		__check_store_iter(test, min, i, 1);
+		__check_store_iter(xa, min, i, 1);
 		XA_BUG_ON(xa, !xa_empty(xa));
 
 		for (j = 0; j < min; j++)
 			xa_store_index(xa, j, GFP_KERNEL);
-		__check_store_iter(test, 0, i, min);
+		__check_store_iter(xa, 0, i, min);
 		XA_BUG_ON(xa, !xa_empty(xa));
 		for (j = 0; j < min; j++)
 			xa_store_index(xa, min + j, GFP_KERNEL);
-		__check_store_iter(test, min, i, min);
+		__check_store_iter(xa, min, i, min);
 		XA_BUG_ON(xa, !xa_empty(xa));
 	}
 #ifdef CONFIG_XARRAY_MULTI
 	xa_store_index(xa, 63, GFP_KERNEL);
 	xa_store_index(xa, 65, GFP_KERNEL);
-	__check_store_iter(test, 64, 2, 1);
-	xa_erase_index(test, xa, 63);
+	__check_store_iter(xa, 64, 2, 1);
+	xa_erase_index(xa, 63);
 #endif
 	XA_BUG_ON(xa, !xa_empty(xa));
 }
 
-static noinline void check_multi_find_1(struct kunit *test, unsigned int order)
+static noinline void check_multi_find_1(struct xarray *xa, unsigned order)
 {
 #ifdef CONFIG_XARRAY_MULTI
-	struct xarray *xa = xa_param(test);
-
 	unsigned long multi = 3 << order;
 	unsigned long next = 4 << order;
 	unsigned long index;
···
 	XA_BUG_ON(xa, xa_find_after(xa, &index, next, XA_PRESENT) != NULL);
 	XA_BUG_ON(xa, index != next);
 
-	xa_erase_index(test, xa, multi);
-	xa_erase_index(test, xa, next);
-	xa_erase_index(test, xa, next + 1);
+	xa_erase_index(xa, multi);
+	xa_erase_index(xa, next);
+	xa_erase_index(xa, next + 1);
 	XA_BUG_ON(xa, !xa_empty(xa));
 #endif
 }
 
-static noinline void check_multi_find_2(struct kunit *test)
+static noinline void check_multi_find_2(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	unsigned int max_order = IS_ENABLED(CONFIG_XARRAY_MULTI) ? 10 : 1;
 	unsigned int i, j;
 	void *entry;
···
 					GFP_KERNEL);
 			rcu_read_lock();
 			xas_for_each(&xas, entry, ULONG_MAX) {
-				xa_erase_index(test, xa, index);
+				xa_erase_index(xa, index);
 			}
 			rcu_read_unlock();
-			xa_erase_index(test, xa, index - 1);
+			xa_erase_index(xa, index - 1);
 			XA_BUG_ON(xa, !xa_empty(xa));
 		}
 	}
 }
 
-static noinline void check_multi_find_3(struct kunit *test)
+static noinline void check_multi_find_3(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	unsigned int order;
 
 	for (order = 5; order < order_limit; order++) {
···
 		XA_BUG_ON(xa, !xa_empty(xa));
 		xa_store_order(xa, 0, order - 4, xa_mk_index(0), GFP_KERNEL);
 		XA_BUG_ON(xa, xa_find_after(xa, &index, ULONG_MAX, XA_PRESENT));
-		xa_erase_index(test, xa, 0);
+		xa_erase_index(xa, 0);
 	}
 }
 
-static noinline void check_find_1(struct kunit *test)
+static noinline void check_find_1(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	unsigned long i, j, k;
 
 	XA_BUG_ON(xa, !xa_empty(xa));
···
 				else
 					XA_BUG_ON(xa, entry != NULL);
 			}
-			xa_erase_index(test, xa, j);
+			xa_erase_index(xa, j);
 			XA_BUG_ON(xa, xa_get_mark(xa, j, XA_MARK_0));
 			XA_BUG_ON(xa, !xa_get_mark(xa, i, XA_MARK_0));
 		}
-		xa_erase_index(test, xa, i);
+		xa_erase_index(xa, i);
 		XA_BUG_ON(xa, xa_get_mark(xa, i, XA_MARK_0));
 	}
 	XA_BUG_ON(xa, !xa_empty(xa));
 }
 
-static noinline void check_find_2(struct kunit *test)
+static noinline void check_find_2(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	void *entry;
 	unsigned long i, j, index;
 
···
 	xa_destroy(xa);
 }
 
-static noinline void check_find_3(struct kunit *test)
+static noinline void check_find_3(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE(xas, xa, 0);
 	unsigned long i, j, k;
 	void *entry;
···
 	xa_destroy(xa);
 }
 
-static noinline void check_find_4(struct kunit *test)
+static noinline void check_find_4(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	unsigned long index = 0;
 	void *entry;
 
···
 	entry = xa_find_after(xa, &index, ULONG_MAX, XA_PRESENT);
 	XA_BUG_ON(xa, entry);
 
-	xa_erase_index(test, xa, ULONG_MAX);
+	xa_erase_index(xa, ULONG_MAX);
 }
 
-static noinline void check_find(struct kunit *test)
+static noinline void check_find(struct xarray *xa)
 {
 	unsigned i;
 
-	check_find_1(test);
-	check_find_2(test);
-	check_find_3(test);
-	check_find_4(test);
+	check_find_1(xa);
+	check_find_2(xa);
+	check_find_3(xa);
+	check_find_4(xa);
 
 	for (i = 2; i < 10; i++)
-		check_multi_find_1(test, i);
-	check_multi_find_2(test);
-	check_multi_find_3(test);
+		check_multi_find_1(xa, i);
+	check_multi_find_2(xa);
+	check_multi_find_3(xa);
 }
 
 /* See find_swap_entry() in mm/shmem.c */
···
 	return entry ? xas.xa_index : -1;
 }
 
-static noinline void check_find_entry(struct kunit *test)
+static noinline void check_find_entry(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 #ifdef CONFIG_XARRAY_MULTI
 	unsigned int order;
 	unsigned long offset, index;
···
 	xa_store_index(xa, ULONG_MAX, GFP_KERNEL);
 	XA_BUG_ON(xa, xa_find_entry(xa, xa) != -1);
 	XA_BUG_ON(xa, xa_find_entry(xa, xa_mk_index(ULONG_MAX)) != -1);
-	xa_erase_index(test, xa, ULONG_MAX);
+	xa_erase_index(xa, ULONG_MAX);
 	XA_BUG_ON(xa, !xa_empty(xa));
 }
 
-static noinline void check_pause(struct kunit *test)
+static noinline void check_pause(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE(xas, xa, 0);
 	void *entry;
 	unsigned int order;
···
 
 }
 
-static noinline void check_move_tiny(struct kunit *test)
+static noinline void check_move_tiny(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE(xas, xa, 0);
 
 	XA_BUG_ON(xa, !xa_empty(xa));
···
 	XA_BUG_ON(xa, xas_prev(&xas) != xa_mk_index(0));
 	XA_BUG_ON(xa, xas_prev(&xas) != NULL);
 	rcu_read_unlock();
-	xa_erase_index(test, xa, 0);
+	xa_erase_index(xa, 0);
 	XA_BUG_ON(xa, !xa_empty(xa));
 }
 
-static noinline void check_move_max(struct kunit *test)
+static noinline void check_move_max(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE(xas, xa, 0);
 
 	xa_store_index(xa, ULONG_MAX, GFP_KERNEL);
···
 	XA_BUG_ON(xa, xas_find(&xas, ULONG_MAX) != NULL);
 	rcu_read_unlock();
 
-	xa_erase_index(test, xa, ULONG_MAX);
+	xa_erase_index(xa, ULONG_MAX);
 	XA_BUG_ON(xa, !xa_empty(xa));
 }
 
-static noinline void check_move_small(struct kunit *test, unsigned long idx)
+static noinline void check_move_small(struct xarray *xa, unsigned long idx)
 {
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE(xas, xa, 0);
 	unsigned long i;
 
···
 	XA_BUG_ON(xa, xas.xa_index != ULONG_MAX);
 	rcu_read_unlock();
 
-	xa_erase_index(test, xa, 0);
-	xa_erase_index(test, xa, idx);
+	xa_erase_index(xa, 0);
+	xa_erase_index(xa, idx);
 	XA_BUG_ON(xa, !xa_empty(xa));
 }
 
-static noinline void check_move(struct kunit *test)
+static noinline void check_move(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE(xas, xa, (1 << 16) - 1);
 	unsigned long i;
 
···
 	rcu_read_unlock();
 
 	for (i = (1 << 8); i < (1 << 15); i++)
-		xa_erase_index(test, xa, i);
+		xa_erase_index(xa, i);
 
 	i = xas.xa_index;
 
···
 
 	xa_destroy(xa);
 
-	check_move_tiny(test);
-	check_move_max(test);
+	check_move_tiny(xa);
+	check_move_max(xa);
 
 	for (i = 0; i < 16; i++)
-		check_move_small(test, 1UL << i);
+		check_move_small(xa, 1UL << i);
 
 	for (i = 2; i < 16; i++)
-		check_move_small(test, (1UL << i) - 1);
+		check_move_small(xa, (1UL << i) - 1);
 }
 
-static noinline void xa_store_many_order(struct kunit *test, struct xarray *xa,
+static noinline void xa_store_many_order(struct xarray *xa,
 		unsigned long index, unsigned order)
 {
 	XA_STATE_ORDER(xas, xa, index, order);
···
 	XA_BUG_ON(xa, xas_error(&xas));
 }
 
-static noinline void check_create_range_1(struct kunit *test,
+static noinline void check_create_range_1(struct xarray *xa,
 		unsigned long index, unsigned order)
 {
-	struct xarray *xa = xa_param(test);
-
 	unsigned long i;
 
-	xa_store_many_order(test, xa, index, order);
+	xa_store_many_order(xa, index, order);
 	for (i = index; i < index + (1UL << order); i++)
-		xa_erase_index(test, xa, i);
+		xa_erase_index(xa, i);
 	XA_BUG_ON(xa, !xa_empty(xa));
 }
 
-static noinline void check_create_range_2(struct kunit *test, unsigned int order)
+static noinline void check_create_range_2(struct xarray *xa, unsigned order)
 {
-	struct xarray *xa = xa_param(test);
-
 	unsigned long i;
 	unsigned long nr = 1UL << order;
 
 	for (i = 0; i < nr * nr; i += nr)
-		xa_store_many_order(test, xa, i, order);
+		xa_store_many_order(xa, i, order);
 	for (i = 0; i < nr * nr; i++)
-		xa_erase_index(test, xa, i);
+		xa_erase_index(xa, i);
 	XA_BUG_ON(xa, !xa_empty(xa));
 }
 
-static noinline void check_create_range_3(struct kunit *test)
+static noinline void check_create_range_3(void)
 {
 	XA_STATE(xas, NULL, 0);
 	xas_set_err(&xas, -EEXIST);
···
 	XA_BUG_ON(NULL, xas_error(&xas) != -EEXIST);
 }
 
-static noinline void check_create_range_4(struct kunit *test,
+static noinline void check_create_range_4(struct xarray *xa,
 		unsigned long index, unsigned order)
 {
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE_ORDER(xas, xa, index, order);
 	unsigned long base = xas.xa_index;
 	unsigned long i = 0;
···
 	XA_BUG_ON(xa, xas_error(&xas));
 
 	for (i = base; i < base + (1UL << order); i++)
-		xa_erase_index(test, xa, i);
+		xa_erase_index(xa, i);
 	XA_BUG_ON(xa, !xa_empty(xa));
 }
 
-static noinline void check_create_range_5(struct kunit *test,
+static noinline void check_create_range_5(struct xarray *xa,
 		unsigned long index, unsigned int order)
 {
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE_ORDER(xas, xa, index, order);
 	unsigned int i;
 
···
 	xa_destroy(xa);
 }
 
-static noinline void check_create_range(struct kunit *test)
+static noinline void check_create_range(struct xarray *xa)
 {
 	unsigned int order;
 	unsigned int max_order = IS_ENABLED(CONFIG_XARRAY_MULTI) ? 12 : 1;
 
 	for (order = 0; order < max_order; order++) {
-		check_create_range_1(test, 0, order);
-		check_create_range_1(test, 1U << order, order);
-		check_create_range_1(test, 2U << order, order);
-		check_create_range_1(test, 3U << order, order);
-		check_create_range_1(test, 1U << 24, order);
+		check_create_range_1(xa, 0, order);
+		check_create_range_1(xa, 1U << order, order);
+		check_create_range_1(xa, 2U << order, order);
+		check_create_range_1(xa, 3U << order, order);
+		check_create_range_1(xa, 1U << 24, order);
 		if (order < 10)
-			check_create_range_2(test, order);
+			check_create_range_2(xa, order);
 
-		check_create_range_4(test, 0, order);
-		check_create_range_4(test, 1U << order, order);
-		check_create_range_4(test, 2U << order, order);
-		check_create_range_4(test, 3U << order, order);
-		check_create_range_4(test, 1U << 24, order);
+		check_create_range_4(xa, 0, order);
+		check_create_range_4(xa, 1U << order, order);
+		check_create_range_4(xa, 2U << order, order);
+		check_create_range_4(xa, 3U << order, order);
+		check_create_range_4(xa, 1U << 24, order);
 
-		check_create_range_4(test, 1, order);
-		check_create_range_4(test, (1U << order) + 1, order);
-		check_create_range_4(test, (2U << order) + 1, order);
-		check_create_range_4(test, (2U << order) - 1, order);
-		check_create_range_4(test, (3U << order) + 1, order);
-		check_create_range_4(test, (3U << order) - 1, order);
-		check_create_range_4(test, (1U << 24) + 1, order);
+		check_create_range_4(xa, 1, order);
+		check_create_range_4(xa, (1U << order) + 1, order);
+		check_create_range_4(xa, (2U << order) + 1, order);
+		check_create_range_4(xa, (2U << order) - 1, order);
+		check_create_range_4(xa, (3U << order) + 1, order);
+		check_create_range_4(xa, (3U << order) - 1, order);
+		check_create_range_4(xa, (1U << 24) + 1, order);
 
-		check_create_range_5(test, 0, order);
-		check_create_range_5(test, (1U << order), order);
+		check_create_range_5(xa, 0, order);
+		check_create_range_5(xa, (1U << order), order);
 	}
 
-	check_create_range_3(test);
+	check_create_range_3();
 }
 
-static noinline void __check_store_range(struct kunit *test, unsigned long first,
+static noinline void __check_store_range(struct xarray *xa, unsigned long first,
 		unsigned long last)
 {
-	struct xarray *xa = xa_param(test);
-
 #ifdef CONFIG_XARRAY_MULTI
 	xa_store_range(xa, first, last, xa_mk_index(first), GFP_KERNEL);
 
···
 	XA_BUG_ON(xa, !xa_empty(xa));
 }
 
-static noinline void check_store_range(struct kunit *test)
+static noinline void check_store_range(struct xarray *xa)
 {
 	unsigned long i, j;
 
 	for (i = 0; i < 128; i++) {
 		for (j = i; j < 128; j++) {
-			__check_store_range(test, i, j);
-			__check_store_range(test, 128 + i, 128 + j);
-			__check_store_range(test, 4095 + i, 4095 + j);
-			__check_store_range(test, 4096 + i, 4096 + j);
-			__check_store_range(test, 123456 + i, 123456 + j);
-			__check_store_range(test, (1 << 24) + i, (1 << 24) + j);
+			__check_store_range(xa, i, j);
+			__check_store_range(xa, 128 + i, 128 + j);
+			__check_store_range(xa, 4095 + i, 4095 + j);
+			__check_store_range(xa, 4096 + i, 4096 + j);
+			__check_store_range(xa, 123456 + i, 123456 + j);
+			__check_store_range(xa, (1 << 24) + i, (1 << 24) + j);
 		}
 	}
 }
 
 #ifdef CONFIG_XARRAY_MULTI
-static void check_split_1(struct kunit *test, unsigned long index,
+static void check_split_1(struct xarray *xa, unsigned long index,
 				unsigned int order, unsigned int new_order)
 {
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE_ORDER(xas, xa, index, new_order);
 	unsigned int i, found;
 	void *entry;
···
 	xa_destroy(xa);
 }
 
-static noinline void check_split(struct kunit *test)
+static noinline void check_split(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	unsigned int order, new_order;
 
 	XA_BUG_ON(xa, !xa_empty(xa));
 
 	for (order = 1; order < 2 * XA_CHUNK_SHIFT; order++) {
 		for (new_order = 0; new_order < order; new_order++) {
-			check_split_1(test, 0, order, new_order);
-			check_split_1(test, 1UL << order, order, new_order);
-			check_split_1(test, 3UL << order, order, new_order);
+			check_split_1(xa, 0, order, new_order);
+			check_split_1(xa, 1UL << order, order, new_order);
+			check_split_1(xa, 3UL << order, order, new_order);
 		}
 	}
 }
 #else
-static void check_split(struct kunit *test) { }
+static void check_split(struct xarray *xa) { }
 #endif
 
-static void check_align_1(struct kunit *test, char *name)
+static void check_align_1(struct xarray *xa, char *name)
 {
-	struct xarray *xa = xa_param(test);
-
 	int i;
 	unsigned int id;
 	unsigned long index;
···
  * We should always be able to store without allocating memory after
  * reserving a slot.
  */
-static void check_align_2(struct kunit *test, char *name)
+static void check_align_2(struct xarray *xa, char *name)
 {
-	struct xarray *xa = xa_param(test);
-
 	int i;
 
 	XA_BUG_ON(xa, !xa_empty(xa));
···
 	XA_BUG_ON(xa, !xa_empty(xa));
 }
 
-static noinline void check_align(struct kunit *test)
+static noinline void check_align(struct xarray *xa)
 {
 	char name[] = "Motorola 68000";
 
-	check_align_1(test, name);
-	check_align_1(test, name + 1);
-	check_align_1(test, name + 2);
-	check_align_1(test, name + 3);
-	check_align_2(test, name);
+	check_align_1(xa, name);
+	check_align_1(xa, name + 1);
+	check_align_1(xa, name + 2);
+	check_align_1(xa, name + 3);
+	check_align_2(xa, name);
 }
 
 static LIST_HEAD(shadow_nodes);
···
 	}
 }
 
-static noinline void shadow_remove(struct kunit *test, struct xarray *xa)
+static noinline void shadow_remove(struct xarray *xa)
 {
 	struct xa_node *node;
 
···
 	xa_unlock(xa);
 }
 
-struct workingset_testcase {
-	struct xarray *xa;
-	unsigned long index;
-};
-
-static noinline void check_workingset(struct kunit *test)
+static noinline void check_workingset(struct xarray *xa, unsigned long index)
 {
-	struct workingset_testcase tc = *(struct workingset_testcase *)test->param_value;
-	struct xarray *xa = tc.xa;
-	unsigned long index = tc.index;
-
 	XA_STATE(xas, xa, index);
 	xas_set_update(&xas, test_update_node);
 
···
 	xas_unlock(&xas);
 	XA_BUG_ON(xa, list_empty(&shadow_nodes));
 
-	shadow_remove(test, xa);
+	shadow_remove(xa);
 	XA_BUG_ON(xa, !list_empty(&shadow_nodes));
 	XA_BUG_ON(xa, !xa_empty(xa));
 }
···
  * Check that the pointer / value / sibling entries are accounted the
  * way we expect them to be.
  */
-static noinline void check_account(struct kunit *test)
+static noinline void check_account(struct xarray *xa)
 {
 #ifdef CONFIG_XARRAY_MULTI
-	struct xarray *xa = xa_param(test);
-
 	unsigned int order;
 
 	for (order = 1; order < 12; order++) {
···
 #endif
 }
 
-static noinline void check_get_order(struct kunit *test)
+static noinline void check_get_order(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	unsigned int max_order = IS_ENABLED(CONFIG_XARRAY_MULTI) ? 20 : 1;
 	unsigned int order;
 	unsigned long i, j;
···
 	}
 }
 
-static noinline void check_xas_get_order(struct kunit *test)
+static noinline void check_xas_get_order(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE(xas, xa, 0);
 
 	unsigned int max_order = IS_ENABLED(CONFIG_XARRAY_MULTI) ? 20 : 1;
···
 	}
 }
 
-static noinline void check_xas_conflict_get_order(struct kunit *test)
+static noinline void check_xas_conflict_get_order(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	XA_STATE(xas, xa, 0);
 
 	void *entry;
···
 }
 
 
-static noinline void check_destroy(struct kunit *test)
+static noinline void check_destroy(struct xarray *xa)
 {
-	struct xarray *xa = xa_param(test);
-
 	unsigned long index;
 
 	XA_BUG_ON(xa, !xa_empty(xa));
···
 }
 
 static DEFINE_XARRAY(array);
-static struct xarray *arrays[] = { &array };
-KUNIT_ARRAY_PARAM(array, arrays, NULL);
 
-static struct xarray *xa0s[] = { &xa0 };
-KUNIT_ARRAY_PARAM(xa0, xa0s, NULL);
+static int xarray_checks(void)
+{
+	check_xa_err(&array);
+	check_xas_retry(&array);
+	check_xa_load(&array);
+	check_xa_mark(&array);
+	check_xa_shrink(&array);
+	check_xas_erase(&array);
+	check_insert(&array);
+	check_cmpxchg(&array);
+	check_cmpxchg_order(&array);
+	check_reserve(&array);
+	check_reserve(&xa0);
+	check_multi_store(&array);
+	check_multi_store_advanced(&array);
+	check_get_order(&array);
+	check_xas_get_order(&array);
+	check_xas_conflict_get_order(&array);
+	check_xa_alloc();
+	check_find(&array);
+	check_find_entry(&array);
+	check_pause(&array);
+	check_account(&array);
+	check_destroy(&array);
+	check_move(&array);
+	check_create_range(&array);
+	check_store_range(&array);
+	check_store_iter(&array);
+	check_align(&xa0);
+	check_split(&array);
 
-static struct workingset_testcase workingset_testcases[] = {
-	{ &array, 0 },
-	{ &array, 64 },
-	{ &array, 4096 },
-};
-KUNIT_ARRAY_PARAM(workingset, workingset_testcases, NULL);
+	check_workingset(&array, 0);
+	check_workingset(&array, 64);
+	check_workingset(&array, 4096);
 
-static struct kunit_case xarray_cases[] = {
-	KUNIT_CASE_PARAM(check_xa_err, array_gen_params),
-	KUNIT_CASE_PARAM(check_xas_retry, array_gen_params),
-	KUNIT_CASE_PARAM(check_xa_load, array_gen_params),
-	KUNIT_CASE_PARAM(check_xa_mark, array_gen_params),
-	KUNIT_CASE_PARAM(check_xa_shrink, array_gen_params),
-	KUNIT_CASE_PARAM(check_xas_erase, array_gen_params),
-	KUNIT_CASE_PARAM(check_insert, array_gen_params),
-	KUNIT_CASE_PARAM(check_cmpxchg, array_gen_params),
-	KUNIT_CASE_PARAM(check_cmpxchg_order, array_gen_params),
-	KUNIT_CASE_PARAM(check_reserve, array_gen_params),
-	KUNIT_CASE_PARAM(check_reserve, xa0_gen_params),
-	KUNIT_CASE_PARAM(check_multi_store, array_gen_params),
-	KUNIT_CASE_PARAM(check_multi_store_advanced, array_gen_params),
-	KUNIT_CASE_PARAM(check_get_order, array_gen_params),
-	KUNIT_CASE_PARAM(check_xas_get_order, array_gen_params),
-	KUNIT_CASE_PARAM(check_xas_conflict_get_order, array_gen_params),
-	KUNIT_CASE(check_xa_alloc),
-	KUNIT_CASE_PARAM(check_find, array_gen_params),
-	KUNIT_CASE_PARAM(check_find_entry, array_gen_params),
-	KUNIT_CASE_PARAM(check_pause, array_gen_params),
-	KUNIT_CASE_PARAM(check_account, array_gen_params),
-	KUNIT_CASE_PARAM(check_destroy, array_gen_params),
-	KUNIT_CASE_PARAM(check_move, array_gen_params),
-	KUNIT_CASE_PARAM(check_create_range, array_gen_params),
-	KUNIT_CASE_PARAM(check_store_range, array_gen_params),
-	KUNIT_CASE_PARAM(check_store_iter, array_gen_params),
-	KUNIT_CASE_PARAM(check_align, xa0_gen_params),
-	KUNIT_CASE_PARAM(check_split, array_gen_params),
-	KUNIT_CASE_PARAM(check_workingset, workingset_gen_params),
-	{},
-};
+	printk("XArray: %u of %u tests passed\n", tests_passed, tests_run);
+	return (tests_run == tests_passed) ? 0 : -EINVAL;
+}
 
-static struct kunit_suite xarray_suite = {
-	.name = "xarray",
-	.test_cases = xarray_cases,
-};
+static void xarray_exit(void)
+{
+}
 
-kunit_test_suite(xarray_suite);
-
+module_init(xarray_checks);
+module_exit(xarray_exit);
 MODULE_AUTHOR("Matthew Wilcox <[e-mail]>");
 MODULE_DESCRIPTION("XArray API test module");
 MODULE_LICENSE("GPL");

mm/compaction.c

···
  */
 static enum compact_result
 compaction_suit_allocation_order(struct zone *zone, unsigned int order,
-				 int highest_zoneidx, unsigned int alloc_flags)
+				 int highest_zoneidx, unsigned int alloc_flags,
+				 bool async)
 {
 	unsigned long watermark;
 
···
 	if (zone_watermark_ok(zone, order, watermark, highest_zoneidx,
 			      alloc_flags))
 		return COMPACT_SUCCESS;
+
+	/*
+	 * For unmovable allocations (without ALLOC_CMA), check if there is enough
+	 * free memory in the non-CMA pageblocks. Otherwise compaction could form
+	 * the high-order page in CMA pageblocks, which would not help the
+	 * allocation to succeed. However, limit the check to costly order async
+	 * compaction (such as opportunistic THP attempts) because there is the
+	 * possibility that compaction would migrate pages from non-CMA to CMA
+	 * pageblock.
+	 */
+	if (order > PAGE_ALLOC_COSTLY_ORDER && async &&
+	    !(alloc_flags & ALLOC_CMA)) {
+		watermark = low_wmark_pages(zone) + compact_gap(order);
+		if (!__zone_watermark_ok(zone, 0, watermark, highest_zoneidx,
+					   0, zone_page_state(zone, NR_FREE_PAGES)))
+			return COMPACT_SKIPPED;
+	}
 
 	if (!compaction_suitable(zone, order, highest_zoneidx))
 		return COMPACT_SKIPPED;
···
 	if (!is_via_compact_memory(cc->order)) {
 		ret = compaction_suit_allocation_order(cc->zone, cc->order,
 						       cc->highest_zoneidx,
-						       cc->alloc_flags);
+						       cc->alloc_flags,
+						       cc->mode == MIGRATE_ASYNC);
 		if (ret != COMPACT_CONTINUE)
 			return ret;
 	}
···
 
 		ret = compaction_suit_allocation_order(zone,
 				pgdat->kcompactd_max_order,
-				highest_zoneidx, ALLOC_WMARK_MIN);
+				highest_zoneidx, ALLOC_WMARK_MIN,
+				false);
 		if (ret == COMPACT_CONTINUE)
 			return true;
 	}
···
 			continue;
 
 		ret = compaction_suit_allocation_order(zone,
-				cc.order, zoneid, ALLOC_WMARK_MIN);
+				cc.order, zoneid, ALLOC_WMARK_MIN,
+				false);
 		if (ret != COMPACT_CONTINUE)
 			continue;
 

mm/gup.c

···
 /*
  * Returns the number of collected folios. Return value is always >= 0.
  */
-static unsigned long collect_longterm_unpinnable_folios(
+static void collect_longterm_unpinnable_folios(
 		struct list_head *movable_folio_list,
 		struct pages_or_folios *pofs)
 {
-	unsigned long i, collected = 0;
 	struct folio *prev_folio = NULL;
 	bool drain_allow = true;
+	unsigned long i;
 
 	for (i = 0; i < pofs->nr_entries; i++) {
 		struct folio *folio = pofs_get_folio(pofs, i);
···
 
 		if (folio_is_longterm_pinnable(folio))
 			continue;
-
-		collected++;
 
 		if (folio_is_device_coherent(folio))
 			continue;
···
 				    NR_ISOLATED_ANON + folio_is_file_lru(folio),
 				    folio_nr_pages(folio));
 	}
-
-	return collected;
 }
 
 /*
···
 check_and_migrate_movable_pages_or_folios(struct pages_or_folios *pofs)
 {
 	LIST_HEAD(movable_folio_list);
-	unsigned long collected;
 
-	collected = collect_longterm_unpinnable_folios(&movable_folio_list,
-						       pofs);
-	if (!collected)
+	collect_longterm_unpinnable_folios(&movable_folio_list, pofs);
+	if (list_empty(&movable_folio_list))
 		return 0;
 
 	return migrate_longterm_unpinnable_folios(&movable_folio_list, pofs);

mm/hugetlb.c

···
 		.thread_fn	= gather_bootmem_prealloc_parallel,
 		.fn_arg		= NULL,
 		.start		= 0,
-		.size		= num_node_state(N_MEMORY),
+		.size		= nr_node_ids,
 		.align		= 1,
 		.min_chunk	= 1,
 		.max_threads	= num_node_state(N_MEMORY),

mm/kfence/core.c

···
 #include <linux/log2.h>
 #include <linux/memblock.h>
 #include <linux/moduleparam.h>
+#include <linux/nodemask.h>
 #include <linux/notifier.h>
 #include <linux/panic_notifier.h>
 #include <linux/random.h>
···
 	 * properties (e.g. reside in DMAable memory).
 	 */
 	if ((flags & GFP_ZONEMASK) ||
+	    ((flags & __GFP_THISNODE) && num_online_nodes() > 1) ||
 	    (s->flags & (SLAB_CACHE_DMA | SLAB_CACHE_DMA32))) {
 		atomic_long_inc(&counters[KFENCE_COUNTER_SKIP_INCOMPAT]);
 		return NULL;

mm/kmemleak.c

···
 			unsigned long phys = object->pointer;
 
 			if (PHYS_PFN(phys) < min_low_pfn ||
-			    PHYS_PFN(phys + object->size) >= max_low_pfn)
+			    PHYS_PFN(phys + object->size) > max_low_pfn)
 				__paint_it(object, KMEMLEAK_BLACK);
 		}
 

mm/swapfile.c

···
 		if (!cluster_scan_range(si, ci, offset, nr_pages, &need_reclaim))
 			continue;
 		if (need_reclaim) {
-			ret = cluster_reclaim_range(si, ci, start, end);
+			ret = cluster_reclaim_range(si, ci, offset, offset + nr_pages);
 			/*
 			 * Reclaim drops ci->lock and cluster could be used
 			 * by another order. Not checking flag as off-list

mm/vmscan.c

···
 	struct folio_batch free_folios;
 	LIST_HEAD(ret_folios);
 	LIST_HEAD(demote_folios);
-	unsigned int nr_reclaimed = 0;
+	unsigned int nr_reclaimed = 0, nr_demoted = 0;
 	unsigned int pgactivate = 0;
 	bool do_demote_pass;
 	struct swap_iocb *plug = NULL;
···
 	/* 'folio_list' is always empty here */
 
 	/* Migrate folios selected for demotion */
-	stat->nr_demoted = demote_folio_list(&demote_folios, pgdat);
-	nr_reclaimed += stat->nr_demoted;
+	nr_demoted = demote_folio_list(&demote_folios, pgdat);
+	nr_reclaimed += nr_demoted;
+	stat->nr_demoted += nr_demoted;
 	/* Folios that could not be demoted are still in @demote_folios */
 	if (!list_empty(&demote_folios)) {
 		/* Folios which weren't demoted go back on @folio_list */
···
 	unsigned long nr_skipped[MAX_NR_ZONES] = { 0, };
 	unsigned long skipped = 0;
 	unsigned long scan, total_scan, nr_pages;
+	unsigned long max_nr_skipped = 0;
 	LIST_HEAD(folios_skipped);
 
 	total_scan = 0;
···
 		nr_pages = folio_nr_pages(folio);
 		total_scan += nr_pages;
 
-		if (folio_zonenum(folio) > sc->reclaim_idx) {
+		/* Using max_nr_skipped to prevent hard LOCKUP*/
+		if (max_nr_skipped < SWAP_CLUSTER_MAX_SKIPPED &&
+		    (folio_zonenum(folio) > sc->reclaim_idx)) {
 			nr_skipped[folio_zonenum(folio)] += nr_pages;
 			move_to = &folios_skipped;
+			max_nr_skipped++;
 			goto move;
 		}
 

mm/zsmalloc.c

···
 	.lock	= INIT_LOCAL_LOCK(lock),
 };
 
-static inline bool is_first_zpdesc(struct zpdesc *zpdesc)
+static inline bool __maybe_unused is_first_zpdesc(struct zpdesc *zpdesc)
 {
 	return PagePrivate(zpdesc_page(zpdesc));
 }

scripts/gdb/linux/cpus.py

···
             var_ptr = gdb.parse_and_eval("&pcpu_hot.current_task")
             return per_cpu(var_ptr, cpu).dereference()
     elif utils.is_target_arch("aarch64"):
-        current_task_addr = gdb.parse_and_eval("$SP_EL0")
+        current_task_addr = gdb.parse_and_eval("(unsigned long)$SP_EL0")
         if (current_task_addr >> 63) != 0:
             current_task = current_task_addr.cast(task_ptr_type)
             return current_task.dereference()