Commit 58d6ea30 authored by Matthew Wilcox's avatar Matthew Wilcox
Browse files

xarray: Add XArray unconditional store operations 



xa_store() differs from radix_tree_insert() in that it will overwrite an
existing element in the array rather than returning an error.  This is
the behaviour which most users want, and those that want more complex
behaviour generally want to use the xas family of routines anyway.

For memory allocation, xa_store() will first attempt to request memory
from the slab allocator; if memory is not immediately available, it will
drop the xa_lock and allocate memory, keeping a pointer in the xa_state.
It does not use the per-CPU cache, although those will continue to exist
until all radix tree users are converted to the xarray.

This patch also includes xa_erase() and __xa_erase() for a streamlined
way to store NULL.  Since there is no need to allocate memory in order
to store a NULL in the XArray, we do not need to trouble the user with
deciding what memory allocation flags to use.

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

include/linux/xarray.h

+145 −2
Original line number Diff line number Diff line
@@ -205,10 +205,17 @@ typedef unsigned __bitwise xa_mark_t; 
#define XA_PRESENT		((__force xa_mark_t)8U)

#define XA_MARK_MAX		XA_MARK_2



enum xa_lock_type {

	XA_LOCK_IRQ = 1,

	XA_LOCK_BH = 2,

};



/*

 * Values for xa_flags.  The radix tree stores its GFP flags in the xa_flags,

 * and we remain compatible with that.

 */

#define XA_FLAGS_LOCK_IRQ	((__force gfp_t)XA_LOCK_IRQ)

#define XA_FLAGS_LOCK_BH	((__force gfp_t)XA_LOCK_BH)

#define XA_FLAGS_MARK(mark)	((__force gfp_t)((1U << __GFP_BITS_SHIFT) << \

						(__force unsigned)(mark)))
@@ -267,6 +274,7 @@ struct xarray { 


void xa_init_flags(struct xarray *, gfp_t flags);

void *xa_load(struct xarray *, unsigned long index);

void *xa_store(struct xarray *, unsigned long index, void *entry, gfp_t);

bool xa_get_mark(struct xarray *, unsigned long index, xa_mark_t);

void xa_set_mark(struct xarray *, unsigned long index, xa_mark_t);

void xa_clear_mark(struct xarray *, unsigned long index, xa_mark_t);
@@ -309,6 +317,23 @@ static inline bool xa_marked(const struct xarray *xa, xa_mark_t mark) 
	return xa->xa_flags & XA_FLAGS_MARK(mark);

}



/**

 * xa_erase() - Erase this entry from the XArray.

 * @xa: XArray.

 * @index: Index of entry.

 *

 * This function is the equivalent of calling xa_store() with %NULL as

 * the third argument.  The XArray does not need to allocate memory, so

 * the user does not need to provide GFP flags.

 *

 * Context: Process context.  Takes and releases the xa_lock.

 * Return: The entry which used to be at this index.

 */

static inline void *xa_erase(struct xarray *xa, unsigned long index)

{

	return xa_store(xa, index, NULL, 0);

}



#define xa_trylock(xa)		spin_trylock(&(xa)->xa_lock)

#define xa_lock(xa)		spin_lock(&(xa)->xa_lock)

#define xa_unlock(xa)		spin_unlock(&(xa)->xa_lock)
@@ -322,11 +347,65 @@ static inline bool xa_marked(const struct xarray *xa, xa_mark_t mark) 
				spin_unlock_irqrestore(&(xa)->xa_lock, flags)



/*

 * Versions of the normal API which require the caller to hold the xa_lock.

 */

 * Versions of the normal API which require the caller to hold the

 * xa_lock.  If the GFP flags allow it, they will drop the lock to

 * allocate memory, then reacquire it afterwards.  These functions

 * may also re-enable interrupts if the XArray flags indicate the

 * locking should be interrupt safe.

 */

void *__xa_erase(struct xarray *, unsigned long index);

void *__xa_store(struct xarray *, unsigned long index, void *entry, gfp_t);

void __xa_set_mark(struct xarray *, unsigned long index, xa_mark_t);

void __xa_clear_mark(struct xarray *, unsigned long index, xa_mark_t);



/**

 * xa_erase_bh() - Erase this entry from the XArray.

 * @xa: XArray.

 * @index: Index of entry.

 *

 * This function is the equivalent of calling xa_store() with %NULL as

 * the third argument.  The XArray does not need to allocate memory, so

 * the user does not need to provide GFP flags.

 *

 * Context: Process context.  Takes and releases the xa_lock while

 * disabling softirqs.

 * Return: The entry which used to be at this index.

 */

static inline void *xa_erase_bh(struct xarray *xa, unsigned long index)

{

	void *entry;



	xa_lock_bh(xa);

	entry = __xa_erase(xa, index);

	xa_unlock_bh(xa);



	return entry;

}



/**

 * xa_erase_irq() - Erase this entry from the XArray.

 * @xa: XArray.

 * @index: Index of entry.

 *

 * This function is the equivalent of calling xa_store() with %NULL as

 * the third argument.  The XArray does not need to allocate memory, so

 * the user does not need to provide GFP flags.

 *

 * Context: Process context.  Takes and releases the xa_lock while

 * disabling interrupts.

 * Return: The entry which used to be at this index.

 */

static inline void *xa_erase_irq(struct xarray *xa, unsigned long index)

{

	void *entry;



	xa_lock_irq(xa);

	entry = __xa_erase(xa, index);

	xa_unlock_irq(xa);



	return entry;

}



/* Everything below here is the Advanced API.  Proceed with caution. */



