revert "xarray: port tests to kunit"

Revert c7bb5cf9fc4e ("xarray: port tests to kunit").  It broke the build
when compiing the xarray userspace test harness code.

Reported-by: Sidhartha Kumar <sidhartha.kumar@oracle.com>
Closes: https://lkml.kernel.org/r/07cf896e-adf8-414f-a629-a808fc26014a@oracle.com
Cc: David Gow <davidgow@google.com>
Cc: Matthew Wilcox <willy@infradead.org>
Cc: Tamir Duberstein <tamird@gmail.com>
Cc: "Liam R. Howlett" <Liam.Howlett@oracle.com>
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Lorenzo Stoakes <lorenzo.stoakes@oracle.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/arch/m68k/configs/amiga_defconfig b/arch/m68k/configs/amiga_defconfig
index 8acfa66e109542bdbca1adc282ee01b6bed4deed..dbf2ea561c855130314b12203c7fb1b0e3d63dbb 100644 (file)
--- a/arch/m68k/configs/amiga_defconfig
+++ b/arch/m68k/configs/amiga_defconfig
@@ -626,6 +626,7 @@ CONFIG_TEST_PRINTF=m
 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

diff --git a/arch/m68k/configs/apollo_defconfig b/arch/m68k/configs/apollo_defconfig
index 35e9a08723048afb52b4fe23c860c7fc1ba89d64..b0fd199cc0a4e7b8486bb97d2b9c4343d39115fb 100644 (file)
--- a/arch/m68k/configs/apollo_defconfig
+++ b/arch/m68k/configs/apollo_defconfig
@@ -583,6 +583,7 @@ CONFIG_TEST_PRINTF=m
 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

diff --git a/arch/m68k/configs/atari_defconfig b/arch/m68k/configs/atari_defconfig
index 32891ddd3cc591b1050ea2451e32fa1186a6f9ad..bb5b2d3b6c103ccac0a4b4fd81d1df7bed35debd 100644 (file)
--- a/arch/m68k/configs/atari_defconfig
+++ b/arch/m68k/configs/atari_defconfig
@@ -603,6 +603,7 @@ CONFIG_TEST_PRINTF=m
 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

diff --git a/arch/m68k/configs/bvme6000_defconfig b/arch/m68k/configs/bvme6000_defconfig
index ca276f0db3dd1a260d267a9d466872088316c3f6..8315a13bab73baa16fe6cc7d3c497dfbe9fb3394 100644 (file)
--- a/arch/m68k/configs/bvme6000_defconfig
+++ b/arch/m68k/configs/bvme6000_defconfig
@@ -575,6 +575,7 @@ CONFIG_TEST_PRINTF=m
 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

diff --git a/arch/m68k/configs/hp300_defconfig b/arch/m68k/configs/hp300_defconfig
index e83f14fe1a4f85515bc19fef8a63da15c79a729d..350370657e5fe94d6a5a2a1aae366dab4166569a 100644 (file)
--- a/arch/m68k/configs/hp300_defconfig
+++ b/arch/m68k/configs/hp300_defconfig
@@ -585,6 +585,7 @@ CONFIG_TEST_PRINTF=m
 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

diff --git a/arch/m68k/configs/mac_defconfig b/arch/m68k/configs/mac_defconfig
index 6b58be24da7931996a70188343769027a6dc80aa..f942b4755702656fc2bf9a4a54ccd2532fb6932d 100644 (file)
--- a/arch/m68k/configs/mac_defconfig
+++ b/arch/m68k/configs/mac_defconfig
@@ -602,6 +602,7 @@ CONFIG_TEST_PRINTF=m
 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

diff --git a/arch/m68k/configs/multi_defconfig b/arch/m68k/configs/multi_defconfig
index 0e8d24f825656232df788864e3311ab4c5747286..b1eaad02efab92dc6e4b27893b00e20496c70f3f 100644 (file)
--- a/arch/m68k/configs/multi_defconfig
+++ b/arch/m68k/configs/multi_defconfig
@@ -689,6 +689,7 @@ CONFIG_TEST_PRINTF=m
 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

diff --git a/arch/m68k/configs/mvme147_defconfig b/arch/m68k/configs/mvme147_defconfig
index 24a7608c13ac70794397ddf9f5d8486003be63c4..6309a4442bb3f962a4d87760b8f999ed4b43323a 100644 (file)
--- a/arch/m68k/configs/mvme147_defconfig
+++ b/arch/m68k/configs/mvme147_defconfig
@@ -575,6 +575,7 @@ CONFIG_TEST_PRINTF=m
 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

