memblock tests: update tests to check if memblock_alloc zeroed memory

Add an assert in memblock_alloc() tests where allocation is expected to
occur. The assert checks whether the entire chunk of allocated memory is
cleared.

The current memblock_alloc() tests do not check whether the allocated
memory was zeroed. memblock_alloc() should zero the allocated memory since
it is a wrapper for memblock_alloc_try_nid().

Reviewed-by: Shaoqin Huang <shaoqin.huang@intel.com>
Reviewed-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/83ffb941b65074f40eb14552f8bfe5b71fe50abd.1661578349.git.remckee0@gmail.com

authored by

Rebecca Mckeever and committed by

Mike Rapoport 3 years ago ac76d803 61ebea2b

+42

3 changed files

expand all

tools

testing

memblock

tests

alloc_api.c

common.c

common.h

+23

tools/testing/memblock/tests/alloc_api.c

··· 22 22 allocated_ptr = memblock_alloc(size, SMP_CACHE_BYTES); 23 23 24 24 ASSERT_NE(allocated_ptr, NULL); 25 + ASSERT_MEM_EQ(allocated_ptr, 0, size); 26 + 25 27 ASSERT_EQ(rgn->size, size); 26 28 ASSERT_EQ(rgn->base, expected_start); 27 29 ··· 82 80 allocated_ptr = memblock_alloc(r2_size, alignment); 83 81 84 82 ASSERT_NE(allocated_ptr, NULL); 83 + ASSERT_MEM_EQ(allocated_ptr, 0, r2_size); 84 + 85 85 ASSERT_EQ(rgn1->size, r1.size); 86 86 ASSERT_EQ(rgn1->base, r1.base); 87 87 ··· 129 125 allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES); 130 126 131 127 ASSERT_NE(allocated_ptr, NULL); 128 + ASSERT_MEM_EQ(allocated_ptr, 0, r2_size); 129 + 132 130 ASSERT_EQ(rgn->size, total_size); 133 131 ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - total_size); 134 132 ··· 179 173 allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES); 180 174 181 175 ASSERT_NE(allocated_ptr, NULL); 176 + ASSERT_MEM_EQ(allocated_ptr, 0, r2_size); 177 + 182 178 ASSERT_EQ(rgn->size, total_size); 183 179 ASSERT_EQ(rgn->base, r1.base - r2_size); 184 180 ··· 231 223 allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES); 232 224 233 225 ASSERT_NE(allocated_ptr, NULL); 226 + ASSERT_MEM_EQ(allocated_ptr, 0, r3_size); 227 + 234 228 ASSERT_EQ(rgn->size, r2.size + r3_size); 235 229 ASSERT_EQ(rgn->base, r2.base - r3_size); 236 230 ··· 287 277 allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES); 288 278 289 279 ASSERT_NE(allocated_ptr, NULL); 280 + ASSERT_MEM_EQ(allocated_ptr, 0, r3_size); 281 + 290 282 ASSERT_EQ(rgn->size, total_size); 291 283 ASSERT_EQ(rgn->base, r1.base - r2.size - r3_size); 292 284 ··· 430 418 allocated_ptr = memblock_alloc(available_size, SMP_CACHE_BYTES); 431 419 432 420 ASSERT_NE(allocated_ptr, NULL); 421 + ASSERT_MEM_EQ(allocated_ptr, 0, available_size); 422 + 433 423 ASSERT_EQ(rgn->size, MEM_SIZE); 434 424 ASSERT_EQ(rgn->base, memblock_start_of_DRAM()); 435 425 ··· 486 472 allocated_ptr = memblock_alloc(SZ_2, SMP_CACHE_BYTES); 487 473 488 474 ASSERT_NE(allocated_ptr, NULL); 475 + ASSERT_MEM_EQ(allocated_ptr, 0, SZ_2); 476 + 489 477 ASSERT_EQ(rgn->size, SZ_2); 490 478 ASSERT_EQ(rgn->base, memblock_start_of_DRAM()); 491 479 ··· 544 528 allocated_ptr = memblock_alloc(r2_size, alignment); 545 529 546 530 ASSERT_NE(allocated_ptr, NULL); 531 + ASSERT_MEM_EQ(allocated_ptr, 0, r2_size); 547 532 548 533 ASSERT_EQ(rgn1->size, r1.size); 549 534 ASSERT_EQ(rgn1->base, r1.base); ··· 588 571 allocated_ptr = memblock_alloc(r1_size, SMP_CACHE_BYTES); 589 572 590 573 ASSERT_NE(allocated_ptr, NULL); 574 + ASSERT_MEM_EQ(allocated_ptr, 0, r1_size); 575 + 591 576 ASSERT_EQ(rgn->size, total_size); 592 577 ASSERT_EQ(rgn->base, memblock_start_of_DRAM()); 593 578 ··· 637 618 allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES); 638 619 639 620 ASSERT_NE(allocated_ptr, NULL); 621 + ASSERT_MEM_EQ(allocated_ptr, 0, r2_size); 622 + 640 623 ASSERT_EQ(rgn->size, total_size); 641 624 ASSERT_EQ(rgn->base, r1.base); 642 625 ··· 690 669 allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES); 691 670 692 671 ASSERT_NE(allocated_ptr, NULL); 672 + ASSERT_MEM_EQ(allocated_ptr, 0, r3_size); 673 + 693 674 ASSERT_EQ(rgn->size, r2.size + r3_size); 694 675 ASSERT_EQ(rgn->base, r2.base); 695 676

tools/testing/memblock/tests/common.c

··· 60 60 memblock.current_limit = MEMBLOCK_ALLOC_ANYWHERE; 61 61 } 62 62 63 + static inline void fill_memblock(void) 64 + { 65 + memset(memory_block.base, 1, MEM_SIZE); 66 + } 67 + 63 68 void setup_memblock(void) 64 69 { 65 70 reset_memblock_regions(); 66 71 memblock_add((phys_addr_t)memory_block.base, MEM_SIZE); 72 + fill_memblock(); 67 73 } 68 74 69 75 void dummy_physical_memory_init(void) 70 76 { 71 77 memory_block.base = malloc(MEM_SIZE); 72 78 assert(memory_block.base); 79 + fill_memblock(); 73 80 } 74 81 75 82 void dummy_physical_memory_cleanup(void)

+12

tools/testing/memblock/tests/common.h

··· 51 51 assert((_expected) < (_seen)); \ 52 52 } while (0) 53 53 54 + /** 55 + * ASSERT_MEM_EQ(): 56 + * Check that the first @_size bytes of @_seen are all equal to @_expected. 57 + * If false, print failed test message (if running with --verbose) and then 58 + * assert. 59 + */ 60 + #define ASSERT_MEM_EQ(_seen, _expected, _size) do { \ 61 + for (int _i = 0; _i < (_size); _i++) { \ 62 + ASSERT_EQ(((char *)_seen)[_i], (_expected)); \ 63 + } \ 64 + } while (0) 65 + 54 66 #define PREFIX_PUSH() prefix_push(__func__) 55 67 56 68 /*

Configure Feed

Configure Feed