[PATCH 0/8] memblock tests: update and extend memblock simulator

[PATCH 0/8] memblock tests: update and extend memblock simulator

[Rebecca Mckeever]

These patches update existing tests in memblock simulator, add
additional tests for memblock functions that are already being tested,
and add test coverage for additional memblock functions.

Updated tests for:
- memblock_alloc()
- memblock_alloc_try_nid()
- memblock_alloc_from()

The updates to memblock_alloc() tests include the addition of an assert
that checks whether the entire chunk of allocated memory is cleared. For
memblock_alloc_try_nid() and memblock_alloc_from(), the assert that checks
whether the allocated memory is cleared now checks the entire chunk of
allocated memory instead of just the first byte. To make this more robust,
setup_memblock() and dummy_physical_memory_init() fill the entire MEM_SIZE
simulated physical memory with nonzero values by calling fill_memblock().
setup_memblock() is called at the beginning of most tests. Tests that
don't call setup_memblock() call fill_memblock() directly.

Additional tests for:
- memblock_add()
- memblock_reserve()
- memblock_remove()
- memblock_free()
- memblock_alloc()

Introducing test coverage for:
- memblock_alloc_raw()
- memblock_alloc_try_nid_raw()
- memblock_set_bottom_up()
- memblock_bottom_up()
- memblock_trim_memory()

The tests for the memblock_alloc_*raw() functions test both top-down and
bottom-up allocation directions. To add coverage for memblock_alloc_raw(),
the alloc_api was updated so that it runs through all the existing tests
twice: once for memblock_alloc() and once for memblock_alloc_raw(). When
the tests run memblock_alloc_raw(), they test that the entire memory
region is nonzero instead of testing that it is zero.

Similarly, the alloc_nid_api was updated to run through its tests twice,
once for memblock_alloc_try_nid() and once for
memblock_alloc_try_nid_raw(). When the tests run
memblock_alloc_try_nid_raw(), they test that the entire memory region is
nonzero instead of testing that it is zero.

The patchset also adds labels to verbose output for generic
memblock_alloc*() tests that indicate which allocation direction is set.
The function names of those tests do not include this information.

Rebecca Mckeever (8):
  memblock tests: update tests to check if memblock_alloc zeroed memory
  memblock tests: update zeroed memory check for memblock_alloc_* tests
  memblock tests: add labels to verbose output for generic alloc tests
  memblock tests: add additional tests for basic api and memblock_alloc
  memblock tests: update alloc_api to test memblock_alloc_raw
  memblock tests: update alloc_nid_api to test
    memblock_alloc_try_nid_raw
  memblock tests: add tests for memblock_*bottom_up functions
  memblock tests: add tests for memblock_trim_memory

 tools/testing/memblock/tests/alloc_api.c      | 184 ++++-
 .../memblock/tests/alloc_helpers_api.c        |  20 +-
 tools/testing/memblock/tests/alloc_nid_api.c  | 268 +++---
 tools/testing/memblock/tests/basic_api.c      | 773 +++++++++++++++++-
 tools/testing/memblock/tests/common.c         |   7 +
 tools/testing/memblock/tests/common.h         |  46 ++
 6 files changed, 1108 insertions(+), 190 deletions(-)

-- 
2.25.1

[PATCH 1/8] memblock tests: update tests to check if memblock_alloc zeroed memory

[Rebecca Mckeever]

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().

Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
---
 tools/testing/memblock/tests/alloc_api.c | 24 ++++++++++++++++++++++++
 tools/testing/memblock/tests/common.c    |  7 +++++++
 tools/testing/memblock/tests/common.h    | 13 +++++++++++++
 3 files changed, 44 insertions(+)

diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
index a14f38eb8a89..71c89cb9b2a8 100644
--- a/tools/testing/memblock/tests/alloc_api.c
+++ b/tools/testing/memblock/tests/alloc_api.c
@@ -22,6 +22,8 @@ static int alloc_top_down_simple_check(void)
 	allocated_ptr = memblock_alloc(size, SMP_CACHE_BYTES);
 
 	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
+
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, expected_start);
 
@@ -80,6 +82,8 @@ static int alloc_top_down_disjoint_check(void)
 	allocated_ptr = memblock_alloc(r2_size, alignment);
 
 	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
+
 	ASSERT_EQ(rgn1->size, r1.size);
 	ASSERT_EQ(rgn1->base, r1.base);
 
@@ -125,6 +129,8 @@ static int alloc_top_down_before_check(void)
 	allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
 
 	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
+
 	ASSERT_EQ(rgn->size, total_size);
 	ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - total_size);
 
@@ -173,6 +179,8 @@ static int alloc_top_down_after_check(void)
 	allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
 
 	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
+
 	ASSERT_EQ(rgn->size, total_size);
 	ASSERT_EQ(rgn->base, r1.base - r2_size);
 
@@ -223,6 +231,8 @@ static int alloc_top_down_second_fit_check(void)
 	allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
 
 	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
+
 	ASSERT_EQ(rgn->size, r2.size + r3_size);
 	ASSERT_EQ(rgn->base, r2.base - r3_size);
 
@@ -277,6 +287,8 @@ static int alloc_in_between_generic_check(void)
 	allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
 
 	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
+
 	ASSERT_EQ(rgn->size, total_size);
 	ASSERT_EQ(rgn->base, r1.base - r2.size - r3_size);
 
@@ -418,6 +430,8 @@ static int alloc_limited_space_generic_check(void)
 	allocated_ptr = memblock_alloc(available_size, SMP_CACHE_BYTES);
 
 	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, available_size);
+
 	ASSERT_EQ(rgn->size, MEM_SIZE);
 	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
 
@@ -442,6 +456,7 @@ static int alloc_no_memory_generic_check(void)
 	PREFIX_PUSH();
 
 	reset_memblock_regions();
+	fill_memblock();
 
 	allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
 
@@ -472,6 +487,8 @@ static int alloc_bottom_up_simple_check(void)
 	allocated_ptr = memblock_alloc(SZ_2, SMP_CACHE_BYTES);
 
 	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, SZ_2);
+
 	ASSERT_EQ(rgn->size, SZ_2);
 	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
 
@@ -528,6 +545,7 @@ static int alloc_bottom_up_disjoint_check(void)
 	allocated_ptr = memblock_alloc(r2_size, alignment);
 
 	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
 
 	ASSERT_EQ(rgn1->size, r1.size);
 	ASSERT_EQ(rgn1->base, r1.base);
@@ -571,6 +589,8 @@ static int alloc_bottom_up_before_check(void)
 	allocated_ptr = memblock_alloc(r1_size, SMP_CACHE_BYTES);
 
 	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r1_size);
+
 	ASSERT_EQ(rgn->size, total_size);
 	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
 
@@ -618,6 +638,8 @@ static int alloc_bottom_up_after_check(void)
 	allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
 
 	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
+
 	ASSERT_EQ(rgn->size, total_size);
 	ASSERT_EQ(rgn->base, r1.base);
 
@@ -669,6 +691,8 @@ static int alloc_bottom_up_second_fit_check(void)
 	allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
 
 	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
+
 	ASSERT_EQ(rgn->size, r2.size + r3_size);
 	ASSERT_EQ(rgn->base, r2.base);
 
diff --git a/tools/testing/memblock/tests/common.c b/tools/testing/memblock/tests/common.c
index 76a8ad818f3a..0ca26fe12c38 100644
--- a/tools/testing/memblock/tests/common.c
+++ b/tools/testing/memblock/tests/common.c
@@ -60,16 +60,23 @@ void reset_memblock_attributes(void)
 	memblock.current_limit	= MEMBLOCK_ALLOC_ANYWHERE;
 }
 
+void fill_memblock(void)
+{
+	memset(memory_block.base, 1, MEM_SIZE);
+}
+
 void setup_memblock(void)
 {
 	reset_memblock_regions();
 	memblock_add((phys_addr_t)memory_block.base, MEM_SIZE);
+	fill_memblock();
 }
 
 void dummy_physical_memory_init(void)
 {
 	memory_block.base = malloc(MEM_SIZE);
 	assert(memory_block.base);
+	fill_memblock();
 }
 
 void dummy_physical_memory_cleanup(void)
diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h
index d396e5423a8e..7a16a7dc8f2c 100644
--- a/tools/testing/memblock/tests/common.h
+++ b/tools/testing/memblock/tests/common.h
@@ -51,6 +51,18 @@
 	assert((_expected) < (_seen)); \
 } while (0)
 
+/**
+ * ASSERT_MEM_EQ():
+ * Check that the first @_size bytes of @_seen are all equal to @_expected.
+ * If false, print failed test message (if running with --verbose) and then
+ * assert.
+ */
+#define ASSERT_MEM_EQ(_seen, _expected, _size) do { \
+	for (int _i = 0; _i < (_size); _i++) { \
+		ASSERT_EQ((_seen)[_i], (_expected)); \
+	} \
+} while (0)
+
 #define PREFIX_PUSH() prefix_push(__func__)
 
 /*
@@ -70,6 +82,7 @@ struct region {
 
 void reset_memblock_regions(void);
 void reset_memblock_attributes(void);
+void fill_memblock(void);
 void setup_memblock(void);
 void dummy_physical_memory_init(void);
 void dummy_physical_memory_cleanup(void);
-- 
2.25.1

[PATCH 2/8] memblock tests: update zeroed memory check for memblock_alloc_* tests

[Rebecca Mckeever]

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>
Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
---
 .../memblock/tests/alloc_helpers_api.c        |  8 +--
 tools/testing/memblock/tests/alloc_nid_api.c  | 72 +++++--------------
 2 files changed, 20 insertions(+), 60 deletions(-)

diff --git a/tools/testing/memblock/tests/alloc_helpers_api.c b/tools/testing/memblock/tests/alloc_helpers_api.c
index 1069b4bdd5fd..796527cf3bd2 100644
--- a/tools/testing/memblock/tests/alloc_helpers_api.c
+++ b/tools/testing/memblock/tests/alloc_helpers_api.c
@@ -19,7 +19,6 @@ static int alloc_from_simple_generic_check(void)
 {
 	struct memblock_region *rgn = &memblock.reserved.regions[0];
 	void *allocated_ptr = NULL;
-	char *b;
 
 	PREFIX_PUSH();
 
@@ -31,10 +30,9 @@ static int alloc_from_simple_generic_check(void)
 	min_addr = memblock_end_of_DRAM() - SMP_CACHE_BYTES;
 
 	allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
-	b = (char *)allocated_ptr;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_EQ(*b, 0);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, min_addr);
@@ -66,7 +64,6 @@ static int alloc_from_misaligned_generic_check(void)
 {
 	struct memblock_region *rgn = &memblock.reserved.regions[0];
 	void *allocated_ptr = NULL;
-	char *b;
 
 	PREFIX_PUSH();
 
@@ -79,10 +76,9 @@ static int alloc_from_misaligned_generic_check(void)
 	min_addr = memblock_end_of_DRAM() - (SMP_CACHE_BYTES * 2 - 1);
 
 	allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
-	b = (char *)allocated_ptr;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_EQ(*b, 0);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - SMP_CACHE_BYTES);
diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
index 255fd514e9f5..71b7beb35526 100644
--- a/tools/testing/memblock/tests/alloc_nid_api.c
+++ b/tools/testing/memblock/tests/alloc_nid_api.c
@@ -19,7 +19,6 @@ static int alloc_try_nid_top_down_simple_check(void)
 {
 	struct memblock_region *rgn = &memblock.reserved.regions[0];
 	void *allocated_ptr = NULL;
-	char *b;
 
 	PREFIX_PUSH();
 
@@ -35,11 +34,10 @@ static int alloc_try_nid_top_down_simple_check(void)
 
 	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
 					       min_addr, max_addr, NUMA_NO_NODE);
-	b = (char *)allocated_ptr;
 	rgn_end = rgn->base + rgn->size;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_EQ(*b, 0);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, max_addr - size);
@@ -74,7 +72,6 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
 {
 	struct memblock_region *rgn = &memblock.reserved.regions[0];
 	void *allocated_ptr = NULL;
-	char *b;
 
 	PREFIX_PUSH();
 
@@ -91,11 +88,10 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
 
 	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
 					       min_addr, max_addr, NUMA_NO_NODE);
-	b = (char *)allocated_ptr;
 	rgn_end = rgn->base + rgn->size;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_EQ(*b, 0);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, max_addr - size - misalign);
@@ -128,7 +124,6 @@ static int alloc_try_nid_exact_address_generic_check(void)
 {
 	struct memblock_region *rgn = &memblock.reserved.regions[0];
 	void *allocated_ptr = NULL;
-	char *b;
 
 	PREFIX_PUSH();
 
@@ -144,11 +139,10 @@ static int alloc_try_nid_exact_address_generic_check(void)
 
 	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
 					       min_addr, max_addr, NUMA_NO_NODE);
-	b = (char *)allocated_ptr;
 	rgn_end = rgn->base + rgn->size;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_EQ(*b, 0);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, min_addr);
@@ -183,7 +177,6 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
 {
 	struct memblock_region *rgn = &memblock.reserved.regions[0];
 	void *allocated_ptr = NULL;
-	char *b;
 
 	PREFIX_PUSH();
 
@@ -198,10 +191,9 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
 
 	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
 					       min_addr, max_addr, NUMA_NO_NODE);
-	b = (char *)allocated_ptr;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_EQ(*b, 0);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, max_addr - size);
@@ -277,7 +269,6 @@ static int alloc_try_nid_min_reserved_generic_check(void)
 {
 	struct memblock_region *rgn = &memblock.reserved.regions[0];
 	void *allocated_ptr = NULL;
-	char *b;
 
 	PREFIX_PUSH();
 
@@ -298,10 +289,9 @@ static int alloc_try_nid_min_reserved_generic_check(void)
 
 	allocated_ptr = memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES,
 					       min_addr, max_addr, NUMA_NO_NODE);
-	b = (char *)allocated_ptr;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_EQ(*b, 0);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
 
 	ASSERT_EQ(rgn->size, total_size);
 	ASSERT_EQ(rgn->base, reserved_base);
@@ -332,7 +322,6 @@ static int alloc_try_nid_max_reserved_generic_check(void)
 {
 	struct memblock_region *rgn = &memblock.reserved.regions[0];
 	void *allocated_ptr = NULL;
-	char *b;
 
 	PREFIX_PUSH();
 
@@ -351,10 +340,9 @@ static int alloc_try_nid_max_reserved_generic_check(void)
 
 	allocated_ptr = memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES,
 					       min_addr, max_addr, NUMA_NO_NODE);
-	b = (char *)allocated_ptr;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_EQ(*b, 0);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
 
 	ASSERT_EQ(rgn->size, total_size);
 	ASSERT_EQ(rgn->base, min_addr);
@@ -389,7 +377,6 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
 	struct memblock_region *rgn1 = &memblock.reserved.regions[1];
 	struct memblock_region *rgn2 = &memblock.reserved.regions[0];
 	void *allocated_ptr = NULL;
-	char *b;
 	struct region r1, r2;
 
 	PREFIX_PUSH();
@@ -417,10 +404,9 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
 
 	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
 					       min_addr, max_addr, NUMA_NO_NODE);
-	b = (char *)allocated_ptr;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_EQ(*b, 0);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
 
 	ASSERT_EQ(rgn1->size, r1.size + r3_size);
 	ASSERT_EQ(rgn1->base, max_addr - r3_size);
@@ -456,7 +442,6 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
 {
 	struct memblock_region *rgn = &memblock.reserved.regions[0];
 	void *allocated_ptr = NULL;
-	char *b;
 	struct region r1, r2;
 
 	PREFIX_PUSH();
@@ -483,10 +468,9 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
 
 	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
 					       min_addr, max_addr, NUMA_NO_NODE);
-	b = (char *)allocated_ptr;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_EQ(*b, 0);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
 
 	ASSERT_EQ(rgn->size, total_size);
 	ASSERT_EQ(rgn->base, r2.base);
@@ -522,7 +506,6 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
 	struct memblock_region *rgn1 = &memblock.reserved.regions[1];
 	struct memblock_region *rgn2 = &memblock.reserved.regions[0];
 	void *allocated_ptr = NULL;
-	char *b;
 	struct region r1, r2;
 
 	PREFIX_PUSH();
@@ -550,10 +533,9 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
 
 	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
 					       min_addr, max_addr, NUMA_NO_NODE);
-	b = (char *)allocated_ptr;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_EQ(*b, 0);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
 
 	ASSERT_EQ(rgn1->size, r1.size);
 	ASSERT_EQ(rgn1->base, r1.base);
@@ -634,7 +616,6 @@ static int alloc_try_nid_top_down_cap_max_check(void)
 {
 	struct memblock_region *rgn = &memblock.reserved.regions[0];
 	void *allocated_ptr = NULL;
-	char *b;
 
 	PREFIX_PUSH();
 
@@ -649,10 +630,9 @@ static int alloc_try_nid_top_down_cap_max_check(void)
 
 	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
 					       min_addr, max_addr, NUMA_NO_NODE);
-	b = (char *)allocated_ptr;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_EQ(*b, 0);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
@@ -674,7 +654,6 @@ static int alloc_try_nid_top_down_cap_min_check(void)
 {
 	struct memblock_region *rgn = &memblock.reserved.regions[0];
 	void *allocated_ptr = NULL;
-	char *b;
 
 	PREFIX_PUSH();
 
@@ -689,10 +668,9 @@ static int alloc_try_nid_top_down_cap_min_check(void)
 
 	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
 					       min_addr, max_addr, NUMA_NO_NODE);
-	b = (char *)allocated_ptr;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_EQ(*b, 0);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
@@ -723,7 +701,6 @@ static int alloc_try_nid_bottom_up_simple_check(void)
 {
 	struct memblock_region *rgn = &memblock.reserved.regions[0];
 	void *allocated_ptr = NULL;
-	char *b;
 
 	PREFIX_PUSH();
 
@@ -740,11 +717,10 @@ static int alloc_try_nid_bottom_up_simple_check(void)
 	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
 					       min_addr, max_addr,
 					       NUMA_NO_NODE);
-	b = (char *)allocated_ptr;
 	rgn_end = rgn->base + rgn->size;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_EQ(*b, 0);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, min_addr);
@@ -779,7 +755,6 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
 {
 	struct memblock_region *rgn = &memblock.reserved.regions[0];
 	void *allocated_ptr = NULL;
-	char *b;
 
 	PREFIX_PUSH();
 
@@ -797,11 +772,10 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
 	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
 					       min_addr, max_addr,
 					       NUMA_NO_NODE);
-	b = (char *)allocated_ptr;
 	rgn_end = rgn->base + rgn->size;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_EQ(*b, 0);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, min_addr + (SMP_CACHE_BYTES - misalign));
@@ -836,7 +810,6 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
 {
 	struct memblock_region *rgn = &memblock.reserved.regions[0];
 	void *allocated_ptr = NULL;
-	char *b;
 
 	PREFIX_PUSH();
 
@@ -852,10 +825,9 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
 	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
 					       min_addr, max_addr,
 					       NUMA_NO_NODE);
-	b = (char *)allocated_ptr;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_EQ(*b, 0);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
@@ -890,7 +862,6 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
 	struct memblock_region *rgn1 = &memblock.reserved.regions[1];
 	struct memblock_region *rgn2 = &memblock.reserved.regions[0];
 	void *allocated_ptr = NULL;
-	char *b;
 	struct region r1, r2;
 
 	PREFIX_PUSH();
@@ -919,10 +890,9 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
 	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
 					       min_addr, max_addr,
 					       NUMA_NO_NODE);
-	b = (char *)allocated_ptr;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_EQ(*b, 0);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
 
 	ASSERT_EQ(rgn1->size, r1.size);
 	ASSERT_EQ(rgn1->base, max_addr);
@@ -964,7 +934,6 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
 	struct memblock_region *rgn2 = &memblock.reserved.regions[1];
 	struct memblock_region *rgn3 = &memblock.reserved.regions[0];
 	void *allocated_ptr = NULL;
-	char *b;
 	struct region r1, r2;
 
 	PREFIX_PUSH();
@@ -993,10 +962,9 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
 	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
 					       min_addr, max_addr,
 					       NUMA_NO_NODE);
-	b = (char *)allocated_ptr;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_EQ(*b, 0);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
 
 	ASSERT_EQ(rgn3->size, r3_size);
 	ASSERT_EQ(rgn3->base, memblock_start_of_DRAM());
@@ -1024,7 +992,6 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
 {
 	struct memblock_region *rgn = &memblock.reserved.regions[0];
 	void *allocated_ptr = NULL;
-	char *b;
 
 	PREFIX_PUSH();
 
@@ -1040,10 +1007,9 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
 	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
 					       min_addr, max_addr,
 					       NUMA_NO_NODE);
-	b = (char *)allocated_ptr;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_EQ(*b, 0);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, min_addr);
@@ -1065,7 +1031,6 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
 {
 	struct memblock_region *rgn = &memblock.reserved.regions[0];
 	void *allocated_ptr = NULL;
-	char *b;
 
 	PREFIX_PUSH();
 
@@ -1081,10 +1046,9 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
 	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
 					       min_addr, max_addr,
 					       NUMA_NO_NODE);
-	b = (char *)allocated_ptr;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_EQ(*b, 0);
+	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
-- 
2.25.1

[PATCH 3/8] memblock tests: add labels to verbose output for generic alloc tests

[Rebecca Mckeever]

Generic tests for memblock_alloc*() functions do not use separate
functions for testing top-down and bottom-up allocation directions.
Therefore, the function name that is displayed in the verbose testing
output does not include the allocation direction.

Add an additional prefix when running generic tests for
memblock_alloc*() functions that indicates which allocation direction is
set. The prefix will be displayed when the tests are run in verbose mode.

Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
---
 tools/testing/memblock/tests/alloc_api.c      | 36 +++++++------------
 .../memblock/tests/alloc_helpers_api.c        | 12 +++----
 tools/testing/memblock/tests/alloc_nid_api.c  | 36 +++++++------------
 tools/testing/memblock/tests/common.h         | 16 +++++++++
 4 files changed, 44 insertions(+), 56 deletions(-)

diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
index 71c89cb9b2a8..73c2c43e702a 100644
--- a/tools/testing/memblock/tests/alloc_api.c
+++ b/tools/testing/memblock/tests/alloc_api.c
@@ -752,10 +752,8 @@ static int alloc_after_check(void)
 static int alloc_in_between_check(void)
 {
 	test_print("\tRunning %s...\n", __func__);
-	memblock_set_bottom_up(false);
-	alloc_in_between_generic_check();
-	memblock_set_bottom_up(true);
-	alloc_in_between_generic_check();
+	run_top_down(alloc_in_between_generic_check);
+	run_bottom_up(alloc_in_between_generic_check);
 
 	return 0;
 }
@@ -774,10 +772,8 @@ static int alloc_second_fit_check(void)
 static int alloc_small_gaps_check(void)
 {
 	test_print("\tRunning %s...\n", __func__);
-	memblock_set_bottom_up(false);
-	alloc_small_gaps_generic_check();
-	memblock_set_bottom_up(true);
-	alloc_small_gaps_generic_check();
+	run_top_down(alloc_small_gaps_generic_check);
+	run_bottom_up(alloc_small_gaps_generic_check);
 
 	return 0;
 }
@@ -785,10 +781,8 @@ static int alloc_small_gaps_check(void)
 static int alloc_all_reserved_check(void)
 {
 	test_print("\tRunning %s...\n", __func__);
-	memblock_set_bottom_up(false);
-	alloc_all_reserved_generic_check();
-	memblock_set_bottom_up(true);
-	alloc_all_reserved_generic_check();
+	run_top_down(alloc_all_reserved_generic_check);
+	run_bottom_up(alloc_all_reserved_generic_check);
 
 	return 0;
 }
@@ -796,10 +790,8 @@ static int alloc_all_reserved_check(void)
 static int alloc_no_space_check(void)
 {
 	test_print("\tRunning %s...\n", __func__);
-	memblock_set_bottom_up(false);
-	alloc_no_space_generic_check();
-	memblock_set_bottom_up(true);
-	alloc_no_space_generic_check();
+	run_top_down(alloc_no_space_generic_check);
+	run_bottom_up(alloc_no_space_generic_check);
 
 	return 0;
 }
@@ -807,10 +799,8 @@ static int alloc_no_space_check(void)
 static int alloc_limited_space_check(void)
 {
 	test_print("\tRunning %s...\n", __func__);
-	memblock_set_bottom_up(false);
-	alloc_limited_space_generic_check();
-	memblock_set_bottom_up(true);
-	alloc_limited_space_generic_check();
+	run_top_down(alloc_limited_space_generic_check);
+	run_bottom_up(alloc_limited_space_generic_check);
 
 	return 0;
 }
@@ -818,10 +808,8 @@ static int alloc_limited_space_check(void)
 static int alloc_no_memory_check(void)
 {
 	test_print("\tRunning %s...\n", __func__);
-	memblock_set_bottom_up(false);
-	alloc_no_memory_generic_check();
-	memblock_set_bottom_up(true);
-	alloc_no_memory_generic_check();
+	run_top_down(alloc_no_memory_generic_check);
+	run_bottom_up(alloc_no_memory_generic_check);
 
 	return 0;
 }
diff --git a/tools/testing/memblock/tests/alloc_helpers_api.c b/tools/testing/memblock/tests/alloc_helpers_api.c
index 796527cf3bd2..1ccf02639ad6 100644
--- a/tools/testing/memblock/tests/alloc_helpers_api.c
+++ b/tools/testing/memblock/tests/alloc_helpers_api.c
@@ -357,10 +357,8 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
 static int alloc_from_simple_check(void)
 {
 	test_print("\tRunning %s...\n", __func__);
-	memblock_set_bottom_up(false);
-	alloc_from_simple_generic_check();
-	memblock_set_bottom_up(true);
-	alloc_from_simple_generic_check();
+	run_top_down(alloc_from_simple_generic_check);
+	run_bottom_up(alloc_from_simple_generic_check);
 
 	return 0;
 }
@@ -368,10 +366,8 @@ static int alloc_from_simple_check(void)
 static int alloc_from_misaligned_check(void)
 {
 	test_print("\tRunning %s...\n", __func__);
-	memblock_set_bottom_up(false);
-	alloc_from_misaligned_generic_check();
-	memblock_set_bottom_up(true);
-	alloc_from_misaligned_generic_check();
+	run_top_down(alloc_from_misaligned_generic_check);
+	run_bottom_up(alloc_from_misaligned_generic_check);
 
 	return 0;
 }
diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
index 71b7beb35526..82fa8ea36320 100644
--- a/tools/testing/memblock/tests/alloc_nid_api.c
+++ b/tools/testing/memblock/tests/alloc_nid_api.c
@@ -1142,10 +1142,8 @@ static int alloc_try_nid_cap_min_check(void)
 static int alloc_try_nid_min_reserved_check(void)
 {
 	test_print("\tRunning %s...\n", __func__);
-	memblock_set_bottom_up(false);
-	alloc_try_nid_min_reserved_generic_check();
-	memblock_set_bottom_up(true);
-	alloc_try_nid_min_reserved_generic_check();
+	run_top_down(alloc_try_nid_min_reserved_generic_check);
+	run_bottom_up(alloc_try_nid_min_reserved_generic_check);
 
 	return 0;
 }
@@ -1153,10 +1151,8 @@ static int alloc_try_nid_min_reserved_check(void)
 static int alloc_try_nid_max_reserved_check(void)
 {
 	test_print("\tRunning %s...\n", __func__);
-	memblock_set_bottom_up(false);
-	alloc_try_nid_max_reserved_generic_check();
-	memblock_set_bottom_up(true);
-	alloc_try_nid_max_reserved_generic_check();
+	run_top_down(alloc_try_nid_max_reserved_generic_check);
+	run_bottom_up(alloc_try_nid_max_reserved_generic_check);
 
 	return 0;
 }
@@ -1164,10 +1160,8 @@ static int alloc_try_nid_max_reserved_check(void)
 static int alloc_try_nid_exact_address_check(void)
 {
 	test_print("\tRunning %s...\n", __func__);
-	memblock_set_bottom_up(false);
-	alloc_try_nid_exact_address_generic_check();
-	memblock_set_bottom_up(true);
-	alloc_try_nid_exact_address_generic_check();
+	run_top_down(alloc_try_nid_exact_address_generic_check);
+	run_bottom_up(alloc_try_nid_exact_address_generic_check);
 
 	return 0;
 }
@@ -1175,10 +1169,8 @@ static int alloc_try_nid_exact_address_check(void)
 static int alloc_try_nid_reserved_full_merge_check(void)
 {
 	test_print("\tRunning %s...\n", __func__);
-	memblock_set_bottom_up(false);
-	alloc_try_nid_reserved_full_merge_generic_check();
-	memblock_set_bottom_up(true);
-	alloc_try_nid_reserved_full_merge_generic_check();
+	run_top_down(alloc_try_nid_reserved_full_merge_generic_check);
+	run_bottom_up(alloc_try_nid_reserved_full_merge_generic_check);
 
 	return 0;
 }
@@ -1186,10 +1178,8 @@ static int alloc_try_nid_reserved_full_merge_check(void)
 static int alloc_try_nid_reserved_all_check(void)
 {
 	test_print("\tRunning %s...\n", __func__);
-	memblock_set_bottom_up(false);
-	alloc_try_nid_reserved_all_generic_check();
-	memblock_set_bottom_up(true);
-	alloc_try_nid_reserved_all_generic_check();
+	run_top_down(alloc_try_nid_reserved_all_generic_check);
+	run_bottom_up(alloc_try_nid_reserved_all_generic_check);
 
 	return 0;
 }
@@ -1197,10 +1187,8 @@ static int alloc_try_nid_reserved_all_check(void)
 static int alloc_try_nid_low_max_check(void)
 {
 	test_print("\tRunning %s...\n", __func__);
-	memblock_set_bottom_up(false);
-	alloc_try_nid_low_max_generic_check();
-	memblock_set_bottom_up(true);
-	alloc_try_nid_low_max_generic_check();
+	run_top_down(alloc_try_nid_low_max_generic_check);
+	run_bottom_up(alloc_try_nid_low_max_generic_check);
 
 	return 0;
 }
diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h
index 7a16a7dc8f2c..e0dd5b410099 100644
--- a/tools/testing/memblock/tests/common.h
+++ b/tools/testing/memblock/tests/common.h
@@ -101,4 +101,20 @@ static inline void test_pass_pop(void)
 	prefix_pop();
 }
 
+static inline void run_top_down(int (*func)())
+{
+	memblock_set_bottom_up(false);
+	prefix_push("top-down");
+	func();
+	prefix_pop();
+}
+
+static inline void run_bottom_up(int (*func)())
+{
+	memblock_set_bottom_up(true);
+	prefix_push("bottom-up");
+	func();
+	prefix_pop();
+}
+
 #endif
-- 
2.25.1

[PATCH 4/8] memblock tests: add additional tests for basic api and memblock_alloc

[Rebecca Mckeever]

Add tests for memblock_add(), memblock_reserve(), memblock_remove(),
memblock_free(), and memblock_alloc() for the following test scenarios.

memblock_add() and memblock_reserve():
- add/reserve a memory block in the gap between two existing memory
  blocks, and check that the blocks are merged into one region
- try to add/reserve memblock regions that extend past PHYS_ADDR_MAX

memblock_remove() and memblock_free():
- remove/free a region when it is the only available region
    + These tests ensure that the first region is overwritten with a
      "dummy" region when the last remaining region of that type is
      removed or freed.
- remove/free() a region that overlaps with two existing regions of the
  relevant type
- try to remove/free memblock regions that extend past PHYS_ADDR_MAX

memblock_alloc():
- try to allocate a region that is larger than the total size of available
  memory (memblock.memory)

Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
---
 tools/testing/memblock/tests/alloc_api.c |  44 ++
 tools/testing/memblock/tests/basic_api.c | 499 +++++++++++++++++++++++
 2 files changed, 543 insertions(+)

diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
index 73c2c43e702a..fe1ee3b2e851 100644
--- a/tools/testing/memblock/tests/alloc_api.c
+++ b/tools/testing/memblock/tests/alloc_api.c
@@ -470,6 +470,40 @@ static int alloc_no_memory_generic_check(void)
 	return 0;
 }
 
+/*
+ * A test that tries to allocate a region that is larger than the total size of
+ * available memory (memblock.memory):
+ *
+ *  +-----------------------------------+
+ *  |                 new               |
+ *  +-----------------------------------+
+ *  |                                 |
+ *  |                                 |
+ *  +---------------------------------+
+ *
+ * Expect no allocation to happen.
+ */
+static int alloc_too_large_generic_check(void)
+{
+	struct memblock_region *rgn = &memblock.reserved.regions[0];
+	void *allocated_ptr = NULL;
+
+	PREFIX_PUSH();
+
+	setup_memblock();
+
+	allocated_ptr = memblock_alloc(MEM_SIZE + SZ_2, SMP_CACHE_BYTES);
+
+	ASSERT_EQ(allocated_ptr, NULL);
+	ASSERT_EQ(rgn->size, 0);
+	ASSERT_EQ(rgn->base, 0);
+	ASSERT_EQ(memblock.reserved.total_size, 0);
+
+	test_pass_pop();
+
+	return 0;
+}
+
 /*
  * A simple test that tries to allocate a small memory region.
  * Expect to allocate an aligned region at the beginning of the available
@@ -814,6 +848,15 @@ static int alloc_no_memory_check(void)
 	return 0;
 }
 
+static int alloc_too_large_check(void)
+{
+	test_print("\tRunning %s...\n", __func__);
+	run_top_down(alloc_too_large_generic_check);
+	run_bottom_up(alloc_too_large_generic_check);
+
+	return 0;
+}
+
 int memblock_alloc_checks(void)
 {
 	const char *func_testing = "memblock_alloc";
@@ -836,6 +879,7 @@ int memblock_alloc_checks(void)
 	alloc_no_space_check();
 	alloc_limited_space_check();
 	alloc_no_memory_check();
+	alloc_too_large_check();
 
 	dummy_physical_memory_cleanup();
 
diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c
index 66f46f261e66..ef5642d0863b 100644
--- a/tools/testing/memblock/tests/basic_api.c
+++ b/tools/testing/memblock/tests/basic_api.c
@@ -326,6 +326,102 @@ static int memblock_add_twice_check(void)
 	return 0;
 }
 
+/*
+ * A test that tries to add two memory blocks that don't overlap with one
+ * another and then add a third memory block in the space between the first two:
+ *
+ *  |        +--------+--------+--------+  |
+ *  |        |   r1   |   r3   |   r2   |  |
+ *  +--------+--------+--------+--------+--+
+ *
+ * Expect to merge the three entries into one region that starts at r1.base
+ * and has size of r1.size + r2.size + r3.size. The region counter and total
+ * size of the available memory are updated.
+ */
+static int memblock_add_between_check(void)
+{
+	struct memblock_region *rgn;
+	phys_addr_t total_size;
+
+	rgn = &memblock.memory.regions[0];
+
+	struct region r1 = {
+		.base = SZ_1G,
+		.size = SZ_8K
+	};
+	struct region r2 = {
+		.base = SZ_1G + SZ_16K,
+		.size = SZ_8K
+	};
+	struct region r3 = {
+		.base = SZ_1G + SZ_8K,
+		.size = SZ_8K
+	};
+
+	PREFIX_PUSH();
+
+	total_size = r1.size + r2.size + r3.size;
+
+	reset_memblock_regions();
+	memblock_add(r1.base, r1.size);
+	memblock_add(r2.base, r2.size);
+	memblock_add(r3.base, r3.size);
+
+	ASSERT_EQ(rgn->base, r1.base);
+	ASSERT_EQ(rgn->size, total_size);
+
+	ASSERT_EQ(memblock.memory.cnt, 1);
+	ASSERT_EQ(memblock.memory.total_size, total_size);
+
+	test_pass_pop();
+
+	return 0;
+}
+
+/*
+ * A simple test that tries to add a memory block r when r extends past
+ * PHYS_ADDR_MAX:
+ *
+ *                               +--------+
+ *                               |    r   |
+ *                               +--------+
+ *  |                            +----+
+ *  |                            | rgn|
+ *  +----------------------------+----+
+ *
+ * Expect to add a memory block of size PHYS_ADDR_MAX - r.base. Expect the
+ * total size of available memory and the counter to be updated.
+ */
+static int memblock_add_near_max_check(void)
+{
+	struct memblock_region *rgn;
+	phys_addr_t total_size;
+
+	rgn = &memblock.memory.regions[0];
+
+	struct region r = {
+		.base = PHYS_ADDR_MAX - SZ_1M,
+		.size = SZ_2M
+	};
+
+	PREFIX_PUSH();
+
+	total_size = PHYS_ADDR_MAX - r.base;
+
+	reset_memblock_regions();
+	memblock_add(r.base, r.size);
+
+	ASSERT_EQ(rgn->base, r.base);
+	ASSERT_EQ(rgn->size, total_size);
+
+	ASSERT_EQ(memblock.memory.cnt, 1);
+	ASSERT_EQ(memblock.memory.total_size, total_size);
+
+	test_pass_pop();
+
+	return 0;
+}
+
 static int memblock_add_checks(void)
 {
 	prefix_reset();
@@ -339,6 +435,8 @@ static int memblock_add_checks(void)
 	memblock_add_overlap_bottom_check();
 	memblock_add_within_check();
 	memblock_add_twice_check();
+	memblock_add_between_check();
+	memblock_add_near_max_check();
 
 	prefix_pop();
 
@@ -604,6 +702,102 @@ static int memblock_reserve_twice_check(void)
 	return 0;
 }
 
