lib/test_xarray.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
IS_ENABLED
xa_mk_index
xa_store_index
xa_insert_index
xa_alloc_index
xa_erase_index
xa_store_order
check_xa_err
check_xas_retry
check_xa_load
check_xa_mark_1
check_xa_mark_2
check_xa_mark
check_xa_shrink
check_insert
check_cmpxchg
check_reserve
check_xas_erase
check_multi_store_1
check_multi_store_2
check_multi_store_3
check_multi_store
check_xa_alloc_1
check_xa_alloc_2
check_xa_alloc_3
check_xa_alloc
__check_store_iter
check_store_iter
check_multi_find_1
check_multi_find_2
check_multi_find_3
check_find_1
check_find_2
check_find_3
check_find_4
check_find
xa_find_entry
check_find_entry
check_pause
check_move_tiny
check_move_max
check_move_small
check_move
xa_store_many_order
check_create_range_1
check_create_range_2
check_create_range_3
check_create_range_4
check_create_range
__check_store_range
check_store_range
check_align_1
check_align_2
check_align
test_update_node
shadow_remove
check_workingset
check_account
check_destroy
xarray_checks
xarray_exit
   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(struct xarray *xa)
 293 {
 294         unsigned long index;
 295 
 296         for (index = 0; index < 16384; index += 4)
 297                 check_xa_mark_1(xa, index);
 298 
 299         check_xa_mark_2(xa);
 300 }
 301 
 302 static noinline void check_xa_shrink(struct xarray *xa)
 303 {
 304         XA_STATE(xas, xa, 1);
 305         struct xa_node *node;
 306         unsigned int order;
 307         unsigned int max_order = IS_ENABLED(CONFIG_XARRAY_MULTI) ? 15 : 1;
 308 
 309         XA_BUG_ON(xa, !xa_empty(xa));
 310         XA_BUG_ON(xa, xa_store_index(xa, 0, GFP_KERNEL) != NULL);
 311         XA_BUG_ON(xa, xa_store_index(xa, 1, GFP_KERNEL) != NULL);
 312 
 313         /*
 314          * Check that erasing the entry at 1 shrinks the tree and properly
 315          * marks the node as being deleted.
 316          */
 317         xas_lock(&xas);
 318         XA_BUG_ON(xa, xas_load(&xas) != xa_mk_value(1));
 319         node = xas.xa_node;
 320         XA_BUG_ON(xa, xa_entry_locked(xa, node, 0) != xa_mk_value(0));
 321         XA_BUG_ON(xa, xas_store(&xas, NULL) != xa_mk_value(1));
 322         XA_BUG_ON(xa, xa_load(xa, 1) != NULL);
 323         XA_BUG_ON(xa, xas.xa_node != XAS_BOUNDS);
 324         XA_BUG_ON(xa, xa_entry_locked(xa, node, 0) != XA_RETRY_ENTRY);
 325         XA_BUG_ON(xa, xas_load(&xas) != NULL);
 326         xas_unlock(&xas);
 327         XA_BUG_ON(xa, xa_load(xa, 0) != xa_mk_value(0));
 328         xa_erase_index(xa, 0);
 329         XA_BUG_ON(xa, !xa_empty(xa));
 330 
 331         for (order = 0; order < max_order; order++) {
 332                 unsigned long max = (1UL << order) - 1;
 333                 xa_store_order(xa, 0, order, xa_mk_value(0), GFP_KERNEL);
 334                 XA_BUG_ON(xa, xa_load(xa, max) != xa_mk_value(0));
 335                 XA_BUG_ON(xa, xa_load(xa, max + 1) != NULL);
 336                 rcu_read_lock();
 337                 node = xa_head(xa);
 338                 rcu_read_unlock();
 339                 XA_BUG_ON(xa, xa_store_index(xa, ULONG_MAX, GFP_KERNEL) !=
 340                                 NULL);
 341                 rcu_read_lock();
 342                 XA_BUG_ON(xa, xa_head(xa) == node);
 343                 rcu_read_unlock();
 344                 XA_BUG_ON(xa, xa_load(xa, max + 1) != NULL);
 345                 xa_erase_index(xa, ULONG_MAX);
 346                 XA_BUG_ON(xa, xa->xa_head != node);
 347                 xa_erase_index(xa, 0);
 348         }
 349 }
 350 
 351 static noinline void check_insert(struct xarray *xa)
 352 {
 353         unsigned long i;
 354 
 355         for (i = 0; i < 1024; i++) {
 356                 xa_insert_index(xa, i);
 357                 XA_BUG_ON(xa, xa_load(xa, i - 1) != NULL);
 358                 XA_BUG_ON(xa, xa_load(xa, i + 1) != NULL);
 359                 xa_erase_index(xa, i);
 360         }
 361 
 362         for (i = 10; i < BITS_PER_LONG; i++) {
 363                 xa_insert_index(xa, 1UL << i);
 364                 XA_BUG_ON(xa, xa_load(xa, (1UL << i) - 1) != NULL);
 365                 XA_BUG_ON(xa, xa_load(xa, (1UL << i) + 1) != NULL);
 366                 xa_erase_index(xa, 1UL << i);
 367 
 368                 xa_insert_index(xa, (1UL << i) - 1);
 369                 XA_BUG_ON(xa, xa_load(xa, (1UL << i) - 2) != NULL);
 370                 XA_BUG_ON(xa, xa_load(xa, 1UL << i) != NULL);
 371                 xa_erase_index(xa, (1UL << i) - 1);
 372         }
 373 
 374         xa_insert_index(xa, ~0UL);
 375         XA_BUG_ON(xa, xa_load(xa, 0UL) != NULL);
 376         XA_BUG_ON(xa, xa_load(xa, ~1UL) != NULL);
 377         xa_erase_index(xa, ~0UL);
 378 
 379         XA_BUG_ON(xa, !xa_empty(xa));
 380 }
 381 
 382 static noinline void check_cmpxchg(struct xarray *xa)
 383 {
 384         void *FIVE = xa_mk_value(5);
 385         void *SIX = xa_mk_value(6);
 386         void *LOTS = xa_mk_value(12345678);
 387 
 388         XA_BUG_ON(xa, !xa_empty(xa));
 389         XA_BUG_ON(xa, xa_store_index(xa, 12345678, GFP_KERNEL) != NULL);
 390         XA_BUG_ON(xa, xa_insert(xa, 12345678, xa, GFP_KERNEL) != -EBUSY);
 391         XA_BUG_ON(xa, xa_cmpxchg(xa, 12345678, SIX, FIVE, GFP_KERNEL) != LOTS);
 392         XA_BUG_ON(xa, xa_cmpxchg(xa, 12345678, LOTS, FIVE, GFP_KERNEL) != LOTS);
 393         XA_BUG_ON(xa, xa_cmpxchg(xa, 12345678, FIVE, LOTS, GFP_KERNEL) != FIVE);
 394         XA_BUG_ON(xa, xa_cmpxchg(xa, 5, FIVE, NULL, GFP_KERNEL) != NULL);
 395         XA_BUG_ON(xa, xa_cmpxchg(xa, 5, NULL, FIVE, GFP_KERNEL) != NULL);
 396         xa_erase_index(xa, 12345678);
 397         xa_erase_index(xa, 5);
 398         XA_BUG_ON(xa, !xa_empty(xa));
 399 }
 400 
 401 static noinline void check_reserve(struct xarray *xa)
 402 {
 403         void *entry;
 404         unsigned long index;
 405         int count;
 406 
 407         /* An array with a reserved entry is not empty */
 408         XA_BUG_ON(xa, !xa_empty(xa));
 409         XA_BUG_ON(xa, xa_reserve(xa, 12345678, GFP_KERNEL) != 0);
 410         XA_BUG_ON(xa, xa_empty(xa));
 411         XA_BUG_ON(xa, xa_load(xa, 12345678));
 412         xa_release(xa, 12345678);
 413         XA_BUG_ON(xa, !xa_empty(xa));
 414 
 415         /* Releasing a used entry does nothing */
 416         XA_BUG_ON(xa, xa_reserve(xa, 12345678, GFP_KERNEL) != 0);
 417         XA_BUG_ON(xa, xa_store_index(xa, 12345678, GFP_NOWAIT) != NULL);
 418         xa_release(xa, 12345678);
 419         xa_erase_index(xa, 12345678);
 420         XA_BUG_ON(xa, !xa_empty(xa));
 421 
 422         /* cmpxchg sees a reserved entry as ZERO */
 423         XA_BUG_ON(xa, xa_reserve(xa, 12345678, GFP_KERNEL) != 0);
 424         XA_BUG_ON(xa, xa_cmpxchg(xa, 12345678, XA_ZERO_ENTRY,
 425                                 xa_mk_value(12345678), GFP_NOWAIT) != NULL);
 426         xa_release(xa, 12345678);
 427         xa_erase_index(xa, 12345678);
 428         XA_BUG_ON(xa, !xa_empty(xa));
 429 
 430         /* xa_insert treats it as busy */
 431         XA_BUG_ON(xa, xa_reserve(xa, 12345678, GFP_KERNEL) != 0);
 432         XA_BUG_ON(xa, xa_insert(xa, 12345678, xa_mk_value(12345678), 0) !=
 433                         -EBUSY);
 434         XA_BUG_ON(xa, xa_empty(xa));
 435         XA_BUG_ON(xa, xa_erase(xa, 12345678) != NULL);
 436         XA_BUG_ON(xa, !xa_empty(xa));
 437 
 438         /* Can iterate through a reserved entry */
 439         xa_store_index(xa, 5, GFP_KERNEL);
 440         XA_BUG_ON(xa, xa_reserve(xa, 6, GFP_KERNEL) != 0);
 441         xa_store_index(xa, 7, GFP_KERNEL);
 442 
 443         count = 0;
 444         xa_for_each(xa, index, entry) {
 445                 XA_BUG_ON(xa, index != 5 && index != 7);
 446                 count++;
 447         }
 448         XA_BUG_ON(xa, count != 2);
 449 
 450         /* If we free a reserved entry, we should be able to allocate it */
 451         if (xa->xa_flags & XA_FLAGS_ALLOC) {
 452                 u32 id;
 453 
 454                 XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_value(8),
 455                                         XA_LIMIT(5, 10), GFP_KERNEL) != 0);
 456                 XA_BUG_ON(xa, id != 8);
 457 
 458                 xa_release(xa, 6);
 459                 XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_value(6),
 460                                         XA_LIMIT(5, 10), GFP_KERNEL) != 0);
 461                 XA_BUG_ON(xa, id != 6);
 462         }
 463 
 464         xa_destroy(xa);
 465 }
 466 
 467 static noinline void check_xas_erase(struct xarray *xa)
 468 {
 469         XA_STATE(xas, xa, 0);
 470         void *entry;
 471         unsigned long i, j;
 472 
 473         for (i = 0; i < 200; i++) {
 474                 for (j = i; j < 2 * i + 17; j++) {
 475                         xas_set(&xas, j);
 476                         do {
 477                                 xas_lock(&xas);
 478                                 xas_store(&xas, xa_mk_index(j));
 479                                 xas_unlock(&xas);
 480                         } while (xas_nomem(&xas, GFP_KERNEL));
 481                 }
 482 
 483                 xas_set(&xas, ULONG_MAX);
 484                 do {
 485                         xas_lock(&xas);
 486                         xas_store(&xas, xa_mk_value(0));
 487                         xas_unlock(&xas);
 488                 } while (xas_nomem(&xas, GFP_KERNEL));
 489 
 490                 xas_lock(&xas);
 491                 xas_store(&xas, NULL);
 492 
 493                 xas_set(&xas, 0);
 494                 j = i;
 495                 xas_for_each(&xas, entry, ULONG_MAX) {
 496                         XA_BUG_ON(xa, entry != xa_mk_index(j));
 497                         xas_store(&xas, NULL);
 498                         j++;
 499                 }
 500                 xas_unlock(&xas);
 501                 XA_BUG_ON(xa, !xa_empty(xa));
 502         }
 503 }
 504 
 505 #ifdef CONFIG_XARRAY_MULTI
 506 static noinline void check_multi_store_1(struct xarray *xa, unsigned long index,
 507                 unsigned int order)
 508 {
 509         XA_STATE(xas, xa, index);
 510         unsigned long min = index & ~((1UL << order) - 1);
 511         unsigned long max = min + (1UL << order);
 512 
 513         xa_store_order(xa, index, order, xa_mk_index(index), GFP_KERNEL);
 514         XA_BUG_ON(xa, xa_load(xa, min) != xa_mk_index(index));
 515         XA_BUG_ON(xa, xa_load(xa, max - 1) != xa_mk_index(index));
 516         XA_BUG_ON(xa, xa_load(xa, max) != NULL);
 517         XA_BUG_ON(xa, xa_load(xa, min - 1) != NULL);
 518 
 519         xas_lock(&xas);
 520         XA_BUG_ON(xa, xas_store(&xas, xa_mk_index(min)) != xa_mk_index(index));
 521         xas_unlock(&xas);
 522         XA_BUG_ON(xa, xa_load(xa, min) != xa_mk_index(min));
 523         XA_BUG_ON(xa, xa_load(xa, max - 1) != xa_mk_index(min));
 524         XA_BUG_ON(xa, xa_load(xa, max) != NULL);
 525         XA_BUG_ON(xa, xa_load(xa, min - 1) != NULL);
 526 
 527         xa_erase_index(xa, min);
 528         XA_BUG_ON(xa, !xa_empty(xa));
 529 }
 530 
 531 static noinline void check_multi_store_2(struct xarray *xa, unsigned long index,
 532                 unsigned int order)
 533 {
 534         XA_STATE(xas, xa, index);
 535         xa_store_order(xa, index, order, xa_mk_value(0), GFP_KERNEL);
 536 
 537         xas_lock(&xas);
 538         XA_BUG_ON(xa, xas_store(&xas, xa_mk_value(1)) != xa_mk_value(0));
 539         XA_BUG_ON(xa, xas.xa_index != index);
 540         XA_BUG_ON(xa, xas_store(&xas, NULL) != xa_mk_value(1));
 541         xas_unlock(&xas);
 542         XA_BUG_ON(xa, !xa_empty(xa));
 543 }
 544 
 545 static noinline void check_multi_store_3(struct xarray *xa, unsigned long index,
 546                 unsigned int order)
 547 {
 548         XA_STATE(xas, xa, 0);
 549         void *entry;
 550         int n = 0;
 551 
 552         xa_store_order(xa, index, order, xa_mk_index(index), GFP_KERNEL);
 553 
 554         xas_lock(&xas);
 555         xas_for_each(&xas, entry, ULONG_MAX) {
 556                 XA_BUG_ON(xa, entry != xa_mk_index(index));
 557                 n++;
 558         }
 559         XA_BUG_ON(xa, n != 1);
 560         xas_set(&xas, index + 1);
 561         xas_for_each(&xas, entry, ULONG_MAX) {
 562                 XA_BUG_ON(xa, entry != xa_mk_index(index));
 563                 n++;
 564         }
 565         XA_BUG_ON(xa, n != 2);
 566         xas_unlock(&xas);
 567 
 568         xa_destroy(xa);
 569 }
 570 #endif
 571 
 572 static noinline void check_multi_store(struct xarray *xa)
 573 {
 574 #ifdef CONFIG_XARRAY_MULTI
 575         unsigned long i, j, k;
 576         unsigned int max_order = (sizeof(long) == 4) ? 30 : 60;
 577 
 578         /* Loading from any position returns the same value */
 579         xa_store_order(xa, 0, 1, xa_mk_value(0), GFP_KERNEL);
 580         XA_BUG_ON(xa, xa_load(xa, 0) != xa_mk_value(0));
 581         XA_BUG_ON(xa, xa_load(xa, 1) != xa_mk_value(0));
 582         XA_BUG_ON(xa, xa_load(xa, 2) != NULL);
 583         rcu_read_lock();
 584         XA_BUG_ON(xa, xa_to_node(xa_head(xa))->count != 2);
 585         XA_BUG_ON(xa, xa_to_node(xa_head(xa))->nr_values != 2);
 586         rcu_read_unlock();
 587 
 588         /* Storing adjacent to the value does not alter the value */
 589         xa_store(xa, 3, xa, GFP_KERNEL);
 590         XA_BUG_ON(xa, xa_load(xa, 0) != xa_mk_value(0));
 591         XA_BUG_ON(xa, xa_load(xa, 1) != xa_mk_value(0));
 592         XA_BUG_ON(xa, xa_load(xa, 2) != NULL);
 593         rcu_read_lock();
 594         XA_BUG_ON(xa, xa_to_node(xa_head(xa))->count != 3);
 595         XA_BUG_ON(xa, xa_to_node(xa_head(xa))->nr_values != 2);
 596         rcu_read_unlock();
 597 
 598         /* Overwriting multiple indexes works */
 599         xa_store_order(xa, 0, 2, xa_mk_value(1), GFP_KERNEL);
 600         XA_BUG_ON(xa, xa_load(xa, 0) != xa_mk_value(1));
 601         XA_BUG_ON(xa, xa_load(xa, 1) != xa_mk_value(1));
 602         XA_BUG_ON(xa, xa_load(xa, 2) != xa_mk_value(1));
 603         XA_BUG_ON(xa, xa_load(xa, 3) != xa_mk_value(1));
 604         XA_BUG_ON(xa, xa_load(xa, 4) != NULL);
 605         rcu_read_lock();
 606         XA_BUG_ON(xa, xa_to_node(xa_head(xa))->count != 4);
 607         XA_BUG_ON(xa, xa_to_node(xa_head(xa))->nr_values != 4);
 608         rcu_read_unlock();
 609 
 610         /* We can erase multiple values with a single store */
 611         xa_store_order(xa, 0, BITS_PER_LONG - 1, NULL, GFP_KERNEL);
 612         XA_BUG_ON(xa, !xa_empty(xa));
 613 
 614         /* Even when the first slot is empty but the others aren't */
 615         xa_store_index(xa, 1, GFP_KERNEL);
 616         xa_store_index(xa, 2, GFP_KERNEL);
 617         xa_store_order(xa, 0, 2, NULL, GFP_KERNEL);
 618         XA_BUG_ON(xa, !xa_empty(xa));
 619 
 620         for (i = 0; i < max_order; i++) {
 621                 for (j = 0; j < max_order; j++) {
 622                         xa_store_order(xa, 0, i, xa_mk_index(i), GFP_KERNEL);
 623                         xa_store_order(xa, 0, j, xa_mk_index(j), GFP_KERNEL);
 624 
 625                         for (k = 0; k < max_order; k++) {
 626                                 void *entry = xa_load(xa, (1UL << k) - 1);
 627                                 if ((i < k) && (j < k))
 628                                         XA_BUG_ON(xa, entry != NULL);
 629                                 else
 630                                         XA_BUG_ON(xa, entry != xa_mk_index(j));
 631                         }
 632 
 633                         xa_erase(xa, 0);
 634                         XA_BUG_ON(xa, !xa_empty(xa));
 635                 }
 636         }
 637 
 638         for (i = 0; i < 20; i++) {
 639                 check_multi_store_1(xa, 200, i);
 640                 check_multi_store_1(xa, 0, i);
 641                 check_multi_store_1(xa, (1UL << i) + 1, i);
 642         }
 643         check_multi_store_2(xa, 4095, 9);
 644 
 645         for (i = 1; i < 20; i++) {
 646                 check_multi_store_3(xa, 0, i);
 647                 check_multi_store_3(xa, 1UL << i, i);
 648         }
 649 #endif
 650 }
 651 
 652 static noinline void check_xa_alloc_1(struct xarray *xa, unsigned int base)
 653 {
 654         int i;
 655         u32 id;
 656 
 657         XA_BUG_ON(xa, !xa_empty(xa));
 658         /* An empty array should assign %base to the first alloc */
 659         xa_alloc_index(xa, base, GFP_KERNEL);
 660 
 661         /* Erasing it should make the array empty again */
 662         xa_erase_index(xa, base);
 663         XA_BUG_ON(xa, !xa_empty(xa));
 664 
 665         /* And it should assign %base again */
 666         xa_alloc_index(xa, base, GFP_KERNEL);
 667 
 668         /* Allocating and then erasing a lot should not lose base */
 669         for (i = base + 1; i < 2 * XA_CHUNK_SIZE; i++)
 670                 xa_alloc_index(xa, i, GFP_KERNEL);
 671         for (i = base; i < 2 * XA_CHUNK_SIZE; i++)
 672                 xa_erase_index(xa, i);
 673         xa_alloc_index(xa, base, GFP_KERNEL);
 674 
 675         /* Destroying the array should do the same as erasing */
 676         xa_destroy(xa);
 677 
 678         /* And it should assign %base again */
 679         xa_alloc_index(xa, base, GFP_KERNEL);
 680 
 681         /* The next assigned ID should be base+1 */
 682         xa_alloc_index(xa, base + 1, GFP_KERNEL);
 683         xa_erase_index(xa, base + 1);
 684 
 685         /* Storing a value should mark it used */
 686         xa_store_index(xa, base + 1, GFP_KERNEL);
 687         xa_alloc_index(xa, base + 2, GFP_KERNEL);
 688 
 689         /* If we then erase base, it should be free */
 690         xa_erase_index(xa, base);
 691         xa_alloc_index(xa, base, GFP_KERNEL);
 692 
 693         xa_erase_index(xa, base + 1);
 694         xa_erase_index(xa, base + 2);
 695 
 696         for (i = 1; i < 5000; i++) {
 697                 xa_alloc_index(xa, base + i, GFP_KERNEL);
 698         }
 699 
 700         xa_destroy(xa);
 701 
 702         /* Check that we fail properly at the limit of allocation */
 703         XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(UINT_MAX - 1),
 704                                 XA_LIMIT(UINT_MAX - 1, UINT_MAX),
 705                                 GFP_KERNEL) != 0);
 706         XA_BUG_ON(xa, id != 0xfffffffeU);
 707         XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(UINT_MAX),
 708                                 XA_LIMIT(UINT_MAX - 1, UINT_MAX),
 709                                 GFP_KERNEL) != 0);
 710         XA_BUG_ON(xa, id != 0xffffffffU);
 711         id = 3;
 712         XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(0),
 713                                 XA_LIMIT(UINT_MAX - 1, UINT_MAX),
 714                                 GFP_KERNEL) != -EBUSY);
 715         XA_BUG_ON(xa, id != 3);
 716         xa_destroy(xa);
 717 
 718         XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(10), XA_LIMIT(10, 5),
 719                                 GFP_KERNEL) != -EBUSY);
 720         XA_BUG_ON(xa, xa_store_index(xa, 3, GFP_KERNEL) != 0);
 721         XA_BUG_ON(xa, xa_alloc(xa, &id, xa_mk_index(10), XA_LIMIT(10, 5),
 722                                 GFP_KERNEL) != -EBUSY);
 723         xa_erase_index(xa, 3);
 724         XA_BUG_ON(xa, !xa_empty(xa));
 725 }
 726 
 727 static noinline void check_xa_alloc_2(struct xarray *xa, unsigned int base)
 728 {
 729         unsigned int i, id;
 730         unsigned long index;
 731         void *entry;
 732 
 733         /* Allocate and free a NULL and check xa_empty() behaves */
 734         XA_BUG_ON(xa, !xa_empty(xa));
 735         XA_BUG_ON(xa, xa_alloc(xa, &id, NULL, xa_limit_32b, GFP_KERNEL) != 0);
 736         XA_BUG_ON(xa, id != base);
 737         XA_BUG_ON(xa, xa_empty(xa));
 738         XA_BUG_ON(xa, xa_erase(xa, id) != NULL);
 739         XA_BUG_ON(xa, !xa_empty(xa));
 740 
 741         /* Ditto, but check destroy instead of erase */
 742         XA_BUG_ON(xa, !xa_empty(xa));
 743         XA_BUG_ON(xa, xa_alloc(xa, &id, NULL, xa_limit_32b, GFP_KERNEL) != 0);
 744         XA_BUG_ON(xa, id != base);
 745         XA_BUG_ON(xa, xa_empty(xa));
 746         xa_destroy(xa);
 747         XA_BUG_ON(xa, !xa_empty(xa));
 748 
 749         for (i = base; i < base + 10; i++) {
 750                 XA_BUG_ON(xa, xa_alloc(xa, &id, NULL, xa_limit_32b,
 751                                         GFP_KERNEL) != 0);
 752                 XA_BUG_ON(xa, id != i);
 753         }
 754 
 755         XA_BUG_ON(xa, xa_store(xa, 3, xa_mk_index(3), GFP_KERNEL) != NULL);
 756         XA_BUG_ON(xa, xa_store(xa, 4, xa_mk_index(4), GFP_KERNEL) != NULL);
 757         XA_BUG_ON(xa, xa_store(xa, 4, NULL, GFP_KERNEL) != xa_mk_index(4));
 758         XA_BUG_ON(xa, xa_erase(xa, 5) != NULL);
 759         XA_BUG_ON(xa, xa_alloc(xa, &id, NULL, xa_limit_32b, GFP_KERNEL) != 0);
 760         XA_BUG_ON(xa, id != 5);
 761 
 762         xa_for_each(xa, index, entry) {
 763                 xa_erase_index(xa, index);
 764         }
 765 
 766         for (i = base; i < base + 9; i++) {
 767                 XA_BUG_ON(xa, xa_erase(xa, i) != NULL);
 768                 XA_BUG_ON(xa, xa_empty(xa));
 769         }
 770         XA_BUG_ON(xa, xa_erase(xa, 8) != NULL);
 771         XA_BUG_ON(xa, xa_empty(xa));
 772         XA_BUG_ON(xa, xa_erase(xa, base + 9) != NULL);
 773         XA_BUG_ON(xa, !xa_empty(xa));
 774 
 775         xa_destroy(xa);
 776 }
 777 
 778 static noinline void check_xa_alloc_3(struct xarray *xa, unsigned int base)
 779 {
 780         struct xa_limit limit = XA_LIMIT(1, 0x3fff);
 781         u32 next = 0;
 782         unsigned int i, id;
 783         unsigned long index;
 784         void *entry;
 785 
 786         XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(1), limit,
 787                                 &next, GFP_KERNEL) != 0);
 788         XA_BUG_ON(xa, id != 1);
 789 
 790         next = 0x3ffd;
 791         XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(0x3ffd), limit,
 792                                 &next, GFP_KERNEL) != 0);
 793         XA_BUG_ON(xa, id != 0x3ffd);
 794         xa_erase_index(xa, 0x3ffd);
 795         xa_erase_index(xa, 1);
 796         XA_BUG_ON(xa, !xa_empty(xa));
 797 
 798         for (i = 0x3ffe; i < 0x4003; i++) {
 799                 if (i < 0x4000)
 800                         entry = xa_mk_index(i);
 801                 else
 802                         entry = xa_mk_index(i - 0x3fff);
 803                 XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, entry, limit,
 804                                         &next, GFP_KERNEL) != (id == 1));
 805                 XA_BUG_ON(xa, xa_mk_index(id) != entry);
 806         }
 807 
 808         /* Check wrap-around is handled correctly */
 809         if (base != 0)
 810                 xa_erase_index(xa, base);
 811         xa_erase_index(xa, base + 1);
 812         next = UINT_MAX;
 813         XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(UINT_MAX),
 814                                 xa_limit_32b, &next, GFP_KERNEL) != 0);
 815         XA_BUG_ON(xa, id != UINT_MAX);
 816         XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(base),
 817                                 xa_limit_32b, &next, GFP_KERNEL) != 1);
 818         XA_BUG_ON(xa, id != base);
 819         XA_BUG_ON(xa, xa_alloc_cyclic(xa, &id, xa_mk_index(base + 1),
 820                                 xa_limit_32b, &next, GFP_KERNEL) != 0);
 821         XA_BUG_ON(xa, id != base + 1);
 822 
 823         xa_for_each(xa, index, entry)
 824                 xa_erase_index(xa, index);
 825 
 826         XA_BUG_ON(xa, !xa_empty(xa));
 827 }
 828 
 829 static DEFINE_XARRAY_ALLOC(xa0);
 830 static DEFINE_XARRAY_ALLOC1(xa1);
 831 
 832 static noinline void check_xa_alloc(void)
 833 {
 834         check_xa_alloc_1(&xa0, 0);
 835         check_xa_alloc_1(&xa1, 1);
 836         check_xa_alloc_2(&xa0, 0);
 837         check_xa_alloc_2(&xa1, 1);
 838         check_xa_alloc_3(&xa0, 0);
 839         check_xa_alloc_3(&xa1, 1);
 840 }
 841 
 842 static noinline void __check_store_iter(struct xarray *xa, unsigned long start,
 843                         unsigned int order, unsigned int present)
 844 {
 845         XA_STATE_ORDER(xas, xa, start, order);
 846         void *entry;
 847         unsigned int count = 0;
 848 
 849 retry:
 850         xas_lock(&xas);
 851         xas_for_each_conflict(&xas, entry) {
 852                 XA_BUG_ON(xa, !xa_is_value(entry));
 853                 XA_BUG_ON(xa, entry < xa_mk_index(start));
 854                 XA_BUG_ON(xa, entry > xa_mk_index(start + (1UL << order) - 1));
 855                 count++;
 856         }
 857         xas_store(&xas, xa_mk_index(start));
 858         xas_unlock(&xas);
 859         if (xas_nomem(&xas, GFP_KERNEL)) {
 860                 count = 0;
 861                 goto retry;
 862         }
 863         XA_BUG_ON(xa, xas_error(&xas));
 864         XA_BUG_ON(xa, count != present);
 865         XA_BUG_ON(xa, xa_load(xa, start) != xa_mk_index(start));
 866         XA_BUG_ON(xa, xa_load(xa, start + (1UL << order) - 1) !=
 867                         xa_mk_index(start));
 868         xa_erase_index(xa, start);
 869 }
 870 
 871 static noinline void check_store_iter(struct xarray *xa)
 872 {
 873         unsigned int i, j;
 874         unsigned int max_order = IS_ENABLED(CONFIG_XARRAY_MULTI) ? 20 : 1;
 875 
 876         for (i = 0; i < max_order; i++) {
 877                 unsigned int min = 1 << i;
 878                 unsigned int max = (2 << i) - 1;
 879                 __check_store_iter(xa, 0, i, 0);
 880                 XA_BUG_ON(xa, !xa_empty(xa));
 881                 __check_store_iter(xa, min, i, 0);
 882                 XA_BUG_ON(xa, !xa_empty(xa));
 883 
 884                 xa_store_index(xa, min, GFP_KERNEL);
 885                 __check_store_iter(xa, min, i, 1);
 886                 XA_BUG_ON(xa, !xa_empty(xa));
 887                 xa_store_index(xa, max, GFP_KERNEL);
 888                 __check_store_iter(xa, min, i, 1);
 889                 XA_BUG_ON(xa, !xa_empty(xa));
 890 
 891                 for (j = 0; j < min; j++)
 892                         xa_store_index(xa, j, GFP_KERNEL);
 893                 __check_store_iter(xa, 0, i, min);
 894                 XA_BUG_ON(xa, !xa_empty(xa));
 895                 for (j = 0; j < min; j++)
 896                         xa_store_index(xa, min + j, GFP_KERNEL);
 897                 __check_store_iter(xa, min, i, min);
 898                 XA_BUG_ON(xa, !xa_empty(xa));
 899         }
 900 #ifdef CONFIG_XARRAY_MULTI
 901         xa_store_index(xa, 63, GFP_KERNEL);
 902         xa_store_index(xa, 65, GFP_KERNEL);
 903         __check_store_iter(xa, 64, 2, 1);
 904         xa_erase_index(xa, 63);
 905 #endif
 906         XA_BUG_ON(xa, !xa_empty(xa));
 907 }
 908 
 909 static noinline void check_multi_find_1(struct xarray *xa, unsigned order)
 910 {
 911 #ifdef CONFIG_XARRAY_MULTI
 912         unsigned long multi = 3 << order;
 913         unsigned long next = 4 << order;
 914         unsigned long index;
 915 
 916         xa_store_order(xa, multi, order, xa_mk_value(multi), GFP_KERNEL);
 917         XA_BUG_ON(xa, xa_store_index(xa, next, GFP_KERNEL) != NULL);
 918         XA_BUG_ON(xa, xa_store_index(xa, next + 1, GFP_KERNEL) != NULL);
 919 
 920         index = 0;
 921         XA_BUG_ON(xa, xa_find(xa, &index, ULONG_MAX, XA_PRESENT) !=
 922                         xa_mk_value(multi));
 923         XA_BUG_ON(xa, index != multi);
 924         index = multi + 1;
 925         XA_BUG_ON(xa, xa_find(xa, &index, ULONG_MAX, XA_PRESENT) !=
 926                         xa_mk_value(multi));
 927         XA_BUG_ON(xa, (index < multi) || (index >= next));
 928         XA_BUG_ON(xa, xa_find_after(xa, &index, ULONG_MAX, XA_PRESENT) !=
 929                         xa_mk_value(next));
 930         XA_BUG_ON(xa, index != next);
 931         XA_BUG_ON(xa, xa_find_after(xa, &index, next, XA_PRESENT) != NULL);
 932         XA_BUG_ON(xa, index != next);
 933 
 934         xa_erase_index(xa, multi);
 935         xa_erase_index(xa, next);
 936         xa_erase_index(xa, next + 1);
 937         XA_BUG_ON(xa, !xa_empty(xa));
 938 #endif
 939 }
 940 
 941 static noinline void check_multi_find_2(struct xarray *xa)
 942 {
 943         unsigned int max_order = IS_ENABLED(CONFIG_XARRAY_MULTI) ? 10 : 1;
 944         unsigned int i, j;
 945         void *entry;
 946 
 947         for (i = 0; i < max_order; i++) {
 948                 unsigned long index = 1UL << i;
 949                 for (j = 0; j < index; j++) {
 950                         XA_STATE(xas, xa, j + index);
 951                         xa_store_index(xa, index - 1, GFP_KERNEL);
 952                         xa_store_order(xa, index, i, xa_mk_index(index),
 953                                         GFP_KERNEL);
 954                         rcu_read_lock();
 955                         xas_for_each(&xas, entry, ULONG_MAX) {
 956                                 xa_erase_index(xa, index);
 957                         }
 958                         rcu_read_unlock();
 959                         xa_erase_index(xa, index - 1);
 960                         XA_BUG_ON(xa, !xa_empty(xa));
 961                 }
 962         }
 963 }
 964 
 965 static noinline void check_multi_find_3(struct xarray *xa)
 966 {
 967         unsigned int order;
 968 
 969         for (order = 5; order < order_limit; order++) {
 970                 unsigned long index = 1UL << (order - 5);
 971 
 972                 XA_BUG_ON(xa, !xa_empty(xa));
 973                 xa_store_order(xa, 0, order - 4, xa_mk_index(0), GFP_KERNEL);
 974                 XA_BUG_ON(xa, xa_find_after(xa, &index, ULONG_MAX, XA_PRESENT));
 975                 xa_erase_index(xa, 0);
 976         }
 977 }
 978 
 979 static noinline void check_find_1(struct xarray *xa)
 980 {
 981         unsigned long i, j, k;
 982 
 983         XA_BUG_ON(xa, !xa_empty(xa));
 984 
 985         /*
 986          * Check xa_find with all pairs between 0 and 99 inclusive,
 987          * starting at every index between 0 and 99
 988          */
 989         for (i = 0; i < 100; i++) {
 990                 XA_BUG_ON(xa, xa_store_index(xa, i, GFP_KERNEL) != NULL);
 991                 xa_set_mark(xa, i, XA_MARK_0);
 992                 for (j = 0; j < i; j++) {
 993                         XA_BUG_ON(xa, xa_store_index(xa, j, GFP_KERNEL) !=
 994                                         NULL);
 995                         xa_set_mark(xa, j, XA_MARK_0);
 996                         for (k = 0; k < 100; k++) {
 997                                 unsigned long index = k;
 998                                 void *entry = xa_find(xa, &index, ULONG_MAX,
 999                                                                 XA_PRESENT);
1000                                 if (k <= j)
1001                                         XA_BUG_ON(xa, index != j);
1002                                 else if (k <= i)
1003                                         XA_BUG_ON(xa, index != i);
1004                                 else
1005                                         XA_BUG_ON(xa, entry != NULL);
1006 
1007                                 index = k;
1008                                 entry = xa_find(xa, &index, ULONG_MAX,
1009                                                                 XA_MARK_0);
1010                                 if (k <= j)
1011                                         XA_BUG_ON(xa, index != j);
1012                                 else if (k <= i)
1013                                         XA_BUG_ON(xa, index != i);
1014                                 else
1015                                         XA_BUG_ON(xa, entry != NULL);
1016                         }
1017                         xa_erase_index(xa, j);
1018                         XA_BUG_ON(xa, xa_get_mark(xa, j, XA_MARK_0));
1019                         XA_BUG_ON(xa, !xa_get_mark(xa, i, XA_MARK_0));
1020                 }
1021                 xa_erase_index(xa, i);
1022                 XA_BUG_ON(xa, xa_get_mark(xa, i, XA_MARK_0));
1023         }
1024         XA_BUG_ON(xa, !xa_empty(xa));
1025 }
1026 
1027 static noinline void check_find_2(struct xarray *xa)
1028 {
1029         void *entry;
1030         unsigned long i, j, index;
1031 
1032         xa_for_each(xa, index, entry) {
1033                 XA_BUG_ON(xa, true);
1034         }
1035 
1036         for (i = 0; i < 1024; i++) {
1037                 xa_store_index(xa, index, GFP_KERNEL);
1038                 j = 0;
1039                 xa_for_each(xa, index, entry) {
1040                         XA_BUG_ON(xa, xa_mk_index(index) != entry);
1041                         XA_BUG_ON(xa, index != j++);
1042                 }
1043         }
1044 
1045         xa_destroy(xa);
1046 }
1047 
1048 static noinline void check_find_3(struct xarray *xa)
1049 {
1050         XA_STATE(xas, xa, 0);
1051         unsigned long i, j, k;
1052         void *entry;
1053 
1054         for (i = 0; i < 100; i++) {
1055                 for (j = 0; j < 100; j++) {
1056                         rcu_read_lock();
1057                         for (k = 0; k < 100; k++) {
1058                                 xas_set(&xas, j);
1059                                 xas_for_each_marked(&xas, entry, k, XA_MARK_0)
1060                                         ;
1061                                 if (j > k)
1062                                         XA_BUG_ON(xa,
1063                                                 xas.xa_node != XAS_RESTART);
1064                         }
1065                         rcu_read_unlock();
1066                 }
1067                 xa_store_index(xa, i, GFP_KERNEL);
1068                 xa_set_mark(xa, i, XA_MARK_0);
1069         }
1070         xa_destroy(xa);
1071 }
1072 
1073 static noinline void check_find_4(struct xarray *xa)
1074 {
1075         unsigned long index = 0;
1076         void *entry;
1077 
1078         xa_store_index(xa, ULONG_MAX, GFP_KERNEL);
1079 
1080         entry = xa_find_after(xa, &index, ULONG_MAX, XA_PRESENT);
1081         XA_BUG_ON(xa, entry != xa_mk_index(ULONG_MAX));
1082 
1083         entry = xa_find_after(xa, &index, ULONG_MAX, XA_PRESENT);
1084         XA_BUG_ON(xa, entry);
1085 
1086         xa_erase_index(xa, ULONG_MAX);
1087 }
1088 
1089 static noinline void check_find(struct xarray *xa)
1090 {
1091         unsigned i;
1092 
1093         check_find_1(xa);
1094         check_find_2(xa);
1095         check_find_3(xa);
1096         check_find_4(xa);
1097 
1098         for (i = 2; i < 10; i++)
1099                 check_multi_find_1(xa, i);
1100         check_multi_find_2(xa);
1101         check_multi_find_3(xa);
1102 }
1103 
1104 /* See find_swap_entry() in mm/shmem.c */
1105 static noinline unsigned long xa_find_entry(struct xarray *xa, void *item)
1106 {
1107         XA_STATE(xas, xa, 0);
1108         unsigned int checked = 0;
1109         void *entry;
1110 
1111         rcu_read_lock();
1112         xas_for_each(&xas, entry, ULONG_MAX) {
1113                 if (xas_retry(&xas, entry))
1114                         continue;
1115                 if (entry == item)
1116                         break;
1117                 checked++;
1118                 if ((checked % 4) != 0)
1119                         continue;
1120                 xas_pause(&xas);
1121         }
1122         rcu_read_unlock();
1123 
1124         return entry ? xas.xa_index : -1;
1125 }
1126 
1127 static noinline void check_find_entry(struct xarray *xa)
1128 {
1129 #ifdef CONFIG_XARRAY_MULTI
1130         unsigned int order;
1131         unsigned long offset, index;
1132 
1133         for (order = 0; order < 20; order++) {
1134                 for (offset = 0; offset < (1UL << (order + 3));
1135                      offset += (1UL << order)) {
1136                         for (index = 0; index < (1UL << (order + 5));
1137                              index += (1UL << order)) {
1138                                 xa_store_order(xa, index, order,
1139                                                 xa_mk_index(index), GFP_KERNEL);
1140                                 XA_BUG_ON(xa, xa_load(xa, index) !=
1141                                                 xa_mk_index(index));
1142                                 XA_BUG_ON(xa, xa_find_entry(xa,
1143                                                 xa_mk_index(index)) != index);
1144                         }
1145                         XA_BUG_ON(xa, xa_find_entry(xa, xa) != -1);
1146                         xa_destroy(xa);
1147                 }
1148         }
1149 #endif
1150 
1151         XA_BUG_ON(xa, xa_find_entry(xa, xa) != -1);
1152         xa_store_index(xa, ULONG_MAX, GFP_KERNEL);
1153         XA_BUG_ON(xa, xa_find_entry(xa, xa) != -1);
1154         XA_BUG_ON(xa, xa_find_entry(xa, xa_mk_index(ULONG_MAX)) != -1);
1155         xa_erase_index(xa, ULONG_MAX);
1156         XA_BUG_ON(xa, !xa_empty(xa));
1157 }
1158 
1159 static noinline void check_pause(struct xarray *xa)
1160 {
1161         XA_STATE(xas, xa, 0);
1162         void *entry;
1163         unsigned int order;
1164         unsigned long index = 1;
1165         unsigned int count = 0;
1166 
1167         for (order = 0; order < order_limit; order++) {
1168                 XA_BUG_ON(xa, xa_store_order(xa, index, order,
1169                                         xa_mk_index(index), GFP_KERNEL));
1170                 index += 1UL << order;
1171         }
1172 
1173         rcu_read_lock();
1174         xas_for_each(&xas, entry, ULONG_MAX) {
1175                 XA_BUG_ON(xa, entry != xa_mk_index(1UL << count));
1176                 count++;
1177         }
1178         rcu_read_unlock();
1179         XA_BUG_ON(xa, count != order_limit);
1180 
1181         count = 0;
1182         xas_set(&xas, 0);
1183         rcu_read_lock();
1184         xas_for_each(&xas, entry, ULONG_MAX) {
1185                 XA_BUG_ON(xa, entry != xa_mk_index(1UL << count));
1186                 count++;
1187                 xas_pause(&xas);
1188         }
1189         rcu_read_unlock();
1190         XA_BUG_ON(xa, count != order_limit);
1191 
1192         xa_destroy(xa);
1193 }
1194 
1195 static noinline void check_move_tiny(struct xarray *xa)
1196 {
1197         XA_STATE(xas, xa, 0);
1198 
1199         XA_BUG_ON(xa, !xa_empty(xa));
1200         rcu_read_lock();
1201         XA_BUG_ON(xa, xas_next(&xas) != NULL);
1202         XA_BUG_ON(xa, xas_next(&xas) != NULL);
1203         rcu_read_unlock();
1204         xa_store_index(xa, 0, GFP_KERNEL);
1205         rcu_read_lock();
1206         xas_set(&xas, 0);
1207         XA_BUG_ON(xa, xas_next(&xas) != xa_mk_index(0));
1208         XA_BUG_ON(xa, xas_next(&xas) != NULL);
1209         xas_set(&xas, 0);
1210         XA_BUG_ON(xa, xas_prev(&xas) != xa_mk_index(0));
1211         XA_BUG_ON(xa, xas_prev(&xas) != NULL);
1212         rcu_read_unlock();
1213         xa_erase_index(xa, 0);
1214         XA_BUG_ON(xa, !xa_empty(xa));
1215 }
1216 
1217 static noinline void check_move_max(struct xarray *xa)
1218 {
1219         XA_STATE(xas, xa, 0);
1220 
1221         xa_store_index(xa, ULONG_MAX, GFP_KERNEL);
1222         rcu_read_lock();
1223         XA_BUG_ON(xa, xas_find(&xas, ULONG_MAX) != xa_mk_index(ULONG_MAX));
1224         XA_BUG_ON(xa, xas_find(&xas, ULONG_MAX) != NULL);
1225         rcu_read_unlock();
1226 
1227         xas_set(&xas, 0);
1228         rcu_read_lock();
1229         XA_BUG_ON(xa, xas_find(&xas, ULONG_MAX) != xa_mk_index(ULONG_MAX));
1230         xas_pause(&xas);
1231         XA_BUG_ON(xa, xas_find(&xas, ULONG_MAX) != NULL);
1232         rcu_read_unlock();
1233 
1234         xa_erase_index(xa, ULONG_MAX);
1235         XA_BUG_ON(xa, !xa_empty(xa));
1236 }
1237 
1238 static noinline void check_move_small(struct xarray *xa, unsigned long idx)
1239 {
1240         XA_STATE(xas, xa, 0);
1241         unsigned long i;
1242 
1243         xa_store_index(xa, 0, GFP_KERNEL);
1244         xa_store_index(xa, idx, GFP_KERNEL);
1245 
1246         rcu_read_lock();
1247         for (i = 0; i < idx * 4; i++) {
1248                 void *entry = xas_next(&xas);
1249                 if (i <= idx)
1250                         XA_BUG_ON(xa, xas.xa_node == XAS_RESTART);
1251                 XA_BUG_ON(xa, xas.xa_index != i);
1252                 if (i == 0 || i == idx)
1253                         XA_BUG_ON(xa, entry != xa_mk_index(i));
1254                 else
1255                         XA_BUG_ON(xa, entry != NULL);
1256         }
1257         xas_next(&xas);
1258         XA_BUG_ON(xa, xas.xa_index != i);
1259 
1260         do {
1261                 void *entry = xas_prev(&xas);
1262                 i--;
1263                 if (i <= idx)
1264                         XA_BUG_ON(xa, xas.xa_node == XAS_RESTART);
1265                 XA_BUG_ON(xa, xas.xa_index != i);
1266                 if (i == 0 || i == idx)
1267                         XA_BUG_ON(xa, entry != xa_mk_index(i));
1268                 else
1269                         XA_BUG_ON(xa, entry != NULL);
1270         } while (i > 0);
1271 
1272         xas_set(&xas, ULONG_MAX);
1273         XA_BUG_ON(xa, xas_next(&xas) != NULL);
1274         XA_BUG_ON(xa, xas.xa_index != ULONG_MAX);
1275         XA_BUG_ON(xa, xas_next(&xas) != xa_mk_value(0));
1276         XA_BUG_ON(xa, xas.xa_index != 0);
1277         XA_BUG_ON(xa, xas_prev(&xas) != NULL);
1278         XA_BUG_ON(xa, xas.xa_index != ULONG_MAX);
1279         rcu_read_unlock();
1280 
1281         xa_erase_index(xa, 0);
1282         xa_erase_index(xa, idx);
1283         XA_BUG_ON(xa, !xa_empty(xa));
1284 }
1285 
1286 static noinline void check_move(struct xarray *xa)
1287 {
1288         XA_STATE(xas, xa, (1 << 16) - 1);
1289         unsigned long i;
1290 
1291         for (i = 0; i < (1 << 16); i++)
1292                 XA_BUG_ON(xa, xa_store_index(xa, i, GFP_KERNEL) != NULL);
1293 
1294         rcu_read_lock();
1295         do {
1296                 void *entry = xas_prev(&xas);
1297                 i--;
1298                 XA_BUG_ON(xa, entry != xa_mk_index(i));
1299                 XA_BUG_ON(xa, i != xas.xa_index);
1300         } while (i != 0);
1301 
1302         XA_BUG_ON(xa, xas_prev(&xas) != NULL);
1303         XA_BUG_ON(xa, xas.xa_index != ULONG_MAX);
1304 
1305         do {
1306                 void *entry = xas_next(&xas);
1307                 XA_BUG_ON(xa, entry != xa_mk_index(i));
1308                 XA_BUG_ON(xa, i != xas.xa_index);
1309                 i++;
1310         } while (i < (1 << 16));
1311         rcu_read_unlock();
1312 
1313         for (i = (1 << 8); i < (1 << 15); i++)
1314                 xa_erase_index(xa, i);
1315 
1316         i = xas.xa_index;
1317 
1318         rcu_read_lock();
1319         do {
1320                 void *entry = xas_prev(&xas);
1321                 i--;
1322                 if ((i < (1 << 8)) || (i >= (1 << 15)))
1323                         XA_BUG_ON(xa, entry != xa_mk_index(i));
1324                 else
1325                         XA_BUG_ON(xa, entry != NULL);
1326                 XA_BUG_ON(xa, i != xas.xa_index);
1327         } while (i != 0);
1328 
1329         XA_BUG_ON(xa, xas_prev(&xas) != NULL);
1330         XA_BUG_ON(xa, xas.xa_index != ULONG_MAX);
1331 
1332         do {
1333                 void *entry = xas_next(&xas);
1334                 if ((i < (1 << 8)) || (i >= (1 << 15)))
1335                         XA_BUG_ON(xa, entry != xa_mk_index(i));
1336                 else
1337                         XA_BUG_ON(xa, entry != NULL);
1338                 XA_BUG_ON(xa, i != xas.xa_index);
1339                 i++;
1340         } while (i < (1 << 16));
1341         rcu_read_unlock();
1342 
1343         xa_destroy(xa);
1344 
1345         check_move_tiny(xa);
1346         check_move_max(xa);
1347 
1348         for (i = 0; i < 16; i++)
1349                 check_move_small(xa, 1UL << i);
1350 
1351         for (i = 2; i < 16; i++)
1352                 check_move_small(xa, (1UL << i) - 1);
1353 }
1354 
1355 static noinline void xa_store_many_order(struct xarray *xa,
1356                 unsigned long index, unsigned order)
1357 {
1358         XA_STATE_ORDER(xas, xa, index, order);
1359         unsigned int i = 0;
1360 
1361         do {
1362                 xas_lock(&xas);
1363                 XA_BUG_ON(xa, xas_find_conflict(&xas));
1364                 xas_create_range(&xas);
1365                 if (xas_error(&xas))
1366                         goto unlock;
1367                 for (i = 0; i < (1U << order); i++) {
1368                         XA_BUG_ON(xa, xas_store(&xas, xa_mk_index(index + i)));
1369                         xas_next(&xas);
1370                 }
1371 unlock:
1372                 xas_unlock(&xas);
1373         } while (xas_nomem(&xas, GFP_KERNEL));
1374 
1375         XA_BUG_ON(xa, xas_error(&xas));
1376 }
1377 
1378 static noinline void check_create_range_1(struct xarray *xa,
1379                 unsigned long index, unsigned order)
1380 {
1381         unsigned long i;
1382 
1383         xa_store_many_order(xa, index, order);
1384         for (i = index; i < index + (1UL << order); i++)
1385                 xa_erase_index(xa, i);
1386         XA_BUG_ON(xa, !xa_empty(xa));
1387 }
1388 
1389 static noinline void check_create_range_2(struct xarray *xa, unsigned order)
1390 {
1391         unsigned long i;
1392         unsigned long nr = 1UL << order;
1393 
1394         for (i = 0; i < nr * nr; i += nr)
1395                 xa_store_many_order(xa, i, order);
1396         for (i = 0; i < nr * nr; i++)
1397                 xa_erase_index(xa, i);
1398         XA_BUG_ON(xa, !xa_empty(xa));
1399 }
1400 
1401 static noinline void check_create_range_3(void)
1402 {
1403         XA_STATE(xas, NULL, 0);
1404         xas_set_err(&xas, -EEXIST);
1405         xas_create_range(&xas);
1406         XA_BUG_ON(NULL, xas_error(&xas) != -EEXIST);
1407 }
1408 
1409 static noinline void check_create_range_4(struct xarray *xa,
1410                 unsigned long index, unsigned order)
1411 {
1412         XA_STATE_ORDER(xas, xa, index, order);
1413         unsigned long base = xas.xa_index;
1414         unsigned long i = 0;
1415 
1416         xa_store_index(xa, index, GFP_KERNEL);
1417         do {
1418                 xas_lock(&xas);
1419                 xas_create_range(&xas);
1420                 if (xas_error(&xas))
1421                         goto unlock;
1422                 for (i = 0; i < (1UL << order); i++) {
1423                         void *old = xas_store(&xas, xa_mk_index(base + i));
1424                         if (xas.xa_index == index)
1425                                 XA_BUG_ON(xa, old != xa_mk_index(base + i));
1426                         else
1427                                 XA_BUG_ON(xa, old != NULL);
1428                         xas_next(&xas);
1429                 }
1430 unlock:
1431                 xas_unlock(&xas);
1432         } while (xas_nomem(&xas, GFP_KERNEL));
1433 
1434         XA_BUG_ON(xa, xas_error(&xas));
1435 
1436         for (i = base; i < base + (1UL << order); i++)
1437                 xa_erase_index(xa, i);
1438         XA_BUG_ON(xa, !xa_empty(xa));
1439 }
1440 
1441 static noinline void check_create_range(struct xarray *xa)
1442 {
1443         unsigned int order;
1444         unsigned int max_order = IS_ENABLED(CONFIG_XARRAY_MULTI) ? 12 : 1;
1445 
1446         for (order = 0; order < max_order; order++) {
1447                 check_create_range_1(xa, 0, order);
1448                 check_create_range_1(xa, 1U << order, order);
1449                 check_create_range_1(xa, 2U << order, order);
1450                 check_create_range_1(xa, 3U << order, order);
1451                 check_create_range_1(xa, 1U << 24, order);
1452                 if (order < 10)
1453                         check_create_range_2(xa, order);
1454 
1455                 check_create_range_4(xa, 0, order);
1456                 check_create_range_4(xa, 1U << order, order);
1457                 check_create_range_4(xa, 2U << order, order);
1458                 check_create_range_4(xa, 3U << order, order);
1459                 check_create_range_4(xa, 1U << 24, order);
1460 
1461                 check_create_range_4(xa, 1, order);
1462                 check_create_range_4(xa, (1U << order) + 1, order);
1463                 check_create_range_4(xa, (2U << order) + 1, order);
1464                 check_create_range_4(xa, (2U << order) - 1, order);
1465                 check_create_range_4(xa, (3U << order) + 1, order);
1466                 check_create_range_4(xa, (3U << order) - 1, order);
1467                 check_create_range_4(xa, (1U << 24) + 1, order);
1468         }
1469 
1470         check_create_range_3();
1471 }
1472 
1473 static noinline void __check_store_range(struct xarray *xa, unsigned long first,
1474                 unsigned long last)
1475 {
1476 #ifdef CONFIG_XARRAY_MULTI
1477         xa_store_range(xa, first, last, xa_mk_index(first), GFP_KERNEL);
1478 
1479         XA_BUG_ON(xa, xa_load(xa, first) != xa_mk_index(first));
1480         XA_BUG_ON(xa, xa_load(xa, last) != xa_mk_index(first));
1481         XA_BUG_ON(xa, xa_load(xa, first - 1) != NULL);
1482         XA_BUG_ON(xa, xa_load(xa, last + 1) != NULL);
1483 
1484         xa_store_range(xa, first, last, NULL, GFP_KERNEL);
1485 #endif
1486 
1487         XA_BUG_ON(xa, !xa_empty(xa));
1488 }
1489 
1490 static noinline void check_store_range(struct xarray *xa)
1491 {
1492         unsigned long i, j;
1493 
1494         for (i = 0; i < 128; i++) {
1495                 for (j = i; j < 128; j++) {
1496                         __check_store_range(xa, i, j);
1497                         __check_store_range(xa, 128 + i, 128 + j);
1498                         __check_store_range(xa, 4095 + i, 4095 + j);
1499                         __check_store_range(xa, 4096 + i, 4096 + j);
1500                         __check_store_range(xa, 123456 + i, 123456 + j);
1501                         __check_store_range(xa, (1 << 24) + i, (1 << 24) + j);
1502                 }
1503         }
1504 }
1505 
1506 static void check_align_1(struct xarray *xa, char *name)
1507 {
1508         int i;
1509         unsigned int id;
1510         unsigned long index;
1511         void *entry;
1512 
1513         for (i = 0; i < 8; i++) {
1514                 XA_BUG_ON(xa, xa_alloc(xa, &id, name + i, xa_limit_32b,
1515                                         GFP_KERNEL) != 0);
1516                 XA_BUG_ON(xa, id != i);
1517         }
1518         xa_for_each(xa, index, entry)
1519                 XA_BUG_ON(xa, xa_is_err(entry));
1520         xa_destroy(xa);
1521 }
1522 
1523 /*
1524  * We should always be able to store without allocating memory after
1525  * reserving a slot.
1526  */
1527 static void check_align_2(struct xarray *xa, char *name)
1528 {
1529         int i;
1530 
1531         XA_BUG_ON(xa, !xa_empty(xa));
1532 
1533         for (i = 0; i < 8; i++) {
1534                 XA_BUG_ON(xa, xa_store(xa, 0, name + i, GFP_KERNEL) != NULL);
1535                 xa_erase(xa, 0);
1536         }
1537 
1538         for (i = 0; i < 8; i++) {
1539                 XA_BUG_ON(xa, xa_reserve(xa, 0, GFP_KERNEL) != 0);
1540                 XA_BUG_ON(xa, xa_store(xa, 0, name + i, 0) != NULL);
1541                 xa_erase(xa, 0);
1542         }
1543 
1544         XA_BUG_ON(xa, !xa_empty(xa));
1545 }
1546 
1547 static noinline void check_align(struct xarray *xa)
1548 {
1549         char name[] = "Motorola 68000";
1550 
1551         check_align_1(xa, name);
1552         check_align_1(xa, name + 1);
1553         check_align_1(xa, name + 2);
1554         check_align_1(xa, name + 3);
1555         check_align_2(xa, name);
1556 }
1557 
1558 static LIST_HEAD(shadow_nodes);
1559 
1560 static void test_update_node(struct xa_node *node)
1561 {
1562         if (node->count && node->count == node->nr_values) {
1563                 if (list_empty(&node->private_list))
1564                         list_add(&shadow_nodes, &node->private_list);
1565         } else {
1566                 if (!list_empty(&node->private_list))
1567                         list_del_init(&node->private_list);
1568         }
1569 }
1570 
1571 static noinline void shadow_remove(struct xarray *xa)
1572 {
1573         struct xa_node *node;
1574 
1575         xa_lock(xa);
1576         while ((node = list_first_entry_or_null(&shadow_nodes,
1577                                         struct xa_node, private_list))) {
1578                 XA_STATE(xas, node->array, 0);
1579                 XA_BUG_ON(xa, node->array != xa);
1580                 list_del_init(&node->private_list);
1581                 xas.xa_node = xa_parent_locked(node->array, node);
1582                 xas.xa_offset = node->offset;
1583                 xas.xa_shift = node->shift + XA_CHUNK_SHIFT;
1584                 xas_set_update(&xas, test_update_node);
1585                 xas_store(&xas, NULL);
1586         }
1587         xa_unlock(xa);
1588 }
1589 
1590 static noinline void check_workingset(struct xarray *xa, unsigned long index)
1591 {
1592         XA_STATE(xas, xa, index);
1593         xas_set_update(&xas, test_update_node);
1594 
1595         do {
1596                 xas_lock(&xas);
1597                 xas_store(&xas, xa_mk_value(0));
1598                 xas_next(&xas);
1599                 xas_store(&xas, xa_mk_value(1));
1600                 xas_unlock(&xas);
1601         } while (xas_nomem(&xas, GFP_KERNEL));
1602 
1603         XA_BUG_ON(xa, list_empty(&shadow_nodes));
1604 
1605         xas_lock(&xas);
1606         xas_next(&xas);
1607         xas_store(&xas, &xas);
1608         XA_BUG_ON(xa, !list_empty(&shadow_nodes));
1609 
1610         xas_store(&xas, xa_mk_value(2));
1611         xas_unlock(&xas);
1612         XA_BUG_ON(xa, list_empty(&shadow_nodes));
1613 
1614         shadow_remove(xa);
1615         XA_BUG_ON(xa, !list_empty(&shadow_nodes));
1616         XA_BUG_ON(xa, !xa_empty(xa));
1617 }
1618 
1619 /*
1620  * Check that the pointer / value / sibling entries are accounted the
1621  * way we expect them to be.
1622  */
1623 static noinline void check_account(struct xarray *xa)
1624 {
1625 #ifdef CONFIG_XARRAY_MULTI
1626         unsigned int order;
1627 
1628         for (order = 1; order < 12; order++) {
1629                 XA_STATE(xas, xa, 1 << order);
1630 
1631                 xa_store_order(xa, 0, order, xa, GFP_KERNEL);
1632                 rcu_read_lock();
1633                 xas_load(&xas);
1634                 XA_BUG_ON(xa, xas.xa_node->count == 0);
1635                 XA_BUG_ON(xa, xas.xa_node->count > (1 << order));
1636                 XA_BUG_ON(xa, xas.xa_node->nr_values != 0);
1637                 rcu_read_unlock();
1638 
1639                 xa_store_order(xa, 1 << order, order, xa_mk_index(1UL << order),
1640                                 GFP_KERNEL);
1641                 XA_BUG_ON(xa, xas.xa_node->count != xas.xa_node->nr_values * 2);
1642 
1643                 xa_erase(xa, 1 << order);
1644                 XA_BUG_ON(xa, xas.xa_node->nr_values != 0);
1645 
1646                 xa_erase(xa, 0);
1647                 XA_BUG_ON(xa, !xa_empty(xa));
1648         }
1649 #endif
1650 }
1651 
1652 static noinline void check_destroy(struct xarray *xa)
1653 {
1654         unsigned long index;
1655 
1656         XA_BUG_ON(xa, !xa_empty(xa));
1657 
1658         /* Destroying an empty array is a no-op */
1659         xa_destroy(xa);
1660         XA_BUG_ON(xa, !xa_empty(xa));
1661 
1662         /* Destroying an array with a single entry */
1663         for (index = 0; index < 1000; index++) {
1664                 xa_store_index(xa, index, GFP_KERNEL);
1665                 XA_BUG_ON(xa, xa_empty(xa));
1666                 xa_destroy(xa);
1667                 XA_BUG_ON(xa, !xa_empty(xa));
1668         }
1669 
1670         /* Destroying an array with a single entry at ULONG_MAX */
1671         xa_store(xa, ULONG_MAX, xa, GFP_KERNEL);
1672         XA_BUG_ON(xa, xa_empty(xa));
1673         xa_destroy(xa);
1674         XA_BUG_ON(xa, !xa_empty(xa));
1675 
1676 #ifdef CONFIG_XARRAY_MULTI
1677         /* Destroying an array with a multi-index entry */
1678         xa_store_order(xa, 1 << 11, 11, xa, GFP_KERNEL);
1679         XA_BUG_ON(xa, xa_empty(xa));
1680         xa_destroy(xa);
1681         XA_BUG_ON(xa, !xa_empty(xa));
1682 #endif
1683 }
1684 
1685 static DEFINE_XARRAY(array);
1686 
1687 static int xarray_checks(void)
1688 {
1689         check_xa_err(&array);
1690         check_xas_retry(&array);
1691         check_xa_load(&array);
1692         check_xa_mark(&array);
1693         check_xa_shrink(&array);
1694         check_xas_erase(&array);
1695         check_insert(&array);
1696         check_cmpxchg(&array);
1697         check_reserve(&array);
1698         check_reserve(&xa0);
1699         check_multi_store(&array);
1700         check_xa_alloc();
1701         check_find(&array);
1702         check_find_entry(&array);
1703         check_pause(&array);
1704         check_account(&array);
1705         check_destroy(&array);
1706         check_move(&array);
1707         check_create_range(&array);
1708         check_store_range(&array);
1709         check_store_iter(&array);
1710         check_align(&xa0);
1711 
1712         check_workingset(&array, 0);
1713         check_workingset(&array, 64);
1714         check_workingset(&array, 4096);
1715 
1716         printk("XArray: %u of %u tests passed\n", tests_passed, tests_run);
1717         return (tests_run == tests_passed) ? 0 : -EINVAL;
1718 }
1719 
1720 static void xarray_exit(void)
1721 {
1722 }
1723 
1724 module_init(xarray_checks);
1725 module_exit(xarray_exit);
1726 MODULE_AUTHOR("Matthew Wilcox <willy@infradead.org>");
1727 MODULE_LICENSE("GPL");
/* [<][>][^][v][top][bottom][index][help] */
root/lib/test_xarray.c

DEFINITIONS
