* [PATCH v3 0/4] memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options
@ 2022-06-22 9:29 Rebecca Mckeever
2022-06-22 9:29 ` [PATCH v3 1/4] memblock tests: add user-provided arguments to Makefile Rebecca Mckeever
` (6 more replies)
0 siblings, 7 replies; 31+ messages in thread
From: Rebecca Mckeever @ 2022-06-22 9:29 UTC (permalink / raw)
To: Mike Rapoport, linux-mm, linux-kernel; +Cc: David Hildenbrand, Rebecca Mckeever
These patches add options VERBOSE and MEMBLOCK_DEBUG to Memblock
simulator, which can be specified when running make. These patches also
implement the functionality for these options.
VERBOSE
Usage:
$ make VERBOSE=1
Passing VERBOSE=1 will enable verbose output from Memblock simulator. For
each test, the verbose output includes the name of the memblock function
being tested, the name of the test, and whether the test passed or failed.
Since all the tests in Memblock simulator run as one monolithic test, this
output is a quick way to get a summary of test results.
MEMBLOCK_DEBUG
Usage:
$ make MEMBLOCK_DEBUG=1
Passing MEMBLOCK_DEBUG=1 will enable memblock_dbg() messages. These
are debug messages built into several functions in memblock that include
information such as the name of the function and the size and start and
end addresses of the memblock region.
Rebecca Mckeever (4):
memblock tests: add user-provided arguments to Makefile
memblock tests: add verbose output to memblock tests
memblock tests: set memblock_debug to enable memblock_dbg() messages
memblock tests: remove completed TODO items
tools/testing/memblock/Makefile | 4 +
tools/testing/memblock/README | 10 +-
tools/testing/memblock/TODO | 14 +-
tools/testing/memblock/internal.h | 7 +
.../testing/memblock/scripts/Makefile.include | 10 +
tools/testing/memblock/tests/alloc_api.c | 241 ++++++++----
.../memblock/tests/alloc_helpers_api.c | 135 +++++--
tools/testing/memblock/tests/alloc_nid_api.c | 371 ++++++++++++------
tools/testing/memblock/tests/basic_api.c | 365 ++++++++++++-----
tools/testing/memblock/tests/common.c | 58 +++
tools/testing/memblock/tests/common.h | 54 +++
11 files changed, 913 insertions(+), 356 deletions(-)
---
Changes
v1 -> v2
PATCH 2, in common.c:
Remove #ifdef VERBOSE around prefixes and related constants
Add __maybe_unused to prefixes
Move PREFIXES_LEN_MAX, DELIM, and DELIM_LEN so that they are
immediately after the other constants
Add #ifdef VERBOSE around definitions for test_*() and prefix_*()
v2 -> v3
PATCH 1:
Add Reviewed-by tag
---
--
2.34.1
^ permalink raw reply [flat|nested] 31+ messages in thread
* [PATCH v3 1/4] memblock tests: add user-provided arguments to Makefile
2022-06-22 9:29 [PATCH v3 0/4] memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options Rebecca Mckeever
@ 2022-06-22 9:29 ` Rebecca Mckeever
2022-06-23 3:47 ` Mike Rapoport
2022-06-22 9:29 ` [PATCH v3 2/4] memblock tests: add verbose output to memblock tests Rebecca Mckeever
` (5 subsequent siblings)
6 siblings, 1 reply; 31+ messages in thread
From: Rebecca Mckeever @ 2022-06-22 9:29 UTC (permalink / raw)
To: Mike Rapoport, linux-mm, linux-kernel; +Cc: David Hildenbrand, Rebecca Mckeever
Add VERBOSE and MEMBLOCK_DEBUG user-provided arguments. VERBOSE will
enable verbose output from Memblock simulator. MEMBLOCK_DEBUG will enable
memblock_dbg() messages.
Update the help message to include VERBOSE and MEMBLOCK_DEBUG. Update
the README to include VERBOSE. The README does not include all available
options and refers to the help message for the remaining options.
Therefore, omit MEMBLOCK_DEBUG from README.
Reviewed-by: David Hildenbrand <david@redhat.com>
Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
---
tools/testing/memblock/Makefile | 4 ++++
tools/testing/memblock/README | 10 +++++++++-
tools/testing/memblock/scripts/Makefile.include | 10 ++++++++++
3 files changed, 23 insertions(+), 1 deletion(-)
diff --git a/tools/testing/memblock/Makefile b/tools/testing/memblock/Makefile
index a698e24b35e7..9fde49ad73bd 100644
--- a/tools/testing/memblock/Makefile
+++ b/tools/testing/memblock/Makefile
@@ -45,6 +45,10 @@ help:
@echo ' clean - Remove generated files and symlinks in the directory'
@echo ''
@echo 'Configuration:'
+ @echo ' make VERBOSE=1 - enable verbose output, which includes the'
+ @echo ' names of functions being tested and the'
+ @echo ' number of test cases passing'
+ @echo ' make MEMBLOCK_DEBUG=1 - enable memblock_dbg() messages'
@echo ' make NUMA=1 - simulate enabled NUMA'
@echo ' make MOVABLE_NODE=1 - override `movable_node_is_enabled`'
@echo ' definition to simulate movable NUMA nodes'
diff --git a/tools/testing/memblock/README b/tools/testing/memblock/README
index ca6afcff013a..058146b528a5 100644
--- a/tools/testing/memblock/README
+++ b/tools/testing/memblock/README
@@ -34,7 +34,15 @@ To run the tests, build the main target and run it:
$ make && ./main
A successful run produces no output. It is also possible to override different
-configuration parameters. For example, to simulate enabled NUMA, use:
+configuration parameters. For example, to include verbose output, specify the
+VERBOSE flag when building the main target:
+
+$ make VERBOSE=1
+
+This will print information about which functions are being tested and the
+number of test cases that passed.
+
+To simulate enabled NUMA, use:
$ make NUMA=1
diff --git a/tools/testing/memblock/scripts/Makefile.include b/tools/testing/memblock/scripts/Makefile.include
index 641569ccb7b0..4401f79bed4c 100644
--- a/tools/testing/memblock/scripts/Makefile.include
+++ b/tools/testing/memblock/scripts/Makefile.include
@@ -17,3 +17,13 @@ ifeq ($(32BIT_PHYS_ADDR_T), 1)
CFLAGS += -m32 -U CONFIG_PHYS_ADDR_T_64BIT
LDFLAGS += -m32
endif
+
+# Enable verbose testing output
+ifeq ($(VERBOSE), 1)
+ CFLAGS += -D VERBOSE
+endif
+
+# Enable memblock_dbg() messages
+ifeq ($(MEMBLOCK_DEBUG), 1)
+ CFLAGS += -D MEMBLOCK_DEBUG
+endif
--
2.34.1
^ permalink raw reply related [flat|nested] 31+ messages in thread
* [PATCH v3 2/4] memblock tests: add verbose output to memblock tests
2022-06-22 9:29 [PATCH v3 0/4] memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options Rebecca Mckeever
2022-06-22 9:29 ` [PATCH v3 1/4] memblock tests: add user-provided arguments to Makefile Rebecca Mckeever
@ 2022-06-22 9:29 ` Rebecca Mckeever
2022-06-22 10:32 ` Huang, Shaoqin
` (2 more replies)
2022-06-22 9:29 ` [PATCH v3 3/4] memblock tests: set memblock_debug to enable memblock_dbg() messages Rebecca Mckeever
` (4 subsequent siblings)
6 siblings, 3 replies; 31+ messages in thread
From: Rebecca Mckeever @ 2022-06-22 9:29 UTC (permalink / raw)
To: Mike Rapoport, linux-mm, linux-kernel; +Cc: David Hildenbrand, Rebecca Mckeever
Add and use functions for printing verbose testing output.
If the Memblock simulator was compiled with VERBOSE=1:
prefix_push() appends the given string to a prefix string that will be
printed in the test functions.
prefix_pop() removes the last prefix from the prefix string.
prefix_reset() clears the prefix string.
test_fail() prints a message after a test fails containing the test
number of the failing test and the prefix.
test_pass() prints a message after a test passes containing its test
number and the prefix.
test_print() prints the given formatted output string.
If the Memblock simulator was not compiled with VERBOSE=1, these
functions do nothing.
Add the assert wrapper macros ASSERT_EQ(), ASSERT_NE(), and ASSERT_LT().
If the assert condition fails, these macros call test_fail() before
executing assert().
Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
---
tools/testing/memblock/tests/alloc_api.c | 241 ++++++++----
.../memblock/tests/alloc_helpers_api.c | 135 +++++--
tools/testing/memblock/tests/alloc_nid_api.c | 371 ++++++++++++------
tools/testing/memblock/tests/basic_api.c | 365 ++++++++++++-----
tools/testing/memblock/tests/common.c | 58 +++
tools/testing/memblock/tests/common.h | 54 +++
6 files changed, 880 insertions(+), 344 deletions(-)
diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
index d1aa7e15c18d..96df033d4300 100644
--- a/tools/testing/memblock/tests/alloc_api.c
+++ b/tools/testing/memblock/tests/alloc_api.c
@@ -10,6 +10,8 @@ static int alloc_top_down_simple_check(void)
struct memblock_region *rgn = &memblock.reserved.regions[0];
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
phys_addr_t size = SZ_2;
phys_addr_t expected_start;
@@ -19,12 +21,15 @@ static int alloc_top_down_simple_check(void)
allocated_ptr = memblock_alloc(size, SMP_CACHE_BYTES);
- assert(allocated_ptr);
- assert(rgn->size == size);
- assert(rgn->base == expected_start);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(rgn->size, size);
+ ASSERT_EQ(rgn->base, expected_start);
+
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -55,6 +60,8 @@ static int alloc_top_down_disjoint_check(void)
struct region r1;
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
phys_addr_t r2_size = SZ_16;
/* Use custom alignment */
phys_addr_t alignment = SMP_CACHE_BYTES * 2;
@@ -73,15 +80,18 @@ static int alloc_top_down_disjoint_check(void)
allocated_ptr = memblock_alloc(r2_size, alignment);
- assert(allocated_ptr);
- assert(rgn1->size == r1.size);
- assert(rgn1->base == r1.base);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(rgn1->size, r1.size);
+ ASSERT_EQ(rgn1->base, r1.base);
- assert(rgn2->size == r2_size);
- assert(rgn2->base == expected_start);
+ ASSERT_EQ(rgn2->size, r2_size);
+ ASSERT_EQ(rgn2->base, expected_start);
- assert(memblock.reserved.cnt == 2);
- assert(memblock.reserved.total_size == total_size);
+ ASSERT_EQ(memblock.reserved.cnt, 2);
+ ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -101,6 +111,8 @@ static int alloc_top_down_before_check(void)
struct memblock_region *rgn = &memblock.reserved.regions[0];
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
/*
* The first region ends at the aligned address to test region merging
*/
@@ -114,12 +126,15 @@ static int alloc_top_down_before_check(void)
allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
- assert(allocated_ptr);
- assert(rgn->size == total_size);
- assert(rgn->base == memblock_end_of_DRAM() - total_size);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(rgn->size, total_size);
+ ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - total_size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == total_size);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -141,6 +156,8 @@ static int alloc_top_down_after_check(void)
struct region r1;
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
phys_addr_t r2_size = SZ_512;
phys_addr_t total_size;
@@ -158,12 +175,15 @@ static int alloc_top_down_after_check(void)
allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
- assert(allocated_ptr);
- assert(rgn->size == total_size);
- assert(rgn->base == r1.base - r2_size);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(rgn->size, total_size);
+ ASSERT_EQ(rgn->base, r1.base - r2_size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == total_size);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -186,6 +206,8 @@ static int alloc_top_down_second_fit_check(void)
struct region r1, r2;
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
phys_addr_t r3_size = SZ_1K;
phys_addr_t total_size;
@@ -204,12 +226,15 @@ static int alloc_top_down_second_fit_check(void)
allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
- assert(allocated_ptr);
- assert(rgn->size == r2.size + r3_size);
- assert(rgn->base == r2.base - r3_size);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(rgn->size, r2.size + r3_size);
+ ASSERT_EQ(rgn->base, r2.base - r3_size);
- assert(memblock.reserved.cnt == 2);
- assert(memblock.reserved.total_size == total_size);
+ ASSERT_EQ(memblock.reserved.cnt, 2);
+ ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -231,6 +256,8 @@ static int alloc_in_between_generic_check(void)
struct region r1, r2;
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
phys_addr_t gap_size = SMP_CACHE_BYTES;
phys_addr_t r3_size = SZ_64;
/*
@@ -254,12 +281,15 @@ static int alloc_in_between_generic_check(void)
allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
- assert(allocated_ptr);
- assert(rgn->size == total_size);
- assert(rgn->base == r1.base - r2.size - r3_size);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(rgn->size, total_size);
+ ASSERT_EQ(rgn->base, r1.base - r2.size - r3_size);
+
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, total_size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == total_size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -281,6 +311,8 @@ static int alloc_small_gaps_generic_check(void)
{
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
phys_addr_t region_size = SZ_1K;
phys_addr_t gap_size = SZ_256;
phys_addr_t region_end;
@@ -296,7 +328,10 @@ static int alloc_small_gaps_generic_check(void)
allocated_ptr = memblock_alloc(region_size, SMP_CACHE_BYTES);
- assert(!allocated_ptr);
+ ASSERT_EQ(allocated_ptr, NULL);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -309,6 +344,8 @@ static int alloc_all_reserved_generic_check(void)
{
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
setup_memblock();
/* Simulate full memory */
@@ -316,7 +353,10 @@ static int alloc_all_reserved_generic_check(void)
allocated_ptr = memblock_alloc(SZ_256, SMP_CACHE_BYTES);
- assert(!allocated_ptr);
+ ASSERT_EQ(allocated_ptr, NULL);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -338,6 +378,8 @@ static int alloc_no_space_generic_check(void)
{
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
setup_memblock();
phys_addr_t available_size = SZ_256;
@@ -348,7 +390,10 @@ static int alloc_no_space_generic_check(void)
allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
- assert(!allocated_ptr);
+ ASSERT_EQ(allocated_ptr, NULL);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -369,6 +414,8 @@ static int alloc_limited_space_generic_check(void)
struct memblock_region *rgn = &memblock.reserved.regions[0];
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
phys_addr_t available_size = SZ_256;
phys_addr_t reserved_size = MEM_SIZE - available_size;
@@ -379,12 +426,15 @@ static int alloc_limited_space_generic_check(void)
allocated_ptr = memblock_alloc(available_size, SMP_CACHE_BYTES);
- assert(allocated_ptr);
- assert(rgn->size == MEM_SIZE);
- assert(rgn->base == memblock_start_of_DRAM());
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(rgn->size, MEM_SIZE);
+ ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
+
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, MEM_SIZE);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == MEM_SIZE);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -399,14 +449,19 @@ static int alloc_no_memory_generic_check(void)
struct memblock_region *rgn = &memblock.reserved.regions[0];
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
reset_memblock_regions();
allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
- assert(!allocated_ptr);
- assert(rgn->size == 0);
- assert(rgn->base == 0);
- assert(memblock.reserved.total_size == 0);
+ ASSERT_EQ(allocated_ptr, NULL);
+ ASSERT_EQ(rgn->size, 0);
+ ASSERT_EQ(rgn->base, 0);
+ ASSERT_EQ(memblock.reserved.total_size, 0);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -421,16 +476,21 @@ static int alloc_bottom_up_simple_check(void)
struct memblock_region *rgn = &memblock.reserved.regions[0];
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
setup_memblock();
allocated_ptr = memblock_alloc(SZ_2, SMP_CACHE_BYTES);
- assert(allocated_ptr);
- assert(rgn->size == SZ_2);
- assert(rgn->base == memblock_start_of_DRAM());
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(rgn->size, SZ_2);
+ ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == SZ_2);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, SZ_2);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -459,6 +519,8 @@ static int alloc_bottom_up_disjoint_check(void)
struct region r1;
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
phys_addr_t r2_size = SZ_16;
/* Use custom alignment */
phys_addr_t alignment = SMP_CACHE_BYTES * 2;
@@ -477,16 +539,19 @@ static int alloc_bottom_up_disjoint_check(void)
allocated_ptr = memblock_alloc(r2_size, alignment);
- assert(allocated_ptr);
+ ASSERT_NE(allocated_ptr, NULL);
- assert(rgn1->size == r1.size);
- assert(rgn1->base == r1.base);
+ ASSERT_EQ(rgn1->size, r1.size);
+ ASSERT_EQ(rgn1->base, r1.base);
- assert(rgn2->size == r2_size);
- assert(rgn2->base == expected_start);
+ ASSERT_EQ(rgn2->size, r2_size);
+ ASSERT_EQ(rgn2->base, expected_start);
- assert(memblock.reserved.cnt == 2);
- assert(memblock.reserved.total_size == total_size);
+ ASSERT_EQ(memblock.reserved.cnt, 2);
+ ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -506,6 +571,8 @@ static int alloc_bottom_up_before_check(void)
struct memblock_region *rgn = &memblock.reserved.regions[0];
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
phys_addr_t r1_size = SZ_512;
phys_addr_t r2_size = SZ_128;
phys_addr_t total_size = r1_size + r2_size;
@@ -516,12 +583,15 @@ static int alloc_bottom_up_before_check(void)
allocated_ptr = memblock_alloc(r1_size, SMP_CACHE_BYTES);
- assert(allocated_ptr);
- assert(rgn->size == total_size);
- assert(rgn->base == memblock_start_of_DRAM());
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(rgn->size, total_size);
+ ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == total_size);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -542,6 +612,8 @@ static int alloc_bottom_up_after_check(void)
struct region r1;
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
phys_addr_t r2_size = SZ_512;
phys_addr_t total_size;
@@ -559,12 +631,15 @@ static int alloc_bottom_up_after_check(void)
allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
- assert(allocated_ptr);
- assert(rgn->size == total_size);
- assert(rgn->base == r1.base);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(rgn->size, total_size);
+ ASSERT_EQ(rgn->base, r1.base);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == total_size);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -588,6 +663,8 @@ static int alloc_bottom_up_second_fit_check(void)
struct region r1, r2;
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
phys_addr_t r3_size = SZ_1K;
phys_addr_t total_size;
@@ -606,12 +683,15 @@ static int alloc_bottom_up_second_fit_check(void)
allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
- assert(allocated_ptr);
- assert(rgn->size == r2.size + r3_size);
- assert(rgn->base == r2.base);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(rgn->size, r2.size + r3_size);
+ ASSERT_EQ(rgn->base, r2.base);
- assert(memblock.reserved.cnt == 2);
- assert(memblock.reserved.total_size == total_size);
+ ASSERT_EQ(memblock.reserved.cnt, 2);
+ ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -619,6 +699,7 @@ static int alloc_bottom_up_second_fit_check(void)
/* Test case wrappers */
static int alloc_simple_check(void)
{
+ test_print("\tRunning %s...\n", __func__);
memblock_set_bottom_up(false);
alloc_top_down_simple_check();
memblock_set_bottom_up(true);
@@ -629,6 +710,7 @@ static int alloc_simple_check(void)
static int alloc_disjoint_check(void)
{
+ test_print("\tRunning %s...\n", __func__);
memblock_set_bottom_up(false);
alloc_top_down_disjoint_check();
memblock_set_bottom_up(true);
@@ -639,6 +721,7 @@ static int alloc_disjoint_check(void)
static int alloc_before_check(void)
{
+ test_print("\tRunning %s...\n", __func__);
memblock_set_bottom_up(false);
alloc_top_down_before_check();
memblock_set_bottom_up(true);
@@ -649,6 +732,7 @@ static int alloc_before_check(void)
static int alloc_after_check(void)
{
+ test_print("\tRunning %s...\n", __func__);
memblock_set_bottom_up(false);
alloc_top_down_after_check();
memblock_set_bottom_up(true);
@@ -659,6 +743,7 @@ 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);
@@ -669,6 +754,7 @@ static int alloc_in_between_check(void)
static int alloc_second_fit_check(void)
{
+ test_print("\tRunning %s...\n", __func__);
memblock_set_bottom_up(false);
alloc_top_down_second_fit_check();
memblock_set_bottom_up(true);
@@ -679,6 +765,7 @@ 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);
@@ -689,6 +776,7 @@ 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);
@@ -699,6 +787,7 @@ 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);
@@ -709,6 +798,7 @@ 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);
@@ -719,6 +809,7 @@ 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);
@@ -729,6 +820,12 @@ static int alloc_no_memory_check(void)
int memblock_alloc_checks(void)
{
+ static const char func_testing[] = "memblock_alloc";
+
+ prefix_reset();
+ prefix_push(func_testing);
+ test_print("Running %s tests...\n", func_testing);
+
reset_memblock_attributes();
dummy_physical_memory_init();
@@ -746,5 +843,7 @@ int memblock_alloc_checks(void)
dummy_physical_memory_cleanup();
+ prefix_pop();
+
return 0;
}
diff --git a/tools/testing/memblock/tests/alloc_helpers_api.c b/tools/testing/memblock/tests/alloc_helpers_api.c
index 963a966db461..f6eaed540427 100644
--- a/tools/testing/memblock/tests/alloc_helpers_api.c
+++ b/tools/testing/memblock/tests/alloc_helpers_api.c
@@ -21,6 +21,8 @@ static int alloc_from_simple_generic_check(void)
void *allocated_ptr = NULL;
char *b;
+ prefix_push(__func__);
+
phys_addr_t size = SZ_16;
phys_addr_t min_addr;
@@ -31,14 +33,17 @@ static int alloc_from_simple_generic_check(void)
allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
b = (char *)allocated_ptr;
- assert(allocated_ptr);
- assert(*b == 0);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(*b, 0);
+
+ ASSERT_EQ(rgn->size, size);
+ ASSERT_EQ(rgn->base, min_addr);
- assert(rgn->size == size);
- assert(rgn->base == min_addr);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -64,6 +69,8 @@ static int alloc_from_misaligned_generic_check(void)
void *allocated_ptr = NULL;
char *b;
+ prefix_push(__func__);
+
phys_addr_t size = SZ_32;
phys_addr_t min_addr;
@@ -75,14 +82,17 @@ static int alloc_from_misaligned_generic_check(void)
allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
b = (char *)allocated_ptr;
- assert(allocated_ptr);
- assert(*b == 0);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(*b, 0);
- assert(rgn->size == size);
- assert(rgn->base == memblock_end_of_DRAM() - SMP_CACHE_BYTES);
+ ASSERT_EQ(rgn->size, size);
+ ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - SMP_CACHE_BYTES);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == size);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -110,6 +120,8 @@ static int alloc_from_top_down_high_addr_check(void)
struct memblock_region *rgn = &memblock.reserved.regions[0];
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
phys_addr_t size = SZ_32;
phys_addr_t min_addr;
@@ -120,12 +132,15 @@ static int alloc_from_top_down_high_addr_check(void)
allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
- assert(allocated_ptr);
- assert(rgn->size == size);
- assert(rgn->base == memblock_end_of_DRAM() - SMP_CACHE_BYTES);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(rgn->size, size);
+ ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - SMP_CACHE_BYTES);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == size);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -151,6 +166,8 @@ static int alloc_from_top_down_no_space_above_check(void)
struct memblock_region *rgn = &memblock.reserved.regions[0];
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
phys_addr_t r1_size = SZ_64;
phys_addr_t r2_size = SZ_2;
phys_addr_t total_size = r1_size + r2_size;
@@ -165,12 +182,15 @@ static int alloc_from_top_down_no_space_above_check(void)
allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
- assert(allocated_ptr);
- assert(rgn->base == min_addr - r1_size);
- assert(rgn->size == total_size);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(rgn->base, min_addr - r1_size);
+ ASSERT_EQ(rgn->size, total_size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == total_size);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -186,6 +206,8 @@ static int alloc_from_top_down_min_addr_cap_check(void)
struct memblock_region *rgn = &memblock.reserved.regions[0];
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
phys_addr_t r1_size = SZ_64;
phys_addr_t min_addr;
phys_addr_t start_addr;
@@ -199,12 +221,15 @@ static int alloc_from_top_down_min_addr_cap_check(void)
allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
- assert(allocated_ptr);
- assert(rgn->base == start_addr);
- assert(rgn->size == MEM_SIZE);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(rgn->base, start_addr);
+ ASSERT_EQ(rgn->size, MEM_SIZE);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == MEM_SIZE);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, MEM_SIZE);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -230,6 +255,8 @@ static int alloc_from_bottom_up_high_addr_check(void)
struct memblock_region *rgn = &memblock.reserved.regions[0];
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
phys_addr_t size = SZ_32;
phys_addr_t min_addr;
@@ -240,12 +267,15 @@ static int alloc_from_bottom_up_high_addr_check(void)
allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
- assert(allocated_ptr);
- assert(rgn->size == size);
- assert(rgn->base == memblock_start_of_DRAM());
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(rgn->size, size);
+ ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
+
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -270,6 +300,8 @@ static int alloc_from_bottom_up_no_space_above_check(void)
struct memblock_region *rgn = &memblock.reserved.regions[0];
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
phys_addr_t r1_size = SZ_64;
phys_addr_t min_addr;
phys_addr_t r2_size;
@@ -284,12 +316,15 @@ static int alloc_from_bottom_up_no_space_above_check(void)
allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
- assert(allocated_ptr);
- assert(rgn->base == memblock_start_of_DRAM());
- assert(rgn->size == r1_size);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
+ ASSERT_EQ(rgn->size, r1_size);
+
+ ASSERT_EQ(memblock.reserved.cnt, 2);
+ ASSERT_EQ(memblock.reserved.total_size, r1_size + r2_size);
- assert(memblock.reserved.cnt == 2);
- assert(memblock.reserved.total_size == r1_size + r2_size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -304,6 +339,8 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
struct memblock_region *rgn = &memblock.reserved.regions[0];
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
phys_addr_t r1_size = SZ_64;
phys_addr_t min_addr;
phys_addr_t start_addr;
@@ -315,12 +352,15 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
- assert(allocated_ptr);
- assert(rgn->base == start_addr);
- assert(rgn->size == r1_size);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(rgn->base, start_addr);
+ ASSERT_EQ(rgn->size, r1_size);
+
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, r1_size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == r1_size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -328,6 +368,7 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
/* Test case wrappers */
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);
@@ -338,6 +379,7 @@ 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);
@@ -348,6 +390,7 @@ static int alloc_from_misaligned_check(void)
static int alloc_from_high_addr_check(void)
{
+ test_print("\tRunning %s...\n", __func__);
memblock_set_bottom_up(false);
alloc_from_top_down_high_addr_check();
memblock_set_bottom_up(true);
@@ -358,6 +401,7 @@ static int alloc_from_high_addr_check(void)
static int alloc_from_no_space_above_check(void)
{
+ test_print("\tRunning %s...\n", __func__);
memblock_set_bottom_up(false);
alloc_from_top_down_no_space_above_check();
memblock_set_bottom_up(true);
@@ -368,6 +412,7 @@ static int alloc_from_no_space_above_check(void)
static int alloc_from_min_addr_cap_check(void)
{
+ test_print("\tRunning %s...\n", __func__);
memblock_set_bottom_up(false);
alloc_from_top_down_min_addr_cap_check();
memblock_set_bottom_up(true);
@@ -378,6 +423,12 @@ static int alloc_from_min_addr_cap_check(void)
int memblock_alloc_helpers_checks(void)
{
+ static const char func_testing[] = "memblock_alloc_from";
+
+ prefix_reset();
+ prefix_push(func_testing);
+ test_print("Running %s tests...\n", func_testing);
+
reset_memblock_attributes();
dummy_physical_memory_init();
diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
index 6390206e50e1..601f4a7ee30d 100644
--- a/tools/testing/memblock/tests/alloc_nid_api.c
+++ b/tools/testing/memblock/tests/alloc_nid_api.c
@@ -21,6 +21,8 @@ static int alloc_try_nid_top_down_simple_check(void)
void *allocated_ptr = NULL;
char *b;
+ prefix_push(__func__);
+
phys_addr_t size = SZ_128;
phys_addr_t min_addr;
phys_addr_t max_addr;
@@ -36,15 +38,18 @@ static int alloc_try_nid_top_down_simple_check(void)
b = (char *)allocated_ptr;
rgn_end = rgn->base + rgn->size;
- assert(allocated_ptr);
- assert(*b == 0);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(*b, 0);
+
+ ASSERT_EQ(rgn->size, size);
+ ASSERT_EQ(rgn->base, max_addr - size);
+ ASSERT_EQ(rgn_end, max_addr);
- assert(rgn->size == size);
- assert(rgn->base == max_addr - size);
- assert(rgn_end == max_addr);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -72,6 +77,8 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
void *allocated_ptr = NULL;
char *b;
+ prefix_push(__func__);
+
phys_addr_t size = SZ_128;
phys_addr_t misalign = SZ_2;
phys_addr_t min_addr;
@@ -88,15 +95,18 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
b = (char *)allocated_ptr;
rgn_end = rgn->base + rgn->size;
- assert(allocated_ptr);
- assert(*b == 0);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(*b, 0);
- assert(rgn->size == size);
- assert(rgn->base == max_addr - size - misalign);
- assert(rgn_end < max_addr);
+ ASSERT_EQ(rgn->size, size);
+ ASSERT_EQ(rgn->base, max_addr - size - misalign);
+ ASSERT_LT(rgn_end, max_addr);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == size);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -122,6 +132,8 @@ static int alloc_try_nid_exact_address_generic_check(void)
void *allocated_ptr = NULL;
char *b;
+ prefix_push(__func__);
+
phys_addr_t size = SZ_1K;
phys_addr_t min_addr;
phys_addr_t max_addr;
@@ -137,15 +149,18 @@ static int alloc_try_nid_exact_address_generic_check(void)
b = (char *)allocated_ptr;
rgn_end = rgn->base + rgn->size;
- assert(allocated_ptr);
- assert(*b == 0);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(*b, 0);
+
+ ASSERT_EQ(rgn->size, size);
+ ASSERT_EQ(rgn->base, min_addr);
+ ASSERT_EQ(rgn_end, max_addr);
- assert(rgn->size == size);
- assert(rgn->base == min_addr);
- assert(rgn_end == max_addr);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -173,6 +188,8 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
void *allocated_ptr = NULL;
char *b;
+ prefix_push(__func__);
+
phys_addr_t size = SZ_256;
phys_addr_t min_addr;
phys_addr_t max_addr;
@@ -186,14 +203,17 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
min_addr, max_addr, NUMA_NO_NODE);
b = (char *)allocated_ptr;
- assert(allocated_ptr);
- assert(*b == 0);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(*b, 0);
+
+ ASSERT_EQ(rgn->size, size);
+ ASSERT_EQ(rgn->base, max_addr - size);
- assert(rgn->size == size);
- assert(rgn->base == max_addr - size);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -222,6 +242,8 @@ static int alloc_try_nid_low_max_generic_check(void)
{
void *allocated_ptr = NULL;
+ prefix_push(__func__);
+
phys_addr_t size = SZ_1K;
phys_addr_t min_addr;
phys_addr_t max_addr;
@@ -234,7 +256,10 @@ static int alloc_try_nid_low_max_generic_check(void)
allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
min_addr, max_addr, NUMA_NO_NODE);
- assert(!allocated_ptr);
+ ASSERT_EQ(allocated_ptr, NULL);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -259,6 +284,8 @@ static int alloc_try_nid_min_reserved_generic_check(void)
void *allocated_ptr = NULL;
char *b;
+ prefix_push(__func__);
+
phys_addr_t r1_size = SZ_128;
phys_addr_t r2_size = SZ_64;
phys_addr_t total_size = r1_size + r2_size;
@@ -278,14 +305,17 @@ static int alloc_try_nid_min_reserved_generic_check(void)
min_addr, max_addr, NUMA_NO_NODE);
b = (char *)allocated_ptr;
- assert(allocated_ptr);
- assert(*b == 0);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(*b, 0);
- assert(rgn->size == total_size);
- assert(rgn->base == reserved_base);
+ ASSERT_EQ(rgn->size, total_size);
+ ASSERT_EQ(rgn->base, reserved_base);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == total_size);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -310,6 +340,8 @@ static int alloc_try_nid_max_reserved_generic_check(void)
void *allocated_ptr = NULL;
char *b;
+ prefix_push(__func__);
+
phys_addr_t r1_size = SZ_64;
phys_addr_t r2_size = SZ_128;
phys_addr_t total_size = r1_size + r2_size;
@@ -327,14 +359,17 @@ static int alloc_try_nid_max_reserved_generic_check(void)
min_addr, max_addr, NUMA_NO_NODE);
b = (char *)allocated_ptr;
- assert(allocated_ptr);
- assert(*b == 0);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(*b, 0);
+
+ ASSERT_EQ(rgn->size, total_size);
+ ASSERT_EQ(rgn->base, min_addr);
- assert(rgn->size == total_size);
- assert(rgn->base == min_addr);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, total_size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == total_size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -364,6 +399,8 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
char *b;
struct region r1, r2;
+ prefix_push(__func__);
+
phys_addr_t r3_size = SZ_64;
phys_addr_t gap_size = SMP_CACHE_BYTES;
phys_addr_t total_size;
@@ -389,17 +426,20 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
min_addr, max_addr, NUMA_NO_NODE);
b = (char *)allocated_ptr;
- assert(allocated_ptr);
- assert(*b == 0);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(*b, 0);
+
+ ASSERT_EQ(rgn1->size, r1.size + r3_size);
+ ASSERT_EQ(rgn1->base, max_addr - r3_size);
- assert(rgn1->size == r1.size + r3_size);
- assert(rgn1->base == max_addr - r3_size);
+ ASSERT_EQ(rgn2->size, r2.size);
+ ASSERT_EQ(rgn2->base, r2.base);
- assert(rgn2->size == r2.size);
- assert(rgn2->base == r2.base);
+ ASSERT_EQ(memblock.reserved.cnt, 2);
+ ASSERT_EQ(memblock.reserved.total_size, total_size);
- assert(memblock.reserved.cnt == 2);
- assert(memblock.reserved.total_size == total_size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -427,6 +467,8 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
char *b;
struct region r1, r2;
+ prefix_push(__func__);
+
phys_addr_t r3_size = SZ_64;
phys_addr_t total_size;
phys_addr_t max_addr;
@@ -451,14 +493,17 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
min_addr, max_addr, NUMA_NO_NODE);
b = (char *)allocated_ptr;
- assert(allocated_ptr);
- assert(*b == 0);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(*b, 0);
- assert(rgn->size == total_size);
- assert(rgn->base == r2.base);
+ ASSERT_EQ(rgn->size, total_size);
+ ASSERT_EQ(rgn->base, r2.base);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == total_size);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -489,6 +534,8 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
char *b;
struct region r1, r2;
+ prefix_push(__func__);
+
phys_addr_t r3_size = SZ_256;
phys_addr_t gap_size = SMP_CACHE_BYTES;
phys_addr_t total_size;
@@ -514,17 +561,20 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
min_addr, max_addr, NUMA_NO_NODE);
b = (char *)allocated_ptr;
- assert(allocated_ptr);
- assert(*b == 0);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(*b, 0);
+
+ ASSERT_EQ(rgn1->size, r1.size);
+ ASSERT_EQ(rgn1->base, r1.base);
- assert(rgn1->size == r1.size);
- assert(rgn1->base == r1.base);
+ ASSERT_EQ(rgn2->size, r2.size + r3_size);
+ ASSERT_EQ(rgn2->base, r2.base - r3_size);
- assert(rgn2->size == r2.size + r3_size);
- assert(rgn2->base == r2.base - r3_size);
+ ASSERT_EQ(memblock.reserved.cnt, 2);
+ ASSERT_EQ(memblock.reserved.total_size, total_size);
- assert(memblock.reserved.cnt == 2);
- assert(memblock.reserved.total_size == total_size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -554,6 +604,8 @@ static int alloc_try_nid_reserved_all_generic_check(void)
void *allocated_ptr = NULL;
struct region r1, r2;
+ prefix_push(__func__);
+
phys_addr_t r3_size = SZ_256;
phys_addr_t gap_size = SMP_CACHE_BYTES;
phys_addr_t max_addr;
@@ -576,7 +628,10 @@ static int alloc_try_nid_reserved_all_generic_check(void)
allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
min_addr, max_addr, NUMA_NO_NODE);
- assert(!allocated_ptr);
+ ASSERT_EQ(allocated_ptr, NULL);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -592,6 +647,8 @@ static int alloc_try_nid_top_down_cap_max_check(void)
void *allocated_ptr = NULL;
char *b;
+ prefix_push(__func__);
+
phys_addr_t size = SZ_256;
phys_addr_t min_addr;
phys_addr_t max_addr;
@@ -605,14 +662,17 @@ static int alloc_try_nid_top_down_cap_max_check(void)
min_addr, max_addr, NUMA_NO_NODE);
b = (char *)allocated_ptr;
- assert(allocated_ptr);
- assert(*b == 0);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(*b, 0);
+
+ ASSERT_EQ(rgn->size, size);
+ ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
- assert(rgn->size == size);
- assert(rgn->base == memblock_end_of_DRAM() - size);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -628,6 +688,8 @@ static int alloc_try_nid_top_down_cap_min_check(void)
void *allocated_ptr = NULL;
char *b;
+ prefix_push(__func__);
+
phys_addr_t size = SZ_1K;
phys_addr_t min_addr;
phys_addr_t max_addr;
@@ -641,14 +703,17 @@ static int alloc_try_nid_top_down_cap_min_check(void)
min_addr, max_addr, NUMA_NO_NODE);
b = (char *)allocated_ptr;
- assert(allocated_ptr);
- assert(*b == 0);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(*b, 0);
- assert(rgn->size == size);
- assert(rgn->base == memblock_end_of_DRAM() - size);
+ ASSERT_EQ(rgn->size, size);
+ ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == size);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -673,6 +738,8 @@ static int alloc_try_nid_bottom_up_simple_check(void)
void *allocated_ptr = NULL;
char *b;
+ prefix_push(__func__);
+
phys_addr_t size = SZ_128;
phys_addr_t min_addr;
phys_addr_t max_addr;
@@ -689,15 +756,18 @@ static int alloc_try_nid_bottom_up_simple_check(void)
b = (char *)allocated_ptr;
rgn_end = rgn->base + rgn->size;
- assert(allocated_ptr);
- assert(*b == 0);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(*b, 0);
+
+ ASSERT_EQ(rgn->size, size);
+ ASSERT_EQ(rgn->base, min_addr);
+ ASSERT_LT(rgn_end, max_addr);
- assert(rgn->size == size);
- assert(rgn->base == min_addr);
- assert(rgn_end < max_addr);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -725,6 +795,8 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
void *allocated_ptr = NULL;
char *b;
+ prefix_push(__func__);
+
phys_addr_t size = SZ_128;
phys_addr_t misalign = SZ_2;
phys_addr_t min_addr;
@@ -742,15 +814,18 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
b = (char *)allocated_ptr;
rgn_end = rgn->base + rgn->size;
- assert(allocated_ptr);
- assert(*b == 0);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(*b, 0);
+
+ ASSERT_EQ(rgn->size, size);
+ ASSERT_EQ(rgn->base, min_addr + (SMP_CACHE_BYTES - misalign));
+ ASSERT_LT(rgn_end, max_addr);
- assert(rgn->size == size);
- assert(rgn->base == min_addr + (SMP_CACHE_BYTES - misalign));
- assert(rgn_end < max_addr);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -778,6 +853,8 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
void *allocated_ptr = NULL;
char *b;
+ prefix_push(__func__);
+
phys_addr_t size = SZ_256;
phys_addr_t min_addr;
phys_addr_t max_addr;
@@ -792,14 +869,17 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
NUMA_NO_NODE);
b = (char *)allocated_ptr;
- assert(allocated_ptr);
- assert(*b == 0);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(*b, 0);
- assert(rgn->size == size);
- assert(rgn->base == memblock_start_of_DRAM());
+ ASSERT_EQ(rgn->size, size);
+ ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == size);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -829,6 +909,8 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
char *b;
struct region r1, r2;
+ prefix_push(__func__);
+
phys_addr_t r3_size = SZ_64;
phys_addr_t gap_size = SMP_CACHE_BYTES;
phys_addr_t total_size;
@@ -855,17 +937,20 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
NUMA_NO_NODE);
b = (char *)allocated_ptr;
- assert(allocated_ptr);
- assert(*b == 0);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(*b, 0);
- assert(rgn1->size == r1.size);
- assert(rgn1->base == max_addr);
+ ASSERT_EQ(rgn1->size, r1.size);
+ ASSERT_EQ(rgn1->base, max_addr);
- assert(rgn2->size == r2.size + r3_size);
- assert(rgn2->base == r2.base);
+ ASSERT_EQ(rgn2->size, r2.size + r3_size);
+ ASSERT_EQ(rgn2->base, r2.base);
- assert(memblock.reserved.cnt == 2);
- assert(memblock.reserved.total_size == total_size);
+ ASSERT_EQ(memblock.reserved.cnt, 2);
+ ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -899,6 +984,8 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
char *b;
struct region r1, r2;
+ prefix_push(__func__);
+
phys_addr_t r3_size = SZ_256;
phys_addr_t gap_size = SMP_CACHE_BYTES;
phys_addr_t total_size;
@@ -925,20 +1012,23 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
NUMA_NO_NODE);
b = (char *)allocated_ptr;
- assert(allocated_ptr);
- assert(*b == 0);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(*b, 0);
+
+ ASSERT_EQ(rgn3->size, r3_size);
+ ASSERT_EQ(rgn3->base, memblock_start_of_DRAM());
- assert(rgn3->size == r3_size);
- assert(rgn3->base == memblock_start_of_DRAM());
+ ASSERT_EQ(rgn2->size, r2.size);
+ ASSERT_EQ(rgn2->base, r2.base);
- assert(rgn2->size == r2.size);
- assert(rgn2->base == r2.base);
+ ASSERT_EQ(rgn1->size, r1.size);
+ ASSERT_EQ(rgn1->base, r1.base);
- assert(rgn1->size == r1.size);
- assert(rgn1->base == r1.base);
+ ASSERT_EQ(memblock.reserved.cnt, 3);
+ ASSERT_EQ(memblock.reserved.total_size, total_size);
- assert(memblock.reserved.cnt == 3);
- assert(memblock.reserved.total_size == total_size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -954,6 +1044,8 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
void *allocated_ptr = NULL;
char *b;
+ prefix_push(__func__);
+
phys_addr_t size = SZ_256;
phys_addr_t min_addr;
phys_addr_t max_addr;
@@ -968,14 +1060,17 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
NUMA_NO_NODE);
b = (char *)allocated_ptr;
- assert(allocated_ptr);
- assert(*b == 0);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(*b, 0);
+
+ ASSERT_EQ(rgn->size, size);
+ ASSERT_EQ(rgn->base, min_addr);
- assert(rgn->size == size);
- assert(rgn->base == min_addr);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -991,6 +1086,8 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
void *allocated_ptr = NULL;
char *b;
+ prefix_push(__func__);
+
phys_addr_t size = SZ_1K;
phys_addr_t min_addr;
phys_addr_t max_addr;
@@ -1005,14 +1102,17 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
NUMA_NO_NODE);
b = (char *)allocated_ptr;
- assert(allocated_ptr);
- assert(*b == 0);
+ ASSERT_NE(allocated_ptr, NULL);
+ ASSERT_EQ(*b, 0);
+
+ ASSERT_EQ(rgn->size, size);
+ ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
- assert(rgn->size == size);
- assert(rgn->base == memblock_start_of_DRAM());
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -1020,6 +1120,7 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
/* Test case wrappers */
static int alloc_try_nid_simple_check(void)
{
+ test_print("\tRunning %s...\n", __func__);
memblock_set_bottom_up(false);
alloc_try_nid_top_down_simple_check();
memblock_set_bottom_up(true);
@@ -1030,6 +1131,7 @@ static int alloc_try_nid_simple_check(void)
static int alloc_try_nid_misaligned_check(void)
{
+ test_print("\tRunning %s...\n", __func__);
memblock_set_bottom_up(false);
alloc_try_nid_top_down_end_misaligned_check();
memblock_set_bottom_up(true);
@@ -1040,6 +1142,7 @@ static int alloc_try_nid_misaligned_check(void)
static int alloc_try_nid_narrow_range_check(void)
{
+ test_print("\tRunning %s...\n", __func__);
memblock_set_bottom_up(false);
alloc_try_nid_top_down_narrow_range_check();
memblock_set_bottom_up(true);
@@ -1050,6 +1153,7 @@ static int alloc_try_nid_narrow_range_check(void)
static int alloc_try_nid_reserved_with_space_check(void)
{
+ test_print("\tRunning %s...\n", __func__);
memblock_set_bottom_up(false);
alloc_try_nid_top_down_reserved_with_space_check();
memblock_set_bottom_up(true);
@@ -1060,6 +1164,7 @@ static int alloc_try_nid_reserved_with_space_check(void)
static int alloc_try_nid_reserved_no_space_check(void)
{
+ test_print("\tRunning %s...\n", __func__);
memblock_set_bottom_up(false);
alloc_try_nid_top_down_reserved_no_space_check();
memblock_set_bottom_up(true);
@@ -1070,6 +1175,7 @@ static int alloc_try_nid_reserved_no_space_check(void)
static int alloc_try_nid_cap_max_check(void)
{
+ test_print("\tRunning %s...\n", __func__);
memblock_set_bottom_up(false);
alloc_try_nid_top_down_cap_max_check();
memblock_set_bottom_up(true);
@@ -1080,6 +1186,7 @@ static int alloc_try_nid_cap_max_check(void)
static int alloc_try_nid_cap_min_check(void)
{
+ test_print("\tRunning %s...\n", __func__);
memblock_set_bottom_up(false);
alloc_try_nid_top_down_cap_min_check();
memblock_set_bottom_up(true);
@@ -1090,6 +1197,7 @@ 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);
@@ -1100,6 +1208,7 @@ 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);
@@ -1110,6 +1219,7 @@ 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);
@@ -1120,6 +1230,7 @@ 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);
@@ -1130,6 +1241,7 @@ 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);
@@ -1140,6 +1252,7 @@ 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);
@@ -1150,6 +1263,12 @@ static int alloc_try_nid_low_max_check(void)
int memblock_alloc_nid_checks(void)
{
+ static const char func_testing[] = "memblock_alloc_try_nid";
+
+ prefix_reset();
+ prefix_push(func_testing);
+ test_print("Running %s tests...\n", func_testing);
+
reset_memblock_attributes();
dummy_physical_memory_init();
@@ -1170,5 +1289,7 @@ int memblock_alloc_nid_checks(void)
dummy_physical_memory_cleanup();
+ prefix_pop();
+
return 0;
}
diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c
index a7bc180316d6..f223a9a57be7 100644
--- a/tools/testing/memblock/tests/basic_api.c
+++ b/tools/testing/memblock/tests/basic_api.c
@@ -4,21 +4,30 @@
#include "basic_api.h"
#define EXPECTED_MEMBLOCK_REGIONS 128
+#define FUNC_ADD "memblock_add"
+#define FUNC_RESERVE "memblock_reserve"
+#define FUNC_REMOVE "memblock_remove"
+#define FUNC_FREE "memblock_free"
static int memblock_initialization_check(void)
{
- assert(memblock.memory.regions);
- assert(memblock.memory.cnt == 1);
- assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
- assert(strcmp(memblock.memory.name, "memory") == 0);
+ prefix_push(__func__);
- assert(memblock.reserved.regions);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
- assert(strcmp(memblock.reserved.name, "reserved") == 0);
+ ASSERT_NE(memblock.memory.regions, NULL);
+ ASSERT_EQ(memblock.memory.cnt, 1);
+ ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
+ ASSERT_EQ(strcmp(memblock.memory.name, "memory"), 0);
- assert(!memblock.bottom_up);
- assert(memblock.current_limit == MEMBLOCK_ALLOC_ANYWHERE);
+ ASSERT_NE(memblock.reserved.regions, NULL);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
+ ASSERT_EQ(strcmp(memblock.reserved.name, "reserved"), 0);
+
+ ASSERT_EQ(memblock.bottom_up, false);
+ ASSERT_EQ(memblock.current_limit, MEMBLOCK_ALLOC_ANYWHERE);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -40,14 +49,19 @@ static int memblock_add_simple_check(void)
.size = SZ_4M
};
+ prefix_push(__func__);
+
reset_memblock_regions();
memblock_add(r.base, r.size);
- assert(rgn->base == r.base);
- assert(rgn->size == r.size);
+ ASSERT_EQ(rgn->base, r.base);
+ ASSERT_EQ(rgn->size, r.size);
+
+ ASSERT_EQ(memblock.memory.cnt, 1);
+ ASSERT_EQ(memblock.memory.total_size, r.size);
- assert(memblock.memory.cnt == 1);
- assert(memblock.memory.total_size == r.size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -69,18 +83,27 @@ static int memblock_add_node_simple_check(void)
.size = SZ_16M
};
+ prefix_pop();
+ prefix_push("memblock_add_node");
+ prefix_push(__func__);
+
reset_memblock_regions();
memblock_add_node(r.base, r.size, 1, MEMBLOCK_HOTPLUG);
- assert(rgn->base == r.base);
- assert(rgn->size == r.size);
+ ASSERT_EQ(rgn->base, r.base);
+ ASSERT_EQ(rgn->size, r.size);
#ifdef CONFIG_NUMA
- assert(rgn->nid == 1);
+ ASSERT_EQ(rgn->nid, 1);
#endif
- assert(rgn->flags == MEMBLOCK_HOTPLUG);
+ ASSERT_EQ(rgn->flags, MEMBLOCK_HOTPLUG);
+
+ ASSERT_EQ(memblock.memory.cnt, 1);
+ ASSERT_EQ(memblock.memory.total_size, r.size);
- assert(memblock.memory.cnt == 1);
- assert(memblock.memory.total_size == r.size);
+ test_pass();
+ prefix_pop();
+ prefix_pop();
+ prefix_push(FUNC_ADD);
return 0;
}
@@ -113,18 +136,23 @@ static int memblock_add_disjoint_check(void)
.size = SZ_8K
};
+ prefix_push(__func__);
+
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_add(r2.base, r2.size);
- assert(rgn1->base == r1.base);
- assert(rgn1->size == r1.size);
+ 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(rgn2->base == r2.base);
- assert(rgn2->size == r2.size);
+ ASSERT_EQ(memblock.memory.cnt, 2);
+ ASSERT_EQ(memblock.memory.total_size, r1.size + r2.size);
- assert(memblock.memory.cnt == 2);
- assert(memblock.memory.total_size == r1.size + r2.size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -162,17 +190,22 @@ static int memblock_add_overlap_top_check(void)
.size = SZ_512M
};
+ prefix_push(__func__);
+
total_size = (r1.base - r2.base) + r1.size;
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_add(r2.base, r2.size);
- assert(rgn->base == r2.base);
- assert(rgn->size == total_size);
+ ASSERT_EQ(rgn->base, r2.base);
+ ASSERT_EQ(rgn->size, total_size);
+
+ ASSERT_EQ(memblock.memory.cnt, 1);
+ ASSERT_EQ(memblock.memory.total_size, total_size);
- assert(memblock.memory.cnt == 1);
- assert(memblock.memory.total_size == total_size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -210,17 +243,22 @@ static int memblock_add_overlap_bottom_check(void)
.size = SZ_1G
};
+ prefix_push(__func__);
+
total_size = (r2.base - r1.base) + r2.size;
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_add(r2.base, r2.size);
- assert(rgn->base == r1.base);
- assert(rgn->size == total_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);
- assert(memblock.memory.cnt == 1);
- assert(memblock.memory.total_size == total_size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -255,15 +293,20 @@ static int memblock_add_within_check(void)
.size = SZ_1M
};
+ prefix_push(__func__);
+
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_add(r2.base, r2.size);
- assert(rgn->base == r1.base);
- assert(rgn->size == r1.size);
+ ASSERT_EQ(rgn->base, r1.base);
+ ASSERT_EQ(rgn->size, r1.size);
+
+ ASSERT_EQ(memblock.memory.cnt, 1);
+ ASSERT_EQ(memblock.memory.total_size, r1.size);
- assert(memblock.memory.cnt == 1);
- assert(memblock.memory.total_size == r1.size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -279,19 +322,28 @@ static int memblock_add_twice_check(void)
.size = SZ_2M
};
+ prefix_push(__func__);
+
reset_memblock_regions();
memblock_add(r.base, r.size);
memblock_add(r.base, r.size);
- assert(memblock.memory.cnt == 1);
- assert(memblock.memory.total_size == r.size);
+ ASSERT_EQ(memblock.memory.cnt, 1);
+ ASSERT_EQ(memblock.memory.total_size, r.size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
static int memblock_add_checks(void)
{
+ prefix_reset();
+ prefix_push(FUNC_ADD);
+ test_print("Running %s tests...\n", FUNC_ADD);
+
memblock_add_simple_check();
memblock_add_node_simple_check();
memblock_add_disjoint_check();
@@ -300,6 +352,8 @@ static int memblock_add_checks(void)
memblock_add_within_check();
memblock_add_twice_check();
+ prefix_pop();
+
return 0;
}
@@ -320,11 +374,16 @@ static int memblock_reserve_simple_check(void)
.size = SZ_128M
};
+ prefix_push(__func__);
+
reset_memblock_regions();
memblock_reserve(r.base, r.size);
- assert(rgn->base == r.base);
- assert(rgn->size == r.size);
+ ASSERT_EQ(rgn->base, r.base);
+ ASSERT_EQ(rgn->size, r.size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -356,18 +415,23 @@ static int memblock_reserve_disjoint_check(void)
.size = SZ_512M
};
+ prefix_push(__func__);
+
reset_memblock_regions();
memblock_reserve(r1.base, r1.size);
memblock_reserve(r2.base, r2.size);
- assert(rgn1->base == r1.base);
- assert(rgn1->size == r1.size);
+ 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(rgn2->base == r2.base);
- assert(rgn2->size == r2.size);
+ ASSERT_EQ(memblock.reserved.cnt, 2);
+ ASSERT_EQ(memblock.reserved.total_size, r1.size + r2.size);
- assert(memblock.reserved.cnt == 2);
- assert(memblock.reserved.total_size == r1.size + r2.size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -406,17 +470,22 @@ static int memblock_reserve_overlap_top_check(void)
.size = SZ_1G
};
+ prefix_push(__func__);
+
total_size = (r1.base - r2.base) + r1.size;
reset_memblock_regions();
memblock_reserve(r1.base, r1.size);
memblock_reserve(r2.base, r2.size);
- assert(rgn->base == r2.base);
- assert(rgn->size == total_size);
+ ASSERT_EQ(rgn->base, r2.base);
+ ASSERT_EQ(rgn->size, total_size);
+
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, total_size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == total_size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -455,17 +524,22 @@ static int memblock_reserve_overlap_bottom_check(void)
.size = SZ_128K
};
+ prefix_push(__func__);
+
total_size = (r2.base - r1.base) + r2.size;
reset_memblock_regions();
memblock_reserve(r1.base, r1.size);
memblock_reserve(r2.base, r2.size);
- assert(rgn->base == r1.base);
- assert(rgn->size == total_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);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == total_size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -502,15 +576,20 @@ static int memblock_reserve_within_check(void)
.size = SZ_64K
};
+ prefix_push(__func__);
+
reset_memblock_regions();
memblock_reserve(r1.base, r1.size);
memblock_reserve(r2.base, r2.size);
- assert(rgn->base == r1.base);
- assert(rgn->size == r1.size);
+ ASSERT_EQ(rgn->base, r1.base);
+ ASSERT_EQ(rgn->size, r1.size);
+
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, r1.size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == r1.size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -527,19 +606,28 @@ static int memblock_reserve_twice_check(void)
.size = SZ_2M
};
+ prefix_push(__func__);
+
reset_memblock_regions();
memblock_reserve(r.base, r.size);
memblock_reserve(r.base, r.size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == r.size);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, r.size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
static int memblock_reserve_checks(void)
{
+ prefix_reset();
+ prefix_push(FUNC_RESERVE);
+ test_print("Running %s tests...\n", FUNC_RESERVE);
+
memblock_reserve_simple_check();
memblock_reserve_disjoint_check();
memblock_reserve_overlap_top_check();
@@ -547,6 +635,8 @@ static int memblock_reserve_checks(void)
memblock_reserve_within_check();
memblock_reserve_twice_check();
+ prefix_pop();
+
return 0;
}
@@ -581,16 +671,21 @@ static int memblock_remove_simple_check(void)
.size = SZ_4M
};
+ prefix_push(__func__);
+
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_add(r2.base, r2.size);
memblock_remove(r1.base, r1.size);
- assert(rgn->base == r2.base);
- assert(rgn->size == r2.size);
+ ASSERT_EQ(rgn->base, r2.base);
+ ASSERT_EQ(rgn->size, r2.size);
- assert(memblock.memory.cnt == 1);
- assert(memblock.memory.total_size == r2.size);
+ ASSERT_EQ(memblock.memory.cnt, 1);
+ ASSERT_EQ(memblock.memory.total_size, r2.size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -626,15 +721,20 @@ static int memblock_remove_absent_check(void)
.size = SZ_1G
};
+ prefix_push(__func__);
+
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_remove(r2.base, r2.size);
- assert(rgn->base == r1.base);
- assert(rgn->size == r1.size);
+ ASSERT_EQ(rgn->base, r1.base);
+ ASSERT_EQ(rgn->size, r1.size);
+
+ ASSERT_EQ(memblock.memory.cnt, 1);
+ ASSERT_EQ(memblock.memory.total_size, r1.size);
- assert(memblock.memory.cnt == 1);
- assert(memblock.memory.total_size == r1.size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -674,6 +774,8 @@ static int memblock_remove_overlap_top_check(void)
.size = SZ_32M
};
+ prefix_push(__func__);
+
r1_end = r1.base + r1.size;
r2_end = r2.base + r2.size;
total_size = r1_end - r2_end;
@@ -682,11 +784,14 @@ static int memblock_remove_overlap_top_check(void)
memblock_add(r1.base, r1.size);
memblock_remove(r2.base, r2.size);
- assert(rgn->base == r1.base + r2.base);
- assert(rgn->size == total_size);
+ ASSERT_EQ(rgn->base, r1.base + r2.base);
+ ASSERT_EQ(rgn->size, total_size);
+
+ ASSERT_EQ(memblock.memory.cnt, 1);
+ ASSERT_EQ(memblock.memory.total_size, total_size);
- assert(memblock.memory.cnt == 1);
- assert(memblock.memory.total_size == total_size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -724,17 +829,23 @@ static int memblock_remove_overlap_bottom_check(void)
.size = SZ_256M
};
+ prefix_push(__func__);
+
total_size = r2.base - r1.base;
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_remove(r2.base, r2.size);
- assert(rgn->base == r1.base);
- assert(rgn->size == total_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();
+ prefix_pop();
- assert(memblock.memory.cnt == 1);
- assert(memblock.memory.total_size == total_size);
return 0;
}
@@ -774,6 +885,8 @@ static int memblock_remove_within_check(void)
.size = SZ_1M
};
+ prefix_push(__func__);
+
r1_size = r2.base - r1.base;
r2_size = (r1.base + r1.size) - (r2.base + r2.size);
total_size = r1_size + r2_size;
@@ -782,26 +895,35 @@ static int memblock_remove_within_check(void)
memblock_add(r1.base, r1.size);
memblock_remove(r2.base, r2.size);
- assert(rgn1->base == r1.base);
- assert(rgn1->size == r1_size);
+ ASSERT_EQ(rgn1->base, r1.base);
+ ASSERT_EQ(rgn1->size, r1_size);
+
+ ASSERT_EQ(rgn2->base, r2.base + r2.size);
+ ASSERT_EQ(rgn2->size, r2_size);
- assert(rgn2->base == r2.base + r2.size);
- assert(rgn2->size == r2_size);
+ ASSERT_EQ(memblock.memory.cnt, 2);
+ ASSERT_EQ(memblock.memory.total_size, total_size);
- assert(memblock.memory.cnt == 2);
- assert(memblock.memory.total_size == total_size);
+ test_pass();
+ prefix_pop();
return 0;
}
static int memblock_remove_checks(void)
{
+ prefix_reset();
+ prefix_push(FUNC_REMOVE);
+ test_print("Running %s tests...\n", FUNC_REMOVE);
+
memblock_remove_simple_check();
memblock_remove_absent_check();
memblock_remove_overlap_top_check();
memblock_remove_overlap_bottom_check();
memblock_remove_within_check();
+ prefix_pop();
+
return 0;
}
@@ -835,16 +957,21 @@ static int memblock_free_simple_check(void)
.size = SZ_1M
};
+ prefix_push(__func__);
+
reset_memblock_regions();
memblock_reserve(r1.base, r1.size);
memblock_reserve(r2.base, r2.size);
memblock_free((void *)r1.base, r1.size);
- assert(rgn->base == r2.base);
- assert(rgn->size == r2.size);
+ ASSERT_EQ(rgn->base, r2.base);
+ ASSERT_EQ(rgn->size, r2.size);
+
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, r2.size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == r2.size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -880,15 +1007,20 @@ static int memblock_free_absent_check(void)
.size = SZ_128M
};
+ prefix_push(__func__);
+
reset_memblock_regions();
memblock_reserve(r1.base, r1.size);
memblock_free((void *)r2.base, r2.size);
- assert(rgn->base == r1.base);
- assert(rgn->size == r1.size);
+ ASSERT_EQ(rgn->base, r1.base);
+ ASSERT_EQ(rgn->size, r1.size);
+
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, r1.size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == r1.size);
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -928,17 +1060,22 @@ static int memblock_free_overlap_top_check(void)
.size = SZ_8M
};
+ prefix_push(__func__);
+
total_size = (r1.size + r1.base) - (r2.base + r2.size);
reset_memblock_regions();
memblock_reserve(r1.base, r1.size);
memblock_free((void *)r2.base, r2.size);
- assert(rgn->base == r2.base + r2.size);
- assert(rgn->size == total_size);
+ ASSERT_EQ(rgn->base, r2.base + r2.size);
+ ASSERT_EQ(rgn->size, total_size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == total_size);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -973,17 +1110,22 @@ static int memblock_free_overlap_bottom_check(void)
.size = SZ_32M
};
+ prefix_push(__func__);
+
total_size = r2.base - r1.base;
reset_memblock_regions();
memblock_reserve(r1.base, r1.size);
memblock_free((void *)r2.base, r2.size);
- assert(rgn->base == r1.base);
- assert(rgn->size == total_size);
+ ASSERT_EQ(rgn->base, r1.base);
+ ASSERT_EQ(rgn->size, total_size);
- assert(memblock.reserved.cnt == 1);
- assert(memblock.reserved.total_size == total_size);
+ ASSERT_EQ(memblock.reserved.cnt, 1);
+ ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
@@ -1024,6 +1166,8 @@ static int memblock_free_within_check(void)
.size = SZ_1M
};
+ prefix_push(__func__);
+
r1_size = r2.base - r1.base;
r2_size = (r1.base + r1.size) - (r2.base + r2.size);
total_size = r1_size + r2_size;
@@ -1032,26 +1176,35 @@ static int memblock_free_within_check(void)
memblock_reserve(r1.base, r1.size);
memblock_free((void *)r2.base, r2.size);
- assert(rgn1->base == r1.base);
- assert(rgn1->size == r1_size);
+ ASSERT_EQ(rgn1->base, r1.base);
+ ASSERT_EQ(rgn1->size, r1_size);
- assert(rgn2->base == r2.base + r2.size);
- assert(rgn2->size == r2_size);
+ ASSERT_EQ(rgn2->base, r2.base + r2.size);
+ ASSERT_EQ(rgn2->size, r2_size);
- assert(memblock.reserved.cnt == 2);
- assert(memblock.reserved.total_size == total_size);
+ ASSERT_EQ(memblock.reserved.cnt, 2);
+ ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+ test_pass();
+ prefix_pop();
return 0;
}
static int memblock_free_checks(void)
{
+ prefix_reset();
+ prefix_push(FUNC_FREE);
+ test_print("Running %s tests...\n", FUNC_FREE);
+
memblock_free_simple_check();
memblock_free_absent_check();
memblock_free_overlap_top_check();
memblock_free_overlap_bottom_check();
memblock_free_within_check();
+ prefix_pop();
+
return 0;
}
diff --git a/tools/testing/memblock/tests/common.c b/tools/testing/memblock/tests/common.c
index 62d3191f7c9a..e55b2a8bf0ff 100644
--- a/tools/testing/memblock/tests/common.c
+++ b/tools/testing/memblock/tests/common.c
@@ -4,8 +4,12 @@
#define INIT_MEMBLOCK_REGIONS 128
#define INIT_MEMBLOCK_RESERVED_REGIONS INIT_MEMBLOCK_REGIONS
+#define PREFIXES_LEN_MAX 256
+#define DELIM ": "
+#define DELIM_LEN strlen(DELIM)
static struct test_memory memory_block;
+static char __maybe_unused prefixes[PREFIXES_LEN_MAX];
void reset_memblock_regions(void)
{
@@ -46,3 +50,57 @@ void dummy_physical_memory_cleanup(void)
{
free(memory_block.base);
}
+
+#ifdef VERBOSE
+void test_fail(void)
+{
+ ksft_test_result_fail(": %sfailed\n", prefixes);
+}
+
+void test_pass(void)
+{
+ ksft_test_result_pass(": %spassed\n", prefixes);
+}
+
+void test_print(const char *fmt, ...)
+{
+ int saved_errno = errno;
+ va_list args;
+
+ va_start(args, fmt);
+ errno = saved_errno;
+ vprintf(fmt, args);
+ va_end(args);
+}
+
+void prefix_reset(void)
+{
+ memset(prefixes, 0, PREFIXES_LEN_MAX);
+}
+
+void prefix_push(const char *prefix)
+{
+ int prefix_max = PREFIXES_LEN_MAX - strlen(prefixes) - DELIM_LEN - 1;
+
+ assert(strlen(prefix) <= prefix_max);
+ strncat(prefixes, prefix, prefix_max);
+ strncat(prefixes, DELIM, PREFIXES_LEN_MAX - strlen(prefixes) - 1);
+}
+
+void prefix_pop(void)
+{
+ char *ptr;
+
+ ptr = strrchr(prefixes, DELIM[0]);
+ if (!ptr)
+ prefixes[0] = 0;
+ else
+ *(ptr) = 0;
+
+ ptr = strrchr(prefixes, DELIM[0]);
+ if (!ptr)
+ prefixes[0] = 0;
+ else
+ *(ptr + DELIM_LEN) = 0;
+}
+#endif /* VERBOSE */
diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h
index 619054d03219..bdddb5f72871 100644
--- a/tools/testing/memblock/tests/common.h
+++ b/tools/testing/memblock/tests/common.h
@@ -7,9 +7,47 @@
#include <linux/types.h>
#include <linux/memblock.h>
#include <linux/sizes.h>
+#include <linux/printk.h>
+#include <../selftests/kselftest.h>
#define MEM_SIZE SZ_16K
+/**
+ * ASSERT_EQ():
+ * Check the condition
+ * @_expected == @_seen
+ * If false, print failed test message (if in VERBOSE mode) and then assert
+ */
+#define ASSERT_EQ(_expected, _seen) do { \
+ if ((_expected) != (_seen)) \
+ test_fail(); \
+ assert((_expected) == (_seen)); \
+} while (0)
+
+/**
+ * ASSERT_NE():
+ * Check the condition
+ * @_expected != @_seen
+ * If false, print failed test message (if in VERBOSE mode) and then assert
+ */
+#define ASSERT_NE(_expected, _seen) do { \
+ if ((_expected) == (_seen)) \
+ test_fail(); \
+ assert((_expected) != (_seen)); \
+} while (0)
+
+/**
+ * ASSERT_LT():
+ * Check the condition
+ * @_expected < @_seen
+ * If false, print failed test message (if in VERBOSE mode) and then assert
+ */
+#define ASSERT_LT(_expected, _seen) do { \
+ if ((_expected) >= (_seen)) \
+ test_fail(); \
+ assert((_expected) < (_seen)); \
+} while (0)
+
/*
* Available memory registered with memblock needs to be valid for allocs
* test to run. This is a convenience wrapper for memory allocated in
@@ -31,4 +69,20 @@ void setup_memblock(void);
void dummy_physical_memory_init(void);
void dummy_physical_memory_cleanup(void);
+#ifdef VERBOSE
+void test_fail(void);
+void test_pass(void);
+void test_print(const char *fmt, ...);
+void prefix_reset(void);
+void prefix_push(const char *prefix);
+void prefix_pop(void);
+#else
+static inline void test_fail(void) {}
+static inline void test_pass(void) {}
+static inline void test_print(const char *fmt, ...) {}
+static inline void prefix_reset(void) {}
+static inline void prefix_push(const char *prefix) {}
+static inline void prefix_pop(void) {}
+#endif /* VERBOSE */
+
#endif
--
2.34.1
^ permalink raw reply related [flat|nested] 31+ messages in thread
* [PATCH v3 3/4] memblock tests: set memblock_debug to enable memblock_dbg() messages
2022-06-22 9:29 [PATCH v3 0/4] memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options Rebecca Mckeever
2022-06-22 9:29 ` [PATCH v3 1/4] memblock tests: add user-provided arguments to Makefile Rebecca Mckeever
2022-06-22 9:29 ` [PATCH v3 2/4] memblock tests: add verbose output to memblock tests Rebecca Mckeever
@ 2022-06-22 9:29 ` Rebecca Mckeever
2022-06-22 9:29 ` [PATCH v3 4/4] memblock tests: remove completed TODO items Rebecca Mckeever
` (3 subsequent siblings)
6 siblings, 0 replies; 31+ messages in thread
From: Rebecca Mckeever @ 2022-06-22 9:29 UTC (permalink / raw)
To: Mike Rapoport, linux-mm, linux-kernel; +Cc: David Hildenbrand, Rebecca Mckeever
If Memblock simulator was compiled with MEMBLOCK_DEBUG=1, set
memblock_debug to 1 so that memblock_dbg() will print debug information
when memblock functions are tested in Memblock simulator.
Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
---
tools/testing/memblock/internal.h | 7 +++++++
1 file changed, 7 insertions(+)
diff --git a/tools/testing/memblock/internal.h b/tools/testing/memblock/internal.h
index 94b52a8718b5..c2a492c05e0c 100644
--- a/tools/testing/memblock/internal.h
+++ b/tools/testing/memblock/internal.h
@@ -2,6 +2,13 @@
#ifndef _MM_INTERNAL_H
#define _MM_INTERNAL_H
+/*
+ * Enable memblock_dbg() messages
+ */
+#ifdef MEMBLOCK_DEBUG
+static int memblock_debug = 1;
+#endif
+
struct page {};
void memblock_free_pages(struct page *page, unsigned long pfn,
--
2.34.1
^ permalink raw reply related [flat|nested] 31+ messages in thread
* [PATCH v3 4/4] memblock tests: remove completed TODO items
2022-06-22 9:29 [PATCH v3 0/4] memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options Rebecca Mckeever
` (2 preceding siblings ...)
2022-06-22 9:29 ` [PATCH v3 3/4] memblock tests: set memblock_debug to enable memblock_dbg() messages Rebecca Mckeever
@ 2022-06-22 9:29 ` Rebecca Mckeever
2022-06-22 10:00 ` [PATCH v3 0/4] memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options David Hildenbrand
` (2 subsequent siblings)
6 siblings, 0 replies; 31+ messages in thread
From: Rebecca Mckeever @ 2022-06-22 9:29 UTC (permalink / raw)
To: Mike Rapoport, linux-mm, linux-kernel; +Cc: David Hildenbrand, Rebecca Mckeever
Remove completed items from TODO list.
Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
---
tools/testing/memblock/TODO | 14 +++-----------
1 file changed, 3 insertions(+), 11 deletions(-)
diff --git a/tools/testing/memblock/TODO b/tools/testing/memblock/TODO
index cd1a30d5acc9..33044c634ea7 100644
--- a/tools/testing/memblock/TODO
+++ b/tools/testing/memblock/TODO
@@ -1,25 +1,17 @@
TODO
=====
-1. Add verbose output (e.g., what is being tested and how many tests cases are
- passing)
-
-2. Add flags to Makefile:
- + verbosity level
- + enable memblock_dbg() messages (i.e. pass "-D CONFIG_DEBUG_MEMORY_INIT"
- flag)
-
-3. Add tests trying to memblock_add() or memblock_reserve() 129th region.
+1. Add tests trying to memblock_add() or memblock_reserve() 129th region.
This will trigger memblock_double_array(), make sure it succeeds.
*Important:* These tests require valid memory ranges, use dummy physical
memory block from common.c to implement them. It is also very
likely that the current MEM_SIZE won't be enough for these
test cases. Use realloc to adjust the size accordingly.
-4. Add test cases using this functions (implement them for both directions):
+2. Add test cases using this functions (implement them for both directions):
+ memblock_alloc_raw()
+ memblock_alloc_exact_nid_raw()
+ memblock_alloc_try_nid_raw()
-5. Add tests for memblock_alloc_node() to check if the correct NUMA node is set
+3. Add tests for memblock_alloc_node() to check if the correct NUMA node is set
for the new region
--
2.34.1
^ permalink raw reply related [flat|nested] 31+ messages in thread
* Re: [PATCH v3 0/4] memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options
2022-06-22 9:29 [PATCH v3 0/4] memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options Rebecca Mckeever
` (3 preceding siblings ...)
2022-06-22 9:29 ` [PATCH v3 4/4] memblock tests: remove completed TODO items Rebecca Mckeever
@ 2022-06-22 10:00 ` David Hildenbrand
2022-06-23 0:54 ` Rebecca Mckeever
2022-06-22 14:17 ` Mike Rapoport
2022-06-23 3:30 ` Ira Weiny
6 siblings, 1 reply; 31+ messages in thread
From: David Hildenbrand @ 2022-06-22 10:00 UTC (permalink / raw)
To: Rebecca Mckeever, Mike Rapoport, linux-mm, linux-kernel
On 22.06.22 11:29, Rebecca Mckeever wrote:
> These patches add options VERBOSE and MEMBLOCK_DEBUG to Memblock
> simulator, which can be specified when running make. These patches also
> implement the functionality for these options.
>
> VERBOSE
> Usage:
>
> $ make VERBOSE=1
>
> Passing VERBOSE=1 will enable verbose output from Memblock simulator. For
> each test, the verbose output includes the name of the memblock function
> being tested, the name of the test, and whether the test passed or failed.
> Since all the tests in Memblock simulator run as one monolithic test, this
> output is a quick way to get a summary of test results.
>
> MEMBLOCK_DEBUG
> Usage:
>
> $ make MEMBLOCK_DEBUG=1
>
> Passing MEMBLOCK_DEBUG=1 will enable memblock_dbg() messages. These
> are debug messages built into several functions in memblock that include
> information such as the name of the function and the size and start and
> end addresses of the memblock region.
>
> Rebecca Mckeever (4):
> memblock tests: add user-provided arguments to Makefile
> memblock tests: add verbose output to memblock tests
> memblock tests: set memblock_debug to enable memblock_dbg() messages
> memblock tests: remove completed TODO items
>
> tools/testing/memblock/Makefile | 4 +
> tools/testing/memblock/README | 10 +-
> tools/testing/memblock/TODO | 14 +-
> tools/testing/memblock/internal.h | 7 +
> .../testing/memblock/scripts/Makefile.include | 10 +
> tools/testing/memblock/tests/alloc_api.c | 241 ++++++++----
> .../memblock/tests/alloc_helpers_api.c | 135 +++++--
> tools/testing/memblock/tests/alloc_nid_api.c | 371 ++++++++++++------
> tools/testing/memblock/tests/basic_api.c | 365 ++++++++++++-----
> tools/testing/memblock/tests/common.c | 58 +++
> tools/testing/memblock/tests/common.h | 54 +++
> 11 files changed, 913 insertions(+), 356 deletions(-)
>
> ---
> Changes
>
> v1 -> v2
> PATCH 2, in common.c:
> Remove #ifdef VERBOSE around prefixes and related constants
> Add __maybe_unused to prefixes
> Move PREFIXES_LEN_MAX, DELIM, and DELIM_LEN so that they are
> immediately after the other constants
> Add #ifdef VERBOSE around definitions for test_*() and prefix_*()
>
> v2 -> v3
> PATCH 1:
> Add Reviewed-by tag
> ---
>
Hi Rebecca,
no need to resend a new version that frequently; wait for more feedback
first.
Usually, people expect a new version when there hasn't been more review
feedback for a few days.
Also, there is usually no need to send a new version when you get a
rb/ack tag: the maintainer might just pick them up when applying the
patches.
--
Thanks,
David / dhildenb
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 2/4] memblock tests: add verbose output to memblock tests
2022-06-22 9:29 ` [PATCH v3 2/4] memblock tests: add verbose output to memblock tests Rebecca Mckeever
@ 2022-06-22 10:32 ` Huang, Shaoqin
2022-06-23 0:45 ` Rebecca Mckeever
2022-06-23 3:37 ` Ira Weiny
2022-06-23 4:30 ` Mike Rapoport
2 siblings, 1 reply; 31+ messages in thread
From: Huang, Shaoqin @ 2022-06-22 10:32 UTC (permalink / raw)
To: Rebecca Mckeever, Mike Rapoport, linux-mm, linux-kernel; +Cc: David Hildenbrand
Just test it and everything works fine. And I think there are some thing
can improve:
The prefix_push() and prefix_pop() are used in so many functions
and almost of them just put the prefix_push(__func__) begin in the head
and the prefix_pop() in the end.
May be you can define some macro that when you output something and
automatically push the __func__ as prefix. And when leave the function,
automatically pop it. And only in some special place, you call it manually.
On 6/22/2022 5:29 PM, Rebecca Mckeever wrote:
> Add and use functions for printing verbose testing output.
>
> If the Memblock simulator was compiled with VERBOSE=1:
> prefix_push() appends the given string to a prefix string that will be
> printed in the test functions.
> prefix_pop() removes the last prefix from the prefix string.
> prefix_reset() clears the prefix string.
> test_fail() prints a message after a test fails containing the test
> number of the failing test and the prefix.
> test_pass() prints a message after a test passes containing its test
> number and the prefix.
> test_print() prints the given formatted output string.
>
Comments like this is more clear, not just indent:
- prefix_push(): appends ...
- prefix_pop(): removes ...
> If the Memblock simulator was not compiled with VERBOSE=1, these
> functions do nothing.
>
> Add the assert wrapper macros ASSERT_EQ(), ASSERT_NE(), and ASSERT_LT().
> If the assert condition fails, these macros call test_fail() before
> executing assert().
>
> Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> ---
> tools/testing/memblock/tests/alloc_api.c | 241 ++++++++----
> .../memblock/tests/alloc_helpers_api.c | 135 +++++--
> tools/testing/memblock/tests/alloc_nid_api.c | 371 ++++++++++++------
> tools/testing/memblock/tests/basic_api.c | 365 ++++++++++++-----
> tools/testing/memblock/tests/common.c | 58 +++
> tools/testing/memblock/tests/common.h | 54 +++
> 6 files changed, 880 insertions(+), 344 deletions(-)
>
> diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
> index d1aa7e15c18d..96df033d4300 100644
> --- a/tools/testing/memblock/tests/alloc_api.c
> +++ b/tools/testing/memblock/tests/alloc_api.c
> @@ -10,6 +10,8 @@ static int alloc_top_down_simple_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_2;
> phys_addr_t expected_start;
>
> @@ -19,12 +21,15 @@ static int alloc_top_down_simple_check(void)
>
> allocated_ptr = memblock_alloc(size, SMP_CACHE_BYTES);
>
> - assert(allocated_ptr);
> - assert(rgn->size == size);
> - assert(rgn->base == expected_start);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, expected_start);
> +
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -55,6 +60,8 @@ static int alloc_top_down_disjoint_check(void)
> struct region r1;
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r2_size = SZ_16;
> /* Use custom alignment */
> phys_addr_t alignment = SMP_CACHE_BYTES * 2;
> @@ -73,15 +80,18 @@ static int alloc_top_down_disjoint_check(void)
>
> allocated_ptr = memblock_alloc(r2_size, alignment);
>
> - assert(allocated_ptr);
> - assert(rgn1->size == r1.size);
> - assert(rgn1->base == r1.base);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn1->size, r1.size);
> + ASSERT_EQ(rgn1->base, r1.base);
>
> - assert(rgn2->size == r2_size);
> - assert(rgn2->base == expected_start);
> + ASSERT_EQ(rgn2->size, r2_size);
> + ASSERT_EQ(rgn2->base, expected_start);
>
> - assert(memblock.reserved.cnt == 2);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 2);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -101,6 +111,8 @@ static int alloc_top_down_before_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> /*
> * The first region ends at the aligned address to test region merging
> */
> @@ -114,12 +126,15 @@ static int alloc_top_down_before_check(void)
>
> allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
>
> - assert(allocated_ptr);
> - assert(rgn->size == total_size);
> - assert(rgn->base == memblock_end_of_DRAM() - total_size);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, total_size);
> + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - total_size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -141,6 +156,8 @@ static int alloc_top_down_after_check(void)
> struct region r1;
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r2_size = SZ_512;
> phys_addr_t total_size;
>
> @@ -158,12 +175,15 @@ static int alloc_top_down_after_check(void)
>
> allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
>
> - assert(allocated_ptr);
> - assert(rgn->size == total_size);
> - assert(rgn->base == r1.base - r2_size);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, total_size);
> + ASSERT_EQ(rgn->base, r1.base - r2_size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -186,6 +206,8 @@ static int alloc_top_down_second_fit_check(void)
> struct region r1, r2;
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r3_size = SZ_1K;
> phys_addr_t total_size;
>
> @@ -204,12 +226,15 @@ static int alloc_top_down_second_fit_check(void)
>
> allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
>
> - assert(allocated_ptr);
> - assert(rgn->size == r2.size + r3_size);
> - assert(rgn->base == r2.base - r3_size);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, r2.size + r3_size);
> + ASSERT_EQ(rgn->base, r2.base - r3_size);
>
> - assert(memblock.reserved.cnt == 2);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 2);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -231,6 +256,8 @@ static int alloc_in_between_generic_check(void)
> struct region r1, r2;
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t gap_size = SMP_CACHE_BYTES;
> phys_addr_t r3_size = SZ_64;
> /*
> @@ -254,12 +281,15 @@ static int alloc_in_between_generic_check(void)
>
> allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
>
> - assert(allocated_ptr);
> - assert(rgn->size == total_size);
> - assert(rgn->base == r1.base - r2.size - r3_size);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, total_size);
> + ASSERT_EQ(rgn->base, r1.base - r2.size - r3_size);
> +
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -281,6 +311,8 @@ static int alloc_small_gaps_generic_check(void)
> {
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t region_size = SZ_1K;
> phys_addr_t gap_size = SZ_256;
> phys_addr_t region_end;
> @@ -296,7 +328,10 @@ static int alloc_small_gaps_generic_check(void)
>
> allocated_ptr = memblock_alloc(region_size, SMP_CACHE_BYTES);
>
> - assert(!allocated_ptr);
> + ASSERT_EQ(allocated_ptr, NULL);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -309,6 +344,8 @@ static int alloc_all_reserved_generic_check(void)
> {
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> setup_memblock();
>
> /* Simulate full memory */
> @@ -316,7 +353,10 @@ static int alloc_all_reserved_generic_check(void)
>
> allocated_ptr = memblock_alloc(SZ_256, SMP_CACHE_BYTES);
>
> - assert(!allocated_ptr);
> + ASSERT_EQ(allocated_ptr, NULL);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -338,6 +378,8 @@ static int alloc_no_space_generic_check(void)
> {
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> setup_memblock();
>
> phys_addr_t available_size = SZ_256;
> @@ -348,7 +390,10 @@ static int alloc_no_space_generic_check(void)
>
> allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
>
> - assert(!allocated_ptr);
> + ASSERT_EQ(allocated_ptr, NULL);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -369,6 +414,8 @@ static int alloc_limited_space_generic_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t available_size = SZ_256;
> phys_addr_t reserved_size = MEM_SIZE - available_size;
>
> @@ -379,12 +426,15 @@ static int alloc_limited_space_generic_check(void)
>
> allocated_ptr = memblock_alloc(available_size, SMP_CACHE_BYTES);
>
> - assert(allocated_ptr);
> - assert(rgn->size == MEM_SIZE);
> - assert(rgn->base == memblock_start_of_DRAM());
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, MEM_SIZE);
> + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> +
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, MEM_SIZE);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == MEM_SIZE);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -399,14 +449,19 @@ static int alloc_no_memory_generic_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
>
> allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
>
> - assert(!allocated_ptr);
> - assert(rgn->size == 0);
> - assert(rgn->base == 0);
> - assert(memblock.reserved.total_size == 0);
> + ASSERT_EQ(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, 0);
> + ASSERT_EQ(rgn->base, 0);
> + ASSERT_EQ(memblock.reserved.total_size, 0);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -421,16 +476,21 @@ static int alloc_bottom_up_simple_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> setup_memblock();
>
> allocated_ptr = memblock_alloc(SZ_2, SMP_CACHE_BYTES);
>
> - assert(allocated_ptr);
> - assert(rgn->size == SZ_2);
> - assert(rgn->base == memblock_start_of_DRAM());
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, SZ_2);
> + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == SZ_2);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, SZ_2);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -459,6 +519,8 @@ static int alloc_bottom_up_disjoint_check(void)
> struct region r1;
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r2_size = SZ_16;
> /* Use custom alignment */
> phys_addr_t alignment = SMP_CACHE_BYTES * 2;
> @@ -477,16 +539,19 @@ static int alloc_bottom_up_disjoint_check(void)
>
> allocated_ptr = memblock_alloc(r2_size, alignment);
>
> - assert(allocated_ptr);
> + ASSERT_NE(allocated_ptr, NULL);
>
> - assert(rgn1->size == r1.size);
> - assert(rgn1->base == r1.base);
> + ASSERT_EQ(rgn1->size, r1.size);
> + ASSERT_EQ(rgn1->base, r1.base);
>
> - assert(rgn2->size == r2_size);
> - assert(rgn2->base == expected_start);
> + ASSERT_EQ(rgn2->size, r2_size);
> + ASSERT_EQ(rgn2->base, expected_start);
>
> - assert(memblock.reserved.cnt == 2);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 2);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -506,6 +571,8 @@ static int alloc_bottom_up_before_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r1_size = SZ_512;
> phys_addr_t r2_size = SZ_128;
> phys_addr_t total_size = r1_size + r2_size;
> @@ -516,12 +583,15 @@ static int alloc_bottom_up_before_check(void)
>
> allocated_ptr = memblock_alloc(r1_size, SMP_CACHE_BYTES);
>
> - assert(allocated_ptr);
> - assert(rgn->size == total_size);
> - assert(rgn->base == memblock_start_of_DRAM());
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, total_size);
> + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -542,6 +612,8 @@ static int alloc_bottom_up_after_check(void)
> struct region r1;
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r2_size = SZ_512;
> phys_addr_t total_size;
>
> @@ -559,12 +631,15 @@ static int alloc_bottom_up_after_check(void)
>
> allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
>
> - assert(allocated_ptr);
> - assert(rgn->size == total_size);
> - assert(rgn->base == r1.base);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, total_size);
> + ASSERT_EQ(rgn->base, r1.base);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -588,6 +663,8 @@ static int alloc_bottom_up_second_fit_check(void)
> struct region r1, r2;
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r3_size = SZ_1K;
> phys_addr_t total_size;
>
> @@ -606,12 +683,15 @@ static int alloc_bottom_up_second_fit_check(void)
>
> allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
>
> - assert(allocated_ptr);
> - assert(rgn->size == r2.size + r3_size);
> - assert(rgn->base == r2.base);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, r2.size + r3_size);
> + ASSERT_EQ(rgn->base, r2.base);
>
> - assert(memblock.reserved.cnt == 2);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 2);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -619,6 +699,7 @@ static int alloc_bottom_up_second_fit_check(void)
> /* Test case wrappers */
> static int alloc_simple_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_top_down_simple_check();
> memblock_set_bottom_up(true);
> @@ -629,6 +710,7 @@ static int alloc_simple_check(void)
>
> static int alloc_disjoint_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_top_down_disjoint_check();
> memblock_set_bottom_up(true);
> @@ -639,6 +721,7 @@ static int alloc_disjoint_check(void)
>
> static int alloc_before_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_top_down_before_check();
> memblock_set_bottom_up(true);
> @@ -649,6 +732,7 @@ static int alloc_before_check(void)
>
> static int alloc_after_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_top_down_after_check();
> memblock_set_bottom_up(true);
> @@ -659,6 +743,7 @@ 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);
> @@ -669,6 +754,7 @@ static int alloc_in_between_check(void)
>
> static int alloc_second_fit_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_top_down_second_fit_check();
> memblock_set_bottom_up(true);
> @@ -679,6 +765,7 @@ 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);
> @@ -689,6 +776,7 @@ 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);
> @@ -699,6 +787,7 @@ 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);
> @@ -709,6 +798,7 @@ 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);
> @@ -719,6 +809,7 @@ 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);
> @@ -729,6 +820,12 @@ static int alloc_no_memory_check(void)
>
> int memblock_alloc_checks(void)
> {
> + static const char func_testing[] = "memblock_alloc";
> +
> + prefix_reset();
> + prefix_push(func_testing);
> + test_print("Running %s tests...\n", func_testing);
> +
> reset_memblock_attributes();
> dummy_physical_memory_init();
>
> @@ -746,5 +843,7 @@ int memblock_alloc_checks(void)
>
> dummy_physical_memory_cleanup();
>
> + prefix_pop();
> +
> return 0;
> }
> diff --git a/tools/testing/memblock/tests/alloc_helpers_api.c b/tools/testing/memblock/tests/alloc_helpers_api.c
> index 963a966db461..f6eaed540427 100644
> --- a/tools/testing/memblock/tests/alloc_helpers_api.c
> +++ b/tools/testing/memblock/tests/alloc_helpers_api.c
> @@ -21,6 +21,8 @@ static int alloc_from_simple_generic_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_16;
> phys_addr_t min_addr;
>
> @@ -31,14 +33,17 @@ static int alloc_from_simple_generic_check(void)
> allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, min_addr);
>
> - assert(rgn->size == size);
> - assert(rgn->base == min_addr);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -64,6 +69,8 @@ static int alloc_from_misaligned_generic_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_32;
> phys_addr_t min_addr;
>
> @@ -75,14 +82,17 @@ static int alloc_from_misaligned_generic_check(void)
> allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
>
> - assert(rgn->size == size);
> - assert(rgn->base == memblock_end_of_DRAM() - SMP_CACHE_BYTES);
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - SMP_CACHE_BYTES);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -110,6 +120,8 @@ static int alloc_from_top_down_high_addr_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_32;
> phys_addr_t min_addr;
>
> @@ -120,12 +132,15 @@ static int alloc_from_top_down_high_addr_check(void)
>
> allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
>
> - assert(allocated_ptr);
> - assert(rgn->size == size);
> - assert(rgn->base == memblock_end_of_DRAM() - SMP_CACHE_BYTES);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - SMP_CACHE_BYTES);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -151,6 +166,8 @@ static int alloc_from_top_down_no_space_above_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r1_size = SZ_64;
> phys_addr_t r2_size = SZ_2;
> phys_addr_t total_size = r1_size + r2_size;
> @@ -165,12 +182,15 @@ static int alloc_from_top_down_no_space_above_check(void)
>
> allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
>
> - assert(allocated_ptr);
> - assert(rgn->base == min_addr - r1_size);
> - assert(rgn->size == total_size);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->base, min_addr - r1_size);
> + ASSERT_EQ(rgn->size, total_size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -186,6 +206,8 @@ static int alloc_from_top_down_min_addr_cap_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r1_size = SZ_64;
> phys_addr_t min_addr;
> phys_addr_t start_addr;
> @@ -199,12 +221,15 @@ static int alloc_from_top_down_min_addr_cap_check(void)
>
> allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
>
> - assert(allocated_ptr);
> - assert(rgn->base == start_addr);
> - assert(rgn->size == MEM_SIZE);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->base, start_addr);
> + ASSERT_EQ(rgn->size, MEM_SIZE);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == MEM_SIZE);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, MEM_SIZE);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -230,6 +255,8 @@ static int alloc_from_bottom_up_high_addr_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_32;
> phys_addr_t min_addr;
>
> @@ -240,12 +267,15 @@ static int alloc_from_bottom_up_high_addr_check(void)
>
> allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
>
> - assert(allocated_ptr);
> - assert(rgn->size == size);
> - assert(rgn->base == memblock_start_of_DRAM());
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> +
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -270,6 +300,8 @@ static int alloc_from_bottom_up_no_space_above_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r1_size = SZ_64;
> phys_addr_t min_addr;
> phys_addr_t r2_size;
> @@ -284,12 +316,15 @@ static int alloc_from_bottom_up_no_space_above_check(void)
>
> allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
>
> - assert(allocated_ptr);
> - assert(rgn->base == memblock_start_of_DRAM());
> - assert(rgn->size == r1_size);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> + ASSERT_EQ(rgn->size, r1_size);
> +
> + ASSERT_EQ(memblock.reserved.cnt, 2);
> + ASSERT_EQ(memblock.reserved.total_size, r1_size + r2_size);
>
> - assert(memblock.reserved.cnt == 2);
> - assert(memblock.reserved.total_size == r1_size + r2_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -304,6 +339,8 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r1_size = SZ_64;
> phys_addr_t min_addr;
> phys_addr_t start_addr;
> @@ -315,12 +352,15 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
>
> allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
>
> - assert(allocated_ptr);
> - assert(rgn->base == start_addr);
> - assert(rgn->size == r1_size);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->base, start_addr);
> + ASSERT_EQ(rgn->size, r1_size);
> +
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, r1_size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == r1_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -328,6 +368,7 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
> /* Test case wrappers */
> 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);
> @@ -338,6 +379,7 @@ 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);
> @@ -348,6 +390,7 @@ static int alloc_from_misaligned_check(void)
>
> static int alloc_from_high_addr_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_from_top_down_high_addr_check();
> memblock_set_bottom_up(true);
> @@ -358,6 +401,7 @@ static int alloc_from_high_addr_check(void)
>
> static int alloc_from_no_space_above_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_from_top_down_no_space_above_check();
> memblock_set_bottom_up(true);
> @@ -368,6 +412,7 @@ static int alloc_from_no_space_above_check(void)
>
> static int alloc_from_min_addr_cap_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_from_top_down_min_addr_cap_check();
> memblock_set_bottom_up(true);
> @@ -378,6 +423,12 @@ static int alloc_from_min_addr_cap_check(void)
>
> int memblock_alloc_helpers_checks(void)
> {
> + static const char func_testing[] = "memblock_alloc_from";
> +
> + prefix_reset();
> + prefix_push(func_testing);
> + test_print("Running %s tests...\n", func_testing);
> +
> reset_memblock_attributes();
> dummy_physical_memory_init();
>
> diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
> index 6390206e50e1..601f4a7ee30d 100644
> --- a/tools/testing/memblock/tests/alloc_nid_api.c
> +++ b/tools/testing/memblock/tests/alloc_nid_api.c
> @@ -21,6 +21,8 @@ static int alloc_try_nid_top_down_simple_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_128;
> phys_addr_t min_addr;
> phys_addr_t max_addr;
> @@ -36,15 +38,18 @@ static int alloc_try_nid_top_down_simple_check(void)
> b = (char *)allocated_ptr;
> rgn_end = rgn->base + rgn->size;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, max_addr - size);
> + ASSERT_EQ(rgn_end, max_addr);
>
> - assert(rgn->size == size);
> - assert(rgn->base == max_addr - size);
> - assert(rgn_end == max_addr);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -72,6 +77,8 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_128;
> phys_addr_t misalign = SZ_2;
> phys_addr_t min_addr;
> @@ -88,15 +95,18 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
> b = (char *)allocated_ptr;
> rgn_end = rgn->base + rgn->size;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
>
> - assert(rgn->size == size);
> - assert(rgn->base == max_addr - size - misalign);
> - assert(rgn_end < max_addr);
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, max_addr - size - misalign);
> + ASSERT_LT(rgn_end, max_addr);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -122,6 +132,8 @@ static int alloc_try_nid_exact_address_generic_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_1K;
> phys_addr_t min_addr;
> phys_addr_t max_addr;
> @@ -137,15 +149,18 @@ static int alloc_try_nid_exact_address_generic_check(void)
> b = (char *)allocated_ptr;
> rgn_end = rgn->base + rgn->size;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, min_addr);
> + ASSERT_EQ(rgn_end, max_addr);
>
> - assert(rgn->size == size);
> - assert(rgn->base == min_addr);
> - assert(rgn_end == max_addr);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -173,6 +188,8 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_256;
> phys_addr_t min_addr;
> phys_addr_t max_addr;
> @@ -186,14 +203,17 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
> min_addr, max_addr, NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, max_addr - size);
>
> - assert(rgn->size == size);
> - assert(rgn->base == max_addr - size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -222,6 +242,8 @@ static int alloc_try_nid_low_max_generic_check(void)
> {
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_1K;
> phys_addr_t min_addr;
> phys_addr_t max_addr;
> @@ -234,7 +256,10 @@ static int alloc_try_nid_low_max_generic_check(void)
> allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> min_addr, max_addr, NUMA_NO_NODE);
>
> - assert(!allocated_ptr);
> + ASSERT_EQ(allocated_ptr, NULL);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -259,6 +284,8 @@ static int alloc_try_nid_min_reserved_generic_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t r1_size = SZ_128;
> phys_addr_t r2_size = SZ_64;
> phys_addr_t total_size = r1_size + r2_size;
> @@ -278,14 +305,17 @@ static int alloc_try_nid_min_reserved_generic_check(void)
> min_addr, max_addr, NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
>
> - assert(rgn->size == total_size);
> - assert(rgn->base == reserved_base);
> + ASSERT_EQ(rgn->size, total_size);
> + ASSERT_EQ(rgn->base, reserved_base);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -310,6 +340,8 @@ static int alloc_try_nid_max_reserved_generic_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t r1_size = SZ_64;
> phys_addr_t r2_size = SZ_128;
> phys_addr_t total_size = r1_size + r2_size;
> @@ -327,14 +359,17 @@ static int alloc_try_nid_max_reserved_generic_check(void)
> min_addr, max_addr, NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn->size, total_size);
> + ASSERT_EQ(rgn->base, min_addr);
>
> - assert(rgn->size == total_size);
> - assert(rgn->base == min_addr);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -364,6 +399,8 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
> char *b;
> struct region r1, r2;
>
> + prefix_push(__func__);
> +
> phys_addr_t r3_size = SZ_64;
> phys_addr_t gap_size = SMP_CACHE_BYTES;
> phys_addr_t total_size;
> @@ -389,17 +426,20 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
> min_addr, max_addr, NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn1->size, r1.size + r3_size);
> + ASSERT_EQ(rgn1->base, max_addr - r3_size);
>
> - assert(rgn1->size == r1.size + r3_size);
> - assert(rgn1->base == max_addr - r3_size);
> + ASSERT_EQ(rgn2->size, r2.size);
> + ASSERT_EQ(rgn2->base, r2.base);
>
> - assert(rgn2->size == r2.size);
> - assert(rgn2->base == r2.base);
> + ASSERT_EQ(memblock.reserved.cnt, 2);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>
> - assert(memblock.reserved.cnt == 2);
> - assert(memblock.reserved.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -427,6 +467,8 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
> char *b;
> struct region r1, r2;
>
> + prefix_push(__func__);
> +
> phys_addr_t r3_size = SZ_64;
> phys_addr_t total_size;
> phys_addr_t max_addr;
> @@ -451,14 +493,17 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
> min_addr, max_addr, NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
>
> - assert(rgn->size == total_size);
> - assert(rgn->base == r2.base);
> + ASSERT_EQ(rgn->size, total_size);
> + ASSERT_EQ(rgn->base, r2.base);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -489,6 +534,8 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
> char *b;
> struct region r1, r2;
>
> + prefix_push(__func__);
> +
> phys_addr_t r3_size = SZ_256;
> phys_addr_t gap_size = SMP_CACHE_BYTES;
> phys_addr_t total_size;
> @@ -514,17 +561,20 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
> min_addr, max_addr, NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn1->size, r1.size);
> + ASSERT_EQ(rgn1->base, r1.base);
>
> - assert(rgn1->size == r1.size);
> - assert(rgn1->base == r1.base);
> + ASSERT_EQ(rgn2->size, r2.size + r3_size);
> + ASSERT_EQ(rgn2->base, r2.base - r3_size);
>
> - assert(rgn2->size == r2.size + r3_size);
> - assert(rgn2->base == r2.base - r3_size);
> + ASSERT_EQ(memblock.reserved.cnt, 2);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>
> - assert(memblock.reserved.cnt == 2);
> - assert(memblock.reserved.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -554,6 +604,8 @@ static int alloc_try_nid_reserved_all_generic_check(void)
> void *allocated_ptr = NULL;
> struct region r1, r2;
>
> + prefix_push(__func__);
> +
> phys_addr_t r3_size = SZ_256;
> phys_addr_t gap_size = SMP_CACHE_BYTES;
> phys_addr_t max_addr;
> @@ -576,7 +628,10 @@ static int alloc_try_nid_reserved_all_generic_check(void)
> allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
> min_addr, max_addr, NUMA_NO_NODE);
>
> - assert(!allocated_ptr);
> + ASSERT_EQ(allocated_ptr, NULL);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -592,6 +647,8 @@ static int alloc_try_nid_top_down_cap_max_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_256;
> phys_addr_t min_addr;
> phys_addr_t max_addr;
> @@ -605,14 +662,17 @@ static int alloc_try_nid_top_down_cap_max_check(void)
> min_addr, max_addr, NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
>
> - assert(rgn->size == size);
> - assert(rgn->base == memblock_end_of_DRAM() - size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -628,6 +688,8 @@ static int alloc_try_nid_top_down_cap_min_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_1K;
> phys_addr_t min_addr;
> phys_addr_t max_addr;
> @@ -641,14 +703,17 @@ static int alloc_try_nid_top_down_cap_min_check(void)
> min_addr, max_addr, NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
>
> - assert(rgn->size == size);
> - assert(rgn->base == memblock_end_of_DRAM() - size);
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -673,6 +738,8 @@ static int alloc_try_nid_bottom_up_simple_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_128;
> phys_addr_t min_addr;
> phys_addr_t max_addr;
> @@ -689,15 +756,18 @@ static int alloc_try_nid_bottom_up_simple_check(void)
> b = (char *)allocated_ptr;
> rgn_end = rgn->base + rgn->size;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, min_addr);
> + ASSERT_LT(rgn_end, max_addr);
>
> - assert(rgn->size == size);
> - assert(rgn->base == min_addr);
> - assert(rgn_end < max_addr);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -725,6 +795,8 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_128;
> phys_addr_t misalign = SZ_2;
> phys_addr_t min_addr;
> @@ -742,15 +814,18 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
> b = (char *)allocated_ptr;
> rgn_end = rgn->base + rgn->size;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, min_addr + (SMP_CACHE_BYTES - misalign));
> + ASSERT_LT(rgn_end, max_addr);
>
> - assert(rgn->size == size);
> - assert(rgn->base == min_addr + (SMP_CACHE_BYTES - misalign));
> - assert(rgn_end < max_addr);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -778,6 +853,8 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_256;
> phys_addr_t min_addr;
> phys_addr_t max_addr;
> @@ -792,14 +869,17 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
> NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
>
> - assert(rgn->size == size);
> - assert(rgn->base == memblock_start_of_DRAM());
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -829,6 +909,8 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
> char *b;
> struct region r1, r2;
>
> + prefix_push(__func__);
> +
> phys_addr_t r3_size = SZ_64;
> phys_addr_t gap_size = SMP_CACHE_BYTES;
> phys_addr_t total_size;
> @@ -855,17 +937,20 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
> NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
>
> - assert(rgn1->size == r1.size);
> - assert(rgn1->base == max_addr);
> + ASSERT_EQ(rgn1->size, r1.size);
> + ASSERT_EQ(rgn1->base, max_addr);
>
> - assert(rgn2->size == r2.size + r3_size);
> - assert(rgn2->base == r2.base);
> + ASSERT_EQ(rgn2->size, r2.size + r3_size);
> + ASSERT_EQ(rgn2->base, r2.base);
>
> - assert(memblock.reserved.cnt == 2);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 2);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -899,6 +984,8 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
> char *b;
> struct region r1, r2;
>
> + prefix_push(__func__);
> +
> phys_addr_t r3_size = SZ_256;
> phys_addr_t gap_size = SMP_CACHE_BYTES;
> phys_addr_t total_size;
> @@ -925,20 +1012,23 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
> NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn3->size, r3_size);
> + ASSERT_EQ(rgn3->base, memblock_start_of_DRAM());
>
> - assert(rgn3->size == r3_size);
> - assert(rgn3->base == memblock_start_of_DRAM());
> + ASSERT_EQ(rgn2->size, r2.size);
> + ASSERT_EQ(rgn2->base, r2.base);
>
> - assert(rgn2->size == r2.size);
> - assert(rgn2->base == r2.base);
> + ASSERT_EQ(rgn1->size, r1.size);
> + ASSERT_EQ(rgn1->base, r1.base);
>
> - assert(rgn1->size == r1.size);
> - assert(rgn1->base == r1.base);
> + ASSERT_EQ(memblock.reserved.cnt, 3);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>
> - assert(memblock.reserved.cnt == 3);
> - assert(memblock.reserved.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -954,6 +1044,8 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_256;
> phys_addr_t min_addr;
> phys_addr_t max_addr;
> @@ -968,14 +1060,17 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
> NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, min_addr);
>
> - assert(rgn->size == size);
> - assert(rgn->base == min_addr);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -991,6 +1086,8 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_1K;
> phys_addr_t min_addr;
> phys_addr_t max_addr;
> @@ -1005,14 +1102,17 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
> NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
>
> - assert(rgn->size == size);
> - assert(rgn->base == memblock_start_of_DRAM());
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -1020,6 +1120,7 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
> /* Test case wrappers */
> static int alloc_try_nid_simple_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_try_nid_top_down_simple_check();
> memblock_set_bottom_up(true);
> @@ -1030,6 +1131,7 @@ static int alloc_try_nid_simple_check(void)
>
> static int alloc_try_nid_misaligned_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_try_nid_top_down_end_misaligned_check();
> memblock_set_bottom_up(true);
> @@ -1040,6 +1142,7 @@ static int alloc_try_nid_misaligned_check(void)
>
> static int alloc_try_nid_narrow_range_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_try_nid_top_down_narrow_range_check();
> memblock_set_bottom_up(true);
> @@ -1050,6 +1153,7 @@ static int alloc_try_nid_narrow_range_check(void)
>
> static int alloc_try_nid_reserved_with_space_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_try_nid_top_down_reserved_with_space_check();
> memblock_set_bottom_up(true);
> @@ -1060,6 +1164,7 @@ static int alloc_try_nid_reserved_with_space_check(void)
>
> static int alloc_try_nid_reserved_no_space_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_try_nid_top_down_reserved_no_space_check();
> memblock_set_bottom_up(true);
> @@ -1070,6 +1175,7 @@ static int alloc_try_nid_reserved_no_space_check(void)
>
> static int alloc_try_nid_cap_max_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_try_nid_top_down_cap_max_check();
> memblock_set_bottom_up(true);
> @@ -1080,6 +1186,7 @@ static int alloc_try_nid_cap_max_check(void)
>
> static int alloc_try_nid_cap_min_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_try_nid_top_down_cap_min_check();
> memblock_set_bottom_up(true);
> @@ -1090,6 +1197,7 @@ 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);
> @@ -1100,6 +1208,7 @@ 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);
> @@ -1110,6 +1219,7 @@ 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);
> @@ -1120,6 +1230,7 @@ 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);
> @@ -1130,6 +1241,7 @@ 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);
> @@ -1140,6 +1252,7 @@ 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);
> @@ -1150,6 +1263,12 @@ static int alloc_try_nid_low_max_check(void)
>
> int memblock_alloc_nid_checks(void)
> {
> + static const char func_testing[] = "memblock_alloc_try_nid";
> +
> + prefix_reset();
> + prefix_push(func_testing);
> + test_print("Running %s tests...\n", func_testing);
> +
> reset_memblock_attributes();
> dummy_physical_memory_init();
>
> @@ -1170,5 +1289,7 @@ int memblock_alloc_nid_checks(void)
>
> dummy_physical_memory_cleanup();
>
> + prefix_pop();
> +
> return 0;
> }
> diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c
> index a7bc180316d6..f223a9a57be7 100644
> --- a/tools/testing/memblock/tests/basic_api.c
> +++ b/tools/testing/memblock/tests/basic_api.c
> @@ -4,21 +4,30 @@
> #include "basic_api.h"
>
> #define EXPECTED_MEMBLOCK_REGIONS 128
> +#define FUNC_ADD "memblock_add"
> +#define FUNC_RESERVE "memblock_reserve"
> +#define FUNC_REMOVE "memblock_remove"
> +#define FUNC_FREE "memblock_free"
>
> static int memblock_initialization_check(void)
> {
> - assert(memblock.memory.regions);
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
> - assert(strcmp(memblock.memory.name, "memory") == 0);
> + prefix_push(__func__);
>
> - assert(memblock.reserved.regions);
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
> - assert(strcmp(memblock.reserved.name, "reserved") == 0);
> + ASSERT_NE(memblock.memory.regions, NULL);
> + ASSERT_EQ(memblock.memory.cnt, 1);
> + ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
> + ASSERT_EQ(strcmp(memblock.memory.name, "memory"), 0);
>
> - assert(!memblock.bottom_up);
> - assert(memblock.current_limit == MEMBLOCK_ALLOC_ANYWHERE);
> + ASSERT_NE(memblock.reserved.regions, NULL);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
> + ASSERT_EQ(strcmp(memblock.reserved.name, "reserved"), 0);
> +
> + ASSERT_EQ(memblock.bottom_up, false);
> + ASSERT_EQ(memblock.current_limit, MEMBLOCK_ALLOC_ANYWHERE);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -40,14 +49,19 @@ static int memblock_add_simple_check(void)
> .size = SZ_4M
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_add(r.base, r.size);
>
> - assert(rgn->base == r.base);
> - assert(rgn->size == r.size);
> + ASSERT_EQ(rgn->base, r.base);
> + ASSERT_EQ(rgn->size, r.size);
> +
> + ASSERT_EQ(memblock.memory.cnt, 1);
> + ASSERT_EQ(memblock.memory.total_size, r.size);
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == r.size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -69,18 +83,27 @@ static int memblock_add_node_simple_check(void)
> .size = SZ_16M
> };
>
> + prefix_pop();
> + prefix_push("memblock_add_node");
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_add_node(r.base, r.size, 1, MEMBLOCK_HOTPLUG);
>
> - assert(rgn->base == r.base);
> - assert(rgn->size == r.size);
> + ASSERT_EQ(rgn->base, r.base);
> + ASSERT_EQ(rgn->size, r.size);
> #ifdef CONFIG_NUMA
> - assert(rgn->nid == 1);
> + ASSERT_EQ(rgn->nid, 1);
> #endif
> - assert(rgn->flags == MEMBLOCK_HOTPLUG);
> + ASSERT_EQ(rgn->flags, MEMBLOCK_HOTPLUG);
> +
> + ASSERT_EQ(memblock.memory.cnt, 1);
> + ASSERT_EQ(memblock.memory.total_size, r.size);
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == r.size);
> + test_pass();
> + prefix_pop();
> + prefix_pop();
> + prefix_push(FUNC_ADD);
>
> return 0;
> }
> @@ -113,18 +136,23 @@ static int memblock_add_disjoint_check(void)
> .size = SZ_8K
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_add(r1.base, r1.size);
> memblock_add(r2.base, r2.size);
>
> - assert(rgn1->base == r1.base);
> - assert(rgn1->size == r1.size);
> + 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(rgn2->base == r2.base);
> - assert(rgn2->size == r2.size);
> + ASSERT_EQ(memblock.memory.cnt, 2);
> + ASSERT_EQ(memblock.memory.total_size, r1.size + r2.size);
>
> - assert(memblock.memory.cnt == 2);
> - assert(memblock.memory.total_size == r1.size + r2.size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -162,17 +190,22 @@ static int memblock_add_overlap_top_check(void)
> .size = SZ_512M
> };
>
> + prefix_push(__func__);
> +
> total_size = (r1.base - r2.base) + r1.size;
>
> reset_memblock_regions();
> memblock_add(r1.base, r1.size);
> memblock_add(r2.base, r2.size);
>
> - assert(rgn->base == r2.base);
> - assert(rgn->size == total_size);
> + ASSERT_EQ(rgn->base, r2.base);
> + ASSERT_EQ(rgn->size, total_size);
> +
> + ASSERT_EQ(memblock.memory.cnt, 1);
> + ASSERT_EQ(memblock.memory.total_size, total_size);
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -210,17 +243,22 @@ static int memblock_add_overlap_bottom_check(void)
> .size = SZ_1G
> };
>
> + prefix_push(__func__);
> +
> total_size = (r2.base - r1.base) + r2.size;
>
> reset_memblock_regions();
> memblock_add(r1.base, r1.size);
> memblock_add(r2.base, r2.size);
>
> - assert(rgn->base == r1.base);
> - assert(rgn->size == total_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);
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -255,15 +293,20 @@ static int memblock_add_within_check(void)
> .size = SZ_1M
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_add(r1.base, r1.size);
> memblock_add(r2.base, r2.size);
>
> - assert(rgn->base == r1.base);
> - assert(rgn->size == r1.size);
> + ASSERT_EQ(rgn->base, r1.base);
> + ASSERT_EQ(rgn->size, r1.size);
> +
> + ASSERT_EQ(memblock.memory.cnt, 1);
> + ASSERT_EQ(memblock.memory.total_size, r1.size);
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == r1.size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -279,19 +322,28 @@ static int memblock_add_twice_check(void)
> .size = SZ_2M
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
>
> memblock_add(r.base, r.size);
> memblock_add(r.base, r.size);
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == r.size);
> + ASSERT_EQ(memblock.memory.cnt, 1);
> + ASSERT_EQ(memblock.memory.total_size, r.size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
>
> static int memblock_add_checks(void)
> {
> + prefix_reset();
> + prefix_push(FUNC_ADD);
> + test_print("Running %s tests...\n", FUNC_ADD);
> +
> memblock_add_simple_check();
> memblock_add_node_simple_check();
> memblock_add_disjoint_check();
> @@ -300,6 +352,8 @@ static int memblock_add_checks(void)
> memblock_add_within_check();
> memblock_add_twice_check();
>
> + prefix_pop();
> +
> return 0;
> }
>
> @@ -320,11 +374,16 @@ static int memblock_reserve_simple_check(void)
> .size = SZ_128M
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_reserve(r.base, r.size);
>
> - assert(rgn->base == r.base);
> - assert(rgn->size == r.size);
> + ASSERT_EQ(rgn->base, r.base);
> + ASSERT_EQ(rgn->size, r.size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -356,18 +415,23 @@ static int memblock_reserve_disjoint_check(void)
> .size = SZ_512M
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_reserve(r1.base, r1.size);
> memblock_reserve(r2.base, r2.size);
>
> - assert(rgn1->base == r1.base);
> - assert(rgn1->size == r1.size);
> + 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(rgn2->base == r2.base);
> - assert(rgn2->size == r2.size);
> + ASSERT_EQ(memblock.reserved.cnt, 2);
> + ASSERT_EQ(memblock.reserved.total_size, r1.size + r2.size);
>
> - assert(memblock.reserved.cnt == 2);
> - assert(memblock.reserved.total_size == r1.size + r2.size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -406,17 +470,22 @@ static int memblock_reserve_overlap_top_check(void)
> .size = SZ_1G
> };
>
> + prefix_push(__func__);
> +
> total_size = (r1.base - r2.base) + r1.size;
>
> reset_memblock_regions();
> memblock_reserve(r1.base, r1.size);
> memblock_reserve(r2.base, r2.size);
>
> - assert(rgn->base == r2.base);
> - assert(rgn->size == total_size);
> + ASSERT_EQ(rgn->base, r2.base);
> + ASSERT_EQ(rgn->size, total_size);
> +
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -455,17 +524,22 @@ static int memblock_reserve_overlap_bottom_check(void)
> .size = SZ_128K
> };
>
> + prefix_push(__func__);
> +
> total_size = (r2.base - r1.base) + r2.size;
>
> reset_memblock_regions();
> memblock_reserve(r1.base, r1.size);
> memblock_reserve(r2.base, r2.size);
>
> - assert(rgn->base == r1.base);
> - assert(rgn->size == total_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);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -502,15 +576,20 @@ static int memblock_reserve_within_check(void)
> .size = SZ_64K
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_reserve(r1.base, r1.size);
> memblock_reserve(r2.base, r2.size);
>
> - assert(rgn->base == r1.base);
> - assert(rgn->size == r1.size);
> + ASSERT_EQ(rgn->base, r1.base);
> + ASSERT_EQ(rgn->size, r1.size);
> +
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, r1.size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == r1.size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -527,19 +606,28 @@ static int memblock_reserve_twice_check(void)
> .size = SZ_2M
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
>
> memblock_reserve(r.base, r.size);
> memblock_reserve(r.base, r.size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == r.size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, r.size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
>
> static int memblock_reserve_checks(void)
> {
> + prefix_reset();
> + prefix_push(FUNC_RESERVE);
> + test_print("Running %s tests...\n", FUNC_RESERVE);
> +
> memblock_reserve_simple_check();
> memblock_reserve_disjoint_check();
> memblock_reserve_overlap_top_check();
> @@ -547,6 +635,8 @@ static int memblock_reserve_checks(void)
> memblock_reserve_within_check();
> memblock_reserve_twice_check();
>
> + prefix_pop();
> +
> return 0;
> }
>
> @@ -581,16 +671,21 @@ static int memblock_remove_simple_check(void)
> .size = SZ_4M
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_add(r1.base, r1.size);
> memblock_add(r2.base, r2.size);
> memblock_remove(r1.base, r1.size);
>
> - assert(rgn->base == r2.base);
> - assert(rgn->size == r2.size);
> + ASSERT_EQ(rgn->base, r2.base);
> + ASSERT_EQ(rgn->size, r2.size);
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == r2.size);
> + ASSERT_EQ(memblock.memory.cnt, 1);
> + ASSERT_EQ(memblock.memory.total_size, r2.size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -626,15 +721,20 @@ static int memblock_remove_absent_check(void)
> .size = SZ_1G
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_add(r1.base, r1.size);
> memblock_remove(r2.base, r2.size);
>
> - assert(rgn->base == r1.base);
> - assert(rgn->size == r1.size);
> + ASSERT_EQ(rgn->base, r1.base);
> + ASSERT_EQ(rgn->size, r1.size);
> +
> + ASSERT_EQ(memblock.memory.cnt, 1);
> + ASSERT_EQ(memblock.memory.total_size, r1.size);
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == r1.size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -674,6 +774,8 @@ static int memblock_remove_overlap_top_check(void)
> .size = SZ_32M
> };
>
> + prefix_push(__func__);
> +
> r1_end = r1.base + r1.size;
> r2_end = r2.base + r2.size;
> total_size = r1_end - r2_end;
> @@ -682,11 +784,14 @@ static int memblock_remove_overlap_top_check(void)
> memblock_add(r1.base, r1.size);
> memblock_remove(r2.base, r2.size);
>
> - assert(rgn->base == r1.base + r2.base);
> - assert(rgn->size == total_size);
> + ASSERT_EQ(rgn->base, r1.base + r2.base);
> + ASSERT_EQ(rgn->size, total_size);
> +
> + ASSERT_EQ(memblock.memory.cnt, 1);
> + ASSERT_EQ(memblock.memory.total_size, total_size);
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -724,17 +829,23 @@ static int memblock_remove_overlap_bottom_check(void)
> .size = SZ_256M
> };
>
> + prefix_push(__func__);
> +
> total_size = r2.base - r1.base;
>
> reset_memblock_regions();
> memblock_add(r1.base, r1.size);
> memblock_remove(r2.base, r2.size);
>
> - assert(rgn->base == r1.base);
> - assert(rgn->size == total_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();
> + prefix_pop();
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == total_size);
> return 0;
> }
>
> @@ -774,6 +885,8 @@ static int memblock_remove_within_check(void)
> .size = SZ_1M
> };
>
> + prefix_push(__func__);
> +
> r1_size = r2.base - r1.base;
> r2_size = (r1.base + r1.size) - (r2.base + r2.size);
> total_size = r1_size + r2_size;
> @@ -782,26 +895,35 @@ static int memblock_remove_within_check(void)
> memblock_add(r1.base, r1.size);
> memblock_remove(r2.base, r2.size);
>
> - assert(rgn1->base == r1.base);
> - assert(rgn1->size == r1_size);
> + ASSERT_EQ(rgn1->base, r1.base);
> + ASSERT_EQ(rgn1->size, r1_size);
> +
> + ASSERT_EQ(rgn2->base, r2.base + r2.size);
> + ASSERT_EQ(rgn2->size, r2_size);
>
> - assert(rgn2->base == r2.base + r2.size);
> - assert(rgn2->size == r2_size);
> + ASSERT_EQ(memblock.memory.cnt, 2);
> + ASSERT_EQ(memblock.memory.total_size, total_size);
>
> - assert(memblock.memory.cnt == 2);
> - assert(memblock.memory.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
>
> static int memblock_remove_checks(void)
> {
> + prefix_reset();
> + prefix_push(FUNC_REMOVE);
> + test_print("Running %s tests...\n", FUNC_REMOVE);
> +
> memblock_remove_simple_check();
> memblock_remove_absent_check();
> memblock_remove_overlap_top_check();
> memblock_remove_overlap_bottom_check();
> memblock_remove_within_check();
>
> + prefix_pop();
> +
> return 0;
> }
>
> @@ -835,16 +957,21 @@ static int memblock_free_simple_check(void)
> .size = SZ_1M
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_reserve(r1.base, r1.size);
> memblock_reserve(r2.base, r2.size);
> memblock_free((void *)r1.base, r1.size);
>
> - assert(rgn->base == r2.base);
> - assert(rgn->size == r2.size);
> + ASSERT_EQ(rgn->base, r2.base);
> + ASSERT_EQ(rgn->size, r2.size);
> +
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, r2.size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == r2.size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -880,15 +1007,20 @@ static int memblock_free_absent_check(void)
> .size = SZ_128M
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_reserve(r1.base, r1.size);
> memblock_free((void *)r2.base, r2.size);
>
> - assert(rgn->base == r1.base);
> - assert(rgn->size == r1.size);
> + ASSERT_EQ(rgn->base, r1.base);
> + ASSERT_EQ(rgn->size, r1.size);
> +
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, r1.size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == r1.size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -928,17 +1060,22 @@ static int memblock_free_overlap_top_check(void)
> .size = SZ_8M
> };
>
> + prefix_push(__func__);
> +
> total_size = (r1.size + r1.base) - (r2.base + r2.size);
>
> reset_memblock_regions();
> memblock_reserve(r1.base, r1.size);
> memblock_free((void *)r2.base, r2.size);
>
> - assert(rgn->base == r2.base + r2.size);
> - assert(rgn->size == total_size);
> + ASSERT_EQ(rgn->base, r2.base + r2.size);
> + ASSERT_EQ(rgn->size, total_size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -973,17 +1110,22 @@ static int memblock_free_overlap_bottom_check(void)
> .size = SZ_32M
> };
>
> + prefix_push(__func__);
> +
> total_size = r2.base - r1.base;
>
> reset_memblock_regions();
> memblock_reserve(r1.base, r1.size);
> memblock_free((void *)r2.base, r2.size);
>
> - assert(rgn->base == r1.base);
> - assert(rgn->size == total_size);
> + ASSERT_EQ(rgn->base, r1.base);
> + ASSERT_EQ(rgn->size, total_size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -1024,6 +1166,8 @@ static int memblock_free_within_check(void)
> .size = SZ_1M
> };
>
> + prefix_push(__func__);
> +
> r1_size = r2.base - r1.base;
> r2_size = (r1.base + r1.size) - (r2.base + r2.size);
> total_size = r1_size + r2_size;
> @@ -1032,26 +1176,35 @@ static int memblock_free_within_check(void)
> memblock_reserve(r1.base, r1.size);
> memblock_free((void *)r2.base, r2.size);
>
> - assert(rgn1->base == r1.base);
> - assert(rgn1->size == r1_size);
> + ASSERT_EQ(rgn1->base, r1.base);
> + ASSERT_EQ(rgn1->size, r1_size);
>
> - assert(rgn2->base == r2.base + r2.size);
> - assert(rgn2->size == r2_size);
> + ASSERT_EQ(rgn2->base, r2.base + r2.size);
> + ASSERT_EQ(rgn2->size, r2_size);
>
> - assert(memblock.reserved.cnt == 2);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 2);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
>
> static int memblock_free_checks(void)
> {
> + prefix_reset();
> + prefix_push(FUNC_FREE);
> + test_print("Running %s tests...\n", FUNC_FREE);
> +
> memblock_free_simple_check();
> memblock_free_absent_check();
> memblock_free_overlap_top_check();
> memblock_free_overlap_bottom_check();
> memblock_free_within_check();
>
> + prefix_pop();
> +
> return 0;
> }
>
> diff --git a/tools/testing/memblock/tests/common.c b/tools/testing/memblock/tests/common.c
> index 62d3191f7c9a..e55b2a8bf0ff 100644
> --- a/tools/testing/memblock/tests/common.c
> +++ b/tools/testing/memblock/tests/common.c
> @@ -4,8 +4,12 @@
>
> #define INIT_MEMBLOCK_REGIONS 128
> #define INIT_MEMBLOCK_RESERVED_REGIONS INIT_MEMBLOCK_REGIONS
> +#define PREFIXES_LEN_MAX 256
> +#define DELIM ": "
> +#define DELIM_LEN strlen(DELIM)
>
> static struct test_memory memory_block;
> +static char __maybe_unused prefixes[PREFIXES_LEN_MAX];
>
> void reset_memblock_regions(void)
> {
> @@ -46,3 +50,57 @@ void dummy_physical_memory_cleanup(void)
> {
> free(memory_block.base);
> }
> +
> +#ifdef VERBOSE
> +void test_fail(void)
> +{
> + ksft_test_result_fail(": %sfailed\n", prefixes);
> +}
> +
> +void test_pass(void)
> +{
> + ksft_test_result_pass(": %spassed\n", prefixes);
> +}
> +
> +void test_print(const char *fmt, ...)
> +{
> + int saved_errno = errno;
> + va_list args;
> +
> + va_start(args, fmt);
> + errno = saved_errno;
> + vprintf(fmt, args);
> + va_end(args);
> +}
> +
> +void prefix_reset(void)
> +{
> + memset(prefixes, 0, PREFIXES_LEN_MAX);
> +}
> +
> +void prefix_push(const char *prefix)
> +{
> + int prefix_max = PREFIXES_LEN_MAX - strlen(prefixes) - DELIM_LEN - 1;
> +
> + assert(strlen(prefix) <= prefix_max);
> + strncat(prefixes, prefix, prefix_max);
> + strncat(prefixes, DELIM, PREFIXES_LEN_MAX - strlen(prefixes) - 1);
> +}
> +
> +void prefix_pop(void)
> +{
> + char *ptr;
> +
> + ptr = strrchr(prefixes, DELIM[0]);
> + if (!ptr)
> + prefixes[0] = 0;
> + else
> + *(ptr) = 0;
> +
> + ptr = strrchr(prefixes, DELIM[0]);
> + if (!ptr)
> + prefixes[0] = 0;
> + else
> + *(ptr + DELIM_LEN) = 0;
> +}
> +#endif /* VERBOSE */
> diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h
> index 619054d03219..bdddb5f72871 100644
> --- a/tools/testing/memblock/tests/common.h
> +++ b/tools/testing/memblock/tests/common.h
> @@ -7,9 +7,47 @@
> #include <linux/types.h>
> #include <linux/memblock.h>
> #include <linux/sizes.h>
> +#include <linux/printk.h>
> +#include <../selftests/kselftest.h>
>
> #define MEM_SIZE SZ_16K
>
> +/**
> + * ASSERT_EQ():
> + * Check the condition
> + * @_expected == @_seen
> + * If false, print failed test message (if in VERBOSE mode) and then assert
> + */
> +#define ASSERT_EQ(_expected, _seen) do { \
> + if ((_expected) != (_seen)) \
> + test_fail(); \
> + assert((_expected) == (_seen)); \
> +} while (0)
> +
> +/**
> + * ASSERT_NE():
> + * Check the condition
> + * @_expected != @_seen
> + * If false, print failed test message (if in VERBOSE mode) and then assert
> + */
> +#define ASSERT_NE(_expected, _seen) do { \
> + if ((_expected) == (_seen)) \
> + test_fail(); \
> + assert((_expected) != (_seen)); \
> +} while (0)
> +
> +/**
> + * ASSERT_LT():
> + * Check the condition
> + * @_expected < @_seen
> + * If false, print failed test message (if in VERBOSE mode) and then assert
> + */
> +#define ASSERT_LT(_expected, _seen) do { \
> + if ((_expected) >= (_seen)) \
> + test_fail(); \
> + assert((_expected) < (_seen)); \
> +} while (0)
> +
> /*
> * Available memory registered with memblock needs to be valid for allocs
> * test to run. This is a convenience wrapper for memory allocated in
> @@ -31,4 +69,20 @@ void setup_memblock(void);
> void dummy_physical_memory_init(void);
> void dummy_physical_memory_cleanup(void);
>
> +#ifdef VERBOSE
> +void test_fail(void);
> +void test_pass(void);
> +void test_print(const char *fmt, ...);
> +void prefix_reset(void);
> +void prefix_push(const char *prefix);
> +void prefix_pop(void);
> +#else
> +static inline void test_fail(void) {}
> +static inline void test_pass(void) {}
> +static inline void test_print(const char *fmt, ...) {}
> +static inline void prefix_reset(void) {}
> +static inline void prefix_push(const char *prefix) {}
> +static inline void prefix_pop(void) {}
> +#endif /* VERBOSE */
> +
> #endif
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 0/4] memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options
2022-06-22 9:29 [PATCH v3 0/4] memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options Rebecca Mckeever
` (4 preceding siblings ...)
2022-06-22 10:00 ` [PATCH v3 0/4] memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options David Hildenbrand
@ 2022-06-22 14:17 ` Mike Rapoport
2022-06-23 1:01 ` Rebecca Mckeever
2022-06-23 3:30 ` Ira Weiny
6 siblings, 1 reply; 31+ messages in thread
From: Mike Rapoport @ 2022-06-22 14:17 UTC (permalink / raw)
To: Rebecca Mckeever; +Cc: linux-mm, linux-kernel, David Hildenbrand
Hi Rebecca,
On Wed, Jun 22, 2022 at 04:29:05AM -0500, Rebecca Mckeever wrote:
> These patches add options VERBOSE and MEMBLOCK_DEBUG to Memblock
> simulator, which can be specified when running make. These patches also
> implement the functionality for these options.
>
> VERBOSE
> Usage:
>
> $ make VERBOSE=1
>
> Passing VERBOSE=1 will enable verbose output from Memblock simulator. For
> each test, the verbose output includes the name of the memblock function
> being tested, the name of the test, and whether the test passed or failed.
> Since all the tests in Memblock simulator run as one monolithic test, this
> output is a quick way to get a summary of test results.
>
> MEMBLOCK_DEBUG
> Usage:
>
> $ make MEMBLOCK_DEBUG=1
>
> Passing MEMBLOCK_DEBUG=1 will enable memblock_dbg() messages. These
> are debug messages built into several functions in memblock that include
> information such as the name of the function and the size and start and
> end addresses of the memblock region.
>
> Rebecca Mckeever (4):
> memblock tests: add user-provided arguments to Makefile
> memblock tests: add verbose output to memblock tests
> memblock tests: set memblock_debug to enable memblock_dbg() messages
> memblock tests: remove completed TODO items
>
> tools/testing/memblock/Makefile | 4 +
> tools/testing/memblock/README | 10 +-
> tools/testing/memblock/TODO | 14 +-
> tools/testing/memblock/internal.h | 7 +
> .../testing/memblock/scripts/Makefile.include | 10 +
> tools/testing/memblock/tests/alloc_api.c | 241 ++++++++----
> .../memblock/tests/alloc_helpers_api.c | 135 +++++--
> tools/testing/memblock/tests/alloc_nid_api.c | 371 ++++++++++++------
> tools/testing/memblock/tests/basic_api.c | 365 ++++++++++++-----
> tools/testing/memblock/tests/common.c | 58 +++
> tools/testing/memblock/tests/common.h | 54 +++
> 11 files changed, 913 insertions(+), 356 deletions(-)
>
> ---
> Changes
>
> v1 -> v2
> PATCH 2, in common.c:
> Remove #ifdef VERBOSE around prefixes and related constants
> Add __maybe_unused to prefixes
> Move PREFIXES_LEN_MAX, DELIM, and DELIM_LEN so that they are
> immediately after the other constants
> Add #ifdef VERBOSE around definitions for test_*() and prefix_*()
>
> v2 -> v3
> PATCH 1:
> Add Reviewed-by tag
> ---
The patch changelog in a cover letter usually goes before the commit list
and diffstat.
> --
> 2.34.1
>
--
Sincerely yours,
Mike.
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 2/4] memblock tests: add verbose output to memblock tests
2022-06-22 10:32 ` Huang, Shaoqin
@ 2022-06-23 0:45 ` Rebecca Mckeever
2022-06-23 1:29 ` Huang, Shaoqin
0 siblings, 1 reply; 31+ messages in thread
From: Rebecca Mckeever @ 2022-06-23 0:45 UTC (permalink / raw)
To: Huang, Shaoqin; +Cc: Mike Rapoport, linux-mm, linux-kernel, David Hildenbrand
On Wed, Jun 22, 2022 at 06:32:04PM +0800, Huang, Shaoqin wrote:
> Just test it and everything works fine. And I think there are some thing can
> improve:
>
> The prefix_push() and prefix_pop() are used in so many functions and
> almost of them just put the prefix_push(__func__) begin in the head and the
> prefix_pop() in the end.
> May be you can define some macro that when you output something and
> automatically push the __func__ as prefix. And when leave the function,
> automatically pop it. And only in some special place, you call it manually.
>
Thank you for your review. I'm not sure how you would automatically push
__func__ since you have to be inside the function to access that
variable. Let me know if you have any suggestions. I am thinking about
adding another function in common.c that just calls test_pass() followed
by prefix_pop() since those are called together so often.
>
> On 6/22/2022 5:29 PM, Rebecca Mckeever wrote:
> > Add and use functions for printing verbose testing output.
> >
> > If the Memblock simulator was compiled with VERBOSE=1:
> > prefix_push() appends the given string to a prefix string that will be
> > printed in the test functions.
> > prefix_pop() removes the last prefix from the prefix string.
> > prefix_reset() clears the prefix string.
> > test_fail() prints a message after a test fails containing the test
> > number of the failing test and the prefix.
> > test_pass() prints a message after a test passes containing its test
> > number and the prefix.
> > test_print() prints the given formatted output string.
> >
>
> Comments like this is more clear, not just indent:
> - prefix_push(): appends ...
> - prefix_pop(): removes ...
>
That does look better, I'll update the commit text.
> > If the Memblock simulator was not compiled with VERBOSE=1, these
> > functions do nothing.
> >
> > Add the assert wrapper macros ASSERT_EQ(), ASSERT_NE(), and ASSERT_LT().
> > If the assert condition fails, these macros call test_fail() before
> > executing assert().
> >
> > Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> > ---
> > tools/testing/memblock/tests/alloc_api.c | 241 ++++++++----
> > .../memblock/tests/alloc_helpers_api.c | 135 +++++--
> > tools/testing/memblock/tests/alloc_nid_api.c | 371 ++++++++++++------
> > tools/testing/memblock/tests/basic_api.c | 365 ++++++++++++-----
> > tools/testing/memblock/tests/common.c | 58 +++
> > tools/testing/memblock/tests/common.h | 54 +++
> > 6 files changed, 880 insertions(+), 344 deletions(-)
> >
> > diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
> > index d1aa7e15c18d..96df033d4300 100644
> > --- a/tools/testing/memblock/tests/alloc_api.c
> > +++ b/tools/testing/memblock/tests/alloc_api.c
> > @@ -10,6 +10,8 @@ static int alloc_top_down_simple_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_2;
> > phys_addr_t expected_start;
> > @@ -19,12 +21,15 @@ static int alloc_top_down_simple_check(void)
> > allocated_ptr = memblock_alloc(size, SMP_CACHE_BYTES);
> > - assert(allocated_ptr);
> > - assert(rgn->size == size);
> > - assert(rgn->base == expected_start);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, expected_start);
> > +
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -55,6 +60,8 @@ static int alloc_top_down_disjoint_check(void)
> > struct region r1;
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > phys_addr_t r2_size = SZ_16;
> > /* Use custom alignment */
> > phys_addr_t alignment = SMP_CACHE_BYTES * 2;
> > @@ -73,15 +80,18 @@ static int alloc_top_down_disjoint_check(void)
> > allocated_ptr = memblock_alloc(r2_size, alignment);
> > - assert(allocated_ptr);
> > - assert(rgn1->size == r1.size);
> > - assert(rgn1->base == r1.base);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn1->size, r1.size);
> > + ASSERT_EQ(rgn1->base, r1.base);
> > - assert(rgn2->size == r2_size);
> > - assert(rgn2->base == expected_start);
> > + ASSERT_EQ(rgn2->size, r2_size);
> > + ASSERT_EQ(rgn2->base, expected_start);
> > - assert(memblock.reserved.cnt == 2);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -101,6 +111,8 @@ static int alloc_top_down_before_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > /*
> > * The first region ends at the aligned address to test region merging
> > */
> > @@ -114,12 +126,15 @@ static int alloc_top_down_before_check(void)
> > allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
> > - assert(allocated_ptr);
> > - assert(rgn->size == total_size);
> > - assert(rgn->base == memblock_end_of_DRAM() - total_size);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, total_size);
> > + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - total_size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -141,6 +156,8 @@ static int alloc_top_down_after_check(void)
> > struct region r1;
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > phys_addr_t r2_size = SZ_512;
> > phys_addr_t total_size;
> > @@ -158,12 +175,15 @@ static int alloc_top_down_after_check(void)
> > allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
> > - assert(allocated_ptr);
> > - assert(rgn->size == total_size);
> > - assert(rgn->base == r1.base - r2_size);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, total_size);
> > + ASSERT_EQ(rgn->base, r1.base - r2_size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -186,6 +206,8 @@ static int alloc_top_down_second_fit_check(void)
> > struct region r1, r2;
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > phys_addr_t r3_size = SZ_1K;
> > phys_addr_t total_size;
> > @@ -204,12 +226,15 @@ static int alloc_top_down_second_fit_check(void)
> > allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
> > - assert(allocated_ptr);
> > - assert(rgn->size == r2.size + r3_size);
> > - assert(rgn->base == r2.base - r3_size);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, r2.size + r3_size);
> > + ASSERT_EQ(rgn->base, r2.base - r3_size);
> > - assert(memblock.reserved.cnt == 2);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -231,6 +256,8 @@ static int alloc_in_between_generic_check(void)
> > struct region r1, r2;
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > phys_addr_t gap_size = SMP_CACHE_BYTES;
> > phys_addr_t r3_size = SZ_64;
> > /*
> > @@ -254,12 +281,15 @@ static int alloc_in_between_generic_check(void)
> > allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
> > - assert(allocated_ptr);
> > - assert(rgn->size == total_size);
> > - assert(rgn->base == r1.base - r2.size - r3_size);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, total_size);
> > + ASSERT_EQ(rgn->base, r1.base - r2.size - r3_size);
> > +
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -281,6 +311,8 @@ static int alloc_small_gaps_generic_check(void)
> > {
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > phys_addr_t region_size = SZ_1K;
> > phys_addr_t gap_size = SZ_256;
> > phys_addr_t region_end;
> > @@ -296,7 +328,10 @@ static int alloc_small_gaps_generic_check(void)
> > allocated_ptr = memblock_alloc(region_size, SMP_CACHE_BYTES);
> > - assert(!allocated_ptr);
> > + ASSERT_EQ(allocated_ptr, NULL);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -309,6 +344,8 @@ static int alloc_all_reserved_generic_check(void)
> > {
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > setup_memblock();
> > /* Simulate full memory */
> > @@ -316,7 +353,10 @@ static int alloc_all_reserved_generic_check(void)
> > allocated_ptr = memblock_alloc(SZ_256, SMP_CACHE_BYTES);
> > - assert(!allocated_ptr);
> > + ASSERT_EQ(allocated_ptr, NULL);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -338,6 +378,8 @@ static int alloc_no_space_generic_check(void)
> > {
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > setup_memblock();
> > phys_addr_t available_size = SZ_256;
> > @@ -348,7 +390,10 @@ static int alloc_no_space_generic_check(void)
> > allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
> > - assert(!allocated_ptr);
> > + ASSERT_EQ(allocated_ptr, NULL);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -369,6 +414,8 @@ static int alloc_limited_space_generic_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > phys_addr_t available_size = SZ_256;
> > phys_addr_t reserved_size = MEM_SIZE - available_size;
> > @@ -379,12 +426,15 @@ static int alloc_limited_space_generic_check(void)
> > allocated_ptr = memblock_alloc(available_size, SMP_CACHE_BYTES);
> > - assert(allocated_ptr);
> > - assert(rgn->size == MEM_SIZE);
> > - assert(rgn->base == memblock_start_of_DRAM());
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, MEM_SIZE);
> > + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> > +
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, MEM_SIZE);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == MEM_SIZE);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -399,14 +449,19 @@ static int alloc_no_memory_generic_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
> > - assert(!allocated_ptr);
> > - assert(rgn->size == 0);
> > - assert(rgn->base == 0);
> > - assert(memblock.reserved.total_size == 0);
> > + ASSERT_EQ(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, 0);
> > + ASSERT_EQ(rgn->base, 0);
> > + ASSERT_EQ(memblock.reserved.total_size, 0);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -421,16 +476,21 @@ static int alloc_bottom_up_simple_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > setup_memblock();
> > allocated_ptr = memblock_alloc(SZ_2, SMP_CACHE_BYTES);
> > - assert(allocated_ptr);
> > - assert(rgn->size == SZ_2);
> > - assert(rgn->base == memblock_start_of_DRAM());
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, SZ_2);
> > + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == SZ_2);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, SZ_2);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -459,6 +519,8 @@ static int alloc_bottom_up_disjoint_check(void)
> > struct region r1;
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > phys_addr_t r2_size = SZ_16;
> > /* Use custom alignment */
> > phys_addr_t alignment = SMP_CACHE_BYTES * 2;
> > @@ -477,16 +539,19 @@ static int alloc_bottom_up_disjoint_check(void)
> > allocated_ptr = memblock_alloc(r2_size, alignment);
> > - assert(allocated_ptr);
> > + ASSERT_NE(allocated_ptr, NULL);
> > - assert(rgn1->size == r1.size);
> > - assert(rgn1->base == r1.base);
> > + ASSERT_EQ(rgn1->size, r1.size);
> > + ASSERT_EQ(rgn1->base, r1.base);
> > - assert(rgn2->size == r2_size);
> > - assert(rgn2->base == expected_start);
> > + ASSERT_EQ(rgn2->size, r2_size);
> > + ASSERT_EQ(rgn2->base, expected_start);
> > - assert(memblock.reserved.cnt == 2);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -506,6 +571,8 @@ static int alloc_bottom_up_before_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > phys_addr_t r1_size = SZ_512;
> > phys_addr_t r2_size = SZ_128;
> > phys_addr_t total_size = r1_size + r2_size;
> > @@ -516,12 +583,15 @@ static int alloc_bottom_up_before_check(void)
> > allocated_ptr = memblock_alloc(r1_size, SMP_CACHE_BYTES);
> > - assert(allocated_ptr);
> > - assert(rgn->size == total_size);
> > - assert(rgn->base == memblock_start_of_DRAM());
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, total_size);
> > + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -542,6 +612,8 @@ static int alloc_bottom_up_after_check(void)
> > struct region r1;
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > phys_addr_t r2_size = SZ_512;
> > phys_addr_t total_size;
> > @@ -559,12 +631,15 @@ static int alloc_bottom_up_after_check(void)
> > allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
> > - assert(allocated_ptr);
> > - assert(rgn->size == total_size);
> > - assert(rgn->base == r1.base);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, total_size);
> > + ASSERT_EQ(rgn->base, r1.base);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -588,6 +663,8 @@ static int alloc_bottom_up_second_fit_check(void)
> > struct region r1, r2;
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > phys_addr_t r3_size = SZ_1K;
> > phys_addr_t total_size;
> > @@ -606,12 +683,15 @@ static int alloc_bottom_up_second_fit_check(void)
> > allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
> > - assert(allocated_ptr);
> > - assert(rgn->size == r2.size + r3_size);
> > - assert(rgn->base == r2.base);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, r2.size + r3_size);
> > + ASSERT_EQ(rgn->base, r2.base);
> > - assert(memblock.reserved.cnt == 2);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -619,6 +699,7 @@ static int alloc_bottom_up_second_fit_check(void)
> > /* Test case wrappers */
> > static int alloc_simple_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_top_down_simple_check();
> > memblock_set_bottom_up(true);
> > @@ -629,6 +710,7 @@ static int alloc_simple_check(void)
> > static int alloc_disjoint_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_top_down_disjoint_check();
> > memblock_set_bottom_up(true);
> > @@ -639,6 +721,7 @@ static int alloc_disjoint_check(void)
> > static int alloc_before_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_top_down_before_check();
> > memblock_set_bottom_up(true);
> > @@ -649,6 +732,7 @@ static int alloc_before_check(void)
> > static int alloc_after_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_top_down_after_check();
> > memblock_set_bottom_up(true);
> > @@ -659,6 +743,7 @@ 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);
> > @@ -669,6 +754,7 @@ static int alloc_in_between_check(void)
> > static int alloc_second_fit_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_top_down_second_fit_check();
> > memblock_set_bottom_up(true);
> > @@ -679,6 +765,7 @@ 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);
> > @@ -689,6 +776,7 @@ 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);
> > @@ -699,6 +787,7 @@ 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);
> > @@ -709,6 +798,7 @@ 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);
> > @@ -719,6 +809,7 @@ 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);
> > @@ -729,6 +820,12 @@ static int alloc_no_memory_check(void)
> > int memblock_alloc_checks(void)
> > {
> > + static const char func_testing[] = "memblock_alloc";
> > +
> > + prefix_reset();
> > + prefix_push(func_testing);
> > + test_print("Running %s tests...\n", func_testing);
> > +
> > reset_memblock_attributes();
> > dummy_physical_memory_init();
> > @@ -746,5 +843,7 @@ int memblock_alloc_checks(void)
> > dummy_physical_memory_cleanup();
> > + prefix_pop();
> > +
> > return 0;
> > }
> > diff --git a/tools/testing/memblock/tests/alloc_helpers_api.c b/tools/testing/memblock/tests/alloc_helpers_api.c
> > index 963a966db461..f6eaed540427 100644
> > --- a/tools/testing/memblock/tests/alloc_helpers_api.c
> > +++ b/tools/testing/memblock/tests/alloc_helpers_api.c
> > @@ -21,6 +21,8 @@ static int alloc_from_simple_generic_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_16;
> > phys_addr_t min_addr;
> > @@ -31,14 +33,17 @@ static int alloc_from_simple_generic_check(void)
> > allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
> > b = (char *)allocated_ptr;
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, min_addr);
> > - assert(rgn->size == size);
> > - assert(rgn->base == min_addr);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -64,6 +69,8 @@ static int alloc_from_misaligned_generic_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_32;
> > phys_addr_t min_addr;
> > @@ -75,14 +82,17 @@ static int alloc_from_misaligned_generic_check(void)
> > allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
> > b = (char *)allocated_ptr;
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > - assert(rgn->size == size);
> > - assert(rgn->base == memblock_end_of_DRAM() - SMP_CACHE_BYTES);
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - SMP_CACHE_BYTES);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -110,6 +120,8 @@ static int alloc_from_top_down_high_addr_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_32;
> > phys_addr_t min_addr;
> > @@ -120,12 +132,15 @@ static int alloc_from_top_down_high_addr_check(void)
> > allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
> > - assert(allocated_ptr);
> > - assert(rgn->size == size);
> > - assert(rgn->base == memblock_end_of_DRAM() - SMP_CACHE_BYTES);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - SMP_CACHE_BYTES);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -151,6 +166,8 @@ static int alloc_from_top_down_no_space_above_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > phys_addr_t r1_size = SZ_64;
> > phys_addr_t r2_size = SZ_2;
> > phys_addr_t total_size = r1_size + r2_size;
> > @@ -165,12 +182,15 @@ static int alloc_from_top_down_no_space_above_check(void)
> > allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
> > - assert(allocated_ptr);
> > - assert(rgn->base == min_addr - r1_size);
> > - assert(rgn->size == total_size);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->base, min_addr - r1_size);
> > + ASSERT_EQ(rgn->size, total_size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -186,6 +206,8 @@ static int alloc_from_top_down_min_addr_cap_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > phys_addr_t r1_size = SZ_64;
> > phys_addr_t min_addr;
> > phys_addr_t start_addr;
> > @@ -199,12 +221,15 @@ static int alloc_from_top_down_min_addr_cap_check(void)
> > allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
> > - assert(allocated_ptr);
> > - assert(rgn->base == start_addr);
> > - assert(rgn->size == MEM_SIZE);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->base, start_addr);
> > + ASSERT_EQ(rgn->size, MEM_SIZE);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == MEM_SIZE);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, MEM_SIZE);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -230,6 +255,8 @@ static int alloc_from_bottom_up_high_addr_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_32;
> > phys_addr_t min_addr;
> > @@ -240,12 +267,15 @@ static int alloc_from_bottom_up_high_addr_check(void)
> > allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
> > - assert(allocated_ptr);
> > - assert(rgn->size == size);
> > - assert(rgn->base == memblock_start_of_DRAM());
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> > +
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -270,6 +300,8 @@ static int alloc_from_bottom_up_no_space_above_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > phys_addr_t r1_size = SZ_64;
> > phys_addr_t min_addr;
> > phys_addr_t r2_size;
> > @@ -284,12 +316,15 @@ static int alloc_from_bottom_up_no_space_above_check(void)
> > allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
> > - assert(allocated_ptr);
> > - assert(rgn->base == memblock_start_of_DRAM());
> > - assert(rgn->size == r1_size);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> > + ASSERT_EQ(rgn->size, r1_size);
> > +
> > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > + ASSERT_EQ(memblock.reserved.total_size, r1_size + r2_size);
> > - assert(memblock.reserved.cnt == 2);
> > - assert(memblock.reserved.total_size == r1_size + r2_size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -304,6 +339,8 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > phys_addr_t r1_size = SZ_64;
> > phys_addr_t min_addr;
> > phys_addr_t start_addr;
> > @@ -315,12 +352,15 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
> > allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
> > - assert(allocated_ptr);
> > - assert(rgn->base == start_addr);
> > - assert(rgn->size == r1_size);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->base, start_addr);
> > + ASSERT_EQ(rgn->size, r1_size);
> > +
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, r1_size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == r1_size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -328,6 +368,7 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
> > /* Test case wrappers */
> > 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);
> > @@ -338,6 +379,7 @@ 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);
> > @@ -348,6 +390,7 @@ static int alloc_from_misaligned_check(void)
> > static int alloc_from_high_addr_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_from_top_down_high_addr_check();
> > memblock_set_bottom_up(true);
> > @@ -358,6 +401,7 @@ static int alloc_from_high_addr_check(void)
> > static int alloc_from_no_space_above_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_from_top_down_no_space_above_check();
> > memblock_set_bottom_up(true);
> > @@ -368,6 +412,7 @@ static int alloc_from_no_space_above_check(void)
> > static int alloc_from_min_addr_cap_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_from_top_down_min_addr_cap_check();
> > memblock_set_bottom_up(true);
> > @@ -378,6 +423,12 @@ static int alloc_from_min_addr_cap_check(void)
> > int memblock_alloc_helpers_checks(void)
> > {
> > + static const char func_testing[] = "memblock_alloc_from";
> > +
> > + prefix_reset();
> > + prefix_push(func_testing);
> > + test_print("Running %s tests...\n", func_testing);
> > +
> > reset_memblock_attributes();
> > dummy_physical_memory_init();
> > diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
> > index 6390206e50e1..601f4a7ee30d 100644
> > --- a/tools/testing/memblock/tests/alloc_nid_api.c
> > +++ b/tools/testing/memblock/tests/alloc_nid_api.c
> > @@ -21,6 +21,8 @@ static int alloc_try_nid_top_down_simple_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_128;
> > phys_addr_t min_addr;
> > phys_addr_t max_addr;
> > @@ -36,15 +38,18 @@ static int alloc_try_nid_top_down_simple_check(void)
> > b = (char *)allocated_ptr;
> > rgn_end = rgn->base + rgn->size;
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, max_addr - size);
> > + ASSERT_EQ(rgn_end, max_addr);
> > - assert(rgn->size == size);
> > - assert(rgn->base == max_addr - size);
> > - assert(rgn_end == max_addr);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -72,6 +77,8 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_128;
> > phys_addr_t misalign = SZ_2;
> > phys_addr_t min_addr;
> > @@ -88,15 +95,18 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
> > b = (char *)allocated_ptr;
> > rgn_end = rgn->base + rgn->size;
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > - assert(rgn->size == size);
> > - assert(rgn->base == max_addr - size - misalign);
> > - assert(rgn_end < max_addr);
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, max_addr - size - misalign);
> > + ASSERT_LT(rgn_end, max_addr);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -122,6 +132,8 @@ static int alloc_try_nid_exact_address_generic_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_1K;
> > phys_addr_t min_addr;
> > phys_addr_t max_addr;
> > @@ -137,15 +149,18 @@ static int alloc_try_nid_exact_address_generic_check(void)
> > b = (char *)allocated_ptr;
> > rgn_end = rgn->base + rgn->size;
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, min_addr);
> > + ASSERT_EQ(rgn_end, max_addr);
> > - assert(rgn->size == size);
> > - assert(rgn->base == min_addr);
> > - assert(rgn_end == max_addr);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -173,6 +188,8 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_256;
> > phys_addr_t min_addr;
> > phys_addr_t max_addr;
> > @@ -186,14 +203,17 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
> > min_addr, max_addr, NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, max_addr - size);
> > - assert(rgn->size == size);
> > - assert(rgn->base == max_addr - size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -222,6 +242,8 @@ static int alloc_try_nid_low_max_generic_check(void)
> > {
> > void *allocated_ptr = NULL;
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_1K;
> > phys_addr_t min_addr;
> > phys_addr_t max_addr;
> > @@ -234,7 +256,10 @@ static int alloc_try_nid_low_max_generic_check(void)
> > allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> > min_addr, max_addr, NUMA_NO_NODE);
> > - assert(!allocated_ptr);
> > + ASSERT_EQ(allocated_ptr, NULL);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -259,6 +284,8 @@ static int alloc_try_nid_min_reserved_generic_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> > + prefix_push(__func__);
> > +
> > phys_addr_t r1_size = SZ_128;
> > phys_addr_t r2_size = SZ_64;
> > phys_addr_t total_size = r1_size + r2_size;
> > @@ -278,14 +305,17 @@ static int alloc_try_nid_min_reserved_generic_check(void)
> > min_addr, max_addr, NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > - assert(rgn->size == total_size);
> > - assert(rgn->base == reserved_base);
> > + ASSERT_EQ(rgn->size, total_size);
> > + ASSERT_EQ(rgn->base, reserved_base);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -310,6 +340,8 @@ static int alloc_try_nid_max_reserved_generic_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> > + prefix_push(__func__);
> > +
> > phys_addr_t r1_size = SZ_64;
> > phys_addr_t r2_size = SZ_128;
> > phys_addr_t total_size = r1_size + r2_size;
> > @@ -327,14 +359,17 @@ static int alloc_try_nid_max_reserved_generic_check(void)
> > min_addr, max_addr, NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn->size, total_size);
> > + ASSERT_EQ(rgn->base, min_addr);
> > - assert(rgn->size == total_size);
> > - assert(rgn->base == min_addr);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -364,6 +399,8 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
> > char *b;
> > struct region r1, r2;
> > + prefix_push(__func__);
> > +
> > phys_addr_t r3_size = SZ_64;
> > phys_addr_t gap_size = SMP_CACHE_BYTES;
> > phys_addr_t total_size;
> > @@ -389,17 +426,20 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
> > min_addr, max_addr, NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn1->size, r1.size + r3_size);
> > + ASSERT_EQ(rgn1->base, max_addr - r3_size);
> > - assert(rgn1->size == r1.size + r3_size);
> > - assert(rgn1->base == max_addr - r3_size);
> > + ASSERT_EQ(rgn2->size, r2.size);
> > + ASSERT_EQ(rgn2->base, r2.base);
> > - assert(rgn2->size == r2.size);
> > - assert(rgn2->base == r2.base);
> > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > - assert(memblock.reserved.cnt == 2);
> > - assert(memblock.reserved.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -427,6 +467,8 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
> > char *b;
> > struct region r1, r2;
> > + prefix_push(__func__);
> > +
> > phys_addr_t r3_size = SZ_64;
> > phys_addr_t total_size;
> > phys_addr_t max_addr;
> > @@ -451,14 +493,17 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
> > min_addr, max_addr, NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > - assert(rgn->size == total_size);
> > - assert(rgn->base == r2.base);
> > + ASSERT_EQ(rgn->size, total_size);
> > + ASSERT_EQ(rgn->base, r2.base);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -489,6 +534,8 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
> > char *b;
> > struct region r1, r2;
> > + prefix_push(__func__);
> > +
> > phys_addr_t r3_size = SZ_256;
> > phys_addr_t gap_size = SMP_CACHE_BYTES;
> > phys_addr_t total_size;
> > @@ -514,17 +561,20 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
> > min_addr, max_addr, NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn1->size, r1.size);
> > + ASSERT_EQ(rgn1->base, r1.base);
> > - assert(rgn1->size == r1.size);
> > - assert(rgn1->base == r1.base);
> > + ASSERT_EQ(rgn2->size, r2.size + r3_size);
> > + ASSERT_EQ(rgn2->base, r2.base - r3_size);
> > - assert(rgn2->size == r2.size + r3_size);
> > - assert(rgn2->base == r2.base - r3_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > - assert(memblock.reserved.cnt == 2);
> > - assert(memblock.reserved.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -554,6 +604,8 @@ static int alloc_try_nid_reserved_all_generic_check(void)
> > void *allocated_ptr = NULL;
> > struct region r1, r2;
> > + prefix_push(__func__);
> > +
> > phys_addr_t r3_size = SZ_256;
> > phys_addr_t gap_size = SMP_CACHE_BYTES;
> > phys_addr_t max_addr;
> > @@ -576,7 +628,10 @@ static int alloc_try_nid_reserved_all_generic_check(void)
> > allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
> > min_addr, max_addr, NUMA_NO_NODE);
> > - assert(!allocated_ptr);
> > + ASSERT_EQ(allocated_ptr, NULL);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -592,6 +647,8 @@ static int alloc_try_nid_top_down_cap_max_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_256;
> > phys_addr_t min_addr;
> > phys_addr_t max_addr;
> > @@ -605,14 +662,17 @@ static int alloc_try_nid_top_down_cap_max_check(void)
> > min_addr, max_addr, NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
> > - assert(rgn->size == size);
> > - assert(rgn->base == memblock_end_of_DRAM() - size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -628,6 +688,8 @@ static int alloc_try_nid_top_down_cap_min_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_1K;
> > phys_addr_t min_addr;
> > phys_addr_t max_addr;
> > @@ -641,14 +703,17 @@ static int alloc_try_nid_top_down_cap_min_check(void)
> > min_addr, max_addr, NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > - assert(rgn->size == size);
> > - assert(rgn->base == memblock_end_of_DRAM() - size);
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -673,6 +738,8 @@ static int alloc_try_nid_bottom_up_simple_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_128;
> > phys_addr_t min_addr;
> > phys_addr_t max_addr;
> > @@ -689,15 +756,18 @@ static int alloc_try_nid_bottom_up_simple_check(void)
> > b = (char *)allocated_ptr;
> > rgn_end = rgn->base + rgn->size;
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, min_addr);
> > + ASSERT_LT(rgn_end, max_addr);
> > - assert(rgn->size == size);
> > - assert(rgn->base == min_addr);
> > - assert(rgn_end < max_addr);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -725,6 +795,8 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_128;
> > phys_addr_t misalign = SZ_2;
> > phys_addr_t min_addr;
> > @@ -742,15 +814,18 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
> > b = (char *)allocated_ptr;
> > rgn_end = rgn->base + rgn->size;
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, min_addr + (SMP_CACHE_BYTES - misalign));
> > + ASSERT_LT(rgn_end, max_addr);
> > - assert(rgn->size == size);
> > - assert(rgn->base == min_addr + (SMP_CACHE_BYTES - misalign));
> > - assert(rgn_end < max_addr);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -778,6 +853,8 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_256;
> > phys_addr_t min_addr;
> > phys_addr_t max_addr;
> > @@ -792,14 +869,17 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
> > NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > - assert(rgn->size == size);
> > - assert(rgn->base == memblock_start_of_DRAM());
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -829,6 +909,8 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
> > char *b;
> > struct region r1, r2;
> > + prefix_push(__func__);
> > +
> > phys_addr_t r3_size = SZ_64;
> > phys_addr_t gap_size = SMP_CACHE_BYTES;
> > phys_addr_t total_size;
> > @@ -855,17 +937,20 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
> > NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > - assert(rgn1->size == r1.size);
> > - assert(rgn1->base == max_addr);
> > + ASSERT_EQ(rgn1->size, r1.size);
> > + ASSERT_EQ(rgn1->base, max_addr);
> > - assert(rgn2->size == r2.size + r3_size);
> > - assert(rgn2->base == r2.base);
> > + ASSERT_EQ(rgn2->size, r2.size + r3_size);
> > + ASSERT_EQ(rgn2->base, r2.base);
> > - assert(memblock.reserved.cnt == 2);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -899,6 +984,8 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
> > char *b;
> > struct region r1, r2;
> > + prefix_push(__func__);
> > +
> > phys_addr_t r3_size = SZ_256;
> > phys_addr_t gap_size = SMP_CACHE_BYTES;
> > phys_addr_t total_size;
> > @@ -925,20 +1012,23 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
> > NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn3->size, r3_size);
> > + ASSERT_EQ(rgn3->base, memblock_start_of_DRAM());
> > - assert(rgn3->size == r3_size);
> > - assert(rgn3->base == memblock_start_of_DRAM());
> > + ASSERT_EQ(rgn2->size, r2.size);
> > + ASSERT_EQ(rgn2->base, r2.base);
> > - assert(rgn2->size == r2.size);
> > - assert(rgn2->base == r2.base);
> > + ASSERT_EQ(rgn1->size, r1.size);
> > + ASSERT_EQ(rgn1->base, r1.base);
> > - assert(rgn1->size == r1.size);
> > - assert(rgn1->base == r1.base);
> > + ASSERT_EQ(memblock.reserved.cnt, 3);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > - assert(memblock.reserved.cnt == 3);
> > - assert(memblock.reserved.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -954,6 +1044,8 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_256;
> > phys_addr_t min_addr;
> > phys_addr_t max_addr;
> > @@ -968,14 +1060,17 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
> > NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, min_addr);
> > - assert(rgn->size == size);
> > - assert(rgn->base == min_addr);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -991,6 +1086,8 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_1K;
> > phys_addr_t min_addr;
> > phys_addr_t max_addr;
> > @@ -1005,14 +1102,17 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
> > NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> > - assert(rgn->size == size);
> > - assert(rgn->base == memblock_start_of_DRAM());
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -1020,6 +1120,7 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
> > /* Test case wrappers */
> > static int alloc_try_nid_simple_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_try_nid_top_down_simple_check();
> > memblock_set_bottom_up(true);
> > @@ -1030,6 +1131,7 @@ static int alloc_try_nid_simple_check(void)
> > static int alloc_try_nid_misaligned_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_try_nid_top_down_end_misaligned_check();
> > memblock_set_bottom_up(true);
> > @@ -1040,6 +1142,7 @@ static int alloc_try_nid_misaligned_check(void)
> > static int alloc_try_nid_narrow_range_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_try_nid_top_down_narrow_range_check();
> > memblock_set_bottom_up(true);
> > @@ -1050,6 +1153,7 @@ static int alloc_try_nid_narrow_range_check(void)
> > static int alloc_try_nid_reserved_with_space_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_try_nid_top_down_reserved_with_space_check();
> > memblock_set_bottom_up(true);
> > @@ -1060,6 +1164,7 @@ static int alloc_try_nid_reserved_with_space_check(void)
> > static int alloc_try_nid_reserved_no_space_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_try_nid_top_down_reserved_no_space_check();
> > memblock_set_bottom_up(true);
> > @@ -1070,6 +1175,7 @@ static int alloc_try_nid_reserved_no_space_check(void)
> > static int alloc_try_nid_cap_max_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_try_nid_top_down_cap_max_check();
> > memblock_set_bottom_up(true);
> > @@ -1080,6 +1186,7 @@ static int alloc_try_nid_cap_max_check(void)
> > static int alloc_try_nid_cap_min_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_try_nid_top_down_cap_min_check();
> > memblock_set_bottom_up(true);
> > @@ -1090,6 +1197,7 @@ 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);
> > @@ -1100,6 +1208,7 @@ 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);
> > @@ -1110,6 +1219,7 @@ 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);
> > @@ -1120,6 +1230,7 @@ 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);
> > @@ -1130,6 +1241,7 @@ 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);
> > @@ -1140,6 +1252,7 @@ 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);
> > @@ -1150,6 +1263,12 @@ static int alloc_try_nid_low_max_check(void)
> > int memblock_alloc_nid_checks(void)
> > {
> > + static const char func_testing[] = "memblock_alloc_try_nid";
> > +
> > + prefix_reset();
> > + prefix_push(func_testing);
> > + test_print("Running %s tests...\n", func_testing);
> > +
> > reset_memblock_attributes();
> > dummy_physical_memory_init();
> > @@ -1170,5 +1289,7 @@ int memblock_alloc_nid_checks(void)
> > dummy_physical_memory_cleanup();
> > + prefix_pop();
> > +
> > return 0;
> > }
> > diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c
> > index a7bc180316d6..f223a9a57be7 100644
> > --- a/tools/testing/memblock/tests/basic_api.c
> > +++ b/tools/testing/memblock/tests/basic_api.c
> > @@ -4,21 +4,30 @@
> > #include "basic_api.h"
> > #define EXPECTED_MEMBLOCK_REGIONS 128
> > +#define FUNC_ADD "memblock_add"
> > +#define FUNC_RESERVE "memblock_reserve"
> > +#define FUNC_REMOVE "memblock_remove"
> > +#define FUNC_FREE "memblock_free"
> > static int memblock_initialization_check(void)
> > {
> > - assert(memblock.memory.regions);
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
> > - assert(strcmp(memblock.memory.name, "memory") == 0);
> > + prefix_push(__func__);
> > - assert(memblock.reserved.regions);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
> > - assert(strcmp(memblock.reserved.name, "reserved") == 0);
> > + ASSERT_NE(memblock.memory.regions, NULL);
> > + ASSERT_EQ(memblock.memory.cnt, 1);
> > + ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
> > + ASSERT_EQ(strcmp(memblock.memory.name, "memory"), 0);
> > - assert(!memblock.bottom_up);
> > - assert(memblock.current_limit == MEMBLOCK_ALLOC_ANYWHERE);
> > + ASSERT_NE(memblock.reserved.regions, NULL);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
> > + ASSERT_EQ(strcmp(memblock.reserved.name, "reserved"), 0);
> > +
> > + ASSERT_EQ(memblock.bottom_up, false);
> > + ASSERT_EQ(memblock.current_limit, MEMBLOCK_ALLOC_ANYWHERE);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -40,14 +49,19 @@ static int memblock_add_simple_check(void)
> > .size = SZ_4M
> > };
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_add(r.base, r.size);
> > - assert(rgn->base == r.base);
> > - assert(rgn->size == r.size);
> > + ASSERT_EQ(rgn->base, r.base);
> > + ASSERT_EQ(rgn->size, r.size);
> > +
> > + ASSERT_EQ(memblock.memory.cnt, 1);
> > + ASSERT_EQ(memblock.memory.total_size, r.size);
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == r.size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -69,18 +83,27 @@ static int memblock_add_node_simple_check(void)
> > .size = SZ_16M
> > };
> > + prefix_pop();
> > + prefix_push("memblock_add_node");
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_add_node(r.base, r.size, 1, MEMBLOCK_HOTPLUG);
> > - assert(rgn->base == r.base);
> > - assert(rgn->size == r.size);
> > + ASSERT_EQ(rgn->base, r.base);
> > + ASSERT_EQ(rgn->size, r.size);
> > #ifdef CONFIG_NUMA
> > - assert(rgn->nid == 1);
> > + ASSERT_EQ(rgn->nid, 1);
> > #endif
> > - assert(rgn->flags == MEMBLOCK_HOTPLUG);
> > + ASSERT_EQ(rgn->flags, MEMBLOCK_HOTPLUG);
> > +
> > + ASSERT_EQ(memblock.memory.cnt, 1);
> > + ASSERT_EQ(memblock.memory.total_size, r.size);
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == r.size);
> > + test_pass();
> > + prefix_pop();
> > + prefix_pop();
> > + prefix_push(FUNC_ADD);
> > return 0;
> > }
> > @@ -113,18 +136,23 @@ static int memblock_add_disjoint_check(void)
> > .size = SZ_8K
> > };
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_add(r1.base, r1.size);
> > memblock_add(r2.base, r2.size);
> > - assert(rgn1->base == r1.base);
> > - assert(rgn1->size == r1.size);
> > + 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(rgn2->base == r2.base);
> > - assert(rgn2->size == r2.size);
> > + ASSERT_EQ(memblock.memory.cnt, 2);
> > + ASSERT_EQ(memblock.memory.total_size, r1.size + r2.size);
> > - assert(memblock.memory.cnt == 2);
> > - assert(memblock.memory.total_size == r1.size + r2.size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -162,17 +190,22 @@ static int memblock_add_overlap_top_check(void)
> > .size = SZ_512M
> > };
> > + prefix_push(__func__);
> > +
> > total_size = (r1.base - r2.base) + r1.size;
> > reset_memblock_regions();
> > memblock_add(r1.base, r1.size);
> > memblock_add(r2.base, r2.size);
> > - assert(rgn->base == r2.base);
> > - assert(rgn->size == total_size);
> > + ASSERT_EQ(rgn->base, r2.base);
> > + ASSERT_EQ(rgn->size, total_size);
> > +
> > + ASSERT_EQ(memblock.memory.cnt, 1);
> > + ASSERT_EQ(memblock.memory.total_size, total_size);
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -210,17 +243,22 @@ static int memblock_add_overlap_bottom_check(void)
> > .size = SZ_1G
> > };
> > + prefix_push(__func__);
> > +
> > total_size = (r2.base - r1.base) + r2.size;
> > reset_memblock_regions();
> > memblock_add(r1.base, r1.size);
> > memblock_add(r2.base, r2.size);
> > - assert(rgn->base == r1.base);
> > - assert(rgn->size == total_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);
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -255,15 +293,20 @@ static int memblock_add_within_check(void)
> > .size = SZ_1M
> > };
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_add(r1.base, r1.size);
> > memblock_add(r2.base, r2.size);
> > - assert(rgn->base == r1.base);
> > - assert(rgn->size == r1.size);
> > + ASSERT_EQ(rgn->base, r1.base);
> > + ASSERT_EQ(rgn->size, r1.size);
> > +
> > + ASSERT_EQ(memblock.memory.cnt, 1);
> > + ASSERT_EQ(memblock.memory.total_size, r1.size);
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == r1.size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -279,19 +322,28 @@ static int memblock_add_twice_check(void)
> > .size = SZ_2M
> > };
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_add(r.base, r.size);
> > memblock_add(r.base, r.size);
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == r.size);
> > + ASSERT_EQ(memblock.memory.cnt, 1);
> > + ASSERT_EQ(memblock.memory.total_size, r.size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > static int memblock_add_checks(void)
> > {
> > + prefix_reset();
> > + prefix_push(FUNC_ADD);
> > + test_print("Running %s tests...\n", FUNC_ADD);
> > +
> > memblock_add_simple_check();
> > memblock_add_node_simple_check();
> > memblock_add_disjoint_check();
> > @@ -300,6 +352,8 @@ static int memblock_add_checks(void)
> > memblock_add_within_check();
> > memblock_add_twice_check();
> > + prefix_pop();
> > +
> > return 0;
> > }
> > @@ -320,11 +374,16 @@ static int memblock_reserve_simple_check(void)
> > .size = SZ_128M
> > };
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_reserve(r.base, r.size);
> > - assert(rgn->base == r.base);
> > - assert(rgn->size == r.size);
> > + ASSERT_EQ(rgn->base, r.base);
> > + ASSERT_EQ(rgn->size, r.size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -356,18 +415,23 @@ static int memblock_reserve_disjoint_check(void)
> > .size = SZ_512M
> > };
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_reserve(r1.base, r1.size);
> > memblock_reserve(r2.base, r2.size);
> > - assert(rgn1->base == r1.base);
> > - assert(rgn1->size == r1.size);
> > + 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(rgn2->base == r2.base);
> > - assert(rgn2->size == r2.size);
> > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > + ASSERT_EQ(memblock.reserved.total_size, r1.size + r2.size);
> > - assert(memblock.reserved.cnt == 2);
> > - assert(memblock.reserved.total_size == r1.size + r2.size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -406,17 +470,22 @@ static int memblock_reserve_overlap_top_check(void)
> > .size = SZ_1G
> > };
> > + prefix_push(__func__);
> > +
> > total_size = (r1.base - r2.base) + r1.size;
> > reset_memblock_regions();
> > memblock_reserve(r1.base, r1.size);
> > memblock_reserve(r2.base, r2.size);
> > - assert(rgn->base == r2.base);
> > - assert(rgn->size == total_size);
> > + ASSERT_EQ(rgn->base, r2.base);
> > + ASSERT_EQ(rgn->size, total_size);
> > +
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -455,17 +524,22 @@ static int memblock_reserve_overlap_bottom_check(void)
> > .size = SZ_128K
> > };
> > + prefix_push(__func__);
> > +
> > total_size = (r2.base - r1.base) + r2.size;
> > reset_memblock_regions();
> > memblock_reserve(r1.base, r1.size);
> > memblock_reserve(r2.base, r2.size);
> > - assert(rgn->base == r1.base);
> > - assert(rgn->size == total_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);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -502,15 +576,20 @@ static int memblock_reserve_within_check(void)
> > .size = SZ_64K
> > };
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_reserve(r1.base, r1.size);
> > memblock_reserve(r2.base, r2.size);
> > - assert(rgn->base == r1.base);
> > - assert(rgn->size == r1.size);
> > + ASSERT_EQ(rgn->base, r1.base);
> > + ASSERT_EQ(rgn->size, r1.size);
> > +
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, r1.size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == r1.size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -527,19 +606,28 @@ static int memblock_reserve_twice_check(void)
> > .size = SZ_2M
> > };
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_reserve(r.base, r.size);
> > memblock_reserve(r.base, r.size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == r.size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, r.size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > static int memblock_reserve_checks(void)
> > {
> > + prefix_reset();
> > + prefix_push(FUNC_RESERVE);
> > + test_print("Running %s tests...\n", FUNC_RESERVE);
> > +
> > memblock_reserve_simple_check();
> > memblock_reserve_disjoint_check();
> > memblock_reserve_overlap_top_check();
> > @@ -547,6 +635,8 @@ static int memblock_reserve_checks(void)
> > memblock_reserve_within_check();
> > memblock_reserve_twice_check();
> > + prefix_pop();
> > +
> > return 0;
> > }
> > @@ -581,16 +671,21 @@ static int memblock_remove_simple_check(void)
> > .size = SZ_4M
> > };
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_add(r1.base, r1.size);
> > memblock_add(r2.base, r2.size);
> > memblock_remove(r1.base, r1.size);
> > - assert(rgn->base == r2.base);
> > - assert(rgn->size == r2.size);
> > + ASSERT_EQ(rgn->base, r2.base);
> > + ASSERT_EQ(rgn->size, r2.size);
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == r2.size);
> > + ASSERT_EQ(memblock.memory.cnt, 1);
> > + ASSERT_EQ(memblock.memory.total_size, r2.size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -626,15 +721,20 @@ static int memblock_remove_absent_check(void)
> > .size = SZ_1G
> > };
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_add(r1.base, r1.size);
> > memblock_remove(r2.base, r2.size);
> > - assert(rgn->base == r1.base);
> > - assert(rgn->size == r1.size);
> > + ASSERT_EQ(rgn->base, r1.base);
> > + ASSERT_EQ(rgn->size, r1.size);
> > +
> > + ASSERT_EQ(memblock.memory.cnt, 1);
> > + ASSERT_EQ(memblock.memory.total_size, r1.size);
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == r1.size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -674,6 +774,8 @@ static int memblock_remove_overlap_top_check(void)
> > .size = SZ_32M
> > };
> > + prefix_push(__func__);
> > +
> > r1_end = r1.base + r1.size;
> > r2_end = r2.base + r2.size;
> > total_size = r1_end - r2_end;
> > @@ -682,11 +784,14 @@ static int memblock_remove_overlap_top_check(void)
> > memblock_add(r1.base, r1.size);
> > memblock_remove(r2.base, r2.size);
> > - assert(rgn->base == r1.base + r2.base);
> > - assert(rgn->size == total_size);
> > + ASSERT_EQ(rgn->base, r1.base + r2.base);
> > + ASSERT_EQ(rgn->size, total_size);
> > +
> > + ASSERT_EQ(memblock.memory.cnt, 1);
> > + ASSERT_EQ(memblock.memory.total_size, total_size);
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -724,17 +829,23 @@ static int memblock_remove_overlap_bottom_check(void)
> > .size = SZ_256M
> > };
> > + prefix_push(__func__);
> > +
> > total_size = r2.base - r1.base;
> > reset_memblock_regions();
> > memblock_add(r1.base, r1.size);
> > memblock_remove(r2.base, r2.size);
> > - assert(rgn->base == r1.base);
> > - assert(rgn->size == total_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();
> > + prefix_pop();
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == total_size);
> > return 0;
> > }
> > @@ -774,6 +885,8 @@ static int memblock_remove_within_check(void)
> > .size = SZ_1M
> > };
> > + prefix_push(__func__);
> > +
> > r1_size = r2.base - r1.base;
> > r2_size = (r1.base + r1.size) - (r2.base + r2.size);
> > total_size = r1_size + r2_size;
> > @@ -782,26 +895,35 @@ static int memblock_remove_within_check(void)
> > memblock_add(r1.base, r1.size);
> > memblock_remove(r2.base, r2.size);
> > - assert(rgn1->base == r1.base);
> > - assert(rgn1->size == r1_size);
> > + ASSERT_EQ(rgn1->base, r1.base);
> > + ASSERT_EQ(rgn1->size, r1_size);
> > +
> > + ASSERT_EQ(rgn2->base, r2.base + r2.size);
> > + ASSERT_EQ(rgn2->size, r2_size);
> > - assert(rgn2->base == r2.base + r2.size);
> > - assert(rgn2->size == r2_size);
> > + ASSERT_EQ(memblock.memory.cnt, 2);
> > + ASSERT_EQ(memblock.memory.total_size, total_size);
> > - assert(memblock.memory.cnt == 2);
> > - assert(memblock.memory.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > static int memblock_remove_checks(void)
> > {
> > + prefix_reset();
> > + prefix_push(FUNC_REMOVE);
> > + test_print("Running %s tests...\n", FUNC_REMOVE);
> > +
> > memblock_remove_simple_check();
> > memblock_remove_absent_check();
> > memblock_remove_overlap_top_check();
> > memblock_remove_overlap_bottom_check();
> > memblock_remove_within_check();
> > + prefix_pop();
> > +
> > return 0;
> > }
> > @@ -835,16 +957,21 @@ static int memblock_free_simple_check(void)
> > .size = SZ_1M
> > };
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_reserve(r1.base, r1.size);
> > memblock_reserve(r2.base, r2.size);
> > memblock_free((void *)r1.base, r1.size);
> > - assert(rgn->base == r2.base);
> > - assert(rgn->size == r2.size);
> > + ASSERT_EQ(rgn->base, r2.base);
> > + ASSERT_EQ(rgn->size, r2.size);
> > +
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, r2.size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == r2.size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -880,15 +1007,20 @@ static int memblock_free_absent_check(void)
> > .size = SZ_128M
> > };
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_reserve(r1.base, r1.size);
> > memblock_free((void *)r2.base, r2.size);
> > - assert(rgn->base == r1.base);
> > - assert(rgn->size == r1.size);
> > + ASSERT_EQ(rgn->base, r1.base);
> > + ASSERT_EQ(rgn->size, r1.size);
> > +
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, r1.size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == r1.size);
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -928,17 +1060,22 @@ static int memblock_free_overlap_top_check(void)
> > .size = SZ_8M
> > };
> > + prefix_push(__func__);
> > +
> > total_size = (r1.size + r1.base) - (r2.base + r2.size);
> > reset_memblock_regions();
> > memblock_reserve(r1.base, r1.size);
> > memblock_free((void *)r2.base, r2.size);
> > - assert(rgn->base == r2.base + r2.size);
> > - assert(rgn->size == total_size);
> > + ASSERT_EQ(rgn->base, r2.base + r2.size);
> > + ASSERT_EQ(rgn->size, total_size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -973,17 +1110,22 @@ static int memblock_free_overlap_bottom_check(void)
> > .size = SZ_32M
> > };
> > + prefix_push(__func__);
> > +
> > total_size = r2.base - r1.base;
> > reset_memblock_regions();
> > memblock_reserve(r1.base, r1.size);
> > memblock_free((void *)r2.base, r2.size);
> > - assert(rgn->base == r1.base);
> > - assert(rgn->size == total_size);
> > + ASSERT_EQ(rgn->base, r1.base);
> > + ASSERT_EQ(rgn->size, total_size);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > @@ -1024,6 +1166,8 @@ static int memblock_free_within_check(void)
> > .size = SZ_1M
> > };
> > + prefix_push(__func__);
> > +
> > r1_size = r2.base - r1.base;
> > r2_size = (r1.base + r1.size) - (r2.base + r2.size);
> > total_size = r1_size + r2_size;
> > @@ -1032,26 +1176,35 @@ static int memblock_free_within_check(void)
> > memblock_reserve(r1.base, r1.size);
> > memblock_free((void *)r2.base, r2.size);
> > - assert(rgn1->base == r1.base);
> > - assert(rgn1->size == r1_size);
> > + ASSERT_EQ(rgn1->base, r1.base);
> > + ASSERT_EQ(rgn1->size, r1_size);
> > - assert(rgn2->base == r2.base + r2.size);
> > - assert(rgn2->size == r2_size);
> > + ASSERT_EQ(rgn2->base, r2.base + r2.size);
> > + ASSERT_EQ(rgn2->size, r2_size);
> > - assert(memblock.reserved.cnt == 2);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> > return 0;
> > }
> > static int memblock_free_checks(void)
> > {
> > + prefix_reset();
> > + prefix_push(FUNC_FREE);
> > + test_print("Running %s tests...\n", FUNC_FREE);
> > +
> > memblock_free_simple_check();
> > memblock_free_absent_check();
> > memblock_free_overlap_top_check();
> > memblock_free_overlap_bottom_check();
> > memblock_free_within_check();
> > + prefix_pop();
> > +
> > return 0;
> > }
> > diff --git a/tools/testing/memblock/tests/common.c b/tools/testing/memblock/tests/common.c
> > index 62d3191f7c9a..e55b2a8bf0ff 100644
> > --- a/tools/testing/memblock/tests/common.c
> > +++ b/tools/testing/memblock/tests/common.c
> > @@ -4,8 +4,12 @@
> > #define INIT_MEMBLOCK_REGIONS 128
> > #define INIT_MEMBLOCK_RESERVED_REGIONS INIT_MEMBLOCK_REGIONS
> > +#define PREFIXES_LEN_MAX 256
> > +#define DELIM ": "
> > +#define DELIM_LEN strlen(DELIM)
> > static struct test_memory memory_block;
> > +static char __maybe_unused prefixes[PREFIXES_LEN_MAX];
> > void reset_memblock_regions(void)
> > {
> > @@ -46,3 +50,57 @@ void dummy_physical_memory_cleanup(void)
> > {
> > free(memory_block.base);
> > }
> > +
> > +#ifdef VERBOSE
> > +void test_fail(void)
> > +{
> > + ksft_test_result_fail(": %sfailed\n", prefixes);
> > +}
> > +
> > +void test_pass(void)
> > +{
> > + ksft_test_result_pass(": %spassed\n", prefixes);
> > +}
> > +
> > +void test_print(const char *fmt, ...)
> > +{
> > + int saved_errno = errno;
> > + va_list args;
> > +
> > + va_start(args, fmt);
> > + errno = saved_errno;
> > + vprintf(fmt, args);
> > + va_end(args);
> > +}
> > +
> > +void prefix_reset(void)
> > +{
> > + memset(prefixes, 0, PREFIXES_LEN_MAX);
> > +}
> > +
> > +void prefix_push(const char *prefix)
> > +{
> > + int prefix_max = PREFIXES_LEN_MAX - strlen(prefixes) - DELIM_LEN - 1;
> > +
> > + assert(strlen(prefix) <= prefix_max);
> > + strncat(prefixes, prefix, prefix_max);
> > + strncat(prefixes, DELIM, PREFIXES_LEN_MAX - strlen(prefixes) - 1);
> > +}
> > +
> > +void prefix_pop(void)
> > +{
> > + char *ptr;
> > +
> > + ptr = strrchr(prefixes, DELIM[0]);
> > + if (!ptr)
> > + prefixes[0] = 0;
> > + else
> > + *(ptr) = 0;
> > +
> > + ptr = strrchr(prefixes, DELIM[0]);
> > + if (!ptr)
> > + prefixes[0] = 0;
> > + else
> > + *(ptr + DELIM_LEN) = 0;
> > +}
> > +#endif /* VERBOSE */
> > diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h
> > index 619054d03219..bdddb5f72871 100644
> > --- a/tools/testing/memblock/tests/common.h
> > +++ b/tools/testing/memblock/tests/common.h
> > @@ -7,9 +7,47 @@
> > #include <linux/types.h>
> > #include <linux/memblock.h>
> > #include <linux/sizes.h>
> > +#include <linux/printk.h>
> > +#include <../selftests/kselftest.h>
> > #define MEM_SIZE SZ_16K
> > +/**
> > + * ASSERT_EQ():
> > + * Check the condition
> > + * @_expected == @_seen
> > + * If false, print failed test message (if in VERBOSE mode) and then assert
> > + */
> > +#define ASSERT_EQ(_expected, _seen) do { \
> > + if ((_expected) != (_seen)) \
> > + test_fail(); \
> > + assert((_expected) == (_seen)); \
> > +} while (0)
> > +
> > +/**
> > + * ASSERT_NE():
> > + * Check the condition
> > + * @_expected != @_seen
> > + * If false, print failed test message (if in VERBOSE mode) and then assert
> > + */
> > +#define ASSERT_NE(_expected, _seen) do { \
> > + if ((_expected) == (_seen)) \
> > + test_fail(); \
> > + assert((_expected) != (_seen)); \
> > +} while (0)
> > +
> > +/**
> > + * ASSERT_LT():
> > + * Check the condition
> > + * @_expected < @_seen
> > + * If false, print failed test message (if in VERBOSE mode) and then assert
> > + */
> > +#define ASSERT_LT(_expected, _seen) do { \
> > + if ((_expected) >= (_seen)) \
> > + test_fail(); \
> > + assert((_expected) < (_seen)); \
> > +} while (0)
> > +
> > /*
> > * Available memory registered with memblock needs to be valid for allocs
> > * test to run. This is a convenience wrapper for memory allocated in
> > @@ -31,4 +69,20 @@ void setup_memblock(void);
> > void dummy_physical_memory_init(void);
> > void dummy_physical_memory_cleanup(void);
> > +#ifdef VERBOSE
> > +void test_fail(void);
> > +void test_pass(void);
> > +void test_print(const char *fmt, ...);
> > +void prefix_reset(void);
> > +void prefix_push(const char *prefix);
> > +void prefix_pop(void);
> > +#else
> > +static inline void test_fail(void) {}
> > +static inline void test_pass(void) {}
> > +static inline void test_print(const char *fmt, ...) {}
> > +static inline void prefix_reset(void) {}
> > +static inline void prefix_push(const char *prefix) {}
> > +static inline void prefix_pop(void) {}
> > +#endif /* VERBOSE */
> > +
> > #endif
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 0/4] memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options
2022-06-22 10:00 ` [PATCH v3 0/4] memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options David Hildenbrand
@ 2022-06-23 0:54 ` Rebecca Mckeever
0 siblings, 0 replies; 31+ messages in thread
From: Rebecca Mckeever @ 2022-06-23 0:54 UTC (permalink / raw)
To: David Hildenbrand; +Cc: Mike Rapoport, linux-mm, linux-kernel
On Wed, Jun 22, 2022 at 12:00:05PM +0200, David Hildenbrand wrote:
> On 22.06.22 11:29, Rebecca Mckeever wrote:
> > These patches add options VERBOSE and MEMBLOCK_DEBUG to Memblock
> > simulator, which can be specified when running make. These patches also
> > implement the functionality for these options.
> >
> > VERBOSE
> > Usage:
> >
> > $ make VERBOSE=1
> >
> > Passing VERBOSE=1 will enable verbose output from Memblock simulator. For
> > each test, the verbose output includes the name of the memblock function
> > being tested, the name of the test, and whether the test passed or failed.
> > Since all the tests in Memblock simulator run as one monolithic test, this
> > output is a quick way to get a summary of test results.
> >
> > MEMBLOCK_DEBUG
> > Usage:
> >
> > $ make MEMBLOCK_DEBUG=1
> >
> > Passing MEMBLOCK_DEBUG=1 will enable memblock_dbg() messages. These
> > are debug messages built into several functions in memblock that include
> > information such as the name of the function and the size and start and
> > end addresses of the memblock region.
> >
> > Rebecca Mckeever (4):
> > memblock tests: add user-provided arguments to Makefile
> > memblock tests: add verbose output to memblock tests
> > memblock tests: set memblock_debug to enable memblock_dbg() messages
> > memblock tests: remove completed TODO items
> >
> > tools/testing/memblock/Makefile | 4 +
> > tools/testing/memblock/README | 10 +-
> > tools/testing/memblock/TODO | 14 +-
> > tools/testing/memblock/internal.h | 7 +
> > .../testing/memblock/scripts/Makefile.include | 10 +
> > tools/testing/memblock/tests/alloc_api.c | 241 ++++++++----
> > .../memblock/tests/alloc_helpers_api.c | 135 +++++--
> > tools/testing/memblock/tests/alloc_nid_api.c | 371 ++++++++++++------
> > tools/testing/memblock/tests/basic_api.c | 365 ++++++++++++-----
> > tools/testing/memblock/tests/common.c | 58 +++
> > tools/testing/memblock/tests/common.h | 54 +++
> > 11 files changed, 913 insertions(+), 356 deletions(-)
> >
> > ---
> > Changes
> >
> > v1 -> v2
> > PATCH 2, in common.c:
> > Remove #ifdef VERBOSE around prefixes and related constants
> > Add __maybe_unused to prefixes
> > Move PREFIXES_LEN_MAX, DELIM, and DELIM_LEN so that they are
> > immediately after the other constants
> > Add #ifdef VERBOSE around definitions for test_*() and prefix_*()
> >
> > v2 -> v3
> > PATCH 1:
> > Add Reviewed-by tag
> > ---
> >
>
> Hi Rebecca,
>
> no need to resend a new version that frequently; wait for more feedback
> first.
>
> Usually, people expect a new version when there hasn't been more review
> feedback for a few days.
>
> Also, there is usually no need to send a new version when you get a
> rb/ack tag: the maintainer might just pick them up when applying the
> patches.
>
Hi David,
I sent v2 because I noticed a nontrivial mistake after I sent v1 and I
wanted to save reviewers some trouble by correcting it right away. I
agree that v3 was probably unnecessary.
> --
> Thanks,
>
> David / dhildenb
>
Thanks,
Rebecca
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 0/4] memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options
2022-06-22 14:17 ` Mike Rapoport
@ 2022-06-23 1:01 ` Rebecca Mckeever
0 siblings, 0 replies; 31+ messages in thread
From: Rebecca Mckeever @ 2022-06-23 1:01 UTC (permalink / raw)
To: Mike Rapoport; +Cc: linux-mm, linux-kernel, David Hildenbrand
Hi Mike,
On Wed, Jun 22, 2022 at 09:17:24AM -0500, Mike Rapoport wrote:
> Hi Rebecca,
>
> On Wed, Jun 22, 2022 at 04:29:05AM -0500, Rebecca Mckeever wrote:
> > These patches add options VERBOSE and MEMBLOCK_DEBUG to Memblock
> > simulator, which can be specified when running make. These patches also
> > implement the functionality for these options.
> >
> > VERBOSE
> > Usage:
> >
> > $ make VERBOSE=1
> >
> > Passing VERBOSE=1 will enable verbose output from Memblock simulator. For
> > each test, the verbose output includes the name of the memblock function
> > being tested, the name of the test, and whether the test passed or failed.
> > Since all the tests in Memblock simulator run as one monolithic test, this
> > output is a quick way to get a summary of test results.
> >
> > MEMBLOCK_DEBUG
> > Usage:
> >
> > $ make MEMBLOCK_DEBUG=1
> >
> > Passing MEMBLOCK_DEBUG=1 will enable memblock_dbg() messages. These
> > are debug messages built into several functions in memblock that include
> > information such as the name of the function and the size and start and
> > end addresses of the memblock region.
> >
> > Rebecca Mckeever (4):
> > memblock tests: add user-provided arguments to Makefile
> > memblock tests: add verbose output to memblock tests
> > memblock tests: set memblock_debug to enable memblock_dbg() messages
> > memblock tests: remove completed TODO items
> >
> > tools/testing/memblock/Makefile | 4 +
> > tools/testing/memblock/README | 10 +-
> > tools/testing/memblock/TODO | 14 +-
> > tools/testing/memblock/internal.h | 7 +
> > .../testing/memblock/scripts/Makefile.include | 10 +
> > tools/testing/memblock/tests/alloc_api.c | 241 ++++++++----
> > .../memblock/tests/alloc_helpers_api.c | 135 +++++--
> > tools/testing/memblock/tests/alloc_nid_api.c | 371 ++++++++++++------
> > tools/testing/memblock/tests/basic_api.c | 365 ++++++++++++-----
> > tools/testing/memblock/tests/common.c | 58 +++
> > tools/testing/memblock/tests/common.h | 54 +++
> > 11 files changed, 913 insertions(+), 356 deletions(-)
> >
> > ---
> > Changes
> >
> > v1 -> v2
> > PATCH 2, in common.c:
> > Remove #ifdef VERBOSE around prefixes and related constants
> > Add __maybe_unused to prefixes
> > Move PREFIXES_LEN_MAX, DELIM, and DELIM_LEN so that they are
> > immediately after the other constants
> > Add #ifdef VERBOSE around definitions for test_*() and prefix_*()
> >
> > v2 -> v3
> > PATCH 1:
> > Add Reviewed-by tag
> > ---
>
> The patch changelog in a cover letter usually goes before the commit list
> and diffstat.
>
Thanks for letting me know, I will do that next time.
> > --
> > 2.34.1
> >
>
> --
> Sincerely yours,
> Mike.
Thanks,
Rebecca
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 2/4] memblock tests: add verbose output to memblock tests
2022-06-23 0:45 ` Rebecca Mckeever
@ 2022-06-23 1:29 ` Huang, Shaoqin
2022-06-23 3:10 ` Rebecca Mckeever
2022-06-23 4:05 ` Mike Rapoport
0 siblings, 2 replies; 31+ messages in thread
From: Huang, Shaoqin @ 2022-06-23 1:29 UTC (permalink / raw)
To: Rebecca Mckeever; +Cc: Mike Rapoport, linux-mm, linux-kernel, David Hildenbrand
On 6/23/2022 8:45 AM, Rebecca Mckeever wrote:
> On Wed, Jun 22, 2022 at 06:32:04PM +0800, Huang, Shaoqin wrote:
>> Just test it and everything works fine. And I think there are some thing can
>> improve:
>>
>> The prefix_push() and prefix_pop() are used in so many functions and
>> almost of them just put the prefix_push(__func__) begin in the head and the
>> prefix_pop() in the end.
>> May be you can define some macro that when you output something and
>> automatically push the __func__ as prefix. And when leave the function,
>> automatically pop it. And only in some special place, you call it manually.
>>
> Thank you for your review. I'm not sure how you would automatically push
> __func__ since you have to be inside the function to access that
> variable. Let me know if you have any suggestions. I am thinking about
> adding another function in common.c that just calls test_pass() followed
> by prefix_pop() since those are called together so often.
Just like:
#define test_pass_macro() \
do { \
prefix_push(__func__); \
test_pass(); \
prefix_pop(); \
} while (0)
This macro will automatically push the __fun__ as prefix when you call
test_pass_macro(). And then pop it after test_pass() output.
And use this macro() to hidden most of the paired prefix_* functions.
And I think that's the simplist way. May be someone has a better solution.
>>
>> On 6/22/2022 5:29 PM, Rebecca Mckeever wrote:
>>> Add and use functions for printing verbose testing output.
>>>
>>> If the Memblock simulator was compiled with VERBOSE=1:
>>> prefix_push() appends the given string to a prefix string that will be
>>> printed in the test functions.
>>> prefix_pop() removes the last prefix from the prefix string.
>>> prefix_reset() clears the prefix string.
>>> test_fail() prints a message after a test fails containing the test
>>> number of the failing test and the prefix.
>>> test_pass() prints a message after a test passes containing its test
>>> number and the prefix.
>>> test_print() prints the given formatted output string.
>>>
>>
>> Comments like this is more clear, not just indent:
>> - prefix_push(): appends ...
>> - prefix_pop(): removes ...
>>
> That does look better, I'll update the commit text.
>
>>> If the Memblock simulator was not compiled with VERBOSE=1, these
>>> functions do nothing.
>>>
>>> Add the assert wrapper macros ASSERT_EQ(), ASSERT_NE(), and ASSERT_LT().
>>> If the assert condition fails, these macros call test_fail() before
>>> executing assert().
>>>
>>> Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
>>> ---
>>> tools/testing/memblock/tests/alloc_api.c | 241 ++++++++----
>>> .../memblock/tests/alloc_helpers_api.c | 135 +++++--
>>> tools/testing/memblock/tests/alloc_nid_api.c | 371 ++++++++++++------
>>> tools/testing/memblock/tests/basic_api.c | 365 ++++++++++++-----
>>> tools/testing/memblock/tests/common.c | 58 +++
>>> tools/testing/memblock/tests/common.h | 54 +++
>>> 6 files changed, 880 insertions(+), 344 deletions(-)
>>>
>>> diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
>>> index d1aa7e15c18d..96df033d4300 100644
>>> --- a/tools/testing/memblock/tests/alloc_api.c
>>> +++ b/tools/testing/memblock/tests/alloc_api.c
>>> @@ -10,6 +10,8 @@ static int alloc_top_down_simple_check(void)
>>> struct memblock_region *rgn = &memblock.reserved.regions[0];
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t size = SZ_2;
>>> phys_addr_t expected_start;
>>> @@ -19,12 +21,15 @@ static int alloc_top_down_simple_check(void)
>>> allocated_ptr = memblock_alloc(size, SMP_CACHE_BYTES);
>>> - assert(allocated_ptr);
>>> - assert(rgn->size == size);
>>> - assert(rgn->base == expected_start);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(rgn->size, size);
>>> + ASSERT_EQ(rgn->base, expected_start);
>>> +
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -55,6 +60,8 @@ static int alloc_top_down_disjoint_check(void)
>>> struct region r1;
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t r2_size = SZ_16;
>>> /* Use custom alignment */
>>> phys_addr_t alignment = SMP_CACHE_BYTES * 2;
>>> @@ -73,15 +80,18 @@ static int alloc_top_down_disjoint_check(void)
>>> allocated_ptr = memblock_alloc(r2_size, alignment);
>>> - assert(allocated_ptr);
>>> - assert(rgn1->size == r1.size);
>>> - assert(rgn1->base == r1.base);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(rgn1->size, r1.size);
>>> + ASSERT_EQ(rgn1->base, r1.base);
>>> - assert(rgn2->size == r2_size);
>>> - assert(rgn2->base == expected_start);
>>> + ASSERT_EQ(rgn2->size, r2_size);
>>> + ASSERT_EQ(rgn2->base, expected_start);
>>> - assert(memblock.reserved.cnt == 2);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 2);
>>> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -101,6 +111,8 @@ static int alloc_top_down_before_check(void)
>>> struct memblock_region *rgn = &memblock.reserved.regions[0];
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> /*
>>> * The first region ends at the aligned address to test region merging
>>> */
>>> @@ -114,12 +126,15 @@ static int alloc_top_down_before_check(void)
>>> allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
>>> - assert(allocated_ptr);
>>> - assert(rgn->size == total_size);
>>> - assert(rgn->base == memblock_end_of_DRAM() - total_size);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(rgn->size, total_size);
>>> + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - total_size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -141,6 +156,8 @@ static int alloc_top_down_after_check(void)
>>> struct region r1;
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t r2_size = SZ_512;
>>> phys_addr_t total_size;
>>> @@ -158,12 +175,15 @@ static int alloc_top_down_after_check(void)
>>> allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
>>> - assert(allocated_ptr);
>>> - assert(rgn->size == total_size);
>>> - assert(rgn->base == r1.base - r2_size);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(rgn->size, total_size);
>>> + ASSERT_EQ(rgn->base, r1.base - r2_size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -186,6 +206,8 @@ static int alloc_top_down_second_fit_check(void)
>>> struct region r1, r2;
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t r3_size = SZ_1K;
>>> phys_addr_t total_size;
>>> @@ -204,12 +226,15 @@ static int alloc_top_down_second_fit_check(void)
>>> allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
>>> - assert(allocated_ptr);
>>> - assert(rgn->size == r2.size + r3_size);
>>> - assert(rgn->base == r2.base - r3_size);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(rgn->size, r2.size + r3_size);
>>> + ASSERT_EQ(rgn->base, r2.base - r3_size);
>>> - assert(memblock.reserved.cnt == 2);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 2);
>>> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -231,6 +256,8 @@ static int alloc_in_between_generic_check(void)
>>> struct region r1, r2;
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t gap_size = SMP_CACHE_BYTES;
>>> phys_addr_t r3_size = SZ_64;
>>> /*
>>> @@ -254,12 +281,15 @@ static int alloc_in_between_generic_check(void)
>>> allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
>>> - assert(allocated_ptr);
>>> - assert(rgn->size == total_size);
>>> - assert(rgn->base == r1.base - r2.size - r3_size);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(rgn->size, total_size);
>>> + ASSERT_EQ(rgn->base, r1.base - r2.size - r3_size);
>>> +
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -281,6 +311,8 @@ static int alloc_small_gaps_generic_check(void)
>>> {
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t region_size = SZ_1K;
>>> phys_addr_t gap_size = SZ_256;
>>> phys_addr_t region_end;
>>> @@ -296,7 +328,10 @@ static int alloc_small_gaps_generic_check(void)
>>> allocated_ptr = memblock_alloc(region_size, SMP_CACHE_BYTES);
>>> - assert(!allocated_ptr);
>>> + ASSERT_EQ(allocated_ptr, NULL);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -309,6 +344,8 @@ static int alloc_all_reserved_generic_check(void)
>>> {
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> setup_memblock();
>>> /* Simulate full memory */
>>> @@ -316,7 +353,10 @@ static int alloc_all_reserved_generic_check(void)
>>> allocated_ptr = memblock_alloc(SZ_256, SMP_CACHE_BYTES);
>>> - assert(!allocated_ptr);
>>> + ASSERT_EQ(allocated_ptr, NULL);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -338,6 +378,8 @@ static int alloc_no_space_generic_check(void)
>>> {
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> setup_memblock();
>>> phys_addr_t available_size = SZ_256;
>>> @@ -348,7 +390,10 @@ static int alloc_no_space_generic_check(void)
>>> allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
>>> - assert(!allocated_ptr);
>>> + ASSERT_EQ(allocated_ptr, NULL);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -369,6 +414,8 @@ static int alloc_limited_space_generic_check(void)
>>> struct memblock_region *rgn = &memblock.reserved.regions[0];
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t available_size = SZ_256;
>>> phys_addr_t reserved_size = MEM_SIZE - available_size;
>>> @@ -379,12 +426,15 @@ static int alloc_limited_space_generic_check(void)
>>> allocated_ptr = memblock_alloc(available_size, SMP_CACHE_BYTES);
>>> - assert(allocated_ptr);
>>> - assert(rgn->size == MEM_SIZE);
>>> - assert(rgn->base == memblock_start_of_DRAM());
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(rgn->size, MEM_SIZE);
>>> + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
>>> +
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, MEM_SIZE);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == MEM_SIZE);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -399,14 +449,19 @@ static int alloc_no_memory_generic_check(void)
>>> struct memblock_region *rgn = &memblock.reserved.regions[0];
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> reset_memblock_regions();
>>> allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
>>> - assert(!allocated_ptr);
>>> - assert(rgn->size == 0);
>>> - assert(rgn->base == 0);
>>> - assert(memblock.reserved.total_size == 0);
>>> + ASSERT_EQ(allocated_ptr, NULL);
>>> + ASSERT_EQ(rgn->size, 0);
>>> + ASSERT_EQ(rgn->base, 0);
>>> + ASSERT_EQ(memblock.reserved.total_size, 0);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -421,16 +476,21 @@ static int alloc_bottom_up_simple_check(void)
>>> struct memblock_region *rgn = &memblock.reserved.regions[0];
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> setup_memblock();
>>> allocated_ptr = memblock_alloc(SZ_2, SMP_CACHE_BYTES);
>>> - assert(allocated_ptr);
>>> - assert(rgn->size == SZ_2);
>>> - assert(rgn->base == memblock_start_of_DRAM());
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(rgn->size, SZ_2);
>>> + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == SZ_2);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, SZ_2);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -459,6 +519,8 @@ static int alloc_bottom_up_disjoint_check(void)
>>> struct region r1;
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t r2_size = SZ_16;
>>> /* Use custom alignment */
>>> phys_addr_t alignment = SMP_CACHE_BYTES * 2;
>>> @@ -477,16 +539,19 @@ static int alloc_bottom_up_disjoint_check(void)
>>> allocated_ptr = memblock_alloc(r2_size, alignment);
>>> - assert(allocated_ptr);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> - assert(rgn1->size == r1.size);
>>> - assert(rgn1->base == r1.base);
>>> + ASSERT_EQ(rgn1->size, r1.size);
>>> + ASSERT_EQ(rgn1->base, r1.base);
>>> - assert(rgn2->size == r2_size);
>>> - assert(rgn2->base == expected_start);
>>> + ASSERT_EQ(rgn2->size, r2_size);
>>> + ASSERT_EQ(rgn2->base, expected_start);
>>> - assert(memblock.reserved.cnt == 2);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 2);
>>> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -506,6 +571,8 @@ static int alloc_bottom_up_before_check(void)
>>> struct memblock_region *rgn = &memblock.reserved.regions[0];
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t r1_size = SZ_512;
>>> phys_addr_t r2_size = SZ_128;
>>> phys_addr_t total_size = r1_size + r2_size;
>>> @@ -516,12 +583,15 @@ static int alloc_bottom_up_before_check(void)
>>> allocated_ptr = memblock_alloc(r1_size, SMP_CACHE_BYTES);
>>> - assert(allocated_ptr);
>>> - assert(rgn->size == total_size);
>>> - assert(rgn->base == memblock_start_of_DRAM());
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(rgn->size, total_size);
>>> + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -542,6 +612,8 @@ static int alloc_bottom_up_after_check(void)
>>> struct region r1;
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t r2_size = SZ_512;
>>> phys_addr_t total_size;
>>> @@ -559,12 +631,15 @@ static int alloc_bottom_up_after_check(void)
>>> allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
>>> - assert(allocated_ptr);
>>> - assert(rgn->size == total_size);
>>> - assert(rgn->base == r1.base);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(rgn->size, total_size);
>>> + ASSERT_EQ(rgn->base, r1.base);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -588,6 +663,8 @@ static int alloc_bottom_up_second_fit_check(void)
>>> struct region r1, r2;
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t r3_size = SZ_1K;
>>> phys_addr_t total_size;
>>> @@ -606,12 +683,15 @@ static int alloc_bottom_up_second_fit_check(void)
>>> allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
>>> - assert(allocated_ptr);
>>> - assert(rgn->size == r2.size + r3_size);
>>> - assert(rgn->base == r2.base);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(rgn->size, r2.size + r3_size);
>>> + ASSERT_EQ(rgn->base, r2.base);
>>> - assert(memblock.reserved.cnt == 2);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 2);
>>> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -619,6 +699,7 @@ static int alloc_bottom_up_second_fit_check(void)
>>> /* Test case wrappers */
>>> static int alloc_simple_check(void)
>>> {
>>> + test_print("\tRunning %s...\n", __func__);
>>> memblock_set_bottom_up(false);
>>> alloc_top_down_simple_check();
>>> memblock_set_bottom_up(true);
>>> @@ -629,6 +710,7 @@ static int alloc_simple_check(void)
>>> static int alloc_disjoint_check(void)
>>> {
>>> + test_print("\tRunning %s...\n", __func__);
>>> memblock_set_bottom_up(false);
>>> alloc_top_down_disjoint_check();
>>> memblock_set_bottom_up(true);
>>> @@ -639,6 +721,7 @@ static int alloc_disjoint_check(void)
>>> static int alloc_before_check(void)
>>> {
>>> + test_print("\tRunning %s...\n", __func__);
>>> memblock_set_bottom_up(false);
>>> alloc_top_down_before_check();
>>> memblock_set_bottom_up(true);
>>> @@ -649,6 +732,7 @@ static int alloc_before_check(void)
>>> static int alloc_after_check(void)
>>> {
>>> + test_print("\tRunning %s...\n", __func__);
>>> memblock_set_bottom_up(false);
>>> alloc_top_down_after_check();
>>> memblock_set_bottom_up(true);
>>> @@ -659,6 +743,7 @@ 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);
>>> @@ -669,6 +754,7 @@ static int alloc_in_between_check(void)
>>> static int alloc_second_fit_check(void)
>>> {
>>> + test_print("\tRunning %s...\n", __func__);
>>> memblock_set_bottom_up(false);
>>> alloc_top_down_second_fit_check();
>>> memblock_set_bottom_up(true);
>>> @@ -679,6 +765,7 @@ 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);
>>> @@ -689,6 +776,7 @@ 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);
>>> @@ -699,6 +787,7 @@ 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);
>>> @@ -709,6 +798,7 @@ 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);
>>> @@ -719,6 +809,7 @@ 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);
>>> @@ -729,6 +820,12 @@ static int alloc_no_memory_check(void)
>>> int memblock_alloc_checks(void)
>>> {
>>> + static const char func_testing[] = "memblock_alloc";
>>> +
>>> + prefix_reset();
>>> + prefix_push(func_testing);
>>> + test_print("Running %s tests...\n", func_testing);
>>> +
>>> reset_memblock_attributes();
>>> dummy_physical_memory_init();
>>> @@ -746,5 +843,7 @@ int memblock_alloc_checks(void)
>>> dummy_physical_memory_cleanup();
>>> + prefix_pop();
>>> +
>>> return 0;
>>> }
>>> diff --git a/tools/testing/memblock/tests/alloc_helpers_api.c b/tools/testing/memblock/tests/alloc_helpers_api.c
>>> index 963a966db461..f6eaed540427 100644
>>> --- a/tools/testing/memblock/tests/alloc_helpers_api.c
>>> +++ b/tools/testing/memblock/tests/alloc_helpers_api.c
>>> @@ -21,6 +21,8 @@ static int alloc_from_simple_generic_check(void)
>>> void *allocated_ptr = NULL;
>>> char *b;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t size = SZ_16;
>>> phys_addr_t min_addr;
>>> @@ -31,14 +33,17 @@ static int alloc_from_simple_generic_check(void)
>>> allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
>>> b = (char *)allocated_ptr;
>>> - assert(allocated_ptr);
>>> - assert(*b == 0);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(*b, 0);
>>> +
>>> + ASSERT_EQ(rgn->size, size);
>>> + ASSERT_EQ(rgn->base, min_addr);
>>> - assert(rgn->size == size);
>>> - assert(rgn->base == min_addr);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -64,6 +69,8 @@ static int alloc_from_misaligned_generic_check(void)
>>> void *allocated_ptr = NULL;
>>> char *b;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t size = SZ_32;
>>> phys_addr_t min_addr;
>>> @@ -75,14 +82,17 @@ static int alloc_from_misaligned_generic_check(void)
>>> allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
>>> b = (char *)allocated_ptr;
>>> - assert(allocated_ptr);
>>> - assert(*b == 0);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(*b, 0);
>>> - assert(rgn->size == size);
>>> - assert(rgn->base == memblock_end_of_DRAM() - SMP_CACHE_BYTES);
>>> + ASSERT_EQ(rgn->size, size);
>>> + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - SMP_CACHE_BYTES);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -110,6 +120,8 @@ static int alloc_from_top_down_high_addr_check(void)
>>> struct memblock_region *rgn = &memblock.reserved.regions[0];
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t size = SZ_32;
>>> phys_addr_t min_addr;
>>> @@ -120,12 +132,15 @@ static int alloc_from_top_down_high_addr_check(void)
>>> allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
>>> - assert(allocated_ptr);
>>> - assert(rgn->size == size);
>>> - assert(rgn->base == memblock_end_of_DRAM() - SMP_CACHE_BYTES);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(rgn->size, size);
>>> + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - SMP_CACHE_BYTES);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -151,6 +166,8 @@ static int alloc_from_top_down_no_space_above_check(void)
>>> struct memblock_region *rgn = &memblock.reserved.regions[0];
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t r1_size = SZ_64;
>>> phys_addr_t r2_size = SZ_2;
>>> phys_addr_t total_size = r1_size + r2_size;
>>> @@ -165,12 +182,15 @@ static int alloc_from_top_down_no_space_above_check(void)
>>> allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
>>> - assert(allocated_ptr);
>>> - assert(rgn->base == min_addr - r1_size);
>>> - assert(rgn->size == total_size);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(rgn->base, min_addr - r1_size);
>>> + ASSERT_EQ(rgn->size, total_size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -186,6 +206,8 @@ static int alloc_from_top_down_min_addr_cap_check(void)
>>> struct memblock_region *rgn = &memblock.reserved.regions[0];
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t r1_size = SZ_64;
>>> phys_addr_t min_addr;
>>> phys_addr_t start_addr;
>>> @@ -199,12 +221,15 @@ static int alloc_from_top_down_min_addr_cap_check(void)
>>> allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
>>> - assert(allocated_ptr);
>>> - assert(rgn->base == start_addr);
>>> - assert(rgn->size == MEM_SIZE);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(rgn->base, start_addr);
>>> + ASSERT_EQ(rgn->size, MEM_SIZE);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == MEM_SIZE);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, MEM_SIZE);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -230,6 +255,8 @@ static int alloc_from_bottom_up_high_addr_check(void)
>>> struct memblock_region *rgn = &memblock.reserved.regions[0];
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t size = SZ_32;
>>> phys_addr_t min_addr;
>>> @@ -240,12 +267,15 @@ static int alloc_from_bottom_up_high_addr_check(void)
>>> allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
>>> - assert(allocated_ptr);
>>> - assert(rgn->size == size);
>>> - assert(rgn->base == memblock_start_of_DRAM());
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(rgn->size, size);
>>> + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
>>> +
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -270,6 +300,8 @@ static int alloc_from_bottom_up_no_space_above_check(void)
>>> struct memblock_region *rgn = &memblock.reserved.regions[0];
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t r1_size = SZ_64;
>>> phys_addr_t min_addr;
>>> phys_addr_t r2_size;
>>> @@ -284,12 +316,15 @@ static int alloc_from_bottom_up_no_space_above_check(void)
>>> allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
>>> - assert(allocated_ptr);
>>> - assert(rgn->base == memblock_start_of_DRAM());
>>> - assert(rgn->size == r1_size);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
>>> + ASSERT_EQ(rgn->size, r1_size);
>>> +
>>> + ASSERT_EQ(memblock.reserved.cnt, 2);
>>> + ASSERT_EQ(memblock.reserved.total_size, r1_size + r2_size);
>>> - assert(memblock.reserved.cnt == 2);
>>> - assert(memblock.reserved.total_size == r1_size + r2_size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -304,6 +339,8 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
>>> struct memblock_region *rgn = &memblock.reserved.regions[0];
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t r1_size = SZ_64;
>>> phys_addr_t min_addr;
>>> phys_addr_t start_addr;
>>> @@ -315,12 +352,15 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
>>> allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
>>> - assert(allocated_ptr);
>>> - assert(rgn->base == start_addr);
>>> - assert(rgn->size == r1_size);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(rgn->base, start_addr);
>>> + ASSERT_EQ(rgn->size, r1_size);
>>> +
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, r1_size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == r1_size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -328,6 +368,7 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
>>> /* Test case wrappers */
>>> 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);
>>> @@ -338,6 +379,7 @@ 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);
>>> @@ -348,6 +390,7 @@ static int alloc_from_misaligned_check(void)
>>> static int alloc_from_high_addr_check(void)
>>> {
>>> + test_print("\tRunning %s...\n", __func__);
>>> memblock_set_bottom_up(false);
>>> alloc_from_top_down_high_addr_check();
>>> memblock_set_bottom_up(true);
>>> @@ -358,6 +401,7 @@ static int alloc_from_high_addr_check(void)
>>> static int alloc_from_no_space_above_check(void)
>>> {
>>> + test_print("\tRunning %s...\n", __func__);
>>> memblock_set_bottom_up(false);
>>> alloc_from_top_down_no_space_above_check();
>>> memblock_set_bottom_up(true);
>>> @@ -368,6 +412,7 @@ static int alloc_from_no_space_above_check(void)
>>> static int alloc_from_min_addr_cap_check(void)
>>> {
>>> + test_print("\tRunning %s...\n", __func__);
>>> memblock_set_bottom_up(false);
>>> alloc_from_top_down_min_addr_cap_check();
>>> memblock_set_bottom_up(true);
>>> @@ -378,6 +423,12 @@ static int alloc_from_min_addr_cap_check(void)
>>> int memblock_alloc_helpers_checks(void)
>>> {
>>> + static const char func_testing[] = "memblock_alloc_from";
>>> +
>>> + prefix_reset();
>>> + prefix_push(func_testing);
>>> + test_print("Running %s tests...\n", func_testing);
>>> +
>>> reset_memblock_attributes();
>>> dummy_physical_memory_init();
>>> diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
>>> index 6390206e50e1..601f4a7ee30d 100644
>>> --- a/tools/testing/memblock/tests/alloc_nid_api.c
>>> +++ b/tools/testing/memblock/tests/alloc_nid_api.c
>>> @@ -21,6 +21,8 @@ static int alloc_try_nid_top_down_simple_check(void)
>>> void *allocated_ptr = NULL;
>>> char *b;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t size = SZ_128;
>>> phys_addr_t min_addr;
>>> phys_addr_t max_addr;
>>> @@ -36,15 +38,18 @@ static int alloc_try_nid_top_down_simple_check(void)
>>> b = (char *)allocated_ptr;
>>> rgn_end = rgn->base + rgn->size;
>>> - assert(allocated_ptr);
>>> - assert(*b == 0);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(*b, 0);
>>> +
>>> + ASSERT_EQ(rgn->size, size);
>>> + ASSERT_EQ(rgn->base, max_addr - size);
>>> + ASSERT_EQ(rgn_end, max_addr);
>>> - assert(rgn->size == size);
>>> - assert(rgn->base == max_addr - size);
>>> - assert(rgn_end == max_addr);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -72,6 +77,8 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
>>> void *allocated_ptr = NULL;
>>> char *b;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t size = SZ_128;
>>> phys_addr_t misalign = SZ_2;
>>> phys_addr_t min_addr;
>>> @@ -88,15 +95,18 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
>>> b = (char *)allocated_ptr;
>>> rgn_end = rgn->base + rgn->size;
>>> - assert(allocated_ptr);
>>> - assert(*b == 0);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(*b, 0);
>>> - assert(rgn->size == size);
>>> - assert(rgn->base == max_addr - size - misalign);
>>> - assert(rgn_end < max_addr);
>>> + ASSERT_EQ(rgn->size, size);
>>> + ASSERT_EQ(rgn->base, max_addr - size - misalign);
>>> + ASSERT_LT(rgn_end, max_addr);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -122,6 +132,8 @@ static int alloc_try_nid_exact_address_generic_check(void)
>>> void *allocated_ptr = NULL;
>>> char *b;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t size = SZ_1K;
>>> phys_addr_t min_addr;
>>> phys_addr_t max_addr;
>>> @@ -137,15 +149,18 @@ static int alloc_try_nid_exact_address_generic_check(void)
>>> b = (char *)allocated_ptr;
>>> rgn_end = rgn->base + rgn->size;
>>> - assert(allocated_ptr);
>>> - assert(*b == 0);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(*b, 0);
>>> +
>>> + ASSERT_EQ(rgn->size, size);
>>> + ASSERT_EQ(rgn->base, min_addr);
>>> + ASSERT_EQ(rgn_end, max_addr);
>>> - assert(rgn->size == size);
>>> - assert(rgn->base == min_addr);
>>> - assert(rgn_end == max_addr);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -173,6 +188,8 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
>>> void *allocated_ptr = NULL;
>>> char *b;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t size = SZ_256;
>>> phys_addr_t min_addr;
>>> phys_addr_t max_addr;
>>> @@ -186,14 +203,17 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
>>> min_addr, max_addr, NUMA_NO_NODE);
>>> b = (char *)allocated_ptr;
>>> - assert(allocated_ptr);
>>> - assert(*b == 0);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(*b, 0);
>>> +
>>> + ASSERT_EQ(rgn->size, size);
>>> + ASSERT_EQ(rgn->base, max_addr - size);
>>> - assert(rgn->size == size);
>>> - assert(rgn->base == max_addr - size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -222,6 +242,8 @@ static int alloc_try_nid_low_max_generic_check(void)
>>> {
>>> void *allocated_ptr = NULL;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t size = SZ_1K;
>>> phys_addr_t min_addr;
>>> phys_addr_t max_addr;
>>> @@ -234,7 +256,10 @@ static int alloc_try_nid_low_max_generic_check(void)
>>> allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
>>> min_addr, max_addr, NUMA_NO_NODE);
>>> - assert(!allocated_ptr);
>>> + ASSERT_EQ(allocated_ptr, NULL);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -259,6 +284,8 @@ static int alloc_try_nid_min_reserved_generic_check(void)
>>> void *allocated_ptr = NULL;
>>> char *b;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t r1_size = SZ_128;
>>> phys_addr_t r2_size = SZ_64;
>>> phys_addr_t total_size = r1_size + r2_size;
>>> @@ -278,14 +305,17 @@ static int alloc_try_nid_min_reserved_generic_check(void)
>>> min_addr, max_addr, NUMA_NO_NODE);
>>> b = (char *)allocated_ptr;
>>> - assert(allocated_ptr);
>>> - assert(*b == 0);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(*b, 0);
>>> - assert(rgn->size == total_size);
>>> - assert(rgn->base == reserved_base);
>>> + ASSERT_EQ(rgn->size, total_size);
>>> + ASSERT_EQ(rgn->base, reserved_base);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -310,6 +340,8 @@ static int alloc_try_nid_max_reserved_generic_check(void)
>>> void *allocated_ptr = NULL;
>>> char *b;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t r1_size = SZ_64;
>>> phys_addr_t r2_size = SZ_128;
>>> phys_addr_t total_size = r1_size + r2_size;
>>> @@ -327,14 +359,17 @@ static int alloc_try_nid_max_reserved_generic_check(void)
>>> min_addr, max_addr, NUMA_NO_NODE);
>>> b = (char *)allocated_ptr;
>>> - assert(allocated_ptr);
>>> - assert(*b == 0);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(*b, 0);
>>> +
>>> + ASSERT_EQ(rgn->size, total_size);
>>> + ASSERT_EQ(rgn->base, min_addr);
>>> - assert(rgn->size == total_size);
>>> - assert(rgn->base == min_addr);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -364,6 +399,8 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
>>> char *b;
>>> struct region r1, r2;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t r3_size = SZ_64;
>>> phys_addr_t gap_size = SMP_CACHE_BYTES;
>>> phys_addr_t total_size;
>>> @@ -389,17 +426,20 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
>>> min_addr, max_addr, NUMA_NO_NODE);
>>> b = (char *)allocated_ptr;
>>> - assert(allocated_ptr);
>>> - assert(*b == 0);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(*b, 0);
>>> +
>>> + ASSERT_EQ(rgn1->size, r1.size + r3_size);
>>> + ASSERT_EQ(rgn1->base, max_addr - r3_size);
>>> - assert(rgn1->size == r1.size + r3_size);
>>> - assert(rgn1->base == max_addr - r3_size);
>>> + ASSERT_EQ(rgn2->size, r2.size);
>>> + ASSERT_EQ(rgn2->base, r2.base);
>>> - assert(rgn2->size == r2.size);
>>> - assert(rgn2->base == r2.base);
>>> + ASSERT_EQ(memblock.reserved.cnt, 2);
>>> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>>> - assert(memblock.reserved.cnt == 2);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -427,6 +467,8 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
>>> char *b;
>>> struct region r1, r2;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t r3_size = SZ_64;
>>> phys_addr_t total_size;
>>> phys_addr_t max_addr;
>>> @@ -451,14 +493,17 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
>>> min_addr, max_addr, NUMA_NO_NODE);
>>> b = (char *)allocated_ptr;
>>> - assert(allocated_ptr);
>>> - assert(*b == 0);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(*b, 0);
>>> - assert(rgn->size == total_size);
>>> - assert(rgn->base == r2.base);
>>> + ASSERT_EQ(rgn->size, total_size);
>>> + ASSERT_EQ(rgn->base, r2.base);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -489,6 +534,8 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
>>> char *b;
>>> struct region r1, r2;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t r3_size = SZ_256;
>>> phys_addr_t gap_size = SMP_CACHE_BYTES;
>>> phys_addr_t total_size;
>>> @@ -514,17 +561,20 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
>>> min_addr, max_addr, NUMA_NO_NODE);
>>> b = (char *)allocated_ptr;
>>> - assert(allocated_ptr);
>>> - assert(*b == 0);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(*b, 0);
>>> +
>>> + ASSERT_EQ(rgn1->size, r1.size);
>>> + ASSERT_EQ(rgn1->base, r1.base);
>>> - assert(rgn1->size == r1.size);
>>> - assert(rgn1->base == r1.base);
>>> + ASSERT_EQ(rgn2->size, r2.size + r3_size);
>>> + ASSERT_EQ(rgn2->base, r2.base - r3_size);
>>> - assert(rgn2->size == r2.size + r3_size);
>>> - assert(rgn2->base == r2.base - r3_size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 2);
>>> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>>> - assert(memblock.reserved.cnt == 2);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -554,6 +604,8 @@ static int alloc_try_nid_reserved_all_generic_check(void)
>>> void *allocated_ptr = NULL;
>>> struct region r1, r2;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t r3_size = SZ_256;
>>> phys_addr_t gap_size = SMP_CACHE_BYTES;
>>> phys_addr_t max_addr;
>>> @@ -576,7 +628,10 @@ static int alloc_try_nid_reserved_all_generic_check(void)
>>> allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
>>> min_addr, max_addr, NUMA_NO_NODE);
>>> - assert(!allocated_ptr);
>>> + ASSERT_EQ(allocated_ptr, NULL);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -592,6 +647,8 @@ static int alloc_try_nid_top_down_cap_max_check(void)
>>> void *allocated_ptr = NULL;
>>> char *b;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t size = SZ_256;
>>> phys_addr_t min_addr;
>>> phys_addr_t max_addr;
>>> @@ -605,14 +662,17 @@ static int alloc_try_nid_top_down_cap_max_check(void)
>>> min_addr, max_addr, NUMA_NO_NODE);
>>> b = (char *)allocated_ptr;
>>> - assert(allocated_ptr);
>>> - assert(*b == 0);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(*b, 0);
>>> +
>>> + ASSERT_EQ(rgn->size, size);
>>> + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
>>> - assert(rgn->size == size);
>>> - assert(rgn->base == memblock_end_of_DRAM() - size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -628,6 +688,8 @@ static int alloc_try_nid_top_down_cap_min_check(void)
>>> void *allocated_ptr = NULL;
>>> char *b;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t size = SZ_1K;
>>> phys_addr_t min_addr;
>>> phys_addr_t max_addr;
>>> @@ -641,14 +703,17 @@ static int alloc_try_nid_top_down_cap_min_check(void)
>>> min_addr, max_addr, NUMA_NO_NODE);
>>> b = (char *)allocated_ptr;
>>> - assert(allocated_ptr);
>>> - assert(*b == 0);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(*b, 0);
>>> - assert(rgn->size == size);
>>> - assert(rgn->base == memblock_end_of_DRAM() - size);
>>> + ASSERT_EQ(rgn->size, size);
>>> + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -673,6 +738,8 @@ static int alloc_try_nid_bottom_up_simple_check(void)
>>> void *allocated_ptr = NULL;
>>> char *b;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t size = SZ_128;
>>> phys_addr_t min_addr;
>>> phys_addr_t max_addr;
>>> @@ -689,15 +756,18 @@ static int alloc_try_nid_bottom_up_simple_check(void)
>>> b = (char *)allocated_ptr;
>>> rgn_end = rgn->base + rgn->size;
>>> - assert(allocated_ptr);
>>> - assert(*b == 0);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(*b, 0);
>>> +
>>> + ASSERT_EQ(rgn->size, size);
>>> + ASSERT_EQ(rgn->base, min_addr);
>>> + ASSERT_LT(rgn_end, max_addr);
>>> - assert(rgn->size == size);
>>> - assert(rgn->base == min_addr);
>>> - assert(rgn_end < max_addr);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -725,6 +795,8 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
>>> void *allocated_ptr = NULL;
>>> char *b;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t size = SZ_128;
>>> phys_addr_t misalign = SZ_2;
>>> phys_addr_t min_addr;
>>> @@ -742,15 +814,18 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
>>> b = (char *)allocated_ptr;
>>> rgn_end = rgn->base + rgn->size;
>>> - assert(allocated_ptr);
>>> - assert(*b == 0);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(*b, 0);
>>> +
>>> + ASSERT_EQ(rgn->size, size);
>>> + ASSERT_EQ(rgn->base, min_addr + (SMP_CACHE_BYTES - misalign));
>>> + ASSERT_LT(rgn_end, max_addr);
>>> - assert(rgn->size == size);
>>> - assert(rgn->base == min_addr + (SMP_CACHE_BYTES - misalign));
>>> - assert(rgn_end < max_addr);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -778,6 +853,8 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
>>> void *allocated_ptr = NULL;
>>> char *b;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t size = SZ_256;
>>> phys_addr_t min_addr;
>>> phys_addr_t max_addr;
>>> @@ -792,14 +869,17 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
>>> NUMA_NO_NODE);
>>> b = (char *)allocated_ptr;
>>> - assert(allocated_ptr);
>>> - assert(*b == 0);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(*b, 0);
>>> - assert(rgn->size == size);
>>> - assert(rgn->base == memblock_start_of_DRAM());
>>> + ASSERT_EQ(rgn->size, size);
>>> + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -829,6 +909,8 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
>>> char *b;
>>> struct region r1, r2;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t r3_size = SZ_64;
>>> phys_addr_t gap_size = SMP_CACHE_BYTES;
>>> phys_addr_t total_size;
>>> @@ -855,17 +937,20 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
>>> NUMA_NO_NODE);
>>> b = (char *)allocated_ptr;
>>> - assert(allocated_ptr);
>>> - assert(*b == 0);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(*b, 0);
>>> - assert(rgn1->size == r1.size);
>>> - assert(rgn1->base == max_addr);
>>> + ASSERT_EQ(rgn1->size, r1.size);
>>> + ASSERT_EQ(rgn1->base, max_addr);
>>> - assert(rgn2->size == r2.size + r3_size);
>>> - assert(rgn2->base == r2.base);
>>> + ASSERT_EQ(rgn2->size, r2.size + r3_size);
>>> + ASSERT_EQ(rgn2->base, r2.base);
>>> - assert(memblock.reserved.cnt == 2);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 2);
>>> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -899,6 +984,8 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
>>> char *b;
>>> struct region r1, r2;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t r3_size = SZ_256;
>>> phys_addr_t gap_size = SMP_CACHE_BYTES;
>>> phys_addr_t total_size;
>>> @@ -925,20 +1012,23 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
>>> NUMA_NO_NODE);
>>> b = (char *)allocated_ptr;
>>> - assert(allocated_ptr);
>>> - assert(*b == 0);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(*b, 0);
>>> +
>>> + ASSERT_EQ(rgn3->size, r3_size);
>>> + ASSERT_EQ(rgn3->base, memblock_start_of_DRAM());
>>> - assert(rgn3->size == r3_size);
>>> - assert(rgn3->base == memblock_start_of_DRAM());
>>> + ASSERT_EQ(rgn2->size, r2.size);
>>> + ASSERT_EQ(rgn2->base, r2.base);
>>> - assert(rgn2->size == r2.size);
>>> - assert(rgn2->base == r2.base);
>>> + ASSERT_EQ(rgn1->size, r1.size);
>>> + ASSERT_EQ(rgn1->base, r1.base);
>>> - assert(rgn1->size == r1.size);
>>> - assert(rgn1->base == r1.base);
>>> + ASSERT_EQ(memblock.reserved.cnt, 3);
>>> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>>> - assert(memblock.reserved.cnt == 3);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -954,6 +1044,8 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
>>> void *allocated_ptr = NULL;
>>> char *b;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t size = SZ_256;
>>> phys_addr_t min_addr;
>>> phys_addr_t max_addr;
>>> @@ -968,14 +1060,17 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
>>> NUMA_NO_NODE);
>>> b = (char *)allocated_ptr;
>>> - assert(allocated_ptr);
>>> - assert(*b == 0);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(*b, 0);
>>> +
>>> + ASSERT_EQ(rgn->size, size);
>>> + ASSERT_EQ(rgn->base, min_addr);
>>> - assert(rgn->size == size);
>>> - assert(rgn->base == min_addr);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -991,6 +1086,8 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
>>> void *allocated_ptr = NULL;
>>> char *b;
>>> + prefix_push(__func__);
>>> +
>>> phys_addr_t size = SZ_1K;
>>> phys_addr_t min_addr;
>>> phys_addr_t max_addr;
>>> @@ -1005,14 +1102,17 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
>>> NUMA_NO_NODE);
>>> b = (char *)allocated_ptr;
>>> - assert(allocated_ptr);
>>> - assert(*b == 0);
>>> + ASSERT_NE(allocated_ptr, NULL);
>>> + ASSERT_EQ(*b, 0);
>>> +
>>> + ASSERT_EQ(rgn->size, size);
>>> + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
>>> - assert(rgn->size == size);
>>> - assert(rgn->base == memblock_start_of_DRAM());
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -1020,6 +1120,7 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
>>> /* Test case wrappers */
>>> static int alloc_try_nid_simple_check(void)
>>> {
>>> + test_print("\tRunning %s...\n", __func__);
>>> memblock_set_bottom_up(false);
>>> alloc_try_nid_top_down_simple_check();
>>> memblock_set_bottom_up(true);
>>> @@ -1030,6 +1131,7 @@ static int alloc_try_nid_simple_check(void)
>>> static int alloc_try_nid_misaligned_check(void)
>>> {
>>> + test_print("\tRunning %s...\n", __func__);
>>> memblock_set_bottom_up(false);
>>> alloc_try_nid_top_down_end_misaligned_check();
>>> memblock_set_bottom_up(true);
>>> @@ -1040,6 +1142,7 @@ static int alloc_try_nid_misaligned_check(void)
>>> static int alloc_try_nid_narrow_range_check(void)
>>> {
>>> + test_print("\tRunning %s...\n", __func__);
>>> memblock_set_bottom_up(false);
>>> alloc_try_nid_top_down_narrow_range_check();
>>> memblock_set_bottom_up(true);
>>> @@ -1050,6 +1153,7 @@ static int alloc_try_nid_narrow_range_check(void)
>>> static int alloc_try_nid_reserved_with_space_check(void)
>>> {
>>> + test_print("\tRunning %s...\n", __func__);
>>> memblock_set_bottom_up(false);
>>> alloc_try_nid_top_down_reserved_with_space_check();
>>> memblock_set_bottom_up(true);
>>> @@ -1060,6 +1164,7 @@ static int alloc_try_nid_reserved_with_space_check(void)
>>> static int alloc_try_nid_reserved_no_space_check(void)
>>> {
>>> + test_print("\tRunning %s...\n", __func__);
>>> memblock_set_bottom_up(false);
>>> alloc_try_nid_top_down_reserved_no_space_check();
>>> memblock_set_bottom_up(true);
>>> @@ -1070,6 +1175,7 @@ static int alloc_try_nid_reserved_no_space_check(void)
>>> static int alloc_try_nid_cap_max_check(void)
>>> {
>>> + test_print("\tRunning %s...\n", __func__);
>>> memblock_set_bottom_up(false);
>>> alloc_try_nid_top_down_cap_max_check();
>>> memblock_set_bottom_up(true);
>>> @@ -1080,6 +1186,7 @@ static int alloc_try_nid_cap_max_check(void)
>>> static int alloc_try_nid_cap_min_check(void)
>>> {
>>> + test_print("\tRunning %s...\n", __func__);
>>> memblock_set_bottom_up(false);
>>> alloc_try_nid_top_down_cap_min_check();
>>> memblock_set_bottom_up(true);
>>> @@ -1090,6 +1197,7 @@ 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);
>>> @@ -1100,6 +1208,7 @@ 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);
>>> @@ -1110,6 +1219,7 @@ 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);
>>> @@ -1120,6 +1230,7 @@ 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);
>>> @@ -1130,6 +1241,7 @@ 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);
>>> @@ -1140,6 +1252,7 @@ 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);
>>> @@ -1150,6 +1263,12 @@ static int alloc_try_nid_low_max_check(void)
>>> int memblock_alloc_nid_checks(void)
>>> {
>>> + static const char func_testing[] = "memblock_alloc_try_nid";
>>> +
>>> + prefix_reset();
>>> + prefix_push(func_testing);
>>> + test_print("Running %s tests...\n", func_testing);
>>> +
>>> reset_memblock_attributes();
>>> dummy_physical_memory_init();
>>> @@ -1170,5 +1289,7 @@ int memblock_alloc_nid_checks(void)
>>> dummy_physical_memory_cleanup();
>>> + prefix_pop();
>>> +
>>> return 0;
>>> }
>>> diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c
>>> index a7bc180316d6..f223a9a57be7 100644
>>> --- a/tools/testing/memblock/tests/basic_api.c
>>> +++ b/tools/testing/memblock/tests/basic_api.c
>>> @@ -4,21 +4,30 @@
>>> #include "basic_api.h"
>>> #define EXPECTED_MEMBLOCK_REGIONS 128
>>> +#define FUNC_ADD "memblock_add"
>>> +#define FUNC_RESERVE "memblock_reserve"
>>> +#define FUNC_REMOVE "memblock_remove"
>>> +#define FUNC_FREE "memblock_free"
>>> static int memblock_initialization_check(void)
>>> {
>>> - assert(memblock.memory.regions);
>>> - assert(memblock.memory.cnt == 1);
>>> - assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
>>> - assert(strcmp(memblock.memory.name, "memory") == 0);
>>> + prefix_push(__func__);
>>> - assert(memblock.reserved.regions);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
>>> - assert(strcmp(memblock.reserved.name, "reserved") == 0);
>>> + ASSERT_NE(memblock.memory.regions, NULL);
>>> + ASSERT_EQ(memblock.memory.cnt, 1);
>>> + ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
>>> + ASSERT_EQ(strcmp(memblock.memory.name, "memory"), 0);
>>> - assert(!memblock.bottom_up);
>>> - assert(memblock.current_limit == MEMBLOCK_ALLOC_ANYWHERE);
>>> + ASSERT_NE(memblock.reserved.regions, NULL);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
>>> + ASSERT_EQ(strcmp(memblock.reserved.name, "reserved"), 0);
>>> +
>>> + ASSERT_EQ(memblock.bottom_up, false);
>>> + ASSERT_EQ(memblock.current_limit, MEMBLOCK_ALLOC_ANYWHERE);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -40,14 +49,19 @@ static int memblock_add_simple_check(void)
>>> .size = SZ_4M
>>> };
>>> + prefix_push(__func__);
>>> +
>>> reset_memblock_regions();
>>> memblock_add(r.base, r.size);
>>> - assert(rgn->base == r.base);
>>> - assert(rgn->size == r.size);
>>> + ASSERT_EQ(rgn->base, r.base);
>>> + ASSERT_EQ(rgn->size, r.size);
>>> +
>>> + ASSERT_EQ(memblock.memory.cnt, 1);
>>> + ASSERT_EQ(memblock.memory.total_size, r.size);
>>> - assert(memblock.memory.cnt == 1);
>>> - assert(memblock.memory.total_size == r.size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -69,18 +83,27 @@ static int memblock_add_node_simple_check(void)
>>> .size = SZ_16M
>>> };
>>> + prefix_pop();
>>> + prefix_push("memblock_add_node");
>>> + prefix_push(__func__);
>>> +
>>> reset_memblock_regions();
>>> memblock_add_node(r.base, r.size, 1, MEMBLOCK_HOTPLUG);
>>> - assert(rgn->base == r.base);
>>> - assert(rgn->size == r.size);
>>> + ASSERT_EQ(rgn->base, r.base);
>>> + ASSERT_EQ(rgn->size, r.size);
>>> #ifdef CONFIG_NUMA
>>> - assert(rgn->nid == 1);
>>> + ASSERT_EQ(rgn->nid, 1);
>>> #endif
>>> - assert(rgn->flags == MEMBLOCK_HOTPLUG);
>>> + ASSERT_EQ(rgn->flags, MEMBLOCK_HOTPLUG);
>>> +
>>> + ASSERT_EQ(memblock.memory.cnt, 1);
>>> + ASSERT_EQ(memblock.memory.total_size, r.size);
>>> - assert(memblock.memory.cnt == 1);
>>> - assert(memblock.memory.total_size == r.size);
>>> + test_pass();
>>> + prefix_pop();
>>> + prefix_pop();
>>> + prefix_push(FUNC_ADD);
>>> return 0;
>>> }
>>> @@ -113,18 +136,23 @@ static int memblock_add_disjoint_check(void)
>>> .size = SZ_8K
>>> };
>>> + prefix_push(__func__);
>>> +
>>> reset_memblock_regions();
>>> memblock_add(r1.base, r1.size);
>>> memblock_add(r2.base, r2.size);
>>> - assert(rgn1->base == r1.base);
>>> - assert(rgn1->size == r1.size);
>>> + 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(rgn2->base == r2.base);
>>> - assert(rgn2->size == r2.size);
>>> + ASSERT_EQ(memblock.memory.cnt, 2);
>>> + ASSERT_EQ(memblock.memory.total_size, r1.size + r2.size);
>>> - assert(memblock.memory.cnt == 2);
>>> - assert(memblock.memory.total_size == r1.size + r2.size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -162,17 +190,22 @@ static int memblock_add_overlap_top_check(void)
>>> .size = SZ_512M
>>> };
>>> + prefix_push(__func__);
>>> +
>>> total_size = (r1.base - r2.base) + r1.size;
>>> reset_memblock_regions();
>>> memblock_add(r1.base, r1.size);
>>> memblock_add(r2.base, r2.size);
>>> - assert(rgn->base == r2.base);
>>> - assert(rgn->size == total_size);
>>> + ASSERT_EQ(rgn->base, r2.base);
>>> + ASSERT_EQ(rgn->size, total_size);
>>> +
>>> + ASSERT_EQ(memblock.memory.cnt, 1);
>>> + ASSERT_EQ(memblock.memory.total_size, total_size);
>>> - assert(memblock.memory.cnt == 1);
>>> - assert(memblock.memory.total_size == total_size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -210,17 +243,22 @@ static int memblock_add_overlap_bottom_check(void)
>>> .size = SZ_1G
>>> };
>>> + prefix_push(__func__);
>>> +
>>> total_size = (r2.base - r1.base) + r2.size;
>>> reset_memblock_regions();
>>> memblock_add(r1.base, r1.size);
>>> memblock_add(r2.base, r2.size);
>>> - assert(rgn->base == r1.base);
>>> - assert(rgn->size == total_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);
>>> - assert(memblock.memory.cnt == 1);
>>> - assert(memblock.memory.total_size == total_size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -255,15 +293,20 @@ static int memblock_add_within_check(void)
>>> .size = SZ_1M
>>> };
>>> + prefix_push(__func__);
>>> +
>>> reset_memblock_regions();
>>> memblock_add(r1.base, r1.size);
>>> memblock_add(r2.base, r2.size);
>>> - assert(rgn->base == r1.base);
>>> - assert(rgn->size == r1.size);
>>> + ASSERT_EQ(rgn->base, r1.base);
>>> + ASSERT_EQ(rgn->size, r1.size);
>>> +
>>> + ASSERT_EQ(memblock.memory.cnt, 1);
>>> + ASSERT_EQ(memblock.memory.total_size, r1.size);
>>> - assert(memblock.memory.cnt == 1);
>>> - assert(memblock.memory.total_size == r1.size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -279,19 +322,28 @@ static int memblock_add_twice_check(void)
>>> .size = SZ_2M
>>> };
>>> + prefix_push(__func__);
>>> +
>>> reset_memblock_regions();
>>> memblock_add(r.base, r.size);
>>> memblock_add(r.base, r.size);
>>> - assert(memblock.memory.cnt == 1);
>>> - assert(memblock.memory.total_size == r.size);
>>> + ASSERT_EQ(memblock.memory.cnt, 1);
>>> + ASSERT_EQ(memblock.memory.total_size, r.size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> static int memblock_add_checks(void)
>>> {
>>> + prefix_reset();
>>> + prefix_push(FUNC_ADD);
>>> + test_print("Running %s tests...\n", FUNC_ADD);
>>> +
>>> memblock_add_simple_check();
>>> memblock_add_node_simple_check();
>>> memblock_add_disjoint_check();
>>> @@ -300,6 +352,8 @@ static int memblock_add_checks(void)
>>> memblock_add_within_check();
>>> memblock_add_twice_check();
>>> + prefix_pop();
>>> +
>>> return 0;
>>> }
>>> @@ -320,11 +374,16 @@ static int memblock_reserve_simple_check(void)
>>> .size = SZ_128M
>>> };
>>> + prefix_push(__func__);
>>> +
>>> reset_memblock_regions();
>>> memblock_reserve(r.base, r.size);
>>> - assert(rgn->base == r.base);
>>> - assert(rgn->size == r.size);
>>> + ASSERT_EQ(rgn->base, r.base);
>>> + ASSERT_EQ(rgn->size, r.size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -356,18 +415,23 @@ static int memblock_reserve_disjoint_check(void)
>>> .size = SZ_512M
>>> };
>>> + prefix_push(__func__);
>>> +
>>> reset_memblock_regions();
>>> memblock_reserve(r1.base, r1.size);
>>> memblock_reserve(r2.base, r2.size);
>>> - assert(rgn1->base == r1.base);
>>> - assert(rgn1->size == r1.size);
>>> + 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(rgn2->base == r2.base);
>>> - assert(rgn2->size == r2.size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 2);
>>> + ASSERT_EQ(memblock.reserved.total_size, r1.size + r2.size);
>>> - assert(memblock.reserved.cnt == 2);
>>> - assert(memblock.reserved.total_size == r1.size + r2.size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -406,17 +470,22 @@ static int memblock_reserve_overlap_top_check(void)
>>> .size = SZ_1G
>>> };
>>> + prefix_push(__func__);
>>> +
>>> total_size = (r1.base - r2.base) + r1.size;
>>> reset_memblock_regions();
>>> memblock_reserve(r1.base, r1.size);
>>> memblock_reserve(r2.base, r2.size);
>>> - assert(rgn->base == r2.base);
>>> - assert(rgn->size == total_size);
>>> + ASSERT_EQ(rgn->base, r2.base);
>>> + ASSERT_EQ(rgn->size, total_size);
>>> +
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -455,17 +524,22 @@ static int memblock_reserve_overlap_bottom_check(void)
>>> .size = SZ_128K
>>> };
>>> + prefix_push(__func__);
>>> +
>>> total_size = (r2.base - r1.base) + r2.size;
>>> reset_memblock_regions();
>>> memblock_reserve(r1.base, r1.size);
>>> memblock_reserve(r2.base, r2.size);
>>> - assert(rgn->base == r1.base);
>>> - assert(rgn->size == total_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);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -502,15 +576,20 @@ static int memblock_reserve_within_check(void)
>>> .size = SZ_64K
>>> };
>>> + prefix_push(__func__);
>>> +
>>> reset_memblock_regions();
>>> memblock_reserve(r1.base, r1.size);
>>> memblock_reserve(r2.base, r2.size);
>>> - assert(rgn->base == r1.base);
>>> - assert(rgn->size == r1.size);
>>> + ASSERT_EQ(rgn->base, r1.base);
>>> + ASSERT_EQ(rgn->size, r1.size);
>>> +
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, r1.size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == r1.size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -527,19 +606,28 @@ static int memblock_reserve_twice_check(void)
>>> .size = SZ_2M
>>> };
>>> + prefix_push(__func__);
>>> +
>>> reset_memblock_regions();
>>> memblock_reserve(r.base, r.size);
>>> memblock_reserve(r.base, r.size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == r.size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, r.size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> static int memblock_reserve_checks(void)
>>> {
>>> + prefix_reset();
>>> + prefix_push(FUNC_RESERVE);
>>> + test_print("Running %s tests...\n", FUNC_RESERVE);
>>> +
>>> memblock_reserve_simple_check();
>>> memblock_reserve_disjoint_check();
>>> memblock_reserve_overlap_top_check();
>>> @@ -547,6 +635,8 @@ static int memblock_reserve_checks(void)
>>> memblock_reserve_within_check();
>>> memblock_reserve_twice_check();
>>> + prefix_pop();
>>> +
>>> return 0;
>>> }
>>> @@ -581,16 +671,21 @@ static int memblock_remove_simple_check(void)
>>> .size = SZ_4M
>>> };
>>> + prefix_push(__func__);
>>> +
>>> reset_memblock_regions();
>>> memblock_add(r1.base, r1.size);
>>> memblock_add(r2.base, r2.size);
>>> memblock_remove(r1.base, r1.size);
>>> - assert(rgn->base == r2.base);
>>> - assert(rgn->size == r2.size);
>>> + ASSERT_EQ(rgn->base, r2.base);
>>> + ASSERT_EQ(rgn->size, r2.size);
>>> - assert(memblock.memory.cnt == 1);
>>> - assert(memblock.memory.total_size == r2.size);
>>> + ASSERT_EQ(memblock.memory.cnt, 1);
>>> + ASSERT_EQ(memblock.memory.total_size, r2.size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -626,15 +721,20 @@ static int memblock_remove_absent_check(void)
>>> .size = SZ_1G
>>> };
>>> + prefix_push(__func__);
>>> +
>>> reset_memblock_regions();
>>> memblock_add(r1.base, r1.size);
>>> memblock_remove(r2.base, r2.size);
>>> - assert(rgn->base == r1.base);
>>> - assert(rgn->size == r1.size);
>>> + ASSERT_EQ(rgn->base, r1.base);
>>> + ASSERT_EQ(rgn->size, r1.size);
>>> +
>>> + ASSERT_EQ(memblock.memory.cnt, 1);
>>> + ASSERT_EQ(memblock.memory.total_size, r1.size);
>>> - assert(memblock.memory.cnt == 1);
>>> - assert(memblock.memory.total_size == r1.size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -674,6 +774,8 @@ static int memblock_remove_overlap_top_check(void)
>>> .size = SZ_32M
>>> };
>>> + prefix_push(__func__);
>>> +
>>> r1_end = r1.base + r1.size;
>>> r2_end = r2.base + r2.size;
>>> total_size = r1_end - r2_end;
>>> @@ -682,11 +784,14 @@ static int memblock_remove_overlap_top_check(void)
>>> memblock_add(r1.base, r1.size);
>>> memblock_remove(r2.base, r2.size);
>>> - assert(rgn->base == r1.base + r2.base);
>>> - assert(rgn->size == total_size);
>>> + ASSERT_EQ(rgn->base, r1.base + r2.base);
>>> + ASSERT_EQ(rgn->size, total_size);
>>> +
>>> + ASSERT_EQ(memblock.memory.cnt, 1);
>>> + ASSERT_EQ(memblock.memory.total_size, total_size);
>>> - assert(memblock.memory.cnt == 1);
>>> - assert(memblock.memory.total_size == total_size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -724,17 +829,23 @@ static int memblock_remove_overlap_bottom_check(void)
>>> .size = SZ_256M
>>> };
>>> + prefix_push(__func__);
>>> +
>>> total_size = r2.base - r1.base;
>>> reset_memblock_regions();
>>> memblock_add(r1.base, r1.size);
>>> memblock_remove(r2.base, r2.size);
>>> - assert(rgn->base == r1.base);
>>> - assert(rgn->size == total_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();
>>> + prefix_pop();
>>> - assert(memblock.memory.cnt == 1);
>>> - assert(memblock.memory.total_size == total_size);
>>> return 0;
>>> }
>>> @@ -774,6 +885,8 @@ static int memblock_remove_within_check(void)
>>> .size = SZ_1M
>>> };
>>> + prefix_push(__func__);
>>> +
>>> r1_size = r2.base - r1.base;
>>> r2_size = (r1.base + r1.size) - (r2.base + r2.size);
>>> total_size = r1_size + r2_size;
>>> @@ -782,26 +895,35 @@ static int memblock_remove_within_check(void)
>>> memblock_add(r1.base, r1.size);
>>> memblock_remove(r2.base, r2.size);
>>> - assert(rgn1->base == r1.base);
>>> - assert(rgn1->size == r1_size);
>>> + ASSERT_EQ(rgn1->base, r1.base);
>>> + ASSERT_EQ(rgn1->size, r1_size);
>>> +
>>> + ASSERT_EQ(rgn2->base, r2.base + r2.size);
>>> + ASSERT_EQ(rgn2->size, r2_size);
>>> - assert(rgn2->base == r2.base + r2.size);
>>> - assert(rgn2->size == r2_size);
>>> + ASSERT_EQ(memblock.memory.cnt, 2);
>>> + ASSERT_EQ(memblock.memory.total_size, total_size);
>>> - assert(memblock.memory.cnt == 2);
>>> - assert(memblock.memory.total_size == total_size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> static int memblock_remove_checks(void)
>>> {
>>> + prefix_reset();
>>> + prefix_push(FUNC_REMOVE);
>>> + test_print("Running %s tests...\n", FUNC_REMOVE);
>>> +
>>> memblock_remove_simple_check();
>>> memblock_remove_absent_check();
>>> memblock_remove_overlap_top_check();
>>> memblock_remove_overlap_bottom_check();
>>> memblock_remove_within_check();
>>> + prefix_pop();
>>> +
>>> return 0;
>>> }
>>> @@ -835,16 +957,21 @@ static int memblock_free_simple_check(void)
>>> .size = SZ_1M
>>> };
>>> + prefix_push(__func__);
>>> +
>>> reset_memblock_regions();
>>> memblock_reserve(r1.base, r1.size);
>>> memblock_reserve(r2.base, r2.size);
>>> memblock_free((void *)r1.base, r1.size);
>>> - assert(rgn->base == r2.base);
>>> - assert(rgn->size == r2.size);
>>> + ASSERT_EQ(rgn->base, r2.base);
>>> + ASSERT_EQ(rgn->size, r2.size);
>>> +
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, r2.size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == r2.size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -880,15 +1007,20 @@ static int memblock_free_absent_check(void)
>>> .size = SZ_128M
>>> };
>>> + prefix_push(__func__);
>>> +
>>> reset_memblock_regions();
>>> memblock_reserve(r1.base, r1.size);
>>> memblock_free((void *)r2.base, r2.size);
>>> - assert(rgn->base == r1.base);
>>> - assert(rgn->size == r1.size);
>>> + ASSERT_EQ(rgn->base, r1.base);
>>> + ASSERT_EQ(rgn->size, r1.size);
>>> +
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, r1.size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == r1.size);
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -928,17 +1060,22 @@ static int memblock_free_overlap_top_check(void)
>>> .size = SZ_8M
>>> };
>>> + prefix_push(__func__);
>>> +
>>> total_size = (r1.size + r1.base) - (r2.base + r2.size);
>>> reset_memblock_regions();
>>> memblock_reserve(r1.base, r1.size);
>>> memblock_free((void *)r2.base, r2.size);
>>> - assert(rgn->base == r2.base + r2.size);
>>> - assert(rgn->size == total_size);
>>> + ASSERT_EQ(rgn->base, r2.base + r2.size);
>>> + ASSERT_EQ(rgn->size, total_size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -973,17 +1110,22 @@ static int memblock_free_overlap_bottom_check(void)
>>> .size = SZ_32M
>>> };
>>> + prefix_push(__func__);
>>> +
>>> total_size = r2.base - r1.base;
>>> reset_memblock_regions();
>>> memblock_reserve(r1.base, r1.size);
>>> memblock_free((void *)r2.base, r2.size);
>>> - assert(rgn->base == r1.base);
>>> - assert(rgn->size == total_size);
>>> + ASSERT_EQ(rgn->base, r1.base);
>>> + ASSERT_EQ(rgn->size, total_size);
>>> - assert(memblock.reserved.cnt == 1);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 1);
>>> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> @@ -1024,6 +1166,8 @@ static int memblock_free_within_check(void)
>>> .size = SZ_1M
>>> };
>>> + prefix_push(__func__);
>>> +
>>> r1_size = r2.base - r1.base;
>>> r2_size = (r1.base + r1.size) - (r2.base + r2.size);
>>> total_size = r1_size + r2_size;
>>> @@ -1032,26 +1176,35 @@ static int memblock_free_within_check(void)
>>> memblock_reserve(r1.base, r1.size);
>>> memblock_free((void *)r2.base, r2.size);
>>> - assert(rgn1->base == r1.base);
>>> - assert(rgn1->size == r1_size);
>>> + ASSERT_EQ(rgn1->base, r1.base);
>>> + ASSERT_EQ(rgn1->size, r1_size);
>>> - assert(rgn2->base == r2.base + r2.size);
>>> - assert(rgn2->size == r2_size);
>>> + ASSERT_EQ(rgn2->base, r2.base + r2.size);
>>> + ASSERT_EQ(rgn2->size, r2_size);
>>> - assert(memblock.reserved.cnt == 2);
>>> - assert(memblock.reserved.total_size == total_size);
>>> + ASSERT_EQ(memblock.reserved.cnt, 2);
>>> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>>> +
>>> + test_pass();
>>> + prefix_pop();
>>> return 0;
>>> }
>>> static int memblock_free_checks(void)
>>> {
>>> + prefix_reset();
>>> + prefix_push(FUNC_FREE);
>>> + test_print("Running %s tests...\n", FUNC_FREE);
>>> +
>>> memblock_free_simple_check();
>>> memblock_free_absent_check();
>>> memblock_free_overlap_top_check();
>>> memblock_free_overlap_bottom_check();
>>> memblock_free_within_check();
>>> + prefix_pop();
>>> +
>>> return 0;
>>> }
>>> diff --git a/tools/testing/memblock/tests/common.c b/tools/testing/memblock/tests/common.c
>>> index 62d3191f7c9a..e55b2a8bf0ff 100644
>>> --- a/tools/testing/memblock/tests/common.c
>>> +++ b/tools/testing/memblock/tests/common.c
>>> @@ -4,8 +4,12 @@
>>> #define INIT_MEMBLOCK_REGIONS 128
>>> #define INIT_MEMBLOCK_RESERVED_REGIONS INIT_MEMBLOCK_REGIONS
>>> +#define PREFIXES_LEN_MAX 256
>>> +#define DELIM ": "
>>> +#define DELIM_LEN strlen(DELIM)
>>> static struct test_memory memory_block;
>>> +static char __maybe_unused prefixes[PREFIXES_LEN_MAX];
>>> void reset_memblock_regions(void)
>>> {
>>> @@ -46,3 +50,57 @@ void dummy_physical_memory_cleanup(void)
>>> {
>>> free(memory_block.base);
>>> }
>>> +
>>> +#ifdef VERBOSE
>>> +void test_fail(void)
>>> +{
>>> + ksft_test_result_fail(": %sfailed\n", prefixes);
>>> +}
>>> +
>>> +void test_pass(void)
>>> +{
>>> + ksft_test_result_pass(": %spassed\n", prefixes);
>>> +}
>>> +
>>> +void test_print(const char *fmt, ...)
>>> +{
>>> + int saved_errno = errno;
>>> + va_list args;
>>> +
>>> + va_start(args, fmt);
>>> + errno = saved_errno;
>>> + vprintf(fmt, args);
>>> + va_end(args);
>>> +}
>>> +
>>> +void prefix_reset(void)
>>> +{
>>> + memset(prefixes, 0, PREFIXES_LEN_MAX);
>>> +}
>>> +
>>> +void prefix_push(const char *prefix)
>>> +{
>>> + int prefix_max = PREFIXES_LEN_MAX - strlen(prefixes) - DELIM_LEN - 1;
>>> +
>>> + assert(strlen(prefix) <= prefix_max);
>>> + strncat(prefixes, prefix, prefix_max);
>>> + strncat(prefixes, DELIM, PREFIXES_LEN_MAX - strlen(prefixes) - 1);
>>> +}
>>> +
>>> +void prefix_pop(void)
>>> +{
>>> + char *ptr;
>>> +
>>> + ptr = strrchr(prefixes, DELIM[0]);
>>> + if (!ptr)
>>> + prefixes[0] = 0;
>>> + else
>>> + *(ptr) = 0;
>>> +
>>> + ptr = strrchr(prefixes, DELIM[0]);
>>> + if (!ptr)
>>> + prefixes[0] = 0;
>>> + else
>>> + *(ptr + DELIM_LEN) = 0;
>>> +}
>>> +#endif /* VERBOSE */
>>> diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h
>>> index 619054d03219..bdddb5f72871 100644
>>> --- a/tools/testing/memblock/tests/common.h
>>> +++ b/tools/testing/memblock/tests/common.h
>>> @@ -7,9 +7,47 @@
>>> #include <linux/types.h>
>>> #include <linux/memblock.h>
>>> #include <linux/sizes.h>
>>> +#include <linux/printk.h>
>>> +#include <../selftests/kselftest.h>
>>> #define MEM_SIZE SZ_16K
>>> +/**
>>> + * ASSERT_EQ():
>>> + * Check the condition
>>> + * @_expected == @_seen
>>> + * If false, print failed test message (if in VERBOSE mode) and then assert
>>> + */
>>> +#define ASSERT_EQ(_expected, _seen) do { \
>>> + if ((_expected) != (_seen)) \
>>> + test_fail(); \
>>> + assert((_expected) == (_seen)); \
>>> +} while (0)
>>> +
>>> +/**
>>> + * ASSERT_NE():
>>> + * Check the condition
>>> + * @_expected != @_seen
>>> + * If false, print failed test message (if in VERBOSE mode) and then assert
>>> + */
>>> +#define ASSERT_NE(_expected, _seen) do { \
>>> + if ((_expected) == (_seen)) \
>>> + test_fail(); \
>>> + assert((_expected) != (_seen)); \
>>> +} while (0)
>>> +
>>> +/**
>>> + * ASSERT_LT():
>>> + * Check the condition
>>> + * @_expected < @_seen
>>> + * If false, print failed test message (if in VERBOSE mode) and then assert
>>> + */
>>> +#define ASSERT_LT(_expected, _seen) do { \
>>> + if ((_expected) >= (_seen)) \
>>> + test_fail(); \
>>> + assert((_expected) < (_seen)); \
>>> +} while (0)
>>> +
>>> /*
>>> * Available memory registered with memblock needs to be valid for allocs
>>> * test to run. This is a convenience wrapper for memory allocated in
>>> @@ -31,4 +69,20 @@ void setup_memblock(void);
>>> void dummy_physical_memory_init(void);
>>> void dummy_physical_memory_cleanup(void);
>>> +#ifdef VERBOSE
>>> +void test_fail(void);
>>> +void test_pass(void);
>>> +void test_print(const char *fmt, ...);
>>> +void prefix_reset(void);
>>> +void prefix_push(const char *prefix);
>>> +void prefix_pop(void);
>>> +#else
>>> +static inline void test_fail(void) {}
>>> +static inline void test_pass(void) {}
>>> +static inline void test_print(const char *fmt, ...) {}
>>> +static inline void prefix_reset(void) {}
>>> +static inline void prefix_push(const char *prefix) {}
>>> +static inline void prefix_pop(void) {}
>>> +#endif /* VERBOSE */
>>> +
>>> #endif
>
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 2/4] memblock tests: add verbose output to memblock tests
2022-06-23 1:29 ` Huang, Shaoqin
@ 2022-06-23 3:10 ` Rebecca Mckeever
2022-06-23 4:05 ` Mike Rapoport
1 sibling, 0 replies; 31+ messages in thread
From: Rebecca Mckeever @ 2022-06-23 3:10 UTC (permalink / raw)
To: Huang, Shaoqin; +Cc: Mike Rapoport, linux-mm, linux-kernel, David Hildenbrand
On Thu, Jun 23, 2022 at 09:29:05AM +0800, Huang, Shaoqin wrote:
>
>
> On 6/23/2022 8:45 AM, Rebecca Mckeever wrote:
> > On Wed, Jun 22, 2022 at 06:32:04PM +0800, Huang, Shaoqin wrote:
> > > Just test it and everything works fine. And I think there are some thing can
> > > improve:
> > >
> > > The prefix_push() and prefix_pop() are used in so many functions and
> > > almost of them just put the prefix_push(__func__) begin in the head and the
> > > prefix_pop() in the end.
> > > May be you can define some macro that when you output something and
> > > automatically push the __func__ as prefix. And when leave the function,
> > > automatically pop it. And only in some special place, you call it manually.
> > >
> > Thank you for your review. I'm not sure how you would automatically push
> > __func__ since you have to be inside the function to access that
> > variable. Let me know if you have any suggestions. I am thinking about
> > adding another function in common.c that just calls test_pass() followed
> > by prefix_pop() since those are called together so often.
>
> Just like:
> #define test_pass_macro() \
> do { \
> prefix_push(__func__); \
> test_pass(); \
> prefix_pop(); \
> } while (0)
>
> This macro will automatically push the __fun__ as prefix when you call
> test_pass_macro(). And then pop it after test_pass() output.
>
Okay, that makes sense. I was calling prefix_push() at the beginning
because I was previously calling a testing function at the beginning of
the test, so I didn't think about moving it. I will implement your
suggestion. Thanks!
> And use this macro() to hidden most of the paired prefix_* functions.
>
> And I think that's the simplist way. May be someone has a better solution.
>
> > >
> > > On 6/22/2022 5:29 PM, Rebecca Mckeever wrote:
> > > > Add and use functions for printing verbose testing output.
> > > >
> > > > If the Memblock simulator was compiled with VERBOSE=1:
> > > > prefix_push() appends the given string to a prefix string that will be
> > > > printed in the test functions.
> > > > prefix_pop() removes the last prefix from the prefix string.
> > > > prefix_reset() clears the prefix string.
> > > > test_fail() prints a message after a test fails containing the test
> > > > number of the failing test and the prefix.
> > > > test_pass() prints a message after a test passes containing its test
> > > > number and the prefix.
> > > > test_print() prints the given formatted output string.
> > > >
> > >
> > > Comments like this is more clear, not just indent:
> > > - prefix_push(): appends ...
> > > - prefix_pop(): removes ...
> > >
> > That does look better, I'll update the commit text.
> >
> > > > If the Memblock simulator was not compiled with VERBOSE=1, these
> > > > functions do nothing.
> > > >
> > > > Add the assert wrapper macros ASSERT_EQ(), ASSERT_NE(), and ASSERT_LT().
> > > > If the assert condition fails, these macros call test_fail() before
> > > > executing assert().
> > > >
> > > > Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> > > > ---
> > > > tools/testing/memblock/tests/alloc_api.c | 241 ++++++++----
> > > > .../memblock/tests/alloc_helpers_api.c | 135 +++++--
> > > > tools/testing/memblock/tests/alloc_nid_api.c | 371 ++++++++++++------
> > > > tools/testing/memblock/tests/basic_api.c | 365 ++++++++++++-----
> > > > tools/testing/memblock/tests/common.c | 58 +++
> > > > tools/testing/memblock/tests/common.h | 54 +++
> > > > 6 files changed, 880 insertions(+), 344 deletions(-)
> > > >
> > > > diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
> > > > index d1aa7e15c18d..96df033d4300 100644
> > > > --- a/tools/testing/memblock/tests/alloc_api.c
> > > > +++ b/tools/testing/memblock/tests/alloc_api.c
> > > > @@ -10,6 +10,8 @@ static int alloc_top_down_simple_check(void)
> > > > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t size = SZ_2;
> > > > phys_addr_t expected_start;
> > > > @@ -19,12 +21,15 @@ static int alloc_top_down_simple_check(void)
> > > > allocated_ptr = memblock_alloc(size, SMP_CACHE_BYTES);
> > > > - assert(allocated_ptr);
> > > > - assert(rgn->size == size);
> > > > - assert(rgn->base == expected_start);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(rgn->size, size);
> > > > + ASSERT_EQ(rgn->base, expected_start);
> > > > +
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -55,6 +60,8 @@ static int alloc_top_down_disjoint_check(void)
> > > > struct region r1;
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t r2_size = SZ_16;
> > > > /* Use custom alignment */
> > > > phys_addr_t alignment = SMP_CACHE_BYTES * 2;
> > > > @@ -73,15 +80,18 @@ static int alloc_top_down_disjoint_check(void)
> > > > allocated_ptr = memblock_alloc(r2_size, alignment);
> > > > - assert(allocated_ptr);
> > > > - assert(rgn1->size == r1.size);
> > > > - assert(rgn1->base == r1.base);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(rgn1->size, r1.size);
> > > > + ASSERT_EQ(rgn1->base, r1.base);
> > > > - assert(rgn2->size == r2_size);
> > > > - assert(rgn2->base == expected_start);
> > > > + ASSERT_EQ(rgn2->size, r2_size);
> > > > + ASSERT_EQ(rgn2->base, expected_start);
> > > > - assert(memblock.reserved.cnt == 2);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > > > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -101,6 +111,8 @@ static int alloc_top_down_before_check(void)
> > > > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > /*
> > > > * The first region ends at the aligned address to test region merging
> > > > */
> > > > @@ -114,12 +126,15 @@ static int alloc_top_down_before_check(void)
> > > > allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
> > > > - assert(allocated_ptr);
> > > > - assert(rgn->size == total_size);
> > > > - assert(rgn->base == memblock_end_of_DRAM() - total_size);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(rgn->size, total_size);
> > > > + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - total_size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -141,6 +156,8 @@ static int alloc_top_down_after_check(void)
> > > > struct region r1;
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t r2_size = SZ_512;
> > > > phys_addr_t total_size;
> > > > @@ -158,12 +175,15 @@ static int alloc_top_down_after_check(void)
> > > > allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
> > > > - assert(allocated_ptr);
> > > > - assert(rgn->size == total_size);
> > > > - assert(rgn->base == r1.base - r2_size);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(rgn->size, total_size);
> > > > + ASSERT_EQ(rgn->base, r1.base - r2_size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -186,6 +206,8 @@ static int alloc_top_down_second_fit_check(void)
> > > > struct region r1, r2;
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t r3_size = SZ_1K;
> > > > phys_addr_t total_size;
> > > > @@ -204,12 +226,15 @@ static int alloc_top_down_second_fit_check(void)
> > > > allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
> > > > - assert(allocated_ptr);
> > > > - assert(rgn->size == r2.size + r3_size);
> > > > - assert(rgn->base == r2.base - r3_size);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(rgn->size, r2.size + r3_size);
> > > > + ASSERT_EQ(rgn->base, r2.base - r3_size);
> > > > - assert(memblock.reserved.cnt == 2);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > > > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -231,6 +256,8 @@ static int alloc_in_between_generic_check(void)
> > > > struct region r1, r2;
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t gap_size = SMP_CACHE_BYTES;
> > > > phys_addr_t r3_size = SZ_64;
> > > > /*
> > > > @@ -254,12 +281,15 @@ static int alloc_in_between_generic_check(void)
> > > > allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
> > > > - assert(allocated_ptr);
> > > > - assert(rgn->size == total_size);
> > > > - assert(rgn->base == r1.base - r2.size - r3_size);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(rgn->size, total_size);
> > > > + ASSERT_EQ(rgn->base, r1.base - r2.size - r3_size);
> > > > +
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -281,6 +311,8 @@ static int alloc_small_gaps_generic_check(void)
> > > > {
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t region_size = SZ_1K;
> > > > phys_addr_t gap_size = SZ_256;
> > > > phys_addr_t region_end;
> > > > @@ -296,7 +328,10 @@ static int alloc_small_gaps_generic_check(void)
> > > > allocated_ptr = memblock_alloc(region_size, SMP_CACHE_BYTES);
> > > > - assert(!allocated_ptr);
> > > > + ASSERT_EQ(allocated_ptr, NULL);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -309,6 +344,8 @@ static int alloc_all_reserved_generic_check(void)
> > > > {
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > setup_memblock();
> > > > /* Simulate full memory */
> > > > @@ -316,7 +353,10 @@ static int alloc_all_reserved_generic_check(void)
> > > > allocated_ptr = memblock_alloc(SZ_256, SMP_CACHE_BYTES);
> > > > - assert(!allocated_ptr);
> > > > + ASSERT_EQ(allocated_ptr, NULL);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -338,6 +378,8 @@ static int alloc_no_space_generic_check(void)
> > > > {
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > setup_memblock();
> > > > phys_addr_t available_size = SZ_256;
> > > > @@ -348,7 +390,10 @@ static int alloc_no_space_generic_check(void)
> > > > allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
> > > > - assert(!allocated_ptr);
> > > > + ASSERT_EQ(allocated_ptr, NULL);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -369,6 +414,8 @@ static int alloc_limited_space_generic_check(void)
> > > > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t available_size = SZ_256;
> > > > phys_addr_t reserved_size = MEM_SIZE - available_size;
> > > > @@ -379,12 +426,15 @@ static int alloc_limited_space_generic_check(void)
> > > > allocated_ptr = memblock_alloc(available_size, SMP_CACHE_BYTES);
> > > > - assert(allocated_ptr);
> > > > - assert(rgn->size == MEM_SIZE);
> > > > - assert(rgn->base == memblock_start_of_DRAM());
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(rgn->size, MEM_SIZE);
> > > > + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> > > > +
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, MEM_SIZE);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == MEM_SIZE);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -399,14 +449,19 @@ static int alloc_no_memory_generic_check(void)
> > > > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > reset_memblock_regions();
> > > > allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
> > > > - assert(!allocated_ptr);
> > > > - assert(rgn->size == 0);
> > > > - assert(rgn->base == 0);
> > > > - assert(memblock.reserved.total_size == 0);
> > > > + ASSERT_EQ(allocated_ptr, NULL);
> > > > + ASSERT_EQ(rgn->size, 0);
> > > > + ASSERT_EQ(rgn->base, 0);
> > > > + ASSERT_EQ(memblock.reserved.total_size, 0);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -421,16 +476,21 @@ static int alloc_bottom_up_simple_check(void)
> > > > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > setup_memblock();
> > > > allocated_ptr = memblock_alloc(SZ_2, SMP_CACHE_BYTES);
> > > > - assert(allocated_ptr);
> > > > - assert(rgn->size == SZ_2);
> > > > - assert(rgn->base == memblock_start_of_DRAM());
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(rgn->size, SZ_2);
> > > > + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == SZ_2);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, SZ_2);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -459,6 +519,8 @@ static int alloc_bottom_up_disjoint_check(void)
> > > > struct region r1;
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t r2_size = SZ_16;
> > > > /* Use custom alignment */
> > > > phys_addr_t alignment = SMP_CACHE_BYTES * 2;
> > > > @@ -477,16 +539,19 @@ static int alloc_bottom_up_disjoint_check(void)
> > > > allocated_ptr = memblock_alloc(r2_size, alignment);
> > > > - assert(allocated_ptr);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > - assert(rgn1->size == r1.size);
> > > > - assert(rgn1->base == r1.base);
> > > > + ASSERT_EQ(rgn1->size, r1.size);
> > > > + ASSERT_EQ(rgn1->base, r1.base);
> > > > - assert(rgn2->size == r2_size);
> > > > - assert(rgn2->base == expected_start);
> > > > + ASSERT_EQ(rgn2->size, r2_size);
> > > > + ASSERT_EQ(rgn2->base, expected_start);
> > > > - assert(memblock.reserved.cnt == 2);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > > > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -506,6 +571,8 @@ static int alloc_bottom_up_before_check(void)
> > > > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t r1_size = SZ_512;
> > > > phys_addr_t r2_size = SZ_128;
> > > > phys_addr_t total_size = r1_size + r2_size;
> > > > @@ -516,12 +583,15 @@ static int alloc_bottom_up_before_check(void)
> > > > allocated_ptr = memblock_alloc(r1_size, SMP_CACHE_BYTES);
> > > > - assert(allocated_ptr);
> > > > - assert(rgn->size == total_size);
> > > > - assert(rgn->base == memblock_start_of_DRAM());
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(rgn->size, total_size);
> > > > + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -542,6 +612,8 @@ static int alloc_bottom_up_after_check(void)
> > > > struct region r1;
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t r2_size = SZ_512;
> > > > phys_addr_t total_size;
> > > > @@ -559,12 +631,15 @@ static int alloc_bottom_up_after_check(void)
> > > > allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
> > > > - assert(allocated_ptr);
> > > > - assert(rgn->size == total_size);
> > > > - assert(rgn->base == r1.base);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(rgn->size, total_size);
> > > > + ASSERT_EQ(rgn->base, r1.base);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -588,6 +663,8 @@ static int alloc_bottom_up_second_fit_check(void)
> > > > struct region r1, r2;
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t r3_size = SZ_1K;
> > > > phys_addr_t total_size;
> > > > @@ -606,12 +683,15 @@ static int alloc_bottom_up_second_fit_check(void)
> > > > allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
> > > > - assert(allocated_ptr);
> > > > - assert(rgn->size == r2.size + r3_size);
> > > > - assert(rgn->base == r2.base);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(rgn->size, r2.size + r3_size);
> > > > + ASSERT_EQ(rgn->base, r2.base);
> > > > - assert(memblock.reserved.cnt == 2);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > > > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -619,6 +699,7 @@ static int alloc_bottom_up_second_fit_check(void)
> > > > /* Test case wrappers */
> > > > static int alloc_simple_check(void)
> > > > {
> > > > + test_print("\tRunning %s...\n", __func__);
> > > > memblock_set_bottom_up(false);
> > > > alloc_top_down_simple_check();
> > > > memblock_set_bottom_up(true);
> > > > @@ -629,6 +710,7 @@ static int alloc_simple_check(void)
> > > > static int alloc_disjoint_check(void)
> > > > {
> > > > + test_print("\tRunning %s...\n", __func__);
> > > > memblock_set_bottom_up(false);
> > > > alloc_top_down_disjoint_check();
> > > > memblock_set_bottom_up(true);
> > > > @@ -639,6 +721,7 @@ static int alloc_disjoint_check(void)
> > > > static int alloc_before_check(void)
> > > > {
> > > > + test_print("\tRunning %s...\n", __func__);
> > > > memblock_set_bottom_up(false);
> > > > alloc_top_down_before_check();
> > > > memblock_set_bottom_up(true);
> > > > @@ -649,6 +732,7 @@ static int alloc_before_check(void)
> > > > static int alloc_after_check(void)
> > > > {
> > > > + test_print("\tRunning %s...\n", __func__);
> > > > memblock_set_bottom_up(false);
> > > > alloc_top_down_after_check();
> > > > memblock_set_bottom_up(true);
> > > > @@ -659,6 +743,7 @@ 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);
> > > > @@ -669,6 +754,7 @@ static int alloc_in_between_check(void)
> > > > static int alloc_second_fit_check(void)
> > > > {
> > > > + test_print("\tRunning %s...\n", __func__);
> > > > memblock_set_bottom_up(false);
> > > > alloc_top_down_second_fit_check();
> > > > memblock_set_bottom_up(true);
> > > > @@ -679,6 +765,7 @@ 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);
> > > > @@ -689,6 +776,7 @@ 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);
> > > > @@ -699,6 +787,7 @@ 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);
> > > > @@ -709,6 +798,7 @@ 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);
> > > > @@ -719,6 +809,7 @@ 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);
> > > > @@ -729,6 +820,12 @@ static int alloc_no_memory_check(void)
> > > > int memblock_alloc_checks(void)
> > > > {
> > > > + static const char func_testing[] = "memblock_alloc";
> > > > +
> > > > + prefix_reset();
> > > > + prefix_push(func_testing);
> > > > + test_print("Running %s tests...\n", func_testing);
> > > > +
> > > > reset_memblock_attributes();
> > > > dummy_physical_memory_init();
> > > > @@ -746,5 +843,7 @@ int memblock_alloc_checks(void)
> > > > dummy_physical_memory_cleanup();
> > > > + prefix_pop();
> > > > +
> > > > return 0;
> > > > }
> > > > diff --git a/tools/testing/memblock/tests/alloc_helpers_api.c b/tools/testing/memblock/tests/alloc_helpers_api.c
> > > > index 963a966db461..f6eaed540427 100644
> > > > --- a/tools/testing/memblock/tests/alloc_helpers_api.c
> > > > +++ b/tools/testing/memblock/tests/alloc_helpers_api.c
> > > > @@ -21,6 +21,8 @@ static int alloc_from_simple_generic_check(void)
> > > > void *allocated_ptr = NULL;
> > > > char *b;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t size = SZ_16;
> > > > phys_addr_t min_addr;
> > > > @@ -31,14 +33,17 @@ static int alloc_from_simple_generic_check(void)
> > > > allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
> > > > b = (char *)allocated_ptr;
> > > > - assert(allocated_ptr);
> > > > - assert(*b == 0);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(*b, 0);
> > > > +
> > > > + ASSERT_EQ(rgn->size, size);
> > > > + ASSERT_EQ(rgn->base, min_addr);
> > > > - assert(rgn->size == size);
> > > > - assert(rgn->base == min_addr);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -64,6 +69,8 @@ static int alloc_from_misaligned_generic_check(void)
> > > > void *allocated_ptr = NULL;
> > > > char *b;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t size = SZ_32;
> > > > phys_addr_t min_addr;
> > > > @@ -75,14 +82,17 @@ static int alloc_from_misaligned_generic_check(void)
> > > > allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
> > > > b = (char *)allocated_ptr;
> > > > - assert(allocated_ptr);
> > > > - assert(*b == 0);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(*b, 0);
> > > > - assert(rgn->size == size);
> > > > - assert(rgn->base == memblock_end_of_DRAM() - SMP_CACHE_BYTES);
> > > > + ASSERT_EQ(rgn->size, size);
> > > > + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - SMP_CACHE_BYTES);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -110,6 +120,8 @@ static int alloc_from_top_down_high_addr_check(void)
> > > > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t size = SZ_32;
> > > > phys_addr_t min_addr;
> > > > @@ -120,12 +132,15 @@ static int alloc_from_top_down_high_addr_check(void)
> > > > allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
> > > > - assert(allocated_ptr);
> > > > - assert(rgn->size == size);
> > > > - assert(rgn->base == memblock_end_of_DRAM() - SMP_CACHE_BYTES);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(rgn->size, size);
> > > > + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - SMP_CACHE_BYTES);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -151,6 +166,8 @@ static int alloc_from_top_down_no_space_above_check(void)
> > > > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t r1_size = SZ_64;
> > > > phys_addr_t r2_size = SZ_2;
> > > > phys_addr_t total_size = r1_size + r2_size;
> > > > @@ -165,12 +182,15 @@ static int alloc_from_top_down_no_space_above_check(void)
> > > > allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
> > > > - assert(allocated_ptr);
> > > > - assert(rgn->base == min_addr - r1_size);
> > > > - assert(rgn->size == total_size);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(rgn->base, min_addr - r1_size);
> > > > + ASSERT_EQ(rgn->size, total_size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -186,6 +206,8 @@ static int alloc_from_top_down_min_addr_cap_check(void)
> > > > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t r1_size = SZ_64;
> > > > phys_addr_t min_addr;
> > > > phys_addr_t start_addr;
> > > > @@ -199,12 +221,15 @@ static int alloc_from_top_down_min_addr_cap_check(void)
> > > > allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
> > > > - assert(allocated_ptr);
> > > > - assert(rgn->base == start_addr);
> > > > - assert(rgn->size == MEM_SIZE);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(rgn->base, start_addr);
> > > > + ASSERT_EQ(rgn->size, MEM_SIZE);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == MEM_SIZE);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, MEM_SIZE);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -230,6 +255,8 @@ static int alloc_from_bottom_up_high_addr_check(void)
> > > > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t size = SZ_32;
> > > > phys_addr_t min_addr;
> > > > @@ -240,12 +267,15 @@ static int alloc_from_bottom_up_high_addr_check(void)
> > > > allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
> > > > - assert(allocated_ptr);
> > > > - assert(rgn->size == size);
> > > > - assert(rgn->base == memblock_start_of_DRAM());
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(rgn->size, size);
> > > > + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> > > > +
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -270,6 +300,8 @@ static int alloc_from_bottom_up_no_space_above_check(void)
> > > > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t r1_size = SZ_64;
> > > > phys_addr_t min_addr;
> > > > phys_addr_t r2_size;
> > > > @@ -284,12 +316,15 @@ static int alloc_from_bottom_up_no_space_above_check(void)
> > > > allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
> > > > - assert(allocated_ptr);
> > > > - assert(rgn->base == memblock_start_of_DRAM());
> > > > - assert(rgn->size == r1_size);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> > > > + ASSERT_EQ(rgn->size, r1_size);
> > > > +
> > > > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > > > + ASSERT_EQ(memblock.reserved.total_size, r1_size + r2_size);
> > > > - assert(memblock.reserved.cnt == 2);
> > > > - assert(memblock.reserved.total_size == r1_size + r2_size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -304,6 +339,8 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
> > > > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t r1_size = SZ_64;
> > > > phys_addr_t min_addr;
> > > > phys_addr_t start_addr;
> > > > @@ -315,12 +352,15 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
> > > > allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
> > > > - assert(allocated_ptr);
> > > > - assert(rgn->base == start_addr);
> > > > - assert(rgn->size == r1_size);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(rgn->base, start_addr);
> > > > + ASSERT_EQ(rgn->size, r1_size);
> > > > +
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, r1_size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == r1_size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -328,6 +368,7 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
> > > > /* Test case wrappers */
> > > > 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);
> > > > @@ -338,6 +379,7 @@ 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);
> > > > @@ -348,6 +390,7 @@ static int alloc_from_misaligned_check(void)
> > > > static int alloc_from_high_addr_check(void)
> > > > {
> > > > + test_print("\tRunning %s...\n", __func__);
> > > > memblock_set_bottom_up(false);
> > > > alloc_from_top_down_high_addr_check();
> > > > memblock_set_bottom_up(true);
> > > > @@ -358,6 +401,7 @@ static int alloc_from_high_addr_check(void)
> > > > static int alloc_from_no_space_above_check(void)
> > > > {
> > > > + test_print("\tRunning %s...\n", __func__);
> > > > memblock_set_bottom_up(false);
> > > > alloc_from_top_down_no_space_above_check();
> > > > memblock_set_bottom_up(true);
> > > > @@ -368,6 +412,7 @@ static int alloc_from_no_space_above_check(void)
> > > > static int alloc_from_min_addr_cap_check(void)
> > > > {
> > > > + test_print("\tRunning %s...\n", __func__);
> > > > memblock_set_bottom_up(false);
> > > > alloc_from_top_down_min_addr_cap_check();
> > > > memblock_set_bottom_up(true);
> > > > @@ -378,6 +423,12 @@ static int alloc_from_min_addr_cap_check(void)
> > > > int memblock_alloc_helpers_checks(void)
> > > > {
> > > > + static const char func_testing[] = "memblock_alloc_from";
> > > > +
> > > > + prefix_reset();
> > > > + prefix_push(func_testing);
> > > > + test_print("Running %s tests...\n", func_testing);
> > > > +
> > > > reset_memblock_attributes();
> > > > dummy_physical_memory_init();
> > > > diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
> > > > index 6390206e50e1..601f4a7ee30d 100644
> > > > --- a/tools/testing/memblock/tests/alloc_nid_api.c
> > > > +++ b/tools/testing/memblock/tests/alloc_nid_api.c
> > > > @@ -21,6 +21,8 @@ static int alloc_try_nid_top_down_simple_check(void)
> > > > void *allocated_ptr = NULL;
> > > > char *b;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t size = SZ_128;
> > > > phys_addr_t min_addr;
> > > > phys_addr_t max_addr;
> > > > @@ -36,15 +38,18 @@ static int alloc_try_nid_top_down_simple_check(void)
> > > > b = (char *)allocated_ptr;
> > > > rgn_end = rgn->base + rgn->size;
> > > > - assert(allocated_ptr);
> > > > - assert(*b == 0);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(*b, 0);
> > > > +
> > > > + ASSERT_EQ(rgn->size, size);
> > > > + ASSERT_EQ(rgn->base, max_addr - size);
> > > > + ASSERT_EQ(rgn_end, max_addr);
> > > > - assert(rgn->size == size);
> > > > - assert(rgn->base == max_addr - size);
> > > > - assert(rgn_end == max_addr);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -72,6 +77,8 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
> > > > void *allocated_ptr = NULL;
> > > > char *b;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t size = SZ_128;
> > > > phys_addr_t misalign = SZ_2;
> > > > phys_addr_t min_addr;
> > > > @@ -88,15 +95,18 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
> > > > b = (char *)allocated_ptr;
> > > > rgn_end = rgn->base + rgn->size;
> > > > - assert(allocated_ptr);
> > > > - assert(*b == 0);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(*b, 0);
> > > > - assert(rgn->size == size);
> > > > - assert(rgn->base == max_addr - size - misalign);
> > > > - assert(rgn_end < max_addr);
> > > > + ASSERT_EQ(rgn->size, size);
> > > > + ASSERT_EQ(rgn->base, max_addr - size - misalign);
> > > > + ASSERT_LT(rgn_end, max_addr);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -122,6 +132,8 @@ static int alloc_try_nid_exact_address_generic_check(void)
> > > > void *allocated_ptr = NULL;
> > > > char *b;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t size = SZ_1K;
> > > > phys_addr_t min_addr;
> > > > phys_addr_t max_addr;
> > > > @@ -137,15 +149,18 @@ static int alloc_try_nid_exact_address_generic_check(void)
> > > > b = (char *)allocated_ptr;
> > > > rgn_end = rgn->base + rgn->size;
> > > > - assert(allocated_ptr);
> > > > - assert(*b == 0);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(*b, 0);
> > > > +
> > > > + ASSERT_EQ(rgn->size, size);
> > > > + ASSERT_EQ(rgn->base, min_addr);
> > > > + ASSERT_EQ(rgn_end, max_addr);
> > > > - assert(rgn->size == size);
> > > > - assert(rgn->base == min_addr);
> > > > - assert(rgn_end == max_addr);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -173,6 +188,8 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
> > > > void *allocated_ptr = NULL;
> > > > char *b;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t size = SZ_256;
> > > > phys_addr_t min_addr;
> > > > phys_addr_t max_addr;
> > > > @@ -186,14 +203,17 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
> > > > min_addr, max_addr, NUMA_NO_NODE);
> > > > b = (char *)allocated_ptr;
> > > > - assert(allocated_ptr);
> > > > - assert(*b == 0);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(*b, 0);
> > > > +
> > > > + ASSERT_EQ(rgn->size, size);
> > > > + ASSERT_EQ(rgn->base, max_addr - size);
> > > > - assert(rgn->size == size);
> > > > - assert(rgn->base == max_addr - size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -222,6 +242,8 @@ static int alloc_try_nid_low_max_generic_check(void)
> > > > {
> > > > void *allocated_ptr = NULL;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t size = SZ_1K;
> > > > phys_addr_t min_addr;
> > > > phys_addr_t max_addr;
> > > > @@ -234,7 +256,10 @@ static int alloc_try_nid_low_max_generic_check(void)
> > > > allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> > > > min_addr, max_addr, NUMA_NO_NODE);
> > > > - assert(!allocated_ptr);
> > > > + ASSERT_EQ(allocated_ptr, NULL);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -259,6 +284,8 @@ static int alloc_try_nid_min_reserved_generic_check(void)
> > > > void *allocated_ptr = NULL;
> > > > char *b;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t r1_size = SZ_128;
> > > > phys_addr_t r2_size = SZ_64;
> > > > phys_addr_t total_size = r1_size + r2_size;
> > > > @@ -278,14 +305,17 @@ static int alloc_try_nid_min_reserved_generic_check(void)
> > > > min_addr, max_addr, NUMA_NO_NODE);
> > > > b = (char *)allocated_ptr;
> > > > - assert(allocated_ptr);
> > > > - assert(*b == 0);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(*b, 0);
> > > > - assert(rgn->size == total_size);
> > > > - assert(rgn->base == reserved_base);
> > > > + ASSERT_EQ(rgn->size, total_size);
> > > > + ASSERT_EQ(rgn->base, reserved_base);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -310,6 +340,8 @@ static int alloc_try_nid_max_reserved_generic_check(void)
> > > > void *allocated_ptr = NULL;
> > > > char *b;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t r1_size = SZ_64;
> > > > phys_addr_t r2_size = SZ_128;
> > > > phys_addr_t total_size = r1_size + r2_size;
> > > > @@ -327,14 +359,17 @@ static int alloc_try_nid_max_reserved_generic_check(void)
> > > > min_addr, max_addr, NUMA_NO_NODE);
> > > > b = (char *)allocated_ptr;
> > > > - assert(allocated_ptr);
> > > > - assert(*b == 0);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(*b, 0);
> > > > +
> > > > + ASSERT_EQ(rgn->size, total_size);
> > > > + ASSERT_EQ(rgn->base, min_addr);
> > > > - assert(rgn->size == total_size);
> > > > - assert(rgn->base == min_addr);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -364,6 +399,8 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
> > > > char *b;
> > > > struct region r1, r2;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t r3_size = SZ_64;
> > > > phys_addr_t gap_size = SMP_CACHE_BYTES;
> > > > phys_addr_t total_size;
> > > > @@ -389,17 +426,20 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
> > > > min_addr, max_addr, NUMA_NO_NODE);
> > > > b = (char *)allocated_ptr;
> > > > - assert(allocated_ptr);
> > > > - assert(*b == 0);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(*b, 0);
> > > > +
> > > > + ASSERT_EQ(rgn1->size, r1.size + r3_size);
> > > > + ASSERT_EQ(rgn1->base, max_addr - r3_size);
> > > > - assert(rgn1->size == r1.size + r3_size);
> > > > - assert(rgn1->base == max_addr - r3_size);
> > > > + ASSERT_EQ(rgn2->size, r2.size);
> > > > + ASSERT_EQ(rgn2->base, r2.base);
> > > > - assert(rgn2->size == r2.size);
> > > > - assert(rgn2->base == r2.base);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > > > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > > > - assert(memblock.reserved.cnt == 2);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -427,6 +467,8 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
> > > > char *b;
> > > > struct region r1, r2;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t r3_size = SZ_64;
> > > > phys_addr_t total_size;
> > > > phys_addr_t max_addr;
> > > > @@ -451,14 +493,17 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
> > > > min_addr, max_addr, NUMA_NO_NODE);
> > > > b = (char *)allocated_ptr;
> > > > - assert(allocated_ptr);
> > > > - assert(*b == 0);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(*b, 0);
> > > > - assert(rgn->size == total_size);
> > > > - assert(rgn->base == r2.base);
> > > > + ASSERT_EQ(rgn->size, total_size);
> > > > + ASSERT_EQ(rgn->base, r2.base);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -489,6 +534,8 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
> > > > char *b;
> > > > struct region r1, r2;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t r3_size = SZ_256;
> > > > phys_addr_t gap_size = SMP_CACHE_BYTES;
> > > > phys_addr_t total_size;
> > > > @@ -514,17 +561,20 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
> > > > min_addr, max_addr, NUMA_NO_NODE);
> > > > b = (char *)allocated_ptr;
> > > > - assert(allocated_ptr);
> > > > - assert(*b == 0);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(*b, 0);
> > > > +
> > > > + ASSERT_EQ(rgn1->size, r1.size);
> > > > + ASSERT_EQ(rgn1->base, r1.base);
> > > > - assert(rgn1->size == r1.size);
> > > > - assert(rgn1->base == r1.base);
> > > > + ASSERT_EQ(rgn2->size, r2.size + r3_size);
> > > > + ASSERT_EQ(rgn2->base, r2.base - r3_size);
> > > > - assert(rgn2->size == r2.size + r3_size);
> > > > - assert(rgn2->base == r2.base - r3_size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > > > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > > > - assert(memblock.reserved.cnt == 2);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -554,6 +604,8 @@ static int alloc_try_nid_reserved_all_generic_check(void)
> > > > void *allocated_ptr = NULL;
> > > > struct region r1, r2;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t r3_size = SZ_256;
> > > > phys_addr_t gap_size = SMP_CACHE_BYTES;
> > > > phys_addr_t max_addr;
> > > > @@ -576,7 +628,10 @@ static int alloc_try_nid_reserved_all_generic_check(void)
> > > > allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
> > > > min_addr, max_addr, NUMA_NO_NODE);
> > > > - assert(!allocated_ptr);
> > > > + ASSERT_EQ(allocated_ptr, NULL);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -592,6 +647,8 @@ static int alloc_try_nid_top_down_cap_max_check(void)
> > > > void *allocated_ptr = NULL;
> > > > char *b;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t size = SZ_256;
> > > > phys_addr_t min_addr;
> > > > phys_addr_t max_addr;
> > > > @@ -605,14 +662,17 @@ static int alloc_try_nid_top_down_cap_max_check(void)
> > > > min_addr, max_addr, NUMA_NO_NODE);
> > > > b = (char *)allocated_ptr;
> > > > - assert(allocated_ptr);
> > > > - assert(*b == 0);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(*b, 0);
> > > > +
> > > > + ASSERT_EQ(rgn->size, size);
> > > > + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
> > > > - assert(rgn->size == size);
> > > > - assert(rgn->base == memblock_end_of_DRAM() - size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -628,6 +688,8 @@ static int alloc_try_nid_top_down_cap_min_check(void)
> > > > void *allocated_ptr = NULL;
> > > > char *b;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t size = SZ_1K;
> > > > phys_addr_t min_addr;
> > > > phys_addr_t max_addr;
> > > > @@ -641,14 +703,17 @@ static int alloc_try_nid_top_down_cap_min_check(void)
> > > > min_addr, max_addr, NUMA_NO_NODE);
> > > > b = (char *)allocated_ptr;
> > > > - assert(allocated_ptr);
> > > > - assert(*b == 0);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(*b, 0);
> > > > - assert(rgn->size == size);
> > > > - assert(rgn->base == memblock_end_of_DRAM() - size);
> > > > + ASSERT_EQ(rgn->size, size);
> > > > + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -673,6 +738,8 @@ static int alloc_try_nid_bottom_up_simple_check(void)
> > > > void *allocated_ptr = NULL;
> > > > char *b;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t size = SZ_128;
> > > > phys_addr_t min_addr;
> > > > phys_addr_t max_addr;
> > > > @@ -689,15 +756,18 @@ static int alloc_try_nid_bottom_up_simple_check(void)
> > > > b = (char *)allocated_ptr;
> > > > rgn_end = rgn->base + rgn->size;
> > > > - assert(allocated_ptr);
> > > > - assert(*b == 0);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(*b, 0);
> > > > +
> > > > + ASSERT_EQ(rgn->size, size);
> > > > + ASSERT_EQ(rgn->base, min_addr);
> > > > + ASSERT_LT(rgn_end, max_addr);
> > > > - assert(rgn->size == size);
> > > > - assert(rgn->base == min_addr);
> > > > - assert(rgn_end < max_addr);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -725,6 +795,8 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
> > > > void *allocated_ptr = NULL;
> > > > char *b;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t size = SZ_128;
> > > > phys_addr_t misalign = SZ_2;
> > > > phys_addr_t min_addr;
> > > > @@ -742,15 +814,18 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
> > > > b = (char *)allocated_ptr;
> > > > rgn_end = rgn->base + rgn->size;
> > > > - assert(allocated_ptr);
> > > > - assert(*b == 0);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(*b, 0);
> > > > +
> > > > + ASSERT_EQ(rgn->size, size);
> > > > + ASSERT_EQ(rgn->base, min_addr + (SMP_CACHE_BYTES - misalign));
> > > > + ASSERT_LT(rgn_end, max_addr);
> > > > - assert(rgn->size == size);
> > > > - assert(rgn->base == min_addr + (SMP_CACHE_BYTES - misalign));
> > > > - assert(rgn_end < max_addr);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -778,6 +853,8 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
> > > > void *allocated_ptr = NULL;
> > > > char *b;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t size = SZ_256;
> > > > phys_addr_t min_addr;
> > > > phys_addr_t max_addr;
> > > > @@ -792,14 +869,17 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
> > > > NUMA_NO_NODE);
> > > > b = (char *)allocated_ptr;
> > > > - assert(allocated_ptr);
> > > > - assert(*b == 0);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(*b, 0);
> > > > - assert(rgn->size == size);
> > > > - assert(rgn->base == memblock_start_of_DRAM());
> > > > + ASSERT_EQ(rgn->size, size);
> > > > + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -829,6 +909,8 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
> > > > char *b;
> > > > struct region r1, r2;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t r3_size = SZ_64;
> > > > phys_addr_t gap_size = SMP_CACHE_BYTES;
> > > > phys_addr_t total_size;
> > > > @@ -855,17 +937,20 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
> > > > NUMA_NO_NODE);
> > > > b = (char *)allocated_ptr;
> > > > - assert(allocated_ptr);
> > > > - assert(*b == 0);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(*b, 0);
> > > > - assert(rgn1->size == r1.size);
> > > > - assert(rgn1->base == max_addr);
> > > > + ASSERT_EQ(rgn1->size, r1.size);
> > > > + ASSERT_EQ(rgn1->base, max_addr);
> > > > - assert(rgn2->size == r2.size + r3_size);
> > > > - assert(rgn2->base == r2.base);
> > > > + ASSERT_EQ(rgn2->size, r2.size + r3_size);
> > > > + ASSERT_EQ(rgn2->base, r2.base);
> > > > - assert(memblock.reserved.cnt == 2);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > > > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -899,6 +984,8 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
> > > > char *b;
> > > > struct region r1, r2;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t r3_size = SZ_256;
> > > > phys_addr_t gap_size = SMP_CACHE_BYTES;
> > > > phys_addr_t total_size;
> > > > @@ -925,20 +1012,23 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
> > > > NUMA_NO_NODE);
> > > > b = (char *)allocated_ptr;
> > > > - assert(allocated_ptr);
> > > > - assert(*b == 0);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(*b, 0);
> > > > +
> > > > + ASSERT_EQ(rgn3->size, r3_size);
> > > > + ASSERT_EQ(rgn3->base, memblock_start_of_DRAM());
> > > > - assert(rgn3->size == r3_size);
> > > > - assert(rgn3->base == memblock_start_of_DRAM());
> > > > + ASSERT_EQ(rgn2->size, r2.size);
> > > > + ASSERT_EQ(rgn2->base, r2.base);
> > > > - assert(rgn2->size == r2.size);
> > > > - assert(rgn2->base == r2.base);
> > > > + ASSERT_EQ(rgn1->size, r1.size);
> > > > + ASSERT_EQ(rgn1->base, r1.base);
> > > > - assert(rgn1->size == r1.size);
> > > > - assert(rgn1->base == r1.base);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 3);
> > > > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > > > - assert(memblock.reserved.cnt == 3);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -954,6 +1044,8 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
> > > > void *allocated_ptr = NULL;
> > > > char *b;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t size = SZ_256;
> > > > phys_addr_t min_addr;
> > > > phys_addr_t max_addr;
> > > > @@ -968,14 +1060,17 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
> > > > NUMA_NO_NODE);
> > > > b = (char *)allocated_ptr;
> > > > - assert(allocated_ptr);
> > > > - assert(*b == 0);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(*b, 0);
> > > > +
> > > > + ASSERT_EQ(rgn->size, size);
> > > > + ASSERT_EQ(rgn->base, min_addr);
> > > > - assert(rgn->size == size);
> > > > - assert(rgn->base == min_addr);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -991,6 +1086,8 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
> > > > void *allocated_ptr = NULL;
> > > > char *b;
> > > > + prefix_push(__func__);
> > > > +
> > > > phys_addr_t size = SZ_1K;
> > > > phys_addr_t min_addr;
> > > > phys_addr_t max_addr;
> > > > @@ -1005,14 +1102,17 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
> > > > NUMA_NO_NODE);
> > > > b = (char *)allocated_ptr;
> > > > - assert(allocated_ptr);
> > > > - assert(*b == 0);
> > > > + ASSERT_NE(allocated_ptr, NULL);
> > > > + ASSERT_EQ(*b, 0);
> > > > +
> > > > + ASSERT_EQ(rgn->size, size);
> > > > + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> > > > - assert(rgn->size == size);
> > > > - assert(rgn->base == memblock_start_of_DRAM());
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -1020,6 +1120,7 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
> > > > /* Test case wrappers */
> > > > static int alloc_try_nid_simple_check(void)
> > > > {
> > > > + test_print("\tRunning %s...\n", __func__);
> > > > memblock_set_bottom_up(false);
> > > > alloc_try_nid_top_down_simple_check();
> > > > memblock_set_bottom_up(true);
> > > > @@ -1030,6 +1131,7 @@ static int alloc_try_nid_simple_check(void)
> > > > static int alloc_try_nid_misaligned_check(void)
> > > > {
> > > > + test_print("\tRunning %s...\n", __func__);
> > > > memblock_set_bottom_up(false);
> > > > alloc_try_nid_top_down_end_misaligned_check();
> > > > memblock_set_bottom_up(true);
> > > > @@ -1040,6 +1142,7 @@ static int alloc_try_nid_misaligned_check(void)
> > > > static int alloc_try_nid_narrow_range_check(void)
> > > > {
> > > > + test_print("\tRunning %s...\n", __func__);
> > > > memblock_set_bottom_up(false);
> > > > alloc_try_nid_top_down_narrow_range_check();
> > > > memblock_set_bottom_up(true);
> > > > @@ -1050,6 +1153,7 @@ static int alloc_try_nid_narrow_range_check(void)
> > > > static int alloc_try_nid_reserved_with_space_check(void)
> > > > {
> > > > + test_print("\tRunning %s...\n", __func__);
> > > > memblock_set_bottom_up(false);
> > > > alloc_try_nid_top_down_reserved_with_space_check();
> > > > memblock_set_bottom_up(true);
> > > > @@ -1060,6 +1164,7 @@ static int alloc_try_nid_reserved_with_space_check(void)
> > > > static int alloc_try_nid_reserved_no_space_check(void)
> > > > {
> > > > + test_print("\tRunning %s...\n", __func__);
> > > > memblock_set_bottom_up(false);
> > > > alloc_try_nid_top_down_reserved_no_space_check();
> > > > memblock_set_bottom_up(true);
> > > > @@ -1070,6 +1175,7 @@ static int alloc_try_nid_reserved_no_space_check(void)
> > > > static int alloc_try_nid_cap_max_check(void)
> > > > {
> > > > + test_print("\tRunning %s...\n", __func__);
> > > > memblock_set_bottom_up(false);
> > > > alloc_try_nid_top_down_cap_max_check();
> > > > memblock_set_bottom_up(true);
> > > > @@ -1080,6 +1186,7 @@ static int alloc_try_nid_cap_max_check(void)
> > > > static int alloc_try_nid_cap_min_check(void)
> > > > {
> > > > + test_print("\tRunning %s...\n", __func__);
> > > > memblock_set_bottom_up(false);
> > > > alloc_try_nid_top_down_cap_min_check();
> > > > memblock_set_bottom_up(true);
> > > > @@ -1090,6 +1197,7 @@ 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);
> > > > @@ -1100,6 +1208,7 @@ 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);
> > > > @@ -1110,6 +1219,7 @@ 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);
> > > > @@ -1120,6 +1230,7 @@ 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);
> > > > @@ -1130,6 +1241,7 @@ 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);
> > > > @@ -1140,6 +1252,7 @@ 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);
> > > > @@ -1150,6 +1263,12 @@ static int alloc_try_nid_low_max_check(void)
> > > > int memblock_alloc_nid_checks(void)
> > > > {
> > > > + static const char func_testing[] = "memblock_alloc_try_nid";
> > > > +
> > > > + prefix_reset();
> > > > + prefix_push(func_testing);
> > > > + test_print("Running %s tests...\n", func_testing);
> > > > +
> > > > reset_memblock_attributes();
> > > > dummy_physical_memory_init();
> > > > @@ -1170,5 +1289,7 @@ int memblock_alloc_nid_checks(void)
> > > > dummy_physical_memory_cleanup();
> > > > + prefix_pop();
> > > > +
> > > > return 0;
> > > > }
> > > > diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c
> > > > index a7bc180316d6..f223a9a57be7 100644
> > > > --- a/tools/testing/memblock/tests/basic_api.c
> > > > +++ b/tools/testing/memblock/tests/basic_api.c
> > > > @@ -4,21 +4,30 @@
> > > > #include "basic_api.h"
> > > > #define EXPECTED_MEMBLOCK_REGIONS 128
> > > > +#define FUNC_ADD "memblock_add"
> > > > +#define FUNC_RESERVE "memblock_reserve"
> > > > +#define FUNC_REMOVE "memblock_remove"
> > > > +#define FUNC_FREE "memblock_free"
> > > > static int memblock_initialization_check(void)
> > > > {
> > > > - assert(memblock.memory.regions);
> > > > - assert(memblock.memory.cnt == 1);
> > > > - assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
> > > > - assert(strcmp(memblock.memory.name, "memory") == 0);
> > > > + prefix_push(__func__);
> > > > - assert(memblock.reserved.regions);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
> > > > - assert(strcmp(memblock.reserved.name, "reserved") == 0);
> > > > + ASSERT_NE(memblock.memory.regions, NULL);
> > > > + ASSERT_EQ(memblock.memory.cnt, 1);
> > > > + ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
> > > > + ASSERT_EQ(strcmp(memblock.memory.name, "memory"), 0);
> > > > - assert(!memblock.bottom_up);
> > > > - assert(memblock.current_limit == MEMBLOCK_ALLOC_ANYWHERE);
> > > > + ASSERT_NE(memblock.reserved.regions, NULL);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
> > > > + ASSERT_EQ(strcmp(memblock.reserved.name, "reserved"), 0);
> > > > +
> > > > + ASSERT_EQ(memblock.bottom_up, false);
> > > > + ASSERT_EQ(memblock.current_limit, MEMBLOCK_ALLOC_ANYWHERE);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -40,14 +49,19 @@ static int memblock_add_simple_check(void)
> > > > .size = SZ_4M
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > reset_memblock_regions();
> > > > memblock_add(r.base, r.size);
> > > > - assert(rgn->base == r.base);
> > > > - assert(rgn->size == r.size);
> > > > + ASSERT_EQ(rgn->base, r.base);
> > > > + ASSERT_EQ(rgn->size, r.size);
> > > > +
> > > > + ASSERT_EQ(memblock.memory.cnt, 1);
> > > > + ASSERT_EQ(memblock.memory.total_size, r.size);
> > > > - assert(memblock.memory.cnt == 1);
> > > > - assert(memblock.memory.total_size == r.size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -69,18 +83,27 @@ static int memblock_add_node_simple_check(void)
> > > > .size = SZ_16M
> > > > };
> > > > + prefix_pop();
> > > > + prefix_push("memblock_add_node");
> > > > + prefix_push(__func__);
> > > > +
> > > > reset_memblock_regions();
> > > > memblock_add_node(r.base, r.size, 1, MEMBLOCK_HOTPLUG);
> > > > - assert(rgn->base == r.base);
> > > > - assert(rgn->size == r.size);
> > > > + ASSERT_EQ(rgn->base, r.base);
> > > > + ASSERT_EQ(rgn->size, r.size);
> > > > #ifdef CONFIG_NUMA
> > > > - assert(rgn->nid == 1);
> > > > + ASSERT_EQ(rgn->nid, 1);
> > > > #endif
> > > > - assert(rgn->flags == MEMBLOCK_HOTPLUG);
> > > > + ASSERT_EQ(rgn->flags, MEMBLOCK_HOTPLUG);
> > > > +
> > > > + ASSERT_EQ(memblock.memory.cnt, 1);
> > > > + ASSERT_EQ(memblock.memory.total_size, r.size);
> > > > - assert(memblock.memory.cnt == 1);
> > > > - assert(memblock.memory.total_size == r.size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > + prefix_pop();
> > > > + prefix_push(FUNC_ADD);
> > > > return 0;
> > > > }
> > > > @@ -113,18 +136,23 @@ static int memblock_add_disjoint_check(void)
> > > > .size = SZ_8K
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > reset_memblock_regions();
> > > > memblock_add(r1.base, r1.size);
> > > > memblock_add(r2.base, r2.size);
> > > > - assert(rgn1->base == r1.base);
> > > > - assert(rgn1->size == r1.size);
> > > > + 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(rgn2->base == r2.base);
> > > > - assert(rgn2->size == r2.size);
> > > > + ASSERT_EQ(memblock.memory.cnt, 2);
> > > > + ASSERT_EQ(memblock.memory.total_size, r1.size + r2.size);
> > > > - assert(memblock.memory.cnt == 2);
> > > > - assert(memblock.memory.total_size == r1.size + r2.size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -162,17 +190,22 @@ static int memblock_add_overlap_top_check(void)
> > > > .size = SZ_512M
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > total_size = (r1.base - r2.base) + r1.size;
> > > > reset_memblock_regions();
> > > > memblock_add(r1.base, r1.size);
> > > > memblock_add(r2.base, r2.size);
> > > > - assert(rgn->base == r2.base);
> > > > - assert(rgn->size == total_size);
> > > > + ASSERT_EQ(rgn->base, r2.base);
> > > > + ASSERT_EQ(rgn->size, total_size);
> > > > +
> > > > + ASSERT_EQ(memblock.memory.cnt, 1);
> > > > + ASSERT_EQ(memblock.memory.total_size, total_size);
> > > > - assert(memblock.memory.cnt == 1);
> > > > - assert(memblock.memory.total_size == total_size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -210,17 +243,22 @@ static int memblock_add_overlap_bottom_check(void)
> > > > .size = SZ_1G
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > total_size = (r2.base - r1.base) + r2.size;
> > > > reset_memblock_regions();
> > > > memblock_add(r1.base, r1.size);
> > > > memblock_add(r2.base, r2.size);
> > > > - assert(rgn->base == r1.base);
> > > > - assert(rgn->size == total_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);
> > > > - assert(memblock.memory.cnt == 1);
> > > > - assert(memblock.memory.total_size == total_size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -255,15 +293,20 @@ static int memblock_add_within_check(void)
> > > > .size = SZ_1M
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > reset_memblock_regions();
> > > > memblock_add(r1.base, r1.size);
> > > > memblock_add(r2.base, r2.size);
> > > > - assert(rgn->base == r1.base);
> > > > - assert(rgn->size == r1.size);
> > > > + ASSERT_EQ(rgn->base, r1.base);
> > > > + ASSERT_EQ(rgn->size, r1.size);
> > > > +
> > > > + ASSERT_EQ(memblock.memory.cnt, 1);
> > > > + ASSERT_EQ(memblock.memory.total_size, r1.size);
> > > > - assert(memblock.memory.cnt == 1);
> > > > - assert(memblock.memory.total_size == r1.size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -279,19 +322,28 @@ static int memblock_add_twice_check(void)
> > > > .size = SZ_2M
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > reset_memblock_regions();
> > > > memblock_add(r.base, r.size);
> > > > memblock_add(r.base, r.size);
> > > > - assert(memblock.memory.cnt == 1);
> > > > - assert(memblock.memory.total_size == r.size);
> > > > + ASSERT_EQ(memblock.memory.cnt, 1);
> > > > + ASSERT_EQ(memblock.memory.total_size, r.size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > static int memblock_add_checks(void)
> > > > {
> > > > + prefix_reset();
> > > > + prefix_push(FUNC_ADD);
> > > > + test_print("Running %s tests...\n", FUNC_ADD);
> > > > +
> > > > memblock_add_simple_check();
> > > > memblock_add_node_simple_check();
> > > > memblock_add_disjoint_check();
> > > > @@ -300,6 +352,8 @@ static int memblock_add_checks(void)
> > > > memblock_add_within_check();
> > > > memblock_add_twice_check();
> > > > + prefix_pop();
> > > > +
> > > > return 0;
> > > > }
> > > > @@ -320,11 +374,16 @@ static int memblock_reserve_simple_check(void)
> > > > .size = SZ_128M
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > reset_memblock_regions();
> > > > memblock_reserve(r.base, r.size);
> > > > - assert(rgn->base == r.base);
> > > > - assert(rgn->size == r.size);
> > > > + ASSERT_EQ(rgn->base, r.base);
> > > > + ASSERT_EQ(rgn->size, r.size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -356,18 +415,23 @@ static int memblock_reserve_disjoint_check(void)
> > > > .size = SZ_512M
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > reset_memblock_regions();
> > > > memblock_reserve(r1.base, r1.size);
> > > > memblock_reserve(r2.base, r2.size);
> > > > - assert(rgn1->base == r1.base);
> > > > - assert(rgn1->size == r1.size);
> > > > + 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(rgn2->base == r2.base);
> > > > - assert(rgn2->size == r2.size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > > > + ASSERT_EQ(memblock.reserved.total_size, r1.size + r2.size);
> > > > - assert(memblock.reserved.cnt == 2);
> > > > - assert(memblock.reserved.total_size == r1.size + r2.size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -406,17 +470,22 @@ static int memblock_reserve_overlap_top_check(void)
> > > > .size = SZ_1G
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > total_size = (r1.base - r2.base) + r1.size;
> > > > reset_memblock_regions();
> > > > memblock_reserve(r1.base, r1.size);
> > > > memblock_reserve(r2.base, r2.size);
> > > > - assert(rgn->base == r2.base);
> > > > - assert(rgn->size == total_size);
> > > > + ASSERT_EQ(rgn->base, r2.base);
> > > > + ASSERT_EQ(rgn->size, total_size);
> > > > +
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -455,17 +524,22 @@ static int memblock_reserve_overlap_bottom_check(void)
> > > > .size = SZ_128K
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > total_size = (r2.base - r1.base) + r2.size;
> > > > reset_memblock_regions();
> > > > memblock_reserve(r1.base, r1.size);
> > > > memblock_reserve(r2.base, r2.size);
> > > > - assert(rgn->base == r1.base);
> > > > - assert(rgn->size == total_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);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -502,15 +576,20 @@ static int memblock_reserve_within_check(void)
> > > > .size = SZ_64K
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > reset_memblock_regions();
> > > > memblock_reserve(r1.base, r1.size);
> > > > memblock_reserve(r2.base, r2.size);
> > > > - assert(rgn->base == r1.base);
> > > > - assert(rgn->size == r1.size);
> > > > + ASSERT_EQ(rgn->base, r1.base);
> > > > + ASSERT_EQ(rgn->size, r1.size);
> > > > +
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, r1.size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == r1.size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -527,19 +606,28 @@ static int memblock_reserve_twice_check(void)
> > > > .size = SZ_2M
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > reset_memblock_regions();
> > > > memblock_reserve(r.base, r.size);
> > > > memblock_reserve(r.base, r.size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == r.size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, r.size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > static int memblock_reserve_checks(void)
> > > > {
> > > > + prefix_reset();
> > > > + prefix_push(FUNC_RESERVE);
> > > > + test_print("Running %s tests...\n", FUNC_RESERVE);
> > > > +
> > > > memblock_reserve_simple_check();
> > > > memblock_reserve_disjoint_check();
> > > > memblock_reserve_overlap_top_check();
> > > > @@ -547,6 +635,8 @@ static int memblock_reserve_checks(void)
> > > > memblock_reserve_within_check();
> > > > memblock_reserve_twice_check();
> > > > + prefix_pop();
> > > > +
> > > > return 0;
> > > > }
> > > > @@ -581,16 +671,21 @@ static int memblock_remove_simple_check(void)
> > > > .size = SZ_4M
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > reset_memblock_regions();
> > > > memblock_add(r1.base, r1.size);
> > > > memblock_add(r2.base, r2.size);
> > > > memblock_remove(r1.base, r1.size);
> > > > - assert(rgn->base == r2.base);
> > > > - assert(rgn->size == r2.size);
> > > > + ASSERT_EQ(rgn->base, r2.base);
> > > > + ASSERT_EQ(rgn->size, r2.size);
> > > > - assert(memblock.memory.cnt == 1);
> > > > - assert(memblock.memory.total_size == r2.size);
> > > > + ASSERT_EQ(memblock.memory.cnt, 1);
> > > > + ASSERT_EQ(memblock.memory.total_size, r2.size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -626,15 +721,20 @@ static int memblock_remove_absent_check(void)
> > > > .size = SZ_1G
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > reset_memblock_regions();
> > > > memblock_add(r1.base, r1.size);
> > > > memblock_remove(r2.base, r2.size);
> > > > - assert(rgn->base == r1.base);
> > > > - assert(rgn->size == r1.size);
> > > > + ASSERT_EQ(rgn->base, r1.base);
> > > > + ASSERT_EQ(rgn->size, r1.size);
> > > > +
> > > > + ASSERT_EQ(memblock.memory.cnt, 1);
> > > > + ASSERT_EQ(memblock.memory.total_size, r1.size);
> > > > - assert(memblock.memory.cnt == 1);
> > > > - assert(memblock.memory.total_size == r1.size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -674,6 +774,8 @@ static int memblock_remove_overlap_top_check(void)
> > > > .size = SZ_32M
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > r1_end = r1.base + r1.size;
> > > > r2_end = r2.base + r2.size;
> > > > total_size = r1_end - r2_end;
> > > > @@ -682,11 +784,14 @@ static int memblock_remove_overlap_top_check(void)
> > > > memblock_add(r1.base, r1.size);
> > > > memblock_remove(r2.base, r2.size);
> > > > - assert(rgn->base == r1.base + r2.base);
> > > > - assert(rgn->size == total_size);
> > > > + ASSERT_EQ(rgn->base, r1.base + r2.base);
> > > > + ASSERT_EQ(rgn->size, total_size);
> > > > +
> > > > + ASSERT_EQ(memblock.memory.cnt, 1);
> > > > + ASSERT_EQ(memblock.memory.total_size, total_size);
> > > > - assert(memblock.memory.cnt == 1);
> > > > - assert(memblock.memory.total_size == total_size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -724,17 +829,23 @@ static int memblock_remove_overlap_bottom_check(void)
> > > > .size = SZ_256M
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > total_size = r2.base - r1.base;
> > > > reset_memblock_regions();
> > > > memblock_add(r1.base, r1.size);
> > > > memblock_remove(r2.base, r2.size);
> > > > - assert(rgn->base == r1.base);
> > > > - assert(rgn->size == total_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();
> > > > + prefix_pop();
> > > > - assert(memblock.memory.cnt == 1);
> > > > - assert(memblock.memory.total_size == total_size);
> > > > return 0;
> > > > }
> > > > @@ -774,6 +885,8 @@ static int memblock_remove_within_check(void)
> > > > .size = SZ_1M
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > r1_size = r2.base - r1.base;
> > > > r2_size = (r1.base + r1.size) - (r2.base + r2.size);
> > > > total_size = r1_size + r2_size;
> > > > @@ -782,26 +895,35 @@ static int memblock_remove_within_check(void)
> > > > memblock_add(r1.base, r1.size);
> > > > memblock_remove(r2.base, r2.size);
> > > > - assert(rgn1->base == r1.base);
> > > > - assert(rgn1->size == r1_size);
> > > > + ASSERT_EQ(rgn1->base, r1.base);
> > > > + ASSERT_EQ(rgn1->size, r1_size);
> > > > +
> > > > + ASSERT_EQ(rgn2->base, r2.base + r2.size);
> > > > + ASSERT_EQ(rgn2->size, r2_size);
> > > > - assert(rgn2->base == r2.base + r2.size);
> > > > - assert(rgn2->size == r2_size);
> > > > + ASSERT_EQ(memblock.memory.cnt, 2);
> > > > + ASSERT_EQ(memblock.memory.total_size, total_size);
> > > > - assert(memblock.memory.cnt == 2);
> > > > - assert(memblock.memory.total_size == total_size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > static int memblock_remove_checks(void)
> > > > {
> > > > + prefix_reset();
> > > > + prefix_push(FUNC_REMOVE);
> > > > + test_print("Running %s tests...\n", FUNC_REMOVE);
> > > > +
> > > > memblock_remove_simple_check();
> > > > memblock_remove_absent_check();
> > > > memblock_remove_overlap_top_check();
> > > > memblock_remove_overlap_bottom_check();
> > > > memblock_remove_within_check();
> > > > + prefix_pop();
> > > > +
> > > > return 0;
> > > > }
> > > > @@ -835,16 +957,21 @@ static int memblock_free_simple_check(void)
> > > > .size = SZ_1M
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > reset_memblock_regions();
> > > > memblock_reserve(r1.base, r1.size);
> > > > memblock_reserve(r2.base, r2.size);
> > > > memblock_free((void *)r1.base, r1.size);
> > > > - assert(rgn->base == r2.base);
> > > > - assert(rgn->size == r2.size);
> > > > + ASSERT_EQ(rgn->base, r2.base);
> > > > + ASSERT_EQ(rgn->size, r2.size);
> > > > +
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, r2.size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == r2.size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -880,15 +1007,20 @@ static int memblock_free_absent_check(void)
> > > > .size = SZ_128M
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > reset_memblock_regions();
> > > > memblock_reserve(r1.base, r1.size);
> > > > memblock_free((void *)r2.base, r2.size);
> > > > - assert(rgn->base == r1.base);
> > > > - assert(rgn->size == r1.size);
> > > > + ASSERT_EQ(rgn->base, r1.base);
> > > > + ASSERT_EQ(rgn->size, r1.size);
> > > > +
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, r1.size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == r1.size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -928,17 +1060,22 @@ static int memblock_free_overlap_top_check(void)
> > > > .size = SZ_8M
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > total_size = (r1.size + r1.base) - (r2.base + r2.size);
> > > > reset_memblock_regions();
> > > > memblock_reserve(r1.base, r1.size);
> > > > memblock_free((void *)r2.base, r2.size);
> > > > - assert(rgn->base == r2.base + r2.size);
> > > > - assert(rgn->size == total_size);
> > > > + ASSERT_EQ(rgn->base, r2.base + r2.size);
> > > > + ASSERT_EQ(rgn->size, total_size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -973,17 +1110,22 @@ static int memblock_free_overlap_bottom_check(void)
> > > > .size = SZ_32M
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > total_size = r2.base - r1.base;
> > > > reset_memblock_regions();
> > > > memblock_reserve(r1.base, r1.size);
> > > > memblock_free((void *)r2.base, r2.size);
> > > > - assert(rgn->base == r1.base);
> > > > - assert(rgn->size == total_size);
> > > > + ASSERT_EQ(rgn->base, r1.base);
> > > > + ASSERT_EQ(rgn->size, total_size);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > @@ -1024,6 +1166,8 @@ static int memblock_free_within_check(void)
> > > > .size = SZ_1M
> > > > };
> > > > + prefix_push(__func__);
> > > > +
> > > > r1_size = r2.base - r1.base;
> > > > r2_size = (r1.base + r1.size) - (r2.base + r2.size);
> > > > total_size = r1_size + r2_size;
> > > > @@ -1032,26 +1176,35 @@ static int memblock_free_within_check(void)
> > > > memblock_reserve(r1.base, r1.size);
> > > > memblock_free((void *)r2.base, r2.size);
> > > > - assert(rgn1->base == r1.base);
> > > > - assert(rgn1->size == r1_size);
> > > > + ASSERT_EQ(rgn1->base, r1.base);
> > > > + ASSERT_EQ(rgn1->size, r1_size);
> > > > - assert(rgn2->base == r2.base + r2.size);
> > > > - assert(rgn2->size == r2_size);
> > > > + ASSERT_EQ(rgn2->base, r2.base + r2.size);
> > > > + ASSERT_EQ(rgn2->size, r2_size);
> > > > - assert(memblock.reserved.cnt == 2);
> > > > - assert(memblock.reserved.total_size == total_size);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > > > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > > return 0;
> > > > }
> > > > static int memblock_free_checks(void)
> > > > {
> > > > + prefix_reset();
> > > > + prefix_push(FUNC_FREE);
> > > > + test_print("Running %s tests...\n", FUNC_FREE);
> > > > +
> > > > memblock_free_simple_check();
> > > > memblock_free_absent_check();
> > > > memblock_free_overlap_top_check();
> > > > memblock_free_overlap_bottom_check();
> > > > memblock_free_within_check();
> > > > + prefix_pop();
> > > > +
> > > > return 0;
> > > > }
> > > > diff --git a/tools/testing/memblock/tests/common.c b/tools/testing/memblock/tests/common.c
> > > > index 62d3191f7c9a..e55b2a8bf0ff 100644
> > > > --- a/tools/testing/memblock/tests/common.c
> > > > +++ b/tools/testing/memblock/tests/common.c
> > > > @@ -4,8 +4,12 @@
> > > > #define INIT_MEMBLOCK_REGIONS 128
> > > > #define INIT_MEMBLOCK_RESERVED_REGIONS INIT_MEMBLOCK_REGIONS
> > > > +#define PREFIXES_LEN_MAX 256
> > > > +#define DELIM ": "
> > > > +#define DELIM_LEN strlen(DELIM)
> > > > static struct test_memory memory_block;
> > > > +static char __maybe_unused prefixes[PREFIXES_LEN_MAX];
> > > > void reset_memblock_regions(void)
> > > > {
> > > > @@ -46,3 +50,57 @@ void dummy_physical_memory_cleanup(void)
> > > > {
> > > > free(memory_block.base);
> > > > }
> > > > +
> > > > +#ifdef VERBOSE
> > > > +void test_fail(void)
> > > > +{
> > > > + ksft_test_result_fail(": %sfailed\n", prefixes);
> > > > +}
> > > > +
> > > > +void test_pass(void)
> > > > +{
> > > > + ksft_test_result_pass(": %spassed\n", prefixes);
> > > > +}
> > > > +
> > > > +void test_print(const char *fmt, ...)
> > > > +{
> > > > + int saved_errno = errno;
> > > > + va_list args;
> > > > +
> > > > + va_start(args, fmt);
> > > > + errno = saved_errno;
> > > > + vprintf(fmt, args);
> > > > + va_end(args);
> > > > +}
> > > > +
> > > > +void prefix_reset(void)
> > > > +{
> > > > + memset(prefixes, 0, PREFIXES_LEN_MAX);
> > > > +}
> > > > +
> > > > +void prefix_push(const char *prefix)
> > > > +{
> > > > + int prefix_max = PREFIXES_LEN_MAX - strlen(prefixes) - DELIM_LEN - 1;
> > > > +
> > > > + assert(strlen(prefix) <= prefix_max);
> > > > + strncat(prefixes, prefix, prefix_max);
> > > > + strncat(prefixes, DELIM, PREFIXES_LEN_MAX - strlen(prefixes) - 1);
> > > > +}
> > > > +
> > > > +void prefix_pop(void)
> > > > +{
> > > > + char *ptr;
> > > > +
> > > > + ptr = strrchr(prefixes, DELIM[0]);
> > > > + if (!ptr)
> > > > + prefixes[0] = 0;
> > > > + else
> > > > + *(ptr) = 0;
> > > > +
> > > > + ptr = strrchr(prefixes, DELIM[0]);
> > > > + if (!ptr)
> > > > + prefixes[0] = 0;
> > > > + else
> > > > + *(ptr + DELIM_LEN) = 0;
> > > > +}
> > > > +#endif /* VERBOSE */
> > > > diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h
> > > > index 619054d03219..bdddb5f72871 100644
> > > > --- a/tools/testing/memblock/tests/common.h
> > > > +++ b/tools/testing/memblock/tests/common.h
> > > > @@ -7,9 +7,47 @@
> > > > #include <linux/types.h>
> > > > #include <linux/memblock.h>
> > > > #include <linux/sizes.h>
> > > > +#include <linux/printk.h>
> > > > +#include <../selftests/kselftest.h>
> > > > #define MEM_SIZE SZ_16K
> > > > +/**
> > > > + * ASSERT_EQ():
> > > > + * Check the condition
> > > > + * @_expected == @_seen
> > > > + * If false, print failed test message (if in VERBOSE mode) and then assert
> > > > + */
> > > > +#define ASSERT_EQ(_expected, _seen) do { \
> > > > + if ((_expected) != (_seen)) \
> > > > + test_fail(); \
> > > > + assert((_expected) == (_seen)); \
> > > > +} while (0)
> > > > +
> > > > +/**
> > > > + * ASSERT_NE():
> > > > + * Check the condition
> > > > + * @_expected != @_seen
> > > > + * If false, print failed test message (if in VERBOSE mode) and then assert
> > > > + */
> > > > +#define ASSERT_NE(_expected, _seen) do { \
> > > > + if ((_expected) == (_seen)) \
> > > > + test_fail(); \
> > > > + assert((_expected) != (_seen)); \
> > > > +} while (0)
> > > > +
> > > > +/**
> > > > + * ASSERT_LT():
> > > > + * Check the condition
> > > > + * @_expected < @_seen
> > > > + * If false, print failed test message (if in VERBOSE mode) and then assert
> > > > + */
> > > > +#define ASSERT_LT(_expected, _seen) do { \
> > > > + if ((_expected) >= (_seen)) \
> > > > + test_fail(); \
> > > > + assert((_expected) < (_seen)); \
> > > > +} while (0)
> > > > +
> > > > /*
> > > > * Available memory registered with memblock needs to be valid for allocs
> > > > * test to run. This is a convenience wrapper for memory allocated in
> > > > @@ -31,4 +69,20 @@ void setup_memblock(void);
> > > > void dummy_physical_memory_init(void);
> > > > void dummy_physical_memory_cleanup(void);
> > > > +#ifdef VERBOSE
> > > > +void test_fail(void);
> > > > +void test_pass(void);
> > > > +void test_print(const char *fmt, ...);
> > > > +void prefix_reset(void);
> > > > +void prefix_push(const char *prefix);
> > > > +void prefix_pop(void);
> > > > +#else
> > > > +static inline void test_fail(void) {}
> > > > +static inline void test_pass(void) {}
> > > > +static inline void test_print(const char *fmt, ...) {}
> > > > +static inline void prefix_reset(void) {}
> > > > +static inline void prefix_push(const char *prefix) {}
> > > > +static inline void prefix_pop(void) {}
> > > > +#endif /* VERBOSE */
> > > > +
> > > > #endif
> >
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 0/4] memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options
2022-06-22 9:29 [PATCH v3 0/4] memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options Rebecca Mckeever
` (5 preceding siblings ...)
2022-06-22 14:17 ` Mike Rapoport
@ 2022-06-23 3:30 ` Ira Weiny
2022-06-23 4:20 ` Rebecca Mckeever
6 siblings, 1 reply; 31+ messages in thread
From: Ira Weiny @ 2022-06-23 3:30 UTC (permalink / raw)
To: Rebecca Mckeever; +Cc: Mike Rapoport, linux-mm, linux-kernel, David Hildenbrand
On Wed, Jun 22, 2022 at 04:29:05AM -0500, Rebecca Mckeever wrote:
> These patches add options VERBOSE and MEMBLOCK_DEBUG to Memblock
> simulator, which can be specified when running make. These patches also
> implement the functionality for these options.
I seem to be missing patch 3/4 and I don't see it on lore?
https://lore.kernel.org/linux-mm/004e021cc3cb7be8749361b3b1cb324459b9cb9f.1655889641.git.remckee0@gmail.com/
Did it get sent? Did it define the ASSERT_*() macros?
Ira
>
> VERBOSE
> Usage:
>
> $ make VERBOSE=1
>
> Passing VERBOSE=1 will enable verbose output from Memblock simulator. For
> each test, the verbose output includes the name of the memblock function
> being tested, the name of the test, and whether the test passed or failed.
> Since all the tests in Memblock simulator run as one monolithic test, this
> output is a quick way to get a summary of test results.
>
> MEMBLOCK_DEBUG
> Usage:
>
> $ make MEMBLOCK_DEBUG=1
>
> Passing MEMBLOCK_DEBUG=1 will enable memblock_dbg() messages. These
> are debug messages built into several functions in memblock that include
> information such as the name of the function and the size and start and
> end addresses of the memblock region.
>
> Rebecca Mckeever (4):
> memblock tests: add user-provided arguments to Makefile
> memblock tests: add verbose output to memblock tests
> memblock tests: set memblock_debug to enable memblock_dbg() messages
> memblock tests: remove completed TODO items
>
> tools/testing/memblock/Makefile | 4 +
> tools/testing/memblock/README | 10 +-
> tools/testing/memblock/TODO | 14 +-
> tools/testing/memblock/internal.h | 7 +
> .../testing/memblock/scripts/Makefile.include | 10 +
> tools/testing/memblock/tests/alloc_api.c | 241 ++++++++----
> .../memblock/tests/alloc_helpers_api.c | 135 +++++--
> tools/testing/memblock/tests/alloc_nid_api.c | 371 ++++++++++++------
> tools/testing/memblock/tests/basic_api.c | 365 ++++++++++++-----
> tools/testing/memblock/tests/common.c | 58 +++
> tools/testing/memblock/tests/common.h | 54 +++
> 11 files changed, 913 insertions(+), 356 deletions(-)
>
> ---
> Changes
>
> v1 -> v2
> PATCH 2, in common.c:
> Remove #ifdef VERBOSE around prefixes and related constants
> Add __maybe_unused to prefixes
> Move PREFIXES_LEN_MAX, DELIM, and DELIM_LEN so that they are
> immediately after the other constants
> Add #ifdef VERBOSE around definitions for test_*() and prefix_*()
>
> v2 -> v3
> PATCH 1:
> Add Reviewed-by tag
> ---
>
> --
> 2.34.1
>
>
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 2/4] memblock tests: add verbose output to memblock tests
2022-06-22 9:29 ` [PATCH v3 2/4] memblock tests: add verbose output to memblock tests Rebecca Mckeever
2022-06-22 10:32 ` Huang, Shaoqin
@ 2022-06-23 3:37 ` Ira Weiny
2022-06-23 7:25 ` Rebecca Mckeever
2022-06-23 4:30 ` Mike Rapoport
2 siblings, 1 reply; 31+ messages in thread
From: Ira Weiny @ 2022-06-23 3:37 UTC (permalink / raw)
To: Rebecca Mckeever; +Cc: Mike Rapoport, linux-mm, linux-kernel, David Hildenbrand
On Wed, Jun 22, 2022 at 04:29:07AM -0500, Rebecca Mckeever wrote:
> Add and use functions for printing verbose testing output.
>
> If the Memblock simulator was compiled with VERBOSE=1:
> prefix_push() appends the given string to a prefix string that will be
> printed in the test functions.
> prefix_pop() removes the last prefix from the prefix string.
> prefix_reset() clears the prefix string.
> test_fail() prints a message after a test fails containing the test
> number of the failing test and the prefix.
> test_pass() prints a message after a test passes containing its test
> number and the prefix.
> test_print() prints the given formatted output string.
>
> If the Memblock simulator was not compiled with VERBOSE=1, these
> functions do nothing.
>
> Add the assert wrapper macros ASSERT_EQ(), ASSERT_NE(), and ASSERT_LT().
> If the assert condition fails, these macros call test_fail() before
> executing assert().
The VERBOSE=1 change and the use of ASSERT_*() macros seem to be doing 2
different things.
Does patch 3/4 modify ASSERT_*() to use the prefix? If so this kind of ties
the 2 changes together. However, I think I would split it into 2 patches
anyway.
Ira
>
> Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> ---
> tools/testing/memblock/tests/alloc_api.c | 241 ++++++++----
> .../memblock/tests/alloc_helpers_api.c | 135 +++++--
> tools/testing/memblock/tests/alloc_nid_api.c | 371 ++++++++++++------
> tools/testing/memblock/tests/basic_api.c | 365 ++++++++++++-----
> tools/testing/memblock/tests/common.c | 58 +++
> tools/testing/memblock/tests/common.h | 54 +++
> 6 files changed, 880 insertions(+), 344 deletions(-)
>
> diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
> index d1aa7e15c18d..96df033d4300 100644
> --- a/tools/testing/memblock/tests/alloc_api.c
> +++ b/tools/testing/memblock/tests/alloc_api.c
> @@ -10,6 +10,8 @@ static int alloc_top_down_simple_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_2;
> phys_addr_t expected_start;
>
> @@ -19,12 +21,15 @@ static int alloc_top_down_simple_check(void)
>
> allocated_ptr = memblock_alloc(size, SMP_CACHE_BYTES);
>
> - assert(allocated_ptr);
> - assert(rgn->size == size);
> - assert(rgn->base == expected_start);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, expected_start);
> +
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -55,6 +60,8 @@ static int alloc_top_down_disjoint_check(void)
> struct region r1;
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r2_size = SZ_16;
> /* Use custom alignment */
> phys_addr_t alignment = SMP_CACHE_BYTES * 2;
> @@ -73,15 +80,18 @@ static int alloc_top_down_disjoint_check(void)
>
> allocated_ptr = memblock_alloc(r2_size, alignment);
>
> - assert(allocated_ptr);
> - assert(rgn1->size == r1.size);
> - assert(rgn1->base == r1.base);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn1->size, r1.size);
> + ASSERT_EQ(rgn1->base, r1.base);
>
> - assert(rgn2->size == r2_size);
> - assert(rgn2->base == expected_start);
> + ASSERT_EQ(rgn2->size, r2_size);
> + ASSERT_EQ(rgn2->base, expected_start);
>
> - assert(memblock.reserved.cnt == 2);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 2);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -101,6 +111,8 @@ static int alloc_top_down_before_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> /*
> * The first region ends at the aligned address to test region merging
> */
> @@ -114,12 +126,15 @@ static int alloc_top_down_before_check(void)
>
> allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
>
> - assert(allocated_ptr);
> - assert(rgn->size == total_size);
> - assert(rgn->base == memblock_end_of_DRAM() - total_size);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, total_size);
> + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - total_size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -141,6 +156,8 @@ static int alloc_top_down_after_check(void)
> struct region r1;
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r2_size = SZ_512;
> phys_addr_t total_size;
>
> @@ -158,12 +175,15 @@ static int alloc_top_down_after_check(void)
>
> allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
>
> - assert(allocated_ptr);
> - assert(rgn->size == total_size);
> - assert(rgn->base == r1.base - r2_size);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, total_size);
> + ASSERT_EQ(rgn->base, r1.base - r2_size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -186,6 +206,8 @@ static int alloc_top_down_second_fit_check(void)
> struct region r1, r2;
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r3_size = SZ_1K;
> phys_addr_t total_size;
>
> @@ -204,12 +226,15 @@ static int alloc_top_down_second_fit_check(void)
>
> allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
>
> - assert(allocated_ptr);
> - assert(rgn->size == r2.size + r3_size);
> - assert(rgn->base == r2.base - r3_size);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, r2.size + r3_size);
> + ASSERT_EQ(rgn->base, r2.base - r3_size);
>
> - assert(memblock.reserved.cnt == 2);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 2);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -231,6 +256,8 @@ static int alloc_in_between_generic_check(void)
> struct region r1, r2;
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t gap_size = SMP_CACHE_BYTES;
> phys_addr_t r3_size = SZ_64;
> /*
> @@ -254,12 +281,15 @@ static int alloc_in_between_generic_check(void)
>
> allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
>
> - assert(allocated_ptr);
> - assert(rgn->size == total_size);
> - assert(rgn->base == r1.base - r2.size - r3_size);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, total_size);
> + ASSERT_EQ(rgn->base, r1.base - r2.size - r3_size);
> +
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -281,6 +311,8 @@ static int alloc_small_gaps_generic_check(void)
> {
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t region_size = SZ_1K;
> phys_addr_t gap_size = SZ_256;
> phys_addr_t region_end;
> @@ -296,7 +328,10 @@ static int alloc_small_gaps_generic_check(void)
>
> allocated_ptr = memblock_alloc(region_size, SMP_CACHE_BYTES);
>
> - assert(!allocated_ptr);
> + ASSERT_EQ(allocated_ptr, NULL);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -309,6 +344,8 @@ static int alloc_all_reserved_generic_check(void)
> {
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> setup_memblock();
>
> /* Simulate full memory */
> @@ -316,7 +353,10 @@ static int alloc_all_reserved_generic_check(void)
>
> allocated_ptr = memblock_alloc(SZ_256, SMP_CACHE_BYTES);
>
> - assert(!allocated_ptr);
> + ASSERT_EQ(allocated_ptr, NULL);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -338,6 +378,8 @@ static int alloc_no_space_generic_check(void)
> {
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> setup_memblock();
>
> phys_addr_t available_size = SZ_256;
> @@ -348,7 +390,10 @@ static int alloc_no_space_generic_check(void)
>
> allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
>
> - assert(!allocated_ptr);
> + ASSERT_EQ(allocated_ptr, NULL);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -369,6 +414,8 @@ static int alloc_limited_space_generic_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t available_size = SZ_256;
> phys_addr_t reserved_size = MEM_SIZE - available_size;
>
> @@ -379,12 +426,15 @@ static int alloc_limited_space_generic_check(void)
>
> allocated_ptr = memblock_alloc(available_size, SMP_CACHE_BYTES);
>
> - assert(allocated_ptr);
> - assert(rgn->size == MEM_SIZE);
> - assert(rgn->base == memblock_start_of_DRAM());
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, MEM_SIZE);
> + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> +
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, MEM_SIZE);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == MEM_SIZE);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -399,14 +449,19 @@ static int alloc_no_memory_generic_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
>
> allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
>
> - assert(!allocated_ptr);
> - assert(rgn->size == 0);
> - assert(rgn->base == 0);
> - assert(memblock.reserved.total_size == 0);
> + ASSERT_EQ(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, 0);
> + ASSERT_EQ(rgn->base, 0);
> + ASSERT_EQ(memblock.reserved.total_size, 0);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -421,16 +476,21 @@ static int alloc_bottom_up_simple_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> setup_memblock();
>
> allocated_ptr = memblock_alloc(SZ_2, SMP_CACHE_BYTES);
>
> - assert(allocated_ptr);
> - assert(rgn->size == SZ_2);
> - assert(rgn->base == memblock_start_of_DRAM());
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, SZ_2);
> + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == SZ_2);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, SZ_2);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -459,6 +519,8 @@ static int alloc_bottom_up_disjoint_check(void)
> struct region r1;
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r2_size = SZ_16;
> /* Use custom alignment */
> phys_addr_t alignment = SMP_CACHE_BYTES * 2;
> @@ -477,16 +539,19 @@ static int alloc_bottom_up_disjoint_check(void)
>
> allocated_ptr = memblock_alloc(r2_size, alignment);
>
> - assert(allocated_ptr);
> + ASSERT_NE(allocated_ptr, NULL);
>
> - assert(rgn1->size == r1.size);
> - assert(rgn1->base == r1.base);
> + ASSERT_EQ(rgn1->size, r1.size);
> + ASSERT_EQ(rgn1->base, r1.base);
>
> - assert(rgn2->size == r2_size);
> - assert(rgn2->base == expected_start);
> + ASSERT_EQ(rgn2->size, r2_size);
> + ASSERT_EQ(rgn2->base, expected_start);
>
> - assert(memblock.reserved.cnt == 2);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 2);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -506,6 +571,8 @@ static int alloc_bottom_up_before_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r1_size = SZ_512;
> phys_addr_t r2_size = SZ_128;
> phys_addr_t total_size = r1_size + r2_size;
> @@ -516,12 +583,15 @@ static int alloc_bottom_up_before_check(void)
>
> allocated_ptr = memblock_alloc(r1_size, SMP_CACHE_BYTES);
>
> - assert(allocated_ptr);
> - assert(rgn->size == total_size);
> - assert(rgn->base == memblock_start_of_DRAM());
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, total_size);
> + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -542,6 +612,8 @@ static int alloc_bottom_up_after_check(void)
> struct region r1;
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r2_size = SZ_512;
> phys_addr_t total_size;
>
> @@ -559,12 +631,15 @@ static int alloc_bottom_up_after_check(void)
>
> allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
>
> - assert(allocated_ptr);
> - assert(rgn->size == total_size);
> - assert(rgn->base == r1.base);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, total_size);
> + ASSERT_EQ(rgn->base, r1.base);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -588,6 +663,8 @@ static int alloc_bottom_up_second_fit_check(void)
> struct region r1, r2;
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r3_size = SZ_1K;
> phys_addr_t total_size;
>
> @@ -606,12 +683,15 @@ static int alloc_bottom_up_second_fit_check(void)
>
> allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
>
> - assert(allocated_ptr);
> - assert(rgn->size == r2.size + r3_size);
> - assert(rgn->base == r2.base);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, r2.size + r3_size);
> + ASSERT_EQ(rgn->base, r2.base);
>
> - assert(memblock.reserved.cnt == 2);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 2);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -619,6 +699,7 @@ static int alloc_bottom_up_second_fit_check(void)
> /* Test case wrappers */
> static int alloc_simple_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_top_down_simple_check();
> memblock_set_bottom_up(true);
> @@ -629,6 +710,7 @@ static int alloc_simple_check(void)
>
> static int alloc_disjoint_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_top_down_disjoint_check();
> memblock_set_bottom_up(true);
> @@ -639,6 +721,7 @@ static int alloc_disjoint_check(void)
>
> static int alloc_before_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_top_down_before_check();
> memblock_set_bottom_up(true);
> @@ -649,6 +732,7 @@ static int alloc_before_check(void)
>
> static int alloc_after_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_top_down_after_check();
> memblock_set_bottom_up(true);
> @@ -659,6 +743,7 @@ 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);
> @@ -669,6 +754,7 @@ static int alloc_in_between_check(void)
>
> static int alloc_second_fit_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_top_down_second_fit_check();
> memblock_set_bottom_up(true);
> @@ -679,6 +765,7 @@ 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);
> @@ -689,6 +776,7 @@ 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);
> @@ -699,6 +787,7 @@ 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);
> @@ -709,6 +798,7 @@ 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);
> @@ -719,6 +809,7 @@ 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);
> @@ -729,6 +820,12 @@ static int alloc_no_memory_check(void)
>
> int memblock_alloc_checks(void)
> {
> + static const char func_testing[] = "memblock_alloc";
> +
> + prefix_reset();
> + prefix_push(func_testing);
> + test_print("Running %s tests...\n", func_testing);
> +
> reset_memblock_attributes();
> dummy_physical_memory_init();
>
> @@ -746,5 +843,7 @@ int memblock_alloc_checks(void)
>
> dummy_physical_memory_cleanup();
>
> + prefix_pop();
> +
> return 0;
> }
> diff --git a/tools/testing/memblock/tests/alloc_helpers_api.c b/tools/testing/memblock/tests/alloc_helpers_api.c
> index 963a966db461..f6eaed540427 100644
> --- a/tools/testing/memblock/tests/alloc_helpers_api.c
> +++ b/tools/testing/memblock/tests/alloc_helpers_api.c
> @@ -21,6 +21,8 @@ static int alloc_from_simple_generic_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_16;
> phys_addr_t min_addr;
>
> @@ -31,14 +33,17 @@ static int alloc_from_simple_generic_check(void)
> allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, min_addr);
>
> - assert(rgn->size == size);
> - assert(rgn->base == min_addr);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -64,6 +69,8 @@ static int alloc_from_misaligned_generic_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_32;
> phys_addr_t min_addr;
>
> @@ -75,14 +82,17 @@ static int alloc_from_misaligned_generic_check(void)
> allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
>
> - assert(rgn->size == size);
> - assert(rgn->base == memblock_end_of_DRAM() - SMP_CACHE_BYTES);
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - SMP_CACHE_BYTES);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -110,6 +120,8 @@ static int alloc_from_top_down_high_addr_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_32;
> phys_addr_t min_addr;
>
> @@ -120,12 +132,15 @@ static int alloc_from_top_down_high_addr_check(void)
>
> allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
>
> - assert(allocated_ptr);
> - assert(rgn->size == size);
> - assert(rgn->base == memblock_end_of_DRAM() - SMP_CACHE_BYTES);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - SMP_CACHE_BYTES);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -151,6 +166,8 @@ static int alloc_from_top_down_no_space_above_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r1_size = SZ_64;
> phys_addr_t r2_size = SZ_2;
> phys_addr_t total_size = r1_size + r2_size;
> @@ -165,12 +182,15 @@ static int alloc_from_top_down_no_space_above_check(void)
>
> allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
>
> - assert(allocated_ptr);
> - assert(rgn->base == min_addr - r1_size);
> - assert(rgn->size == total_size);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->base, min_addr - r1_size);
> + ASSERT_EQ(rgn->size, total_size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -186,6 +206,8 @@ static int alloc_from_top_down_min_addr_cap_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r1_size = SZ_64;
> phys_addr_t min_addr;
> phys_addr_t start_addr;
> @@ -199,12 +221,15 @@ static int alloc_from_top_down_min_addr_cap_check(void)
>
> allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
>
> - assert(allocated_ptr);
> - assert(rgn->base == start_addr);
> - assert(rgn->size == MEM_SIZE);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->base, start_addr);
> + ASSERT_EQ(rgn->size, MEM_SIZE);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == MEM_SIZE);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, MEM_SIZE);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -230,6 +255,8 @@ static int alloc_from_bottom_up_high_addr_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_32;
> phys_addr_t min_addr;
>
> @@ -240,12 +267,15 @@ static int alloc_from_bottom_up_high_addr_check(void)
>
> allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
>
> - assert(allocated_ptr);
> - assert(rgn->size == size);
> - assert(rgn->base == memblock_start_of_DRAM());
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> +
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -270,6 +300,8 @@ static int alloc_from_bottom_up_no_space_above_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r1_size = SZ_64;
> phys_addr_t min_addr;
> phys_addr_t r2_size;
> @@ -284,12 +316,15 @@ static int alloc_from_bottom_up_no_space_above_check(void)
>
> allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
>
> - assert(allocated_ptr);
> - assert(rgn->base == memblock_start_of_DRAM());
> - assert(rgn->size == r1_size);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> + ASSERT_EQ(rgn->size, r1_size);
> +
> + ASSERT_EQ(memblock.reserved.cnt, 2);
> + ASSERT_EQ(memblock.reserved.total_size, r1_size + r2_size);
>
> - assert(memblock.reserved.cnt == 2);
> - assert(memblock.reserved.total_size == r1_size + r2_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -304,6 +339,8 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
> struct memblock_region *rgn = &memblock.reserved.regions[0];
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t r1_size = SZ_64;
> phys_addr_t min_addr;
> phys_addr_t start_addr;
> @@ -315,12 +352,15 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
>
> allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
>
> - assert(allocated_ptr);
> - assert(rgn->base == start_addr);
> - assert(rgn->size == r1_size);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(rgn->base, start_addr);
> + ASSERT_EQ(rgn->size, r1_size);
> +
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, r1_size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == r1_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -328,6 +368,7 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
> /* Test case wrappers */
> 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);
> @@ -338,6 +379,7 @@ 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);
> @@ -348,6 +390,7 @@ static int alloc_from_misaligned_check(void)
>
> static int alloc_from_high_addr_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_from_top_down_high_addr_check();
> memblock_set_bottom_up(true);
> @@ -358,6 +401,7 @@ static int alloc_from_high_addr_check(void)
>
> static int alloc_from_no_space_above_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_from_top_down_no_space_above_check();
> memblock_set_bottom_up(true);
> @@ -368,6 +412,7 @@ static int alloc_from_no_space_above_check(void)
>
> static int alloc_from_min_addr_cap_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_from_top_down_min_addr_cap_check();
> memblock_set_bottom_up(true);
> @@ -378,6 +423,12 @@ static int alloc_from_min_addr_cap_check(void)
>
> int memblock_alloc_helpers_checks(void)
> {
> + static const char func_testing[] = "memblock_alloc_from";
> +
> + prefix_reset();
> + prefix_push(func_testing);
> + test_print("Running %s tests...\n", func_testing);
> +
> reset_memblock_attributes();
> dummy_physical_memory_init();
>
> diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
> index 6390206e50e1..601f4a7ee30d 100644
> --- a/tools/testing/memblock/tests/alloc_nid_api.c
> +++ b/tools/testing/memblock/tests/alloc_nid_api.c
> @@ -21,6 +21,8 @@ static int alloc_try_nid_top_down_simple_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_128;
> phys_addr_t min_addr;
> phys_addr_t max_addr;
> @@ -36,15 +38,18 @@ static int alloc_try_nid_top_down_simple_check(void)
> b = (char *)allocated_ptr;
> rgn_end = rgn->base + rgn->size;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, max_addr - size);
> + ASSERT_EQ(rgn_end, max_addr);
>
> - assert(rgn->size == size);
> - assert(rgn->base == max_addr - size);
> - assert(rgn_end == max_addr);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -72,6 +77,8 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_128;
> phys_addr_t misalign = SZ_2;
> phys_addr_t min_addr;
> @@ -88,15 +95,18 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
> b = (char *)allocated_ptr;
> rgn_end = rgn->base + rgn->size;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
>
> - assert(rgn->size == size);
> - assert(rgn->base == max_addr - size - misalign);
> - assert(rgn_end < max_addr);
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, max_addr - size - misalign);
> + ASSERT_LT(rgn_end, max_addr);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -122,6 +132,8 @@ static int alloc_try_nid_exact_address_generic_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_1K;
> phys_addr_t min_addr;
> phys_addr_t max_addr;
> @@ -137,15 +149,18 @@ static int alloc_try_nid_exact_address_generic_check(void)
> b = (char *)allocated_ptr;
> rgn_end = rgn->base + rgn->size;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, min_addr);
> + ASSERT_EQ(rgn_end, max_addr);
>
> - assert(rgn->size == size);
> - assert(rgn->base == min_addr);
> - assert(rgn_end == max_addr);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -173,6 +188,8 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_256;
> phys_addr_t min_addr;
> phys_addr_t max_addr;
> @@ -186,14 +203,17 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
> min_addr, max_addr, NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, max_addr - size);
>
> - assert(rgn->size == size);
> - assert(rgn->base == max_addr - size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -222,6 +242,8 @@ static int alloc_try_nid_low_max_generic_check(void)
> {
> void *allocated_ptr = NULL;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_1K;
> phys_addr_t min_addr;
> phys_addr_t max_addr;
> @@ -234,7 +256,10 @@ static int alloc_try_nid_low_max_generic_check(void)
> allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> min_addr, max_addr, NUMA_NO_NODE);
>
> - assert(!allocated_ptr);
> + ASSERT_EQ(allocated_ptr, NULL);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -259,6 +284,8 @@ static int alloc_try_nid_min_reserved_generic_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t r1_size = SZ_128;
> phys_addr_t r2_size = SZ_64;
> phys_addr_t total_size = r1_size + r2_size;
> @@ -278,14 +305,17 @@ static int alloc_try_nid_min_reserved_generic_check(void)
> min_addr, max_addr, NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
>
> - assert(rgn->size == total_size);
> - assert(rgn->base == reserved_base);
> + ASSERT_EQ(rgn->size, total_size);
> + ASSERT_EQ(rgn->base, reserved_base);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -310,6 +340,8 @@ static int alloc_try_nid_max_reserved_generic_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t r1_size = SZ_64;
> phys_addr_t r2_size = SZ_128;
> phys_addr_t total_size = r1_size + r2_size;
> @@ -327,14 +359,17 @@ static int alloc_try_nid_max_reserved_generic_check(void)
> min_addr, max_addr, NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn->size, total_size);
> + ASSERT_EQ(rgn->base, min_addr);
>
> - assert(rgn->size == total_size);
> - assert(rgn->base == min_addr);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -364,6 +399,8 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
> char *b;
> struct region r1, r2;
>
> + prefix_push(__func__);
> +
> phys_addr_t r3_size = SZ_64;
> phys_addr_t gap_size = SMP_CACHE_BYTES;
> phys_addr_t total_size;
> @@ -389,17 +426,20 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
> min_addr, max_addr, NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn1->size, r1.size + r3_size);
> + ASSERT_EQ(rgn1->base, max_addr - r3_size);
>
> - assert(rgn1->size == r1.size + r3_size);
> - assert(rgn1->base == max_addr - r3_size);
> + ASSERT_EQ(rgn2->size, r2.size);
> + ASSERT_EQ(rgn2->base, r2.base);
>
> - assert(rgn2->size == r2.size);
> - assert(rgn2->base == r2.base);
> + ASSERT_EQ(memblock.reserved.cnt, 2);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>
> - assert(memblock.reserved.cnt == 2);
> - assert(memblock.reserved.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -427,6 +467,8 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
> char *b;
> struct region r1, r2;
>
> + prefix_push(__func__);
> +
> phys_addr_t r3_size = SZ_64;
> phys_addr_t total_size;
> phys_addr_t max_addr;
> @@ -451,14 +493,17 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
> min_addr, max_addr, NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
>
> - assert(rgn->size == total_size);
> - assert(rgn->base == r2.base);
> + ASSERT_EQ(rgn->size, total_size);
> + ASSERT_EQ(rgn->base, r2.base);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -489,6 +534,8 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
> char *b;
> struct region r1, r2;
>
> + prefix_push(__func__);
> +
> phys_addr_t r3_size = SZ_256;
> phys_addr_t gap_size = SMP_CACHE_BYTES;
> phys_addr_t total_size;
> @@ -514,17 +561,20 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
> min_addr, max_addr, NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn1->size, r1.size);
> + ASSERT_EQ(rgn1->base, r1.base);
>
> - assert(rgn1->size == r1.size);
> - assert(rgn1->base == r1.base);
> + ASSERT_EQ(rgn2->size, r2.size + r3_size);
> + ASSERT_EQ(rgn2->base, r2.base - r3_size);
>
> - assert(rgn2->size == r2.size + r3_size);
> - assert(rgn2->base == r2.base - r3_size);
> + ASSERT_EQ(memblock.reserved.cnt, 2);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>
> - assert(memblock.reserved.cnt == 2);
> - assert(memblock.reserved.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -554,6 +604,8 @@ static int alloc_try_nid_reserved_all_generic_check(void)
> void *allocated_ptr = NULL;
> struct region r1, r2;
>
> + prefix_push(__func__);
> +
> phys_addr_t r3_size = SZ_256;
> phys_addr_t gap_size = SMP_CACHE_BYTES;
> phys_addr_t max_addr;
> @@ -576,7 +628,10 @@ static int alloc_try_nid_reserved_all_generic_check(void)
> allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
> min_addr, max_addr, NUMA_NO_NODE);
>
> - assert(!allocated_ptr);
> + ASSERT_EQ(allocated_ptr, NULL);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -592,6 +647,8 @@ static int alloc_try_nid_top_down_cap_max_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_256;
> phys_addr_t min_addr;
> phys_addr_t max_addr;
> @@ -605,14 +662,17 @@ static int alloc_try_nid_top_down_cap_max_check(void)
> min_addr, max_addr, NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
>
> - assert(rgn->size == size);
> - assert(rgn->base == memblock_end_of_DRAM() - size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -628,6 +688,8 @@ static int alloc_try_nid_top_down_cap_min_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_1K;
> phys_addr_t min_addr;
> phys_addr_t max_addr;
> @@ -641,14 +703,17 @@ static int alloc_try_nid_top_down_cap_min_check(void)
> min_addr, max_addr, NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
>
> - assert(rgn->size == size);
> - assert(rgn->base == memblock_end_of_DRAM() - size);
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -673,6 +738,8 @@ static int alloc_try_nid_bottom_up_simple_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_128;
> phys_addr_t min_addr;
> phys_addr_t max_addr;
> @@ -689,15 +756,18 @@ static int alloc_try_nid_bottom_up_simple_check(void)
> b = (char *)allocated_ptr;
> rgn_end = rgn->base + rgn->size;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, min_addr);
> + ASSERT_LT(rgn_end, max_addr);
>
> - assert(rgn->size == size);
> - assert(rgn->base == min_addr);
> - assert(rgn_end < max_addr);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -725,6 +795,8 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_128;
> phys_addr_t misalign = SZ_2;
> phys_addr_t min_addr;
> @@ -742,15 +814,18 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
> b = (char *)allocated_ptr;
> rgn_end = rgn->base + rgn->size;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, min_addr + (SMP_CACHE_BYTES - misalign));
> + ASSERT_LT(rgn_end, max_addr);
>
> - assert(rgn->size == size);
> - assert(rgn->base == min_addr + (SMP_CACHE_BYTES - misalign));
> - assert(rgn_end < max_addr);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -778,6 +853,8 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_256;
> phys_addr_t min_addr;
> phys_addr_t max_addr;
> @@ -792,14 +869,17 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
> NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
>
> - assert(rgn->size == size);
> - assert(rgn->base == memblock_start_of_DRAM());
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -829,6 +909,8 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
> char *b;
> struct region r1, r2;
>
> + prefix_push(__func__);
> +
> phys_addr_t r3_size = SZ_64;
> phys_addr_t gap_size = SMP_CACHE_BYTES;
> phys_addr_t total_size;
> @@ -855,17 +937,20 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
> NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
>
> - assert(rgn1->size == r1.size);
> - assert(rgn1->base == max_addr);
> + ASSERT_EQ(rgn1->size, r1.size);
> + ASSERT_EQ(rgn1->base, max_addr);
>
> - assert(rgn2->size == r2.size + r3_size);
> - assert(rgn2->base == r2.base);
> + ASSERT_EQ(rgn2->size, r2.size + r3_size);
> + ASSERT_EQ(rgn2->base, r2.base);
>
> - assert(memblock.reserved.cnt == 2);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 2);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -899,6 +984,8 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
> char *b;
> struct region r1, r2;
>
> + prefix_push(__func__);
> +
> phys_addr_t r3_size = SZ_256;
> phys_addr_t gap_size = SMP_CACHE_BYTES;
> phys_addr_t total_size;
> @@ -925,20 +1012,23 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
> NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn3->size, r3_size);
> + ASSERT_EQ(rgn3->base, memblock_start_of_DRAM());
>
> - assert(rgn3->size == r3_size);
> - assert(rgn3->base == memblock_start_of_DRAM());
> + ASSERT_EQ(rgn2->size, r2.size);
> + ASSERT_EQ(rgn2->base, r2.base);
>
> - assert(rgn2->size == r2.size);
> - assert(rgn2->base == r2.base);
> + ASSERT_EQ(rgn1->size, r1.size);
> + ASSERT_EQ(rgn1->base, r1.base);
>
> - assert(rgn1->size == r1.size);
> - assert(rgn1->base == r1.base);
> + ASSERT_EQ(memblock.reserved.cnt, 3);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>
> - assert(memblock.reserved.cnt == 3);
> - assert(memblock.reserved.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -954,6 +1044,8 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_256;
> phys_addr_t min_addr;
> phys_addr_t max_addr;
> @@ -968,14 +1060,17 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
> NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, min_addr);
>
> - assert(rgn->size == size);
> - assert(rgn->base == min_addr);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -991,6 +1086,8 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
> void *allocated_ptr = NULL;
> char *b;
>
> + prefix_push(__func__);
> +
> phys_addr_t size = SZ_1K;
> phys_addr_t min_addr;
> phys_addr_t max_addr;
> @@ -1005,14 +1102,17 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
> NUMA_NO_NODE);
> b = (char *)allocated_ptr;
>
> - assert(allocated_ptr);
> - assert(*b == 0);
> + ASSERT_NE(allocated_ptr, NULL);
> + ASSERT_EQ(*b, 0);
> +
> + ASSERT_EQ(rgn->size, size);
> + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
>
> - assert(rgn->size == size);
> - assert(rgn->base == memblock_start_of_DRAM());
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -1020,6 +1120,7 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
> /* Test case wrappers */
> static int alloc_try_nid_simple_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_try_nid_top_down_simple_check();
> memblock_set_bottom_up(true);
> @@ -1030,6 +1131,7 @@ static int alloc_try_nid_simple_check(void)
>
> static int alloc_try_nid_misaligned_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_try_nid_top_down_end_misaligned_check();
> memblock_set_bottom_up(true);
> @@ -1040,6 +1142,7 @@ static int alloc_try_nid_misaligned_check(void)
>
> static int alloc_try_nid_narrow_range_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_try_nid_top_down_narrow_range_check();
> memblock_set_bottom_up(true);
> @@ -1050,6 +1153,7 @@ static int alloc_try_nid_narrow_range_check(void)
>
> static int alloc_try_nid_reserved_with_space_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_try_nid_top_down_reserved_with_space_check();
> memblock_set_bottom_up(true);
> @@ -1060,6 +1164,7 @@ static int alloc_try_nid_reserved_with_space_check(void)
>
> static int alloc_try_nid_reserved_no_space_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_try_nid_top_down_reserved_no_space_check();
> memblock_set_bottom_up(true);
> @@ -1070,6 +1175,7 @@ static int alloc_try_nid_reserved_no_space_check(void)
>
> static int alloc_try_nid_cap_max_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_try_nid_top_down_cap_max_check();
> memblock_set_bottom_up(true);
> @@ -1080,6 +1186,7 @@ static int alloc_try_nid_cap_max_check(void)
>
> static int alloc_try_nid_cap_min_check(void)
> {
> + test_print("\tRunning %s...\n", __func__);
> memblock_set_bottom_up(false);
> alloc_try_nid_top_down_cap_min_check();
> memblock_set_bottom_up(true);
> @@ -1090,6 +1197,7 @@ 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);
> @@ -1100,6 +1208,7 @@ 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);
> @@ -1110,6 +1219,7 @@ 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);
> @@ -1120,6 +1230,7 @@ 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);
> @@ -1130,6 +1241,7 @@ 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);
> @@ -1140,6 +1252,7 @@ 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);
> @@ -1150,6 +1263,12 @@ static int alloc_try_nid_low_max_check(void)
>
> int memblock_alloc_nid_checks(void)
> {
> + static const char func_testing[] = "memblock_alloc_try_nid";
> +
> + prefix_reset();
> + prefix_push(func_testing);
> + test_print("Running %s tests...\n", func_testing);
> +
> reset_memblock_attributes();
> dummy_physical_memory_init();
>
> @@ -1170,5 +1289,7 @@ int memblock_alloc_nid_checks(void)
>
> dummy_physical_memory_cleanup();
>
> + prefix_pop();
> +
> return 0;
> }
> diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c
> index a7bc180316d6..f223a9a57be7 100644
> --- a/tools/testing/memblock/tests/basic_api.c
> +++ b/tools/testing/memblock/tests/basic_api.c
> @@ -4,21 +4,30 @@
> #include "basic_api.h"
>
> #define EXPECTED_MEMBLOCK_REGIONS 128
> +#define FUNC_ADD "memblock_add"
> +#define FUNC_RESERVE "memblock_reserve"
> +#define FUNC_REMOVE "memblock_remove"
> +#define FUNC_FREE "memblock_free"
>
> static int memblock_initialization_check(void)
> {
> - assert(memblock.memory.regions);
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
> - assert(strcmp(memblock.memory.name, "memory") == 0);
> + prefix_push(__func__);
>
> - assert(memblock.reserved.regions);
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
> - assert(strcmp(memblock.reserved.name, "reserved") == 0);
> + ASSERT_NE(memblock.memory.regions, NULL);
> + ASSERT_EQ(memblock.memory.cnt, 1);
> + ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
> + ASSERT_EQ(strcmp(memblock.memory.name, "memory"), 0);
>
> - assert(!memblock.bottom_up);
> - assert(memblock.current_limit == MEMBLOCK_ALLOC_ANYWHERE);
> + ASSERT_NE(memblock.reserved.regions, NULL);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
> + ASSERT_EQ(strcmp(memblock.reserved.name, "reserved"), 0);
> +
> + ASSERT_EQ(memblock.bottom_up, false);
> + ASSERT_EQ(memblock.current_limit, MEMBLOCK_ALLOC_ANYWHERE);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -40,14 +49,19 @@ static int memblock_add_simple_check(void)
> .size = SZ_4M
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_add(r.base, r.size);
>
> - assert(rgn->base == r.base);
> - assert(rgn->size == r.size);
> + ASSERT_EQ(rgn->base, r.base);
> + ASSERT_EQ(rgn->size, r.size);
> +
> + ASSERT_EQ(memblock.memory.cnt, 1);
> + ASSERT_EQ(memblock.memory.total_size, r.size);
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == r.size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -69,18 +83,27 @@ static int memblock_add_node_simple_check(void)
> .size = SZ_16M
> };
>
> + prefix_pop();
> + prefix_push("memblock_add_node");
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_add_node(r.base, r.size, 1, MEMBLOCK_HOTPLUG);
>
> - assert(rgn->base == r.base);
> - assert(rgn->size == r.size);
> + ASSERT_EQ(rgn->base, r.base);
> + ASSERT_EQ(rgn->size, r.size);
> #ifdef CONFIG_NUMA
> - assert(rgn->nid == 1);
> + ASSERT_EQ(rgn->nid, 1);
> #endif
> - assert(rgn->flags == MEMBLOCK_HOTPLUG);
> + ASSERT_EQ(rgn->flags, MEMBLOCK_HOTPLUG);
> +
> + ASSERT_EQ(memblock.memory.cnt, 1);
> + ASSERT_EQ(memblock.memory.total_size, r.size);
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == r.size);
> + test_pass();
> + prefix_pop();
> + prefix_pop();
> + prefix_push(FUNC_ADD);
>
> return 0;
> }
> @@ -113,18 +136,23 @@ static int memblock_add_disjoint_check(void)
> .size = SZ_8K
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_add(r1.base, r1.size);
> memblock_add(r2.base, r2.size);
>
> - assert(rgn1->base == r1.base);
> - assert(rgn1->size == r1.size);
> + 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(rgn2->base == r2.base);
> - assert(rgn2->size == r2.size);
> + ASSERT_EQ(memblock.memory.cnt, 2);
> + ASSERT_EQ(memblock.memory.total_size, r1.size + r2.size);
>
> - assert(memblock.memory.cnt == 2);
> - assert(memblock.memory.total_size == r1.size + r2.size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -162,17 +190,22 @@ static int memblock_add_overlap_top_check(void)
> .size = SZ_512M
> };
>
> + prefix_push(__func__);
> +
> total_size = (r1.base - r2.base) + r1.size;
>
> reset_memblock_regions();
> memblock_add(r1.base, r1.size);
> memblock_add(r2.base, r2.size);
>
> - assert(rgn->base == r2.base);
> - assert(rgn->size == total_size);
> + ASSERT_EQ(rgn->base, r2.base);
> + ASSERT_EQ(rgn->size, total_size);
> +
> + ASSERT_EQ(memblock.memory.cnt, 1);
> + ASSERT_EQ(memblock.memory.total_size, total_size);
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -210,17 +243,22 @@ static int memblock_add_overlap_bottom_check(void)
> .size = SZ_1G
> };
>
> + prefix_push(__func__);
> +
> total_size = (r2.base - r1.base) + r2.size;
>
> reset_memblock_regions();
> memblock_add(r1.base, r1.size);
> memblock_add(r2.base, r2.size);
>
> - assert(rgn->base == r1.base);
> - assert(rgn->size == total_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);
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -255,15 +293,20 @@ static int memblock_add_within_check(void)
> .size = SZ_1M
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_add(r1.base, r1.size);
> memblock_add(r2.base, r2.size);
>
> - assert(rgn->base == r1.base);
> - assert(rgn->size == r1.size);
> + ASSERT_EQ(rgn->base, r1.base);
> + ASSERT_EQ(rgn->size, r1.size);
> +
> + ASSERT_EQ(memblock.memory.cnt, 1);
> + ASSERT_EQ(memblock.memory.total_size, r1.size);
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == r1.size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -279,19 +322,28 @@ static int memblock_add_twice_check(void)
> .size = SZ_2M
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
>
> memblock_add(r.base, r.size);
> memblock_add(r.base, r.size);
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == r.size);
> + ASSERT_EQ(memblock.memory.cnt, 1);
> + ASSERT_EQ(memblock.memory.total_size, r.size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
>
> static int memblock_add_checks(void)
> {
> + prefix_reset();
> + prefix_push(FUNC_ADD);
> + test_print("Running %s tests...\n", FUNC_ADD);
> +
> memblock_add_simple_check();
> memblock_add_node_simple_check();
> memblock_add_disjoint_check();
> @@ -300,6 +352,8 @@ static int memblock_add_checks(void)
> memblock_add_within_check();
> memblock_add_twice_check();
>
> + prefix_pop();
> +
> return 0;
> }
>
> @@ -320,11 +374,16 @@ static int memblock_reserve_simple_check(void)
> .size = SZ_128M
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_reserve(r.base, r.size);
>
> - assert(rgn->base == r.base);
> - assert(rgn->size == r.size);
> + ASSERT_EQ(rgn->base, r.base);
> + ASSERT_EQ(rgn->size, r.size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -356,18 +415,23 @@ static int memblock_reserve_disjoint_check(void)
> .size = SZ_512M
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_reserve(r1.base, r1.size);
> memblock_reserve(r2.base, r2.size);
>
> - assert(rgn1->base == r1.base);
> - assert(rgn1->size == r1.size);
> + 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(rgn2->base == r2.base);
> - assert(rgn2->size == r2.size);
> + ASSERT_EQ(memblock.reserved.cnt, 2);
> + ASSERT_EQ(memblock.reserved.total_size, r1.size + r2.size);
>
> - assert(memblock.reserved.cnt == 2);
> - assert(memblock.reserved.total_size == r1.size + r2.size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -406,17 +470,22 @@ static int memblock_reserve_overlap_top_check(void)
> .size = SZ_1G
> };
>
> + prefix_push(__func__);
> +
> total_size = (r1.base - r2.base) + r1.size;
>
> reset_memblock_regions();
> memblock_reserve(r1.base, r1.size);
> memblock_reserve(r2.base, r2.size);
>
> - assert(rgn->base == r2.base);
> - assert(rgn->size == total_size);
> + ASSERT_EQ(rgn->base, r2.base);
> + ASSERT_EQ(rgn->size, total_size);
> +
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -455,17 +524,22 @@ static int memblock_reserve_overlap_bottom_check(void)
> .size = SZ_128K
> };
>
> + prefix_push(__func__);
> +
> total_size = (r2.base - r1.base) + r2.size;
>
> reset_memblock_regions();
> memblock_reserve(r1.base, r1.size);
> memblock_reserve(r2.base, r2.size);
>
> - assert(rgn->base == r1.base);
> - assert(rgn->size == total_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);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -502,15 +576,20 @@ static int memblock_reserve_within_check(void)
> .size = SZ_64K
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_reserve(r1.base, r1.size);
> memblock_reserve(r2.base, r2.size);
>
> - assert(rgn->base == r1.base);
> - assert(rgn->size == r1.size);
> + ASSERT_EQ(rgn->base, r1.base);
> + ASSERT_EQ(rgn->size, r1.size);
> +
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, r1.size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == r1.size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -527,19 +606,28 @@ static int memblock_reserve_twice_check(void)
> .size = SZ_2M
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
>
> memblock_reserve(r.base, r.size);
> memblock_reserve(r.base, r.size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == r.size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, r.size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
>
> static int memblock_reserve_checks(void)
> {
> + prefix_reset();
> + prefix_push(FUNC_RESERVE);
> + test_print("Running %s tests...\n", FUNC_RESERVE);
> +
> memblock_reserve_simple_check();
> memblock_reserve_disjoint_check();
> memblock_reserve_overlap_top_check();
> @@ -547,6 +635,8 @@ static int memblock_reserve_checks(void)
> memblock_reserve_within_check();
> memblock_reserve_twice_check();
>
> + prefix_pop();
> +
> return 0;
> }
>
> @@ -581,16 +671,21 @@ static int memblock_remove_simple_check(void)
> .size = SZ_4M
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_add(r1.base, r1.size);
> memblock_add(r2.base, r2.size);
> memblock_remove(r1.base, r1.size);
>
> - assert(rgn->base == r2.base);
> - assert(rgn->size == r2.size);
> + ASSERT_EQ(rgn->base, r2.base);
> + ASSERT_EQ(rgn->size, r2.size);
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == r2.size);
> + ASSERT_EQ(memblock.memory.cnt, 1);
> + ASSERT_EQ(memblock.memory.total_size, r2.size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -626,15 +721,20 @@ static int memblock_remove_absent_check(void)
> .size = SZ_1G
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_add(r1.base, r1.size);
> memblock_remove(r2.base, r2.size);
>
> - assert(rgn->base == r1.base);
> - assert(rgn->size == r1.size);
> + ASSERT_EQ(rgn->base, r1.base);
> + ASSERT_EQ(rgn->size, r1.size);
> +
> + ASSERT_EQ(memblock.memory.cnt, 1);
> + ASSERT_EQ(memblock.memory.total_size, r1.size);
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == r1.size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -674,6 +774,8 @@ static int memblock_remove_overlap_top_check(void)
> .size = SZ_32M
> };
>
> + prefix_push(__func__);
> +
> r1_end = r1.base + r1.size;
> r2_end = r2.base + r2.size;
> total_size = r1_end - r2_end;
> @@ -682,11 +784,14 @@ static int memblock_remove_overlap_top_check(void)
> memblock_add(r1.base, r1.size);
> memblock_remove(r2.base, r2.size);
>
> - assert(rgn->base == r1.base + r2.base);
> - assert(rgn->size == total_size);
> + ASSERT_EQ(rgn->base, r1.base + r2.base);
> + ASSERT_EQ(rgn->size, total_size);
> +
> + ASSERT_EQ(memblock.memory.cnt, 1);
> + ASSERT_EQ(memblock.memory.total_size, total_size);
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -724,17 +829,23 @@ static int memblock_remove_overlap_bottom_check(void)
> .size = SZ_256M
> };
>
> + prefix_push(__func__);
> +
> total_size = r2.base - r1.base;
>
> reset_memblock_regions();
> memblock_add(r1.base, r1.size);
> memblock_remove(r2.base, r2.size);
>
> - assert(rgn->base == r1.base);
> - assert(rgn->size == total_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();
> + prefix_pop();
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == total_size);
> return 0;
> }
>
> @@ -774,6 +885,8 @@ static int memblock_remove_within_check(void)
> .size = SZ_1M
> };
>
> + prefix_push(__func__);
> +
> r1_size = r2.base - r1.base;
> r2_size = (r1.base + r1.size) - (r2.base + r2.size);
> total_size = r1_size + r2_size;
> @@ -782,26 +895,35 @@ static int memblock_remove_within_check(void)
> memblock_add(r1.base, r1.size);
> memblock_remove(r2.base, r2.size);
>
> - assert(rgn1->base == r1.base);
> - assert(rgn1->size == r1_size);
> + ASSERT_EQ(rgn1->base, r1.base);
> + ASSERT_EQ(rgn1->size, r1_size);
> +
> + ASSERT_EQ(rgn2->base, r2.base + r2.size);
> + ASSERT_EQ(rgn2->size, r2_size);
>
> - assert(rgn2->base == r2.base + r2.size);
> - assert(rgn2->size == r2_size);
> + ASSERT_EQ(memblock.memory.cnt, 2);
> + ASSERT_EQ(memblock.memory.total_size, total_size);
>
> - assert(memblock.memory.cnt == 2);
> - assert(memblock.memory.total_size == total_size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
>
> static int memblock_remove_checks(void)
> {
> + prefix_reset();
> + prefix_push(FUNC_REMOVE);
> + test_print("Running %s tests...\n", FUNC_REMOVE);
> +
> memblock_remove_simple_check();
> memblock_remove_absent_check();
> memblock_remove_overlap_top_check();
> memblock_remove_overlap_bottom_check();
> memblock_remove_within_check();
>
> + prefix_pop();
> +
> return 0;
> }
>
> @@ -835,16 +957,21 @@ static int memblock_free_simple_check(void)
> .size = SZ_1M
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_reserve(r1.base, r1.size);
> memblock_reserve(r2.base, r2.size);
> memblock_free((void *)r1.base, r1.size);
>
> - assert(rgn->base == r2.base);
> - assert(rgn->size == r2.size);
> + ASSERT_EQ(rgn->base, r2.base);
> + ASSERT_EQ(rgn->size, r2.size);
> +
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, r2.size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == r2.size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -880,15 +1007,20 @@ static int memblock_free_absent_check(void)
> .size = SZ_128M
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_reserve(r1.base, r1.size);
> memblock_free((void *)r2.base, r2.size);
>
> - assert(rgn->base == r1.base);
> - assert(rgn->size == r1.size);
> + ASSERT_EQ(rgn->base, r1.base);
> + ASSERT_EQ(rgn->size, r1.size);
> +
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, r1.size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == r1.size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -928,17 +1060,22 @@ static int memblock_free_overlap_top_check(void)
> .size = SZ_8M
> };
>
> + prefix_push(__func__);
> +
> total_size = (r1.size + r1.base) - (r2.base + r2.size);
>
> reset_memblock_regions();
> memblock_reserve(r1.base, r1.size);
> memblock_free((void *)r2.base, r2.size);
>
> - assert(rgn->base == r2.base + r2.size);
> - assert(rgn->size == total_size);
> + ASSERT_EQ(rgn->base, r2.base + r2.size);
> + ASSERT_EQ(rgn->size, total_size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -973,17 +1110,22 @@ static int memblock_free_overlap_bottom_check(void)
> .size = SZ_32M
> };
>
> + prefix_push(__func__);
> +
> total_size = r2.base - r1.base;
>
> reset_memblock_regions();
> memblock_reserve(r1.base, r1.size);
> memblock_free((void *)r2.base, r2.size);
>
> - assert(rgn->base == r1.base);
> - assert(rgn->size == total_size);
> + ASSERT_EQ(rgn->base, r1.base);
> + ASSERT_EQ(rgn->size, total_size);
>
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -1024,6 +1166,8 @@ static int memblock_free_within_check(void)
> .size = SZ_1M
> };
>
> + prefix_push(__func__);
> +
> r1_size = r2.base - r1.base;
> r2_size = (r1.base + r1.size) - (r2.base + r2.size);
> total_size = r1_size + r2_size;
> @@ -1032,26 +1176,35 @@ static int memblock_free_within_check(void)
> memblock_reserve(r1.base, r1.size);
> memblock_free((void *)r2.base, r2.size);
>
> - assert(rgn1->base == r1.base);
> - assert(rgn1->size == r1_size);
> + ASSERT_EQ(rgn1->base, r1.base);
> + ASSERT_EQ(rgn1->size, r1_size);
>
> - assert(rgn2->base == r2.base + r2.size);
> - assert(rgn2->size == r2_size);
> + ASSERT_EQ(rgn2->base, r2.base + r2.size);
> + ASSERT_EQ(rgn2->size, r2_size);
>
> - assert(memblock.reserved.cnt == 2);
> - assert(memblock.reserved.total_size == total_size);
> + ASSERT_EQ(memblock.reserved.cnt, 2);
> + ASSERT_EQ(memblock.reserved.total_size, total_size);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
>
> static int memblock_free_checks(void)
> {
> + prefix_reset();
> + prefix_push(FUNC_FREE);
> + test_print("Running %s tests...\n", FUNC_FREE);
> +
> memblock_free_simple_check();
> memblock_free_absent_check();
> memblock_free_overlap_top_check();
> memblock_free_overlap_bottom_check();
> memblock_free_within_check();
>
> + prefix_pop();
> +
> return 0;
> }
>
> diff --git a/tools/testing/memblock/tests/common.c b/tools/testing/memblock/tests/common.c
> index 62d3191f7c9a..e55b2a8bf0ff 100644
> --- a/tools/testing/memblock/tests/common.c
> +++ b/tools/testing/memblock/tests/common.c
> @@ -4,8 +4,12 @@
>
> #define INIT_MEMBLOCK_REGIONS 128
> #define INIT_MEMBLOCK_RESERVED_REGIONS INIT_MEMBLOCK_REGIONS
> +#define PREFIXES_LEN_MAX 256
> +#define DELIM ": "
> +#define DELIM_LEN strlen(DELIM)
>
> static struct test_memory memory_block;
> +static char __maybe_unused prefixes[PREFIXES_LEN_MAX];
>
> void reset_memblock_regions(void)
> {
> @@ -46,3 +50,57 @@ void dummy_physical_memory_cleanup(void)
> {
> free(memory_block.base);
> }
> +
> +#ifdef VERBOSE
> +void test_fail(void)
> +{
> + ksft_test_result_fail(": %sfailed\n", prefixes);
> +}
> +
> +void test_pass(void)
> +{
> + ksft_test_result_pass(": %spassed\n", prefixes);
> +}
> +
> +void test_print(const char *fmt, ...)
> +{
> + int saved_errno = errno;
> + va_list args;
> +
> + va_start(args, fmt);
> + errno = saved_errno;
> + vprintf(fmt, args);
> + va_end(args);
> +}
> +
> +void prefix_reset(void)
> +{
> + memset(prefixes, 0, PREFIXES_LEN_MAX);
> +}
> +
> +void prefix_push(const char *prefix)
> +{
> + int prefix_max = PREFIXES_LEN_MAX - strlen(prefixes) - DELIM_LEN - 1;
> +
> + assert(strlen(prefix) <= prefix_max);
> + strncat(prefixes, prefix, prefix_max);
> + strncat(prefixes, DELIM, PREFIXES_LEN_MAX - strlen(prefixes) - 1);
> +}
> +
> +void prefix_pop(void)
> +{
> + char *ptr;
> +
> + ptr = strrchr(prefixes, DELIM[0]);
> + if (!ptr)
> + prefixes[0] = 0;
> + else
> + *(ptr) = 0;
> +
> + ptr = strrchr(prefixes, DELIM[0]);
> + if (!ptr)
> + prefixes[0] = 0;
> + else
> + *(ptr + DELIM_LEN) = 0;
> +}
> +#endif /* VERBOSE */
> diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h
> index 619054d03219..bdddb5f72871 100644
> --- a/tools/testing/memblock/tests/common.h
> +++ b/tools/testing/memblock/tests/common.h
> @@ -7,9 +7,47 @@
> #include <linux/types.h>
> #include <linux/memblock.h>
> #include <linux/sizes.h>
> +#include <linux/printk.h>
> +#include <../selftests/kselftest.h>
>
> #define MEM_SIZE SZ_16K
>
> +/**
> + * ASSERT_EQ():
> + * Check the condition
> + * @_expected == @_seen
> + * If false, print failed test message (if in VERBOSE mode) and then assert
> + */
> +#define ASSERT_EQ(_expected, _seen) do { \
> + if ((_expected) != (_seen)) \
> + test_fail(); \
> + assert((_expected) == (_seen)); \
> +} while (0)
> +
> +/**
> + * ASSERT_NE():
> + * Check the condition
> + * @_expected != @_seen
> + * If false, print failed test message (if in VERBOSE mode) and then assert
> + */
> +#define ASSERT_NE(_expected, _seen) do { \
> + if ((_expected) == (_seen)) \
> + test_fail(); \
> + assert((_expected) != (_seen)); \
> +} while (0)
> +
> +/**
> + * ASSERT_LT():
> + * Check the condition
> + * @_expected < @_seen
> + * If false, print failed test message (if in VERBOSE mode) and then assert
> + */
> +#define ASSERT_LT(_expected, _seen) do { \
> + if ((_expected) >= (_seen)) \
> + test_fail(); \
> + assert((_expected) < (_seen)); \
> +} while (0)
> +
> /*
> * Available memory registered with memblock needs to be valid for allocs
> * test to run. This is a convenience wrapper for memory allocated in
> @@ -31,4 +69,20 @@ void setup_memblock(void);
> void dummy_physical_memory_init(void);
> void dummy_physical_memory_cleanup(void);
>
> +#ifdef VERBOSE
> +void test_fail(void);
> +void test_pass(void);
> +void test_print(const char *fmt, ...);
> +void prefix_reset(void);
> +void prefix_push(const char *prefix);
> +void prefix_pop(void);
> +#else
> +static inline void test_fail(void) {}
> +static inline void test_pass(void) {}
> +static inline void test_print(const char *fmt, ...) {}
> +static inline void prefix_reset(void) {}
> +static inline void prefix_push(const char *prefix) {}
> +static inline void prefix_pop(void) {}
> +#endif /* VERBOSE */
> +
> #endif
> --
> 2.34.1
>
>
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 1/4] memblock tests: add user-provided arguments to Makefile
2022-06-22 9:29 ` [PATCH v3 1/4] memblock tests: add user-provided arguments to Makefile Rebecca Mckeever
@ 2022-06-23 3:47 ` Mike Rapoport
2022-06-23 4:45 ` Rebecca Mckeever
0 siblings, 1 reply; 31+ messages in thread
From: Mike Rapoport @ 2022-06-23 3:47 UTC (permalink / raw)
To: Rebecca Mckeever; +Cc: linux-mm, linux-kernel, David Hildenbrand
Hi Rebecca,
On Wed, Jun 22, 2022 at 04:29:06AM -0500, Rebecca Mckeever wrote:
>
> Subject: memblock tests: add user-provided arguments to Makefile
Please be more specific here, e.g.
memblock tests: Makefile: add arguments to control verbosity
> Add VERBOSE and MEMBLOCK_DEBUG user-provided arguments. VERBOSE will
> enable verbose output from Memblock simulator. MEMBLOCK_DEBUG will enable
> memblock_dbg() messages.
>
> Update the help message to include VERBOSE and MEMBLOCK_DEBUG. Update
> the README to include VERBOSE. The README does not include all available
> options and refers to the help message for the remaining options.
> Therefore, omit MEMBLOCK_DEBUG from README.
>
> Reviewed-by: David Hildenbrand <david@redhat.com>
> Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> ---
> tools/testing/memblock/Makefile | 4 ++++
> tools/testing/memblock/README | 10 +++++++++-
> tools/testing/memblock/scripts/Makefile.include | 10 ++++++++++
> 3 files changed, 23 insertions(+), 1 deletion(-)
>
> diff --git a/tools/testing/memblock/Makefile b/tools/testing/memblock/Makefile
> index a698e24b35e7..9fde49ad73bd 100644
> --- a/tools/testing/memblock/Makefile
> +++ b/tools/testing/memblock/Makefile
> @@ -45,6 +45,10 @@ help:
> @echo ' clean - Remove generated files and symlinks in the directory'
> @echo ''
> @echo 'Configuration:'
> + @echo ' make VERBOSE=1 - enable verbose output, which includes the'
> + @echo ' names of functions being tested and the'
> + @echo ' number of test cases passing'
> + @echo ' make MEMBLOCK_DEBUG=1 - enable memblock_dbg() messages'
> @echo ' make NUMA=1 - simulate enabled NUMA'
> @echo ' make MOVABLE_NODE=1 - override `movable_node_is_enabled`'
> @echo ' definition to simulate movable NUMA nodes'
> diff --git a/tools/testing/memblock/README b/tools/testing/memblock/README
> index ca6afcff013a..058146b528a5 100644
> --- a/tools/testing/memblock/README
> +++ b/tools/testing/memblock/README
> @@ -34,7 +34,15 @@ To run the tests, build the main target and run it:
> $ make && ./main
>
> A successful run produces no output. It is also possible to override different
> -configuration parameters. For example, to simulate enabled NUMA, use:
> +configuration parameters. For example, to include verbose output, specify the
> +VERBOSE flag when building the main target:
> +
> +$ make VERBOSE=1
> +
> +This will print information about which functions are being tested and the
> +number of test cases that passed.
> +
> +To simulate enabled NUMA, use:
>
> $ make NUMA=1
>
> diff --git a/tools/testing/memblock/scripts/Makefile.include b/tools/testing/memblock/scripts/Makefile.include
> index 641569ccb7b0..4401f79bed4c 100644
> --- a/tools/testing/memblock/scripts/Makefile.include
> +++ b/tools/testing/memblock/scripts/Makefile.include
> @@ -17,3 +17,13 @@ ifeq ($(32BIT_PHYS_ADDR_T), 1)
> CFLAGS += -m32 -U CONFIG_PHYS_ADDR_T_64BIT
> LDFLAGS += -m32
> endif
> +
> +# Enable verbose testing output
> +ifeq ($(VERBOSE), 1)
> + CFLAGS += -D VERBOSE
> +endif
> +
> +# Enable memblock_dbg() messages
> +ifeq ($(MEMBLOCK_DEBUG), 1)
> + CFLAGS += -D MEMBLOCK_DEBUG
> +endif
> --
> 2.34.1
>
--
Sincerely yours,
Mike.
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 2/4] memblock tests: add verbose output to memblock tests
2022-06-23 1:29 ` Huang, Shaoqin
2022-06-23 3:10 ` Rebecca Mckeever
@ 2022-06-23 4:05 ` Mike Rapoport
2022-06-23 4:56 ` Rebecca Mckeever
1 sibling, 1 reply; 31+ messages in thread
From: Mike Rapoport @ 2022-06-23 4:05 UTC (permalink / raw)
To: Huang, Shaoqin
Cc: Rebecca Mckeever, linux-mm, linux-kernel, David Hildenbrand
On Thu, Jun 23, 2022 at 09:29:05AM +0800, Huang, Shaoqin wrote:
>
>
> On 6/23/2022 8:45 AM, Rebecca Mckeever wrote:
> > On Wed, Jun 22, 2022 at 06:32:04PM +0800, Huang, Shaoqin wrote:
> > > Just test it and everything works fine. And I think there are some thing can
> > > improve:
> > >
> > > The prefix_push() and prefix_pop() are used in so many functions and
> > > almost of them just put the prefix_push(__func__) begin in the head and the
> > > prefix_pop() in the end.
> > > May be you can define some macro that when you output something and
> > > automatically push the __func__ as prefix. And when leave the function,
> > > automatically pop it. And only in some special place, you call it manually.
> > >
> > Thank you for your review. I'm not sure how you would automatically push
> > __func__ since you have to be inside the function to access that
> > variable. Let me know if you have any suggestions. I am thinking about
> > adding another function in common.c that just calls test_pass() followed
> > by prefix_pop() since those are called together so often.
>
> Just like:
> #define test_pass_macro() \
> do { \
> prefix_push(__func__); \
> test_pass(); \
> prefix_pop(); \
> } while (0)
This will not print the name of the failing test, e.g. instead of
not ok 28 : memblock_alloc: alloc_bottom_up_disjoint_check: failed
with Rebecca's implementation it'll print
not ok 28 : memblock_alloc: failed
How about
#define PREFIX_PUSH() prefix_push(__func__)?
> This macro will automatically push the __fun__ as prefix when you call
> test_pass_macro(). And then pop it after test_pass() output.
>
> And use this macro() to hidden most of the paired prefix_* functions.
>
> And I think that's the simplist way. May be someone has a better solution.
>
--
Sincerely yours,
Mike.
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 0/4] memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options
2022-06-23 3:30 ` Ira Weiny
@ 2022-06-23 4:20 ` Rebecca Mckeever
2022-06-23 4:38 ` Mike Rapoport
0 siblings, 1 reply; 31+ messages in thread
From: Rebecca Mckeever @ 2022-06-23 4:20 UTC (permalink / raw)
To: Ira Weiny; +Cc: Mike Rapoport, linux-mm, linux-kernel, David Hildenbrand
On Wed, Jun 22, 2022 at 08:30:36PM -0700, Ira Weiny wrote:
> On Wed, Jun 22, 2022 at 04:29:05AM -0500, Rebecca Mckeever wrote:
> > These patches add options VERBOSE and MEMBLOCK_DEBUG to Memblock
> > simulator, which can be specified when running make. These patches also
> > implement the functionality for these options.
>
> I seem to be missing patch 3/4 and I don't see it on lore?
>
> https://lore.kernel.org/linux-mm/004e021cc3cb7be8749361b3b1cb324459b9cb9f.1655889641.git.remckee0@gmail.com/
>
> Did it get sent? Did it define the ASSERT_*() macros?
That's strange, my email shows that it was sent to linux-mm@kvack.org and
linux-kernel@vger.kernel.org but I'm not seeing it on lore either.
Should I resend just patch 3/4? For now, you can take a look at v1.
Patch 3 is unchanged from v1, which is showing up on lore:
https://lore.kernel.org/linux-mm/fe34452209f54287023ccacd666eade81ecd9a24.1655878337.git.remckee0@gmail.com/T/#u
It does not define the ASSERT_*() macros, that happens in patch 2.
Patch 3 implements MEMBLOCK_DEBUG.
Thanks,
Rebecca
>
> Ira
>
> >
> > VERBOSE
> > Usage:
> >
> > $ make VERBOSE=1
> >
> > Passing VERBOSE=1 will enable verbose output from Memblock simulator. For
> > each test, the verbose output includes the name of the memblock function
> > being tested, the name of the test, and whether the test passed or failed.
> > Since all the tests in Memblock simulator run as one monolithic test, this
> > output is a quick way to get a summary of test results.
> >
> > MEMBLOCK_DEBUG
> > Usage:
> >
> > $ make MEMBLOCK_DEBUG=1
> >
> > Passing MEMBLOCK_DEBUG=1 will enable memblock_dbg() messages. These
> > are debug messages built into several functions in memblock that include
> > information such as the name of the function and the size and start and
> > end addresses of the memblock region.
> >
> > Rebecca Mckeever (4):
> > memblock tests: add user-provided arguments to Makefile
> > memblock tests: add verbose output to memblock tests
> > memblock tests: set memblock_debug to enable memblock_dbg() messages
> > memblock tests: remove completed TODO items
> >
> > tools/testing/memblock/Makefile | 4 +
> > tools/testing/memblock/README | 10 +-
> > tools/testing/memblock/TODO | 14 +-
> > tools/testing/memblock/internal.h | 7 +
> > .../testing/memblock/scripts/Makefile.include | 10 +
> > tools/testing/memblock/tests/alloc_api.c | 241 ++++++++----
> > .../memblock/tests/alloc_helpers_api.c | 135 +++++--
> > tools/testing/memblock/tests/alloc_nid_api.c | 371 ++++++++++++------
> > tools/testing/memblock/tests/basic_api.c | 365 ++++++++++++-----
> > tools/testing/memblock/tests/common.c | 58 +++
> > tools/testing/memblock/tests/common.h | 54 +++
> > 11 files changed, 913 insertions(+), 356 deletions(-)
> >
> > ---
> > Changes
> >
> > v1 -> v2
> > PATCH 2, in common.c:
> > Remove #ifdef VERBOSE around prefixes and related constants
> > Add __maybe_unused to prefixes
> > Move PREFIXES_LEN_MAX, DELIM, and DELIM_LEN so that they are
> > immediately after the other constants
> > Add #ifdef VERBOSE around definitions for test_*() and prefix_*()
> >
> > v2 -> v3
> > PATCH 1:
> > Add Reviewed-by tag
> > ---
> >
> > --
> > 2.34.1
> >
> >
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 2/4] memblock tests: add verbose output to memblock tests
2022-06-22 9:29 ` [PATCH v3 2/4] memblock tests: add verbose output to memblock tests Rebecca Mckeever
2022-06-22 10:32 ` Huang, Shaoqin
2022-06-23 3:37 ` Ira Weiny
@ 2022-06-23 4:30 ` Mike Rapoport
2022-06-23 6:30 ` Rebecca Mckeever
2 siblings, 1 reply; 31+ messages in thread
From: Mike Rapoport @ 2022-06-23 4:30 UTC (permalink / raw)
To: Rebecca Mckeever; +Cc: linux-mm, linux-kernel, David Hildenbrand
On Wed, Jun 22, 2022 at 04:29:07AM -0500, Rebecca Mckeever wrote:
> Add and use functions for printing verbose testing output.
>
> If the Memblock simulator was compiled with VERBOSE=1:
> prefix_push() appends the given string to a prefix string that will be
> printed in the test functions.
> prefix_pop() removes the last prefix from the prefix string.
> prefix_reset() clears the prefix string.
> test_fail() prints a message after a test fails containing the test
> number of the failing test and the prefix.
> test_pass() prints a message after a test passes containing its test
> number and the prefix.
> test_print() prints the given formatted output string.
>
> If the Memblock simulator was not compiled with VERBOSE=1, these
> functions do nothing.
>
> Add the assert wrapper macros ASSERT_EQ(), ASSERT_NE(), and ASSERT_LT().
> If the assert condition fails, these macros call test_fail() before
> executing assert().
>
> Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> ---
> tools/testing/memblock/tests/alloc_api.c | 241 ++++++++----
> .../memblock/tests/alloc_helpers_api.c | 135 +++++--
> tools/testing/memblock/tests/alloc_nid_api.c | 371 ++++++++++++------
> tools/testing/memblock/tests/basic_api.c | 365 ++++++++++++-----
> tools/testing/memblock/tests/common.c | 58 +++
> tools/testing/memblock/tests/common.h | 54 +++
> 6 files changed, 880 insertions(+), 344 deletions(-)
>
> diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
> index d1aa7e15c18d..96df033d4300 100644
> --- a/tools/testing/memblock/tests/alloc_api.c
> +++ b/tools/testing/memblock/tests/alloc_api.c
...
> @@ -729,6 +820,12 @@ static int alloc_no_memory_check(void)
>
> int memblock_alloc_checks(void)
> {
> + static const char func_testing[] = "memblock_alloc";
> +
> + prefix_reset();
> + prefix_push(func_testing);
> + test_print("Running %s tests...\n", func_testing);
Why not
test_print("Running memblock_alloc tests...\n");
?
(applies to other cases below)
> +
> reset_memblock_attributes();
> dummy_physical_memory_init();
...
> diff --git a/tools/testing/memblock/tests/alloc_helpers_api.c b/tools/testing/memblock/tests/alloc_helpers_api.c
> index 963a966db461..f6eaed540427 100644
> --- a/tools/testing/memblock/tests/alloc_helpers_api.c
> +++ b/tools/testing/memblock/tests/alloc_helpers_api.c
...
> @@ -378,6 +423,12 @@ static int alloc_from_min_addr_cap_check(void)
>
> int memblock_alloc_helpers_checks(void)
> {
> + static const char func_testing[] = "memblock_alloc_from";
> +
> + prefix_reset();
> + prefix_push(func_testing);
> + test_print("Running %s tests...\n", func_testing);
> +
> reset_memblock_attributes();
> dummy_physical_memory_init();
>
> diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
> index 6390206e50e1..601f4a7ee30d 100644
> --- a/tools/testing/memblock/tests/alloc_nid_api.c
> +++ b/tools/testing/memblock/tests/alloc_nid_api.c
...
> @@ -1150,6 +1263,12 @@ static int alloc_try_nid_low_max_check(void)
>
> int memblock_alloc_nid_checks(void)
> {
> + static const char func_testing[] = "memblock_alloc_try_nid";
> +
> + prefix_reset();
> + prefix_push(func_testing);
> + test_print("Running %s tests...\n", func_testing);
> +
> reset_memblock_attributes();
> dummy_physical_memory_init();
>
> @@ -1170,5 +1289,7 @@ int memblock_alloc_nid_checks(void)
>
> dummy_physical_memory_cleanup();
>
> + prefix_pop();
> +
> return 0;
> }
> diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c
> index a7bc180316d6..f223a9a57be7 100644
> --- a/tools/testing/memblock/tests/basic_api.c
> +++ b/tools/testing/memblock/tests/basic_api.c
> @@ -4,21 +4,30 @@
> #include "basic_api.h"
>
> #define EXPECTED_MEMBLOCK_REGIONS 128
> +#define FUNC_ADD "memblock_add"
> +#define FUNC_RESERVE "memblock_reserve"
> +#define FUNC_REMOVE "memblock_remove"
> +#define FUNC_FREE "memblock_free"
>
> static int memblock_initialization_check(void)
> {
> - assert(memblock.memory.regions);
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
> - assert(strcmp(memblock.memory.name, "memory") == 0);
> + prefix_push(__func__);
>
> - assert(memblock.reserved.regions);
> - assert(memblock.reserved.cnt == 1);
> - assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
> - assert(strcmp(memblock.reserved.name, "reserved") == 0);
> + ASSERT_NE(memblock.memory.regions, NULL);
> + ASSERT_EQ(memblock.memory.cnt, 1);
> + ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
> + ASSERT_EQ(strcmp(memblock.memory.name, "memory"), 0);
>
> - assert(!memblock.bottom_up);
> - assert(memblock.current_limit == MEMBLOCK_ALLOC_ANYWHERE);
> + ASSERT_NE(memblock.reserved.regions, NULL);
> + ASSERT_EQ(memblock.reserved.cnt, 1);
> + ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
> + ASSERT_EQ(strcmp(memblock.reserved.name, "reserved"), 0);
> +
> + ASSERT_EQ(memblock.bottom_up, false);
> + ASSERT_EQ(memblock.current_limit, MEMBLOCK_ALLOC_ANYWHERE);
> +
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -40,14 +49,19 @@ static int memblock_add_simple_check(void)
> .size = SZ_4M
> };
>
> + prefix_push(__func__);
> +
> reset_memblock_regions();
> memblock_add(r.base, r.size);
>
> - assert(rgn->base == r.base);
> - assert(rgn->size == r.size);
> + ASSERT_EQ(rgn->base, r.base);
> + ASSERT_EQ(rgn->size, r.size);
> +
> + ASSERT_EQ(memblock.memory.cnt, 1);
> + ASSERT_EQ(memblock.memory.total_size, r.size);
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == r.size);
> + test_pass();
> + prefix_pop();
>
> return 0;
> }
> @@ -69,18 +83,27 @@ static int memblock_add_node_simple_check(void)
> .size = SZ_16M
> };
>
> + prefix_pop();
> + prefix_push("memblock_add_node");
> + prefix_push(__func__);
I think there is no need to change the prefix from memblock_add to
memblock_add_node here.
ok 3 : memblock_add: memblock_add_node_simple_check: passed
provides enough information.
> +
> reset_memblock_regions();
> memblock_add_node(r.base, r.size, 1, MEMBLOCK_HOTPLUG);
>
> - assert(rgn->base == r.base);
> - assert(rgn->size == r.size);
> + ASSERT_EQ(rgn->base, r.base);
> + ASSERT_EQ(rgn->size, r.size);
> #ifdef CONFIG_NUMA
> - assert(rgn->nid == 1);
> + ASSERT_EQ(rgn->nid, 1);
> #endif
> - assert(rgn->flags == MEMBLOCK_HOTPLUG);
> + ASSERT_EQ(rgn->flags, MEMBLOCK_HOTPLUG);
> +
> + ASSERT_EQ(memblock.memory.cnt, 1);
> + ASSERT_EQ(memblock.memory.total_size, r.size);
>
> - assert(memblock.memory.cnt == 1);
> - assert(memblock.memory.total_size == r.size);
> + test_pass();
> + prefix_pop();
> + prefix_pop();
> + prefix_push(FUNC_ADD);
>
> return 0;
> }
--
Sincerely yours,
Mike.
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 0/4] memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options
2022-06-23 4:20 ` Rebecca Mckeever
@ 2022-06-23 4:38 ` Mike Rapoport
2022-06-23 5:48 ` Ira Weiny
0 siblings, 1 reply; 31+ messages in thread
From: Mike Rapoport @ 2022-06-23 4:38 UTC (permalink / raw)
To: Rebecca Mckeever; +Cc: Ira Weiny, linux-mm, linux-kernel, David Hildenbrand
On Wed, Jun 22, 2022 at 11:20:11PM -0500, Rebecca Mckeever wrote:
> On Wed, Jun 22, 2022 at 08:30:36PM -0700, Ira Weiny wrote:
> > On Wed, Jun 22, 2022 at 04:29:05AM -0500, Rebecca Mckeever wrote:
> > > These patches add options VERBOSE and MEMBLOCK_DEBUG to Memblock
> > > simulator, which can be specified when running make. These patches also
> > > implement the functionality for these options.
> >
> > I seem to be missing patch 3/4 and I don't see it on lore?
> >
> > https://lore.kernel.org/linux-mm/004e021cc3cb7be8749361b3b1cb324459b9cb9f.1655889641.git.remckee0@gmail.com/
> >
> > Did it get sent? Did it define the ASSERT_*() macros?
I see it on lore in both linux-mm and linux-kernel, and here as well:
https://lore.kernel.org/all/39c5c97d2b5c1ab88b7bbbf02633f840fd5dfcdf.1655889641.git.remckee0@gmail.com/
> That's strange, my email shows that it was sent to linux-mm@kvack.org and
> linux-kernel@vger.kernel.org but I'm not seeing it on lore either.
> Should I resend just patch 3/4?
No need to resend.
> For now, you can take a look at v1. Patch 3 is unchanged from v1, which
> is showing up on lore:
>
> https://lore.kernel.org/linux-mm/fe34452209f54287023ccacd666eade81ecd9a24.1655878337.git.remckee0@gmail.com/T/#u
>
> It does not define the ASSERT_*() macros, that happens in patch 2.
> Patch 3 implements MEMBLOCK_DEBUG.
>
> Thanks,
> Rebecca
>
--
Sincerely yours,
Mike.
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 1/4] memblock tests: add user-provided arguments to Makefile
2022-06-23 3:47 ` Mike Rapoport
@ 2022-06-23 4:45 ` Rebecca Mckeever
2022-06-23 4:52 ` Mike Rapoport
0 siblings, 1 reply; 31+ messages in thread
From: Rebecca Mckeever @ 2022-06-23 4:45 UTC (permalink / raw)
To: Mike Rapoport; +Cc: linux-mm, linux-kernel, David Hildenbrand
Hi Mike,
On Wed, Jun 22, 2022 at 10:47:55PM -0500, Mike Rapoport wrote:
> Hi Rebecca,
>
> On Wed, Jun 22, 2022 at 04:29:06AM -0500, Rebecca Mckeever wrote:
> >
> > Subject: memblock tests: add user-provided arguments to Makefile
>
> Please be more specific here, e.g.
>
> memblock tests: Makefile: add arguments to control verbosity
>
Should I also mention debug messages, or does verbosity refer to both
arguments?
> > Add VERBOSE and MEMBLOCK_DEBUG user-provided arguments. VERBOSE will
> > enable verbose output from Memblock simulator. MEMBLOCK_DEBUG will enable
> > memblock_dbg() messages.
> >
> > Update the help message to include VERBOSE and MEMBLOCK_DEBUG. Update
> > the README to include VERBOSE. The README does not include all available
> > options and refers to the help message for the remaining options.
> > Therefore, omit MEMBLOCK_DEBUG from README.
> >
> > Reviewed-by: David Hildenbrand <david@redhat.com>
> > Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> > ---
> > tools/testing/memblock/Makefile | 4 ++++
> > tools/testing/memblock/README | 10 +++++++++-
> > tools/testing/memblock/scripts/Makefile.include | 10 ++++++++++
> > 3 files changed, 23 insertions(+), 1 deletion(-)
> >
> > diff --git a/tools/testing/memblock/Makefile b/tools/testing/memblock/Makefile
> > index a698e24b35e7..9fde49ad73bd 100644
> > --- a/tools/testing/memblock/Makefile
> > +++ b/tools/testing/memblock/Makefile
> > @@ -45,6 +45,10 @@ help:
> > @echo ' clean - Remove generated files and symlinks in the directory'
> > @echo ''
> > @echo 'Configuration:'
> > + @echo ' make VERBOSE=1 - enable verbose output, which includes the'
> > + @echo ' names of functions being tested and the'
> > + @echo ' number of test cases passing'
> > + @echo ' make MEMBLOCK_DEBUG=1 - enable memblock_dbg() messages'
> > @echo ' make NUMA=1 - simulate enabled NUMA'
> > @echo ' make MOVABLE_NODE=1 - override `movable_node_is_enabled`'
> > @echo ' definition to simulate movable NUMA nodes'
> > diff --git a/tools/testing/memblock/README b/tools/testing/memblock/README
> > index ca6afcff013a..058146b528a5 100644
> > --- a/tools/testing/memblock/README
> > +++ b/tools/testing/memblock/README
> > @@ -34,7 +34,15 @@ To run the tests, build the main target and run it:
> > $ make && ./main
> >
> > A successful run produces no output. It is also possible to override different
> > -configuration parameters. For example, to simulate enabled NUMA, use:
> > +configuration parameters. For example, to include verbose output, specify the
> > +VERBOSE flag when building the main target:
> > +
> > +$ make VERBOSE=1
> > +
> > +This will print information about which functions are being tested and the
> > +number of test cases that passed.
> > +
> > +To simulate enabled NUMA, use:
> >
> > $ make NUMA=1
> >
> > diff --git a/tools/testing/memblock/scripts/Makefile.include b/tools/testing/memblock/scripts/Makefile.include
> > index 641569ccb7b0..4401f79bed4c 100644
> > --- a/tools/testing/memblock/scripts/Makefile.include
> > +++ b/tools/testing/memblock/scripts/Makefile.include
> > @@ -17,3 +17,13 @@ ifeq ($(32BIT_PHYS_ADDR_T), 1)
> > CFLAGS += -m32 -U CONFIG_PHYS_ADDR_T_64BIT
> > LDFLAGS += -m32
> > endif
> > +
> > +# Enable verbose testing output
> > +ifeq ($(VERBOSE), 1)
> > + CFLAGS += -D VERBOSE
> > +endif
> > +
> > +# Enable memblock_dbg() messages
> > +ifeq ($(MEMBLOCK_DEBUG), 1)
> > + CFLAGS += -D MEMBLOCK_DEBUG
> > +endif
> > --
> > 2.34.1
> >
>
> --
> Sincerely yours,
> Mike.
Thanks,
Rebecca
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 1/4] memblock tests: add user-provided arguments to Makefile
2022-06-23 4:45 ` Rebecca Mckeever
@ 2022-06-23 4:52 ` Mike Rapoport
0 siblings, 0 replies; 31+ messages in thread
From: Mike Rapoport @ 2022-06-23 4:52 UTC (permalink / raw)
To: Rebecca Mckeever; +Cc: linux-mm, linux-kernel, David Hildenbrand
On Wed, Jun 22, 2022 at 11:45:36PM -0500, Rebecca Mckeever wrote:
> Hi Mike,
>
> On Wed, Jun 22, 2022 at 10:47:55PM -0500, Mike Rapoport wrote:
> > Hi Rebecca,
> >
> > On Wed, Jun 22, 2022 at 04:29:06AM -0500, Rebecca Mckeever wrote:
> > >
> > > Subject: memblock tests: add user-provided arguments to Makefile
> >
> > Please be more specific here, e.g.
> >
> > memblock tests: Makefile: add arguments to control verbosity
> >
>
> Should I also mention debug messages, or does verbosity refer to both
> arguments?
It does as enabling memblock_dbg() is also about overall verbosity.
But if you manage to squeeze both in 75 characters I won't mind :)
> > > Add VERBOSE and MEMBLOCK_DEBUG user-provided arguments. VERBOSE will
> > > enable verbose output from Memblock simulator. MEMBLOCK_DEBUG will enable
> > > memblock_dbg() messages.
> > >
> > > Update the help message to include VERBOSE and MEMBLOCK_DEBUG. Update
> > > the README to include VERBOSE. The README does not include all available
> > > options and refers to the help message for the remaining options.
> > > Therefore, omit MEMBLOCK_DEBUG from README.
> > >
> > > Reviewed-by: David Hildenbrand <david@redhat.com>
> > > Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> > > ---
> > > tools/testing/memblock/Makefile | 4 ++++
> > > tools/testing/memblock/README | 10 +++++++++-
> > > tools/testing/memblock/scripts/Makefile.include | 10 ++++++++++
> > > 3 files changed, 23 insertions(+), 1 deletion(-)
> > >
> > > diff --git a/tools/testing/memblock/Makefile b/tools/testing/memblock/Makefile
> > > index a698e24b35e7..9fde49ad73bd 100644
> > > --- a/tools/testing/memblock/Makefile
> > > +++ b/tools/testing/memblock/Makefile
> > > @@ -45,6 +45,10 @@ help:
> > > @echo ' clean - Remove generated files and symlinks in the directory'
> > > @echo ''
> > > @echo 'Configuration:'
> > > + @echo ' make VERBOSE=1 - enable verbose output, which includes the'
> > > + @echo ' names of functions being tested and the'
> > > + @echo ' number of test cases passing'
> > > + @echo ' make MEMBLOCK_DEBUG=1 - enable memblock_dbg() messages'
> > > @echo ' make NUMA=1 - simulate enabled NUMA'
> > > @echo ' make MOVABLE_NODE=1 - override `movable_node_is_enabled`'
> > > @echo ' definition to simulate movable NUMA nodes'
> > > diff --git a/tools/testing/memblock/README b/tools/testing/memblock/README
> > > index ca6afcff013a..058146b528a5 100644
> > > --- a/tools/testing/memblock/README
> > > +++ b/tools/testing/memblock/README
> > > @@ -34,7 +34,15 @@ To run the tests, build the main target and run it:
> > > $ make && ./main
> > >
> > > A successful run produces no output. It is also possible to override different
> > > -configuration parameters. For example, to simulate enabled NUMA, use:
> > > +configuration parameters. For example, to include verbose output, specify the
> > > +VERBOSE flag when building the main target:
> > > +
> > > +$ make VERBOSE=1
> > > +
> > > +This will print information about which functions are being tested and the
> > > +number of test cases that passed.
> > > +
> > > +To simulate enabled NUMA, use:
> > >
> > > $ make NUMA=1
> > >
> > > diff --git a/tools/testing/memblock/scripts/Makefile.include b/tools/testing/memblock/scripts/Makefile.include
> > > index 641569ccb7b0..4401f79bed4c 100644
> > > --- a/tools/testing/memblock/scripts/Makefile.include
> > > +++ b/tools/testing/memblock/scripts/Makefile.include
> > > @@ -17,3 +17,13 @@ ifeq ($(32BIT_PHYS_ADDR_T), 1)
> > > CFLAGS += -m32 -U CONFIG_PHYS_ADDR_T_64BIT
> > > LDFLAGS += -m32
> > > endif
> > > +
> > > +# Enable verbose testing output
> > > +ifeq ($(VERBOSE), 1)
> > > + CFLAGS += -D VERBOSE
> > > +endif
> > > +
> > > +# Enable memblock_dbg() messages
> > > +ifeq ($(MEMBLOCK_DEBUG), 1)
> > > + CFLAGS += -D MEMBLOCK_DEBUG
> > > +endif
> > > --
> > > 2.34.1
> > >
> >
> > --
> > Sincerely yours,
> > Mike.
>
> Thanks,
> Rebecca
--
Sincerely yours,
Mike.
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 2/4] memblock tests: add verbose output to memblock tests
2022-06-23 4:05 ` Mike Rapoport
@ 2022-06-23 4:56 ` Rebecca Mckeever
2022-06-23 5:04 ` Mike Rapoport
0 siblings, 1 reply; 31+ messages in thread
From: Rebecca Mckeever @ 2022-06-23 4:56 UTC (permalink / raw)
To: Mike Rapoport; +Cc: Huang, Shaoqin, linux-mm, linux-kernel, David Hildenbrand
On Wed, Jun 22, 2022 at 11:05:27PM -0500, Mike Rapoport wrote:
> On Thu, Jun 23, 2022 at 09:29:05AM +0800, Huang, Shaoqin wrote:
> >
> >
> > On 6/23/2022 8:45 AM, Rebecca Mckeever wrote:
> > > On Wed, Jun 22, 2022 at 06:32:04PM +0800, Huang, Shaoqin wrote:
> > > > Just test it and everything works fine. And I think there are some thing can
> > > > improve:
> > > >
> > > > The prefix_push() and prefix_pop() are used in so many functions and
> > > > almost of them just put the prefix_push(__func__) begin in the head and the
> > > > prefix_pop() in the end.
> > > > May be you can define some macro that when you output something and
> > > > automatically push the __func__ as prefix. And when leave the function,
> > > > automatically pop it. And only in some special place, you call it manually.
> > > >
> > > Thank you for your review. I'm not sure how you would automatically push
> > > __func__ since you have to be inside the function to access that
> > > variable. Let me know if you have any suggestions. I am thinking about
> > > adding another function in common.c that just calls test_pass() followed
> > > by prefix_pop() since those are called together so often.
> >
> > Just like:
> > #define test_pass_macro() \
> > do { \
> > prefix_push(__func__); \
> > test_pass(); \
> > prefix_pop(); \
> > } while (0)
>
> This will not print the name of the failing test, e.g. instead of
>
> not ok 28 : memblock_alloc: alloc_bottom_up_disjoint_check: failed
>
> with Rebecca's implementation it'll print
>
> not ok 28 : memblock_alloc: failed
>
Oh yeah, prefix_push() needs to be called before the asserts.
> How about
>
> #define PREFIX_PUSH() prefix_push(__func__)?
>
Good idea. What about
#define TEST_PASS() do { \
test_pass(); \
prefix_pop(); \
} while (0)
? Or would it be better to make a function?
> > This macro will automatically push the __fun__ as prefix when you call
> > test_pass_macro(). And then pop it after test_pass() output.
> >
> > And use this macro() to hidden most of the paired prefix_* functions.
> >
> > And I think that's the simplist way. May be someone has a better solution.
> >
>
> --
> Sincerely yours,
> Mike.
Thanks,
Rebecca
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 2/4] memblock tests: add verbose output to memblock tests
2022-06-23 4:56 ` Rebecca Mckeever
@ 2022-06-23 5:04 ` Mike Rapoport
2022-06-23 7:57 ` Rebecca Mckeever
0 siblings, 1 reply; 31+ messages in thread
From: Mike Rapoport @ 2022-06-23 5:04 UTC (permalink / raw)
To: Rebecca Mckeever
Cc: Huang, Shaoqin, linux-mm, linux-kernel, David Hildenbrand
On Wed, Jun 22, 2022 at 11:56:30PM -0500, Rebecca Mckeever wrote:
> On Wed, Jun 22, 2022 at 11:05:27PM -0500, Mike Rapoport wrote:
> > On Thu, Jun 23, 2022 at 09:29:05AM +0800, Huang, Shaoqin wrote:
> > >
> > >
> > > On 6/23/2022 8:45 AM, Rebecca Mckeever wrote:
> > > > On Wed, Jun 22, 2022 at 06:32:04PM +0800, Huang, Shaoqin wrote:
> > > > > Just test it and everything works fine. And I think there are some thing can
> > > > > improve:
> > > > >
> > > > > The prefix_push() and prefix_pop() are used in so many functions and
> > > > > almost of them just put the prefix_push(__func__) begin in the head and the
> > > > > prefix_pop() in the end.
> > > > > May be you can define some macro that when you output something and
> > > > > automatically push the __func__ as prefix. And when leave the function,
> > > > > automatically pop it. And only in some special place, you call it manually.
> > > > >
> > > > Thank you for your review. I'm not sure how you would automatically push
> > > > __func__ since you have to be inside the function to access that
> > > > variable. Let me know if you have any suggestions. I am thinking about
> > > > adding another function in common.c that just calls test_pass() followed
> > > > by prefix_pop() since those are called together so often.
> > >
> > > Just like:
> > > #define test_pass_macro() \
> > > do { \
> > > prefix_push(__func__); \
> > > test_pass(); \
> > > prefix_pop(); \
> > > } while (0)
> >
> > This will not print the name of the failing test, e.g. instead of
> >
> > not ok 28 : memblock_alloc: alloc_bottom_up_disjoint_check: failed
> >
> > with Rebecca's implementation it'll print
> >
> > not ok 28 : memblock_alloc: failed
> >
> Oh yeah, prefix_push() needs to be called before the asserts.
>
> > How about
> >
> > #define PREFIX_PUSH() prefix_push(__func__)?
> >
> Good idea. What about
>
> #define TEST_PASS() do { \
> test_pass(); \
> prefix_pop(); \
> } while (0)
>
> ? Or would it be better to make a function?
static inline function would be better.
> Thanks,
> Rebecca
--
Sincerely yours,
Mike.
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 0/4] memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options
2022-06-23 4:38 ` Mike Rapoport
@ 2022-06-23 5:48 ` Ira Weiny
0 siblings, 0 replies; 31+ messages in thread
From: Ira Weiny @ 2022-06-23 5:48 UTC (permalink / raw)
To: Mike Rapoport; +Cc: Rebecca Mckeever, linux-mm, linux-kernel, David Hildenbrand
On Wed, Jun 22, 2022 at 11:38:35PM -0500, Mike Rapoport wrote:
> On Wed, Jun 22, 2022 at 11:20:11PM -0500, Rebecca Mckeever wrote:
> > On Wed, Jun 22, 2022 at 08:30:36PM -0700, Ira Weiny wrote:
> > > On Wed, Jun 22, 2022 at 04:29:05AM -0500, Rebecca Mckeever wrote:
> > > > These patches add options VERBOSE and MEMBLOCK_DEBUG to Memblock
> > > > simulator, which can be specified when running make. These patches also
> > > > implement the functionality for these options.
> > >
> > > I seem to be missing patch 3/4 and I don't see it on lore?
> > >
> > > https://lore.kernel.org/linux-mm/004e021cc3cb7be8749361b3b1cb324459b9cb9f.1655889641.git.remckee0@gmail.com/
> > >
> > > Did it get sent? Did it define the ASSERT_*() macros?
>
> I see it on lore in both linux-mm and linux-kernel, and here as well:
>
> https://lore.kernel.org/all/39c5c97d2b5c1ab88b7bbbf02633f840fd5dfcdf.1655889641.git.remckee0@gmail.com/
Odd. Thanks!
Ira
>
> > That's strange, my email shows that it was sent to linux-mm@kvack.org and
> > linux-kernel@vger.kernel.org but I'm not seeing it on lore either.
> > Should I resend just patch 3/4?
>
> No need to resend.
>
> > For now, you can take a look at v1. Patch 3 is unchanged from v1, which
> > is showing up on lore:
> >
> > https://lore.kernel.org/linux-mm/fe34452209f54287023ccacd666eade81ecd9a24.1655878337.git.remckee0@gmail.com/T/#u
> >
> > It does not define the ASSERT_*() macros, that happens in patch 2.
> > Patch 3 implements MEMBLOCK_DEBUG.
> >
> > Thanks,
> > Rebecca
> >
>
> --
> Sincerely yours,
> Mike.
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 2/4] memblock tests: add verbose output to memblock tests
2022-06-23 4:30 ` Mike Rapoport
@ 2022-06-23 6:30 ` Rebecca Mckeever
2022-06-23 14:40 ` Mike Rapoport
0 siblings, 1 reply; 31+ messages in thread
From: Rebecca Mckeever @ 2022-06-23 6:30 UTC (permalink / raw)
To: Mike Rapoport; +Cc: linux-mm, linux-kernel, David Hildenbrand
On Wed, Jun 22, 2022 at 11:30:10PM -0500, Mike Rapoport wrote:
> On Wed, Jun 22, 2022 at 04:29:07AM -0500, Rebecca Mckeever wrote:
> > Add and use functions for printing verbose testing output.
> >
> > If the Memblock simulator was compiled with VERBOSE=1:
> > prefix_push() appends the given string to a prefix string that will be
> > printed in the test functions.
> > prefix_pop() removes the last prefix from the prefix string.
> > prefix_reset() clears the prefix string.
> > test_fail() prints a message after a test fails containing the test
> > number of the failing test and the prefix.
> > test_pass() prints a message after a test passes containing its test
> > number and the prefix.
> > test_print() prints the given formatted output string.
> >
> > If the Memblock simulator was not compiled with VERBOSE=1, these
> > functions do nothing.
> >
> > Add the assert wrapper macros ASSERT_EQ(), ASSERT_NE(), and ASSERT_LT().
> > If the assert condition fails, these macros call test_fail() before
> > executing assert().
> >
> > Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> > ---
> > tools/testing/memblock/tests/alloc_api.c | 241 ++++++++----
> > .../memblock/tests/alloc_helpers_api.c | 135 +++++--
> > tools/testing/memblock/tests/alloc_nid_api.c | 371 ++++++++++++------
> > tools/testing/memblock/tests/basic_api.c | 365 ++++++++++++-----
> > tools/testing/memblock/tests/common.c | 58 +++
> > tools/testing/memblock/tests/common.h | 54 +++
> > 6 files changed, 880 insertions(+), 344 deletions(-)
> >
> > diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
> > index d1aa7e15c18d..96df033d4300 100644
> > --- a/tools/testing/memblock/tests/alloc_api.c
> > +++ b/tools/testing/memblock/tests/alloc_api.c
>
> ...
>
> > @@ -729,6 +820,12 @@ static int alloc_no_memory_check(void)
> >
> > int memblock_alloc_checks(void)
> > {
> > + static const char func_testing[] = "memblock_alloc";
> > +
> > + prefix_reset();
> > + prefix_push(func_testing);
> > + test_print("Running %s tests...\n", func_testing);
>
> Why not
>
> test_print("Running memblock_alloc tests...\n");
>
> ?
>
> (applies to other cases below)
Both prefix_push() and test_print() are using that string, and I thought
it made sense to use a constant instead of hard coding the string in both
places. Is it better to hard code the string in this case?
>
> > +
> > reset_memblock_attributes();
> > dummy_physical_memory_init();
>
> ...
>
> > diff --git a/tools/testing/memblock/tests/alloc_helpers_api.c b/tools/testing/memblock/tests/alloc_helpers_api.c
> > index 963a966db461..f6eaed540427 100644
> > --- a/tools/testing/memblock/tests/alloc_helpers_api.c
> > +++ b/tools/testing/memblock/tests/alloc_helpers_api.c
>
> ...
>
> > @@ -378,6 +423,12 @@ static int alloc_from_min_addr_cap_check(void)
> >
> > int memblock_alloc_helpers_checks(void)
> > {
> > + static const char func_testing[] = "memblock_alloc_from";
> > +
> > + prefix_reset();
> > + prefix_push(func_testing);
> > + test_print("Running %s tests...\n", func_testing);
> > +
> > reset_memblock_attributes();
> > dummy_physical_memory_init();
> >
> > diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
> > index 6390206e50e1..601f4a7ee30d 100644
> > --- a/tools/testing/memblock/tests/alloc_nid_api.c
> > +++ b/tools/testing/memblock/tests/alloc_nid_api.c
>
> ...
>
> > @@ -1150,6 +1263,12 @@ static int alloc_try_nid_low_max_check(void)
> >
> > int memblock_alloc_nid_checks(void)
> > {
> > + static const char func_testing[] = "memblock_alloc_try_nid";
> > +
> > + prefix_reset();
> > + prefix_push(func_testing);
> > + test_print("Running %s tests...\n", func_testing);
> > +
> > reset_memblock_attributes();
> > dummy_physical_memory_init();
> >
> > @@ -1170,5 +1289,7 @@ int memblock_alloc_nid_checks(void)
> >
> > dummy_physical_memory_cleanup();
> >
> > + prefix_pop();
> > +
> > return 0;
> > }
> > diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c
> > index a7bc180316d6..f223a9a57be7 100644
> > --- a/tools/testing/memblock/tests/basic_api.c
> > +++ b/tools/testing/memblock/tests/basic_api.c
> > @@ -4,21 +4,30 @@
> > #include "basic_api.h"
> >
> > #define EXPECTED_MEMBLOCK_REGIONS 128
> > +#define FUNC_ADD "memblock_add"
> > +#define FUNC_RESERVE "memblock_reserve"
> > +#define FUNC_REMOVE "memblock_remove"
> > +#define FUNC_FREE "memblock_free"
> >
> > static int memblock_initialization_check(void)
> > {
> > - assert(memblock.memory.regions);
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
> > - assert(strcmp(memblock.memory.name, "memory") == 0);
> > + prefix_push(__func__);
> >
> > - assert(memblock.reserved.regions);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
> > - assert(strcmp(memblock.reserved.name, "reserved") == 0);
> > + ASSERT_NE(memblock.memory.regions, NULL);
> > + ASSERT_EQ(memblock.memory.cnt, 1);
> > + ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
> > + ASSERT_EQ(strcmp(memblock.memory.name, "memory"), 0);
> >
> > - assert(!memblock.bottom_up);
> > - assert(memblock.current_limit == MEMBLOCK_ALLOC_ANYWHERE);
> > + ASSERT_NE(memblock.reserved.regions, NULL);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
> > + ASSERT_EQ(strcmp(memblock.reserved.name, "reserved"), 0);
> > +
> > + ASSERT_EQ(memblock.bottom_up, false);
> > + ASSERT_EQ(memblock.current_limit, MEMBLOCK_ALLOC_ANYWHERE);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -40,14 +49,19 @@ static int memblock_add_simple_check(void)
> > .size = SZ_4M
> > };
> >
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_add(r.base, r.size);
> >
> > - assert(rgn->base == r.base);
> > - assert(rgn->size == r.size);
> > + ASSERT_EQ(rgn->base, r.base);
> > + ASSERT_EQ(rgn->size, r.size);
> > +
> > + ASSERT_EQ(memblock.memory.cnt, 1);
> > + ASSERT_EQ(memblock.memory.total_size, r.size);
> >
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == r.size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -69,18 +83,27 @@ static int memblock_add_node_simple_check(void)
> > .size = SZ_16M
> > };
> >
> > + prefix_pop();
> > + prefix_push("memblock_add_node");
> > + prefix_push(__func__);
>
> I think there is no need to change the prefix from memblock_add to
> memblock_add_node here.
>
> ok 3 : memblock_add: memblock_add_node_simple_check: passed
>
> provides enough information.
>
Will do.
> > +
> > reset_memblock_regions();
> > memblock_add_node(r.base, r.size, 1, MEMBLOCK_HOTPLUG);
> >
> > - assert(rgn->base == r.base);
> > - assert(rgn->size == r.size);
> > + ASSERT_EQ(rgn->base, r.base);
> > + ASSERT_EQ(rgn->size, r.size);
> > #ifdef CONFIG_NUMA
> > - assert(rgn->nid == 1);
> > + ASSERT_EQ(rgn->nid, 1);
> > #endif
> > - assert(rgn->flags == MEMBLOCK_HOTPLUG);
> > + ASSERT_EQ(rgn->flags, MEMBLOCK_HOTPLUG);
> > +
> > + ASSERT_EQ(memblock.memory.cnt, 1);
> > + ASSERT_EQ(memblock.memory.total_size, r.size);
> >
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == r.size);
> > + test_pass();
> > + prefix_pop();
> > + prefix_pop();
> > + prefix_push(FUNC_ADD);
> >
> > return 0;
> > }
>
> --
> Sincerely yours,
> Mike.
Thanks,
Rebecca
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 2/4] memblock tests: add verbose output to memblock tests
2022-06-23 3:37 ` Ira Weiny
@ 2022-06-23 7:25 ` Rebecca Mckeever
0 siblings, 0 replies; 31+ messages in thread
From: Rebecca Mckeever @ 2022-06-23 7:25 UTC (permalink / raw)
To: Ira Weiny; +Cc: Mike Rapoport, linux-mm, linux-kernel, David Hildenbrand
On Wed, Jun 22, 2022 at 08:37:44PM -0700, Ira Weiny wrote:
> On Wed, Jun 22, 2022 at 04:29:07AM -0500, Rebecca Mckeever wrote:
> > Add and use functions for printing verbose testing output.
> >
> > If the Memblock simulator was compiled with VERBOSE=1:
> > prefix_push() appends the given string to a prefix string that will be
> > printed in the test functions.
> > prefix_pop() removes the last prefix from the prefix string.
> > prefix_reset() clears the prefix string.
> > test_fail() prints a message after a test fails containing the test
> > number of the failing test and the prefix.
> > test_pass() prints a message after a test passes containing its test
> > number and the prefix.
> > test_print() prints the given formatted output string.
> >
> > If the Memblock simulator was not compiled with VERBOSE=1, these
> > functions do nothing.
> >
> > Add the assert wrapper macros ASSERT_EQ(), ASSERT_NE(), and ASSERT_LT().
> > If the assert condition fails, these macros call test_fail() before
> > executing assert().
>
>
> The VERBOSE=1 change and the use of ASSERT_*() macros seem to be doing 2
> different things.
>
Patch 1 adds the VERBOSE argument to the Makefile. Patch 2 implements
the output that will be printed when the program is compiled with
make VERBOSE=1
by adding and using the prefix_*() and test_*() functions. The
ASSERT_*() macros run test_fail() before running each assert() for
convenience. The assert()s were already present before these patches.
> Does patch 3/4 modify ASSERT_*() to use the prefix? If so this kind of ties
> the 2 changes together. However, I think I would split it into 2 patches
> anyway.
>
Considering what I said above, do you have any suggestions on how to
split up Patch 2? Or is the commit message misleading?
> Ira
>
Thanks,
Rebecca
> >
> > Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> > ---
> > tools/testing/memblock/tests/alloc_api.c | 241 ++++++++----
> > .../memblock/tests/alloc_helpers_api.c | 135 +++++--
> > tools/testing/memblock/tests/alloc_nid_api.c | 371 ++++++++++++------
> > tools/testing/memblock/tests/basic_api.c | 365 ++++++++++++-----
> > tools/testing/memblock/tests/common.c | 58 +++
> > tools/testing/memblock/tests/common.h | 54 +++
> > 6 files changed, 880 insertions(+), 344 deletions(-)
> >
> > diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
> > index d1aa7e15c18d..96df033d4300 100644
> > --- a/tools/testing/memblock/tests/alloc_api.c
> > +++ b/tools/testing/memblock/tests/alloc_api.c
> > @@ -10,6 +10,8 @@ static int alloc_top_down_simple_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_2;
> > phys_addr_t expected_start;
> >
> > @@ -19,12 +21,15 @@ static int alloc_top_down_simple_check(void)
> >
> > allocated_ptr = memblock_alloc(size, SMP_CACHE_BYTES);
> >
> > - assert(allocated_ptr);
> > - assert(rgn->size == size);
> > - assert(rgn->base == expected_start);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, expected_start);
> > +
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -55,6 +60,8 @@ static int alloc_top_down_disjoint_check(void)
> > struct region r1;
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t r2_size = SZ_16;
> > /* Use custom alignment */
> > phys_addr_t alignment = SMP_CACHE_BYTES * 2;
> > @@ -73,15 +80,18 @@ static int alloc_top_down_disjoint_check(void)
> >
> > allocated_ptr = memblock_alloc(r2_size, alignment);
> >
> > - assert(allocated_ptr);
> > - assert(rgn1->size == r1.size);
> > - assert(rgn1->base == r1.base);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn1->size, r1.size);
> > + ASSERT_EQ(rgn1->base, r1.base);
> >
> > - assert(rgn2->size == r2_size);
> > - assert(rgn2->base == expected_start);
> > + ASSERT_EQ(rgn2->size, r2_size);
> > + ASSERT_EQ(rgn2->base, expected_start);
> >
> > - assert(memblock.reserved.cnt == 2);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -101,6 +111,8 @@ static int alloc_top_down_before_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > /*
> > * The first region ends at the aligned address to test region merging
> > */
> > @@ -114,12 +126,15 @@ static int alloc_top_down_before_check(void)
> >
> > allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
> >
> > - assert(allocated_ptr);
> > - assert(rgn->size == total_size);
> > - assert(rgn->base == memblock_end_of_DRAM() - total_size);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, total_size);
> > + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - total_size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -141,6 +156,8 @@ static int alloc_top_down_after_check(void)
> > struct region r1;
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t r2_size = SZ_512;
> > phys_addr_t total_size;
> >
> > @@ -158,12 +175,15 @@ static int alloc_top_down_after_check(void)
> >
> > allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
> >
> > - assert(allocated_ptr);
> > - assert(rgn->size == total_size);
> > - assert(rgn->base == r1.base - r2_size);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, total_size);
> > + ASSERT_EQ(rgn->base, r1.base - r2_size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -186,6 +206,8 @@ static int alloc_top_down_second_fit_check(void)
> > struct region r1, r2;
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t r3_size = SZ_1K;
> > phys_addr_t total_size;
> >
> > @@ -204,12 +226,15 @@ static int alloc_top_down_second_fit_check(void)
> >
> > allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
> >
> > - assert(allocated_ptr);
> > - assert(rgn->size == r2.size + r3_size);
> > - assert(rgn->base == r2.base - r3_size);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, r2.size + r3_size);
> > + ASSERT_EQ(rgn->base, r2.base - r3_size);
> >
> > - assert(memblock.reserved.cnt == 2);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -231,6 +256,8 @@ static int alloc_in_between_generic_check(void)
> > struct region r1, r2;
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t gap_size = SMP_CACHE_BYTES;
> > phys_addr_t r3_size = SZ_64;
> > /*
> > @@ -254,12 +281,15 @@ static int alloc_in_between_generic_check(void)
> >
> > allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
> >
> > - assert(allocated_ptr);
> > - assert(rgn->size == total_size);
> > - assert(rgn->base == r1.base - r2.size - r3_size);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, total_size);
> > + ASSERT_EQ(rgn->base, r1.base - r2.size - r3_size);
> > +
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -281,6 +311,8 @@ static int alloc_small_gaps_generic_check(void)
> > {
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t region_size = SZ_1K;
> > phys_addr_t gap_size = SZ_256;
> > phys_addr_t region_end;
> > @@ -296,7 +328,10 @@ static int alloc_small_gaps_generic_check(void)
> >
> > allocated_ptr = memblock_alloc(region_size, SMP_CACHE_BYTES);
> >
> > - assert(!allocated_ptr);
> > + ASSERT_EQ(allocated_ptr, NULL);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -309,6 +344,8 @@ static int alloc_all_reserved_generic_check(void)
> > {
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > setup_memblock();
> >
> > /* Simulate full memory */
> > @@ -316,7 +353,10 @@ static int alloc_all_reserved_generic_check(void)
> >
> > allocated_ptr = memblock_alloc(SZ_256, SMP_CACHE_BYTES);
> >
> > - assert(!allocated_ptr);
> > + ASSERT_EQ(allocated_ptr, NULL);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -338,6 +378,8 @@ static int alloc_no_space_generic_check(void)
> > {
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > setup_memblock();
> >
> > phys_addr_t available_size = SZ_256;
> > @@ -348,7 +390,10 @@ static int alloc_no_space_generic_check(void)
> >
> > allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
> >
> > - assert(!allocated_ptr);
> > + ASSERT_EQ(allocated_ptr, NULL);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -369,6 +414,8 @@ static int alloc_limited_space_generic_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t available_size = SZ_256;
> > phys_addr_t reserved_size = MEM_SIZE - available_size;
> >
> > @@ -379,12 +426,15 @@ static int alloc_limited_space_generic_check(void)
> >
> > allocated_ptr = memblock_alloc(available_size, SMP_CACHE_BYTES);
> >
> > - assert(allocated_ptr);
> > - assert(rgn->size == MEM_SIZE);
> > - assert(rgn->base == memblock_start_of_DRAM());
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, MEM_SIZE);
> > + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> > +
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, MEM_SIZE);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == MEM_SIZE);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -399,14 +449,19 @@ static int alloc_no_memory_generic_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> >
> > allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
> >
> > - assert(!allocated_ptr);
> > - assert(rgn->size == 0);
> > - assert(rgn->base == 0);
> > - assert(memblock.reserved.total_size == 0);
> > + ASSERT_EQ(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, 0);
> > + ASSERT_EQ(rgn->base, 0);
> > + ASSERT_EQ(memblock.reserved.total_size, 0);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -421,16 +476,21 @@ static int alloc_bottom_up_simple_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > setup_memblock();
> >
> > allocated_ptr = memblock_alloc(SZ_2, SMP_CACHE_BYTES);
> >
> > - assert(allocated_ptr);
> > - assert(rgn->size == SZ_2);
> > - assert(rgn->base == memblock_start_of_DRAM());
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, SZ_2);
> > + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == SZ_2);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, SZ_2);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -459,6 +519,8 @@ static int alloc_bottom_up_disjoint_check(void)
> > struct region r1;
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t r2_size = SZ_16;
> > /* Use custom alignment */
> > phys_addr_t alignment = SMP_CACHE_BYTES * 2;
> > @@ -477,16 +539,19 @@ static int alloc_bottom_up_disjoint_check(void)
> >
> > allocated_ptr = memblock_alloc(r2_size, alignment);
> >
> > - assert(allocated_ptr);
> > + ASSERT_NE(allocated_ptr, NULL);
> >
> > - assert(rgn1->size == r1.size);
> > - assert(rgn1->base == r1.base);
> > + ASSERT_EQ(rgn1->size, r1.size);
> > + ASSERT_EQ(rgn1->base, r1.base);
> >
> > - assert(rgn2->size == r2_size);
> > - assert(rgn2->base == expected_start);
> > + ASSERT_EQ(rgn2->size, r2_size);
> > + ASSERT_EQ(rgn2->base, expected_start);
> >
> > - assert(memblock.reserved.cnt == 2);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -506,6 +571,8 @@ static int alloc_bottom_up_before_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t r1_size = SZ_512;
> > phys_addr_t r2_size = SZ_128;
> > phys_addr_t total_size = r1_size + r2_size;
> > @@ -516,12 +583,15 @@ static int alloc_bottom_up_before_check(void)
> >
> > allocated_ptr = memblock_alloc(r1_size, SMP_CACHE_BYTES);
> >
> > - assert(allocated_ptr);
> > - assert(rgn->size == total_size);
> > - assert(rgn->base == memblock_start_of_DRAM());
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, total_size);
> > + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -542,6 +612,8 @@ static int alloc_bottom_up_after_check(void)
> > struct region r1;
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t r2_size = SZ_512;
> > phys_addr_t total_size;
> >
> > @@ -559,12 +631,15 @@ static int alloc_bottom_up_after_check(void)
> >
> > allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
> >
> > - assert(allocated_ptr);
> > - assert(rgn->size == total_size);
> > - assert(rgn->base == r1.base);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, total_size);
> > + ASSERT_EQ(rgn->base, r1.base);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -588,6 +663,8 @@ static int alloc_bottom_up_second_fit_check(void)
> > struct region r1, r2;
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t r3_size = SZ_1K;
> > phys_addr_t total_size;
> >
> > @@ -606,12 +683,15 @@ static int alloc_bottom_up_second_fit_check(void)
> >
> > allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
> >
> > - assert(allocated_ptr);
> > - assert(rgn->size == r2.size + r3_size);
> > - assert(rgn->base == r2.base);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, r2.size + r3_size);
> > + ASSERT_EQ(rgn->base, r2.base);
> >
> > - assert(memblock.reserved.cnt == 2);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -619,6 +699,7 @@ static int alloc_bottom_up_second_fit_check(void)
> > /* Test case wrappers */
> > static int alloc_simple_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_top_down_simple_check();
> > memblock_set_bottom_up(true);
> > @@ -629,6 +710,7 @@ static int alloc_simple_check(void)
> >
> > static int alloc_disjoint_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_top_down_disjoint_check();
> > memblock_set_bottom_up(true);
> > @@ -639,6 +721,7 @@ static int alloc_disjoint_check(void)
> >
> > static int alloc_before_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_top_down_before_check();
> > memblock_set_bottom_up(true);
> > @@ -649,6 +732,7 @@ static int alloc_before_check(void)
> >
> > static int alloc_after_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_top_down_after_check();
> > memblock_set_bottom_up(true);
> > @@ -659,6 +743,7 @@ 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);
> > @@ -669,6 +754,7 @@ static int alloc_in_between_check(void)
> >
> > static int alloc_second_fit_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_top_down_second_fit_check();
> > memblock_set_bottom_up(true);
> > @@ -679,6 +765,7 @@ 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);
> > @@ -689,6 +776,7 @@ 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);
> > @@ -699,6 +787,7 @@ 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);
> > @@ -709,6 +798,7 @@ 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);
> > @@ -719,6 +809,7 @@ 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);
> > @@ -729,6 +820,12 @@ static int alloc_no_memory_check(void)
> >
> > int memblock_alloc_checks(void)
> > {
> > + static const char func_testing[] = "memblock_alloc";
> > +
> > + prefix_reset();
> > + prefix_push(func_testing);
> > + test_print("Running %s tests...\n", func_testing);
> > +
> > reset_memblock_attributes();
> > dummy_physical_memory_init();
> >
> > @@ -746,5 +843,7 @@ int memblock_alloc_checks(void)
> >
> > dummy_physical_memory_cleanup();
> >
> > + prefix_pop();
> > +
> > return 0;
> > }
> > diff --git a/tools/testing/memblock/tests/alloc_helpers_api.c b/tools/testing/memblock/tests/alloc_helpers_api.c
> > index 963a966db461..f6eaed540427 100644
> > --- a/tools/testing/memblock/tests/alloc_helpers_api.c
> > +++ b/tools/testing/memblock/tests/alloc_helpers_api.c
> > @@ -21,6 +21,8 @@ static int alloc_from_simple_generic_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_16;
> > phys_addr_t min_addr;
> >
> > @@ -31,14 +33,17 @@ static int alloc_from_simple_generic_check(void)
> > allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
> > b = (char *)allocated_ptr;
> >
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, min_addr);
> >
> > - assert(rgn->size == size);
> > - assert(rgn->base == min_addr);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -64,6 +69,8 @@ static int alloc_from_misaligned_generic_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_32;
> > phys_addr_t min_addr;
> >
> > @@ -75,14 +82,17 @@ static int alloc_from_misaligned_generic_check(void)
> > allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
> > b = (char *)allocated_ptr;
> >
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> >
> > - assert(rgn->size == size);
> > - assert(rgn->base == memblock_end_of_DRAM() - SMP_CACHE_BYTES);
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - SMP_CACHE_BYTES);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -110,6 +120,8 @@ static int alloc_from_top_down_high_addr_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_32;
> > phys_addr_t min_addr;
> >
> > @@ -120,12 +132,15 @@ static int alloc_from_top_down_high_addr_check(void)
> >
> > allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
> >
> > - assert(allocated_ptr);
> > - assert(rgn->size == size);
> > - assert(rgn->base == memblock_end_of_DRAM() - SMP_CACHE_BYTES);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - SMP_CACHE_BYTES);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -151,6 +166,8 @@ static int alloc_from_top_down_no_space_above_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t r1_size = SZ_64;
> > phys_addr_t r2_size = SZ_2;
> > phys_addr_t total_size = r1_size + r2_size;
> > @@ -165,12 +182,15 @@ static int alloc_from_top_down_no_space_above_check(void)
> >
> > allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
> >
> > - assert(allocated_ptr);
> > - assert(rgn->base == min_addr - r1_size);
> > - assert(rgn->size == total_size);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->base, min_addr - r1_size);
> > + ASSERT_EQ(rgn->size, total_size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -186,6 +206,8 @@ static int alloc_from_top_down_min_addr_cap_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t r1_size = SZ_64;
> > phys_addr_t min_addr;
> > phys_addr_t start_addr;
> > @@ -199,12 +221,15 @@ static int alloc_from_top_down_min_addr_cap_check(void)
> >
> > allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
> >
> > - assert(allocated_ptr);
> > - assert(rgn->base == start_addr);
> > - assert(rgn->size == MEM_SIZE);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->base, start_addr);
> > + ASSERT_EQ(rgn->size, MEM_SIZE);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == MEM_SIZE);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, MEM_SIZE);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -230,6 +255,8 @@ static int alloc_from_bottom_up_high_addr_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_32;
> > phys_addr_t min_addr;
> >
> > @@ -240,12 +267,15 @@ static int alloc_from_bottom_up_high_addr_check(void)
> >
> > allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
> >
> > - assert(allocated_ptr);
> > - assert(rgn->size == size);
> > - assert(rgn->base == memblock_start_of_DRAM());
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> > +
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -270,6 +300,8 @@ static int alloc_from_bottom_up_no_space_above_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t r1_size = SZ_64;
> > phys_addr_t min_addr;
> > phys_addr_t r2_size;
> > @@ -284,12 +316,15 @@ static int alloc_from_bottom_up_no_space_above_check(void)
> >
> > allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
> >
> > - assert(allocated_ptr);
> > - assert(rgn->base == memblock_start_of_DRAM());
> > - assert(rgn->size == r1_size);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> > + ASSERT_EQ(rgn->size, r1_size);
> > +
> > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > + ASSERT_EQ(memblock.reserved.total_size, r1_size + r2_size);
> >
> > - assert(memblock.reserved.cnt == 2);
> > - assert(memblock.reserved.total_size == r1_size + r2_size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -304,6 +339,8 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
> > struct memblock_region *rgn = &memblock.reserved.regions[0];
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t r1_size = SZ_64;
> > phys_addr_t min_addr;
> > phys_addr_t start_addr;
> > @@ -315,12 +352,15 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
> >
> > allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
> >
> > - assert(allocated_ptr);
> > - assert(rgn->base == start_addr);
> > - assert(rgn->size == r1_size);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(rgn->base, start_addr);
> > + ASSERT_EQ(rgn->size, r1_size);
> > +
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, r1_size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == r1_size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -328,6 +368,7 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
> > /* Test case wrappers */
> > 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);
> > @@ -338,6 +379,7 @@ 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);
> > @@ -348,6 +390,7 @@ static int alloc_from_misaligned_check(void)
> >
> > static int alloc_from_high_addr_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_from_top_down_high_addr_check();
> > memblock_set_bottom_up(true);
> > @@ -358,6 +401,7 @@ static int alloc_from_high_addr_check(void)
> >
> > static int alloc_from_no_space_above_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_from_top_down_no_space_above_check();
> > memblock_set_bottom_up(true);
> > @@ -368,6 +412,7 @@ static int alloc_from_no_space_above_check(void)
> >
> > static int alloc_from_min_addr_cap_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_from_top_down_min_addr_cap_check();
> > memblock_set_bottom_up(true);
> > @@ -378,6 +423,12 @@ static int alloc_from_min_addr_cap_check(void)
> >
> > int memblock_alloc_helpers_checks(void)
> > {
> > + static const char func_testing[] = "memblock_alloc_from";
> > +
> > + prefix_reset();
> > + prefix_push(func_testing);
> > + test_print("Running %s tests...\n", func_testing);
> > +
> > reset_memblock_attributes();
> > dummy_physical_memory_init();
> >
> > diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
> > index 6390206e50e1..601f4a7ee30d 100644
> > --- a/tools/testing/memblock/tests/alloc_nid_api.c
> > +++ b/tools/testing/memblock/tests/alloc_nid_api.c
> > @@ -21,6 +21,8 @@ static int alloc_try_nid_top_down_simple_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_128;
> > phys_addr_t min_addr;
> > phys_addr_t max_addr;
> > @@ -36,15 +38,18 @@ static int alloc_try_nid_top_down_simple_check(void)
> > b = (char *)allocated_ptr;
> > rgn_end = rgn->base + rgn->size;
> >
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, max_addr - size);
> > + ASSERT_EQ(rgn_end, max_addr);
> >
> > - assert(rgn->size == size);
> > - assert(rgn->base == max_addr - size);
> > - assert(rgn_end == max_addr);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -72,6 +77,8 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_128;
> > phys_addr_t misalign = SZ_2;
> > phys_addr_t min_addr;
> > @@ -88,15 +95,18 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
> > b = (char *)allocated_ptr;
> > rgn_end = rgn->base + rgn->size;
> >
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> >
> > - assert(rgn->size == size);
> > - assert(rgn->base == max_addr - size - misalign);
> > - assert(rgn_end < max_addr);
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, max_addr - size - misalign);
> > + ASSERT_LT(rgn_end, max_addr);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -122,6 +132,8 @@ static int alloc_try_nid_exact_address_generic_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_1K;
> > phys_addr_t min_addr;
> > phys_addr_t max_addr;
> > @@ -137,15 +149,18 @@ static int alloc_try_nid_exact_address_generic_check(void)
> > b = (char *)allocated_ptr;
> > rgn_end = rgn->base + rgn->size;
> >
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, min_addr);
> > + ASSERT_EQ(rgn_end, max_addr);
> >
> > - assert(rgn->size == size);
> > - assert(rgn->base == min_addr);
> > - assert(rgn_end == max_addr);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -173,6 +188,8 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_256;
> > phys_addr_t min_addr;
> > phys_addr_t max_addr;
> > @@ -186,14 +203,17 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
> > min_addr, max_addr, NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> >
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, max_addr - size);
> >
> > - assert(rgn->size == size);
> > - assert(rgn->base == max_addr - size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -222,6 +242,8 @@ static int alloc_try_nid_low_max_generic_check(void)
> > {
> > void *allocated_ptr = NULL;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_1K;
> > phys_addr_t min_addr;
> > phys_addr_t max_addr;
> > @@ -234,7 +256,10 @@ static int alloc_try_nid_low_max_generic_check(void)
> > allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
> > min_addr, max_addr, NUMA_NO_NODE);
> >
> > - assert(!allocated_ptr);
> > + ASSERT_EQ(allocated_ptr, NULL);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -259,6 +284,8 @@ static int alloc_try_nid_min_reserved_generic_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t r1_size = SZ_128;
> > phys_addr_t r2_size = SZ_64;
> > phys_addr_t total_size = r1_size + r2_size;
> > @@ -278,14 +305,17 @@ static int alloc_try_nid_min_reserved_generic_check(void)
> > min_addr, max_addr, NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> >
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> >
> > - assert(rgn->size == total_size);
> > - assert(rgn->base == reserved_base);
> > + ASSERT_EQ(rgn->size, total_size);
> > + ASSERT_EQ(rgn->base, reserved_base);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -310,6 +340,8 @@ static int alloc_try_nid_max_reserved_generic_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t r1_size = SZ_64;
> > phys_addr_t r2_size = SZ_128;
> > phys_addr_t total_size = r1_size + r2_size;
> > @@ -327,14 +359,17 @@ static int alloc_try_nid_max_reserved_generic_check(void)
> > min_addr, max_addr, NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> >
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn->size, total_size);
> > + ASSERT_EQ(rgn->base, min_addr);
> >
> > - assert(rgn->size == total_size);
> > - assert(rgn->base == min_addr);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -364,6 +399,8 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
> > char *b;
> > struct region r1, r2;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t r3_size = SZ_64;
> > phys_addr_t gap_size = SMP_CACHE_BYTES;
> > phys_addr_t total_size;
> > @@ -389,17 +426,20 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
> > min_addr, max_addr, NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> >
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn1->size, r1.size + r3_size);
> > + ASSERT_EQ(rgn1->base, max_addr - r3_size);
> >
> > - assert(rgn1->size == r1.size + r3_size);
> > - assert(rgn1->base == max_addr - r3_size);
> > + ASSERT_EQ(rgn2->size, r2.size);
> > + ASSERT_EQ(rgn2->base, r2.base);
> >
> > - assert(rgn2->size == r2.size);
> > - assert(rgn2->base == r2.base);
> > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> >
> > - assert(memblock.reserved.cnt == 2);
> > - assert(memblock.reserved.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -427,6 +467,8 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
> > char *b;
> > struct region r1, r2;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t r3_size = SZ_64;
> > phys_addr_t total_size;
> > phys_addr_t max_addr;
> > @@ -451,14 +493,17 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
> > min_addr, max_addr, NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> >
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> >
> > - assert(rgn->size == total_size);
> > - assert(rgn->base == r2.base);
> > + ASSERT_EQ(rgn->size, total_size);
> > + ASSERT_EQ(rgn->base, r2.base);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -489,6 +534,8 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
> > char *b;
> > struct region r1, r2;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t r3_size = SZ_256;
> > phys_addr_t gap_size = SMP_CACHE_BYTES;
> > phys_addr_t total_size;
> > @@ -514,17 +561,20 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
> > min_addr, max_addr, NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> >
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn1->size, r1.size);
> > + ASSERT_EQ(rgn1->base, r1.base);
> >
> > - assert(rgn1->size == r1.size);
> > - assert(rgn1->base == r1.base);
> > + ASSERT_EQ(rgn2->size, r2.size + r3_size);
> > + ASSERT_EQ(rgn2->base, r2.base - r3_size);
> >
> > - assert(rgn2->size == r2.size + r3_size);
> > - assert(rgn2->base == r2.base - r3_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> >
> > - assert(memblock.reserved.cnt == 2);
> > - assert(memblock.reserved.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -554,6 +604,8 @@ static int alloc_try_nid_reserved_all_generic_check(void)
> > void *allocated_ptr = NULL;
> > struct region r1, r2;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t r3_size = SZ_256;
> > phys_addr_t gap_size = SMP_CACHE_BYTES;
> > phys_addr_t max_addr;
> > @@ -576,7 +628,10 @@ static int alloc_try_nid_reserved_all_generic_check(void)
> > allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
> > min_addr, max_addr, NUMA_NO_NODE);
> >
> > - assert(!allocated_ptr);
> > + ASSERT_EQ(allocated_ptr, NULL);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -592,6 +647,8 @@ static int alloc_try_nid_top_down_cap_max_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_256;
> > phys_addr_t min_addr;
> > phys_addr_t max_addr;
> > @@ -605,14 +662,17 @@ static int alloc_try_nid_top_down_cap_max_check(void)
> > min_addr, max_addr, NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> >
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
> >
> > - assert(rgn->size == size);
> > - assert(rgn->base == memblock_end_of_DRAM() - size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -628,6 +688,8 @@ static int alloc_try_nid_top_down_cap_min_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_1K;
> > phys_addr_t min_addr;
> > phys_addr_t max_addr;
> > @@ -641,14 +703,17 @@ static int alloc_try_nid_top_down_cap_min_check(void)
> > min_addr, max_addr, NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> >
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> >
> > - assert(rgn->size == size);
> > - assert(rgn->base == memblock_end_of_DRAM() - size);
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -673,6 +738,8 @@ static int alloc_try_nid_bottom_up_simple_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_128;
> > phys_addr_t min_addr;
> > phys_addr_t max_addr;
> > @@ -689,15 +756,18 @@ static int alloc_try_nid_bottom_up_simple_check(void)
> > b = (char *)allocated_ptr;
> > rgn_end = rgn->base + rgn->size;
> >
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, min_addr);
> > + ASSERT_LT(rgn_end, max_addr);
> >
> > - assert(rgn->size == size);
> > - assert(rgn->base == min_addr);
> > - assert(rgn_end < max_addr);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -725,6 +795,8 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_128;
> > phys_addr_t misalign = SZ_2;
> > phys_addr_t min_addr;
> > @@ -742,15 +814,18 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
> > b = (char *)allocated_ptr;
> > rgn_end = rgn->base + rgn->size;
> >
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, min_addr + (SMP_CACHE_BYTES - misalign));
> > + ASSERT_LT(rgn_end, max_addr);
> >
> > - assert(rgn->size == size);
> > - assert(rgn->base == min_addr + (SMP_CACHE_BYTES - misalign));
> > - assert(rgn_end < max_addr);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -778,6 +853,8 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_256;
> > phys_addr_t min_addr;
> > phys_addr_t max_addr;
> > @@ -792,14 +869,17 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
> > NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> >
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> >
> > - assert(rgn->size == size);
> > - assert(rgn->base == memblock_start_of_DRAM());
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -829,6 +909,8 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
> > char *b;
> > struct region r1, r2;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t r3_size = SZ_64;
> > phys_addr_t gap_size = SMP_CACHE_BYTES;
> > phys_addr_t total_size;
> > @@ -855,17 +937,20 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
> > NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> >
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> >
> > - assert(rgn1->size == r1.size);
> > - assert(rgn1->base == max_addr);
> > + ASSERT_EQ(rgn1->size, r1.size);
> > + ASSERT_EQ(rgn1->base, max_addr);
> >
> > - assert(rgn2->size == r2.size + r3_size);
> > - assert(rgn2->base == r2.base);
> > + ASSERT_EQ(rgn2->size, r2.size + r3_size);
> > + ASSERT_EQ(rgn2->base, r2.base);
> >
> > - assert(memblock.reserved.cnt == 2);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -899,6 +984,8 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
> > char *b;
> > struct region r1, r2;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t r3_size = SZ_256;
> > phys_addr_t gap_size = SMP_CACHE_BYTES;
> > phys_addr_t total_size;
> > @@ -925,20 +1012,23 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
> > NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> >
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn3->size, r3_size);
> > + ASSERT_EQ(rgn3->base, memblock_start_of_DRAM());
> >
> > - assert(rgn3->size == r3_size);
> > - assert(rgn3->base == memblock_start_of_DRAM());
> > + ASSERT_EQ(rgn2->size, r2.size);
> > + ASSERT_EQ(rgn2->base, r2.base);
> >
> > - assert(rgn2->size == r2.size);
> > - assert(rgn2->base == r2.base);
> > + ASSERT_EQ(rgn1->size, r1.size);
> > + ASSERT_EQ(rgn1->base, r1.base);
> >
> > - assert(rgn1->size == r1.size);
> > - assert(rgn1->base == r1.base);
> > + ASSERT_EQ(memblock.reserved.cnt, 3);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> >
> > - assert(memblock.reserved.cnt == 3);
> > - assert(memblock.reserved.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -954,6 +1044,8 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_256;
> > phys_addr_t min_addr;
> > phys_addr_t max_addr;
> > @@ -968,14 +1060,17 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
> > NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> >
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, min_addr);
> >
> > - assert(rgn->size == size);
> > - assert(rgn->base == min_addr);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -991,6 +1086,8 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
> > void *allocated_ptr = NULL;
> > char *b;
> >
> > + prefix_push(__func__);
> > +
> > phys_addr_t size = SZ_1K;
> > phys_addr_t min_addr;
> > phys_addr_t max_addr;
> > @@ -1005,14 +1102,17 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
> > NUMA_NO_NODE);
> > b = (char *)allocated_ptr;
> >
> > - assert(allocated_ptr);
> > - assert(*b == 0);
> > + ASSERT_NE(allocated_ptr, NULL);
> > + ASSERT_EQ(*b, 0);
> > +
> > + ASSERT_EQ(rgn->size, size);
> > + ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
> >
> > - assert(rgn->size == size);
> > - assert(rgn->base == memblock_start_of_DRAM());
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -1020,6 +1120,7 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
> > /* Test case wrappers */
> > static int alloc_try_nid_simple_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_try_nid_top_down_simple_check();
> > memblock_set_bottom_up(true);
> > @@ -1030,6 +1131,7 @@ static int alloc_try_nid_simple_check(void)
> >
> > static int alloc_try_nid_misaligned_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_try_nid_top_down_end_misaligned_check();
> > memblock_set_bottom_up(true);
> > @@ -1040,6 +1142,7 @@ static int alloc_try_nid_misaligned_check(void)
> >
> > static int alloc_try_nid_narrow_range_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_try_nid_top_down_narrow_range_check();
> > memblock_set_bottom_up(true);
> > @@ -1050,6 +1153,7 @@ static int alloc_try_nid_narrow_range_check(void)
> >
> > static int alloc_try_nid_reserved_with_space_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_try_nid_top_down_reserved_with_space_check();
> > memblock_set_bottom_up(true);
> > @@ -1060,6 +1164,7 @@ static int alloc_try_nid_reserved_with_space_check(void)
> >
> > static int alloc_try_nid_reserved_no_space_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_try_nid_top_down_reserved_no_space_check();
> > memblock_set_bottom_up(true);
> > @@ -1070,6 +1175,7 @@ static int alloc_try_nid_reserved_no_space_check(void)
> >
> > static int alloc_try_nid_cap_max_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_try_nid_top_down_cap_max_check();
> > memblock_set_bottom_up(true);
> > @@ -1080,6 +1186,7 @@ static int alloc_try_nid_cap_max_check(void)
> >
> > static int alloc_try_nid_cap_min_check(void)
> > {
> > + test_print("\tRunning %s...\n", __func__);
> > memblock_set_bottom_up(false);
> > alloc_try_nid_top_down_cap_min_check();
> > memblock_set_bottom_up(true);
> > @@ -1090,6 +1197,7 @@ 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);
> > @@ -1100,6 +1208,7 @@ 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);
> > @@ -1110,6 +1219,7 @@ 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);
> > @@ -1120,6 +1230,7 @@ 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);
> > @@ -1130,6 +1241,7 @@ 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);
> > @@ -1140,6 +1252,7 @@ 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);
> > @@ -1150,6 +1263,12 @@ static int alloc_try_nid_low_max_check(void)
> >
> > int memblock_alloc_nid_checks(void)
> > {
> > + static const char func_testing[] = "memblock_alloc_try_nid";
> > +
> > + prefix_reset();
> > + prefix_push(func_testing);
> > + test_print("Running %s tests...\n", func_testing);
> > +
> > reset_memblock_attributes();
> > dummy_physical_memory_init();
> >
> > @@ -1170,5 +1289,7 @@ int memblock_alloc_nid_checks(void)
> >
> > dummy_physical_memory_cleanup();
> >
> > + prefix_pop();
> > +
> > return 0;
> > }
> > diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c
> > index a7bc180316d6..f223a9a57be7 100644
> > --- a/tools/testing/memblock/tests/basic_api.c
> > +++ b/tools/testing/memblock/tests/basic_api.c
> > @@ -4,21 +4,30 @@
> > #include "basic_api.h"
> >
> > #define EXPECTED_MEMBLOCK_REGIONS 128
> > +#define FUNC_ADD "memblock_add"
> > +#define FUNC_RESERVE "memblock_reserve"
> > +#define FUNC_REMOVE "memblock_remove"
> > +#define FUNC_FREE "memblock_free"
> >
> > static int memblock_initialization_check(void)
> > {
> > - assert(memblock.memory.regions);
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
> > - assert(strcmp(memblock.memory.name, "memory") == 0);
> > + prefix_push(__func__);
> >
> > - assert(memblock.reserved.regions);
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
> > - assert(strcmp(memblock.reserved.name, "reserved") == 0);
> > + ASSERT_NE(memblock.memory.regions, NULL);
> > + ASSERT_EQ(memblock.memory.cnt, 1);
> > + ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
> > + ASSERT_EQ(strcmp(memblock.memory.name, "memory"), 0);
> >
> > - assert(!memblock.bottom_up);
> > - assert(memblock.current_limit == MEMBLOCK_ALLOC_ANYWHERE);
> > + ASSERT_NE(memblock.reserved.regions, NULL);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
> > + ASSERT_EQ(strcmp(memblock.reserved.name, "reserved"), 0);
> > +
> > + ASSERT_EQ(memblock.bottom_up, false);
> > + ASSERT_EQ(memblock.current_limit, MEMBLOCK_ALLOC_ANYWHERE);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -40,14 +49,19 @@ static int memblock_add_simple_check(void)
> > .size = SZ_4M
> > };
> >
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_add(r.base, r.size);
> >
> > - assert(rgn->base == r.base);
> > - assert(rgn->size == r.size);
> > + ASSERT_EQ(rgn->base, r.base);
> > + ASSERT_EQ(rgn->size, r.size);
> > +
> > + ASSERT_EQ(memblock.memory.cnt, 1);
> > + ASSERT_EQ(memblock.memory.total_size, r.size);
> >
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == r.size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -69,18 +83,27 @@ static int memblock_add_node_simple_check(void)
> > .size = SZ_16M
> > };
> >
> > + prefix_pop();
> > + prefix_push("memblock_add_node");
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_add_node(r.base, r.size, 1, MEMBLOCK_HOTPLUG);
> >
> > - assert(rgn->base == r.base);
> > - assert(rgn->size == r.size);
> > + ASSERT_EQ(rgn->base, r.base);
> > + ASSERT_EQ(rgn->size, r.size);
> > #ifdef CONFIG_NUMA
> > - assert(rgn->nid == 1);
> > + ASSERT_EQ(rgn->nid, 1);
> > #endif
> > - assert(rgn->flags == MEMBLOCK_HOTPLUG);
> > + ASSERT_EQ(rgn->flags, MEMBLOCK_HOTPLUG);
> > +
> > + ASSERT_EQ(memblock.memory.cnt, 1);
> > + ASSERT_EQ(memblock.memory.total_size, r.size);
> >
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == r.size);
> > + test_pass();
> > + prefix_pop();
> > + prefix_pop();
> > + prefix_push(FUNC_ADD);
> >
> > return 0;
> > }
> > @@ -113,18 +136,23 @@ static int memblock_add_disjoint_check(void)
> > .size = SZ_8K
> > };
> >
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_add(r1.base, r1.size);
> > memblock_add(r2.base, r2.size);
> >
> > - assert(rgn1->base == r1.base);
> > - assert(rgn1->size == r1.size);
> > + 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(rgn2->base == r2.base);
> > - assert(rgn2->size == r2.size);
> > + ASSERT_EQ(memblock.memory.cnt, 2);
> > + ASSERT_EQ(memblock.memory.total_size, r1.size + r2.size);
> >
> > - assert(memblock.memory.cnt == 2);
> > - assert(memblock.memory.total_size == r1.size + r2.size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -162,17 +190,22 @@ static int memblock_add_overlap_top_check(void)
> > .size = SZ_512M
> > };
> >
> > + prefix_push(__func__);
> > +
> > total_size = (r1.base - r2.base) + r1.size;
> >
> > reset_memblock_regions();
> > memblock_add(r1.base, r1.size);
> > memblock_add(r2.base, r2.size);
> >
> > - assert(rgn->base == r2.base);
> > - assert(rgn->size == total_size);
> > + ASSERT_EQ(rgn->base, r2.base);
> > + ASSERT_EQ(rgn->size, total_size);
> > +
> > + ASSERT_EQ(memblock.memory.cnt, 1);
> > + ASSERT_EQ(memblock.memory.total_size, total_size);
> >
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -210,17 +243,22 @@ static int memblock_add_overlap_bottom_check(void)
> > .size = SZ_1G
> > };
> >
> > + prefix_push(__func__);
> > +
> > total_size = (r2.base - r1.base) + r2.size;
> >
> > reset_memblock_regions();
> > memblock_add(r1.base, r1.size);
> > memblock_add(r2.base, r2.size);
> >
> > - assert(rgn->base == r1.base);
> > - assert(rgn->size == total_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);
> >
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -255,15 +293,20 @@ static int memblock_add_within_check(void)
> > .size = SZ_1M
> > };
> >
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_add(r1.base, r1.size);
> > memblock_add(r2.base, r2.size);
> >
> > - assert(rgn->base == r1.base);
> > - assert(rgn->size == r1.size);
> > + ASSERT_EQ(rgn->base, r1.base);
> > + ASSERT_EQ(rgn->size, r1.size);
> > +
> > + ASSERT_EQ(memblock.memory.cnt, 1);
> > + ASSERT_EQ(memblock.memory.total_size, r1.size);
> >
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == r1.size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -279,19 +322,28 @@ static int memblock_add_twice_check(void)
> > .size = SZ_2M
> > };
> >
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> >
> > memblock_add(r.base, r.size);
> > memblock_add(r.base, r.size);
> >
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == r.size);
> > + ASSERT_EQ(memblock.memory.cnt, 1);
> > + ASSERT_EQ(memblock.memory.total_size, r.size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> >
> > static int memblock_add_checks(void)
> > {
> > + prefix_reset();
> > + prefix_push(FUNC_ADD);
> > + test_print("Running %s tests...\n", FUNC_ADD);
> > +
> > memblock_add_simple_check();
> > memblock_add_node_simple_check();
> > memblock_add_disjoint_check();
> > @@ -300,6 +352,8 @@ static int memblock_add_checks(void)
> > memblock_add_within_check();
> > memblock_add_twice_check();
> >
> > + prefix_pop();
> > +
> > return 0;
> > }
> >
> > @@ -320,11 +374,16 @@ static int memblock_reserve_simple_check(void)
> > .size = SZ_128M
> > };
> >
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_reserve(r.base, r.size);
> >
> > - assert(rgn->base == r.base);
> > - assert(rgn->size == r.size);
> > + ASSERT_EQ(rgn->base, r.base);
> > + ASSERT_EQ(rgn->size, r.size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -356,18 +415,23 @@ static int memblock_reserve_disjoint_check(void)
> > .size = SZ_512M
> > };
> >
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_reserve(r1.base, r1.size);
> > memblock_reserve(r2.base, r2.size);
> >
> > - assert(rgn1->base == r1.base);
> > - assert(rgn1->size == r1.size);
> > + 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(rgn2->base == r2.base);
> > - assert(rgn2->size == r2.size);
> > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > + ASSERT_EQ(memblock.reserved.total_size, r1.size + r2.size);
> >
> > - assert(memblock.reserved.cnt == 2);
> > - assert(memblock.reserved.total_size == r1.size + r2.size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -406,17 +470,22 @@ static int memblock_reserve_overlap_top_check(void)
> > .size = SZ_1G
> > };
> >
> > + prefix_push(__func__);
> > +
> > total_size = (r1.base - r2.base) + r1.size;
> >
> > reset_memblock_regions();
> > memblock_reserve(r1.base, r1.size);
> > memblock_reserve(r2.base, r2.size);
> >
> > - assert(rgn->base == r2.base);
> > - assert(rgn->size == total_size);
> > + ASSERT_EQ(rgn->base, r2.base);
> > + ASSERT_EQ(rgn->size, total_size);
> > +
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -455,17 +524,22 @@ static int memblock_reserve_overlap_bottom_check(void)
> > .size = SZ_128K
> > };
> >
> > + prefix_push(__func__);
> > +
> > total_size = (r2.base - r1.base) + r2.size;
> >
> > reset_memblock_regions();
> > memblock_reserve(r1.base, r1.size);
> > memblock_reserve(r2.base, r2.size);
> >
> > - assert(rgn->base == r1.base);
> > - assert(rgn->size == total_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);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -502,15 +576,20 @@ static int memblock_reserve_within_check(void)
> > .size = SZ_64K
> > };
> >
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_reserve(r1.base, r1.size);
> > memblock_reserve(r2.base, r2.size);
> >
> > - assert(rgn->base == r1.base);
> > - assert(rgn->size == r1.size);
> > + ASSERT_EQ(rgn->base, r1.base);
> > + ASSERT_EQ(rgn->size, r1.size);
> > +
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, r1.size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == r1.size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -527,19 +606,28 @@ static int memblock_reserve_twice_check(void)
> > .size = SZ_2M
> > };
> >
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> >
> > memblock_reserve(r.base, r.size);
> > memblock_reserve(r.base, r.size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == r.size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, r.size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> >
> > static int memblock_reserve_checks(void)
> > {
> > + prefix_reset();
> > + prefix_push(FUNC_RESERVE);
> > + test_print("Running %s tests...\n", FUNC_RESERVE);
> > +
> > memblock_reserve_simple_check();
> > memblock_reserve_disjoint_check();
> > memblock_reserve_overlap_top_check();
> > @@ -547,6 +635,8 @@ static int memblock_reserve_checks(void)
> > memblock_reserve_within_check();
> > memblock_reserve_twice_check();
> >
> > + prefix_pop();
> > +
> > return 0;
> > }
> >
> > @@ -581,16 +671,21 @@ static int memblock_remove_simple_check(void)
> > .size = SZ_4M
> > };
> >
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_add(r1.base, r1.size);
> > memblock_add(r2.base, r2.size);
> > memblock_remove(r1.base, r1.size);
> >
> > - assert(rgn->base == r2.base);
> > - assert(rgn->size == r2.size);
> > + ASSERT_EQ(rgn->base, r2.base);
> > + ASSERT_EQ(rgn->size, r2.size);
> >
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == r2.size);
> > + ASSERT_EQ(memblock.memory.cnt, 1);
> > + ASSERT_EQ(memblock.memory.total_size, r2.size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -626,15 +721,20 @@ static int memblock_remove_absent_check(void)
> > .size = SZ_1G
> > };
> >
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_add(r1.base, r1.size);
> > memblock_remove(r2.base, r2.size);
> >
> > - assert(rgn->base == r1.base);
> > - assert(rgn->size == r1.size);
> > + ASSERT_EQ(rgn->base, r1.base);
> > + ASSERT_EQ(rgn->size, r1.size);
> > +
> > + ASSERT_EQ(memblock.memory.cnt, 1);
> > + ASSERT_EQ(memblock.memory.total_size, r1.size);
> >
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == r1.size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -674,6 +774,8 @@ static int memblock_remove_overlap_top_check(void)
> > .size = SZ_32M
> > };
> >
> > + prefix_push(__func__);
> > +
> > r1_end = r1.base + r1.size;
> > r2_end = r2.base + r2.size;
> > total_size = r1_end - r2_end;
> > @@ -682,11 +784,14 @@ static int memblock_remove_overlap_top_check(void)
> > memblock_add(r1.base, r1.size);
> > memblock_remove(r2.base, r2.size);
> >
> > - assert(rgn->base == r1.base + r2.base);
> > - assert(rgn->size == total_size);
> > + ASSERT_EQ(rgn->base, r1.base + r2.base);
> > + ASSERT_EQ(rgn->size, total_size);
> > +
> > + ASSERT_EQ(memblock.memory.cnt, 1);
> > + ASSERT_EQ(memblock.memory.total_size, total_size);
> >
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -724,17 +829,23 @@ static int memblock_remove_overlap_bottom_check(void)
> > .size = SZ_256M
> > };
> >
> > + prefix_push(__func__);
> > +
> > total_size = r2.base - r1.base;
> >
> > reset_memblock_regions();
> > memblock_add(r1.base, r1.size);
> > memblock_remove(r2.base, r2.size);
> >
> > - assert(rgn->base == r1.base);
> > - assert(rgn->size == total_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();
> > + prefix_pop();
> >
> > - assert(memblock.memory.cnt == 1);
> > - assert(memblock.memory.total_size == total_size);
> > return 0;
> > }
> >
> > @@ -774,6 +885,8 @@ static int memblock_remove_within_check(void)
> > .size = SZ_1M
> > };
> >
> > + prefix_push(__func__);
> > +
> > r1_size = r2.base - r1.base;
> > r2_size = (r1.base + r1.size) - (r2.base + r2.size);
> > total_size = r1_size + r2_size;
> > @@ -782,26 +895,35 @@ static int memblock_remove_within_check(void)
> > memblock_add(r1.base, r1.size);
> > memblock_remove(r2.base, r2.size);
> >
> > - assert(rgn1->base == r1.base);
> > - assert(rgn1->size == r1_size);
> > + ASSERT_EQ(rgn1->base, r1.base);
> > + ASSERT_EQ(rgn1->size, r1_size);
> > +
> > + ASSERT_EQ(rgn2->base, r2.base + r2.size);
> > + ASSERT_EQ(rgn2->size, r2_size);
> >
> > - assert(rgn2->base == r2.base + r2.size);
> > - assert(rgn2->size == r2_size);
> > + ASSERT_EQ(memblock.memory.cnt, 2);
> > + ASSERT_EQ(memblock.memory.total_size, total_size);
> >
> > - assert(memblock.memory.cnt == 2);
> > - assert(memblock.memory.total_size == total_size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> >
> > static int memblock_remove_checks(void)
> > {
> > + prefix_reset();
> > + prefix_push(FUNC_REMOVE);
> > + test_print("Running %s tests...\n", FUNC_REMOVE);
> > +
> > memblock_remove_simple_check();
> > memblock_remove_absent_check();
> > memblock_remove_overlap_top_check();
> > memblock_remove_overlap_bottom_check();
> > memblock_remove_within_check();
> >
> > + prefix_pop();
> > +
> > return 0;
> > }
> >
> > @@ -835,16 +957,21 @@ static int memblock_free_simple_check(void)
> > .size = SZ_1M
> > };
> >
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_reserve(r1.base, r1.size);
> > memblock_reserve(r2.base, r2.size);
> > memblock_free((void *)r1.base, r1.size);
> >
> > - assert(rgn->base == r2.base);
> > - assert(rgn->size == r2.size);
> > + ASSERT_EQ(rgn->base, r2.base);
> > + ASSERT_EQ(rgn->size, r2.size);
> > +
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, r2.size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == r2.size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -880,15 +1007,20 @@ static int memblock_free_absent_check(void)
> > .size = SZ_128M
> > };
> >
> > + prefix_push(__func__);
> > +
> > reset_memblock_regions();
> > memblock_reserve(r1.base, r1.size);
> > memblock_free((void *)r2.base, r2.size);
> >
> > - assert(rgn->base == r1.base);
> > - assert(rgn->size == r1.size);
> > + ASSERT_EQ(rgn->base, r1.base);
> > + ASSERT_EQ(rgn->size, r1.size);
> > +
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, r1.size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == r1.size);
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -928,17 +1060,22 @@ static int memblock_free_overlap_top_check(void)
> > .size = SZ_8M
> > };
> >
> > + prefix_push(__func__);
> > +
> > total_size = (r1.size + r1.base) - (r2.base + r2.size);
> >
> > reset_memblock_regions();
> > memblock_reserve(r1.base, r1.size);
> > memblock_free((void *)r2.base, r2.size);
> >
> > - assert(rgn->base == r2.base + r2.size);
> > - assert(rgn->size == total_size);
> > + ASSERT_EQ(rgn->base, r2.base + r2.size);
> > + ASSERT_EQ(rgn->size, total_size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -973,17 +1110,22 @@ static int memblock_free_overlap_bottom_check(void)
> > .size = SZ_32M
> > };
> >
> > + prefix_push(__func__);
> > +
> > total_size = r2.base - r1.base;
> >
> > reset_memblock_regions();
> > memblock_reserve(r1.base, r1.size);
> > memblock_free((void *)r2.base, r2.size);
> >
> > - assert(rgn->base == r1.base);
> > - assert(rgn->size == total_size);
> > + ASSERT_EQ(rgn->base, r1.base);
> > + ASSERT_EQ(rgn->size, total_size);
> >
> > - assert(memblock.reserved.cnt == 1);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> > @@ -1024,6 +1166,8 @@ static int memblock_free_within_check(void)
> > .size = SZ_1M
> > };
> >
> > + prefix_push(__func__);
> > +
> > r1_size = r2.base - r1.base;
> > r2_size = (r1.base + r1.size) - (r2.base + r2.size);
> > total_size = r1_size + r2_size;
> > @@ -1032,26 +1176,35 @@ static int memblock_free_within_check(void)
> > memblock_reserve(r1.base, r1.size);
> > memblock_free((void *)r2.base, r2.size);
> >
> > - assert(rgn1->base == r1.base);
> > - assert(rgn1->size == r1_size);
> > + ASSERT_EQ(rgn1->base, r1.base);
> > + ASSERT_EQ(rgn1->size, r1_size);
> >
> > - assert(rgn2->base == r2.base + r2.size);
> > - assert(rgn2->size == r2_size);
> > + ASSERT_EQ(rgn2->base, r2.base + r2.size);
> > + ASSERT_EQ(rgn2->size, r2_size);
> >
> > - assert(memblock.reserved.cnt == 2);
> > - assert(memblock.reserved.total_size == total_size);
> > + ASSERT_EQ(memblock.reserved.cnt, 2);
> > + ASSERT_EQ(memblock.reserved.total_size, total_size);
> > +
> > + test_pass();
> > + prefix_pop();
> >
> > return 0;
> > }
> >
> > static int memblock_free_checks(void)
> > {
> > + prefix_reset();
> > + prefix_push(FUNC_FREE);
> > + test_print("Running %s tests...\n", FUNC_FREE);
> > +
> > memblock_free_simple_check();
> > memblock_free_absent_check();
> > memblock_free_overlap_top_check();
> > memblock_free_overlap_bottom_check();
> > memblock_free_within_check();
> >
> > + prefix_pop();
> > +
> > return 0;
> > }
> >
> > diff --git a/tools/testing/memblock/tests/common.c b/tools/testing/memblock/tests/common.c
> > index 62d3191f7c9a..e55b2a8bf0ff 100644
> > --- a/tools/testing/memblock/tests/common.c
> > +++ b/tools/testing/memblock/tests/common.c
> > @@ -4,8 +4,12 @@
> >
> > #define INIT_MEMBLOCK_REGIONS 128
> > #define INIT_MEMBLOCK_RESERVED_REGIONS INIT_MEMBLOCK_REGIONS
> > +#define PREFIXES_LEN_MAX 256
> > +#define DELIM ": "
> > +#define DELIM_LEN strlen(DELIM)
> >
> > static struct test_memory memory_block;
> > +static char __maybe_unused prefixes[PREFIXES_LEN_MAX];
> >
> > void reset_memblock_regions(void)
> > {
> > @@ -46,3 +50,57 @@ void dummy_physical_memory_cleanup(void)
> > {
> > free(memory_block.base);
> > }
> > +
> > +#ifdef VERBOSE
> > +void test_fail(void)
> > +{
> > + ksft_test_result_fail(": %sfailed\n", prefixes);
> > +}
> > +
> > +void test_pass(void)
> > +{
> > + ksft_test_result_pass(": %spassed\n", prefixes);
> > +}
> > +
> > +void test_print(const char *fmt, ...)
> > +{
> > + int saved_errno = errno;
> > + va_list args;
> > +
> > + va_start(args, fmt);
> > + errno = saved_errno;
> > + vprintf(fmt, args);
> > + va_end(args);
> > +}
> > +
> > +void prefix_reset(void)
> > +{
> > + memset(prefixes, 0, PREFIXES_LEN_MAX);
> > +}
> > +
> > +void prefix_push(const char *prefix)
> > +{
> > + int prefix_max = PREFIXES_LEN_MAX - strlen(prefixes) - DELIM_LEN - 1;
> > +
> > + assert(strlen(prefix) <= prefix_max);
> > + strncat(prefixes, prefix, prefix_max);
> > + strncat(prefixes, DELIM, PREFIXES_LEN_MAX - strlen(prefixes) - 1);
> > +}
> > +
> > +void prefix_pop(void)
> > +{
> > + char *ptr;
> > +
> > + ptr = strrchr(prefixes, DELIM[0]);
> > + if (!ptr)
> > + prefixes[0] = 0;
> > + else
> > + *(ptr) = 0;
> > +
> > + ptr = strrchr(prefixes, DELIM[0]);
> > + if (!ptr)
> > + prefixes[0] = 0;
> > + else
> > + *(ptr + DELIM_LEN) = 0;
> > +}
> > +#endif /* VERBOSE */
> > diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h
> > index 619054d03219..bdddb5f72871 100644
> > --- a/tools/testing/memblock/tests/common.h
> > +++ b/tools/testing/memblock/tests/common.h
> > @@ -7,9 +7,47 @@
> > #include <linux/types.h>
> > #include <linux/memblock.h>
> > #include <linux/sizes.h>
> > +#include <linux/printk.h>
> > +#include <../selftests/kselftest.h>
> >
> > #define MEM_SIZE SZ_16K
> >
> > +/**
> > + * ASSERT_EQ():
> > + * Check the condition
> > + * @_expected == @_seen
> > + * If false, print failed test message (if in VERBOSE mode) and then assert
> > + */
> > +#define ASSERT_EQ(_expected, _seen) do { \
> > + if ((_expected) != (_seen)) \
> > + test_fail(); \
> > + assert((_expected) == (_seen)); \
> > +} while (0)
> > +
> > +/**
> > + * ASSERT_NE():
> > + * Check the condition
> > + * @_expected != @_seen
> > + * If false, print failed test message (if in VERBOSE mode) and then assert
> > + */
> > +#define ASSERT_NE(_expected, _seen) do { \
> > + if ((_expected) == (_seen)) \
> > + test_fail(); \
> > + assert((_expected) != (_seen)); \
> > +} while (0)
> > +
> > +/**
> > + * ASSERT_LT():
> > + * Check the condition
> > + * @_expected < @_seen
> > + * If false, print failed test message (if in VERBOSE mode) and then assert
> > + */
> > +#define ASSERT_LT(_expected, _seen) do { \
> > + if ((_expected) >= (_seen)) \
> > + test_fail(); \
> > + assert((_expected) < (_seen)); \
> > +} while (0)
> > +
> > /*
> > * Available memory registered with memblock needs to be valid for allocs
> > * test to run. This is a convenience wrapper for memory allocated in
> > @@ -31,4 +69,20 @@ void setup_memblock(void);
> > void dummy_physical_memory_init(void);
> > void dummy_physical_memory_cleanup(void);
> >
> > +#ifdef VERBOSE
> > +void test_fail(void);
> > +void test_pass(void);
> > +void test_print(const char *fmt, ...);
> > +void prefix_reset(void);
> > +void prefix_push(const char *prefix);
> > +void prefix_pop(void);
> > +#else
> > +static inline void test_fail(void) {}
> > +static inline void test_pass(void) {}
> > +static inline void test_print(const char *fmt, ...) {}
> > +static inline void prefix_reset(void) {}
> > +static inline void prefix_push(const char *prefix) {}
> > +static inline void prefix_pop(void) {}
> > +#endif /* VERBOSE */
> > +
> > #endif
> > --
> > 2.34.1
> >
> >
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 2/4] memblock tests: add verbose output to memblock tests
2022-06-23 5:04 ` Mike Rapoport
@ 2022-06-23 7:57 ` Rebecca Mckeever
2022-06-23 13:11 ` Mike Rapoport
0 siblings, 1 reply; 31+ messages in thread
From: Rebecca Mckeever @ 2022-06-23 7:57 UTC (permalink / raw)
To: Mike Rapoport; +Cc: Huang, Shaoqin, linux-mm, linux-kernel, David Hildenbrand
On Thu, Jun 23, 2022 at 12:04:33AM -0500, Mike Rapoport wrote:
> On Wed, Jun 22, 2022 at 11:56:30PM -0500, Rebecca Mckeever wrote:
> > On Wed, Jun 22, 2022 at 11:05:27PM -0500, Mike Rapoport wrote:
> > > On Thu, Jun 23, 2022 at 09:29:05AM +0800, Huang, Shaoqin wrote:
> > > >
> > > >
> > > > On 6/23/2022 8:45 AM, Rebecca Mckeever wrote:
> > > > > On Wed, Jun 22, 2022 at 06:32:04PM +0800, Huang, Shaoqin wrote:
> > > > > > Just test it and everything works fine. And I think there are some thing can
> > > > > > improve:
> > > > > >
> > > > > > The prefix_push() and prefix_pop() are used in so many functions and
> > > > > > almost of them just put the prefix_push(__func__) begin in the head and the
> > > > > > prefix_pop() in the end.
> > > > > > May be you can define some macro that when you output something and
> > > > > > automatically push the __func__ as prefix. And when leave the function,
> > > > > > automatically pop it. And only in some special place, you call it manually.
> > > > > >
> > > > > Thank you for your review. I'm not sure how you would automatically push
> > > > > __func__ since you have to be inside the function to access that
> > > > > variable. Let me know if you have any suggestions. I am thinking about
> > > > > adding another function in common.c that just calls test_pass() followed
> > > > > by prefix_pop() since those are called together so often.
> > > >
> > > > Just like:
> > > > #define test_pass_macro() \
> > > > do { \
> > > > prefix_push(__func__); \
> > > > test_pass(); \
> > > > prefix_pop(); \
> > > > } while (0)
> > >
> > > This will not print the name of the failing test, e.g. instead of
> > >
> > > not ok 28 : memblock_alloc: alloc_bottom_up_disjoint_check: failed
> > >
> > > with Rebecca's implementation it'll print
> > >
> > > not ok 28 : memblock_alloc: failed
> > >
> > Oh yeah, prefix_push() needs to be called before the asserts.
> >
> > > How about
> > >
> > > #define PREFIX_PUSH() prefix_push(__func__)?
> > >
> > Good idea. What about
> >
> > #define TEST_PASS() do { \
> > test_pass(); \
> > prefix_pop(); \
> > } while (0)
> >
> > ? Or would it be better to make a function?
>
> static inline function would be better.
>
Would there be any advantage to defining a different version for each
side of #ifdef VERBOSE?
> > Thanks,
> > Rebecca
>
> --
> Sincerely yours,
> Mike.
Thanks,
Rebecca
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 2/4] memblock tests: add verbose output to memblock tests
2022-06-23 7:57 ` Rebecca Mckeever
@ 2022-06-23 13:11 ` Mike Rapoport
0 siblings, 0 replies; 31+ messages in thread
From: Mike Rapoport @ 2022-06-23 13:11 UTC (permalink / raw)
To: Rebecca Mckeever
Cc: Huang, Shaoqin, linux-mm, linux-kernel, David Hildenbrand
On Thu, Jun 23, 2022 at 02:57:30AM -0500, Rebecca Mckeever wrote:
> On Thu, Jun 23, 2022 at 12:04:33AM -0500, Mike Rapoport wrote:
> > On Wed, Jun 22, 2022 at 11:56:30PM -0500, Rebecca Mckeever wrote:
> > > On Wed, Jun 22, 2022 at 11:05:27PM -0500, Mike Rapoport wrote:
> > > > On Thu, Jun 23, 2022 at 09:29:05AM +0800, Huang, Shaoqin wrote:
> > > > >
> > > > >
> > > > > On 6/23/2022 8:45 AM, Rebecca Mckeever wrote:
> > > > > > On Wed, Jun 22, 2022 at 06:32:04PM +0800, Huang, Shaoqin wrote:
> > > > > > > Just test it and everything works fine. And I think there are some thing can
> > > > > > > improve:
> > > > > > >
> > > > > > > The prefix_push() and prefix_pop() are used in so many functions and
> > > > > > > almost of them just put the prefix_push(__func__) begin in the head and the
> > > > > > > prefix_pop() in the end.
> > > > > > > May be you can define some macro that when you output something and
> > > > > > > automatically push the __func__ as prefix. And when leave the function,
> > > > > > > automatically pop it. And only in some special place, you call it manually.
> > > > > > >
> > > > > > Thank you for your review. I'm not sure how you would automatically push
> > > > > > __func__ since you have to be inside the function to access that
> > > > > > variable. Let me know if you have any suggestions. I am thinking about
> > > > > > adding another function in common.c that just calls test_pass() followed
> > > > > > by prefix_pop() since those are called together so often.
> > > > >
> > > > > Just like:
> > > > > #define test_pass_macro() \
> > > > > do { \
> > > > > prefix_push(__func__); \
> > > > > test_pass(); \
> > > > > prefix_pop(); \
> > > > > } while (0)
> > > >
> > > > This will not print the name of the failing test, e.g. instead of
> > > >
> > > > not ok 28 : memblock_alloc: alloc_bottom_up_disjoint_check: failed
> > > >
> > > > with Rebecca's implementation it'll print
> > > >
> > > > not ok 28 : memblock_alloc: failed
> > > >
> > > Oh yeah, prefix_push() needs to be called before the asserts.
> > >
> > > > How about
> > > >
> > > > #define PREFIX_PUSH() prefix_push(__func__)?
> > > >
> > > Good idea. What about
> > >
> > > #define TEST_PASS() do { \
> > > test_pass(); \
> > > prefix_pop(); \
> > > } while (0)
> > >
> > > ? Or would it be better to make a function?
> >
> > static inline function would be better.
> >
> Would there be any advantage to defining a different version for each
> side of #ifdef VERBOSE?
No, a single version will do. For !VERBOSE builds it will be optimized out
anyway.
>
> Thanks,
> Rebecca
--
Sincerely yours,
Mike.
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 2/4] memblock tests: add verbose output to memblock tests
2022-06-23 6:30 ` Rebecca Mckeever
@ 2022-06-23 14:40 ` Mike Rapoport
2022-06-24 7:18 ` Rebecca Mckeever
0 siblings, 1 reply; 31+ messages in thread
From: Mike Rapoport @ 2022-06-23 14:40 UTC (permalink / raw)
To: Rebecca Mckeever; +Cc: linux-mm, linux-kernel, David Hildenbrand
On Thu, Jun 23, 2022 at 01:30:42AM -0500, Rebecca Mckeever wrote:
> On Wed, Jun 22, 2022 at 11:30:10PM -0500, Mike Rapoport wrote:
> > On Wed, Jun 22, 2022 at 04:29:07AM -0500, Rebecca Mckeever wrote:
> > > Add and use functions for printing verbose testing output.
> > >
> > > If the Memblock simulator was compiled with VERBOSE=1:
> > > prefix_push() appends the given string to a prefix string that will be
> > > printed in the test functions.
> > > prefix_pop() removes the last prefix from the prefix string.
> > > prefix_reset() clears the prefix string.
> > > test_fail() prints a message after a test fails containing the test
> > > number of the failing test and the prefix.
> > > test_pass() prints a message after a test passes containing its test
> > > number and the prefix.
> > > test_print() prints the given formatted output string.
> > >
> > > If the Memblock simulator was not compiled with VERBOSE=1, these
> > > functions do nothing.
> > >
> > > Add the assert wrapper macros ASSERT_EQ(), ASSERT_NE(), and ASSERT_LT().
> > > If the assert condition fails, these macros call test_fail() before
> > > executing assert().
> > >
> > > Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> > > ---
> > > tools/testing/memblock/tests/alloc_api.c | 241 ++++++++----
> > > .../memblock/tests/alloc_helpers_api.c | 135 +++++--
> > > tools/testing/memblock/tests/alloc_nid_api.c | 371 ++++++++++++------
> > > tools/testing/memblock/tests/basic_api.c | 365 ++++++++++++-----
> > > tools/testing/memblock/tests/common.c | 58 +++
> > > tools/testing/memblock/tests/common.h | 54 +++
> > > 6 files changed, 880 insertions(+), 344 deletions(-)
> > >
> > > diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
> > > index d1aa7e15c18d..96df033d4300 100644
> > > --- a/tools/testing/memblock/tests/alloc_api.c
> > > +++ b/tools/testing/memblock/tests/alloc_api.c
> >
> > ...
> >
> > > @@ -729,6 +820,12 @@ static int alloc_no_memory_check(void)
> > >
> > > int memblock_alloc_checks(void)
> > > {
> > > + static const char func_testing[] = "memblock_alloc";
> > > +
> > > + prefix_reset();
> > > + prefix_push(func_testing);
> > > + test_print("Running %s tests...\n", func_testing);
> >
> > Why not
> >
> > test_print("Running memblock_alloc tests...\n");
> >
> > ?
> >
> > (applies to other cases below)
>
> Both prefix_push() and test_print() are using that string, and I thought
> it made sense to use a constant instead of hard coding the string in both
> places. Is it better to hard code the string in this case?
Oh, missed that.
I'd drop static, it doesn't really matter here.
> > > +
> > > reset_memblock_attributes();
> > > dummy_physical_memory_init();
> >
> > ...
> >
> > > diff --git a/tools/testing/memblock/tests/alloc_helpers_api.c b/tools/testing/memblock/tests/alloc_helpers_api.c
> > > index 963a966db461..f6eaed540427 100644
> > > --- a/tools/testing/memblock/tests/alloc_helpers_api.c
> > > +++ b/tools/testing/memblock/tests/alloc_helpers_api.c
> >
> > ...
> >
> > > @@ -378,6 +423,12 @@ static int alloc_from_min_addr_cap_check(void)
> > >
> > > int memblock_alloc_helpers_checks(void)
> > > {
> > > + static const char func_testing[] = "memblock_alloc_from";
> > > +
> > > + prefix_reset();
> > > + prefix_push(func_testing);
> > > + test_print("Running %s tests...\n", func_testing);
> > > +
> > > reset_memblock_attributes();
> > > dummy_physical_memory_init();
> > >
> > > diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
> > > index 6390206e50e1..601f4a7ee30d 100644
> > > --- a/tools/testing/memblock/tests/alloc_nid_api.c
> > > +++ b/tools/testing/memblock/tests/alloc_nid_api.c
> >
> > ...
> >
> > > @@ -1150,6 +1263,12 @@ static int alloc_try_nid_low_max_check(void)
> > >
> > > int memblock_alloc_nid_checks(void)
> > > {
> > > + static const char func_testing[] = "memblock_alloc_try_nid";
> > > +
> > > + prefix_reset();
> > > + prefix_push(func_testing);
> > > + test_print("Running %s tests...\n", func_testing);
> > > +
> > > reset_memblock_attributes();
> > > dummy_physical_memory_init();
> > >
> > > @@ -1170,5 +1289,7 @@ int memblock_alloc_nid_checks(void)
> > >
> > > dummy_physical_memory_cleanup();
> > >
> > > + prefix_pop();
> > > +
> > > return 0;
> > > }
> > > diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c
> > > index a7bc180316d6..f223a9a57be7 100644
> > > --- a/tools/testing/memblock/tests/basic_api.c
> > > +++ b/tools/testing/memblock/tests/basic_api.c
> > > @@ -4,21 +4,30 @@
> > > #include "basic_api.h"
> > >
> > > #define EXPECTED_MEMBLOCK_REGIONS 128
> > > +#define FUNC_ADD "memblock_add"
> > > +#define FUNC_RESERVE "memblock_reserve"
> > > +#define FUNC_REMOVE "memblock_remove"
> > > +#define FUNC_FREE "memblock_free"
> > >
> > > static int memblock_initialization_check(void)
> > > {
> > > - assert(memblock.memory.regions);
> > > - assert(memblock.memory.cnt == 1);
> > > - assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
> > > - assert(strcmp(memblock.memory.name, "memory") == 0);
> > > + prefix_push(__func__);
> > >
> > > - assert(memblock.reserved.regions);
> > > - assert(memblock.reserved.cnt == 1);
> > > - assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
> > > - assert(strcmp(memblock.reserved.name, "reserved") == 0);
> > > + ASSERT_NE(memblock.memory.regions, NULL);
> > > + ASSERT_EQ(memblock.memory.cnt, 1);
> > > + ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
> > > + ASSERT_EQ(strcmp(memblock.memory.name, "memory"), 0);
> > >
> > > - assert(!memblock.bottom_up);
> > > - assert(memblock.current_limit == MEMBLOCK_ALLOC_ANYWHERE);
> > > + ASSERT_NE(memblock.reserved.regions, NULL);
> > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > + ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
> > > + ASSERT_EQ(strcmp(memblock.reserved.name, "reserved"), 0);
> > > +
> > > + ASSERT_EQ(memblock.bottom_up, false);
> > > + ASSERT_EQ(memblock.current_limit, MEMBLOCK_ALLOC_ANYWHERE);
> > > +
> > > + test_pass();
> > > + prefix_pop();
> > >
> > > return 0;
> > > }
> > > @@ -40,14 +49,19 @@ static int memblock_add_simple_check(void)
> > > .size = SZ_4M
> > > };
> > >
> > > + prefix_push(__func__);
> > > +
> > > reset_memblock_regions();
> > > memblock_add(r.base, r.size);
> > >
> > > - assert(rgn->base == r.base);
> > > - assert(rgn->size == r.size);
> > > + ASSERT_EQ(rgn->base, r.base);
> > > + ASSERT_EQ(rgn->size, r.size);
> > > +
> > > + ASSERT_EQ(memblock.memory.cnt, 1);
> > > + ASSERT_EQ(memblock.memory.total_size, r.size);
> > >
> > > - assert(memblock.memory.cnt == 1);
> > > - assert(memblock.memory.total_size == r.size);
> > > + test_pass();
> > > + prefix_pop();
> > >
> > > return 0;
> > > }
> > > @@ -69,18 +83,27 @@ static int memblock_add_node_simple_check(void)
> > > .size = SZ_16M
> > > };
> > >
> > > + prefix_pop();
> > > + prefix_push("memblock_add_node");
> > > + prefix_push(__func__);
> >
> > I think there is no need to change the prefix from memblock_add to
> > memblock_add_node here.
> >
> > ok 3 : memblock_add: memblock_add_node_simple_check: passed
> >
> > provides enough information.
> >
>
> Will do.
>
> > > +
> > > reset_memblock_regions();
> > > memblock_add_node(r.base, r.size, 1, MEMBLOCK_HOTPLUG);
> > >
> > > - assert(rgn->base == r.base);
> > > - assert(rgn->size == r.size);
> > > + ASSERT_EQ(rgn->base, r.base);
> > > + ASSERT_EQ(rgn->size, r.size);
> > > #ifdef CONFIG_NUMA
> > > - assert(rgn->nid == 1);
> > > + ASSERT_EQ(rgn->nid, 1);
> > > #endif
> > > - assert(rgn->flags == MEMBLOCK_HOTPLUG);
> > > + ASSERT_EQ(rgn->flags, MEMBLOCK_HOTPLUG);
> > > +
> > > + ASSERT_EQ(memblock.memory.cnt, 1);
> > > + ASSERT_EQ(memblock.memory.total_size, r.size);
> > >
> > > - assert(memblock.memory.cnt == 1);
> > > - assert(memblock.memory.total_size == r.size);
> > > + test_pass();
> > > + prefix_pop();
> > > + prefix_pop();
> > > + prefix_push(FUNC_ADD);
> > >
> > > return 0;
> > > }
> >
> > --
> > Sincerely yours,
> > Mike.
>
> Thanks,
> Rebecca
--
Sincerely yours,
Mike.
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH v3 2/4] memblock tests: add verbose output to memblock tests
2022-06-23 14:40 ` Mike Rapoport
@ 2022-06-24 7:18 ` Rebecca Mckeever
0 siblings, 0 replies; 31+ messages in thread
From: Rebecca Mckeever @ 2022-06-24 7:18 UTC (permalink / raw)
To: Mike Rapoport; +Cc: linux-mm, linux-kernel, David Hildenbrand
On Thu, Jun 23, 2022 at 09:40:30AM -0500, Mike Rapoport wrote:
> On Thu, Jun 23, 2022 at 01:30:42AM -0500, Rebecca Mckeever wrote:
> > On Wed, Jun 22, 2022 at 11:30:10PM -0500, Mike Rapoport wrote:
> > > On Wed, Jun 22, 2022 at 04:29:07AM -0500, Rebecca Mckeever wrote:
> > > > Add and use functions for printing verbose testing output.
> > > >
> > > > If the Memblock simulator was compiled with VERBOSE=1:
> > > > prefix_push() appends the given string to a prefix string that will be
> > > > printed in the test functions.
> > > > prefix_pop() removes the last prefix from the prefix string.
> > > > prefix_reset() clears the prefix string.
> > > > test_fail() prints a message after a test fails containing the test
> > > > number of the failing test and the prefix.
> > > > test_pass() prints a message after a test passes containing its test
> > > > number and the prefix.
> > > > test_print() prints the given formatted output string.
> > > >
> > > > If the Memblock simulator was not compiled with VERBOSE=1, these
> > > > functions do nothing.
> > > >
> > > > Add the assert wrapper macros ASSERT_EQ(), ASSERT_NE(), and ASSERT_LT().
> > > > If the assert condition fails, these macros call test_fail() before
> > > > executing assert().
> > > >
> > > > Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> > > > ---
> > > > tools/testing/memblock/tests/alloc_api.c | 241 ++++++++----
> > > > .../memblock/tests/alloc_helpers_api.c | 135 +++++--
> > > > tools/testing/memblock/tests/alloc_nid_api.c | 371 ++++++++++++------
> > > > tools/testing/memblock/tests/basic_api.c | 365 ++++++++++++-----
> > > > tools/testing/memblock/tests/common.c | 58 +++
> > > > tools/testing/memblock/tests/common.h | 54 +++
> > > > 6 files changed, 880 insertions(+), 344 deletions(-)
> > > >
> > > > diff --git a/tools/testing/memblock/tests/alloc_api.c b/tools/testing/memblock/tests/alloc_api.c
> > > > index d1aa7e15c18d..96df033d4300 100644
> > > > --- a/tools/testing/memblock/tests/alloc_api.c
> > > > +++ b/tools/testing/memblock/tests/alloc_api.c
> > >
> > > ...
> > >
> > > > @@ -729,6 +820,12 @@ static int alloc_no_memory_check(void)
> > > >
> > > > int memblock_alloc_checks(void)
> > > > {
> > > > + static const char func_testing[] = "memblock_alloc";
> > > > +
> > > > + prefix_reset();
> > > > + prefix_push(func_testing);
> > > > + test_print("Running %s tests...\n", func_testing);
> > >
> > > Why not
> > >
> > > test_print("Running memblock_alloc tests...\n");
> > >
> > > ?
> > >
> > > (applies to other cases below)
> >
> > Both prefix_push() and test_print() are using that string, and I thought
> > it made sense to use a constant instead of hard coding the string in both
> > places. Is it better to hard code the string in this case?
>
> Oh, missed that.
> I'd drop static, it doesn't really matter here.
>
Will do.
> > > > +
> > > > reset_memblock_attributes();
> > > > dummy_physical_memory_init();
> > >
> > > ...
> > >
> > > > diff --git a/tools/testing/memblock/tests/alloc_helpers_api.c b/tools/testing/memblock/tests/alloc_helpers_api.c
> > > > index 963a966db461..f6eaed540427 100644
> > > > --- a/tools/testing/memblock/tests/alloc_helpers_api.c
> > > > +++ b/tools/testing/memblock/tests/alloc_helpers_api.c
> > >
> > > ...
> > >
> > > > @@ -378,6 +423,12 @@ static int alloc_from_min_addr_cap_check(void)
> > > >
> > > > int memblock_alloc_helpers_checks(void)
> > > > {
> > > > + static const char func_testing[] = "memblock_alloc_from";
> > > > +
> > > > + prefix_reset();
> > > > + prefix_push(func_testing);
> > > > + test_print("Running %s tests...\n", func_testing);
> > > > +
> > > > reset_memblock_attributes();
> > > > dummy_physical_memory_init();
> > > >
> > > > diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
> > > > index 6390206e50e1..601f4a7ee30d 100644
> > > > --- a/tools/testing/memblock/tests/alloc_nid_api.c
> > > > +++ b/tools/testing/memblock/tests/alloc_nid_api.c
> > >
> > > ...
> > >
> > > > @@ -1150,6 +1263,12 @@ static int alloc_try_nid_low_max_check(void)
> > > >
> > > > int memblock_alloc_nid_checks(void)
> > > > {
> > > > + static const char func_testing[] = "memblock_alloc_try_nid";
> > > > +
> > > > + prefix_reset();
> > > > + prefix_push(func_testing);
> > > > + test_print("Running %s tests...\n", func_testing);
> > > > +
> > > > reset_memblock_attributes();
> > > > dummy_physical_memory_init();
> > > >
> > > > @@ -1170,5 +1289,7 @@ int memblock_alloc_nid_checks(void)
> > > >
> > > > dummy_physical_memory_cleanup();
> > > >
> > > > + prefix_pop();
> > > > +
> > > > return 0;
> > > > }
> > > > diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c
> > > > index a7bc180316d6..f223a9a57be7 100644
> > > > --- a/tools/testing/memblock/tests/basic_api.c
> > > > +++ b/tools/testing/memblock/tests/basic_api.c
> > > > @@ -4,21 +4,30 @@
> > > > #include "basic_api.h"
> > > >
> > > > #define EXPECTED_MEMBLOCK_REGIONS 128
> > > > +#define FUNC_ADD "memblock_add"
> > > > +#define FUNC_RESERVE "memblock_reserve"
> > > > +#define FUNC_REMOVE "memblock_remove"
> > > > +#define FUNC_FREE "memblock_free"
> > > >
> > > > static int memblock_initialization_check(void)
> > > > {
> > > > - assert(memblock.memory.regions);
> > > > - assert(memblock.memory.cnt == 1);
> > > > - assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
> > > > - assert(strcmp(memblock.memory.name, "memory") == 0);
> > > > + prefix_push(__func__);
> > > >
> > > > - assert(memblock.reserved.regions);
> > > > - assert(memblock.reserved.cnt == 1);
> > > > - assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
> > > > - assert(strcmp(memblock.reserved.name, "reserved") == 0);
> > > > + ASSERT_NE(memblock.memory.regions, NULL);
> > > > + ASSERT_EQ(memblock.memory.cnt, 1);
> > > > + ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
> > > > + ASSERT_EQ(strcmp(memblock.memory.name, "memory"), 0);
> > > >
> > > > - assert(!memblock.bottom_up);
> > > > - assert(memblock.current_limit == MEMBLOCK_ALLOC_ANYWHERE);
> > > > + ASSERT_NE(memblock.reserved.regions, NULL);
> > > > + ASSERT_EQ(memblock.reserved.cnt, 1);
> > > > + ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
> > > > + ASSERT_EQ(strcmp(memblock.reserved.name, "reserved"), 0);
> > > > +
> > > > + ASSERT_EQ(memblock.bottom_up, false);
> > > > + ASSERT_EQ(memblock.current_limit, MEMBLOCK_ALLOC_ANYWHERE);
> > > > +
> > > > + test_pass();
> > > > + prefix_pop();
> > > >
> > > > return 0;
> > > > }
> > > > @@ -40,14 +49,19 @@ static int memblock_add_simple_check(void)
> > > > .size = SZ_4M
> > > > };
> > > >
> > > > + prefix_push(__func__);
> > > > +
> > > > reset_memblock_regions();
> > > > memblock_add(r.base, r.size);
> > > >
> > > > - assert(rgn->base == r.base);
> > > > - assert(rgn->size == r.size);
> > > > + ASSERT_EQ(rgn->base, r.base);
> > > > + ASSERT_EQ(rgn->size, r.size);
> > > > +
> > > > + ASSERT_EQ(memblock.memory.cnt, 1);
> > > > + ASSERT_EQ(memblock.memory.total_size, r.size);
> > > >
> > > > - assert(memblock.memory.cnt == 1);
> > > > - assert(memblock.memory.total_size == r.size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > >
> > > > return 0;
> > > > }
> > > > @@ -69,18 +83,27 @@ static int memblock_add_node_simple_check(void)
> > > > .size = SZ_16M
> > > > };
> > > >
> > > > + prefix_pop();
> > > > + prefix_push("memblock_add_node");
> > > > + prefix_push(__func__);
> > >
> > > I think there is no need to change the prefix from memblock_add to
> > > memblock_add_node here.
> > >
> > > ok 3 : memblock_add: memblock_add_node_simple_check: passed
> > >
> > > provides enough information.
> > >
> >
> > Will do.
> >
> > > > +
> > > > reset_memblock_regions();
> > > > memblock_add_node(r.base, r.size, 1, MEMBLOCK_HOTPLUG);
> > > >
> > > > - assert(rgn->base == r.base);
> > > > - assert(rgn->size == r.size);
> > > > + ASSERT_EQ(rgn->base, r.base);
> > > > + ASSERT_EQ(rgn->size, r.size);
> > > > #ifdef CONFIG_NUMA
> > > > - assert(rgn->nid == 1);
> > > > + ASSERT_EQ(rgn->nid, 1);
> > > > #endif
> > > > - assert(rgn->flags == MEMBLOCK_HOTPLUG);
> > > > + ASSERT_EQ(rgn->flags, MEMBLOCK_HOTPLUG);
> > > > +
> > > > + ASSERT_EQ(memblock.memory.cnt, 1);
> > > > + ASSERT_EQ(memblock.memory.total_size, r.size);
> > > >
> > > > - assert(memblock.memory.cnt == 1);
> > > > - assert(memblock.memory.total_size == r.size);
> > > > + test_pass();
> > > > + prefix_pop();
> > > > + prefix_pop();
> > > > + prefix_push(FUNC_ADD);
> > > >
> > > > return 0;
> > > > }
> > >
> > > --
> > > Sincerely yours,
> > > Mike.
> >
> > Thanks,
> > Rebecca
>
> --
> Sincerely yours,
> Mike.
^ permalink raw reply [flat|nested] 31+ messages in thread
end of thread, other threads:[~2022-06-24 7:18 UTC | newest]
Thread overview: 31+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-06-22 9:29 [PATCH v3 0/4] memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options Rebecca Mckeever
2022-06-22 9:29 ` [PATCH v3 1/4] memblock tests: add user-provided arguments to Makefile Rebecca Mckeever
2022-06-23 3:47 ` Mike Rapoport
2022-06-23 4:45 ` Rebecca Mckeever
2022-06-23 4:52 ` Mike Rapoport
2022-06-22 9:29 ` [PATCH v3 2/4] memblock tests: add verbose output to memblock tests Rebecca Mckeever
2022-06-22 10:32 ` Huang, Shaoqin
2022-06-23 0:45 ` Rebecca Mckeever
2022-06-23 1:29 ` Huang, Shaoqin
2022-06-23 3:10 ` Rebecca Mckeever
2022-06-23 4:05 ` Mike Rapoport
2022-06-23 4:56 ` Rebecca Mckeever
2022-06-23 5:04 ` Mike Rapoport
2022-06-23 7:57 ` Rebecca Mckeever
2022-06-23 13:11 ` Mike Rapoport
2022-06-23 3:37 ` Ira Weiny
2022-06-23 7:25 ` Rebecca Mckeever
2022-06-23 4:30 ` Mike Rapoport
2022-06-23 6:30 ` Rebecca Mckeever
2022-06-23 14:40 ` Mike Rapoport
2022-06-24 7:18 ` Rebecca Mckeever
2022-06-22 9:29 ` [PATCH v3 3/4] memblock tests: set memblock_debug to enable memblock_dbg() messages Rebecca Mckeever
2022-06-22 9:29 ` [PATCH v3 4/4] memblock tests: remove completed TODO items Rebecca Mckeever
2022-06-22 10:00 ` [PATCH v3 0/4] memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options David Hildenbrand
2022-06-23 0:54 ` Rebecca Mckeever
2022-06-22 14:17 ` Mike Rapoport
2022-06-23 1:01 ` Rebecca Mckeever
2022-06-23 3:30 ` Ira Weiny
2022-06-23 4:20 ` Rebecca Mckeever
2022-06-23 4:38 ` Mike Rapoport
2022-06-23 5:48 ` Ira Weiny
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.