+/*
+ * A test that tries to mark two memory blocks that don't overlap as reserved
+ * and then reserve a third memory block in the space between the first two:
+ *
+ *  |        +--------+--------+--------+  |
+ *  |        |   r1   |   r3   |   r2   |  |
+ *  +--------+--------+--------+--------+--+
+ *
+ * Expect to merge the three entries into one reserved region that starts at
+ * r1.base and has size of r1.size + r2.size + r3.size. The region counter and
+ * total for memblock.reserved are updated.
+ */
+static int memblock_reserve_between_check(void)
+{
+	struct memblock_region *rgn;
+	phys_addr_t total_size;
+
+	rgn = &memblock.reserved.regions[0];
+
+	struct region r1 = {
+		.base = SZ_1G,
+		.size = SZ_8K
+	};
+	struct region r2 = {
+		.base = SZ_1G + SZ_16K,
+		.size = SZ_8K
+	};
+	struct region r3 = {
+		.base = SZ_1G + SZ_8K,
+		.size = SZ_8K
+	};
+
+	PREFIX_PUSH();
+
+	total_size = r1.size + r2.size + r3.size;
+
+	reset_memblock_regions();
+	memblock_reserve(r1.base, r1.size);
+	memblock_reserve(r2.base, r2.size);
+	memblock_reserve(r3.base, r3.size);
+
+	ASSERT_EQ(rgn->base, r1.base);
+	ASSERT_EQ(rgn->size, total_size);
+
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+	test_pass_pop();
+
+	return 0;
+}
+
+/*
+ * A simple test that tries to reserve a memory block r when r extends past
+ * PHYS_ADDR_MAX:
+ *
+ *                               +--------+
+ *                               |    r   |
+ *                               +--------+
+ *  |                            +----+
+ *  |                            | rgn|
+ *  +----------------------------+----+
+ *
+ * Expect to reserve a memory block of size PHYS_ADDR_MAX - r.base. Expect the
+ * total size of reserved memory and the counter to be updated.
+ */
+static int memblock_reserve_near_max_check(void)
+{
+	struct memblock_region *rgn;
+	phys_addr_t total_size;
+
+	rgn = &memblock.reserved.regions[0];
+
+	struct region r = {
+		.base = PHYS_ADDR_MAX - SZ_1M,
+		.size = SZ_2M
+	};
+
+	PREFIX_PUSH();
+
+	total_size = PHYS_ADDR_MAX - r.base;
+
+	reset_memblock_regions();
+	memblock_reserve(r.base, r.size);
+
+	ASSERT_EQ(rgn->base, r.base);
+	ASSERT_EQ(rgn->size, total_size);
+
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+	test_pass_pop();
+
+	return 0;
+}
+
 static int memblock_reserve_checks(void)
 {
 	prefix_reset();
@@ -616,6 +810,8 @@ static int memblock_reserve_checks(void)
 	memblock_reserve_overlap_bottom_check();
 	memblock_reserve_within_check();
 	memblock_reserve_twice_check();
+	memblock_reserve_between_check();
+	memblock_reserve_near_max_check();
 
 	prefix_pop();
 
@@ -887,6 +1083,155 @@ static int memblock_remove_within_check(void)
 	return 0;
 }
 
+/*
+ * A simple test that tries to remove a region r1 from the array of
+ * available memory regions when r1 is the only available region.
+ * Expect to add a memory block r1 and then remove r1 so that a dummy
+ * region is added. The region counter stays the same, and the total size
+ * is updated.
+ */
+static int memblock_remove_only_region_check(void)
+{
+	struct memblock_region *rgn;
+
+	rgn = &memblock.memory.regions[0];
+
+	struct region r1 = {
+		.base = SZ_2K,
+		.size = SZ_4K
+	};
+
+	PREFIX_PUSH();
+
+	reset_memblock_regions();
+	memblock_add(r1.base, r1.size);
+	memblock_remove(r1.base, r1.size);
+
+	ASSERT_EQ(rgn->base, 0);
+	ASSERT_EQ(rgn->size, 0);
+
+	ASSERT_EQ(memblock.memory.cnt, 1);
+	ASSERT_EQ(memblock.memory.total_size, 0);
+
+	test_pass_pop();
+
+	return 0;
+}
+
+/*
+ * A simple test that tries remove a region r2 from the array of available
+ * memory regions when r2 extends past PHYS_ADDR_MAX:
+ *
+ *                               +--------+
+ *                               |   r2   |
+ *                               +--------+
+ *  |                        +---+....+
+ *  |                        |rgn|    |
+ *  +------------------------+---+----+
+ *
+ * Expect that only the portion between PHYS_ADDR_MAX and r2.base is removed.
+ * Expect the total size of available memory to be updated and the counter to
+ * not be updated.
+ */
+static int memblock_remove_near_max_check(void)
+{
+	struct memblock_region *rgn;
+	phys_addr_t total_size;
+
+	rgn = &memblock.memory.regions[0];
+
+	struct region r1 = {
+		.base = PHYS_ADDR_MAX - SZ_2M,
+		.size = SZ_2M
+	};
+
+	struct region r2 = {
+		.base = PHYS_ADDR_MAX - SZ_1M,
+		.size = SZ_2M
+	};
+
+	PREFIX_PUSH();
+
+	total_size = r1.size - (PHYS_ADDR_MAX - r2.base);
+
+	reset_memblock_regions();
+	memblock_add(r1.base, r1.size);
+	memblock_remove(r2.base, r2.size);
+
+	ASSERT_EQ(rgn->base, r1.base);
+	ASSERT_EQ(rgn->size, total_size);
+
+	ASSERT_EQ(memblock.memory.cnt, 1);
+	ASSERT_EQ(memblock.memory.total_size, total_size);
+
+	test_pass_pop();
+
+	return 0;
+}
+
+/*
+ * A test that tries to remove a region r3 that overlaps with two existing
+ * regions r1 and r2:
+ *
+ *            +----------------+
+ *            |       r3       |
+ *            +----------------+
+ *  |    +----+.....   ........+--------+
+ *  |    |    |r1  :   :       |r2      |     |
+ *  +----+----+----+---+-------+--------+-----+
+ *
+ * Expect that only the intersections of r1 with r3 and r2 with r3 are removed
+ * from the available memory pool. Expect the total size of available memory to
+ * be updated and the counter to not be updated.
+ */
+static int memblock_remove_overlap_two_check(void)
+{
+	struct memblock_region *rgn1, *rgn2;
+	phys_addr_t r1_size, r2_size, r2_end, r3_end, total_size;
+
+	rgn1 = &memblock.memory.regions[0];
+	rgn2 = &memblock.memory.regions[1];
+
+	struct region r1 = {
+		.base = SZ_16M,
+		.size = SZ_32M
+	};
+	struct region r2 = {
+		.base = SZ_64M,
+		.size = SZ_64M
+	};
+	struct region r3 = {
+		.base = SZ_32M,
+		.size = SZ_64M
+	};
+
+	PREFIX_PUSH();
+
+	r2_end = r2.base + r2.size;
+	r3_end = r3.base + r3.size;
+	r1_size = r3.base - r1.base;
+	r2_size = r2_end - r3_end;
+	total_size = r1_size + r2_size;
+
+	reset_memblock_regions();
+	memblock_add(r1.base, r1.size);
+	memblock_add(r2.base, r2.size);
+	memblock_remove(r3.base, r3.size);
+
+	ASSERT_EQ(rgn1->base, r1.base);
+	ASSERT_EQ(rgn1->size, r1_size);
+
+	ASSERT_EQ(rgn2->base, r3_end);
+	ASSERT_EQ(rgn2->size, r2_size);
+
+	ASSERT_EQ(memblock.memory.cnt, 2);
+	ASSERT_EQ(memblock.memory.total_size, total_size);
+
+	test_pass_pop();
+
+	return 0;
+}
+
 static int memblock_remove_checks(void)
 {
 	prefix_reset();
@@ -898,6 +1243,9 @@ static int memblock_remove_checks(void)
 	memblock_remove_overlap_top_check();
 	memblock_remove_overlap_bottom_check();
 	memblock_remove_within_check();
+	memblock_remove_only_region_check();
+	memblock_remove_near_max_check();
+	memblock_remove_overlap_two_check();
 
 	prefix_pop();
 
@@ -1163,6 +1511,154 @@ static int memblock_free_within_check(void)
 	return 0;
 }
 
+/*
+ * A simple test that tries to free a memory block r1 that was marked
+ * earlier as reserved when r1 is the only available region.
+ * Expect to reserve a memory block r1 and then free r1 so that r1 is
+ * overwritten with a dummy region. The region counter stays the same,
+ * and the total size is updated.
+ */
+static int memblock_free_only_region_check(void)
+{
+	struct memblock_region *rgn;
+
+	rgn = &memblock.reserved.regions[0];
+
+	struct region r1 = {
+		.base = SZ_2K,
+		.size = SZ_4K
+	};
+
+	PREFIX_PUSH();
+
+	reset_memblock_regions();
+	memblock_reserve(r1.base, r1.size);
+	memblock_free((void *)r1.base, r1.size);
+
+	ASSERT_EQ(rgn->base, 0);
+	ASSERT_EQ(rgn->size, 0);
+
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, 0);
+
+	test_pass_pop();
+
+	return 0;
+}
+
+/*
+ * A simple test that tries free a region r2 when r2 extends past PHYS_ADDR_MAX:
+ *
+ *                               +--------+
+ *                               |   r2   |
+ *                               +--------+
+ *  |                        +---+....+
+ *  |                        |rgn|    |
+ *  +------------------------+---+----+
+ *
+ * Expect that only the portion between PHYS_ADDR_MAX and r2.base is freed.
+ * Expect the total size of reserved memory to be updated and the counter to
+ * not be updated.
+ */
+static int memblock_free_near_max_check(void)
+{
+	struct memblock_region *rgn;
+	phys_addr_t total_size;
+
+	rgn = &memblock.reserved.regions[0];
+
+	struct region r1 = {
+		.base = PHYS_ADDR_MAX - SZ_2M,
+		.size = SZ_2M
+	};
+
+	struct region r2 = {
+		.base = PHYS_ADDR_MAX - SZ_1M,
+		.size = SZ_2M
+	};
+
+	PREFIX_PUSH();
+
+	total_size = r1.size - (PHYS_ADDR_MAX - r2.base);
+
+	reset_memblock_regions();
+	memblock_reserve(r1.base, r1.size);
+	memblock_free((void *)r2.base, r2.size);
+
+	ASSERT_EQ(rgn->base, r1.base);
+	ASSERT_EQ(rgn->size, total_size);
+
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+	test_pass_pop();
+
+	return 0;
+}
+
+/*
+ * A test that tries to free a reserved region r3 that overlaps with two
+ * existing reserved regions r1 and r2:
+ *
+ *            +----------------+
+ *            |       r3       |
+ *            +----------------+
+ *  |    +----+.....   ........+--------+
+ *  |    |    |r1  :   :       |r2      |     |
+ *  +----+----+----+---+-------+--------+-----+
+ *
+ * Expect that only the intersections of r1 with r3 and r2 with r3 are freed
+ * from the collection of reserved memory. Expect the total size of reserved
+ * memory to be updated and the counter to not be updated.
+ */
+static int memblock_free_overlap_two_check(void)
+{
+	struct memblock_region *rgn1, *rgn2;
+	phys_addr_t r1_size, r2_size, r2_end, r3_end, total_size;
+
+	rgn1 = &memblock.reserved.regions[0];
+	rgn2 = &memblock.reserved.regions[1];
+
+	struct region r1 = {
+		.base = SZ_16M,
+		.size = SZ_32M
+	};
+	struct region r2 = {
+		.base = SZ_64M,
+		.size = SZ_64M
+	};
+	struct region r3 = {
+		.base = SZ_32M,
+		.size = SZ_64M
+	};
+
+	PREFIX_PUSH();
+
+	r2_end = r2.base + r2.size;
+	r3_end = r3.base + r3.size;
+	r1_size = r3.base - r1.base;
+	r2_size = r2_end - r3_end;
+	total_size = r1_size + r2_size;
+
+	reset_memblock_regions();
+	memblock_reserve(r1.base, r1.size);
+	memblock_reserve(r2.base, r2.size);
+	memblock_free((void *)r3.base, r3.size);
+
+	ASSERT_EQ(rgn1->base, r1.base);
+	ASSERT_EQ(rgn1->size, r1_size);
+
+	ASSERT_EQ(rgn2->base, r3_end);
+	ASSERT_EQ(rgn2->size, r2_size);
+
+	ASSERT_EQ(memblock.reserved.cnt, 2);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+	test_pass_pop();
+
+	return 0;
+}
+
 static int memblock_free_checks(void)
 {
 	prefix_reset();
@@ -1174,6 +1670,9 @@ static int memblock_free_checks(void)
 	memblock_free_overlap_top_check();
 	memblock_free_overlap_bottom_check();
 	memblock_free_within_check();
+	memblock_free_only_region_check();
+	memblock_free_near_max_check();
+	memblock_free_overlap_two_check();
 
 	prefix_pop();
 
-- 
2.25.1

[PATCH 5/8] memblock tests: update alloc_api to test memblock_alloc_raw

[Rebecca Mckeever]

Update memblock_alloc() tests so that they test either memblock_alloc()
or memblock_alloc_raw() depending on the value of alloc_test_flags. Run
through all the existing tests in memblock_alloc_api twice: once for
memblock_alloc() and once for memblock_alloc_raw().

When the tests run memblock_alloc(), they test that the entire memory
region is zero. When the tests run memblock_alloc_raw(), they test that
the entire memory region is nonzero.

Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
---
 tools/testing/memblock/tests/alloc_api.c | 106 ++++++++++++++++-------
 tools/testing/memblock/tests/common.h    |  17 ++++
 2 files changed, 90 insertions(+), 33 deletions(-)

diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
index fe1ee3b2e851..e3c0dc2174e9 100644
--- a/tools/testing/memblock/tests/alloc_api.c
+++ b/tools/testing/memblock/tests/alloc_api.c
@@ -1,6 +1,37 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 #include "alloc_api.h"
 
+static const char * const func_testing[] = {
+	"memblock_alloc",
+	"memblock_alloc_raw"
+};
+
+static int alloc_test_flags = TEST_ZEROED;
+
+static inline const char * const get_func_testing(int flags)
+{
+	if (flags & TEST_RAW)
+		return func_testing[1];
+	else
+		return func_testing[0];
+}
+
+static inline void *run_memblock_alloc(phys_addr_t size, phys_addr_t align)
+{
+	if (alloc_test_flags & TEST_RAW)
+		return memblock_alloc_raw(size, align);
+	else
+		return memblock_alloc(size, align);
+}
+
+static inline void verify_mem_content(void *mem, int size)
+{
+	if (alloc_test_flags & TEST_RAW)
+		ASSERT_MEM_NE((char *)mem, 0, size);
+	else
+		ASSERT_MEM_EQ((char *)mem, 0, size);
+}
+
 /*
  * A simple test that tries to allocate a small memory region.
  * Expect to allocate an aligned region near the end of the available memory.
@@ -19,10 +50,10 @@ static int alloc_top_down_simple_check(void)
 
 	expected_start = memblock_end_of_DRAM() - SMP_CACHE_BYTES;
 
-	allocated_ptr = memblock_alloc(size, SMP_CACHE_BYTES);
+	allocated_ptr = run_memblock_alloc(size, SMP_CACHE_BYTES);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
+	verify_mem_content(allocated_ptr, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, expected_start);
@@ -79,10 +110,10 @@ static int alloc_top_down_disjoint_check(void)
 
 	memblock_reserve(r1.base, r1.size);
 
-	allocated_ptr = memblock_alloc(r2_size, alignment);
+	allocated_ptr = run_memblock_alloc(r2_size, alignment);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
+	verify_mem_content(allocated_ptr, r2_size);
 
 	ASSERT_EQ(rgn1->size, r1.size);
 	ASSERT_EQ(rgn1->base, r1.base);
@@ -126,10 +157,10 @@ static int alloc_top_down_before_check(void)
 
 	memblock_reserve(memblock_end_of_DRAM() - total_size, r1_size);
 
-	allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
+	allocated_ptr = run_memblock_alloc(r2_size, SMP_CACHE_BYTES);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
+	verify_mem_content(allocated_ptr, r2_size);
 
 	ASSERT_EQ(rgn->size, total_size);
 	ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - total_size);
@@ -176,10 +207,10 @@ static int alloc_top_down_after_check(void)
 
 	memblock_reserve(r1.base, r1.size);
 
-	allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
+	allocated_ptr = run_memblock_alloc(r2_size, SMP_CACHE_BYTES);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
+	verify_mem_content(allocated_ptr, r2_size);
 
 	ASSERT_EQ(rgn->size, total_size);
 	ASSERT_EQ(rgn->base, r1.base - r2_size);
@@ -228,10 +259,10 @@ static int alloc_top_down_second_fit_check(void)
 	memblock_reserve(r1.base, r1.size);
 	memblock_reserve(r2.base, r2.size);
 
-	allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
+	allocated_ptr = run_memblock_alloc(r3_size, SMP_CACHE_BYTES);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
+	verify_mem_content(allocated_ptr, r3_size);
 
 	ASSERT_EQ(rgn->size, r2.size + r3_size);
 	ASSERT_EQ(rgn->base, r2.base - r3_size);
@@ -284,10 +315,10 @@ static int alloc_in_between_generic_check(void)
 	memblock_reserve(r1.base, r1.size);
 	memblock_reserve(r2.base, r2.size);
 
-	allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
+	allocated_ptr = run_memblock_alloc(r3_size, SMP_CACHE_BYTES);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
+	verify_mem_content(allocated_ptr, r3_size);
 
 	ASSERT_EQ(rgn->size, total_size);
 	ASSERT_EQ(rgn->base, r1.base - r2.size - r3_size);
@@ -332,7 +363,7 @@ static int alloc_small_gaps_generic_check(void)
 		region_end += gap_size + region_size;
 	}
 
-	allocated_ptr = memblock_alloc(region_size, SMP_CACHE_BYTES);
+	allocated_ptr = run_memblock_alloc(region_size, SMP_CACHE_BYTES);
 
 	ASSERT_EQ(allocated_ptr, NULL);
 
@@ -356,7 +387,7 @@ static int alloc_all_reserved_generic_check(void)
 	/* Simulate full memory */
 	memblock_reserve(memblock_start_of_DRAM(), MEM_SIZE);
 
-	allocated_ptr = memblock_alloc(SZ_256, SMP_CACHE_BYTES);
+	allocated_ptr = run_memblock_alloc(SZ_256, SMP_CACHE_BYTES);
 
 	ASSERT_EQ(allocated_ptr, NULL);
 
@@ -392,7 +423,7 @@ static int alloc_no_space_generic_check(void)
 	/* Simulate almost-full memory */
 	memblock_reserve(memblock_start_of_DRAM(), reserved_size);
 
-	allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
+	allocated_ptr = run_memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
 
 	ASSERT_EQ(allocated_ptr, NULL);
 
@@ -427,10 +458,10 @@ static int alloc_limited_space_generic_check(void)
 	/* Simulate almost-full memory */
 	memblock_reserve(memblock_start_of_DRAM(), reserved_size);
 
-	allocated_ptr = memblock_alloc(available_size, SMP_CACHE_BYTES);
+	allocated_ptr = run_memblock_alloc(available_size, SMP_CACHE_BYTES);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, available_size);
+	verify_mem_content(allocated_ptr, available_size);
 
 	ASSERT_EQ(rgn->size, MEM_SIZE);
 	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
@@ -458,7 +489,7 @@ static int alloc_no_memory_generic_check(void)
 	reset_memblock_regions();
 	fill_memblock();
 
-	allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
+	allocated_ptr = run_memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
 
 	ASSERT_EQ(allocated_ptr, NULL);
 	ASSERT_EQ(rgn->size, 0);
@@ -492,7 +523,7 @@ static int alloc_too_large_generic_check(void)
 
 	setup_memblock();
 
-	allocated_ptr = memblock_alloc(MEM_SIZE + SZ_2, SMP_CACHE_BYTES);
+	allocated_ptr = run_memblock_alloc(MEM_SIZE + SZ_2, SMP_CACHE_BYTES);
 
 	ASSERT_EQ(allocated_ptr, NULL);
 	ASSERT_EQ(rgn->size, 0);
@@ -518,10 +549,10 @@ static int alloc_bottom_up_simple_check(void)
 
 	setup_memblock();
 
-	allocated_ptr = memblock_alloc(SZ_2, SMP_CACHE_BYTES);
+	allocated_ptr = run_memblock_alloc(SZ_2, SMP_CACHE_BYTES);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, SZ_2);
+	verify_mem_content(allocated_ptr, SZ_2);
 
 	ASSERT_EQ(rgn->size, SZ_2);
 	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
@@ -576,10 +607,10 @@ static int alloc_bottom_up_disjoint_check(void)
 
 	memblock_reserve(r1.base, r1.size);
 
-	allocated_ptr = memblock_alloc(r2_size, alignment);
+	allocated_ptr = run_memblock_alloc(r2_size, alignment);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
+	verify_mem_content(allocated_ptr, r2_size);
 
 	ASSERT_EQ(rgn1->size, r1.size);
 	ASSERT_EQ(rgn1->base, r1.base);
@@ -620,10 +651,10 @@ static int alloc_bottom_up_before_check(void)
 
 	memblock_reserve(memblock_start_of_DRAM() + r1_size, r2_size);
 
-	allocated_ptr = memblock_alloc(r1_size, SMP_CACHE_BYTES);
+	allocated_ptr = run_memblock_alloc(r1_size, SMP_CACHE_BYTES);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r1_size);
+	verify_mem_content(allocated_ptr, r1_size);
 
 	ASSERT_EQ(rgn->size, total_size);
 	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
@@ -669,10 +700,10 @@ static int alloc_bottom_up_after_check(void)
 
 	memblock_reserve(r1.base, r1.size);
 
-	allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
+	allocated_ptr = run_memblock_alloc(r2_size, SMP_CACHE_BYTES);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
+	verify_mem_content(allocated_ptr, r2_size);
 
 	ASSERT_EQ(rgn->size, total_size);
 	ASSERT_EQ(rgn->base, r1.base);
@@ -722,10 +753,10 @@ static int alloc_bottom_up_second_fit_check(void)
 	memblock_reserve(r1.base, r1.size);
 	memblock_reserve(r2.base, r2.size);
 
-	allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
+	allocated_ptr = run_memblock_alloc(r3_size, SMP_CACHE_BYTES);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
+	verify_mem_content(allocated_ptr, r3_size);
 
 	ASSERT_EQ(rgn->size, r2.size + r3_size);
 	ASSERT_EQ(rgn->base, r2.base);
@@ -857,13 +888,14 @@ static int alloc_too_large_check(void)
 	return 0;
 }
 
-int memblock_alloc_checks(void)
+static int memblock_alloc_checks_internal(int flags)
 {
-	const char *func_testing = "memblock_alloc";
+	const char *func = get_func_testing(flags);
 
+	alloc_test_flags = flags;
 	prefix_reset();
-	prefix_push(func_testing);
-	test_print("Running %s tests...\n", func_testing);
+	prefix_push(func);
+	test_print("Running %s tests...\n", func);
 
 	reset_memblock_attributes();
 	dummy_physical_memory_init();
@@ -887,3 +919,11 @@ int memblock_alloc_checks(void)
 
 	return 0;
 }
