| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-Id: <506cf5293c8a21c012b7ea87b14af07754d3e656.1646055639.git.karolinadrobnik@gmail.com>
Date: Mon, 28 Feb 2022 15:46:48 +0100
From: Karolina Drobnik <karolinadrobnik@...il.com>
To: linux-mm@...ck.org
Cc: rppt@...nel.org, akpm@...ux-foundation.org,
linux-kernel@...r.kernel.org,
Karolina Drobnik <karolinadrobnik@...il.com>
Subject: [PATCH 6/9] memblock tests: Add memblock_alloc_from tests for bottom up
Add checks for memblock_alloc_from for bottom up 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 parameter is too close to the end of the available
memory
Add test case wrappers to test both directions in the same context.
Signed-off-by: Karolina Drobnik <karolinadrobnik@...il.com>
---
.../memblock/tests/alloc_helpers_api.c | 175 +++++++++++++++++-
1 file changed, 171 insertions(+), 4 deletions(-)
diff --git a/tools/testing/memblock/tests/alloc_helpers_api.c b/tools/testing/memblock/tests/alloc_helpers_api.c
index dc5152adcc5b..963a966db461 100644
--- a/tools/testing/memblock/tests/alloc_helpers_api.c
+++ b/tools/testing/memblock/tests/alloc_helpers_api.c
@@ -209,16 +209,183 @@ static int alloc_from_top_down_min_addr_cap_check(void)
return 0;
}
-int memblock_alloc_helpers_checks(void)
+/*
+ * A test that tries to allocate a memory region above an address that is too
+ * close to the end of the memory:
+ *
+ * +
+ * |-----------+ + |
+ * | rgn | | |
+ * +-----------+--------------+-----+
+ * ^ ^
+ * | |
+ * Aligned address min_addr
+ * boundary
+ *
+ * Expect to prioritize granting memory over satisfying the minimal address
+ * requirement. Allocation happens at beginning of the available memory.
+ */
+static int alloc_from_bottom_up_high_addr_check(void)
{
- reset_memblock_attributes();
- dummy_physical_memory_init();
+ 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_8;
+
+ allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
+
+ assert(allocated_ptr);
+ assert(rgn->size == size);
+ assert(rgn->base == memblock_start_of_DRAM());
+
+ assert(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 at the beginning of the available memory.
+ */
+static int alloc_from_bottom_up_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 min_addr;
+ phys_addr_t r2_size;
+
+ setup_memblock();
+
+ min_addr = memblock_start_of_DRAM() + SZ_128;
+ r2_size = memblock_end_of_DRAM() - min_addr;
+
+ /* No space above this address */
+ memblock_reserve(min_addr - SMP_CACHE_BYTES, r2_size);
+
+ allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
+
+ assert(allocated_ptr);
+ assert(rgn->base == memblock_start_of_DRAM());
+ assert(rgn->size == r1_size);
+
+ assert(memblock.reserved.cnt == 2);
+ assert(memblock.reserved.total_size == r1_size + r2_size);
+
+ return 0;
+}
+
+/*
+ * A test that tries to allocate a memory region with a minimal address below
+ * the start address of the available memory. Expect to allocate a region
+ * at the beginning of the available memory.
+ */
+static int alloc_from_bottom_up_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;
+
+ allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
+
+ assert(allocated_ptr);
+ assert(rgn->base == start_addr);
+ assert(rgn->size == r1_size);
+
+ assert(memblock.reserved.cnt == 1);
+ assert(memblock.reserved.total_size == r1_size);
+
+ return 0;
+}
+
+/* Test case wrappers */
+static int alloc_from_simple_check(void)
+{
+ memblock_set_bottom_up(false);
+ alloc_from_simple_generic_check();
+ memblock_set_bottom_up(true);
alloc_from_simple_generic_check();
+
+ return 0;
+}
+
+static int alloc_from_misaligned_check(void)
+{
+ memblock_set_bottom_up(false);
alloc_from_misaligned_generic_check();
+ memblock_set_bottom_up(true);
+ alloc_from_misaligned_generic_check();
+
+ return 0;
+}
+
+static int alloc_from_high_addr_check(void)
+{
+ memblock_set_bottom_up(false);
alloc_from_top_down_high_addr_check();
- alloc_from_top_down_min_addr_cap_check();
+ memblock_set_bottom_up(true);
+ alloc_from_bottom_up_high_addr_check();
+
+ return 0;
+}
+
+static int alloc_from_no_space_above_check(void)
+{
+ memblock_set_bottom_up(false);
alloc_from_top_down_no_space_above_check();
+ memblock_set_bottom_up(true);
+ alloc_from_bottom_up_no_space_above_check();
+
+ return 0;
+}
+
+static int alloc_from_min_addr_cap_check(void)
+{
+ memblock_set_bottom_up(false);
+ alloc_from_top_down_min_addr_cap_check();
+ memblock_set_bottom_up(true);
+ alloc_from_bottom_up_min_addr_cap_check();
+
+ return 0;
+}
+
+int memblock_alloc_helpers_checks(void)
+{
+ reset_memblock_attributes();
+ dummy_physical_memory_init();
+
+ alloc_from_simple_check();
+ alloc_from_misaligned_check();
+ alloc_from_high_addr_check();
+ alloc_from_no_space_above_check();
+ alloc_from_min_addr_cap_check();
dummy_physical_memory_cleanup();
--
2.30.2
Powered by blists - more mailing lists