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: Matthew Wilcox <willy@infradead.org>
This commit is contained in:
Matthew Wilcox
Родитель
4e99d4e957
Коммит
2264f5132f
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
50
lib/xarray.c
50
lib/xarray.c
|
|
@ -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)
|
||||
{
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче