[linux-2.6-block.git] / lib / test_xarray.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * test_xarray.c: Test the XArray API
 * Copyright (c) 2017-2018 Microsoft Corporation
 * Author: Matthew Wilcox <willy@infradead.org>
 */

#include <linux/xarray.h>
#include <linux/module.h>

static unsigned int tests_run;
static unsigned int tests_passed;

#ifndef XA_DEBUG
# ifdef __KERNEL__
void xa_dump(const struct xarray *xa) { }
# endif
#undef XA_BUG_ON
#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

static void *xa_store_index(struct xarray *xa, unsigned long index, gfp_t gfp)
{
	return xa_store(xa, index, xa_mk_value(index & LONG_MAX), gfp);
}

static void xa_erase_index(struct xarray *xa, unsigned long index)
{
	XA_BUG_ON(xa, xa_erase(xa, index) != xa_mk_value(index & LONG_MAX));
	XA_BUG_ON(xa, xa_load(xa, index) != NULL);
}

/*
 * If anyone needs this, please move it to xarray.c.  We have no current
 * users outside the test suite because all current multislot users want
 * to use the advanced API.
 */
static void *xa_store_order(struct xarray *xa, unsigned long index,
		unsigned order, void *entry, gfp_t gfp)
{
	XA_STATE_ORDER(xas, xa, index, order);
	void *curr;

	do {
		xas_lock(&xas);
		curr = xas_store(&xas, entry);
		xas_unlock(&xas);
	} while (xas_nomem(&xas, gfp));

	return curr;
}

static noinline void check_xa_err(struct xarray *xa)
{
	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__
	/* The kernel does not fail GFP_NOWAIT allocations */
	XA_BUG_ON(xa, xa_err(xa_store_index(xa, 1, GFP_NOWAIT)) != -ENOMEM);
	XA_BUG_ON(xa, xa_err(xa_store_index(xa, 1, GFP_NOWAIT)) != -ENOMEM);
#endif
	XA_BUG_ON(xa, xa_err(xa_store_index(xa, 1, GFP_KERNEL)) != 0);
	XA_BUG_ON(xa, xa_err(xa_store(xa, 1, xa_mk_value(0), GFP_KERNEL)) != 0);
	XA_BUG_ON(xa, xa_err(xa_erase(xa, 1)) != 0);
// kills the test-suite :-(
//	XA_BUG_ON(xa, xa_err(xa_store(xa, 0, xa_mk_internal(0), 0)) != -EINVAL);
}

static noinline void check_xa_load(struct xarray *xa)
{
	unsigned long i, j;

	for (i = 0; i < 1024; i++) {
		for (j = 0; j < 1024; j++) {
			void *entry = xa_load(xa, j);
			if (j < i)
				XA_BUG_ON(xa, xa_to_value(entry) != j);
			else
				XA_BUG_ON(xa, entry);
		}
		XA_BUG_ON(xa, xa_store_index(xa, i, GFP_KERNEL) != NULL);
	}

	for (i = 0; i < 1024; i++) {
		for (j = 0; j < 1024; j++) {
			void *entry = xa_load(xa, j);
			if (j >= i)
				XA_BUG_ON(xa, xa_to_value(entry) != j);
			else
				XA_BUG_ON(xa, entry);
		}
		xa_erase_index(xa, i);
	}
	XA_BUG_ON(xa, !xa_empty(xa));
}

