1 // SPDX-License-Identifier: GPL-2.0-or-later 2 #include "alloc_api.h" 3 4 static int alloc_test_flags = TEST_F_NONE; 5 6 static inline const char * const get_memblock_alloc_name(int flags) 7 { 8 if (flags & TEST_F_RAW) 9 return "memblock_alloc_raw"; 10 return "memblock_alloc"; 11 } 12 13 static inline void *run_memblock_alloc(phys_addr_t size, phys_addr_t align) 14 { 15 if (alloc_test_flags & TEST_F_RAW) 16 return memblock_alloc_raw(size, align); 17 return memblock_alloc(size, align); 18 } 19 20 /* 21 * A simple test that tries to allocate a small memory region. 22 * Expect to allocate an aligned region near the end of the available memory. 23 */ 24 static int alloc_top_down_simple_check(void) 25 { 26 struct memblock_region *rgn = &memblock.reserved.regions[0]; 27 void *allocated_ptr = NULL; 28 phys_addr_t size = SZ_2; 29 phys_addr_t expected_start; 30 31 PREFIX_PUSH(); 32 setup_memblock(); 33 34 expected_start = memblock_end_of_DRAM() - SMP_CACHE_BYTES; 35 36 allocated_ptr = run_memblock_alloc(size, SMP_CACHE_BYTES); 37 38 ASSERT_NE(allocated_ptr, NULL); 39 assert_mem_content(allocated_ptr, size, alloc_test_flags); 40 41 ASSERT_EQ(rgn->size, size); 42 ASSERT_EQ(rgn->base, expected_start); 43 44 ASSERT_EQ(memblock.reserved.cnt, 1); 45 ASSERT_EQ(memblock.reserved.total_size, size); 46 47 test_pass_pop(); 48 49 return 0; 50 } 51 52 /* 53 * A test that tries to allocate memory next to a reserved region that starts at 54 * the misaligned address. Expect to create two separate entries, with the new 55 * entry aligned to the provided alignment: 56 * 57 * + 58 * | +--------+ +--------| 59 * | | rgn2 | | rgn1 | 60 * +------------+--------+---------+--------+ 61 * ^ 62 * | 63 * Aligned address boundary 64 * 65 * The allocation direction is top-down and region arrays are sorted from lower 66 * to higher addresses, so the new region will be the first entry in 67 * memory.reserved array. The previously reserved region does not get modified. 68 * Region counter and total size get updated. 69 */ 70 static int alloc_top_down_disjoint_check(void) 71 { 72 /* After allocation, this will point to the "old" region */ 73 struct memblock_region *rgn1 = &memblock.reserved.regions[1]; 74 struct memblock_region *rgn2 = &memblock.reserved.regions[0]; 75 struct region r1; 76 void *allocated_ptr = NULL; 77 phys_addr_t r2_size = SZ_16; 78 /* Use custom alignment */ 79 phys_addr_t alignment = SMP_CACHE_BYTES * 2; 80 phys_addr_t total_size; 81 phys_addr_t expected_start; 82 83 PREFIX_PUSH(); 84 setup_memblock(); 85 86 r1.base = memblock_end_of_DRAM() - SZ_2; 87 r1.size = SZ_2; 88 89 total_size = r1.size + r2_size; 90 expected_start = memblock_end_of_DRAM() - alignment; 91 92 memblock_reserve(r1.base, r1.size); 93 94 allocated_ptr = run_memblock_alloc(r2_size, alignment); 95 96 ASSERT_NE(allocated_ptr, NULL); 97 assert_mem_content(allocated_ptr, r2_size, alloc_test_flags); 98 99 ASSERT_EQ(rgn1->size, r1.size); 100 ASSERT_EQ(rgn1->base, r1.base); 101 102 ASSERT_EQ(rgn2->size, r2_size); 103 ASSERT_EQ(rgn2->base, expected_start); 104 105 ASSERT_EQ(memblock.reserved.cnt, 2); 106 ASSERT_EQ(memblock.reserved.total_size, total_size); 107 108 test_pass_pop(); 109 110 return 0; 111 } 112 113 /* 114 * A test that tries to allocate memory when there is enough space at the end 115 * of the previously reserved block (i.e. first fit): 116 * 117 * | +--------+--------------| 118 * | | r1 | r2 | 119 * +--------------+--------+--------------+ 120 * 121 * Expect a merge of both regions. Only the region size gets updated. 122 */ 123 static int alloc_top_down_before_check(void) 124 { 125 struct memblock_region *rgn = &memblock.reserved.regions[0]; 126 void *allocated_ptr = NULL; 127 /* 128 * The first region ends at the aligned address to test region merging 129 */ 130 phys_addr_t r1_size = SMP_CACHE_BYTES; 131 phys_addr_t r2_size = SZ_512; 132 phys_addr_t total_size = r1_size + r2_size; 133 134 PREFIX_PUSH(); 135 setup_memblock(); 136 137 memblock_reserve(memblock_end_of_DRAM() - total_size, r1_size); 138 139 allocated_ptr = run_memblock_alloc(r2_size, SMP_CACHE_BYTES); 140 141 ASSERT_NE(allocated_ptr, NULL); 142 assert_mem_content(allocated_ptr, r2_size, alloc_test_flags); 143 144 ASSERT_EQ(rgn->size, total_size); 145 ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - total_size); 146 147 ASSERT_EQ(memblock.reserved.cnt, 1); 148 ASSERT_EQ(memblock.reserved.total_size, total_size); 149 150 test_pass_pop(); 151 152 return 0; 153 } 154 155 /* 156 * A test that tries to allocate memory when there is not enough space at the 157 * end of the previously reserved block (i.e. second fit): 158 * 159 * | +-----------+------+ | 160 * | | r2 | r1 | | 161 * +------------+-----------+------+-----+ 162 * 163 * Expect a merge of both regions. Both the base address and size of the region 164 * get updated. 165 */ 166 static int alloc_top_down_after_check(void) 167 { 168 struct memblock_region *rgn = &memblock.reserved.regions[0]; 169 struct region r1; 170 void *allocated_ptr = NULL; 171 phys_addr_t r2_size = SZ_512; 172 phys_addr_t total_size; 173 174 PREFIX_PUSH(); 175 setup_memblock(); 176 177 /* 178 * The first region starts at the aligned address to test region merging 179 */ 180 r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES; 181 r1.size = SZ_8; 182 183 total_size = r1.size + r2_size; 184 185 memblock_reserve(r1.base, r1.size); 186 187 allocated_ptr = run_memblock_alloc(r2_size, SMP_CACHE_BYTES); 188 189 ASSERT_NE(allocated_ptr, NULL); 190 assert_mem_content(allocated_ptr, r2_size, alloc_test_flags); 191 192 ASSERT_EQ(rgn->size, total_size); 193 ASSERT_EQ(rgn->base, r1.base - r2_size); 194 195 ASSERT_EQ(memblock.reserved.cnt, 1); 196 ASSERT_EQ(memblock.reserved.total_size, total_size); 197 198 test_pass_pop(); 199 200 return 0; 201 } 202 203 /* 204 * A test that tries to allocate memory when there are two reserved regions with 205 * a gap too small to fit the new region: 206 * 207 * | +--------+----------+ +------| 208 * | | r3 | r2 | | r1 | 209 * +-------+--------+----------+---+------+ 210 * 211 * Expect to allocate a region before the one that starts at the lower address, 212 * and merge them into one. The region counter and total size fields get 213 * updated. 214 */ 215 static int alloc_top_down_second_fit_check(void) 216 { 217 struct memblock_region *rgn = &memblock.reserved.regions[0]; 218 struct region r1, r2; 219 void *allocated_ptr = NULL; 220 phys_addr_t r3_size = SZ_1K; 221 phys_addr_t total_size; 222 223 PREFIX_PUSH(); 224 setup_memblock(); 225 226 r1.base = memblock_end_of_DRAM() - SZ_512; 227 r1.size = SZ_512; 228 229 r2.base = r1.base - SZ_512; 230 r2.size = SZ_256; 231 232 total_size = r1.size + r2.size + r3_size; 233 234 memblock_reserve(r1.base, r1.size); 235 memblock_reserve(r2.base, r2.size); 236 237 allocated_ptr = run_memblock_alloc(r3_size, SMP_CACHE_BYTES); 238 239 ASSERT_NE(allocated_ptr, NULL); 240 assert_mem_content(allocated_ptr, r3_size, alloc_test_flags); 241 242 ASSERT_EQ(rgn->size, r2.size + r3_size); 243 ASSERT_EQ(rgn->base, r2.base - r3_size); 244 245 ASSERT_EQ(memblock.reserved.cnt, 2); 246 ASSERT_EQ(memblock.reserved.total_size, total_size); 247 248 test_pass_pop(); 249 250 return 0; 251 } 252 253 /* 254 * A test that tries to allocate memory when there are two reserved regions with 255 * a gap big enough to accommodate the new region: 256 * 257 * | +--------+--------+--------+ | 258 * | | r2 | r3 | r1 | | 259 * +-----+--------+--------+--------+-----+ 260 * 261 * Expect to merge all of them, creating one big entry in memblock.reserved 262 * array. The region counter and total size fields get updated. 263 */ 264 static int alloc_in_between_generic_check(void) 265 { 266 struct memblock_region *rgn = &memblock.reserved.regions[0]; 267 struct region r1, r2; 268 void *allocated_ptr = NULL; 269 phys_addr_t gap_size = SMP_CACHE_BYTES; 270 phys_addr_t r3_size = SZ_64; 271 /* 272 * Calculate regions size so there's just enough space for the new entry 273 */ 274 phys_addr_t rgn_size = (MEM_SIZE - (2 * gap_size + r3_size)) / 2; 275 phys_addr_t total_size; 276 277 PREFIX_PUSH(); 278 setup_memblock(); 279 280 r1.size = rgn_size; 281 r1.base = memblock_end_of_DRAM() - (gap_size + rgn_size); 282 283 r2.size = rgn_size; 284 r2.base = memblock_start_of_DRAM() + gap_size; 285 286 total_size = r1.size + r2.size + r3_size; 287 288 memblock_reserve(r1.base, r1.size); 289 memblock_reserve(r2.base, r2.size); 290 291 allocated_ptr = run_memblock_alloc(r3_size, SMP_CACHE_BYTES); 292 293 ASSERT_NE(allocated_ptr, NULL); 294 assert_mem_content(allocated_ptr, r3_size, alloc_test_flags); 295 296 ASSERT_EQ(rgn->size, total_size); 297 ASSERT_EQ(rgn->base, r1.base - r2.size - r3_size); 298 299 ASSERT_EQ(memblock.reserved.cnt, 1); 300 ASSERT_EQ(memblock.reserved.total_size, total_size); 301 302 test_pass_pop(); 303 304 return 0; 305 } 306 307 /* 308 * A test that tries to allocate memory when the memory is filled with reserved 309 * regions with memory gaps too small to fit the new region: 310 * 311 * +-------+ 312 * | new | 313 * +--+----+ 314 * | +-----+ +-----+ +-----+ | 315 * | | res | | res | | res | | 316 * +----+-----+----+-----+----+-----+----+ 317 * 318 * Expect no allocation to happen. 319 */ 320 static int alloc_small_gaps_generic_check(void) 321 { 322 void *allocated_ptr = NULL; 323 phys_addr_t region_size = SZ_1K; 324 phys_addr_t gap_size = SZ_256; 325 phys_addr_t region_end; 326 327 PREFIX_PUSH(); 328 setup_memblock(); 329 330 region_end = memblock_start_of_DRAM(); 331 332 while (region_end < memblock_end_of_DRAM()) { 333 memblock_reserve(region_end + gap_size, region_size); 334 region_end += gap_size + region_size; 335 } 336 337 allocated_ptr = run_memblock_alloc(region_size, SMP_CACHE_BYTES); 338 339 ASSERT_EQ(allocated_ptr, NULL); 340 341 test_pass_pop(); 342 343 return 0; 344 } 345 346 /* 347 * A test that tries to allocate memory when all memory is reserved. 348 * Expect no allocation to happen. 349 */ 350 static int alloc_all_reserved_generic_check(void) 351 { 352 void *allocated_ptr = NULL; 353 354 PREFIX_PUSH(); 355 setup_memblock(); 356 357 /* Simulate full memory */ 358 memblock_reserve(memblock_start_of_DRAM(), MEM_SIZE); 359 360 allocated_ptr = run_memblock_alloc(SZ_256, SMP_CACHE_BYTES); 361 362 ASSERT_EQ(allocated_ptr, NULL); 363 364 test_pass_pop(); 365 366 return 0; 367 } 368 369 /* 370 * A test that tries to allocate memory when the memory is almost full, 371 * with not enough space left for the new region: 372 * 373 * +-------+ 374 * | new | 375 * +-------+ 376 * |-----------------------------+ | 377 * | reserved | | 378 * +-----------------------------+---+ 379 * 380 * Expect no allocation to happen. 381 */ 382 static int alloc_no_space_generic_check(void) 383 { 384 void *allocated_ptr = NULL; 385 phys_addr_t available_size = SZ_256; 386 phys_addr_t reserved_size = MEM_SIZE - available_size; 387 388 PREFIX_PUSH(); 389 setup_memblock(); 390 391 /* Simulate almost-full memory */ 392 memblock_reserve(memblock_start_of_DRAM(), reserved_size); 393 394 allocated_ptr = run_memblock_alloc(SZ_1K, SMP_CACHE_BYTES); 395 396 ASSERT_EQ(allocated_ptr, NULL); 397 398 test_pass_pop(); 399 400 return 0; 401 } 402 403 /* 404 * A test that tries to allocate memory when the memory is almost full, 405 * but there is just enough space left: 406 * 407 * |---------------------------+---------| 408 * | reserved | new | 409 * +---------------------------+---------+ 410 * 411 * Expect to allocate memory and merge all the regions. The total size field 412 * gets updated. 413 */ 414 static int alloc_limited_space_generic_check(void) 415 { 416 struct memblock_region *rgn = &memblock.reserved.regions[0]; 417 void *allocated_ptr = NULL; 418 phys_addr_t available_size = SZ_256; 419 phys_addr_t reserved_size = MEM_SIZE - available_size; 420 421 PREFIX_PUSH(); 422 setup_memblock(); 423 424 /* Simulate almost-full memory */ 425 memblock_reserve(memblock_start_of_DRAM(), reserved_size); 426 427 allocated_ptr = run_memblock_alloc(available_size, SMP_CACHE_BYTES); 428 429 ASSERT_NE(allocated_ptr, NULL); 430 assert_mem_content(allocated_ptr, available_size, alloc_test_flags); 431 432 ASSERT_EQ(rgn->size, MEM_SIZE); 433 ASSERT_EQ(rgn->base, memblock_start_of_DRAM()); 434 435 ASSERT_EQ(memblock.reserved.cnt, 1); 436 ASSERT_EQ(memblock.reserved.total_size, MEM_SIZE); 437 438 test_pass_pop(); 439 440 return 0; 441 } 442 443 /* 444 * A test that tries to allocate memory when there is no available memory 445 * registered (i.e. memblock.memory has only a dummy entry). 446 * Expect no allocation to happen. 447 */ 448 static int alloc_no_memory_generic_check(void) 449 { 450 struct memblock_region *rgn = &memblock.reserved.regions[0]; 451 void *allocated_ptr = NULL; 452 453 PREFIX_PUSH(); 454 455 reset_memblock_regions(); 456 457 allocated_ptr = run_memblock_alloc(SZ_1K, SMP_CACHE_BYTES); 458 459 ASSERT_EQ(allocated_ptr, NULL); 460 ASSERT_EQ(rgn->size, 0); 461 ASSERT_EQ(rgn->base, 0); 462 ASSERT_EQ(memblock.reserved.total_size, 0); 463 464 test_pass_pop(); 465 466 return 0; 467 } 468 469 /* 470 * A test that tries to allocate a region that is larger than the total size of 471 * available memory (memblock.memory): 472 * 473 * +-----------------------------------+ 474 * | new | 475 * +-----------------------------------+ 476 * | | 477 * | | 478 * +---------------------------------+ 479 * 480 * Expect no allocation to happen. 481 */ 482 static int alloc_too_large_generic_check(void) 483 { 484 struct memblock_region *rgn = &memblock.reserved.regions[0]; 485 void *allocated_ptr = NULL; 486 487 PREFIX_PUSH(); 488 setup_memblock(); 489 490 allocated_ptr = run_memblock_alloc(MEM_SIZE + SZ_2, SMP_CACHE_BYTES); 491 492 ASSERT_EQ(allocated_ptr, NULL); 493 ASSERT_EQ(rgn->size, 0); 494 ASSERT_EQ(rgn->base, 0); 495 ASSERT_EQ(memblock.reserved.total_size, 0); 496 497 test_pass_pop(); 498 499 return 0; 500 } 501 502 /* 503 * A simple test that tries to allocate a small memory region. 504 * Expect to allocate an aligned region at the beginning of the available 505 * memory. 506 */ 507 static int alloc_bottom_up_simple_check(void) 508 { 509 struct memblock_region *rgn = &memblock.reserved.regions[0]; 510 void *allocated_ptr = NULL; 511 512 PREFIX_PUSH(); 513 setup_memblock(); 514 515 allocated_ptr = run_memblock_alloc(SZ_2, SMP_CACHE_BYTES); 516 517 ASSERT_NE(allocated_ptr, NULL); 518 assert_mem_content(allocated_ptr, SZ_2, alloc_test_flags); 519 520 ASSERT_EQ(rgn->size, SZ_2); 521 ASSERT_EQ(rgn->base, memblock_start_of_DRAM()); 522 523 ASSERT_EQ(memblock.reserved.cnt, 1); 524 ASSERT_EQ(memblock.reserved.total_size, SZ_2); 525 526 test_pass_pop(); 527 528 return 0; 529 } 530 531 /* 532 * A test that tries to allocate memory next to a reserved region that starts at 533 * the misaligned address. Expect to create two separate entries, with the new 534 * entry aligned to the provided alignment: 535 * 536 * + 537 * | +----------+ +----------+ | 538 * | | rgn1 | | rgn2 | | 539 * +----+----------+---+----------+-----+ 540 * ^ 541 * | 542 * Aligned address boundary 543 * 544 * The allocation direction is bottom-up, so the new region will be the second 545 * entry in memory.reserved array. The previously reserved region does not get 546 * modified. Region counter and total size get updated. 547 */ 548 static int alloc_bottom_up_disjoint_check(void) 549 { 550 struct memblock_region *rgn1 = &memblock.reserved.regions[0]; 551 struct memblock_region *rgn2 = &memblock.reserved.regions[1]; 552 struct region r1; 553 void *allocated_ptr = NULL; 554 phys_addr_t r2_size = SZ_16; 555 /* Use custom alignment */ 556 phys_addr_t alignment = SMP_CACHE_BYTES * 2; 557 phys_addr_t total_size; 558 phys_addr_t expected_start; 559 560 PREFIX_PUSH(); 561 setup_memblock(); 562 563 r1.base = memblock_start_of_DRAM() + SZ_2; 564 r1.size = SZ_2; 565 566 total_size = r1.size + r2_size; 567 expected_start = memblock_start_of_DRAM() + alignment; 568 569 memblock_reserve(r1.base, r1.size); 570 571 allocated_ptr = run_memblock_alloc(r2_size, alignment); 572 573 ASSERT_NE(allocated_ptr, NULL); 574 assert_mem_content(allocated_ptr, r2_size, alloc_test_flags); 575 576 ASSERT_EQ(rgn1->size, r1.size); 577 ASSERT_EQ(rgn1->base, r1.base); 578 579 ASSERT_EQ(rgn2->size, r2_size); 580 ASSERT_EQ(rgn2->base, expected_start); 581 582 ASSERT_EQ(memblock.reserved.cnt, 2); 583 ASSERT_EQ(memblock.reserved.total_size, total_size); 584 585 test_pass_pop(); 586 587 return 0; 588 } 589 590 /* 591 * A test that tries to allocate memory when there is enough space at 592 * the beginning of the previously reserved block (i.e. first fit): 593 * 594 * |------------------+--------+ | 595 * | r1 | r2 | | 596 * +------------------+--------+---------+ 597 * 598 * Expect a merge of both regions. Only the region size gets updated. 599 */ 600 static int alloc_bottom_up_before_check(void) 601 { 602 struct memblock_region *rgn = &memblock.reserved.regions[0]; 603 void *allocated_ptr = NULL; 604 phys_addr_t r1_size = SZ_512; 605 phys_addr_t r2_size = SZ_128; 606 phys_addr_t total_size = r1_size + r2_size; 607 608 PREFIX_PUSH(); 609 setup_memblock(); 610 611 memblock_reserve(memblock_start_of_DRAM() + r1_size, r2_size); 612 613 allocated_ptr = run_memblock_alloc(r1_size, SMP_CACHE_BYTES); 614 615 ASSERT_NE(allocated_ptr, NULL); 616 assert_mem_content(allocated_ptr, r1_size, alloc_test_flags); 617 618 ASSERT_EQ(rgn->size, total_size); 619 ASSERT_EQ(rgn->base, memblock_start_of_DRAM()); 620 621 ASSERT_EQ(memblock.reserved.cnt, 1); 622 ASSERT_EQ(memblock.reserved.total_size, total_size); 623 624 test_pass_pop(); 625 626 return 0; 627 } 628 629 /* 630 * A test that tries to allocate memory when there is not enough space at 631 * the beginning of the previously reserved block (i.e. second fit): 632 * 633 * | +--------+--------------+ | 634 * | | r1 | r2 | | 635 * +----+--------+--------------+---------+ 636 * 637 * Expect a merge of both regions. Only the region size gets updated. 638 */ 639 static int alloc_bottom_up_after_check(void) 640 { 641 struct memblock_region *rgn = &memblock.reserved.regions[0]; 642 struct region r1; 643 void *allocated_ptr = NULL; 644 phys_addr_t r2_size = SZ_512; 645 phys_addr_t total_size; 646 647 PREFIX_PUSH(); 648 setup_memblock(); 649 650 /* 651 * The first region starts at the aligned address to test region merging 652 */ 653 r1.base = memblock_start_of_DRAM() + SMP_CACHE_BYTES; 654 r1.size = SZ_64; 655 656 total_size = r1.size + r2_size; 657 658 memblock_reserve(r1.base, r1.size); 659 660 allocated_ptr = run_memblock_alloc(r2_size, SMP_CACHE_BYTES); 661 662 ASSERT_NE(allocated_ptr, NULL); 663 assert_mem_content(allocated_ptr, r2_size, alloc_test_flags); 664 665 ASSERT_EQ(rgn->size, total_size); 666 ASSERT_EQ(rgn->base, r1.base); 667 668 ASSERT_EQ(memblock.reserved.cnt, 1); 669 ASSERT_EQ(memblock.reserved.total_size, total_size); 670 671 test_pass_pop(); 672 673 return 0; 674 } 675 676 /* 677 * A test that tries to allocate memory when there are two reserved regions, the 678 * first one starting at the beginning of the available memory, with a gap too 679 * small to fit the new region: 680 * 681 * |------------+ +--------+--------+ | 682 * | r1 | | r2 | r3 | | 683 * +------------+-----+--------+--------+--+ 684 * 685 * Expect to allocate after the second region, which starts at the higher 686 * address, and merge them into one. The region counter and total size fields 687 * get updated. 688 */ 689 static int alloc_bottom_up_second_fit_check(void) 690 { 691 struct memblock_region *rgn = &memblock.reserved.regions[1]; 692 struct region r1, r2; 693 void *allocated_ptr = NULL; 694 phys_addr_t r3_size = SZ_1K; 695 phys_addr_t total_size; 696 697 PREFIX_PUSH(); 698 setup_memblock(); 699 700 r1.base = memblock_start_of_DRAM(); 701 r1.size = SZ_512; 702 703 r2.base = r1.base + r1.size + SZ_512; 704 r2.size = SZ_256; 705 706 total_size = r1.size + r2.size + r3_size; 707 708 memblock_reserve(r1.base, r1.size); 709 memblock_reserve(r2.base, r2.size); 710 711 allocated_ptr = run_memblock_alloc(r3_size, SMP_CACHE_BYTES); 712 713 ASSERT_NE(allocated_ptr, NULL); 714 assert_mem_content(allocated_ptr, r3_size, alloc_test_flags); 715 716 ASSERT_EQ(rgn->size, r2.size + r3_size); 717 ASSERT_EQ(rgn->base, r2.base); 718 719 ASSERT_EQ(memblock.reserved.cnt, 2); 720 ASSERT_EQ(memblock.reserved.total_size, total_size); 721 722 test_pass_pop(); 723 724 return 0; 725 } 726 727 /* Test case wrappers */ 728 static int alloc_simple_check(void) 729 { 730 test_print("\tRunning %s...\n", __func__); 731 memblock_set_bottom_up(false); 732 alloc_top_down_simple_check(); 733 memblock_set_bottom_up(true); 734 alloc_bottom_up_simple_check(); 735 736 return 0; 737 } 738 739 static int alloc_disjoint_check(void) 740 { 741 test_print("\tRunning %s...\n", __func__); 742 memblock_set_bottom_up(false); 743 alloc_top_down_disjoint_check(); 744 memblock_set_bottom_up(true); 745 alloc_bottom_up_disjoint_check(); 746 747 return 0; 748 } 749 750 static int alloc_before_check(void) 751 { 752 test_print("\tRunning %s...\n", __func__); 753 memblock_set_bottom_up(false); 754 alloc_top_down_before_check(); 755 memblock_set_bottom_up(true); 756 alloc_bottom_up_before_check(); 757 758 return 0; 759 } 760 761 static int alloc_after_check(void) 762 { 763 test_print("\tRunning %s...\n", __func__); 764 memblock_set_bottom_up(false); 765 alloc_top_down_after_check(); 766 memblock_set_bottom_up(true); 767 alloc_bottom_up_after_check(); 768 769 return 0; 770 } 771 772 static int alloc_in_between_check(void) 773 { 774 test_print("\tRunning %s...\n", __func__); 775 run_top_down(alloc_in_between_generic_check); 776 run_bottom_up(alloc_in_between_generic_check); 777 778 return 0; 779 } 780 781 static int alloc_second_fit_check(void) 782 { 783 test_print("\tRunning %s...\n", __func__); 784 memblock_set_bottom_up(false); 785 alloc_top_down_second_fit_check(); 786 memblock_set_bottom_up(true); 787 alloc_bottom_up_second_fit_check(); 788 789 return 0; 790 } 791 792 static int alloc_small_gaps_check(void) 793 { 794 test_print("\tRunning %s...\n", __func__); 795 run_top_down(alloc_small_gaps_generic_check); 796 run_bottom_up(alloc_small_gaps_generic_check); 797 798 return 0; 799 } 800 801 static int alloc_all_reserved_check(void) 802 { 803 test_print("\tRunning %s...\n", __func__); 804 run_top_down(alloc_all_reserved_generic_check); 805 run_bottom_up(alloc_all_reserved_generic_check); 806 807 return 0; 808 } 809 810 static int alloc_no_space_check(void) 811 { 812 test_print("\tRunning %s...\n", __func__); 813 run_top_down(alloc_no_space_generic_check); 814 run_bottom_up(alloc_no_space_generic_check); 815 816 return 0; 817 } 818 819 static int alloc_limited_space_check(void) 820 { 821 test_print("\tRunning %s...\n", __func__); 822 run_top_down(alloc_limited_space_generic_check); 823 run_bottom_up(alloc_limited_space_generic_check); 824 825 return 0; 826 } 827 828 static int alloc_no_memory_check(void) 829 { 830 test_print("\tRunning %s...\n", __func__); 831 run_top_down(alloc_no_memory_generic_check); 832 run_bottom_up(alloc_no_memory_generic_check); 833 834 return 0; 835 } 836 837 static int alloc_too_large_check(void) 838 { 839 test_print("\tRunning %s...\n", __func__); 840 run_top_down(alloc_too_large_generic_check); 841 run_bottom_up(alloc_too_large_generic_check); 842 843 return 0; 844 } 845 846 static int memblock_alloc_checks_internal(int flags) 847 { 848 const char *func = get_memblock_alloc_name(flags); 849 850 alloc_test_flags = flags; 851 prefix_reset(); 852 prefix_push(func); 853 test_print("Running %s tests...\n", func); 854 855 reset_memblock_attributes(); 856 dummy_physical_memory_init(); 857 858 alloc_simple_check(); 859 alloc_disjoint_check(); 860 alloc_before_check(); 861 alloc_after_check(); 862 alloc_second_fit_check(); 863 alloc_small_gaps_check(); 864 alloc_in_between_check(); 865 alloc_all_reserved_check(); 866 alloc_no_space_check(); 867 alloc_limited_space_check(); 868 alloc_no_memory_check(); 869 alloc_too_large_check(); 870 871 dummy_physical_memory_cleanup(); 872 873 prefix_pop(); 874 875 return 0; 876 } 877 878 int memblock_alloc_checks(void) 879 { 880 memblock_alloc_checks_internal(TEST_F_NONE); 881 memblock_alloc_checks_internal(TEST_F_RAW); 882 883 return 0; 884 } 885