diff --git a/arch/m68k/configs/mvme16x_defconfig b/arch/m68k/configs/mvme16x_defconfig
index c415f75821f39d9cdad78e391c36479c88c1a990..3feb0731f8142d0c2bd5b81539afe9a08bb41d48 100644 (file)
--- a/arch/m68k/configs/mvme16x_defconfig
+++ b/arch/m68k/configs/mvme16x_defconfig
@@ -576,6 +576,7 @@ CONFIG_TEST_PRINTF=m
 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

diff --git a/arch/m68k/configs/q40_defconfig b/arch/m68k/configs/q40_defconfig
index 2c715a8ff551ef3464dab3027e322a2b8e687d07..ea04b1b0da7d466133d6a3b060477cde6ac30c59 100644 (file)
--- a/arch/m68k/configs/q40_defconfig
+++ b/arch/m68k/configs/q40_defconfig
@@ -592,6 +592,7 @@ CONFIG_TEST_PRINTF=m
 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

diff --git a/arch/m68k/configs/sun3_defconfig b/arch/m68k/configs/sun3_defconfig
index 15ff37fcccbfbbd7b37991c45bfab5d32456e57e..f52d9af92153dbd3bbbc7520d6bb3bbd1e37743a 100644 (file)
--- a/arch/m68k/configs/sun3_defconfig
+++ b/arch/m68k/configs/sun3_defconfig
@@ -572,6 +572,7 @@ CONFIG_TEST_PRINTF=m
 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

diff --git a/arch/m68k/configs/sun3x_defconfig b/arch/m68k/configs/sun3x_defconfig
index 40a44bf9f48d16166bdf8437dba95eb4b09a8a3b..f348447824da930f72c2965f90db0122a48d10cd 100644 (file)
--- a/arch/m68k/configs/sun3x_defconfig
+++ b/arch/m68k/configs/sun3x_defconfig
@@ -573,6 +573,7 @@ CONFIG_TEST_PRINTF=m
 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

diff --git a/arch/powerpc/configs/ppc64_defconfig b/arch/powerpc/configs/ppc64_defconfig
index e9c46b59ebbcb2eb6bd0921fe7b86c4ec9d586b6..465eb96c755e0f8bf9a7245fcab4ebb9b540f201 100644 (file)
--- a/arch/powerpc/configs/ppc64_defconfig
+++ b/arch/powerpc/configs/ppc64_defconfig
@@ -448,6 +448,7 @@ CONFIG_TEST_PRINTF=m
 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

diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index 775966cf6114e2a7f8e642fd1b6bd347a2f96834..1af972a92d06f6e3f7beec4bd086c00b412c83ac 100644 (file)
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -2456,22 +2456,8 @@ config TEST_BITMAP
 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"

diff --git a/lib/Makefile b/lib/Makefile
index f1c6e9d76a7c057942178d0de9371b266d889aec..d5cfc7afbbb8215cdb8d03c26fe7b7be13d75d24 100644 (file)
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -94,6 +94,7 @@ GCOV_PROFILE_test_bitmap.o := n
 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
@@ -372,7 +373,6 @@ CFLAGS_bitfield_kunit.o := $(DISABLE_STRUCTLEAK_PLUGIN)
 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

diff --git a/lib/test_xarray.c b/lib/test_xarray.c
index eab5971d0a481e284987821b55c388766265a90b..6932a26f4927cfc37d255264063c1f193d8513c7 100644 (file)
--- a/lib/test_xarray.c
+++ b/lib/test_xarray.c
@@ -6,10 +6,11 @@
  * Author: Matthew Wilcox <willy@infradead.org>
  */
 
-#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;
@@ -19,12 +20,15 @@ static const unsigned int order_limit =
 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
 
@@ -38,13 +42,13 @@ static void *xa_store_index(struct xarray *xa, unsigned long index, gfp_t gfp)
        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;
 
@@ -53,7 +57,7 @@ static void xa_alloc_index(struct kunit *test, struct xarray *xa, unsigned long
        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);
@@ -79,15 +83,8 @@ static void *xa_store_order(struct xarray *xa, unsigned long index,
        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__
@@ -102,10 +99,8 @@ static noinline void check_xa_err(struct kunit *test)
 //     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;
 
@@ -114,7 +109,7 @@ static noinline void check_xas_retry(struct kunit *test)
 
        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)));
@@ -145,14 +140,12 @@ static noinline void check_xas_retry(struct kunit *test)
        }
        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++) {
@@ -174,15 +167,13 @@ static noinline void check_xa_load(struct kunit *test)
                        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;
 
@@ -202,7 +193,7 @@ static noinline void check_xa_mark_1(struct kunit *test, unsigned long index)
        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);
