kunit: memcpy: Split slow memcpy tests into MEMCPY_SLOW_KUNIT_TEST
Subsystems (2)
PATCH 1/1 kunit: memcpy: Split slow memcpy tests into MEMCPY_SLOW_KUNIT_TEST
Since the long memcpy tests may stall a system for tens of seconds in virtualized architecture environments, split those tests off under CONFIG_MEMCPY_SLOW_KUNIT_TEST so they can be separately disabled.
---
Guenter, does this give you the needed flexibility to turn on the memcpy kunit tests again in your slower environments?
--- lib/Kconfig.debug | 9 +++++++++ lib/memcpy_kunit.c | 17 +++++++++++++---- 2 files changed, 22 insertions(+), 4 deletions(-)
lib/Kconfig.debug +9 -0
@@ -2621,6 +2621,15 @@ config MEMCPY_KUNIT_TEST If unsure, say N. +config MEMCPY_SLOW_KUNIT_TEST + tristate "Include exhaustive memcpy tests" if !KUNIT_ALL_TESTS + depends on MEMCPY_KUNIT_TEST + default KUNIT_ALL_TESTS + help + Some memcpy tests are quite exhaustive in checking for overlaps + and bit ranges. These can be very slow, so they are split out + as a separate config. + config IS_SIGNED_TYPE_KUNIT_TEST tristate "Test is_signed_type() macro" if !KUNIT_ALL_TESTS depends on KUNIT
lib/memcpy_kunit.c +13 -4
@@ -307,8 +307,12 @@ static void set_random_nonzero(struct kunit *test, u8 *byte) } } -static void init_large (struct kunit *test) +static int init_large (struct kunit *test) { +if (!IS_ENABLED (CONFIG_MEMCPY_SLOW_KUNIT_TEST )) { +kunit_skip (test,"Slow test skipped. Enable with CONFIG_MEMCPY_SLOW_KUNIT_TEST=y" ); +return -EBUSY ; + }/* Get many bit patterns. */ get_random_bytes (large_src,ARRAY_SIZE (large_src));
@@ -319,6 +323,8 @@ static void init_large(struct kunit *test)/* Explicitly zero the entire destination. */ memset (large_dst,0 ,ARRAY_SIZE (large_dst)); + +return 0 ; }/*
@@ -327,7 +333,9 @@ static void init_large(struct kunit *test)*/ static void copy_large_test (struct kunit *test,bool use_memmove) { -init_large (test); + +if (init_large (test)) +return ;/* Copy a growing number of non-overlapping bytes ... */ for (int bytes =1 ; bytes <=ARRAY_SIZE (large_src); bytes++) {
@@ -472,7 +480,8 @@ static void memmove_overlap_test(struct kunit *test)static const int bytes_start =1 ;static const int bytes_end =ARRAY_SIZE (large_src) +1 ; -init_large (test); +if (init_large (test)) +return ;/* Copy a growing number of overlapping bytes ... */ for (int bytes = bytes_start; bytes < bytes_end;
@@ -549,8 +558,8 @@ static void strtomem_test(struct kunit *test)static struct kunit_case memcpy_test_cases[] = {KUNIT_CASE (memset_test),KUNIT_CASE (memcpy_test), -KUNIT_CASE (memcpy_large_test),KUNIT_CASE (memmove_test), +KUNIT_CASE (memcpy_large_test),KUNIT_CASE (memmove_large_test),KUNIT_CASE (memmove_overlap_test),KUNIT_CASE (strtomem_test),
Signature · 1 line
2.34.1
Quoted 10 lines · Kees Cook
Since the long memcpy tests may stall a system for tens of seconds in virtualized architecture environments, split those tests off under
CONFIG_MEMCPY_SLOW_KUNIT_TESTso they can be separately disabled.Reported-by Guenter Roeck <[email protected]>Cc Andrew Morton <[email protected]>Cc Nathan Chancellor <[email protected]>Signed-off-by Kees Cook <[email protected]>
Quoted 3 lines
---
Guenter, does this give you the needed flexibility to turn on the memcpy kunit tests again in your slower environments?
I'll be traveling this weekend. Give me until early next week to give it a try.
Thanks,
Guenter
Quoted 86 lines
--- lib/Kconfig.debug | 9 +++++++++ lib/memcpy_kunit.c | 17 +++++++++++++---- 2 files changed, 22 insertions(+), 4 deletions(-)lib/Kconfig.debug +9
-0@@ -2621,6 +2621,15 @@ config MEMCPY_KUNIT_TEST If unsure, say N. +config MEMCPY_SLOW_KUNIT_TEST + tristate "Include exhaustive memcpy tests" if !KUNIT_ALL_TESTS + depends on MEMCPY_KUNIT_TEST + default KUNIT_ALL_TESTS + help + Some memcpy tests are quite exhaustive in checking for overlaps + and bit ranges. These can be very slow, so they are split out + as a separate config. + config IS_SIGNED_TYPE_KUNIT_TEST tristate "Test is_signed_type() macro" if !KUNIT_ALL_TESTS depends on KUNITlib/memcpy_kunit.c +13
-4@@ -307,8 +307,12 @@ static void set_random_nonzero(struct kunit *test, u8 *byte) } } -static void init_large (struct kunit *test) +static int init_large (struct kunit *test) { +if (!IS_ENABLED (CONFIG_MEMCPY_SLOW_KUNIT_TEST )) { +kunit_skip (test,"Slow test skipped. Enable with CONFIG_MEMCPY_SLOW_KUNIT_TEST=y" ); +return -EBUSY ; + }/* Get many bit patterns. */ get_random_bytes (large_src,ARRAY_SIZE (large_src));@@ -319,6 +323,8 @@ static void init_large(struct kunit *test)/* Explicitly zero the entire destination. */ memset (large_dst,0 ,ARRAY_SIZE (large_dst)); + +return 0 ; }/* @@ -327,7 +333,9 @@ static void init_large(struct kunit *test)*/ static void copy_large_test (struct kunit *test,bool use_memmove) { -init_large (test); + +if (init_large (test)) +return ;/* Copy a growing number of non-overlapping bytes ... */ for (int bytes =1 ; bytes <=ARRAY_SIZE (large_src); bytes++) {@@ -472,7 +480,8 @@ static void memmove_overlap_test(struct kunit *test)static const int bytes_start =1 ;static const int bytes_end =ARRAY_SIZE (large_src) +1 ; -init_large (test); +if (init_large (test)) +return ;/* Copy a growing number of overlapping bytes ... */ for (int bytes = bytes_start; bytes < bytes_end;@@ -549,8 +558,8 @@ static void strtomem_test(struct kunit *test)static struct kunit_case memcpy_test_cases[] = {KUNIT_CASE (memset_test),KUNIT_CASE (memcpy_test), -KUNIT_CASE (memcpy_large_test),KUNIT_CASE (memmove_test), +KUNIT_CASE (memcpy_large_test),KUNIT_CASE (memmove_large_test),KUNIT_CASE (memmove_overlap_test),KUNIT_CASE (strtomem_test),Signature · 1 line
2.34.1
Hi Kees,
Quoted 10 lines · Kees Cook
Since the long memcpy tests may stall a system for tens of seconds in virtualized architecture environments, split those tests off under
CONFIG_MEMCPY_SLOW_KUNIT_TESTso they can be separately disabled.Reported-by Guenter Roeck <[email protected]>Cc Andrew Morton <[email protected]>Cc Nathan Chancellor <[email protected]>Signed-off-by Kees Cook <[email protected]>
Thanks for your patch!
lib/Kconfig.debug config MEMCPY_KUNIT_TEST · line 2625
Quoted 8 lines
lib/Kconfig.debug +2
-0@@ -2621,6 +2621,15 @@ config MEMCPY_KUNIT_TEST If unsure, say N. +config MEMCPY_SLOW_KUNIT_TEST + tristate "Include exhaustive memcpy tests" if !KUNIT_ALL_TESTS
Why the tristate?
Quoted 15 lines
lib/Kconfig.debug +7
-0+ depends on MEMCPY_KUNIT_TEST + default KUNIT_ALL_TESTS + help + Some memcpy tests are quite exhaustive in checking for overlaps + and bit ranges. These can be very slow, so they are split out + as a separate config. + config IS_SIGNED_TYPE_KUNIT_TEST tristate "Test is_signed_type() macro" if !KUNIT_ALL_TESTS depends on KUNITlib/memcpy_kunit.c +0
-0
lib/memcpy_kunit.c static void set_random_nonzero(struct kunit *test, u8 *byte) · line 313
Quoted 8 lines
lib/memcpy_kunit.c +3
-1@@ -307,8 +307,12 @@ static void set_random_nonzero(struct kunit *test, u8 *byte) } } -static void init_large (struct kunit *test) +static int init_large (struct kunit *test) { +if (!IS_ENABLED (CONFIG_MEMCPY_SLOW_KUNIT_TEST )) { +kunit_skip (test,"Slow test skipped. Enable with CONFIG_MEMCPY_SLOW_KUNIT_TEST=y" );
So I can't make the slower tests available for when I need them, but not run them by default?
I guess that's why you made MEMCPY_SLOW_KUNIT_TEST tristate originally, to have a separate module with the slow tests?
lib/memcpy_kunit.c static void set_random_nonzero(struct kunit *test, u8 *byte) · line 318
Quoted 5 lines
lib/memcpy_kunit.c +2
-0+return -EBUSY ; + }/* Get many bit patterns. */ get_random_bytes (large_src,ARRAY_SIZE (large_src));
Gr{oetje,eeting}s,
Geert
--
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]
In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that.
-- Linus Torvalds
+Cc rest of kunit from MAINTAINERS
Quoted 45 lines · Geert Uytterhoeven
Hi Kees,
Quoted 10 lines · Kees Cook
Since the long memcpy tests may stall a system for tens of seconds in virtualized architecture environments, split those tests off under
CONFIG_MEMCPY_SLOW_KUNIT_TESTso they can be separately disabled.Reported-by Guenter Roeck <[email protected]>Cc Andrew Morton <[email protected]>Cc Nathan Chancellor <[email protected]>Signed-off-by Kees Cook <[email protected]>Thanks for your patch!
lib/Kconfig.debug config MEMCPY_KUNIT_TEST · line 2625
Quoted 8 lines
lib/Kconfig.debug +2
-0@@ -2621,6 +2621,15 @@ config MEMCPY_KUNIT_TEST If unsure, say N. +config MEMCPY_SLOW_KUNIT_TEST + tristate "Include exhaustive memcpy tests" if !KUNIT_ALL_TESTSWhy the tristate?
Quoted 18 lines
lib/Kconfig.debug +7
-0+ depends on MEMCPY_KUNIT_TEST + default KUNIT_ALL_TESTS + help + Some memcpy tests are quite exhaustive in checking for overlaps + and bit ranges. These can be very slow, so they are split out + as a separate config. + config IS_SIGNED_TYPE_KUNIT_TEST tristate "Test is_signed_type() macro" if !KUNIT_ALL_TESTS depends on KUNITlib/memcpy_kunit.c +0
-0@@ -307,8 +307,12 @@ static void set_random_nonzero(struct kunit *test, u8 *byte) } }
Quoted 8 lines
lib/memcpy_kunit.c static void set_random_nonzero(struct kunit *test, u8 *byte) · line 313
Quoted 5 lines
lib/memcpy_kunit.c +3
-1-static void init_large (struct kunit *test) +static int init_large (struct kunit *test) { +if (!IS_ENABLED (CONFIG_MEMCPY_SLOW_KUNIT_TEST )) { +kunit_skip (test,"Slow test skipped. Enable with CONFIG_MEMCPY_SLOW_KUNIT_TEST=y" );So I can't make the slower tests available for when I need them, but not run them by default?
Indeed it seems weird to tie this to a config option without runtime override.
Quoted 2 lines
I guess that's why you made
MEMCPY_SLOW_KUNIT_TESTtristate originally, to have a separate module with the slow tests?
On the other hand I can imagine requiring a separate module for slow tests would lead to more churn - IIUC there would need to be two files instead of memcpy_kunit.c, possibly a duplicated boilerplate code (or another shared .c file).
So the idea is to have a generic way to mark some tests as slow and a way to opt-in/opt-out for those when running the tests. Maybe KUnit folks already have such mechanism or have an idea how to implement that.
Quoted 16 lines
lib/memcpy_kunit.c static void set_random_nonzero(struct kunit *test, u8 *byte) · line 318
Quoted 5 lines
lib/memcpy_kunit.c +2
-0+return -EBUSY ; + }/* Get many bit patterns. */ get_random_bytes (large_src,ARRAY_SIZE (large_src));Gr{oetje,eeting}s,
Geert
--
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that.
-- Linus Torvalds
Quoted 10 lines · Vlastimil Babka
+Cc rest of kunit from
MAINTAINERSQuoted 6 lines · Geert Uytterhoeven
Hi Kees,
Quoted 3 lines · Kees Cook
Since the long memcpy tests may stall a system for tens of seconds in virtualized architecture environments, split those tests off under
CONFIG_MEMCPY_SLOW_KUNIT_TESTso they can be separately disabled.
<snip>
Quoted 15 lines
Quoted 9 lines
lib/memcpy_kunit.c static void set_random_nonzero(struct kunit *test, u8 *byte) · line 313
Quoted 6 lines
lib/memcpy_kunit.c +3
-1-static void init_large (struct kunit *test) +static int init_large (struct kunit *test) { +if (!IS_ENABLED (CONFIG_MEMCPY_SLOW_KUNIT_TEST )) { +kunit_skip (test,"Slow test skipped. Enable with CONFIG_MEMCPY_SLOW_KUNIT_TEST=y" );So I can't make the slower tests available for when I need them, but not run them by default?
Indeed it seems weird to tie this to a config option without runtime override.
Quoted 2 lines
I guess that's why you made
MEMCPY_SLOW_KUNIT_TESTtristate originally, to have a separate module with the slow tests?
Quoted 8 lines
On the other hand I can imagine requiring a separate module for slow tests would lead to more churn - IIUC there would need to be two files instead of
memcpy_kunit.c, possibly a duplicated boilerplate code (or another shared .c file).So the idea is to have a generic way to mark some tests as slow and a way to opt-in/opt-out for those when running the tests. Maybe KUnit folks already have such mechanism or have an idea how to implement that.
There is no mechanism atm, and we'd still need to figure it out so it'll be a while.
So I think a patch like this makes sense in the short-term.
This is definitely something we've always thought would be useful eventually. See this TODO which has been there since day 1 ;)
https://elixir.bootlin.com/linux/latest/source/lib/kunit/try-catch.c#L36
It just felt like it would be premature to come up with something when basically all the tests up until now ran ~instantly.
Throwing out some rough implementation ideas:
I was thinking the granularity for these timeout annotations would be at the suite-level.
If we go with that, then I guess the intended flow is to group slow tests into their own suite and mark them as such.
Then maybe we'd have some runtime way of disabling/enabling "long" tests, like a cmdline opt.
E.g. you'd pass kunit.max_test_size=30 to exclude tests longer than 30 seconds.
Daniel
Quoted 11 lines · Kees Cook
Since the long memcpy tests may stall a system for tens of seconds in virtualized architecture environments, split those tests off under
CONFIG_MEMCPY_SLOW_KUNIT_TESTso they can be separately disabled.Reported-by Guenter Roeck <[email protected]>Cc Andrew Morton <[email protected]>Cc Nathan Chancellor <[email protected]>Signed-off-by Kees Cook <[email protected]>
Thanks for the patch!
Quoted 89 lines
---
Guenter, does this give you the needed flexibility to turn on the memcpy kunit tests again in your slower environments?--- lib/Kconfig.debug | 9 +++++++++ lib/memcpy_kunit.c | 17 +++++++++++++---- 2 files changed, 22 insertions(+), 4 deletions(-)lib/Kconfig.debug +9
-0@@ -2621,6 +2621,15 @@ config MEMCPY_KUNIT_TEST If unsure, say N. +config MEMCPY_SLOW_KUNIT_TEST + tristate "Include exhaustive memcpy tests" if !KUNIT_ALL_TESTS + depends on MEMCPY_KUNIT_TEST + default KUNIT_ALL_TESTS + help + Some memcpy tests are quite exhaustive in checking for overlaps + and bit ranges. These can be very slow, so they are split out + as a separate config. + config IS_SIGNED_TYPE_KUNIT_TEST tristate "Test is_signed_type() macro" if !KUNIT_ALL_TESTS depends on KUNITlib/memcpy_kunit.c +13
-5@@ -307,8 +307,12 @@ static void set_random_nonzero(struct kunit *test, u8 *byte) } } -static void init_large (struct kunit *test) +static int init_large (struct kunit *test) { +if (!IS_ENABLED (CONFIG_MEMCPY_SLOW_KUNIT_TEST )) { +kunit_skip (test,"Slow test skipped. Enable with CONFIG_MEMCPY_SLOW_KUNIT_TEST=y" ); +return -EBUSY ; + }/* Get many bit patterns. */ get_random_bytes (large_src,ARRAY_SIZE (large_src));@@ -319,6 +323,8 @@ static void init_large(struct kunit *test)/* Explicitly zero the entire destination. */ memset (large_dst,0 ,ARRAY_SIZE (large_dst)); + +return 0 ; }/* @@ -327,7 +333,9 @@ static void init_large(struct kunit *test)*/ static void copy_large_test (struct kunit *test,bool use_memmove) { -init_large (test); + +if (init_large (test)) +return ;/* Copy a growing number of non-overlapping bytes ... */ for (int bytes =1 ; bytes <=ARRAY_SIZE (large_src); bytes++) {@@ -472,7 +480,8 @@ static void memmove_overlap_test(struct kunit *test)static const int bytes_start =1 ;static const int bytes_end =ARRAY_SIZE (large_src) +1 ; -init_large (test); +if (init_large (test)) +return ;/* Copy a growing number of overlapping bytes ... */ for (int bytes = bytes_start; bytes < bytes_end;@@ -549,8 +558,8 @@ static void strtomem_test(struct kunit *test)static struct kunit_case memcpy_test_cases[] = {KUNIT_CASE (memset_test),KUNIT_CASE (memcpy_test), -KUNIT_CASE (memcpy_large_test),KUNIT_CASE (memmove_test), +KUNIT_CASE (memcpy_large_test),KUNIT_CASE (memmove_large_test),KUNIT_CASE (memmove_overlap_test),KUNIT_CASE (strtomem_test), --2.34.1
Signature · 2 lines
Thanks, ~Nick Desaulniers
Quoted 10 lines · Kees Cook
Since the long memcpy tests may stall a system for tens of seconds in virtualized architecture environments, split those tests off under
CONFIG_MEMCPY_SLOW_KUNIT_TESTso they can be separately disabled.Reported-by Guenter Roeck <[email protected]>Cc Andrew Morton <[email protected]>Cc Nathan Chancellor <[email protected]>Signed-off-by Kees Cook <[email protected]>
Quoted 3 lines
---
Guenter, does this give you the needed flexibility to turn on the memcpy kunit tests again in your slower environments?
Yes, it does, and it works.
Quoted 10 lines
--- lib/Kconfig.debug | 9 +++++++++ lib/memcpy_kunit.c | 17 +++++++++++++---- 2 files changed, 22 insertions(+), 4 deletions(-)lib/Kconfig.debug +0
-0
lib/Kconfig.debug config MEMCPY_KUNIT_TEST · line 2625
Quoted 5 lines
lib/Kconfig.debug +2
-0@@ -2621,6 +2621,15 @@ config MEMCPY_KUNIT_TEST If unsure, say N. +config MEMCPY_SLOW_KUNIT_TEST + tristate "Include exhaustive memcpy tests" if !KUNIT_ALL_TESTS
As Geert noticed, bool should be sufficient here since this is not a separate test.
Thanks,
Guenter
Quoted 71 lines
lib/Kconfig.debug +7
-0+ depends on MEMCPY_KUNIT_TEST + default KUNIT_ALL_TESTS + help + Some memcpy tests are quite exhaustive in checking for overlaps + and bit ranges. These can be very slow, so they are split out + as a separate config. + config IS_SIGNED_TYPE_KUNIT_TEST tristate "Test is_signed_type() macro" if !KUNIT_ALL_TESTS depends on KUNITlib/memcpy_kunit.c +13
-4@@ -307,8 +307,12 @@ static void set_random_nonzero(struct kunit *test, u8 *byte) } } -static void init_large (struct kunit *test) +static int init_large (struct kunit *test) { +if (!IS_ENABLED (CONFIG_MEMCPY_SLOW_KUNIT_TEST )) { +kunit_skip (test,"Slow test skipped. Enable with CONFIG_MEMCPY_SLOW_KUNIT_TEST=y" ); +return -EBUSY ; + }/* Get many bit patterns. */ get_random_bytes (large_src,ARRAY_SIZE (large_src));@@ -319,6 +323,8 @@ static void init_large(struct kunit *test)/* Explicitly zero the entire destination. */ memset (large_dst,0 ,ARRAY_SIZE (large_dst)); + +return 0 ; }/* @@ -327,7 +333,9 @@ static void init_large(struct kunit *test)*/ static void copy_large_test (struct kunit *test,bool use_memmove) { -init_large (test); + +if (init_large (test)) +return ;/* Copy a growing number of non-overlapping bytes ... */ for (int bytes =1 ; bytes <=ARRAY_SIZE (large_src); bytes++) {@@ -472,7 +480,8 @@ static void memmove_overlap_test(struct kunit *test)static const int bytes_start =1 ;static const int bytes_end =ARRAY_SIZE (large_src) +1 ; -init_large (test); +if (init_large (test)) +return ;/* Copy a growing number of overlapping bytes ... */ for (int bytes = bytes_start; bytes < bytes_end;@@ -549,8 +558,8 @@ static void strtomem_test(struct kunit *test)static struct kunit_case memcpy_test_cases[] = {KUNIT_CASE (memset_test),KUNIT_CASE (memcpy_test), -KUNIT_CASE (memcpy_large_test),KUNIT_CASE (memmove_test), +KUNIT_CASE (memcpy_large_test),KUNIT_CASE (memmove_large_test),KUNIT_CASE (memmove_overlap_test),KUNIT_CASE (strtomem_test),Signature · 1 line
2.34.1
Quoted 11 lines · Kees Cook
Since the long memcpy tests may stall a system for tens of seconds in virtualized architecture environments, split those tests off under
CONFIG_MEMCPY_SLOW_KUNIT_TESTso they can be separately disabled.Reported-by Guenter Roeck <[email protected]>Cc Andrew Morton <[email protected]>Cc Nathan Chancellor <[email protected]>Signed-off-by Kees Cook <[email protected]>
Quoted 4 lines
---
Guenter, does this give you the needed flexibility to turn on the memcpy kunit tests again in your slower environments?
---
Sorry for the delay: I've just got back from holidays.
This looks good to me (modulo the tristate/bool issue mentioned).
Having a specific way to tag tests as "slow" is something we've considered having in KUnit for a while, but (at least initially), there weren't any tests slow enough for it to be worthwhile. It looks like that's changing (alongside this, there are a few DRM tests which are quite slow, as well as some of the KCSAN tests. Even the time64_to_tm_test_date_range test, while very quick under UML on a modern system, is noticeably slow under qemu and times out on something like an old 486...). Daniel's comments elsewhere in this thread have some good ideas.
That being said, it'll probably take long enough to work out and implement a good way of giving tests "properties" and requesting only fast tests run that just putting tests which are slow enough to cause problems behind a kconfig entry seems a pretty solid intermediate solution.
So this is:
(assuming the tristate goes to bool), and I'll look into getting a way of marking tests as "slow" and enabling/disabling them at runtime.
Cheers,
-- David
Quoted 9 lines
lib/Kconfig.debug | 9 +++++++++ lib/memcpy_kunit.c | 17 +++++++++++++---- 2 files changed, 22 insertions(+), 4 deletions(-)lib/Kconfig.debug +0
-0
lib/Kconfig.debug config MEMCPY_KUNIT_TEST · line 2625
Quoted 5 lines
lib/Kconfig.debug +2
-0@@ -2621,6 +2621,15 @@ config MEMCPY_KUNIT_TEST If unsure, say N. +config MEMCPY_SLOW_KUNIT_TEST + tristate "Include exhaustive memcpy tests" if !KUNIT_ALL_TESTS
As mentioned, if this is just going to be a toggle, it can be a "bool".
Quoted 71 lines
lib/Kconfig.debug +7
-0+ depends on MEMCPY_KUNIT_TEST + default KUNIT_ALL_TESTS + help + Some memcpy tests are quite exhaustive in checking for overlaps + and bit ranges. These can be very slow, so they are split out + as a separate config. + config IS_SIGNED_TYPE_KUNIT_TEST tristate "Test is_signed_type() macro" if !KUNIT_ALL_TESTS depends on KUNITlib/memcpy_kunit.c +13
-5@@ -307,8 +307,12 @@ static void set_random_nonzero(struct kunit *test, u8 *byte) } } -static void init_large (struct kunit *test) +static int init_large (struct kunit *test) { +if (!IS_ENABLED (CONFIG_MEMCPY_SLOW_KUNIT_TEST )) { +kunit_skip (test,"Slow test skipped. Enable with CONFIG_MEMCPY_SLOW_KUNIT_TEST=y" ); +return -EBUSY ; + }/* Get many bit patterns. */ get_random_bytes (large_src,ARRAY_SIZE (large_src));@@ -319,6 +323,8 @@ static void init_large(struct kunit *test)/* Explicitly zero the entire destination. */ memset (large_dst,0 ,ARRAY_SIZE (large_dst)); + +return 0 ; }/* @@ -327,7 +333,9 @@ static void init_large(struct kunit *test)*/ static void copy_large_test (struct kunit *test,bool use_memmove) { -init_large (test); + +if (init_large (test)) +return ;/* Copy a growing number of non-overlapping bytes ... */ for (int bytes =1 ; bytes <=ARRAY_SIZE (large_src); bytes++) {@@ -472,7 +480,8 @@ static void memmove_overlap_test(struct kunit *test)static const int bytes_start =1 ;static const int bytes_end =ARRAY_SIZE (large_src) +1 ; -init_large (test); +if (init_large (test)) +return ;/* Copy a growing number of overlapping bytes ... */ for (int bytes = bytes_start; bytes < bytes_end;@@ -549,8 +558,8 @@ static void strtomem_test(struct kunit *test)static struct kunit_case memcpy_test_cases[] = {KUNIT_CASE (memset_test),KUNIT_CASE (memcpy_test), -KUNIT_CASE (memcpy_large_test),KUNIT_CASE (memmove_test), +KUNIT_CASE (memcpy_large_test),KUNIT_CASE (memmove_large_test),KUNIT_CASE (memmove_overlap_test),KUNIT_CASE (strtomem_test), --2.34.1