History

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

Linus Torvalds committed 7 years ago

Commit ea295482 parents f3124cc 4a5c8d87 files · +561 −260Browse files

Showing the changes to include/linux (1 of 7 files). Show all

Unified · Split

include/linux/xarray.h+212−84
@@ -131,6 +131,12 @@ static inline unsigned int xa_pointer_tag(void *entry) · 130 unmodified lines
131131 * xa_mk_internal() - Create an internal entry.
132132 * @v: Value to turn into an internal entry.
133133 *
134+ * Internal entries are used for a number of purposes. Entries 0-255 are
135+ * used for sibling entries (only 0-62 are used by the current code). 256
136+ * is used for the retry entry. 257 is used for the reserved / zero entry.
137+ * Negative internal entries are used to represent errnos. Node pointers
138+ * are also tagged as internal entries in some situations.
139+ *
134140 * Context: Any context.
135141 * Return: An XArray internal entry corresponding to this value.
136142 */
@@ -163,6 +169,22 @@ static inline bool xa_is_internal(const void *entry) · 26 unmodified lines
163169 return ((unsigned long)entry & 3) == 2;
164170 }
165171
172+#define XA_ZERO_ENTRY xa_mk_internal(257)
173+
174+/**
175+ * xa_is_zero() - Is the entry a zero entry?
176+ * @entry: Entry retrieved from the XArray
177+ *
178+ * The normal API will return NULL as the contents of a slot containing
179+ * a zero entry. You can only see zero entries by using the advanced API.
180+ *
181+ * Return: %true if the entry is a zero entry.
182+ */
183+static inline bool xa_is_zero(const void *entry)
184+{
185+ return unlikely(entry == XA_ZERO_ENTRY);
186+}
187+
166188 /**
167189 * xa_is_err() - Report whether an XArray operation returned an error
168190 * @entry: Result from calling an XArray function
@@ -200,6 +222,27 @@ static inline int xa_err(void *entry) · 31 unmodified lines
200222 return 0;
201223 }
202224
225+/**
226+ * struct xa_limit - Represents a range of IDs.
227+ * @min: The lowest ID to allocate (inclusive).
228+ * @max: The maximum ID to allocate (inclusive).
229+ *
230+ * This structure is used either directly or via the XA_LIMIT() macro
231+ * to communicate the range of IDs that are valid for allocation.
232+ * Two common ranges are predefined for you:
233+ * * xa_limit_32b - [0 - UINT_MAX]
234+ * * xa_limit_31b - [0 - INT_MAX]
235+ */
236+struct xa_limit {
237+ u32 max;
238+ u32 min;
239+};
240+
241+#define XA_LIMIT(_min, _max) (struct xa_limit) { .min = _min, .max = _max }
242+
243+#define xa_limit_32b XA_LIMIT(0, UINT_MAX)
244+#define xa_limit_31b XA_LIMIT(0, INT_MAX)
245+
203246 typedef unsigned __bitwise xa_mark_t;
204247 #define XA_MARK_0 ((__force xa_mark_t)0U)
205248 #define XA_MARK_1 ((__force xa_mark_t)1U)
@@ -220,10 +263,14 @@ enum xa_lock_type { · 14 unmodified lines
220263 #define XA_FLAGS_LOCK_IRQ ((__force gfp_t)XA_LOCK_IRQ)
221264 #define XA_FLAGS_LOCK_BH ((__force gfp_t)XA_LOCK_BH)
222265 #define XA_FLAGS_TRACK_FREE ((__force gfp_t)4U)
266+#define XA_FLAGS_ZERO_BUSY ((__force gfp_t)8U)
267+#define XA_FLAGS_ALLOC_WRAPPED ((__force gfp_t)16U)
223268 #define XA_FLAGS_MARK(mark) ((__force gfp_t)((1U << __GFP_BITS_SHIFT) << \
224269 (__force unsigned)(mark)))
225270
271+/* ALLOC is for a normal 0-based alloc. ALLOC1 is for an 1-based alloc */
226272 #define XA_FLAGS_ALLOC (XA_FLAGS_TRACK_FREE | XA_FLAGS_MARK(XA_FREE_MARK))
273+#define XA_FLAGS_ALLOC1 (XA_FLAGS_TRACK_FREE | XA_FLAGS_ZERO_BUSY)
227274
228275 /**
229276 * struct xarray - The anchor of the XArray.
@@ -279,7 +326,7 @@ struct xarray { · 49 unmodified lines
279326 #define DEFINE_XARRAY(name) DEFINE_XARRAY_FLAGS(name, 0)
280327
281328 /**
282− * DEFINE_XARRAY_ALLOC() - Define an XArray which can allocate IDs.
329+ * DEFINE_XARRAY_ALLOC() - Define an XArray which allocates IDs starting at 0.
283330 * @name: A string that names your XArray.
284331 *
285332 * This is intended for file scope definitions of allocating XArrays.
@@ -287,6 +334,15 @@ struct xarray { · 1 unmodified line
287334 */
288335 #define DEFINE_XARRAY_ALLOC(name) DEFINE_XARRAY_FLAGS(name, XA_FLAGS_ALLOC)
289336
337+/**
338+ * DEFINE_XARRAY_ALLOC1() - Define an XArray which allocates IDs starting at 1.
339+ * @name: A string that names your XArray.
340+ *
341+ * This is intended for file scope definitions of allocating XArrays.
342+ * See also DEFINE_XARRAY().
343+ */
344+#define DEFINE_XARRAY_ALLOC1(name) DEFINE_XARRAY_FLAGS(name, XA_FLAGS_ALLOC1)
345+
290346 void *xa_load(struct xarray *, unsigned long index);
291347 void *xa_store(struct xarray *, unsigned long index, void *entry, gfp_t);
292348 void *xa_erase(struct xarray *, unsigned long index);
@@ -463,9 +519,12 @@ void *__xa_erase(struct xarray *, unsigned long index); · 170 unmodified lines
463519 void *__xa_store(struct xarray *, unsigned long index, void *entry, gfp_t);
464520 void *__xa_cmpxchg(struct xarray *, unsigned long index, void *old,
465521 void *entry, gfp_t);
466−int __xa_insert(struct xarray *, unsigned long index, void *entry, gfp_t);
467−int __xa_alloc(struct xarray *, u32 *id, u32 max, void *entry, gfp_t);
468−int __xa_reserve(struct xarray *, unsigned long index, gfp_t);
522+int __must_check __xa_insert(struct xarray *, unsigned long index,
523+ void *entry, gfp_t);
524+int __must_check __xa_alloc(struct xarray *, u32 *id, void *entry,
525+ struct xa_limit, gfp_t);
526+int __must_check __xa_alloc_cyclic(struct xarray *, u32 *id, void *entry,
527+ struct xa_limit, u32 *next, gfp_t);
469528 void __xa_set_mark(struct xarray *, unsigned long index, xa_mark_t);
470529 void __xa_clear_mark(struct xarray *, unsigned long index, xa_mark_t);
471530
@@ -526,9 +585,9 @@ static inline void *xa_store_irq(struct xarray *xa, unsigned long index, · 54 unmodified lines
526585 * @xa: XArray.
527586 * @index: Index of entry.
528587 *
529− * This function is the equivalent of calling xa_store() with %NULL as
530− * the third argument. The XArray does not need to allocate memory, so
531− * the user does not need to provide GFP flags.
588+ * After this function returns, loading from @index will return %NULL.
589+ * If the index is part of a multi-index entry, all indices will be erased
590+ * and none of the entries will be part of a multi-index entry.
532591 *
533592 * Context: Any context. Takes and releases the xa_lock while
534593 * disabling softirqs.
@@ -550,9 +609,9 @@ static inline void *xa_erase_bh(struct xarray *xa, unsigned long index) · 15 unmodified lines
550609 * @xa: XArray.
551610 * @index: Index of entry.
552611 *
553− * This function is the equivalent of calling xa_store() with %NULL as
554− * the third argument. The XArray does not need to allocate memory, so
555− * the user does not need to provide GFP flags.
612+ * After this function returns, loading from @index will return %NULL.
613+ * If the index is part of a multi-index entry, all indices will be erased
614+ * and none of the entries will be part of a multi-index entry.
556615 *
557616 * Context: Process context. Takes and releases the xa_lock while
558617 * disabling interrupts.
@@ -664,11 +723,11 @@ static inline void *xa_cmpxchg_irq(struct xarray *xa, unsigned long index, · 105 unmodified lines
664723 *
665724 * Context: Any context. Takes and releases the xa_lock. May sleep if
666725 * the @gfp flags permit.
667− * Return: 0 if the store succeeded. -EEXIST if another entry was present.
726+ * Return: 0 if the store succeeded. -EBUSY if another entry was present.
668727 * -ENOMEM if memory could not be allocated.
669728 */
670−static inline int xa_insert(struct xarray *xa, unsigned long index,
671− void *entry, gfp_t gfp)
729+static inline int __must_check xa_insert(struct xarray *xa,
730+ unsigned long index, void *entry, gfp_t gfp)
672731 {
673732 int err;
674733
@@ -693,11 +752,11 @@ static inline int xa_insert(struct xarray *xa, unsigned long index, · 18 unmodified lines
693752 *
694753 * Context: Any context. Takes and releases the xa_lock while
695754 * disabling softirqs. May sleep if the @gfp flags permit.
696− * Return: 0 if the store succeeded. -EEXIST if another entry was present.
755+ * Return: 0 if the store succeeded. -EBUSY if another entry was present.
697756 * -ENOMEM if memory could not be allocated.
698757 */
699−static inline int xa_insert_bh(struct xarray *xa, unsigned long index,
700− void *entry, gfp_t gfp)
758+static inline int __must_check xa_insert_bh(struct xarray *xa,
759+ unsigned long index, void *entry, gfp_t gfp)
701760 {
702761 int err;
703762
@@ -722,11 +781,11 @@ static inline int xa_insert_bh(struct xarray *xa, unsigned long index, · 18 unmodified lines
722781 *
723782 * Context: Process context. Takes and releases the xa_lock while
724783 * disabling interrupts. May sleep if the @gfp flags permit.
725− * Return: 0 if the store succeeded. -EEXIST if another entry was present.
784+ * Return: 0 if the store succeeded. -EBUSY if another entry was present.
726785 * -ENOMEM if memory could not be allocated.
727786 */
728−static inline int xa_insert_irq(struct xarray *xa, unsigned long index,
729− void *entry, gfp_t gfp)
787+static inline int __must_check xa_insert_irq(struct xarray *xa,
788+ unsigned long index, void *entry, gfp_t gfp)
730789 {
731790 int err;
732791
@@ -741,26 +800,26 @@ static inline int xa_insert_irq(struct xarray *xa, unsigned long index, · 8 unmodified lines
741800 * xa_alloc() - Find somewhere to store this entry in the XArray.
742801 * @xa: XArray.
743802 * @id: Pointer to ID.
744− * @max: Maximum ID to allocate (inclusive).
745803 * @entry: New entry.
804+ * @limit: Range of ID to allocate.
746805 * @gfp: Memory allocation flags.
747806 *
748− * Allocates an unused ID in the range specified by @id and @max.
749− * Updates the @id pointer with the index, then stores the entry at that
750− * index. A concurrent lookup will not see an uninitialised @id.
807+ * Finds an empty entry in @xa between @limit.min and @limit.max,
808+ * stores the index into the @id pointer, then stores the entry at
809+ * that index. A concurrent lookup will not see an uninitialised @id.
751810 *
752− * Context: Process context. Takes and releases the xa_lock. May sleep if
811+ * Context: Any context. Takes and releases the xa_lock. May sleep if
753812 * the @gfp flags permit.
754− * Return: 0 on success, -ENOMEM if memory allocation fails or -ENOSPC if
755− * there is no more space in the XArray.
813+ * Return: 0 on success, -ENOMEM if memory could not be allocated or
814+ * -EBUSY if there are no free entries in @limit.
756815 */
757−static inline int xa_alloc(struct xarray *xa, u32 *id, u32 max, void *entry,
758− gfp_t gfp)
816+static inline __must_check int xa_alloc(struct xarray *xa, u32 *id,
817+ void *entry, struct xa_limit limit, gfp_t gfp)
759818 {
760819 int err;
761820
762821 xa_lock(xa);
763− err = __xa_alloc(xa, id, max, entry, gfp);
822+ err = __xa_alloc(xa, id, entry, limit, gfp);
764823 xa_unlock(xa);
765824
766825 return err;
@@ -770,26 +829,26 @@ static inline int xa_alloc(struct xarray *xa, u32 *id, u32 max, void *entry, · 3 unmodified lines
770829 * xa_alloc_bh() - Find somewhere to store this entry in the XArray.
771830 * @xa: XArray.
772831 * @id: Pointer to ID.
773− * @max: Maximum ID to allocate (inclusive).
774832 * @entry: New entry.
833+ * @limit: Range of ID to allocate.
775834 * @gfp: Memory allocation flags.
776835 *
777− * Allocates an unused ID in the range specified by @id and @max.
778− * Updates the @id pointer with the index, then stores the entry at that
779− * index. A concurrent lookup will not see an uninitialised @id.
836+ * Finds an empty entry in @xa between @limit.min and @limit.max,
837+ * stores the index into the @id pointer, then stores the entry at
838+ * that index. A concurrent lookup will not see an uninitialised @id.
780839 *
781840 * Context: Any context. Takes and releases the xa_lock while
782841 * disabling softirqs. May sleep if the @gfp flags permit.
783− * Return: 0 on success, -ENOMEM if memory allocation fails or -ENOSPC if
784− * there is no more space in the XArray.
842+ * Return: 0 on success, -ENOMEM if memory could not be allocated or
843+ * -EBUSY if there are no free entries in @limit.
785844 */
786−static inline int xa_alloc_bh(struct xarray *xa, u32 *id, u32 max, void *entry,
787− gfp_t gfp)
845+static inline int __must_check xa_alloc_bh(struct xarray *xa, u32 *id,
846+ void *entry, struct xa_limit limit, gfp_t gfp)
788847 {
789848 int err;
790849
791850 xa_lock_bh(xa);
792− err = __xa_alloc(xa, id, max, entry, gfp);
851+ err = __xa_alloc(xa, id, entry, limit, gfp);
793852 xa_unlock_bh(xa);
794853
795854 return err;
@@ -799,26 +858,125 @@ static inline int xa_alloc_bh(struct xarray *xa, u32 *id, u32 max, void *entry, · 3 unmodified lines
799858 * xa_alloc_irq() - Find somewhere to store this entry in the XArray.
800859 * @xa: XArray.
801860 * @id: Pointer to ID.
802− * @max: Maximum ID to allocate (inclusive).
803861 * @entry: New entry.
862+ * @limit: Range of ID to allocate.
804863 * @gfp: Memory allocation flags.
805864 *
806− * Allocates an unused ID in the range specified by @id and @max.
807− * Updates the @id pointer with the index, then stores the entry at that
808− * index. A concurrent lookup will not see an uninitialised @id.
865+ * Finds an empty entry in @xa between @limit.min and @limit.max,
866+ * stores the index into the @id pointer, then stores the entry at
867+ * that index. A concurrent lookup will not see an uninitialised @id.
809868 *
810869 * Context: Process context. Takes and releases the xa_lock while
811870 * disabling interrupts. May sleep if the @gfp flags permit.
812− * Return: 0 on success, -ENOMEM if memory allocation fails or -ENOSPC if
813− * there is no more space in the XArray.
871+ * Return: 0 on success, -ENOMEM if memory could not be allocated or
872+ * -EBUSY if there are no free entries in @limit.
814873 */
815−static inline int xa_alloc_irq(struct xarray *xa, u32 *id, u32 max, void *entry,
816− gfp_t gfp)
874+static inline int __must_check xa_alloc_irq(struct xarray *xa, u32 *id,
875+ void *entry, struct xa_limit limit, gfp_t gfp)
817876 {
818877 int err;
819878
820879 xa_lock_irq(xa);
821− err = __xa_alloc(xa, id, max, entry, gfp);
880+ err = __xa_alloc(xa, id, entry, limit, gfp);
881+ xa_unlock_irq(xa);
882+
883+ return err;
884+}
885+
886+/**
887+ * xa_alloc_cyclic() - Find somewhere to store this entry in the XArray.
888+ * @xa: XArray.
889+ * @id: Pointer to ID.
890+ * @entry: New entry.
891+ * @limit: Range of allocated ID.
892+ * @next: Pointer to next ID to allocate.
893+ * @gfp: Memory allocation flags.
894+ *
895+ * Finds an empty entry in @xa between @limit.min and @limit.max,
896+ * stores the index into the @id pointer, then stores the entry at
897+ * that index. A concurrent lookup will not see an uninitialised @id.
898+ * The search for an empty entry will start at @next and will wrap
899+ * around if necessary.
900+ *
901+ * Context: Any context. Takes and releases the xa_lock. May sleep if
902+ * the @gfp flags permit.
903+ * Return: 0 if the allocation succeeded without wrapping. 1 if the
904+ * allocation succeeded after wrapping, -ENOMEM if memory could not be
905+ * allocated or -EBUSY if there are no free entries in @limit.
906+ */
907+static inline int xa_alloc_cyclic(struct xarray *xa, u32 *id, void *entry,
908+ struct xa_limit limit, u32 *next, gfp_t gfp)
909+{
910+ int err;
911+
912+ xa_lock(xa);
913+ err = __xa_alloc_cyclic(xa, id, entry, limit, next, gfp);
914+ xa_unlock(xa);
915+
916+ return err;
917+}
918+
919+/**
920+ * xa_alloc_cyclic_bh() - Find somewhere to store this entry in the XArray.
921+ * @xa: XArray.
922+ * @id: Pointer to ID.
923+ * @entry: New entry.
924+ * @limit: Range of allocated ID.
925+ * @next: Pointer to next ID to allocate.
926+ * @gfp: Memory allocation flags.
927+ *
928+ * Finds an empty entry in @xa between @limit.min and @limit.max,
929+ * stores the index into the @id pointer, then stores the entry at
930+ * that index. A concurrent lookup will not see an uninitialised @id.
931+ * The search for an empty entry will start at @next and will wrap
932+ * around if necessary.
933+ *
934+ * Context: Any context. Takes and releases the xa_lock while
935+ * disabling softirqs. May sleep if the @gfp flags permit.
936+ * Return: 0 if the allocation succeeded without wrapping. 1 if the
937+ * allocation succeeded after wrapping, -ENOMEM if memory could not be
938+ * allocated or -EBUSY if there are no free entries in @limit.
939+ */
940+static inline int xa_alloc_cyclic_bh(struct xarray *xa, u32 *id, void *entry,
941+ struct xa_limit limit, u32 *next, gfp_t gfp)
942+{
943+ int err;
944+
945+ xa_lock_bh(xa);
946+ err = __xa_alloc_cyclic(xa, id, entry, limit, next, gfp);
947+ xa_unlock_bh(xa);
948+
949+ return err;
950+}
951+
952+/**
953+ * xa_alloc_cyclic_irq() - Find somewhere to store this entry in the XArray.
954+ * @xa: XArray.
955+ * @id: Pointer to ID.
956+ * @entry: New entry.
957+ * @limit: Range of allocated ID.
958+ * @next: Pointer to next ID to allocate.
959+ * @gfp: Memory allocation flags.
960+ *
961+ * Finds an empty entry in @xa between @limit.min and @limit.max,
962+ * stores the index into the @id pointer, then stores the entry at
963+ * that index. A concurrent lookup will not see an uninitialised @id.
964+ * The search for an empty entry will start at @next and will wrap
965+ * around if necessary.
966+ *
967+ * Context: Process context. Takes and releases the xa_lock while
968+ * disabling interrupts. May sleep if the @gfp flags permit.
969+ * Return: 0 if the allocation succeeded without wrapping. 1 if the
970+ * allocation succeeded after wrapping, -ENOMEM if memory could not be
971+ * allocated or -EBUSY if there are no free entries in @limit.
972+ */
973+static inline int xa_alloc_cyclic_irq(struct xarray *xa, u32 *id, void *entry,
974+ struct xa_limit limit, u32 *next, gfp_t gfp)
975+{
976+ int err;
977+
978+ xa_lock_irq(xa);
979+ err = __xa_alloc_cyclic(xa, id, entry, limit, next, gfp);
822980 xa_unlock_irq(xa);
823981
824982 return err;
@@ -842,16 +1000,10 @@ static inline int xa_alloc_irq(struct xarray *xa, u32 *id, u32 max, void *entry, · 17 unmodified lines
8421000 * May sleep if the @gfp flags permit.
8431001 * Return: 0 if the reservation succeeded or -ENOMEM if it failed.
8441002 */
845−static inline
1003+static inline __must_check
8461004 int xa_reserve(struct xarray *xa, unsigned long index, gfp_t gfp)
8471005 {
848− int ret;
849−
850− xa_lock(xa);
851− ret = __xa_reserve(xa, index, gfp);
852− xa_unlock(xa);
853−
854− return ret;
1006+ return xa_err(xa_cmpxchg(xa, index, NULL, XA_ZERO_ENTRY, gfp));
8551007 }
8561008
8571009 /**
@@ -866,16 +1018,10 @@ int xa_reserve(struct xarray *xa, unsigned long index, gfp_t gfp) · 8 unmodified lines
8661018 * disabling softirqs.
8671019 * Return: 0 if the reservation succeeded or -ENOMEM if it failed.
8681020 */
869−static inline
1021+static inline __must_check
8701022 int xa_reserve_bh(struct xarray *xa, unsigned long index, gfp_t gfp)
8711023 {
872− int ret;
873−
874− xa_lock_bh(xa);
875− ret = __xa_reserve(xa, index, gfp);
876− xa_unlock_bh(xa);
877−
878− return ret;
1024+ return xa_err(xa_cmpxchg_bh(xa, index, NULL, XA_ZERO_ENTRY, gfp));
8791025 }
8801026
8811027 /**
@@ -890,16 +1036,10 @@ int xa_reserve_bh(struct xarray *xa, unsigned long index, gfp_t gfp) · 8 unmodified lines
8901036 * disabling interrupts.
8911037 * Return: 0 if the reservation succeeded or -ENOMEM if it failed.
8921038 */
893−static inline
1039+static inline __must_check
8941040 int xa_reserve_irq(struct xarray *xa, unsigned long index, gfp_t gfp)
8951041 {
896− int ret;
897−
898− xa_lock_irq(xa);
899− ret = __xa_reserve(xa, index, gfp);
900− xa_unlock_irq(xa);
901−
902− return ret;
1042+ return xa_err(xa_cmpxchg_irq(xa, index, NULL, XA_ZERO_ENTRY, gfp));
9031043 }
9041044
9051045 /**
@@ -913,7 +1053,7 @@ int xa_reserve_irq(struct xarray *xa, unsigned long index, gfp_t gfp) · 7 unmodified lines
9131053 */
9141054 static inline void xa_release(struct xarray *xa, unsigned long index)
9151055 {
916− xa_cmpxchg(xa, index, NULL, NULL, 0);
1056+ xa_cmpxchg(xa, index, XA_ZERO_ENTRY, NULL, 0);
9171057 }
9181058
9191059 /* Everything below here is the Advanced API. Proceed with caution. */
@@ -1073,18 +1213,6 @@ static inline bool xa_is_sibling(const void *entry) · 153 unmodified lines
10731213 }
10741214
10751215 #define XA_RETRY_ENTRY xa_mk_internal(256)
1076−#define XA_ZERO_ENTRY xa_mk_internal(257)
1077−
1078−/**
1079− * xa_is_zero() - Is the entry a zero entry?
1080− * @entry: Entry retrieved from the XArray
1081− *
1082− * Return: %true if the entry is a zero entry.
1083− */
1084−static inline bool xa_is_zero(const void *entry)
1085−{
1086− return unlikely(entry == XA_ZERO_ENTRY);
1087−}
10881216
10891217 /**
10901218 * xa_is_retry() - Is the entry a retry entry?

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