/*
@@ -441,6 +520,12 @@ static inline struct xa_node *xa_parent_locked(const struct xarray *xa, 
						lockdep_is_held(&xa->xa_lock));

}



/* Private */

static inline void *xa_mk_node(const struct xa_node *node)

{

	return (void *)((unsigned long)node | 2);

}



/* Private */

static inline struct xa_node *xa_to_node(const void *entry)

{
@@ -647,6 +732,12 @@ static inline bool xas_not_node(struct xa_node *node) 
	return ((unsigned long)node & 3) || !node;

}



/* True if the node represents head-of-tree, RESTART or BOUNDS */

static inline bool xas_top(struct xa_node *node)

{

	return node <= XAS_RESTART;

}



/**

 * xas_reset() - Reset an XArray operation state.

 * @xas: XArray operation state.
@@ -683,10 +774,14 @@ static inline bool xas_retry(struct xa_state *xas, const void *entry) 
}



void *xas_load(struct xa_state *);

void *xas_store(struct xa_state *, void *entry);



bool xas_get_mark(const struct xa_state *, xa_mark_t);

void xas_set_mark(const struct xa_state *, xa_mark_t);

void xas_clear_mark(const struct xa_state *, xa_mark_t);

void xas_init_marks(const struct xa_state *);



bool xas_nomem(struct xa_state *, gfp_t);



/**

 * xas_reload() - Refetch an entry from the xarray.
@@ -711,4 +806,52 @@ static inline void *xas_reload(struct xa_state *xas) 
	return xa_head(xas->xa);

}



/**

 * xas_set() - Set up XArray operation state for a different index.

 * @xas: XArray operation state.

 * @index: New index into the XArray.

 *

 * Move the operation state to refer to a different index.  This will

 * have the effect of starting a walk from the top; see xas_next()

 * to move to an adjacent index.

 */

static inline void xas_set(struct xa_state *xas, unsigned long index)

{

	xas->xa_index = index;

	xas->xa_node = XAS_RESTART;

}



/**

 * xas_set_order() - Set up XArray operation state for a multislot entry.

 * @xas: XArray operation state.

 * @index: Target of the operation.

 * @order: Entry occupies 2^@order indices.

 */

static inline void xas_set_order(struct xa_state *xas, unsigned long index,

					unsigned int order)

{

#ifdef CONFIG_XARRAY_MULTI

	xas->xa_index = order < BITS_PER_LONG ? (index >> order) << order : 0;

	xas->xa_shift = order - (order % XA_CHUNK_SHIFT);

	xas->xa_sibs = (1 << (order % XA_CHUNK_SHIFT)) - 1;

	xas->xa_node = XAS_RESTART;

#else

	BUG_ON(order > 0);

	xas_set(xas, index);

#endif

}



/**

 * xas_set_update() - Set up XArray operation state for a callback.

 * @xas: XArray operation state.

 * @update: Function to call when updating a node.

 *

 * The XArray can notify a caller after it has updated an xa_node.

 * This is advanced functionality and is only needed by the page cache.

 */

static inline void xas_set_update(struct xa_state *xas, xa_update_node_t update)

{

	xas->xa_update = update;

}



#endif /* _LINUX_XARRAY_H */

lib/radix-tree.c

+2 −2
Original line number Diff line number Diff line
@@ -47,7 +47,7 @@ static unsigned long height_to_maxnodes[RADIX_TREE_MAX_PATH + 1] __read_mostly; 
/*

 * Radix tree node cache.

 */

static struct kmem_cache *radix_tree_node_cachep;

struct kmem_cache *radix_tree_node_cachep;



/*

 * The radix tree is variable-height, so an insert operation not only has
@@ -365,7 +365,7 @@ out: 
	return ret;

}



static void radix_tree_node_rcu_free(struct rcu_head *head)

void radix_tree_node_rcu_free(struct rcu_head *head)

{

	struct radix_tree_node *node =

			container_of(head, struct radix_tree_node, rcu_head);

lib/test_xarray.c

+173 −4
Original line number Diff line number Diff line
@@ -30,13 +30,49 @@ void xa_dump(const struct xarray *xa) { } 


static void *xa_store_index(struct xarray *xa, unsigned long index, gfp_t gfp)

{

	radix_tree_insert(xa, index, xa_mk_value(index));

	return NULL;

	return xa_store(xa, index, xa_mk_value(index & LONG_MAX), gfp);

}



static void xa_erase_index(struct xarray *xa, unsigned long index)

{

	radix_tree_delete(xa, 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)
@@ -69,6 +105,9 @@ static noinline void check_xa_load(struct xarray *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);
@@ -90,6 +129,37 @@ static noinline void check_xa_mark_1(struct xarray *xa, unsigned long index) 
	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)
@@ -100,12 +170,111 @@ static noinline void check_xa_mark(struct xarray *xa) 
		check_xa_mark_1(xa, index);

}



static RADIX_TREE(array, GFP_KERNEL);

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_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_multi_store(&array);



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

	return (tests_run == tests_passed) ? 0 : -EINVAL;

lib/xarray.c

+693 −0

File changed.

Preview size limit exceeded, changes collapsed.

tools/include/linux/bitmap.h

+1 −0
Original line number Diff line number Diff line
@@ -15,6 +15,7 @@ void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1, 
		 const unsigned long *bitmap2, int bits);

int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,

		 const unsigned long *bitmap2, unsigned int bits);

void bitmap_clear(unsigned long *map, unsigned int start, int len);



#define BITMAP_FIRST_WORD_MASK(start) (~0UL << ((start) & (BITS_PER_LONG - 1)))

CRA Git | Maintained and supported by SUSTech CRA and CCSE