+
+int memblock_alloc_checks(void)
+{
+	memblock_alloc_checks_internal(TEST_ZEROED);
+	memblock_alloc_checks_internal(TEST_RAW);
+
+	return 0;
+}
diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h
index e0dd5b410099..a0594f1e4fe3 100644
--- a/tools/testing/memblock/tests/common.h
+++ b/tools/testing/memblock/tests/common.h
@@ -12,6 +12,11 @@
 
 #define MEM_SIZE SZ_16K
 
+enum test_flags {
+	TEST_ZEROED = 0x0,
+	TEST_RAW = 0x1
+};
+
 /**
  * ASSERT_EQ():
  * Check the condition
@@ -63,6 +68,18 @@
 	} \
 } while (0)
 
+/**
+ * ASSERT_MEM_NE():
+ * Check that none of the first @_size bytes of @_seen are equal to @_expected.
+ * If false, print failed test message (if running with --verbose) and then
+ * assert.
+ */
+#define ASSERT_MEM_NE(_seen, _expected, _size) do { \
+	for (int _i = 0; _i < (_size); _i++) { \
+		ASSERT_NE((_seen)[_i], (_expected)); \
+	} \
+} while (0)
+
 #define PREFIX_PUSH() prefix_push(__func__)
 
 /*
-- 
2.25.1

[PATCH 6/8] memblock tests: update alloc_nid_api to test memblock_alloc_try_nid_raw

[Rebecca Mckeever]

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.

Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
---
 tools/testing/memblock/tests/alloc_nid_api.c | 196 ++++++++++++-------
 1 file changed, 127 insertions(+), 69 deletions(-)

diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
index 82fa8ea36320..e16106d8446b 100644
--- a/tools/testing/memblock/tests/alloc_nid_api.c
+++ b/tools/testing/memblock/tests/alloc_nid_api.c
@@ -1,6 +1,42 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 #include "alloc_nid_api.h"
 
+static const char * const func_testing[] = {
+	"memblock_alloc_try_nid",
+	"memblock_alloc_try_nid_raw"
+};
+
+static int alloc_nid_test_flags = TEST_ZEROED;
+
+static inline const char * const get_func_testing(int flags)
+{
+	if (flags & TEST_RAW)
+		return func_testing[1];
+	else
+		return func_testing[0];
+}
+
+static inline void *run_memblock_alloc_try_nid(phys_addr_t size,
+					       phys_addr_t align,
+					       phys_addr_t min_addr,
+					       phys_addr_t max_addr, int nid)
+{
+	if (alloc_nid_test_flags & TEST_RAW)
+		return memblock_alloc_try_nid_raw(size, align, min_addr,
+						  max_addr, nid);
+	else
+		return memblock_alloc_try_nid(size, align, min_addr,
+					      max_addr, nid);
+}
+
+static inline void verify_mem_content(void *mem, int size)
+{
+	if (alloc_nid_test_flags & TEST_RAW)
+		ASSERT_MEM_NE((char *)mem, 0, size);
+	else
+		ASSERT_MEM_EQ((char *)mem, 0, size);
+}
+
 /*
  * A simple test that tries to allocate a memory region within min_addr and
  * max_addr range:
@@ -32,12 +68,13 @@ static int alloc_try_nid_top_down_simple_check(void)
 	min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2;
 	max_addr = min_addr + SZ_512;
 
-	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
-					       min_addr, max_addr, NUMA_NO_NODE);
+	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
+						   min_addr, max_addr,
+						   NUMA_NO_NODE);
 	rgn_end = rgn->base + rgn->size;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
+	verify_mem_content(allocated_ptr, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, max_addr - size);
@@ -86,12 +123,13 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
 	min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2;
 	max_addr = min_addr + SZ_512 + misalign;
 
-	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
-					       min_addr, max_addr, NUMA_NO_NODE);
+	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
+						   min_addr, max_addr,
+						   NUMA_NO_NODE);
 	rgn_end = rgn->base + rgn->size;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
+	verify_mem_content(allocated_ptr, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, max_addr - size - misalign);
@@ -137,12 +175,13 @@ static int alloc_try_nid_exact_address_generic_check(void)
 	min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES;
 	max_addr = min_addr + size;
 
-	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
-					       min_addr, max_addr, NUMA_NO_NODE);
+	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
+						   min_addr, max_addr,
+						   NUMA_NO_NODE);
 	rgn_end = rgn->base + rgn->size;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
+	verify_mem_content(allocated_ptr, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, min_addr);
@@ -189,11 +228,12 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
 	min_addr = memblock_start_of_DRAM() + SZ_512;
 	max_addr = min_addr + SMP_CACHE_BYTES;
 
-	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
-					       min_addr, max_addr, NUMA_NO_NODE);
+	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
+						   min_addr, max_addr,
+						   NUMA_NO_NODE);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
+	verify_mem_content(allocated_ptr, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, max_addr - size);
@@ -241,8 +281,9 @@ static int alloc_try_nid_low_max_generic_check(void)
 	min_addr = memblock_start_of_DRAM();
 	max_addr = min_addr + SMP_CACHE_BYTES;
 
-	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
-					       min_addr, max_addr, NUMA_NO_NODE);
+	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
+						   min_addr, max_addr,
+						   NUMA_NO_NODE);
 
 	ASSERT_EQ(allocated_ptr, NULL);
 
@@ -287,11 +328,12 @@ static int alloc_try_nid_min_reserved_generic_check(void)
 
 	memblock_reserve(reserved_base, r1_size);
 
-	allocated_ptr = memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES,
-					       min_addr, max_addr, NUMA_NO_NODE);
+	allocated_ptr = run_memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES,
+						   min_addr, max_addr,
+						   NUMA_NO_NODE);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
+	verify_mem_content(allocated_ptr, r2_size);
 
 	ASSERT_EQ(rgn->size, total_size);
 	ASSERT_EQ(rgn->base, reserved_base);
@@ -338,11 +380,12 @@ static int alloc_try_nid_max_reserved_generic_check(void)
 
 	memblock_reserve(max_addr, r1_size);
 
-	allocated_ptr = memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES,
-					       min_addr, max_addr, NUMA_NO_NODE);
+	allocated_ptr = run_memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES,
+						   min_addr, max_addr,
+						   NUMA_NO_NODE);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
+	verify_mem_content(allocated_ptr, r2_size);
 
 	ASSERT_EQ(rgn->size, total_size);
 	ASSERT_EQ(rgn->base, min_addr);
@@ -402,11 +445,12 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
 	memblock_reserve(r1.base, r1.size);
 	memblock_reserve(r2.base, r2.size);
 
-	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
-					       min_addr, max_addr, NUMA_NO_NODE);
+	allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
+						   min_addr, max_addr,
+						   NUMA_NO_NODE);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
+	verify_mem_content(allocated_ptr, r3_size);
 
 	ASSERT_EQ(rgn1->size, r1.size + r3_size);
 	ASSERT_EQ(rgn1->base, max_addr - r3_size);
@@ -466,11 +510,12 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
 	memblock_reserve(r1.base, r1.size);
 	memblock_reserve(r2.base, r2.size);
 
-	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
-					       min_addr, max_addr, NUMA_NO_NODE);
+	allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
+						   min_addr, max_addr,
+						   NUMA_NO_NODE);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
+	verify_mem_content(allocated_ptr, r3_size);
 
 	ASSERT_EQ(rgn->size, total_size);
 	ASSERT_EQ(rgn->base, r2.base);
@@ -531,11 +576,12 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
 	memblock_reserve(r1.base, r1.size);
 	memblock_reserve(r2.base, r2.size);
 
-	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
-					       min_addr, max_addr, NUMA_NO_NODE);
+	allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
+						   min_addr, max_addr,
+						   NUMA_NO_NODE);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
+	verify_mem_content(allocated_ptr, r3_size);
 
 	ASSERT_EQ(rgn1->size, r1.size);
 	ASSERT_EQ(rgn1->base, r1.base);
@@ -597,8 +643,9 @@ static int alloc_try_nid_reserved_all_generic_check(void)
 	memblock_reserve(r1.base, r1.size);
 	memblock_reserve(r2.base, r2.size);
 
-	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
-					       min_addr, max_addr, NUMA_NO_NODE);
+	allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
+						   min_addr, max_addr,
+						   NUMA_NO_NODE);
 
 	ASSERT_EQ(allocated_ptr, NULL);
 
@@ -628,11 +675,12 @@ static int alloc_try_nid_top_down_cap_max_check(void)
 	min_addr = memblock_end_of_DRAM() - SZ_1K;
 	max_addr = memblock_end_of_DRAM() + SZ_256;
 
-	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
-					       min_addr, max_addr, NUMA_NO_NODE);
+	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
+						   min_addr, max_addr,
+						   NUMA_NO_NODE);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
+	verify_mem_content(allocated_ptr, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
@@ -666,11 +714,12 @@ static int alloc_try_nid_top_down_cap_min_check(void)
 	min_addr = memblock_start_of_DRAM() - SZ_256;
 	max_addr = memblock_end_of_DRAM();
 
-	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
-					       min_addr, max_addr, NUMA_NO_NODE);
+	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
+						   min_addr, max_addr,
+						   NUMA_NO_NODE);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
+	verify_mem_content(allocated_ptr, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
@@ -714,13 +763,13 @@ static int alloc_try_nid_bottom_up_simple_check(void)
 	min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2;
 	max_addr = min_addr + SZ_512;
 
-	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
-					       min_addr, max_addr,
-					       NUMA_NO_NODE);
+	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
+						   min_addr, max_addr,
+						   NUMA_NO_NODE);
 	rgn_end = rgn->base + rgn->size;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
+	verify_mem_content(allocated_ptr, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, min_addr);
@@ -769,13 +818,13 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
 	min_addr = memblock_start_of_DRAM() + misalign;
 	max_addr = min_addr + SZ_512;
 
-	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
-					       min_addr, max_addr,
-					       NUMA_NO_NODE);
+	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
+						   min_addr, max_addr,
+						   NUMA_NO_NODE);
 	rgn_end = rgn->base + rgn->size;
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
+	verify_mem_content(allocated_ptr, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, min_addr + (SMP_CACHE_BYTES - misalign));
@@ -822,12 +871,12 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
 	min_addr = memblock_start_of_DRAM() + SZ_512;
 	max_addr = min_addr + SMP_CACHE_BYTES;
 
-	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
-					       min_addr, max_addr,
-					       NUMA_NO_NODE);
+	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
+						   min_addr, max_addr,
+						   NUMA_NO_NODE);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
+	verify_mem_content(allocated_ptr, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
@@ -887,12 +936,12 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
 	memblock_reserve(r1.base, r1.size);
 	memblock_reserve(r2.base, r2.size);
 
-	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
-					       min_addr, max_addr,
-					       NUMA_NO_NODE);
+	allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
+						   min_addr, max_addr,
+						   NUMA_NO_NODE);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
+	verify_mem_content(allocated_ptr, r3_size);
 
 	ASSERT_EQ(rgn1->size, r1.size);
 	ASSERT_EQ(rgn1->base, max_addr);
@@ -959,12 +1008,12 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
 	memblock_reserve(r1.base, r1.size);
 	memblock_reserve(r2.base, r2.size);
 
-	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
-					       min_addr, max_addr,
-					       NUMA_NO_NODE);
+	allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
+						   min_addr, max_addr,
+						   NUMA_NO_NODE);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
+	verify_mem_content(allocated_ptr, r3_size);
 
 	ASSERT_EQ(rgn3->size, r3_size);
 	ASSERT_EQ(rgn3->base, memblock_start_of_DRAM());
@@ -1004,12 +1053,12 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
 	min_addr = memblock_start_of_DRAM() + SZ_1K;
 	max_addr = memblock_end_of_DRAM() + SZ_256;
 
-	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
-					       min_addr, max_addr,
-					       NUMA_NO_NODE);
+	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
+						   min_addr, max_addr,
+						   NUMA_NO_NODE);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
+	verify_mem_content(allocated_ptr, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, min_addr);
@@ -1043,12 +1092,12 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
 	min_addr = memblock_start_of_DRAM();
 	max_addr = memblock_end_of_DRAM() - SZ_256;
 
-	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
-					       min_addr, max_addr,
-					       NUMA_NO_NODE);
+	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
+						   min_addr, max_addr,
+						   NUMA_NO_NODE);
 
 	ASSERT_NE(allocated_ptr, NULL);
-	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
+	verify_mem_content(allocated_ptr, size);
 
 	ASSERT_EQ(rgn->size, size);
 	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
@@ -1193,13 +1242,14 @@ static int alloc_try_nid_low_max_check(void)
 	return 0;
 }
 
-int memblock_alloc_nid_checks(void)
+static int memblock_alloc_nid_checks_internal(int flags)
 {
-	const char *func_testing = "memblock_alloc_try_nid";
+	const char *func = get_func_testing(flags);
 
+	alloc_nid_test_flags = flags;
 	prefix_reset();
-	prefix_push(func_testing);
-	test_print("Running %s tests...\n", func_testing);
+	prefix_push(func);
+	test_print("Running %s tests...\n", func);
 
 	reset_memblock_attributes();
 	dummy_physical_memory_init();
@@ -1225,3 +1275,11 @@ int memblock_alloc_nid_checks(void)
 
 	return 0;
 }
+
+int memblock_alloc_nid_checks(void)
+{
+	memblock_alloc_nid_checks_internal(TEST_ZEROED);
+	memblock_alloc_nid_checks_internal(TEST_RAW);
+
+	return 0;
+}
-- 
2.25.1

[PATCH 7/8] memblock tests: add tests for memblock_*bottom_up functions

[Rebecca Mckeever]

Add simple tests for memblock_set_bottom_up() and memblock_bottom_up().

Reviewed-by: David Hildenbrand <david@redhat.com>
Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
---
 tools/testing/memblock/tests/basic_api.c | 45 ++++++++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c
index ef5642d0863b..d7f008e7a12a 100644
--- a/tools/testing/memblock/tests/basic_api.c
+++ b/tools/testing/memblock/tests/basic_api.c
@@ -1679,6 +1679,50 @@ static int memblock_free_checks(void)
 	return 0;
 }
 
+static int memblock_set_bottom_up_check(void)
+{
+	prefix_push("memblock_set_bottom_up");
+
+	memblock_set_bottom_up(false);
+	ASSERT_EQ(memblock.bottom_up, false);
+	memblock_set_bottom_up(true);
+	ASSERT_EQ(memblock.bottom_up, true);
+
+	reset_memblock_attributes();
+	test_pass_pop();
+
+	return 0;
+}
+
+static int memblock_bottom_up_check(void)
+{
+	prefix_push("memblock_bottom_up");
+
+	memblock_set_bottom_up(false);
+	ASSERT_EQ(memblock_bottom_up(), memblock.bottom_up);
+	ASSERT_EQ(memblock_bottom_up(), false);
+	memblock_set_bottom_up(true);
+	ASSERT_EQ(memblock_bottom_up(), memblock.bottom_up);
+	ASSERT_EQ(memblock_bottom_up(), true);
+
+	reset_memblock_attributes();
+	test_pass_pop();
+
+	return 0;
+}
+
+static int memblock_bottom_up_checks(void)
+{
+	test_print("Running memblock_*bottom_up tests...\n");
+
+	prefix_reset();
+	memblock_set_bottom_up_check();
+	prefix_reset();
+	memblock_bottom_up_check();
+
+	return 0;
+}
+
 int memblock_basic_checks(void)
 {
 	memblock_initialization_check();
@@ -1686,6 +1730,7 @@ int memblock_basic_checks(void)
 	memblock_reserve_checks();
 	memblock_remove_checks();
 	memblock_free_checks();
+	memblock_bottom_up_checks();
 
 	return 0;
 }
-- 
2.25.1

[PATCH 8/8] memblock tests: add tests for memblock_trim_memory

[Rebecca Mckeever]

Add tests for memblock_trim_memory() for the following scenarios:
- all regions aligned
- one region unalign that is smaller than the alignment
- one region unaligned at the base
- one region unaligned at the end

Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
---
 tools/testing/memblock/tests/basic_api.c | 223 +++++++++++++++++++++++
 1 file changed, 223 insertions(+)

diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c
index d7f008e7a12a..c8bb44f20846 100644
--- a/tools/testing/memblock/tests/basic_api.c
+++ b/tools/testing/memblock/tests/basic_api.c
@@ -8,6 +8,7 @@
 #define FUNC_RESERVE					"memblock_reserve"
 #define FUNC_REMOVE					"memblock_remove"
 #define FUNC_FREE					"memblock_free"
+#define FUNC_TRIM					"memblock_trim_memory"
 
 static int memblock_initialization_check(void)
 {
@@ -1723,6 +1724,227 @@ static int memblock_bottom_up_checks(void)
 	return 0;
 }
 
+/*
+ * A test that tries to trim memory when both ends of the memory region are
+ * aligned. Expect that the memory will not be trimmed. Expect the counter to
+ * not be updated.
+ */
+static int memblock_trim_memory_aligned_check(void)
+{
+	struct memblock_region *rgn;
+	phys_addr_t alignment = SMP_CACHE_BYTES;
+
+	rgn = &memblock.memory.regions[0];
+
+	struct region r = {
+		.base = alignment,
+		.size = alignment * 4
+	};
+
+	PREFIX_PUSH();
+
+	reset_memblock_regions();
+	memblock_add(r.base, r.size);
+	memblock_trim_memory(alignment);
+
+	ASSERT_EQ(rgn->base, r.base);
+	ASSERT_EQ(rgn->size, r.size);
+
+	ASSERT_EQ(memblock.memory.cnt, 1);
+
+	test_pass_pop();
+
+	return 0;
+}
+
+/*
+ * A test that tries to trim memory when there are two available regions, r1 and
+ * r2. Region r1 is aligned on both ends and region r2 is unaligned on one end
+ * and smaller than the alignment:
+ *
+ *                                     alignment
+ *                                     |--------|
+ * |        +-----------------+        +------+   |
+ * |        |        r1       |        |  r2  |   |
+ * +--------+-----------------+--------+------+---+
+ *          ^        ^        ^        ^      ^
+ *          |________|________|________|      |
+ *                            |               Unaligned address
+ *                Aligned addresses
+ *
+ * Expect that r1 will not be trimmed and r2 will be removed. Expect the
+ * counter to be updated.
+ */
+static int memblock_trim_memory_too_small_check(void)
+{
+	struct memblock_region *rgn;
+	phys_addr_t alignment = SMP_CACHE_BYTES;
+
+	rgn = &memblock.memory.regions[0];
+
+	struct region r1 = {
+		.base = alignment,
+		.size = alignment * 2
+	};
+	struct region r2 = {
+		.base = alignment * 4,
+		.size = alignment - SZ_2
+	};
+
+	PREFIX_PUSH();
+
+	reset_memblock_regions();
+	memblock_add(r1.base, r1.size);
+	memblock_add(r2.base, r2.size);
+	memblock_trim_memory(alignment);
+
+	ASSERT_EQ(rgn->base, r1.base);
+	ASSERT_EQ(rgn->size, r1.size);
+
+	ASSERT_EQ(memblock.memory.cnt, 1);
+
+	test_pass_pop();
+
+	return 0;
+}
+
+/*
+ * A test that tries to trim memory when there are two available regions, r1 and
+ * r2. Region r1 is aligned on both ends and region r2 is unaligned at the base
+ * and aligned at the end:
+ *
+ *                               Unaligned address
+ *                                       |
+ *                                       v
+ * |        +-----------------+          +---------------+   |
+ * |        |        r1       |          |      r2       |   |
+ * +--------+-----------------+----------+---------------+---+
+ *          ^        ^        ^        ^        ^        ^
+ *          |________|________|________|________|________|
+ *                            |
+ *                    Aligned addresses
+ *
+ * Expect that r1 will not be trimmed and r2 will be trimmed at the base.
+ * Expect the counter to not be updated.
+ */
+static int memblock_trim_memory_unaligned_base_check(void)
+{
+	struct memblock_region *rgn1, *rgn2;
+	phys_addr_t alignment = SMP_CACHE_BYTES;
+	phys_addr_t offset = SZ_2;
+	phys_addr_t r2_base, r2_size;
+
+	rgn1 = &memblock.memory.regions[0];
+	rgn2 = &memblock.memory.regions[1];
+
+	struct region r1 = {
+		.base = alignment,
+		.size = alignment * 2
+	};
+	struct region r2 = {
+		.base = alignment * 4 + offset,
+		.size = alignment * 2 - offset
+	};
+
+	PREFIX_PUSH();
+
+	r2_base = r2.base + (alignment - offset);
+	r2_size = r2.size - (alignment - offset);
+
+	reset_memblock_regions();
+	memblock_add(r1.base, r1.size);
+	memblock_add(r2.base, r2.size);
+	memblock_trim_memory(alignment);
+
+	ASSERT_EQ(rgn1->base, r1.base);
+	ASSERT_EQ(rgn1->size, r1.size);
+
+	ASSERT_EQ(rgn2->base, r2_base);
+	ASSERT_EQ(rgn2->size, r2_size);
+
+	ASSERT_EQ(memblock.memory.cnt, 2);
+
+	test_pass_pop();
+
+	return 0;
+}
+
+/*
+ * A test that tries to trim memory when there are two available regions, r1 and
+ * r2. Region r1 is aligned on both ends and region r2 is aligned at the base
+ * and unaligned at the end:
+ *
+ *                                             Unaligned address
+ *                                                     |
+ *                                                     v
+ * |        +-----------------+        +---------------+   |
+ * |        |        r1       |        |      r2       |   |
+ * +--------+-----------------+--------+---------------+---+
+ *          ^        ^        ^        ^        ^        ^
+ *          |________|________|________|________|________|
+ *                            |
+ *                    Aligned addresses
+ *
+ * Expect that r1 will not be trimmed and r2 will be trimmed at the base.
+ * Expect the counter to not be updated.
+ */
+static int memblock_trim_memory_unaligned_end_check(void)
+{
+	struct memblock_region *rgn1, *rgn2;
+	phys_addr_t alignment = SMP_CACHE_BYTES;
+	phys_addr_t offset = SZ_2;
+	phys_addr_t r2_size;
+
+	rgn1 = &memblock.memory.regions[0];
+	rgn2 = &memblock.memory.regions[1];
+
+	struct region r1 = {
+		.base = alignment,
+		.size = alignment * 2
+	};
+	struct region r2 = {
+		.base = alignment * 4,
+		.size = alignment * 2 - offset
+	};
+
+	PREFIX_PUSH();
+
+	r2_size = r2.size - (alignment - offset);
+
+	reset_memblock_regions();
+	memblock_add(r1.base, r1.size);
+	memblock_add(r2.base, r2.size);
+	memblock_trim_memory(alignment);
+
+	ASSERT_EQ(rgn1->base, r1.base);
+	ASSERT_EQ(rgn1->size, r1.size);
+
+	ASSERT_EQ(rgn2->base, r2.base);
+	ASSERT_EQ(rgn2->size, r2_size);
+
+	ASSERT_EQ(memblock.memory.cnt, 2);
+
+	test_pass_pop();
+
+	return 0;
+}
+
+static int memblock_trim_memory_checks(void)
+{
+	prefix_reset();
+	prefix_push(FUNC_TRIM);
+	test_print("Running %s tests...\n", FUNC_TRIM);
+
+	memblock_trim_memory_aligned_check();
+	memblock_trim_memory_too_small_check();
+	memblock_trim_memory_unaligned_base_check();
+	memblock_trim_memory_unaligned_end_check();
+
+	prefix_pop();
+
+	return 0;
+}
+
 int memblock_basic_checks(void)
 {
 	memblock_initialization_check();
@@ -1731,6 +1953,7 @@ int memblock_basic_checks(void)
 	memblock_remove_checks();
 	memblock_free_checks();
 	memblock_bottom_up_checks();
+	memblock_trim_memory_checks();
 
 	return 0;
 }
-- 
2.25.1

Re: [PATCH 1/8] memblock tests: update tests to check if memblock_alloc zeroed memory

[Huang, Shaoqin]

Hi, Rebecca.

On 8/14/2022 1:53 PM, Rebecca Mckeever wrote:
> 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().
> 
> Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> ---
>   tools/testing/memblock/tests/alloc_api.c | 24 ++++++++++++++++++++++++
>   tools/testing/memblock/tests/common.c    |  7 +++++++
>   tools/testing/memblock/tests/common.h    | 13 +++++++++++++
>   3 files changed, 44 insertions(+)
> 
> diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
> index a14f38eb8a89..71c89cb9b2a8 100644
> --- a/tools/testing/memblock/tests/alloc_api.c
> +++ b/tools/testing/memblock/tests/alloc_api.c
> @@ -22,6 +22,8 @@ static int alloc_top_down_simple_check(void)
>   	allocated_ptr = memblock_alloc(size, SMP_CACHE_BYTES);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
> +
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, expected_start);
>   
> @@ -80,6 +82,8 @@ static int alloc_top_down_disjoint_check(void)
>   	allocated_ptr = memblock_alloc(r2_size, alignment);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
> +
>   	ASSERT_EQ(rgn1->size, r1.size);
>   	ASSERT_EQ(rgn1->base, r1.base);
>   
> @@ -125,6 +129,8 @@ static int alloc_top_down_before_check(void)
>   	allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
> +
>   	ASSERT_EQ(rgn->size, total_size);
>   	ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - total_size);
>   
> @@ -173,6 +179,8 @@ static int alloc_top_down_after_check(void)
>   	allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
> +
>   	ASSERT_EQ(rgn->size, total_size);
>   	ASSERT_EQ(rgn->base, r1.base - r2_size);
>   
> @@ -223,6 +231,8 @@ static int alloc_top_down_second_fit_check(void)
>   	allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
> +
>   	ASSERT_EQ(rgn->size, r2.size + r3_size);
>   	ASSERT_EQ(rgn->base, r2.base - r3_size);
>   
> @@ -277,6 +287,8 @@ static int alloc_in_between_generic_check(void)
>   	allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
> +
>   	ASSERT_EQ(rgn->size, total_size);
>   	ASSERT_EQ(rgn->base, r1.base - r2.size - r3_size);
>   
> @@ -418,6 +430,8 @@ static int alloc_limited_space_generic_check(void)
>   	allocated_ptr = memblock_alloc(available_size, SMP_CACHE_BYTES);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, available_size);
> +
>   	ASSERT_EQ(rgn->size, MEM_SIZE);
>   	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
>   
> @@ -442,6 +456,7 @@ static int alloc_no_memory_generic_check(void)
>   	PREFIX_PUSH();
>   
>   	reset_memblock_regions();
> +	fill_memblock();

Maybe we don't need this line, it has no effect at here. Anyway, Others 
Looks Good to me.

Reviewed-by: Shaoqin Huang <shaoqin.huang@intel.com>

