summaryrefslogtreecommitdiffstats
path: root/tools
diff options
context:
space:
mode:
authorKarolina Drobnik <karolinadrobnik@gmail.com>2022-02-28 15:46:47 +0100
committerMike Rapoport <rppt@linux.ibm.com>2022-03-09 14:54:03 +0100
commit16567b5f30f6ea13a78a3b553e0c9c0c1ba34e64 (patch)
tree30a66b9502b7d8a55000e2e90d6605f6b1c0edad /tools
parentmemblock tests: Add memblock_alloc tests for bottom up (diff)
downloadlinux-16567b5f30f6ea13a78a3b553e0c9c0c1ba34e64.tar.xz
linux-16567b5f30f6ea13a78a3b553e0c9c0c1ba34e64.zip
memblock tests: Add memblock_alloc_from tests for top down
Add checks for memblock_alloc_from for default allocation direction. The tested scenarios are: - Not enough space to allocate memory at the minimal address - Minimal address parameter is smaller than the start address of the available memory - Minimal address is too close to the available memory Add simple memblock_alloc_from test that can be used to test both allocation directions (minimal address is aligned or misaligned). Signed-off-by: Karolina Drobnik <karolinadrobnik@gmail.com> Signed-off-by: Mike Rapoport <rppt@linux.ibm.com> Link: https://lore.kernel.org/r/3dd645f437975fd393010b95b8faa85d2b86490a.1646055639.git.karolinadrobnik@gmail.com
Diffstat (limited to 'tools')
-rw-r--r--tools/testing/memblock/Makefile3
-rw-r--r--tools/testing/memblock/main.c2
-rw-r--r--tools/testing/memblock/tests/alloc_helpers_api.c226
-rw-r--r--tools/testing/memblock/tests/alloc_helpers_api.h9
4 files changed, 239 insertions, 1 deletions
diff --git a/tools/testing/memblock/Makefile b/tools/testing/memblock/Makefile
index 5b01cfd808d0..89e374470009 100644
--- a/tools/testing/memblock/Makefile
+++ b/tools/testing/memblock/Makefile
@@ -6,7 +6,8 @@ CFLAGS += -I. -I../../include -Wall -O2 -fsanitize=address \
-fsanitize=undefined -D CONFIG_PHYS_ADDR_T_64BIT
LDFLAGS += -fsanitize=address -fsanitize=undefined
TARGETS = main
-TEST_OFILES = tests/alloc_api.o tests/basic_api.o tests/common.o
+TEST_OFILES = tests/alloc_helpers_api.o tests/alloc_api.o tests/basic_api.o \
+ tests/common.o
DEP_OFILES = memblock.o lib/slab.o mmzone.o slab.o
OFILES = main.o $(DEP_OFILES) $(TEST_OFILES)
EXTR_SRC = ../../../mm/memblock.c
diff --git a/tools/testing/memblock/main.c b/tools/testing/memblock/main.c
index e7cc45dc06d4..b63150ee554f 100644
--- a/tools/testing/memblock/main.c
+++ b/tools/testing/memblock/main.c
@@ -1,11 +1,13 @@
// SPDX-License-Identifier: GPL-2.0-or-later
#include "tests/basic_api.h"
#include "tests/alloc_api.h"
+#include "tests/alloc_helpers_api.h"
int main(int argc, char **argv)
{
memblock_basic_checks();
memblock_alloc_checks();
+ memblock_alloc_helpers_checks();
return 0;
}
diff --git a/tools/testing/memblock/tests/alloc_helpers_api.c b/tools/testing/memblock/tests/alloc_helpers_api.c
new file mode 100644
index 000000000000..dc5152adcc5b
--- /dev/null
+++ b/tools/testing/memblock/tests/alloc_helpers_api.c
@@ -0,0 +1,226 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#include "alloc_helpers_api.h"
+
+/*
+ * A simple test that tries to allocate a memory region above a specified,
+ * aligned address:
+ *
+ * +
+ * | +-----------+ |
+ * | | rgn | |
+ * +----------+-----------+---------+
+ * ^
+ * |
+ * Aligned min_addr
+ *
+ * Expect to allocate a cleared region at the minimal memory address.
+ */
+static int alloc_from_simple_generic_check(void)
+{
+ struct memblock_region *rgn = &memblock.reserved.regions[0];
+ void *allocated_ptr = NULL;
+ char *b;
+
+ phys_addr_t size = SZ_16;
+ phys_addr_t min_addr;
+
+ setup_memblock();
+
+ min_addr = memblock_end_of_DRAM() - SMP_CACHE_BYTES;
+
+ allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
+ b = (char *)allocated_ptr;
+
+ assert(allocated_ptr);
+ assert(*b == 0);
+
+ assert(rgn->size == size);
+ assert(rgn->base == min_addr);
+
+ assert(memblock.reserved.cnt == 1);
+ assert(memblock.reserved.total_size == size);
+
+ return 0;
+}
+
+/*
+ * A test that tries to allocate a memory region above a certain address.
+ * The minimal address here is not aligned:
+ *
+ * + +
+ * | + +---------+ |
+ * | | | rgn | |
+ * +------+------+---------+------------+
+ * ^ ^------.
+ * | |
+ * min_addr Aligned address
+ * boundary
+ *
+ * Expect to allocate a cleared region at the closest aligned memory address.
+ */
+static int alloc_from_misaligned_generic_check(void)
+{
+ struct memblock_region *rgn = &memblock.reserved.regions[0];
+ void *allocated_ptr = NULL;
+ char *b;
+
+ phys_addr_t size = SZ_32;
+ phys_addr_t min_addr;
+
+ setup_memblock();
+
+ /* A misaligned address */
+ min_addr = memblock_end_of_DRAM() - (SMP_CACHE_BYTES * 2 - 1);
+
+ allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
+ b = (char *)allocated_ptr;
+
+ assert(allocated_ptr);
+ assert(*b == 0);
+
+ assert(rgn->size == size);
+ assert(rgn->base == memblock_end_of_DRAM() - SMP_CACHE_BYTES);
+
+ assert(memblock.reserved.cnt == 1);
+ assert(memblock.reserved.total_size == size);
+
+ return 0;
+}
+
+/*
+ * A test that tries to allocate a memory region above an address that is too
+ * close to the end of the memory:
+ *
+ * + +
+ * | +--------+---+ |
+ * | | rgn + | |
+ * +-----------+--------+---+------+
+ * ^ ^
+ * | |
+ * | min_addr
+ * |
+ * Aligned address
+ * boundary
+ *
+ * Expect to prioritize granting memory over satisfying the minimal address
+ * requirement.
+ */
+static int alloc_from_top_down_high_addr_check(void)
+{
+ struct memblock_region *rgn = &memblock.reserved.regions[0];
+ void *allocated_ptr = NULL;
+
+ phys_addr_t size = SZ_32;
+ phys_addr_t min_addr;
+
+ setup_memblock();
+
+ /* The address is too close to the end of the memory */
+ min_addr = memblock_end_of_DRAM() - SZ_16;
+
+ 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(memblock.reserved.cnt == 1);
+ assert(memblock.reserved.total_size == size);
+
+ return 0;
+}
+
+/*
+ * A test that tries to allocate a memory region when there is no space
+ * available above the minimal address above a certain address:
+ *
+ * +
+ * | +---------+-------------|
+ * | | rgn | |
+ * +--------+---------+-------------+
+ * ^
+ * |
+ * min_addr
+ *
+ * Expect to prioritize granting memory over satisfying the minimal address
+ * requirement and to allocate next to the previously reserved region. The
+ * regions get merged into one.
+ */
+static int alloc_from_top_down_no_space_above_check(void)
+{
+ struct memblock_region *rgn = &memblock.reserved.regions[0];
+ void *allocated_ptr = NULL;
+
+ phys_addr_t r1_size = SZ_64;
+ phys_addr_t r2_size = SZ_2;
+ phys_addr_t total_size = r1_size + r2_size;
+ phys_addr_t min_addr;
+
+ setup_memblock();
+
+ min_addr = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2;
+
+ /* No space above this address */
+ memblock_reserve(min_addr, r2_size);
+
+ 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(memblock.reserved.cnt == 1);
+ assert(memblock.reserved.total_size == total_size);
+
+ return 0;
+}
+
+/*
+ * A test that tries to allocate a memory region with a minimal address below
+ * the start address of the available memory. As the allocation is top-down,
+ * first reserve a region that will force allocation near the start.
+ * Expect successful allocation and merge of both regions.
+ */
+static int alloc_from_top_down_min_addr_cap_check(void)
+{
+ struct memblock_region *rgn = &memblock.reserved.regions[0];
+ void *allocated_ptr = NULL;
+
+ phys_addr_t r1_size = SZ_64;
+ phys_addr_t min_addr;
+ phys_addr_t start_addr;
+
+ setup_memblock();
+
+ start_addr = (phys_addr_t)memblock_start_of_DRAM();
+ min_addr = start_addr - SMP_CACHE_BYTES * 3;
+
+ memblock_reserve(start_addr + r1_size, MEM_SIZE - r1_size);
+
+ 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(memblock.reserved.cnt == 1);
+ assert(memblock.reserved.total_size == MEM_SIZE);
+
+ return 0;
+}
+
+int memblock_alloc_helpers_checks(void)
+{
+ reset_memblock_attributes();
+ dummy_physical_memory_init();
+
+ alloc_from_simple_generic_check();
+ alloc_from_misaligned_generic_check();
+ alloc_from_top_down_high_addr_check();
+ alloc_from_top_down_min_addr_cap_check();
+ alloc_from_top_down_no_space_above_check();
+
+ dummy_physical_memory_cleanup();
+
+ return 0;
+}
diff --git a/tools/testing/memblock/tests/alloc_helpers_api.h b/tools/testing/memblock/tests/alloc_helpers_api.h
new file mode 100644
index 000000000000..c9e4827b1623
--- /dev/null
+++ b/tools/testing/memblock/tests/alloc_helpers_api.h
@@ -0,0 +1,9 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+#ifndef _MEMBLOCK_ALLOC_HELPERS_H
+#define _MEMBLOCK_ALLOC_HELPERS_H
+
+#include "common.h"
+
+int memblock_alloc_helpers_checks(void);
+
+#endif