From: Kaitao Cheng <kaitao.cheng@linux.dev>
To: Mike Rapoport <rppt@kernel.org>,
Andrew Morton <akpm@linux-foundation.org>,
Muchun Song <muchun.song@linux.dev>,
Lorenzo Stoakes <ljs@kernel.org>
Cc: Priyanshu Kumar <priyanshukumarpu@gmail.com>,
linux-mm@kvack.org, linux-kernel@vger.kernel.org,
Kaitao Cheng <chengkaitao@kylinos.cn>
Subject: [PATCH 1/2] memblock tests: Move exact nid tests to memblock_alloc_range_nid()
Date: Thu, 17 Sep 2026 16:15:03 +0800 [thread overview]
Message-ID: <20260917081504.30426-2-kaitao.cheng@linux.dev> (raw)
In-Reply-To: <20260917081504.30426-1-kaitao.cheng@linux.dev>
From: Kaitao Cheng <chengkaitao@kylinos.cn>
After memmap_alloc() stopped requesting allocations from an exact NUMA
node, memblock_alloc_exact_nid_raw() no longer has any in-kernel users
and is being removed.
Preserve coverage of exact-node allocation by converting the applicable
NUMA tests to call memblock_alloc_range_nid() with exact_nid set. Remove
the tests that depend on memblock_alloc_internal() retrying below
min_addr, as memblock_alloc_range_nid() treats its address range as a
hard constraint.
Remove the now-unused TEST_F_EXACT support from the shared allocation
tests.
Suggested-by: Lorenzo Stoakes <ljs@kernel.org>
Signed-off-by: Kaitao Cheng <chengkaitao@kylinos.cn>
---
.../memblock/tests/alloc_exact_nid_api.c | 454 ++----------------
tools/testing/memblock/tests/alloc_nid_api.c | 20 -
tools/testing/memblock/tests/alloc_nid_api.h | 1 -
tools/testing/memblock/tests/common.h | 2 -
4 files changed, 37 insertions(+), 440 deletions(-)
diff --git a/tools/testing/memblock/tests/alloc_exact_nid_api.c b/tools/testing/memblock/tests/alloc_exact_nid_api.c
index 0c46c73b5e04..52c63d011870 100644
--- a/tools/testing/memblock/tests/alloc_exact_nid_api.c
+++ b/tools/testing/memblock/tests/alloc_exact_nid_api.c
@@ -1,8 +1,7 @@
// SPDX-License-Identifier: GPL-2.0-or-later
#include "alloc_exact_nid_api.h"
-#include "alloc_nid_api.h"
-#define FUNC_NAME "memblock_alloc_exact_nid_raw"
+#define FUNC_NAME "memblock_alloc_range_nid(exact)"
/*
* contains the fraction of MEM_SIZE contained in each node in basis point
@@ -19,6 +18,18 @@ static const unsigned int node_fractions[] = {
625, /* 1/16 */
};
+static void *alloc_range_exact_nid(phys_addr_t size, phys_addr_t align,
+ phys_addr_t min_addr,
+ phys_addr_t max_addr, int nid)
+{
+ phys_addr_t addr;
+
+ addr = memblock_alloc_range_nid(size, align, min_addr, max_addr, nid,
+ true);
+
+ return addr ? phys_to_virt(addr) : NULL;
+}
+
/*
* A test that tries to allocate a memory region in a specific NUMA node that
* has enough memory to allocate a region of the requested size.
@@ -42,9 +53,8 @@ static int alloc_exact_nid_top_down_numa_simple_check(void)
min_addr = memblock_start_of_DRAM();
max_addr = memblock_end_of_DRAM();
- allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
- min_addr, max_addr,
- nid_req);
+ allocated_ptr = alloc_range_exact_nid(size, SMP_CACHE_BYTES,
+ min_addr, max_addr, nid_req);
ASSERT_NE(allocated_ptr, NULL);
ASSERT_MEM_NE(allocated_ptr, 0, size);
@@ -98,9 +108,8 @@ static int alloc_exact_nid_top_down_numa_part_reserved_check(void)
max_addr = memblock_end_of_DRAM();
memblock_reserve(r1.base, r1.size);
- allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
- min_addr, max_addr,
- nid_req);
+ allocated_ptr = alloc_range_exact_nid(size, SMP_CACHE_BYTES,
+ min_addr, max_addr, nid_req);
ASSERT_NE(allocated_ptr, NULL);
ASSERT_MEM_NE(allocated_ptr, 0, size);
@@ -117,177 +126,6 @@ static int alloc_exact_nid_top_down_numa_part_reserved_check(void)
return 0;
}
-/*
- * A test that tries to allocate a memory region that spans over the min_addr
- * and max_addr range and overlaps with two different nodes, where the first
- * node is the requested node:
- *
- * min_addr
- * | max_addr
- * | |
- * v v
- * | +-----------------------+-----------+ |
- * | | requested | node3 | |
- * +-----------+-----------------------+-----------+--------------+
- * + +
- * | +-----------+ |
- * | | rgn | |
- * +-----------------------+-----------+--------------------------+
- *
- * Expect to drop the lower limit and allocate a memory region that ends at
- * the end of the requested node.
- */
-static int alloc_exact_nid_top_down_numa_split_range_low_check(void)
-{
- int nid_req = 2;
- struct memblock_region *new_rgn = &memblock.reserved.regions[0];
- struct memblock_region *req_node = &memblock.memory.regions[nid_req];
- void *allocated_ptr = NULL;
- phys_addr_t size = SZ_512;
- phys_addr_t min_addr;
- phys_addr_t max_addr;
- phys_addr_t req_node_end;
-
- PREFIX_PUSH();
- setup_numa_memblock(node_fractions);
-
- req_node_end = region_end(req_node);
- min_addr = req_node_end - SZ_256;
- max_addr = min_addr + size;
-
- allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
- min_addr, max_addr,
- nid_req);
-
- ASSERT_NE(allocated_ptr, NULL);
- ASSERT_MEM_NE(allocated_ptr, 0, size);
-
- ASSERT_EQ(new_rgn->size, size);
- ASSERT_EQ(new_rgn->base, req_node_end - size);
- ASSERT_LE(req_node->base, new_rgn->base);
-
- ASSERT_EQ(memblock.reserved.cnt, 1);
- ASSERT_EQ(memblock.reserved.total_size, size);
-
- test_pass_pop();
-
- return 0;
-}
-
-/*
- * A test that tries to allocate a memory region that spans over the min_addr
- * and max_addr range and overlaps with two different nodes, where the requested
- * node ends before min_addr:
- *
- * min_addr
- * | max_addr
- * | |
- * v v
- * | +---------------+ +-------------+---------+ |
- * | | requested | | node1 | node2 | |
- * +----+---------------+--------+-------------+---------+----------+
- * + +
- * | +---------+ |
- * | | rgn | |
- * +----------+---------+-------------------------------------------+
- *
- * Expect to drop the lower limit and allocate a memory region that ends at
- * the end of the requested node.
- */
-static int alloc_exact_nid_top_down_numa_no_overlap_split_check(void)
-{
- int nid_req = 2;
- struct memblock_region *new_rgn = &memblock.reserved.regions[0];
- struct memblock_region *req_node = &memblock.memory.regions[nid_req];
- struct memblock_region *node2 = &memblock.memory.regions[6];
- void *allocated_ptr = NULL;
- phys_addr_t size;
- phys_addr_t min_addr;
- phys_addr_t max_addr;
-
- PREFIX_PUSH();
- setup_numa_memblock(node_fractions);
-
- size = SZ_512;
- min_addr = node2->base - SZ_256;
- max_addr = min_addr + size;
-
- allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
- min_addr, max_addr,
- nid_req);
-
- ASSERT_NE(allocated_ptr, NULL);
- ASSERT_MEM_NE(allocated_ptr, 0, size);
-
- ASSERT_EQ(new_rgn->size, size);
- ASSERT_EQ(new_rgn->base, region_end(req_node) - size);
- ASSERT_LE(req_node->base, new_rgn->base);
-
- ASSERT_EQ(memblock.reserved.cnt, 1);
- ASSERT_EQ(memblock.reserved.total_size, size);
-
- test_pass_pop();
-
- return 0;
-}
-
-/*
- * A test that tries to allocate memory within min_addr and max_add range when
- * the requested node and the range do not overlap, and requested node ends
- * before min_addr. The range overlaps with multiple nodes along node
- * boundaries:
- *
- * min_addr
- * | max_addr
- * | |
- * v v
- * |-----------+ +----------+----...----+----------+ |
- * | requested | | min node | ... | max node | |
- * +-----------+-----------+----------+----...----+----------+------+
- * + +
- * | +-----+ |
- * | | rgn | |
- * +-----+-----+----------------------------------------------------+
- *
- * Expect to drop the lower limit and allocate a memory region that ends at
- * the end of the requested node.
- */
-static int alloc_exact_nid_top_down_numa_no_overlap_low_check(void)
-{
- int nid_req = 0;
- struct memblock_region *new_rgn = &memblock.reserved.regions[0];
- struct memblock_region *req_node = &memblock.memory.regions[nid_req];
- struct memblock_region *min_node = &memblock.memory.regions[2];
- struct memblock_region *max_node = &memblock.memory.regions[5];
- void *allocated_ptr = NULL;
- phys_addr_t size = SZ_64;
- phys_addr_t max_addr;
- phys_addr_t min_addr;
-
- PREFIX_PUSH();
- setup_numa_memblock(node_fractions);
-
- min_addr = min_node->base;
- max_addr = region_end(max_node);
-
- allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
- min_addr, max_addr,
- nid_req);
-
- ASSERT_NE(allocated_ptr, NULL);
- ASSERT_MEM_NE(allocated_ptr, 0, size);
-
- ASSERT_EQ(new_rgn->size, size);
- ASSERT_EQ(new_rgn->base, region_end(req_node) - size);
-
- ASSERT_EQ(memblock.reserved.cnt, 1);
- ASSERT_EQ(memblock.reserved.total_size, size);
-
- test_pass_pop();
-
- return 0;
-}
-
/*
* A test that tries to allocate a memory region in a specific NUMA node that
* has enough memory to allocate a region of the requested size.
@@ -311,9 +149,8 @@ static int alloc_exact_nid_bottom_up_numa_simple_check(void)
min_addr = memblock_start_of_DRAM();
max_addr = memblock_end_of_DRAM();
- allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
- min_addr, max_addr,
- nid_req);
+ allocated_ptr = alloc_range_exact_nid(size, SMP_CACHE_BYTES,
+ min_addr, max_addr, nid_req);
ASSERT_NE(allocated_ptr, NULL);
ASSERT_MEM_NE(allocated_ptr, 0, size);
@@ -369,9 +206,8 @@ static int alloc_exact_nid_bottom_up_numa_part_reserved_check(void)
total_size = size + r1.size;
__memblock_reserve(r1.base, r1.size, nid_req, MEMBLOCK_RSRV_KERN);
- allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
- min_addr, max_addr,
- nid_req);
+ allocated_ptr = alloc_range_exact_nid(size, SMP_CACHE_BYTES,
+ min_addr, max_addr, nid_req);
ASSERT_NE(allocated_ptr, NULL);
ASSERT_MEM_NE(allocated_ptr, 0, size);
@@ -388,178 +224,6 @@ static int alloc_exact_nid_bottom_up_numa_part_reserved_check(void)
return 0;
}
-/*
- * A test that tries to allocate a memory region that spans over the min_addr
- * and max_addr range and overlaps with two different nodes, where the first
- * node is the requested node:
- *
- * min_addr
- * | max_addr
- * | |
- * v v
- * | +-----------------------+-----------+ |
- * | | requested | node3 | |
- * +-----------+-----------------------+-----------+--------------+
- * + +
- * | +-----------+ |
- * | | rgn | |
- * +-----------+-----------+--------------------------------------+
- *
- * Expect to drop the lower limit and allocate a memory region at the beginning
- * of the requested node.
- */
-static int alloc_exact_nid_bottom_up_numa_split_range_low_check(void)
-{
- int nid_req = 2;
- struct memblock_region *new_rgn = &memblock.reserved.regions[0];
- struct memblock_region *req_node = &memblock.memory.regions[nid_req];
- void *allocated_ptr = NULL;
- phys_addr_t size = SZ_512;
- phys_addr_t min_addr;
- phys_addr_t max_addr;
- phys_addr_t req_node_end;
-
- PREFIX_PUSH();
- setup_numa_memblock(node_fractions);
-
- req_node_end = region_end(req_node);
- min_addr = req_node_end - SZ_256;
- max_addr = min_addr + size;
-
- allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
- min_addr, max_addr,
- nid_req);
-
- ASSERT_NE(allocated_ptr, NULL);
- ASSERT_MEM_NE(allocated_ptr, 0, size);
-
- ASSERT_EQ(new_rgn->size, size);
- ASSERT_EQ(new_rgn->base, req_node->base);
- ASSERT_LE(region_end(new_rgn), req_node_end);
-
- ASSERT_EQ(memblock.reserved.cnt, 1);
- ASSERT_EQ(memblock.reserved.total_size, size);
-
- test_pass_pop();
-
- return 0;
-}
-
-/*
- * A test that tries to allocate a memory region that spans over the min_addr
- * and max_addr range and overlaps with two different nodes, where the requested
- * node ends before min_addr:
- *
- * min_addr
- * | max_addr
- * | |
- * v v
- * | +---------------+ +-------------+---------+ |
- * | | requested | | node1 | node2 | |
- * +----+---------------+--------+-------------+---------+---------+
- * + +
- * | +---------+ |
- * | | rgn | |
- * +----+---------+------------------------------------------------+
- *
- * Expect to drop the lower limit and allocate a memory region that starts at
- * the beginning of the requested node.
- */
-static int alloc_exact_nid_bottom_up_numa_no_overlap_split_check(void)
-{
- int nid_req = 2;
- struct memblock_region *new_rgn = &memblock.reserved.regions[0];
- struct memblock_region *req_node = &memblock.memory.regions[nid_req];
- struct memblock_region *node2 = &memblock.memory.regions[6];
- void *allocated_ptr = NULL;
- phys_addr_t size;
- phys_addr_t min_addr;
- phys_addr_t max_addr;
-
- PREFIX_PUSH();
- setup_numa_memblock(node_fractions);
-
- size = SZ_512;
- min_addr = node2->base - SZ_256;
- max_addr = min_addr + size;
-
- allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
- min_addr, max_addr,
- nid_req);
-
- ASSERT_NE(allocated_ptr, NULL);
- ASSERT_MEM_NE(allocated_ptr, 0, size);
-
- ASSERT_EQ(new_rgn->size, size);
- ASSERT_EQ(new_rgn->base, req_node->base);
- ASSERT_LE(region_end(new_rgn), region_end(req_node));
-
- ASSERT_EQ(memblock.reserved.cnt, 1);
- ASSERT_EQ(memblock.reserved.total_size, size);
-
- test_pass_pop();
-
- return 0;
-}
-
-/*
- * A test that tries to allocate memory within min_addr and max_add range when
- * the requested node and the range do not overlap, and requested node ends
- * before min_addr. The range overlaps with multiple nodes along node
- * boundaries:
- *
- * min_addr
- * | max_addr
- * | |
- * v v
- * |-----------+ +----------+----...----+----------+ |
- * | requested | | min node | ... | max node | |
- * +-----------+-----------+----------+----...----+----------+------+
- * + +
- * |-----+ |
- * | rgn | |
- * +-----+----------------------------------------------------------+
- *
- * Expect to drop the lower limit and allocate a memory region that starts at
- * the beginning of the requested node.
- */
-static int alloc_exact_nid_bottom_up_numa_no_overlap_low_check(void)
-{
- int nid_req = 0;
- struct memblock_region *new_rgn = &memblock.reserved.regions[0];
- struct memblock_region *req_node = &memblock.memory.regions[nid_req];
- struct memblock_region *min_node = &memblock.memory.regions[2];
- struct memblock_region *max_node = &memblock.memory.regions[5];
- void *allocated_ptr = NULL;
- phys_addr_t size = SZ_64;
- phys_addr_t max_addr;
- phys_addr_t min_addr;
-
- PREFIX_PUSH();
- setup_numa_memblock(node_fractions);
-
- min_addr = min_node->base;
- max_addr = region_end(max_node);
-
- allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
- min_addr, max_addr,
- nid_req);
-
- ASSERT_NE(allocated_ptr, NULL);
- ASSERT_MEM_NE(allocated_ptr, 0, size);
-
- ASSERT_EQ(new_rgn->size, size);
- ASSERT_EQ(new_rgn->base, req_node->base);
- ASSERT_LE(region_end(new_rgn), region_end(req_node));
-
- ASSERT_EQ(memblock.reserved.cnt, 1);
- ASSERT_EQ(memblock.reserved.total_size, size);
-
- test_pass_pop();
-
- return 0;
-}
-
/*
* A test that tries to allocate a memory region in a specific NUMA node that
* does not have enough memory to allocate a region of the requested size:
@@ -590,9 +254,8 @@ static int alloc_exact_nid_numa_small_node_generic_check(void)
min_addr = memblock_start_of_DRAM();
max_addr = memblock_end_of_DRAM();
- allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
- min_addr, max_addr,
- nid_req);
+ allocated_ptr = alloc_range_exact_nid(size, SMP_CACHE_BYTES,
+ min_addr, max_addr, nid_req);
ASSERT_EQ(allocated_ptr, NULL);
@@ -632,9 +295,8 @@ static int alloc_exact_nid_numa_node_reserved_generic_check(void)
max_addr = memblock_end_of_DRAM();
memblock_reserve(req_node->base, req_node->size);
- allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
- min_addr, max_addr,
- nid_req);
+ allocated_ptr = alloc_range_exact_nid(size, SMP_CACHE_BYTES,
+ min_addr, max_addr, nid_req);
ASSERT_EQ(allocated_ptr, NULL);
@@ -680,9 +342,8 @@ static int alloc_exact_nid_numa_part_reserved_fail_generic_check(void)
max_addr = memblock_end_of_DRAM();
memblock_reserve(r1.base, r1.size);
- allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
- min_addr, max_addr,
- nid_req);
+ allocated_ptr = alloc_range_exact_nid(size, SMP_CACHE_BYTES,
+ min_addr, max_addr, nid_req);
ASSERT_EQ(allocated_ptr, NULL);
@@ -721,9 +382,8 @@ static int alloc_exact_nid_numa_split_range_high_generic_check(void)
min_addr = req_node->base - SZ_256;
max_addr = min_addr + size;
- allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
- min_addr, max_addr,
- nid_req);
+ allocated_ptr = alloc_range_exact_nid(size, SMP_CACHE_BYTES,
+ min_addr, max_addr, nid_req);
ASSERT_EQ(allocated_ptr, NULL);
@@ -764,9 +424,8 @@ static int alloc_exact_nid_numa_no_overlap_high_generic_check(void)
min_addr = min_node->base;
max_addr = region_end(max_node);
- allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
- min_addr, max_addr,
- nid_req);
+ allocated_ptr = alloc_range_exact_nid(size, SMP_CACHE_BYTES,
+ min_addr, max_addr, nid_req);
ASSERT_EQ(allocated_ptr, NULL);
@@ -803,9 +462,8 @@ static int alloc_exact_nid_numa_large_region_generic_check(void)
min_addr = memblock_start_of_DRAM();
max_addr = memblock_end_of_DRAM();
- allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
- min_addr, max_addr,
- nid_req);
+ allocated_ptr = alloc_range_exact_nid(size, SMP_CACHE_BYTES,
+ min_addr, max_addr, nid_req);
ASSERT_EQ(allocated_ptr, NULL);
test_pass_pop();
@@ -864,9 +522,8 @@ static int alloc_exact_nid_numa_reserved_full_merge_generic_check(void)
__memblock_reserve(r1.base, r1.size, nid_req, MEMBLOCK_RSRV_KERN);
__memblock_reserve(r2.base, r2.size, nid_req, MEMBLOCK_RSRV_KERN);
- allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
- min_addr, max_addr,
- nid_req);
+ allocated_ptr = alloc_range_exact_nid(size, SMP_CACHE_BYTES,
+ min_addr, max_addr, nid_req);
ASSERT_NE(allocated_ptr, NULL);
ASSERT_MEM_NE(allocated_ptr, 0, size);
@@ -933,9 +590,8 @@ static int alloc_exact_nid_numa_split_all_reserved_generic_check(void)
memblock_reserve(r1.base, r1.size);
memblock_reserve(r2.base, r2.size);
- allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
- min_addr, max_addr,
- NUMA_NO_NODE);
+ allocated_ptr = alloc_range_exact_nid(size, SMP_CACHE_BYTES,
+ min_addr, max_addr, NUMA_NO_NODE);
ASSERT_EQ(allocated_ptr, NULL);
@@ -967,38 +623,6 @@ static int alloc_exact_nid_numa_part_reserved_check(void)
return 0;
}
-static int alloc_exact_nid_numa_split_range_low_check(void)
-{
- test_print("\tRunning %s...\n", __func__);
- memblock_set_bottom_up(false);
- alloc_exact_nid_top_down_numa_split_range_low_check();
- memblock_set_bottom_up(true);
- alloc_exact_nid_bottom_up_numa_split_range_low_check();
-
- return 0;
-}
-
-static int alloc_exact_nid_numa_no_overlap_split_check(void)
-{
- test_print("\tRunning %s...\n", __func__);
- memblock_set_bottom_up(false);
- alloc_exact_nid_top_down_numa_no_overlap_split_check();
- memblock_set_bottom_up(true);
- alloc_exact_nid_bottom_up_numa_no_overlap_split_check();
-
- return 0;
-}
-
-static int alloc_exact_nid_numa_no_overlap_low_check(void)
-{
- test_print("\tRunning %s...\n", __func__);
- memblock_set_bottom_up(false);
- alloc_exact_nid_top_down_numa_no_overlap_low_check();
- memblock_set_bottom_up(true);
- alloc_exact_nid_bottom_up_numa_no_overlap_low_check();
-
- return 0;
-}
static int alloc_exact_nid_numa_small_node_check(void)
{
@@ -1078,9 +702,6 @@ int __memblock_alloc_exact_nid_numa_checks(void)
alloc_exact_nid_numa_simple_check();
alloc_exact_nid_numa_part_reserved_check();
- alloc_exact_nid_numa_split_range_low_check();
- alloc_exact_nid_numa_no_overlap_split_check();
- alloc_exact_nid_numa_no_overlap_low_check();
alloc_exact_nid_numa_small_node_check();
alloc_exact_nid_numa_node_reserved_check();
@@ -1102,7 +723,6 @@ int memblock_alloc_exact_nid_checks(void)
reset_memblock_attributes();
dummy_physical_memory_init();
- memblock_alloc_exact_nid_range_checks();
memblock_alloc_exact_nid_numa_checks();
dummy_physical_memory_cleanup();
diff --git a/tools/testing/memblock/tests/alloc_nid_api.c b/tools/testing/memblock/tests/alloc_nid_api.c
index c04923532159..3dd4c0bebc41 100644
--- a/tools/testing/memblock/tests/alloc_nid_api.c
+++ b/tools/testing/memblock/tests/alloc_nid_api.c
@@ -20,8 +20,6 @@ static const unsigned int node_fractions[] = {
static inline const char * const get_memblock_alloc_nid_name(int flags)
{
- if (flags & TEST_F_EXACT)
- return "memblock_alloc_exact_nid_raw";
if (flags & TEST_F_RAW)
return "memblock_alloc_try_nid_raw";
return "memblock_alloc_try_nid";
@@ -32,15 +30,6 @@ static inline void *run_memblock_alloc_nid(phys_addr_t size,
phys_addr_t min_addr,
phys_addr_t max_addr, int nid)
{
- assert(!(alloc_nid_test_flags & TEST_F_EXACT) ||
- (alloc_nid_test_flags & TEST_F_RAW));
- /*
- * TEST_F_EXACT should be checked before TEST_F_RAW since
- * memblock_alloc_exact_nid_raw() performs raw allocations.
- */
- if (alloc_nid_test_flags & TEST_F_EXACT)
- return memblock_alloc_exact_nid_raw(size, align, min_addr,
- max_addr, nid);
if (alloc_nid_test_flags & TEST_F_RAW)
return memblock_alloc_try_nid_raw(size, align, min_addr,
max_addr, nid);
@@ -2722,12 +2711,3 @@ int memblock_alloc_nid_checks(void)
return 0;
}
-
-int memblock_alloc_exact_nid_range_checks(void)
-{
- alloc_nid_test_flags = (TEST_F_RAW | TEST_F_EXACT);
-
- memblock_alloc_nid_range_checks();
-
- return 0;
-}
diff --git a/tools/testing/memblock/tests/alloc_nid_api.h b/tools/testing/memblock/tests/alloc_nid_api.h
index 2b8cabacacb8..92d07d230e18 100644
--- a/tools/testing/memblock/tests/alloc_nid_api.h
+++ b/tools/testing/memblock/tests/alloc_nid_api.h
@@ -5,7 +5,6 @@
#include "common.h"
int memblock_alloc_nid_checks(void);
-int memblock_alloc_exact_nid_range_checks(void);
int __memblock_alloc_nid_numa_checks(void);
#ifdef CONFIG_NUMA
diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h
index e1138e06c903..c3cca972dcca 100644
--- a/tools/testing/memblock/tests/common.h
+++ b/tools/testing/memblock/tests/common.h
@@ -23,8 +23,6 @@ enum test_flags {
TEST_F_NONE = 0x0,
/* Perform raw allocations (no zeroing of memory). */
TEST_F_RAW = 0x1,
- /* Perform allocations on the exact node specified. */
- TEST_F_EXACT = 0x2
};
/**
--
2.54.0 (Apple Git-157)
next prev parent reply other threads:[~2026-09-17 8:15 UTC|newest]
Thread overview: 4+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-09-17 8:15 [PATCH 0/2] memblock: Remove unused exact nid allocation API Kaitao Cheng
2026-09-17 8:15 ` Kaitao Cheng [this message]
2026-09-17 8:15 ` [PATCH 2/2] memblock: Remove unused memblock_alloc_exact_nid_raw() Kaitao Cheng
2026-09-17 9:44 ` [PATCH 0/2] memblock: Remove unused exact nid allocation API Mike Rapoport
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20260917081504.30426-2-kaitao.cheng@linux.dev \
--to=kaitao.cheng@linux.dev \
--cc=akpm@linux-foundation.org \
--cc=chengkaitao@kylinos.cn \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-mm@kvack.org \
--cc=ljs@kernel.org \
--cc=muchun.song@linux.dev \
--cc=priyanshukumarpu@gmail.com \
--cc=rppt@kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®