projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
afs: Provide a splice-read wrapper
[linux-block.git] / lib / test_xarray.c
CommitLineData
ad3d6c72
MW		 1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * test_xarray.c: Test the XArray API
4 * Copyright (c) 2017-2018 Microsoft Corporation
c44aa5e8 5 * Copyright (c) 2019-2020 Oracle
ad3d6c72
MW		 6 * Author: Matthew Wilcox <willy@infradead.org>
7 */
8
9#include <linux/xarray.h>
10#include <linux/module.h>
11
12static unsigned int tests_run;
13static unsigned int tests_passed;
14
bd40b17c
MWO		 15static const unsigned int order_limit =
16 IS_ENABLED(CONFIG_XARRAY_MULTI) ? BITS_PER_LONG : 1;
17
ad3d6c72
MW		 18#ifndef XA_DEBUG
19# ifdef __KERNEL__
20void xa_dump(const struct xarray *xa) { }
21# endif
22#undef XA_BUG_ON
23#define XA_BUG_ON(xa, x) do { \
24 tests_run++; \
25 if (x) { \
26 printk("BUG at %s:%d\n", __func__, __LINE__); \
27 xa_dump(xa); \
28 dump_stack(); \
29 } else { \
30 tests_passed++; \
31 } \
32} while (0)
33#endif
34
b7677a13
MW		 35static void *xa_mk_index(unsigned long index)
36{
37 return xa_mk_value(index & LONG_MAX);
38}
39
ad3d6c72
MW		 40static void *xa_store_index(struct xarray *xa, unsigned long index, gfp_t gfp)
41{
b7677a13 42 return xa_store(xa, index, xa_mk_index(index), gfp);
ad3d6c72
MW		 43}
44
12fd2aee
MW		 45static void xa_insert_index(struct xarray *xa, unsigned long index)
46{
47 XA_BUG_ON(xa, xa_insert(xa, index, xa_mk_index(index),
48 GFP_KERNEL) != 0);
49}
50
371c752d
MW		 51static void xa_alloc_index(struct xarray *xa, unsigned long index, gfp_t gfp)
52{
a3e4d3f9 53 u32 id;
371c752d 54
a3e4d3f9 55 XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(index), xa_limit_32b,
371c752d
MW		 56 gfp) != 0);
57 XA_BUG_ON(xa, id != index);
58}
59
ad3d6c72
MW		 60static void xa_erase_index(struct xarray *xa, unsigned long index)
61{
b7677a13 62 XA_BUG_ON(xa, xa_erase(xa, index) != xa_mk_index(index));
58d6ea30
MW		 63 XA_BUG_ON(xa, xa_load(xa, index) != NULL);
64}
65
66/*
67 * If anyone needs this, please move it to xarray.c. We have no current
68 * users outside the test suite because all current multislot users want
69 * to use the advanced API.
70 */
71static void *xa_store_order(struct xarray *xa, unsigned long index,
72 unsigned order, void *entry, gfp_t gfp)
73{
74 XA_STATE_ORDER(xas, xa, index, order);
75 void *curr;
76
77 do {
78 xas_lock(&xas);
79 curr = xas_store(&xas, entry);
80 xas_unlock(&xas);
81 } while (xas_nomem(&xas, gfp));
82
83 return curr;
84}
85
86static noinline void check_xa_err(struct xarray *xa)
87{
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);
90#ifndef __KERNEL__
91 /* The kernel does not fail GFP_NOWAIT allocations */
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);
94#endif
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);
98// kills the test-suite :-(
99// XA_BUG_ON(xa, xa_err(xa_store(xa, 0, xa_mk_internal(0), 0)) != -EINVAL);
ad3d6c72
MW		 100}
101
b803b428
MW		 102static noinline void check_xas_retry(struct xarray *xa)
103{
104 XA_STATE(xas, xa, 0);
105 void *entry;
106
107 xa_store_index(xa, 0, GFP_KERNEL);
108 xa_store_index(xa, 1, GFP_KERNEL);
109
110 rcu_read_lock();
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)));
116 xas_reset(&xas);
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);
bd54211b 120 rcu_read_unlock();
b803b428
MW		 121
122 XA_BUG_ON(xa, xa_store_index(xa, 1, GFP_KERNEL) != NULL);
bd54211b
MW		 123
124 rcu_read_lock();
b803b428
MW		 125 XA_BUG_ON(xa, !xa_is_internal(xas_reload(&xas)));
126 xas.xa_node = XAS_RESTART;
127 XA_BUG_ON(xa, xas_next_entry(&xas, ULONG_MAX) != xa_mk_value(0));
128 rcu_read_unlock();
129
130 /* Make sure we can iterate through retry entries */
131 xas_lock(&xas);
132 xas_set(&xas, 0);
133 xas_store(&xas, XA_RETRY_ENTRY);
134 xas_set(&xas, 1);
135 xas_store(&xas, XA_RETRY_ENTRY);
136
137 xas_set(&xas, 0);
138 xas_for_each(&xas, entry, ULONG_MAX) {
b7677a13 139 xas_store(&xas, xa_mk_index(xas.xa_index));
b803b428
MW		 140 }
141 xas_unlock(&xas);
142
143 xa_erase_index(xa, 0);
144 xa_erase_index(xa, 1);
145}
146
ad3d6c72
MW		 147static noinline void check_xa_load(struct xarray *xa)
148{
149 unsigned long i, j;
150
151 for (i = 0; i < 1024; i++) {
152 for (j = 0; j < 1024; j++) {
153 void *entry = xa_load(xa, j);
154 if (j < i)
155 XA_BUG_ON(xa, xa_to_value(entry) != j);
156 else
157 XA_BUG_ON(xa, entry);
158 }
159 XA_BUG_ON(xa, xa_store_index(xa, i, GFP_KERNEL) != NULL);
160 }
161
162 for (i = 0; i < 1024; i++) {
163 for (j = 0; j < 1024; j++) {
164 void *entry = xa_load(xa, j);
165 if (j >= i)
166 XA_BUG_ON(xa, xa_to_value(entry) != j);
167 else
168 XA_BUG_ON(xa, entry);
169 }
170 xa_erase_index(xa, i);
171 }
172 XA_BUG_ON(xa, !xa_empty(xa));
173}
174
9b89a035
MW		 175static noinline void check_xa_mark_1(struct xarray *xa, unsigned long index)
176{
58d6ea30
MW		 177 unsigned int order;
178 unsigned int max_order = IS_ENABLED(CONFIG_XARRAY_MULTI) ? 8 : 1;
179
9b89a035
MW		 180 /* NULL elements have no marks set */
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));
184
185 /* Storing a pointer will not make a mark appear */
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));
190
191 /* Setting one mark will not set another mark */
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));
194
195 /* Storing NULL clears marks, and they can't be set again */
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));
58d6ea30
MW		 201
202 /*
203 * Storing a multi-index entry over entries with marks gives the
204 * entire entry the union of the marks
205 */
206 BUG_ON((index % 4) != 0);
207 for (order = 2; order < max_order; order++) {
208 unsigned long base = round_down(index, 1UL << order);
209 unsigned long next = base + (1UL << order);
210 unsigned long i;
211
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));
d69d287a 215 xa_set_mark(xa, index + 2, XA_MARK_2);
58d6ea30 216 XA_BUG_ON(xa, xa_store_index(xa, next, GFP_KERNEL));
b7677a13 217 xa_store_order(xa, index, order, xa_mk_index(index),
58d6ea30
MW		 218 GFP_KERNEL);
219 for (i = base; i < next; i++) {
93eb07f7
MW		 220 XA_STATE(xas, xa, i);
221 unsigned int seen = 0;
222 void *entry;
223
58d6ea30 224 XA_BUG_ON(xa, !xa_get_mark(xa, i, XA_MARK_0));
d69d287a
MW		 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));
93eb07f7
MW		 227
228 /* We should see two elements in the array */
fffc9a26 229 rcu_read_lock();
93eb07f7
MW		 230 xas_for_each(&xas, entry, ULONG_MAX)
231 seen++;
fffc9a26 232 rcu_read_unlock();
93eb07f7
MW		 233 XA_BUG_ON(xa, seen != 2);
234
235 /* One of which is marked */
236 xas_set(&xas, 0);
237 seen = 0;
fffc9a26 238 rcu_read_lock();
93eb07f7
MW		 239 xas_for_each_marked(&xas, entry, ULONG_MAX, XA_MARK_0)
240 seen++;
fffc9a26 241 rcu_read_unlock();
93eb07f7 242 XA_BUG_ON(xa, seen != 1);
58d6ea30
MW		 243 }
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));
250 }
251 XA_BUG_ON(xa, !xa_empty(xa));
9b89a035
MW		 252}
253
adb9d9c4
MW		 254static noinline void check_xa_mark_2(struct xarray *xa)
255{
256 XA_STATE(xas, xa, 0);
257 unsigned long index;
258 unsigned int count = 0;
259 void *entry;
260
261 xa_store_index(xa, 0, GFP_KERNEL);
262 xa_set_mark(xa, 0, XA_MARK_0);
263 xas_lock(&xas);
264 xas_load(&xas);
265 xas_init_marks(&xas);
266 xas_unlock(&xas);
267 XA_BUG_ON(xa, !xa_get_mark(xa, 0, XA_MARK_0) == 0);
268
269 for (index = 3500; index < 4500; index++) {
270 xa_store_index(xa, index, GFP_KERNEL);
271 xa_set_mark(xa, index, XA_MARK_0);
272 }
273
274 xas_reset(&xas);
275 rcu_read_lock();
276 xas_for_each_marked(&xas, entry, ULONG_MAX, XA_MARK_0)
277 count++;
278 rcu_read_unlock();
279 XA_BUG_ON(xa, count != 1000);
280
281 xas_lock(&xas);
282 xas_for_each(&xas, entry, ULONG_MAX) {
283 xas_init_marks(&xas);
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));
286 }
287 xas_unlock(&xas);
288
289 xa_destroy(xa);
290}
291
04e9e9bb
MWO		 292static noinline void check_xa_mark_3(struct xarray *xa)
293{
294#ifdef CONFIG_XARRAY_MULTI
295 XA_STATE(xas, xa, 0x41);
296 void *entry;
297 int count = 0;
298
299 xa_store_order(xa, 0x40, 2, xa_mk_index(0x40), GFP_KERNEL);
300 xa_set_mark(xa, 0x41, XA_MARK_0);
301
302 rcu_read_lock();
303 xas_for_each_marked(&xas, entry, ULONG_MAX, XA_MARK_0) {
304 count++;
305 XA_BUG_ON(xa, entry != xa_mk_index(0x40));
306 }
307 XA_BUG_ON(xa, count != 1);
308 rcu_read_unlock();
309 xa_destroy(xa);
310#endif
311}
312
9b89a035
MW		 313static noinline void check_xa_mark(struct xarray *xa)
314{
315 unsigned long index;
316
317 for (index = 0; index < 16384; index += 4)
318 check_xa_mark_1(xa, index);
adb9d9c4
MW		 319
320 check_xa_mark_2(xa);
04e9e9bb 321 check_xa_mark_3(xa);
9b89a035
MW		 322}
323
58d6ea30
MW		 324static noinline void check_xa_shrink(struct xarray *xa)
325{
326 XA_STATE(xas, xa, 1);
327 struct xa_node *node;
93eb07f7
MW		 328 unsigned int order;
329 unsigned int max_order = IS_ENABLED(CONFIG_XARRAY_MULTI) ? 15 : 1;
58d6ea30
MW		 330
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);
334
335 /*
336 * Check that erasing the entry at 1 shrinks the tree and properly
337 * marks the node as being deleted.
338 */
339 xas_lock(&xas);
340 XA_BUG_ON(xa, xas_load(&xas) != xa_mk_value(1));
341 node = xas.xa_node;
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);
348 xas_unlock(&xas);
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));
93eb07f7
MW		 352
353 for (order = 0; order < max_order; order++) {
354 unsigned long max = (1UL << order) - 1;
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);
358 rcu_read_lock();
359 node = xa_head(xa);
360 rcu_read_unlock();
361 XA_BUG_ON(xa, xa_store_index(xa, ULONG_MAX, GFP_KERNEL) !=
362 NULL);
363 rcu_read_lock();
364 XA_BUG_ON(xa, xa_head(xa) == node);
365 rcu_read_unlock();
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);
370 }
58d6ea30
MW		 371}
372
12fd2aee
MW		 373static noinline void check_insert(struct xarray *xa)
374{
375 unsigned long i;
376
377 for (i = 0; i < 1024; i++) {
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);
382 }
383
384 for (i = 10; i < BITS_PER_LONG; 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);
389
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);
394 }
395
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);
400
401 XA_BUG_ON(xa, !xa_empty(xa));
402}
403
41aec91f
MW		 404static noinline void check_cmpxchg(struct xarray *xa)
405{
406 void *FIVE = xa_mk_value(5);
407 void *SIX = xa_mk_value(6);
408 void *LOTS = xa_mk_value(12345678);
409
410 XA_BUG_ON(xa, !xa_empty(xa));
411 XA_BUG_ON(xa, xa_store_index(xa, 12345678, GFP_KERNEL) != NULL);
fd9dc93e 412 XA_BUG_ON(xa, xa_insert(xa, 12345678, xa, GFP_KERNEL) != -EBUSY);
41aec91f
MW		 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);
062b7359
MWO		 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);
41aec91f
MW		 421 xa_erase_index(xa, 12345678);
422 xa_erase_index(xa, 5);
423 XA_BUG_ON(xa, !xa_empty(xa));
424}
425
9f14d4f1
MW		 426static noinline void check_reserve(struct xarray *xa)
427{
428 void *entry;
4a31896c 429 unsigned long index;
b38f6c50 430 int count;
9f14d4f1
MW		 431
432 /* An array with a reserved entry is not empty */
433 XA_BUG_ON(xa, !xa_empty(xa));
f818b82b 434 XA_BUG_ON(xa, xa_reserve(xa, 12345678, GFP_KERNEL) != 0);
9f14d4f1
MW		 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));
439
440 /* Releasing a used entry does nothing */
f818b82b 441 XA_BUG_ON(xa, xa_reserve(xa, 12345678, GFP_KERNEL) != 0);
9f14d4f1
MW		 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));
446
b38f6c50 447 /* cmpxchg sees a reserved entry as ZERO */
f818b82b 448 XA_BUG_ON(xa, xa_reserve(xa, 12345678, GFP_KERNEL) != 0);
b38f6c50
MW		 449 XA_BUG_ON(xa, xa_cmpxchg(xa, 12345678, XA_ZERO_ENTRY,
450 xa_mk_value(12345678), GFP_NOWAIT) != NULL);
9f14d4f1
MW		 451 xa_release(xa, 12345678);
452 xa_erase_index(xa, 12345678);
453 XA_BUG_ON(xa, !xa_empty(xa));
454
b38f6c50 455 /* xa_insert treats it as busy */
f818b82b 456 XA_BUG_ON(xa, xa_reserve(xa, 12345678, GFP_KERNEL) != 0);
b0606fed 457 XA_BUG_ON(xa, xa_insert(xa, 12345678, xa_mk_value(12345678), 0) !=
fd9dc93e 458 -EBUSY);
b0606fed
MW		 459 XA_BUG_ON(xa, xa_empty(xa));
460 XA_BUG_ON(xa, xa_erase(xa, 12345678) != NULL);
4c0608f4
MW		 461 XA_BUG_ON(xa, !xa_empty(xa));
462
9f14d4f1
MW		 463 /* Can iterate through a reserved entry */
464 xa_store_index(xa, 5, GFP_KERNEL);
f818b82b 465 XA_BUG_ON(xa, xa_reserve(xa, 6, GFP_KERNEL) != 0);
9f14d4f1
MW		 466 xa_store_index(xa, 7, GFP_KERNEL);
467
b38f6c50 468 count = 0;
4a31896c 469 xa_for_each(xa, index, entry) {
9f14d4f1 470 XA_BUG_ON(xa, index != 5 && index != 7);
b38f6c50
MW		 471 count++;
472 }
473 XA_BUG_ON(xa, count != 2);
474
475 /* If we free a reserved entry, we should be able to allocate it */
476 if (xa->xa_flags & XA_FLAGS_ALLOC) {
477 u32 id;
478
479 XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_value(8),
480 XA_LIMIT(5, 10), GFP_KERNEL) != 0);
481 XA_BUG_ON(xa, id != 8);
482
483 xa_release(xa, 6);
484 XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_value(6),
485 XA_LIMIT(5, 10), GFP_KERNEL) != 0);
486 XA_BUG_ON(xa, id != 6);
9f14d4f1 487 }
b38f6c50 488
9f14d4f1
MW		 489 xa_destroy(xa);
490}
491
b803b428
MW		 492static noinline void check_xas_erase(struct xarray *xa)
493{
494 XA_STATE(xas, xa, 0);
495 void *entry;
496 unsigned long i, j;
497
498 for (i = 0; i < 200; i++) {
499 for (j = i; j < 2 * i + 17; j++) {
500 xas_set(&xas, j);
501 do {
502 xas_lock(&xas);
b7677a13 503 xas_store(&xas, xa_mk_index(j));
b803b428
MW		 504 xas_unlock(&xas);
505 } while (xas_nomem(&xas, GFP_KERNEL));
506 }
507
508 xas_set(&xas, ULONG_MAX);
509 do {
510 xas_lock(&xas);
511 xas_store(&xas, xa_mk_value(0));
512 xas_unlock(&xas);
513 } while (xas_nomem(&xas, GFP_KERNEL));
514
515 xas_lock(&xas);
516 xas_store(&xas, NULL);
517
518 xas_set(&xas, 0);
519 j = i;
520 xas_for_each(&xas, entry, ULONG_MAX) {
b7677a13 521 XA_BUG_ON(xa, entry != xa_mk_index(j));
b803b428
MW		 522 xas_store(&xas, NULL);
523 j++;
524 }
525 xas_unlock(&xas);
526 XA_BUG_ON(xa, !xa_empty(xa));
527 }
528}
529
4f06d630
MW		 530#ifdef CONFIG_XARRAY_MULTI
531static noinline void check_multi_store_1(struct xarray *xa, unsigned long index,
532 unsigned int order)
533{
534 XA_STATE(xas, xa, index);
535 unsigned long min = index & ~((1UL << order) - 1);
536 unsigned long max = min + (1UL << order);
537
b7677a13
MW		 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));
4f06d630
MW		 541 XA_BUG_ON(xa, xa_load(xa, max) != NULL);
542 XA_BUG_ON(xa, xa_load(xa, min - 1) != NULL);
543
fffc9a26 544 xas_lock(&xas);
b7677a13 545 XA_BUG_ON(xa, xas_store(&xas, xa_mk_index(min)) != xa_mk_index(index));
fffc9a26 546 xas_unlock(&xas);
b7677a13
MW		 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));
4f06d630
MW		 549 XA_BUG_ON(xa, xa_load(xa, max) != NULL);
550 XA_BUG_ON(xa, xa_load(xa, min - 1) != NULL);
551
552 xa_erase_index(xa, min);
553 XA_BUG_ON(xa, !xa_empty(xa));
554}
555
556static noinline void check_multi_store_2(struct xarray *xa, unsigned long index,
557 unsigned int order)
558{
559 XA_STATE(xas, xa, index);
560 xa_store_order(xa, index, order, xa_mk_value(0), GFP_KERNEL);
561
fffc9a26 562 xas_lock(&xas);
4f06d630
MW		 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));
fffc9a26 566 xas_unlock(&xas);
4f06d630
MW		 567 XA_BUG_ON(xa, !xa_empty(xa));
568}
4f145cd6
MW		 569
570static noinline void check_multi_store_3(struct xarray *xa, unsigned long index,
571 unsigned int order)
572{
573 XA_STATE(xas, xa, 0);
574 void *entry;
575 int n = 0;
576
577 xa_store_order(xa, index, order, xa_mk_index(index), GFP_KERNEL);
578
579 xas_lock(&xas);
580 xas_for_each(&xas, entry, ULONG_MAX) {
581 XA_BUG_ON(xa, entry != xa_mk_index(index));
582 n++;
583 }
584 XA_BUG_ON(xa, n != 1);
585 xas_set(&xas, index + 1);
586 xas_for_each(&xas, entry, ULONG_MAX) {
587 XA_BUG_ON(xa, entry != xa_mk_index(index));
588 n++;
589 }
590 XA_BUG_ON(xa, n != 2);
591 xas_unlock(&xas);
592
593 xa_destroy(xa);
594}
4f06d630
MW		 595#endif
596
58d6ea30
MW		 597static noinline void check_multi_store(struct xarray *xa)
598{
599#ifdef CONFIG_XARRAY_MULTI
600 unsigned long i, j, k;
601 unsigned int max_order = (sizeof(long) == 4) ? 30 : 60;
602
603 /* Loading from any position returns the same value */
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);
608 rcu_read_lock();
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);
611 rcu_read_unlock();
612
613 /* Storing adjacent to the value does not alter the value */
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);
618 rcu_read_lock();
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);
621 rcu_read_unlock();
622
623 /* Overwriting multiple indexes works */
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);
630 rcu_read_lock();
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);
633 rcu_read_unlock();
634
635 /* We can erase multiple values with a single store */
5404a7f1 636 xa_store_order(xa, 0, BITS_PER_LONG - 1, NULL, GFP_KERNEL);
58d6ea30
MW		 637 XA_BUG_ON(xa, !xa_empty(xa));
638
639 /* Even when the first slot is empty but the others aren't */
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));
644
645 for (i = 0; i < max_order; i++) {
646 for (j = 0; j < max_order; j++) {
b7677a13
MW		 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);
58d6ea30
MW		 649
650 for (k = 0; k < max_order; k++) {
651 void *entry = xa_load(xa, (1UL << k) - 1);
652 if ((i < k) && (j < k))
653 XA_BUG_ON(xa, entry != NULL);
654 else
b7677a13 655 XA_BUG_ON(xa, entry != xa_mk_index(j));
58d6ea30
MW		 656 }
657
658 xa_erase(xa, 0);
659 XA_BUG_ON(xa, !xa_empty(xa));
660 }
661 }
4f06d630
MW		 662
663 for (i = 0; i < 20; i++) {
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);
667 }
668 check_multi_store_2(xa, 4095, 9);
4f145cd6
MW		 669
670 for (i = 1; i < 20; i++) {
671 check_multi_store_3(xa, 0, i);
672 check_multi_store_3(xa, 1UL << i, i);
673 }
58d6ea30
MW		 674#endif
675}
676
3ccaf57a 677static noinline void check_xa_alloc_1(struct xarray *xa, unsigned int base)
371c752d
MW		 678{
679 int i;
680 u32 id;
681
3ccaf57a
MW		 682 XA_BUG_ON(xa, !xa_empty(xa));
683 /* An empty array should assign %base to the first alloc */
684 xa_alloc_index(xa, base, GFP_KERNEL);
371c752d
MW		 685
686 /* Erasing it should make the array empty again */
3ccaf57a
MW		 687 xa_erase_index(xa, base);
688 XA_BUG_ON(xa, !xa_empty(xa));
689
690 /* And it should assign %base again */
691 xa_alloc_index(xa, base, GFP_KERNEL);
692
693 /* Allocating and then erasing a lot should not lose base */
694 for (i = base + 1; i < 2 * XA_CHUNK_SIZE; i++)
695 xa_alloc_index(xa, i, GFP_KERNEL);
696 for (i = base; i < 2 * XA_CHUNK_SIZE; i++)
697 xa_erase_index(xa, i);
698 xa_alloc_index(xa, base, GFP_KERNEL);
699
700 /* Destroying the array should do the same as erasing */
701 xa_destroy(xa);
371c752d 702
3ccaf57a
MW		 703 /* And it should assign %base again */
704 xa_alloc_index(xa, base, GFP_KERNEL);
371c752d 705
3ccaf57a
MW		 706 /* The next assigned ID should be base+1 */
707 xa_alloc_index(xa, base + 1, GFP_KERNEL);
708 xa_erase_index(xa, base + 1);
371c752d
MW		 709
710 /* Storing a value should mark it used */
3ccaf57a
MW		 711 xa_store_index(xa, base + 1, GFP_KERNEL);
712 xa_alloc_index(xa, base + 2, GFP_KERNEL);
371c752d 713
3ccaf57a
MW		 714 /* If we then erase base, it should be free */
715 xa_erase_index(xa, base);
716 xa_alloc_index(xa, base, GFP_KERNEL);
371c752d 717
3ccaf57a
MW		 718 xa_erase_index(xa, base + 1);
719 xa_erase_index(xa, base + 2);
371c752d
MW		 720
721 for (i = 1; i < 5000; i++) {
3ccaf57a 722 xa_alloc_index(xa, base + i, GFP_KERNEL);
371c752d
MW		 723 }
724
3ccaf57a 725 xa_destroy(xa);
371c752d 726
3ccaf57a 727 /* Check that we fail properly at the limit of allocation */
a3e4d3f9
MW		 728 XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(UINT_MAX - 1),
729 XA_LIMIT(UINT_MAX - 1, UINT_MAX),
371c752d 730 GFP_KERNEL) != 0);
3ccaf57a 731 XA_BUG_ON(xa, id != 0xfffffffeU);
a3e4d3f9
MW		 732 XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(UINT_MAX),
733 XA_LIMIT(UINT_MAX - 1, UINT_MAX),
371c752d 734 GFP_KERNEL) != 0);
3ccaf57a 735 XA_BUG_ON(xa, id != 0xffffffffU);
a3e4d3f9
MW		 736 id = 3;
737 XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(0),
738 XA_LIMIT(UINT_MAX - 1, UINT_MAX),
739 GFP_KERNEL) != -EBUSY);
740 XA_BUG_ON(xa, id != 3);
3ccaf57a 741 xa_destroy(xa);
48483614 742
a3e4d3f9
MW		 743 XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(10), XA_LIMIT(10, 5),
744 GFP_KERNEL) != -EBUSY);
3ccaf57a 745 XA_BUG_ON(xa, xa_store_index(xa, 3, GFP_KERNEL) != 0);
a3e4d3f9
MW		 746 XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(10), XA_LIMIT(10, 5),
747 GFP_KERNEL) != -EBUSY);
3ccaf57a
MW		 748 xa_erase_index(xa, 3);
749 XA_BUG_ON(xa, !xa_empty(xa));
750}
751
a3e4d3f9
MW		 752static noinline void check_xa_alloc_2(struct xarray *xa, unsigned int base)
753{
754 unsigned int i, id;
755 unsigned long index;
756 void *entry;
757
758 /* Allocate and free a NULL and check xa_empty() behaves */
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));
765
766 /* Ditto, but check destroy instead of erase */
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));
773
774 for (i = base; i < base + 10; i++) {
775 XA_BUG_ON(xa, xa_alloc(xa, &id, NULL, xa_limit_32b,
776 GFP_KERNEL) != 0);
777 XA_BUG_ON(xa, id != i);
778 }
779
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);
786
787 xa_for_each(xa, index, entry) {
788 xa_erase_index(xa, index);
789 }
790
791 for (i = base; i < base + 9; i++) {
792 XA_BUG_ON(xa, xa_erase(xa, i) != NULL);
793 XA_BUG_ON(xa, xa_empty(xa));
794 }
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));
799
800 xa_destroy(xa);
801}
802
2fa044e5
MW		 803static noinline void check_xa_alloc_3(struct xarray *xa, unsigned int base)
804{
805 struct xa_limit limit = XA_LIMIT(1, 0x3fff);
806 u32 next = 0;
807 unsigned int i, id;
808 unsigned long index;
809 void *entry;
810
811 XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(1), limit,
812 &next, GFP_KERNEL) != 0);
813 XA_BUG_ON(xa, id != 1);
814
815 next = 0x3ffd;
816 XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(0x3ffd), limit,
817 &next, GFP_KERNEL) != 0);
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));
822
823 for (i = 0x3ffe; i < 0x4003; i++) {
824 if (i < 0x4000)
825 entry = xa_mk_index(i);
826 else
827 entry = xa_mk_index(i - 0x3fff);
828 XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, entry, limit,
829 &next, GFP_KERNEL) != (id == 1));
830 XA_BUG_ON(xa, xa_mk_index(id) != entry);
831 }
832
833 /* Check wrap-around is handled correctly */
834 if (base != 0)
835 xa_erase_index(xa, base);
836 xa_erase_index(xa, base + 1);
837 next = UINT_MAX;
838 XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(UINT_MAX),
839 xa_limit_32b, &next, GFP_KERNEL) != 0);
840 XA_BUG_ON(xa, id != UINT_MAX);
841 XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(base),
842 xa_limit_32b, &next, GFP_KERNEL) != 1);
843 XA_BUG_ON(xa, id != base);
844 XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(base + 1),
845 xa_limit_32b, &next, GFP_KERNEL) != 0);
846 XA_BUG_ON(xa, id != base + 1);
847
848 xa_for_each(xa, index, entry)
849 xa_erase_index(xa, index);
850
851 XA_BUG_ON(xa, !xa_empty(xa));
852}
853
3ccaf57a
MW		 854static DEFINE_XARRAY_ALLOC(xa0);
855static DEFINE_XARRAY_ALLOC1(xa1);
856
857static noinline void check_xa_alloc(void)
858{
859 check_xa_alloc_1(&xa0, 0);
860 check_xa_alloc_1(&xa1, 1);
a3e4d3f9
MW		 861 check_xa_alloc_2(&xa0, 0);
862 check_xa_alloc_2(&xa1, 1);
2fa044e5
MW		 863 check_xa_alloc_3(&xa0, 0);
864 check_xa_alloc_3(&xa1, 1);
371c752d
MW		 865}
866
4e99d4e9
MW		 867static noinline void __check_store_iter(struct xarray *xa, unsigned long start,
868 unsigned int order, unsigned int present)
869{
870 XA_STATE_ORDER(xas, xa, start, order);
871 void *entry;
872 unsigned int count = 0;
873
874retry:
875 xas_lock(&xas);
876 xas_for_each_conflict(&xas, entry) {
877 XA_BUG_ON(xa, !xa_is_value(entry));
b7677a13
MW		 878 XA_BUG_ON(xa, entry < xa_mk_index(start));
879 XA_BUG_ON(xa, entry > xa_mk_index(start + (1UL << order) - 1));
4e99d4e9
MW		 880 count++;
881 }
b7677a13 882 xas_store(&xas, xa_mk_index(start));
4e99d4e9
MW		 883 xas_unlock(&xas);
884 if (xas_nomem(&xas, GFP_KERNEL)) {
885 count = 0;
886 goto retry;
887 }
888 XA_BUG_ON(xa, xas_error(&xas));
889 XA_BUG_ON(xa, count != present);
b7677a13 890 XA_BUG_ON(xa, xa_load(xa, start) != xa_mk_index(start));
4e99d4e9 891 XA_BUG_ON(xa, xa_load(xa, start + (1UL << order) - 1) !=
b7677a13 892 xa_mk_index(start));
4e99d4e9
MW		 893 xa_erase_index(xa, start);
894}
895
896static noinline void check_store_iter(struct xarray *xa)
897{
898 unsigned int i, j;
899 unsigned int max_order = IS_ENABLED(CONFIG_XARRAY_MULTI) ? 20 : 1;
900
901 for (i = 0; i < max_order; i++) {
902 unsigned int min = 1 << i;
903 unsigned int max = (2 << i) - 1;
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));
908
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));
915
916 for (j = 0; j < min; j++)
917 xa_store_index(xa, j, GFP_KERNEL);
918 __check_store_iter(xa, 0, i, min);
919 XA_BUG_ON(xa, !xa_empty(xa));
920 for (j = 0; j < min; j++)
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));
924 }
925#ifdef CONFIG_XARRAY_MULTI
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);
930#endif
931 XA_BUG_ON(xa, !xa_empty(xa));
932}
933
19c30f4d 934static noinline void check_multi_find_1(struct xarray *xa, unsigned order)
b803b428
MW		 935{
936#ifdef CONFIG_XARRAY_MULTI
19c30f4d
MWO		 937 unsigned long multi = 3 << order;
938 unsigned long next = 4 << order;
b803b428
MW		 939 unsigned long index;
940
19c30f4d
MWO		 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);
c44aa5e8 943 XA_BUG_ON(xa, xa_store_index(xa, next + 1, GFP_KERNEL) != NULL);
b803b428
MW		 944
945 index = 0;
946 XA_BUG_ON(xa, xa_find(xa, &index, ULONG_MAX, XA_PRESENT) !=
19c30f4d
MWO		 947 xa_mk_value(multi));
948 XA_BUG_ON(xa, index != multi);
949 index = multi + 1;
b803b428 950 XA_BUG_ON(xa, xa_find(xa, &index, ULONG_MAX, XA_PRESENT) !=
19c30f4d
MWO		 951 xa_mk_value(multi));
952 XA_BUG_ON(xa, (index < multi) || (index >= next));
b803b428 953 XA_BUG_ON(xa, xa_find_after(xa, &index, ULONG_MAX, XA_PRESENT) !=
19c30f4d
MWO		 954 xa_mk_value(next));
955 XA_BUG_ON(xa, index != next);
c44aa5e8
MWO		 956 XA_BUG_ON(xa, xa_find_after(xa, &index, next, XA_PRESENT) != NULL);
957 XA_BUG_ON(xa, index != next);
b803b428 958
19c30f4d
MWO		 959 xa_erase_index(xa, multi);
960 xa_erase_index(xa, next);
c44aa5e8 961 xa_erase_index(xa, next + 1);
b803b428
MW		 962 XA_BUG_ON(xa, !xa_empty(xa));
963#endif
964}
965
966static noinline void check_multi_find_2(struct xarray *xa)
967{
968 unsigned int max_order = IS_ENABLED(CONFIG_XARRAY_MULTI) ? 10 : 1;
969 unsigned int i, j;
970 void *entry;
971
972 for (i = 0; i < max_order; i++) {
973 unsigned long index = 1UL << i;
974 for (j = 0; j < index; j++) {
975 XA_STATE(xas, xa, j + index);
976 xa_store_index(xa, index - 1, GFP_KERNEL);
b7677a13 977 xa_store_order(xa, index, i, xa_mk_index(index),
b803b428
MW		 978 GFP_KERNEL);
979 rcu_read_lock();
980 xas_for_each(&xas, entry, ULONG_MAX) {
981 xa_erase_index(xa, index);
982 }
983 rcu_read_unlock();
984 xa_erase_index(xa, index - 1);
985 XA_BUG_ON(xa, !xa_empty(xa));
986 }
987 }
988}
989
bd40b17c
MWO		 990static noinline void check_multi_find_3(struct xarray *xa)
991{
992 unsigned int order;
993
994 for (order = 5; order < order_limit; order++) {
995 unsigned long index = 1UL << (order - 5);
996
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);
1001 }
1002}
1003
8229706e 1004static noinline void check_find_1(struct xarray *xa)
b803b428
MW		 1005{
1006 unsigned long i, j, k;
1007
1008 XA_BUG_ON(xa, !xa_empty(xa));
1009
1010 /*
1011 * Check xa_find with all pairs between 0 and 99 inclusive,
1012 * starting at every index between 0 and 99
1013 */
1014 for (i = 0; i < 100; i++) {
1015 XA_BUG_ON(xa, xa_store_index(xa, i, GFP_KERNEL) != NULL);
1016 xa_set_mark(xa, i, XA_MARK_0);
1017 for (j = 0; j < i; j++) {
1018 XA_BUG_ON(xa, xa_store_index(xa, j, GFP_KERNEL) !=
1019 NULL);
1020 xa_set_mark(xa, j, XA_MARK_0);
1021 for (k = 0; k < 100; k++) {
1022 unsigned long index = k;
1023 void *entry = xa_find(xa, &index, ULONG_MAX,
1024 XA_PRESENT);
1025 if (k <= j)
1026 XA_BUG_ON(xa, index != j);
1027 else if (k <= i)
1028 XA_BUG_ON(xa, index != i);
1029 else
1030 XA_BUG_ON(xa, entry != NULL);
1031
1032 index = k;
1033 entry = xa_find(xa, &index, ULONG_MAX,
1034 XA_MARK_0);
1035 if (k <= j)
1036 XA_BUG_ON(xa, index != j);
1037 else if (k <= i)
1038 XA_BUG_ON(xa, index != i);
1039 else
1040 XA_BUG_ON(xa, entry != NULL);
1041 }
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));
1045 }
1046 xa_erase_index(xa, i);
1047 XA_BUG_ON(xa, xa_get_mark(xa, i, XA_MARK_0));
1048 }
1049 XA_BUG_ON(xa, !xa_empty(xa));
8229706e
MW		 1050}
1051
1052static noinline void check_find_2(struct xarray *xa)
1053{
1054 void *entry;
4a31896c 1055 unsigned long i, j, index;
8229706e 1056
4a31896c 1057 xa_for_each(xa, index, entry) {
8229706e
MW		 1058 XA_BUG_ON(xa, true);
1059 }
1060
1061 for (i = 0; i < 1024; i++) {
1062 xa_store_index(xa, index, GFP_KERNEL);
1063 j = 0;
4a31896c 1064 xa_for_each(xa, index, entry) {
b7677a13 1065 XA_BUG_ON(xa, xa_mk_index(index) != entry);
8229706e
MW		 1066 XA_BUG_ON(xa, index != j++);
1067 }
1068 }
1069
1070 xa_destroy(xa);
1071}
1072
48483614
MW		 1073static noinline void check_find_3(struct xarray *xa)
1074{
1075 XA_STATE(xas, xa, 0);
1076 unsigned long i, j, k;
1077 void *entry;
1078
1079 for (i = 0; i < 100; i++) {
1080 for (j = 0; j < 100; j++) {
490fd30f 1081 rcu_read_lock();
48483614
MW		 1082 for (k = 0; k < 100; k++) {
1083 xas_set(&xas, j);
1084 xas_for_each_marked(&xas, entry, k, XA_MARK_0)
1085 ;
1086 if (j > k)
1087 XA_BUG_ON(xa,
1088 xas.xa_node != XAS_RESTART);
1089 }
490fd30f 1090 rcu_read_unlock();
48483614
MW		 1091 }
1092 xa_store_index(xa, i, GFP_KERNEL);
1093 xa_set_mark(xa, i, XA_MARK_0);
1094 }
1095 xa_destroy(xa);
1096}
1097
430f24f9
MWO		 1098static noinline void check_find_4(struct xarray *xa)
1099{
1100 unsigned long index = 0;
1101 void *entry;
1102
1103 xa_store_index(xa, ULONG_MAX, GFP_KERNEL);
1104
1105 entry = xa_find_after(xa, &index, ULONG_MAX, XA_PRESENT);
1106 XA_BUG_ON(xa, entry != xa_mk_index(ULONG_MAX));
1107
1108 entry = xa_find_after(xa, &index, ULONG_MAX, XA_PRESENT);
1109 XA_BUG_ON(xa, entry);
1110
1111 xa_erase_index(xa, ULONG_MAX);
1112}
1113
8229706e
MW		 1114static noinline void check_find(struct xarray *xa)
1115{
19c30f4d
MWO		 1116 unsigned i;
1117
8229706e
MW		 1118 check_find_1(xa);
1119 check_find_2(xa);
48483614 1120 check_find_3(xa);
430f24f9 1121 check_find_4(xa);
19c30f4d
MWO		 1122
1123 for (i = 2; i < 10; i++)
1124 check_multi_find_1(xa, i);
b803b428 1125 check_multi_find_2(xa);
bd40b17c 1126 check_multi_find_3(xa);
b803b428
MW		 1127}
1128
e21a2955
MW		 1129/* See find_swap_entry() in mm/shmem.c */
1130static noinline unsigned long xa_find_entry(struct xarray *xa, void *item)
1131{
1132 XA_STATE(xas, xa, 0);
1133 unsigned int checked = 0;
1134 void *entry;
1135
1136 rcu_read_lock();
1137 xas_for_each(&xas, entry, ULONG_MAX) {
1138 if (xas_retry(&xas, entry))
1139 continue;
1140 if (entry == item)
1141 break;
1142 checked++;
1143 if ((checked % 4) != 0)
1144 continue;
1145 xas_pause(&xas);
1146 }
1147 rcu_read_unlock();
1148
1149 return entry ? xas.xa_index : -1;
1150}
1151
1152static noinline void check_find_entry(struct xarray *xa)
1153{
1154#ifdef CONFIG_XARRAY_MULTI
1155 unsigned int order;
1156 unsigned long offset, index;
1157
1158 for (order = 0; order < 20; order++) {
1159 for (offset = 0; offset < (1UL << (order + 3));
1160 offset += (1UL << order)) {
1161 for (index = 0; index < (1UL << (order + 5));
1162 index += (1UL << order)) {
1163 xa_store_order(xa, index, order,
b7677a13 1164 xa_mk_index(index), GFP_KERNEL);
e21a2955 1165 XA_BUG_ON(xa, xa_load(xa, index) !=
b7677a13 1166 xa_mk_index(index));
e21a2955 1167 XA_BUG_ON(xa, xa_find_entry(xa,
b7677a13 1168 xa_mk_index(index)) != index);
e21a2955
MW		 1169 }
1170 XA_BUG_ON(xa, xa_find_entry(xa, xa) != -1);
1171 xa_destroy(xa);
1172 }
1173 }
1174#endif
1175
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);
b7677a13 1179 XA_BUG_ON(xa, xa_find_entry(xa, xa_mk_index(ULONG_MAX)) != -1);
e21a2955
MW		 1180 xa_erase_index(xa, ULONG_MAX);
1181 XA_BUG_ON(xa, !xa_empty(xa));
1182}
1183
c36d451a
MWO		 1184static noinline void check_pause(struct xarray *xa)
1185{
1186 XA_STATE(xas, xa, 0);
1187 void *entry;
1188 unsigned int order;
1189 unsigned long index = 1;
1190 unsigned int count = 0;
1191
1192 for (order = 0; order < order_limit; order++) {
1193 XA_BUG_ON(xa, xa_store_order(xa, index, order,
1194 xa_mk_index(index), GFP_KERNEL));
1195 index += 1UL << order;
1196 }
1197
1198 rcu_read_lock();
1199 xas_for_each(&xas, entry, ULONG_MAX) {
1200 XA_BUG_ON(xa, entry != xa_mk_index(1UL << count));
1201 count++;
1202 }
1203 rcu_read_unlock();
1204 XA_BUG_ON(xa, count != order_limit);
1205
1206 count = 0;
1207 xas_set(&xas, 0);
1208 rcu_read_lock();
1209 xas_for_each(&xas, entry, ULONG_MAX) {
1210 XA_BUG_ON(xa, entry != xa_mk_index(1UL << count));
1211 count++;
1212 xas_pause(&xas);
1213 }
1214 rcu_read_unlock();
1215 XA_BUG_ON(xa, count != order_limit);
1216
1217 xa_destroy(xa);
1218}
1219
91abab83
MWO		 1220static noinline void check_move_tiny(struct xarray *xa)
1221{
1222 XA_STATE(xas, xa, 0);
1223
1224 XA_BUG_ON(xa, !xa_empty(xa));
1225 rcu_read_lock();
1226 XA_BUG_ON(xa, xas_next(&xas) != NULL);
1227 XA_BUG_ON(xa, xas_next(&xas) != NULL);
1228 rcu_read_unlock();
1229 xa_store_index(xa, 0, GFP_KERNEL);
1230 rcu_read_lock();
1231 xas_set(&xas, 0);
1232 XA_BUG_ON(xa, xas_next(&xas) != xa_mk_index(0));
1233 XA_BUG_ON(xa, xas_next(&xas) != NULL);
1234 xas_set(&xas, 0);
1235 XA_BUG_ON(xa, xas_prev(&xas) != xa_mk_index(0));
1236 XA_BUG_ON(xa, xas_prev(&xas) != NULL);
1237 rcu_read_unlock();
1238 xa_erase_index(xa, 0);
1239 XA_BUG_ON(xa, !xa_empty(xa));
1240}
1241
82a22311
MWO		 1242static noinline void check_move_max(struct xarray *xa)
1243{
1244 XA_STATE(xas, xa, 0);
1245
1246 xa_store_index(xa, ULONG_MAX, GFP_KERNEL);
1247 rcu_read_lock();
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);
1250 rcu_read_unlock();
1251
1252 xas_set(&xas, 0);
1253 rcu_read_lock();
1254 XA_BUG_ON(xa, xas_find(&xas, ULONG_MAX) != xa_mk_index(ULONG_MAX));
1255 xas_pause(&xas);
1256 XA_BUG_ON(xa, xas_find(&xas, ULONG_MAX) != NULL);
1257 rcu_read_unlock();
1258
1259 xa_erase_index(xa, ULONG_MAX);
1260 XA_BUG_ON(xa, !xa_empty(xa));
1261}
1262
64d3e9a9
MW		 1263static noinline void check_move_small(struct xarray *xa, unsigned long idx)
1264{
1265 XA_STATE(xas, xa, 0);
1266 unsigned long i;
1267
1268 xa_store_index(xa, 0, GFP_KERNEL);
1269 xa_store_index(xa, idx, GFP_KERNEL);
1270
1271 rcu_read_lock();
1272 for (i = 0; i < idx * 4; i++) {
1273 void *entry = xas_next(&xas);
1274 if (i <= idx)
1275 XA_BUG_ON(xa, xas.xa_node == XAS_RESTART);
1276 XA_BUG_ON(xa, xas.xa_index != i);
1277 if (i == 0 || i == idx)
b7677a13 1278 XA_BUG_ON(xa, entry != xa_mk_index(i));
64d3e9a9
MW		 1279 else
1280 XA_BUG_ON(xa, entry != NULL);
1281 }
1282 xas_next(&xas);
1283 XA_BUG_ON(xa, xas.xa_index != i);
1284
1285 do {
1286 void *entry = xas_prev(&xas);
1287 i--;
1288 if (i <= idx)
1289 XA_BUG_ON(xa, xas.xa_node == XAS_RESTART);
1290 XA_BUG_ON(xa, xas.xa_index != i);
1291 if (i == 0 || i == idx)
b7677a13 1292 XA_BUG_ON(xa, entry != xa_mk_index(i));
64d3e9a9
MW		 1293 else
1294 XA_BUG_ON(xa, entry != NULL);
1295 } while (i > 0);
1296
1297 xas_set(&xas, ULONG_MAX);
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);
1304 rcu_read_unlock();
1305
1306 xa_erase_index(xa, 0);
1307 xa_erase_index(xa, idx);
1308 XA_BUG_ON(xa, !xa_empty(xa));
1309}
1310
1311static noinline void check_move(struct xarray *xa)
1312{
1313 XA_STATE(xas, xa, (1 << 16) - 1);
1314 unsigned long i;
1315
1316 for (i = 0; i < (1 << 16); i++)
1317 XA_BUG_ON(xa, xa_store_index(xa, i, GFP_KERNEL) != NULL);
1318
1319 rcu_read_lock();
1320 do {
1321 void *entry = xas_prev(&xas);
1322 i--;
b7677a13 1323 XA_BUG_ON(xa, entry != xa_mk_index(i));
64d3e9a9
MW		 1324 XA_BUG_ON(xa, i != xas.xa_index);
1325 } while (i != 0);
1326
1327 XA_BUG_ON(xa, xas_prev(&xas) != NULL);
1328 XA_BUG_ON(xa, xas.xa_index != ULONG_MAX);
1329
1330 do {
1331 void *entry = xas_next(&xas);
b7677a13 1332 XA_BUG_ON(xa, entry != xa_mk_index(i));
64d3e9a9
MW		 1333 XA_BUG_ON(xa, i != xas.xa_index);
1334 i++;
1335 } while (i < (1 << 16));
1336 rcu_read_unlock();
1337
1338 for (i = (1 << 8); i < (1 << 15); i++)
1339 xa_erase_index(xa, i);
1340
1341 i = xas.xa_index;
1342
1343 rcu_read_lock();
1344 do {
1345 void *entry = xas_prev(&xas);
1346 i--;
1347 if ((i < (1 << 8)) || (i >= (1 << 15)))
b7677a13 1348 XA_BUG_ON(xa, entry != xa_mk_index(i));
64d3e9a9
MW		 1349 else
1350 XA_BUG_ON(xa, entry != NULL);
1351 XA_BUG_ON(xa, i != xas.xa_index);
1352 } while (i != 0);
1353
1354 XA_BUG_ON(xa, xas_prev(&xas) != NULL);
1355 XA_BUG_ON(xa, xas.xa_index != ULONG_MAX);
1356
1357 do {
1358 void *entry = xas_next(&xas);
1359 if ((i < (1 << 8)) || (i >= (1 << 15)))
b7677a13 1360 XA_BUG_ON(xa, entry != xa_mk_index(i));
64d3e9a9
MW		 1361 else
1362 XA_BUG_ON(xa, entry != NULL);
1363 XA_BUG_ON(xa, i != xas.xa_index);
1364 i++;
1365 } while (i < (1 << 16));
1366 rcu_read_unlock();
1367
1368 xa_destroy(xa);
1369
91abab83 1370 check_move_tiny(xa);
82a22311 1371 check_move_max(xa);
91abab83 1372
64d3e9a9
MW		 1373 for (i = 0; i < 16; i++)
1374 check_move_small(xa, 1UL << i);
1375
1376 for (i = 2; i < 16; i++)
1377 check_move_small(xa, (1UL << i) - 1);
1378}
1379
2264f513
MW		 1380static noinline void xa_store_many_order(struct xarray *xa,
1381 unsigned long index, unsigned order)
1382{
1383 XA_STATE_ORDER(xas, xa, index, order);
1384 unsigned int i = 0;
1385
1386 do {
1387 xas_lock(&xas);
1388 XA_BUG_ON(xa, xas_find_conflict(&xas));
1389 xas_create_range(&xas);
1390 if (xas_error(&xas))
1391 goto unlock;
1392 for (i = 0; i < (1U << order); i++) {
b7677a13 1393 XA_BUG_ON(xa, xas_store(&xas, xa_mk_index(index + i)));
2264f513
MW		 1394 xas_next(&xas);
1395 }
1396unlock:
1397 xas_unlock(&xas);
1398 } while (xas_nomem(&xas, GFP_KERNEL));
1399
1400 XA_BUG_ON(xa, xas_error(&xas));
1401}
1402
1403static noinline void check_create_range_1(struct xarray *xa,
1404 unsigned long index, unsigned order)
1405{
1406 unsigned long i;
1407
1408 xa_store_many_order(xa, index, order);
1409 for (i = index; i < index + (1UL << order); i++)
1410 xa_erase_index(xa, i);
1411 XA_BUG_ON(xa, !xa_empty(xa));
1412}
1413
1414static noinline void check_create_range_2(struct xarray *xa, unsigned order)
1415{
1416 unsigned long i;
1417 unsigned long nr = 1UL << order;
1418
1419 for (i = 0; i < nr * nr; i += nr)
1420 xa_store_many_order(xa, i, order);
1421 for (i = 0; i < nr * nr; i++)
1422 xa_erase_index(xa, i);
1423 XA_BUG_ON(xa, !xa_empty(xa));
1424}
1425
1426static noinline void check_create_range_3(void)
1427{
1428 XA_STATE(xas, NULL, 0);
1429 xas_set_err(&xas, -EEXIST);
1430 xas_create_range(&xas);
1431 XA_BUG_ON(NULL, xas_error(&xas) != -EEXIST);
1432}
1433
1434static noinline void check_create_range_4(struct xarray *xa,
1435 unsigned long index, unsigned order)
1436{
1437 XA_STATE_ORDER(xas, xa, index, order);
1438 unsigned long base = xas.xa_index;
1439 unsigned long i = 0;
1440
1441 xa_store_index(xa, index, GFP_KERNEL);
1442 do {
1443 xas_lock(&xas);
1444 xas_create_range(&xas);
1445 if (xas_error(&xas))
1446 goto unlock;
1447 for (i = 0; i < (1UL << order); i++) {
b7677a13 1448 void *old = xas_store(&xas, xa_mk_index(base + i));
2264f513 1449 if (xas.xa_index == index)
b7677a13 1450 XA_BUG_ON(xa, old != xa_mk_index(base + i));
2264f513
MW		 1451 else
1452 XA_BUG_ON(xa, old != NULL);
1453 xas_next(&xas);
1454 }
1455unlock:
1456 xas_unlock(&xas);
1457 } while (xas_nomem(&xas, GFP_KERNEL));
1458
1459 XA_BUG_ON(xa, xas_error(&xas));
1460
1461 for (i = base; i < base + (1UL << order); i++)
1462 xa_erase_index(xa, i);
1463 XA_BUG_ON(xa, !xa_empty(xa));
1464}
1465
3e3c6580
MWO		 1466static noinline void check_create_range_5(struct xarray *xa,
1467 unsigned long index, unsigned int order)
1468{
1469 XA_STATE_ORDER(xas, xa, index, order);
1470 unsigned int i;
1471
1472 xa_store_order(xa, index, order, xa_mk_index(index), GFP_KERNEL);
1473
1474 for (i = 0; i < order + 10; i++) {
1475 do {
1476 xas_lock(&xas);
1477 xas_create_range(&xas);
1478 xas_unlock(&xas);
1479 } while (xas_nomem(&xas, GFP_KERNEL));
1480 }
1481
1482 xa_destroy(xa);
1483}
1484
2264f513
MW		 1485static noinline void check_create_range(struct xarray *xa)
1486{
1487 unsigned int order;
1488 unsigned int max_order = IS_ENABLED(CONFIG_XARRAY_MULTI) ? 12 : 1;
1489
1490 for (order = 0; order < max_order; order++) {
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);
1496 if (order < 10)
1497 check_create_range_2(xa, order);
1498
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);
1504
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);
3e3c6580
MWO		 1512
1513 check_create_range_5(xa, 0, order);
1514 check_create_range_5(xa, (1U << order), order);
2264f513
MW		 1515 }
1516
1517 check_create_range_3();
1518}
1519
0e9446c3
MW		 1520static noinline void __check_store_range(struct xarray *xa, unsigned long first,
1521 unsigned long last)
1522{
1523#ifdef CONFIG_XARRAY_MULTI
b7677a13 1524 xa_store_range(xa, first, last, xa_mk_index(first), GFP_KERNEL);
0e9446c3 1525
b7677a13
MW		 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));
0e9446c3
MW		 1528 XA_BUG_ON(xa, xa_load(xa, first - 1) != NULL);
1529 XA_BUG_ON(xa, xa_load(xa, last + 1) != NULL);
1530
1531 xa_store_range(xa, first, last, NULL, GFP_KERNEL);
1532#endif
1533
1534 XA_BUG_ON(xa, !xa_empty(xa));
1535}
1536
1537static noinline void check_store_range(struct xarray *xa)
1538{
1539 unsigned long i, j;
1540
1541 for (i = 0; i < 128; i++) {
1542 for (j = i; j < 128; j++) {
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);
5404a7f1 1548 __check_store_range(xa, (1 << 24) + i, (1 << 24) + j);
0e9446c3
MW		 1549 }
1550 }
1551}
1552
8fc75643
MWO		 1553#ifdef CONFIG_XARRAY_MULTI
1554static void check_split_1(struct xarray *xa, unsigned long index,
3012110d 1555 unsigned int order, unsigned int new_order)
8fc75643 1556{
3012110d
MWO		 1557 XA_STATE_ORDER(xas, xa, index, new_order);
1558 unsigned int i;
8fc75643
MWO		 1559
1560 xa_store_order(xa, index, order, xa, GFP_KERNEL);
1561
1562 xas_split_alloc(&xas, xa, order, GFP_KERNEL);
1563 xas_lock(&xas);
1564 xas_split(&xas, xa, order);
3012110d
MWO		 1565 for (i = 0; i < (1 << order); i += (1 << new_order))
1566 __xa_store(xa, index + i, xa_mk_index(index + i), 0);
8fc75643
MWO		 1567 xas_unlock(&xas);
1568
3012110d
MWO		 1569 for (i = 0; i < (1 << order); i++) {
1570 unsigned int val = index + (i & ~((1 << new_order) - 1));
1571 XA_BUG_ON(xa, xa_load(xa, index + i) != xa_mk_index(val));
8fc75643 1572 }
8fc75643
MWO		 1573
1574 xa_set_mark(xa, index, XA_MARK_0);
1575 XA_BUG_ON(xa, !xa_get_mark(xa, index, XA_MARK_0));
1576
1577 xa_destroy(xa);
1578}
1579
1580static noinline void check_split(struct xarray *xa)
1581{
3012110d 1582 unsigned int order, new_order;
8fc75643
MWO		 1583
1584 XA_BUG_ON(xa, !xa_empty(xa));
1585
1586 for (order = 1; order < 2 * XA_CHUNK_SHIFT; order++) {
3012110d
MWO		 1587 for (new_order = 0; new_order < order; new_order++) {
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);
1591 }
8fc75643
MWO		 1592 }
1593}
1594#else
1595static void check_split(struct xarray *xa) { }
1596#endif
1597
76b4e529
MW		 1598static void check_align_1(struct xarray *xa, char *name)
1599{
1600 int i;
1601 unsigned int id;
1602 unsigned long index;
1603 void *entry;
1604
1605 for (i = 0; i < 8; i++) {
a3e4d3f9
MW		 1606 XA_BUG_ON(xa, xa_alloc(xa, &id, name + i, xa_limit_32b,
1607 GFP_KERNEL) != 0);
76b4e529
MW		 1608 XA_BUG_ON(xa, id != i);
1609 }
1610 xa_for_each(xa, index, entry)
1611 XA_BUG_ON(xa, xa_is_err(entry));
1612 xa_destroy(xa);
1613}
1614
4a5c8d89
MW		 1615/*
1616 * We should always be able to store without allocating memory after
1617 * reserving a slot.
1618 */
2fbe967b
MW		 1619static void check_align_2(struct xarray *xa, char *name)
1620{
1621 int i;
1622
1623 XA_BUG_ON(xa, !xa_empty(xa));
1624
1625 for (i = 0; i < 8; i++) {
1626 XA_BUG_ON(xa, xa_store(xa, 0, name + i, GFP_KERNEL) != NULL);
1627 xa_erase(xa, 0);
1628 }
1629
4a5c8d89
MW		 1630 for (i = 0; i < 8; i++) {
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);
1634 }
1635
2fbe967b
MW		 1636 XA_BUG_ON(xa, !xa_empty(xa));
1637}
1638
76b4e529
MW		 1639static noinline void check_align(struct xarray *xa)
1640{
1641 char name[] = "Motorola 68000";
1642
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);
2fbe967b 1647 check_align_2(xa, name);
76b4e529
MW		 1648}
1649
a97e7904
MW		 1650static LIST_HEAD(shadow_nodes);
1651
1652static void test_update_node(struct xa_node *node)
1653{
1654 if (node->count && node->count == node->nr_values) {
1655 if (list_empty(&node->private_list))
1656 list_add(&shadow_nodes, &node->private_list);
1657 } else {
1658 if (!list_empty(&node->private_list))
1659 list_del_init(&node->private_list);
1660 }
1661}
1662
1663static noinline void shadow_remove(struct xarray *xa)
1664{
1665 struct xa_node *node;
1666
1667 xa_lock(xa);
1668 while ((node = list_first_entry_or_null(&shadow_nodes,
1669 struct xa_node, private_list))) {
a97e7904
MW		 1670 XA_BUG_ON(xa, node->array != xa);
1671 list_del_init(&node->private_list);
f82cd2f0 1672 xa_delete_node(node, test_update_node);
a97e7904
MW		 1673 }
1674 xa_unlock(xa);
1675}
1676
1677static noinline void check_workingset(struct xarray *xa, unsigned long index)
1678{
1679 XA_STATE(xas, xa, index);
1680 xas_set_update(&xas, test_update_node);
1681
1682 do {
1683 xas_lock(&xas);
1684 xas_store(&xas, xa_mk_value(0));
1685 xas_next(&xas);
1686 xas_store(&xas, xa_mk_value(1));
1687 xas_unlock(&xas);
1688 } while (xas_nomem(&xas, GFP_KERNEL));
1689
1690 XA_BUG_ON(xa, list_empty(&shadow_nodes));
1691
1692 xas_lock(&xas);
1693 xas_next(&xas);
1694 xas_store(&xas, &xas);
1695 XA_BUG_ON(xa, !list_empty(&shadow_nodes));
1696
1697 xas_store(&xas, xa_mk_value(2));
1698 xas_unlock(&xas);
1699 XA_BUG_ON(xa, list_empty(&shadow_nodes));
1700
1701 shadow_remove(xa);
1702 XA_BUG_ON(xa, !list_empty(&shadow_nodes));
1703 XA_BUG_ON(xa, !xa_empty(xa));
1704}
1705
d6427f81
MW		 1706/*
1707 * Check that the pointer / value / sibling entries are accounted the
1708 * way we expect them to be.
1709 */
1710static noinline void check_account(struct xarray *xa)
1711{
1712#ifdef CONFIG_XARRAY_MULTI
1713 unsigned int order;
1714
1715 for (order = 1; order < 12; order++) {
1716 XA_STATE(xas, xa, 1 << order);
1717
1718 xa_store_order(xa, 0, order, xa, GFP_KERNEL);
fffc9a26 1719 rcu_read_lock();
d6427f81
MW		 1720 xas_load(&xas);
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);
fffc9a26 1724 rcu_read_unlock();
d6427f81 1725
b7677a13 1726 xa_store_order(xa, 1 << order, order, xa_mk_index(1UL << order),
d6427f81
MW		 1727 GFP_KERNEL);
1728 XA_BUG_ON(xa, xas.xa_node->count != xas.xa_node->nr_values * 2);
1729
1730 xa_erase(xa, 1 << order);
1731 XA_BUG_ON(xa, xas.xa_node->nr_values != 0);
1732
1733 xa_erase(xa, 0);
1734 XA_BUG_ON(xa, !xa_empty(xa));
1735 }
1736#endif
1737}
1738
57417ceb
MWO		 1739static noinline void check_get_order(struct xarray *xa)
1740{
1741 unsigned int max_order = IS_ENABLED(CONFIG_XARRAY_MULTI) ? 20 : 1;
1742 unsigned int order;
1743 unsigned long i, j;
1744
1745 for (i = 0; i < 3; i++)
1746 XA_BUG_ON(xa, xa_get_order(xa, i) != 0);
1747
1748 for (order = 0; order < max_order; order++) {
1749 for (i = 0; i < 10; i++) {
1750 xa_store_order(xa, i << order, order,
1751 xa_mk_index(i << order), GFP_KERNEL);
1752 for (j = i << order; j < (i + 1) << order; j++)
1753 XA_BUG_ON(xa, xa_get_order(xa, j) != order);
1754 xa_erase(xa, i << order);
1755 }
1756 }
1757}
1758
687149fc
MW		 1759static noinline void check_destroy(struct xarray *xa)
1760{
1761 unsigned long index;
1762
1763 XA_BUG_ON(xa, !xa_empty(xa));
1764
1765 /* Destroying an empty array is a no-op */
1766 xa_destroy(xa);
1767 XA_BUG_ON(xa, !xa_empty(xa));
1768
1769 /* Destroying an array with a single entry */
1770 for (index = 0; index < 1000; index++) {
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));
1775 }
1776
1777 /* Destroying an array with a single entry at ULONG_MAX */
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));
1782
1783#ifdef CONFIG_XARRAY_MULTI
1784 /* Destroying an array with a multi-index entry */
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));
1789#endif
1790}
1791
58d6ea30 1792static DEFINE_XARRAY(array);
ad3d6c72
MW		 1793
1794static int xarray_checks(void)
1795{
58d6ea30 1796 check_xa_err(&array);
b803b428 1797 check_xas_retry(&array);
ad3d6c72 1798 check_xa_load(&array);
9b89a035 1799 check_xa_mark(&array);
58d6ea30 1800 check_xa_shrink(&array);
b803b428 1801 check_xas_erase(&array);
12fd2aee 1802 check_insert(&array);
41aec91f 1803 check_cmpxchg(&array);
9f14d4f1 1804 check_reserve(&array);
b38f6c50 1805 check_reserve(&xa0);
58d6ea30 1806 check_multi_store(&array);
57417ceb 1807 check_get_order(&array);
371c752d 1808 check_xa_alloc();
b803b428 1809 check_find(&array);
e21a2955 1810 check_find_entry(&array);
c36d451a 1811 check_pause(&array);
d6427f81 1812 check_account(&array);
687149fc 1813 check_destroy(&array);
64d3e9a9 1814 check_move(&array);
2264f513 1815 check_create_range(&array);
0e9446c3 1816 check_store_range(&array);
4e99d4e9 1817 check_store_iter(&array);
76b4e529 1818 check_align(&xa0);
8fc75643 1819 check_split(&array);
ad3d6c72 1820
a97e7904
MW		 1821 check_workingset(&array, 0);
1822 check_workingset(&array, 64);
1823 check_workingset(&array, 4096);
1824
ad3d6c72
MW		 1825 printk("XArray: %u of %u tests passed\n", tests_passed, tests_run);
1826 return (tests_run == tests_passed) ? 0 : -EINVAL;
1827}
1828
1829static void xarray_exit(void)
1830{
1831}
1832
1833module_init(xarray_checks);
1834module_exit(xarray_exit);
1835MODULE_AUTHOR("Matthew Wilcox <willy@infradead.org>");
1836MODULE_LICENSE("GPL");
Linux 6.x block layer and io_uring tree(s)