>   
>   	allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
>   
> @@ -472,6 +487,8 @@ static int alloc_bottom_up_simple_check(void)
>   	allocated_ptr = memblock_alloc(SZ_2, SMP_CACHE_BYTES);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, SZ_2);
> +
>   	ASSERT_EQ(rgn->size, SZ_2);
>   	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
>   
> @@ -528,6 +545,7 @@ static int alloc_bottom_up_disjoint_check(void)
>   	allocated_ptr = memblock_alloc(r2_size, alignment);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
>   
>   	ASSERT_EQ(rgn1->size, r1.size);
>   	ASSERT_EQ(rgn1->base, r1.base);
> @@ -571,6 +589,8 @@ static int alloc_bottom_up_before_check(void)
>   	allocated_ptr = memblock_alloc(r1_size, SMP_CACHE_BYTES);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r1_size);
> +
>   	ASSERT_EQ(rgn->size, total_size);
>   	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
>   
> @@ -618,6 +638,8 @@ static int alloc_bottom_up_after_check(void)
>   	allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
> +
>   	ASSERT_EQ(rgn->size, total_size);
>   	ASSERT_EQ(rgn->base, r1.base);
>   
> @@ -669,6 +691,8 @@ static int alloc_bottom_up_second_fit_check(void)
>   	allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
> +
>   	ASSERT_EQ(rgn->size, r2.size + r3_size);
>   	ASSERT_EQ(rgn->base, r2.base);
>   
> diff --git a/tools/testing/memblock/tests/common.c b/tools/testing/memblock/tests/common.c
> index 76a8ad818f3a..0ca26fe12c38 100644
> --- a/tools/testing/memblock/tests/common.c
> +++ b/tools/testing/memblock/tests/common.c
> @@ -60,16 +60,23 @@ void reset_memblock_attributes(void)
>   	memblock.current_limit	= MEMBLOCK_ALLOC_ANYWHERE;
>   }
>   
> +void fill_memblock(void)
> +{
> +	memset(memory_block.base, 1, MEM_SIZE);
> +}
> +
>   void setup_memblock(void)
>   {
>   	reset_memblock_regions();
>   	memblock_add((phys_addr_t)memory_block.base, MEM_SIZE);
> +	fill_memblock();
>   }
>   
>   void dummy_physical_memory_init(void)
>   {
>   	memory_block.base = malloc(MEM_SIZE);
>   	assert(memory_block.base);
> +	fill_memblock();
>   }
>   
>   void dummy_physical_memory_cleanup(void)
> diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h
> index d396e5423a8e..7a16a7dc8f2c 100644
> --- a/tools/testing/memblock/tests/common.h
> +++ b/tools/testing/memblock/tests/common.h
> @@ -51,6 +51,18 @@
>   	assert((_expected) < (_seen)); \
>   } while (0)
>   
> +/**
> + * ASSERT_MEM_EQ():
> + * Check that the first @_size bytes of @_seen are all equal to @_expected.
> + * If false, print failed test message (if running with --verbose) and then
> + * assert.
> + */
> +#define ASSERT_MEM_EQ(_seen, _expected, _size) do { \
> +	for (int _i = 0; _i < (_size); _i++) { \
> +		ASSERT_EQ((_seen)[_i], (_expected)); \
> +	} \
> +} while (0)
> +
>   #define PREFIX_PUSH() prefix_push(__func__)
>   
>   /*
> @@ -70,6 +82,7 @@ struct region {
>   
>   void reset_memblock_regions(void);
>   void reset_memblock_attributes(void);
> +void fill_memblock(void);
>   void setup_memblock(void);
>   void dummy_physical_memory_init(void);
>   void dummy_physical_memory_cleanup(void);

Re: [PATCH 2/8] memblock tests: update zeroed memory check for memblock_alloc_* tests

[Huang, Shaoqin]

LGTM.

Reviewed-by: Shaoqin Huang <shaoqin.huang@intel.com>

On 8/14/2022 1:53 PM, Rebecca Mckeever wrote:
> 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>
> Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> ---
>   .../memblock/tests/alloc_helpers_api.c        |  8 +--
>   tools/testing/memblock/tests/alloc_nid_api.c  | 72 +++++--------------
>   2 files changed, 20 insertions(+), 60 deletions(-)
> 
> diff --git a/tools/testing/memblock/tests/alloc_helpers_api.c b/tools/testing/memblock/tests/alloc_helpers_api.c
> index 1069b4bdd5fd..796527cf3bd2 100644
> --- a/tools/testing/memblock/tests/alloc_helpers_api.c
> +++ b/tools/testing/memblock/tests/alloc_helpers_api.c
> @@ -19,7 +19,6 @@ static int alloc_from_simple_generic_check(void)
>   {
>   	struct memblock_region *rgn = &memblock.reserved.regions[0];
>   	void *allocated_ptr = NULL;
> -	char *b;
>   
>   	PREFIX_PUSH();
>   
> @@ -31,10 +30,9 @@ static int alloc_from_simple_generic_check(void)
>   	min_addr = memblock_end_of_DRAM() - SMP_CACHE_BYTES;
>   
>   	allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
> -	b = (char *)allocated_ptr;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_EQ(*b, 0);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, min_addr);
> @@ -66,7 +64,6 @@ static int alloc_from_misaligned_generic_check(void)
>   {
>   	struct memblock_region *rgn = &memblock.reserved.regions[0];
>   	void *allocated_ptr = NULL;
> -	char *b;
>   
>   	PREFIX_PUSH();
>   
> @@ -79,10 +76,9 @@ static int alloc_from_misaligned_generic_check(void)
>   	min_addr = memblock_end_of_DRAM() - (SMP_CACHE_BYTES * 2 - 1);
>   
>   	allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
> -	b = (char *)allocated_ptr;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_EQ(*b, 0);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - SMP_CACHE_BYTES);
> diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
> index 255fd514e9f5..71b7beb35526 100644
> --- a/tools/testing/memblock/tests/alloc_nid_api.c
> +++ b/tools/testing/memblock/tests/alloc_nid_api.c
> @@ -19,7 +19,6 @@ static int alloc_try_nid_top_down_simple_check(void)
>   {
>   	struct memblock_region *rgn = &memblock.reserved.regions[0];
>   	void *allocated_ptr = NULL;
> -	char *b;
>   
>   	PREFIX_PUSH();
>   
> @@ -35,11 +34,10 @@ static int alloc_try_nid_top_down_simple_check(void)
>   
>   	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
>   					       min_addr, max_addr, NUMA_NO_NODE);
> -	b = (char *)allocated_ptr;
>   	rgn_end = rgn->base + rgn->size;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_EQ(*b, 0);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, max_addr - size);
> @@ -74,7 +72,6 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
>   {
>   	struct memblock_region *rgn = &memblock.reserved.regions[0];
>   	void *allocated_ptr = NULL;
> -	char *b;
>   
>   	PREFIX_PUSH();
>   
> @@ -91,11 +88,10 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
>   
>   	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
>   					       min_addr, max_addr, NUMA_NO_NODE);
> -	b = (char *)allocated_ptr;
>   	rgn_end = rgn->base + rgn->size;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_EQ(*b, 0);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, max_addr - size - misalign);
> @@ -128,7 +124,6 @@ static int alloc_try_nid_exact_address_generic_check(void)
>   {
>   	struct memblock_region *rgn = &memblock.reserved.regions[0];
>   	void *allocated_ptr = NULL;
> -	char *b;
>   
>   	PREFIX_PUSH();
>   
> @@ -144,11 +139,10 @@ static int alloc_try_nid_exact_address_generic_check(void)
>   
>   	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
>   					       min_addr, max_addr, NUMA_NO_NODE);
> -	b = (char *)allocated_ptr;
>   	rgn_end = rgn->base + rgn->size;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_EQ(*b, 0);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, min_addr);
> @@ -183,7 +177,6 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
>   {
>   	struct memblock_region *rgn = &memblock.reserved.regions[0];
>   	void *allocated_ptr = NULL;
> -	char *b;
>   
>   	PREFIX_PUSH();
>   
> @@ -198,10 +191,9 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
>   
>   	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
>   					       min_addr, max_addr, NUMA_NO_NODE);
> -	b = (char *)allocated_ptr;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_EQ(*b, 0);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, max_addr - size);
> @@ -277,7 +269,6 @@ static int alloc_try_nid_min_reserved_generic_check(void)
>   {
>   	struct memblock_region *rgn = &memblock.reserved.regions[0];
>   	void *allocated_ptr = NULL;
> -	char *b;
>   
>   	PREFIX_PUSH();
>   
> @@ -298,10 +289,9 @@ static int alloc_try_nid_min_reserved_generic_check(void)
>   
>   	allocated_ptr = memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES,
>   					       min_addr, max_addr, NUMA_NO_NODE);
> -	b = (char *)allocated_ptr;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_EQ(*b, 0);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
>   
>   	ASSERT_EQ(rgn->size, total_size);
>   	ASSERT_EQ(rgn->base, reserved_base);
> @@ -332,7 +322,6 @@ static int alloc_try_nid_max_reserved_generic_check(void)
>   {
>   	struct memblock_region *rgn = &memblock.reserved.regions[0];
>   	void *allocated_ptr = NULL;
> -	char *b;
>   
>   	PREFIX_PUSH();
>   
> @@ -351,10 +340,9 @@ static int alloc_try_nid_max_reserved_generic_check(void)
>   
>   	allocated_ptr = memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES,
>   					       min_addr, max_addr, NUMA_NO_NODE);
> -	b = (char *)allocated_ptr;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_EQ(*b, 0);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
>   
>   	ASSERT_EQ(rgn->size, total_size);
>   	ASSERT_EQ(rgn->base, min_addr);
> @@ -389,7 +377,6 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
>   	struct memblock_region *rgn1 = &memblock.reserved.regions[1];
>   	struct memblock_region *rgn2 = &memblock.reserved.regions[0];
>   	void *allocated_ptr = NULL;
> -	char *b;
>   	struct region r1, r2;
>   
>   	PREFIX_PUSH();
> @@ -417,10 +404,9 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
>   
>   	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
>   					       min_addr, max_addr, NUMA_NO_NODE);
> -	b = (char *)allocated_ptr;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_EQ(*b, 0);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
>   
>   	ASSERT_EQ(rgn1->size, r1.size + r3_size);
>   	ASSERT_EQ(rgn1->base, max_addr - r3_size);
> @@ -456,7 +442,6 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
>   {
>   	struct memblock_region *rgn = &memblock.reserved.regions[0];
>   	void *allocated_ptr = NULL;
> -	char *b;
>   	struct region r1, r2;
>   
>   	PREFIX_PUSH();
> @@ -483,10 +468,9 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
>   
>   	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
>   					       min_addr, max_addr, NUMA_NO_NODE);
> -	b = (char *)allocated_ptr;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_EQ(*b, 0);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
>   
>   	ASSERT_EQ(rgn->size, total_size);
>   	ASSERT_EQ(rgn->base, r2.base);
> @@ -522,7 +506,6 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
>   	struct memblock_region *rgn1 = &memblock.reserved.regions[1];
>   	struct memblock_region *rgn2 = &memblock.reserved.regions[0];
>   	void *allocated_ptr = NULL;
> -	char *b;
>   	struct region r1, r2;
>   
>   	PREFIX_PUSH();
> @@ -550,10 +533,9 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
>   
>   	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
>   					       min_addr, max_addr, NUMA_NO_NODE);
> -	b = (char *)allocated_ptr;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_EQ(*b, 0);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
>   
>   	ASSERT_EQ(rgn1->size, r1.size);
>   	ASSERT_EQ(rgn1->base, r1.base);
> @@ -634,7 +616,6 @@ static int alloc_try_nid_top_down_cap_max_check(void)
>   {
>   	struct memblock_region *rgn = &memblock.reserved.regions[0];
>   	void *allocated_ptr = NULL;
> -	char *b;
>   
>   	PREFIX_PUSH();
>   
> @@ -649,10 +630,9 @@ static int alloc_try_nid_top_down_cap_max_check(void)
>   
>   	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
>   					       min_addr, max_addr, NUMA_NO_NODE);
> -	b = (char *)allocated_ptr;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_EQ(*b, 0);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
> @@ -674,7 +654,6 @@ static int alloc_try_nid_top_down_cap_min_check(void)
>   {
>   	struct memblock_region *rgn = &memblock.reserved.regions[0];
>   	void *allocated_ptr = NULL;
> -	char *b;
>   
>   	PREFIX_PUSH();
>   
> @@ -689,10 +668,9 @@ static int alloc_try_nid_top_down_cap_min_check(void)
>   
>   	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
>   					       min_addr, max_addr, NUMA_NO_NODE);
> -	b = (char *)allocated_ptr;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_EQ(*b, 0);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
> @@ -723,7 +701,6 @@ static int alloc_try_nid_bottom_up_simple_check(void)
>   {
>   	struct memblock_region *rgn = &memblock.reserved.regions[0];
>   	void *allocated_ptr = NULL;
> -	char *b;
>   
>   	PREFIX_PUSH();
>   
> @@ -740,11 +717,10 @@ static int alloc_try_nid_bottom_up_simple_check(void)
>   	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
>   					       min_addr, max_addr,
>   					       NUMA_NO_NODE);
> -	b = (char *)allocated_ptr;
>   	rgn_end = rgn->base + rgn->size;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_EQ(*b, 0);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, min_addr);
> @@ -779,7 +755,6 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
>   {
>   	struct memblock_region *rgn = &memblock.reserved.regions[0];
>   	void *allocated_ptr = NULL;
> -	char *b;
>   
>   	PREFIX_PUSH();
>   
> @@ -797,11 +772,10 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
>   	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
>   					       min_addr, max_addr,
>   					       NUMA_NO_NODE);
> -	b = (char *)allocated_ptr;
>   	rgn_end = rgn->base + rgn->size;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_EQ(*b, 0);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, min_addr + (SMP_CACHE_BYTES - misalign));
> @@ -836,7 +810,6 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
>   {
>   	struct memblock_region *rgn = &memblock.reserved.regions[0];
>   	void *allocated_ptr = NULL;
> -	char *b;
>   
>   	PREFIX_PUSH();
>   
> @@ -852,10 +825,9 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
>   	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
>   					       min_addr, max_addr,
>   					       NUMA_NO_NODE);
> -	b = (char *)allocated_ptr;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_EQ(*b, 0);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> @@ -890,7 +862,6 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
>   	struct memblock_region *rgn1 = &memblock.reserved.regions[1];
>   	struct memblock_region *rgn2 = &memblock.reserved.regions[0];
>   	void *allocated_ptr = NULL;
> -	char *b;
>   	struct region r1, r2;
>   
>   	PREFIX_PUSH();
> @@ -919,10 +890,9 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
>   	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
>   					       min_addr, max_addr,
>   					       NUMA_NO_NODE);
> -	b = (char *)allocated_ptr;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_EQ(*b, 0);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
>   
>   	ASSERT_EQ(rgn1->size, r1.size);
>   	ASSERT_EQ(rgn1->base, max_addr);
> @@ -964,7 +934,6 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
>   	struct memblock_region *rgn2 = &memblock.reserved.regions[1];
>   	struct memblock_region *rgn3 = &memblock.reserved.regions[0];
>   	void *allocated_ptr = NULL;
> -	char *b;
>   	struct region r1, r2;
>   
>   	PREFIX_PUSH();
> @@ -993,10 +962,9 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
>   	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
>   					       min_addr, max_addr,
>   					       NUMA_NO_NODE);
> -	b = (char *)allocated_ptr;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_EQ(*b, 0);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
>   
>   	ASSERT_EQ(rgn3->size, r3_size);
>   	ASSERT_EQ(rgn3->base, memblock_start_of_DRAM());
> @@ -1024,7 +992,6 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
>   {
>   	struct memblock_region *rgn = &memblock.reserved.regions[0];
>   	void *allocated_ptr = NULL;
> -	char *b;
>   
>   	PREFIX_PUSH();
>   
> @@ -1040,10 +1007,9 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
>   	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
>   					       min_addr, max_addr,
>   					       NUMA_NO_NODE);
> -	b = (char *)allocated_ptr;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_EQ(*b, 0);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, min_addr);
> @@ -1065,7 +1031,6 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
>   {
>   	struct memblock_region *rgn = &memblock.reserved.regions[0];
>   	void *allocated_ptr = NULL;
> -	char *b;
>   
>   	PREFIX_PUSH();
>   
> @@ -1081,10 +1046,9 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
>   	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
>   					       min_addr, max_addr,
>   					       NUMA_NO_NODE);
> -	b = (char *)allocated_ptr;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_EQ(*b, 0);
> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());

Re: [PATCH 3/8] memblock tests: add labels to verbose output for generic alloc tests

[Huang, Shaoqin]

I found original some of test function has the prefix `top_down` and 
`bottom_up`, and some of test function didn't have the prefix.

In this patch, it just modified these functions which didn't have the 
prefix `top_down` or `bottom_up`, and now there are two style about 
these test functions in the code.

One is:
	run_top_down(alloc_in_between_generic_check);
	run_bottom_up(alloc_in_between_generic_check);

Another one is:
	memblock_set_bottom_up(false);
	alloc_top_down_before_check();
	memblock_set_bottom_up(true);
	alloc_bottom_up_before_check();

Thus there gonna be two output style, here is an example:
ok 89 : memblock_alloc_from: top-down: alloc_from_simple_generic_check: 
passed
ok 90 : memblock_alloc_from: bottom-up: alloc_from_simple_generic_check: 
passed

ok 99 : memblock_alloc_try_nid: alloc_try_nid_top_down_simple_check: passed
ok 100 : memblock_alloc_try_nid: alloc_try_nid_bottom_up_simple_check: 
passed

It may make confuse if one is printed between the colon and one is 
inside the function name.

So maybe make the style consistent is more make sense. And I think this 
can be done by modify all these function name which with `top_down` and 
`bottom_up` inside, and replace them with your new run_top_down() and 
run_bottom_up() functions.

On 8/14/2022 1:53 PM, Rebecca Mckeever wrote:
> Generic tests for memblock_alloc*() functions do not use separate
> functions for testing top-down and bottom-up allocation directions.
> Therefore, the function name that is displayed in the verbose testing
> output does not include the allocation direction.
> 
> Add an additional prefix when running generic tests for
> memblock_alloc*() functions that indicates which allocation direction is
> set. The prefix will be displayed when the tests are run in verbose mode.
> 
> Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> ---
>   tools/testing/memblock/tests/alloc_api.c      | 36 +++++++------------
>   .../memblock/tests/alloc_helpers_api.c        | 12 +++----
>   tools/testing/memblock/tests/alloc_nid_api.c  | 36 +++++++------------
>   tools/testing/memblock/tests/common.h         | 16 +++++++++
>   4 files changed, 44 insertions(+), 56 deletions(-)
> 
> diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
> index 71c89cb9b2a8..73c2c43e702a 100644
> --- a/tools/testing/memblock/tests/alloc_api.c
> +++ b/tools/testing/memblock/tests/alloc_api.c
> @@ -752,10 +752,8 @@ static int alloc_after_check(void)
>   static int alloc_in_between_check(void)
>   {
>   	test_print("\tRunning %s...\n", __func__);
> -	memblock_set_bottom_up(false);
> -	alloc_in_between_generic_check();
> -	memblock_set_bottom_up(true);
> -	alloc_in_between_generic_check();
> +	run_top_down(alloc_in_between_generic_check);
> +	run_bottom_up(alloc_in_between_generic_check);
>   
>   	return 0;
>   }
> @@ -774,10 +772,8 @@ static int alloc_second_fit_check(void)
>   static int alloc_small_gaps_check(void)
>   {
>   	test_print("\tRunning %s...\n", __func__);
> -	memblock_set_bottom_up(false);
> -	alloc_small_gaps_generic_check();
> -	memblock_set_bottom_up(true);
> -	alloc_small_gaps_generic_check();
> +	run_top_down(alloc_small_gaps_generic_check);
> +	run_bottom_up(alloc_small_gaps_generic_check);
>   
>   	return 0;
>   }
> @@ -785,10 +781,8 @@ static int alloc_small_gaps_check(void)
>   static int alloc_all_reserved_check(void)
>   {
>   	test_print("\tRunning %s...\n", __func__);
> -	memblock_set_bottom_up(false);
> -	alloc_all_reserved_generic_check();
> -	memblock_set_bottom_up(true);
> -	alloc_all_reserved_generic_check();
> +	run_top_down(alloc_all_reserved_generic_check);
> +	run_bottom_up(alloc_all_reserved_generic_check);
>   
>   	return 0;
>   }
> @@ -796,10 +790,8 @@ static int alloc_all_reserved_check(void)
>   static int alloc_no_space_check(void)
>   {
>   	test_print("\tRunning %s...\n", __func__);
> -	memblock_set_bottom_up(false);
> -	alloc_no_space_generic_check();
> -	memblock_set_bottom_up(true);
> -	alloc_no_space_generic_check();
> +	run_top_down(alloc_no_space_generic_check);
> +	run_bottom_up(alloc_no_space_generic_check);
>   
>   	return 0;
>   }
> @@ -807,10 +799,8 @@ static int alloc_no_space_check(void)
>   static int alloc_limited_space_check(void)
>   {
>   	test_print("\tRunning %s...\n", __func__);
> -	memblock_set_bottom_up(false);
> -	alloc_limited_space_generic_check();
> -	memblock_set_bottom_up(true);
> -	alloc_limited_space_generic_check();
> +	run_top_down(alloc_limited_space_generic_check);
> +	run_bottom_up(alloc_limited_space_generic_check);
>   
>   	return 0;
>   }
> @@ -818,10 +808,8 @@ static int alloc_limited_space_check(void)
>   static int alloc_no_memory_check(void)
>   {
>   	test_print("\tRunning %s...\n", __func__);
> -	memblock_set_bottom_up(false);
> -	alloc_no_memory_generic_check();
> -	memblock_set_bottom_up(true);
> -	alloc_no_memory_generic_check();
> +	run_top_down(alloc_no_memory_generic_check);
> +	run_bottom_up(alloc_no_memory_generic_check);
>   
>   	return 0;
>   }
> diff --git a/tools/testing/memblock/tests/alloc_helpers_api.c b/tools/testing/memblock/tests/alloc_helpers_api.c
> index 796527cf3bd2..1ccf02639ad6 100644
> --- a/tools/testing/memblock/tests/alloc_helpers_api.c
> +++ b/tools/testing/memblock/tests/alloc_helpers_api.c
> @@ -357,10 +357,8 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
>   static int alloc_from_simple_check(void)
>   {
>   	test_print("\tRunning %s...\n", __func__);
> -	memblock_set_bottom_up(false);
> -	alloc_from_simple_generic_check();
> -	memblock_set_bottom_up(true);
> -	alloc_from_simple_generic_check();
> +	run_top_down(alloc_from_simple_generic_check);
> +	run_bottom_up(alloc_from_simple_generic_check);
>   
>   	return 0;
>   }
> @@ -368,10 +366,8 @@ static int alloc_from_simple_check(void)
>   static int alloc_from_misaligned_check(void)
>   {
>   	test_print("\tRunning %s...\n", __func__);
> -	memblock_set_bottom_up(false);
> -	alloc_from_misaligned_generic_check();
> -	memblock_set_bottom_up(true);
> -	alloc_from_misaligned_generic_check();
> +	run_top_down(alloc_from_misaligned_generic_check);
> +	run_bottom_up(alloc_from_misaligned_generic_check);
>   
>   	return 0;
>   }
> diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
> index 71b7beb35526..82fa8ea36320 100644
> --- a/tools/testing/memblock/tests/alloc_nid_api.c
> +++ b/tools/testing/memblock/tests/alloc_nid_api.c
> @@ -1142,10 +1142,8 @@ static int alloc_try_nid_cap_min_check(void)
>   static int alloc_try_nid_min_reserved_check(void)
>   {
>   	test_print("\tRunning %s...\n", __func__);
> -	memblock_set_bottom_up(false);
> -	alloc_try_nid_min_reserved_generic_check();
> -	memblock_set_bottom_up(true);
> -	alloc_try_nid_min_reserved_generic_check();
> +	run_top_down(alloc_try_nid_min_reserved_generic_check);
> +	run_bottom_up(alloc_try_nid_min_reserved_generic_check);
>   
>   	return 0;
>   }
> @@ -1153,10 +1151,8 @@ static int alloc_try_nid_min_reserved_check(void)
>   static int alloc_try_nid_max_reserved_check(void)
>   {
>   	test_print("\tRunning %s...\n", __func__);
> -	memblock_set_bottom_up(false);
> -	alloc_try_nid_max_reserved_generic_check();
> -	memblock_set_bottom_up(true);
> -	alloc_try_nid_max_reserved_generic_check();
> +	run_top_down(alloc_try_nid_max_reserved_generic_check);
> +	run_bottom_up(alloc_try_nid_max_reserved_generic_check);
>   
>   	return 0;
>   }
> @@ -1164,10 +1160,8 @@ static int alloc_try_nid_max_reserved_check(void)
>   static int alloc_try_nid_exact_address_check(void)
>   {
>   	test_print("\tRunning %s...\n", __func__);
> -	memblock_set_bottom_up(false);
> -	alloc_try_nid_exact_address_generic_check();
> -	memblock_set_bottom_up(true);
> -	alloc_try_nid_exact_address_generic_check();
> +	run_top_down(alloc_try_nid_exact_address_generic_check);
> +	run_bottom_up(alloc_try_nid_exact_address_generic_check);
>   
>   	return 0;
>   }
> @@ -1175,10 +1169,8 @@ static int alloc_try_nid_exact_address_check(void)
>   static int alloc_try_nid_reserved_full_merge_check(void)
>   {
>   	test_print("\tRunning %s...\n", __func__);
> -	memblock_set_bottom_up(false);
> -	alloc_try_nid_reserved_full_merge_generic_check();
> -	memblock_set_bottom_up(true);
> -	alloc_try_nid_reserved_full_merge_generic_check();
> +	run_top_down(alloc_try_nid_reserved_full_merge_generic_check);
> +	run_bottom_up(alloc_try_nid_reserved_full_merge_generic_check);
>   
>   	return 0;
>   }
> @@ -1186,10 +1178,8 @@ static int alloc_try_nid_reserved_full_merge_check(void)
>   static int alloc_try_nid_reserved_all_check(void)
>   {
>   	test_print("\tRunning %s...\n", __func__);
> -	memblock_set_bottom_up(false);
> -	alloc_try_nid_reserved_all_generic_check();
> -	memblock_set_bottom_up(true);
> -	alloc_try_nid_reserved_all_generic_check();
> +	run_top_down(alloc_try_nid_reserved_all_generic_check);
> +	run_bottom_up(alloc_try_nid_reserved_all_generic_check);
>   
>   	return 0;
>   }
> @@ -1197,10 +1187,8 @@ static int alloc_try_nid_reserved_all_check(void)
>   static int alloc_try_nid_low_max_check(void)
>   {
>   	test_print("\tRunning %s...\n", __func__);
> -	memblock_set_bottom_up(false);
> -	alloc_try_nid_low_max_generic_check();
> -	memblock_set_bottom_up(true);
> -	alloc_try_nid_low_max_generic_check();
> +	run_top_down(alloc_try_nid_low_max_generic_check);
> +	run_bottom_up(alloc_try_nid_low_max_generic_check);
>   
>   	return 0;
>   }
> diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h
> index 7a16a7dc8f2c..e0dd5b410099 100644
> --- a/tools/testing/memblock/tests/common.h
> +++ b/tools/testing/memblock/tests/common.h
> @@ -101,4 +101,20 @@ static inline void test_pass_pop(void)
>   	prefix_pop();
>   }
>   
> +static inline void run_top_down(int (*func)())
> +{
> +	memblock_set_bottom_up(false);
> +	prefix_push("top-down");
> +	func();
> +	prefix_pop();
> +}
> +
> +static inline void run_bottom_up(int (*func)())
> +{
> +	memblock_set_bottom_up(true);
> +	prefix_push("bottom-up");
> +	func();
> +	prefix_pop();
> +}
> +
>   #endif

Re: [PATCH 4/8] memblock tests: add additional tests for basic api and memblock_alloc

[Huang, Shaoqin]

Hi, Rebecca.

On 8/14/2022 1:53 PM, Rebecca Mckeever wrote:
> Add tests for memblock_add(), memblock_reserve(), memblock_remove(),
> memblock_free(), and memblock_alloc() for the following test scenarios.
> 
> memblock_add() and memblock_reserve():
> - add/reserve a memory block in the gap between two existing memory
>    blocks, and check that the blocks are merged into one region
> - try to add/reserve memblock regions that extend past PHYS_ADDR_MAX
> 
> memblock_remove() and memblock_free():
> - remove/free a region when it is the only available region
>      + These tests ensure that the first region is overwritten with a
>        "dummy" region when the last remaining region of that type is
>        removed or freed.
> - remove/free() a region that overlaps with two existing regions of the
>    relevant type
> - try to remove/free memblock regions that extend past PHYS_ADDR_MAX
> 
> memblock_alloc():
> - try to allocate a region that is larger than the total size of available
>    memory (memblock.memory)
> 
> Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> ---
>   tools/testing/memblock/tests/alloc_api.c |  44 ++
>   tools/testing/memblock/tests/basic_api.c | 499 +++++++++++++++++++++++
>   2 files changed, 543 insertions(+)
> 
> diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
> index 73c2c43e702a..fe1ee3b2e851 100644
> --- a/tools/testing/memblock/tests/alloc_api.c
> +++ b/tools/testing/memblock/tests/alloc_api.c
> @@ -470,6 +470,40 @@ static int alloc_no_memory_generic_check(void)
>   	return 0;
>   }
>   
> +/*
> + * A test that tries to allocate a region that is larger than the total size of
> + * available memory (memblock.memory):
> + *
> + *  +-----------------------------------+
> + *  |                 new               |
> + *  +-----------------------------------+
> + *  |                                 |
> + *  |                                 |
> + *  +---------------------------------+
> + *
> + * Expect no allocation to happen.
> + */
> +static int alloc_too_large_generic_check(void)
> +{
> +	struct memblock_region *rgn = &memblock.reserved.regions[0];
> +	void *allocated_ptr = NULL;
> +
> +	PREFIX_PUSH();
> +
> +	setup_memblock();
> +
> +	allocated_ptr = memblock_alloc(MEM_SIZE + SZ_2, SMP_CACHE_BYTES);
> +
> +	ASSERT_EQ(allocated_ptr, NULL);
> +	ASSERT_EQ(rgn->size, 0);
> +	ASSERT_EQ(rgn->base, 0);
> +	ASSERT_EQ(memblock.reserved.total_size, 0);
> +
> +	test_pass_pop();
> +
> +	return 0;
> +}
> +
>   /*
>    * A simple test that tries to allocate a small memory region.
>    * Expect to allocate an aligned region at the beginning of the available
> @@ -814,6 +848,15 @@ static int alloc_no_memory_check(void)
>   	return 0;
>   }
>   
> +static int alloc_too_large_check(void)
> +{
> +	test_print("\tRunning %s...\n", __func__);
> +	run_top_down(alloc_too_large_generic_check);
> +	run_bottom_up(alloc_too_large_generic_check);
> +
> +	return 0;
> +}
> +
>   int memblock_alloc_checks(void)
>   {
>   	const char *func_testing = "memblock_alloc";
> @@ -836,6 +879,7 @@ int memblock_alloc_checks(void)
>   	alloc_no_space_check();
>   	alloc_limited_space_check();
>   	alloc_no_memory_check();
> +	alloc_too_large_check();
>   
>   	dummy_physical_memory_cleanup();
>   
> diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c
> index 66f46f261e66..ef5642d0863b 100644
> --- a/tools/testing/memblock/tests/basic_api.c
> +++ b/tools/testing/memblock/tests/basic_api.c
> @@ -326,6 +326,102 @@ static int memblock_add_twice_check(void)
>   	return 0;
>   }
>   
> +/*
> + * A test that tries to add two memory blocks that don't overlap with one
> + * another and then add a third memory block in the space between the first two:
> + *
> + *  |        +--------+--------+--------+  |
> + *  |        |   r1   |   r3   |   r2   |  |
> + *  +--------+--------+--------+--------+--+
> + *
> + * Expect to merge the three entries into one region that starts at r1.base
> + * and has size of r1.size + r2.size + r3.size. The region counter and total
> + * size of the available memory are updated.
> + */
> +static int memblock_add_between_check(void)
> +{
> +	struct memblock_region *rgn;
> +	phys_addr_t total_size;
> +
> +	rgn = &memblock.memory.regions[0];
> +
> +	struct region r1 = {
> +		.base = SZ_1G,
> +		.size = SZ_8K
> +	};
> +	struct region r2 = {
> +		.base = SZ_1G + SZ_16K,
> +		.size = SZ_8K
> +	};
> +	struct region r3 = {
> +		.base = SZ_1G + SZ_8K,
> +		.size = SZ_8K
> +	};
> +
> +	PREFIX_PUSH();
> +
> +	total_size = r1.size + r2.size + r3.size;
> +
> +	reset_memblock_regions();
> +	memblock_add(r1.base, r1.size);
> +	memblock_add(r2.base, r2.size);
> +	memblock_add(r3.base, r3.size);
> +
> +	ASSERT_EQ(rgn->base, r1.base);
> +	ASSERT_EQ(rgn->size, total_size);
> +
> +	ASSERT_EQ(memblock.memory.cnt, 1);
> +	ASSERT_EQ(memblock.memory.total_size, total_size);
> +
> +	test_pass_pop();
> +
> +	return 0;
> +}
> +
> +/*
> + * A simple test that tries to add a memory block r when r extends past
> + * PHYS_ADDR_MAX:
> + *
> + *                               +--------+
> + *                               |    r   |
> + *                               +--------+
> + *  |                            +----+
> + *  |                            | rgn|
> + *  +----------------------------+----+
> + *
> + * Expect to add a memory block of size PHYS_ADDR_MAX - r.base. Expect the
> + * total size of available memory and the counter to be updated.
> + */
> +static int memblock_add_near_max_check(void)
> +{
> +	struct memblock_region *rgn;
> +	phys_addr_t total_size;
> +
> +	rgn = &memblock.memory.regions[0];
> +
> +	struct region r = {
> +		.base = PHYS_ADDR_MAX - SZ_1M,
> +		.size = SZ_2M
> +	};
> +
> +	PREFIX_PUSH();
> +
> +	total_size = PHYS_ADDR_MAX - r.base;
> +
> +	reset_memblock_regions();
> +	memblock_add(r.base, r.size);
> +
> +	ASSERT_EQ(rgn->base, r.base);
> +	ASSERT_EQ(rgn->size, total_size);
> +
> +	ASSERT_EQ(memblock.memory.cnt, 1);
> +	ASSERT_EQ(memblock.memory.total_size, total_size);
> +
> +	test_pass_pop();
> +
> +	return 0;
> +}
> +
>   static int memblock_add_checks(void)
>   {
>   	prefix_reset();
> @@ -339,6 +435,8 @@ static int memblock_add_checks(void)
>   	memblock_add_overlap_bottom_check();
>   	memblock_add_within_check();
>   	memblock_add_twice_check();
> +	memblock_add_between_check();
> +	memblock_add_near_max_check();
>   
>   	prefix_pop();
>   
> @@ -604,6 +702,102 @@ static int memblock_reserve_twice_check(void)
>   	return 0;
>   }
>   
> +/*
> + * A test that tries to mark two memory blocks that don't overlap as reserved
> + * and then reserve a third memory block in the space between the first two:
> + *
> + *  |        +--------+--------+--------+  |
> + *  |        |   r1   |   r3   |   r2   |  |
> + *  +--------+--------+--------+--------+--+
> + *
> + * Expect to merge the three entries into one reserved region that starts at
> + * r1.base and has size of r1.size + r2.size + r3.size. The region counter and
> + * total for memblock.reserved are updated.
> + */
> +static int memblock_reserve_between_check(void)
> +{
> +	struct memblock_region *rgn;
> +	phys_addr_t total_size;
> +
> +	rgn = &memblock.reserved.regions[0];
> +
> +	struct region r1 = {
> +		.base = SZ_1G,
> +		.size = SZ_8K
> +	};
> +	struct region r2 = {
> +		.base = SZ_1G + SZ_16K,
> +		.size = SZ_8K
> +	};
> +	struct region r3 = {
> +		.base = SZ_1G + SZ_8K,
> +		.size = SZ_8K
> +	};
> +
> +	PREFIX_PUSH();
> +
> +	total_size = r1.size + r2.size + r3.size;
> +
> +	reset_memblock_regions();
> +	memblock_reserve(r1.base, r1.size);
> +	memblock_reserve(r2.base, r2.size);
> +	memblock_reserve(r3.base, r3.size);
> +
> +	ASSERT_EQ(rgn->base, r1.base);
> +	ASSERT_EQ(rgn->size, total_size);
> +
> +	ASSERT_EQ(memblock.reserved.cnt, 1);
> +	ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> +	test_pass_pop();
> +
> +	return 0;
> +}
> +
> +/*
> + * A simple test that tries to reserve a memory block r when r extends past
> + * PHYS_ADDR_MAX:
> + *
> + *                               +--------+
> + *                               |    r   |
> + *                               +--------+
> + *  |                            +----+
> + *  |                            | rgn|
> + *  +----------------------------+----+
> + *
> + * Expect to reserve a memory block of size PHYS_ADDR_MAX - r.base. Expect the
> + * total size of reserved memory and the counter to be updated.
> + */
> +static int memblock_reserve_near_max_check(void)
> +{
> +	struct memblock_region *rgn;
> +	phys_addr_t total_size;
> +
> +	rgn = &memblock.reserved.regions[0];
> +
> +	struct region r = {
> +		.base = PHYS_ADDR_MAX - SZ_1M,
> +		.size = SZ_2M
> +	};
> +
> +	PREFIX_PUSH();
> +
> +	total_size = PHYS_ADDR_MAX - r.base;
> +
> +	reset_memblock_regions();
> +	memblock_reserve(r.base, r.size);
> +
> +	ASSERT_EQ(rgn->base, r.base);
> +	ASSERT_EQ(rgn->size, total_size);
> +
> +	ASSERT_EQ(memblock.reserved.cnt, 1);
> +	ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> +	test_pass_pop();
> +
> +	return 0;
> +}
> +
>   static int memblock_reserve_checks(void)
>   {
>   	prefix_reset();
> @@ -616,6 +810,8 @@ static int memblock_reserve_checks(void)
>   	memblock_reserve_overlap_bottom_check();
>   	memblock_reserve_within_check();
>   	memblock_reserve_twice_check();
> +	memblock_reserve_between_check();
> +	memblock_reserve_near_max_check();
>   
>   	prefix_pop();
>   
> @@ -887,6 +1083,155 @@ static int memblock_remove_within_check(void)
>   	return 0;
>   }
>   
> +/*
> + * A simple test that tries to remove a region r1 from the array of
> + * available memory regions when r1 is the only available region.
> + * Expect to add a memory block r1 and then remove r1 so that a dummy
> + * region is added. The region counter stays the same, and the total size
> + * is updated.
> + */
> +static int memblock_remove_only_region_check(void)
> +{
> +	struct memblock_region *rgn;
> +
> +	rgn = &memblock.memory.regions[0];
> +
> +	struct region r1 = {
> +		.base = SZ_2K,
> +		.size = SZ_4K
> +	};
> +
> +	PREFIX_PUSH();
> +
> +	reset_memblock_regions();
> +	memblock_add(r1.base, r1.size);
> +	memblock_remove(r1.base, r1.size);
> +
> +	ASSERT_EQ(rgn->base, 0);
> +	ASSERT_EQ(rgn->size, 0);
> +
> +	ASSERT_EQ(memblock.memory.cnt, 1);
> +	ASSERT_EQ(memblock.memory.total_size, 0);
> +
> +	test_pass_pop();
> +
> +	return 0;
> +}
> +
> +/*
> + * A simple test that tries remove a region r2 from the array of available
> + * memory regions when r2 extends past PHYS_ADDR_MAX:
> + *
> + *                               +--------+
> + *                               |   r2   |
> + *                               +--------+
> + *  |                        +---+....+
> + *  |                        |rgn|    |
> + *  +------------------------+---+----+
> + *
> + * Expect that only the portion between PHYS_ADDR_MAX and r2.base is removed.
> + * Expect the total size of available memory to be updated and the counter to
> + * not be updated.
> + */
> +static int memblock_remove_near_max_check(void)
> +{
> +	struct memblock_region *rgn;
> +	phys_addr_t total_size;
> +
> +	rgn = &memblock.memory.regions[0];
> +
> +	struct region r1 = {
> +		.base = PHYS_ADDR_MAX - SZ_2M,
> +		.size = SZ_2M
> +	};
> +
> +	struct region r2 = {
> +		.base = PHYS_ADDR_MAX - SZ_1M,
> +		.size = SZ_2M
> +	};
> +
> +	PREFIX_PUSH();
> +
> +	total_size = r1.size - (PHYS_ADDR_MAX - r2.base);
> +
> +	reset_memblock_regions();
> +	memblock_add(r1.base, r1.size);
> +	memblock_remove(r2.base, r2.size);
> +
> +	ASSERT_EQ(rgn->base, r1.base);
> +	ASSERT_EQ(rgn->size, total_size);
> +
> +	ASSERT_EQ(memblock.memory.cnt, 1);
> +	ASSERT_EQ(memblock.memory.total_size, total_size);
> +
> +	test_pass_pop();
> +
> +	return 0;
> +}
> +
> +/*
> + * A test that tries to remove a region r3 that overlaps with two existing
> + * regions r1 and r2:
> + *
> + *            +----------------+
> + *            |       r3       |
> + *            +----------------+
> + *  |    +----+.....   ........+--------+
> + *  |    |    |r1  :   :       |r2      |     |
> + *  +----+----+----+---+-------+--------+-----+
> + *
> + * Expect that only the intersections of r1 with r3 and r2 with r3 are removed
> + * from the available memory pool. Expect the total size of available memory to
> + * be updated and the counter to not be updated.
> + */
> +static int memblock_remove_overlap_two_check(void)
> +{
> +	struct memblock_region *rgn1, *rgn2;
> +	phys_addr_t r1_size, r2_size, r2_end, r3_end, total_size;
> +
> +	rgn1 = &memblock.memory.regions[0];
> +	rgn2 = &memblock.memory.regions[1];
> +
> +	struct region r1 = {
> +		.base = SZ_16M,
> +		.size = SZ_32M
> +	};
> +	struct region r2 = {
> +		.base = SZ_64M,
> +		.size = SZ_64M
> +	};
> +	struct region r3 = {
> +		.base = SZ_32M,
> +		.size = SZ_64M
> +	};
> +
> +	PREFIX_PUSH();
> +
> +	r2_end = r2.base + r2.size;
> +	r3_end = r3.base + r3.size;
> +	r1_size = r3.base - r1.base;
> +	r2_size = r2_end - r3_end;
> +	total_size = r1_size + r2_size;
> +
> +	reset_memblock_regions();
> +	memblock_add(r1.base, r1.size);
> +	memblock_add(r2.base, r2.size);
> +	memblock_remove(r3.base, r3.size);
> +
> +	ASSERT_EQ(rgn1->base, r1.base);
> +	ASSERT_EQ(rgn1->size, r1_size);
> +
> +	ASSERT_EQ(rgn2->base, r3_end);
> +	ASSERT_EQ(rgn2->size, r2_size);

I think these variable like r1.size and r1_size is a little confused, at 
least the readability is not very clear.

Maybe modify the r1_size to new_r1_size is more clear, and all other 
r*_size and r*_end.

It also can use other names, thus make these variable distingush and 
more clear.

> +
> +	ASSERT_EQ(memblock.memory.cnt, 2);
> +	ASSERT_EQ(memblock.memory.total_size, total_size);
> +
> +	test_pass_pop();
> +
> +	return 0;
> +}
> +
>   static int memblock_remove_checks(void)
>   {
>   	prefix_reset();
> @@ -898,6 +1243,9 @@ static int memblock_remove_checks(void)
>   	memblock_remove_overlap_top_check();
>   	memblock_remove_overlap_bottom_check();
>   	memblock_remove_within_check();
> +	memblock_remove_only_region_check();
> +	memblock_remove_near_max_check();
> +	memblock_remove_overlap_two_check();
>   
>   	prefix_pop();
>   
> @@ -1163,6 +1511,154 @@ static int memblock_free_within_check(void)
>   	return 0;
>   }
>   
> +/*
> + * A simple test that tries to free a memory block r1 that was marked
> + * earlier as reserved when r1 is the only available region.
> + * Expect to reserve a memory block r1 and then free r1 so that r1 is
> + * overwritten with a dummy region. The region counter stays the same,
> + * and the total size is updated.
> + */
> +static int memblock_free_only_region_check(void)
> +{
> +	struct memblock_region *rgn;
> +
> +	rgn = &memblock.reserved.regions[0];
> +
> +	struct region r1 = {
> +		.base = SZ_2K,
> +		.size = SZ_4K
> +	};
> +
> +	PREFIX_PUSH();
> +
> +	reset_memblock_regions();
> +	memblock_reserve(r1.base, r1.size);
> +	memblock_free((void *)r1.base, r1.size);
> +
> +	ASSERT_EQ(rgn->base, 0);
> +	ASSERT_EQ(rgn->size, 0);
> +
> +	ASSERT_EQ(memblock.reserved.cnt, 1);
> +	ASSERT_EQ(memblock.reserved.total_size, 0);
> +
> +	test_pass_pop();
> +
> +	return 0;
> +}
> +
> +/*
> + * A simple test that tries free a region r2 when r2 extends past PHYS_ADDR_MAX:
> + *
> + *                               +--------+
> + *                               |   r2   |
> + *                               +--------+
> + *  |                        +---+....+
> + *  |                        |rgn|    |
> + *  +------------------------+---+----+
> + *
> + * Expect that only the portion between PHYS_ADDR_MAX and r2.base is freed.
> + * Expect the total size of reserved memory to be updated and the counter to
> + * not be updated.
> + */
> +static int memblock_free_near_max_check(void)
> +{
> +	struct memblock_region *rgn;
> +	phys_addr_t total_size;
> +
> +	rgn = &memblock.reserved.regions[0];
> +
> +	struct region r1 = {
> +		.base = PHYS_ADDR_MAX - SZ_2M,
> +		.size = SZ_2M
> +	};
> +
> +	struct region r2 = {
> +		.base = PHYS_ADDR_MAX - SZ_1M,
> +		.size = SZ_2M
> +	};
> +
> +	PREFIX_PUSH();
> +
> +	total_size = r1.size - (PHYS_ADDR_MAX - r2.base);
> +
> +	reset_memblock_regions();
> +	memblock_reserve(r1.base, r1.size);
> +	memblock_free((void *)r2.base, r2.size);
> +
> +	ASSERT_EQ(rgn->base, r1.base);
> +	ASSERT_EQ(rgn->size, total_size);
> +
> +	ASSERT_EQ(memblock.reserved.cnt, 1);
> +	ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> +	test_pass_pop();
> +
> +	return 0;
> +}
> +
> +/*
> + * A test that tries to free a reserved region r3 that overlaps with two
> + * existing reserved regions r1 and r2:
> + *
> + *            +----------------+
> + *            |       r3       |
> + *            +----------------+
> + *  |    +----+.....   ........+--------+
> + *  |    |    |r1  :   :       |r2      |     |
> + *  +----+----+----+---+-------+--------+-----+
> + *
> + * Expect that only the intersections of r1 with r3 and r2 with r3 are freed
> + * from the collection of reserved memory. Expect the total size of reserved
> + * memory to be updated and the counter to not be updated.
> + */
> +static int memblock_free_overlap_two_check(void)
> +{
> +	struct memblock_region *rgn1, *rgn2;
> +	phys_addr_t r1_size, r2_size, r2_end, r3_end, total_size;
> +
> +	rgn1 = &memblock.reserved.regions[0];
> +	rgn2 = &memblock.reserved.regions[1];
> +
> +	struct region r1 = {
> +		.base = SZ_16M,
> +		.size = SZ_32M
> +	};
> +	struct region r2 = {
> +		.base = SZ_64M,
> +		.size = SZ_64M
> +	};
> +	struct region r3 = {
> +		.base = SZ_32M,
> +		.size = SZ_64M
> +	};
> +
> +	PREFIX_PUSH();
> +
> +	r2_end = r2.base + r2.size;
> +	r3_end = r3.base + r3.size;
> +	r1_size = r3.base - r1.base;
> +	r2_size = r2_end - r3_end;
> +	total_size = r1_size + r2_size;

Same as above.

> +
> +	reset_memblock_regions();
> +	memblock_reserve(r1.base, r1.size);
> +	memblock_reserve(r2.base, r2.size);
> +	memblock_free((void *)r3.base, r3.size);
> +
> +	ASSERT_EQ(rgn1->base, r1.base);
> +	ASSERT_EQ(rgn1->size, r1_size);
> +
> +	ASSERT_EQ(rgn2->base, r3_end);
> +	ASSERT_EQ(rgn2->size, r2_size);
> +
> +	ASSERT_EQ(memblock.reserved.cnt, 2);
> +	ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> +	test_pass_pop();
> +
> +	return 0;
> +}
> +
>   static int memblock_free_checks(void)
>   {
>   	prefix_reset();
> @@ -1174,6 +1670,9 @@ static int memblock_free_checks(void)
>   	memblock_free_overlap_top_check();
>   	memblock_free_overlap_bottom_check();
>   	memblock_free_within_check();
> +	memblock_free_only_region_check();
> +	memblock_free_near_max_check();
> +	memblock_free_overlap_two_check();
>   

Others looks good to me.

>   	prefix_pop();
>   

Re: [PATCH 6/8] memblock tests: update alloc_nid_api to test memblock_alloc_try_nid_raw

[Huang, Shaoqin]

On 8/14/2022 1:53 PM, Rebecca Mckeever wrote:
> 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.
> 
> Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> ---
>   tools/testing/memblock/tests/alloc_nid_api.c | 196 ++++++++++++-------
>   1 file changed, 127 insertions(+), 69 deletions(-)
> 
> diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
> index 82fa8ea36320..e16106d8446b 100644
> --- a/tools/testing/memblock/tests/alloc_nid_api.c
> +++ b/tools/testing/memblock/tests/alloc_nid_api.c
> @@ -1,6 +1,42 @@
>   // SPDX-License-Identifier: GPL-2.0-or-later
>   #include "alloc_nid_api.h"
>   
> +static const char * const func_testing[] = {
> +	"memblock_alloc_try_nid",
> +	"memblock_alloc_try_nid_raw"
> +};
> +
> +static int alloc_nid_test_flags = TEST_ZEROED;
> +
> +static inline const char * const get_func_testing(int flags)
> +{
> +	if (flags & TEST_RAW)
> +		return func_testing[1];
> +	else
> +		return func_testing[0];
> +}
> +
> +static inline void *run_memblock_alloc_try_nid(phys_addr_t size,
> +					       phys_addr_t align,
> +					       phys_addr_t min_addr,
> +					       phys_addr_t max_addr, int nid)
> +{
> +	if (alloc_nid_test_flags & TEST_RAW)
> +		return memblock_alloc_try_nid_raw(size, align, min_addr,
> +						  max_addr, nid);
> +	else
> +		return memblock_alloc_try_nid(size, align, min_addr,
> +					      max_addr, nid);
> +}
> +
> +static inline void verify_mem_content(void *mem, int size)
> +{
> +	if (alloc_nid_test_flags & TEST_RAW)
> +		ASSERT_MEM_NE((char *)mem, 0, size);
> +	else
> +		ASSERT_MEM_EQ((char *)mem, 0, size);
> +}
> +

These static functions seems the same with the PATCH5 did, have you 
considered to keep only one common function?

>   /*
>    * A simple test that tries to allocate a memory region within min_addr and
>    * max_addr range:
> @@ -32,12 +68,13 @@ static int alloc_try_nid_top_down_simple_check(void)
>   	min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2;
>   	max_addr = min_addr + SZ_512;
>   
> -	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> -					       min_addr, max_addr, NUMA_NO_NODE);
> +	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> +						   min_addr, max_addr,
> +						   NUMA_NO_NODE);
>   	rgn_end = rgn->base + rgn->size;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
> +	verify_mem_content(allocated_ptr, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, max_addr - size);
> @@ -86,12 +123,13 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
>   	min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2;
>   	max_addr = min_addr + SZ_512 + misalign;
>   
> -	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> -					       min_addr, max_addr, NUMA_NO_NODE);
> +	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> +						   min_addr, max_addr,
> +						   NUMA_NO_NODE);
>   	rgn_end = rgn->base + rgn->size;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
> +	verify_mem_content(allocated_ptr, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, max_addr - size - misalign);
> @@ -137,12 +175,13 @@ static int alloc_try_nid_exact_address_generic_check(void)
>   	min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES;
>   	max_addr = min_addr + size;
>   
> -	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> -					       min_addr, max_addr, NUMA_NO_NODE);
> +	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> +						   min_addr, max_addr,
> +						   NUMA_NO_NODE);
>   	rgn_end = rgn->base + rgn->size;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
> +	verify_mem_content(allocated_ptr, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, min_addr);
> @@ -189,11 +228,12 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
>   	min_addr = memblock_start_of_DRAM() + SZ_512;
>   	max_addr = min_addr + SMP_CACHE_BYTES;
>   
> -	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> -					       min_addr, max_addr, NUMA_NO_NODE);
> +	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> +						   min_addr, max_addr,
> +						   NUMA_NO_NODE);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
> +	verify_mem_content(allocated_ptr, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, max_addr - size);
> @@ -241,8 +281,9 @@ static int alloc_try_nid_low_max_generic_check(void)
>   	min_addr = memblock_start_of_DRAM();
>   	max_addr = min_addr + SMP_CACHE_BYTES;
>   
> -	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> -					       min_addr, max_addr, NUMA_NO_NODE);
> +	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> +						   min_addr, max_addr,
> +						   NUMA_NO_NODE);
>   
>   	ASSERT_EQ(allocated_ptr, NULL);
>   
> @@ -287,11 +328,12 @@ static int alloc_try_nid_min_reserved_generic_check(void)
>   
>   	memblock_reserve(reserved_base, r1_size);
>   
> -	allocated_ptr = memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES,
> -					       min_addr, max_addr, NUMA_NO_NODE);
> +	allocated_ptr = run_memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES,
> +						   min_addr, max_addr,
> +						   NUMA_NO_NODE);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
> +	verify_mem_content(allocated_ptr, r2_size);
>   
>   	ASSERT_EQ(rgn->size, total_size);
>   	ASSERT_EQ(rgn->base, reserved_base);
> @@ -338,11 +380,12 @@ static int alloc_try_nid_max_reserved_generic_check(void)
>   
>   	memblock_reserve(max_addr, r1_size);
>   
> -	allocated_ptr = memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES,
> -					       min_addr, max_addr, NUMA_NO_NODE);
> +	allocated_ptr = run_memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES,
> +						   min_addr, max_addr,
> +						   NUMA_NO_NODE);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
> +	verify_mem_content(allocated_ptr, r2_size);
>   
>   	ASSERT_EQ(rgn->size, total_size);
>   	ASSERT_EQ(rgn->base, min_addr);
> @@ -402,11 +445,12 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
>   	memblock_reserve(r1.base, r1.size);
>   	memblock_reserve(r2.base, r2.size);
>   
> -	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
> -					       min_addr, max_addr, NUMA_NO_NODE);
> +	allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
> +						   min_addr, max_addr,
> +						   NUMA_NO_NODE);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
> +	verify_mem_content(allocated_ptr, r3_size);
>   
>   	ASSERT_EQ(rgn1->size, r1.size + r3_size);
>   	ASSERT_EQ(rgn1->base, max_addr - r3_size);
> @@ -466,11 +510,12 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
>   	memblock_reserve(r1.base, r1.size);
>   	memblock_reserve(r2.base, r2.size);
>   
> -	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
> -					       min_addr, max_addr, NUMA_NO_NODE);
> +	allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
> +						   min_addr, max_addr,
> +						   NUMA_NO_NODE);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
> +	verify_mem_content(allocated_ptr, r3_size);
>   
>   	ASSERT_EQ(rgn->size, total_size);
>   	ASSERT_EQ(rgn->base, r2.base);
> @@ -531,11 +576,12 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
>   	memblock_reserve(r1.base, r1.size);
>   	memblock_reserve(r2.base, r2.size);
>   
> -	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
> -					       min_addr, max_addr, NUMA_NO_NODE);
> +	allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
> +						   min_addr, max_addr,
> +						   NUMA_NO_NODE);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
> +	verify_mem_content(allocated_ptr, r3_size);
>   
>   	ASSERT_EQ(rgn1->size, r1.size);
>   	ASSERT_EQ(rgn1->base, r1.base);
> @@ -597,8 +643,9 @@ static int alloc_try_nid_reserved_all_generic_check(void)
>   	memblock_reserve(r1.base, r1.size);
>   	memblock_reserve(r2.base, r2.size);
>   
> -	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
> -					       min_addr, max_addr, NUMA_NO_NODE);
> +	allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
> +						   min_addr, max_addr,
> +						   NUMA_NO_NODE);
>   
>   	ASSERT_EQ(allocated_ptr, NULL);
>   
> @@ -628,11 +675,12 @@ static int alloc_try_nid_top_down_cap_max_check(void)
>   	min_addr = memblock_end_of_DRAM() - SZ_1K;
>   	max_addr = memblock_end_of_DRAM() + SZ_256;
>   
> -	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> -					       min_addr, max_addr, NUMA_NO_NODE);
> +	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> +						   min_addr, max_addr,
> +						   NUMA_NO_NODE);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
> +	verify_mem_content(allocated_ptr, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
> @@ -666,11 +714,12 @@ static int alloc_try_nid_top_down_cap_min_check(void)
>   	min_addr = memblock_start_of_DRAM() - SZ_256;
>   	max_addr = memblock_end_of_DRAM();
>   
> -	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> -					       min_addr, max_addr, NUMA_NO_NODE);
> +	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> +						   min_addr, max_addr,
> +						   NUMA_NO_NODE);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
> +	verify_mem_content(allocated_ptr, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
> @@ -714,13 +763,13 @@ static int alloc_try_nid_bottom_up_simple_check(void)
>   	min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2;
>   	max_addr = min_addr + SZ_512;
>   
> -	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> -					       min_addr, max_addr,
> -					       NUMA_NO_NODE);
> +	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> +						   min_addr, max_addr,
> +						   NUMA_NO_NODE);
>   	rgn_end = rgn->base + rgn->size;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
> +	verify_mem_content(allocated_ptr, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, min_addr);
> @@ -769,13 +818,13 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
>   	min_addr = memblock_start_of_DRAM() + misalign;
>   	max_addr = min_addr + SZ_512;
>   
> -	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> -					       min_addr, max_addr,
> -					       NUMA_NO_NODE);
> +	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> +						   min_addr, max_addr,
> +						   NUMA_NO_NODE);
>   	rgn_end = rgn->base + rgn->size;
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
> +	verify_mem_content(allocated_ptr, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, min_addr + (SMP_CACHE_BYTES - misalign));
> @@ -822,12 +871,12 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
>   	min_addr = memblock_start_of_DRAM() + SZ_512;
>   	max_addr = min_addr + SMP_CACHE_BYTES;
>   
> -	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> -					       min_addr, max_addr,
> -					       NUMA_NO_NODE);
> +	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> +						   min_addr, max_addr,
> +						   NUMA_NO_NODE);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
> +	verify_mem_content(allocated_ptr, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> @@ -887,12 +936,12 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
>   	memblock_reserve(r1.base, r1.size);
>   	memblock_reserve(r2.base, r2.size);
>   
> -	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
> -					       min_addr, max_addr,
> -					       NUMA_NO_NODE);
> +	allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
> +						   min_addr, max_addr,
> +						   NUMA_NO_NODE);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
> +	verify_mem_content(allocated_ptr, r3_size);
>   
>   	ASSERT_EQ(rgn1->size, r1.size);
>   	ASSERT_EQ(rgn1->base, max_addr);
> @@ -959,12 +1008,12 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
>   	memblock_reserve(r1.base, r1.size);
>   	memblock_reserve(r2.base, r2.size);
>   
> -	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
> -					       min_addr, max_addr,
> -					       NUMA_NO_NODE);
> +	allocated_ptr = run_memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
> +						   min_addr, max_addr,
> +						   NUMA_NO_NODE);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
> +	verify_mem_content(allocated_ptr, r3_size);
>   
>   	ASSERT_EQ(rgn3->size, r3_size);
>   	ASSERT_EQ(rgn3->base, memblock_start_of_DRAM());
> @@ -1004,12 +1053,12 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
>   	min_addr = memblock_start_of_DRAM() + SZ_1K;
>   	max_addr = memblock_end_of_DRAM() + SZ_256;
>   
> -	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> -					       min_addr, max_addr,
> -					       NUMA_NO_NODE);
> +	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> +						   min_addr, max_addr,
> +						   NUMA_NO_NODE);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
> +	verify_mem_content(allocated_ptr, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, min_addr);
> @@ -1043,12 +1092,12 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
>   	min_addr = memblock_start_of_DRAM();
>   	max_addr = memblock_end_of_DRAM() - SZ_256;
>   
> -	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> -					       min_addr, max_addr,
> -					       NUMA_NO_NODE);
> +	allocated_ptr = run_memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> +						   min_addr, max_addr,
> +						   NUMA_NO_NODE);
>   
>   	ASSERT_NE(allocated_ptr, NULL);
> -	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
> +	verify_mem_content(allocated_ptr, size);
>   
>   	ASSERT_EQ(rgn->size, size);
>   	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> @@ -1193,13 +1242,14 @@ static int alloc_try_nid_low_max_check(void)
>   	return 0;
>   }
>   
> -int memblock_alloc_nid_checks(void)
> +static int memblock_alloc_nid_checks_internal(int flags)
>   {
> -	const char *func_testing = "memblock_alloc_try_nid";
> +	const char *func = get_func_testing(flags);
>   
> +	alloc_nid_test_flags = flags;
>   	prefix_reset();
> -	prefix_push(func_testing);
> -	test_print("Running %s tests...\n", func_testing);
> +	prefix_push(func);
> +	test_print("Running %s tests...\n", func);
>   
>   	reset_memblock_attributes();
>   	dummy_physical_memory_init();
> @@ -1225,3 +1275,11 @@ int memblock_alloc_nid_checks(void)
>   
>   	return 0;
>   }
> +
> +int memblock_alloc_nid_checks(void)
> +{
> +	memblock_alloc_nid_checks_internal(TEST_ZEROED);
> +	memblock_alloc_nid_checks_internal(TEST_RAW);
> +
> +	return 0;
> +}

Re: [PATCH 8/8] memblock tests: add tests for memblock_trim_memory

[Huang, Shaoqin]

On 8/14/2022 1:54 PM, Rebecca Mckeever wrote:
> Add tests for memblock_trim_memory() for the following scenarios:
> - all regions aligned
> - one region unalign that is smaller than the alignment
> - one region unaligned at the base
> - one region unaligned at the end
> 
> Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> ---
>   tools/testing/memblock/tests/basic_api.c | 223 +++++++++++++++++++++++
>   1 file changed, 223 insertions(+)
> 
> diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c
> index d7f008e7a12a..c8bb44f20846 100644
> --- a/tools/testing/memblock/tests/basic_api.c
> +++ b/tools/testing/memblock/tests/basic_api.c
> @@ -8,6 +8,7 @@
>   #define FUNC_RESERVE					"memblock_reserve"
>   #define FUNC_REMOVE					"memblock_remove"
>   #define FUNC_FREE					"memblock_free"
> +#define FUNC_TRIM					"memblock_trim_memory"
>   
>   static int memblock_initialization_check(void)
>   {
> @@ -1723,6 +1724,227 @@ static int memblock_bottom_up_checks(void)
>   	return 0;
>   }
>   
> +/*
> + * A test that tries to trim memory when both ends of the memory region are
> + * aligned. Expect that the memory will not be trimmed. Expect the counter to
> + * not be updated.
> + */
> +static int memblock_trim_memory_aligned_check(void)
> +{
> +	struct memblock_region *rgn;
> +	phys_addr_t alignment = SMP_CACHE_BYTES;
> +
> +	rgn = &memblock.memory.regions[0];
> +
> +	struct region r = {
> +		.base = alignment,
> +		.size = alignment * 4
> +	};
> +
> +	PREFIX_PUSH();
> +
> +	reset_memblock_regions();
> +	memblock_add(r.base, r.size);
> +	memblock_trim_memory(alignment);
> +
> +	ASSERT_EQ(rgn->base, r.base);
> +	ASSERT_EQ(rgn->size, r.size);
> +
> +	ASSERT_EQ(memblock.memory.cnt, 1);
> +
> +	test_pass_pop();
> +
> +	return 0;
> +}
> +
> +/*
> + * A test that tries to trim memory when there are two available regions, r1 and
> + * r2. Region r1 is aligned on both ends and region r2 is unaligned on one end
> + * and smaller than the alignment:
> + *
> + *                                     alignment
> + *                                     |--------|
> + * |        +-----------------+        +------+   |
> + * |        |        r1       |        |  r2  |   |
> + * +--------+-----------------+--------+------+---+
> + *          ^        ^        ^        ^      ^
> + *          |________|________|________|      |
> + *                            |               Unaligned address
> + *                Aligned addresses
> + *
> + * Expect that r1 will not be trimmed and r2 will be removed. Expect the
> + * counter to be updated.
> + */
> +static int memblock_trim_memory_too_small_check(void)
> +{
> +	struct memblock_region *rgn;
> +	phys_addr_t alignment = SMP_CACHE_BYTES;
> +
> +	rgn = &memblock.memory.regions[0];
> +
> +	struct region r1 = {
> +		.base = alignment,
> +		.size = alignment * 2
> +	};
> +	struct region r2 = {
> +		.base = alignment * 4,
> +		.size = alignment - SZ_2
> +	};
> +
> +	PREFIX_PUSH();
> +
> +	reset_memblock_regions();
> +	memblock_add(r1.base, r1.size);
> +	memblock_add(r2.base, r2.size);
> +	memblock_trim_memory(alignment);
> +
> +	ASSERT_EQ(rgn->base, r1.base);
> +	ASSERT_EQ(rgn->size, r1.size);
> +
> +	ASSERT_EQ(memblock.memory.cnt, 1);
> +
> +	test_pass_pop();
> +
> +	return 0;
> +}
> +
> +/*
> + * A test that tries to trim memory when there are two available regions, r1 and
> + * r2. Region r1 is aligned on both ends and region r2 is unaligned at the base
> + * and aligned at the end:
> + *
> + *                               Unaligned address
> + *                                       |
> + *                                       v
> + * |        +-----------------+          +---------------+   |
> + * |        |        r1       |          |      r2       |   |
> + * +--------+-----------------+----------+---------------+---+
> + *          ^        ^        ^        ^        ^        ^
> + *          |________|________|________|________|________|
> + *                            |
> + *                    Aligned addresses
> + *
> + * Expect that r1 will not be trimmed and r2 will be trimmed at the base.
> + * Expect the counter to not be updated.
> + */
> +static int memblock_trim_memory_unaligned_base_check(void)
> +{
> +	struct memblock_region *rgn1, *rgn2;
> +	phys_addr_t alignment = SMP_CACHE_BYTES;
> +	phys_addr_t offset = SZ_2;
> +	phys_addr_t r2_base, r2_size;
> +
> +	rgn1 = &memblock.memory.regions[0];
> +	rgn2 = &memblock.memory.regions[1];
> +
> +	struct region r1 = {
> +		.base = alignment,
> +		.size = alignment * 2
> +	};
> +	struct region r2 = {
> +		.base = alignment * 4 + offset,
> +		.size = alignment * 2 - offset
> +	};
> +
> +	PREFIX_PUSH();
> +
> +	r2_base = r2.base + (alignment - offset);
> +	r2_size = r2.size - (alignment - offset);

Also the variable name.

> +
> +	reset_memblock_regions();
> +	memblock_add(r1.base, r1.size);
> +	memblock_add(r2.base, r2.size);
> +	memblock_trim_memory(alignment);
> +
> +	ASSERT_EQ(rgn1->base, r1.base);
> +	ASSERT_EQ(rgn1->size, r1.size);
> +
> +	ASSERT_EQ(rgn2->base, r2_base);
> +	ASSERT_EQ(rgn2->size, r2_size);
> +
> +	ASSERT_EQ(memblock.memory.cnt, 2);
> +
> +	test_pass_pop();
> +
> +	return 0;
> +}
> +
> +/*
> + * A test that tries to trim memory when there are two available regions, r1 and
> + * r2. Region r1 is aligned on both ends and region r2 is aligned at the base
> + * and unaligned at the end:
> + *
> + *                                             Unaligned address
> + *                                                     |
> + *                                                     v
> + * |        +-----------------+        +---------------+   |
> + * |        |        r1       |        |      r2       |   |
> + * +--------+-----------------+--------+---------------+---+
> + *          ^        ^        ^        ^        ^        ^
> + *          |________|________|________|________|________|
> + *                            |
> + *                    Aligned addresses
> + *
> + * Expect that r1 will not be trimmed and r2 will be trimmed at the base.
								^
							at the end.
> + * Expect the counter to not be updated.
> + */
> +static int memblock_trim_memory_unaligned_end_check(void)
> +{
> +	struct memblock_region *rgn1, *rgn2;
> +	phys_addr_t alignment = SMP_CACHE_BYTES;
> +	phys_addr_t offset = SZ_2;
> +	phys_addr_t r2_size;
> +
> +	rgn1 = &memblock.memory.regions[0];
> +	rgn2 = &memblock.memory.regions[1];
> +
> +	struct region r1 = {
> +		.base = alignment,
> +		.size = alignment * 2
> +	};
> +	struct region r2 = {
> +		.base = alignment * 4,
> +		.size = alignment * 2 - offset
> +	};
> +
> +	PREFIX_PUSH();
> +
> +	r2_size = r2.size - (alignment - offset);
> +
> +	reset_memblock_regions();
> +	memblock_add(r1.base, r1.size);
> +	memblock_add(r2.base, r2.size);
> +	memblock_trim_memory(alignment);
> +
> +	ASSERT_EQ(rgn1->base, r1.base);
> +	ASSERT_EQ(rgn1->size, r1.size);
> +
> +	ASSERT_EQ(rgn2->base, r2.base);
> +	ASSERT_EQ(rgn2->size, r2_size);
> +
> +	ASSERT_EQ(memblock.memory.cnt, 2);
> +
> +	test_pass_pop();
> +
> +	return 0;
> +}
> +
> +static int memblock_trim_memory_checks(void)
> +{
> +	prefix_reset();
> +	prefix_push(FUNC_TRIM);
> +	test_print("Running %s tests...\n", FUNC_TRIM);
> +
> +	memblock_trim_memory_aligned_check();
> +	memblock_trim_memory_too_small_check();
> +	memblock_trim_memory_unaligned_base_check();
> +	memblock_trim_memory_unaligned_end_check();
> +
> +	prefix_pop();
> +
> +	return 0;
> +}
> +
>   int memblock_basic_checks(void)
>   {
>   	memblock_initialization_check();
> @@ -1731,6 +1953,7 @@ int memblock_basic_checks(void)
>   	memblock_remove_checks();
>   	memblock_free_checks();
>   	memblock_bottom_up_checks();
> +	memblock_trim_memory_checks();
>   
>   	return 0;
>   }

Others looks good.

Re: [PATCH 7/8] memblock tests: add tests for memblock_*bottom_up functions

[Huang, Shaoqin]

Reviewed-by: Shaoqin Huang <shaoqin.huang@intel.com>

On 8/14/2022 1:53 PM, Rebecca Mckeever wrote:
> Add simple tests for memblock_set_bottom_up() and memblock_bottom_up().
> 
> Reviewed-by: David Hildenbrand <david@redhat.com>
> Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> ---
>   tools/testing/memblock/tests/basic_api.c | 45 ++++++++++++++++++++++++
>   1 file changed, 45 insertions(+)
> 
> diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c
> index ef5642d0863b..d7f008e7a12a 100644
> --- a/tools/testing/memblock/tests/basic_api.c
> +++ b/tools/testing/memblock/tests/basic_api.c
> @@ -1679,6 +1679,50 @@ static int memblock_free_checks(void)
>   	return 0;
>   }
>   
> +static int memblock_set_bottom_up_check(void)
> +{
> +	prefix_push("memblock_set_bottom_up");
> +
> +	memblock_set_bottom_up(false);
> +	ASSERT_EQ(memblock.bottom_up, false);
> +	memblock_set_bottom_up(true);
> +	ASSERT_EQ(memblock.bottom_up, true);
> +
> +	reset_memblock_attributes();
> +	test_pass_pop();
> +
> +	return 0;
> +}
> +
> +static int memblock_bottom_up_check(void)
> +{
> +	prefix_push("memblock_bottom_up");
> +
> +	memblock_set_bottom_up(false);
> +	ASSERT_EQ(memblock_bottom_up(), memblock.bottom_up);
> +	ASSERT_EQ(memblock_bottom_up(), false);
> +	memblock_set_bottom_up(true);
> +	ASSERT_EQ(memblock_bottom_up(), memblock.bottom_up);
> +	ASSERT_EQ(memblock_bottom_up(), true);
> +
> +	reset_memblock_attributes();
> +	test_pass_pop();
> +
> +	return 0;
> +}
> +
> +static int memblock_bottom_up_checks(void)
> +{
> +	test_print("Running memblock_*bottom_up tests...\n");
> +
> +	prefix_reset();
> +	memblock_set_bottom_up_check();
> +	prefix_reset();
> +	memblock_bottom_up_check();
> +
> +	return 0;
> +}
> +
>   int memblock_basic_checks(void)
>   {
>   	memblock_initialization_check();
> @@ -1686,6 +1730,7 @@ int memblock_basic_checks(void)
>   	memblock_reserve_checks();
>   	memblock_remove_checks();
>   	memblock_free_checks();
> +	memblock_bottom_up_checks();
>   
>   	return 0;
>   }