@@ -253,17 +244,15 @@ static noinline void check_xa_mark_1(struct kunit *test, unsigned long index)
                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;
@@ -300,11 +289,9 @@ static noinline void check_xa_mark_2(struct kunit *test)
        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;
@@ -323,21 +310,19 @@ static noinline void check_xa_mark_3(struct kunit *test)
 #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;
@@ -362,7 +347,7 @@ static noinline void check_xa_shrink(struct kunit *test)
        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++) {
@@ -379,49 +364,45 @@ static noinline void check_xa_shrink(struct kunit *test)
                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);
@@ -437,16 +418,14 @@ static noinline void check_cmpxchg(struct kunit *test)
        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;
 
@@ -497,10 +476,8 @@ static noinline void check_cmpxchg_order(struct kunit *test)
 #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;
@@ -517,7 +494,7 @@ static noinline void check_reserve(struct kunit *test)
        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 */
@@ -525,7 +502,7 @@ static noinline void check_reserve(struct kunit *test)
        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 */
@@ -565,10 +542,8 @@ static noinline void check_reserve(struct kunit *test)
        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;
@@ -606,11 +581,9 @@ static noinline void check_xas_erase(struct kunit *test)
 }
 
 #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);
@@ -629,15 +602,13 @@ static noinline void check_multi_store_1(struct kunit *test, unsigned long index
        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);
 
@@ -649,11 +620,9 @@ static noinline void check_multi_store_2(struct kunit *test, unsigned long index
        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;
@@ -678,11 +647,9 @@ static noinline void check_multi_store_3(struct kunit *test, unsigned long index
 }
 #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;
 
@@ -747,28 +714,26 @@ static noinline void check_multi_store(struct kunit *test)
        }
 
        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;
 
@@ -796,12 +761,10 @@ static noinline void check_xa_multi_store_adv_add(struct kunit *test,
 }
 
 /* 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);
@@ -809,14 +772,12 @@ static noinline void check_xa_multi_store_adv_del_entry(struct kunit *test,
        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);
 }
 
@@ -853,12 +814,10 @@ static unsigned long some_val = 0xdeadbeef;
 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;
@@ -868,7 +827,7 @@ static noinline void check_xa_multi_store_adv(struct kunit *test,
        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);
@@ -876,20 +835,20 @@ static noinline void check_xa_multi_store_adv(struct kunit *test,
        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 */
@@ -897,7 +856,7 @@ static noinline void check_xa_multi_store_adv(struct kunit *test,
        /* 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);
@@ -908,12 +867,12 @@ static noinline void check_xa_multi_store_adv(struct kunit *test,
        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);
@@ -924,12 +883,12 @@ static noinline void check_xa_multi_store_adv(struct kunit *test,
        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;
@@ -941,59 +900,59 @@ static noinline void check_multi_store_advanced(struct kunit *test)
         */
        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);
@@ -1016,14 +975,14 @@ static noinline void check_xa_alloc_1(struct kunit *test, struct xarray *xa, uns
 
        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;
@@ -1059,7 +1018,7 @@ static noinline void check_xa_alloc_2(struct kunit *test, struct xarray *xa, uns
        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++) {
@@ -1074,7 +1033,7 @@ static noinline void check_xa_alloc_2(struct kunit *test, struct xarray *xa, uns
        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;
@@ -1090,8 +1049,8 @@ static noinline void check_xa_alloc_3(struct kunit *test, struct xarray *xa, uns
        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++) {
@@ -1106,8 +1065,8 @@ static noinline void check_xa_alloc_3(struct kunit *test, struct xarray *xa, uns
 
        /* 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);
@@ -1120,7 +1079,7 @@ static noinline void check_xa_alloc_3(struct kunit *test, struct xarray *xa, uns
        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));
 }
@@ -1128,21 +1087,19 @@ static noinline void check_xa_alloc_3(struct kunit *test, struct xarray *xa, uns
 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;
@@ -1166,54 +1123,50 @@ retry:
        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;
@@ -1236,17 +1189,15 @@ static noinline void check_multi_find_1(struct kunit *test, unsigned int order)
        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;
@@ -1260,19 +1211,17 @@ static noinline void check_multi_find_2(struct kunit *test)
                                        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++) {
@@ -1281,14 +1230,12 @@ static noinline void check_multi_find_3(struct kunit *test)
                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));
@@ -1325,20 +1272,18 @@ static noinline void check_find_1(struct kunit *test)
                                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;
 
@@ -1358,10 +1303,8 @@ static noinline void check_find_2(struct kunit *test)
        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;
@@ -1385,10 +1328,8 @@ static noinline void check_find_3(struct kunit *test)
        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;
 
@@ -1400,22 +1341,22 @@ static noinline void check_find_4(struct kunit *test)
        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 */
@@ -1441,10 +1382,8 @@ static noinline unsigned long xa_find_entry(struct xarray *xa, void *item)
        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;
@@ -1471,14 +1410,12 @@ static noinline void check_find_entry(struct kunit *test)
        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;
@@ -1548,10 +1485,8 @@ static noinline void check_pause(struct kunit *test)
 
 }
 
-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));
@@ -1568,14 +1503,12 @@ static noinline void check_move_tiny(struct kunit *test)
        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);
@@ -1591,14 +1524,12 @@ static noinline void check_move_max(struct kunit *test)
        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;
 
@@ -1640,15 +1571,13 @@ static noinline void check_move_small(struct kunit *test, unsigned long idx)
        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;
 
@@ -1675,7 +1604,7 @@ static noinline void check_move(struct kunit *test)
        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;
 
@@ -1706,17 +1635,17 @@ static noinline void check_move(struct kunit *test)
 
        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);
