lib/test_xarray.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * test_xarray.c: Test the XArray API
   4  * Copyright (c) 2017-2018 Microsoft Corporation
   5  * Copyright (c) 2019-2020 Oracle
   6  * Author: Matthew Wilcox <willy@infradead.org>
   7  */
   8
   9 #include <linux/xarray.h>
  10 #include <linux/module.h>
  11
  12 static unsigned int tests_run;
  13 static unsigned int tests_passed;
  14
  15 static const unsigned int order_limit =
  16                 IS_ENABLED(CONFIG_XARRAY_MULTI) ? BITS_PER_LONG : 1;
  17
  18 #ifndef XA_DEBUG
  19 # ifdef __KERNEL__
  20 void 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
  35 static void *xa_mk_index(unsigned long index)
  36 {
  37         return xa_mk_value(index & LONG_MAX);
  38 }
  39
  40 static void *xa_store_index(struct xarray *xa, unsigned long index, gfp_t gfp)
  41 {
  42         return xa_store(xa, index, xa_mk_index(index), gfp);
  43 }
  44
  45 static 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
  51 static void xa_alloc_index(struct xarray *xa, unsigned long index, gfp_t gfp)
  52 {
  53         u32 id;
  54
  55         XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(index), xa_limit_32b,
  56                                 gfp) != 0);
  57         XA_BUG_ON(xa, id != index);
  58 }
  59
  60 static void xa_erase_index(struct xarray *xa, unsigned long index)
  61 {
  62         XA_BUG_ON(xa, xa_erase(xa, index) != xa_mk_index(index));
  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  */
  71 static 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
  86 static 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);
 100 }
 101
 102 static 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);
 120         rcu_read_unlock();
 121
 122         XA_BUG_ON(xa, xa_store_index(xa, 1, GFP_KERNEL) != NULL);
 123
 124         rcu_read_lock();
 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) {
 139                 xas_store(&xas, xa_mk_index(xas.xa_index));
 140         }
 141         xas_unlock(&xas);
 142
 143         xa_erase_index(xa, 0);
 144         xa_erase_index(xa, 1);
 145 }
 146
 147 static 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
 175 static noinline void check_xa_mark_1(struct xarray *xa, unsigned long index)
 176 {
 177         unsigned int order;
 178         unsigned int max_order = IS_ENABLED(CONFIG_XARRAY_MULTI) ? 8 : 1;
 179
 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));
 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));
 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),
 218                                 GFP_KERNEL);
 219                 for (i = base; i < next; i++) {
 220                         XA_STATE(xas, xa, i);
 221                         unsigned int seen = 0;
 222                         void *entry;
 223
 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));
 227
 228                         /* We should see two elements in the array */
 229                         rcu_read_lock();
 230                         xas_for_each(&xas, entry, ULONG_MAX)
 231                                 seen++;
 232                         rcu_read_unlock();
 233                         XA_BUG_ON(xa, seen != 2);
 234
 235                         /* One of which is marked */
 236                         xas_set(&xas, 0);
 237                         seen = 0;
 238                         rcu_read_lock();
 239                         xas_for_each_marked(&xas, entry, ULONG_MAX, XA_MARK_0)
 240                                 seen++;
 241                         rcu_read_unlock();
 242                         XA_BUG_ON(xa, seen != 1);
 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));
 252 }
 253
 254 static 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
 292 static 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
 313 static 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);
 319
 320         check_xa_mark_2(xa);
 321         check_xa_mark_3(xa);
 322 }
 323
 324 static noinline void check_xa_shrink(struct xarray *xa)
 325 {
 326         XA_STATE(xas, xa, 1);
 327         struct xa_node *node;
 328         unsigned int order;
 329         unsigned int max_order = IS_ENABLED(CONFIG_XARRAY_MULTI) ? 15 : 1;
 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));
 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         }
 371 }
 372
 373 static 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
 404 static 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);
 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));
 424 }
 425
 426 static noinline void check_reserve(struct xarray *xa)
 427 {
 428         void *entry;
 429         unsigned long index;
 430         int count;
 431
 432         /* An array with a reserved entry is not empty */
 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));
 439
 440         /* Releasing a used entry does nothing */
 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));
 446
 447         /* cmpxchg sees a reserved entry as ZERO */
 448         XA_BUG_ON(xa, xa_reserve(xa, 12345678, GFP_KERNEL) != 0);
 449         XA_BUG_ON(xa, xa_cmpxchg(xa, 12345678, XA_ZERO_ENTRY,
 450                                 xa_mk_value(12345678), GFP_NOWAIT) != NULL);
 451         xa_release(xa, 12345678);
 452         xa_erase_index(xa, 12345678);
 453         XA_BUG_ON(xa, !xa_empty(xa));
 454
 455         /* xa_insert treats it as busy */
 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) !=
 458                         -EBUSY);
 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));
 462
 463         /* Can iterate through a reserved entry */
 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);
 467
 468         count = 0;
 469         xa_for_each(xa, index, entry) {
 470                 XA_BUG_ON(xa, index != 5 && index != 7);
 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);
 487         }
 488
 489         xa_destroy(xa);
 490 }
 491
 492 static 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);
 503                                 xas_store(&xas, xa_mk_index(j));
 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) {
 521                         XA_BUG_ON(xa, entry != xa_mk_index(j));
 522                         xas_store(&xas, NULL);
 523                         j++;
 524                 }
 525                 xas_unlock(&xas);
 526                 XA_BUG_ON(xa, !xa_empty(xa));
 527         }
 528 }
 529
 530 #ifdef CONFIG_XARRAY_MULTI
 531 static 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
 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);
 543
 544         xas_lock(&xas);
 545         XA_BUG_ON(xa, xas_store(&xas, xa_mk_index(min)) != xa_mk_index(index));
 546         xas_unlock(&xas);
 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);
 551
 552         xa_erase_index(xa, min);
 553         XA_BUG_ON(xa, !xa_empty(xa));
 554 }
 555
 556 static 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
 562         xas_lock(&xas);
 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));
 566         xas_unlock(&xas);
 567         XA_BUG_ON(xa, !xa_empty(xa));
 568 }
 569
 570 static 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 }
 595 #endif
 596
 597 static 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 */
 636         xa_store_order(xa, 0, BITS_PER_LONG - 1, NULL, GFP_KERNEL);
 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++) {
 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);
 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
 655                                         XA_BUG_ON(xa, entry != xa_mk_index(j));
 656                         }
 657
 658                         xa_erase(xa, 0);
 659                         XA_BUG_ON(xa, !xa_empty(xa));
 660                 }
 661         }
 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);
 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         }
 674 #endif
 675 }
 676
 677 static noinline void check_xa_alloc_1(struct xarray *xa, unsigned int base)
 678 {
 679         int i;
 680         u32 id;
 681
 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);
 685
 686         /* Erasing it should make the array empty again */
 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);
 702
 703         /* And it should assign %base again */
 704         xa_alloc_index(xa, base, GFP_KERNEL);
 705
 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);
 709
 710         /* Storing a value should mark it used */
 711         xa_store_index(xa, base + 1, GFP_KERNEL);
 712         xa_alloc_index(xa, base + 2, GFP_KERNEL);
 713
 714         /* If we then erase base, it should be free */
 715         xa_erase_index(xa, base);
 716         xa_alloc_index(xa, base, GFP_KERNEL);
 717
 718         xa_erase_index(xa, base + 1);
 719         xa_erase_index(xa, base + 2);
 720
 721         for (i = 1; i < 5000; i++) {
 722                 xa_alloc_index(xa, base + i, GFP_KERNEL);
 723         }
 724
 725         xa_destroy(xa);
 726
 727         /* Check that we fail properly at the limit of allocation */
 728         XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(UINT_MAX - 1),
 729                                 XA_LIMIT(UINT_MAX - 1, UINT_MAX),
 730                                 GFP_KERNEL) != 0);
 731         XA_BUG_ON(xa, id != 0xfffffffeU);
 732         XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(UINT_MAX),
 733                                 XA_LIMIT(UINT_MAX - 1, UINT_MAX),
 734                                 GFP_KERNEL) != 0);
 735         XA_BUG_ON(xa, id != 0xffffffffU);
 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);
 741         xa_destroy(xa);
 742
 743         XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(10), XA_LIMIT(10, 5),
 744                                 GFP_KERNEL) != -EBUSY);
 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),
 747                                 GFP_KERNEL) != -EBUSY);
 748         xa_erase_index(xa, 3);
 749         XA_BUG_ON(xa, !xa_empty(xa));
 750 }
 751
 752 static 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
 803 static 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
 854 static DEFINE_XARRAY_ALLOC(xa0);
 855 static DEFINE_XARRAY_ALLOC1(xa1);
 856
 857 static noinline void check_xa_alloc(void)
 858 {
 859         check_xa_alloc_1(&xa0, 0);
 860         check_xa_alloc_1(&xa1, 1);
 861         check_xa_alloc_2(&xa0, 0);
 862         check_xa_alloc_2(&xa1, 1);
 863         check_xa_alloc_3(&xa0, 0);
 864         check_xa_alloc_3(&xa1, 1);
 865 }
 866
 867 static 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
 874 retry:
 875         xas_lock(&xas);
 876         xas_for_each_conflict(&xas, entry) {
 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));
 880                 count++;
 881         }
 882         xas_store(&xas, xa_mk_index(start));
 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);
 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) !=
 892                         xa_mk_index(start));
 893         xa_erase_index(xa, start);
 894 }
 895
 896 static 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
 934 static noinline void check_multi_find_1(struct xarray *xa, unsigned order)
 935 {
 936 #ifdef CONFIG_XARRAY_MULTI
 937         unsigned long multi = 3 << order;
 938         unsigned long next = 4 << order;
 939         unsigned long index;
 940
 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);
 944
 945         index = 0;
 946         XA_BUG_ON(xa, xa_find(xa, &index, ULONG_MAX, XA_PRESENT) !=
 947                         xa_mk_value(multi));
 948         XA_BUG_ON(xa, index != multi);
 949         index = multi + 1;
 950         XA_BUG_ON(xa, xa_find(xa, &index, ULONG_MAX, XA_PRESENT) !=
 951                         xa_mk_value(multi));
 952         XA_BUG_ON(xa, (index < multi) || (index >= next));
 953         XA_BUG_ON(xa, xa_find_after(xa, &index, ULONG_MAX, XA_PRESENT) !=
 954                         xa_mk_value(next));
 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);
 958
 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));
 963 #endif
 964 }
 965
 966 static 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);
 977                         xa_store_order(xa, index, i, xa_mk_index(index),
 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
 990 static 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
1004 static noinline void check_find_1(struct xarray *xa)
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));
1050 }
1051
1052 static noinline void check_find_2(struct xarray *xa)
1053 {
1054         void *entry;
1055         unsigned long i, j, index;
1056
1057         xa_for_each(xa, index, entry) {
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;
1064                 xa_for_each(xa, index, entry) {
1065                         XA_BUG_ON(xa, xa_mk_index(index) != entry);
1066                         XA_BUG_ON(xa, index != j++);
1067                 }
1068         }
1069
1070         xa_destroy(xa);
1071 }
1072
1073 static 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++) {
1081                         rcu_read_lock();
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                         }
1090                         rcu_read_unlock();
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
1098 static 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
1114 static noinline void check_find(struct xarray *xa)
1115 {
1116         unsigned i;
1117
1118         check_find_1(xa);
1119         check_find_2(xa);
1120         check_find_3(xa);
1121         check_find_4(xa);
1122
1123         for (i = 2; i < 10; i++)
1124                 check_multi_find_1(xa, i);
1125         check_multi_find_2(xa);
1126         check_multi_find_3(xa);
1127 }
1128
1129 /* See find_swap_entry() in mm/shmem.c */
1130 static 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
1152 static 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,
1164                                                 xa_mk_index(index), GFP_KERNEL);
1165                                 XA_BUG_ON(xa, xa_load(xa, index) !=
1166                                                 xa_mk_index(index));
1167                                 XA_BUG_ON(xa, xa_find_entry(xa,
1168                                                 xa_mk_index(index)) != index);
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);
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));
1182 }
1183
1184 static 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
1220 static 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
1242 static 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
1263 static 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)
1278                         XA_BUG_ON(xa, entry != xa_mk_index(i));
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)
1292                         XA_BUG_ON(xa, entry != xa_mk_index(i));
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
1311 static 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--;
1323                 XA_BUG_ON(xa, entry != xa_mk_index(i));
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);
1332                 XA_BUG_ON(xa, entry != xa_mk_index(i));
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)))
1348                         XA_BUG_ON(xa, entry != xa_mk_index(i));
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)))
1360                         XA_BUG_ON(xa, entry != xa_mk_index(i));
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
1370         check_move_tiny(xa);
1371         check_move_max(xa);
1372
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
1380 static 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++) {
1393                         XA_BUG_ON(xa, xas_store(&xas, xa_mk_index(index + i)));
1394                         xas_next(&xas);
1395                 }
1396 unlock:
1397                 xas_unlock(&xas);
1398         } while (xas_nomem(&xas, GFP_KERNEL));
1399
1400         XA_BUG_ON(xa, xas_error(&xas));
1401 }
1402
1403 static 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
1414 static 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
1426 static 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
1434 static 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++) {
1448                         void *old = xas_store(&xas, xa_mk_index(base + i));
1449                         if (xas.xa_index == index)
1450                                 XA_BUG_ON(xa, old != xa_mk_index(base + i));
1451                         else
1452                                 XA_BUG_ON(xa, old != NULL);
1453                         xas_next(&xas);
1454                 }
1455 unlock:
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
1466 static 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
1485 static 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);
1512
1513                 check_create_range_5(xa, 0, order);
1514                 check_create_range_5(xa, (1U << order), order);
1515         }
1516
1517         check_create_range_3();
1518 }
1519
1520 static noinline void __check_store_range(struct xarray *xa, unsigned long first,
1521                 unsigned long last)
1522 {
1523 #ifdef CONFIG_XARRAY_MULTI
1524         xa_store_range(xa, first, last, xa_mk_index(first), GFP_KERNEL);
1525
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);
1530
1531         xa_store_range(xa, first, last, NULL, GFP_KERNEL);
1532 #endif
1533
1534         XA_BUG_ON(xa, !xa_empty(xa));
1535 }
1536
1537 static 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);
1548                         __check_store_range(xa, (1 << 24) + i, (1 << 24) + j);
1549                 }
1550         }
1551 }
1552
1553 #ifdef CONFIG_XARRAY_MULTI
1554 static void check_split_1(struct xarray *xa, unsigned long index,
1555                                 unsigned int order, unsigned int new_order)
1556 {
1557         XA_STATE_ORDER(xas, xa, index, new_order);
1558         unsigned int i;
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);
1565         for (i = 0; i < (1 << order); i += (1 << new_order))
1566                 __xa_store(xa, index + i, xa_mk_index(index + i), 0);
1567         xas_unlock(&xas);
1568
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));
1572         }
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
1580 static noinline void check_split(struct xarray *xa)
1581 {
1582         unsigned int order, new_order;
1583
1584         XA_BUG_ON(xa, !xa_empty(xa));
1585
1586         for (order = 1; order < 2 * XA_CHUNK_SHIFT; order++) {
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                 }
1592         }
1593 }
1594 #else
1595 static void check_split(struct xarray *xa) { }
1596 #endif
1597
1598 static 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++) {
1606                 XA_BUG_ON(xa, xa_alloc(xa, &id, name + i, xa_limit_32b,
1607                                         GFP_KERNEL) != 0);
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
1615 /*
1616  * We should always be able to store without allocating memory after
1617  * reserving a slot.
1618  */
1619 static 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
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
1636         XA_BUG_ON(xa, !xa_empty(xa));
1637 }
1638
1639 static 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);
1647         check_align_2(xa, name);
1648 }
1649
1650 static LIST_HEAD(shadow_nodes);
1651
1652 static 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
1663 static 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))) {
1670                 XA_BUG_ON(xa, node->array != xa);
1671                 list_del_init(&node->private_list);
1672                 xa_delete_node(node, test_update_node);
1673         }
1674         xa_unlock(xa);
1675 }
1676
1677 static 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
1706 /*
1707  * Check that the pointer / value / sibling entries are accounted the
1708  * way we expect them to be.
1709  */
1710 static 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);
1719                 rcu_read_lock();
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);
1724                 rcu_read_unlock();
1725
1726                 xa_store_order(xa, 1 << order, order, xa_mk_index(1UL << order),
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
1739 static 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
1759 static 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
1792 static DEFINE_XARRAY(array);
1793
1794 static int xarray_checks(void)
1795 {
1796         check_xa_err(&array);
1797         check_xas_retry(&array);
1798         check_xa_load(&array);
1799         check_xa_mark(&array);
1800         check_xa_shrink(&array);
1801         check_xas_erase(&array);
1802         check_insert(&array);
1803         check_cmpxchg(&array);
1804         check_reserve(&array);
1805         check_reserve(&xa0);
1806         check_multi_store(&array);
1807         check_get_order(&array);
1808         check_xa_alloc();
1809         check_find(&array);
1810         check_find_entry(&array);
1811         check_pause(&array);
1812         check_account(&array);
1813         check_destroy(&array);
1814         check_move(&array);
1815         check_create_range(&array);
1816         check_store_range(&array);
1817         check_store_iter(&array);
1818         check_align(&xa0);
1819         check_split(&array);
1820
1821         check_workingset(&array, 0);
1822         check_workingset(&array, 64);
1823         check_workingset(&array, 4096);
1824
1825         printk("XArray: %u of %u tests passed\n", tests_passed, tests_run);
1826         return (tests_run == tests_passed) ? 0 : -EINVAL;
1827 }
1828
1829 static void xarray_exit(void)
1830 {
1831 }
1832
1833 module_init(xarray_checks);
1834 module_exit(xarray_exit);
1835 MODULE_AUTHOR("Matthew Wilcox <willy@infradead.org>");
1836 MODULE_LICENSE("GPL");