Merge tag 'xarray-5.1-rc1' of git://git.infradead.org/users/willy/linux-dax

Pull XArray updates from Matthew Wilcox:
 "This pull request changes the xa_alloc() API. I'm only aware of one
  subsystem that has started trying to use it, and we agree on the fixup
  as part of the merge.

  The xa_insert() error code also changed to match xa_alloc() (EEXIST to
  EBUSY), and I added xa_alloc_cyclic(). Beyond that, the usual
  bugfixes, optimisations and tweaking.

  I now have a git tree with all users of the radix tree and IDR
  converted over to the XArray that I'll be feeding to maintainers over
  the next few weeks"

* tag 'xarray-5.1-rc1' of git://git.infradead.org/users/willy/linux-dax:
  XArray: Fix xa_reserve for 2-byte aligned entries
  XArray: Fix xa_erase of 2-byte aligned entries
  XArray: Use xa_cmpxchg to implement xa_reserve
  XArray: Fix xa_release in allocating arrays
  XArray: Mark xa_insert and xa_reserve as must_check
  XArray: Add cyclic allocation
  XArray: Redesign xa_alloc API
  XArray: Add support for 1s-based allocation
  XArray: Change xa_insert to return -EBUSY
  XArray: Update xa_erase family descriptions
  XArray tests: RCU lock prohibits GFP_KERNEL

2 files changed, 324 insertions, 127 deletions

diff --git a/lib/test_xarray.c b/lib/test_xarray.c
index c596a957f764..5d4bad8bd96a 100644
--- a/lib/test_xarray.c
+++ b/lib/test_xarray.c
@@ -40,9 +40,9 @@ static void *xa_store_index(struct xarray *xa, unsigned long index, gfp_t gfp)
 
 static void xa_alloc_index(struct xarray *xa, unsigned long index, gfp_t gfp)
 {
-        u32 id = 0;
+        u32 id;
 
-        XA_BUG_ON(xa, xa_alloc(xa, &id, UINT_MAX, xa_mk_index(index),
+        XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(index), xa_limit_32b,
                                 gfp) != 0);
         XA_BUG_ON(xa, id != index);
 }
@@ -107,8 +107,11 @@ static noinline void check_xas_retry(struct xarray *xa)
         XA_BUG_ON(xa, xas.xa_node != XAS_RESTART);
         XA_BUG_ON(xa, xas_next_entry(&xas, ULONG_MAX) != xa_mk_value(0));
         XA_BUG_ON(xa, xas.xa_node != NULL);
+        rcu_read_unlock();
 
         XA_BUG_ON(xa, xa_store_index(xa, 1, GFP_KERNEL) != NULL);
+
+        rcu_read_lock();
         XA_BUG_ON(xa, !xa_is_internal(xas_reload(&xas)));
         xas.xa_node = XAS_RESTART;
         XA_BUG_ON(xa, xas_next_entry(&xas, ULONG_MAX) != xa_mk_value(0));
@@ -343,7 +346,7 @@ static noinline void check_cmpxchg(struct xarray *xa)
 
         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_insert(xa, 12345678, xa, GFP_KERNEL) != -EBUSY);
         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);
