Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2264f513 authored by Matthew Wilcox's avatar Matthew Wilcox
Browse files

xarray: Add xas_create_range 



This hopefully temporary function is useful for users who have not yet
been converted to multi-index entries.

Signed-off-by: default avatarMatthew Wilcox <willy@infradead.org>
parent 4e99d4e9

include/linux/xarray.h

+13 −0
Original line number Diff line number Diff line
@@ -822,6 +822,17 @@ static inline bool xas_valid(const struct xa_state *xas) 
	return !xas_invalid(xas);

}



/**

 * xas_is_node() - Does the xas point to a node?

 * @xas: XArray operation state.

 *

 * Return: %true if the xas currently references a node.

 */

static inline bool xas_is_node(const struct xa_state *xas)

{

	return xas_valid(xas) && xas->xa_node;

}



/* True if the pointer is something other than a node */

static inline bool xas_not_node(struct xa_node *node)

{
@@ -889,6 +900,8 @@ void xas_init_marks(const struct xa_state *); 
bool xas_nomem(struct xa_state *, gfp_t);

void xas_pause(struct xa_state *);



void xas_create_range(struct xa_state *);



/**

 * xas_reload() - Refetch an entry from the xarray.

 * @xas: XArray operation state.

lib/test_xarray.c

+119 −0
Original line number Diff line number Diff line
@@ -646,6 +646,124 @@ static noinline void check_move(struct xarray *xa) 
		check_move_small(xa, (1UL << i) - 1);

}



static noinline void xa_store_many_order(struct xarray *xa,

		unsigned long index, unsigned order)

{

	XA_STATE_ORDER(xas, xa, index, order);

	unsigned int i = 0;



	do {

		xas_lock(&xas);

		XA_BUG_ON(xa, xas_find_conflict(&xas));

		xas_create_range(&xas);

		if (xas_error(&xas))

			goto unlock;

		for (i = 0; i < (1U << order); i++) {

			XA_BUG_ON(xa, xas_store(&xas, xa_mk_value(index + i)));

			xas_next(&xas);

		}

unlock:

		xas_unlock(&xas);

	} while (xas_nomem(&xas, GFP_KERNEL));



	XA_BUG_ON(xa, xas_error(&xas));

}



static noinline void check_create_range_1(struct xarray *xa,

		unsigned long index, unsigned order)

{

	unsigned long i;



	xa_store_many_order(xa, index, order);

	for (i = index; i < index + (1UL << order); i++)

		xa_erase_index(xa, i);

	XA_BUG_ON(xa, !xa_empty(xa));

}



static noinline void check_create_range_2(struct xarray *xa, unsigned order)

{

	unsigned long i;

	unsigned long nr = 1UL << order;



	for (i = 0; i < nr * nr; i += nr)

		xa_store_many_order(xa, i, order);

	for (i = 0; i < nr * nr; i++)

		xa_erase_index(xa, i);

	XA_BUG_ON(xa, !xa_empty(xa));

}



static noinline void check_create_range_3(void)

{

	XA_STATE(xas, NULL, 0);

	xas_set_err(&xas, -EEXIST);

	xas_create_range(&xas);

	XA_BUG_ON(NULL, xas_error(&xas) != -EEXIST);

}



static noinline void check_create_range_4(struct xarray *xa,

		unsigned long index, unsigned order)

{

	XA_STATE_ORDER(xas, xa, index, order);

	unsigned long base = xas.xa_index;

	unsigned long i = 0;



	xa_store_index(xa, index, GFP_KERNEL);

	do {

		xas_lock(&xas);

		xas_create_range(&xas);

		if (xas_error(&xas))

			goto unlock;

		for (i = 0; i < (1UL << order); i++) {

			void *old = xas_store(&xas, xa_mk_value(base + i));

			if (xas.xa_index == index)

				XA_BUG_ON(xa, old != xa_mk_value(base + i));

			else

				XA_BUG_ON(xa, old != NULL);

			xas_next(&xas);

		}

unlock:

		xas_unlock(&xas);

	} while (xas_nomem(&xas, GFP_KERNEL));



	XA_BUG_ON(xa, xas_error(&xas));



	for (i = base; i < base + (1UL << order); i++)

		xa_erase_index(xa, i);

	XA_BUG_ON(xa, !xa_empty(xa));

}



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(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(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_3();

}



static noinline void check_destroy(struct xarray *xa)

{

	unsigned long index;
@@ -694,6 +812,7 @@ static int xarray_checks(void) 
	check_find(&array);

	check_destroy(&array);

	check_move(&array);

	check_create_range(&array);

	check_store_iter(&array);



	printk("XArray: %u of %u tests passed\n", tests_passed, tests_run);

lib/xarray.c

+50 −0
Original line number Diff line number Diff line
@@ -637,6 +637,56 @@ static void *xas_create(struct xa_state *xas) 
	return entry;

}



/**

 * xas_create_range() - Ensure that stores to this range will succeed

 * @xas: XArray operation state.

 *

 * Creates all of the slots in the range covered by @xas.  Sets @xas to

 * create single-index entries and positions it at the beginning of the

 * range.  This is for the benefit of users which have not yet been

 * converted to use multi-index entries.

 */

void xas_create_range(struct xa_state *xas)

{

	unsigned long index = xas->xa_index;

	unsigned char shift = xas->xa_shift;

	unsigned char sibs = xas->xa_sibs;



	xas->xa_index |= ((sibs + 1) << shift) - 1;

	if (xas_is_node(xas) && xas->xa_node->shift == xas->xa_shift)

		xas->xa_offset |= sibs;

	xas->xa_shift = 0;

	xas->xa_sibs = 0;



	for (;;) {

		xas_create(xas);

		if (xas_error(xas))

			goto restore;

		if (xas->xa_index <= (index | XA_CHUNK_MASK))

			goto success;

		xas->xa_index -= XA_CHUNK_SIZE;



		for (;;) {

			struct xa_node *node = xas->xa_node;

			xas->xa_node = xa_parent_locked(xas->xa, node);

			xas->xa_offset = node->offset - 1;

			if (node->offset != 0)

				break;

		}

	}



restore:

	xas->xa_shift = shift;

	xas->xa_sibs = sibs;

	xas->xa_index = index;

	return;

success:

	xas->xa_index = index;

	if (xas->xa_node)

		xas_set_offset(xas);

}

EXPORT_SYMBOL_GPL(xas_create_range);



static void update_node(struct xa_state *xas, struct xa_node *node,

		int count, int values)

{