Lines Matching refs:xa
20 void xa_dump(const struct xarray *xa) { }
23 #define XA_BUG_ON(xa, x) do { \
27 xa_dump(xa); \
40 static void *xa_store_index(struct xarray *xa, unsigned long index, gfp_t gfp)
42 return xa_store(xa, index, xa_mk_index(index), gfp);
45 static void xa_insert_index(struct xarray *xa, unsigned long index)
47 XA_BUG_ON(xa, xa_insert(xa, index, xa_mk_index(index),
51 static void xa_alloc_index(struct xarray *xa, unsigned long index, gfp_t gfp)
55 XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(index), xa_limit_32b,
57 XA_BUG_ON(xa, id != index);
60 static void xa_erase_index(struct xarray *xa, unsigned long index)
62 XA_BUG_ON(xa, xa_erase(xa, index) != xa_mk_index(index));
63 XA_BUG_ON(xa, xa_load(xa, index) != NULL);
71 static void *xa_store_order(struct xarray *xa, unsigned long index,
74 XA_STATE_ORDER(xas, xa, index, order);
86 static noinline void check_xa_err(struct xarray *xa)
88 XA_BUG_ON(xa, xa_err(xa_store_index(xa, 0, GFP_NOWAIT)) != 0);
89 XA_BUG_ON(xa, xa_err(xa_erase(xa, 0)) != 0);
92 XA_BUG_ON(xa, xa_err(xa_store_index(xa, 1, GFP_NOWAIT)) != -ENOMEM);
93 XA_BUG_ON(xa, xa_err(xa_store_index(xa, 1, GFP_NOWAIT)) != -ENOMEM);
95 XA_BUG_ON(xa, xa_err(xa_store_index(xa, 1, GFP_KERNEL)) != 0);
96 XA_BUG_ON(xa, xa_err(xa_store(xa, 1, xa_mk_value(0), GFP_KERNEL)) != 0);
97 XA_BUG_ON(xa, xa_err(xa_erase(xa, 1)) != 0);
99 // XA_BUG_ON(xa, xa_err(xa_store(xa, 0, xa_mk_internal(0), 0)) != -EINVAL);
102 static noinline void check_xas_retry(struct xarray *xa)
104 XA_STATE(xas, xa, 0);
107 xa_store_index(xa, 0, GFP_KERNEL);
108 xa_store_index(xa, 1, GFP_KERNEL);
111 XA_BUG_ON(xa, xas_find(&xas, ULONG_MAX) != xa_mk_value(0));
112 xa_erase_index(xa, 1);
113 XA_BUG_ON(xa, !xa_is_retry(xas_reload(&xas)));
114 XA_BUG_ON(xa, xas_retry(&xas, NULL));
115 XA_BUG_ON(xa, xas_retry(&xas, xa_mk_value(0)));
117 XA_BUG_ON(xa, xas.xa_node != XAS_RESTART);
118 XA_BUG_ON(xa, xas_next_entry(&xas, ULONG_MAX) != xa_mk_value(0));
119 XA_BUG_ON(xa, xas.xa_node != NULL);
122 XA_BUG_ON(xa, xa_store_index(xa, 1, GFP_KERNEL) != NULL);
125 XA_BUG_ON(xa, !xa_is_internal(xas_reload(&xas)));
127 XA_BUG_ON(xa, xas_next_entry(&xas, ULONG_MAX) != xa_mk_value(0));
143 xa_erase_index(xa, 0);
144 xa_erase_index(xa, 1);
147 static noinline void check_xa_load(struct xarray *xa)
153 void *entry = xa_load(xa, j);
155 XA_BUG_ON(xa, xa_to_value(entry) != j);
157 XA_BUG_ON(xa, entry);
159 XA_BUG_ON(xa, xa_store_index(xa, i, GFP_KERNEL) != NULL);
164 void *entry = xa_load(xa, j);
166 XA_BUG_ON(xa, xa_to_value(entry) != j);
168 XA_BUG_ON(xa, entry);
170 xa_erase_index(xa, i);
172 XA_BUG_ON(xa, !xa_empty(xa));
175 static noinline void check_xa_mark_1(struct xarray *xa, unsigned long index)
181 XA_BUG_ON(xa, xa_get_mark(xa, index, XA_MARK_0));
182 xa_set_mark(xa, index, XA_MARK_0);
183 XA_BUG_ON(xa, xa_get_mark(xa, index, XA_MARK_0));
186 XA_BUG_ON(xa, xa_store_index(xa, index, GFP_KERNEL) != NULL);
187 XA_BUG_ON(xa, xa_get_mark(xa, index, XA_MARK_0));
188 xa_set_mark(xa, index, XA_MARK_0);
189 XA_BUG_ON(xa, !xa_get_mark(xa, index, XA_MARK_0));
192 XA_BUG_ON(xa, xa_get_mark(xa, index + 1, XA_MARK_0));
193 XA_BUG_ON(xa, xa_get_mark(xa, index, XA_MARK_1));
196 xa_erase_index(xa, index);
197 XA_BUG_ON(xa, !xa_empty(xa));
198 XA_BUG_ON(xa, xa_get_mark(xa, index, XA_MARK_0));
199 xa_set_mark(xa, index, XA_MARK_0);
200 XA_BUG_ON(xa, xa_get_mark(xa, index, XA_MARK_0));
212 XA_BUG_ON(xa, xa_store_index(xa, index + 1, GFP_KERNEL));
213 xa_set_mark(xa, index + 1, XA_MARK_0);
214 XA_BUG_ON(xa, xa_store_index(xa, index + 2, GFP_KERNEL));
215 xa_set_mark(xa, index + 2, XA_MARK_2);
216 XA_BUG_ON(xa, xa_store_index(xa, next, GFP_KERNEL));
217 xa_store_order(xa, index, order, xa_mk_index(index),
220 XA_STATE(xas, xa, i);
224 XA_BUG_ON(xa, !xa_get_mark(xa, i, XA_MARK_0));
225 XA_BUG_ON(xa, xa_get_mark(xa, i, XA_MARK_1));
226 XA_BUG_ON(xa, !xa_get_mark(xa, i, XA_MARK_2));
233 XA_BUG_ON(xa, seen != 2);
242 XA_BUG_ON(xa, seen != 1);
244 XA_BUG_ON(xa, xa_get_mark(xa, next, XA_MARK_0));
245 XA_BUG_ON(xa, xa_get_mark(xa, next, XA_MARK_1));
246 XA_BUG_ON(xa, xa_get_mark(xa, next, XA_MARK_2));
247 xa_erase_index(xa, index);
248 xa_erase_index(xa, next);
249 XA_BUG_ON(xa, !xa_empty(xa));
251 XA_BUG_ON(xa, !xa_empty(xa));
254 static noinline void check_xa_mark_2(struct xarray *xa)
256 XA_STATE(xas, xa, 0);
261 xa_store_index(xa, 0, GFP_KERNEL);
262 xa_set_mark(xa, 0, XA_MARK_0);
267 XA_BUG_ON(xa, !xa_get_mark(xa, 0, XA_MARK_0) == 0);
270 xa_store_index(xa, index, GFP_KERNEL);
271 xa_set_mark(xa, index, XA_MARK_0);
279 XA_BUG_ON(xa, count != 1000);
284 XA_BUG_ON(xa, !xa_get_mark(xa, xas.xa_index, XA_MARK_0));
285 XA_BUG_ON(xa, !xas_get_mark(&xas, XA_MARK_0));
289 xa_destroy(xa);
292 static noinline void check_xa_mark_3(struct xarray *xa)
295 XA_STATE(xas, xa, 0x41);
299 xa_store_order(xa, 0x40, 2, xa_mk_index(0x40), GFP_KERNEL);
300 xa_set_mark(xa, 0x41, XA_MARK_0);
305 XA_BUG_ON(xa, entry != xa_mk_index(0x40));
307 XA_BUG_ON(xa, count != 1);
309 xa_destroy(xa);
313 static noinline void check_xa_mark(struct xarray *xa)
318 check_xa_mark_1(xa, index);
320 check_xa_mark_2(xa);
321 check_xa_mark_3(xa);
324 static noinline void check_xa_shrink(struct xarray *xa)
326 XA_STATE(xas, xa, 1);
331 XA_BUG_ON(xa, !xa_empty(xa));
332 XA_BUG_ON(xa, xa_store_index(xa, 0, GFP_KERNEL) != NULL);
333 XA_BUG_ON(xa, xa_store_index(xa, 1, GFP_KERNEL) != NULL);
340 XA_BUG_ON(xa, xas_load(&xas) != xa_mk_value(1));
342 XA_BUG_ON(xa, xa_entry_locked(xa, node, 0) != xa_mk_value(0));
343 XA_BUG_ON(xa, xas_store(&xas, NULL) != xa_mk_value(1));
344 XA_BUG_ON(xa, xa_load(xa, 1) != NULL);
345 XA_BUG_ON(xa, xas.xa_node != XAS_BOUNDS);
346 XA_BUG_ON(xa, xa_entry_locked(xa, node, 0) != XA_RETRY_ENTRY);
347 XA_BUG_ON(xa, xas_load(&xas) != NULL);
349 XA_BUG_ON(xa, xa_load(xa, 0) != xa_mk_value(0));
350 xa_erase_index(xa, 0);
351 XA_BUG_ON(xa, !xa_empty(xa));
355 xa_store_order(xa, 0, order, xa_mk_value(0), GFP_KERNEL);
356 XA_BUG_ON(xa, xa_load(xa, max) != xa_mk_value(0));
357 XA_BUG_ON(xa, xa_load(xa, max + 1) != NULL);
359 node = xa_head(xa);
361 XA_BUG_ON(xa, xa_store_index(xa, ULONG_MAX, GFP_KERNEL) !=
364 XA_BUG_ON(xa, xa_head(xa) == node);
366 XA_BUG_ON(xa, xa_load(xa, max + 1) != NULL);
367 xa_erase_index(xa, ULONG_MAX);
368 XA_BUG_ON(xa, xa->xa_head != node);
369 xa_erase_index(xa, 0);
373 static noinline void check_insert(struct xarray *xa)
378 xa_insert_index(xa, i);
379 XA_BUG_ON(xa, xa_load(xa, i - 1) != NULL);
380 XA_BUG_ON(xa, xa_load(xa, i + 1) != NULL);
381 xa_erase_index(xa, i);
385 xa_insert_index(xa, 1UL << i);
386 XA_BUG_ON(xa, xa_load(xa, (1UL << i) - 1) != NULL);
387 XA_BUG_ON(xa, xa_load(xa, (1UL << i) + 1) != NULL);
388 xa_erase_index(xa, 1UL << i);
390 xa_insert_index(xa, (1UL << i) - 1);
391 XA_BUG_ON(xa, xa_load(xa, (1UL << i) - 2) != NULL);
392 XA_BUG_ON(xa, xa_load(xa, 1UL << i) != NULL);
393 xa_erase_index(xa, (1UL << i) - 1);
396 xa_insert_index(xa, ~0UL);
397 XA_BUG_ON(xa, xa_load(xa, 0UL) != NULL);
398 XA_BUG_ON(xa, xa_load(xa, ~1UL) != NULL);
399 xa_erase_index(xa, ~0UL);
401 XA_BUG_ON(xa, !xa_empty(xa));
404 static noinline void check_cmpxchg(struct xarray *xa)
410 XA_BUG_ON(xa, !xa_empty(xa));
411 XA_BUG_ON(xa, xa_store_index(xa, 12345678, GFP_KERNEL) != NULL);
412 XA_BUG_ON(xa, xa_insert(xa, 12345678, xa, GFP_KERNEL) != -EBUSY);
413 XA_BUG_ON(xa, xa_cmpxchg(xa, 12345678, SIX, FIVE, GFP_KERNEL) != LOTS);
414 XA_BUG_ON(xa, xa_cmpxchg(xa, 12345678, LOTS, FIVE, GFP_KERNEL) != LOTS);
415 XA_BUG_ON(xa, xa_cmpxchg(xa, 12345678, FIVE, LOTS, GFP_KERNEL) != FIVE);
416 XA_BUG_ON(xa, xa_cmpxchg(xa, 5, FIVE, NULL, GFP_KERNEL) != NULL);
417 XA_BUG_ON(xa, xa_cmpxchg(xa, 5, NULL, FIVE, GFP_KERNEL) != NULL);
418 XA_BUG_ON(xa, xa_insert(xa, 5, FIVE, GFP_KERNEL) != -EBUSY);
419 XA_BUG_ON(xa, xa_cmpxchg(xa, 5, FIVE, NULL, GFP_KERNEL) != FIVE);
420 XA_BUG_ON(xa, xa_insert(xa, 5, FIVE, GFP_KERNEL) == -EBUSY);
421 xa_erase_index(xa, 12345678);
422 xa_erase_index(xa, 5);
423 XA_BUG_ON(xa, !xa_empty(xa));
426 static noinline void check_reserve(struct xarray *xa)
433 XA_BUG_ON(xa, !xa_empty(xa));
434 XA_BUG_ON(xa, xa_reserve(xa, 12345678, GFP_KERNEL) != 0);
435 XA_BUG_ON(xa, xa_empty(xa));
436 XA_BUG_ON(xa, xa_load(xa, 12345678));
437 xa_release(xa, 12345678);
438 XA_BUG_ON(xa, !xa_empty(xa));
441 XA_BUG_ON(xa, xa_reserve(xa, 12345678, GFP_KERNEL) != 0);
442 XA_BUG_ON(xa, xa_store_index(xa, 12345678, GFP_NOWAIT) != NULL);
443 xa_release(xa, 12345678);
444 xa_erase_index(xa, 12345678);
445 XA_BUG_ON(xa, !xa_empty(xa));
448 XA_BUG_ON(xa, xa_reserve(xa, 12345678, GFP_KERNEL) != 0);
449 XA_BUG_ON(xa, xa_cmpxchg(xa, 12345678, XA_ZERO_ENTRY,
451 xa_release(xa, 12345678);
452 xa_erase_index(xa, 12345678);
453 XA_BUG_ON(xa, !xa_empty(xa));
456 XA_BUG_ON(xa, xa_reserve(xa, 12345678, GFP_KERNEL) != 0);
457 XA_BUG_ON(xa, xa_insert(xa, 12345678, xa_mk_value(12345678), 0) !=
459 XA_BUG_ON(xa, xa_empty(xa));
460 XA_BUG_ON(xa, xa_erase(xa, 12345678) != NULL);
461 XA_BUG_ON(xa, !xa_empty(xa));
464 xa_store_index(xa, 5, GFP_KERNEL);
465 XA_BUG_ON(xa, xa_reserve(xa, 6, GFP_KERNEL) != 0);
466 xa_store_index(xa, 7, GFP_KERNEL);
469 xa_for_each(xa, index, entry) {
470 XA_BUG_ON(xa, index != 5 && index != 7);
473 XA_BUG_ON(xa, count != 2);
476 if (xa->xa_flags & XA_FLAGS_ALLOC) {
479 XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_value(8),
481 XA_BUG_ON(xa, id != 8);
483 xa_release(xa, 6);
484 XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_value(6),
486 XA_BUG_ON(xa, id != 6);
489 xa_destroy(xa);
492 static noinline void check_xas_erase(struct xarray *xa)
494 XA_STATE(xas, xa, 0);
521 XA_BUG_ON(xa, entry != xa_mk_index(j));
526 XA_BUG_ON(xa, !xa_empty(xa));
531 static noinline void check_multi_store_1(struct xarray *xa, unsigned long index,
534 XA_STATE(xas, xa, index);
538 xa_store_order(xa, index, order, xa_mk_index(index), GFP_KERNEL);
539 XA_BUG_ON(xa, xa_load(xa, min) != xa_mk_index(index));
540 XA_BUG_ON(xa, xa_load(xa, max - 1) != xa_mk_index(index));
541 XA_BUG_ON(xa, xa_load(xa, max) != NULL);
542 XA_BUG_ON(xa, xa_load(xa, min - 1) != NULL);
545 XA_BUG_ON(xa, xas_store(&xas, xa_mk_index(min)) != xa_mk_index(index));
547 XA_BUG_ON(xa, xa_load(xa, min) != xa_mk_index(min));
548 XA_BUG_ON(xa, xa_load(xa, max - 1) != xa_mk_index(min));
549 XA_BUG_ON(xa, xa_load(xa, max) != NULL);
550 XA_BUG_ON(xa, xa_load(xa, min - 1) != NULL);
552 xa_erase_index(xa, min);
553 XA_BUG_ON(xa, !xa_empty(xa));
556 static noinline void check_multi_store_2(struct xarray *xa, unsigned long index,
559 XA_STATE(xas, xa, index);
560 xa_store_order(xa, index, order, xa_mk_value(0), GFP_KERNEL);
563 XA_BUG_ON(xa, xas_store(&xas, xa_mk_value(1)) != xa_mk_value(0));
564 XA_BUG_ON(xa, xas.xa_index != index);
565 XA_BUG_ON(xa, xas_store(&xas, NULL) != xa_mk_value(1));
567 XA_BUG_ON(xa, !xa_empty(xa));
570 static noinline void check_multi_store_3(struct xarray *xa, unsigned long index,
573 XA_STATE(xas, xa, 0);
577 xa_store_order(xa, index, order, xa_mk_index(index), GFP_KERNEL);
581 XA_BUG_ON(xa, entry != xa_mk_index(index));
584 XA_BUG_ON(xa, n != 1);
587 XA_BUG_ON(xa, entry != xa_mk_index(index));
590 XA_BUG_ON(xa, n != 2);
593 xa_destroy(xa);
597 static noinline void check_multi_store(struct xarray *xa)
604 xa_store_order(xa, 0, 1, xa_mk_value(0), GFP_KERNEL);
605 XA_BUG_ON(xa, xa_load(xa, 0) != xa_mk_value(0));
606 XA_BUG_ON(xa, xa_load(xa, 1) != xa_mk_value(0));
607 XA_BUG_ON(xa, xa_load(xa, 2) != NULL);
609 XA_BUG_ON(xa, xa_to_node(xa_head(xa))->count != 2);
610 XA_BUG_ON(xa, xa_to_node(xa_head(xa))->nr_values != 2);
614 xa_store(xa, 3, xa, GFP_KERNEL);
615 XA_BUG_ON(xa, xa_load(xa, 0) != xa_mk_value(0));
616 XA_BUG_ON(xa, xa_load(xa, 1) != xa_mk_value(0));
617 XA_BUG_ON(xa, xa_load(xa, 2) != NULL);
619 XA_BUG_ON(xa, xa_to_node(xa_head(xa))->count != 3);
620 XA_BUG_ON(xa, xa_to_node(xa_head(xa))->nr_values != 2);
624 xa_store_order(xa, 0, 2, xa_mk_value(1), GFP_KERNEL);
625 XA_BUG_ON(xa, xa_load(xa, 0) != xa_mk_value(1));
626 XA_BUG_ON(xa, xa_load(xa, 1) != xa_mk_value(1));
627 XA_BUG_ON(xa, xa_load(xa, 2) != xa_mk_value(1));
628 XA_BUG_ON(xa, xa_load(xa, 3) != xa_mk_value(1));
629 XA_BUG_ON(xa, xa_load(xa, 4) != NULL);
631 XA_BUG_ON(xa, xa_to_node(xa_head(xa))->count != 4);
632 XA_BUG_ON(xa, xa_to_node(xa_head(xa))->nr_values != 4);
636 xa_store_order(xa, 0, BITS_PER_LONG - 1, NULL, GFP_KERNEL);
637 XA_BUG_ON(xa, !xa_empty(xa));
640 xa_store_index(xa, 1, GFP_KERNEL);
641 xa_store_index(xa, 2, GFP_KERNEL);
642 xa_store_order(xa, 0, 2, NULL, GFP_KERNEL);
643 XA_BUG_ON(xa, !xa_empty(xa));
647 xa_store_order(xa, 0, i, xa_mk_index(i), GFP_KERNEL);
648 xa_store_order(xa, 0, j, xa_mk_index(j), GFP_KERNEL);
651 void *entry = xa_load(xa, (1UL << k) - 1);
653 XA_BUG_ON(xa, entry != NULL);
655 XA_BUG_ON(xa, entry != xa_mk_index(j));
658 xa_erase(xa, 0);
659 XA_BUG_ON(xa, !xa_empty(xa));
664 check_multi_store_1(xa, 200, i);
665 check_multi_store_1(xa, 0, i);
666 check_multi_store_1(xa, (1UL << i) + 1, i);
668 check_multi_store_2(xa, 4095, 9);
671 check_multi_store_3(xa, 0, i);
672 check_multi_store_3(xa, 1UL << i, i);
677 static noinline void check_xa_alloc_1(struct xarray *xa, unsigned int base)
682 XA_BUG_ON(xa, !xa_empty(xa));
684 xa_alloc_index(xa, base, GFP_KERNEL);
687 xa_erase_index(xa, base);
688 XA_BUG_ON(xa, !xa_empty(xa));
691 xa_alloc_index(xa, base, GFP_KERNEL);
695 xa_alloc_index(xa, i, GFP_KERNEL);
697 xa_erase_index(xa, i);
698 xa_alloc_index(xa, base, GFP_KERNEL);
701 xa_destroy(xa);
704 xa_alloc_index(xa, base, GFP_KERNEL);
707 xa_alloc_index(xa, base + 1, GFP_KERNEL);
708 xa_erase_index(xa, base + 1);
711 xa_store_index(xa, base + 1, GFP_KERNEL);
712 xa_alloc_index(xa, base + 2, GFP_KERNEL);
715 xa_erase_index(xa, base);
716 xa_alloc_index(xa, base, GFP_KERNEL);
718 xa_erase_index(xa, base + 1);
719 xa_erase_index(xa, base + 2);
722 xa_alloc_index(xa, base + i, GFP_KERNEL);
725 xa_destroy(xa);
728 XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(UINT_MAX - 1),
731 XA_BUG_ON(xa, id != 0xfffffffeU);
732 XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(UINT_MAX),
735 XA_BUG_ON(xa, id != 0xffffffffU);
737 XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(0),
740 XA_BUG_ON(xa, id != 3);
741 xa_destroy(xa);
743 XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(10), XA_LIMIT(10, 5),
745 XA_BUG_ON(xa, xa_store_index(xa, 3, GFP_KERNEL) != 0);
746 XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(10), XA_LIMIT(10, 5),
748 xa_erase_index(xa, 3);
749 XA_BUG_ON(xa, !xa_empty(xa));
752 static noinline void check_xa_alloc_2(struct xarray *xa, unsigned int base)
759 XA_BUG_ON(xa, !xa_empty(xa));
760 XA_BUG_ON(xa, xa_alloc(xa, &id, NULL, xa_limit_32b, GFP_KERNEL) != 0);
761 XA_BUG_ON(xa, id != base);
762 XA_BUG_ON(xa, xa_empty(xa));
763 XA_BUG_ON(xa, xa_erase(xa, id) != NULL);
764 XA_BUG_ON(xa, !xa_empty(xa));
767 XA_BUG_ON(xa, !xa_empty(xa));
768 XA_BUG_ON(xa, xa_alloc(xa, &id, NULL, xa_limit_32b, GFP_KERNEL) != 0);
769 XA_BUG_ON(xa, id != base);
770 XA_BUG_ON(xa, xa_empty(xa));
771 xa_destroy(xa);
772 XA_BUG_ON(xa, !xa_empty(xa));
775 XA_BUG_ON(xa, xa_alloc(xa, &id, NULL, xa_limit_32b,
777 XA_BUG_ON(xa, id != i);
780 XA_BUG_ON(xa, xa_store(xa, 3, xa_mk_index(3), GFP_KERNEL) != NULL);
781 XA_BUG_ON(xa, xa_store(xa, 4, xa_mk_index(4), GFP_KERNEL) != NULL);
782 XA_BUG_ON(xa, xa_store(xa, 4, NULL, GFP_KERNEL) != xa_mk_index(4));
783 XA_BUG_ON(xa, xa_erase(xa, 5) != NULL);
784 XA_BUG_ON(xa, xa_alloc(xa, &id, NULL, xa_limit_32b, GFP_KERNEL) != 0);
785 XA_BUG_ON(xa, id != 5);
787 xa_for_each(xa, index, entry) {
788 xa_erase_index(xa, index);
792 XA_BUG_ON(xa, xa_erase(xa, i) != NULL);
793 XA_BUG_ON(xa, xa_empty(xa));
795 XA_BUG_ON(xa, xa_erase(xa, 8) != NULL);
796 XA_BUG_ON(xa, xa_empty(xa));
797 XA_BUG_ON(xa, xa_erase(xa, base + 9) != NULL);
798 XA_BUG_ON(xa, !xa_empty(xa));
800 xa_destroy(xa);
803 static noinline void check_xa_alloc_3(struct xarray *xa, unsigned int base)
811 XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(1), limit,
813 XA_BUG_ON(xa, id != 1);
816 XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(0x3ffd), limit,
818 XA_BUG_ON(xa, id != 0x3ffd);
819 xa_erase_index(xa, 0x3ffd);
820 xa_erase_index(xa, 1);
821 XA_BUG_ON(xa, !xa_empty(xa));
828 XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, entry, limit,
830 XA_BUG_ON(xa, xa_mk_index(id) != entry);
835 xa_erase_index(xa, base);
836 xa_erase_index(xa, base + 1);
838 XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(UINT_MAX),
840 XA_BUG_ON(xa, id != UINT_MAX);
841 XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(base),
843 XA_BUG_ON(xa, id != base);
844 XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(base + 1),
846 XA_BUG_ON(xa, id != base + 1);
848 xa_for_each(xa, index, entry)
849 xa_erase_index(xa, index);
851 XA_BUG_ON(xa, !xa_empty(xa));
867 static noinline void __check_store_iter(struct xarray *xa, unsigned long start,
870 XA_STATE_ORDER(xas, xa, start, order);
877 XA_BUG_ON(xa, !xa_is_value(entry));
878 XA_BUG_ON(xa, entry < xa_mk_index(start));
879 XA_BUG_ON(xa, entry > xa_mk_index(start + (1UL << order) - 1));
888 XA_BUG_ON(xa, xas_error(&xas));
889 XA_BUG_ON(xa, count != present);
890 XA_BUG_ON(xa, xa_load(xa, start) != xa_mk_index(start));
891 XA_BUG_ON(xa, xa_load(xa, start + (1UL << order) - 1) !=
893 xa_erase_index(xa, start);
896 static noinline void check_store_iter(struct xarray *xa)
904 __check_store_iter(xa, 0, i, 0);
905 XA_BUG_ON(xa, !xa_empty(xa));
906 __check_store_iter(xa, min, i, 0);
907 XA_BUG_ON(xa, !xa_empty(xa));
909 xa_store_index(xa, min, GFP_KERNEL);
910 __check_store_iter(xa, min, i, 1);
911 XA_BUG_ON(xa, !xa_empty(xa));
912 xa_store_index(xa, max, GFP_KERNEL);
913 __check_store_iter(xa, min, i, 1);
914 XA_BUG_ON(xa, !xa_empty(xa));
917 xa_store_index(xa, j, GFP_KERNEL);
918 __check_store_iter(xa, 0, i, min);
919 XA_BUG_ON(xa, !xa_empty(xa));
921 xa_store_index(xa, min + j, GFP_KERNEL);
922 __check_store_iter(xa, min, i, min);
923 XA_BUG_ON(xa, !xa_empty(xa));
926 xa_store_index(xa, 63, GFP_KERNEL);
927 xa_store_index(xa, 65, GFP_KERNEL);
928 __check_store_iter(xa, 64, 2, 1);
929 xa_erase_index(xa, 63);
931 XA_BUG_ON(xa, !xa_empty(xa));
934 static noinline void check_multi_find_1(struct xarray *xa, unsigned order)
941 xa_store_order(xa, multi, order, xa_mk_value(multi), GFP_KERNEL);
942 XA_BUG_ON(xa, xa_store_index(xa, next, GFP_KERNEL) != NULL);
943 XA_BUG_ON(xa, xa_store_index(xa, next + 1, GFP_KERNEL) != NULL);
946 XA_BUG_ON(xa, xa_find(xa, &index, ULONG_MAX, XA_PRESENT) !=
948 XA_BUG_ON(xa, index != multi);
950 XA_BUG_ON(xa, xa_find(xa, &index, ULONG_MAX, XA_PRESENT) !=
952 XA_BUG_ON(xa, (index < multi) || (index >= next));
953 XA_BUG_ON(xa, xa_find_after(xa, &index, ULONG_MAX, XA_PRESENT) !=
955 XA_BUG_ON(xa, index != next);
956 XA_BUG_ON(xa, xa_find_after(xa, &index, next, XA_PRESENT) != NULL);
957 XA_BUG_ON(xa, index != next);
959 xa_erase_index(xa, multi);
960 xa_erase_index(xa, next);
961 xa_erase_index(xa, next + 1);
962 XA_BUG_ON(xa, !xa_empty(xa));
966 static noinline void check_multi_find_2(struct xarray *xa)
975 XA_STATE(xas, xa, j + index);
976 xa_store_index(xa, index - 1, GFP_KERNEL);
977 xa_store_order(xa, index, i, xa_mk_index(index),
981 xa_erase_index(xa, index);
984 xa_erase_index(xa, index - 1);
985 XA_BUG_ON(xa, !xa_empty(xa));
990 static noinline void check_multi_find_3(struct xarray *xa)
997 XA_BUG_ON(xa, !xa_empty(xa));
998 xa_store_order(xa, 0, order - 4, xa_mk_index(0), GFP_KERNEL);
999 XA_BUG_ON(xa, xa_find_after(xa, &index, ULONG_MAX, XA_PRESENT));
1000 xa_erase_index(xa, 0);
1004 static noinline void check_find_1(struct xarray *xa)
1008 XA_BUG_ON(xa, !xa_empty(xa));
1015 XA_BUG_ON(xa, xa_store_index(xa, i, GFP_KERNEL) != NULL);
1016 xa_set_mark(xa, i, XA_MARK_0);
1018 XA_BUG_ON(xa, xa_store_index(xa, j, GFP_KERNEL) !=
1020 xa_set_mark(xa, j, XA_MARK_0);
1023 void *entry = xa_find(xa, &index, ULONG_MAX,
1026 XA_BUG_ON(xa, index != j);
1028 XA_BUG_ON(xa, index != i);
1030 XA_BUG_ON(xa, entry != NULL);
1033 entry = xa_find(xa, &index, ULONG_MAX,
1036 XA_BUG_ON(xa, index != j);
1038 XA_BUG_ON(xa, index != i);
1040 XA_BUG_ON(xa, entry != NULL);
1042 xa_erase_index(xa, j);
1043 XA_BUG_ON(xa, xa_get_mark(xa, j, XA_MARK_0));
1044 XA_BUG_ON(xa, !xa_get_mark(xa, i, XA_MARK_0));
1046 xa_erase_index(xa, i);
1047 XA_BUG_ON(xa, xa_get_mark(xa, i, XA_MARK_0));
1049 XA_BUG_ON(xa, !xa_empty(xa));
1052 static noinline void check_find_2(struct xarray *xa)
1057 xa_for_each(xa, index, entry) {
1058 XA_BUG_ON(xa, true);
1062 xa_store_index(xa, index, GFP_KERNEL);
1064 xa_for_each(xa, index, entry) {
1065 XA_BUG_ON(xa, xa_mk_index(index) != entry);
1066 XA_BUG_ON(xa, index != j++);
1070 xa_destroy(xa);
1073 static noinline void check_find_3(struct xarray *xa)
1075 XA_STATE(xas, xa, 0);
1087 XA_BUG_ON(xa,
1092 xa_store_index(xa, i, GFP_KERNEL);
1093 xa_set_mark(xa, i, XA_MARK_0);
1095 xa_destroy(xa);
1098 static noinline void check_find_4(struct xarray *xa)
1103 xa_store_index(xa, ULONG_MAX, GFP_KERNEL);
1105 entry = xa_find_after(xa, &index, ULONG_MAX, XA_PRESENT);
1106 XA_BUG_ON(xa, entry != xa_mk_index(ULONG_MAX));
1108 entry = xa_find_after(xa, &index, ULONG_MAX, XA_PRESENT);
1109 XA_BUG_ON(xa, entry);
1111 xa_erase_index(xa, ULONG_MAX);
1114 static noinline void check_find(struct xarray *xa)
1118 check_find_1(xa);
1119 check_find_2(xa);
1120 check_find_3(xa);
1121 check_find_4(xa);
1124 check_multi_find_1(xa, i);
1125 check_multi_find_2(xa);
1126 check_multi_find_3(xa);
1130 static noinline unsigned long xa_find_entry(struct xarray *xa, void *item)
1132 XA_STATE(xas, xa, 0);
1152 static noinline void check_find_entry(struct xarray *xa)
1163 xa_store_order(xa, index, order,
1165 XA_BUG_ON(xa, xa_load(xa, index) !=
1167 XA_BUG_ON(xa, xa_find_entry(xa,
1170 XA_BUG_ON(xa, xa_find_entry(xa, xa) != -1);
1171 xa_destroy(xa);
1176 XA_BUG_ON(xa, xa_find_entry(xa, xa) != -1);
1177 xa_store_index(xa, ULONG_MAX, GFP_KERNEL);
1178 XA_BUG_ON(xa, xa_find_entry(xa, xa) != -1);
1179 XA_BUG_ON(xa, xa_find_entry(xa, xa_mk_index(ULONG_MAX)) != -1);
1180 xa_erase_index(xa, ULONG_MAX);
1181 XA_BUG_ON(xa, !xa_empty(xa));
1184 static noinline void check_pause(struct xarray *xa)
1186 XA_STATE(xas, xa, 0);
1193 XA_BUG_ON(xa, xa_store_order(xa, index, order,
1200 XA_BUG_ON(xa, entry != xa_mk_index(1UL << count));
1204 XA_BUG_ON(xa, count != order_limit);
1210 XA_BUG_ON(xa, entry != xa_mk_index(1UL << count));
1215 XA_BUG_ON(xa, count != order_limit);
1217 xa_destroy(xa);
1220 static noinline void check_move_tiny(struct xarray *xa)
1222 XA_STATE(xas, xa, 0);
1224 XA_BUG_ON(xa, !xa_empty(xa));
1226 XA_BUG_ON(xa, xas_next(&xas) != NULL);
1227 XA_BUG_ON(xa, xas_next(&xas) != NULL);
1229 xa_store_index(xa, 0, GFP_KERNEL);
1232 XA_BUG_ON(xa, xas_next(&xas) != xa_mk_index(0));
1233 XA_BUG_ON(xa, xas_next(&xas) != NULL);
1235 XA_BUG_ON(xa, xas_prev(&xas) != xa_mk_index(0));
1236 XA_BUG_ON(xa, xas_prev(&xas) != NULL);
1238 xa_erase_index(xa, 0);
1239 XA_BUG_ON(xa, !xa_empty(xa));
1242 static noinline void check_move_max(struct xarray *xa)
1244 XA_STATE(xas, xa, 0);
1246 xa_store_index(xa, ULONG_MAX, GFP_KERNEL);
1248 XA_BUG_ON(xa, xas_find(&xas, ULONG_MAX) != xa_mk_index(ULONG_MAX));
1249 XA_BUG_ON(xa, xas_find(&xas, ULONG_MAX) != NULL);
1254 XA_BUG_ON(xa, xas_find(&xas, ULONG_MAX) != xa_mk_index(ULONG_MAX));
1256 XA_BUG_ON(xa, xas_find(&xas, ULONG_MAX) != NULL);
1259 xa_erase_index(xa, ULONG_MAX);
1260 XA_BUG_ON(xa, !xa_empty(xa));
1263 static noinline void check_move_small(struct xarray *xa, unsigned long idx)
1265 XA_STATE(xas, xa, 0);
1268 xa_store_index(xa, 0, GFP_KERNEL);
1269 xa_store_index(xa, idx, GFP_KERNEL);
1275 XA_BUG_ON(xa, xas.xa_node == XAS_RESTART);
1276 XA_BUG_ON(xa, xas.xa_index != i);
1278 XA_BUG_ON(xa, entry != xa_mk_index(i));
1280 XA_BUG_ON(xa, entry != NULL);
1283 XA_BUG_ON(xa, xas.xa_index != i);
1289 XA_BUG_ON(xa, xas.xa_node == XAS_RESTART);
1290 XA_BUG_ON(xa, xas.xa_index != i);
1292 XA_BUG_ON(xa, entry != xa_mk_index(i));
1294 XA_BUG_ON(xa, entry != NULL);
1298 XA_BUG_ON(xa, xas_next(&xas) != NULL);
1299 XA_BUG_ON(xa, xas.xa_index != ULONG_MAX);
1300 XA_BUG_ON(xa, xas_next(&xas) != xa_mk_value(0));
1301 XA_BUG_ON(xa, xas.xa_index != 0);
1302 XA_BUG_ON(xa, xas_prev(&xas) != NULL);
1303 XA_BUG_ON(xa, xas.xa_index != ULONG_MAX);
1306 xa_erase_index(xa, 0);
1307 xa_erase_index(xa, idx);
1308 XA_BUG_ON(xa, !xa_empty(xa));
1311 static noinline void check_move(struct xarray *xa)
1313 XA_STATE(xas, xa, (1 << 16) - 1);
1317 XA_BUG_ON(xa, xa_store_index(xa, i, GFP_KERNEL) != NULL);
1323 XA_BUG_ON(xa, entry != xa_mk_index(i));
1324 XA_BUG_ON(xa, i != xas.xa_index);
1327 XA_BUG_ON(xa, xas_prev(&xas) != NULL);
1328 XA_BUG_ON(xa, xas.xa_index != ULONG_MAX);
1332 XA_BUG_ON(xa, entry != xa_mk_index(i));
1333 XA_BUG_ON(xa, i != xas.xa_index);
1339 xa_erase_index(xa, i);
1348 XA_BUG_ON(xa, entry != xa_mk_index(i));
1350 XA_BUG_ON(xa, entry != NULL);
1351 XA_BUG_ON(xa, i != xas.xa_index);
1354 XA_BUG_ON(xa, xas_prev(&xas) != NULL);
1355 XA_BUG_ON(xa, xas.xa_index != ULONG_MAX);
1360 XA_BUG_ON(xa, entry != xa_mk_index(i));
1362 XA_BUG_ON(xa, entry != NULL);
1363 XA_BUG_ON(xa, i != xas.xa_index);
1368 xa_destroy(xa);
1370 check_move_tiny(xa);
1371 check_move_max(xa);
1374 check_move_small(xa, 1UL << i);
1377 check_move_small(xa, (1UL << i) - 1);
1380 static noinline void xa_store_many_order(struct xarray *xa,
1383 XA_STATE_ORDER(xas, xa, index, order);
1388 XA_BUG_ON(xa, xas_find_conflict(&xas));
1393 XA_BUG_ON(xa, xas_store(&xas, xa_mk_index(index + i)));
1400 XA_BUG_ON(xa, xas_error(&xas));
1403 static noinline void check_create_range_1(struct xarray *xa,
1408 xa_store_many_order(xa, index, order);
1410 xa_erase_index(xa, i);
1411 XA_BUG_ON(xa, !xa_empty(xa));
1414 static noinline void check_create_range_2(struct xarray *xa, unsigned order)
1420 xa_store_many_order(xa, i, order);
1422 xa_erase_index(xa, i);
1423 XA_BUG_ON(xa, !xa_empty(xa));
1434 static noinline void check_create_range_4(struct xarray *xa,
1437 XA_STATE_ORDER(xas, xa, index, order);
1441 xa_store_index(xa, index, GFP_KERNEL);
1450 XA_BUG_ON(xa, old != xa_mk_index(base + i));
1452 XA_BUG_ON(xa, old != NULL);
1459 XA_BUG_ON(xa, xas_error(&xas));
1462 xa_erase_index(xa, i);
1463 XA_BUG_ON(xa, !xa_empty(xa));
1466 static noinline void check_create_range_5(struct xarray *xa,
1469 XA_STATE_ORDER(xas, xa, index, order);
1472 xa_store_order(xa, index, order, xa_mk_index(index), GFP_KERNEL);
1482 xa_destroy(xa);
1485 static noinline void check_create_range(struct xarray *xa)
1491 check_create_range_1(xa, 0, order);
1492 check_create_range_1(xa, 1U << order, order);
1493 check_create_range_1(xa, 2U << order, order);
1494 check_create_range_1(xa, 3U << order, order);
1495 check_create_range_1(xa, 1U << 24, order);
1497 check_create_range_2(xa, order);
1499 check_create_range_4(xa, 0, order);
1500 check_create_range_4(xa, 1U << order, order);
1501 check_create_range_4(xa, 2U << order, order);
1502 check_create_range_4(xa, 3U << order, order);
1503 check_create_range_4(xa, 1U << 24, order);
1505 check_create_range_4(xa, 1, order);
1506 check_create_range_4(xa, (1U << order) + 1, order);
1507 check_create_range_4(xa, (2U << order) + 1, order);
1508 check_create_range_4(xa, (2U << order) - 1, order);
1509 check_create_range_4(xa, (3U << order) + 1, order);
1510 check_create_range_4(xa, (3U << order) - 1, order);
1511 check_create_range_4(xa, (1U << 24) + 1, order);
1513 check_create_range_5(xa, 0, order);
1514 check_create_range_5(xa, (1U << order), order);
1520 static noinline void __check_store_range(struct xarray *xa, unsigned long first,
1524 xa_store_range(xa, first, last, xa_mk_index(first), GFP_KERNEL);
1526 XA_BUG_ON(xa, xa_load(xa, first) != xa_mk_index(first));
1527 XA_BUG_ON(xa, xa_load(xa, last) != xa_mk_index(first));
1528 XA_BUG_ON(xa, xa_load(xa, first - 1) != NULL);
1529 XA_BUG_ON(xa, xa_load(xa, last + 1) != NULL);
1531 xa_store_range(xa, first, last, NULL, GFP_KERNEL);
1534 XA_BUG_ON(xa, !xa_empty(xa));
1537 static noinline void check_store_range(struct xarray *xa)
1543 __check_store_range(xa, i, j);
1544 __check_store_range(xa, 128 + i, 128 + j);
1545 __check_store_range(xa, 4095 + i, 4095 + j);
1546 __check_store_range(xa, 4096 + i, 4096 + j);
1547 __check_store_range(xa, 123456 + i, 123456 + j);
1548 __check_store_range(xa, (1 << 24) + i, (1 << 24) + j);
1554 static void check_split_1(struct xarray *xa, unsigned long index,
1557 XA_STATE_ORDER(xas, xa, index, new_order);
1560 xa_store_order(xa, index, order, xa, GFP_KERNEL);
1562 xas_split_alloc(&xas, xa, order, GFP_KERNEL);
1564 xas_split(&xas, xa, order);
1566 __xa_store(xa, index + i, xa_mk_index(index + i), 0);
1571 XA_BUG_ON(xa, xa_load(xa, index + i) != xa_mk_index(val));
1574 xa_set_mark(xa, index, XA_MARK_0);
1575 XA_BUG_ON(xa, !xa_get_mark(xa, index, XA_MARK_0));
1577 xa_destroy(xa);
1580 static noinline void check_split(struct xarray *xa)
1584 XA_BUG_ON(xa, !xa_empty(xa));
1588 check_split_1(xa, 0, order, new_order);
1589 check_split_1(xa, 1UL << order, order, new_order);
1590 check_split_1(xa, 3UL << order, order, new_order);
1595 static void check_split(struct xarray *xa) { }
1598 static void check_align_1(struct xarray *xa, char *name)
1606 XA_BUG_ON(xa, xa_alloc(xa, &id, name + i, xa_limit_32b,
1608 XA_BUG_ON(xa, id != i);
1610 xa_for_each(xa, index, entry)
1611 XA_BUG_ON(xa, xa_is_err(entry));
1612 xa_destroy(xa);
1619 static void check_align_2(struct xarray *xa, char *name)
1623 XA_BUG_ON(xa, !xa_empty(xa));
1626 XA_BUG_ON(xa, xa_store(xa, 0, name + i, GFP_KERNEL) != NULL);
1627 xa_erase(xa, 0);
1631 XA_BUG_ON(xa, xa_reserve(xa, 0, GFP_KERNEL) != 0);
1632 XA_BUG_ON(xa, xa_store(xa, 0, name + i, 0) != NULL);
1633 xa_erase(xa, 0);
1636 XA_BUG_ON(xa, !xa_empty(xa));
1639 static noinline void check_align(struct xarray *xa)
1643 check_align_1(xa, name);
1644 check_align_1(xa, name + 1);
1645 check_align_1(xa, name + 2);
1646 check_align_1(xa, name + 3);
1647 check_align_2(xa, name);
1663 static noinline void shadow_remove(struct xarray *xa)
1667 xa_lock(xa);
1670 XA_BUG_ON(xa, node->array != xa);
1674 xa_unlock(xa);
1677 static noinline void check_workingset(struct xarray *xa, unsigned long index)
1679 XA_STATE(xas, xa, index);
1690 XA_BUG_ON(xa, list_empty(&shadow_nodes));
1695 XA_BUG_ON(xa, !list_empty(&shadow_nodes));
1699 XA_BUG_ON(xa, list_empty(&shadow_nodes));
1701 shadow_remove(xa);
1702 XA_BUG_ON(xa, !list_empty(&shadow_nodes));
1703 XA_BUG_ON(xa, !xa_empty(xa));
1710 static noinline void check_account(struct xarray *xa)
1716 XA_STATE(xas, xa, 1 << order);
1718 xa_store_order(xa, 0, order, xa, GFP_KERNEL);
1721 XA_BUG_ON(xa, xas.xa_node->count == 0);
1722 XA_BUG_ON(xa, xas.xa_node->count > (1 << order));
1723 XA_BUG_ON(xa, xas.xa_node->nr_values != 0);
1726 xa_store_order(xa, 1 << order, order, xa_mk_index(1UL << order),
1728 XA_BUG_ON(xa, xas.xa_node->count != xas.xa_node->nr_values * 2);
1730 xa_erase(xa, 1 << order);
1731 XA_BUG_ON(xa, xas.xa_node->nr_values != 0);
1733 xa_erase(xa, 0);
1734 XA_BUG_ON(xa, !xa_empty(xa));
1739 static noinline void check_get_order(struct xarray *xa)
1746 XA_BUG_ON(xa, xa_get_order(xa, i) != 0);
1750 xa_store_order(xa, i << order, order,
1753 XA_BUG_ON(xa, xa_get_order(xa, j) != order);
1754 xa_erase(xa, i << order);
1759 static noinline void check_destroy(struct xarray *xa)
1763 XA_BUG_ON(xa, !xa_empty(xa));
1766 xa_destroy(xa);
1767 XA_BUG_ON(xa, !xa_empty(xa));
1771 xa_store_index(xa, index, GFP_KERNEL);
1772 XA_BUG_ON(xa, xa_empty(xa));
1773 xa_destroy(xa);
1774 XA_BUG_ON(xa, !xa_empty(xa));
1778 xa_store(xa, ULONG_MAX, xa, GFP_KERNEL);
1779 XA_BUG_ON(xa, xa_empty(xa));
1780 xa_destroy(xa);
1781 XA_BUG_ON(xa, !xa_empty(xa));
1785 xa_store_order(xa, 1 << 11, 11, xa, GFP_KERNEL);
1786 XA_BUG_ON(xa, xa_empty(xa));
1787 xa_destroy(xa);
1788 XA_BUG_ON(xa, !xa_empty(xa));