@@ -1739,34 +1668,30 @@ unlock:
        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);
@@ -1774,11 +1699,9 @@ static noinline void check_create_range_3(struct kunit *test)
        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;
@@ -1804,15 +1727,13 @@ unlock:
        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;
 
@@ -1829,46 +1750,44 @@ static noinline void check_create_range_5(struct kunit *test,
        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_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(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_5(test, 0, order);
-               check_create_range_5(test, (1U << order), order);
+                       check_create_range_2(xa, 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(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(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);
 
@@ -1883,28 +1802,26 @@ static noinline void __check_store_range(struct kunit *test, unsigned long first
        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;
@@ -1940,30 +1857,26 @@ static void check_split_1(struct kunit *test, unsigned long index,
        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;
@@ -1983,10 +1896,8 @@ static void check_align_1(struct kunit *test, char *name)
  * 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));
@@ -2005,15 +1916,15 @@ static void check_align_2(struct kunit *test, char *name)
        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);
@@ -2029,7 +1940,7 @@ static void test_update_node(struct xa_node *node)
        }
 }
 
-static noinline void shadow_remove(struct kunit *test, struct xarray *xa)
+static noinline void shadow_remove(struct xarray *xa)
 {
        struct xa_node *node;
 
@@ -2043,17 +1954,8 @@ static noinline void shadow_remove(struct kunit *test, struct xarray *xa)
        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);
 
@@ -2076,7 +1978,7 @@ static noinline void check_workingset(struct kunit *test)
        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));
 }
@@ -2085,11 +1987,9 @@ static noinline void check_workingset(struct kunit *test)
  * 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++) {
@@ -2116,10 +2016,8 @@ static noinline void check_account(struct kunit *test)
 #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;
@@ -2138,10 +2036,8 @@ static noinline void check_get_order(struct kunit *test)
        }
 }
 
-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;
@@ -2173,10 +2069,8 @@ static noinline void check_xas_get_order(struct kunit *test)
        }
 }
 
-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;
@@ -2233,10 +2127,8 @@ static noinline void check_xas_conflict_get_order(struct kunit *test)
 }
 
 
-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));
@@ -2269,59 +2161,52 @@ static noinline void check_destroy(struct kunit *test)
 }
 
 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 struct workingset_testcase workingset_testcases[] = {
-       { &array, 0 },
-       { &array, 64 },
-       { &array, 4096 },
-};
-KUNIT_ARRAY_PARAM(workingset, workingset_testcases, NULL);
-
-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),
-       {},
-};
-
-static struct kunit_suite xarray_suite = {
-       .name = "xarray",
-       .test_cases = xarray_cases,
-};
-
-kunit_test_suite(xarray_suite);
 
+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);
+
+       check_workingset(&array, 0);
+       check_workingset(&array, 64);
+       check_workingset(&array, 4096);
+
+       printk("XArray: %u of %u tests passed\n", tests_passed, tests_run);
+       return (tests_run == tests_passed) ? 0 : -EINVAL;
+}
+
+static void xarray_exit(void)
+{
+}
+
+module_init(xarray_checks);
+module_exit(xarray_exit);
 MODULE_AUTHOR("Matthew Wilcox <willy@infradead.org>");
 MODULE_DESCRIPTION("XArray API test module");
 MODULE_LICENSE("GPL");