tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

memblock tests: introduce range tests for memblock_alloc_exact_nid_raw

Add TEST_F_EXACT flag, which specifies that tests should run
memblock_alloc_exact_nid_raw(). Introduce range tests for
memblock_alloc_exact_nid_raw() by using the TEST_F_EXACT flag to run the
range tests in alloc_nid_api.c, since memblock_alloc_exact_nid_raw() and
memblock_alloc_try_nid_raw() behave the same way when nid = NUMA_NO_NODE.

Rename tests and other functions in alloc_nid_api.c by removing "_try".
Since the test names will be displayed in verbose output, they need to
be general enough to refer to any of the memblock functions that the
tests may run.

Acked-by: David Hildenbrand <david@redhat.com>
Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
Link: https://lore.kernel.org/r/5a4b6d1b6130ab7375314e1c45a6d5813dfdabbd.1667802195.git.remckee0@gmail.com

authored by

Rebecca Mckeever and committed by
Mike Rapoport 61da0332 62a56c54

+319 -263
+1 -1
tools/testing/memblock/Makefile
··· 7 7 LDFLAGS += -fsanitize=address -fsanitize=undefined 8 8 TARGETS = main 9 9 TEST_OFILES = tests/alloc_nid_api.o tests/alloc_helpers_api.o tests/alloc_api.o \ 10 - tests/basic_api.o tests/common.o 10 + tests/basic_api.o tests/common.o tests/alloc_exact_nid_api.o 11 11 DEP_OFILES = memblock.o lib/slab.o mmzone.o slab.o 12 12 OFILES = main.o $(DEP_OFILES) $(TEST_OFILES) 13 13 EXTR_SRC = ../../../mm/memblock.c
+2
tools/testing/memblock/main.c
··· 3 3 #include "tests/alloc_api.h" 4 4 #include "tests/alloc_helpers_api.h" 5 5 #include "tests/alloc_nid_api.h" 6 + #include "tests/alloc_exact_nid_api.h" 6 7 #include "tests/common.h" 7 8 8 9 int main(int argc, char **argv) ··· 13 12 memblock_alloc_checks(); 14 13 memblock_alloc_helpers_checks(); 15 14 memblock_alloc_nid_checks(); 15 + memblock_alloc_exact_nid_checks(); 16 16 17 17 return 0; 18 18 }
+22
tools/testing/memblock/tests/alloc_exact_nid_api.c
··· 1 + // SPDX-License-Identifier: GPL-2.0-or-later 2 + #include "alloc_exact_nid_api.h" 3 + #include "alloc_nid_api.h" 4 + 5 + #define FUNC_NAME "memblock_alloc_exact_nid_raw" 6 + 7 + int memblock_alloc_exact_nid_checks(void) 8 + { 9 + prefix_reset(); 10 + prefix_push(FUNC_NAME); 11 + 12 + reset_memblock_attributes(); 13 + dummy_physical_memory_init(); 14 + 15 + memblock_alloc_exact_nid_range_checks(); 16 + 17 + dummy_physical_memory_cleanup(); 18 + 19 + prefix_pop(); 20 + 21 + return 0; 22 + }
+9
tools/testing/memblock/tests/alloc_exact_nid_api.h
··· 1 + /* SPDX-License-Identifier: GPL-2.0-or-later */ 2 + #ifndef _MEMBLOCK_ALLOC_EXACT_NID_H 3 + #define _MEMBLOCK_ALLOC_EXACT_NID_H 4 + 5 + #include "common.h" 6 + 7 + int memblock_alloc_exact_nid_checks(void); 8 + 9 + #endif
+282 -262
tools/testing/memblock/tests/alloc_nid_api.c
··· 18 18 625, /* 1/16 */ 19 19 }; 20 20 21 - static inline const char * const get_memblock_alloc_try_nid_name(int flags) 21 + static inline const char * const get_memblock_alloc_nid_name(int flags) 22 22 { 23 + if (flags & TEST_F_EXACT) 24 + return "memblock_alloc_exact_nid_raw"; 23 25 if (flags & TEST_F_RAW) 24 26 return "memblock_alloc_try_nid_raw"; 25 27 return "memblock_alloc_try_nid"; 26 28 } 27 29 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) 30 + static 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) 32 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 since 39 + * 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); 33 44 if (alloc_nid_test_flags & TEST_F_RAW) 34 45 return memblock_alloc_try_nid_raw(size, align, min_addr, 35 46 max_addr, nid); ··· 61 50 * 62 51 * Expect to allocate a region that ends at max_addr. 63 52 */ 64 - static int alloc_try_nid_top_down_simple_check(void) 53 + static int alloc_nid_top_down_simple_check(void) 65 54 { 66 55 struct memblock_region *rgn = &memblock.reserved.regions[0]; 67 56 void *allocated_ptr = NULL; ··· 76 65 min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2; 77 66 max_addr = min_addr + SZ_512; 78 67 79 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 80 - min_addr, max_addr, 81 - NUMA_NO_NODE); 68 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 69 + min_addr, max_addr, 70 + NUMA_NO_NODE); 82 71 rgn_end = rgn->base + rgn->size; 83 72 84 73 ASSERT_NE(allocated_ptr, NULL); ··· 113 102 * 114 103 * Expect to allocate an aligned region that ends before max_addr. 115 104 */ 116 - static int alloc_try_nid_top_down_end_misaligned_check(void) 105 + static int alloc_nid_top_down_end_misaligned_check(void) 117 106 { 118 107 struct memblock_region *rgn = &memblock.reserved.regions[0]; 119 108 void *allocated_ptr = NULL; ··· 129 118 min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2; 130 119 max_addr = min_addr + SZ_512 + misalign; 131 120 132 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 133 - min_addr, max_addr, 134 - NUMA_NO_NODE); 121 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 122 + min_addr, max_addr, 123 + NUMA_NO_NODE); 135 124 rgn_end = rgn->base + rgn->size; 136 125 137 126 ASSERT_NE(allocated_ptr, NULL); ··· 164 153 * Expect to allocate a region that starts at min_addr and ends at 165 154 * max_addr, given that min_addr is aligned. 166 155 */ 167 - static int alloc_try_nid_exact_address_generic_check(void) 156 + static int alloc_nid_exact_address_generic_check(void) 168 157 { 169 158 struct memblock_region *rgn = &memblock.reserved.regions[0]; 170 159 void *allocated_ptr = NULL; ··· 179 168 min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES; 180 169 max_addr = min_addr + size; 181 170 182 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 183 - min_addr, max_addr, 184 - NUMA_NO_NODE); 171 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 172 + min_addr, max_addr, 173 + NUMA_NO_NODE); 185 174 rgn_end = rgn->base + rgn->size; 186 175 187 176 ASSERT_NE(allocated_ptr, NULL); ··· 216 205 * Expect to drop the lower limit and allocate a memory region which 217 206 * ends at max_addr (if the address is aligned). 218 207 */ 219 - static int alloc_try_nid_top_down_narrow_range_check(void) 208 + static int alloc_nid_top_down_narrow_range_check(void) 220 209 { 221 210 struct memblock_region *rgn = &memblock.reserved.regions[0]; 222 211 void *allocated_ptr = NULL; ··· 230 219 min_addr = memblock_start_of_DRAM() + SZ_512; 231 220 max_addr = min_addr + SMP_CACHE_BYTES; 232 221 233 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 234 - min_addr, max_addr, 235 - NUMA_NO_NODE); 222 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 223 + min_addr, max_addr, 224 + NUMA_NO_NODE); 236 225 237 226 ASSERT_NE(allocated_ptr, NULL); 238 227 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 268 257 * 269 258 * Expect no allocation to happen. 270 259 */ 271 - static int alloc_try_nid_low_max_generic_check(void) 260 + static int alloc_nid_low_max_generic_check(void) 272 261 { 273 262 void *allocated_ptr = NULL; 274 263 phys_addr_t size = SZ_1K; ··· 281 270 min_addr = memblock_start_of_DRAM(); 282 271 max_addr = min_addr + SMP_CACHE_BYTES; 283 272 284 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 285 - min_addr, max_addr, 286 - NUMA_NO_NODE); 273 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 274 + min_addr, max_addr, 275 + NUMA_NO_NODE); 287 276 288 277 ASSERT_EQ(allocated_ptr, NULL); 289 278 ··· 306 295 * 307 296 * Expect a merge of both regions. Only the region size gets updated. 308 297 */ 309 - static int alloc_try_nid_min_reserved_generic_check(void) 298 + static int alloc_nid_min_reserved_generic_check(void) 310 299 { 311 300 struct memblock_region *rgn = &memblock.reserved.regions[0]; 312 301 void *allocated_ptr = NULL; ··· 326 315 327 316 memblock_reserve(reserved_base, r1_size); 328 317 329 - allocated_ptr = run_memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES, 330 - min_addr, max_addr, 331 - NUMA_NO_NODE); 318 + allocated_ptr = run_memblock_alloc_nid(r2_size, SMP_CACHE_BYTES, 319 + min_addr, max_addr, 320 + NUMA_NO_NODE); 332 321 333 322 ASSERT_NE(allocated_ptr, NULL); 334 323 assert_mem_content(allocated_ptr, r2_size, alloc_nid_test_flags); ··· 358 347 * 359 348 * Expect a merge of regions. Only the region size gets updated. 360 349 */ 361 - static int alloc_try_nid_max_reserved_generic_check(void) 350 + static int alloc_nid_max_reserved_generic_check(void) 362 351 { 363 352 struct memblock_region *rgn = &memblock.reserved.regions[0]; 364 353 void *allocated_ptr = NULL; ··· 376 365 377 366 memblock_reserve(max_addr, r1_size); 378 367 379 - allocated_ptr = run_memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES, 380 - min_addr, max_addr, 381 - NUMA_NO_NODE); 368 + allocated_ptr = run_memblock_alloc_nid(r2_size, SMP_CACHE_BYTES, 369 + min_addr, max_addr, 370 + NUMA_NO_NODE); 382 371 383 372 ASSERT_NE(allocated_ptr, NULL); 384 373 assert_mem_content(allocated_ptr, r2_size, alloc_nid_test_flags); ··· 411 400 * updated. The total size field gets updated. 412 401 */ 413 402 414 - static int alloc_try_nid_top_down_reserved_with_space_check(void) 403 + static int alloc_nid_top_down_reserved_with_space_check(void) 415 404 { 416 405 struct memblock_region *rgn1 = &memblock.reserved.regions[1]; 417 406 struct memblock_region *rgn2 = &memblock.reserved.regions[0]; ··· 439 428 memblock_reserve(r1.base, r1.size); 440 429 memblock_reserve(r2.base, r2.size); 441 430 442 - allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 443 - min_addr, max_addr, 444 - NUMA_NO_NODE); 431 + allocated_ptr = run_memblock_alloc_nid(r3_size, SMP_CACHE_BYTES, 432 + min_addr, max_addr, 433 + NUMA_NO_NODE); 445 434 446 435 ASSERT_NE(allocated_ptr, NULL); 447 436 assert_mem_content(allocated_ptr, r3_size, alloc_nid_test_flags); ··· 476 465 * Expect to merge all of the regions into one. The region counter and total 477 466 * size fields get updated. 478 467 */ 479 - static int alloc_try_nid_reserved_full_merge_generic_check(void) 468 + static int alloc_nid_reserved_full_merge_generic_check(void) 480 469 { 481 470 struct memblock_region *rgn = &memblock.reserved.regions[0]; 482 471 void *allocated_ptr = NULL; ··· 502 491 memblock_reserve(r1.base, r1.size); 503 492 memblock_reserve(r2.base, r2.size); 504 493 505 - allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 506 - min_addr, max_addr, 507 - NUMA_NO_NODE); 494 + allocated_ptr = run_memblock_alloc_nid(r3_size, SMP_CACHE_BYTES, 495 + min_addr, max_addr, 496 + NUMA_NO_NODE); 508 497 509 498 ASSERT_NE(allocated_ptr, NULL); 510 499 assert_mem_content(allocated_ptr, r3_size, alloc_nid_test_flags); ··· 538 527 * Expect to merge the new region with r2. The second region does not get 539 528 * updated. The total size counter gets updated. 540 529 */ 541 - static int alloc_try_nid_top_down_reserved_no_space_check(void) 530 + static int alloc_nid_top_down_reserved_no_space_check(void) 542 531 { 543 532 struct memblock_region *rgn1 = &memblock.reserved.regions[1]; 544 533 struct memblock_region *rgn2 = &memblock.reserved.regions[0]; ··· 566 555 memblock_reserve(r1.base, r1.size); 567 556 memblock_reserve(r2.base, r2.size); 568 557 569 - allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 570 - min_addr, max_addr, 571 - NUMA_NO_NODE); 558 + allocated_ptr = run_memblock_alloc_nid(r3_size, SMP_CACHE_BYTES, 559 + min_addr, max_addr, 560 + NUMA_NO_NODE); 572 561 573 562 ASSERT_NE(allocated_ptr, NULL); 574 563 assert_mem_content(allocated_ptr, r3_size, alloc_nid_test_flags); ··· 607 596 * Expect no allocation to happen. 608 597 */ 609 598 610 - static int alloc_try_nid_reserved_all_generic_check(void) 599 + static int alloc_nid_reserved_all_generic_check(void) 611 600 { 612 601 void *allocated_ptr = NULL; 613 602 struct region r1, r2; ··· 631 620 memblock_reserve(r1.base, r1.size); 632 621 memblock_reserve(r2.base, r2.size); 633 622 634 - allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 635 - min_addr, max_addr, 636 - NUMA_NO_NODE); 623 + allocated_ptr = run_memblock_alloc_nid(r3_size, SMP_CACHE_BYTES, 624 + min_addr, max_addr, 625 + NUMA_NO_NODE); 637 626 638 627 ASSERT_EQ(allocated_ptr, NULL); 639 628 ··· 647 636 * bigger than the end address of the available memory. Expect to allocate 648 637 * a region that ends before the end of the memory. 649 638 */ 650 - static int alloc_try_nid_top_down_cap_max_check(void) 639 + static int alloc_nid_top_down_cap_max_check(void) 651 640 { 652 641 struct memblock_region *rgn = &memblock.reserved.regions[0]; 653 642 void *allocated_ptr = NULL; ··· 661 650 min_addr = memblock_end_of_DRAM() - SZ_1K; 662 651 max_addr = memblock_end_of_DRAM() + SZ_256; 663 652 664 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 665 - min_addr, max_addr, 666 - NUMA_NO_NODE); 653 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 654 + min_addr, max_addr, 655 + NUMA_NO_NODE); 667 656 668 657 ASSERT_NE(allocated_ptr, NULL); 669 658 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 684 673 * smaller than the start address of the available memory. Expect to allocate 685 674 * a region that ends before the end of the memory. 686 675 */ 687 - static int alloc_try_nid_top_down_cap_min_check(void) 676 + static int alloc_nid_top_down_cap_min_check(void) 688 677 { 689 678 struct memblock_region *rgn = &memblock.reserved.regions[0]; 690 679 void *allocated_ptr = NULL; ··· 698 687 min_addr = memblock_start_of_DRAM() - SZ_256; 699 688 max_addr = memblock_end_of_DRAM(); 700 689 701 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 702 - min_addr, max_addr, 703 - NUMA_NO_NODE); 690 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 691 + min_addr, max_addr, 692 + NUMA_NO_NODE); 704 693 705 694 ASSERT_NE(allocated_ptr, NULL); 706 695 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 730 719 * 731 720 * Expect to allocate a region that ends before max_addr. 732 721 */ 733 - static int alloc_try_nid_bottom_up_simple_check(void) 722 + static int alloc_nid_bottom_up_simple_check(void) 734 723 { 735 724 struct memblock_region *rgn = &memblock.reserved.regions[0]; 736 725 void *allocated_ptr = NULL; ··· 745 734 min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2; 746 735 max_addr = min_addr + SZ_512; 747 736 748 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 749 - min_addr, max_addr, 750 - NUMA_NO_NODE); 737 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 738 + min_addr, max_addr, 739 + NUMA_NO_NODE); 751 740 rgn_end = rgn->base + rgn->size; 752 741 753 742 ASSERT_NE(allocated_ptr, NULL); ··· 782 771 * 783 772 * Expect to allocate an aligned region that ends before max_addr. 784 773 */ 785 - static int alloc_try_nid_bottom_up_start_misaligned_check(void) 774 + static int alloc_nid_bottom_up_start_misaligned_check(void) 786 775 { 787 776 struct memblock_region *rgn = &memblock.reserved.regions[0]; 788 777 void *allocated_ptr = NULL; ··· 798 787 min_addr = memblock_start_of_DRAM() + misalign; 799 788 max_addr = min_addr + SZ_512; 800 789 801 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 802 - min_addr, max_addr, 803 - NUMA_NO_NODE); 790 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 791 + min_addr, max_addr, 792 + NUMA_NO_NODE); 804 793 rgn_end = rgn->base + rgn->size; 805 794 806 795 ASSERT_NE(allocated_ptr, NULL); ··· 835 824 * Expect to drop the lower limit and allocate a memory region which 836 825 * starts at the beginning of the available memory. 837 826 */ 838 - static int alloc_try_nid_bottom_up_narrow_range_check(void) 827 + static int alloc_nid_bottom_up_narrow_range_check(void) 839 828 { 840 829 struct memblock_region *rgn = &memblock.reserved.regions[0]; 841 830 void *allocated_ptr = NULL; ··· 849 838 min_addr = memblock_start_of_DRAM() + SZ_512; 850 839 max_addr = min_addr + SMP_CACHE_BYTES; 851 840 852 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 853 - min_addr, max_addr, 854 - NUMA_NO_NODE); 841 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 842 + min_addr, max_addr, 843 + NUMA_NO_NODE); 855 844 856 845 ASSERT_NE(allocated_ptr, NULL); 857 846 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 884 873 * updated. The total size field gets updated. 885 874 */ 886 875 887 - static int alloc_try_nid_bottom_up_reserved_with_space_check(void) 876 + static int alloc_nid_bottom_up_reserved_with_space_check(void) 888 877 { 889 878 struct memblock_region *rgn1 = &memblock.reserved.regions[1]; 890 879 struct memblock_region *rgn2 = &memblock.reserved.regions[0]; ··· 912 901 memblock_reserve(r1.base, r1.size); 913 902 memblock_reserve(r2.base, r2.size); 914 903 915 - allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 916 - min_addr, max_addr, 917 - NUMA_NO_NODE); 904 + allocated_ptr = run_memblock_alloc_nid(r3_size, SMP_CACHE_BYTES, 905 + min_addr, max_addr, 906 + NUMA_NO_NODE); 918 907 919 908 ASSERT_NE(allocated_ptr, NULL); 920 909 assert_mem_content(allocated_ptr, r3_size, alloc_nid_test_flags); ··· 953 942 * Other regions are not modified. 954 943 */ 955 944 956 - static int alloc_try_nid_bottom_up_reserved_no_space_check(void) 945 + static int alloc_nid_bottom_up_reserved_no_space_check(void) 957 946 { 958 947 struct memblock_region *rgn1 = &memblock.reserved.regions[2]; 959 948 struct memblock_region *rgn2 = &memblock.reserved.regions[1]; ··· 982 971 memblock_reserve(r1.base, r1.size); 983 972 memblock_reserve(r2.base, r2.size); 984 973 985 - allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 986 - min_addr, max_addr, 987 - NUMA_NO_NODE); 974 + allocated_ptr = run_memblock_alloc_nid(r3_size, SMP_CACHE_BYTES, 975 + min_addr, max_addr, 976 + NUMA_NO_NODE); 988 977 989 978 ASSERT_NE(allocated_ptr, NULL); 990 979 assert_mem_content(allocated_ptr, r3_size, alloc_nid_test_flags); ··· 1011 1000 * bigger than the end address of the available memory. Expect to allocate 1012 1001 * a region that starts at the min_addr. 1013 1002 */ 1014 - static int alloc_try_nid_bottom_up_cap_max_check(void) 1003 + static int alloc_nid_bottom_up_cap_max_check(void) 1015 1004 { 1016 1005 struct memblock_region *rgn = &memblock.reserved.regions[0]; 1017 1006 void *allocated_ptr = NULL; ··· 1025 1014 min_addr = memblock_start_of_DRAM() + SZ_1K; 1026 1015 max_addr = memblock_end_of_DRAM() + SZ_256; 1027 1016 1028 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1029 - min_addr, max_addr, 1030 - NUMA_NO_NODE); 1017 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 1018 + min_addr, max_addr, 1019 + NUMA_NO_NODE); 1031 1020 1032 1021 ASSERT_NE(allocated_ptr, NULL); 1033 1022 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 1048 1037 * smaller than the start address of the available memory. Expect to allocate 1049 1038 * a region at the beginning of the available memory. 1050 1039 */ 1051 - static int alloc_try_nid_bottom_up_cap_min_check(void) 1040 + static int alloc_nid_bottom_up_cap_min_check(void) 1052 1041 { 1053 1042 struct memblock_region *rgn = &memblock.reserved.regions[0]; 1054 1043 void *allocated_ptr = NULL; ··· 1062 1051 min_addr = memblock_start_of_DRAM(); 1063 1052 max_addr = memblock_end_of_DRAM() - SZ_256; 1064 1053 1065 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1066 - min_addr, max_addr, 1067 - NUMA_NO_NODE); 1054 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 1055 + min_addr, max_addr, 1056 + NUMA_NO_NODE); 1068 1057 1069 1058 ASSERT_NE(allocated_ptr, NULL); 1070 1059 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 1081 1070 } 1082 1071 1083 1072 /* Test case wrappers for range tests */ 1084 - static int alloc_try_nid_simple_check(void) 1073 + static int alloc_nid_simple_check(void) 1085 1074 { 1086 1075 test_print("\tRunning %s...\n", __func__); 1087 1076 memblock_set_bottom_up(false); 1088 - alloc_try_nid_top_down_simple_check(); 1077 + alloc_nid_top_down_simple_check(); 1089 1078 memblock_set_bottom_up(true); 1090 - alloc_try_nid_bottom_up_simple_check(); 1079 + alloc_nid_bottom_up_simple_check(); 1091 1080 1092 1081 return 0; 1093 1082 } 1094 1083 1095 - static int alloc_try_nid_misaligned_check(void) 1084 + static int alloc_nid_misaligned_check(void) 1096 1085 { 1097 1086 test_print("\tRunning %s...\n", __func__); 1098 1087 memblock_set_bottom_up(false); 1099 - alloc_try_nid_top_down_end_misaligned_check(); 1088 + alloc_nid_top_down_end_misaligned_check(); 1100 1089 memblock_set_bottom_up(true); 1101 - alloc_try_nid_bottom_up_start_misaligned_check(); 1090 + alloc_nid_bottom_up_start_misaligned_check(); 1102 1091 1103 1092 return 0; 1104 1093 } 1105 1094 1106 - static int alloc_try_nid_narrow_range_check(void) 1095 + static int alloc_nid_narrow_range_check(void) 1107 1096 { 1108 1097 test_print("\tRunning %s...\n", __func__); 1109 1098 memblock_set_bottom_up(false); 1110 - alloc_try_nid_top_down_narrow_range_check(); 1099 + alloc_nid_top_down_narrow_range_check(); 1111 1100 memblock_set_bottom_up(true); 1112 - alloc_try_nid_bottom_up_narrow_range_check(); 1101 + alloc_nid_bottom_up_narrow_range_check(); 1113 1102 1114 1103 return 0; 1115 1104 } 1116 1105 1117 - static int alloc_try_nid_reserved_with_space_check(void) 1106 + static int alloc_nid_reserved_with_space_check(void) 1118 1107 { 1119 1108 test_print("\tRunning %s...\n", __func__); 1120 1109 memblock_set_bottom_up(false); 1121 - alloc_try_nid_top_down_reserved_with_space_check(); 1110 + alloc_nid_top_down_reserved_with_space_check(); 1122 1111 memblock_set_bottom_up(true); 1123 - alloc_try_nid_bottom_up_reserved_with_space_check(); 1112 + alloc_nid_bottom_up_reserved_with_space_check(); 1124 1113 1125 1114 return 0; 1126 1115 } 1127 1116 1128 - static int alloc_try_nid_reserved_no_space_check(void) 1117 + static int alloc_nid_reserved_no_space_check(void) 1129 1118 { 1130 1119 test_print("\tRunning %s...\n", __func__); 1131 1120 memblock_set_bottom_up(false); 1132 - alloc_try_nid_top_down_reserved_no_space_check(); 1121 + alloc_nid_top_down_reserved_no_space_check(); 1133 1122 memblock_set_bottom_up(true); 1134 - alloc_try_nid_bottom_up_reserved_no_space_check(); 1123 + alloc_nid_bottom_up_reserved_no_space_check(); 1135 1124 1136 1125 return 0; 1137 1126 } 1138 1127 1139 - static int alloc_try_nid_cap_max_check(void) 1128 + static int alloc_nid_cap_max_check(void) 1140 1129 { 1141 1130 test_print("\tRunning %s...\n", __func__); 1142 1131 memblock_set_bottom_up(false); 1143 - alloc_try_nid_top_down_cap_max_check(); 1132 + alloc_nid_top_down_cap_max_check(); 1144 1133 memblock_set_bottom_up(true); 1145 - alloc_try_nid_bottom_up_cap_max_check(); 1134 + alloc_nid_bottom_up_cap_max_check(); 1146 1135 1147 1136 return 0; 1148 1137 } 1149 1138 1150 - static int alloc_try_nid_cap_min_check(void) 1139 + static int alloc_nid_cap_min_check(void) 1151 1140 { 1152 1141 test_print("\tRunning %s...\n", __func__); 1153 1142 memblock_set_bottom_up(false); 1154 - alloc_try_nid_top_down_cap_min_check(); 1143 + alloc_nid_top_down_cap_min_check(); 1155 1144 memblock_set_bottom_up(true); 1156 - alloc_try_nid_bottom_up_cap_min_check(); 1145 + alloc_nid_bottom_up_cap_min_check(); 1157 1146 1158 1147 return 0; 1159 1148 } 1160 1149 1161 - static int alloc_try_nid_min_reserved_check(void) 1150 + static int alloc_nid_min_reserved_check(void) 1162 1151 { 1163 1152 test_print("\tRunning %s...\n", __func__); 1164 - run_top_down(alloc_try_nid_min_reserved_generic_check); 1165 - run_bottom_up(alloc_try_nid_min_reserved_generic_check); 1153 + run_top_down(alloc_nid_min_reserved_generic_check); 1154 + run_bottom_up(alloc_nid_min_reserved_generic_check); 1166 1155 1167 1156 return 0; 1168 1157 } 1169 1158 1170 - static int alloc_try_nid_max_reserved_check(void) 1159 + static int alloc_nid_max_reserved_check(void) 1171 1160 { 1172 1161 test_print("\tRunning %s...\n", __func__); 1173 - run_top_down(alloc_try_nid_max_reserved_generic_check); 1174 - run_bottom_up(alloc_try_nid_max_reserved_generic_check); 1162 + run_top_down(alloc_nid_max_reserved_generic_check); 1163 + run_bottom_up(alloc_nid_max_reserved_generic_check); 1175 1164 1176 1165 return 0; 1177 1166 } 1178 1167 1179 - static int alloc_try_nid_exact_address_check(void) 1168 + static int alloc_nid_exact_address_check(void) 1180 1169 { 1181 1170 test_print("\tRunning %s...\n", __func__); 1182 - run_top_down(alloc_try_nid_exact_address_generic_check); 1183 - run_bottom_up(alloc_try_nid_exact_address_generic_check); 1171 + run_top_down(alloc_nid_exact_address_generic_check); 1172 + run_bottom_up(alloc_nid_exact_address_generic_check); 1184 1173 1185 1174 return 0; 1186 1175 } 1187 1176 1188 - static int alloc_try_nid_reserved_full_merge_check(void) 1177 + static int alloc_nid_reserved_full_merge_check(void) 1189 1178 { 1190 1179 test_print("\tRunning %s...\n", __func__); 1191 - run_top_down(alloc_try_nid_reserved_full_merge_generic_check); 1192 - run_bottom_up(alloc_try_nid_reserved_full_merge_generic_check); 1180 + run_top_down(alloc_nid_reserved_full_merge_generic_check); 1181 + run_bottom_up(alloc_nid_reserved_full_merge_generic_check); 1193 1182 1194 1183 return 0; 1195 1184 } 1196 1185 1197 - static int alloc_try_nid_reserved_all_check(void) 1186 + static int alloc_nid_reserved_all_check(void) 1198 1187 { 1199 1188 test_print("\tRunning %s...\n", __func__); 1200 - run_top_down(alloc_try_nid_reserved_all_generic_check); 1201 - run_bottom_up(alloc_try_nid_reserved_all_generic_check); 1189 + run_top_down(alloc_nid_reserved_all_generic_check); 1190 + run_bottom_up(alloc_nid_reserved_all_generic_check); 1202 1191 1203 1192 return 0; 1204 1193 } 1205 1194 1206 - static int alloc_try_nid_low_max_check(void) 1195 + static int alloc_nid_low_max_check(void) 1207 1196 { 1208 1197 test_print("\tRunning %s...\n", __func__); 1209 - run_top_down(alloc_try_nid_low_max_generic_check); 1210 - run_bottom_up(alloc_try_nid_low_max_generic_check); 1198 + run_top_down(alloc_nid_low_max_generic_check); 1199 + run_bottom_up(alloc_nid_low_max_generic_check); 1211 1200 1212 1201 return 0; 1213 1202 } ··· 1215 1204 static int memblock_alloc_nid_range_checks(void) 1216 1205 { 1217 1206 test_print("Running %s range tests...\n", 1218 - get_memblock_alloc_try_nid_name(alloc_nid_test_flags)); 1207 + get_memblock_alloc_nid_name(alloc_nid_test_flags)); 1219 1208 1220 - alloc_try_nid_simple_check(); 1221 - alloc_try_nid_misaligned_check(); 1222 - alloc_try_nid_narrow_range_check(); 1223 - alloc_try_nid_reserved_with_space_check(); 1224 - alloc_try_nid_reserved_no_space_check(); 1225 - alloc_try_nid_cap_max_check(); 1226 - alloc_try_nid_cap_min_check(); 1209 + alloc_nid_simple_check(); 1210 + alloc_nid_misaligned_check(); 1211 + alloc_nid_narrow_range_check(); 1212 + alloc_nid_reserved_with_space_check(); 1213 + alloc_nid_reserved_no_space_check(); 1214 + alloc_nid_cap_max_check(); 1215 + alloc_nid_cap_min_check(); 1227 1216 1228 - alloc_try_nid_min_reserved_check(); 1229 - alloc_try_nid_max_reserved_check(); 1230 - alloc_try_nid_exact_address_check(); 1231 - alloc_try_nid_reserved_full_merge_check(); 1232 - alloc_try_nid_reserved_all_check(); 1233 - alloc_try_nid_low_max_check(); 1217 + alloc_nid_min_reserved_check(); 1218 + alloc_nid_max_reserved_check(); 1219 + alloc_nid_exact_address_check(); 1220 + alloc_nid_reserved_full_merge_check(); 1221 + alloc_nid_reserved_all_check(); 1222 + alloc_nid_low_max_check(); 1234 1223 1235 1224 return 0; 1236 1225 } ··· 1240 1229 * has enough memory to allocate a region of the requested size. 1241 1230 * Expect to allocate an aligned region at the end of the requested node. 1242 1231 */ 1243 - static int alloc_try_nid_top_down_numa_simple_check(void) 1232 + static int alloc_nid_top_down_numa_simple_check(void) 1244 1233 { 1245 1234 int nid_req = 3; 1246 1235 struct memblock_region *new_rgn = &memblock.reserved.regions[0]; ··· 1258 1247 min_addr = memblock_start_of_DRAM(); 1259 1248 max_addr = memblock_end_of_DRAM(); 1260 1249 1261 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1262 - min_addr, max_addr, nid_req); 1250 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 1251 + min_addr, max_addr, nid_req); 1263 1252 1264 1253 ASSERT_NE(allocated_ptr, NULL); 1265 1254 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 1291 1280 * Expect to allocate an aligned region at the end of the last node that has 1292 1281 * enough memory (in this case, nid = 6) after falling back to NUMA_NO_NODE. 1293 1282 */ 1294 - static int alloc_try_nid_top_down_numa_small_node_check(void) 1283 + static int alloc_nid_top_down_numa_small_node_check(void) 1295 1284 { 1296 1285 int nid_req = 1; 1297 1286 int nid_exp = 6; ··· 1310 1299 min_addr = memblock_start_of_DRAM(); 1311 1300 max_addr = memblock_end_of_DRAM(); 1312 1301 1313 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1314 - min_addr, max_addr, nid_req); 1302 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 1303 + min_addr, max_addr, nid_req); 1315 1304 1316 1305 ASSERT_NE(allocated_ptr, NULL); 1317 1306 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 1344 1333 * large enough and has enough unreserved memory (in this case, nid = 6) after 1345 1334 * falling back to NUMA_NO_NODE. The region count and total size get updated. 1346 1335 */ 1347 - static int alloc_try_nid_top_down_numa_node_reserved_check(void) 1336 + static int alloc_nid_top_down_numa_node_reserved_check(void) 1348 1337 { 1349 1338 int nid_req = 2; 1350 1339 int nid_exp = 6; ··· 1364 1353 max_addr = memblock_end_of_DRAM(); 1365 1354 1366 1355 memblock_reserve(req_node->base, req_node->size); 1367 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1368 - min_addr, max_addr, nid_req); 1356 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 1357 + min_addr, max_addr, nid_req); 1369 1358 1370 1359 ASSERT_NE(allocated_ptr, NULL); 1371 1360 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 1397 1386 * Expect to allocate an aligned region at the end of the requested node. The 1398 1387 * region count and total size get updated. 1399 1388 */ 1400 - static int alloc_try_nid_top_down_numa_part_reserved_check(void) 1389 + static int alloc_nid_top_down_numa_part_reserved_check(void) 1401 1390 { 1402 1391 int nid_req = 4; 1403 1392 struct memblock_region *new_rgn = &memblock.reserved.regions[1]; ··· 1419 1408 max_addr = memblock_end_of_DRAM(); 1420 1409 1421 1410 memblock_reserve(r1.base, r1.size); 1422 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1423 - min_addr, max_addr, nid_req); 1411 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 1412 + min_addr, max_addr, nid_req); 1424 1413 1425 1414 ASSERT_NE(allocated_ptr, NULL); 1426 1415 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 1455 1444 * nid = NUMA_NODES - 1) after falling back to NUMA_NO_NODE. The region count 1456 1445 * and total size get updated. 1457 1446 */ 1458 - static int alloc_try_nid_top_down_numa_part_reserved_fallback_check(void) 1447 + static int alloc_nid_top_down_numa_part_reserved_fallback_check(void) 1459 1448 { 1460 1449 int nid_req = 4; 1461 1450 int nid_exp = NUMA_NODES - 1; ··· 1480 1469 max_addr = memblock_end_of_DRAM(); 1481 1470 1482 1471 memblock_reserve(r1.base, r1.size); 1483 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1484 - min_addr, max_addr, nid_req); 1472 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 1473 + min_addr, max_addr, nid_req); 1485 1474 1486 1475 ASSERT_NE(allocated_ptr, NULL); 1487 1476 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 1518 1507 * Expect to drop the lower limit and allocate a memory region that ends at 1519 1508 * the end of the requested node. 1520 1509 */ 1521 - static int alloc_try_nid_top_down_numa_split_range_low_check(void) 1510 + static int alloc_nid_top_down_numa_split_range_low_check(void) 1522 1511 { 1523 1512 int nid_req = 2; 1524 1513 struct memblock_region *new_rgn = &memblock.reserved.regions[0]; ··· 1536 1525 min_addr = req_node_end - SZ_256; 1537 1526 max_addr = min_addr + size; 1538 1527 1539 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1540 - min_addr, max_addr, nid_req); 1528 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 1529 + min_addr, max_addr, nid_req); 1541 1530 1542 1531 ASSERT_NE(allocated_ptr, NULL); 1543 1532 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 1574 1563 * Expect to drop the lower limit and allocate a memory region that 1575 1564 * ends at the end of the first node that overlaps with the range. 1576 1565 */ 1577 - static int alloc_try_nid_top_down_numa_split_range_high_check(void) 1566 + static int alloc_nid_top_down_numa_split_range_high_check(void) 1578 1567 { 1579 1568 int nid_req = 3; 1580 1569 int nid_exp = nid_req - 1; ··· 1593 1582 min_addr = exp_node_end - SZ_256; 1594 1583 max_addr = min_addr + size; 1595 1584 1596 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1597 - min_addr, max_addr, nid_req); 1585 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 1586 + min_addr, max_addr, nid_req); 1598 1587 1599 1588 ASSERT_NE(allocated_ptr, NULL); 1600 1589 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 1631 1620 * Expect to drop the lower limit and allocate a memory region that ends at 1632 1621 * the end of the requested node. 1633 1622 */ 1634 - static int alloc_try_nid_top_down_numa_no_overlap_split_check(void) 1623 + static int alloc_nid_top_down_numa_no_overlap_split_check(void) 1635 1624 { 1636 1625 int nid_req = 2; 1637 1626 struct memblock_region *new_rgn = &memblock.reserved.regions[0]; ··· 1649 1638 min_addr = node2->base - SZ_256; 1650 1639 max_addr = min_addr + size; 1651 1640 1652 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1653 - min_addr, max_addr, nid_req); 1641 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 1642 + min_addr, max_addr, nid_req); 1654 1643 1655 1644 ASSERT_NE(allocated_ptr, NULL); 1656 1645 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 1688 1677 * Expect to allocate a memory region at the end of the final node in 1689 1678 * the range after falling back to NUMA_NO_NODE. 1690 1679 */ 1691 - static int alloc_try_nid_top_down_numa_no_overlap_low_check(void) 1680 + static int alloc_nid_top_down_numa_no_overlap_low_check(void) 1692 1681 { 1693 1682 int nid_req = 0; 1694 1683 struct memblock_region *new_rgn = &memblock.reserved.regions[0]; ··· 1705 1694 min_addr = min_node->base; 1706 1695 max_addr = region_end(max_node); 1707 1696 1708 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1709 - min_addr, max_addr, nid_req); 1697 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 1698 + min_addr, max_addr, nid_req); 1710 1699 1711 1700 ASSERT_NE(allocated_ptr, NULL); 1712 1701 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 1744 1733 * Expect to allocate a memory region at the end of the final node in 1745 1734 * the range after falling back to NUMA_NO_NODE. 1746 1735 */ 1747 - static int alloc_try_nid_top_down_numa_no_overlap_high_check(void) 1736 + static int alloc_nid_top_down_numa_no_overlap_high_check(void) 1748 1737 { 1749 1738 int nid_req = 7; 1750 1739 struct memblock_region *new_rgn = &memblock.reserved.regions[0]; ··· 1761 1750 min_addr = min_node->base; 1762 1751 max_addr = region_end(max_node); 1763 1752 1764 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1765 - min_addr, max_addr, nid_req); 1753 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 1754 + min_addr, max_addr, nid_req); 1766 1755 1767 1756 ASSERT_NE(allocated_ptr, NULL); 1768 1757 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 1784 1773 * has enough memory to allocate a region of the requested size. 1785 1774 * Expect to allocate an aligned region at the beginning of the requested node. 1786 1775 */ 1787 - static int alloc_try_nid_bottom_up_numa_simple_check(void) 1776 + static int alloc_nid_bottom_up_numa_simple_check(void) 1788 1777 { 1789 1778 int nid_req = 3; 1790 1779 struct memblock_region *new_rgn = &memblock.reserved.regions[0]; ··· 1802 1791 min_addr = memblock_start_of_DRAM(); 1803 1792 max_addr = memblock_end_of_DRAM(); 1804 1793 1805 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1806 - min_addr, max_addr, nid_req); 1794 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 1795 + min_addr, max_addr, nid_req); 1807 1796 1808 1797 ASSERT_NE(allocated_ptr, NULL); 1809 1798 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 1835 1824 * Expect to allocate an aligned region at the beginning of the first node that 1836 1825 * has enough memory (in this case, nid = 0) after falling back to NUMA_NO_NODE. 1837 1826 */ 1838 - static int alloc_try_nid_bottom_up_numa_small_node_check(void) 1827 + static int alloc_nid_bottom_up_numa_small_node_check(void) 1839 1828 { 1840 1829 int nid_req = 1; 1841 1830 int nid_exp = 0; ··· 1854 1843 min_addr = memblock_start_of_DRAM(); 1855 1844 max_addr = memblock_end_of_DRAM(); 1856 1845 1857 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1858 - min_addr, max_addr, nid_req); 1846 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 1847 + min_addr, max_addr, nid_req); 1859 1848 1860 1849 ASSERT_NE(allocated_ptr, NULL); 1861 1850 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 1889 1878 * after falling back to NUMA_NO_NODE. The region count and total size get 1890 1879 * updated. 1891 1880 */ 1892 - static int alloc_try_nid_bottom_up_numa_node_reserved_check(void) 1881 + static int alloc_nid_bottom_up_numa_node_reserved_check(void) 1893 1882 { 1894 1883 int nid_req = 2; 1895 1884 int nid_exp = 0; ··· 1909 1898 max_addr = memblock_end_of_DRAM(); 1910 1899 1911 1900 memblock_reserve(req_node->base, req_node->size); 1912 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1913 - min_addr, max_addr, nid_req); 1901 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 1902 + min_addr, max_addr, nid_req); 1914 1903 1915 1904 ASSERT_NE(allocated_ptr, NULL); 1916 1905 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 1942 1931 * Expect to allocate an aligned region in the requested node that merges with 1943 1932 * the existing reserved region. The total size gets updated. 1944 1933 */ 1945 - static int alloc_try_nid_bottom_up_numa_part_reserved_check(void) 1934 + static int alloc_nid_bottom_up_numa_part_reserved_check(void) 1946 1935 { 1947 1936 int nid_req = 4; 1948 1937 struct memblock_region *new_rgn = &memblock.reserved.regions[0]; ··· 1966 1955 total_size = size + r1.size; 1967 1956 1968 1957 memblock_reserve(r1.base, r1.size); 1969 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1970 - min_addr, max_addr, nid_req); 1958 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 1959 + min_addr, max_addr, nid_req); 1971 1960 1972 1961 ASSERT_NE(allocated_ptr, NULL); 1973 1962 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 2002 1991 * nid = 0) after falling back to NUMA_NO_NODE. The region count and total size 2003 1992 * get updated. 2004 1993 */ 2005 - static int alloc_try_nid_bottom_up_numa_part_reserved_fallback_check(void) 1994 + static int alloc_nid_bottom_up_numa_part_reserved_fallback_check(void) 2006 1995 { 2007 1996 int nid_req = 4; 2008 1997 int nid_exp = 0; ··· 2027 2016 max_addr = memblock_end_of_DRAM(); 2028 2017 2029 2018 memblock_reserve(r1.base, r1.size); 2030 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 2031 - min_addr, max_addr, nid_req); 2019 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 2020 + min_addr, max_addr, nid_req); 2032 2021 2033 2022 ASSERT_NE(allocated_ptr, NULL); 2034 2023 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 2065 2054 * Expect to drop the lower limit and allocate a memory region at the beginning 2066 2055 * of the requested node. 2067 2056 */ 2068 - static int alloc_try_nid_bottom_up_numa_split_range_low_check(void) 2057 + static int alloc_nid_bottom_up_numa_split_range_low_check(void) 2069 2058 { 2070 2059 int nid_req = 2; 2071 2060 struct memblock_region *new_rgn = &memblock.reserved.regions[0]; ··· 2083 2072 min_addr = req_node_end - SZ_256; 2084 2073 max_addr = min_addr + size; 2085 2074 2086 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 2087 - min_addr, max_addr, nid_req); 2075 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 2076 + min_addr, max_addr, nid_req); 2088 2077 2089 2078 ASSERT_NE(allocated_ptr, NULL); 2090 2079 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 2121 2110 * Expect to drop the lower limit and allocate a memory region at the beginning 2122 2111 * of the first node that has enough memory. 2123 2112 */ 2124 - static int alloc_try_nid_bottom_up_numa_split_range_high_check(void) 2113 + static int alloc_nid_bottom_up_numa_split_range_high_check(void) 2125 2114 { 2126 2115 int nid_req = 3; 2127 2116 int nid_exp = 0; ··· 2141 2130 min_addr = req_node->base - SZ_256; 2142 2131 max_addr = min_addr + size; 2143 2132 2144 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 2145 - min_addr, max_addr, nid_req); 2133 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 2134 + min_addr, max_addr, nid_req); 2146 2135 2147 2136 ASSERT_NE(allocated_ptr, NULL); 2148 2137 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 2179 2168 * Expect to drop the lower limit and allocate a memory region that starts at 2180 2169 * the beginning of the requested node. 2181 2170 */ 2182 - static int alloc_try_nid_bottom_up_numa_no_overlap_split_check(void) 2171 + static int alloc_nid_bottom_up_numa_no_overlap_split_check(void) 2183 2172 { 2184 2173 int nid_req = 2; 2185 2174 struct memblock_region *new_rgn = &memblock.reserved.regions[0]; ··· 2197 2186 min_addr = node2->base - SZ_256; 2198 2187 max_addr = min_addr + size; 2199 2188 2200 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 2201 - min_addr, max_addr, nid_req); 2189 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 2190 + min_addr, max_addr, nid_req); 2202 2191 2203 2192 ASSERT_NE(allocated_ptr, NULL); 2204 2193 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 2236 2225 * Expect to allocate a memory region at the beginning of the first node 2237 2226 * in the range after falling back to NUMA_NO_NODE. 2238 2227 */ 2239 - static int alloc_try_nid_bottom_up_numa_no_overlap_low_check(void) 2228 + static int alloc_nid_bottom_up_numa_no_overlap_low_check(void) 2240 2229 { 2241 2230 int nid_req = 0; 2242 2231 struct memblock_region *new_rgn = &memblock.reserved.regions[0]; ··· 2253 2242 min_addr = min_node->base; 2254 2243 max_addr = region_end(max_node); 2255 2244 2256 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 2257 - min_addr, max_addr, nid_req); 2245 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 2246 + min_addr, max_addr, nid_req); 2258 2247 2259 2248 ASSERT_NE(allocated_ptr, NULL); 2260 2249 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 2292 2281 * Expect to allocate a memory region at the beginning of the first node 2293 2282 * in the range after falling back to NUMA_NO_NODE. 2294 2283 */ 2295 - static int alloc_try_nid_bottom_up_numa_no_overlap_high_check(void) 2284 + static int alloc_nid_bottom_up_numa_no_overlap_high_check(void) 2296 2285 { 2297 2286 int nid_req = 7; 2298 2287 struct memblock_region *new_rgn = &memblock.reserved.regions[0]; ··· 2309 2298 min_addr = min_node->base; 2310 2299 max_addr = region_end(max_node); 2311 2300 2312 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 2313 - min_addr, max_addr, nid_req); 2301 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 2302 + min_addr, max_addr, nid_req); 2314 2303 2315 2304 ASSERT_NE(allocated_ptr, NULL); 2316 2305 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 2341 2330 * 2342 2331 * Expect no allocation to happen. 2343 2332 */ 2344 - static int alloc_try_nid_numa_large_region_generic_check(void) 2333 + static int alloc_nid_numa_large_region_generic_check(void) 2345 2334 { 2346 2335 int nid_req = 3; 2347 2336 void *allocated_ptr = NULL; ··· 2355 2344 min_addr = memblock_start_of_DRAM(); 2356 2345 max_addr = memblock_end_of_DRAM(); 2357 2346 2358 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 2359 - min_addr, max_addr, nid_req); 2347 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 2348 + min_addr, max_addr, nid_req); 2360 2349 ASSERT_EQ(allocated_ptr, NULL); 2361 2350 2362 2351 test_pass_pop(); ··· 2385 2374 * Expect to merge all of the regions into one. The region counter and total 2386 2375 * size fields get updated. 2387 2376 */ 2388 - static int alloc_try_nid_numa_reserved_full_merge_generic_check(void) 2377 + static int alloc_nid_numa_reserved_full_merge_generic_check(void) 2389 2378 { 2390 2379 int nid_req = 6; 2391 2380 int nid_next = nid_req + 1; ··· 2415 2404 memblock_reserve(r1.base, r1.size); 2416 2405 memblock_reserve(r2.base, r2.size); 2417 2406 2418 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 2419 - min_addr, max_addr, nid_req); 2407 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 2408 + min_addr, max_addr, nid_req); 2420 2409 2421 2410 ASSERT_NE(allocated_ptr, NULL); 2422 2411 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); ··· 2459 2448 * 2460 2449 * Expect no allocation to happen. 2461 2450 */ 2462 - static int alloc_try_nid_numa_split_all_reserved_generic_check(void) 2451 + static int alloc_nid_numa_split_all_reserved_generic_check(void) 2463 2452 { 2464 2453 void *allocated_ptr = NULL; 2465 2454 struct memblock_region *next_node = &memblock.memory.regions[7]; ··· 2483 2472 memblock_reserve(r1.base, r1.size); 2484 2473 memblock_reserve(r2.base, r2.size); 2485 2474 2486 - allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 2487 - min_addr, max_addr, 2488 - NUMA_NO_NODE); 2475 + allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES, 2476 + min_addr, max_addr, 2477 + NUMA_NO_NODE); 2489 2478 2490 2479 ASSERT_EQ(allocated_ptr, NULL); 2491 2480 ··· 2495 2484 } 2496 2485 2497 2486 /* Test case wrappers for NUMA tests */ 2498 - static int alloc_try_nid_numa_simple_check(void) 2487 + static int alloc_nid_numa_simple_check(void) 2499 2488 { 2500 2489 test_print("\tRunning %s...\n", __func__); 2501 2490 memblock_set_bottom_up(false); 2502 - alloc_try_nid_top_down_numa_simple_check(); 2491 + alloc_nid_top_down_numa_simple_check(); 2503 2492 memblock_set_bottom_up(true); 2504 - alloc_try_nid_bottom_up_numa_simple_check(); 2493 + alloc_nid_bottom_up_numa_simple_check(); 2505 2494 2506 2495 return 0; 2507 2496 } 2508 2497 2509 - static int alloc_try_nid_numa_small_node_check(void) 2498 + static int alloc_nid_numa_small_node_check(void) 2510 2499 { 2511 2500 test_print("\tRunning %s...\n", __func__); 2512 2501 memblock_set_bottom_up(false); 2513 - alloc_try_nid_top_down_numa_small_node_check(); 2502 + alloc_nid_top_down_numa_small_node_check(); 2514 2503 memblock_set_bottom_up(true); 2515 - alloc_try_nid_bottom_up_numa_small_node_check(); 2504 + alloc_nid_bottom_up_numa_small_node_check(); 2516 2505 2517 2506 return 0; 2518 2507 } 2519 2508 2520 - static int alloc_try_nid_numa_node_reserved_check(void) 2509 + static int alloc_nid_numa_node_reserved_check(void) 2521 2510 { 2522 2511 test_print("\tRunning %s...\n", __func__); 2523 2512 memblock_set_bottom_up(false); 2524 - alloc_try_nid_top_down_numa_node_reserved_check(); 2513 + alloc_nid_top_down_numa_node_reserved_check(); 2525 2514 memblock_set_bottom_up(true); 2526 - alloc_try_nid_bottom_up_numa_node_reserved_check(); 2515 + alloc_nid_bottom_up_numa_node_reserved_check(); 2527 2516 2528 2517 return 0; 2529 2518 } 2530 2519 2531 - static int alloc_try_nid_numa_part_reserved_check(void) 2520 + static int alloc_nid_numa_part_reserved_check(void) 2532 2521 { 2533 2522 test_print("\tRunning %s...\n", __func__); 2534 2523 memblock_set_bottom_up(false); 2535 - alloc_try_nid_top_down_numa_part_reserved_check(); 2524 + alloc_nid_top_down_numa_part_reserved_check(); 2536 2525 memblock_set_bottom_up(true); 2537 - alloc_try_nid_bottom_up_numa_part_reserved_check(); 2526 + alloc_nid_bottom_up_numa_part_reserved_check(); 2538 2527 2539 2528 return 0; 2540 2529 } 2541 2530 2542 - static int alloc_try_nid_numa_part_reserved_fallback_check(void) 2531 + static int alloc_nid_numa_part_reserved_fallback_check(void) 2543 2532 { 2544 2533 test_print("\tRunning %s...\n", __func__); 2545 2534 memblock_set_bottom_up(false); 2546 - alloc_try_nid_top_down_numa_part_reserved_fallback_check(); 2535 + alloc_nid_top_down_numa_part_reserved_fallback_check(); 2547 2536 memblock_set_bottom_up(true); 2548 - alloc_try_nid_bottom_up_numa_part_reserved_fallback_check(); 2537 + alloc_nid_bottom_up_numa_part_reserved_fallback_check(); 2549 2538 2550 2539 return 0; 2551 2540 } 2552 2541 2553 - static int alloc_try_nid_numa_split_range_low_check(void) 2542 + static int alloc_nid_numa_split_range_low_check(void) 2554 2543 { 2555 2544 test_print("\tRunning %s...\n", __func__); 2556 2545 memblock_set_bottom_up(false); 2557 - alloc_try_nid_top_down_numa_split_range_low_check(); 2546 + alloc_nid_top_down_numa_split_range_low_check(); 2558 2547 memblock_set_bottom_up(true); 2559 - alloc_try_nid_bottom_up_numa_split_range_low_check(); 2548 + alloc_nid_bottom_up_numa_split_range_low_check(); 2560 2549 2561 2550 return 0; 2562 2551 } 2563 2552 2564 - static int alloc_try_nid_numa_split_range_high_check(void) 2553 + static int alloc_nid_numa_split_range_high_check(void) 2565 2554 { 2566 2555 test_print("\tRunning %s...\n", __func__); 2567 2556 memblock_set_bottom_up(false); 2568 - alloc_try_nid_top_down_numa_split_range_high_check(); 2557 + alloc_nid_top_down_numa_split_range_high_check(); 2569 2558 memblock_set_bottom_up(true); 2570 - alloc_try_nid_bottom_up_numa_split_range_high_check(); 2559 + alloc_nid_bottom_up_numa_split_range_high_check(); 2571 2560 2572 2561 return 0; 2573 2562 } 2574 2563 2575 - static int alloc_try_nid_numa_no_overlap_split_check(void) 2564 + static int alloc_nid_numa_no_overlap_split_check(void) 2576 2565 { 2577 2566 test_print("\tRunning %s...\n", __func__); 2578 2567 memblock_set_bottom_up(false); 2579 - alloc_try_nid_top_down_numa_no_overlap_split_check(); 2568 + alloc_nid_top_down_numa_no_overlap_split_check(); 2580 2569 memblock_set_bottom_up(true); 2581 - alloc_try_nid_bottom_up_numa_no_overlap_split_check(); 2570 + alloc_nid_bottom_up_numa_no_overlap_split_check(); 2582 2571 2583 2572 return 0; 2584 2573 } 2585 2574 2586 - static int alloc_try_nid_numa_no_overlap_low_check(void) 2575 + static int alloc_nid_numa_no_overlap_low_check(void) 2587 2576 { 2588 2577 test_print("\tRunning %s...\n", __func__); 2589 2578 memblock_set_bottom_up(false); 2590 - alloc_try_nid_top_down_numa_no_overlap_low_check(); 2579 + alloc_nid_top_down_numa_no_overlap_low_check(); 2591 2580 memblock_set_bottom_up(true); 2592 - alloc_try_nid_bottom_up_numa_no_overlap_low_check(); 2581 + alloc_nid_bottom_up_numa_no_overlap_low_check(); 2593 2582 2594 2583 return 0; 2595 2584 } 2596 2585 2597 - static int alloc_try_nid_numa_no_overlap_high_check(void) 2586 + static int alloc_nid_numa_no_overlap_high_check(void) 2598 2587 { 2599 2588 test_print("\tRunning %s...\n", __func__); 2600 2589 memblock_set_bottom_up(false); 2601 - alloc_try_nid_top_down_numa_no_overlap_high_check(); 2590 + alloc_nid_top_down_numa_no_overlap_high_check(); 2602 2591 memblock_set_bottom_up(true); 2603 - alloc_try_nid_bottom_up_numa_no_overlap_high_check(); 2592 + alloc_nid_bottom_up_numa_no_overlap_high_check(); 2604 2593 2605 2594 return 0; 2606 2595 } 2607 2596 2608 - static int alloc_try_nid_numa_large_region_check(void) 2597 + static int alloc_nid_numa_large_region_check(void) 2609 2598 { 2610 2599 test_print("\tRunning %s...\n", __func__); 2611 - run_top_down(alloc_try_nid_numa_large_region_generic_check); 2612 - run_bottom_up(alloc_try_nid_numa_large_region_generic_check); 2600 + run_top_down(alloc_nid_numa_large_region_generic_check); 2601 + run_bottom_up(alloc_nid_numa_large_region_generic_check); 2613 2602 2614 2603 return 0; 2615 2604 } 2616 2605 2617 - static int alloc_try_nid_numa_reserved_full_merge_check(void) 2606 + static int alloc_nid_numa_reserved_full_merge_check(void) 2618 2607 { 2619 2608 test_print("\tRunning %s...\n", __func__); 2620 - run_top_down(alloc_try_nid_numa_reserved_full_merge_generic_check); 2621 - run_bottom_up(alloc_try_nid_numa_reserved_full_merge_generic_check); 2609 + run_top_down(alloc_nid_numa_reserved_full_merge_generic_check); 2610 + run_bottom_up(alloc_nid_numa_reserved_full_merge_generic_check); 2622 2611 2623 2612 return 0; 2624 2613 } 2625 2614 2626 - static int alloc_try_nid_numa_split_all_reserved_check(void) 2615 + static int alloc_nid_numa_split_all_reserved_check(void) 2627 2616 { 2628 2617 test_print("\tRunning %s...\n", __func__); 2629 - run_top_down(alloc_try_nid_numa_split_all_reserved_generic_check); 2630 - run_bottom_up(alloc_try_nid_numa_split_all_reserved_generic_check); 2618 + run_top_down(alloc_nid_numa_split_all_reserved_generic_check); 2619 + run_bottom_up(alloc_nid_numa_split_all_reserved_generic_check); 2631 2620 2632 2621 return 0; 2633 2622 } ··· 2635 2624 int __memblock_alloc_nid_numa_checks(void) 2636 2625 { 2637 2626 test_print("Running %s NUMA tests...\n", 2638 - get_memblock_alloc_try_nid_name(alloc_nid_test_flags)); 2627 + get_memblock_alloc_nid_name(alloc_nid_test_flags)); 2639 2628 2640 - alloc_try_nid_numa_simple_check(); 2641 - alloc_try_nid_numa_small_node_check(); 2642 - alloc_try_nid_numa_node_reserved_check(); 2643 - alloc_try_nid_numa_part_reserved_check(); 2644 - alloc_try_nid_numa_part_reserved_fallback_check(); 2645 - alloc_try_nid_numa_split_range_low_check(); 2646 - alloc_try_nid_numa_split_range_high_check(); 2629 + alloc_nid_numa_simple_check(); 2630 + alloc_nid_numa_small_node_check(); 2631 + alloc_nid_numa_node_reserved_check(); 2632 + alloc_nid_numa_part_reserved_check(); 2633 + alloc_nid_numa_part_reserved_fallback_check(); 2634 + alloc_nid_numa_split_range_low_check(); 2635 + alloc_nid_numa_split_range_high_check(); 2647 2636 2648 - alloc_try_nid_numa_no_overlap_split_check(); 2649 - alloc_try_nid_numa_no_overlap_low_check(); 2650 - alloc_try_nid_numa_no_overlap_high_check(); 2651 - alloc_try_nid_numa_large_region_check(); 2652 - alloc_try_nid_numa_reserved_full_merge_check(); 2653 - alloc_try_nid_numa_split_all_reserved_check(); 2637 + alloc_nid_numa_no_overlap_split_check(); 2638 + alloc_nid_numa_no_overlap_low_check(); 2639 + alloc_nid_numa_no_overlap_high_check(); 2640 + alloc_nid_numa_large_region_check(); 2641 + alloc_nid_numa_reserved_full_merge_check(); 2642 + alloc_nid_numa_split_all_reserved_check(); 2654 2643 2655 2644 return 0; 2656 2645 } ··· 2660 2649 alloc_nid_test_flags = flags; 2661 2650 2662 2651 prefix_reset(); 2663 - prefix_push(get_memblock_alloc_try_nid_name(flags)); 2652 + prefix_push(get_memblock_alloc_nid_name(flags)); 2664 2653 2665 2654 reset_memblock_attributes(); 2666 2655 dummy_physical_memory_init(); ··· 2679 2668 { 2680 2669 memblock_alloc_nid_checks_internal(TEST_F_NONE); 2681 2670 memblock_alloc_nid_checks_internal(TEST_F_RAW); 2671 + 2672 + return 0; 2673 + } 2674 + 2675 + int memblock_alloc_exact_nid_range_checks(void) 2676 + { 2677 + alloc_nid_test_flags = (TEST_F_RAW | TEST_F_EXACT); 2678 + 2679 + memblock_alloc_nid_range_checks(); 2682 2680 2683 2681 return 0; 2684 2682 }
+1
tools/testing/memblock/tests/alloc_nid_api.h
··· 5 5 #include "common.h" 6 6 7 7 int memblock_alloc_nid_checks(void); 8 + int memblock_alloc_exact_nid_range_checks(void); 8 9 int __memblock_alloc_nid_numa_checks(void); 9 10 10 11 #ifdef CONFIG_NUMA
+2
tools/testing/memblock/tests/common.h
··· 21 21 TEST_F_NONE = 0x0, 22 22 /* Perform raw allocations (no zeroing of memory). */ 23 23 TEST_F_RAW = 0x1, 24 + /* Perform allocations on the exact node specified. */ 25 + TEST_F_EXACT = 0x2 24 26 }; 25 27 26 28 /**