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

Configure Feed

Select the types of activity you want to include in your feed.

memblock tests: update alloc_nid_api to test memblock_alloc_try_nid_raw

Update memblock_alloc_try_nid() tests so that they test either
memblock_alloc_try_nid() or memblock_alloc_try_nid_raw() depending on the
value of alloc_nid_test_flags. Run through all the existing tests in
alloc_nid_api twice: once for memblock_alloc_try_nid() and once for
memblock_alloc_try_nid_raw().

When the tests run memblock_alloc_try_nid(), they test that the entire
memory region is zero. When the tests run memblock_alloc_try_nid_raw(),
they test that the entire memory region is nonzero. The content of the
memory region is initialized to nonzero, and we expect it to remain
unchanged if running memblock_alloc_try_nid_raw().

Reviewed-by: Shaoqin Huang <shaoqin.huang@intel.com>
Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
Link: https://lore.kernel.org/r/6fa8938f67872841c10a00afb042947d1d280a04.1661578349.git.remckee0@gmail.com

authored by

Rebecca Mckeever and committed by
Mike Rapoport ae544fd6 deee033e

+111 -69
+111 -69
tools/testing/memblock/tests/alloc_nid_api.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0-or-later 2 2 #include "alloc_nid_api.h" 3 3 4 + static int alloc_nid_test_flags = TEST_F_NONE; 5 + 6 + static inline const char * const get_memblock_alloc_try_nid_name(int flags) 7 + { 8 + if (flags & TEST_F_RAW) 9 + return "memblock_alloc_try_nid_raw"; 10 + return "memblock_alloc_try_nid"; 11 + } 12 + 13 + static inline void *run_memblock_alloc_try_nid(phys_addr_t size, 14 + phys_addr_t align, 15 + phys_addr_t min_addr, 16 + phys_addr_t max_addr, int nid) 17 + { 18 + if (alloc_nid_test_flags & TEST_F_RAW) 19 + return memblock_alloc_try_nid_raw(size, align, min_addr, 20 + max_addr, nid); 21 + return memblock_alloc_try_nid(size, align, min_addr, max_addr, nid); 22 + } 23 + 4 24 /* 5 25 * A simple test that tries to allocate a memory region within min_addr and 6 26 * max_addr range: ··· 52 32 min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2; 53 33 max_addr = min_addr + SZ_512; 54 34 55 - allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 56 - min_addr, max_addr, NUMA_NO_NODE); 35 + allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 36 + min_addr, max_addr, 37 + NUMA_NO_NODE); 57 38 rgn_end = rgn->base + rgn->size; 58 39 59 40 ASSERT_NE(allocated_ptr, NULL); 60 - ASSERT_MEM_EQ(allocated_ptr, 0, size); 41 + assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); 61 42 62 43 ASSERT_EQ(rgn->size, size); 63 44 ASSERT_EQ(rgn->base, max_addr - size); ··· 107 86 min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2; 108 87 max_addr = min_addr + SZ_512 + misalign; 109 88 110 - allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 111 - min_addr, max_addr, NUMA_NO_NODE); 89 + allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 90 + min_addr, max_addr, 91 + NUMA_NO_NODE); 112 92 rgn_end = rgn->base + rgn->size; 113 93 114 94 ASSERT_NE(allocated_ptr, NULL); 115 - ASSERT_MEM_EQ(allocated_ptr, 0, size); 95 + assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); 116 96 117 97 ASSERT_EQ(rgn->size, size); 118 98 ASSERT_EQ(rgn->base, max_addr - size - misalign); ··· 159 137 min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES; 160 138 max_addr = min_addr + size; 161 139 162 - allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 163 - min_addr, max_addr, NUMA_NO_NODE); 140 + allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 141 + min_addr, max_addr, 142 + NUMA_NO_NODE); 164 143 rgn_end = rgn->base + rgn->size; 165 144 166 145 ASSERT_NE(allocated_ptr, NULL); 167 - ASSERT_MEM_EQ(allocated_ptr, 0, size); 146 + assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); 168 147 169 148 ASSERT_EQ(rgn->size, size); 170 149 ASSERT_EQ(rgn->base, min_addr); ··· 212 189 min_addr = memblock_start_of_DRAM() + SZ_512; 213 190 max_addr = min_addr + SMP_CACHE_BYTES; 214 191 215 - allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 216 - min_addr, max_addr, NUMA_NO_NODE); 192 + allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 193 + min_addr, max_addr, 194 + NUMA_NO_NODE); 217 195 218 196 ASSERT_NE(allocated_ptr, NULL); 219 - ASSERT_MEM_EQ(allocated_ptr, 0, size); 197 + assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); 220 198 221 199 ASSERT_EQ(rgn->size, size); 222 200 ASSERT_EQ(rgn->base, max_addr - size); ··· 265 241 min_addr = memblock_start_of_DRAM(); 266 242 max_addr = min_addr + SMP_CACHE_BYTES; 267 243 268 - allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 269 - min_addr, max_addr, NUMA_NO_NODE); 244 + allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 245 + min_addr, max_addr, 246 + NUMA_NO_NODE); 270 247 271 248 ASSERT_EQ(allocated_ptr, NULL); 272 249 ··· 312 287 313 288 memblock_reserve(reserved_base, r1_size); 314 289 315 - allocated_ptr = memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES, 316 - min_addr, max_addr, NUMA_NO_NODE); 290 + allocated_ptr = run_memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES, 291 + min_addr, max_addr, 292 + NUMA_NO_NODE); 317 293 318 294 ASSERT_NE(allocated_ptr, NULL); 319 - ASSERT_MEM_EQ(allocated_ptr, 0, r2_size); 295 + assert_mem_content(allocated_ptr, r2_size, alloc_nid_test_flags); 320 296 321 297 ASSERT_EQ(rgn->size, total_size); 322 298 ASSERT_EQ(rgn->base, reserved_base); ··· 364 338 365 339 memblock_reserve(max_addr, r1_size); 366 340 367 - allocated_ptr = memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES, 368 - min_addr, max_addr, NUMA_NO_NODE); 341 + allocated_ptr = run_memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES, 342 + min_addr, max_addr, 343 + NUMA_NO_NODE); 369 344 370 345 ASSERT_NE(allocated_ptr, NULL); 371 - ASSERT_MEM_EQ(allocated_ptr, 0, r2_size); 346 + assert_mem_content(allocated_ptr, r2_size, alloc_nid_test_flags); 372 347 373 348 ASSERT_EQ(rgn->size, total_size); 374 349 ASSERT_EQ(rgn->base, min_addr); ··· 429 402 memblock_reserve(r1.base, r1.size); 430 403 memblock_reserve(r2.base, r2.size); 431 404 432 - allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 433 - min_addr, max_addr, NUMA_NO_NODE); 405 + allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 406 + min_addr, max_addr, 407 + NUMA_NO_NODE); 434 408 435 409 ASSERT_NE(allocated_ptr, NULL); 436 - ASSERT_MEM_EQ(allocated_ptr, 0, r3_size); 410 + assert_mem_content(allocated_ptr, r3_size, alloc_nid_test_flags); 437 411 438 412 ASSERT_EQ(rgn1->size, r1.size + r3_size); 439 413 ASSERT_EQ(rgn1->base, max_addr - r3_size); ··· 494 466 memblock_reserve(r1.base, r1.size); 495 467 memblock_reserve(r2.base, r2.size); 496 468 497 - allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 498 - min_addr, max_addr, NUMA_NO_NODE); 469 + allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 470 + min_addr, max_addr, 471 + NUMA_NO_NODE); 499 472 500 473 ASSERT_NE(allocated_ptr, NULL); 501 - ASSERT_MEM_EQ(allocated_ptr, 0, r3_size); 474 + assert_mem_content(allocated_ptr, r3_size, alloc_nid_test_flags); 502 475 503 476 ASSERT_EQ(rgn->size, total_size); 504 477 ASSERT_EQ(rgn->base, r2.base); ··· 560 531 memblock_reserve(r1.base, r1.size); 561 532 memblock_reserve(r2.base, r2.size); 562 533 563 - allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 564 - min_addr, max_addr, NUMA_NO_NODE); 534 + allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 535 + min_addr, max_addr, 536 + NUMA_NO_NODE); 565 537 566 538 ASSERT_NE(allocated_ptr, NULL); 567 - ASSERT_MEM_EQ(allocated_ptr, 0, r3_size); 539 + assert_mem_content(allocated_ptr, r3_size, alloc_nid_test_flags); 568 540 569 541 ASSERT_EQ(rgn1->size, r1.size); 570 542 ASSERT_EQ(rgn1->base, r1.base); ··· 627 597 memblock_reserve(r1.base, r1.size); 628 598 memblock_reserve(r2.base, r2.size); 629 599 630 - allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 631 - min_addr, max_addr, NUMA_NO_NODE); 600 + allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 601 + min_addr, max_addr, 602 + NUMA_NO_NODE); 632 603 633 604 ASSERT_EQ(allocated_ptr, NULL); 634 605 ··· 659 628 min_addr = memblock_end_of_DRAM() - SZ_1K; 660 629 max_addr = memblock_end_of_DRAM() + SZ_256; 661 630 662 - allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 663 - min_addr, max_addr, NUMA_NO_NODE); 631 + allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 632 + min_addr, max_addr, 633 + NUMA_NO_NODE); 664 634 665 635 ASSERT_NE(allocated_ptr, NULL); 666 - ASSERT_MEM_EQ(allocated_ptr, 0, size); 636 + assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); 667 637 668 638 ASSERT_EQ(rgn->size, size); 669 639 ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size); ··· 698 666 min_addr = memblock_start_of_DRAM() - SZ_256; 699 667 max_addr = memblock_end_of_DRAM(); 700 668 701 - allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 702 - min_addr, max_addr, NUMA_NO_NODE); 669 + allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 670 + min_addr, max_addr, 671 + NUMA_NO_NODE); 703 672 704 673 ASSERT_NE(allocated_ptr, NULL); 705 - ASSERT_MEM_EQ(allocated_ptr, 0, size); 674 + assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); 706 675 707 676 ASSERT_EQ(rgn->size, size); 708 677 ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size); ··· 747 714 min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2; 748 715 max_addr = min_addr + SZ_512; 749 716 750 - allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 751 - min_addr, max_addr, 752 - NUMA_NO_NODE); 717 + allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 718 + min_addr, max_addr, 719 + NUMA_NO_NODE); 753 720 rgn_end = rgn->base + rgn->size; 754 721 755 722 ASSERT_NE(allocated_ptr, NULL); 756 - ASSERT_MEM_EQ(allocated_ptr, 0, size); 723 + assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); 757 724 758 725 ASSERT_EQ(rgn->size, size); 759 726 ASSERT_EQ(rgn->base, min_addr); ··· 802 769 min_addr = memblock_start_of_DRAM() + misalign; 803 770 max_addr = min_addr + SZ_512; 804 771 805 - allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 806 - min_addr, max_addr, 807 - NUMA_NO_NODE); 772 + allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 773 + min_addr, max_addr, 774 + NUMA_NO_NODE); 808 775 rgn_end = rgn->base + rgn->size; 809 776 810 777 ASSERT_NE(allocated_ptr, NULL); 811 - ASSERT_MEM_EQ(allocated_ptr, 0, size); 778 + assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); 812 779 813 780 ASSERT_EQ(rgn->size, size); 814 781 ASSERT_EQ(rgn->base, min_addr + (SMP_CACHE_BYTES - misalign)); ··· 855 822 min_addr = memblock_start_of_DRAM() + SZ_512; 856 823 max_addr = min_addr + SMP_CACHE_BYTES; 857 824 858 - allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 859 - min_addr, max_addr, 860 - NUMA_NO_NODE); 825 + allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 826 + min_addr, max_addr, 827 + NUMA_NO_NODE); 861 828 862 829 ASSERT_NE(allocated_ptr, NULL); 863 - ASSERT_MEM_EQ(allocated_ptr, 0, size); 830 + assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); 864 831 865 832 ASSERT_EQ(rgn->size, size); 866 833 ASSERT_EQ(rgn->base, memblock_start_of_DRAM()); ··· 920 887 memblock_reserve(r1.base, r1.size); 921 888 memblock_reserve(r2.base, r2.size); 922 889 923 - allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 924 - min_addr, max_addr, 925 - NUMA_NO_NODE); 890 + allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 891 + min_addr, max_addr, 892 + NUMA_NO_NODE); 926 893 927 894 ASSERT_NE(allocated_ptr, NULL); 928 - ASSERT_MEM_EQ(allocated_ptr, 0, r3_size); 895 + assert_mem_content(allocated_ptr, r3_size, alloc_nid_test_flags); 929 896 930 897 ASSERT_EQ(rgn1->size, r1.size); 931 898 ASSERT_EQ(rgn1->base, max_addr); ··· 992 959 memblock_reserve(r1.base, r1.size); 993 960 memblock_reserve(r2.base, r2.size); 994 961 995 - allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 996 - min_addr, max_addr, 997 - NUMA_NO_NODE); 962 + allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 963 + min_addr, max_addr, 964 + NUMA_NO_NODE); 998 965 999 966 ASSERT_NE(allocated_ptr, NULL); 1000 - ASSERT_MEM_EQ(allocated_ptr, 0, r3_size); 967 + assert_mem_content(allocated_ptr, r3_size, alloc_nid_test_flags); 1001 968 1002 969 ASSERT_EQ(rgn3->size, r3_size); 1003 970 ASSERT_EQ(rgn3->base, memblock_start_of_DRAM()); ··· 1037 1004 min_addr = memblock_start_of_DRAM() + SZ_1K; 1038 1005 max_addr = memblock_end_of_DRAM() + SZ_256; 1039 1006 1040 - allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1041 - min_addr, max_addr, 1042 - NUMA_NO_NODE); 1007 + allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1008 + min_addr, max_addr, 1009 + NUMA_NO_NODE); 1043 1010 1044 1011 ASSERT_NE(allocated_ptr, NULL); 1045 - ASSERT_MEM_EQ(allocated_ptr, 0, size); 1012 + assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); 1046 1013 1047 1014 ASSERT_EQ(rgn->size, size); 1048 1015 ASSERT_EQ(rgn->base, min_addr); ··· 1076 1043 min_addr = memblock_start_of_DRAM(); 1077 1044 max_addr = memblock_end_of_DRAM() - SZ_256; 1078 1045 1079 - allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1080 - min_addr, max_addr, 1081 - NUMA_NO_NODE); 1046 + allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1047 + min_addr, max_addr, 1048 + NUMA_NO_NODE); 1082 1049 1083 1050 ASSERT_NE(allocated_ptr, NULL); 1084 - ASSERT_MEM_EQ(allocated_ptr, 0, size); 1051 + assert_mem_content(allocated_ptr, size, alloc_nid_test_flags); 1085 1052 1086 1053 ASSERT_EQ(rgn->size, size); 1087 1054 ASSERT_EQ(rgn->base, memblock_start_of_DRAM()); ··· 1226 1193 return 0; 1227 1194 } 1228 1195 1229 - int memblock_alloc_nid_checks(void) 1196 + static int memblock_alloc_nid_checks_internal(int flags) 1230 1197 { 1231 - const char *func_testing = "memblock_alloc_try_nid"; 1198 + const char *func = get_memblock_alloc_try_nid_name(flags); 1232 1199 1200 + alloc_nid_test_flags = flags; 1233 1201 prefix_reset(); 1234 - prefix_push(func_testing); 1235 - test_print("Running %s tests...\n", func_testing); 1202 + prefix_push(func); 1203 + test_print("Running %s tests...\n", func); 1236 1204 1237 1205 reset_memblock_attributes(); 1238 1206 dummy_physical_memory_init(); ··· 1256 1222 dummy_physical_memory_cleanup(); 1257 1223 1258 1224 prefix_pop(); 1225 + 1226 + return 0; 1227 + } 1228 + 1229 + int memblock_alloc_nid_checks(void) 1230 + { 1231 + memblock_alloc_nid_checks_internal(TEST_F_NONE); 1232 + memblock_alloc_nid_checks_internal(TEST_F_RAW); 1259 1233 1260 1234 return 0; 1261 1235 }