From: Andrew Morton <akpm@linux-foundation.org>
To: mm-commits@vger.kernel.org,willy@infradead.org,tamird@gmail.com,sidhartha.kumar@oracle.com,lorenzo.stoakes@oracle.com,Liam.Howlett@oracle.com,geert@linux-m68k.org,davidgow@google.com,akpm@linux-foundation.org,akpm@linux-foundation.org
Subject: + revert-xarray-port-tests-to-kunit.patch added to mm-hotfixes-unstable branch
Date: Thu, 30 Jan 2025 16:22:44 -0800 [thread overview]
Message-ID: <20250131002244.B7FCAC4CED2@smtp.kernel.org> (raw)
The patch titled
Subject: revert "xarray: port tests to kunit"
has been added to the -mm mm-hotfixes-unstable branch. Its filename is
revert-xarray-port-tests-to-kunit.patch
This patch will shortly appear at
https://git.kernel.org/pub/scm/linux/kernel/git/akpm/25-new.git/tree/patches/revert-xarray-port-tests-to-kunit.patch
This patch will later appear in the mm-hotfixes-unstable branch at
git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm
Before you just go and hit "reply", please:
a) Consider who else should be cc'ed
b) Prefer to cc a suitable mailing list as well
c) Ideally: find the original patch on the mailing list and do a
reply-to-all to that, adding suitable additional cc's
*** Remember to use Documentation/process/submit-checklist.rst when testing your code ***
The -mm tree is included into linux-next via the mm-everything
branch at git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm
and is updated there every 2-3 working days
------------------------------------------------------
From: Andrew Morton <akpm@linux-foundation.org>
Subject: revert "xarray: port tests to kunit"
Date: Thu Jan 30 04:09:20 PM PST 2025
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>
---
arch/m68k/configs/amiga_defconfig | 1
arch/m68k/configs/apollo_defconfig | 1
arch/m68k/configs/atari_defconfig | 1
arch/m68k/configs/bvme6000_defconfig | 1
arch/m68k/configs/hp300_defconfig | 1
arch/m68k/configs/mac_defconfig | 1
arch/m68k/configs/multi_defconfig | 1
arch/m68k/configs/mvme147_defconfig | 1
arch/m68k/configs/mvme16x_defconfig | 1
arch/m68k/configs/q40_defconfig | 1
arch/m68k/configs/sun3_defconfig | 1
arch/m68k/configs/sun3x_defconfig | 1
arch/powerpc/configs/ppc64_defconfig | 1
lib/Kconfig.debug | 18
lib/Makefile | 2
lib/test_xarray.c | 661 ++++++++++---------------
16 files changed, 289 insertions(+), 405 deletions(-)
--- a/arch/m68k/configs/amiga_defconfig~revert-xarray-port-tests-to-kunit
+++ a/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
--- a/arch/m68k/configs/apollo_defconfig~revert-xarray-port-tests-to-kunit
+++ a/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
--- a/arch/m68k/configs/atari_defconfig~revert-xarray-port-tests-to-kunit
+++ a/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
--- a/arch/m68k/configs/bvme6000_defconfig~revert-xarray-port-tests-to-kunit
+++ a/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
--- a/arch/m68k/configs/hp300_defconfig~revert-xarray-port-tests-to-kunit
+++ a/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
--- a/arch/m68k/configs/mac_defconfig~revert-xarray-port-tests-to-kunit
+++ a/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
--- a/arch/m68k/configs/multi_defconfig~revert-xarray-port-tests-to-kunit
+++ a/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
--- a/arch/m68k/configs/mvme147_defconfig~revert-xarray-port-tests-to-kunit
+++ a/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
--- a/arch/m68k/configs/mvme16x_defconfig~revert-xarray-port-tests-to-kunit
+++ a/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
--- a/arch/m68k/configs/q40_defconfig~revert-xarray-port-tests-to-kunit
+++ a/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
--- a/arch/m68k/configs/sun3_defconfig~revert-xarray-port-tests-to-kunit
+++ a/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
--- a/arch/m68k/configs/sun3x_defconfig~revert-xarray-port-tests-to-kunit
+++ a/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
--- a/arch/powerpc/configs/ppc64_defconfig~revert-xarray-port-tests-to-kunit
+++ a/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
--- a/lib/Kconfig.debug~revert-xarray-port-tests-to-kunit
+++ a/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"
--- a/lib/Makefile~revert-xarray-port-tests-to-kunit
+++ a/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_STR
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
--- a/lib/test_xarray.c~revert-xarray-port-tests-to-kunit
+++ a/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 xarra
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
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 xarra
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
// 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(str
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(str
}
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(struc
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(str
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(str
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(str
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(str
#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(str
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(str
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(struc
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
#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(struc
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(struc
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(struc
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(str
}
#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
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
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
}
#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(s
}
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_stor
}
/* 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_stor
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 = 0xdeadbe
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_stor
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_stor
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_stor
/* 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_stor
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_stor
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_a
*/
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(st
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(st
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(st
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(st
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(st
/* 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(st
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(st
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(
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(
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(
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
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
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
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
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_en
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(st
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
}
-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(str
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(stru
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(st
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 k
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 k
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_
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_
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);
@@ -1883,28 +1802,26 @@ static noinline void __check_store_range
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 *
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 *
* 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 *
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_n
}
}
-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(struc
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(st
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(st
* 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(struc
#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(str
}
}
-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
}
}
-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_
}
-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(struc
}
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,
-};
+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;
+}
-kunit_test_suite(xarray_suite);
+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");
_
Patches currently in -mm which might be from akpm@linux-foundation.org are
revert-xarray-port-tests-to-kunit.patch
maintainers-include-linux-mm-for-xarray-maintenance.patch
mm-vmscan-extract-calculated-pressure-balance-as-a-function-fix.patch
mm-hugetlb-move-hugetlb-cma-code-in-to-its-own-file-checkpatch-fixes.patch
xfs-convert-timeouts-to-secs_to_jiffies-fix.patch
lib-plistc-add-shortcut-for-plist_requeue-fix.patch
reply other threads:[~2025-01-31 0:22 UTC|newest]
Thread overview: [no followups] expand[flat|nested] mbox.gz Atom feed
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20250131002244.B7FCAC4CED2@smtp.kernel.org \
--to=akpm@linux-foundation.org \
--cc=Liam.Howlett@oracle.com \
--cc=davidgow@google.com \
--cc=geert@linux-m68k.org \
--cc=lorenzo.stoakes@oracle.com \
--cc=mm-commits@vger.kernel.org \
--cc=sidhartha.kumar@oracle.com \
--cc=tamird@gmail.com \
--cc=willy@infradead.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.