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