@@ -358,46 +361,65 @@ static noinline void check_reserve(struct xarray *xa)
 {
         void *entry;
         unsigned long index;
+        int count;
 
         /* An array with a reserved entry is not empty */
         XA_BUG_ON(xa, !xa_empty(xa));
-        xa_reserve(xa, 12345678, GFP_KERNEL);
+        XA_BUG_ON(xa, xa_reserve(xa, 12345678, GFP_KERNEL) != 0);
         XA_BUG_ON(xa, xa_empty(xa));
         XA_BUG_ON(xa, xa_load(xa, 12345678));
         xa_release(xa, 12345678);
         XA_BUG_ON(xa, !xa_empty(xa));
 
         /* Releasing a used entry does nothing */
-        xa_reserve(xa, 12345678, GFP_KERNEL);
+        XA_BUG_ON(xa, xa_reserve(xa, 12345678, GFP_KERNEL) != 0);
         XA_BUG_ON(xa, xa_store_index(xa, 12345678, GFP_NOWAIT) != NULL);
         xa_release(xa, 12345678);
         xa_erase_index(xa, 12345678);
         XA_BUG_ON(xa, !xa_empty(xa));
 
-        /* cmpxchg sees a reserved entry as NULL */
-        xa_reserve(xa, 12345678, GFP_KERNEL);
-        XA_BUG_ON(xa, xa_cmpxchg(xa, 12345678, NULL, xa_mk_value(12345678),
-                                GFP_NOWAIT) != NULL);
+        /* cmpxchg sees a reserved entry as ZERO */
+        XA_BUG_ON(xa, xa_reserve(xa, 12345678, GFP_KERNEL) != 0);
+        XA_BUG_ON(xa, xa_cmpxchg(xa, 12345678, XA_ZERO_ENTRY,
+                                xa_mk_value(12345678), GFP_NOWAIT) != NULL);
         xa_release(xa, 12345678);
         xa_erase_index(xa, 12345678);
         XA_BUG_ON(xa, !xa_empty(xa));
 
-        /* But xa_insert does not */
-        xa_reserve(xa, 12345678, GFP_KERNEL);
+        /* xa_insert treats it as busy */
+        XA_BUG_ON(xa, xa_reserve(xa, 12345678, GFP_KERNEL) != 0);
         XA_BUG_ON(xa, xa_insert(xa, 12345678, xa_mk_value(12345678), 0) !=
-                        -EEXIST);
+                        -EBUSY);
         XA_BUG_ON(xa, xa_empty(xa));
         XA_BUG_ON(xa, xa_erase(xa, 12345678) != NULL);
         XA_BUG_ON(xa, !xa_empty(xa));
 
         /* Can iterate through a reserved entry */
         xa_store_index(xa, 5, GFP_KERNEL);
-        xa_reserve(xa, 6, GFP_KERNEL);
+        XA_BUG_ON(xa, xa_reserve(xa, 6, GFP_KERNEL) != 0);
         xa_store_index(xa, 7, GFP_KERNEL);
 
+        count = 0;
         xa_for_each(xa, index, entry) {
                 XA_BUG_ON(xa, index != 5 && index != 7);
+                count++;
+        }
+        XA_BUG_ON(xa, count != 2);
+
+        /* If we free a reserved entry, we should be able to allocate it */
+        if (xa->xa_flags & XA_FLAGS_ALLOC) {
+                u32 id;
+
+                XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_value(8),
+                                        XA_LIMIT(5, 10), GFP_KERNEL) != 0);
+                XA_BUG_ON(xa, id != 8);
+
+                xa_release(xa, 6);
+                XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_value(6),
+                                        XA_LIMIT(5, 10), GFP_KERNEL) != 0);
+                XA_BUG_ON(xa, id != 6);
         }
+
         xa_destroy(xa);
 }
 
@@ -586,64 +608,194 @@ static noinline void check_multi_store(struct xarray *xa)
 #endif
 }
 