Re: [PATCH 1/8] memblock tests: update tests to check if memblock_alloc zeroed memory

[Rebecca Mckeever]

On Mon, Aug 15, 2022 at 04:50:51PM +0800, Huang, Shaoqin wrote:
> Hi, Rebecca.
> 
> On 8/14/2022 1:53 PM, Rebecca Mckeever wrote:
> > 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().
> > 
> > Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> > ---
> >   tools/testing/memblock/tests/alloc_api.c | 24 ++++++++++++++++++++++++
> >   tools/testing/memblock/tests/common.c    |  7 +++++++
> >   tools/testing/memblock/tests/common.h    | 13 +++++++++++++
> >   3 files changed, 44 insertions(+)
> > 
> > diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
> > index a14f38eb8a89..71c89cb9b2a8 100644
> > --- a/tools/testing/memblock/tests/alloc_api.c
> > +++ b/tools/testing/memblock/tests/alloc_api.c
> > @@ -22,6 +22,8 @@ static int alloc_top_down_simple_check(void)
> >   	allocated_ptr = memblock_alloc(size, SMP_CACHE_BYTES);
> >   	ASSERT_NE(allocated_ptr, NULL);
> > +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
> > +
> >   	ASSERT_EQ(rgn->size, size);
> >   	ASSERT_EQ(rgn->base, expected_start);
> > @@ -80,6 +82,8 @@ static int alloc_top_down_disjoint_check(void)
> >   	allocated_ptr = memblock_alloc(r2_size, alignment);
> >   	ASSERT_NE(allocated_ptr, NULL);
> > +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
> > +
> >   	ASSERT_EQ(rgn1->size, r1.size);
> >   	ASSERT_EQ(rgn1->base, r1.base);
> > @@ -125,6 +129,8 @@ static int alloc_top_down_before_check(void)
> >   	allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
> >   	ASSERT_NE(allocated_ptr, NULL);
> > +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
> > +
> >   	ASSERT_EQ(rgn->size, total_size);
> >   	ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - total_size);
> > @@ -173,6 +179,8 @@ static int alloc_top_down_after_check(void)
> >   	allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
> >   	ASSERT_NE(allocated_ptr, NULL);
> > +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
> > +
> >   	ASSERT_EQ(rgn->size, total_size);
> >   	ASSERT_EQ(rgn->base, r1.base - r2_size);
> > @@ -223,6 +231,8 @@ static int alloc_top_down_second_fit_check(void)
> >   	allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
> >   	ASSERT_NE(allocated_ptr, NULL);
> > +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
> > +
> >   	ASSERT_EQ(rgn->size, r2.size + r3_size);
> >   	ASSERT_EQ(rgn->base, r2.base - r3_size);
> > @@ -277,6 +287,8 @@ static int alloc_in_between_generic_check(void)
> >   	allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
> >   	ASSERT_NE(allocated_ptr, NULL);
> > +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
> > +
> >   	ASSERT_EQ(rgn->size, total_size);
> >   	ASSERT_EQ(rgn->base, r1.base - r2.size - r3_size);
> > @@ -418,6 +430,8 @@ static int alloc_limited_space_generic_check(void)
> >   	allocated_ptr = memblock_alloc(available_size, SMP_CACHE_BYTES);
> >   	ASSERT_NE(allocated_ptr, NULL);
> > +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, available_size);
> > +
> >   	ASSERT_EQ(rgn->size, MEM_SIZE);
> >   	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> > @@ -442,6 +456,7 @@ static int alloc_no_memory_generic_check(void)
> >   	PREFIX_PUSH();
> >   	reset_memblock_regions();
> > +	fill_memblock();
> 
> Maybe we don't need this line, it has no effect at here. Anyway, Others
> Looks Good to me.
> 
Do you mean that it's not necessary since the test doesn't run
verify_mem_content()? 

