tools/testing/memblock/tests/alloc_nid_api.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 #include "alloc_nid_api.h"
   3
   4 static int alloc_nid_test_flags = TEST_F_NONE;
   5
   6 /*
   7  * contains the fraction of MEM_SIZE contained in each node in basis point
   8  * units (one hundredth of 1% or 1/10000)
   9  */
  10 static const unsigned int node_fractions[] = {
  11         2500, /* 1/4  */
  12          625, /* 1/16 */
  13         1250, /* 1/8  */
  14         1250, /* 1/8  */
  15          625, /* 1/16 */
  16          625, /* 1/16 */
  17         2500, /* 1/4  */
  18          625, /* 1/16 */
  19 };
  20
  21 static inline const char * const get_memblock_alloc_try_nid_name(int flags)
  22 {
  23         if (flags & TEST_F_RAW)
  24                 return "memblock_alloc_try_nid_raw";
  25         return "memblock_alloc_try_nid";
  26 }
  27
  28 static inline void *run_memblock_alloc_try_nid(phys_addr_t size,
  29                                                phys_addr_t align,
  30                                                phys_addr_t min_addr,
  31                                                phys_addr_t max_addr, int nid)
  32 {
  33         if (alloc_nid_test_flags & TEST_F_RAW)
  34                 return memblock_alloc_try_nid_raw(size, align, min_addr,
  35                                                   max_addr, nid);
  36         return memblock_alloc_try_nid(size, align, min_addr, max_addr, nid);
  37 }
  38
  39 /*
  40  * A simple test that tries to allocate a memory region within min_addr and
  41  * max_addr range:
  42  *
  43  *        +                   +
  44  *   |    +       +-----------+      |
  45  *   |    |       |    rgn    |      |
  46  *   +----+-------+-----------+------+
  47  *        ^                   ^
  48  *        |                   |
  49  *        min_addr           max_addr
  50  *
  51  * Expect to allocate a region that ends at max_addr.
  52  */
  53 static int alloc_try_nid_top_down_simple_check(void)
  54 {
  55         struct memblock_region *rgn = &memblock.reserved.regions[0];
  56         void *allocated_ptr = NULL;
  57         phys_addr_t size = SZ_128;
  58         phys_addr_t min_addr;
  59         phys_addr_t max_addr;
  60         phys_addr_t rgn_end;
  61
  62         PREFIX_PUSH();
  63         setup_memblock();
  64
  65         min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2;
  66         max_addr = min_addr + SZ_512;
  67
  68         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
  69                                                    min_addr, max_addr,
  70                                                    NUMA_NO_NODE);
  71         rgn_end = rgn->base + rgn->size;
  72
  73         ASSERT_NE(allocated_ptr, NULL);
  74         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
  75
  76         ASSERT_EQ(rgn->size, size);
  77         ASSERT_EQ(rgn->base, max_addr - size);
  78         ASSERT_EQ(rgn_end, max_addr);
  79
  80         ASSERT_EQ(memblock.reserved.cnt, 1);
  81         ASSERT_EQ(memblock.reserved.total_size, size);
  82
  83         test_pass_pop();
  84
  85         return 0;
  86 }
  87
  88 /*
  89  * A simple test that tries to allocate a memory region within min_addr and
  90  * max_addr range, where the end address is misaligned:
  91  *
  92  *         +       +            +
  93  *  |      +       +---------+  +    |
  94  *  |      |       |   rgn   |  |    |
  95  *  +------+-------+---------+--+----+
  96  *         ^       ^            ^
  97  *         |       |            |
  98  *       min_add   |            max_addr
  99  *                 |
 100  *                 Aligned address
 101  *                 boundary
 102  *
 103  * Expect to allocate an aligned region that ends before max_addr.
 104  */
 105 static int alloc_try_nid_top_down_end_misaligned_check(void)
 106 {
 107         struct memblock_region *rgn = &memblock.reserved.regions[0];
 108         void *allocated_ptr = NULL;
 109         phys_addr_t size = SZ_128;
 110         phys_addr_t misalign = SZ_2;
 111         phys_addr_t min_addr;
 112         phys_addr_t max_addr;
 113         phys_addr_t rgn_end;
 114
 115         PREFIX_PUSH();
 116         setup_memblock();
 117
 118         min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2;
 119         max_addr = min_addr + SZ_512 + misalign;
 120
 121         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
 122                                                    min_addr, max_addr,
 123                                                    NUMA_NO_NODE);
 124         rgn_end = rgn->base + rgn->size;
 125
 126         ASSERT_NE(allocated_ptr, NULL);
 127         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
 128
 129         ASSERT_EQ(rgn->size, size);
 130         ASSERT_EQ(rgn->base, max_addr - size - misalign);
 131         ASSERT_LT(rgn_end, max_addr);
 132
 133         ASSERT_EQ(memblock.reserved.cnt, 1);
 134         ASSERT_EQ(memblock.reserved.total_size, size);
 135
 136         test_pass_pop();
 137
 138         return 0;
 139 }
 140
 141 /*
 142  * A simple test that tries to allocate a memory region, which spans over the
 143  * min_addr and max_addr range:
 144  *
 145  *         +               +
 146  *  |      +---------------+       |
 147  *  |      |      rgn      |       |
 148  *  +------+---------------+-------+
 149  *         ^               ^
 150  *         |               |
 151  *         min_addr        max_addr
 152  *
 153  * Expect to allocate a region that starts at min_addr and ends at
 154  * max_addr, given that min_addr is aligned.
 155  */
 156 static int alloc_try_nid_exact_address_generic_check(void)
 157 {
 158         struct memblock_region *rgn = &memblock.reserved.regions[0];
 159         void *allocated_ptr = NULL;
 160         phys_addr_t size = SZ_1K;
 161         phys_addr_t min_addr;
 162         phys_addr_t max_addr;
 163         phys_addr_t rgn_end;
 164
 165         PREFIX_PUSH();
 166         setup_memblock();
 167
 168         min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES;
 169         max_addr = min_addr + size;
 170
 171         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
 172                                                    min_addr, max_addr,
 173                                                    NUMA_NO_NODE);
 174         rgn_end = rgn->base + rgn->size;
 175
 176         ASSERT_NE(allocated_ptr, NULL);
 177         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
 178
 179         ASSERT_EQ(rgn->size, size);
 180         ASSERT_EQ(rgn->base, min_addr);
 181         ASSERT_EQ(rgn_end, max_addr);
 182
 183         ASSERT_EQ(memblock.reserved.cnt, 1);
 184         ASSERT_EQ(memblock.reserved.total_size, size);
 185
 186         test_pass_pop();
 187
 188         return 0;
 189 }
 190
 191 /*
 192  * A test that tries to allocate a memory region, which can't fit into
 193  * min_addr and max_addr range:
 194  *
 195  *           +          +     +
 196  *  |        +----------+-----+    |
 197  *  |        |   rgn    +     |    |
 198  *  +--------+----------+-----+----+
 199  *           ^          ^     ^
 200  *           |          |     |
 201  *           Aligned    |    max_addr
 202  *           address    |
 203  *           boundary   min_add
 204  *
 205  * Expect to drop the lower limit and allocate a memory region which
 206  * ends at max_addr (if the address is aligned).
 207  */
 208 static int alloc_try_nid_top_down_narrow_range_check(void)
 209 {
 210         struct memblock_region *rgn = &memblock.reserved.regions[0];
 211         void *allocated_ptr = NULL;
 212         phys_addr_t size = SZ_256;
 213         phys_addr_t min_addr;
 214         phys_addr_t max_addr;
 215
 216         PREFIX_PUSH();
 217         setup_memblock();
 218
 219         min_addr = memblock_start_of_DRAM() + SZ_512;
 220         max_addr = min_addr + SMP_CACHE_BYTES;
 221
 222         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
 223                                                    min_addr, max_addr,
 224                                                    NUMA_NO_NODE);
 225
 226         ASSERT_NE(allocated_ptr, NULL);
 227         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
 228
 229         ASSERT_EQ(rgn->size, size);
 230         ASSERT_EQ(rgn->base, max_addr - size);
 231
 232         ASSERT_EQ(memblock.reserved.cnt, 1);
 233         ASSERT_EQ(memblock.reserved.total_size, size);
 234
 235         test_pass_pop();
 236
 237         return 0;
 238 }
 239
 240 /*
 241  * A test that tries to allocate a memory region, which can't fit into
 242  * min_addr and max_addr range, with the latter being too close to the beginning
 243  * of the available memory:
 244  *
 245  *   +-------------+
 246  *   |     new     |
 247  *   +-------------+
 248  *         +       +
 249  *         |       +              |
 250  *         |       |              |
 251  *         +-------+--------------+
 252  *         ^       ^
 253  *         |       |
 254  *         |       max_addr
 255  *         |
 256  *         min_addr
 257  *
 258  * Expect no allocation to happen.
 259  */
 260 static int alloc_try_nid_low_max_generic_check(void)
 261 {
 262         void *allocated_ptr = NULL;
 263         phys_addr_t size = SZ_1K;
 264         phys_addr_t min_addr;
 265         phys_addr_t max_addr;
 266
 267         PREFIX_PUSH();
 268         setup_memblock();
 269
 270         min_addr = memblock_start_of_DRAM();
 271         max_addr = min_addr + SMP_CACHE_BYTES;
 272
 273         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
 274                                                    min_addr, max_addr,
 275                                                    NUMA_NO_NODE);
 276
 277         ASSERT_EQ(allocated_ptr, NULL);
 278
 279         test_pass_pop();
 280
 281         return 0;
 282 }
 283
 284 /*
 285  * A test that tries to allocate a memory region within min_addr min_addr range,
 286  * with min_addr being so close that it's next to an allocated region:
 287  *
 288  *          +                        +
 289  *  |       +--------+---------------|
 290  *  |       |   r1   |      rgn      |
 291  *  +-------+--------+---------------+
 292  *          ^                        ^
 293  *          |                        |
 294  *          min_addr                 max_addr
 295  *
 296  * Expect a merge of both regions. Only the region size gets updated.
 297  */
 298 static int alloc_try_nid_min_reserved_generic_check(void)
 299 {
 300         struct memblock_region *rgn = &memblock.reserved.regions[0];
 301         void *allocated_ptr = NULL;
 302         phys_addr_t r1_size = SZ_128;
 303         phys_addr_t r2_size = SZ_64;
 304         phys_addr_t total_size = r1_size + r2_size;
 305         phys_addr_t min_addr;
 306         phys_addr_t max_addr;
 307         phys_addr_t reserved_base;
 308
 309         PREFIX_PUSH();
 310         setup_memblock();
 311
 312         max_addr = memblock_end_of_DRAM();
 313         min_addr = max_addr - r2_size;
 314         reserved_base = min_addr - r1_size;
 315
 316         memblock_reserve(reserved_base, r1_size);
 317
 318         allocated_ptr = run_memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES,
 319                                                    min_addr, max_addr,
 320                                                    NUMA_NO_NODE);
 321
 322         ASSERT_NE(allocated_ptr, NULL);
 323         assert_mem_content(allocated_ptr, r2_size, alloc_nid_test_flags);
 324
 325         ASSERT_EQ(rgn->size, total_size);
 326         ASSERT_EQ(rgn->base, reserved_base);
 327
 328         ASSERT_EQ(memblock.reserved.cnt, 1);
 329         ASSERT_EQ(memblock.reserved.total_size, total_size);
 330
 331         test_pass_pop();
 332
 333         return 0;
 334 }
 335
 336 /*
 337  * A test that tries to allocate a memory region within min_addr and max_addr,
 338  * with max_addr being so close that it's next to an allocated region:
 339  *
 340  *             +             +
 341  *  |          +-------------+--------|
 342  *  |          |     rgn     |   r1   |
 343  *  +----------+-------------+--------+
 344  *             ^             ^
 345  *             |             |
 346  *             min_addr      max_addr
 347  *
 348  * Expect a merge of regions. Only the region size gets updated.
 349  */
 350 static int alloc_try_nid_max_reserved_generic_check(void)
 351 {
 352         struct memblock_region *rgn = &memblock.reserved.regions[0];
 353         void *allocated_ptr = NULL;
 354         phys_addr_t r1_size = SZ_64;
 355         phys_addr_t r2_size = SZ_128;
 356         phys_addr_t total_size = r1_size + r2_size;
 357         phys_addr_t min_addr;
 358         phys_addr_t max_addr;
 359
 360         PREFIX_PUSH();
 361         setup_memblock();
 362
 363         max_addr = memblock_end_of_DRAM() - r1_size;
 364         min_addr = max_addr - r2_size;
 365
 366         memblock_reserve(max_addr, r1_size);
 367
 368         allocated_ptr = run_memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES,
 369                                                    min_addr, max_addr,
 370                                                    NUMA_NO_NODE);
 371
 372         ASSERT_NE(allocated_ptr, NULL);
 373         assert_mem_content(allocated_ptr, r2_size, alloc_nid_test_flags);
 374
 375         ASSERT_EQ(rgn->size, total_size);
 376         ASSERT_EQ(rgn->base, min_addr);
 377
 378         ASSERT_EQ(memblock.reserved.cnt, 1);
 379         ASSERT_EQ(memblock.reserved.total_size, total_size);
 380
 381         test_pass_pop();
 382
 383         return 0;
 384 }
 385
 386 /*
 387  * A test that tries to allocate memory within min_addr and max_add range, when
 388  * there are two reserved regions at the borders, with a gap big enough to fit
 389  * a new region:
 390  *
 391  *                +           +
 392  *  |    +--------+   +-------+------+  |
 393  *  |    |   r2   |   |  rgn  |  r1  |  |
 394  *  +----+--------+---+-------+------+--+
 395  *                ^           ^
 396  *                |           |
 397  *                min_addr    max_addr
 398  *
 399  * Expect to merge the new region with r1. The second region does not get
 400  * updated. The total size field gets updated.
 401  */
 402
 403 static int alloc_try_nid_top_down_reserved_with_space_check(void)
 404 {
 405         struct memblock_region *rgn1 = &memblock.reserved.regions[1];
 406         struct memblock_region *rgn2 = &memblock.reserved.regions[0];
 407         void *allocated_ptr = NULL;
 408         struct region r1, r2;
 409         phys_addr_t r3_size = SZ_64;
 410         phys_addr_t gap_size = SMP_CACHE_BYTES;
 411         phys_addr_t total_size;
 412         phys_addr_t max_addr;
 413         phys_addr_t min_addr;
 414
 415         PREFIX_PUSH();
 416         setup_memblock();
 417
 418         r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2;
 419         r1.size = SMP_CACHE_BYTES;
 420
 421         r2.size = SZ_128;
 422         r2.base = r1.base - (r3_size + gap_size + r2.size);
 423
 424         total_size = r1.size + r2.size + r3_size;
 425         min_addr = r2.base + r2.size;
 426         max_addr = r1.base;
 427
 428         memblock_reserve(r1.base, r1.size);
 429         memblock_reserve(r2.base, r2.size);
 430
 431         allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
 432                                                    min_addr, max_addr,
 433                                                    NUMA_NO_NODE);
 434
 435         ASSERT_NE(allocated_ptr, NULL);
 436         assert_mem_content(allocated_ptr, r3_size, alloc_nid_test_flags);
 437
 438         ASSERT_EQ(rgn1->size, r1.size + r3_size);
 439         ASSERT_EQ(rgn1->base, max_addr - r3_size);
 440
 441         ASSERT_EQ(rgn2->size, r2.size);
 442         ASSERT_EQ(rgn2->base, r2.base);
 443
 444         ASSERT_EQ(memblock.reserved.cnt, 2);
 445         ASSERT_EQ(memblock.reserved.total_size, total_size);
 446
 447         test_pass_pop();
 448
 449         return 0;
 450 }
 451
 452 /*
 453  * A test that tries to allocate memory within min_addr and max_add range, when
 454  * there are two reserved regions at the borders, with a gap of a size equal to
 455  * the size of the new region:
 456  *
 457  *                 +        +
 458  *  |     +--------+--------+--------+     |
 459  *  |     |   r2   |   r3   |   r1   |     |
 460  *  +-----+--------+--------+--------+-----+
 461  *                 ^        ^
 462  *                 |        |
 463  *                 min_addr max_addr
 464  *
 465  * Expect to merge all of the regions into one. The region counter and total
 466  * size fields get updated.
 467  */
 468 static int alloc_try_nid_reserved_full_merge_generic_check(void)
 469 {
 470         struct memblock_region *rgn = &memblock.reserved.regions[0];
 471         void *allocated_ptr = NULL;
 472         struct region r1, r2;
 473         phys_addr_t r3_size = SZ_64;
 474         phys_addr_t total_size;
 475         phys_addr_t max_addr;
 476         phys_addr_t min_addr;
 477
 478         PREFIX_PUSH();
 479         setup_memblock();
 480
 481         r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2;
 482         r1.size = SMP_CACHE_BYTES;
 483
 484         r2.size = SZ_128;
 485         r2.base = r1.base - (r3_size + r2.size);
 486
 487         total_size = r1.size + r2.size + r3_size;
 488         min_addr = r2.base + r2.size;
 489         max_addr = r1.base;
 490
 491         memblock_reserve(r1.base, r1.size);
 492         memblock_reserve(r2.base, r2.size);
 493
 494         allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
 495                                                    min_addr, max_addr,
 496                                                    NUMA_NO_NODE);
 497
 498         ASSERT_NE(allocated_ptr, NULL);
 499         assert_mem_content(allocated_ptr, r3_size, alloc_nid_test_flags);
 500
 501         ASSERT_EQ(rgn->size, total_size);
 502         ASSERT_EQ(rgn->base, r2.base);
 503
 504         ASSERT_EQ(memblock.reserved.cnt, 1);
 505         ASSERT_EQ(memblock.reserved.total_size, total_size);
 506
 507         test_pass_pop();
 508
 509         return 0;
 510 }
 511
 512 /*
 513  * A test that tries to allocate memory within min_addr and max_add range, when
 514  * there are two reserved regions at the borders, with a gap that can't fit
 515  * a new region:
 516  *
 517  *                       +    +
 518  *  |  +----------+------+    +------+   |
 519  *  |  |    r3    |  r2  |    |  r1  |   |
 520  *  +--+----------+------+----+------+---+
 521  *                       ^    ^
 522  *                       |    |
 523  *                       |    max_addr
 524  *                       |
 525  *                       min_addr
 526  *
 527  * Expect to merge the new region with r2. The second region does not get
 528  * updated. The total size counter gets updated.
 529  */
 530 static int alloc_try_nid_top_down_reserved_no_space_check(void)
 531 {
 532         struct memblock_region *rgn1 = &memblock.reserved.regions[1];
 533         struct memblock_region *rgn2 = &memblock.reserved.regions[0];
 534         void *allocated_ptr = NULL;
 535         struct region r1, r2;
 536         phys_addr_t r3_size = SZ_256;
 537         phys_addr_t gap_size = SMP_CACHE_BYTES;
 538         phys_addr_t total_size;
 539         phys_addr_t max_addr;
 540         phys_addr_t min_addr;
 541
 542         PREFIX_PUSH();
 543         setup_memblock();
 544
 545         r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2;
 546         r1.size = SMP_CACHE_BYTES;
 547
 548         r2.size = SZ_128;
 549         r2.base = r1.base - (r2.size + gap_size);
 550
 551         total_size = r1.size + r2.size + r3_size;
 552         min_addr = r2.base + r2.size;
 553         max_addr = r1.base;
 554
 555         memblock_reserve(r1.base, r1.size);
 556         memblock_reserve(r2.base, r2.size);
 557
 558         allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
 559                                                    min_addr, max_addr,
 560                                                    NUMA_NO_NODE);
 561
 562         ASSERT_NE(allocated_ptr, NULL);
 563         assert_mem_content(allocated_ptr, r3_size, alloc_nid_test_flags);
 564
 565         ASSERT_EQ(rgn1->size, r1.size);
 566         ASSERT_EQ(rgn1->base, r1.base);
 567
 568         ASSERT_EQ(rgn2->size, r2.size + r3_size);
 569         ASSERT_EQ(rgn2->base, r2.base - r3_size);
 570
 571         ASSERT_EQ(memblock.reserved.cnt, 2);
 572         ASSERT_EQ(memblock.reserved.total_size, total_size);
 573
 574         test_pass_pop();
 575
 576         return 0;
 577 }
 578
 579 /*
 580  * A test that tries to allocate memory within min_addr and max_add range, but
 581  * it's too narrow and everything else is reserved:
 582  *
 583  *            +-----------+
 584  *            |    new    |
 585  *            +-----------+
 586  *                 +      +
 587  *  |--------------+      +----------|
 588  *  |      r2      |      |    r1    |
 589  *  +--------------+------+----------+
 590  *                 ^      ^
 591  *                 |      |
 592  *                 |      max_addr
 593  *                 |
 594  *                 min_addr
 595  *
 596  * Expect no allocation to happen.
 597  */
 598
 599 static int alloc_try_nid_reserved_all_generic_check(void)
 600 {
 601         void *allocated_ptr = NULL;
 602         struct region r1, r2;
 603         phys_addr_t r3_size = SZ_256;
 604         phys_addr_t gap_size = SMP_CACHE_BYTES;
 605         phys_addr_t max_addr;
 606         phys_addr_t min_addr;
 607
 608         PREFIX_PUSH();
 609         setup_memblock();
 610
 611         r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES;
 612         r1.size = SMP_CACHE_BYTES;
 613
 614         r2.size = MEM_SIZE - (r1.size + gap_size);
 615         r2.base = memblock_start_of_DRAM();
 616
 617         min_addr = r2.base + r2.size;
 618         max_addr = r1.base;
 619
 620         memblock_reserve(r1.base, r1.size);
 621         memblock_reserve(r2.base, r2.size);
 622
 623         allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
 624                                                    min_addr, max_addr,
 625                                                    NUMA_NO_NODE);
 626
 627         ASSERT_EQ(allocated_ptr, NULL);
 628
 629         test_pass_pop();
 630
 631         return 0;
 632 }
 633
 634 /*
 635  * A test that tries to allocate a memory region, where max_addr is
 636  * bigger than the end address of the available memory. Expect to allocate
 637  * a region that ends before the end of the memory.
 638  */
 639 static int alloc_try_nid_top_down_cap_max_check(void)
 640 {
 641         struct memblock_region *rgn = &memblock.reserved.regions[0];
 642         void *allocated_ptr = NULL;
 643         phys_addr_t size = SZ_256;
 644         phys_addr_t min_addr;
 645         phys_addr_t max_addr;
 646
 647         PREFIX_PUSH();
 648         setup_memblock();
 649
 650         min_addr = memblock_end_of_DRAM() - SZ_1K;
 651         max_addr = memblock_end_of_DRAM() + SZ_256;
 652
 653         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
 654                                                    min_addr, max_addr,
 655                                                    NUMA_NO_NODE);
 656
 657         ASSERT_NE(allocated_ptr, NULL);
 658         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
 659
 660         ASSERT_EQ(rgn->size, size);
 661         ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
 662
 663         ASSERT_EQ(memblock.reserved.cnt, 1);
 664         ASSERT_EQ(memblock.reserved.total_size, size);
 665
 666         test_pass_pop();
 667
 668         return 0;
 669 }
 670
 671 /*
 672  * A test that tries to allocate a memory region, where min_addr is
 673  * smaller than the start address of the available memory. Expect to allocate
 674  * a region that ends before the end of the memory.
 675  */
 676 static int alloc_try_nid_top_down_cap_min_check(void)
 677 {
 678         struct memblock_region *rgn = &memblock.reserved.regions[0];
 679         void *allocated_ptr = NULL;
 680         phys_addr_t size = SZ_1K;
 681         phys_addr_t min_addr;
 682         phys_addr_t max_addr;
 683
 684         PREFIX_PUSH();
 685         setup_memblock();
 686
 687         min_addr = memblock_start_of_DRAM() - SZ_256;
 688         max_addr = memblock_end_of_DRAM();
 689
 690         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
 691                                                    min_addr, max_addr,
 692                                                    NUMA_NO_NODE);
 693
 694         ASSERT_NE(allocated_ptr, NULL);
 695         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
 696
 697         ASSERT_EQ(rgn->size, size);
 698         ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
 699
 700         ASSERT_EQ(memblock.reserved.cnt, 1);
 701         ASSERT_EQ(memblock.reserved.total_size, size);
 702
 703         test_pass_pop();
 704
 705         return 0;
 706 }
 707
 708 /*
 709  * A simple test that tries to allocate a memory region within min_addr and
 710  * max_addr range:
 711  *
 712  *        +                       +
 713  *   |    +-----------+           |      |
 714  *   |    |    rgn    |           |      |
 715  *   +----+-----------+-----------+------+
 716  *        ^                       ^
 717  *        |                       |
 718  *        min_addr                max_addr
 719  *
 720  * Expect to allocate a region that ends before max_addr.
 721  */
 722 static int alloc_try_nid_bottom_up_simple_check(void)
 723 {
 724         struct memblock_region *rgn = &memblock.reserved.regions[0];
 725         void *allocated_ptr = NULL;
 726         phys_addr_t size = SZ_128;
 727         phys_addr_t min_addr;
 728         phys_addr_t max_addr;
 729         phys_addr_t rgn_end;
 730
 731         PREFIX_PUSH();
 732         setup_memblock();
 733
 734         min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2;
 735         max_addr = min_addr + SZ_512;
 736
 737         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
 738                                                    min_addr, max_addr,
 739                                                    NUMA_NO_NODE);
 740         rgn_end = rgn->base + rgn->size;
 741
 742         ASSERT_NE(allocated_ptr, NULL);
 743         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
 744
 745         ASSERT_EQ(rgn->size, size);
 746         ASSERT_EQ(rgn->base, min_addr);
 747         ASSERT_LT(rgn_end, max_addr);
 748
 749         ASSERT_EQ(memblock.reserved.cnt, 1);
 750         ASSERT_EQ(memblock.reserved.total_size, size);
 751
 752         test_pass_pop();
 753
 754         return 0;
 755 }
 756
 757 /*
 758  * A simple test that tries to allocate a memory region within min_addr and
 759  * max_addr range, where the start address is misaligned:
 760  *
 761  *        +                     +
 762  *  |     +   +-----------+     +     |
 763  *  |     |   |    rgn    |     |     |
 764  *  +-----+---+-----------+-----+-----+
 765  *        ^   ^----.            ^
 766  *        |        |            |
 767  *     min_add     |            max_addr
 768  *                 |
 769  *                 Aligned address
 770  *                 boundary
 771  *
 772  * Expect to allocate an aligned region that ends before max_addr.
 773  */
 774 static int alloc_try_nid_bottom_up_start_misaligned_check(void)
 775 {
 776         struct memblock_region *rgn = &memblock.reserved.regions[0];
 777         void *allocated_ptr = NULL;
 778         phys_addr_t size = SZ_128;
 779         phys_addr_t misalign = SZ_2;
 780         phys_addr_t min_addr;
 781         phys_addr_t max_addr;
 782         phys_addr_t rgn_end;
 783
 784         PREFIX_PUSH();
 785         setup_memblock();
 786
 787         min_addr = memblock_start_of_DRAM() + misalign;
 788         max_addr = min_addr + SZ_512;
 789
 790         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
 791                                                    min_addr, max_addr,
 792                                                    NUMA_NO_NODE);
 793         rgn_end = rgn->base + rgn->size;
 794
 795         ASSERT_NE(allocated_ptr, NULL);
 796         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
 797
 798         ASSERT_EQ(rgn->size, size);
 799         ASSERT_EQ(rgn->base, min_addr + (SMP_CACHE_BYTES - misalign));
 800         ASSERT_LT(rgn_end, max_addr);
 801
 802         ASSERT_EQ(memblock.reserved.cnt, 1);
 803         ASSERT_EQ(memblock.reserved.total_size, size);
 804
 805         test_pass_pop();
 806
 807         return 0;
 808 }
 809
 810 /*
 811  * A test that tries to allocate a memory region, which can't fit into min_addr
 812  * and max_addr range:
 813  *
 814  *                      +    +
 815  *  |---------+         +    +      |
 816  *  |   rgn   |         |    |      |
 817  *  +---------+---------+----+------+
 818  *                      ^    ^
 819  *                      |    |
 820  *                      |    max_addr
 821  *                      |
 822  *                      min_add
 823  *
 824  * Expect to drop the lower limit and allocate a memory region which
 825  * starts at the beginning of the available memory.
 826  */
 827 static int alloc_try_nid_bottom_up_narrow_range_check(void)
 828 {
 829         struct memblock_region *rgn = &memblock.reserved.regions[0];
 830         void *allocated_ptr = NULL;
 831         phys_addr_t size = SZ_256;
 832         phys_addr_t min_addr;
 833         phys_addr_t max_addr;
 834
 835         PREFIX_PUSH();
 836         setup_memblock();
 837
 838         min_addr = memblock_start_of_DRAM() + SZ_512;
 839         max_addr = min_addr + SMP_CACHE_BYTES;
 840
 841         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
 842                                                    min_addr, max_addr,
 843                                                    NUMA_NO_NODE);
 844
 845         ASSERT_NE(allocated_ptr, NULL);
 846         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
 847
 848         ASSERT_EQ(rgn->size, size);
 849         ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
 850
 851         ASSERT_EQ(memblock.reserved.cnt, 1);
 852         ASSERT_EQ(memblock.reserved.total_size, size);
 853
 854         test_pass_pop();
 855
 856         return 0;
 857 }
 858
 859 /*
 860  * A test that tries to allocate memory within min_addr and max_add range, when
 861  * there are two reserved regions at the borders, with a gap big enough to fit
 862  * a new region:
 863  *
 864  *                +           +
 865  *  |    +--------+-------+   +------+  |
 866  *  |    |   r2   |  rgn  |   |  r1  |  |
 867  *  +----+--------+-------+---+------+--+
 868  *                ^           ^
 869  *                |           |
 870  *                min_addr    max_addr
 871  *
 872  * Expect to merge the new region with r2. The second region does not get
 873  * updated. The total size field gets updated.
 874  */
 875
 876 static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
 877 {
 878         struct memblock_region *rgn1 = &memblock.reserved.regions[1];
 879         struct memblock_region *rgn2 = &memblock.reserved.regions[0];
 880         void *allocated_ptr = NULL;
 881         struct region r1, r2;
 882         phys_addr_t r3_size = SZ_64;
 883         phys_addr_t gap_size = SMP_CACHE_BYTES;
 884         phys_addr_t total_size;
 885         phys_addr_t max_addr;
 886         phys_addr_t min_addr;
 887
 888         PREFIX_PUSH();
 889         setup_memblock();
 890
 891         r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2;
 892         r1.size = SMP_CACHE_BYTES;
 893
 894         r2.size = SZ_128;
 895         r2.base = r1.base - (r3_size + gap_size + r2.size);
 896
 897         total_size = r1.size + r2.size + r3_size;
 898         min_addr = r2.base + r2.size;
 899         max_addr = r1.base;
 900
 901         memblock_reserve(r1.base, r1.size);
 902         memblock_reserve(r2.base, r2.size);
 903
 904         allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
 905                                                    min_addr, max_addr,
 906                                                    NUMA_NO_NODE);
 907
 908         ASSERT_NE(allocated_ptr, NULL);
 909         assert_mem_content(allocated_ptr, r3_size, alloc_nid_test_flags);
 910
 911         ASSERT_EQ(rgn1->size, r1.size);
 912         ASSERT_EQ(rgn1->base, max_addr);
 913
 914         ASSERT_EQ(rgn2->size, r2.size + r3_size);
 915         ASSERT_EQ(rgn2->base, r2.base);
 916
 917         ASSERT_EQ(memblock.reserved.cnt, 2);
 918         ASSERT_EQ(memblock.reserved.total_size, total_size);
 919
 920         test_pass_pop();
 921
 922         return 0;
 923 }
 924
 925 /*
 926  * A test that tries to allocate memory within min_addr and max_add range, when
 927  * there are two reserved regions at the borders, with a gap of a size equal to
 928  * the size of the new region:
 929  *
 930  *                         +   +
 931  *  |----------+    +------+   +----+  |
 932  *  |    r3    |    |  r2  |   | r1 |  |
 933  *  +----------+----+------+---+----+--+
 934  *                         ^   ^
 935  *                         |   |
 936  *                         |  max_addr
 937  *                         |
 938  *                         min_addr
 939  *
 940  * Expect to drop the lower limit and allocate memory at the beginning of the
 941  * available memory. The region counter and total size fields get updated.
 942  * Other regions are not modified.
 943  */
 944
 945 static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
 946 {
 947         struct memblock_region *rgn1 = &memblock.reserved.regions[2];
 948         struct memblock_region *rgn2 = &memblock.reserved.regions[1];
 949         struct memblock_region *rgn3 = &memblock.reserved.regions[0];
 950         void *allocated_ptr = NULL;
 951         struct region r1, r2;
 952         phys_addr_t r3_size = SZ_256;
 953         phys_addr_t gap_size = SMP_CACHE_BYTES;
 954         phys_addr_t total_size;
 955         phys_addr_t max_addr;
 956         phys_addr_t min_addr;
 957
 958         PREFIX_PUSH();
 959         setup_memblock();
 960
 961         r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2;
 962         r1.size = SMP_CACHE_BYTES;
 963
 964         r2.size = SZ_128;
 965         r2.base = r1.base - (r2.size + gap_size);
 966
 967         total_size = r1.size + r2.size + r3_size;
 968         min_addr = r2.base + r2.size;
 969         max_addr = r1.base;
 970
 971         memblock_reserve(r1.base, r1.size);
 972         memblock_reserve(r2.base, r2.size);
 973
 974         allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
 975                                                    min_addr, max_addr,
 976                                                    NUMA_NO_NODE);
 977
 978         ASSERT_NE(allocated_ptr, NULL);
 979         assert_mem_content(allocated_ptr, r3_size, alloc_nid_test_flags);
 980
 981         ASSERT_EQ(rgn3->size, r3_size);
 982         ASSERT_EQ(rgn3->base, memblock_start_of_DRAM());
 983
 984         ASSERT_EQ(rgn2->size, r2.size);
 985         ASSERT_EQ(rgn2->base, r2.base);
 986
 987         ASSERT_EQ(rgn1->size, r1.size);
 988         ASSERT_EQ(rgn1->base, r1.base);
 989
 990         ASSERT_EQ(memblock.reserved.cnt, 3);
 991         ASSERT_EQ(memblock.reserved.total_size, total_size);
 992
 993         test_pass_pop();
 994
 995         return 0;
 996 }
 997
 998 /*
 999  * A test that tries to allocate a memory region, where max_addr is
1000  * bigger than the end address of the available memory. Expect to allocate
1001  * a region that starts at the min_addr.
1002  */
1003 static int alloc_try_nid_bottom_up_cap_max_check(void)
1004 {
1005         struct memblock_region *rgn = &memblock.reserved.regions[0];
1006         void *allocated_ptr = NULL;
1007         phys_addr_t size = SZ_256;
1008         phys_addr_t min_addr;
1009         phys_addr_t max_addr;
1010
1011         PREFIX_PUSH();
1012         setup_memblock();
1013
1014         min_addr = memblock_start_of_DRAM() + SZ_1K;
1015         max_addr = memblock_end_of_DRAM() + SZ_256;
1016
1017         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
1018                                                    min_addr, max_addr,
1019                                                    NUMA_NO_NODE);
1020
1021         ASSERT_NE(allocated_ptr, NULL);
1022         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1023
1024         ASSERT_EQ(rgn->size, size);
1025         ASSERT_EQ(rgn->base, min_addr);
1026
1027         ASSERT_EQ(memblock.reserved.cnt, 1);
1028         ASSERT_EQ(memblock.reserved.total_size, size);
1029
1030         test_pass_pop();
1031
1032         return 0;
1033 }
1034
1035 /*
1036  * A test that tries to allocate a memory region, where min_addr is
1037  * smaller than the start address of the available memory. Expect to allocate
1038  * a region at the beginning of the available memory.
1039  */
1040 static int alloc_try_nid_bottom_up_cap_min_check(void)
1041 {
1042         struct memblock_region *rgn = &memblock.reserved.regions[0];
1043         void *allocated_ptr = NULL;
1044         phys_addr_t size = SZ_1K;
1045         phys_addr_t min_addr;
1046         phys_addr_t max_addr;
1047
1048         PREFIX_PUSH();
1049         setup_memblock();
1050
1051         min_addr = memblock_start_of_DRAM();
1052         max_addr = memblock_end_of_DRAM() - SZ_256;
1053
1054         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
1055                                                    min_addr, max_addr,
1056                                                    NUMA_NO_NODE);
1057
1058         ASSERT_NE(allocated_ptr, NULL);
1059         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1060
1061         ASSERT_EQ(rgn->size, size);
1062         ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
1063
1064         ASSERT_EQ(memblock.reserved.cnt, 1);
1065         ASSERT_EQ(memblock.reserved.total_size, size);
1066
1067         test_pass_pop();
1068
1069         return 0;
1070 }
1071
1072 /* Test case wrappers for range tests */
1073 static int alloc_try_nid_simple_check(void)
1074 {
1075         test_print("\tRunning %s...\n", __func__);
1076         memblock_set_bottom_up(false);
1077         alloc_try_nid_top_down_simple_check();
1078         memblock_set_bottom_up(true);
1079         alloc_try_nid_bottom_up_simple_check();
1080
1081         return 0;
1082 }
1083
1084 static int alloc_try_nid_misaligned_check(void)
1085 {
1086         test_print("\tRunning %s...\n", __func__);
1087         memblock_set_bottom_up(false);
1088         alloc_try_nid_top_down_end_misaligned_check();
1089         memblock_set_bottom_up(true);
1090         alloc_try_nid_bottom_up_start_misaligned_check();
1091
1092         return 0;
1093 }
1094
1095 static int alloc_try_nid_narrow_range_check(void)
1096 {
1097         test_print("\tRunning %s...\n", __func__);
1098         memblock_set_bottom_up(false);
1099         alloc_try_nid_top_down_narrow_range_check();
1100         memblock_set_bottom_up(true);
1101         alloc_try_nid_bottom_up_narrow_range_check();
1102
1103         return 0;
1104 }
1105
1106 static int alloc_try_nid_reserved_with_space_check(void)
1107 {
1108         test_print("\tRunning %s...\n", __func__);
1109         memblock_set_bottom_up(false);
1110         alloc_try_nid_top_down_reserved_with_space_check();
1111         memblock_set_bottom_up(true);
1112         alloc_try_nid_bottom_up_reserved_with_space_check();
1113
1114         return 0;
1115 }
1116
1117 static int alloc_try_nid_reserved_no_space_check(void)
1118 {
1119         test_print("\tRunning %s...\n", __func__);
1120         memblock_set_bottom_up(false);
1121         alloc_try_nid_top_down_reserved_no_space_check();
1122         memblock_set_bottom_up(true);
1123         alloc_try_nid_bottom_up_reserved_no_space_check();
1124
1125         return 0;
1126 }
1127
1128 static int alloc_try_nid_cap_max_check(void)
1129 {
1130         test_print("\tRunning %s...\n", __func__);
1131         memblock_set_bottom_up(false);
1132         alloc_try_nid_top_down_cap_max_check();
1133         memblock_set_bottom_up(true);
1134         alloc_try_nid_bottom_up_cap_max_check();
1135
1136         return 0;
1137 }
1138
1139 static int alloc_try_nid_cap_min_check(void)
1140 {
1141         test_print("\tRunning %s...\n", __func__);
1142         memblock_set_bottom_up(false);
1143         alloc_try_nid_top_down_cap_min_check();
1144         memblock_set_bottom_up(true);
1145         alloc_try_nid_bottom_up_cap_min_check();
1146
1147         return 0;
1148 }
1149
1150 static int alloc_try_nid_min_reserved_check(void)
1151 {
1152         test_print("\tRunning %s...\n", __func__);
1153         run_top_down(alloc_try_nid_min_reserved_generic_check);
1154         run_bottom_up(alloc_try_nid_min_reserved_generic_check);
1155
1156         return 0;
1157 }
1158
1159 static int alloc_try_nid_max_reserved_check(void)
1160 {
1161         test_print("\tRunning %s...\n", __func__);
1162         run_top_down(alloc_try_nid_max_reserved_generic_check);
1163         run_bottom_up(alloc_try_nid_max_reserved_generic_check);
1164
1165         return 0;
1166 }
1167
1168 static int alloc_try_nid_exact_address_check(void)
1169 {
1170         test_print("\tRunning %s...\n", __func__);
1171         run_top_down(alloc_try_nid_exact_address_generic_check);
1172         run_bottom_up(alloc_try_nid_exact_address_generic_check);
1173
1174         return 0;
1175 }
1176
1177 static int alloc_try_nid_reserved_full_merge_check(void)
1178 {
1179         test_print("\tRunning %s...\n", __func__);
1180         run_top_down(alloc_try_nid_reserved_full_merge_generic_check);
1181         run_bottom_up(alloc_try_nid_reserved_full_merge_generic_check);
1182
1183         return 0;
1184 }
1185
1186 static int alloc_try_nid_reserved_all_check(void)
1187 {
1188         test_print("\tRunning %s...\n", __func__);
1189         run_top_down(alloc_try_nid_reserved_all_generic_check);
1190         run_bottom_up(alloc_try_nid_reserved_all_generic_check);
1191
1192         return 0;
1193 }
1194
1195 static int alloc_try_nid_low_max_check(void)
1196 {
1197         test_print("\tRunning %s...\n", __func__);
1198         run_top_down(alloc_try_nid_low_max_generic_check);
1199         run_bottom_up(alloc_try_nid_low_max_generic_check);
1200
1201         return 0;
1202 }
1203
1204 static int memblock_alloc_nid_range_checks(void)
1205 {
1206         test_print("Running %s range tests...\n",
1207                    get_memblock_alloc_try_nid_name(alloc_nid_test_flags));
1208
1209         alloc_try_nid_simple_check();
1210         alloc_try_nid_misaligned_check();
1211         alloc_try_nid_narrow_range_check();
1212         alloc_try_nid_reserved_with_space_check();
1213         alloc_try_nid_reserved_no_space_check();
1214         alloc_try_nid_cap_max_check();
1215         alloc_try_nid_cap_min_check();
1216
1217         alloc_try_nid_min_reserved_check();
1218         alloc_try_nid_max_reserved_check();
1219         alloc_try_nid_exact_address_check();
1220         alloc_try_nid_reserved_full_merge_check();
1221         alloc_try_nid_reserved_all_check();
1222         alloc_try_nid_low_max_check();
1223
1224         return 0;
1225 }
1226
1227 /*
1228  * A test that tries to allocate a memory region in a specific NUMA node that
1229  * has enough memory to allocate a region of the requested size.
1230  * Expect to allocate an aligned region at the end of the requested node.
1231  */
1232 static int alloc_try_nid_top_down_numa_simple_check(void)
1233 {
1234         int nid_req = 3;
1235         struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1236         struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1237         void *allocated_ptr = NULL;
1238         phys_addr_t size;
1239         phys_addr_t min_addr;
1240         phys_addr_t max_addr;
1241
1242         PREFIX_PUSH();
1243         setup_numa_memblock(node_fractions);
1244
1245         ASSERT_LE(SZ_4, req_node->size);
1246         size = req_node->size / SZ_4;
1247         min_addr = memblock_start_of_DRAM();
1248         max_addr = memblock_end_of_DRAM();
1249
1250         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
1251                                                    min_addr, max_addr, nid_req);
1252
1253         ASSERT_NE(allocated_ptr, NULL);
1254         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1255
1256         ASSERT_EQ(new_rgn->size, size);
1257         ASSERT_EQ(new_rgn->base, region_end(req_node) - size);
1258         ASSERT_LE(req_node->base, new_rgn->base);
1259
1260         ASSERT_EQ(memblock.reserved.cnt, 1);
1261         ASSERT_EQ(memblock.reserved.total_size, size);
1262
1263         test_pass_pop();
1264
1265         return 0;
1266 }
1267
1268 /*
1269  * A test that tries to allocate a memory region in a specific NUMA node that
1270  * does not have enough memory to allocate a region of the requested size:
1271  *
1272  *  |   +-----+          +------------------+     |
1273  *  |   | req |          |     expected     |     |
1274  *  +---+-----+----------+------------------+-----+
1275  *
1276  *  |                             +---------+     |
1277  *  |                             |   rgn   |     |
1278  *  +-----------------------------+---------+-----+
1279  *
1280  * Expect to allocate an aligned region at the end of the last node that has
1281  * enough memory (in this case, nid = 6) after falling back to NUMA_NO_NODE.
1282  */
1283 static int alloc_try_nid_top_down_numa_small_node_check(void)
1284 {
1285         int nid_req = 1;
1286         int nid_exp = 6;
1287         struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1288         struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1289         struct memblock_region *exp_node = &memblock.memory.regions[nid_exp];
1290         void *allocated_ptr = NULL;
1291         phys_addr_t size;
1292         phys_addr_t min_addr;
1293         phys_addr_t max_addr;
1294
1295         PREFIX_PUSH();
1296         setup_numa_memblock(node_fractions);
1297
1298         size = SZ_2 * req_node->size;
1299         min_addr = memblock_start_of_DRAM();
1300         max_addr = memblock_end_of_DRAM();
1301
1302         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
1303                                                    min_addr, max_addr, nid_req);
1304
1305         ASSERT_NE(allocated_ptr, NULL);
1306         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1307
1308         ASSERT_EQ(new_rgn->size, size);
1309         ASSERT_EQ(new_rgn->base, region_end(exp_node) - size);
1310         ASSERT_LE(exp_node->base, new_rgn->base);
1311
1312         ASSERT_EQ(memblock.reserved.cnt, 1);
1313         ASSERT_EQ(memblock.reserved.total_size, size);
1314
1315         test_pass_pop();
1316
1317         return 0;
1318 }
1319
1320 /*
1321  * A test that tries to allocate a memory region in a specific NUMA node that
1322  * is fully reserved:
1323  *
1324  *  |              +---------+            +------------------+     |
1325  *  |              |requested|            |     expected     |     |
1326  *  +--------------+---------+------------+------------------+-----+
1327  *
1328  *  |              +---------+                     +---------+     |
1329  *  |              | reserved|                     |   new   |     |
1330  *  +--------------+---------+---------------------+---------+-----+
1331  *
1332  * Expect to allocate an aligned region at the end of the last node that is
1333  * large enough and has enough unreserved memory (in this case, nid = 6) after
1334  * falling back to NUMA_NO_NODE. The region count and total size get updated.
1335  */
1336 static int alloc_try_nid_top_down_numa_node_reserved_check(void)
1337 {
1338         int nid_req = 2;
1339         int nid_exp = 6;
1340         struct memblock_region *new_rgn = &memblock.reserved.regions[1];
1341         struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1342         struct memblock_region *exp_node = &memblock.memory.regions[nid_exp];
1343         void *allocated_ptr = NULL;
1344         phys_addr_t size;
1345         phys_addr_t min_addr;
1346         phys_addr_t max_addr;
1347
1348         PREFIX_PUSH();
1349         setup_numa_memblock(node_fractions);
1350
1351         size = req_node->size;
1352         min_addr = memblock_start_of_DRAM();
1353         max_addr = memblock_end_of_DRAM();
1354
1355         memblock_reserve(req_node->base, req_node->size);
1356         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
1357                                                    min_addr, max_addr, nid_req);
1358
1359         ASSERT_NE(allocated_ptr, NULL);
1360         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1361
1362         ASSERT_EQ(new_rgn->size, size);
1363         ASSERT_EQ(new_rgn->base, region_end(exp_node) - size);
1364         ASSERT_LE(exp_node->base, new_rgn->base);
1365
1366         ASSERT_EQ(memblock.reserved.cnt, 2);
1367         ASSERT_EQ(memblock.reserved.total_size, size + req_node->size);
1368
1369         test_pass_pop();
1370
1371         return 0;
1372 }
1373
1374 /*
1375  * A test that tries to allocate a memory region in a specific NUMA node that
1376  * is partially reserved but has enough memory for the allocated region:
1377  *
1378  *  |           +---------------------------------------+          |
1379  *  |           |               requested               |          |
1380  *  +-----------+---------------------------------------+----------+
1381  *
1382  *  |           +------------------+              +-----+          |
1383  *  |           |     reserved     |              | new |          |
1384  *  +-----------+------------------+--------------+-----+----------+
1385  *
1386  * Expect to allocate an aligned region at the end of the requested node. The
1387  * region count and total size get updated.
1388  */
1389 static int alloc_try_nid_top_down_numa_part_reserved_check(void)
1390 {
1391         int nid_req = 4;
1392         struct memblock_region *new_rgn = &memblock.reserved.regions[1];
1393         struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1394         void *allocated_ptr = NULL;
1395         struct region r1;
1396         phys_addr_t size;
1397         phys_addr_t min_addr;
1398         phys_addr_t max_addr;
1399
1400         PREFIX_PUSH();
1401         setup_numa_memblock(node_fractions);
1402
1403         ASSERT_LE(SZ_8, req_node->size);
1404         r1.base = req_node->base;
1405         r1.size = req_node->size / SZ_2;
1406         size = r1.size / SZ_4;
1407         min_addr = memblock_start_of_DRAM();
1408         max_addr = memblock_end_of_DRAM();
1409
1410         memblock_reserve(r1.base, r1.size);
1411         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
1412                                                    min_addr, max_addr, nid_req);
1413
1414         ASSERT_NE(allocated_ptr, NULL);
1415         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1416
1417         ASSERT_EQ(new_rgn->size, size);
1418         ASSERT_EQ(new_rgn->base, region_end(req_node) - size);
1419         ASSERT_LE(req_node->base, new_rgn->base);
1420
1421         ASSERT_EQ(memblock.reserved.cnt, 2);
1422         ASSERT_EQ(memblock.reserved.total_size, size + r1.size);
1423
1424         test_pass_pop();
1425
1426         return 0;
1427 }
1428
1429 /*
1430  * A test that tries to allocate a memory region in a specific NUMA node that
1431  * is partially reserved and does not have enough contiguous memory for the
1432  * allocated region:
1433  *
1434  *  |           +-----------------------+         +----------------------|
1435  *  |           |       requested       |         |       expected       |
1436  *  +-----------+-----------------------+---------+----------------------+
1437  *
1438  *  |                 +----------+                           +-----------|
1439  *  |                 | reserved |                           |    new    |
1440  *  +-----------------+----------+---------------------------+-----------+
1441  *
1442  * Expect to allocate an aligned region at the end of the last node that is
1443  * large enough and has enough unreserved memory (in this case,
1444  * nid = NUMA_NODES - 1) after falling back to NUMA_NO_NODE. The region count
1445  * and total size get updated.
1446  */
1447 static int alloc_try_nid_top_down_numa_part_reserved_fallback_check(void)
1448 {
1449         int nid_req = 4;
1450         int nid_exp = NUMA_NODES - 1;
1451         struct memblock_region *new_rgn = &memblock.reserved.regions[1];
1452         struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1453         struct memblock_region *exp_node = &memblock.memory.regions[nid_exp];
1454         void *allocated_ptr = NULL;
1455         struct region r1;
1456         phys_addr_t size;
1457         phys_addr_t min_addr;
1458         phys_addr_t max_addr;
1459
1460         PREFIX_PUSH();
1461         setup_numa_memblock(node_fractions);
1462
1463         ASSERT_LE(SZ_4, req_node->size);
1464         size = req_node->size / SZ_2;
1465         r1.base = req_node->base + (size / SZ_2);
1466         r1.size = size;
1467
1468         min_addr = memblock_start_of_DRAM();
1469         max_addr = memblock_end_of_DRAM();
1470
1471         memblock_reserve(r1.base, r1.size);
1472         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
1473                                                    min_addr, max_addr, nid_req);
1474
1475         ASSERT_NE(allocated_ptr, NULL);
1476         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1477
1478         ASSERT_EQ(new_rgn->size, size);
1479         ASSERT_EQ(new_rgn->base, region_end(exp_node) - size);
1480         ASSERT_LE(exp_node->base, new_rgn->base);
1481
1482         ASSERT_EQ(memblock.reserved.cnt, 2);
1483         ASSERT_EQ(memblock.reserved.total_size, size + r1.size);
1484
1485         test_pass_pop();
1486
1487         return 0;
1488 }
1489
1490 /*
1491  * A test that tries to allocate a memory region that spans over the min_addr
1492  * and max_addr range and overlaps with two different nodes, where the first
1493  * node is the requested node:
1494  *
1495  *                                min_addr
1496  *                                |           max_addr
1497  *                                |           |
1498  *                                v           v
1499  *  |           +-----------------------+-----------+              |
1500  *  |           |       requested       |   node3   |              |
1501  *  +-----------+-----------------------+-----------+--------------+
1502  *                                +           +
1503  *  |                       +-----------+                          |
1504  *  |                       |    rgn    |                          |
1505  *  +-----------------------+-----------+--------------------------+
1506  *
1507  * Expect to drop the lower limit and allocate a memory region that ends at
1508  * the end of the requested node.
1509  */
1510 static int alloc_try_nid_top_down_numa_split_range_low_check(void)
1511 {
1512         int nid_req = 2;
1513         struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1514         struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1515         void *allocated_ptr = NULL;
1516         phys_addr_t size = SZ_512;
1517         phys_addr_t min_addr;
1518         phys_addr_t max_addr;
1519         phys_addr_t req_node_end;
1520
1521         PREFIX_PUSH();
1522         setup_numa_memblock(node_fractions);
1523
1524         req_node_end = region_end(req_node);
1525         min_addr = req_node_end - SZ_256;
1526         max_addr = min_addr + size;
1527
1528         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
1529                                                    min_addr, max_addr, nid_req);
1530
1531         ASSERT_NE(allocated_ptr, NULL);
1532         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1533
1534         ASSERT_EQ(new_rgn->size, size);
1535         ASSERT_EQ(new_rgn->base, req_node_end - size);
1536         ASSERT_LE(req_node->base, new_rgn->base);
1537
1538         ASSERT_EQ(memblock.reserved.cnt, 1);
1539         ASSERT_EQ(memblock.reserved.total_size, size);
1540
1541         test_pass_pop();
1542
1543         return 0;
1544 }
1545
1546 /*
1547  * A test that tries to allocate a memory region that spans over the min_addr
1548  * and max_addr range and overlaps with two different nodes, where the second
1549  * node is the requested node:
1550  *
1551  *                               min_addr
1552  *                               |         max_addr
1553  *                               |         |
1554  *                               v         v
1555  *  |      +--------------------------+---------+                |
1556  *  |      |         expected         |requested|                |
1557  *  +------+--------------------------+---------+----------------+
1558  *                               +         +
1559  *  |                       +---------+                          |
1560  *  |                       |   rgn   |                          |
1561  *  +-----------------------+---------+--------------------------+
1562  *
1563  * Expect to drop the lower limit and allocate a memory region that
1564  * ends at the end of the first node that overlaps with the range.
1565  */
1566 static int alloc_try_nid_top_down_numa_split_range_high_check(void)
1567 {
1568         int nid_req = 3;
1569         int nid_exp = nid_req - 1;
1570         struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1571         struct memblock_region *exp_node = &memblock.memory.regions[nid_exp];
1572         void *allocated_ptr = NULL;
1573         phys_addr_t size = SZ_512;
1574         phys_addr_t min_addr;
1575         phys_addr_t max_addr;
1576         phys_addr_t exp_node_end;
1577
1578         PREFIX_PUSH();
1579         setup_numa_memblock(node_fractions);
1580
1581         exp_node_end = region_end(exp_node);
1582         min_addr = exp_node_end - SZ_256;
1583         max_addr = min_addr + size;
1584
1585         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
1586                                                    min_addr, max_addr, nid_req);
1587
1588         ASSERT_NE(allocated_ptr, NULL);
1589         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1590
1591         ASSERT_EQ(new_rgn->size, size);
1592         ASSERT_EQ(new_rgn->base, exp_node_end - size);
1593         ASSERT_LE(exp_node->base, new_rgn->base);
1594
1595         ASSERT_EQ(memblock.reserved.cnt, 1);
1596         ASSERT_EQ(memblock.reserved.total_size, size);
1597
1598         test_pass_pop();
1599
1600         return 0;
1601 }
1602
1603 /*
1604  * A test that tries to allocate a memory region that spans over the min_addr
1605  * and max_addr range and overlaps with two different nodes, where the requested
1606  * node ends before min_addr:
1607  *
1608  *                                         min_addr
1609  *                                         |         max_addr
1610  *                                         |         |
1611  *                                         v         v
1612  *  |    +---------------+        +-------------+---------+          |
1613  *  |    |   requested   |        |    node1    |  node2  |          |
1614  *  +----+---------------+--------+-------------+---------+----------+
1615  *                                         +         +
1616  *  |          +---------+                                           |
1617  *  |          |   rgn   |                                           |
1618  *  +----------+---------+-------------------------------------------+
1619  *
1620  * Expect to drop the lower limit and allocate a memory region that ends at
1621  * the end of the requested node.
1622  */
1623 static int alloc_try_nid_top_down_numa_no_overlap_split_check(void)
1624 {
1625         int nid_req = 2;
1626         struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1627         struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1628         struct memblock_region *node2 = &memblock.memory.regions[6];
1629         void *allocated_ptr = NULL;
1630         phys_addr_t size;
1631         phys_addr_t min_addr;
1632         phys_addr_t max_addr;
1633
1634         PREFIX_PUSH();
1635         setup_numa_memblock(node_fractions);
1636
1637         size = SZ_512;
1638         min_addr = node2->base - SZ_256;
1639         max_addr = min_addr + size;
1640
1641         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
1642                                                    min_addr, max_addr, nid_req);
1643
1644         ASSERT_NE(allocated_ptr, NULL);
1645         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1646
1647         ASSERT_EQ(new_rgn->size, size);
1648         ASSERT_EQ(new_rgn->base, region_end(req_node) - size);
1649         ASSERT_LE(req_node->base, new_rgn->base);
1650
1651         ASSERT_EQ(memblock.reserved.cnt, 1);
1652         ASSERT_EQ(memblock.reserved.total_size, size);
1653
1654         test_pass_pop();
1655
1656         return 0;
1657 }
1658
1659 /*
1660  * A test that tries to allocate memory within min_addr and max_add range when
1661  * the requested node and the range do not overlap, and requested node ends
1662  * before min_addr. The range overlaps with multiple nodes along node
1663  * boundaries:
1664  *
1665  *                          min_addr
1666  *                          |                                 max_addr
1667  *                          |                                 |
1668  *                          v                                 v
1669  *  |-----------+           +----------+----...----+----------+      |
1670  *  | requested |           | min node |    ...    | max node |      |
1671  *  +-----------+-----------+----------+----...----+----------+------+
1672  *                          +                                 +
1673  *  |                                                   +-----+      |
1674  *  |                                                   | rgn |      |
1675  *  +---------------------------------------------------+-----+------+
1676  *
1677  * Expect to allocate a memory region at the end of the final node in
1678  * the range after falling back to NUMA_NO_NODE.
1679  */
1680 static int alloc_try_nid_top_down_numa_no_overlap_low_check(void)
1681 {
1682         int nid_req = 0;
1683         struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1684         struct memblock_region *min_node = &memblock.memory.regions[2];
1685         struct memblock_region *max_node = &memblock.memory.regions[5];
1686         void *allocated_ptr = NULL;
1687         phys_addr_t size = SZ_64;
1688         phys_addr_t max_addr;
1689         phys_addr_t min_addr;
1690
1691         PREFIX_PUSH();
1692         setup_numa_memblock(node_fractions);
1693
1694         min_addr = min_node->base;
1695         max_addr = region_end(max_node);
1696
1697         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
1698                                                    min_addr, max_addr, nid_req);
1699
1700         ASSERT_NE(allocated_ptr, NULL);
1701         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1702
1703         ASSERT_EQ(new_rgn->size, size);
1704         ASSERT_EQ(new_rgn->base, max_addr - size);
1705         ASSERT_LE(max_node->base, new_rgn->base);
1706
1707         ASSERT_EQ(memblock.reserved.cnt, 1);
1708         ASSERT_EQ(memblock.reserved.total_size, size);
1709
1710         test_pass_pop();
1711
1712         return 0;
1713 }
1714
1715 /*
1716  * A test that tries to allocate memory within min_addr and max_add range when
1717  * the requested node and the range do not overlap, and requested node starts
1718  * after max_addr. The range overlaps with multiple nodes along node
1719  * boundaries:
1720  *
1721  *        min_addr
1722  *        |                                 max_addr
1723  *        |                                 |
1724  *        v                                 v
1725  *  |     +----------+----...----+----------+        +-----------+   |
1726  *  |     | min node |    ...    | max node |        | requested |   |
1727  *  +-----+----------+----...----+----------+--------+-----------+---+
1728  *        +                                 +
1729  *  |                                 +-----+                        |
1730  *  |                                 | rgn |                        |
1731  *  +---------------------------------+-----+------------------------+
1732  *
1733  * Expect to allocate a memory region at the end of the final node in
1734  * the range after falling back to NUMA_NO_NODE.
1735  */
1736 static int alloc_try_nid_top_down_numa_no_overlap_high_check(void)
1737 {
1738         int nid_req = 7;
1739         struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1740         struct memblock_region *min_node = &memblock.memory.regions[2];
1741         struct memblock_region *max_node = &memblock.memory.regions[5];
1742         void *allocated_ptr = NULL;
1743         phys_addr_t size = SZ_64;
1744         phys_addr_t max_addr;
1745         phys_addr_t min_addr;
1746
1747         PREFIX_PUSH();
1748         setup_numa_memblock(node_fractions);
1749
1750         min_addr = min_node->base;
1751         max_addr = region_end(max_node);
1752
1753         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
1754                                                    min_addr, max_addr, nid_req);
1755
1756         ASSERT_NE(allocated_ptr, NULL);
1757         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1758
1759         ASSERT_EQ(new_rgn->size, size);
1760         ASSERT_EQ(new_rgn->base, max_addr - size);
1761         ASSERT_LE(max_node->base, new_rgn->base);
1762
1763         ASSERT_EQ(memblock.reserved.cnt, 1);
1764         ASSERT_EQ(memblock.reserved.total_size, size);
1765
1766         test_pass_pop();
1767
1768         return 0;
1769 }
1770
1771 /*
1772  * A test that tries to allocate a memory region in a specific NUMA node that
1773  * has enough memory to allocate a region of the requested size.
1774  * Expect to allocate an aligned region at the beginning of the requested node.
1775  */
1776 static int alloc_try_nid_bottom_up_numa_simple_check(void)
1777 {
1778         int nid_req = 3;
1779         struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1780         struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1781         void *allocated_ptr = NULL;
1782         phys_addr_t size;
1783         phys_addr_t min_addr;
1784         phys_addr_t max_addr;
1785
1786         PREFIX_PUSH();
1787         setup_numa_memblock(node_fractions);
1788
1789         ASSERT_LE(SZ_4, req_node->size);
1790         size = req_node->size / SZ_4;
1791         min_addr = memblock_start_of_DRAM();
1792         max_addr = memblock_end_of_DRAM();
1793
1794         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
1795                                                    min_addr, max_addr, nid_req);
1796
1797         ASSERT_NE(allocated_ptr, NULL);
1798         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1799
1800         ASSERT_EQ(new_rgn->size, size);
1801         ASSERT_EQ(new_rgn->base, req_node->base);
1802         ASSERT_LE(region_end(new_rgn), region_end(req_node));
1803
1804         ASSERT_EQ(memblock.reserved.cnt, 1);
1805         ASSERT_EQ(memblock.reserved.total_size, size);
1806
1807         test_pass_pop();
1808
1809         return 0;
1810 }
1811
1812 /*
1813  * A test that tries to allocate a memory region in a specific NUMA node that
1814  * does not have enough memory to allocate a region of the requested size:
1815  *
1816  *  |----------------------+-----+                |
1817  *  |       expected       | req |                |
1818  *  +----------------------+-----+----------------+
1819  *
1820  *  |---------+                                   |
1821  *  |   rgn   |                                   |
1822  *  +---------+-----------------------------------+
1823  *
1824  * Expect to allocate an aligned region at the beginning of the first node that
1825  * has enough memory (in this case, nid = 0) after falling back to NUMA_NO_NODE.
1826  */
1827 static int alloc_try_nid_bottom_up_numa_small_node_check(void)
1828 {
1829         int nid_req = 1;
1830         int nid_exp = 0;
1831         struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1832         struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1833         struct memblock_region *exp_node = &memblock.memory.regions[nid_exp];
1834         void *allocated_ptr = NULL;
1835         phys_addr_t size;
1836         phys_addr_t min_addr;
1837         phys_addr_t max_addr;
1838
1839         PREFIX_PUSH();
1840         setup_numa_memblock(node_fractions);
1841
1842         size = SZ_2 * req_node->size;
1843         min_addr = memblock_start_of_DRAM();
1844         max_addr = memblock_end_of_DRAM();
1845
1846         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
1847                                                    min_addr, max_addr, nid_req);
1848
1849         ASSERT_NE(allocated_ptr, NULL);
1850         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1851
1852         ASSERT_EQ(new_rgn->size, size);
1853         ASSERT_EQ(new_rgn->base, exp_node->base);
1854         ASSERT_LE(region_end(new_rgn), region_end(exp_node));
1855
1856         ASSERT_EQ(memblock.reserved.cnt, 1);
1857         ASSERT_EQ(memblock.reserved.total_size, size);
1858
1859         test_pass_pop();
1860
1861         return 0;
1862 }
1863
1864 /*
1865  * A test that tries to allocate a memory region in a specific NUMA node that
1866  * is fully reserved:
1867  *
1868  *  |----------------------+     +-----------+                    |
1869  *  |       expected       |     | requested |                    |
1870  *  +----------------------+-----+-----------+--------------------+
1871  *
1872  *  |-----------+                +-----------+                    |
1873  *  |    new    |                |  reserved |                    |
1874  *  +-----------+----------------+-----------+--------------------+
1875  *
1876  * Expect to allocate an aligned region at the beginning of the first node that
1877  * is large enough and has enough unreserved memory (in this case, nid = 0)
1878  * after falling back to NUMA_NO_NODE. The region count and total size get
1879  * updated.
1880  */
1881 static int alloc_try_nid_bottom_up_numa_node_reserved_check(void)
1882 {
1883         int nid_req = 2;
1884         int nid_exp = 0;
1885         struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1886         struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1887         struct memblock_region *exp_node = &memblock.memory.regions[nid_exp];
1888         void *allocated_ptr = NULL;
1889         phys_addr_t size;
1890         phys_addr_t min_addr;
1891         phys_addr_t max_addr;
1892
1893         PREFIX_PUSH();
1894         setup_numa_memblock(node_fractions);
1895
1896         size = req_node->size;
1897         min_addr = memblock_start_of_DRAM();
1898         max_addr = memblock_end_of_DRAM();
1899
1900         memblock_reserve(req_node->base, req_node->size);
1901         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
1902                                                    min_addr, max_addr, nid_req);
1903
1904         ASSERT_NE(allocated_ptr, NULL);
1905         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1906
1907         ASSERT_EQ(new_rgn->size, size);
1908         ASSERT_EQ(new_rgn->base, exp_node->base);
1909         ASSERT_LE(region_end(new_rgn), region_end(exp_node));
1910
1911         ASSERT_EQ(memblock.reserved.cnt, 2);
1912         ASSERT_EQ(memblock.reserved.total_size, size + req_node->size);
1913
1914         test_pass_pop();
1915
1916         return 0;
1917 }
1918
1919 /*
1920  * A test that tries to allocate a memory region in a specific NUMA node that
1921  * is partially reserved but has enough memory for the allocated region:
1922  *
1923  *  |           +---------------------------------------+         |
1924  *  |           |               requested               |         |
1925  *  +-----------+---------------------------------------+---------+
1926  *
1927  *  |           +------------------+-----+                        |
1928  *  |           |     reserved     | new |                        |
1929  *  +-----------+------------------+-----+------------------------+
1930  *
1931  * Expect to allocate an aligned region in the requested node that merges with
1932  * the existing reserved region. The total size gets updated.
1933  */
1934 static int alloc_try_nid_bottom_up_numa_part_reserved_check(void)
1935 {
1936         int nid_req = 4;
1937         struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1938         struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1939         void *allocated_ptr = NULL;
1940         struct region r1;
1941         phys_addr_t size;
1942         phys_addr_t min_addr;
1943         phys_addr_t max_addr;
1944         phys_addr_t total_size;
1945
1946         PREFIX_PUSH();
1947         setup_numa_memblock(node_fractions);
1948
1949         ASSERT_LE(SZ_8, req_node->size);
1950         r1.base = req_node->base;
1951         r1.size = req_node->size / SZ_2;
1952         size = r1.size / SZ_4;
1953         min_addr = memblock_start_of_DRAM();
1954         max_addr = memblock_end_of_DRAM();
1955         total_size = size + r1.size;
1956
1957         memblock_reserve(r1.base, r1.size);
1958         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
1959                                                    min_addr, max_addr, nid_req);
1960
1961         ASSERT_NE(allocated_ptr, NULL);
1962         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1963
1964         ASSERT_EQ(new_rgn->size, total_size);
1965         ASSERT_EQ(new_rgn->base, req_node->base);
1966         ASSERT_LE(region_end(new_rgn), region_end(req_node));
1967
1968         ASSERT_EQ(memblock.reserved.cnt, 1);
1969         ASSERT_EQ(memblock.reserved.total_size, total_size);
1970
1971         test_pass_pop();
1972
1973         return 0;
1974 }
1975
1976 /*
1977  * A test that tries to allocate a memory region in a specific NUMA node that
1978  * is partially reserved and does not have enough contiguous memory for the
1979  * allocated region:
1980  *
1981  *  |----------------------+       +-----------------------+         |
1982  *  |       expected       |       |       requested       |         |
1983  *  +----------------------+-------+-----------------------+---------+
1984  *
1985  *  |-----------+                        +----------+                |
1986  *  |    new    |                        | reserved |                |
1987  *  +-----------+------------------------+----------+----------------+
1988  *
1989  * Expect to allocate an aligned region at the beginning of the first
1990  * node that is large enough and has enough unreserved memory (in this case,
1991  * nid = 0) after falling back to NUMA_NO_NODE. The region count and total size
1992  * get updated.
1993  */
1994 static int alloc_try_nid_bottom_up_numa_part_reserved_fallback_check(void)
1995 {
1996         int nid_req = 4;
1997         int nid_exp = 0;
1998         struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1999         struct memblock_region *req_node = &memblock.memory.regions[nid_req];
2000         struct memblock_region *exp_node = &memblock.memory.regions[nid_exp];
2001         void *allocated_ptr = NULL;
2002         struct region r1;
2003         phys_addr_t size;
2004         phys_addr_t min_addr;
2005         phys_addr_t max_addr;
2006
2007         PREFIX_PUSH();
2008         setup_numa_memblock(node_fractions);
2009
2010         ASSERT_LE(SZ_4, req_node->size);
2011         size = req_node->size / SZ_2;
2012         r1.base = req_node->base + (size / SZ_2);
2013         r1.size = size;
2014
2015         min_addr = memblock_start_of_DRAM();
2016         max_addr = memblock_end_of_DRAM();
2017
2018         memblock_reserve(r1.base, r1.size);
2019         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
2020                                                    min_addr, max_addr, nid_req);
2021
2022         ASSERT_NE(allocated_ptr, NULL);
2023         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
2024
2025         ASSERT_EQ(new_rgn->size, size);
2026         ASSERT_EQ(new_rgn->base, exp_node->base);
2027         ASSERT_LE(region_end(new_rgn), region_end(exp_node));
2028
2029         ASSERT_EQ(memblock.reserved.cnt, 2);
2030         ASSERT_EQ(memblock.reserved.total_size, size + r1.size);
2031
2032         test_pass_pop();
2033
2034         return 0;
2035 }
2036
2037 /*
2038  * A test that tries to allocate a memory region that spans over the min_addr
2039  * and max_addr range and overlaps with two different nodes, where the first
2040  * node is the requested node:
2041  *
2042  *                                min_addr
2043  *                                |           max_addr
2044  *                                |           |
2045  *                                v           v
2046  *  |           +-----------------------+-----------+              |
2047  *  |           |       requested       |   node3   |              |
2048  *  +-----------+-----------------------+-----------+--------------+
2049  *                                +           +
2050  *  |           +-----------+                                      |
2051  *  |           |    rgn    |                                      |
2052  *  +-----------+-----------+--------------------------------------+
2053  *
2054  * Expect to drop the lower limit and allocate a memory region at the beginning
2055  * of the requested node.
2056  */
2057 static int alloc_try_nid_bottom_up_numa_split_range_low_check(void)
2058 {
2059         int nid_req = 2;
2060         struct memblock_region *new_rgn = &memblock.reserved.regions[0];
2061         struct memblock_region *req_node = &memblock.memory.regions[nid_req];
2062         void *allocated_ptr = NULL;
2063         phys_addr_t size = SZ_512;
2064         phys_addr_t min_addr;
2065         phys_addr_t max_addr;
2066         phys_addr_t req_node_end;
2067
2068         PREFIX_PUSH();
2069         setup_numa_memblock(node_fractions);
2070
2071         req_node_end = region_end(req_node);
2072         min_addr = req_node_end - SZ_256;
2073         max_addr = min_addr + size;
2074
2075         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
2076                                                    min_addr, max_addr, nid_req);
2077
2078         ASSERT_NE(allocated_ptr, NULL);
2079         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
2080
2081         ASSERT_EQ(new_rgn->size, size);
2082         ASSERT_EQ(new_rgn->base, req_node->base);
2083         ASSERT_LE(region_end(new_rgn), req_node_end);
2084
2085         ASSERT_EQ(memblock.reserved.cnt, 1);
2086         ASSERT_EQ(memblock.reserved.total_size, size);
2087
2088         test_pass_pop();
2089
2090         return 0;
2091 }
2092
2093 /*
2094  * A test that tries to allocate a memory region that spans over the min_addr
2095  * and max_addr range and overlaps with two different nodes, where the second
2096  * node is the requested node:
2097  *
2098  *                                                min_addr
2099  *                                                |         max_addr
2100  *                                                |         |
2101  *                                                v         v
2102  *  |------------------+        +----------------------+---------+      |
2103  *  |     expected     |        |       previous       |requested|      |
2104  *  +------------------+--------+----------------------+---------+------+
2105  *                                                +         +
2106  *  |---------+                                                         |
2107  *  |   rgn   |                                                         |
2108  *  +---------+---------------------------------------------------------+
2109  *
2110  * Expect to drop the lower limit and allocate a memory region at the beginning
2111  * of the first node that has enough memory.
2112  */
2113 static int alloc_try_nid_bottom_up_numa_split_range_high_check(void)
2114 {
2115         int nid_req = 3;
2116         int nid_exp = 0;
2117         struct memblock_region *new_rgn = &memblock.reserved.regions[0];
2118         struct memblock_region *req_node = &memblock.memory.regions[nid_req];
2119         struct memblock_region *exp_node = &memblock.memory.regions[nid_exp];
2120         void *allocated_ptr = NULL;
2121         phys_addr_t size = SZ_512;
2122         phys_addr_t min_addr;
2123         phys_addr_t max_addr;
2124         phys_addr_t exp_node_end;
2125
2126         PREFIX_PUSH();
2127         setup_numa_memblock(node_fractions);
2128
2129         exp_node_end = region_end(req_node);
2130         min_addr = req_node->base - SZ_256;
2131         max_addr = min_addr + size;
2132
2133         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
2134                                                    min_addr, max_addr, nid_req);
2135
2136         ASSERT_NE(allocated_ptr, NULL);
2137         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
2138
2139         ASSERT_EQ(new_rgn->size, size);
2140         ASSERT_EQ(new_rgn->base, exp_node->base);
2141         ASSERT_LE(region_end(new_rgn), exp_node_end);
2142
2143         ASSERT_EQ(memblock.reserved.cnt, 1);
2144         ASSERT_EQ(memblock.reserved.total_size, size);
2145
2146         test_pass_pop();
2147
2148         return 0;
2149 }
2150
2151 /*
2152  * A test that tries to allocate a memory region that spans over the min_addr
2153  * and max_addr range and overlaps with two different nodes, where the requested
2154  * node ends before min_addr:
2155  *
2156  *                                          min_addr
2157  *                                         |         max_addr
2158  *                                         |         |
2159  *                                         v         v
2160  *  |    +---------------+        +-------------+---------+         |
2161  *  |    |   requested   |        |    node1    |  node2  |         |
2162  *  +----+---------------+--------+-------------+---------+---------+
2163  *                                         +         +
2164  *  |    +---------+                                                |
2165  *  |    |   rgn   |                                                |
2166  *  +----+---------+------------------------------------------------+
2167  *
2168  * Expect to drop the lower limit and allocate a memory region that starts at
2169  * the beginning of the requested node.
2170  */
2171 static int alloc_try_nid_bottom_up_numa_no_overlap_split_check(void)
2172 {
2173         int nid_req = 2;
2174         struct memblock_region *new_rgn = &memblock.reserved.regions[0];
2175         struct memblock_region *req_node = &memblock.memory.regions[nid_req];
2176         struct memblock_region *node2 = &memblock.memory.regions[6];
2177         void *allocated_ptr = NULL;
2178         phys_addr_t size;
2179         phys_addr_t min_addr;
2180         phys_addr_t max_addr;
2181
2182         PREFIX_PUSH();
2183         setup_numa_memblock(node_fractions);
2184
2185         size = SZ_512;
2186         min_addr = node2->base - SZ_256;
2187         max_addr = min_addr + size;
2188
2189         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
2190                                                    min_addr, max_addr, nid_req);
2191
2192         ASSERT_NE(allocated_ptr, NULL);
2193         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
2194
2195         ASSERT_EQ(new_rgn->size, size);
2196         ASSERT_EQ(new_rgn->base, req_node->base);
2197         ASSERT_LE(region_end(new_rgn), region_end(req_node));
2198
2199         ASSERT_EQ(memblock.reserved.cnt, 1);
2200         ASSERT_EQ(memblock.reserved.total_size, size);
2201
2202         test_pass_pop();
2203
2204         return 0;
2205 }
2206
2207 /*
2208  * A test that tries to allocate memory within min_addr and max_add range when
2209  * the requested node and the range do not overlap, and requested node ends
2210  * before min_addr. The range overlaps with multiple nodes along node
2211  * boundaries:
2212  *
2213  *                          min_addr
2214  *                          |                                 max_addr
2215  *                          |                                 |
2216  *                          v                                 v
2217  *  |-----------+           +----------+----...----+----------+      |
2218  *  | requested |           | min node |    ...    | max node |      |
2219  *  +-----------+-----------+----------+----...----+----------+------+
2220  *                          +                                 +
2221  *  |                       +-----+                                  |
2222  *  |                       | rgn |                                  |
2223  *  +-----------------------+-----+----------------------------------+
2224  *
2225  * Expect to allocate a memory region at the beginning of the first node
2226  * in the range after falling back to NUMA_NO_NODE.
2227  */
2228 static int alloc_try_nid_bottom_up_numa_no_overlap_low_check(void)
2229 {
2230         int nid_req = 0;
2231         struct memblock_region *new_rgn = &memblock.reserved.regions[0];
2232         struct memblock_region *min_node = &memblock.memory.regions[2];
2233         struct memblock_region *max_node = &memblock.memory.regions[5];
2234         void *allocated_ptr = NULL;
2235         phys_addr_t size = SZ_64;
2236         phys_addr_t max_addr;
2237         phys_addr_t min_addr;
2238
2239         PREFIX_PUSH();
2240         setup_numa_memblock(node_fractions);
2241
2242         min_addr = min_node->base;
2243         max_addr = region_end(max_node);
2244
2245         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
2246                                                    min_addr, max_addr, nid_req);
2247
2248         ASSERT_NE(allocated_ptr, NULL);
2249         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
2250
2251         ASSERT_EQ(new_rgn->size, size);
2252         ASSERT_EQ(new_rgn->base, min_addr);
2253         ASSERT_LE(region_end(new_rgn), region_end(min_node));
2254
2255         ASSERT_EQ(memblock.reserved.cnt, 1);
2256         ASSERT_EQ(memblock.reserved.total_size, size);
2257
2258         test_pass_pop();
2259
2260         return 0;
2261 }
2262
2263 /*
2264  * A test that tries to allocate memory within min_addr and max_add range when
2265  * the requested node and the range do not overlap, and requested node starts
2266  * after max_addr. The range overlaps with multiple nodes along node
2267  * boundaries:
2268  *
2269  *        min_addr
2270  *        |                                 max_addr
2271  *        |                                 |
2272  *        v                                 v
2273  *  |     +----------+----...----+----------+         +---------+   |
2274  *  |     | min node |    ...    | max node |         |requested|   |
2275  *  +-----+----------+----...----+----------+---------+---------+---+
2276  *        +                                 +
2277  *  |     +-----+                                                   |
2278  *  |     | rgn |                                                   |
2279  *  +-----+-----+---------------------------------------------------+
2280  *
2281  * Expect to allocate a memory region at the beginning of the first node
2282  * in the range after falling back to NUMA_NO_NODE.
2283  */
2284 static int alloc_try_nid_bottom_up_numa_no_overlap_high_check(void)
2285 {
2286         int nid_req = 7;
2287         struct memblock_region *new_rgn = &memblock.reserved.regions[0];
2288         struct memblock_region *min_node = &memblock.memory.regions[2];
2289         struct memblock_region *max_node = &memblock.memory.regions[5];
2290         void *allocated_ptr = NULL;
2291         phys_addr_t size = SZ_64;
2292         phys_addr_t max_addr;
2293         phys_addr_t min_addr;
2294
2295         PREFIX_PUSH();
2296         setup_numa_memblock(node_fractions);
2297
2298         min_addr = min_node->base;
2299         max_addr = region_end(max_node);
2300
2301         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
2302                                                    min_addr, max_addr, nid_req);
2303
2304         ASSERT_NE(allocated_ptr, NULL);
2305         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
2306
2307         ASSERT_EQ(new_rgn->size, size);
2308         ASSERT_EQ(new_rgn->base, min_addr);
2309         ASSERT_LE(region_end(new_rgn), region_end(min_node));
2310
2311         ASSERT_EQ(memblock.reserved.cnt, 1);
2312         ASSERT_EQ(memblock.reserved.total_size, size);
2313
2314         test_pass_pop();
2315
2316         return 0;
2317 }
2318
2319 /*
2320  * A test that tries to allocate a memory region in a specific NUMA node that
2321  * does not have enough memory to allocate a region of the requested size.
2322  * Additionally, none of the nodes have enough memory to allocate the region:
2323  *
2324  * +-----------------------------------+
2325  * |                new                |
2326  * +-----------------------------------+
2327  *     |-------+-------+-------+-------+-------+-------+-------+-------|
2328  *     | node0 | node1 | node2 | node3 | node4 | node5 | node6 | node7 |
2329  *     +-------+-------+-------+-------+-------+-------+-------+-------+
2330  *
2331  * Expect no allocation to happen.
2332  */
2333 static int alloc_try_nid_numa_large_region_generic_check(void)
2334 {
2335         int nid_req = 3;
2336         void *allocated_ptr = NULL;
2337         phys_addr_t size = MEM_SIZE / SZ_2;
2338         phys_addr_t min_addr;
2339         phys_addr_t max_addr;
2340
2341         PREFIX_PUSH();
2342         setup_numa_memblock(node_fractions);
2343
2344         min_addr = memblock_start_of_DRAM();
2345         max_addr = memblock_end_of_DRAM();
2346
2347         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
2348                                                    min_addr, max_addr, nid_req);
2349         ASSERT_EQ(allocated_ptr, NULL);
2350
2351         test_pass_pop();
2352
2353         return 0;
2354 }
2355
2356 /*
2357  * A test that tries to allocate memory within min_addr and max_addr range when
2358  * there are two reserved regions at the borders. The requested node starts at
2359  * min_addr and ends at max_addr and is the same size as the region to be
2360  * allocated:
2361  *
2362  *                     min_addr
2363  *                     |                       max_addr
2364  *                     |                       |
2365  *                     v                       v
2366  *  |      +-----------+-----------------------+-----------------------|
2367  *  |      |   node5   |       requested       |         node7         |
2368  *  +------+-----------+-----------------------+-----------------------+
2369  *                     +                       +
2370  *  |             +----+-----------------------+----+                  |
2371  *  |             | r2 |          new          | r1 |                  |
2372  *  +-------------+----+-----------------------+----+------------------+
2373  *
2374  * Expect to merge all of the regions into one. The region counter and total
2375  * size fields get updated.
2376  */
2377 static int alloc_try_nid_numa_reserved_full_merge_generic_check(void)
2378 {
2379         int nid_req = 6;
2380         int nid_next = nid_req + 1;
2381         struct memblock_region *new_rgn = &memblock.reserved.regions[0];
2382         struct memblock_region *req_node = &memblock.memory.regions[nid_req];
2383         struct memblock_region *next_node = &memblock.memory.regions[nid_next];
2384         void *allocated_ptr = NULL;
2385         struct region r1, r2;
2386         phys_addr_t size = req_node->size;
2387         phys_addr_t total_size;
2388         phys_addr_t max_addr;
2389         phys_addr_t min_addr;
2390
2391         PREFIX_PUSH();
2392         setup_numa_memblock(node_fractions);
2393
2394         r1.base = next_node->base;
2395         r1.size = SZ_128;
2396
2397         r2.size = SZ_128;
2398         r2.base = r1.base - (size + r2.size);
2399
2400         total_size = r1.size + r2.size + size;
2401         min_addr = r2.base + r2.size;
2402         max_addr = r1.base;
2403
2404         memblock_reserve(r1.base, r1.size);
2405         memblock_reserve(r2.base, r2.size);
2406
2407         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
2408                                                    min_addr, max_addr, nid_req);
2409
2410         ASSERT_NE(allocated_ptr, NULL);
2411         assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
2412
2413         ASSERT_EQ(new_rgn->size, total_size);
2414         ASSERT_EQ(new_rgn->base, r2.base);
2415
2416         ASSERT_LE(new_rgn->base, req_node->base);
2417         ASSERT_LE(region_end(req_node), region_end(new_rgn));
2418
2419         ASSERT_EQ(memblock.reserved.cnt, 1);
2420         ASSERT_EQ(memblock.reserved.total_size, total_size);
2421
2422         test_pass_pop();
2423
2424         return 0;
2425 }
2426
2427 /*
2428  * A test that tries to allocate memory within min_addr and max_add range,
2429  * where the total range can fit the region, but it is split between two nodes
2430  * and everything else is reserved. Additionally, nid is set to NUMA_NO_NODE
2431  * instead of requesting a specific node:
2432  *
2433  *                         +-----------+
2434  *                         |    new    |
2435  *                         +-----------+
2436  *  |      +---------------------+-----------|
2437  *  |      |      prev node      | next node |
2438  *  +------+---------------------+-----------+
2439  *                         +           +
2440  *  |----------------------+           +-----|
2441  *  |          r1          |           |  r2 |
2442  *  +----------------------+-----------+-----+
2443  *                         ^           ^
2444  *                         |           |
2445  *                         |           max_addr
2446  *                         |
2447  *                         min_addr
2448  *
2449  * Expect no allocation to happen.
2450  */
2451 static int alloc_try_nid_numa_split_all_reserved_generic_check(void)
2452 {
2453         void *allocated_ptr = NULL;
2454         struct memblock_region *next_node = &memblock.memory.regions[7];
2455         struct region r1, r2;
2456         phys_addr_t size = SZ_256;
2457         phys_addr_t max_addr;
2458         phys_addr_t min_addr;
2459
2460         PREFIX_PUSH();
2461         setup_numa_memblock(node_fractions);
2462
2463         r2.base = next_node->base + SZ_128;
2464         r2.size = memblock_end_of_DRAM() - r2.base;
2465
2466         r1.size = MEM_SIZE - (r2.size + size);
2467         r1.base = memblock_start_of_DRAM();
2468
2469         min_addr = r1.base + r1.size;
2470         max_addr = r2.base;
2471
2472         memblock_reserve(r1.base, r1.size);
2473         memblock_reserve(r2.base, r2.size);
2474
2475         allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
2476                                                    min_addr, max_addr,
2477                                                    NUMA_NO_NODE);
2478
2479         ASSERT_EQ(allocated_ptr, NULL);
2480
2481         test_pass_pop();
2482
2483         return 0;
2484 }
2485
2486 /* Test case wrappers for NUMA tests */
2487 static int alloc_try_nid_numa_simple_check(void)
2488 {
2489         test_print("\tRunning %s...\n", __func__);
2490         memblock_set_bottom_up(false);
2491         alloc_try_nid_top_down_numa_simple_check();
2492         memblock_set_bottom_up(true);
2493         alloc_try_nid_bottom_up_numa_simple_check();
2494
2495         return 0;
2496 }
2497
2498 static int alloc_try_nid_numa_small_node_check(void)
2499 {
2500         test_print("\tRunning %s...\n", __func__);
2501         memblock_set_bottom_up(false);
2502         alloc_try_nid_top_down_numa_small_node_check();
2503         memblock_set_bottom_up(true);
2504         alloc_try_nid_bottom_up_numa_small_node_check();
2505
2506         return 0;
2507 }
2508
2509 static int alloc_try_nid_numa_node_reserved_check(void)
2510 {
2511         test_print("\tRunning %s...\n", __func__);
2512         memblock_set_bottom_up(false);
2513         alloc_try_nid_top_down_numa_node_reserved_check();
2514         memblock_set_bottom_up(true);
2515         alloc_try_nid_bottom_up_numa_node_reserved_check();
2516
2517         return 0;
2518 }
2519
2520 static int alloc_try_nid_numa_part_reserved_check(void)
2521 {
2522         test_print("\tRunning %s...\n", __func__);
2523         memblock_set_bottom_up(false);
2524         alloc_try_nid_top_down_numa_part_reserved_check();
2525         memblock_set_bottom_up(true);
2526         alloc_try_nid_bottom_up_numa_part_reserved_check();
2527
2528         return 0;
2529 }
2530
2531 static int alloc_try_nid_numa_part_reserved_fallback_check(void)
2532 {
2533         test_print("\tRunning %s...\n", __func__);
2534         memblock_set_bottom_up(false);
2535         alloc_try_nid_top_down_numa_part_reserved_fallback_check();
2536         memblock_set_bottom_up(true);
2537         alloc_try_nid_bottom_up_numa_part_reserved_fallback_check();
2538
2539         return 0;
2540 }
2541
2542 static int alloc_try_nid_numa_split_range_low_check(void)
2543 {
2544         test_print("\tRunning %s...\n", __func__);
2545         memblock_set_bottom_up(false);
2546         alloc_try_nid_top_down_numa_split_range_low_check();
2547         memblock_set_bottom_up(true);
2548         alloc_try_nid_bottom_up_numa_split_range_low_check();
2549
2550         return 0;
2551 }
2552
2553 static int alloc_try_nid_numa_split_range_high_check(void)
2554 {
2555         test_print("\tRunning %s...\n", __func__);
2556         memblock_set_bottom_up(false);
2557         alloc_try_nid_top_down_numa_split_range_high_check();
2558         memblock_set_bottom_up(true);
2559         alloc_try_nid_bottom_up_numa_split_range_high_check();
2560
2561         return 0;
2562 }
2563
2564 static int alloc_try_nid_numa_no_overlap_split_check(void)
2565 {
2566         test_print("\tRunning %s...\n", __func__);
2567         memblock_set_bottom_up(false);
2568         alloc_try_nid_top_down_numa_no_overlap_split_check();
2569         memblock_set_bottom_up(true);
2570         alloc_try_nid_bottom_up_numa_no_overlap_split_check();
2571
2572         return 0;
2573 }
2574
2575 static int alloc_try_nid_numa_no_overlap_low_check(void)
2576 {
2577         test_print("\tRunning %s...\n", __func__);
2578         memblock_set_bottom_up(false);
2579         alloc_try_nid_top_down_numa_no_overlap_low_check();
2580         memblock_set_bottom_up(true);
2581         alloc_try_nid_bottom_up_numa_no_overlap_low_check();
2582
2583         return 0;
2584 }
2585
2586 static int alloc_try_nid_numa_no_overlap_high_check(void)
2587 {
2588         test_print("\tRunning %s...\n", __func__);
2589         memblock_set_bottom_up(false);
2590         alloc_try_nid_top_down_numa_no_overlap_high_check();
2591         memblock_set_bottom_up(true);
2592         alloc_try_nid_bottom_up_numa_no_overlap_high_check();
2593
2594         return 0;
2595 }
2596
2597 static int alloc_try_nid_numa_large_region_check(void)
2598 {
2599         test_print("\tRunning %s...\n", __func__);
2600         run_top_down(alloc_try_nid_numa_large_region_generic_check);
2601         run_bottom_up(alloc_try_nid_numa_large_region_generic_check);
2602
2603         return 0;
2604 }
2605
2606 static int alloc_try_nid_numa_reserved_full_merge_check(void)
2607 {
2608         test_print("\tRunning %s...\n", __func__);
2609         run_top_down(alloc_try_nid_numa_reserved_full_merge_generic_check);
2610         run_bottom_up(alloc_try_nid_numa_reserved_full_merge_generic_check);
2611
2612         return 0;
2613 }
2614
2615 static int alloc_try_nid_numa_split_all_reserved_check(void)
2616 {
2617         test_print("\tRunning %s...\n", __func__);
2618         run_top_down(alloc_try_nid_numa_split_all_reserved_generic_check);
2619         run_bottom_up(alloc_try_nid_numa_split_all_reserved_generic_check);
2620
2621         return 0;
2622 }
2623
2624 int __memblock_alloc_nid_numa_checks(void)
2625 {
2626         test_print("Running %s NUMA tests...\n",
2627                    get_memblock_alloc_try_nid_name(alloc_nid_test_flags));
2628
2629         alloc_try_nid_numa_simple_check();
2630         alloc_try_nid_numa_small_node_check();
2631         alloc_try_nid_numa_node_reserved_check();
2632         alloc_try_nid_numa_part_reserved_check();
2633         alloc_try_nid_numa_part_reserved_fallback_check();
2634         alloc_try_nid_numa_split_range_low_check();
2635         alloc_try_nid_numa_split_range_high_check();
2636
2637         alloc_try_nid_numa_no_overlap_split_check();
2638         alloc_try_nid_numa_no_overlap_low_check();
2639         alloc_try_nid_numa_no_overlap_high_check();
2640         alloc_try_nid_numa_large_region_check();
2641         alloc_try_nid_numa_reserved_full_merge_check();
2642         alloc_try_nid_numa_split_all_reserved_check();
2643
2644         return 0;
2645 }
2646
2647 static int memblock_alloc_nid_checks_internal(int flags)
2648 {
2649         alloc_nid_test_flags = flags;
2650
2651         prefix_reset();
2652         prefix_push(get_memblock_alloc_try_nid_name(flags));
2653
2654         reset_memblock_attributes();
2655         dummy_physical_memory_init();
2656
2657         memblock_alloc_nid_range_checks();
2658         memblock_alloc_nid_numa_checks();
2659
2660         dummy_physical_memory_cleanup();
2661
2662         prefix_pop();
2663
2664         return 0;
2665 }
2666
2667 int memblock_alloc_nid_checks(void)
2668 {
2669         memblock_alloc_nid_checks_internal(TEST_F_NONE);
2670         memblock_alloc_nid_checks_internal(TEST_F_RAW);
2671
2672         return 0;
2673 }