-static DEFINE_XARRAY_ALLOC(xa0);
-
-static noinline void check_xa_alloc(void)
+static noinline void check_xa_alloc_1(struct xarray *xa, unsigned int base)
 {
         int i;
         u32 id;
 
-        /* An empty array should assign 0 to the first alloc */
-        xa_alloc_index(&xa0, 0, GFP_KERNEL);
+        XA_BUG_ON(xa, !xa_empty(xa));
+        /* An empty array should assign %base to the first alloc */
+        xa_alloc_index(xa, base, GFP_KERNEL);
 
         /* Erasing it should make the array empty again */
-        xa_erase_index(&xa0, 0);
-        XA_BUG_ON(&xa0, !xa_empty(&xa0));
+        xa_erase_index(xa, base);
+        XA_BUG_ON(xa, !xa_empty(xa));
+
+        /* And it should assign %base again */
+        xa_alloc_index(xa, base, GFP_KERNEL);
+
+        /* Allocating and then erasing a lot should not lose base */
+        for (i = base + 1; i < 2 * XA_CHUNK_SIZE; i++)
+                xa_alloc_index(xa, i, GFP_KERNEL);
+        for (i = base; i < 2 * XA_CHUNK_SIZE; i++)
+                xa_erase_index(xa, i);
+        xa_alloc_index(xa, base, GFP_KERNEL);
 
-        /* And it should assign 0 again */
-        xa_alloc_index(&xa0, 0, GFP_KERNEL);
+        /* Destroying the array should do the same as erasing */
+        xa_destroy(xa);
+
+        /* And it should assign %base again */
+        xa_alloc_index(xa, base, GFP_KERNEL);
 
-        /* The next assigned ID should be 1 */
-        xa_alloc_index(&xa0, 1, GFP_KERNEL);
-        xa_erase_index(&xa0, 1);
+        /* The next assigned ID should be base+1 */
+        xa_alloc_index(xa, base + 1, GFP_KERNEL);
+        xa_erase_index(xa, base + 1);
 
         /* Storing a value should mark it used */
-        xa_store_index(&xa0, 1, GFP_KERNEL);
-        xa_alloc_index(&xa0, 2, GFP_KERNEL);
+        xa_store_index(xa, base + 1, GFP_KERNEL);
+        xa_alloc_index(xa, base + 2, GFP_KERNEL);
 
-        /* If we then erase 0, it should be free */
-        xa_erase_index(&xa0, 0);
-        xa_alloc_index(&xa0, 0, GFP_KERNEL);
+        /* If we then erase base, it should be free */
+        xa_erase_index(xa, base);
+        xa_alloc_index(xa, base, GFP_KERNEL);
 
-        xa_erase_index(&xa0, 1);
-        xa_erase_index(&xa0, 2);
+        xa_erase_index(xa, base + 1);
+        xa_erase_index(xa, base + 2);
 
         for (i = 1; i < 5000; i++) {
-                xa_alloc_index(&xa0, i, GFP_KERNEL);
+                xa_alloc_index(xa, base + i, GFP_KERNEL);
         }
 
-        xa_destroy(&xa0);
+        xa_destroy(xa);
 
-        id = 0xfffffffeU;
-        XA_BUG_ON(&xa0, xa_alloc(&xa0, &id, UINT_MAX, xa_mk_index(id),
+        /* Check that we fail properly at the limit of allocation */
+        XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(UINT_MAX - 1),
+                                XA_LIMIT(UINT_MAX - 1, UINT_MAX),
                                 GFP_KERNEL) != 0);
-        XA_BUG_ON(&xa0, id != 0xfffffffeU);
-        XA_BUG_ON(&xa0, xa_alloc(&xa0, &id, UINT_MAX, xa_mk_index(id),
+        XA_BUG_ON(xa, id != 0xfffffffeU);
+        XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(UINT_MAX),
+                                XA_LIMIT(UINT_MAX - 1, UINT_MAX),
                                 GFP_KERNEL) != 0);
-        XA_BUG_ON(&xa0, id != 0xffffffffU);
-        XA_BUG_ON(&xa0, xa_alloc(&xa0, &id, UINT_MAX, xa_mk_index(id),
-                                GFP_KERNEL) != -ENOSPC);
-        XA_BUG_ON(&xa0, id != 0xffffffffU);
-        xa_destroy(&xa0);
-
-        id = 10;
-        XA_BUG_ON(&xa0, xa_alloc(&xa0, &id, 5, xa_mk_index(id),
-                                GFP_KERNEL) != -ENOSPC);
-        XA_BUG_ON(&xa0, xa_store_index(&xa0, 3, GFP_KERNEL) != 0);
-        XA_BUG_ON(&xa0, xa_alloc(&xa0, &id, 5, xa_mk_index(id),
-                                GFP_KERNEL) != -ENOSPC);
-        xa_erase_index(&xa0, 3);
-        XA_BUG_ON(&xa0, !xa_empty(&xa0));
+        XA_BUG_ON(xa, id != 0xffffffffU);
+        id = 3;
+        XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(0),
+                                XA_LIMIT(UINT_MAX - 1, UINT_MAX),
+                                GFP_KERNEL) != -EBUSY);
+        XA_BUG_ON(xa, id != 3);
+        xa_destroy(xa);
+
+        XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(10), XA_LIMIT(10, 5),
+                                GFP_KERNEL) != -EBUSY);
+        XA_BUG_ON(xa, xa_store_index(xa, 3, GFP_KERNEL) != 0);
+        XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(10), XA_LIMIT(10, 5),
+                                GFP_KERNEL) != -EBUSY);
+        xa_erase_index(xa, 3);
+        XA_BUG_ON(xa, !xa_empty(xa));
+}
+
+static noinline void check_xa_alloc_2(struct xarray *xa, unsigned int base)
+{
+        unsigned int i, id;
+        unsigned long index;
+        void *entry;
+
+        /* Allocate and free a NULL and check xa_empty() behaves */
+        XA_BUG_ON(xa, !xa_empty(xa));
+        XA_BUG_ON(xa, xa_alloc(xa, &id, NULL, xa_limit_32b, GFP_KERNEL) != 0);
+        XA_BUG_ON(xa, id != base);
+        XA_BUG_ON(xa, xa_empty(xa));
+        XA_BUG_ON(xa, xa_erase(xa, id) != NULL);
+        XA_BUG_ON(xa, !xa_empty(xa));
+
+        /* Ditto, but check destroy instead of erase */
+        XA_BUG_ON(xa, !xa_empty(xa));
+        XA_BUG_ON(xa, xa_alloc(xa, &id, NULL, xa_limit_32b, GFP_KERNEL) != 0);
+        XA_BUG_ON(xa, id != base);
+        XA_BUG_ON(xa, xa_empty(xa));
+        xa_destroy(xa);
+        XA_BUG_ON(xa, !xa_empty(xa));
+
+        for (i = base; i < base + 10; i++) {
+                XA_BUG_ON(xa, xa_alloc(xa, &id, NULL, xa_limit_32b,
+                                        GFP_KERNEL) != 0);
+                XA_BUG_ON(xa, id != i);
+        }
+
+        XA_BUG_ON(xa, xa_store(xa, 3, xa_mk_index(3), GFP_KERNEL) != NULL);
+        XA_BUG_ON(xa, xa_store(xa, 4, xa_mk_index(4), GFP_KERNEL) != NULL);
+        XA_BUG_ON(xa, xa_store(xa, 4, NULL, GFP_KERNEL) != xa_mk_index(4));
+        XA_BUG_ON(xa, xa_erase(xa, 5) != NULL);
+        XA_BUG_ON(xa, xa_alloc(xa, &id, NULL, xa_limit_32b, GFP_KERNEL) != 0);
+        XA_BUG_ON(xa, id != 5);
+
+        xa_for_each(xa, index, entry) {
+                xa_erase_index(xa, index);
+        }
+
+        for (i = base; i < base + 9; i++) {
+                XA_BUG_ON(xa, xa_erase(xa, i) != NULL);
+                XA_BUG_ON(xa, xa_empty(xa));
+        }
+        XA_BUG_ON(xa, xa_erase(xa, 8) != NULL);
+        XA_BUG_ON(xa, xa_empty(xa));
+        XA_BUG_ON(xa, xa_erase(xa, base + 9) != NULL);
+        XA_BUG_ON(xa, !xa_empty(xa));
+
+        xa_destroy(xa);
+}
+
+static noinline void check_xa_alloc_3(struct xarray *xa, unsigned int base)
+{
+        struct xa_limit limit = XA_LIMIT(1, 0x3fff);
+        u32 next = 0;
+        unsigned int i, id;
+        unsigned long index;
+        void *entry;
+
+        XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(1), limit,
+                                &next, GFP_KERNEL) != 0);
+        XA_BUG_ON(xa, id != 1);
+
+        next = 0x3ffd;
+        XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(0x3ffd), limit,
+                                &next, GFP_KERNEL) != 0);
+        XA_BUG_ON(xa, id != 0x3ffd);
+        xa_erase_index(xa, 0x3ffd);
+        xa_erase_index(xa, 1);
+        XA_BUG_ON(xa, !xa_empty(xa));
+
+        for (i = 0x3ffe; i < 0x4003; i++) {
+                if (i < 0x4000)
+                        entry = xa_mk_index(i);
+                else
+                        entry = xa_mk_index(i - 0x3fff);
+                XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, entry, limit,
+                                        &next, GFP_KERNEL) != (id == 1));
+                XA_BUG_ON(xa, xa_mk_index(id) != entry);
+        }
+
+        /* Check wrap-around is handled correctly */
+        if (base != 0)
+                xa_erase_index(xa, base);
+        xa_erase_index(xa, base + 1);
+        next = UINT_MAX;
+        XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(UINT_MAX),
+                                xa_limit_32b, &next, GFP_KERNEL) != 0);
+        XA_BUG_ON(xa, id != UINT_MAX);
+        XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(base),
+                                xa_limit_32b, &next, GFP_KERNEL) != 1);
+        XA_BUG_ON(xa, id != base);
+        XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(base + 1),
+                                xa_limit_32b, &next, GFP_KERNEL) != 0);
+        XA_BUG_ON(xa, id != base + 1);
+
+        xa_for_each(xa, index, entry)
+                xa_erase_index(xa, index);
+
+        XA_BUG_ON(xa, !xa_empty(xa));
+}
+
+static DEFINE_XARRAY_ALLOC(xa0);
+static DEFINE_XARRAY_ALLOC1(xa1);
+
+static noinline void check_xa_alloc(void)
+{
+        check_xa_alloc_1(&xa0, 0);
+        check_xa_alloc_1(&xa1, 1);
+        check_xa_alloc_2(&xa0, 0);
+        check_xa_alloc_2(&xa1, 1);
+        check_xa_alloc_3(&xa0, 0);
+        check_xa_alloc_3(&xa1, 1);
 }
 
 static noinline void __check_store_iter(struct xarray *xa, unsigned long start,
@@ -1194,9 +1346,8 @@ static void check_align_1(struct xarray *xa, char *name)
         void *entry;
 
         for (i = 0; i < 8; i++) {
-                id = 0;
-                XA_BUG_ON(xa, xa_alloc(xa, &id, UINT_MAX, name + i, GFP_KERNEL)
-                                != 0);
+                XA_BUG_ON(xa, xa_alloc(xa, &id, name + i, xa_limit_32b,
+                                        GFP_KERNEL) != 0);
                 XA_BUG_ON(xa, id != i);
         }
         xa_for_each(xa, index, entry)
@@ -1204,6 +1355,30 @@ static void check_align_1(struct xarray *xa, char *name)
         xa_destroy(xa);
 }
 
