maple_tree: Add mtree_alloc_cyclic()

I need a cyclic allocator for the simple_offset implementation in
fs/libfs.c.

Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Link: https://lore.kernel.org/r/170820144179.6328.12838600511394432325.stgit@91.116.238.104.host.secureserver.net
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/include/linux/maple_tree.h b/include/linux/maple_tree.h
index b3d63123b945b58bc7549142d79fd2783f2b0f07..a53ad4dabd7e8f7618a991d3fd17dc65fe2f33fd 100644 (file)
--- a/include/linux/maple_tree.h
+++ b/include/linux/maple_tree.h
@@ -171,6 +171,7 @@ enum maple_type {
 #define MT_FLAGS_LOCK_IRQ      0x100
 #define MT_FLAGS_LOCK_BH       0x200
 #define MT_FLAGS_LOCK_EXTERN   0x300
+#define MT_FLAGS_ALLOC_WRAPPED 0x0800
 
 #define MAPLE_HEIGHT_MAX       31
 
@@ -319,6 +320,9 @@ int mtree_insert_range(struct maple_tree *mt, unsigned long first,
 int mtree_alloc_range(struct maple_tree *mt, unsigned long *startp,
                void *entry, unsigned long size, unsigned long min,
                unsigned long max, gfp_t gfp);
+int mtree_alloc_cyclic(struct maple_tree *mt, unsigned long *startp,
+               void *entry, unsigned long range_lo, unsigned long range_hi,
+               unsigned long *next, gfp_t gfp);
 int mtree_alloc_rrange(struct maple_tree *mt, unsigned long *startp,
                void *entry, unsigned long size, unsigned long min,
                unsigned long max, gfp_t gfp);
@@ -499,6 +503,9 @@ void *mas_find_range(struct ma_state *mas, unsigned long max);
 void *mas_find_rev(struct ma_state *mas, unsigned long min);
 void *mas_find_range_rev(struct ma_state *mas, unsigned long max);
 int mas_preallocate(struct ma_state *mas, void *entry, gfp_t gfp);
+int mas_alloc_cyclic(struct ma_state *mas, unsigned long *startp,
+               void *entry, unsigned long range_lo, unsigned long range_hi,
+               unsigned long *next, gfp_t gfp);
 
 bool mas_nomem(struct ma_state *mas, gfp_t gfp);
 void mas_pause(struct ma_state *mas);

diff --git a/lib/maple_tree.c b/lib/maple_tree.c
index 6f241bb38799201defb1b31154920dcc257b9831..af097028872722f4e3a0225f5ca4adb9097c3f39 100644 (file)
--- a/lib/maple_tree.c
+++ b/lib/maple_tree.c
@@ -4290,6 +4290,56 @@ exists:
 
 }
 
+/**
+ * mas_alloc_cyclic() - Internal call to find somewhere to store an entry
+ * @mas: The maple state.
+ * @startp: Pointer to ID.
+ * @range_lo: Lower bound of range to search.
+ * @range_hi: Upper bound of range to search.
+ * @entry: The entry to store.
+ * @next: Pointer to next ID to allocate.
+ * @gfp: The GFP_FLAGS to use for allocations.
+ *
+ * Return: 0 if the allocation succeeded without wrapping, 1 if the
+ * allocation succeeded after wrapping, or -EBUSY if there are no
+ * free entries.
+ */
+int mas_alloc_cyclic(struct ma_state *mas, unsigned long *startp,
+               void *entry, unsigned long range_lo, unsigned long range_hi,
+               unsigned long *next, gfp_t gfp)
+{
+       unsigned long min = range_lo;
+       int ret = 0;
+
+       range_lo = max(min, *next);
+       ret = mas_empty_area(mas, range_lo, range_hi, 1);
+       if ((mas->tree->ma_flags & MT_FLAGS_ALLOC_WRAPPED) && ret == 0) {
+               mas->tree->ma_flags &= ~MT_FLAGS_ALLOC_WRAPPED;
+               ret = 1;
+       }
+       if (ret < 0 && range_lo > min) {
+               ret = mas_empty_area(mas, min, range_hi, 1);
+               if (ret == 0)
+                       ret = 1;
+       }
+       if (ret < 0)
+               return ret;
+
+       do {
+               mas_insert(mas, entry);
+       } while (mas_nomem(mas, gfp));
+       if (mas_is_err(mas))
+               return xa_err(mas->node);
+
+       *startp = mas->index;
+       *next = *startp + 1;
+       if (*next == 0)
+               mas->tree->ma_flags |= MT_FLAGS_ALLOC_WRAPPED;
+
+       return ret;
+}
+EXPORT_SYMBOL(mas_alloc_cyclic);
+
 static __always_inline void mas_rewalk(struct ma_state *mas, unsigned long index)
 {
 retry:
@@ -6443,6 +6493,49 @@ unlock:
 }
 EXPORT_SYMBOL(mtree_alloc_range);
 
+/**
+ * mtree_alloc_cyclic() - Find somewhere to store this entry in the tree.
+ * @mt: The maple tree.
+ * @startp: Pointer to ID.
+ * @range_lo: Lower bound of range to search.
+ * @range_hi: Upper bound of range to search.
+ * @entry: The entry to store.
+ * @next: Pointer to next ID to allocate.
+ * @gfp: The GFP_FLAGS to use for allocations.
+ *
+ * Finds an empty entry in @mt after @next, stores the new index into
+ * the @id pointer, stores the entry at that index, then updates @next.
+ *
+ * @mt must be initialized with the MT_FLAGS_ALLOC_RANGE flag.
+ *
+ * Context: Any context.  Takes and releases the mt.lock.  May sleep if
+ * the @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, -EINVAL if @mt cannot be used, or -EBUSY if there are no
+ * free entries.
+ */
+int mtree_alloc_cyclic(struct maple_tree *mt, unsigned long *startp,
+               void *entry, unsigned long range_lo, unsigned long range_hi,
+               unsigned long *next, gfp_t gfp)
+{
+       int ret;
+
+       MA_STATE(mas, mt, 0, 0);
+
+       if (!mt_is_alloc(mt))
+               return -EINVAL;
+       if (WARN_ON_ONCE(mt_is_reserved(entry)))
+               return -EINVAL;
+       mtree_lock(mt);
+       ret = mas_alloc_cyclic(&mas, startp, entry, range_lo, range_hi,
+                              next, gfp);
+       mtree_unlock(mt);
+       return ret;
+}
+EXPORT_SYMBOL(mtree_alloc_cyclic);
+
 int mtree_alloc_rrange(struct maple_tree *mt, unsigned long *startp,
                void *entry, unsigned long size, unsigned long min,
                unsigned long max, gfp_t gfp)