History

XArray: Add cyclic allocation

This differs slightly from the IDR equivalent in five ways. 1. It can allocate up to UINT_MAX instead of being limited to INT_MAX, like xa_alloc(). Also like xa_alloc(), it will write to the 'id' pointer before placing the entry in the XArray. 2. The 'next' cursor is allocated separately from the XArray instead of being part of the IDR. This saves memory for all the users which do not use the cyclic allocation API and suits some users better. 3. It returns -EBUSY instead of -ENOSPC. 4. It will attempt to wrap back to the minimum value on memory allocation failure as well as on an -EBUSY error, assuming that a user would rather allocate a small ID than suffer an ID allocation failure. 5. It reports whether it has wrapped, which is important to some users.

Matthew Wilcox committed 8 years ago

Commit 2fa044e1 parent a3e4d3f4 files · +208 −1Browse files

Unified · Split

4 files
  1. Documentation/core-api/xarray.rst +3 −1
  2. include/linux/xarray.h +102 −0
  3. lib/test_xarray.c +53 −0
  4. lib/xarray.c +50 −0
Documentation/core-api/xarray.rst+3−1
@@ -144,7 +144,9 @@ you only want to free the entry if it's ``NULL``). · 143 unmodified lines
144144
145145 By default, the lowest free entry is allocated starting from 0. If you
146146 want to allocate entries starting at 1, it is more efficient to use
147−:c:func:`DEFINE_XARRAY_ALLOC1` or ``XA_FLAGS_ALLOC1``.
147+:c:func:`DEFINE_XARRAY_ALLOC1` or ``XA_FLAGS_ALLOC1``. If you want to
148+allocate IDs up to a maximum, then wrap back around to the lowest free
149+ID, you can use :c:func:`xa_alloc_cyclic`.
148150
149151 You cannot use ``XA_MARK_0`` with an allocating XArray as this mark
150152 is used to track whether an entry is free or not. The other marks are
include/linux/xarray.h+102−0
@@ -242,6 +242,7 @@ enum xa_lock_type { · 241 unmodified lines
242242 #define XA_FLAGS_LOCK_BH ((__force gfp_t)XA_LOCK_BH)
243243 #define XA_FLAGS_TRACK_FREE ((__force gfp_t)4U)
244244 #define XA_FLAGS_ZERO_BUSY ((__force gfp_t)8U)
245+#define XA_FLAGS_ALLOC_WRAPPED ((__force gfp_t)16U)
245246 #define XA_FLAGS_MARK(mark) ((__force gfp_t)((1U << __GFP_BITS_SHIFT) << \
246247 (__force unsigned)(mark)))
247248
@@ -499,6 +500,8 @@ void *__xa_cmpxchg(struct xarray *, unsigned long index, void *old, · 251 unmodified lines
499500 int __xa_insert(struct xarray *, unsigned long index, void *entry, gfp_t);
500501 int __must_check __xa_alloc(struct xarray *, u32 *id, void *entry,
501502 struct xa_limit, gfp_t);
503+int __must_check __xa_alloc_cyclic(struct xarray *, u32 *id, void *entry,
504+ struct xa_limit, u32 *next, gfp_t);
502505 int __xa_reserve(struct xarray *, unsigned long index, gfp_t);
503506 void __xa_set_mark(struct xarray *, unsigned long index, xa_mark_t);
504507 void __xa_clear_mark(struct xarray *, unsigned long index, xa_mark_t);
@@ -858,6 +861,105 @@ static inline int __must_check xa_alloc_irq(struct xarray *xa, u32 *id, · 353 unmodified lines
858861 return err;
859862 }
860863
864+/**
865+ * xa_alloc_cyclic() - Find somewhere to store this entry in the XArray.
866+ * @xa: XArray.
867+ * @id: Pointer to ID.
868+ * @entry: New entry.
869+ * @limit: Range of allocated ID.
870+ * @next: Pointer to next ID to allocate.
871+ * @gfp: Memory allocation flags.
872+ *
873+ * Finds an empty entry in @xa between @limit.min and @limit.max,
874+ * stores the index into the @id pointer, then stores the entry at
875+ * that index. A concurrent lookup will not see an uninitialised @id.
876+ * The search for an empty entry will start at @next and will wrap
877+ * around if necessary.
878+ *
879+ * Context: Any context. Takes and releases the xa_lock. May sleep if
880+ * the @gfp flags permit.
881+ * Return: 0 if the allocation succeeded without wrapping. 1 if the
882+ * allocation succeeded after wrapping, -ENOMEM if memory could not be
883+ * allocated or -EBUSY if there are no free entries in @limit.
884+ */
885+static inline int xa_alloc_cyclic(struct xarray *xa, u32 *id, void *entry,
886+ struct xa_limit limit, u32 *next, gfp_t gfp)
887+{
888+ int err;
889+
890+ xa_lock(xa);
891+ err = __xa_alloc_cyclic(xa, id, entry, limit, next, gfp);
892+ xa_unlock(xa);
893+
894+ return err;
895+}
896+
897+/**
898+ * xa_alloc_cyclic_bh() - Find somewhere to store this entry in the XArray.
899+ * @xa: XArray.
900+ * @id: Pointer to ID.
901+ * @entry: New entry.
902+ * @limit: Range of allocated ID.
903+ * @next: Pointer to next ID to allocate.
904+ * @gfp: Memory allocation flags.
905+ *
906+ * Finds an empty entry in @xa between @limit.min and @limit.max,
907+ * stores the index into the @id pointer, then stores the entry at
908+ * that index. A concurrent lookup will not see an uninitialised @id.
909+ * The search for an empty entry will start at @next and will wrap
910+ * around if necessary.
911+ *
912+ * Context: Any context. Takes and releases the xa_lock while
913+ * disabling softirqs. May sleep if the @gfp flags permit.
914+ * Return: 0 if the allocation succeeded without wrapping. 1 if the
915+ * allocation succeeded after wrapping, -ENOMEM if memory could not be
916+ * allocated or -EBUSY if there are no free entries in @limit.
917+ */
918+static inline int xa_alloc_cyclic_bh(struct xarray *xa, u32 *id, void *entry,
919+ struct xa_limit limit, u32 *next, gfp_t gfp)
920+{
921+ int err;
922+
923+ xa_lock_bh(xa);
924+ err = __xa_alloc_cyclic(xa, id, entry, limit, next, gfp);
925+ xa_unlock_bh(xa);
926+
927+ return err;
928+}
929+
930+/**
931+ * xa_alloc_cyclic_irq() - Find somewhere to store this entry in the XArray.
932+ * @xa: XArray.
933+ * @id: Pointer to ID.
934+ * @entry: New entry.
935+ * @limit: Range of allocated ID.
936+ * @next: Pointer to next ID to allocate.
937+ * @gfp: Memory allocation flags.
938+ *
939+ * Finds an empty entry in @xa between @limit.min and @limit.max,
940+ * stores the index into the @id pointer, then stores the entry at
941+ * that index. A concurrent lookup will not see an uninitialised @id.
942+ * The search for an empty entry will start at @next and will wrap
943+ * around if necessary.
944+ *
945+ * Context: Process context. Takes and releases the xa_lock while
946+ * disabling interrupts. May sleep if the @gfp flags permit.
947+ * Return: 0 if the allocation succeeded without wrapping. 1 if the
948+ * allocation succeeded after wrapping, -ENOMEM if memory could not be
949+ * allocated or -EBUSY if there are no free entries in @limit.
950+ */
951+static inline int xa_alloc_cyclic_irq(struct xarray *xa, u32 *id, void *entry,
952+ struct xa_limit limit, u32 *next, gfp_t gfp)
953+{
954+ int err;
955+
956+ xa_lock_irq(xa);
957+ err = __xa_alloc_cyclic(xa, id, entry, limit, next, gfp);
958+ xa_unlock_irq(xa);
959+
960+ return err;
961+}
962+
861963 /**
862964 * xa_reserve() - Reserve this index in the XArray.
863965 * @xa: XArray.
lib/test_xarray.c+53−0
@@ -715,6 +715,57 @@ static noinline void check_xa_alloc_2(struct xarray *xa, unsigned int base) · 714 unmodified lines
715715 xa_destroy(xa);
716716 }
717717
718+static noinline void check_xa_alloc_3(struct xarray *xa, unsigned int base)
719+{
720+ struct xa_limit limit = XA_LIMIT(1, 0x3fff);
721+ u32 next = 0;
722+ unsigned int i, id;
723+ unsigned long index;
724+ void *entry;
725+
726+ XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(1), limit,
727+ &next, GFP_KERNEL) != 0);
728+ XA_BUG_ON(xa, id != 1);
729+
730+ next = 0x3ffd;
731+ XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(0x3ffd), limit,
732+ &next, GFP_KERNEL) != 0);
733+ XA_BUG_ON(xa, id != 0x3ffd);
734+ xa_erase_index(xa, 0x3ffd);
735+ xa_erase_index(xa, 1);
736+ XA_BUG_ON(xa, !xa_empty(xa));
737+
738+ for (i = 0x3ffe; i < 0x4003; i++) {
739+ if (i < 0x4000)
740+ entry = xa_mk_index(i);
741+ else
742+ entry = xa_mk_index(i - 0x3fff);
743+ XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, entry, limit,
744+ &next, GFP_KERNEL) != (id == 1));
745+ XA_BUG_ON(xa, xa_mk_index(id) != entry);
746+ }
747+
748+ /* Check wrap-around is handled correctly */
749+ if (base != 0)
750+ xa_erase_index(xa, base);
751+ xa_erase_index(xa, base + 1);
752+ next = UINT_MAX;
753+ XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(UINT_MAX),
754+ xa_limit_32b, &next, GFP_KERNEL) != 0);
755+ XA_BUG_ON(xa, id != UINT_MAX);
756+ XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(base),
757+ xa_limit_32b, &next, GFP_KERNEL) != 1);
758+ XA_BUG_ON(xa, id != base);
759+ XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(base + 1),
760+ xa_limit_32b, &next, GFP_KERNEL) != 0);
761+ XA_BUG_ON(xa, id != base + 1);
762+
763+ xa_for_each(xa, index, entry)
764+ xa_erase_index(xa, index);
765+
766+ XA_BUG_ON(xa, !xa_empty(xa));
767+}
768+
718769 static DEFINE_XARRAY_ALLOC(xa0);
719770 static DEFINE_XARRAY_ALLOC1(xa1);
720771
@@ -724,6 +775,8 @@ static noinline void check_xa_alloc(void) · 3 unmodified lines
724775 check_xa_alloc_1(&xa1, 1);
725776 check_xa_alloc_2(&xa0, 0);
726777 check_xa_alloc_2(&xa1, 1);
778+ check_xa_alloc_3(&xa0, 0);
779+ check_xa_alloc_3(&xa1, 1);
727780 }
728781
729782 static noinline void __check_store_iter(struct xarray *xa, unsigned long start,
lib/xarray.c+50−0
@@ -1656,6 +1656,56 @@ int __xa_alloc(struct xarray *xa, u32 *id, void *entry, · 1655 unmodified lines
16561656 }
16571657 EXPORT_SYMBOL(__xa_alloc);
16581658
1659+/**
1660+ * __xa_alloc_cyclic() - Find somewhere to store this entry in the XArray.
1661+ * @xa: XArray.
1662+ * @id: Pointer to ID.
1663+ * @entry: New entry.
1664+ * @limit: Range of allocated ID.
1665+ * @next: Pointer to next ID to allocate.
1666+ * @gfp: Memory allocation flags.
1667+ *
1668+ * Finds an empty entry in @xa between @limit.min and @limit.max,
1669+ * stores the index into the @id pointer, then stores the entry at
1670+ * that index. A concurrent lookup will not see an uninitialised @id.
1671+ * The search for an empty entry will start at @next and will wrap
1672+ * around if necessary.
1673+ *
1674+ * Context: Any context. Expects xa_lock to be held on entry. May
1675+ * release and reacquire xa_lock if @gfp flags permit.
1676+ * Return: 0 if the allocation succeeded without wrapping. 1 if the
1677+ * allocation succeeded after wrapping, -ENOMEM if memory could not be
1678+ * allocated or -EBUSY if there are no free entries in @limit.
1679+ */
1680+int __xa_alloc_cyclic(struct xarray *xa, u32 *id, void *entry,
1681+ struct xa_limit limit, u32 *next, gfp_t gfp)
1682+{
1683+ u32 min = limit.min;
1684+ int ret;
1685+
1686+ limit.min = max(min, *next);
1687+ ret = __xa_alloc(xa, id, entry, limit, gfp);
1688+ if ((xa->xa_flags & XA_FLAGS_ALLOC_WRAPPED) && ret == 0) {
1689+ xa->xa_flags &= ~XA_FLAGS_ALLOC_WRAPPED;
1690+ ret = 1;
1691+ }
1692+
1693+ if (ret < 0 && limit.min > min) {
1694+ limit.min = min;
1695+ ret = __xa_alloc(xa, id, entry, limit, gfp);
1696+ if (ret == 0)
1697+ ret = 1;
1698+ }
1699+
1700+ if (ret >= 0) {
1701+ *next = *id + 1;
1702+ if (*next == 0)
1703+ xa->xa_flags |= XA_FLAGS_ALLOC_WRAPPED;
1704+ }
1705+ return ret;
1706+}
1707+EXPORT_SYMBOL(__xa_alloc_cyclic);
1708+
16591709 /**
16601710 * __xa_set_mark() - Set this mark on this entry while locked.
16611711 * @xa: XArray.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t