Files
linux/tools/testing/memblock/tests/alloc_low_api.c
T
Tianyi Chen 2345d7e354 memblock tests: cover allocations below the low address limit
Add memblock_alloc_low() coverage using the simulator's low address
limit. Exercise aligned allocation, an allocation whose last byte is
immediately below the limit, an alignment constraint that prevents
fitting below it, and fully reserved low memory with high memory still
available.

Run each case with bottom-up and top-down allocation. Check zeroing
and reserved-region accounting as well as returned addresses. Verify
that an unrestricted allocation can use the free high memory after
the low allocation fails.

Document the simulated limit and remove the completed TODO.

Assisted-by: LLM
Signed-off-by: Tianyi Chen <[email protected]>
Link: https://patch.msgid.link/142ab1025fd1e4b5dcd2a1591b964626ebce9d23.1788997523.git.hi@tychen.cc
Signed-off-by: Mike Rapoport (Microsoft) <[email protected]>
2026-09-10 13:10:20 +03:00

149 lines
4.1 KiB
C

// SPDX-License-Identifier: GPL-2.0-or-later
#include "alloc_low_api.h"
#include <linux/align.h>
/* Allocate at the first or last aligned address below the low limit. */
static int alloc_low_simple_check(void)
{
struct memblock_region *rgn = &memblock.reserved.regions[0];
phys_addr_t size = SZ_64;
phys_addr_t expected;
void *allocated_ptr;
PREFIX_PUSH();
setup_memblock();
/* Simulated physical RAM is not necessarily SMP_CACHE_BYTES aligned. */
if (memblock_bottom_up())
expected = ALIGN(memblock_start_of_DRAM(), SMP_CACHE_BYTES);
else
expected = ALIGN_DOWN(ARCH_LOW_ADDRESS_LIMIT - size,
SMP_CACHE_BYTES);
allocated_ptr = memblock_alloc_low(size, SMP_CACHE_BYTES);
ASSERT_NE(allocated_ptr, NULL);
ASSERT_EQ((phys_addr_t)(uintptr_t)allocated_ptr, expected);
ASSERT_MEM_EQ(allocated_ptr, 0, size);
ASSERT_EQ(rgn->base, expected);
ASSERT_EQ(rgn->size, size);
ASSERT_LE(region_end(rgn), ARCH_LOW_ADDRESS_LIMIT);
ASSERT_EQ(memblock.reserved.cnt, 1);
ASSERT_EQ(memblock.reserved.total_size, size);
test_pass_pop();
return 0;
}
/* The last byte of the allocation is immediately below the low limit. */
static int alloc_low_exact_limit_check(void)
{
phys_addr_t limit = ARCH_LOW_ADDRESS_LIMIT;
phys_addr_t base = ALIGN_DOWN(limit - SZ_64, SMP_CACHE_BYTES);
phys_addr_t size = limit - base;
void *allocated_ptr;
PREFIX_PUSH();
setup_memblock();
ASSERT_EQ(memblock_remove(memblock_start_of_DRAM(),
base - memblock_start_of_DRAM()), 0);
allocated_ptr = memblock_alloc_low(size, SMP_CACHE_BYTES);
ASSERT_NE(allocated_ptr, NULL);
ASSERT_EQ((phys_addr_t)(uintptr_t)allocated_ptr, base);
ASSERT_MEM_EQ(allocated_ptr, 0, size);
ASSERT_EQ(memblock.reserved.regions[0].base, base);
ASSERT_EQ(region_end(&memblock.reserved.regions[0]), limit);
ASSERT_EQ(memblock.reserved.cnt, 1);
ASSERT_EQ(memblock.reserved.total_size, size);
test_pass_pop();
return 0;
}
/*
* There are size bytes below the limit, but aligning the start makes the
* allocation cross it. Memory above the limit must not satisfy the request.
*/
static int alloc_low_alignment_crosses_limit_check(void)
{
phys_addr_t limit = ARCH_LOW_ADDRESS_LIMIT;
phys_addr_t base = ALIGN_DOWN(limit, SMP_CACHE_BYTES) - 1;
phys_addr_t size = limit - base;
void *allocated_ptr;
PREFIX_PUSH();
setup_memblock();
ASSERT_EQ(memblock_remove(memblock_start_of_DRAM(),
base - memblock_start_of_DRAM()), 0);
allocated_ptr = memblock_alloc_low(size, SMP_CACHE_BYTES);
ASSERT_EQ(allocated_ptr, NULL);
ASSERT_EQ(memblock.reserved.cnt, 0);
ASSERT_EQ(memblock.reserved.total_size, 0);
ASSERT_MEM_EQ((void *)(uintptr_t)base, 1, memblock_end_of_DRAM() - base);
test_pass_pop();
return 0;
}
/* Allocation must fail after reserving all low memory, with high memory free. */
static int alloc_low_reserved_check(void)
{
phys_addr_t limit = ARCH_LOW_ADDRESS_LIMIT;
phys_addr_t base = dummy_physical_memory_base();
phys_addr_t size = SZ_64;
void *allocated_ptr;
PREFIX_PUSH();
setup_memblock();
ASSERT_EQ(memblock_reserve(base, limit - base), 0);
allocated_ptr = memblock_alloc_low(size, SMP_CACHE_BYTES);
ASSERT_EQ(allocated_ptr, NULL);
ASSERT_EQ(memblock.reserved.cnt, 1);
ASSERT_EQ(memblock.reserved.regions[0].base, base);
ASSERT_EQ(memblock.reserved.regions[0].size, limit - base);
ASSERT_EQ(memblock.reserved.total_size, limit - base);
ASSERT_MEM_EQ((void *)(uintptr_t)base, 1, MEM_SIZE);
allocated_ptr = memblock_alloc(size, SMP_CACHE_BYTES);
ASSERT_NE(allocated_ptr, NULL);
ASSERT_LE(limit, (phys_addr_t)(uintptr_t)allocated_ptr);
ASSERT_MEM_EQ(allocated_ptr, 0, size);
test_pass_pop();
return 0;
}
static int alloc_low_checks(void)
{
alloc_low_simple_check();
alloc_low_exact_limit_check();
alloc_low_alignment_crosses_limit_check();
alloc_low_reserved_check();
return 0;
}
int memblock_alloc_low_checks(void)
{
prefix_reset();
prefix_push("memblock_alloc_low");
test_print("Running memblock_alloc_low tests...\n");
reset_memblock_attributes();
dummy_physical_memory_init();
run_top_down(alloc_low_checks);
run_bottom_up(alloc_low_checks);
dummy_physical_memory_cleanup();
prefix_pop();
return 0;
}