kvj
/
linux-zen-server
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
linux-zen-server/tools/testing/memblock/tests/basic_api.c

2144 lines
50 KiB
C
Raw Normal View History

Initial commit
2023-08-30 17:53:23 +02:00
// SPDX-License-Identifier: GPL-2.0-or-later
#include <string.h>
#include <linux/memblock.h>
#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"
#define FUNC_TRIM "memblock_trim_memory"
static int memblock_initialization_check(void)
{
PREFIX_PUSH();
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_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_pop();
return 0;
}
/*
* A simple test that adds a memory block of a specified base address
* and size to the collection of available memory regions (memblock.memory).
* Expect to create a new entry. The region counter and total memory get
* updated.
*/
static int memblock_add_simple_check(void)
{
struct memblock_region *rgn;
rgn = &memblock.memory.regions[0];
struct region r = {
.base = SZ_1G,
.size = SZ_4M
};
PREFIX_PUSH();
reset_memblock_regions();
memblock_add(r.base, 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);
test_pass_pop();
return 0;
}
/*
* A simple test that adds a memory block of a specified base address, size,
* NUMA node and memory flags to the collection of available memory regions.
* Expect to create a new entry. The region counter and total memory get
* updated.
*/
static int memblock_add_node_simple_check(void)
{
struct memblock_region *rgn;
rgn = &memblock.memory.regions[0];
struct region r = {
.base = SZ_1M,
.size = SZ_16M
};
PREFIX_PUSH();
reset_memblock_regions();
memblock_add_node(r.base, r.size, 1, MEMBLOCK_HOTPLUG);
ASSERT_EQ(rgn->base, r.base);
ASSERT_EQ(rgn->size, r.size);
#ifdef CONFIG_NUMA
ASSERT_EQ(rgn->nid, 1);
#endif
ASSERT_EQ(rgn->flags, MEMBLOCK_HOTPLUG);
ASSERT_EQ(memblock.memory.cnt, 1);
ASSERT_EQ(memblock.memory.total_size, r.size);
test_pass_pop();
return 0;
}
/*
* A test that tries to add two memory blocks that don't overlap with one
* another:
*
* | +--------+ +--------+ |
* | | r1 | | r2 | |
* +--------+--------+--------+--------+--+
*
* Expect to add two correctly initialized entries to the collection of
* available memory regions (memblock.memory). The total size and
* region counter fields get updated.
*/
static int memblock_add_disjoint_check(void)
{
struct memblock_region *rgn1, *rgn2;
rgn1 = &memblock.memory.regions[0];
rgn2 = &memblock.memory.regions[1];
struct region r1 = {
.base = SZ_1G,
.size = SZ_8K
};
struct region r2 = {
.base = SZ_1G + SZ_16K,
.size = SZ_8K
};
PREFIX_PUSH();
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_add(r2.base, r2.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_EQ(memblock.memory.cnt, 2);
ASSERT_EQ(memblock.memory.total_size, r1.size + r2.size);
test_pass_pop();
return 0;
}
/*
* A test that tries to add two memory blocks r1 and r2, where r2 overlaps
* with the beginning of r1 (that is r1.base < r2.base + r2.size):
*
* | +----+----+------------+ |
* | | |r2 | r1 | |
* +----+----+----+------------+----------+
* ^ ^
* | |
* | r1.base
* |
* r2.base
*
* Expect to merge the two entries into one region that starts at r2.base
* and has size of two regions minus their intersection. The total size of
* the available memory is updated, and the region counter stays the same.
*/
static int memblock_add_overlap_top_check(void)
{
struct memblock_region *rgn;
phys_addr_t total_size;
rgn = &memblock.memory.regions[0];
struct region r1 = {
.base = SZ_512M,
.size = SZ_1G
};
struct region r2 = {
.base = SZ_256M,
.size = SZ_512M
};
PREFIX_PUSH();
total_size = (r1.base - r2.base) + r1.size;
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_add(r2.base, r2.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);
test_pass_pop();
return 0;
}
/*
* A test that tries to add two memory blocks r1 and r2, where r2 overlaps
* with the end of r1 (that is r2.base < r1.base + r1.size):
*
* | +--+------+----------+ |
* | | | r1 | r2 | |
* +--+--+------+----------+--------------+
* ^ ^
* | |
* | r2.base
* |
* r1.base
*
* Expect to merge the two entries into one region that starts at r1.base
* and has size of two regions minus their intersection. The total size of
* the available memory is updated, and the region counter stays the same.
*/
static int memblock_add_overlap_bottom_check(void)
{
struct memblock_region *rgn;
phys_addr_t total_size;
rgn = &memblock.memory.regions[0];
struct region r1 = {
.base = SZ_128M,
.size = SZ_512M
};
struct region r2 = {
.base = SZ_256M,
.size = SZ_1G
};
PREFIX_PUSH();
total_size = (r2.base - r1.base) + r2.size;
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_add(r2.base, r2.size);
ASSERT_EQ(rgn->base, r1.base);
ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.memory.cnt, 1);
ASSERT_EQ(memblock.memory.total_size, total_size);
test_pass_pop();
return 0;
}
/*
* A test that tries to add two memory blocks r1 and r2, where r2 is
* within the range of r1 (that is r1.base < r2.base &&
* r2.base + r2.size < r1.base + r1.size):
*
* | +-------+--+-----------------------+
* | | |r2| r1 |
* +---+-------+--+-----------------------+
* ^
* |
* r1.base
*
* Expect to merge two entries into one region that stays the same.
* The counter and total size of available memory are not updated.
*/
static int memblock_add_within_check(void)
{
struct memblock_region *rgn;
rgn = &memblock.memory.regions[0];
struct region r1 = {
.base = SZ_8M,
.size = SZ_32M
};
struct region r2 = {
.base = SZ_16M,
.size = SZ_1M
};
PREFIX_PUSH();
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_add(r2.base, r2.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);
test_pass_pop();
return 0;
}
/*
* A simple test that tries to add the same memory block twice. Expect
* the counter and total size of available memory to not be updated.
*/
static int memblock_add_twice_check(void)
{
struct region r = {
.base = SZ_16K,
.size = SZ_2M
};
PREFIX_PUSH();
reset_memblock_regions();
memblock_add(r.base, r.size);
memblock_add(r.base, r.size);
ASSERT_EQ(memblock.memory.cnt, 1);
ASSERT_EQ(memblock.memory.total_size, r.size);
test_pass_pop();
return 0;
}
/*
* A test that tries to add two memory blocks that don't overlap with one
* another and then add a third memory block in the space between the first two:
*
* | +--------+--------+--------+ |
* | | r1 | r3 | r2 | |
* +--------+--------+--------+--------+--+
*
* Expect to merge the three entries into one region that starts at r1.base
* and has size of r1.size + r2.size + r3.size. The region counter and total
* size of the available memory are updated.
*/
static int memblock_add_between_check(void)
{
struct memblock_region *rgn;
phys_addr_t total_size;
rgn = &memblock.memory.regions[0];
struct region r1 = {
.base = SZ_1G,
.size = SZ_8K
};
struct region r2 = {
.base = SZ_1G + SZ_16K,
.size = SZ_8K
};
struct region r3 = {
.base = SZ_1G + SZ_8K,
.size = SZ_8K
};
PREFIX_PUSH();
total_size = r1.size + r2.size + r3.size;
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_add(r2.base, r2.size);
memblock_add(r3.base, r3.size);
ASSERT_EQ(rgn->base, r1.base);
ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.memory.cnt, 1);
ASSERT_EQ(memblock.memory.total_size, total_size);
test_pass_pop();
return 0;
}
/*
* A simple test that tries to add a memory block r when r extends past
* PHYS_ADDR_MAX:
*
* +--------+
* | r |
* +--------+
* | +----+
* | | rgn|
* +----------------------------+----+
*
* Expect to add a memory block of size PHYS_ADDR_MAX - r.base. Expect the
* total size of available memory and the counter to be updated.
*/
static int memblock_add_near_max_check(void)
{
struct memblock_region *rgn;
phys_addr_t total_size;
rgn = &memblock.memory.regions[0];
struct region r = {
.base = PHYS_ADDR_MAX - SZ_1M,
.size = SZ_2M
};
PREFIX_PUSH();
total_size = PHYS_ADDR_MAX - r.base;
reset_memblock_regions();
memblock_add(r.base, r.size);
ASSERT_EQ(rgn->base, r.base);
ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.memory.cnt, 1);
ASSERT_EQ(memblock.memory.total_size, total_size);
test_pass_pop();
return 0;
}
/*
* A test that trying to add the 129th memory block.
* Expect to trigger memblock_double_array() to double the
* memblock.memory.max, find a new valid memory as
* memory.regions.
*/
static int memblock_add_many_check(void)
{
int i;
void *orig_region;
struct region r = {
.base = SZ_16K,
.size = SZ_16K,
};
phys_addr_t new_memory_regions_size;
phys_addr_t base, size = SZ_64;
phys_addr_t gap_size = SZ_64;
PREFIX_PUSH();
reset_memblock_regions();
memblock_allow_resize();
dummy_physical_memory_init();
/*
* We allocated enough memory by using dummy_physical_memory_init(), and
* split it into small block. First we split a large enough memory block
* as the memory region which will be choosed by memblock_double_array().
*/
base = PAGE_ALIGN(dummy_physical_memory_base());
new_memory_regions_size = PAGE_ALIGN(INIT_MEMBLOCK_REGIONS * 2 *
sizeof(struct memblock_region));
memblock_add(base, new_memory_regions_size);
/* This is the base of small memory block. */
base += new_memory_regions_size + gap_size;
orig_region = memblock.memory.regions;
for (i = 0; i < INIT_MEMBLOCK_REGIONS; i++) {
/*
* Add these small block to fulfill the memblock. We keep a
* gap between the nearby memory to avoid being merged.
*/
memblock_add(base, size);
base += size + gap_size;
ASSERT_EQ(memblock.memory.cnt, i + 2);
ASSERT_EQ(memblock.memory.total_size, new_memory_regions_size +
(i + 1) * size);
}
/*
* At there, memblock_double_array() has been succeed, check if it
* update the memory.max.
*/
ASSERT_EQ(memblock.memory.max, INIT_MEMBLOCK_REGIONS * 2);
/* memblock_double_array() will reserve the memory it used. Check it. */
ASSERT_EQ(memblock.reserved.cnt, 1);
ASSERT_EQ(memblock.reserved.total_size, new_memory_regions_size);
/*
* Now memblock_double_array() works fine. Let's check after the
* double_array(), the memblock_add() still works as normal.
*/
memblock_add(r.base, r.size);
ASSERT_EQ(memblock.memory.regions[0].base, r.base);
ASSERT_EQ(memblock.memory.regions[0].size, r.size);
ASSERT_EQ(memblock.memory.cnt, INIT_MEMBLOCK_REGIONS + 2);
ASSERT_EQ(memblock.memory.total_size, INIT_MEMBLOCK_REGIONS * size +
new_memory_regions_size +
r.size);
ASSERT_EQ(memblock.memory.max, INIT_MEMBLOCK_REGIONS * 2);
dummy_physical_memory_cleanup();
/*
* The current memory.regions is occupying a range of memory that
* allocated from dummy_physical_memory_init(). After free the memory,
* we must not use it. So restore the origin memory region to make sure
* the tests can run as normal and not affected by the double array.
*/
memblock.memory.regions = orig_region;
memblock.memory.cnt = INIT_MEMBLOCK_REGIONS;
test_pass_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();
memblock_add_overlap_top_check();
memblock_add_overlap_bottom_check();
memblock_add_within_check();
memblock_add_twice_check();
memblock_add_between_check();
memblock_add_near_max_check();
memblock_add_many_check();
prefix_pop();
return 0;
}
/*
* A simple test that marks a memory block of a specified base address
* and size as reserved and to the collection of reserved memory regions
* (memblock.reserved). Expect to create a new entry. The region counter
* and total memory size are updated.
*/
static int memblock_reserve_simple_check(void)
{
struct memblock_region *rgn;
rgn = &memblock.reserved.regions[0];
struct region r = {
.base = SZ_2G,
.size = SZ_128M
};
PREFIX_PUSH();
reset_memblock_regions();
memblock_reserve(r.base, r.size);
ASSERT_EQ(rgn->base, r.base);
ASSERT_EQ(rgn->size, r.size);
test_pass_pop();
return 0;
}
/*
* A test that tries to mark two memory blocks that don't overlap as reserved:
*
* | +--+ +----------------+ |
* | |r1| | r2 | |
* +--------+--+------+----------------+--+
*
* Expect to add two entries to the collection of reserved memory regions
* (memblock.reserved). The total size and region counter for
* memblock.reserved are updated.
*/
static int memblock_reserve_disjoint_check(void)
{
struct memblock_region *rgn1, *rgn2;
rgn1 = &memblock.reserved.regions[0];
rgn2 = &memblock.reserved.regions[1];
struct region r1 = {
.base = SZ_256M,
.size = SZ_16M
};
struct region r2 = {
.base = SZ_512M,
.size = SZ_512M
};
PREFIX_PUSH();
reset_memblock_regions();
memblock_reserve(r1.base, r1.size);
memblock_reserve(r2.base, r2.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_EQ(memblock.reserved.cnt, 2);
ASSERT_EQ(memblock.reserved.total_size, r1.size + r2.size);
test_pass_pop();
return 0;
}
/*
* A test that tries to mark two memory blocks r1 and r2 as reserved,
* where r2 overlaps with the beginning of r1 (that is
* r1.base < r2.base + r2.size):
*
* | +--------------+--+--------------+ |
* | | r2 | | r1 | |
* +--+--------------+--+--------------+--+
* ^ ^
* | |
* | r1.base
* |
* r2.base
*
* Expect to merge two entries into one region that starts at r2.base and
* has size of two regions minus their intersection. The total size of the
* reserved memory is updated, and the region counter is not updated.
*/
static int memblock_reserve_overlap_top_check(void)
{
struct memblock_region *rgn;
phys_addr_t total_size;
rgn = &memblock.reserved.regions[0];
struct region r1 = {
.base = SZ_1G,
.size = SZ_1G
};
struct region r2 = {
.base = SZ_128M,
.size = SZ_1G
};
PREFIX_PUSH();
total_size = (r1.base - r2.base) + r1.size;
reset_memblock_regions();
memblock_reserve(r1.base, r1.size);
memblock_reserve(r2.base, r2.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);
test_pass_pop();
return 0;
}
/*
* A test that tries to mark two memory blocks r1 and r2 as reserved,
* where r2 overlaps with the end of r1 (that is
* r2.base < r1.base + r1.size):
*
* | +--------------+--+--------------+ |
* | | r1 | | r2 | |
* +--+--------------+--+--------------+--+
* ^ ^
* | |
* | r2.base
* |
* r1.base
*
* Expect to merge two entries into one region that starts at r1.base and
* has size of two regions minus their intersection. The total size of the
* reserved memory is updated, and the region counter is not updated.
*/
static int memblock_reserve_overlap_bottom_check(void)
{
struct memblock_region *rgn;
phys_addr_t total_size;
rgn = &memblock.reserved.regions[0];
struct region r1 = {
.base = SZ_2K,
.size = SZ_128K
};
struct region r2 = {
.base = SZ_128K,
.size = SZ_128K
};
PREFIX_PUSH();
total_size = (r2.base - r1.base) + r2.size;
reset_memblock_regions();
memblock_reserve(r1.base, r1.size);
memblock_reserve(r2.base, r2.size);
ASSERT_EQ(rgn->base, r1.base);
ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.reserved.cnt, 1);
ASSERT_EQ(memblock.reserved.total_size, total_size);
test_pass_pop();
return 0;
}
/*
* A test that tries to mark two memory blocks r1 and r2 as reserved,
* where r2 is within the range of r1 (that is
* (r1.base < r2.base) && (r2.base + r2.size < r1.base + r1.size)):
*
* | +-----+--+---------------------------|
* | | |r2| r1 |
* +-+-----+--+---------------------------+
* ^ ^
* | |
* | r2.base
* |
* r1.base
*
* Expect to merge two entries into one region that stays the same. The
* counter and total size of available memory are not updated.
*/
static int memblock_reserve_within_check(void)
{
struct memblock_region *rgn;
rgn = &memblock.reserved.regions[0];
struct region r1 = {
.base = SZ_1M,
.size = SZ_8M
};
struct region r2 = {
.base = SZ_2M,
.size = SZ_64K
};
PREFIX_PUSH();
reset_memblock_regions();
memblock_reserve(r1.base, r1.size);
memblock_reserve(r2.base, r2.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);
test_pass_pop();
return 0;
}
/*
* A simple test that tries to reserve the same memory block twice.
* Expect the region counter and total size of reserved memory to not
* be updated.
*/
static int memblock_reserve_twice_check(void)
{
struct region r = {
.base = SZ_16K,
.size = SZ_2M
};
PREFIX_PUSH();
reset_memblock_regions();
memblock_reserve(r.base, r.size);
memblock_reserve(r.base, r.size);
ASSERT_EQ(memblock.reserved.cnt, 1);
ASSERT_EQ(memblock.reserved.total_size, r.size);
test_pass_pop();
return 0;
}
/*
* A test that tries to mark two memory blocks that don't overlap as reserved
* and then reserve a third memory block in the space between the first two:
*
* | +--------+--------+--------+ |
* | | r1 | r3 | r2 | |
* +--------+--------+--------+--------+--+
*
* Expect to merge the three entries into one reserved region that starts at
* r1.base and has size of r1.size + r2.size + r3.size. The region counter and
* total for memblock.reserved are updated.
*/
static int memblock_reserve_between_check(void)
{
struct memblock_region *rgn;
phys_addr_t total_size;
rgn = &memblock.reserved.regions[0];
struct region r1 = {
.base = SZ_1G,
.size = SZ_8K
};
struct region r2 = {
.base = SZ_1G + SZ_16K,
.size = SZ_8K
};
struct region r3 = {
.base = SZ_1G + SZ_8K,
.size = SZ_8K
};
PREFIX_PUSH();
total_size = r1.size + r2.size + r3.size;
reset_memblock_regions();
memblock_reserve(r1.base, r1.size);
memblock_reserve(r2.base, r2.size);
memblock_reserve(r3.base, r3.size);
ASSERT_EQ(rgn->base, r1.base);
ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.reserved.cnt, 1);
ASSERT_EQ(memblock.reserved.total_size, total_size);
test_pass_pop();
return 0;
}
/*
* A simple test that tries to reserve a memory block r when r extends past
* PHYS_ADDR_MAX:
*
* +--------+
* | r |
* +--------+
* | +----+
* | | rgn|
* +----------------------------+----+
*
* Expect to reserve a memory block of size PHYS_ADDR_MAX - r.base. Expect the
* total size of reserved memory and the counter to be updated.
*/
static int memblock_reserve_near_max_check(void)
{
struct memblock_region *rgn;
phys_addr_t total_size;
rgn = &memblock.reserved.regions[0];
struct region r = {
.base = PHYS_ADDR_MAX - SZ_1M,
.size = SZ_2M
};
PREFIX_PUSH();
total_size = PHYS_ADDR_MAX - r.base;
reset_memblock_regions();
memblock_reserve(r.base, r.size);
ASSERT_EQ(rgn->base, r.base);
ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.reserved.cnt, 1);
ASSERT_EQ(memblock.reserved.total_size, total_size);
test_pass_pop();
return 0;
}
/*
* A test that trying to reserve the 129th memory block.
* Expect to trigger memblock_double_array() to double the
* memblock.memory.max, find a new valid memory as
* reserved.regions.
*/
static int memblock_reserve_many_check(void)
{
int i;
void *orig_region;
struct region r = {
.base = SZ_16K,
.size = SZ_16K,
};
phys_addr_t memory_base = SZ_128K;
phys_addr_t new_reserved_regions_size;
PREFIX_PUSH();
reset_memblock_regions();
memblock_allow_resize();
/* Add a valid memory region used by double_array(). */
dummy_physical_memory_init();
memblock_add(dummy_physical_memory_base(), MEM_SIZE);
for (i = 0; i < INIT_MEMBLOCK_REGIONS; i++) {
/* Reserve some fakes memory region to fulfill the memblock. */
memblock_reserve(memory_base, MEM_SIZE);
ASSERT_EQ(memblock.reserved.cnt, i + 1);
ASSERT_EQ(memblock.reserved.total_size, (i + 1) * MEM_SIZE);
/* Keep the gap so these memory region will not be merged. */
memory_base += MEM_SIZE * 2;
}
orig_region = memblock.reserved.regions;
/* This reserve the 129 memory_region, and makes it double array. */
memblock_reserve(memory_base, MEM_SIZE);
/*
* This is the memory region size used by the doubled reserved.regions,
* and it has been reserved due to it has been used. The size is used to
* calculate the total_size that the memblock.reserved have now.
*/
new_reserved_regions_size = PAGE_ALIGN((INIT_MEMBLOCK_REGIONS * 2) *
sizeof(struct memblock_region));
/*
* The double_array() will find a free memory region as the new
* reserved.regions, and the used memory region will be reserved, so
* there will be one more region exist in the reserved memblock. And the
* one more reserved region's size is new_reserved_regions_size.
*/
ASSERT_EQ(memblock.reserved.cnt, INIT_MEMBLOCK_REGIONS + 2);
ASSERT_EQ(memblock.reserved.total_size, (INIT_MEMBLOCK_REGIONS + 1) * MEM_SIZE +
new_reserved_regions_size);
ASSERT_EQ(memblock.reserved.max, INIT_MEMBLOCK_REGIONS * 2);
/*
* Now memblock_double_array() works fine. Let's check after the
* double_array(), the memblock_reserve() still works as normal.
*/
memblock_reserve(r.base, r.size);
ASSERT_EQ(memblock.reserved.regions[0].base, r.base);
ASSERT_EQ(memblock.reserved.regions[0].size, r.size);
ASSERT_EQ(memblock.reserved.cnt, INIT_MEMBLOCK_REGIONS + 3);
ASSERT_EQ(memblock.reserved.total_size, (INIT_MEMBLOCK_REGIONS + 1) * MEM_SIZE +
new_reserved_regions_size +
r.size);
ASSERT_EQ(memblock.reserved.max, INIT_MEMBLOCK_REGIONS * 2);
dummy_physical_memory_cleanup();
/*
* The current reserved.regions is occupying a range of memory that
* allocated from dummy_physical_memory_init(). After free the memory,
* we must not use it. So restore the origin memory region to make sure
* the tests can run as normal and not affected by the double array.
*/
memblock.reserved.regions = orig_region;
memblock.reserved.cnt = INIT_MEMBLOCK_RESERVED_REGIONS;
test_pass_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();
memblock_reserve_overlap_bottom_check();
memblock_reserve_within_check();
memblock_reserve_twice_check();
memblock_reserve_between_check();
memblock_reserve_near_max_check();
memblock_reserve_many_check();
prefix_pop();
return 0;
}
/*
* A simple test that tries to remove a region r1 from the array of
* available memory regions. By "removing" a region we mean overwriting it
* with the next region r2 in memblock.memory:
*
* | ...... +----------------+ |
* | : r1 : | r2 | |
* +--+----+----------+----------------+--+
* ^
* |
* rgn.base
*
* Expect to add two memory blocks r1 and r2 and then remove r1 so that
* r2 is the first available region. The region counter and total size
* are updated.
*/
static int memblock_remove_simple_check(void)
{
struct memblock_region *rgn;
rgn = &memblock.memory.regions[0];
struct region r1 = {
.base = SZ_2K,
.size = SZ_4K
};
struct region r2 = {
.base = SZ_128K,
.size = SZ_4M
};
PREFIX_PUSH();
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_add(r2.base, r2.size);
memblock_remove(r1.base, r1.size);
ASSERT_EQ(rgn->base, r2.base);
ASSERT_EQ(rgn->size, r2.size);
ASSERT_EQ(memblock.memory.cnt, 1);
ASSERT_EQ(memblock.memory.total_size, r2.size);
test_pass_pop();
return 0;
}
/*
* A test that tries to remove a region r2 that was not registered as
* available memory (i.e. has no corresponding entry in memblock.memory):
*
* +----------------+
* | r2 |
* +----------------+
* | +----+ |
* | | r1 | |
* +--+----+------------------------------+
* ^
* |
* rgn.base
*
* Expect the array, regions counter and total size to not be modified.
*/
static int memblock_remove_absent_check(void)
{
struct memblock_region *rgn;
rgn = &memblock.memory.regions[0];
struct region r1 = {
.base = SZ_512K,
.size = SZ_4M
};
struct region r2 = {
.base = SZ_64M,
.size = SZ_1G
};
PREFIX_PUSH();
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_remove(r2.base, r2.size);
ASSERT_EQ(rgn->base, r1.base);
ASSERT_EQ(rgn->size, r1.size);
ASSERT_EQ(memblock.memory.cnt, 1);
ASSERT_EQ(memblock.memory.total_size, r1.size);
test_pass_pop();
return 0;
}
/*
* A test that tries to remove a region r2 that overlaps with the
* beginning of the already existing entry r1
* (that is r1.base < r2.base + r2.size):
*
* +-----------------+
* | r2 |
* +-----------------+
* | .........+--------+ |
* | : r1 | rgn | |
* +-----------------+--------+--------+--+
* ^ ^
* | |
* | rgn.base
* r1.base
*
* Expect that only the intersection of both regions is removed from the
* available memory pool. The regions counter and total size are updated.
*/
static int memblock_remove_overlap_top_check(void)
{
struct memblock_region *rgn;
phys_addr_t r1_end, r2_end, total_size;
rgn = &memblock.memory.regions[0];
struct region r1 = {
.base = SZ_32M,
.size = SZ_32M
};
struct region r2 = {
.base = SZ_16M,
.size = SZ_32M
};
PREFIX_PUSH();
r1_end = r1.base + r1.size;
r2_end = r2.base + r2.size;
total_size = r1_end - r2_end;
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_remove(r2.base, r2.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);
test_pass_pop();
return 0;
}
/*
* A test that tries to remove a region r2 that overlaps with the end of
* the already existing region r1 (that is r2.base < r1.base + r1.size):
*
* +--------------------------------+
* | r2 |
* +--------------------------------+
* | +---+..... |
* | |rgn| r1 : |
* +-+---+----+---------------------------+
* ^
* |
* r1.base
*
* Expect that only the intersection of both regions is removed from the
* available memory pool. The regions counter and total size are updated.
*/
static int memblock_remove_overlap_bottom_check(void)
{
struct memblock_region *rgn;
phys_addr_t total_size;
rgn = &memblock.memory.regions[0];
struct region r1 = {
.base = SZ_2M,
.size = SZ_64M
};
struct region r2 = {
.base = SZ_32M,
.size = SZ_256M
};
PREFIX_PUSH();
total_size = r2.base - r1.base;
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_remove(r2.base, r2.size);
ASSERT_EQ(rgn->base, r1.base);
ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.memory.cnt, 1);
ASSERT_EQ(memblock.memory.total_size, total_size);
test_pass_pop();
return 0;
}
/*
* A test that tries to remove a region r2 that is within the range of
* the already existing entry r1 (that is
* (r1.base < r2.base) && (r2.base + r2.size < r1.base + r1.size)):
*
* +----+
* | r2 |
* +----+
* | +-------------+....+---------------+ |
* | | rgn1 | r1 | rgn2 | |
* +-+-------------+----+---------------+-+
* ^
* |
* r1.base
*
* Expect that the region is split into two - one that ends at r2.base and
* another that starts at r2.base + r2.size, with appropriate sizes. The
* region counter and total size are updated.
*/
static int memblock_remove_within_check(void)
{
struct memblock_region *rgn1, *rgn2;
phys_addr_t r1_size, r2_size, total_size;
rgn1 = &memblock.memory.regions[0];
rgn2 = &memblock.memory.regions[1];
struct region r1 = {
.base = SZ_1M,
.size = SZ_32M
};
struct region r2 = {
.base = SZ_16M,
.size = SZ_1M
};
PREFIX_PUSH();
r1_size = r2.base - r1.base;
r2_size = (r1.base + r1.size) - (r2.base + r2.size);
total_size = r1_size + r2_size;
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_remove(r2.base, r2.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_EQ(memblock.memory.cnt, 2);
ASSERT_EQ(memblock.memory.total_size, total_size);
test_pass_pop();
return 0;
}
/*
* A simple test that tries to remove a region r1 from the array of
* available memory regions when r1 is the only available region.
* Expect to add a memory block r1 and then remove r1 so that a dummy
* region is added. The region counter stays the same, and the total size
* is updated.
*/
static int memblock_remove_only_region_check(void)
{
struct memblock_region *rgn;
rgn = &memblock.memory.regions[0];
struct region r1 = {
.base = SZ_2K,
.size = SZ_4K
};
PREFIX_PUSH();
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_remove(r1.base, r1.size);
ASSERT_EQ(rgn->base, 0);
ASSERT_EQ(rgn->size, 0);
ASSERT_EQ(memblock.memory.cnt, 1);
ASSERT_EQ(memblock.memory.total_size, 0);
test_pass_pop();
return 0;
}
/*
* A simple test that tries remove a region r2 from the array of available
* memory regions when r2 extends past PHYS_ADDR_MAX:
*
* +--------+
* | r2 |
* +--------+
* | +---+....+
* | |rgn| |
* +------------------------+---+----+
*
* Expect that only the portion between PHYS_ADDR_MAX and r2.base is removed.
* Expect the total size of available memory to be updated and the counter to
* not be updated.
*/
static int memblock_remove_near_max_check(void)
{
struct memblock_region *rgn;
phys_addr_t total_size;
rgn = &memblock.memory.regions[0];
struct region r1 = {
.base = PHYS_ADDR_MAX - SZ_2M,
.size = SZ_2M
};
struct region r2 = {
.base = PHYS_ADDR_MAX - SZ_1M,
.size = SZ_2M
};
PREFIX_PUSH();
total_size = r1.size - (PHYS_ADDR_MAX - r2.base);
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_remove(r2.base, r2.size);
ASSERT_EQ(rgn->base, r1.base);
ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.memory.cnt, 1);
ASSERT_EQ(memblock.memory.total_size, total_size);
test_pass_pop();
return 0;
}
/*
* A test that tries to remove a region r3 that overlaps with two existing
* regions r1 and r2:
*
* +----------------+
* | r3 |
* +----------------+
* | +----+..... ........+--------+
* | | |r1 : : |r2 | |
* +----+----+----+---+-------+--------+-----+
*
* Expect that only the intersections of r1 with r3 and r2 with r3 are removed
* from the available memory pool. Expect the total size of available memory to
* be updated and the counter to not be updated.
*/
static int memblock_remove_overlap_two_check(void)
{
struct memblock_region *rgn1, *rgn2;
phys_addr_t new_r1_size, new_r2_size, r2_end, r3_end, total_size;
rgn1 = &memblock.memory.regions[0];
rgn2 = &memblock.memory.regions[1];
struct region r1 = {
.base = SZ_16M,
.size = SZ_32M
};
struct region r2 = {
.base = SZ_64M,
.size = SZ_64M
};
struct region r3 = {
.base = SZ_32M,
.size = SZ_64M
};
PREFIX_PUSH();
r2_end = r2.base + r2.size;
r3_end = r3.base + r3.size;
new_r1_size = r3.base - r1.base;
new_r2_size = r2_end - r3_end;
total_size = new_r1_size + new_r2_size;
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_add(r2.base, r2.size);
memblock_remove(r3.base, r3.size);
ASSERT_EQ(rgn1->base, r1.base);
ASSERT_EQ(rgn1->size, new_r1_size);
ASSERT_EQ(rgn2->base, r3_end);
ASSERT_EQ(rgn2->size, new_r2_size);
ASSERT_EQ(memblock.memory.cnt, 2);
ASSERT_EQ(memblock.memory.total_size, total_size);
test_pass_pop();
return 0;
}
static int memblock_remove_checks(void)
{
prefix_reset();
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();
memblock_remove_only_region_check();
memblock_remove_near_max_check();
memblock_remove_overlap_two_check();
prefix_pop();
return 0;
}
/*
* A simple test that tries to free a memory block r1 that was marked
* earlier as reserved. By "freeing" a region we mean overwriting it with
* the next entry r2 in memblock.reserved:
*
* | ...... +----+ |
* | : r1 : | r2 | |
* +--------------+----+-----------+----+-+
* ^
* |
* rgn.base
*
* Expect to reserve two memory regions and then erase r1 region with the
* value of r2. The region counter and total size are updated.
*/
static int memblock_free_simple_check(void)
{
struct memblock_region *rgn;
rgn = &memblock.reserved.regions[0];
struct region r1 = {
.base = SZ_4M,
.size = SZ_1M
};
struct region r2 = {
.base = SZ_8M,
.size = SZ_1M
};
PREFIX_PUSH();
reset_memblock_regions();
memblock_reserve(r1.base, r1.size);
memblock_reserve(r2.base, r2.size);
memblock_free((void *)r1.base, r1.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);
test_pass_pop();
return 0;
}
/*
* A test that tries to free a region r2 that was not marked as reserved
* (i.e. has no corresponding entry in memblock.reserved):
*
* +----------------+
* | r2 |
* +----------------+
* | +----+ |
* | | r1 | |
* +--+----+------------------------------+
* ^
* |
* rgn.base
*
* The array, regions counter and total size are not modified.
*/
static int memblock_free_absent_check(void)
{
struct memblock_region *rgn;
rgn = &memblock.reserved.regions[0];
struct region r1 = {
.base = SZ_2M,
.size = SZ_8K
};
struct region r2 = {
.base = SZ_16M,
.size = SZ_128M
};
PREFIX_PUSH();
reset_memblock_regions();
memblock_reserve(r1.base, r1.size);
memblock_free((void *)r2.base, r2.size);
ASSERT_EQ(rgn->base, r1.base);
ASSERT_EQ(rgn->size, r1.size);
ASSERT_EQ(memblock.reserved.cnt, 1);
ASSERT_EQ(memblock.reserved.total_size, r1.size);
test_pass_pop();
return 0;
}
/*
* A test that tries to free a region r2 that overlaps with the beginning
* of the already existing entry r1 (that is r1.base < r2.base + r2.size):
*
* +----+
* | r2 |
* +----+
* | ...+--------------+ |
* | : | r1 | |
* +----+--+--------------+---------------+
* ^ ^
* | |
* | rgn.base
* |
* r1.base
*
* Expect that only the intersection of both regions is freed. The
* regions counter and total size are updated.
*/
static int memblock_free_overlap_top_check(void)
{
struct memblock_region *rgn;
phys_addr_t total_size;
rgn = &memblock.reserved.regions[0];
struct region r1 = {
.base = SZ_8M,
.size = SZ_32M
};
struct region r2 = {
.base = SZ_1M,
.size = SZ_8M
};
PREFIX_PUSH();
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_EQ(rgn->base, r2.base + r2.size);
ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.reserved.cnt, 1);
ASSERT_EQ(memblock.reserved.total_size, total_size);
test_pass_pop();
return 0;
}
/*
* A test that tries to free a region r2 that overlaps with the end of
* the already existing entry r1 (that is r2.base < r1.base + r1.size):
*
* +----------------+
* | r2 |
* +----------------+
* | +-----------+..... |
* | | r1 | : |
* +----+-----------+----+----------------+
*
* Expect that only the intersection of both regions is freed. The
* regions counter and total size are updated.
*/
static int memblock_free_overlap_bottom_check(void)
{
struct memblock_region *rgn;
phys_addr_t total_size;
rgn = &memblock.reserved.regions[0];
struct region r1 = {
.base = SZ_8M,
.size = SZ_32M
};
struct region r2 = {
.base = SZ_32M,
.size = SZ_32M
};
PREFIX_PUSH();
total_size = r2.base - r1.base;
reset_memblock_regions();
memblock_reserve(r1.base, r1.size);
memblock_free((void *)r2.base, r2.size);
ASSERT_EQ(rgn->base, r1.base);
ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.reserved.cnt, 1);
ASSERT_EQ(memblock.reserved.total_size, total_size);
test_pass_pop();
return 0;
}
/*
* A test that tries to free a region r2 that is within the range of the
* already existing entry r1 (that is
* (r1.base < r2.base) && (r2.base + r2.size < r1.base + r1.size)):
*
* +----+
* | r2 |
* +----+
* | +------------+....+---------------+
* | | rgn1 | r1 | rgn2 |
* +----+------------+----+---------------+
* ^
* |
* r1.base
*
* Expect that the region is split into two - one that ends at r2.base and
* another that starts at r2.base + r2.size, with appropriate sizes. The
* region counter and total size fields are updated.
*/
static int memblock_free_within_check(void)
{
struct memblock_region *rgn1, *rgn2;
phys_addr_t r1_size, r2_size, total_size;
rgn1 = &memblock.reserved.regions[0];
rgn2 = &memblock.reserved.regions[1];
struct region r1 = {
.base = SZ_1M,
.size = SZ_8M
};
struct region r2 = {
.base = SZ_4M,
.size = SZ_1M
};
PREFIX_PUSH();
r1_size = r2.base - r1.base;
r2_size = (r1.base + r1.size) - (r2.base + r2.size);
total_size = r1_size + r2_size;
reset_memblock_regions();
memblock_reserve(r1.base, r1.size);
memblock_free((void *)r2.base, r2.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_EQ(memblock.reserved.cnt, 2);
ASSERT_EQ(memblock.reserved.total_size, total_size);
test_pass_pop();
return 0;
}
/*
* A simple test that tries to free a memory block r1 that was marked
* earlier as reserved when r1 is the only available region.
* Expect to reserve a memory block r1 and then free r1 so that r1 is
* overwritten with a dummy region. The region counter stays the same,
* and the total size is updated.
*/
static int memblock_free_only_region_check(void)
{
struct memblock_region *rgn;
rgn = &memblock.reserved.regions[0];
struct region r1 = {
.base = SZ_2K,
.size = SZ_4K
};
PREFIX_PUSH();
reset_memblock_regions();
memblock_reserve(r1.base, r1.size);
memblock_free((void *)r1.base, r1.size);
ASSERT_EQ(rgn->base, 0);
ASSERT_EQ(rgn->size, 0);
ASSERT_EQ(memblock.reserved.cnt, 1);
ASSERT_EQ(memblock.reserved.total_size, 0);
test_pass_pop();
return 0;
}
/*
* A simple test that tries free a region r2 when r2 extends past PHYS_ADDR_MAX:
*
* +--------+
* | r2 |
* +--------+
* | +---+....+
* | |rgn| |
* +------------------------+---+----+
*
* Expect that only the portion between PHYS_ADDR_MAX and r2.base is freed.
* Expect the total size of reserved memory to be updated and the counter to
* not be updated.
*/
static int memblock_free_near_max_check(void)
{
struct memblock_region *rgn;
phys_addr_t total_size;
rgn = &memblock.reserved.regions[0];
struct region r1 = {
.base = PHYS_ADDR_MAX - SZ_2M,
.size = SZ_2M
};
struct region r2 = {
.base = PHYS_ADDR_MAX - SZ_1M,
.size = SZ_2M
};
PREFIX_PUSH();
total_size = r1.size - (PHYS_ADDR_MAX - r2.base);
reset_memblock_regions();
memblock_reserve(r1.base, r1.size);
memblock_free((void *)r2.base, r2.size);
ASSERT_EQ(rgn->base, r1.base);
ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.reserved.cnt, 1);
ASSERT_EQ(memblock.reserved.total_size, total_size);
test_pass_pop();
return 0;
}
/*
* A test that tries to free a reserved region r3 that overlaps with two
* existing reserved regions r1 and r2:
*
* +----------------+
* | r3 |
* +----------------+
* | +----+..... ........+--------+
* | | |r1 : : |r2 | |
* +----+----+----+---+-------+--------+-----+
*
* Expect that only the intersections of r1 with r3 and r2 with r3 are freed
* from the collection of reserved memory. Expect the total size of reserved
* memory to be updated and the counter to not be updated.
*/
static int memblock_free_overlap_two_check(void)
{
struct memblock_region *rgn1, *rgn2;
phys_addr_t new_r1_size, new_r2_size, r2_end, r3_end, total_size;
rgn1 = &memblock.reserved.regions[0];
rgn2 = &memblock.reserved.regions[1];
struct region r1 = {
.base = SZ_16M,
.size = SZ_32M
};
struct region r2 = {
.base = SZ_64M,
.size = SZ_64M
};
struct region r3 = {
.base = SZ_32M,
.size = SZ_64M
};
PREFIX_PUSH();
r2_end = r2.base + r2.size;
r3_end = r3.base + r3.size;
new_r1_size = r3.base - r1.base;
new_r2_size = r2_end - r3_end;
total_size = new_r1_size + new_r2_size;
reset_memblock_regions();
memblock_reserve(r1.base, r1.size);
memblock_reserve(r2.base, r2.size);
memblock_free((void *)r3.base, r3.size);
ASSERT_EQ(rgn1->base, r1.base);
ASSERT_EQ(rgn1->size, new_r1_size);
ASSERT_EQ(rgn2->base, r3_end);
ASSERT_EQ(rgn2->size, new_r2_size);
ASSERT_EQ(memblock.reserved.cnt, 2);
ASSERT_EQ(memblock.reserved.total_size, total_size);
test_pass_pop();
return 0;
}
static int memblock_free_checks(void)
{
prefix_reset();
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();
memblock_free_only_region_check();
memblock_free_near_max_check();
memblock_free_overlap_two_check();
prefix_pop();
return 0;
}
static int memblock_set_bottom_up_check(void)
{
prefix_push("memblock_set_bottom_up");
memblock_set_bottom_up(false);
ASSERT_EQ(memblock.bottom_up, false);
memblock_set_bottom_up(true);
ASSERT_EQ(memblock.bottom_up, true);
reset_memblock_attributes();
test_pass_pop();
return 0;
}
static int memblock_bottom_up_check(void)
{
prefix_push("memblock_bottom_up");
memblock_set_bottom_up(false);
ASSERT_EQ(memblock_bottom_up(), memblock.bottom_up);
ASSERT_EQ(memblock_bottom_up(), false);
memblock_set_bottom_up(true);
ASSERT_EQ(memblock_bottom_up(), memblock.bottom_up);
ASSERT_EQ(memblock_bottom_up(), true);
reset_memblock_attributes();
test_pass_pop();
return 0;
}
static int memblock_bottom_up_checks(void)
{
test_print("Running memblock_*bottom_up tests...\n");
prefix_reset();
memblock_set_bottom_up_check();
prefix_reset();
memblock_bottom_up_check();
return 0;
}
/*
* A test that tries to trim memory when both ends of the memory region are
* aligned. Expect that the memory will not be trimmed. Expect the counter to
* not be updated.
*/
static int memblock_trim_memory_aligned_check(void)
{
struct memblock_region *rgn;
const phys_addr_t alignment = SMP_CACHE_BYTES;
rgn = &memblock.memory.regions[0];
struct region r = {
.base = alignment,
.size = alignment * 4
};
PREFIX_PUSH();
reset_memblock_regions();
memblock_add(r.base, r.size);
memblock_trim_memory(alignment);
ASSERT_EQ(rgn->base, r.base);
ASSERT_EQ(rgn->size, r.size);
ASSERT_EQ(memblock.memory.cnt, 1);
test_pass_pop();
return 0;
}
/*
* A test that tries to trim memory when there are two available regions, r1 and
* r2. Region r1 is aligned on both ends and region r2 is unaligned on one end
* and smaller than the alignment:
*
* alignment
* |--------|
* | +-----------------+ +------+ |
* | | r1 | | r2 | |
* +--------+-----------------+--------+------+---+
* ^ ^ ^ ^ ^
* |________|________|________| |
* | Unaligned address
* Aligned addresses
*
* Expect that r1 will not be trimmed and r2 will be removed. Expect the
* counter to be updated.
*/
static int memblock_trim_memory_too_small_check(void)
{
struct memblock_region *rgn;
const phys_addr_t alignment = SMP_CACHE_BYTES;
rgn = &memblock.memory.regions[0];
struct region r1 = {
.base = alignment,
.size = alignment * 2
};
struct region r2 = {
.base = alignment * 4,
.size = alignment - SZ_2
};
PREFIX_PUSH();
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_add(r2.base, r2.size);
memblock_trim_memory(alignment);
ASSERT_EQ(rgn->base, r1.base);
ASSERT_EQ(rgn->size, r1.size);
ASSERT_EQ(memblock.memory.cnt, 1);
test_pass_pop();
return 0;
}
/*
* A test that tries to trim memory when there are two available regions, r1 and
* r2. Region r1 is aligned on both ends and region r2 is unaligned at the base
* and aligned at the end:
*
* Unaligned address
* |
* v
* | +-----------------+ +---------------+ |
* | | r1 | | r2 | |
* +--------+-----------------+----------+---------------+---+
* ^ ^ ^ ^ ^ ^
* |________|________|________|________|________|
* |
* Aligned addresses
*
* Expect that r1 will not be trimmed and r2 will be trimmed at the base.
* Expect the counter to not be updated.
*/
static int memblock_trim_memory_unaligned_base_check(void)
{
struct memblock_region *rgn1, *rgn2;
const phys_addr_t alignment = SMP_CACHE_BYTES;
phys_addr_t offset = SZ_2;
phys_addr_t new_r2_base, new_r2_size;
rgn1 = &memblock.memory.regions[0];
rgn2 = &memblock.memory.regions[1];
struct region r1 = {
.base = alignment,
.size = alignment * 2
};
struct region r2 = {
.base = alignment * 4 + offset,
.size = alignment * 2 - offset
};
PREFIX_PUSH();
new_r2_base = r2.base + (alignment - offset);
new_r2_size = r2.size - (alignment - offset);
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_add(r2.base, r2.size);
memblock_trim_memory(alignment);
ASSERT_EQ(rgn1->base, r1.base);
ASSERT_EQ(rgn1->size, r1.size);
ASSERT_EQ(rgn2->base, new_r2_base);
ASSERT_EQ(rgn2->size, new_r2_size);
ASSERT_EQ(memblock.memory.cnt, 2);
test_pass_pop();
return 0;
}
/*
* A test that tries to trim memory when there are two available regions, r1 and
* r2. Region r1 is aligned on both ends and region r2 is aligned at the base
* and unaligned at the end:
*
* Unaligned address
* |
* v
* | +-----------------+ +---------------+ |
* | | r1 | | r2 | |
* +--------+-----------------+--------+---------------+---+
* ^ ^ ^ ^ ^ ^
* |________|________|________|________|________|
* |
* Aligned addresses
*
* Expect that r1 will not be trimmed and r2 will be trimmed at the end.
* Expect the counter to not be updated.
*/
static int memblock_trim_memory_unaligned_end_check(void)
{
struct memblock_region *rgn1, *rgn2;
const phys_addr_t alignment = SMP_CACHE_BYTES;
phys_addr_t offset = SZ_2;
phys_addr_t new_r2_size;
rgn1 = &memblock.memory.regions[0];
rgn2 = &memblock.memory.regions[1];
struct region r1 = {
.base = alignment,
.size = alignment * 2
};
struct region r2 = {
.base = alignment * 4,
.size = alignment * 2 - offset
};
PREFIX_PUSH();
new_r2_size = r2.size - (alignment - offset);
reset_memblock_regions();
memblock_add(r1.base, r1.size);
memblock_add(r2.base, r2.size);
memblock_trim_memory(alignment);
ASSERT_EQ(rgn1->base, r1.base);
ASSERT_EQ(rgn1->size, r1.size);
ASSERT_EQ(rgn2->base, r2.base);
ASSERT_EQ(rgn2->size, new_r2_size);
ASSERT_EQ(memblock.memory.cnt, 2);
test_pass_pop();
return 0;
}
static int memblock_trim_memory_checks(void)
{
prefix_reset();
prefix_push(FUNC_TRIM);
test_print("Running %s tests...\n", FUNC_TRIM);
memblock_trim_memory_aligned_check();
memblock_trim_memory_too_small_check();
memblock_trim_memory_unaligned_base_check();
memblock_trim_memory_unaligned_end_check();
prefix_pop();
return 0;
}
int memblock_basic_checks(void)
{
memblock_initialization_check();
memblock_add_checks();
memblock_reserve_checks();
memblock_remove_checks();
memblock_free_checks();
memblock_bottom_up_checks();
memblock_trim_memory_checks();
return 0;
}