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 zeroed memory check for memblock_alloc_* tests

Update the assert in memblock_alloc_try_nid() and memblock_alloc_from()
tests that checks whether the memory is cleared so that it checks the
entire chunk of allocated memory instead of just the first byte.

Reviewed-by: David Hildenbrand <david@redhat.com>
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/24b3271751756100142e65b75284d43b4d30c9b7.1661578349.git.remckee0@gmail.com

authored by

Rebecca Mckeever and committed by
Mike Rapoport 25b9defb ac76d803

+20 -60
+2 -6
tools/testing/memblock/tests/alloc_helpers_api.c
··· 19 19 { 20 20 struct memblock_region *rgn = &memblock.reserved.regions[0]; 21 21 void *allocated_ptr = NULL; 22 - char *b; 23 22 24 23 PREFIX_PUSH(); 25 24 ··· 30 31 min_addr = memblock_end_of_DRAM() - SMP_CACHE_BYTES; 31 32 32 33 allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr); 33 - b = (char *)allocated_ptr; 34 34 35 35 ASSERT_NE(allocated_ptr, NULL); 36 - ASSERT_EQ(*b, 0); 36 + ASSERT_MEM_EQ(allocated_ptr, 0, size); 37 37 38 38 ASSERT_EQ(rgn->size, size); 39 39 ASSERT_EQ(rgn->base, min_addr); ··· 64 66 { 65 67 struct memblock_region *rgn = &memblock.reserved.regions[0]; 66 68 void *allocated_ptr = NULL; 67 - char *b; 68 69 69 70 PREFIX_PUSH(); 70 71 ··· 76 79 min_addr = memblock_end_of_DRAM() - (SMP_CACHE_BYTES * 2 - 1); 77 80 78 81 allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr); 79 - b = (char *)allocated_ptr; 80 82 81 83 ASSERT_NE(allocated_ptr, NULL); 82 - ASSERT_EQ(*b, 0); 84 + ASSERT_MEM_EQ(allocated_ptr, 0, size); 83 85 84 86 ASSERT_EQ(rgn->size, size); 85 87 ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - SMP_CACHE_BYTES);
+18 -54
tools/testing/memblock/tests/alloc_nid_api.c
··· 19 19 { 20 20 struct memblock_region *rgn = &memblock.reserved.regions[0]; 21 21 void *allocated_ptr = NULL; 22 - char *b; 23 22 24 23 PREFIX_PUSH(); 25 24 ··· 34 35 35 36 allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 36 37 min_addr, max_addr, NUMA_NO_NODE); 37 - b = (char *)allocated_ptr; 38 38 rgn_end = rgn->base + rgn->size; 39 39 40 40 ASSERT_NE(allocated_ptr, NULL); 41 - ASSERT_EQ(*b, 0); 41 + ASSERT_MEM_EQ(allocated_ptr, 0, size); 42 42 43 43 ASSERT_EQ(rgn->size, size); 44 44 ASSERT_EQ(rgn->base, max_addr - size); ··· 72 74 { 73 75 struct memblock_region *rgn = &memblock.reserved.regions[0]; 74 76 void *allocated_ptr = NULL; 75 - char *b; 76 77 77 78 PREFIX_PUSH(); 78 79 ··· 88 91 89 92 allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 90 93 min_addr, max_addr, NUMA_NO_NODE); 91 - b = (char *)allocated_ptr; 92 94 rgn_end = rgn->base + rgn->size; 93 95 94 96 ASSERT_NE(allocated_ptr, NULL); 95 - ASSERT_EQ(*b, 0); 97 + ASSERT_MEM_EQ(allocated_ptr, 0, size); 96 98 97 99 ASSERT_EQ(rgn->size, size); 98 100 ASSERT_EQ(rgn->base, max_addr - size - misalign); ··· 124 128 { 125 129 struct memblock_region *rgn = &memblock.reserved.regions[0]; 126 130 void *allocated_ptr = NULL; 127 - char *b; 128 131 129 132 PREFIX_PUSH(); 130 133 ··· 139 144 140 145 allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 141 146 min_addr, max_addr, NUMA_NO_NODE); 142 - b = (char *)allocated_ptr; 143 147 rgn_end = rgn->base + rgn->size; 144 148 145 149 ASSERT_NE(allocated_ptr, NULL); 146 - ASSERT_EQ(*b, 0); 150 + ASSERT_MEM_EQ(allocated_ptr, 0, size); 147 151 148 152 ASSERT_EQ(rgn->size, size); 149 153 ASSERT_EQ(rgn->base, min_addr); ··· 177 183 { 178 184 struct memblock_region *rgn = &memblock.reserved.regions[0]; 179 185 void *allocated_ptr = NULL; 180 - char *b; 181 186 182 187 PREFIX_PUSH(); 183 188 ··· 191 198 192 199 allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 193 200 min_addr, max_addr, NUMA_NO_NODE); 194 - b = (char *)allocated_ptr; 195 201 196 202 ASSERT_NE(allocated_ptr, NULL); 197 - ASSERT_EQ(*b, 0); 203 + ASSERT_MEM_EQ(allocated_ptr, 0, size); 198 204 199 205 ASSERT_EQ(rgn->size, size); 200 206 ASSERT_EQ(rgn->base, max_addr - size); ··· 269 277 { 270 278 struct memblock_region *rgn = &memblock.reserved.regions[0]; 271 279 void *allocated_ptr = NULL; 272 - char *b; 273 280 274 281 PREFIX_PUSH(); 275 282 ··· 289 298 290 299 allocated_ptr = memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES, 291 300 min_addr, max_addr, NUMA_NO_NODE); 292 - b = (char *)allocated_ptr; 293 301 294 302 ASSERT_NE(allocated_ptr, NULL); 295 - ASSERT_EQ(*b, 0); 303 + ASSERT_MEM_EQ(allocated_ptr, 0, r2_size); 296 304 297 305 ASSERT_EQ(rgn->size, total_size); 298 306 ASSERT_EQ(rgn->base, reserved_base); ··· 322 332 { 323 333 struct memblock_region *rgn = &memblock.reserved.regions[0]; 324 334 void *allocated_ptr = NULL; 325 - char *b; 326 335 327 336 PREFIX_PUSH(); 328 337 ··· 340 351 341 352 allocated_ptr = memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES, 342 353 min_addr, max_addr, NUMA_NO_NODE); 343 - b = (char *)allocated_ptr; 344 354 345 355 ASSERT_NE(allocated_ptr, NULL); 346 - ASSERT_EQ(*b, 0); 356 + ASSERT_MEM_EQ(allocated_ptr, 0, r2_size); 347 357 348 358 ASSERT_EQ(rgn->size, total_size); 349 359 ASSERT_EQ(rgn->base, min_addr); ··· 377 389 struct memblock_region *rgn1 = &memblock.reserved.regions[1]; 378 390 struct memblock_region *rgn2 = &memblock.reserved.regions[0]; 379 391 void *allocated_ptr = NULL; 380 - char *b; 381 392 struct region r1, r2; 382 393 383 394 PREFIX_PUSH(); ··· 404 417 405 418 allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 406 419 min_addr, max_addr, NUMA_NO_NODE); 407 - b = (char *)allocated_ptr; 408 420 409 421 ASSERT_NE(allocated_ptr, NULL); 410 - ASSERT_EQ(*b, 0); 422 + ASSERT_MEM_EQ(allocated_ptr, 0, r3_size); 411 423 412 424 ASSERT_EQ(rgn1->size, r1.size + r3_size); 413 425 ASSERT_EQ(rgn1->base, max_addr - r3_size); ··· 442 456 { 443 457 struct memblock_region *rgn = &memblock.reserved.regions[0]; 444 458 void *allocated_ptr = NULL; 445 - char *b; 446 459 struct region r1, r2; 447 460 448 461 PREFIX_PUSH(); ··· 468 483 469 484 allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 470 485 min_addr, max_addr, NUMA_NO_NODE); 471 - b = (char *)allocated_ptr; 472 486 473 487 ASSERT_NE(allocated_ptr, NULL); 474 - ASSERT_EQ(*b, 0); 488 + ASSERT_MEM_EQ(allocated_ptr, 0, r3_size); 475 489 476 490 ASSERT_EQ(rgn->size, total_size); 477 491 ASSERT_EQ(rgn->base, r2.base); ··· 506 522 struct memblock_region *rgn1 = &memblock.reserved.regions[1]; 507 523 struct memblock_region *rgn2 = &memblock.reserved.regions[0]; 508 524 void *allocated_ptr = NULL; 509 - char *b; 510 525 struct region r1, r2; 511 526 512 527 PREFIX_PUSH(); ··· 533 550 534 551 allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 535 552 min_addr, max_addr, NUMA_NO_NODE); 536 - b = (char *)allocated_ptr; 537 553 538 554 ASSERT_NE(allocated_ptr, NULL); 539 - ASSERT_EQ(*b, 0); 555 + ASSERT_MEM_EQ(allocated_ptr, 0, r3_size); 540 556 541 557 ASSERT_EQ(rgn1->size, r1.size); 542 558 ASSERT_EQ(rgn1->base, r1.base); ··· 616 634 { 617 635 struct memblock_region *rgn = &memblock.reserved.regions[0]; 618 636 void *allocated_ptr = NULL; 619 - char *b; 620 637 621 638 PREFIX_PUSH(); 622 639 ··· 630 649 631 650 allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 632 651 min_addr, max_addr, NUMA_NO_NODE); 633 - b = (char *)allocated_ptr; 634 652 635 653 ASSERT_NE(allocated_ptr, NULL); 636 - ASSERT_EQ(*b, 0); 654 + ASSERT_MEM_EQ(allocated_ptr, 0, size); 637 655 638 656 ASSERT_EQ(rgn->size, size); 639 657 ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size); ··· 654 674 { 655 675 struct memblock_region *rgn = &memblock.reserved.regions[0]; 656 676 void *allocated_ptr = NULL; 657 - char *b; 658 677 659 678 PREFIX_PUSH(); 660 679 ··· 668 689 669 690 allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 670 691 min_addr, max_addr, NUMA_NO_NODE); 671 - b = (char *)allocated_ptr; 672 692 673 693 ASSERT_NE(allocated_ptr, NULL); 674 - ASSERT_EQ(*b, 0); 694 + ASSERT_MEM_EQ(allocated_ptr, 0, size); 675 695 676 696 ASSERT_EQ(rgn->size, size); 677 697 ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size); ··· 701 723 { 702 724 struct memblock_region *rgn = &memblock.reserved.regions[0]; 703 725 void *allocated_ptr = NULL; 704 - char *b; 705 726 706 727 PREFIX_PUSH(); 707 728 ··· 717 740 allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 718 741 min_addr, max_addr, 719 742 NUMA_NO_NODE); 720 - b = (char *)allocated_ptr; 721 743 rgn_end = rgn->base + rgn->size; 722 744 723 745 ASSERT_NE(allocated_ptr, NULL); 724 - ASSERT_EQ(*b, 0); 746 + ASSERT_MEM_EQ(allocated_ptr, 0, size); 725 747 726 748 ASSERT_EQ(rgn->size, size); 727 749 ASSERT_EQ(rgn->base, min_addr); ··· 755 779 { 756 780 struct memblock_region *rgn = &memblock.reserved.regions[0]; 757 781 void *allocated_ptr = NULL; 758 - char *b; 759 782 760 783 PREFIX_PUSH(); 761 784 ··· 772 797 allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 773 798 min_addr, max_addr, 774 799 NUMA_NO_NODE); 775 - b = (char *)allocated_ptr; 776 800 rgn_end = rgn->base + rgn->size; 777 801 778 802 ASSERT_NE(allocated_ptr, NULL); 779 - ASSERT_EQ(*b, 0); 803 + ASSERT_MEM_EQ(allocated_ptr, 0, size); 780 804 781 805 ASSERT_EQ(rgn->size, size); 782 806 ASSERT_EQ(rgn->base, min_addr + (SMP_CACHE_BYTES - misalign)); ··· 810 836 { 811 837 struct memblock_region *rgn = &memblock.reserved.regions[0]; 812 838 void *allocated_ptr = NULL; 813 - char *b; 814 839 815 840 PREFIX_PUSH(); 816 841 ··· 825 852 allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 826 853 min_addr, max_addr, 827 854 NUMA_NO_NODE); 828 - b = (char *)allocated_ptr; 829 855 830 856 ASSERT_NE(allocated_ptr, NULL); 831 - ASSERT_EQ(*b, 0); 857 + ASSERT_MEM_EQ(allocated_ptr, 0, size); 832 858 833 859 ASSERT_EQ(rgn->size, size); 834 860 ASSERT_EQ(rgn->base, memblock_start_of_DRAM()); ··· 862 890 struct memblock_region *rgn1 = &memblock.reserved.regions[1]; 863 891 struct memblock_region *rgn2 = &memblock.reserved.regions[0]; 864 892 void *allocated_ptr = NULL; 865 - char *b; 866 893 struct region r1, r2; 867 894 868 895 PREFIX_PUSH(); ··· 890 919 allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 891 920 min_addr, max_addr, 892 921 NUMA_NO_NODE); 893 - b = (char *)allocated_ptr; 894 922 895 923 ASSERT_NE(allocated_ptr, NULL); 896 - ASSERT_EQ(*b, 0); 924 + ASSERT_MEM_EQ(allocated_ptr, 0, r3_size); 897 925 898 926 ASSERT_EQ(rgn1->size, r1.size); 899 927 ASSERT_EQ(rgn1->base, max_addr); ··· 934 964 struct memblock_region *rgn2 = &memblock.reserved.regions[1]; 935 965 struct memblock_region *rgn3 = &memblock.reserved.regions[0]; 936 966 void *allocated_ptr = NULL; 937 - char *b; 938 967 struct region r1, r2; 939 968 940 969 PREFIX_PUSH(); ··· 962 993 allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES, 963 994 min_addr, max_addr, 964 995 NUMA_NO_NODE); 965 - b = (char *)allocated_ptr; 966 996 967 997 ASSERT_NE(allocated_ptr, NULL); 968 - ASSERT_EQ(*b, 0); 998 + ASSERT_MEM_EQ(allocated_ptr, 0, r3_size); 969 999 970 1000 ASSERT_EQ(rgn3->size, r3_size); 971 1001 ASSERT_EQ(rgn3->base, memblock_start_of_DRAM()); ··· 992 1024 { 993 1025 struct memblock_region *rgn = &memblock.reserved.regions[0]; 994 1026 void *allocated_ptr = NULL; 995 - char *b; 996 1027 997 1028 PREFIX_PUSH(); 998 1029 ··· 1007 1040 allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1008 1041 min_addr, max_addr, 1009 1042 NUMA_NO_NODE); 1010 - b = (char *)allocated_ptr; 1011 1043 1012 1044 ASSERT_NE(allocated_ptr, NULL); 1013 - ASSERT_EQ(*b, 0); 1045 + ASSERT_MEM_EQ(allocated_ptr, 0, size); 1014 1046 1015 1047 ASSERT_EQ(rgn->size, size); 1016 1048 ASSERT_EQ(rgn->base, min_addr); ··· 1031 1065 { 1032 1066 struct memblock_region *rgn = &memblock.reserved.regions[0]; 1033 1067 void *allocated_ptr = NULL; 1034 - char *b; 1035 1068 1036 1069 PREFIX_PUSH(); 1037 1070 ··· 1046 1081 allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES, 1047 1082 min_addr, max_addr, 1048 1083 NUMA_NO_NODE); 1049 - b = (char *)allocated_ptr; 1050 1084 1051 1085 ASSERT_NE(allocated_ptr, NULL); 1052 - ASSERT_EQ(*b, 0); 1086 + ASSERT_MEM_EQ(allocated_ptr, 0, size); 1053 1087 1054 1088 ASSERT_EQ(rgn->size, size); 1055 1089 ASSERT_EQ(rgn->base, memblock_start_of_DRAM());