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>

diff --git a/include/linux/xarray.h b/include/linux/xarray.h
index 2664e718dbd318e6da892a35949284697d0302ee..deae17aa0ed7fb26296420f1802ffebcbc8d8764 100644 (file)
--- a/include/linux/xarray.h
+++ b/include/linux/xarray.h
@@ -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.

diff --git a/lib/test_xarray.c b/lib/test_xarray.c
index 8eba3de1baeae89b41b9b7f781bce34f843cf006..703370015d10d19b2472fd5165e4965f12487ee3 100644 (file)
--- a/lib/test_xarray.c
+++ b/lib/test_xarray.c
@@ -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);

diff --git a/lib/xarray.c b/lib/xarray.c
index 41f8ebc651f5d54a1acb31887906cbd34270b629..ff37516fe8321b666e1c3ab06b0532ff28590306 100644 (file)
--- a/lib/xarray.c
+++ b/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)
 {