On Sat, 8 Jun 2024 at 10:09, Heinrich Schuchardt <xypron.g...@gmx.de> wrote:
>
> On 6/7/24 20:52, Sughosh Ganu wrote:
> > The LMB code has been changed so that the memory reservations and
> > allocations are now persistent and global. With this change, the
> > design of the LMB tests needs to be changed accordingly. For now, mark
> > the LMB tests to be run only manually. The tests won't be run as part
> > of the unit test suite, and thus would not interfere with the running
> > of the rest of the tests.
>
> We should run important tests in the CI.
>
> You could trigger the 'manual' test from a Python test and reboot the
> system to get into an initial state.
Yes, that is one of the solutions that I have in mind. Will work on
this for the next version. Thanks.
-sughosh
>
> Best regards
>
> Heinrich
>
> >
> > Signed-off-by: Sughosh Ganu <sughosh.g...@linaro.org>
> > ---
> > test/lib/lmb.c | 49 ++++++++++++++++++++++++-------------------------
> > 1 file changed, 24 insertions(+), 25 deletions(-)
> >
> > diff --git a/test/lib/lmb.c b/test/lib/lmb.c
> > index 67a6be5bc3..813f7e3100 100644
> > --- a/test/lib/lmb.c
> > +++ b/test/lib/lmb.c
> > @@ -195,7 +195,7 @@ static int test_multi_alloc_512mb_x2(struct
> > unit_test_state *uts,
> > }
> >
> > /* Create a memory region with one reserved region and allocate */
> > -static int lib_test_lmb_simple(struct unit_test_state *uts)
> > +static int lib_test_lmb_simple_norun(struct unit_test_state *uts)
> > {
> > int ret;
> >
> > @@ -207,10 +207,10 @@ static int lib_test_lmb_simple(struct unit_test_state
> > *uts)
> > /* simulate 512 MiB RAM beginning at 1.5GiB */
> > return test_multi_alloc_512mb(uts, 0xE0000000);
> > }
> > -LIB_TEST(lib_test_lmb_simple, 0);
> > +LIB_TEST(lib_test_lmb_simple_norun, UT_TESTF_MANUAL);
> >
> > /* Create two memory regions with one reserved region and allocate */
> > -static int lib_test_lmb_simple_x2(struct unit_test_state *uts)
> > +static int lib_test_lmb_simple_x2_norun(struct unit_test_state *uts)
> > {
> > int ret;
> >
> > @@ -222,7 +222,7 @@ static int lib_test_lmb_simple_x2(struct
> > unit_test_state *uts)
> > /* simulate 512 MiB RAM beginning at 3.5GiB and 1 GiB */
> > return test_multi_alloc_512mb_x2(uts, 0xE0000000, 0x40000000);
> > }
> > -LIB_TEST(lib_test_lmb_simple_x2, 0);
> > +LIB_TEST(lib_test_lmb_simple_x2_norun, UT_TESTF_MANUAL);
> >
> > /* Simulate 512 MiB RAM, allocate some blocks that fit/don't fit */
> > static int test_bigblock(struct unit_test_state *uts, const phys_addr_t
> > ram)
> > @@ -275,7 +275,7 @@ static int test_bigblock(struct unit_test_state *uts,
> > const phys_addr_t ram)
> > return 0;
> > }
> >
> > -static int lib_test_lmb_big(struct unit_test_state *uts)
> > +static int lib_test_lmb_big_norun(struct unit_test_state *uts)
> > {
> > int ret;
> >
> > @@ -287,7 +287,7 @@ static int lib_test_lmb_big(struct unit_test_state *uts)
> > /* simulate 512 MiB RAM beginning at 1.5GiB */
> > return test_bigblock(uts, 0xE0000000);
> > }
> > -LIB_TEST(lib_test_lmb_big, 0);
> > +LIB_TEST(lib_test_lmb_big_norun, UT_TESTF_MANUAL);
> >
> > /* Simulate 512 MiB RAM, allocate a block without previous reservation */
> > static int test_noreserved(struct unit_test_state *uts, const phys_addr_t
> > ram,
> > @@ -348,7 +348,7 @@ static int test_noreserved(struct unit_test_state *uts,
> > const phys_addr_t ram,
> > return 0;
> > }
> >
> > -static int lib_test_lmb_noreserved(struct unit_test_state *uts)
> > +static int lib_test_lmb_noreserved_norun(struct unit_test_state *uts)
> > {
> > int ret;
> >
> > @@ -360,10 +360,9 @@ static int lib_test_lmb_noreserved(struct
> > unit_test_state *uts)
> > /* simulate 512 MiB RAM beginning at 1.5GiB */
> > return test_noreserved(uts, 0xE0000000, 4, 1);
> > }
> > +LIB_TEST(lib_test_lmb_noreserved_norun, UT_TESTF_MANUAL);
> >
> > -LIB_TEST(lib_test_lmb_noreserved, 0);
> > -
> > -static int lib_test_lmb_unaligned_size(struct unit_test_state *uts)
> > +static int lib_test_lmb_unaligned_size_norun(struct unit_test_state *uts)
> > {
> > int ret;
> >
> > @@ -375,13 +374,13 @@ static int lib_test_lmb_unaligned_size(struct
> > unit_test_state *uts)
> > /* simulate 512 MiB RAM beginning at 1.5GiB */
> > return test_noreserved(uts, 0xE0000000, 5, 8);
> > }
> > -LIB_TEST(lib_test_lmb_unaligned_size, 0);
> > +LIB_TEST(lib_test_lmb_unaligned_size_norun, UT_TESTF_MANUAL);
> >
> > /*
> > * Simulate a RAM that starts at 0 and allocate down to address 0, which
> > must
> > * fail as '0' means failure for the lmb_alloc functions.
> > */
> > -static int lib_test_lmb_at_0(struct unit_test_state *uts)
> > +static int lib_test_lmb_at_0_norun(struct unit_test_state *uts)
> > {
> > const phys_addr_t ram = 0;
> > const phys_size_t ram_size = 0x20000000;
> > @@ -417,9 +416,9 @@ static int lib_test_lmb_at_0(struct unit_test_state
> > *uts)
> >
> > return 0;
> > }
> > -LIB_TEST(lib_test_lmb_at_0, 0);
> > +LIB_TEST(lib_test_lmb_at_0_norun, UT_TESTF_MANUAL);
> >
> > -static int lib_test_lmb_overlapping_add(struct unit_test_state *uts)
> > +static int lib_test_lmb_overlapping_add_norun(struct unit_test_state *uts)
> > {
> > const phys_addr_t ram = 0x40000000;
> > const phys_size_t ram_size = 0x20000000;
> > @@ -433,10 +432,10 @@ static int lib_test_lmb_overlapping_add(struct
> > unit_test_state *uts)
> >
> > return 0;
> > }
> > -LIB_TEST(lib_test_lmb_overlapping_add, 0);
> > +LIB_TEST(lib_test_lmb_overlapping_add_norun, UT_TESTF_MANUAL);
> >
> > /* Check that calling lmb_reserve with overlapping regions fails. */
> > -static int lib_test_lmb_overlapping_reserve(struct unit_test_state *uts)
> > +static int lib_test_lmb_overlapping_reserve_norun(struct unit_test_state
> > *uts)
> > {
> > const phys_addr_t ram = 0x40000000;
> > const phys_size_t ram_size = 0x20000000;
> > @@ -480,7 +479,7 @@ static int lib_test_lmb_overlapping_reserve(struct
> > unit_test_state *uts)
> > 0, 0, 0, 0);
> > return 0;
> > }
> > -LIB_TEST(lib_test_lmb_overlapping_reserve, 0);
> > +LIB_TEST(lib_test_lmb_overlapping_reserve_norun, UT_TESTF_MANUAL);
> >
> > /*
> > * Simulate 512 MiB RAM, reserve 3 blocks, allocate addresses in between.
> > @@ -596,7 +595,7 @@ static int test_alloc_addr(struct unit_test_state *uts,
> > const phys_addr_t ram)
> > return 0;
> > }
> >
> > -static int lib_test_lmb_alloc_addr(struct unit_test_state *uts)
> > +static int lib_test_lmb_alloc_addr_norun(struct unit_test_state *uts)
> > {
> > int ret;
> >
> > @@ -608,7 +607,7 @@ static int lib_test_lmb_alloc_addr(struct
> > unit_test_state *uts)
> > /* simulate 512 MiB RAM beginning at 1.5GiB */
> > return test_alloc_addr(uts, 0xE0000000);
> > }
> > -LIB_TEST(lib_test_lmb_alloc_addr, 0);
> > +LIB_TEST(lib_test_lmb_alloc_addr_norun, UT_TESTF_MANUAL);
> >
> > /* Simulate 512 MiB RAM, reserve 3 blocks, check addresses in between */
> > static int test_get_unreserved_size(struct unit_test_state *uts,
> > @@ -665,7 +664,7 @@ static int test_get_unreserved_size(struct
> > unit_test_state *uts,
> > return 0;
> > }
> >
> > -static int lib_test_lmb_get_free_size(struct unit_test_state *uts)
> > +static int lib_test_lmb_get_free_size_norun(struct unit_test_state *uts)
> > {
> > int ret;
> >
> > @@ -677,10 +676,10 @@ static int lib_test_lmb_get_free_size(struct
> > unit_test_state *uts)
> > /* simulate 512 MiB RAM beginning at 1.5GiB */
> > return test_get_unreserved_size(uts, 0xE0000000);
> > }
> > -LIB_TEST(lib_test_lmb_get_free_size, 0);
> > +LIB_TEST(lib_test_lmb_get_free_size_norun, UT_TESTF_MANUAL);
> >
> > #ifdef CONFIG_LMB_USE_MAX_REGIONS
> > -static int lib_test_lmb_max_regions(struct unit_test_state *uts)
> > +static int lib_test_lmb_max_regions_norun(struct unit_test_state *uts)
> > {
> > const phys_addr_t ram = 0x00000000;
> > /*
> > @@ -745,10 +744,10 @@ static int lib_test_lmb_max_regions(struct
> > unit_test_state *uts)
> >
> > return 0;
> > }
> > -LIB_TEST(lib_test_lmb_max_regions, 0);
> > +LIB_TEST(lib_test_lmb_max_regions_norun, UT_TESTF_MANUAL);
> > #endif
> >
> > -static int lib_test_lmb_flags(struct unit_test_state *uts)
> > +static int lib_test_lmb_flags_norun(struct unit_test_state *uts)
> > {
> > const phys_addr_t ram = 0x40000000;
> > const phys_size_t ram_size = 0x20000000;
> > @@ -832,4 +831,4 @@ static int lib_test_lmb_flags(struct unit_test_state
> > *uts)
> >
> > return 0;
> > }
> > -LIB_TEST(lib_test_lmb_flags, 0);
> > +LIB_TEST(lib_test_lmb_flags_norun, UT_TESTF_MANUAL);
>