+/*
+ * We should always be able to store without allocating memory after
+ * reserving a slot.
+ */
+static void check_align_2(struct xarray *xa, char *name)
+{
+        int i;
+
+        XA_BUG_ON(xa, !xa_empty(xa));
+
+        for (i = 0; i < 8; i++) {
+                XA_BUG_ON(xa, xa_store(xa, 0, name + i, GFP_KERNEL) != NULL);
+                xa_erase(xa, 0);
+        }
+
+        for (i = 0; i < 8; i++) {
+                XA_BUG_ON(xa, xa_reserve(xa, 0, GFP_KERNEL) != 0);
+                XA_BUG_ON(xa, xa_store(xa, 0, name + i, 0) != NULL);
+                xa_erase(xa, 0);
+        }
+
+        XA_BUG_ON(xa, !xa_empty(xa));
+}
+
 static noinline void check_align(struct xarray *xa)
 {
         char name[] = "Motorola 68000";
@@ -1212,7 +1387,7 @@ static noinline void check_align(struct xarray *xa)
         check_align_1(xa, name + 1);
         check_align_1(xa, name + 2);
         check_align_1(xa, name + 3);
-//      check_align_2(xa, name);
+        check_align_2(xa, name);
 }
 
 static LIST_HEAD(shadow_nodes);
