2 files changed, 203 insertions, 247 deletions

diff --git a/lib/idr.c b/lib/idr.c
index 9a366b5be2c2..3c20ad9b0463 100644
--- a/lib/idr.c
+++ b/lib/idr.c
@@ -6,8 +6,6 @@
 #include <linux/spinlock.h>
 #include <linux/xarray.h>
 
-DEFINE_PER_CPU(struct ida_bitmap *, ida_bitmap);
-
 /**
  * idr_alloc_u32() - Allocate an ID.
  * @idr: IDR handle.
@@ -320,6 +318,9 @@ EXPORT_SYMBOL(idr_replace);
  * free the individual IDs in it.  You can use ida_is_empty() to find
  * out whether the IDA has any IDs currently allocated.
  *
+ * The IDA handles its own locking.  It is safe to call any of the IDA
+ * functions without synchronisation in your code.
+ *
  * IDs are currently limited to the range [0-INT_MAX].  If this is an awkward
  * limitation, it should be quite straightforward to raise the maximum.
  */
@@ -327,151 +328,197 @@ EXPORT_SYMBOL(idr_replace);
 /*
  * Developer's notes:
  *
- * The IDA uses the functionality provided by the IDR & radix tree to store
- * bitmaps in each entry.  The IDR_FREE tag means there is at least one bit
- * free, unlike the IDR where it means at least one entry is free.
+ * The IDA uses the functionality provided by the XArray to store bitmaps in
+ * each entry.  The XA_FREE_MARK is only cleared when all bits in the bitmap
+ * have been set.
  *
- * I considered telling the radix tree that each slot is an order-10 node
- * and storing the bit numbers in the radix tree, but the radix tree can't
- * allow a single multiorder entry at index 0, which would significantly
- * increase memory consumption for the IDA.  So instead we divide the index
- * by the number of bits in the leaf bitmap before doing a radix tree lookup.
+ * I considered telling the XArray that each slot is an order-10 node
+ * and indexing by bit number, but the XArray can't allow a single multi-index
+ * entry in the head, which would significantly increase memory consumption
+ * for the IDA.  So instead we divide the index by the number of bits in the
+ * leaf bitmap before doing a radix tree lookup.
  *
  * As an optimisation, if there are only a few low bits set in any given
  * leaf, instead of allocating a 128-byte bitmap, we store the bits
- * directly in the entry.
- *
- * We allow the radix tree 'exceptional' count to get out of date.  Nothing
- * in the IDA nor the radix tree code checks it.  If it becomes important
- * to maintain an accurate exceptional count, switch the rcu_assign_pointer()
- * calls to radix_tree_iter_replace() which will correct the exceptional
- * count.
- *
- * The IDA always requires a lock to alloc/free.  If we add a 'test_bit'
+ * as a value entry.  Value entries never have the XA_FREE_MARK cleared
+ * because we can always convert them into a bitmap entry.
+ *
+ * It would be possible to optimise further; once we've run out of a
+ * single 128-byte bitmap, we currently switch to a 576-byte node, put
+ * the 128-byte bitmap in the first entry and then start allocating extra
+ * 128-byte entries.  We could instead use the 512 bytes of the node's
+ * data as a bitmap before moving to that scheme.  I do not believe this
+ * is a worthwhile optimisation; Rasmus Villemoes surveyed the current
+ * users of the IDA and almost none of them use more than 1024 entries.
+ * Those that do use more than the 8192 IDs that the 512 bytes would
+ * provide.
+ *
+ * The IDA always uses a lock to alloc/free.  If we add a 'test_bit'
  * equivalent, it will still need locking.  Going to RCU lookup would require
  * using RCU to free bitmaps, and that's not trivial without embedding an
  * RCU head in the bitmap, which adds a 2-pointer overhead to each 128-byte
  * bitmap, which is excessive.
  */
 
