memblock tests: model the low allocation limit within dummy memory
PATCH v2 1/2 memblock tests: model the low allocation limit within dummy memory
The simulator represents physical addresses using the address of its allocated buffer. That buffer can lie above the default ARCH_LOW_ADDRESS_LIMIT, preventing meaningful memblock_alloc_low() tests.
Use the existing architecture override in asm/dma.h to place the limit halfway through the dummy memory buffer. Resolve it after the buffer has been allocated, so both low and high memory can be represented regardless of its address. The production allocator is unchanged.
--- tools/testing/memblock/asm/dma.h | 6 ++++++ tools/testing/memblock/tests/common.c | 5 +++++ 2 files changed, 11 insertions(+)
tools/testing/memblock/asm/dma.h +6 -0
@@ -2,4 +2,10 @@#ifndef _TOOLS_DMA_H#define _TOOLS_DMA_H +#include <linux/types.h> + +phys_addr_t dummy_physical_memory_low_limit (void ); + +#define ARCH_LOW_ADDRESS_LIMIT dummy_physical_memory_low_limit() +#endif
tools/testing/memblock/tests/common.c +5 -0
@@ -118,6 +118,11 @@ phys_addr_t dummy_physical_memory_base(void)return (phys_addr_t )memory_block.base; } +phys_addr_t dummy_physical_memory_low_limit (void ) +{ +return dummy_physical_memory_base () +MEM_SIZE /2 ; +} +static void usage (const char *prog) {BUILD_BUG_ON (ARRAY_SIZE (help_opts) !=ARRAY_SIZE (long_opts) -1 );
Signature · 1 line
2.55.0
PATCH v2 2/2 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 ending exactly at 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. The full suite passes with ASan and UBSan in default, NUMA, 32-bit physical address and debug configurations, with movable-node mode both enabled and disabled.
--- tools/testing/memblock/Makefile | 3 +- tools/testing/memblock/README | 13 +- tools/testing/memblock/TODO | 5 - tools/testing/memblock/main.c | 2 + tools/testing/memblock/tests/alloc_low_api.c | 147 +++++++++++++++++++ tools/testing/memblock/tests/alloc_low_api.h | 9 ++ 6 files changed, 166 insertions(+), 13 deletions(-) delete mode 100644 tools/testing/memblock/TODO create mode 100644 tools/testing/memblock/tests/alloc_low_api.c create mode 100644 tools/testing/memblock/tests/alloc_low_api.h
tools/testing/memblock/Makefile +2 -1
@@ -7,7 +7,8 @@ CFLAGS += -I. -I../../include -Wall -O2 -fsanitize=address \ LDFLAGS += -fsanitize=address -fsanitize=undefined TARGETS = main TEST_OFILES = tests/alloc_nid_api.o tests/alloc_helpers_api.o tests/alloc_api.o \ - tests/basic_api.o tests/common.o tests/alloc_exact_nid_api.o + tests/basic_api.o tests/common.o tests/alloc_exact_nid_api.o \ + tests/alloc_low_api.o DEP_OFILES = memblock.o lib/slab.o mmzone.o slab.o cmdline.o OFILES = main.o $(DEP_OFILES) $(TEST_OFILES) EXTR_SRC = ../../../mm/memblock.c
tools/testing/memblock/README +6 -7
@@ -67,13 +67,13 @@ memblock |-- tests | |-- alloc_api.(c|h) -- memblock_alloc tests | |-- alloc_helpers_api.(c|h) -- memblock_alloc_from tests +| |-- alloc_low_api.(c|h) -- memblock_alloc_low tests | |-- alloc_nid_api.(c|h) -- memblock_alloc_try_nid tests | |-- basic_api.(c|h) -- memblock_add/memblock_reserve/... tests | |-- common.(c|h) -- helper functions for resetting memblock; |-- main.c --------------. dummy physical memory definition |-- Makefile `- test runner |-- README -|-- TODO |-- .gitignore Simulating physical memory
@@ -101,12 +101,11 @@ There's no need to explicitly free the dummy memory from memblock via memblock_free() call. The entry will be erased by reset_memblock_regions(), called at the beginning of each test. -Known issues -============ - -1. Tests for memblock_alloc_low() can't be easily implemented. The function uses - ARCH_LOW_ADDRESS_LIMIT marco, which can't be changed to point at the low - memory of the memory_block. +The simulator defines ARCH_LOW_ADDRESS_LIMIT in asm/dma.h using the midpoint +of the MEM_SIZE range beginning at the dummy physical memory base. This keeps +the low-address limit within the allocated buffer even when malloc() returns +an address above the kernel's default limit. The limit is an exclusive upper +bound, as in the memblock allocation API. References ==========
tools/testing/memblock/TODO deleted +0 -5
@@ -1,5 +0,0 @@ -TODO -===== - -1. Add tests for memblock_alloc_low() once the simulator can model - ARCH_LOW_ADDRESS_LIMIT against the low memory in memory_block
tools/testing/memblock/main.c +2 -0
@@ -4,6 +4,7 @@#include "tests/alloc_helpers_api.h" #include "tests/alloc_nid_api.h" #include "tests/alloc_exact_nid_api.h" +#include "tests/alloc_low_api.h" #include "tests/common.h" int main (int argc,char **argv)
@@ -12,6 +13,7 @@ int main(int argc, char **argv)memblock_basic_checks ();memblock_alloc_checks ();memblock_alloc_helpers_checks (); +memblock_alloc_low_checks ();memblock_alloc_nid_checks ();memblock_alloc_exact_nid_checks ();
tools/testing/memblock/tests/alloc_low_api.c new file +147 -0
147 lines not on this page · raw message
tools/testing/memblock/tests/alloc_low_api.h new file +9 -0
@@ -0,0 +1,9 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +#ifndef _MEMBLOCK_ALLOC_LOW_H +#define _MEMBLOCK_ALLOC_LOW_H + +#include "common.h" + +int memblock_alloc_low_checks (void ); + +#endif
Signature · 1 line
2.55.0
Mike Rapoport
maintainerRe: [PATCH 2/2] memblock tests: cover allocations below the low address limit
Quoted 124 lines · Tianyi Chen
Add
memblock_alloc_low()coverage using the simulator's low address limit. Exercise aligned allocation, an allocation ending exactly at 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. The full suite passes with ASan and UBSan in default, NUMA, 32-bit physical address and debug configurations, with movable-node mode both enabled and disabled.
Assisted-by LLMSigned-off-by Tianyi Chen <[email protected]>--- tools/testing/memblock/Makefile | 3 +- tools/testing/memblock/README | 13 +- tools/testing/memblock/TODO | 5 - tools/testing/memblock/main.c | 2 + tools/testing/memblock/tests/alloc_low_api.c | 147 +++++++++++++++++++ tools/testing/memblock/tests/alloc_low_api.h | 9 ++ 6 files changed, 166 insertions(+), 13 deletions(-) delete mode 100644 tools/testing/memblock/TODO create mode 100644 tools/testing/memblock/tests/alloc_low_api.c create mode 100644 tools/testing/memblock/tests/alloc_low_api.htools/testing/memblock/Makefile +2
-1@@ -7,7 +7,8 @@ CFLAGS += -I. -I../../include -Wall -O2 -fsanitize=address \ LDFLAGS += -fsanitize=address -fsanitize=undefined TARGETS = main TEST_OFILES = tests/alloc_nid_api.o tests/alloc_helpers_api.o tests/alloc_api.o \ - tests/basic_api.o tests/common.o tests/alloc_exact_nid_api.o + tests/basic_api.o tests/common.o tests/alloc_exact_nid_api.o \ + tests/alloc_low_api.o DEP_OFILES = memblock.o lib/slab.o mmzone.o slab.o cmdline.o OFILES = main.o $(DEP_OFILES) $(TEST_OFILES) EXTR_SRC = ../../../mm/memblock.ctools/testing/memblock/README +6
-7@@ -67,13 +67,13 @@ memblock |-- tests | |-- alloc_api.(c|h) -- memblock_alloc tests | |-- alloc_helpers_api.(c|h) -- memblock_alloc_from tests +| |-- alloc_low_api.(c|h) -- memblock_alloc_low tests | |-- alloc_nid_api.(c|h) -- memblock_alloc_try_nid tests | |-- basic_api.(c|h) -- memblock_add/memblock_reserve/... tests | |-- common.(c|h) -- helper functions for resetting memblock; |-- main.c --------------. dummy physical memory definition |-- Makefile `- test runner |-- README -|-- TODO |-- .gitignore Simulating physical memory@@ -101,12 +101,11 @@ There's no need to explicitly free the dummy memory from memblock via memblock_free() call. The entry will be erased by reset_memblock_regions(), called at the beginning of each test. -Known issues -============ - -1. Tests for memblock_alloc_low() can't be easily implemented. The function uses - ARCH_LOW_ADDRESS_LIMIT marco, which can't be changed to point at the low - memory of the memory_block. +The simulator defines ARCH_LOW_ADDRESS_LIMIT in asm/dma.h using the midpoint +of the MEM_SIZE range beginning at the dummy physical memory base. This keeps +the low-address limit within the allocated buffer even when malloc() returns +an address above the kernel's default limit. The limit is an exclusive upper +bound, as in the memblock allocation API. References ==========tools/testing/memblock/TODO deleted +0
-5@@ -1,5 +0,0 @@ -TODO -===== - -1. Add tests for memblock_alloc_low() once the simulator can model - ARCH_LOW_ADDRESS_LIMIT against the low memory in memory_blocktools/testing/memblock/main.c +2
-0@@ -4,6 +4,7 @@#include "tests/alloc_helpers_api.h" #include "tests/alloc_nid_api.h" #include "tests/alloc_exact_nid_api.h" +#include "tests/alloc_low_api.h" #include "tests/common.h" int main (int argc,char **argv)@@ -12,6 +13,7 @@ int main(int argc, char **argv)memblock_basic_checks ();memblock_alloc_checks ();memblock_alloc_helpers_checks (); +memblock_alloc_low_checks ();memblock_alloc_nid_checks ();memblock_alloc_exact_nid_checks ();tools/testing/memblock/tests/alloc_low_api.c new file +7
-0@@ -0,0 +1,147 @@ +// 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 ) +{
tools/testing/memblock/tests/alloc_low_api.c line 17
Quoted 10 lines
tools/testing/memblock/tests/alloc_low_api.c new file +10
-0+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 (); + +if (memblock_bottom_up ()) + expected =ALIGN (memblock_start_of_DRAM (),SMP_CACHE_BYTES );
Can we ever have memblock_start_of_DRAM() not aligned to SMP_CACHE_BYTES?
Quoted 10 lines
tools/testing/memblock/tests/alloc_low_api.c new file +10
-0+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);
tools/testing/memblock/tests/alloc_low_api.c line 37
Quoted 10 lines
tools/testing/memblock/tests/alloc_low_api.c new file +10
-0+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 only low memory available ends exactly at the exclusive limit. */
What do you mean by "exclusive limit"?
Quoted 44 lines
tools/testing/memblock/tests/alloc_low_api.c new file +44
-0+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 ); +
tools/testing/memblock/tests/alloc_low_api.c line 91
Quoted 10 lines
tools/testing/memblock/tests/alloc_low_api.c new file +10
-0+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 ; +} + +/* Reserving all low memory must fail even though high memory remains free. */
Is this what the test checks?
Quoted 75 lines
tools/testing/memblock/tests/alloc_low_api.c new file +56
-0+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 ; +}tools/testing/memblock/tests/alloc_low_api.h new file +9
-0@@ -0,0 +1,9 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +#ifndef _MEMBLOCK_ALLOC_LOW_H +#define _MEMBLOCK_ALLOC_LOW_H + +#include "common.h" + +int memblock_alloc_low_checks (void ); + +#endif Signature · 1 line
2.55.0
Signature · 2 lines
Sincerely yours, Mike.
Mike Rapoport
maintainerQuoted 11 lines · Tianyi Chen
The simulator represents physical addresses using the address of its allocated buffer. That buffer can lie above the default
ARCH_LOW_ADDRESS_LIMIT, preventing meaningfulmemblock_alloc_low()tests.Use the existing architecture override in
asm/dma.hto place the limit halfway through the dummy memory buffer. Resolve it after the buffer has been allocated, so both low and high memory can be represented regardless of its address. The production allocator is unchanged.Assisted-by LLM
Please add LLM attribution as per
https://docs.kernel.org/process/coding-assistants.html#attribution
Quoted 26 lines
Signed-off-by Tianyi Chen <[email protected]>--- tools/testing/memblock/asm/dma.h | 6 ++++++ tools/testing/memblock/tests/common.c | 5 +++++ 2 files changed, 11 insertions(+)tools/testing/memblock/asm/dma.h +6
-0@@ -2,4 +2,10 @@#ifndef _TOOLS_DMA_H#define _TOOLS_DMA_H +#include <linux/types.h> + +phys_addr_t dummy_physical_memory_low_limit (void ); + +#define ARCH_LOW_ADDRESS_LIMIT dummy_physical_memory_low_limit() +#endif tools/testing/memblock/tests/common.c +0
-0
tools/testing/memblock/tests/common.c phys_addr_t dummy_physical_memory_base(void) · line 123
Quoted 6 lines
tools/testing/memblock/tests/common.c +3
-0@@ -118,6 +118,11 @@ phys_addr_t dummy_physical_memory_base(void)return (phys_addr_t )memory_block.base; } +phys_addr_t dummy_physical_memory_low_limit (void ) +{ +return dummy_physical_memory_base () +MEM_SIZE /2 ;
Shouldn't this be PHYS_MEM_SIZE?
Quoted 9 lines
tools/testing/memblock/tests/common.c +2
-0+} +static void usage (const char *prog) {BUILD_BUG_ON (ARRAY_SIZE (help_opts) !=ARRAY_SIZE (long_opts) -1 );Signature · 1 line
2.55.0
Signature · 2 lines
Sincerely yours, Mike.
Hi Mike,
Thank you for reviewing both patches. I have addressed the attribution and wording in v2:
https://lore.kernel.org/r/178874362959.1415955.18132997964995947947.memblock-v2-0@tychen.cc
Quoted 1 line
Shouldn't this be
PHYS_MEM_SIZE?
MEM_SIZE is intentional here. setup_memblock() registers only MEM_SIZE (32 KiB), although malloc() allocates a PHYS_MEM_SIZE (16 MiB) backing buffer. Splitting the registered range leaves usable memory on both sides of the limit. PHYS_MEM_SIZE / 2 would put the limit above all registered memory. The comment, README and commit message now explain this.
On the alignment question in patch 2: the registered base is the malloc() result, which is not guaranteed to have SMP_CACHE_BYTES alignment (32 bytes in this simulator). ALIGN() also matches the allocator's round_up(this_start, align) in __memblock_find_range_bottom_up(); it is harmless when the base is already aligned.
By "exclusive limit" I meant the first address an allocation must not use. region_end() is base + size, so equality with the limit is valid. I have replaced that wording with the allocation's last byte being immediately below the limit.
You are also right about the reserved-memory comment: reserving low memory succeeds; the subsequent low-memory allocation must fail. I have corrected that description. Both patches now use Assisted-by: Codex:GPT-6.
The five configuration combinations described in the cover letter passed with ASan/UBSan, movable-node mode enabled and disabled, and both allocation directions. The cover also records the separate, pre-existing BUILD=32 basic_api assertion failure.
Thanks,
Tianyi
v2 cover memblock tests: cover low-address allocations
In reply to Tianyi ChenModel a low allocation limit within the dummy memory registered with memblock, then exercise memblock_alloc_low() in both allocation directions.
Changes in v2, following Mike Rapoport's review:
- Clarify why the limit splits MEM_SIZE, the region registered by setup_memblock(), rather than the larger PHYS_MEM_SIZE malloc buffer.
- Explain why the malloc-backed base still needs alignment.
- Describe the boundary in terms of the last usable byte and clarify that reserving low memory succeeds; the following allocation fails.
- Update Assisted-by tags to the required tool:model format.
No allocator or test behavior changes from v1.
Validation with the existing Makefile and ASan/UBSan enabled:
- Default, NUMA=1, 32BIT_PHYS_ADDR_T=1, 32BIT_PHYS_ADDR_T=1 with NUMA=1, and MEMBLOCK_DEBUG=1 with NUMA=1 builds passed.
- Each configuration passed both ./main -v and ./main -v -m.
- A separate BUILD=32 run still hits the pre-existing memblock_free_near_max_check assertion in basic_api.c, also seen on the baseline. This is distinct from the passing 32-bit physical-address configuration above.
v1: https://lore.kernel.org/r/[email protected]
Review: https://lore.kernel.org/r/[email protected]
Review: https://lore.kernel.org/r/[email protected]
Tianyi Chen (2):
memblock tests: model the low allocation limit within dummy memory memblock tests: cover allocations below the low address limit
tools/testing/memblock/Makefile | 3 +- tools/testing/memblock/README | 14 +- tools/testing/memblock/TODO | 5 - tools/testing/memblock/asm/dma.h | 6 + tools/testing/memblock/main.c | 2 + tools/testing/memblock/tests/alloc_low_api.c | 148 +++++++++++++++++++ tools/testing/memblock/tests/alloc_low_api.h | 9 ++ tools/testing/memblock/tests/common.c | 6 + 8 files changed, 180 insertions(+), 13 deletions(-) delete mode 100644 tools/testing/memblock/TODO create mode 100644 tools/testing/memblock/tests/alloc_low_api.c create mode 100644 tools/testing/memblock/tests/alloc_low_api.h
Signature · 1 line
2.55.0
PATCH v2 1/2 memblock tests: model the low allocation limit within dummy memory
The simulator represents physical addresses using the address of its allocated buffer. That buffer can lie above the default ARCH_LOW_ADDRESS_LIMIT, preventing meaningful memblock_alloc_low() tests.
Use the architecture override in asm/dma.h to place the limit halfway through the MEM_SIZE region registered by setup_memblock(). This leaves registered memory on both sides of the limit. PHYS_MEM_SIZE describes the larger backing allocation, rather than the registered region. Resolve the limit after allocating the buffer. The production allocator is unchanged.
--- tools/testing/memblock/asm/dma.h | 6 ++++++ tools/testing/memblock/tests/common.c | 6 ++++++ 2 files changed, 12 insertions(+)
tools/testing/memblock/asm/dma.h +6 -0
@@ -2,4 +2,10 @@#ifndef _TOOLS_DMA_H#define _TOOLS_DMA_H +#include <linux/types.h> + +phys_addr_t dummy_physical_memory_low_limit (void ); + +#define ARCH_LOW_ADDRESS_LIMIT dummy_physical_memory_low_limit() +#endif
tools/testing/memblock/tests/common.c +6 -0
@@ -118,6 +118,12 @@ phys_addr_t dummy_physical_memory_base(void)return (phys_addr_t )memory_block.base; } +phys_addr_t dummy_physical_memory_low_limit (void ) +{ +/* Split the MEM_SIZE region registered by setup_memblock(), not the buffer. */ +return dummy_physical_memory_base () +MEM_SIZE /2 ; +} +static void usage (const char *prog) {BUILD_BUG_ON (ARRAY_SIZE (help_opts) !=ARRAY_SIZE (long_opts) -1 );
Signature · 1 line
2.55.0
Mike Rapoport
maintainerHi,
Quoted 35 lines
The simulator represents physical addresses using the address of its allocated buffer. That buffer can lie above the default
ARCH_LOW_ADDRESS_LIMIT, preventing meaningfulmemblock_alloc_low()tests.Use the architecture override in
asm/dma.hto place the limit halfway through theMEM_SIZEregion registered bysetup_memblock(). This leaves registered memory on both sides of the limit.PHYS_MEM_SIZEdescribes the larger backing allocation, rather than the registered region. Resolve the limit after allocating the buffer. The production allocator is unchanged.Assisted-by Codex:GPT-6Signed-off-by Tianyi Chen <[email protected]>tools/testing/memblock/asm/dma.h +6
-0@@ -2,4 +2,10 @@#ifndef _TOOLS_DMA_H#define _TOOLS_DMA_H +#include <linux/types.h> + +phys_addr_t dummy_physical_memory_low_limit (void ); + +#define ARCH_LOW_ADDRESS_LIMIT dummy_physical_memory_low_limit() +#endif tools/testing/memblock/tests/common.c +0
-0
tools/testing/memblock/tests/common.c phys_addr_t dummy_physical_memory_base(void) · line 123
Quoted 6 lines
tools/testing/memblock/tests/common.c +3
-0@@ -118,6 +118,12 @@ phys_addr_t dummy_physical_memory_base(void)return (phys_addr_t )memory_block.base; } +phys_addr_t dummy_physical_memory_low_limit (void ) +{ +/* Split the MEM_SIZE region registered by setup_memblock(), not the buffer. */
The comment should not address the review comments ;-)
It should state the universal truth, like "low limit is half of the memory registered with setup_memblock()"
Signature · 2 lines
Sincerely yours, Mike.
PATCH v2 2/2 memblock tests: cover allocations below the low address limit
In reply to Tianyi ChenAdd 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 registered memory range and its simulated limit, clarify the allocation boundary, and remove the completed TODO.
--- tools/testing/memblock/Makefile | 3 +- tools/testing/memblock/README | 14 +- tools/testing/memblock/TODO | 5 - tools/testing/memblock/main.c | 2 + tools/testing/memblock/tests/alloc_low_api.c | 148 +++++++++++++++++++ tools/testing/memblock/tests/alloc_low_api.h | 9 ++ 6 files changed, 168 insertions(+), 13 deletions(-) delete mode 100644 tools/testing/memblock/TODO create mode 100644 tools/testing/memblock/tests/alloc_low_api.c create mode 100644 tools/testing/memblock/tests/alloc_low_api.h
tools/testing/memblock/Makefile +2 -1
@@ -7,7 +7,8 @@ CFLAGS += -I. -I../../include -Wall -O2 -fsanitize=address \ LDFLAGS += -fsanitize=address -fsanitize=undefined TARGETS = main TEST_OFILES = tests/alloc_nid_api.o tests/alloc_helpers_api.o tests/alloc_api.o \ - tests/basic_api.o tests/common.o tests/alloc_exact_nid_api.o + tests/basic_api.o tests/common.o tests/alloc_exact_nid_api.o \ + tests/alloc_low_api.o DEP_OFILES = memblock.o lib/slab.o mmzone.o slab.o cmdline.o OFILES = main.o $(DEP_OFILES) $(TEST_OFILES) EXTR_SRC = ../../../mm/memblock.c
tools/testing/memblock/README +7 -7
@@ -67,13 +67,13 @@ memblock |-- tests | |-- alloc_api.(c|h) -- memblock_alloc tests | |-- alloc_helpers_api.(c|h) -- memblock_alloc_from tests +| |-- alloc_low_api.(c|h) -- memblock_alloc_low tests | |-- alloc_nid_api.(c|h) -- memblock_alloc_try_nid tests | |-- basic_api.(c|h) -- memblock_add/memblock_reserve/... tests | |-- common.(c|h) -- helper functions for resetting memblock; |-- main.c --------------. dummy physical memory definition |-- Makefile `- test runner |-- README -|-- TODO |-- .gitignore Simulating physical memory
@@ -101,12 +101,12 @@ There's no need to explicitly free the dummy memory from memblock via memblock_free() call. The entry will be erased by reset_memblock_regions(), called at the beginning of each test. -Known issues -============ - -1. Tests for memblock_alloc_low() can't be easily implemented. The function uses - ARCH_LOW_ADDRESS_LIMIT marco, which can't be changed to point at the low - memory of the memory_block. +The simulator defines ARCH_LOW_ADDRESS_LIMIT in asm/dma.h using the midpoint +of the MEM_SIZE range registered by setup_memblock(), rather than the larger +PHYS_MEM_SIZE backing buffer. This leaves registered memory both below and +above the limit, even when malloc() returns an address above the kernel's +default limit. The limit is the first address an allocation must not use; +an allocation's base plus its size may equal the limit. References ==========
tools/testing/memblock/TODO deleted +0 -5
@@ -1,5 +0,0 @@ -TODO -===== - -1. Add tests for memblock_alloc_low() once the simulator can model - ARCH_LOW_ADDRESS_LIMIT against the low memory in memory_block
tools/testing/memblock/main.c +2 -0
@@ -4,6 +4,7 @@#include "tests/alloc_helpers_api.h" #include "tests/alloc_nid_api.h" #include "tests/alloc_exact_nid_api.h" +#include "tests/alloc_low_api.h" #include "tests/common.h" int main (int argc,char **argv)
@@ -12,6 +13,7 @@ int main(int argc, char **argv)memblock_basic_checks ();memblock_alloc_checks ();memblock_alloc_helpers_checks (); +memblock_alloc_low_checks ();memblock_alloc_nid_checks ();memblock_alloc_exact_nid_checks ();
tools/testing/memblock/tests/alloc_low_api.c new file +148 -0
148 lines not on this page · raw message
tools/testing/memblock/tests/alloc_low_api.h new file +9 -0
@@ -0,0 +1,9 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +#ifndef _MEMBLOCK_ALLOC_LOW_H +#define _MEMBLOCK_ALLOC_LOW_H + +#include "common.h" + +int memblock_alloc_low_checks (void ); + +#endif
Signature · 1 line
2.55.0
Mike Rapoport
maintainerRe: [PATCH v2 2/2] memblock tests: cover allocations below the low address limit
Hi,
Quoted 53 lines
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 registered memory range and its simulated limit, clarify the allocation boundary, and remove the completed TODO.
Assisted-by Codex:GPT-6Signed-off-by Tianyi Chen <[email protected]>tools/testing/memblock/Makefile +2
-1@@ -7,7 +7,8 @@ CFLAGS += -I. -I../../include -Wall -O2 -fsanitize=address \ LDFLAGS += -fsanitize=address -fsanitize=undefined TARGETS = main TEST_OFILES = tests/alloc_nid_api.o tests/alloc_helpers_api.o tests/alloc_api.o \ - tests/basic_api.o tests/common.o tests/alloc_exact_nid_api.o + tests/basic_api.o tests/common.o tests/alloc_exact_nid_api.o \ + tests/alloc_low_api.o DEP_OFILES = memblock.o lib/slab.o mmzone.o slab.o cmdline.o OFILES = main.o $(DEP_OFILES) $(TEST_OFILES) EXTR_SRC = ../../../mm/memblock.ctools/testing/memblock/README +1
-1@@ -67,13 +67,13 @@ memblock |-- tests | |-- alloc_api.(c|h) -- memblock_alloc tests | |-- alloc_helpers_api.(c|h) -- memblock_alloc_from tests +| |-- alloc_low_api.(c|h) -- memblock_alloc_low tests | |-- alloc_nid_api.(c|h) -- memblock_alloc_try_nid tests | |-- basic_api.(c|h) -- memblock_add/memblock_reserve/... tests | |-- common.(c|h) -- helper functions for resetting memblock; |-- main.c --------------. dummy physical memory definition |-- Makefile `- test runner |-- README -|-- TODO |-- .gitignore Simulating physical memory@@ -101,12 +101,12 @@ There's no need to explicitly free the dummy memory from memblock via memblock_free() call. The entry will be erased by reset_memblock_regions(), called at the beginning of each test.
tools/testing/memblock/README There's no need to explicitly free the dummy memory from memblock via · line 106
Quoted 10 lines
tools/testing/memblock/README +3
-6-Known issues -============ - -1. Tests for memblock_alloc_low() can't be easily implemented. The function uses - ARCH_LOW_ADDRESS_LIMIT marco, which can't be changed to point at the low - memory of the memory_block. +The simulator defines ARCH_LOW_ADDRESS_LIMIT in asm/dma.h using the midpoint +of the MEM_SIZE range registered by setup_memblock(), rather than the larger +PHYS_MEM_SIZE backing buffer. This leaves registered memory both below and
"rather than ..." part is excessive
tools/testing/memblock/README There's no need to explicitly free the dummy memory from memblock via · line 107
Quoted 1 line
tools/testing/memblock/README +1
-0+above the limit, even when malloc() returns an address above the kernel's
Why do we care about what malloc() returns here?
Quoted 48 lines
tools/testing/memblock/README +2
-0+default limit. The limit is the first address an allocation must not use; +an allocation's base plus its size may equal the limit. References ==========tools/testing/memblock/TODO deleted +0
-5@@ -1,5 +0,0 @@ -TODO -===== - -1. Add tests for memblock_alloc_low() once the simulator can model - ARCH_LOW_ADDRESS_LIMIT against the low memory in memory_blocktools/testing/memblock/main.c +2
-0@@ -4,6 +4,7 @@#include "tests/alloc_helpers_api.h" #include "tests/alloc_nid_api.h" #include "tests/alloc_exact_nid_api.h" +#include "tests/alloc_low_api.h" #include "tests/common.h" int main (int argc,char **argv)@@ -12,6 +13,7 @@ int main(int argc, char **argv)memblock_basic_checks ();memblock_alloc_checks ();memblock_alloc_helpers_checks (); +memblock_alloc_low_checks ();memblock_alloc_nid_checks ();memblock_alloc_exact_nid_checks ();tools/testing/memblock/tests/alloc_low_api.c new file +6
-0@@ -0,0 +1,148 @@ +// 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 )
tools/testing/memblock/tests/alloc_low_api.c line 16
Quoted 10 lines
tools/testing/memblock/tests/alloc_low_api.c new file +10
-0+{ +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 (); + +/* malloc() does not guarantee SMP_CACHE_BYTES alignment. */
I'd drop malloc() and say "simulated physical RAM isn't necessarily SMP_CACHE_BYTES aligned"
tools/testing/memblock/tests/alloc_low_api.c line 26
Quoted 10 lines
tools/testing/memblock/tests/alloc_low_api.c new file +10
-0+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);
Isn't (phys_addr_t) cast enough?
Signature · 2 lines
Sincerely yours, Mike.
Mike Rapoport
maintainerRe: [PATCH v2 0/2] memblock tests: cover low-address allocations
In reply to Tianyi ChenHi,
For the future postings, please don't send vN+1 as a reply to vN.
Quoted 47 lines · Tianyi Chen
Model a low allocation limit within the dummy memory registered with memblock, then exercise
memblock_alloc_low()in both allocation directions.Changes in v2, following Mike Rapoport's review:
- Clarify why the limit splitsMEM_SIZE, the region registered bysetup_memblock(), rather than the largerPHYS_MEM_SIZEmalloc buffer.
- Explain why the malloc-backed base still needs alignment.
- Describe the boundary in terms of the last usable byte and clarify that reserving low memory succeeds; the following allocation fails.
- Update Assisted-by tags to the required tool:model format.No allocator or test behavior changes from v1.
Validation with the existing
Makefileand ASan/UBSan enabled:
- Default, NUMA=1, 32BIT_PHYS_ADDR_T=1, 32BIT_PHYS_ADDR_T=1 with NUMA=1, and MEMBLOCK_DEBUG=1 with NUMA=1 builds passed.
- Each configuration passed both ./main -v and ./main -v -m.
- A separate BUILD=32 run still hits the pre-existingmemblock_free_near_max_checkassertion inbasic_api.c, also seen on the baseline. This is distinct from the passing 32-bit physical-address configuration above.v1: https://lore.kernel.org/r/[email protected]
Review: https://lore.kernel.org/r/[email protected]
Review: https://lore.kernel.org/r/[email protected]Tianyi Chen (2):
memblock tests: model the low allocation limit within dummy memory memblock tests: cover allocations below the low address limittools/testing/memblock/Makefile | 3 +- tools/testing/memblock/README | 14 +- tools/testing/memblock/TODO | 5 - tools/testing/memblock/asm/dma.h | 6 + tools/testing/memblock/main.c | 2 + tools/testing/memblock/tests/alloc_low_api.c | 148 +++++++++++++++++++ tools/testing/memblock/tests/alloc_low_api.h | 9 ++ tools/testing/memblock/tests/common.c | 6 + 8 files changed, 180 insertions(+), 13 deletions(-) delete mode 100644 tools/testing/memblock/TODO create mode 100644 tools/testing/memblock/tests/alloc_low_api.c create mode 100644 tools/testing/memblock/tests/alloc_low_api.hSignature · 1 line
2.55.0
Signature · 2 lines
Sincerely yours, Mike.
Re: [PATCH v2 0/2] memblock tests: cover low-address allocations
Hi Mike,
Sorry for sending v2 as a reply to v1. I have posted v3 as a separate thread:
https://lore.kernel.org/r/[email protected]
I shortened the comments and README to describe the low limit and simulated RAM alignment directly. Both patches now use Assisted-by: LLM.
I also checked the pointer casts with BUILD=32, where pointers are 32-bit and phys_addr_t is 64-bit. The tested compiler sign-extends a direct cast to phys_addr_t, while conversion through uintptr_t zero-extends it. Direct casts also introduce warnings, so I retained uintptr_t to preserve the existing conversion behavior. There are no executable code changes from v2.
Thanks for the review,
Tianyi