static noinline void check_xa_mark_1(struct xarray *xa, unsigned long index)
{
	unsigned int order;
	unsigned int max_order = IS_ENABLED(CONFIG_XARRAY_MULTI) ? 8 : 1;

	/* NULL elements have no marks set */
	XA_BUG_ON(xa, xa_get_mark(xa, index, XA_MARK_0));
	xa_set_mark(xa, index, XA_MARK_0);
	XA_BUG_ON(xa, xa_get_mark(xa, index, XA_MARK_0));

	/* Storing a pointer will not make a mark appear */
	XA_BUG_ON(xa, xa_store_index(xa, index, GFP_KERNEL) != NULL);
	XA_BUG_ON(xa, xa_get_mark(xa, index, XA_MARK_0));
	xa_set_mark(xa, index, XA_MARK_0);
	XA_BUG_ON(xa, !xa_get_mark(xa, index, XA_MARK_0));

	/* Setting one mark will not set another mark */
	XA_BUG_ON(xa, xa_get_mark(xa, index + 1, XA_MARK_0));
	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(xa, index);
	XA_BUG_ON(xa, !xa_empty(xa));
	XA_BUG_ON(xa, xa_get_mark(xa, index, XA_MARK_0));
	xa_set_mark(xa, index, XA_MARK_0);
	XA_BUG_ON(xa, xa_get_mark(xa, index, XA_MARK_0));

	/*
	 * Storing a multi-index entry over entries with marks gives the
	 * entire entry the union of the marks
	 */
	BUG_ON((index % 4) != 0);
	for (order = 2; order < max_order; order++) {
		unsigned long base = round_down(index, 1UL << order);
		unsigned long next = base + (1UL << order);
		unsigned long i;

		XA_BUG_ON(xa, xa_store_index(xa, index + 1, GFP_KERNEL));
		xa_set_mark(xa, index + 1, XA_MARK_0);
		XA_BUG_ON(xa, xa_store_index(xa, index + 2, GFP_KERNEL));
		xa_set_mark(xa, index + 2, XA_MARK_1);
		XA_BUG_ON(xa, xa_store_index(xa, next, GFP_KERNEL));
		xa_store_order(xa, index, order, xa_mk_value(index),
				GFP_KERNEL);
		for (i = base; i < next; i++) {
			XA_BUG_ON(xa, !xa_get_mark(xa, i, XA_MARK_0));
			XA_BUG_ON(xa, !xa_get_mark(xa, i, XA_MARK_1));
			XA_BUG_ON(xa, xa_get_mark(xa, i, XA_MARK_2));
		}
		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(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(struct xarray *xa)
{
	unsigned long index;

	for (index = 0; index < 16384; index += 4)
		check_xa_mark_1(xa, index);
}

static noinline void check_xa_shrink(struct xarray *xa)
{
	XA_STATE(xas, xa, 1);
	struct xa_node *node;

	XA_BUG_ON(xa, !xa_empty(xa));
	XA_BUG_ON(xa, xa_store_index(xa, 0, GFP_KERNEL) != NULL);
	XA_BUG_ON(xa, xa_store_index(xa, 1, GFP_KERNEL) != NULL);

	/*
	 * Check that erasing the entry at 1 shrinks the tree and properly
	 * marks the node as being deleted.
	 */
	xas_lock(&xas);
	XA_BUG_ON(xa, xas_load(&xas) != xa_mk_value(1));
	node = xas.xa_node;
	XA_BUG_ON(xa, xa_entry_locked(xa, node, 0) != xa_mk_value(0));
	XA_BUG_ON(xa, xas_store(&xas, NULL) != xa_mk_value(1));
	XA_BUG_ON(xa, xa_load(xa, 1) != NULL);
	XA_BUG_ON(xa, xas.xa_node != XAS_BOUNDS);
	XA_BUG_ON(xa, xa_entry_locked(xa, node, 0) != XA_RETRY_ENTRY);
	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(xa, 0);
	XA_BUG_ON(xa, !xa_empty(xa));
}

static noinline void check_cmpxchg(struct xarray *xa)
{
	void *FIVE = xa_mk_value(5);
	void *SIX = xa_mk_value(6);
	void *LOTS = xa_mk_value(12345678);

	XA_BUG_ON(xa, !xa_empty(xa));
	XA_BUG_ON(xa, xa_store_index(xa, 12345678, GFP_KERNEL) != NULL);
	XA_BUG_ON(xa, xa_insert(xa, 12345678, xa, GFP_KERNEL) != -EEXIST);
	XA_BUG_ON(xa, xa_cmpxchg(xa, 12345678, SIX, FIVE, GFP_KERNEL) != LOTS);
	XA_BUG_ON(xa, xa_cmpxchg(xa, 12345678, LOTS, FIVE, GFP_KERNEL) != LOTS);
	XA_BUG_ON(xa, xa_cmpxchg(xa, 12345678, FIVE, LOTS, GFP_KERNEL) != FIVE);
	XA_BUG_ON(xa, xa_cmpxchg(xa, 5, FIVE, NULL, GFP_KERNEL) != NULL);
	XA_BUG_ON(xa, xa_cmpxchg(xa, 5, NULL, FIVE, GFP_KERNEL) != NULL);
	xa_erase_index(xa, 12345678);
	xa_erase_index(xa, 5);
	XA_BUG_ON(xa, !xa_empty(xa));
}

static noinline void check_multi_store(struct xarray *xa)
{
#ifdef CONFIG_XARRAY_MULTI
	unsigned long i, j, k;
	unsigned int max_order = (sizeof(long) == 4) ? 30 : 60;

	/* Loading from any position returns the same value */
	xa_store_order(xa, 0, 1, xa_mk_value(0), GFP_KERNEL);
	XA_BUG_ON(xa, xa_load(xa, 0) != xa_mk_value(0));
	XA_BUG_ON(xa, xa_load(xa, 1) != xa_mk_value(0));
	XA_BUG_ON(xa, xa_load(xa, 2) != NULL);
	rcu_read_lock();
	XA_BUG_ON(xa, xa_to_node(xa_head(xa))->count != 2);
	XA_BUG_ON(xa, xa_to_node(xa_head(xa))->nr_values != 2);
	rcu_read_unlock();

	/* Storing adjacent to the value does not alter the value */
	xa_store(xa, 3, xa, GFP_KERNEL);
	XA_BUG_ON(xa, xa_load(xa, 0) != xa_mk_value(0));
	XA_BUG_ON(xa, xa_load(xa, 1) != xa_mk_value(0));
	XA_BUG_ON(xa, xa_load(xa, 2) != NULL);
	rcu_read_lock();
	XA_BUG_ON(xa, xa_to_node(xa_head(xa))->count != 3);
	XA_BUG_ON(xa, xa_to_node(xa_head(xa))->nr_values != 2);
	rcu_read_unlock();

	/* Overwriting multiple indexes works */
	xa_store_order(xa, 0, 2, xa_mk_value(1), GFP_KERNEL);
	XA_BUG_ON(xa, xa_load(xa, 0) != xa_mk_value(1));
	XA_BUG_ON(xa, xa_load(xa, 1) != xa_mk_value(1));
	XA_BUG_ON(xa, xa_load(xa, 2) != xa_mk_value(1));
	XA_BUG_ON(xa, xa_load(xa, 3) != xa_mk_value(1));
	XA_BUG_ON(xa, xa_load(xa, 4) != NULL);
	rcu_read_lock();
	XA_BUG_ON(xa, xa_to_node(xa_head(xa))->count != 4);
	XA_BUG_ON(xa, xa_to_node(xa_head(xa))->nr_values != 4);
	rcu_read_unlock();

	/* We can erase multiple values with a single store */
	xa_store_order(xa, 0, 63, NULL, GFP_KERNEL);
	XA_BUG_ON(xa, !xa_empty(xa));

	/* Even when the first slot is empty but the others aren't */
	xa_store_index(xa, 1, GFP_KERNEL);
	xa_store_index(xa, 2, GFP_KERNEL);
	xa_store_order(xa, 0, 2, NULL, GFP_KERNEL);
	XA_BUG_ON(xa, !xa_empty(xa));

	for (i = 0; i < max_order; i++) {
		for (j = 0; j < max_order; j++) {
			xa_store_order(xa, 0, i, xa_mk_value(i), GFP_KERNEL);
			xa_store_order(xa, 0, j, xa_mk_value(j), GFP_KERNEL);

			for (k = 0; k < max_order; k++) {
				void *entry = xa_load(xa, (1UL << k) - 1);
				if ((i < k) && (j < k))
					XA_BUG_ON(xa, entry != NULL);
				else
					XA_BUG_ON(xa, entry != xa_mk_value(j));
			}

			xa_erase(xa, 0);
			XA_BUG_ON(xa, !xa_empty(xa));
		}
	}
#endif
}

static DEFINE_XARRAY(array);

static int xarray_checks(void)
{
	check_xa_err(&array);
	check_xa_load(&array);
	check_xa_mark(&array);
	check_xa_shrink(&array);
	check_cmpxchg(&array);
	check_multi_store(&array);

	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_LICENSE("GPL");
Commit	Line	Data
ad3d6c72 MW	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* test_xarray.c: Test the XArray API
	4	* Copyright (c) 2017-2018 Microsoft Corporation
	5	* Author: Matthew Wilcox <willy@infradead.org>
	6	*/
	7
	8	#include <linux/xarray.h>
	9	#include <linux/module.h>
	10
	11	static unsigned int tests_run;
	12	static unsigned int tests_passed;
	13
	14	#ifndef XA_DEBUG
	15	# ifdef __KERNEL__
	16	void xa_dump(const struct xarray *xa) { }
	17	# endif
	18	#undef XA_BUG_ON
	19	#define XA_BUG_ON(xa, x) do { \
	20	tests_run++; \
	21	if (x) { \
	22	printk("BUG at %s:%d\n", __func__, __LINE__); \
	23	xa_dump(xa); \
	24	dump_stack(); \
	25	} else { \
	26	tests_passed++; \
	27	} \
	28	} while (0)
	29	#endif
	30
	31	static void xa_store_index(struct xarray xa, unsigned long index, gfp_t gfp)
	32	{
58d6ea30	33	return xa_store(xa, index, xa_mk_value(index & LONG_MAX), gfp);
ad3d6c72 MW	34	}
	35
	36	static void xa_erase_index(struct xarray *xa, unsigned long index)
	37	{
58d6ea30 MW	38	XA_BUG_ON(xa, xa_erase(xa, index) != xa_mk_value(index & LONG_MAX));
	39	XA_BUG_ON(xa, xa_load(xa, index) != NULL);
	40	}
	41
	42	/*
	43	* If anyone needs this, please move it to xarray.c. We have no current
	44	* users outside the test suite because all current multislot users want
	45	* to use the advanced API.
	46	*/
	47	static void xa_store_order(struct xarray xa, unsigned long index,
	48	unsigned order, void *entry, gfp_t gfp)
	49	{
	50	XA_STATE_ORDER(xas, xa, index, order);
	51	void *curr;
	52
	53	do {
	54	xas_lock(&xas);
	55	curr = xas_store(&xas, entry);
	56	xas_unlock(&xas);
	57	} while (xas_nomem(&xas, gfp));
	58
	59	return curr;
	60	}
	61
	62	static noinline void check_xa_err(struct xarray *xa)
	63	{
	64	XA_BUG_ON(xa, xa_err(xa_store_index(xa, 0, GFP_NOWAIT)) != 0);
	65	XA_BUG_ON(xa, xa_err(xa_erase(xa, 0)) != 0);
	66	#ifndef __KERNEL__
	67	/* The kernel does not fail GFP_NOWAIT allocations */
	68	XA_BUG_ON(xa, xa_err(xa_store_index(xa, 1, GFP_NOWAIT)) != -ENOMEM);
	69	XA_BUG_ON(xa, xa_err(xa_store_index(xa, 1, GFP_NOWAIT)) != -ENOMEM);
	70	#endif
	71	XA_BUG_ON(xa, xa_err(xa_store_index(xa, 1, GFP_KERNEL)) != 0);
	72	XA_BUG_ON(xa, xa_err(xa_store(xa, 1, xa_mk_value(0), GFP_KERNEL)) != 0);
	73	XA_BUG_ON(xa, xa_err(xa_erase(xa, 1)) != 0);
	74	// kills the test-suite :-(
	75	// XA_BUG_ON(xa, xa_err(xa_store(xa, 0, xa_mk_internal(0), 0)) != -EINVAL);
ad3d6c72 MW	76	}
	77
	78	static noinline void check_xa_load(struct xarray *xa)
	79	{
	80	unsigned long i, j;
	81
	82	for (i = 0; i < 1024; i++) {
	83	for (j = 0; j < 1024; j++) {
	84	void *entry = xa_load(xa, j);
	85	if (j < i)
	86	XA_BUG_ON(xa, xa_to_value(entry) != j);
	87	else
	88	XA_BUG_ON(xa, entry);
	89	}
	90	XA_BUG_ON(xa, xa_store_index(xa, i, GFP_KERNEL) != NULL);
	91	}
	92
	93	for (i = 0; i < 1024; i++) {
	94	for (j = 0; j < 1024; j++) {
	95	void *entry = xa_load(xa, j);
	96	if (j >= i)
	97	XA_BUG_ON(xa, xa_to_value(entry) != j);
	98	else
	99	XA_BUG_ON(xa, entry);
	100	}
	101	xa_erase_index(xa, i);
	102	}
	103	XA_BUG_ON(xa, !xa_empty(xa));
	104	}
	105
9b89a035 MW	106	static noinline void check_xa_mark_1(struct xarray *xa, unsigned long index)
9b89a035 MW	107	{
58d6ea30 MW	108	unsigned int order;
	109	unsigned int max_order = IS_ENABLED(CONFIG_XARRAY_MULTI) ? 8 : 1;
	110
9b89a035 MW	111	/* NULL elements have no marks set */
	112	XA_BUG_ON(xa, xa_get_mark(xa, index, XA_MARK_0));
	113	xa_set_mark(xa, index, XA_MARK_0);
	114	XA_BUG_ON(xa, xa_get_mark(xa, index, XA_MARK_0));
	115
	116	/* Storing a pointer will not make a mark appear */
	117	XA_BUG_ON(xa, xa_store_index(xa, index, GFP_KERNEL) != NULL);
	118	XA_BUG_ON(xa, xa_get_mark(xa, index, XA_MARK_0));
	119	xa_set_mark(xa, index, XA_MARK_0);
	120	XA_BUG_ON(xa, !xa_get_mark(xa, index, XA_MARK_0));
	121
	122	/* Setting one mark will not set another mark */
	123	XA_BUG_ON(xa, xa_get_mark(xa, index + 1, XA_MARK_0));
	124	XA_BUG_ON(xa, xa_get_mark(xa, index, XA_MARK_1));
	125
	126	/* Storing NULL clears marks, and they can't be set again */
	127	xa_erase_index(xa, index);
	128	XA_BUG_ON(xa, !xa_empty(xa));
	129	XA_BUG_ON(xa, xa_get_mark(xa, index, XA_MARK_0));
	130	xa_set_mark(xa, index, XA_MARK_0);
	131	XA_BUG_ON(xa, xa_get_mark(xa, index, XA_MARK_0));
58d6ea30 MW	132
	133	/*
	134	* Storing a multi-index entry over entries with marks gives the
	135	* entire entry the union of the marks
	136	*/
	137	BUG_ON((index % 4) != 0);
	138	for (order = 2; order < max_order; order++) {
	139	unsigned long base = round_down(index, 1UL << order);
	140	unsigned long next = base + (1UL << order);
	141	unsigned long i;
	142
	143	XA_BUG_ON(xa, xa_store_index(xa, index + 1, GFP_KERNEL));
	144	xa_set_mark(xa, index + 1, XA_MARK_0);
	145	XA_BUG_ON(xa, xa_store_index(xa, index + 2, GFP_KERNEL));
	146	xa_set_mark(xa, index + 2, XA_MARK_1);
	147	XA_BUG_ON(xa, xa_store_index(xa, next, GFP_KERNEL));
	148	xa_store_order(xa, index, order, xa_mk_value(index),
	149	GFP_KERNEL);
	150	for (i = base; i < next; i++) {
	151	XA_BUG_ON(xa, !xa_get_mark(xa, i, XA_MARK_0));
	152	XA_BUG_ON(xa, !xa_get_mark(xa, i, XA_MARK_1));
	153	XA_BUG_ON(xa, xa_get_mark(xa, i, XA_MARK_2));
	154	}
	155	XA_BUG_ON(xa, xa_get_mark(xa, next, XA_MARK_0));
	156	XA_BUG_ON(xa, xa_get_mark(xa, next, XA_MARK_1));
	157	XA_BUG_ON(xa, xa_get_mark(xa, next, XA_MARK_2));
	158	xa_erase_index(xa, index);
	159	xa_erase_index(xa, next);
	160	XA_BUG_ON(xa, !xa_empty(xa));
	161	}
	162	XA_BUG_ON(xa, !xa_empty(xa));
9b89a035 MW	163	}
	164
	165	static noinline void check_xa_mark(struct xarray *xa)
	166	{
	167	unsigned long index;
	168
	169	for (index = 0; index < 16384; index += 4)
	170	check_xa_mark_1(xa, index);
	171	}
	172
58d6ea30 MW	173	static noinline void check_xa_shrink(struct xarray *xa)
	174	{
	175	XA_STATE(xas, xa, 1);
	176	struct xa_node *node;
	177
	178	XA_BUG_ON(xa, !xa_empty(xa));
	179	XA_BUG_ON(xa, xa_store_index(xa, 0, GFP_KERNEL) != NULL);
	180	XA_BUG_ON(xa, xa_store_index(xa, 1, GFP_KERNEL) != NULL);
	181
	182	/*
	183	* Check that erasing the entry at 1 shrinks the tree and properly
	184	* marks the node as being deleted.
	185	*/
	186	xas_lock(&xas);
	187	XA_BUG_ON(xa, xas_load(&xas) != xa_mk_value(1));
	188	node = xas.xa_node;
	189	XA_BUG_ON(xa, xa_entry_locked(xa, node, 0) != xa_mk_value(0));
	190	XA_BUG_ON(xa, xas_store(&xas, NULL) != xa_mk_value(1));
	191	XA_BUG_ON(xa, xa_load(xa, 1) != NULL);
	192	XA_BUG_ON(xa, xas.xa_node != XAS_BOUNDS);
	193	XA_BUG_ON(xa, xa_entry_locked(xa, node, 0) != XA_RETRY_ENTRY);
	194	XA_BUG_ON(xa, xas_load(&xas) != NULL);
	195	xas_unlock(&xas);
	196	XA_BUG_ON(xa, xa_load(xa, 0) != xa_mk_value(0));
	197	xa_erase_index(xa, 0);
	198	XA_BUG_ON(xa, !xa_empty(xa));
	199	}
	200
41aec91f MW	201	static noinline void check_cmpxchg(struct xarray *xa)
	202	{
	203	void *FIVE = xa_mk_value(5);
	204	void *SIX = xa_mk_value(6);
	205	void *LOTS = xa_mk_value(12345678);
	206
	207	XA_BUG_ON(xa, !xa_empty(xa));
	208	XA_BUG_ON(xa, xa_store_index(xa, 12345678, GFP_KERNEL) != NULL);
	209	XA_BUG_ON(xa, xa_insert(xa, 12345678, xa, GFP_KERNEL) != -EEXIST);
	210	XA_BUG_ON(xa, xa_cmpxchg(xa, 12345678, SIX, FIVE, GFP_KERNEL) != LOTS);
	211	XA_BUG_ON(xa, xa_cmpxchg(xa, 12345678, LOTS, FIVE, GFP_KERNEL) != LOTS);
	212	XA_BUG_ON(xa, xa_cmpxchg(xa, 12345678, FIVE, LOTS, GFP_KERNEL) != FIVE);
	213	XA_BUG_ON(xa, xa_cmpxchg(xa, 5, FIVE, NULL, GFP_KERNEL) != NULL);
	214	XA_BUG_ON(xa, xa_cmpxchg(xa, 5, NULL, FIVE, GFP_KERNEL) != NULL);
	215	xa_erase_index(xa, 12345678);
	216	xa_erase_index(xa, 5);
	217	XA_BUG_ON(xa, !xa_empty(xa));
	218	}
	219
58d6ea30 MW	220	static noinline void check_multi_store(struct xarray *xa)
	221	{
	222	#ifdef CONFIG_XARRAY_MULTI
	223	unsigned long i, j, k;
	224	unsigned int max_order = (sizeof(long) == 4) ? 30 : 60;
	225
	226	/* Loading from any position returns the same value */
	227	xa_store_order(xa, 0, 1, xa_mk_value(0), GFP_KERNEL);
	228	XA_BUG_ON(xa, xa_load(xa, 0) != xa_mk_value(0));
	229	XA_BUG_ON(xa, xa_load(xa, 1) != xa_mk_value(0));
	230	XA_BUG_ON(xa, xa_load(xa, 2) != NULL);
	231	rcu_read_lock();
	232	XA_BUG_ON(xa, xa_to_node(xa_head(xa))->count != 2);
	233	XA_BUG_ON(xa, xa_to_node(xa_head(xa))->nr_values != 2);
	234	rcu_read_unlock();
	235
	236	/* Storing adjacent to the value does not alter the value */
	237	xa_store(xa, 3, xa, GFP_KERNEL);
	238	XA_BUG_ON(xa, xa_load(xa, 0) != xa_mk_value(0));
	239	XA_BUG_ON(xa, xa_load(xa, 1) != xa_mk_value(0));
	240	XA_BUG_ON(xa, xa_load(xa, 2) != NULL);
	241	rcu_read_lock();
	242	XA_BUG_ON(xa, xa_to_node(xa_head(xa))->count != 3);
	243	XA_BUG_ON(xa, xa_to_node(xa_head(xa))->nr_values != 2);
	244	rcu_read_unlock();
	245
	246	/* Overwriting multiple indexes works */
	247	xa_store_order(xa, 0, 2, xa_mk_value(1), GFP_KERNEL);
	248	XA_BUG_ON(xa, xa_load(xa, 0) != xa_mk_value(1));
	249	XA_BUG_ON(xa, xa_load(xa, 1) != xa_mk_value(1));
	250	XA_BUG_ON(xa, xa_load(xa, 2) != xa_mk_value(1));
	251	XA_BUG_ON(xa, xa_load(xa, 3) != xa_mk_value(1));
	252	XA_BUG_ON(xa, xa_load(xa, 4) != NULL);
	253	rcu_read_lock();
	254	XA_BUG_ON(xa, xa_to_node(xa_head(xa))->count != 4);
	255	XA_BUG_ON(xa, xa_to_node(xa_head(xa))->nr_values != 4);
	256	rcu_read_unlock();
	257
	258	/* We can erase multiple values with a single store */
	259	xa_store_order(xa, 0, 63, NULL, GFP_KERNEL);
	260	XA_BUG_ON(xa, !xa_empty(xa));
	261
	262	/* Even when the first slot is empty but the others aren't */
	263	xa_store_index(xa, 1, GFP_KERNEL);
	264	xa_store_index(xa, 2, GFP_KERNEL);
	265	xa_store_order(xa, 0, 2, NULL, GFP_KERNEL);
	266	XA_BUG_ON(xa, !xa_empty(xa));
	267
	268	for (i = 0; i < max_order; i++) {
	269	for (j = 0; j < max_order; j++) {
	270	xa_store_order(xa, 0, i, xa_mk_value(i), GFP_KERNEL);
	271	xa_store_order(xa, 0, j, xa_mk_value(j), GFP_KERNEL);
	272
	273	for (k = 0; k < max_order; k++) {
	274	void *entry = xa_load(xa, (1UL << k) - 1);
	275	if ((i < k) && (j < k))
	276	XA_BUG_ON(xa, entry != NULL);
	277	else
	278	XA_BUG_ON(xa, entry != xa_mk_value(j));
	279	}
	280
	281	xa_erase(xa, 0);
	282	XA_BUG_ON(xa, !xa_empty(xa));
	283	}
284	}
285	#endif
286	}
287
288	static DEFINE_XARRAY(array);
ad3d6c72 MW	289
	290	static int xarray_checks(void)
	291	{
58d6ea30	292	check_xa_err(&array);
ad3d6c72	293	check_xa_load(&array);
9b89a035	294	check_xa_mark(&array);
58d6ea30	295	check_xa_shrink(&array);
41aec91f	296	check_cmpxchg(&array);
58d6ea30	297	check_multi_store(&array);
ad3d6c72 MW	298
	299	printk("XArray: %u of %u tests passed\n", tests_passed, tests_run);
	300	return (tests_run == tests_passed) ? 0 : -EINVAL;
	301	}
	302
	303	static void xarray_exit(void)
	304	{
	305	}
	306
	307	module_init(xarray_checks);
	308	module_exit(xarray_exit);
	309	MODULE_AUTHOR("Matthew Wilcox <willy@infradead.org>");
	310	MODULE_LICENSE("GPL");