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
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 <[email protected]>
Signed-off-by: Rebecca Mckeever <[email protected]>
---
.../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
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 <[email protected]>
---
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
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 <[email protected]>
---
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
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 <[email protected]>
---
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
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 <[email protected]>
---
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
Add simple tests for memblock_set_bottom_up() and memblock_bottom_up().
Reviewed-by: David Hildenbrand <[email protected]>
Signed-off-by: Rebecca Mckeever <[email protected]>
---
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
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 <[email protected]>
---
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
LGTM.
Reviewed-by: Shaoqin Huang <[email protected]>
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 <[email protected]>
> Signed-off-by: Rebecca Mckeever <[email protected]>
> ---
> .../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());
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 <[email protected]>
> ---
> 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
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 <[email protected]>
> ---
> 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();
>
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 <[email protected]>
> ---
> 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.
Reviewed-by: Shaoqin Huang <[email protected]>
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 <[email protected]>
> Signed-off-by: Rebecca Mckeever <[email protected]>
> ---
> 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;
> }
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 <[email protected]>
> ---
> 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;
> +}
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 <[email protected]>
> > ---
> > 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
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 <[email protected]>
>>> ---
>>> 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
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 <[email protected]>
> > > > ---
> > > > 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
On Tue, Aug 16, 2022 at 09:24:53AM +0800, Huang, Shaoqin wrote:
>
>
> 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 <[email protected]>
> > ---
> > 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?
>
I considered it. The function will need to have a flags parameter added
to it if the definition is moved to common.h. I will make this change.
> > /*
> > * 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;
> > +}
Thanks,
Rebecca
Hi Shaoqin,
On Mon, Aug 15, 2022 at 06:19:38PM +0800, Huang, Shaoqin wrote:
> 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 <[email protected]>
> > ---
> > 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.
>
I'll update the r*_size names to new_r*_size. I'll leave the r*_end
variables as-is because in this case the end of rgn2 (the region created
from r2) does not change. The end of rgn1 does change, so I would update
the name of r1_end if it was used.
> > +
> > + 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();
Thanks,
Rebecca
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 <[email protected]>
>>>>> ---
>>>>> 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
>
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 <[email protected]>
> > ---
> > 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