@@ -1354,6 +1529,7 @@ static int xarray_checks(void)
         check_xas_erase(&array);
         check_cmpxchg(&array);
         check_reserve(&array);
+        check_reserve(&xa0);
         check_multi_store(&array);
         check_xa_alloc();
         check_find(&array);
diff --git a/lib/xarray.c b/lib/xarray.c
index 81c3171ddde9..6be3acbb861f 100644
--- a/lib/xarray.c
+++ b/lib/xarray.c
@@ -57,6 +57,11 @@ static inline bool xa_track_free(const struct xarray *xa)
         return xa->xa_flags & XA_FLAGS_TRACK_FREE;
 }
 
+static inline bool xa_zero_busy(const struct xarray *xa)
+{
+        return xa->xa_flags & XA_FLAGS_ZERO_BUSY;
+}
+
 static inline void xa_mark_set(struct xarray *xa, xa_mark_t mark)
 {
         if (!(xa->xa_flags & XA_FLAGS_MARK(mark)))
@@ -432,6 +437,8 @@ static void xas_shrink(struct xa_state *xas)
                         break;
                 if (!xa_is_node(entry) && node->shift)
                         break;
+                if (xa_is_zero(entry) && xa_zero_busy(xa))
+                        entry = NULL;
                 xas->xa_node = XAS_BOUNDS;
 
                 RCU_INIT_POINTER(xa->xa_head, entry);
@@ -628,6 +635,8 @@ static void *xas_create(struct xa_state *xas, bool allow_root)
         if (xas_top(node)) {
                 entry = xa_head_locked(xa);
                 xas->xa_node = NULL;
+                if (!entry && xa_zero_busy(xa))
+                        entry = XA_ZERO_ENTRY;
                 shift = xas_expand(xas, entry);
                 if (shift < 0)
                         return NULL;
@@ -758,10 +767,12 @@ void *xas_store(struct xa_state *xas, void *entry)
         void *first, *next;
         bool value = xa_is_value(entry);
 
-        if (entry)
-                first = xas_create(xas, !xa_is_node(entry));
-        else
+        if (entry) {
+                bool allow_root = !xa_is_node(entry) && !xa_is_zero(entry);
+                first = xas_create(xas, allow_root);
+        } else {
                 first = xas_load(xas);
+        }
 
         if (xas_invalid(xas))
                 return first;
@@ -791,7 +802,7 @@ void *xas_store(struct xa_state *xas, void *entry)
                  * entry is set to NULL.
                  */
                 rcu_assign_pointer(*slot, entry);
-                if (xa_is_node(next))
+                if (xa_is_node(next) && (!node || node->shift))
                         xas_free_nodes(xas, xa_to_node(next));
                 if (!node)
                         break;
@@ -1294,13 +1305,12 @@ static void *xas_result(struct xa_state *xas, void *curr)
  * @xa: XArray.
  * @index: Index into array.
  *
- * If the entry at this index is a multi-index entry then all indices will
- * be erased, and the entry will no longer be a multi-index entry.
- * This function expects the xa_lock to be held on entry.
+ * After this function returns, loading from @index will return %NULL.
+ * If the index is part of a multi-index entry, all indices will be erased
+ * and none of the entries will be part of a multi-index entry.
  *
- * Context: Any context.  Expects xa_lock to be held on entry.  May
- * release and reacquire xa_lock if @gfp flags permit.
- * Return: The old entry at this index.
+ * Context: Any context.  Expects xa_lock to be held on entry.
+ * Return: The entry which used to be at this index.
  */
 void *__xa_erase(struct xarray *xa, unsigned long index)
 {
@@ -1314,9 +1324,9 @@ EXPORT_SYMBOL(__xa_erase);
  * @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.
+ * After this function returns, loading from @index will return %NULL.
+ * If the index is part of a multi-index entry, all indices will be erased
+ * and none of the entries will be part of a multi-index entry.
  *
  * Context: Any context.  Takes and releases the xa_lock.
  * Return: The entry which used to be at this index.
@@ -1421,16 +1431,12 @@ void *__xa_cmpxchg(struct xarray *xa, unsigned long index,
 
         if (WARN_ON_ONCE(xa_is_advanced(entry)))
                 return XA_ERROR(-EINVAL);
-        if (xa_track_free(xa) && !entry)
-                entry = XA_ZERO_ENTRY;
 
         do {
                 curr = xas_load(&xas);
-                if (curr == XA_ZERO_ENTRY)
-                        curr = NULL;
                 if (curr == old) {
                         xas_store(&xas, entry);
-                        if (xa_track_free(xa))
+                        if (xa_track_free(xa) && entry && !curr)
                                 xas_clear_mark(&xas, XA_FREE_MARK);
                 }
         } while (__xas_nomem(&xas, gfp));
@@ -1452,7 +1458,7 @@ EXPORT_SYMBOL(__xa_cmpxchg);
  *
  * Context: Any context.  Expects xa_lock to be held on entry.  May
  * release and reacquire xa_lock if @gfp flags permit.
- * Return: 0 if the store succeeded.  -EEXIST if another entry was present.
+ * Return: 0 if the store succeeded.  -EBUSY if another entry was present.
  * -ENOMEM if memory could not be allocated.
  */
 int __xa_insert(struct xarray *xa, unsigned long index, void *entry, gfp_t gfp)
@@ -1472,7 +1478,7 @@ int __xa_insert(struct xarray *xa, unsigned long index, void *entry, gfp_t gfp)
                         if (xa_track_free(xa))
                                 xas_clear_mark(&xas, XA_FREE_MARK);
                 } else {
-                        xas_set_err(&xas, -EEXIST);
+                        xas_set_err(&xas, -EBUSY);
                 }
         } while (__xas_nomem(&xas, gfp));
 
@@ -1480,42 +1486,6 @@ int __xa_insert(struct xarray *xa, unsigned long index, void *entry, gfp_t gfp)
 }
 EXPORT_SYMBOL(__xa_insert);
 
-/**
- * __xa_reserve() - Reserve this index in the XArray.
- * @xa: XArray.
- * @index: Index into array.
- * @gfp: Memory allocation flags.
- *
- * Ensures there is somewhere to store an entry at @index in the array.
- * If there is already something stored at @index, this function does
- * nothing.  If there was nothing there, the entry is marked as reserved.
- * Loading from a reserved entry returns a %NULL pointer.
- *
- * If you do not use the entry that you have reserved, call xa_release()
- * or xa_erase() to free any unnecessary memory.
- *
- * Context: Any context.  Expects the xa_lock to be held on entry.  May
- * release the lock, sleep and reacquire the lock if the @gfp flags permit.
- * Return: 0 if the reservation succeeded or -ENOMEM if it failed.
- */
-int __xa_reserve(struct xarray *xa, unsigned long index, gfp_t gfp)
-{
-        XA_STATE(xas, xa, index);
-        void *curr;
-
-        do {
-                curr = xas_load(&xas);
-                if (!curr) {
-                        xas_store(&xas, XA_ZERO_ENTRY);
-                        if (xa_track_free(xa))
-                                xas_clear_mark(&xas, XA_FREE_MARK);
-                }
-        } while (__xas_nomem(&xas, gfp));
-
-        return xas_error(&xas);
-}
-EXPORT_SYMBOL(__xa_reserve);
-
 #ifdef CONFIG_XARRAY_MULTI
 static void xas_set_range(struct xa_state *xas, unsigned long first,
                 unsigned long last)
@@ -1607,23 +1577,23 @@ EXPORT_SYMBOL(xa_store_range);
  * __xa_alloc() - Find somewhere to store this entry in the XArray.
  * @xa: XArray.
  * @id: Pointer to ID.
- * @max: Maximum ID to allocate (inclusive).
+ * @limit: Range for allocated ID.
  * @entry: New entry.
  * @gfp: Memory allocation flags.
  *
- * Allocates an unused ID in the range specified by @id and @max.
- * Updates the @id pointer with the index, then stores the entry at that
- * index.  A concurrent lookup will not see an uninitialised @id.
+ * Finds an empty entry in @xa between @limit.min and @limit.max,
+ * stores the index into the @id pointer, then stores the entry at
+ * that index.  A concurrent lookup will not see an uninitialised @id.
  *
  * Context: Any context.  Expects xa_lock to be held on entry.  May
  * release and reacquire xa_lock if @gfp flags permit.
- * Return: 0 on success, -ENOMEM if memory allocation fails or -ENOSPC if
- * there is no more space in the XArray.
+ * Return: 0 on success, -ENOMEM if memory could not be allocated or
+ * -EBUSY if there are no free entries in @limit.
  */
-int __xa_alloc(struct xarray *xa, u32 *id, u32 max, void *entry, gfp_t gfp)
+int __xa_alloc(struct xarray *xa, u32 *id, void *entry,
+                struct xa_limit limit, gfp_t gfp)
 {
         XA_STATE(xas, xa, 0);
-        int err;
 
         if (WARN_ON_ONCE(xa_is_advanced(entry)))
                 return -EINVAL;
@@ -1634,22 +1604,71 @@ int __xa_alloc(struct xarray *xa, u32 *id, u32 max, void *entry, gfp_t gfp)
                 entry = XA_ZERO_ENTRY;
 
         do {
-                xas.xa_index = *id;
-                xas_find_marked(&xas, max, XA_FREE_MARK);
+                xas.xa_index = limit.min;
+                xas_find_marked(&xas, limit.max, XA_FREE_MARK);
                 if (xas.xa_node == XAS_RESTART)
-                        xas_set_err(&xas, -ENOSPC);
+                        xas_set_err(&xas, -EBUSY);
+                else
+                        *id = xas.xa_index;
                 xas_store(&xas, entry);
                 xas_clear_mark(&xas, XA_FREE_MARK);
         } while (__xas_nomem(&xas, gfp));
 
-        err = xas_error(&xas);
-        if (!err)
-                *id = xas.xa_index;
-        return err;
+        return xas_error(&xas);
 }
 EXPORT_SYMBOL(__xa_alloc);
 
 /**
+ * __xa_alloc_cyclic() - Find somewhere to store this entry in the XArray.
+ * @xa: XArray.
+ * @id: Pointer to ID.
+ * @entry: New entry.
+ * @limit: Range of allocated ID.
+ * @next: Pointer to next ID to allocate.
+ * @gfp: Memory allocation flags.
+ *
+ * Finds an empty entry in @xa between @limit.min and @limit.max,
+ * stores the index into the @id pointer, then stores the entry at
+ * that index.  A concurrent lookup will not see an uninitialised @id.
+ * The search for an empty entry will start at @next and will wrap
+ * around if necessary.
+ *
+ * Context: Any context.  Expects xa_lock to be held on entry.  May
+ * release and reacquire xa_lock if @gfp flags permit.
+ * Return: 0 if the allocation succeeded without wrapping.  1 if the
+ * allocation succeeded after wrapping, -ENOMEM if memory could not be
+ * allocated or -EBUSY if there are no free entries in @limit.
+ */
+int __xa_alloc_cyclic(struct xarray *xa, u32 *id, void *entry,
+                struct xa_limit limit, u32 *next, gfp_t gfp)
+{
+        u32 min = limit.min;
+        int ret;
+
+        limit.min = max(min, *next);
+        ret = __xa_alloc(xa, id, entry, limit, gfp);
+        if ((xa->xa_flags & XA_FLAGS_ALLOC_WRAPPED) && ret == 0) {
+                xa->xa_flags &= ~XA_FLAGS_ALLOC_WRAPPED;
+                ret = 1;
+        }
+
+        if (ret < 0 && limit.min > min) {
+                limit.min = min;
+                ret = __xa_alloc(xa, id, entry, limit, gfp);
+                if (ret == 0)
+                        ret = 1;
+        }
+
+        if (ret >= 0) {
+                *next = *id + 1;
+                if (*next == 0)
+                        xa->xa_flags |= XA_FLAGS_ALLOC_WRAPPED;
+        }
+        return ret;
+}
+EXPORT_SYMBOL(__xa_alloc_cyclic);
+
+/**
  * __xa_set_mark() - Set this mark on this entry while locked.
  * @xa: XArray.
  * @index: Index of entry.
@@ -1943,6 +1962,8 @@ void xa_destroy(struct xarray *xa)
         entry = xa_head_locked(xa);
         RCU_INIT_POINTER(xa->xa_head, NULL);
         xas_init_marks(&xas);
+        if (xa_zero_busy(xa))
+                xa_mark_clear(xa, XA_FREE_MARK);
         /* lockdep checks we're still holding the lock in xas_free_nodes() */
         if (xa_is_node(entry))
                 xas_free_nodes(&xas, xa_to_node(entry));