| Message ID | 20220913064138.407601-2-shaoqin.huang@intel.com (mailing list archive) |
|---|---|
| State | New |
| Headers | show |
| Series | Add tests trying to memblock_add() or memblock_reserve() 129th region | expand |
On Tue, Sep 13, 2022 at 02:41:30PM +0800, shaoqin.huang@intel.com wrote: > From: Shaoqin Huang <shaoqin.huang@intel.com> > > Add 129th region into the memblock, and this will trigger the > memblock_double_array() function, this needs valid memory regions. So > using dummy_physical_memory_init() to allocate a large enough memory > region, and split it into a large enough memory which can be choosed by > memblock_double_array(), and the left memory will be split into small > memory region, and add them into the memblock. It make sure the > memblock_double_array() will always choose the valid memory region that > is allocated by the dummy_physical_memory_init(). > So memblock_double_array() must success. > > Another thing should be done is to restore the memory.regions after > memblock_double_array(), due to now the memory.regions is pointing to a > memory region allocated by dummy_physical_memory_init(). And it will > affect the subsequent tests if we don't restore the memory region. So > simply record the origin region, and restore it after the test. > > Signed-off-by: Shaoqin Huang <shaoqin.huang@intel.com> > --- > tools/testing/memblock/tests/basic_api.c | 96 ++++++++++++++++++++++++ > tools/testing/memblock/tests/common.c | 7 +- > tools/testing/memblock/tests/common.h | 3 + > 3 files changed, 104 insertions(+), 2 deletions(-) > > diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c > index a13a57ba0815..7120fd8e47b1 100644 > --- a/tools/testing/memblock/tests/basic_api.c > +++ b/tools/testing/memblock/tests/basic_api.c > @@ -423,6 +423,101 @@ static int memblock_add_near_max_check(void) > return 0; > } > > +/* > + * A test that trying to add the 129th memory block. > + * Expect to trigger memblock_double_array() to double the > + * memblock.memory.max, find a new valid memory as > + * memory.regions. > + */ > +static int memblock_add_many_check(void) > +{ > + int i; > + void *orig_region; > + struct region r = { > + .base = SZ_16K, > + .size = MEM_SIZE, > + }; > + phys_addr_t new_memory_regions_size; > + phys_addr_t base, size, block_size; > + > + PREFIX_PUSH(); > + > + reset_memblock_regions(); > + memblock_allow_resize(); > + > + dummy_physical_memory_init(); > + /* > + * We allocated enough memory by using dummy_physical_memory_init(), and > + * split it into small block. First we split a large enough memory block > + * as the memory region which will be choosed by memblock_double_array(). > + */ > + base = PAGE_ALIGN(dummy_physical_memory_base()); > + new_memory_regions_size = PAGE_ALIGN(INIT_MEMBLOCK_REGIONS * 2 * > + sizeof(struct memblock_region)); > + memblock_add(base, new_memory_regions_size); Why don't you simply increase MEM_SIZE, to say 1M? This will make all the calculations here way simpler. > + > + /* > + * For the left memory, we split them into small block and add them into > + * memblock later. > + */ > + base += new_memory_regions_size; > + size = MEM_SIZE - new_memory_regions_size; > + block_size = size / (INIT_MEMBLOCK_REGIONS * 2); > + > + orig_region = memblock.memory.regions; > + > + for (i = 0; i < INIT_MEMBLOCK_REGIONS; i++) { > + /* > + * Add these small block to fulfill the memblock. We keep an > + * interval between the nearby memory to avoid being merged. > + */ > + memblock_add(base + block_size * (2 * i + 1), block_size); > + > + ASSERT_EQ(memblock.memory.cnt, i + 2); > + ASSERT_EQ(memblock.memory.total_size, new_memory_regions_size + > + (i + 1) * block_size); > + } > + > + /* > + * At there, memblock_double_array() has been succeed, check if it > + * update the memory.max. > + */ > + ASSERT_EQ(memblock.memory.max, INIT_MEMBLOCK_REGIONS * 2); > + > + /* memblock_double_array() will reserve the memory it used. Check it. */ > + ASSERT_EQ(memblock.reserved.cnt, 1); > + ASSERT_EQ(memblock.reserved.total_size, new_memory_regions_size); > + > + /* > + * Now memblock_double_array() works fine. Let's check after the > + * double_array(), the memblock_add() still works as normal. > + */ > + memblock_add(r.base, r.size); > + ASSERT_EQ(memblock.memory.regions[0].base, r.base); > + ASSERT_EQ(memblock.memory.regions[0].size, r.size); > + > + ASSERT_EQ(memblock.memory.cnt, INIT_MEMBLOCK_REGIONS + 2); > + ASSERT_EQ(memblock.memory.total_size, INIT_MEMBLOCK_REGIONS * block_size + > + new_memory_regions_size + > + MEM_SIZE); > + ASSERT_EQ(memblock.memory.max, INIT_MEMBLOCK_REGIONS * 2); > + > + dummy_physical_memory_cleanup(); > + > + /* > + * The current memory.regions is occupying a range of memory that > + * allocated from dummy_physical_memory_init(). After free the memory, > + * we must not use it. So restore the origin memory region to make sure > + * the tests can run as normal and not affected by the double array. > + */ > + memblock.memory.regions = orig_region; > + memblock.memory.cnt = INIT_MEMBLOCK_REGIONS; > + > + test_pass_pop(); > + > + return 0; > +} > + > static int memblock_add_checks(void) > { > prefix_reset(); > @@ -438,6 +533,7 @@ static int memblock_add_checks(void) > memblock_add_twice_check(); > memblock_add_between_check(); > memblock_add_near_max_check(); > + memblock_add_many_check(); > > prefix_pop(); > > diff --git a/tools/testing/memblock/tests/common.c b/tools/testing/memblock/tests/common.c > index eec6901081af..2de6a2b6efd2 100644 > --- a/tools/testing/memblock/tests/common.c > +++ b/tools/testing/memblock/tests/common.c > @@ -5,8 +5,6 @@ > #include <linux/memory_hotplug.h> > #include <linux/build_bug.h> > > -#define INIT_MEMBLOCK_REGIONS 128 > -#define INIT_MEMBLOCK_RESERVED_REGIONS INIT_MEMBLOCK_REGIONS > #define PREFIXES_MAX 15 > #define DELIM ": " > > @@ -84,6 +82,11 @@ void dummy_physical_memory_cleanup(void) > free(memory_block.base); > } > > +phys_addr_t dummy_physical_memory_base(void) > +{ > + return (phys_addr_t)memory_block.base; > +} > + > static void usage(const char *prog) > { > BUILD_BUG_ON(ARRAY_SIZE(help_opts) != ARRAY_SIZE(long_opts) - 1); > diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h > index 78128e109a95..ba14dc989ae9 100644 > --- a/tools/testing/memblock/tests/common.h > +++ b/tools/testing/memblock/tests/common.h > @@ -11,6 +11,8 @@ > #include <../selftests/kselftest.h> > > #define MEM_SIZE SZ_16K > +#define INIT_MEMBLOCK_REGIONS 128 > +#define INIT_MEMBLOCK_RESERVED_REGIONS INIT_MEMBLOCK_REGIONS > > enum test_flags { > /* No special request. */ > @@ -104,6 +106,7 @@ void reset_memblock_attributes(void); > void setup_memblock(void); > void dummy_physical_memory_init(void); > void dummy_physical_memory_cleanup(void); > +phys_addr_t dummy_physical_memory_base(void); > void parse_args(int argc, char **argv); > > void test_fail(void); > -- > 2.34.1 > >
On 9/18/2022 5:25 PM, Mike Rapoport wrote: > On Tue, Sep 13, 2022 at 02:41:30PM +0800, shaoqin.huang@intel.com wrote: >> From: Shaoqin Huang <shaoqin.huang@intel.com> >> >> Add 129th region into the memblock, and this will trigger the >> memblock_double_array() function, this needs valid memory regions. So >> using dummy_physical_memory_init() to allocate a large enough memory >> region, and split it into a large enough memory which can be choosed by >> memblock_double_array(), and the left memory will be split into small >> memory region, and add them into the memblock. It make sure the >> memblock_double_array() will always choose the valid memory region that >> is allocated by the dummy_physical_memory_init(). >> So memblock_double_array() must success. >> >> Another thing should be done is to restore the memory.regions after >> memblock_double_array(), due to now the memory.regions is pointing to a >> memory region allocated by dummy_physical_memory_init(). And it will >> affect the subsequent tests if we don't restore the memory region. So >> simply record the origin region, and restore it after the test. >> >> Signed-off-by: Shaoqin Huang <shaoqin.huang@intel.com> >> --- >> tools/testing/memblock/tests/basic_api.c | 96 ++++++++++++++++++++++++ >> tools/testing/memblock/tests/common.c | 7 +- >> tools/testing/memblock/tests/common.h | 3 + >> 3 files changed, 104 insertions(+), 2 deletions(-) >> >> diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c >> index a13a57ba0815..7120fd8e47b1 100644 >> --- a/tools/testing/memblock/tests/basic_api.c >> +++ b/tools/testing/memblock/tests/basic_api.c >> @@ -423,6 +423,101 @@ static int memblock_add_near_max_check(void) >> return 0; >> } >> >> +/* >> + * A test that trying to add the 129th memory block. >> + * Expect to trigger memblock_double_array() to double the >> + * memblock.memory.max, find a new valid memory as >> + * memory.regions. >> + */ >> +static int memblock_add_many_check(void) >> +{ >> + int i; >> + void *orig_region; >> + struct region r = { >> + .base = SZ_16K, >> + .size = MEM_SIZE, >> + }; >> + phys_addr_t new_memory_regions_size; >> + phys_addr_t base, size, block_size; >> + >> + PREFIX_PUSH(); >> + >> + reset_memblock_regions(); >> + memblock_allow_resize(); >> + >> + dummy_physical_memory_init(); >> + /* >> + * We allocated enough memory by using dummy_physical_memory_init(), and >> + * split it into small block. First we split a large enough memory block >> + * as the memory region which will be choosed by memblock_double_array(). >> + */ >> + base = PAGE_ALIGN(dummy_physical_memory_base()); >> + new_memory_regions_size = PAGE_ALIGN(INIT_MEMBLOCK_REGIONS * 2 * >> + sizeof(struct memblock_region)); >> + memblock_add(base, new_memory_regions_size); > > Why don't you simply increase MEM_SIZE, to say 1M? > This will make all the calculations here way simpler. > Ok. I will increase MEM_SIZE. That can clean the calculation. >> + >> + /* >> + * For the left memory, we split them into small block and add them into >> + * memblock later. >> + */ >> + base += new_memory_regions_size; >> + size = MEM_SIZE - new_memory_regions_size; >> + block_size = size / (INIT_MEMBLOCK_REGIONS * 2); >> + >> + orig_region = memblock.memory.regions; >> + >> + for (i = 0; i < INIT_MEMBLOCK_REGIONS; i++) { >> + /* >> + * Add these small block to fulfill the memblock. We keep an >> + * interval between the nearby memory to avoid being merged. >> + */ >> + memblock_add(base + block_size * (2 * i + 1), block_size); >> + >> + ASSERT_EQ(memblock.memory.cnt, i + 2); >> + ASSERT_EQ(memblock.memory.total_size, new_memory_regions_size + >> + (i + 1) * block_size); >> + } >> + >> + /* >> + * At there, memblock_double_array() has been succeed, check if it >> + * update the memory.max. >> + */ >> + ASSERT_EQ(memblock.memory.max, INIT_MEMBLOCK_REGIONS * 2); >> + >> + /* memblock_double_array() will reserve the memory it used. Check it. */ >> + ASSERT_EQ(memblock.reserved.cnt, 1); >> + ASSERT_EQ(memblock.reserved.total_size, new_memory_regions_size); >> + >> + /* >> + * Now memblock_double_array() works fine. Let's check after the >> + * double_array(), the memblock_add() still works as normal. >> + */ >> + memblock_add(r.base, r.size); >> + ASSERT_EQ(memblock.memory.regions[0].base, r.base); >> + ASSERT_EQ(memblock.memory.regions[0].size, r.size); >> + >> + ASSERT_EQ(memblock.memory.cnt, INIT_MEMBLOCK_REGIONS + 2); >> + ASSERT_EQ(memblock.memory.total_size, INIT_MEMBLOCK_REGIONS * block_size + >> + new_memory_regions_size + >> + MEM_SIZE); >> + ASSERT_EQ(memblock.memory.max, INIT_MEMBLOCK_REGIONS * 2); >> + >> + dummy_physical_memory_cleanup(); >> + >> + /* >> + * The current memory.regions is occupying a range of memory that >> + * allocated from dummy_physical_memory_init(). After free the memory, >> + * we must not use it. So restore the origin memory region to make sure >> + * the tests can run as normal and not affected by the double array. >> + */ >> + memblock.memory.regions = orig_region; >> + memblock.memory.cnt = INIT_MEMBLOCK_REGIONS; >> + >> + test_pass_pop(); >> + >> + return 0; >> +} >> + >> static int memblock_add_checks(void) >> { >> prefix_reset(); >> @@ -438,6 +533,7 @@ static int memblock_add_checks(void) >> memblock_add_twice_check(); >> memblock_add_between_check(); >> memblock_add_near_max_check(); >> + memblock_add_many_check(); >> >> prefix_pop(); >> >> diff --git a/tools/testing/memblock/tests/common.c b/tools/testing/memblock/tests/common.c >> index eec6901081af..2de6a2b6efd2 100644 >> --- a/tools/testing/memblock/tests/common.c >> +++ b/tools/testing/memblock/tests/common.c >> @@ -5,8 +5,6 @@ >> #include <linux/memory_hotplug.h> >> #include <linux/build_bug.h> >> >> -#define INIT_MEMBLOCK_REGIONS 128 >> -#define INIT_MEMBLOCK_RESERVED_REGIONS INIT_MEMBLOCK_REGIONS >> #define PREFIXES_MAX 15 >> #define DELIM ": " >> >> @@ -84,6 +82,11 @@ void dummy_physical_memory_cleanup(void) >> free(memory_block.base); >> } >> >> +phys_addr_t dummy_physical_memory_base(void) >> +{ >> + return (phys_addr_t)memory_block.base; >> +} >> + >> static void usage(const char *prog) >> { >> BUILD_BUG_ON(ARRAY_SIZE(help_opts) != ARRAY_SIZE(long_opts) - 1); >> diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h >> index 78128e109a95..ba14dc989ae9 100644 >> --- a/tools/testing/memblock/tests/common.h >> +++ b/tools/testing/memblock/tests/common.h >> @@ -11,6 +11,8 @@ >> #include <../selftests/kselftest.h> >> >> #define MEM_SIZE SZ_16K >> +#define INIT_MEMBLOCK_REGIONS 128 >> +#define INIT_MEMBLOCK_RESERVED_REGIONS INIT_MEMBLOCK_REGIONS >> >> enum test_flags { >> /* No special request. */ >> @@ -104,6 +106,7 @@ void reset_memblock_attributes(void); >> void setup_memblock(void); >> void dummy_physical_memory_init(void); >> void dummy_physical_memory_cleanup(void); >> +phys_addr_t dummy_physical_memory_base(void); >> void parse_args(int argc, char **argv); >> >> void test_fail(void); >> -- >> 2.34.1 >> >> >
diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c index a13a57ba0815..7120fd8e47b1 100644 --- a/tools/testing/memblock/tests/basic_api.c +++ b/tools/testing/memblock/tests/basic_api.c @@ -423,6 +423,101 @@ static int memblock_add_near_max_check(void) return 0; } +/* + * A test that trying to add the 129th memory block. + * Expect to trigger memblock_double_array() to double the + * memblock.memory.max, find a new valid memory as + * memory.regions. + */ +static int memblock_add_many_check(void) +{ + int i; + void *orig_region; + struct region r = { + .base = SZ_16K, + .size = MEM_SIZE, + }; + phys_addr_t new_memory_regions_size; + phys_addr_t base, size, block_size; + + PREFIX_PUSH(); + + reset_memblock_regions(); + memblock_allow_resize(); + + dummy_physical_memory_init(); + /* + * We allocated enough memory by using dummy_physical_memory_init(), and + * split it into small block. First we split a large enough memory block + * as the memory region which will be choosed by memblock_double_array(). + */ + base = PAGE_ALIGN(dummy_physical_memory_base()); + new_memory_regions_size = PAGE_ALIGN(INIT_MEMBLOCK_REGIONS * 2 * + sizeof(struct memblock_region)); + memblock_add(base, new_memory_regions_size); + + /* + * For the left memory, we split them into small block and add them into + * memblock later. + */ + base += new_memory_regions_size; + size = MEM_SIZE - new_memory_regions_size; + block_size = size / (INIT_MEMBLOCK_REGIONS * 2); + + orig_region = memblock.memory.regions; + + for (i = 0; i < INIT_MEMBLOCK_REGIONS; i++) { + /* + * Add these small block to fulfill the memblock. We keep an + * interval between the nearby memory to avoid being merged. + */ + memblock_add(base + block_size * (2 * i + 1), block_size); + + ASSERT_EQ(memblock.memory.cnt, i + 2); + ASSERT_EQ(memblock.memory.total_size, new_memory_regions_size + + (i + 1) * block_size); + } + + /* + * At there, memblock_double_array() has been succeed, check if it + * update the memory.max. + */ + ASSERT_EQ(memblock.memory.max, INIT_MEMBLOCK_REGIONS * 2); + + /* memblock_double_array() will reserve the memory it used. Check it. */ + ASSERT_EQ(memblock.reserved.cnt, 1); + ASSERT_EQ(memblock.reserved.total_size, new_memory_regions_size); + + /* + * Now memblock_double_array() works fine. Let's check after the + * double_array(), the memblock_add() still works as normal. + */ + memblock_add(r.base, r.size); + ASSERT_EQ(memblock.memory.regions[0].base, r.base); + ASSERT_EQ(memblock.memory.regions[0].size, r.size); + + ASSERT_EQ(memblock.memory.cnt, INIT_MEMBLOCK_REGIONS + 2); + ASSERT_EQ(memblock.memory.total_size, INIT_MEMBLOCK_REGIONS * block_size + + new_memory_regions_size + + MEM_SIZE); + ASSERT_EQ(memblock.memory.max, INIT_MEMBLOCK_REGIONS * 2); + + dummy_physical_memory_cleanup(); + + /* + * The current memory.regions is occupying a range of memory that + * allocated from dummy_physical_memory_init(). After free the memory, + * we must not use it. So restore the origin memory region to make sure + * the tests can run as normal and not affected by the double array. + */ + memblock.memory.regions = orig_region; + memblock.memory.cnt = INIT_MEMBLOCK_REGIONS; + + test_pass_pop(); + + return 0; +} + static int memblock_add_checks(void) { prefix_reset(); @@ -438,6 +533,7 @@ static int memblock_add_checks(void) memblock_add_twice_check(); memblock_add_between_check(); memblock_add_near_max_check(); + memblock_add_many_check(); prefix_pop(); diff --git a/tools/testing/memblock/tests/common.c b/tools/testing/memblock/tests/common.c index eec6901081af..2de6a2b6efd2 100644 --- a/tools/testing/memblock/tests/common.c +++ b/tools/testing/memblock/tests/common.c @@ -5,8 +5,6 @@ #include <linux/memory_hotplug.h> #include <linux/build_bug.h> -#define INIT_MEMBLOCK_REGIONS 128 -#define INIT_MEMBLOCK_RESERVED_REGIONS INIT_MEMBLOCK_REGIONS #define PREFIXES_MAX 15 #define DELIM ": " @@ -84,6 +82,11 @@ void dummy_physical_memory_cleanup(void) free(memory_block.base); } +phys_addr_t dummy_physical_memory_base(void) +{ + return (phys_addr_t)memory_block.base; +} + static void usage(const char *prog) { BUILD_BUG_ON(ARRAY_SIZE(help_opts) != ARRAY_SIZE(long_opts) - 1); diff --git a/tools/testing/memblock/tests/common.h b/tools/testing/memblock/tests/common.h index 78128e109a95..ba14dc989ae9 100644 --- a/tools/testing/memblock/tests/common.h +++ b/tools/testing/memblock/tests/common.h @@ -11,6 +11,8 @@ #include <../selftests/kselftest.h> #define MEM_SIZE SZ_16K +#define INIT_MEMBLOCK_REGIONS 128 +#define INIT_MEMBLOCK_RESERVED_REGIONS INIT_MEMBLOCK_REGIONS enum test_flags { /* No special request. */ @@ -104,6 +106,7 @@ void reset_memblock_attributes(void); void setup_memblock(void); void dummy_physical_memory_init(void); void dummy_physical_memory_cleanup(void); +phys_addr_t dummy_physical_memory_base(void); void parse_args(int argc, char **argv); void test_fail(void);