-#define IDA_MAX (0x80000000U / IDA_BITMAP_BITS - 1)
-
-static int ida_get_new_above(struct ida *ida, int start)
+/**
+ * ida_alloc_range() - Allocate an unused ID.
+ * @ida: IDA handle.
+ * @min: Lowest ID to allocate.
+ * @max: Highest ID to allocate.
+ * @gfp: Memory allocation flags.
+ *
+ * Allocate an ID between @min and @max, inclusive.  The allocated ID will
+ * not exceed %INT_MAX, even if @max is larger.
+ *
+ * Context: Any context.
+ * Return: The allocated ID, or %-ENOMEM if memory could not be allocated,
+ * or %-ENOSPC if there are no free IDs.
+ */
+int ida_alloc_range(struct ida *ida, unsigned int min, unsigned int max,
+                        gfp_t gfp)
 {
-        struct radix_tree_root *root = &ida->ida_rt;
-        void __rcu **slot;
-        struct radix_tree_iter iter;
-        struct ida_bitmap *bitmap;
-        unsigned long index;
-        unsigned bit;
-        int new;
-
-        index = start / IDA_BITMAP_BITS;
-        bit = start % IDA_BITMAP_BITS;
-
-        slot = radix_tree_iter_init(&iter, index);
-        for (;;) {
-                if (slot)
-                        slot = radix_tree_next_slot(slot, &iter,
-                                                RADIX_TREE_ITER_TAGGED);
-                if (!slot) {
-                        slot = idr_get_free(root, &iter, GFP_NOWAIT, IDA_MAX);
-                        if (IS_ERR(slot)) {
-                                if (slot == ERR_PTR(-ENOMEM))
-                                        return -EAGAIN;
-                                return PTR_ERR(slot);
+        XA_STATE(xas, &ida->xa, min / IDA_BITMAP_BITS);
+        unsigned bit = min % IDA_BITMAP_BITS;
+        unsigned long flags;
+        struct ida_bitmap *bitmap, *alloc = NULL;
+
+        if ((int)min < 0)
+                return -ENOSPC;
+
+        if ((int)max < 0)
+                max = INT_MAX;
+
+retry:
+        xas_lock_irqsave(&xas, flags);
+next:
+        bitmap = xas_find_marked(&xas, max / IDA_BITMAP_BITS, XA_FREE_MARK);
+        if (xas.xa_index > min / IDA_BITMAP_BITS)
+                bit = 0;
+        if (xas.xa_index * IDA_BITMAP_BITS + bit > max)
+                goto nospc;
+
+        if (xa_is_value(bitmap)) {
+                unsigned long tmp = xa_to_value(bitmap);
+
+                if (bit < BITS_PER_XA_VALUE) {
+                        bit = find_next_zero_bit(&tmp, BITS_PER_XA_VALUE, bit);
+                        if (xas.xa_index * IDA_BITMAP_BITS + bit > max)
+                                goto nospc;
+                        if (bit < BITS_PER_XA_VALUE) {
+                                tmp |= 1UL << bit;
+                                xas_store(&xas, xa_mk_value(tmp));
+                                goto out;
                         }
                 }
-                if (iter.index > index)
-                        bit = 0;
-                new = iter.index * IDA_BITMAP_BITS;
-                bitmap = rcu_dereference_raw(*slot);
-                if (xa_is_value(bitmap)) {
-                        unsigned long tmp = xa_to_value(bitmap);
-                        int vbit = find_next_zero_bit(&tmp, BITS_PER_XA_VALUE,
-                                                        bit);
-                        if (vbit < BITS_PER_XA_VALUE) {
-                                tmp |= 1UL << vbit;
-                                rcu_assign_pointer(*slot, xa_mk_value(tmp));
-                                return new + vbit;
-                        }
-                        bitmap = this_cpu_xchg(ida_bitmap, NULL);
-                        if (!bitmap)
-                                return -EAGAIN;
-                        bitmap->bitmap[0] = tmp;
-                        rcu_assign_pointer(*slot, bitmap);
+                bitmap = alloc;
+                if (!bitmap)
+                        bitmap = kzalloc(sizeof(*bitmap), GFP_NOWAIT);
+                if (!bitmap)
+                        goto alloc;
+                bitmap->bitmap[0] = tmp;
+                xas_store(&xas, bitmap);
+                if (xas_error(&xas)) {
+                        bitmap->bitmap[0] = 0;
+                        goto out;
                 }
+        }
 
-                if (bitmap) {
-                        bit = find_next_zero_bit(bitmap->bitmap,
-                                                        IDA_BITMAP_BITS, bit);
-                        new += bit;
-                        if (new < 0)
-                                return -ENOSPC;
-                        if (bit == IDA_BITMAP_BITS)
-                                continue;
+        if (bitmap) {
+                bit = find_next_zero_bit(bitmap->bitmap, IDA_BITMAP_BITS, bit);
+                if (xas.xa_index * IDA_BITMAP_BITS + bit > max)
+                        goto nospc;
+                if (bit == IDA_BITMAP_BITS)
+                        goto next;
 
-                        __set_bit(bit, bitmap->bitmap);
-                        if (bitmap_full(bitmap->bitmap, IDA_BITMAP_BITS))
-                                radix_tree_iter_tag_clear(root, &iter,
-                                                                IDR_FREE);
+                __set_bit(bit, bitmap->bitmap);
+                if (bitmap_full(bitmap->bitmap, IDA_BITMAP_BITS))
+                        xas_clear_mark(&xas, XA_FREE_MARK);
+        } else {
+                if (bit < BITS_PER_XA_VALUE) {
+                        bitmap = xa_mk_value(1UL << bit);
                 } else {
-                        new += bit;
-                        if (new < 0)
-                                return -ENOSPC;
-                        if (bit < BITS_PER_XA_VALUE) {
-                                bitmap = xa_mk_value(1UL << bit);
-                        } else {
-                                bitmap = this_cpu_xchg(ida_bitmap, NULL);
-                                if (!bitmap)
-                                        return -EAGAIN;
-                                __set_bit(bit, bitmap->bitmap);
-                        }
-                        radix_tree_iter_replace(root, &iter, slot, bitmap);
+                        bitmap = alloc;
+                        if (!bitmap)
+                                bitmap = kzalloc(sizeof(*bitmap), GFP_NOWAIT);
+                        if (!bitmap)
+                                goto alloc;
+                        __set_bit(bit, bitmap->bitmap);
                 }