> Reviewed-by: Shaoqin Huang <shaoqin.huang@intel.com>
> 
> >   	allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
> > @@ -472,6 +487,8 @@ static int alloc_bottom_up_simple_check(void)
> >   	allocated_ptr = memblock_alloc(SZ_2, SMP_CACHE_BYTES);
> >   	ASSERT_NE(allocated_ptr, NULL);
> > +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, SZ_2);
> > +
> >   	ASSERT_EQ(rgn->size, SZ_2);
> >   	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> > @@ -528,6 +545,7 @@ static int alloc_bottom_up_disjoint_check(void)
> >   	allocated_ptr = memblock_alloc(r2_size, alignment);
> >   	ASSERT_NE(allocated_ptr, NULL);
> > +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
> >   	ASSERT_EQ(rgn1->size, r1.size);
> >   	ASSERT_EQ(rgn1->base, r1.base);
> > @@ -571,6 +589,8 @@ static int alloc_bottom_up_before_check(void)
> >   	allocated_ptr = memblock_alloc(r1_size, SMP_CACHE_BYTES);
> >   	ASSERT_NE(allocated_ptr, NULL);
> > +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r1_size);
> > +
> >   	ASSERT_EQ(rgn->size, total_size);
> >   	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> > @@ -618,6 +638,8 @@ static int alloc_bottom_up_after_check(void)
> >   	allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
> >   	ASSERT_NE(allocated_ptr, NULL);
> > +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
> > +
> >   	ASSERT_EQ(rgn->size, total_size);
> >   	ASSERT_EQ(rgn->base, r1.base);
> > @@ -669,6 +691,8 @@ static int alloc_bottom_up_second_fit_check(void)
> >   	allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
> >   	ASSERT_NE(allocated_ptr, NULL);
> > +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
> > +
> >   	ASSERT_EQ(rgn->size, r2.size + r3_size);
> >   	ASSERT_EQ(rgn->base, r2.base);
> > diff --git a/tools/testing/memblock/tests/common.c b/tools/testing/memblock/tests/common.c
> > index 76a8ad818f3a..0ca26fe12c38 100644
> > --- a/tools/testing/memblock/tests/common.c
> > +++ b/tools/testing/memblock/tests/common.c
> > @@ -60,16 +60,23 @@ void reset_memblock_attributes(void)
> >   	memblock.current_limit	= MEMBLOCK_ALLOC_ANYWHERE;
> >   }
> > +void fill_memblock(void)
> > +{
> > +	memset(memory_block.base, 1, MEM_SIZE);
> > +}
> > +
> >   void setup_memblock(void)
> >   {
> >   	reset_memblock_regions();
> >   	memblock_add((phys_addr_t)memory_block.base, MEM_SIZE);
> > +	fill_memblock();
> >   }
> >   void dummy_physical_memory_init(void)
> >   {
> >   	memory_block.base = malloc(MEM_SIZE);
> >   	assert(memory_block.base);
> > +	fill_memblock();
> >   }
> >   void dummy_physical_memory_cleanup(void)
> > diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h
> > index d396e5423a8e..7a16a7dc8f2c 100644
> > --- a/tools/testing/memblock/tests/common.h
> > +++ b/tools/testing/memblock/tests/common.h
> > @@ -51,6 +51,18 @@
> >   	assert((_expected) < (_seen)); \
> >   } while (0)
> > +/**
> > + * ASSERT_MEM_EQ():
> > + * Check that the first @_size bytes of @_seen are all equal to @_expected.
> > + * If false, print failed test message (if running with --verbose) and then
> > + * assert.
> > + */
> > +#define ASSERT_MEM_EQ(_seen, _expected, _size) do { \
> > +	for (int _i = 0; _i < (_size); _i++) { \
> > +		ASSERT_EQ((_seen)[_i], (_expected)); \
> > +	} \
> > +} while (0)
> > +
> >   #define PREFIX_PUSH() prefix_push(__func__)
> >   /*
> > @@ -70,6 +82,7 @@ struct region {
> >   void reset_memblock_regions(void);
> >   void reset_memblock_attributes(void);
> > +void fill_memblock(void);
> >   void setup_memblock(void);
> >   void dummy_physical_memory_init(void);
> >   void dummy_physical_memory_cleanup(void);

Re: [PATCH 1/8] memblock tests: update tests to check if memblock_alloc zeroed memory

[Huang, Shaoqin]

On 8/16/2022 10:15 AM, Rebecca Mckeever wrote:
> On Mon, Aug 15, 2022 at 04:50:51PM +0800, Huang, Shaoqin wrote:
>> Hi, Rebecca.
>>
>> On 8/14/2022 1:53 PM, Rebecca Mckeever wrote:
>>> 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().
>>>
>>> Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
>>> ---
>>>    tools/testing/memblock/tests/alloc_api.c | 24 ++++++++++++++++++++++++
>>>    tools/testing/memblock/tests/common.c    |  7 +++++++
>>>    tools/testing/memblock/tests/common.h    | 13 +++++++++++++
>>>    3 files changed, 44 insertions(+)
>>>
>>> diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
>>> index a14f38eb8a89..71c89cb9b2a8 100644
>>> --- a/tools/testing/memblock/tests/alloc_api.c
>>> +++ b/tools/testing/memblock/tests/alloc_api.c
>>> @@ -22,6 +22,8 @@ static int alloc_top_down_simple_check(void)
>>>    	allocated_ptr = memblock_alloc(size, SMP_CACHE_BYTES);
>>>    	ASSERT_NE(allocated_ptr, NULL);
>>> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, size);
>>> +
>>>    	ASSERT_EQ(rgn->size, size);
>>>    	ASSERT_EQ(rgn->base, expected_start);
>>> @@ -80,6 +82,8 @@ static int alloc_top_down_disjoint_check(void)
>>>    	allocated_ptr = memblock_alloc(r2_size, alignment);
>>>    	ASSERT_NE(allocated_ptr, NULL);
>>> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
>>> +
>>>    	ASSERT_EQ(rgn1->size, r1.size);
>>>    	ASSERT_EQ(rgn1->base, r1.base);
>>> @@ -125,6 +129,8 @@ static int alloc_top_down_before_check(void)
>>>    	allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
>>>    	ASSERT_NE(allocated_ptr, NULL);
>>> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
>>> +
>>>    	ASSERT_EQ(rgn->size, total_size);
>>>    	ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - total_size);
>>> @@ -173,6 +179,8 @@ static int alloc_top_down_after_check(void)
>>>    	allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
>>>    	ASSERT_NE(allocated_ptr, NULL);
>>> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
>>> +
>>>    	ASSERT_EQ(rgn->size, total_size);
>>>    	ASSERT_EQ(rgn->base, r1.base - r2_size);
>>> @@ -223,6 +231,8 @@ static int alloc_top_down_second_fit_check(void)
>>>    	allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
>>>    	ASSERT_NE(allocated_ptr, NULL);
>>> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
>>> +
>>>    	ASSERT_EQ(rgn->size, r2.size + r3_size);
>>>    	ASSERT_EQ(rgn->base, r2.base - r3_size);
>>> @@ -277,6 +287,8 @@ static int alloc_in_between_generic_check(void)
>>>    	allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
>>>    	ASSERT_NE(allocated_ptr, NULL);
>>> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
>>> +
>>>    	ASSERT_EQ(rgn->size, total_size);
>>>    	ASSERT_EQ(rgn->base, r1.base - r2.size - r3_size);
>>> @@ -418,6 +430,8 @@ static int alloc_limited_space_generic_check(void)
>>>    	allocated_ptr = memblock_alloc(available_size, SMP_CACHE_BYTES);
>>>    	ASSERT_NE(allocated_ptr, NULL);
>>> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, available_size);
>>> +
>>>    	ASSERT_EQ(rgn->size, MEM_SIZE);
>>>    	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
>>> @@ -442,6 +456,7 @@ static int alloc_no_memory_generic_check(void)
>>>    	PREFIX_PUSH();
>>>    	reset_memblock_regions();
>>> +	fill_memblock();
>>
>> Maybe we don't need this line, it has no effect at here. Anyway, Others
>> Looks Good to me.
>>
> Do you mean that it's not necessary since the test doesn't run
> verify_mem_content()?
> 

Yes. And the test function name is alloc_no_memory_...(). So I just 
think no memory operation in it may be same with the function name.

>> Reviewed-by: Shaoqin Huang <shaoqin.huang@intel.com>
>>
>>>    	allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
>>> @@ -472,6 +487,8 @@ static int alloc_bottom_up_simple_check(void)
>>>    	allocated_ptr = memblock_alloc(SZ_2, SMP_CACHE_BYTES);
>>>    	ASSERT_NE(allocated_ptr, NULL);
>>> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, SZ_2);
>>> +
>>>    	ASSERT_EQ(rgn->size, SZ_2);
>>>    	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
>>> @@ -528,6 +545,7 @@ static int alloc_bottom_up_disjoint_check(void)
>>>    	allocated_ptr = memblock_alloc(r2_size, alignment);
>>>    	ASSERT_NE(allocated_ptr, NULL);
>>> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
>>>    	ASSERT_EQ(rgn1->size, r1.size);
>>>    	ASSERT_EQ(rgn1->base, r1.base);
>>> @@ -571,6 +589,8 @@ static int alloc_bottom_up_before_check(void)
>>>    	allocated_ptr = memblock_alloc(r1_size, SMP_CACHE_BYTES);
>>>    	ASSERT_NE(allocated_ptr, NULL);
>>> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r1_size);
>>> +
>>>    	ASSERT_EQ(rgn->size, total_size);
>>>    	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
>>> @@ -618,6 +638,8 @@ static int alloc_bottom_up_after_check(void)
>>>    	allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
>>>    	ASSERT_NE(allocated_ptr, NULL);
>>> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r2_size);
>>> +
>>>    	ASSERT_EQ(rgn->size, total_size);
>>>    	ASSERT_EQ(rgn->base, r1.base);
>>> @@ -669,6 +691,8 @@ static int alloc_bottom_up_second_fit_check(void)
>>>    	allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
>>>    	ASSERT_NE(allocated_ptr, NULL);
>>> +	ASSERT_MEM_EQ((char *)allocated_ptr, 0, r3_size);
>>> +
>>>    	ASSERT_EQ(rgn->size, r2.size + r3_size);
>>>    	ASSERT_EQ(rgn->base, r2.base);
>>> diff --git a/tools/testing/memblock/tests/common.c b/tools/testing/memblock/tests/common.c
>>> index 76a8ad818f3a..0ca26fe12c38 100644
>>> --- a/tools/testing/memblock/tests/common.c
>>> +++ b/tools/testing/memblock/tests/common.c
>>> @@ -60,16 +60,23 @@ void reset_memblock_attributes(void)
>>>    	memblock.current_limit	= MEMBLOCK_ALLOC_ANYWHERE;
>>>    }
>>> +void fill_memblock(void)
>>> +{
>>> +	memset(memory_block.base, 1, MEM_SIZE);
>>> +}
>>> +
>>>    void setup_memblock(void)
>>>    {
>>>    	reset_memblock_regions();
>>>    	memblock_add((phys_addr_t)memory_block.base, MEM_SIZE);
>>> +	fill_memblock();
>>>    }
>>>    void dummy_physical_memory_init(void)
>>>    {
>>>    	memory_block.base = malloc(MEM_SIZE);
>>>    	assert(memory_block.base);
>>> +	fill_memblock();
>>>    }
>>>    void dummy_physical_memory_cleanup(void)
>>> diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h
>>> index d396e5423a8e..7a16a7dc8f2c 100644
>>> --- a/tools/testing/memblock/tests/common.h
>>> +++ b/tools/testing/memblock/tests/common.h
>>> @@ -51,6 +51,18 @@
>>>    	assert((_expected) < (_seen)); \
>>>    } while (0)
>>> +/**
>>> + * ASSERT_MEM_EQ():
>>> + * Check that the first @_size bytes of @_seen are all equal to @_expected.
>>> + * If false, print failed test message (if running with --verbose) and then
>>> + * assert.
>>> + */
>>> +#define ASSERT_MEM_EQ(_seen, _expected, _size) do { \
>>> +	for (int _i = 0; _i < (_size); _i++) { \
>>> +		ASSERT_EQ((_seen)[_i], (_expected)); \
>>> +	} \
>>> +} while (0)
>>> +
>>>    #define PREFIX_PUSH() prefix_push(__func__)
>>>    /*
>>> @@ -70,6 +82,7 @@ struct region {
>>>    void reset_memblock_regions(void);
>>>    void reset_memblock_attributes(void);
>>> +void fill_memblock(void);
>>>    void setup_memblock(void);
>>>    void dummy_physical_memory_init(void);
>>>    void dummy_physical_memory_cleanup(void);

Re: [PATCH 3/8] memblock tests: add labels to verbose output for generic alloc tests

[Rebecca Mckeever]

On Mon, Aug 15, 2022 at 05:15:47PM +0800, Huang, Shaoqin wrote:
> I found original some of test function has the prefix `top_down` and
> `bottom_up`, and some of test function didn't have the prefix.
> 
> In this patch, it just modified these functions which didn't have the prefix
> `top_down` or `bottom_up`, and now there are two style about these test
> functions in the code.
> 
> One is:
> 	run_top_down(alloc_in_between_generic_check);
> 	run_bottom_up(alloc_in_between_generic_check);
> 
> Another one is:
> 	memblock_set_bottom_up(false);
> 	alloc_top_down_before_check();
> 	memblock_set_bottom_up(true);
> 	alloc_bottom_up_before_check();
> 
> Thus there gonna be two output style, here is an example:
> ok 89 : memblock_alloc_from: top-down: alloc_from_simple_generic_check:
> passed
> ok 90 : memblock_alloc_from: bottom-up: alloc_from_simple_generic_check:
> passed
> 
> ok 99 : memblock_alloc_try_nid: alloc_try_nid_top_down_simple_check: passed
> ok 100 : memblock_alloc_try_nid: alloc_try_nid_bottom_up_simple_check:
> passed
> 
> It may make confuse if one is printed between the colon and one is inside
> the function name.
> 
> So maybe make the style consistent is more make sense. And I think this can
> be done by modify all these function name which with `top_down` and
> `bottom_up` inside, and replace them with your new run_top_down() and
> run_bottom_up() functions.
> 
So you're saying use run_top_down() and run_bottom_up() even for functions
with `top_down` and `bottom_up` in the name, but don't change the names?

> On 8/14/2022 1:53 PM, Rebecca Mckeever wrote:
> > Generic tests for memblock_alloc*() functions do not use separate
> > functions for testing top-down and bottom-up allocation directions.
> > Therefore, the function name that is displayed in the verbose testing
> > output does not include the allocation direction.
> > 
> > Add an additional prefix when running generic tests for
> > memblock_alloc*() functions that indicates which allocation direction is
> > set. The prefix will be displayed when the tests are run in verbose mode.
> > 
> > Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> > ---
> >   tools/testing/memblock/tests/alloc_api.c      | 36 +++++++------------
> >   .../memblock/tests/alloc_helpers_api.c        | 12 +++----
> >   tools/testing/memblock/tests/alloc_nid_api.c  | 36 +++++++------------
> >   tools/testing/memblock/tests/common.h         | 16 +++++++++
> >   4 files changed, 44 insertions(+), 56 deletions(-)
> > 
> > diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
> > index 71c89cb9b2a8..73c2c43e702a 100644
> > --- a/tools/testing/memblock/tests/alloc_api.c
> > +++ b/tools/testing/memblock/tests/alloc_api.c
> > @@ -752,10 +752,8 @@ static int alloc_after_check(void)
> >   static int alloc_in_between_check(void)
> >   {
> >   	test_print("\tRunning %s...\n", __func__);
> > -	memblock_set_bottom_up(false);
> > -	alloc_in_between_generic_check();
> > -	memblock_set_bottom_up(true);
> > -	alloc_in_between_generic_check();
> > +	run_top_down(alloc_in_between_generic_check);
> > +	run_bottom_up(alloc_in_between_generic_check);
> >   	return 0;
> >   }
> > @@ -774,10 +772,8 @@ static int alloc_second_fit_check(void)
> >   static int alloc_small_gaps_check(void)
> >   {
> >   	test_print("\tRunning %s...\n", __func__);
> > -	memblock_set_bottom_up(false);
> > -	alloc_small_gaps_generic_check();
> > -	memblock_set_bottom_up(true);
> > -	alloc_small_gaps_generic_check();
> > +	run_top_down(alloc_small_gaps_generic_check);
> > +	run_bottom_up(alloc_small_gaps_generic_check);
> >   	return 0;
> >   }
> > @@ -785,10 +781,8 @@ static int alloc_small_gaps_check(void)
> >   static int alloc_all_reserved_check(void)
> >   {
> >   	test_print("\tRunning %s...\n", __func__);
> > -	memblock_set_bottom_up(false);
> > -	alloc_all_reserved_generic_check();
> > -	memblock_set_bottom_up(true);
> > -	alloc_all_reserved_generic_check();
> > +	run_top_down(alloc_all_reserved_generic_check);
> > +	run_bottom_up(alloc_all_reserved_generic_check);
> >   	return 0;
> >   }
> > @@ -796,10 +790,8 @@ static int alloc_all_reserved_check(void)
> >   static int alloc_no_space_check(void)
> >   {
> >   	test_print("\tRunning %s...\n", __func__);
> > -	memblock_set_bottom_up(false);
> > -	alloc_no_space_generic_check();
> > -	memblock_set_bottom_up(true);
> > -	alloc_no_space_generic_check();
> > +	run_top_down(alloc_no_space_generic_check);
> > +	run_bottom_up(alloc_no_space_generic_check);
> >   	return 0;
> >   }
> > @@ -807,10 +799,8 @@ static int alloc_no_space_check(void)
> >   static int alloc_limited_space_check(void)
> >   {
> >   	test_print("\tRunning %s...\n", __func__);
> > -	memblock_set_bottom_up(false);
> > -	alloc_limited_space_generic_check();
> > -	memblock_set_bottom_up(true);
> > -	alloc_limited_space_generic_check();
> > +	run_top_down(alloc_limited_space_generic_check);
> > +	run_bottom_up(alloc_limited_space_generic_check);
> >   	return 0;
> >   }
> > @@ -818,10 +808,8 @@ static int alloc_limited_space_check(void)
> >   static int alloc_no_memory_check(void)
> >   {
> >   	test_print("\tRunning %s...\n", __func__);
> > -	memblock_set_bottom_up(false);
> > -	alloc_no_memory_generic_check();
> > -	memblock_set_bottom_up(true);
> > -	alloc_no_memory_generic_check();
> > +	run_top_down(alloc_no_memory_generic_check);
> > +	run_bottom_up(alloc_no_memory_generic_check);
> >   	return 0;
> >   }
> > diff --git a/tools/testing/memblock/tests/alloc_helpers_api.c b/tools/testing/memblock/tests/alloc_helpers_api.c
> > index 796527cf3bd2..1ccf02639ad6 100644
> > --- a/tools/testing/memblock/tests/alloc_helpers_api.c
> > +++ b/tools/testing/memblock/tests/alloc_helpers_api.c
> > @@ -357,10 +357,8 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
> >   static int alloc_from_simple_check(void)
> >   {
> >   	test_print("\tRunning %s...\n", __func__);
> > -	memblock_set_bottom_up(false);
> > -	alloc_from_simple_generic_check();
> > -	memblock_set_bottom_up(true);
> > -	alloc_from_simple_generic_check();
> > +	run_top_down(alloc_from_simple_generic_check);
> > +	run_bottom_up(alloc_from_simple_generic_check);
> >   	return 0;
> >   }
> > @@ -368,10 +366,8 @@ static int alloc_from_simple_check(void)
> >   static int alloc_from_misaligned_check(void)
> >   {
> >   	test_print("\tRunning %s...\n", __func__);
> > -	memblock_set_bottom_up(false);
> > -	alloc_from_misaligned_generic_check();
> > -	memblock_set_bottom_up(true);
> > -	alloc_from_misaligned_generic_check();
> > +	run_top_down(alloc_from_misaligned_generic_check);
> > +	run_bottom_up(alloc_from_misaligned_generic_check);
> >   	return 0;
> >   }
> > diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
> > index 71b7beb35526..82fa8ea36320 100644
> > --- a/tools/testing/memblock/tests/alloc_nid_api.c
> > +++ b/tools/testing/memblock/tests/alloc_nid_api.c
> > @@ -1142,10 +1142,8 @@ static int alloc_try_nid_cap_min_check(void)
> >   static int alloc_try_nid_min_reserved_check(void)
> >   {
> >   	test_print("\tRunning %s...\n", __func__);
> > -	memblock_set_bottom_up(false);
> > -	alloc_try_nid_min_reserved_generic_check();
> > -	memblock_set_bottom_up(true);
> > -	alloc_try_nid_min_reserved_generic_check();
> > +	run_top_down(alloc_try_nid_min_reserved_generic_check);
> > +	run_bottom_up(alloc_try_nid_min_reserved_generic_check);
> >   	return 0;
> >   }
> > @@ -1153,10 +1151,8 @@ static int alloc_try_nid_min_reserved_check(void)
> >   static int alloc_try_nid_max_reserved_check(void)
> >   {
> >   	test_print("\tRunning %s...\n", __func__);
> > -	memblock_set_bottom_up(false);
> > -	alloc_try_nid_max_reserved_generic_check();
> > -	memblock_set_bottom_up(true);
> > -	alloc_try_nid_max_reserved_generic_check();
> > +	run_top_down(alloc_try_nid_max_reserved_generic_check);
> > +	run_bottom_up(alloc_try_nid_max_reserved_generic_check);
> >   	return 0;
> >   }
> > @@ -1164,10 +1160,8 @@ static int alloc_try_nid_max_reserved_check(void)
> >   static int alloc_try_nid_exact_address_check(void)
> >   {
> >   	test_print("\tRunning %s...\n", __func__);
> > -	memblock_set_bottom_up(false);
> > -	alloc_try_nid_exact_address_generic_check();
> > -	memblock_set_bottom_up(true);
> > -	alloc_try_nid_exact_address_generic_check();
> > +	run_top_down(alloc_try_nid_exact_address_generic_check);
> > +	run_bottom_up(alloc_try_nid_exact_address_generic_check);
> >   	return 0;
> >   }
> > @@ -1175,10 +1169,8 @@ static int alloc_try_nid_exact_address_check(void)
> >   static int alloc_try_nid_reserved_full_merge_check(void)
> >   {
> >   	test_print("\tRunning %s...\n", __func__);
> > -	memblock_set_bottom_up(false);
> > -	alloc_try_nid_reserved_full_merge_generic_check();
> > -	memblock_set_bottom_up(true);
> > -	alloc_try_nid_reserved_full_merge_generic_check();
> > +	run_top_down(alloc_try_nid_reserved_full_merge_generic_check);
> > +	run_bottom_up(alloc_try_nid_reserved_full_merge_generic_check);
> >   	return 0;
> >   }
> > @@ -1186,10 +1178,8 @@ static int alloc_try_nid_reserved_full_merge_check(void)
> >   static int alloc_try_nid_reserved_all_check(void)
> >   {
> >   	test_print("\tRunning %s...\n", __func__);
> > -	memblock_set_bottom_up(false);
> > -	alloc_try_nid_reserved_all_generic_check();
> > -	memblock_set_bottom_up(true);
> > -	alloc_try_nid_reserved_all_generic_check();
> > +	run_top_down(alloc_try_nid_reserved_all_generic_check);
> > +	run_bottom_up(alloc_try_nid_reserved_all_generic_check);
> >   	return 0;
> >   }
> > @@ -1197,10 +1187,8 @@ static int alloc_try_nid_reserved_all_check(void)
> >   static int alloc_try_nid_low_max_check(void)
> >   {
> >   	test_print("\tRunning %s...\n", __func__);
> > -	memblock_set_bottom_up(false);
> > -	alloc_try_nid_low_max_generic_check();
> > -	memblock_set_bottom_up(true);
> > -	alloc_try_nid_low_max_generic_check();
> > +	run_top_down(alloc_try_nid_low_max_generic_check);
> > +	run_bottom_up(alloc_try_nid_low_max_generic_check);
> >   	return 0;
> >   }
> > diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h
> > index 7a16a7dc8f2c..e0dd5b410099 100644
> > --- a/tools/testing/memblock/tests/common.h
> > +++ b/tools/testing/memblock/tests/common.h
> > @@ -101,4 +101,20 @@ static inline void test_pass_pop(void)
> >   	prefix_pop();
> >   }
> > +static inline void run_top_down(int (*func)())
> > +{
> > +	memblock_set_bottom_up(false);
> > +	prefix_push("top-down");
> > +	func();
> > +	prefix_pop();
> > +}
> > +
> > +static inline void run_bottom_up(int (*func)())
> > +{
> > +	memblock_set_bottom_up(true);
> > +	prefix_push("bottom-up");
> > +	func();
> > +	prefix_pop();
> > +}
> > +
> >   #endif

Re: [PATCH 3/8] memblock tests: add labels to verbose output for generic alloc tests

[Huang, Shaoqin]

On 8/16/2022 10:39 AM, Rebecca Mckeever wrote:
> On Mon, Aug 15, 2022 at 05:15:47PM +0800, Huang, Shaoqin wrote:
>> I found original some of test function has the prefix `top_down` and
>> `bottom_up`, and some of test function didn't have the prefix.
>>
>> In this patch, it just modified these functions which didn't have the prefix
>> `top_down` or `bottom_up`, and now there are two style about these test
>> functions in the code.
>>
>> One is:
>> 	run_top_down(alloc_in_between_generic_check);
>> 	run_bottom_up(alloc_in_between_generic_check);
>>
>> Another one is:
>> 	memblock_set_bottom_up(false);
>> 	alloc_top_down_before_check();
>> 	memblock_set_bottom_up(true);
>> 	alloc_bottom_up_before_check();
>>
>> Thus there gonna be two output style, here is an example:
>> ok 89 : memblock_alloc_from: top-down: alloc_from_simple_generic_check:
>> passed
>> ok 90 : memblock_alloc_from: bottom-up: alloc_from_simple_generic_check:
>> passed
>>
>> ok 99 : memblock_alloc_try_nid: alloc_try_nid_top_down_simple_check: passed
>> ok 100 : memblock_alloc_try_nid: alloc_try_nid_bottom_up_simple_check:
>> passed
>>
>> It may make confuse if one is printed between the colon and one is inside
>> the function name.
>>
>> So maybe make the style consistent is more make sense. And I think this can
>> be done by modify all these function name which with `top_down` and
>> `bottom_up` inside, and replace them with your new run_top_down() and
>> run_bottom_up() functions.
>>
> So you're saying use run_top_down() and run_bottom_up() even for functions
> with `top_down` and `bottom_up` in the name, but don't change the names?
> 

Yes. We can't delete these `top_down` and `bottom_up` in the name and 
makes two functions to have the same name. Due to these functions with 
`top_down` and `bottom_up` have different implementation.

If use run_top_down() and run_bottom_up() for these functions. We can 
get the consistent output style, but a little redundant output(Maybe 
this isn't a good idea).

>> On 8/14/2022 1:53 PM, Rebecca Mckeever wrote:
>>> Generic tests for memblock_alloc*() functions do not use separate
>>> functions for testing top-down and bottom-up allocation directions.
>>> Therefore, the function name that is displayed in the verbose testing
>>> output does not include the allocation direction.
>>>
>>> Add an additional prefix when running generic tests for
>>> memblock_alloc*() functions that indicates which allocation direction is
>>> set. The prefix will be displayed when the tests are run in verbose mode.
>>>
>>> Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
>>> ---
>>>    tools/testing/memblock/tests/alloc_api.c      | 36 +++++++------------
>>>    .../memblock/tests/alloc_helpers_api.c        | 12 +++----
>>>    tools/testing/memblock/tests/alloc_nid_api.c  | 36 +++++++------------
>>>    tools/testing/memblock/tests/common.h         | 16 +++++++++
>>>    4 files changed, 44 insertions(+), 56 deletions(-)
>>>
>>> diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
>>> index 71c89cb9b2a8..73c2c43e702a 100644
>>> --- a/tools/testing/memblock/tests/alloc_api.c
>>> +++ b/tools/testing/memblock/tests/alloc_api.c
>>> @@ -752,10 +752,8 @@ static int alloc_after_check(void)
>>>    static int alloc_in_between_check(void)
>>>    {
>>>    	test_print("\tRunning %s...\n", __func__);
>>> -	memblock_set_bottom_up(false);
>>> -	alloc_in_between_generic_check();
>>> -	memblock_set_bottom_up(true);
>>> -	alloc_in_between_generic_check();
>>> +	run_top_down(alloc_in_between_generic_check);
>>> +	run_bottom_up(alloc_in_between_generic_check);
>>>    	return 0;
>>>    }
>>> @@ -774,10 +772,8 @@ static int alloc_second_fit_check(void)
>>>    static int alloc_small_gaps_check(void)
>>>    {
>>>    	test_print("\tRunning %s...\n", __func__);
>>> -	memblock_set_bottom_up(false);
>>> -	alloc_small_gaps_generic_check();
>>> -	memblock_set_bottom_up(true);
>>> -	alloc_small_gaps_generic_check();
>>> +	run_top_down(alloc_small_gaps_generic_check);
>>> +	run_bottom_up(alloc_small_gaps_generic_check);
>>>    	return 0;
>>>    }
>>> @@ -785,10 +781,8 @@ static int alloc_small_gaps_check(void)
>>>    static int alloc_all_reserved_check(void)
>>>    {
>>>    	test_print("\tRunning %s...\n", __func__);
>>> -	memblock_set_bottom_up(false);
>>> -	alloc_all_reserved_generic_check();
>>> -	memblock_set_bottom_up(true);
>>> -	alloc_all_reserved_generic_check();
>>> +	run_top_down(alloc_all_reserved_generic_check);
>>> +	run_bottom_up(alloc_all_reserved_generic_check);
>>>    	return 0;
>>>    }
>>> @@ -796,10 +790,8 @@ static int alloc_all_reserved_check(void)
>>>    static int alloc_no_space_check(void)
>>>    {
>>>    	test_print("\tRunning %s...\n", __func__);
>>> -	memblock_set_bottom_up(false);
>>> -	alloc_no_space_generic_check();
>>> -	memblock_set_bottom_up(true);
>>> -	alloc_no_space_generic_check();
>>> +	run_top_down(alloc_no_space_generic_check);
>>> +	run_bottom_up(alloc_no_space_generic_check);
>>>    	return 0;
>>>    }
>>> @@ -807,10 +799,8 @@ static int alloc_no_space_check(void)
>>>    static int alloc_limited_space_check(void)
>>>    {
>>>    	test_print("\tRunning %s...\n", __func__);
>>> -	memblock_set_bottom_up(false);
>>> -	alloc_limited_space_generic_check();
>>> -	memblock_set_bottom_up(true);
>>> -	alloc_limited_space_generic_check();
>>> +	run_top_down(alloc_limited_space_generic_check);
>>> +	run_bottom_up(alloc_limited_space_generic_check);
>>>    	return 0;
>>>    }
>>> @@ -818,10 +808,8 @@ static int alloc_limited_space_check(void)
>>>    static int alloc_no_memory_check(void)
>>>    {
>>>    	test_print("\tRunning %s...\n", __func__);
>>> -	memblock_set_bottom_up(false);
>>> -	alloc_no_memory_generic_check();
>>> -	memblock_set_bottom_up(true);
>>> -	alloc_no_memory_generic_check();
>>> +	run_top_down(alloc_no_memory_generic_check);
>>> +	run_bottom_up(alloc_no_memory_generic_check);
>>>    	return 0;
>>>    }
>>> diff --git a/tools/testing/memblock/tests/alloc_helpers_api.c b/tools/testing/memblock/tests/alloc_helpers_api.c
>>> index 796527cf3bd2..1ccf02639ad6 100644
>>> --- a/tools/testing/memblock/tests/alloc_helpers_api.c
>>> +++ b/tools/testing/memblock/tests/alloc_helpers_api.c
>>> @@ -357,10 +357,8 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
>>>    static int alloc_from_simple_check(void)
>>>    {
>>>    	test_print("\tRunning %s...\n", __func__);
>>> -	memblock_set_bottom_up(false);
>>> -	alloc_from_simple_generic_check();
>>> -	memblock_set_bottom_up(true);
>>> -	alloc_from_simple_generic_check();
>>> +	run_top_down(alloc_from_simple_generic_check);
>>> +	run_bottom_up(alloc_from_simple_generic_check);
>>>    	return 0;
>>>    }
>>> @@ -368,10 +366,8 @@ static int alloc_from_simple_check(void)
>>>    static int alloc_from_misaligned_check(void)
>>>    {
>>>    	test_print("\tRunning %s...\n", __func__);
>>> -	memblock_set_bottom_up(false);
>>> -	alloc_from_misaligned_generic_check();
>>> -	memblock_set_bottom_up(true);
>>> -	alloc_from_misaligned_generic_check();
>>> +	run_top_down(alloc_from_misaligned_generic_check);
>>> +	run_bottom_up(alloc_from_misaligned_generic_check);
>>>    	return 0;
>>>    }
>>> diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
>>> index 71b7beb35526..82fa8ea36320 100644
>>> --- a/tools/testing/memblock/tests/alloc_nid_api.c
>>> +++ b/tools/testing/memblock/tests/alloc_nid_api.c
>>> @@ -1142,10 +1142,8 @@ static int alloc_try_nid_cap_min_check(void)
>>>    static int alloc_try_nid_min_reserved_check(void)
>>>    {
>>>    	test_print("\tRunning %s...\n", __func__);
>>> -	memblock_set_bottom_up(false);
>>> -	alloc_try_nid_min_reserved_generic_check();
>>> -	memblock_set_bottom_up(true);
>>> -	alloc_try_nid_min_reserved_generic_check();
>>> +	run_top_down(alloc_try_nid_min_reserved_generic_check);
>>> +	run_bottom_up(alloc_try_nid_min_reserved_generic_check);
>>>    	return 0;
>>>    }
>>> @@ -1153,10 +1151,8 @@ static int alloc_try_nid_min_reserved_check(void)
>>>    static int alloc_try_nid_max_reserved_check(void)
>>>    {
>>>    	test_print("\tRunning %s...\n", __func__);
>>> -	memblock_set_bottom_up(false);
>>> -	alloc_try_nid_max_reserved_generic_check();
>>> -	memblock_set_bottom_up(true);
>>> -	alloc_try_nid_max_reserved_generic_check();
>>> +	run_top_down(alloc_try_nid_max_reserved_generic_check);
>>> +	run_bottom_up(alloc_try_nid_max_reserved_generic_check);
>>>    	return 0;
>>>    }
>>> @@ -1164,10 +1160,8 @@ static int alloc_try_nid_max_reserved_check(void)
>>>    static int alloc_try_nid_exact_address_check(void)
>>>    {
>>>    	test_print("\tRunning %s...\n", __func__);
>>> -	memblock_set_bottom_up(false);
>>> -	alloc_try_nid_exact_address_generic_check();
>>> -	memblock_set_bottom_up(true);
>>> -	alloc_try_nid_exact_address_generic_check();
>>> +	run_top_down(alloc_try_nid_exact_address_generic_check);
>>> +	run_bottom_up(alloc_try_nid_exact_address_generic_check);
>>>    	return 0;
>>>    }
>>> @@ -1175,10 +1169,8 @@ static int alloc_try_nid_exact_address_check(void)
>>>    static int alloc_try_nid_reserved_full_merge_check(void)
>>>    {
>>>    	test_print("\tRunning %s...\n", __func__);
>>> -	memblock_set_bottom_up(false);
>>> -	alloc_try_nid_reserved_full_merge_generic_check();
>>> -	memblock_set_bottom_up(true);
>>> -	alloc_try_nid_reserved_full_merge_generic_check();
>>> +	run_top_down(alloc_try_nid_reserved_full_merge_generic_check);
>>> +	run_bottom_up(alloc_try_nid_reserved_full_merge_generic_check);
>>>    	return 0;
>>>    }
>>> @@ -1186,10 +1178,8 @@ static int alloc_try_nid_reserved_full_merge_check(void)
>>>    static int alloc_try_nid_reserved_all_check(void)
>>>    {
>>>    	test_print("\tRunning %s...\n", __func__);
>>> -	memblock_set_bottom_up(false);
>>> -	alloc_try_nid_reserved_all_generic_check();
>>> -	memblock_set_bottom_up(true);
>>> -	alloc_try_nid_reserved_all_generic_check();
>>> +	run_top_down(alloc_try_nid_reserved_all_generic_check);
>>> +	run_bottom_up(alloc_try_nid_reserved_all_generic_check);
>>>    	return 0;
>>>    }
>>> @@ -1197,10 +1187,8 @@ static int alloc_try_nid_reserved_all_check(void)
>>>    static int alloc_try_nid_low_max_check(void)
>>>    {
>>>    	test_print("\tRunning %s...\n", __func__);
>>> -	memblock_set_bottom_up(false);
>>> -	alloc_try_nid_low_max_generic_check();
>>> -	memblock_set_bottom_up(true);
>>> -	alloc_try_nid_low_max_generic_check();
>>> +	run_top_down(alloc_try_nid_low_max_generic_check);
>>> +	run_bottom_up(alloc_try_nid_low_max_generic_check);
>>>    	return 0;
>>>    }
>>> diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h
>>> index 7a16a7dc8f2c..e0dd5b410099 100644
>>> --- a/tools/testing/memblock/tests/common.h
>>> +++ b/tools/testing/memblock/tests/common.h
>>> @@ -101,4 +101,20 @@ static inline void test_pass_pop(void)
>>>    	prefix_pop();
>>>    }
>>> +static inline void run_top_down(int (*func)())
>>> +{
>>> +	memblock_set_bottom_up(false);
>>> +	prefix_push("top-down");
>>> +	func();
>>> +	prefix_pop();
>>> +}
>>> +
>>> +static inline void run_bottom_up(int (*func)())
>>> +{
>>> +	memblock_set_bottom_up(true);
>>> +	prefix_push("bottom-up");
>>> +	func();
>>> +	prefix_pop();
>>> +}
>>> +
>>>    #endif

Re: [PATCH 3/8] memblock tests: add labels to verbose output for generic alloc tests

[Rebecca Mckeever]

On Tue, Aug 16, 2022 at 11:08:44AM +0800, Huang, Shaoqin wrote:
> 
> 
> On 8/16/2022 10:39 AM, Rebecca Mckeever wrote:
> > On Mon, Aug 15, 2022 at 05:15:47PM +0800, Huang, Shaoqin wrote:
> > > I found original some of test function has the prefix `top_down` and
> > > `bottom_up`, and some of test function didn't have the prefix.
> > > 
> > > In this patch, it just modified these functions which didn't have the prefix
> > > `top_down` or `bottom_up`, and now there are two style about these test
> > > functions in the code.
> > > 
> > > One is:
> > > 	run_top_down(alloc_in_between_generic_check);
> > > 	run_bottom_up(alloc_in_between_generic_check);
> > > 
> > > Another one is:
> > > 	memblock_set_bottom_up(false);
> > > 	alloc_top_down_before_check();
> > > 	memblock_set_bottom_up(true);
> > > 	alloc_bottom_up_before_check();
> > > 
> > > Thus there gonna be two output style, here is an example:
> > > ok 89 : memblock_alloc_from: top-down: alloc_from_simple_generic_check:
> > > passed
> > > ok 90 : memblock_alloc_from: bottom-up: alloc_from_simple_generic_check:
> > > passed
> > > 
> > > ok 99 : memblock_alloc_try_nid: alloc_try_nid_top_down_simple_check: passed
> > > ok 100 : memblock_alloc_try_nid: alloc_try_nid_bottom_up_simple_check:
> > > passed
> > > 
> > > It may make confuse if one is printed between the colon and one is inside
> > > the function name.
> > > 
> > > So maybe make the style consistent is more make sense. And I think this can
> > > be done by modify all these function name which with `top_down` and
> > > `bottom_up` inside, and replace them with your new run_top_down() and
> > > run_bottom_up() functions.
> > > 
> > So you're saying use run_top_down() and run_bottom_up() even for functions
> > with `top_down` and `bottom_up` in the name, but don't change the names?
> > 
> 
> Yes. We can't delete these `top_down` and `bottom_up` in the name and makes
> two functions to have the same name. Due to these functions with `top_down`
> and `bottom_up` have different implementation.
> 
> If use run_top_down() and run_bottom_up() for these functions. We can get
> the consistent output style, but a little redundant output(Maybe this isn't
> a good idea).
> 
Yes, I think the output would be too redundant. Even though there are
two different output styles, the style is consistent within each pair of
tests. So there is at least a consistent pattern.

> > > On 8/14/2022 1:53 PM, Rebecca Mckeever wrote:
> > > > Generic tests for memblock_alloc*() functions do not use separate
> > > > functions for testing top-down and bottom-up allocation directions.
> > > > Therefore, the function name that is displayed in the verbose testing
> > > > output does not include the allocation direction.
> > > > 
> > > > Add an additional prefix when running generic tests for
> > > > memblock_alloc*() functions that indicates which allocation direction is
> > > > set. The prefix will be displayed when the tests are run in verbose mode.
> > > > 
> > > > Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> > > > ---
> > > >    tools/testing/memblock/tests/alloc_api.c      | 36 +++++++------------
> > > >    .../memblock/tests/alloc_helpers_api.c        | 12 +++----
> > > >    tools/testing/memblock/tests/alloc_nid_api.c  | 36 +++++++------------
> > > >    tools/testing/memblock/tests/common.h         | 16 +++++++++
> > > >    4 files changed, 44 insertions(+), 56 deletions(-)
> > > > 
> > > > diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
> > > > index 71c89cb9b2a8..73c2c43e702a 100644
> > > > --- a/tools/testing/memblock/tests/alloc_api.c
> > > > +++ b/tools/testing/memblock/tests/alloc_api.c
> > > > @@ -752,10 +752,8 @@ static int alloc_after_check(void)
> > > >    static int alloc_in_between_check(void)
> > > >    {
> > > >    	test_print("\tRunning %s...\n", __func__);
> > > > -	memblock_set_bottom_up(false);
> > > > -	alloc_in_between_generic_check();
> > > > -	memblock_set_bottom_up(true);
> > > > -	alloc_in_between_generic_check();
> > > > +	run_top_down(alloc_in_between_generic_check);
> > > > +	run_bottom_up(alloc_in_between_generic_check);
> > > >    	return 0;
> > > >    }
> > > > @@ -774,10 +772,8 @@ static int alloc_second_fit_check(void)
> > > >    static int alloc_small_gaps_check(void)
> > > >    {
> > > >    	test_print("\tRunning %s...\n", __func__);
> > > > -	memblock_set_bottom_up(false);
> > > > -	alloc_small_gaps_generic_check();
> > > > -	memblock_set_bottom_up(true);
> > > > -	alloc_small_gaps_generic_check();
> > > > +	run_top_down(alloc_small_gaps_generic_check);
> > > > +	run_bottom_up(alloc_small_gaps_generic_check);
> > > >    	return 0;
> > > >    }
> > > > @@ -785,10 +781,8 @@ static int alloc_small_gaps_check(void)
> > > >    static int alloc_all_reserved_check(void)
> > > >    {
> > > >    	test_print("\tRunning %s...\n", __func__);
> > > > -	memblock_set_bottom_up(false);
> > > > -	alloc_all_reserved_generic_check();
> > > > -	memblock_set_bottom_up(true);
> > > > -	alloc_all_reserved_generic_check();
> > > > +	run_top_down(alloc_all_reserved_generic_check);
> > > > +	run_bottom_up(alloc_all_reserved_generic_check);
> > > >    	return 0;
> > > >    }
> > > > @@ -796,10 +790,8 @@ static int alloc_all_reserved_check(void)
> > > >    static int alloc_no_space_check(void)
> > > >    {
> > > >    	test_print("\tRunning %s...\n", __func__);
> > > > -	memblock_set_bottom_up(false);
> > > > -	alloc_no_space_generic_check();
> > > > -	memblock_set_bottom_up(true);
> > > > -	alloc_no_space_generic_check();
> > > > +	run_top_down(alloc_no_space_generic_check);
> > > > +	run_bottom_up(alloc_no_space_generic_check);
> > > >    	return 0;
> > > >    }
> > > > @@ -807,10 +799,8 @@ static int alloc_no_space_check(void)
> > > >    static int alloc_limited_space_check(void)
> > > >    {
> > > >    	test_print("\tRunning %s...\n", __func__);
> > > > -	memblock_set_bottom_up(false);
> > > > -	alloc_limited_space_generic_check();
> > > > -	memblock_set_bottom_up(true);
> > > > -	alloc_limited_space_generic_check();
> > > > +	run_top_down(alloc_limited_space_generic_check);
> > > > +	run_bottom_up(alloc_limited_space_generic_check);
> > > >    	return 0;
> > > >    }
> > > > @@ -818,10 +808,8 @@ static int alloc_limited_space_check(void)
> > > >    static int alloc_no_memory_check(void)
> > > >    {
> > > >    	test_print("\tRunning %s...\n", __func__);
> > > > -	memblock_set_bottom_up(false);
> > > > -	alloc_no_memory_generic_check();
> > > > -	memblock_set_bottom_up(true);
> > > > -	alloc_no_memory_generic_check();
> > > > +	run_top_down(alloc_no_memory_generic_check);
> > > > +	run_bottom_up(alloc_no_memory_generic_check);
> > > >    	return 0;
> > > >    }
> > > > diff --git a/tools/testing/memblock/tests/alloc_helpers_api.c b/tools/testing/memblock/tests/alloc_helpers_api.c
> > > > index 796527cf3bd2..1ccf02639ad6 100644
> > > > --- a/tools/testing/memblock/tests/alloc_helpers_api.c
> > > > +++ b/tools/testing/memblock/tests/alloc_helpers_api.c
> > > > @@ -357,10 +357,8 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
> > > >    static int alloc_from_simple_check(void)
> > > >    {
> > > >    	test_print("\tRunning %s...\n", __func__);
> > > > -	memblock_set_bottom_up(false);
> > > > -	alloc_from_simple_generic_check();
> > > > -	memblock_set_bottom_up(true);
> > > > -	alloc_from_simple_generic_check();
> > > > +	run_top_down(alloc_from_simple_generic_check);
> > > > +	run_bottom_up(alloc_from_simple_generic_check);
> > > >    	return 0;
> > > >    }
> > > > @@ -368,10 +366,8 @@ static int alloc_from_simple_check(void)
> > > >    static int alloc_from_misaligned_check(void)
> > > >    {
> > > >    	test_print("\tRunning %s...\n", __func__);
> > > > -	memblock_set_bottom_up(false);
> > > > -	alloc_from_misaligned_generic_check();
> > > > -	memblock_set_bottom_up(true);
> > > > -	alloc_from_misaligned_generic_check();
> > > > +	run_top_down(alloc_from_misaligned_generic_check);
> > > > +	run_bottom_up(alloc_from_misaligned_generic_check);
> > > >    	return 0;
> > > >    }
> > > > diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
> > > > index 71b7beb35526..82fa8ea36320 100644
> > > > --- a/tools/testing/memblock/tests/alloc_nid_api.c
> > > > +++ b/tools/testing/memblock/tests/alloc_nid_api.c
> > > > @@ -1142,10 +1142,8 @@ static int alloc_try_nid_cap_min_check(void)
> > > >    static int alloc_try_nid_min_reserved_check(void)
> > > >    {
> > > >    	test_print("\tRunning %s...\n", __func__);
> > > > -	memblock_set_bottom_up(false);
> > > > -	alloc_try_nid_min_reserved_generic_check();
> > > > -	memblock_set_bottom_up(true);
> > > > -	alloc_try_nid_min_reserved_generic_check();
> > > > +	run_top_down(alloc_try_nid_min_reserved_generic_check);
> > > > +	run_bottom_up(alloc_try_nid_min_reserved_generic_check);
> > > >    	return 0;
> > > >    }
> > > > @@ -1153,10 +1151,8 @@ static int alloc_try_nid_min_reserved_check(void)
> > > >    static int alloc_try_nid_max_reserved_check(void)
> > > >    {
> > > >    	test_print("\tRunning %s...\n", __func__);
> > > > -	memblock_set_bottom_up(false);
> > > > -	alloc_try_nid_max_reserved_generic_check();
> > > > -	memblock_set_bottom_up(true);
> > > > -	alloc_try_nid_max_reserved_generic_check();
> > > > +	run_top_down(alloc_try_nid_max_reserved_generic_check);
> > > > +	run_bottom_up(alloc_try_nid_max_reserved_generic_check);
> > > >    	return 0;
> > > >    }
> > > > @@ -1164,10 +1160,8 @@ static int alloc_try_nid_max_reserved_check(void)
> > > >    static int alloc_try_nid_exact_address_check(void)
> > > >    {
> > > >    	test_print("\tRunning %s...\n", __func__);
> > > > -	memblock_set_bottom_up(false);
> > > > -	alloc_try_nid_exact_address_generic_check();
> > > > -	memblock_set_bottom_up(true);
> > > > -	alloc_try_nid_exact_address_generic_check();
> > > > +	run_top_down(alloc_try_nid_exact_address_generic_check);
> > > > +	run_bottom_up(alloc_try_nid_exact_address_generic_check);
> > > >    	return 0;
> > > >    }
> > > > @@ -1175,10 +1169,8 @@ static int alloc_try_nid_exact_address_check(void)
> > > >    static int alloc_try_nid_reserved_full_merge_check(void)
> > > >    {
> > > >    	test_print("\tRunning %s...\n", __func__);
> > > > -	memblock_set_bottom_up(false);
> > > > -	alloc_try_nid_reserved_full_merge_generic_check();
> > > > -	memblock_set_bottom_up(true);
> > > > -	alloc_try_nid_reserved_full_merge_generic_check();
> > > > +	run_top_down(alloc_try_nid_reserved_full_merge_generic_check);
> > > > +	run_bottom_up(alloc_try_nid_reserved_full_merge_generic_check);
> > > >    	return 0;
> > > >    }
> > > > @@ -1186,10 +1178,8 @@ static int alloc_try_nid_reserved_full_merge_check(void)
> > > >    static int alloc_try_nid_reserved_all_check(void)
> > > >    {
> > > >    	test_print("\tRunning %s...\n", __func__);
> > > > -	memblock_set_bottom_up(false);
> > > > -	alloc_try_nid_reserved_all_generic_check();
> > > > -	memblock_set_bottom_up(true);
> > > > -	alloc_try_nid_reserved_all_generic_check();
> > > > +	run_top_down(alloc_try_nid_reserved_all_generic_check);
> > > > +	run_bottom_up(alloc_try_nid_reserved_all_generic_check);
> > > >    	return 0;
> > > >    }
> > > > @@ -1197,10 +1187,8 @@ static int alloc_try_nid_reserved_all_check(void)
> > > >    static int alloc_try_nid_low_max_check(void)
> > > >    {
> > > >    	test_print("\tRunning %s...\n", __func__);
> > > > -	memblock_set_bottom_up(false);
> > > > -	alloc_try_nid_low_max_generic_check();
> > > > -	memblock_set_bottom_up(true);
> > > > -	alloc_try_nid_low_max_generic_check();
> > > > +	run_top_down(alloc_try_nid_low_max_generic_check);
> > > > +	run_bottom_up(alloc_try_nid_low_max_generic_check);
> > > >    	return 0;
> > > >    }
> > > > diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h
> > > > index 7a16a7dc8f2c..e0dd5b410099 100644
> > > > --- a/tools/testing/memblock/tests/common.h
> > > > +++ b/tools/testing/memblock/tests/common.h
> > > > @@ -101,4 +101,20 @@ static inline void test_pass_pop(void)
> > > >    	prefix_pop();
> > > >    }
> > > > +static inline void run_top_down(int (*func)())
> > > > +{
> > > > +	memblock_set_bottom_up(false);
> > > > +	prefix_push("top-down");
> > > > +	func();
> > > > +	prefix_pop();
> > > > +}
> > > > +
> > > > +static inline void run_bottom_up(int (*func)())
> > > > +{
> > > > +	memblock_set_bottom_up(true);
> > > > +	prefix_push("bottom-up");
> > > > +	func();
> > > > +	prefix_pop();
> > > > +}
> > > > +
> > > >    #endif

Thanks,
Rebecca

Re: [PATCH 3/8] memblock tests: add labels to verbose output for generic alloc tests

[Huang, Shaoqin]

On 8/19/2022 1:03 PM, Rebecca Mckeever wrote:
> On Tue, Aug 16, 2022 at 11:08:44AM +0800, Huang, Shaoqin wrote:
>>
>>
>> On 8/16/2022 10:39 AM, Rebecca Mckeever wrote:
>>> On Mon, Aug 15, 2022 at 05:15:47PM +0800, Huang, Shaoqin wrote:
>>>> I found original some of test function has the prefix `top_down` and
>>>> `bottom_up`, and some of test function didn't have the prefix.
>>>>
>>>> In this patch, it just modified these functions which didn't have the prefix
>>>> `top_down` or `bottom_up`, and now there are two style about these test
>>>> functions in the code.
>>>>
>>>> One is:
>>>> 	run_top_down(alloc_in_between_generic_check);
>>>> 	run_bottom_up(alloc_in_between_generic_check);
>>>>
>>>> Another one is:
>>>> 	memblock_set_bottom_up(false);
>>>> 	alloc_top_down_before_check();
>>>> 	memblock_set_bottom_up(true);
>>>> 	alloc_bottom_up_before_check();
>>>>
>>>> Thus there gonna be two output style, here is an example:
>>>> ok 89 : memblock_alloc_from: top-down: alloc_from_simple_generic_check:
>>>> passed
>>>> ok 90 : memblock_alloc_from: bottom-up: alloc_from_simple_generic_check:
>>>> passed
>>>>
>>>> ok 99 : memblock_alloc_try_nid: alloc_try_nid_top_down_simple_check: passed
>>>> ok 100 : memblock_alloc_try_nid: alloc_try_nid_bottom_up_simple_check:
>>>> passed
>>>>
>>>> It may make confuse if one is printed between the colon and one is inside
>>>> the function name.
>>>>
>>>> So maybe make the style consistent is more make sense. And I think this can
>>>> be done by modify all these function name which with `top_down` and
>>>> `bottom_up` inside, and replace them with your new run_top_down() and
>>>> run_bottom_up() functions.
>>>>
>>> So you're saying use run_top_down() and run_bottom_up() even for functions
>>> with `top_down` and `bottom_up` in the name, but don't change the names?
>>>
>>
>> Yes. We can't delete these `top_down` and `bottom_up` in the name and makes
>> two functions to have the same name. Due to these functions with `top_down`
>> and `bottom_up` have different implementation.
>>
>> If use run_top_down() and run_bottom_up() for these functions. We can get
>> the consistent output style, but a little redundant output(Maybe this isn't
>> a good idea).
>>
> Yes, I think the output would be too redundant. Even though there are
> two different output styles, the style is consistent within each pair of
> tests. So there is at least a consistent pattern.
> 

Ok. Just keep the current implementation is fine.

>>>> On 8/14/2022 1:53 PM, Rebecca Mckeever wrote:
>>>>> Generic tests for memblock_alloc*() functions do not use separate
>>>>> functions for testing top-down and bottom-up allocation directions.
>>>>> Therefore, the function name that is displayed in the verbose testing
>>>>> output does not include the allocation direction.
>>>>>
>>>>> Add an additional prefix when running generic tests for
>>>>> memblock_alloc*() functions that indicates which allocation direction is
>>>>> set. The prefix will be displayed when the tests are run in verbose mode.
>>>>>
>>>>> Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
>>>>> ---
>>>>>     tools/testing/memblock/tests/alloc_api.c      | 36 +++++++------------
>>>>>     .../memblock/tests/alloc_helpers_api.c        | 12 +++----
>>>>>     tools/testing/memblock/tests/alloc_nid_api.c  | 36 +++++++------------
>>>>>     tools/testing/memblock/tests/common.h         | 16 +++++++++
>>>>>     4 files changed, 44 insertions(+), 56 deletions(-)
>>>>>
>>>>> diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
>>>>> index 71c89cb9b2a8..73c2c43e702a 100644
>>>>> --- a/tools/testing/memblock/tests/alloc_api.c
>>>>> +++ b/tools/testing/memblock/tests/alloc_api.c
>>>>> @@ -752,10 +752,8 @@ static int alloc_after_check(void)
>>>>>     static int alloc_in_between_check(void)
>>>>>     {
>>>>>     	test_print("\tRunning %s...\n", __func__);
>>>>> -	memblock_set_bottom_up(false);
>>>>> -	alloc_in_between_generic_check();
>>>>> -	memblock_set_bottom_up(true);
>>>>> -	alloc_in_between_generic_check();
>>>>> +	run_top_down(alloc_in_between_generic_check);
>>>>> +	run_bottom_up(alloc_in_between_generic_check);
>>>>>     	return 0;
>>>>>     }
>>>>> @@ -774,10 +772,8 @@ static int alloc_second_fit_check(void)
>>>>>     static int alloc_small_gaps_check(void)
>>>>>     {
>>>>>     	test_print("\tRunning %s...\n", __func__);
>>>>> -	memblock_set_bottom_up(false);
>>>>> -	alloc_small_gaps_generic_check();
>>>>> -	memblock_set_bottom_up(true);
>>>>> -	alloc_small_gaps_generic_check();
>>>>> +	run_top_down(alloc_small_gaps_generic_check);
>>>>> +	run_bottom_up(alloc_small_gaps_generic_check);
>>>>>     	return 0;
>>>>>     }
>>>>> @@ -785,10 +781,8 @@ static int alloc_small_gaps_check(void)
>>>>>     static int alloc_all_reserved_check(void)
>>>>>     {
>>>>>     	test_print("\tRunning %s...\n", __func__);
>>>>> -	memblock_set_bottom_up(false);
>>>>> -	alloc_all_reserved_generic_check();
>>>>> -	memblock_set_bottom_up(true);
>>>>> -	alloc_all_reserved_generic_check();
>>>>> +	run_top_down(alloc_all_reserved_generic_check);
>>>>> +	run_bottom_up(alloc_all_reserved_generic_check);
>>>>>     	return 0;
>>>>>     }
>>>>> @@ -796,10 +790,8 @@ static int alloc_all_reserved_check(void)
>>>>>     static int alloc_no_space_check(void)
>>>>>     {
>>>>>     	test_print("\tRunning %s...\n", __func__);
>>>>> -	memblock_set_bottom_up(false);
>>>>> -	alloc_no_space_generic_check();
>>>>> -	memblock_set_bottom_up(true);
>>>>> -	alloc_no_space_generic_check();
>>>>> +	run_top_down(alloc_no_space_generic_check);
>>>>> +	run_bottom_up(alloc_no_space_generic_check);
>>>>>     	return 0;
>>>>>     }
>>>>> @@ -807,10 +799,8 @@ static int alloc_no_space_check(void)
>>>>>     static int alloc_limited_space_check(void)
>>>>>     {
>>>>>     	test_print("\tRunning %s...\n", __func__);
>>>>> -	memblock_set_bottom_up(false);
>>>>> -	alloc_limited_space_generic_check();
>>>>> -	memblock_set_bottom_up(true);
>>>>> -	alloc_limited_space_generic_check();
>>>>> +	run_top_down(alloc_limited_space_generic_check);
>>>>> +	run_bottom_up(alloc_limited_space_generic_check);
>>>>>     	return 0;
>>>>>     }
>>>>> @@ -818,10 +808,8 @@ static int alloc_limited_space_check(void)
>>>>>     static int alloc_no_memory_check(void)
>>>>>     {
>>>>>     	test_print("\tRunning %s...\n", __func__);
>>>>> -	memblock_set_bottom_up(false);
>>>>> -	alloc_no_memory_generic_check();
>>>>> -	memblock_set_bottom_up(true);
>>>>> -	alloc_no_memory_generic_check();
>>>>> +	run_top_down(alloc_no_memory_generic_check);
>>>>> +	run_bottom_up(alloc_no_memory_generic_check);
>>>>>     	return 0;
>>>>>     }
>>>>> diff --git a/tools/testing/memblock/tests/alloc_helpers_api.c b/tools/testing/memblock/tests/alloc_helpers_api.c
>>>>> index 796527cf3bd2..1ccf02639ad6 100644
>>>>> --- a/tools/testing/memblock/tests/alloc_helpers_api.c
>>>>> +++ b/tools/testing/memblock/tests/alloc_helpers_api.c
>>>>> @@ -357,10 +357,8 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
>>>>>     static int alloc_from_simple_check(void)
>>>>>     {
>>>>>     	test_print("\tRunning %s...\n", __func__);
>>>>> -	memblock_set_bottom_up(false);
>>>>> -	alloc_from_simple_generic_check();
>>>>> -	memblock_set_bottom_up(true);
>>>>> -	alloc_from_simple_generic_check();
>>>>> +	run_top_down(alloc_from_simple_generic_check);
>>>>> +	run_bottom_up(alloc_from_simple_generic_check);
>>>>>     	return 0;
>>>>>     }
>>>>> @@ -368,10 +366,8 @@ static int alloc_from_simple_check(void)
>>>>>     static int alloc_from_misaligned_check(void)
>>>>>     {
>>>>>     	test_print("\tRunning %s...\n", __func__);
>>>>> -	memblock_set_bottom_up(false);
>>>>> -	alloc_from_misaligned_generic_check();
>>>>> -	memblock_set_bottom_up(true);
>>>>> -	alloc_from_misaligned_generic_check();
>>>>> +	run_top_down(alloc_from_misaligned_generic_check);
>>>>> +	run_bottom_up(alloc_from_misaligned_generic_check);
>>>>>     	return 0;
>>>>>     }
>>>>> diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
>>>>> index 71b7beb35526..82fa8ea36320 100644
>>>>> --- a/tools/testing/memblock/tests/alloc_nid_api.c
>>>>> +++ b/tools/testing/memblock/tests/alloc_nid_api.c
>>>>> @@ -1142,10 +1142,8 @@ static int alloc_try_nid_cap_min_check(void)
>>>>>     static int alloc_try_nid_min_reserved_check(void)
>>>>>     {
>>>>>     	test_print("\tRunning %s...\n", __func__);
>>>>> -	memblock_set_bottom_up(false);
>>>>> -	alloc_try_nid_min_reserved_generic_check();
>>>>> -	memblock_set_bottom_up(true);
>>>>> -	alloc_try_nid_min_reserved_generic_check();
>>>>> +	run_top_down(alloc_try_nid_min_reserved_generic_check);
>>>>> +	run_bottom_up(alloc_try_nid_min_reserved_generic_check);
>>>>>     	return 0;
>>>>>     }
>>>>> @@ -1153,10 +1151,8 @@ static int alloc_try_nid_min_reserved_check(void)
>>>>>     static int alloc_try_nid_max_reserved_check(void)
>>>>>     {
>>>>>     	test_print("\tRunning %s...\n", __func__);
>>>>> -	memblock_set_bottom_up(false);
>>>>> -	alloc_try_nid_max_reserved_generic_check();
>>>>> -	memblock_set_bottom_up(true);
>>>>> -	alloc_try_nid_max_reserved_generic_check();
>>>>> +	run_top_down(alloc_try_nid_max_reserved_generic_check);
>>>>> +	run_bottom_up(alloc_try_nid_max_reserved_generic_check);
>>>>>     	return 0;
>>>>>     }
>>>>> @@ -1164,10 +1160,8 @@ static int alloc_try_nid_max_reserved_check(void)
>>>>>     static int alloc_try_nid_exact_address_check(void)
>>>>>     {
>>>>>     	test_print("\tRunning %s...\n", __func__);
>>>>> -	memblock_set_bottom_up(false);
>>>>> -	alloc_try_nid_exact_address_generic_check();
>>>>> -	memblock_set_bottom_up(true);
>>>>> -	alloc_try_nid_exact_address_generic_check();
>>>>> +	run_top_down(alloc_try_nid_exact_address_generic_check);
>>>>> +	run_bottom_up(alloc_try_nid_exact_address_generic_check);
>>>>>     	return 0;
>>>>>     }
>>>>> @@ -1175,10 +1169,8 @@ static int alloc_try_nid_exact_address_check(void)
>>>>>     static int alloc_try_nid_reserved_full_merge_check(void)
>>>>>     {
>>>>>     	test_print("\tRunning %s...\n", __func__);
>>>>> -	memblock_set_bottom_up(false);
>>>>> -	alloc_try_nid_reserved_full_merge_generic_check();
>>>>> -	memblock_set_bottom_up(true);
>>>>> -	alloc_try_nid_reserved_full_merge_generic_check();
>>>>> +	run_top_down(alloc_try_nid_reserved_full_merge_generic_check);
>>>>> +	run_bottom_up(alloc_try_nid_reserved_full_merge_generic_check);
>>>>>     	return 0;
>>>>>     }
>>>>> @@ -1186,10 +1178,8 @@ static int alloc_try_nid_reserved_full_merge_check(void)
>>>>>     static int alloc_try_nid_reserved_all_check(void)
>>>>>     {
>>>>>     	test_print("\tRunning %s...\n", __func__);
>>>>> -	memblock_set_bottom_up(false);
>>>>> -	alloc_try_nid_reserved_all_generic_check();
>>>>> -	memblock_set_bottom_up(true);
>>>>> -	alloc_try_nid_reserved_all_generic_check();
>>>>> +	run_top_down(alloc_try_nid_reserved_all_generic_check);
>>>>> +	run_bottom_up(alloc_try_nid_reserved_all_generic_check);
>>>>>     	return 0;
>>>>>     }
>>>>> @@ -1197,10 +1187,8 @@ static int alloc_try_nid_reserved_all_check(void)
>>>>>     static int alloc_try_nid_low_max_check(void)
>>>>>     {
>>>>>     	test_print("\tRunning %s...\n", __func__);
>>>>> -	memblock_set_bottom_up(false);
>>>>> -	alloc_try_nid_low_max_generic_check();
>>>>> -	memblock_set_bottom_up(true);
>>>>> -	alloc_try_nid_low_max_generic_check();
>>>>> +	run_top_down(alloc_try_nid_low_max_generic_check);
>>>>> +	run_bottom_up(alloc_try_nid_low_max_generic_check);
>>>>>     	return 0;
>>>>>     }
>>>>> diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h
>>>>> index 7a16a7dc8f2c..e0dd5b410099 100644
>>>>> --- a/tools/testing/memblock/tests/common.h
>>>>> +++ b/tools/testing/memblock/tests/common.h
>>>>> @@ -101,4 +101,20 @@ static inline void test_pass_pop(void)
>>>>>     	prefix_pop();
>>>>>     }
>>>>> +static inline void run_top_down(int (*func)())
>>>>> +{
>>>>> +	memblock_set_bottom_up(false);
>>>>> +	prefix_push("top-down");
>>>>> +	func();
>>>>> +	prefix_pop();
>>>>> +}
>>>>> +
>>>>> +static inline void run_bottom_up(int (*func)())
>>>>> +{
>>>>> +	memblock_set_bottom_up(true);
>>>>> +	prefix_push("bottom-up");
>>>>> +	func();
>>>>> +	prefix_pop();
>>>>> +}
>>>>> +
>>>>>     #endif
> 
> Thanks,
> Rebecca
> 

Re: [PATCH 8/8] memblock tests: add tests for memblock_trim_memory

[Rebecca Mckeever]

On Tue, Aug 16, 2022 at 09:46:11AM +0800, Huang, Shaoqin wrote:
> 
> 
> On 8/14/2022 1:54 PM, Rebecca Mckeever wrote:
> > Add tests for memblock_trim_memory() for the following scenarios:
> > - all regions aligned
> > - one region unalign that is smaller than the alignment
> > - one region unaligned at the base
> > - one region unaligned at the end
> > 
> > Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> > ---
> >   tools/testing/memblock/tests/basic_api.c | 223 +++++++++++++++++++++++
> >   1 file changed, 223 insertions(+)
> > 
> > diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c
> > index d7f008e7a12a..c8bb44f20846 100644
> > --- a/tools/testing/memblock/tests/basic_api.c
> > +++ b/tools/testing/memblock/tests/basic_api.c
> > @@ -8,6 +8,7 @@
> >   #define FUNC_RESERVE					"memblock_reserve"
> >   #define FUNC_REMOVE					"memblock_remove"
> >   #define FUNC_FREE					"memblock_free"
> > +#define FUNC_TRIM					"memblock_trim_memory"
> >   static int memblock_initialization_check(void)
> >   {
> > @@ -1723,6 +1724,227 @@ static int memblock_bottom_up_checks(void)
> >   	return 0;
> >   }
> > +/*
> > + * A test that tries to trim memory when both ends of the memory region are
> > + * aligned. Expect that the memory will not be trimmed. Expect the counter to
> > + * not be updated.
> > + */
> > +static int memblock_trim_memory_aligned_check(void)
> > +{
> > +	struct memblock_region *rgn;
> > +	phys_addr_t alignment = SMP_CACHE_BYTES;
> > +
> > +	rgn = &memblock.memory.regions[0];
> > +
> > +	struct region r = {
> > +		.base = alignment,
> > +		.size = alignment * 4
> > +	};
> > +
> > +	PREFIX_PUSH();
> > +
> > +	reset_memblock_regions();
> > +	memblock_add(r.base, r.size);
> > +	memblock_trim_memory(alignment);
> > +
> > +	ASSERT_EQ(rgn->base, r.base);
> > +	ASSERT_EQ(rgn->size, r.size);
> > +
> > +	ASSERT_EQ(memblock.memory.cnt, 1);
> > +
> > +	test_pass_pop();
> > +
> > +	return 0;
> > +}
> > +
> > +/*
> > + * A test that tries to trim memory when there are two available regions, r1 and
> > + * r2. Region r1 is aligned on both ends and region r2 is unaligned on one end
> > + * and smaller than the alignment:
> > + *
> > + *                                     alignment
> > + *                                     |--------|
> > + * |        +-----------------+        +------+   |
> > + * |        |        r1       |        |  r2  |   |
> > + * +--------+-----------------+--------+------+---+
> > + *          ^        ^        ^        ^      ^
> > + *          |________|________|________|      |
> > + *                            |               Unaligned address
> > + *                Aligned addresses
> > + *
> > + * Expect that r1 will not be trimmed and r2 will be removed. Expect the
> > + * counter to be updated.
> > + */
> > +static int memblock_trim_memory_too_small_check(void)
> > +{
> > +	struct memblock_region *rgn;
> > +	phys_addr_t alignment = SMP_CACHE_BYTES;
> > +
> > +	rgn = &memblock.memory.regions[0];
> > +
> > +	struct region r1 = {
> > +		.base = alignment,
> > +		.size = alignment * 2
> > +	};
> > +	struct region r2 = {
> > +		.base = alignment * 4,
> > +		.size = alignment - SZ_2
> > +	};
> > +
> > +	PREFIX_PUSH();
> > +
> > +	reset_memblock_regions();
> > +	memblock_add(r1.base, r1.size);
> > +	memblock_add(r2.base, r2.size);
> > +	memblock_trim_memory(alignment);
> > +
> > +	ASSERT_EQ(rgn->base, r1.base);
> > +	ASSERT_EQ(rgn->size, r1.size);
> > +
> > +	ASSERT_EQ(memblock.memory.cnt, 1);
> > +
> > +	test_pass_pop();
> > +
> > +	return 0;
> > +}
> > +
> > +/*
> > + * A test that tries to trim memory when there are two available regions, r1 and
> > + * r2. Region r1 is aligned on both ends and region r2 is unaligned at the base
> > + * and aligned at the end:
> > + *
> > + *                               Unaligned address
> > + *                                       |
> > + *                                       v
> > + * |        +-----------------+          +---------------+   |
> > + * |        |        r1       |          |      r2       |   |
> > + * +--------+-----------------+----------+---------------+---+
> > + *          ^        ^        ^        ^        ^        ^
> > + *          |________|________|________|________|________|
> > + *                            |
> > + *                    Aligned addresses
> > + *
> > + * Expect that r1 will not be trimmed and r2 will be trimmed at the base.
> > + * Expect the counter to not be updated.
> > + */
> > +static int memblock_trim_memory_unaligned_base_check(void)
> > +{
> > +	struct memblock_region *rgn1, *rgn2;
> > +	phys_addr_t alignment = SMP_CACHE_BYTES;
> > +	phys_addr_t offset = SZ_2;
> > +	phys_addr_t r2_base, r2_size;
> > +
> > +	rgn1 = &memblock.memory.regions[0];
> > +	rgn2 = &memblock.memory.regions[1];
> > +
> > +	struct region r1 = {
> > +		.base = alignment,
> > +		.size = alignment * 2
> > +	};
> > +	struct region r2 = {
> > +		.base = alignment * 4 + offset,
> > +		.size = alignment * 2 - offset
> > +	};
> > +
> > +	PREFIX_PUSH();
> > +
> > +	r2_base = r2.base + (alignment - offset);
> > +	r2_size = r2.size - (alignment - offset);
> 
> Also the variable name.
> 
> > +
> > +	reset_memblock_regions();
> > +	memblock_add(r1.base, r1.size);
> > +	memblock_add(r2.base, r2.size);
> > +	memblock_trim_memory(alignment);
> > +
> > +	ASSERT_EQ(rgn1->base, r1.base);
> > +	ASSERT_EQ(rgn1->size, r1.size);
> > +
> > +	ASSERT_EQ(rgn2->base, r2_base);
> > +	ASSERT_EQ(rgn2->size, r2_size);
> > +
> > +	ASSERT_EQ(memblock.memory.cnt, 2);
> > +
> > +	test_pass_pop();
> > +
> > +	return 0;
> > +}
> > +
> > +/*
> > + * A test that tries to trim memory when there are two available regions, r1 and
> > + * r2. Region r1 is aligned on both ends and region r2 is aligned at the base
> > + * and unaligned at the end:
> > + *
> > + *                                             Unaligned address
> > + *                                                     |
> > + *                                                     v
> > + * |        +-----------------+        +---------------+   |
> > + * |        |        r1       |        |      r2       |   |
> > + * +--------+-----------------+--------+---------------+---+
> > + *          ^        ^        ^        ^        ^        ^
> > + *          |________|________|________|________|________|
> > + *                            |
> > + *                    Aligned addresses
> > + *
> > + * Expect that r1 will not be trimmed and r2 will be trimmed at the base.
> 								^
> 							at the end.

I forgot to make this change in v2. I will include it in v3.

> > + * Expect the counter to not be updated.
> > + */
> > +static int memblock_trim_memory_unaligned_end_check(void)
> > +{
> > +	struct memblock_region *rgn1, *rgn2;
> > +	phys_addr_t alignment = SMP_CACHE_BYTES;
> > +	phys_addr_t offset = SZ_2;
> > +	phys_addr_t r2_size;
> > +
> > +	rgn1 = &memblock.memory.regions[0];
> > +	rgn2 = &memblock.memory.regions[1];
> > +
> > +	struct region r1 = {
> > +		.base = alignment,
> > +		.size = alignment * 2
> > +	};
> > +	struct region r2 = {
> > +		.base = alignment * 4,
> > +		.size = alignment * 2 - offset
> > +	};
> > +
> > +	PREFIX_PUSH();
> > +
> > +	r2_size = r2.size - (alignment - offset);
> > +
> > +	reset_memblock_regions();
> > +	memblock_add(r1.base, r1.size);
> > +	memblock_add(r2.base, r2.size);
> > +	memblock_trim_memory(alignment);
> > +
> > +	ASSERT_EQ(rgn1->base, r1.base);
> > +	ASSERT_EQ(rgn1->size, r1.size);
> > +
> > +	ASSERT_EQ(rgn2->base, r2.base);
> > +	ASSERT_EQ(rgn2->size, r2_size);
> > +
> > +	ASSERT_EQ(memblock.memory.cnt, 2);
> > +
> > +	test_pass_pop();
> > +
> > +	return 0;
> > +}
> > +
> > +static int memblock_trim_memory_checks(void)
> > +{
> > +	prefix_reset();
> > +	prefix_push(FUNC_TRIM);
> > +	test_print("Running %s tests...\n", FUNC_TRIM);
> > +
> > +	memblock_trim_memory_aligned_check();
> > +	memblock_trim_memory_too_small_check();
> > +	memblock_trim_memory_unaligned_base_check();
> > +	memblock_trim_memory_unaligned_end_check();
> > +
> > +	prefix_pop();
> > +
> > +	return 0;
> > +}
> > +
> >   int memblock_basic_checks(void)
> >   {
> >   	memblock_initialization_check();
> > @@ -1731,6 +1953,7 @@ int memblock_basic_checks(void)
> >   	memblock_remove_checks();
> >   	memblock_free_checks();
> >   	memblock_bottom_up_checks();
> > +	memblock_trim_memory_checks();
> >   	return 0;
> >   }
> 
> Others looks good.

Thanks,
Rebecca