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: move variable declarations to single block

Move variable declarations to a single block at the beginning of each
testing function.

Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
Link: https://lore.kernel.org/r/e61431e73977f305fdd027bca99d1dc119e96d84.1662264355.git.remckee0@gmail.com

authored by

Rebecca Mckeever and committed by
Mike Rapoport 42c3ba86 35e49953

+43 -128
+15 -44
tools/testing/memblock/tests/alloc_api.c
··· 25 25 { 26 26 struct memblock_region *rgn = &memblock.reserved.regions[0]; 27 27 void *allocated_ptr = NULL; 28 - 29 - PREFIX_PUSH(); 30 - 31 28 phys_addr_t size = SZ_2; 32 29 phys_addr_t expected_start; 33 30 31 + PREFIX_PUSH(); 34 32 setup_memblock(); 35 33 36 34 expected_start = memblock_end_of_DRAM() - SMP_CACHE_BYTES; ··· 74 76 struct memblock_region *rgn2 = &memblock.reserved.regions[0]; 75 77 struct region r1; 76 78 void *allocated_ptr = NULL; 77 - 78 - PREFIX_PUSH(); 79 - 80 79 phys_addr_t r2_size = SZ_16; 81 80 /* Use custom alignment */ 82 81 phys_addr_t alignment = SMP_CACHE_BYTES * 2; 83 82 phys_addr_t total_size; 84 83 phys_addr_t expected_start; 85 84 85 + PREFIX_PUSH(); 86 86 setup_memblock(); 87 87 88 88 r1.base = memblock_end_of_DRAM() - SZ_2; ··· 124 128 { 125 129 struct memblock_region *rgn = &memblock.reserved.regions[0]; 126 130 void *allocated_ptr = NULL; 127 - 128 - PREFIX_PUSH(); 129 - 130 131 /* 131 132 * The first region ends at the aligned address to test region merging 132 133 */ ··· 131 138 phys_addr_t r2_size = SZ_512; 132 139 phys_addr_t total_size = r1_size + r2_size; 133 140 141 + PREFIX_PUSH(); 134 142 setup_memblock(); 135 143 136 144 memblock_reserve(memblock_end_of_DRAM() - total_size, r1_size); ··· 168 174 struct memblock_region *rgn = &memblock.reserved.regions[0]; 169 175 struct region r1; 170 176 void *allocated_ptr = NULL; 171 - 172 - PREFIX_PUSH(); 173 - 174 177 phys_addr_t r2_size = SZ_512; 175 178 phys_addr_t total_size; 176 179 180 + PREFIX_PUSH(); 177 181 setup_memblock(); 178 182 179 183 /* ··· 217 225 struct memblock_region *rgn = &memblock.reserved.regions[0]; 218 226 struct region r1, r2; 219 227 void *allocated_ptr = NULL; 220 - 221 - PREFIX_PUSH(); 222 - 223 228 phys_addr_t r3_size = SZ_1K; 224 229 phys_addr_t total_size; 225 230 231 + PREFIX_PUSH(); 226 232 setup_memblock(); 227 233 228 234 r1.base = memblock_end_of_DRAM() - SZ_512; ··· 266 276 struct memblock_region *rgn = &memblock.reserved.regions[0]; 267 277 struct region r1, r2; 268 278 void *allocated_ptr = NULL; 269 - 270 - PREFIX_PUSH(); 271 - 272 279 phys_addr_t gap_size = SMP_CACHE_BYTES; 273 280 phys_addr_t r3_size = SZ_64; 274 281 /* ··· 274 287 phys_addr_t rgn_size = (MEM_SIZE - (2 * gap_size + r3_size)) / 2; 275 288 phys_addr_t total_size; 276 289 290 + PREFIX_PUSH(); 277 291 setup_memblock(); 278 292 279 293 r1.size = rgn_size; ··· 320 332 static int alloc_small_gaps_generic_check(void) 321 333 { 322 334 void *allocated_ptr = NULL; 323 - 324 - PREFIX_PUSH(); 325 - 326 335 phys_addr_t region_size = SZ_1K; 327 336 phys_addr_t gap_size = SZ_256; 328 337 phys_addr_t region_end; 329 338 339 + PREFIX_PUSH(); 330 340 setup_memblock(); 331 341 332 342 region_end = memblock_start_of_DRAM(); ··· 352 366 void *allocated_ptr = NULL; 353 367 354 368 PREFIX_PUSH(); 355 - 356 369 setup_memblock(); 357 370 358 371 /* Simulate full memory */ ··· 382 397 static int alloc_no_space_generic_check(void) 383 398 { 384 399 void *allocated_ptr = NULL; 385 - 386 - PREFIX_PUSH(); 387 - 388 - setup_memblock(); 389 - 390 400 phys_addr_t available_size = SZ_256; 391 401 phys_addr_t reserved_size = MEM_SIZE - available_size; 402 + 403 + PREFIX_PUSH(); 404 + setup_memblock(); 392 405 393 406 /* Simulate almost-full memory */ 394 407 memblock_reserve(memblock_start_of_DRAM(), reserved_size); ··· 415 432 { 416 433 struct memblock_region *rgn = &memblock.reserved.regions[0]; 417 434 void *allocated_ptr = NULL; 418 - 419 - PREFIX_PUSH(); 420 - 421 435 phys_addr_t available_size = SZ_256; 422 436 phys_addr_t reserved_size = MEM_SIZE - available_size; 423 437 438 + PREFIX_PUSH(); 424 439 setup_memblock(); 425 440 426 441 /* Simulate almost-full memory */ ··· 485 504 void *allocated_ptr = NULL; 486 505 487 506 PREFIX_PUSH(); 488 - 489 507 setup_memblock(); 490 508 491 509 allocated_ptr = run_memblock_alloc(MEM_SIZE + SZ_2, SMP_CACHE_BYTES); ··· 510 530 void *allocated_ptr = NULL; 511 531 512 532 PREFIX_PUSH(); 513 - 514 533 setup_memblock(); 515 534 516 535 allocated_ptr = run_memblock_alloc(SZ_2, SMP_CACHE_BYTES); ··· 551 572 struct memblock_region *rgn2 = &memblock.reserved.regions[1]; 552 573 struct region r1; 553 574 void *allocated_ptr = NULL; 554 - 555 - PREFIX_PUSH(); 556 - 557 575 phys_addr_t r2_size = SZ_16; 558 576 /* Use custom alignment */ 559 577 phys_addr_t alignment = SMP_CACHE_BYTES * 2; 560 578 phys_addr_t total_size; 561 579 phys_addr_t expected_start; 562 580 581 + PREFIX_PUSH(); 563 582 setup_memblock(); 564 583 565 584 r1.base = memblock_start_of_DRAM() + SZ_2; ··· 601 624 { 602 625 struct memblock_region *rgn = &memblock.reserved.regions[0]; 603 626 void *allocated_ptr = NULL; 604 - 605 - PREFIX_PUSH(); 606 - 607 627 phys_addr_t r1_size = SZ_512; 608 628 phys_addr_t r2_size = SZ_128; 609 629 phys_addr_t total_size = r1_size + r2_size; 610 630 631 + PREFIX_PUSH(); 611 632 setup_memblock(); 612 633 613 634 memblock_reserve(memblock_start_of_DRAM() + r1_size, r2_size); ··· 641 666 struct memblock_region *rgn = &memblock.reserved.regions[0]; 642 667 struct region r1; 643 668 void *allocated_ptr = NULL; 644 - 645 - PREFIX_PUSH(); 646 - 647 669 phys_addr_t r2_size = SZ_512; 648 670 phys_addr_t total_size; 649 671 672 + PREFIX_PUSH(); 650 673 setup_memblock(); 651 674 652 675 /* ··· 691 718 struct memblock_region *rgn = &memblock.reserved.regions[1]; 692 719 struct region r1, r2; 693 720 void *allocated_ptr = NULL; 694 - 695 - PREFIX_PUSH(); 696 - 697 721 phys_addr_t r3_size = SZ_1K; 698 722 phys_addr_t total_size; 699 723 724 + PREFIX_PUSH(); 700 725 setup_memblock(); 701 726 702 727 r1.base = memblock_start_of_DRAM();
+8 -24
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 - 23 - PREFIX_PUSH(); 24 - 25 22 phys_addr_t size = SZ_16; 26 23 phys_addr_t min_addr; 27 24 25 + PREFIX_PUSH(); 28 26 setup_memblock(); 29 27 30 28 min_addr = memblock_end_of_DRAM() - SMP_CACHE_BYTES; ··· 62 64 { 63 65 struct memblock_region *rgn = &memblock.reserved.regions[0]; 64 66 void *allocated_ptr = NULL; 65 - 66 - PREFIX_PUSH(); 67 - 68 67 phys_addr_t size = SZ_32; 69 68 phys_addr_t min_addr; 70 69 70 + PREFIX_PUSH(); 71 71 setup_memblock(); 72 72 73 73 /* A misaligned address */ ··· 109 113 { 110 114 struct memblock_region *rgn = &memblock.reserved.regions[0]; 111 115 void *allocated_ptr = NULL; 112 - 113 - PREFIX_PUSH(); 114 - 115 116 phys_addr_t size = SZ_32; 116 117 phys_addr_t min_addr; 117 118 119 + PREFIX_PUSH(); 118 120 setup_memblock(); 119 121 120 122 /* The address is too close to the end of the memory */ ··· 152 158 { 153 159 struct memblock_region *rgn = &memblock.reserved.regions[0]; 154 160 void *allocated_ptr = NULL; 155 - 156 - PREFIX_PUSH(); 157 - 158 161 phys_addr_t r1_size = SZ_64; 159 162 phys_addr_t r2_size = SZ_2; 160 163 phys_addr_t total_size = r1_size + r2_size; 161 164 phys_addr_t min_addr; 162 165 166 + PREFIX_PUSH(); 163 167 setup_memblock(); 164 168 165 169 min_addr = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2; ··· 189 197 { 190 198 struct memblock_region *rgn = &memblock.reserved.regions[0]; 191 199 void *allocated_ptr = NULL; 192 - 193 - PREFIX_PUSH(); 194 - 195 200 phys_addr_t r1_size = SZ_64; 196 201 phys_addr_t min_addr; 197 202 phys_addr_t start_addr; 198 203 204 + PREFIX_PUSH(); 199 205 setup_memblock(); 200 206 201 207 start_addr = (phys_addr_t)memblock_start_of_DRAM(); ··· 235 245 { 236 246 struct memblock_region *rgn = &memblock.reserved.regions[0]; 237 247 void *allocated_ptr = NULL; 238 - 239 - PREFIX_PUSH(); 240 - 241 248 phys_addr_t size = SZ_32; 242 249 phys_addr_t min_addr; 243 250 251 + PREFIX_PUSH(); 244 252 setup_memblock(); 245 253 246 254 /* The address is too close to the end of the memory */ ··· 277 289 { 278 290 struct memblock_region *rgn = &memblock.reserved.regions[0]; 279 291 void *allocated_ptr = NULL; 280 - 281 - PREFIX_PUSH(); 282 - 283 292 phys_addr_t r1_size = SZ_64; 284 293 phys_addr_t min_addr; 285 294 phys_addr_t r2_size; 286 295 296 + PREFIX_PUSH(); 287 297 setup_memblock(); 288 298 289 299 min_addr = memblock_start_of_DRAM() + SZ_128; ··· 313 327 { 314 328 struct memblock_region *rgn = &memblock.reserved.regions[0]; 315 329 void *allocated_ptr = NULL; 316 - 317 - PREFIX_PUSH(); 318 - 319 330 phys_addr_t r1_size = SZ_64; 320 331 phys_addr_t min_addr; 321 332 phys_addr_t start_addr; 322 333 334 + PREFIX_PUSH(); 323 335 setup_memblock(); 324 336 325 337 start_addr = (phys_addr_t)memblock_start_of_DRAM();
+20 -60
tools/testing/memblock/tests/alloc_nid_api.c
··· 39 39 { 40 40 struct memblock_region *rgn = &memblock.reserved.regions[0]; 41 41 void *allocated_ptr = NULL; 42 - 43 - PREFIX_PUSH(); 44 - 45 42 phys_addr_t size = SZ_128; 46 43 phys_addr_t min_addr; 47 44 phys_addr_t max_addr; 48 45 phys_addr_t rgn_end; 49 46 47 + PREFIX_PUSH(); 50 48 setup_memblock(); 51 49 52 50 min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2; ··· 91 93 { 92 94 struct memblock_region *rgn = &memblock.reserved.regions[0]; 93 95 void *allocated_ptr = NULL; 94 - 95 - PREFIX_PUSH(); 96 - 97 96 phys_addr_t size = SZ_128; 98 97 phys_addr_t misalign = SZ_2; 99 98 phys_addr_t min_addr; 100 99 phys_addr_t max_addr; 101 100 phys_addr_t rgn_end; 102 101 102 + PREFIX_PUSH(); 103 103 setup_memblock(); 104 104 105 105 min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2; ··· 142 146 { 143 147 struct memblock_region *rgn = &memblock.reserved.regions[0]; 144 148 void *allocated_ptr = NULL; 145 - 146 - PREFIX_PUSH(); 147 - 148 149 phys_addr_t size = SZ_1K; 149 150 phys_addr_t min_addr; 150 151 phys_addr_t max_addr; 151 152 phys_addr_t rgn_end; 152 153 154 + PREFIX_PUSH(); 153 155 setup_memblock(); 154 156 155 157 min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES; ··· 194 200 { 195 201 struct memblock_region *rgn = &memblock.reserved.regions[0]; 196 202 void *allocated_ptr = NULL; 197 - 198 - PREFIX_PUSH(); 199 - 200 203 phys_addr_t size = SZ_256; 201 204 phys_addr_t min_addr; 202 205 phys_addr_t max_addr; 203 206 207 + PREFIX_PUSH(); 204 208 setup_memblock(); 205 209 206 210 min_addr = memblock_start_of_DRAM() + SZ_512; ··· 245 253 static int alloc_try_nid_low_max_generic_check(void) 246 254 { 247 255 void *allocated_ptr = NULL; 248 - 249 - PREFIX_PUSH(); 250 - 251 256 phys_addr_t size = SZ_1K; 252 257 phys_addr_t min_addr; 253 258 phys_addr_t max_addr; 254 259 260 + PREFIX_PUSH(); 255 261 setup_memblock(); 256 262 257 263 min_addr = memblock_start_of_DRAM(); ··· 284 294 { 285 295 struct memblock_region *rgn = &memblock.reserved.regions[0]; 286 296 void *allocated_ptr = NULL; 287 - 288 - PREFIX_PUSH(); 289 - 290 297 phys_addr_t r1_size = SZ_128; 291 298 phys_addr_t r2_size = SZ_64; 292 299 phys_addr_t total_size = r1_size + r2_size; ··· 291 304 phys_addr_t max_addr; 292 305 phys_addr_t reserved_base; 293 306 307 + PREFIX_PUSH(); 294 308 setup_memblock(); 295 309 296 310 max_addr = memblock_end_of_DRAM(); ··· 336 348 { 337 349 struct memblock_region *rgn = &memblock.reserved.regions[0]; 338 350 void *allocated_ptr = NULL; 339 - 340 - PREFIX_PUSH(); 341 - 342 351 phys_addr_t r1_size = SZ_64; 343 352 phys_addr_t r2_size = SZ_128; 344 353 phys_addr_t total_size = r1_size + r2_size; 345 354 phys_addr_t min_addr; 346 355 phys_addr_t max_addr; 347 356 357 + PREFIX_PUSH(); 348 358 setup_memblock(); 349 359 350 360 max_addr = memblock_end_of_DRAM() - r1_size; ··· 391 405 struct memblock_region *rgn2 = &memblock.reserved.regions[0]; 392 406 void *allocated_ptr = NULL; 393 407 struct region r1, r2; 394 - 395 - PREFIX_PUSH(); 396 - 397 408 phys_addr_t r3_size = SZ_64; 398 409 phys_addr_t gap_size = SMP_CACHE_BYTES; 399 410 phys_addr_t total_size; 400 411 phys_addr_t max_addr; 401 412 phys_addr_t min_addr; 402 413 414 + PREFIX_PUSH(); 403 415 setup_memblock(); 404 416 405 417 r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2; ··· 455 471 struct memblock_region *rgn = &memblock.reserved.regions[0]; 456 472 void *allocated_ptr = NULL; 457 473 struct region r1, r2; 458 - 459 - PREFIX_PUSH(); 460 - 461 474 phys_addr_t r3_size = SZ_64; 462 475 phys_addr_t total_size; 463 476 phys_addr_t max_addr; 464 477 phys_addr_t min_addr; 465 478 479 + PREFIX_PUSH(); 466 480 setup_memblock(); 467 481 468 482 r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2; ··· 518 536 struct memblock_region *rgn2 = &memblock.reserved.regions[0]; 519 537 void *allocated_ptr = NULL; 520 538 struct region r1, r2; 521 - 522 - PREFIX_PUSH(); 523 - 524 539 phys_addr_t r3_size = SZ_256; 525 540 phys_addr_t gap_size = SMP_CACHE_BYTES; 526 541 phys_addr_t total_size; 527 542 phys_addr_t max_addr; 528 543 phys_addr_t min_addr; 529 544 545 + PREFIX_PUSH(); 530 546 setup_memblock(); 531 547 532 548 r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2; ··· 585 605 { 586 606 void *allocated_ptr = NULL; 587 607 struct region r1, r2; 588 - 589 - PREFIX_PUSH(); 590 - 591 608 phys_addr_t r3_size = SZ_256; 592 609 phys_addr_t gap_size = SMP_CACHE_BYTES; 593 610 phys_addr_t max_addr; 594 611 phys_addr_t min_addr; 595 612 613 + PREFIX_PUSH(); 596 614 setup_memblock(); 597 615 598 616 r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES; ··· 625 647 { 626 648 struct memblock_region *rgn = &memblock.reserved.regions[0]; 627 649 void *allocated_ptr = NULL; 628 - 629 - PREFIX_PUSH(); 630 - 631 650 phys_addr_t size = SZ_256; 632 651 phys_addr_t min_addr; 633 652 phys_addr_t max_addr; 634 653 654 + PREFIX_PUSH(); 635 655 setup_memblock(); 636 656 637 657 min_addr = memblock_end_of_DRAM() - SZ_1K; ··· 662 686 { 663 687 struct memblock_region *rgn = &memblock.reserved.regions[0]; 664 688 void *allocated_ptr = NULL; 665 - 666 - PREFIX_PUSH(); 667 - 668 689 phys_addr_t size = SZ_1K; 669 690 phys_addr_t min_addr; 670 691 phys_addr_t max_addr; 671 692 693 + PREFIX_PUSH(); 672 694 setup_memblock(); 673 695 674 696 min_addr = memblock_start_of_DRAM() - SZ_256; ··· 708 734 { 709 735 struct memblock_region *rgn = &memblock.reserved.regions[0]; 710 736 void *allocated_ptr = NULL; 711 - 712 - PREFIX_PUSH(); 713 - 714 737 phys_addr_t size = SZ_128; 715 738 phys_addr_t min_addr; 716 739 phys_addr_t max_addr; 717 740 phys_addr_t rgn_end; 718 741 742 + PREFIX_PUSH(); 719 743 setup_memblock(); 720 744 721 745 min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2; ··· 760 788 { 761 789 struct memblock_region *rgn = &memblock.reserved.regions[0]; 762 790 void *allocated_ptr = NULL; 763 - 764 - PREFIX_PUSH(); 765 - 766 791 phys_addr_t size = SZ_128; 767 792 phys_addr_t misalign = SZ_2; 768 793 phys_addr_t min_addr; 769 794 phys_addr_t max_addr; 770 795 phys_addr_t rgn_end; 771 796 797 + PREFIX_PUSH(); 772 798 setup_memblock(); 773 799 774 800 min_addr = memblock_start_of_DRAM() + misalign; ··· 813 843 { 814 844 struct memblock_region *rgn = &memblock.reserved.regions[0]; 815 845 void *allocated_ptr = NULL; 816 - 817 - PREFIX_PUSH(); 818 - 819 846 phys_addr_t size = SZ_256; 820 847 phys_addr_t min_addr; 821 848 phys_addr_t max_addr; 822 849 850 + PREFIX_PUSH(); 823 851 setup_memblock(); 824 852 825 853 min_addr = memblock_start_of_DRAM() + SZ_512; ··· 864 896 struct memblock_region *rgn2 = &memblock.reserved.regions[0]; 865 897 void *allocated_ptr = NULL; 866 898 struct region r1, r2; 867 - 868 - PREFIX_PUSH(); 869 - 870 899 phys_addr_t r3_size = SZ_64; 871 900 phys_addr_t gap_size = SMP_CACHE_BYTES; 872 901 phys_addr_t total_size; 873 902 phys_addr_t max_addr; 874 903 phys_addr_t min_addr; 875 904 905 + PREFIX_PUSH(); 876 906 setup_memblock(); 877 907 878 908 r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2; ··· 934 968 struct memblock_region *rgn3 = &memblock.reserved.regions[0]; 935 969 void *allocated_ptr = NULL; 936 970 struct region r1, r2; 937 - 938 - PREFIX_PUSH(); 939 - 940 971 phys_addr_t r3_size = SZ_256; 941 972 phys_addr_t gap_size = SMP_CACHE_BYTES; 942 973 phys_addr_t total_size; 943 974 phys_addr_t max_addr; 944 975 phys_addr_t min_addr; 945 976 977 + PREFIX_PUSH(); 946 978 setup_memblock(); 947 979 948 980 r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2; ··· 989 1025 { 990 1026 struct memblock_region *rgn = &memblock.reserved.regions[0]; 991 1027 void *allocated_ptr = NULL; 992 - 993 - PREFIX_PUSH(); 994 - 995 1028 phys_addr_t size = SZ_256; 996 1029 phys_addr_t min_addr; 997 1030 phys_addr_t max_addr; 998 1031 1032 + PREFIX_PUSH(); 999 1033 setup_memblock(); 1000 1034 1001 1035 min_addr = memblock_start_of_DRAM() + SZ_1K; ··· 1026 1064 { 1027 1065 struct memblock_region *rgn = &memblock.reserved.regions[0]; 1028 1066 void *allocated_ptr = NULL; 1029 - 1030 - PREFIX_PUSH(); 1031 - 1032 1067 phys_addr_t size = SZ_1K; 1033 1068 phys_addr_t min_addr; 1034 1069 phys_addr_t max_addr; 1035 1070 1071 + PREFIX_PUSH(); 1036 1072 setup_memblock(); 1037 1073 1038 1074 min_addr = memblock_start_of_DRAM();