x86: kmsan: Don't rename memintrinsics in uninstrumented files
Subsystems (3)
Alexander Potapenko
maintainerPATCH 1/4 x86: kmsan: Don't rename memintrinsics in uninstrumented files
KMSAN should be overriding calls to memset/memcpy/memmove and their __builtin_ versions in instrumented files, so there is no need to override them. In non-instrumented versions we are now required to leave memset() and friends intact, so we cannot replace them with __msan_XXX() functions.
--- arch/x86/include/asm/string_64.h | 17 ----------------- 1 file changed, 17 deletions(-)
arch/x86/include/asm/string_64.h +0 -17
@@ -15,22 +15,11 @@#endif #define __HAVE_ARCH_MEMCPY 1 -#if defined(__SANITIZE_MEMORY__) && defined(__NO_FORTIFY) -#undef memcpy -#define memcpy __msan_memcpy -#else extern void *memcpy (void *to,const void *from,size_t len); -#endif extern void *__memcpy (void *to,const void *from,size_t len);#define __HAVE_ARCH_MEMSET -#if defined(__SANITIZE_MEMORY__) && defined(__NO_FORTIFY) -extern void *__msan_memset (void *s,int c,size_t n); -#undef memset -#define memset __msan_memset -#else void *memset (void *s,int c,size_t n); -#endif void *__memset (void *s,int c,size_t n);#define __HAVE_ARCH_MEMSET16
@@ -70,13 +59,7 @@ static inline void *memset64(uint64_t *s, uint64_t v, size_t n) }#define __HAVE_ARCH_MEMMOVE -#if defined(__SANITIZE_MEMORY__) && defined(__NO_FORTIFY) -#undef memmove -void *__msan_memmove (void *dest,const void *src,size_t len); -#define memmove __msan_memmove -#else void *memmove (void *dest,const void *src,size_t count); -#endif void *__memmove (void *dest,const void *src,size_t count);int memcmp (const void *cs,const void *ct,size_t count);
Signature · 1 line
2.39.2.722.g9855ee24e9-goog
Alexander Potapenko
maintainerPATCH 2/4 kmsan: another take at fixing memcpy tests
5478afc55a21 ("kmsan: fix memcpy tests") uses OPTIMIZER_HIDE_VAR() to hide the uninitialized var from the compiler optimizations.
However OPTIMIZER_HIDE_VAR(uninit) enforces an immediate check of @uninit, so memcpy tests did not actually check the behavior of memcpy(), because they always contained a KMSAN report.
Replace OPTIMIZER_HIDE_VAR() with a file-local asm macro that just clobbers the memory, and add a test case for memcpy() that does not expect an error report.
Also reflow kmsan_test.c with clang-format.
--- mm/kmsan/kmsan_test.c | 43 +++++++++++++++++++++++++++++++++++++------ 1 file changed, 37 insertions(+), 6 deletions(-)
mm/kmsan/kmsan_test.c +37 -6
@@ -407,6 +407,36 @@ static void test_printk(struct kunit *test)KUNIT_EXPECT_TRUE (test,report_matches (&expect)); } +/* +* Prevent the compiler from optimizing @var away. Without this, Clang may +* notice that @var is uninitialized and drop memcpy() calls that use it. +* +* There is OPTIMIZER_HIDE_VAR() in linux/compier.h that we cannot use here, +* because it is implemented as inline assembly receiving @var as a parameter +* and will enforce a KMSAN check. +*/ +#define DO_NOT_OPTIMIZE (var) asm("" ::: "memory") + +/* +* Test case: ensure that memcpy() correctly copies initialized values. +*/ +static void test_init_memcpy (struct kunit *test) +{ +EXPECTATION_NO_REPORT (expect); +volatile int src; +volatile int dst =0 ; + +// Ensure DO_NOT_OPTIMIZE() does not cause extra checks. +DO_NOT_OPTIMIZE (src); + src =1 ; +kunit_info ( + test, +"memcpy()ing aligned initialized src to aligned dst (no reports)\n" ); +memcpy ((void *)&dst, (void *)&src,sizeof (src)); +kmsan_check_memory ((void *)&dst,sizeof (dst)); +KUNIT_EXPECT_TRUE (test,report_matches (&expect)); +} +/* * Test case: ensure that memcpy() correctly copies uninitialized values between * aligned `src` and `dst`.
@@ -420,7 +450,7 @@ static void test_memcpy_aligned_to_aligned(struct kunit *test)kunit_info ( test,"memcpy()ing aligned uninit src to aligned dst (UMR report)\n" ); -OPTIMIZER_HIDE_VAR (uninit_src); +DO_NOT_OPTIMIZE (uninit_src);memcpy ((void *)&dst, (void *)&uninit_src,sizeof (uninit_src));kmsan_check_memory ((void *)&dst,sizeof (dst));KUNIT_EXPECT_TRUE (test,report_matches (&expect));
@@ -443,7 +473,7 @@ static void test_memcpy_aligned_to_unaligned(struct kunit *test)kunit_info ( test,"memcpy()ing aligned uninit src to unaligned dst (UMR report)\n" ); -OPTIMIZER_HIDE_VAR (uninit_src); +DO_NOT_OPTIMIZE (uninit_src);memcpy ((void *)&dst[1 ], (void *)&uninit_src,sizeof (uninit_src));kmsan_check_memory ((void *)dst,4 );KUNIT_EXPECT_TRUE (test,report_matches (&expect));
@@ -467,13 +497,14 @@ static void test_memcpy_aligned_to_unaligned2(struct kunit *test)kunit_info ( test,"memcpy()ing aligned uninit src to unaligned dst - part 2 (UMR report)\n" ); -OPTIMIZER_HIDE_VAR (uninit_src); +DO_NOT_OPTIMIZE (uninit_src);memcpy ((void *)&dst[1 ], (void *)&uninit_src,sizeof (uninit_src));kmsan_check_memory ((void *)&dst[4 ],sizeof (uninit_src));KUNIT_EXPECT_TRUE (test,report_matches (&expect)); } -static noinline void fibonacci(int *array, int size, int start) { +static noinline void fibonacci(int *array, int size, int start) +{if (start <2 || (start == size))return ; array[start] = array[start -1 ] + array[start -2 ];
@@ -482,8 +513,7 @@ static noinline void fibonacci(int *array, int size, int start) {static void test_long_origin_chain (struct kunit *test) { -EXPECTATION_UNINIT_VALUE_FN (expect, -"test_long_origin_chain" ); +EXPECTATION_UNINIT_VALUE_FN (expect,"test_long_origin_chain" );/* (KMSAN_MAX_ORIGIN_DEPTH * 2) recursive calls to fibonacci(). */ volatile int accum[KMSAN_MAX_ORIGIN_DEPTH *2 +2 ];int last =ARRAY_SIZE (accum) -1 ;
@@ -515,6 +545,7 @@ static struct kunit_case kmsan_test_cases[] = {KUNIT_CASE (test_uaf),KUNIT_CASE (test_percpu_propagate),KUNIT_CASE (test_printk), +KUNIT_CASE (test_init_memcpy),KUNIT_CASE (test_memcpy_aligned_to_aligned),KUNIT_CASE (test_memcpy_aligned_to_unaligned), KUNIT_CASE(test_memcpy_aligned_to_unaligned2),
Signature · 1 line
2.39.2.722.g9855ee24e9-goog
Marco Elver
reviewerRe: [PATCH 2/4] kmsan: another take at fixing memcpy tests
Quoted 26 lines · Alexander Potapenko' via kasan-dev
5478afc55a21("kmsan: fix memcpy tests") usesOPTIMIZER_HIDE_VAR()to hide the uninitialized var from the compiler optimizations.However
OPTIMIZER_HIDE_VAR(uninit)enforces an immediate check of @uninit, so memcpy tests did not actually check the behavior ofmemcpy(), because they always contained a KMSAN report.Replace
OPTIMIZER_HIDE_VAR()with a file-local asm macro that just clobbers the memory, and add a test case formemcpy()that does not expect an error report.Also reflow
kmsan_test.cwith clang-format.Signed-off-by Alexander Potapenko <[email protected]>--- mm/kmsan/kmsan_test.c | 43 +++++++++++++++++++++++++++++++++++++------ 1 file changed, 37 insertions(+), 6 deletions(-)mm/kmsan/kmsan_test.c +0
-0@@ -407,6 +407,36 @@ static void test_printk(struct kunit *test)KUNIT_EXPECT_TRUE (test,report_matches (&expect)); }
mm/kmsan/kmsan_test.c static void test_printk(struct kunit *test) · line 418
Quoted 10 lines
mm/kmsan/kmsan_test.c +9
-0+/* +* Prevent the compiler from optimizing @var away. Without this, Clang may +* notice that @var is uninitialized and drop memcpy() calls that use it. +* +* There is OPTIMIZER_HIDE_VAR() in linux/compier.h that we cannot use here, +* because it is implemented as inline assembly receiving @var as a parameter +* and will enforce a KMSAN check. +*/ +#define DO_NOT_OPTIMIZE (var) asm("" ::: "memory")
That's just a normal "barrier()" - use that instead?
mm/kmsan/kmsan_test.c static void test_printk(struct kunit *test) · line 429
Quoted 10 lines
mm/kmsan/kmsan_test.c +10
-0+/* +* Test case: ensure that memcpy() correctly copies initialized values. +*/ +static void test_init_memcpy (struct kunit *test) +{ +EXPECTATION_NO_REPORT (expect); +volatile int src; +volatile int dst =0 ; + +// Ensure DO_NOT_OPTIMIZE() does not cause extra checks.
^^ this comment seems redundant now, given DO_NOT_OPTIMIZE() has a comment (it's also using //-style comment).
Quoted 73 lines
mm/kmsan/kmsan_test.c +17
-7+DO_NOT_OPTIMIZE (src); + src =1 ; +kunit_info ( + test, +"memcpy()ing aligned initialized src to aligned dst (no reports)\n" ); +memcpy ((void *)&dst, (void *)&src,sizeof (src)); +kmsan_check_memory ((void *)&dst,sizeof (dst)); +KUNIT_EXPECT_TRUE (test,report_matches (&expect)); +} +/* * Test case: ensure that memcpy() correctly copies uninitialized values between * aligned `src` and `dst`. @@ -420,7 +450,7 @@ static void test_memcpy_aligned_to_aligned(struct kunit *test)kunit_info ( test,"memcpy()ing aligned uninit src to aligned dst (UMR report)\n" ); -OPTIMIZER_HIDE_VAR (uninit_src); +DO_NOT_OPTIMIZE (uninit_src);memcpy ((void *)&dst, (void *)&uninit_src,sizeof (uninit_src));kmsan_check_memory ((void *)&dst,sizeof (dst));KUNIT_EXPECT_TRUE (test,report_matches (&expect));@@ -443,7 +473,7 @@ static void test_memcpy_aligned_to_unaligned(struct kunit *test)kunit_info ( test,"memcpy()ing aligned uninit src to unaligned dst (UMR report)\n" ); -OPTIMIZER_HIDE_VAR (uninit_src); +DO_NOT_OPTIMIZE (uninit_src);memcpy ((void *)&dst[1 ], (void *)&uninit_src,sizeof (uninit_src));kmsan_check_memory ((void *)dst,4 );KUNIT_EXPECT_TRUE (test,report_matches (&expect));@@ -467,13 +497,14 @@ static void test_memcpy_aligned_to_unaligned2(struct kunit *test)kunit_info ( test,"memcpy()ing aligned uninit src to unaligned dst - part 2 (UMR report)\n" ); -OPTIMIZER_HIDE_VAR (uninit_src); +DO_NOT_OPTIMIZE (uninit_src);memcpy ((void *)&dst[1 ], (void *)&uninit_src,sizeof (uninit_src));kmsan_check_memory ((void *)&dst[4 ],sizeof (uninit_src));KUNIT_EXPECT_TRUE (test,report_matches (&expect)); } -static noinline void fibonacci(int *array, int size, int start) { +static noinline void fibonacci(int *array, int size, int start) +{if (start <2 || (start == size))return ; array[start] = array[start -1 ] + array[start -2 ];@@ -482,8 +513,7 @@ static noinline void fibonacci(int *array, int size, int start) {static void test_long_origin_chain (struct kunit *test) { -EXPECTATION_UNINIT_VALUE_FN (expect, -"test_long_origin_chain" ); +EXPECTATION_UNINIT_VALUE_FN (expect,"test_long_origin_chain" );/* (KMSAN_MAX_ORIGIN_DEPTH * 2) recursive calls to fibonacci(). */ volatile int accum[KMSAN_MAX_ORIGIN_DEPTH *2 +2 ];int last =ARRAY_SIZE (accum) -1 ;@@ -515,6 +545,7 @@ static struct kunit_case kmsan_test_cases[] = {KUNIT_CASE (test_uaf),KUNIT_CASE (test_percpu_propagate),KUNIT_CASE (test_printk), +KUNIT_CASE (test_init_memcpy),KUNIT_CASE (test_memcpy_aligned_to_aligned),KUNIT_CASE (test_memcpy_aligned_to_unaligned), KUNIT_CASE(test_memcpy_aligned_to_unaligned2), --2.39.2.722.g9855ee24e9-goog
--
You received this message because you are subscribed to the Google Groups "kasan-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email to [email protected]. To view this discussion on the web visit https://groups.google.com/d/msgid/kasan-dev/20230301143933.2374658-2-glider%40google.com.
Alexander Potapenko
maintainerRe: [PATCH 2/4] kmsan: another take at fixing memcpy tests
Quoted 3 lines
Quoted 1 line
+#define
DO_NOT_OPTIMIZE(var)asm("" ::: "memory")That's just a normal "
barrier()" - use that instead?
Ok, will do (I still think I'd better hide it behind a macro so that we can change the implementation of DO_NOT_OPTIMIZE in the future if the compiler starts outsmarting us again.
Quoted 5 lines
Quoted 5 lines
mm/kmsan/kmsan_test.c +5
-0+/* +* Test case: ensure that memcpy() correctly copies initialized values. +*/ +static void test_init_memcpy (struct kunit *test) +{
Quoted 8 lines
mm/kmsan/kmsan_test.c static void test_printk(struct kunit *test) · line 429
Quoted 5 lines
mm/kmsan/kmsan_test.c +5
-0+EXPECTATION_NO_REPORT (expect); +volatile int src; +volatile int dst =0 ; + +// Ensure DO_NOT_OPTIMIZE() does not cause extra checks. ^^ this comment seems redundant now, given
DO_NOT_OPTIMIZE()has a comment (it's also using //-style comment).
Moved it to the test description:
/*
* Test case: ensure that memcpy() correctly copies initialized values.
* Also serves as a regression test to ensure DO_NOT_OPTIMIZE() does not cause
* extra checks.
*/
I think it's still relevant here.
Alexander Potapenko
maintainerPATCH 3/4 x86: kmsan: use C versions of memset16/memset32/memset64
In reply to Alexander PotapenkoKMSAN must see as many memory accesses as possible to prevent false positive reports. Fall back to versions of memset16()/memset32()/memset64() implemented in lib/string.c instead of those written in assembly.
--- arch/x86/include/asm/string_64.h | 6 ++++++ 1 file changed, 6 insertions(+)
arch/x86/include/asm/string_64.h +6 -0
@@ -22,6 +22,11 @@ extern void *__memcpy(void *to, const void *from, size_t len);void *memset (void *s,int c,size_t n);void *__memset (void *s,int c,size_t n); +/* +* KMSAN needs to instrument as much code as possible. Use C versions of +* memsetXX() from lib/string.c under KMSAN. +*/ +#if !defined(CONFIG_KMSAN )#define __HAVE_ARCH_MEMSET16static inline void *memset16 (uint16_t *s,uint16_t v,size_t n) {
@@ -57,6 +62,7 @@ static inline void *memset64(uint64_t *s, uint64_t v, size_t n) : "memory"); return s; } +#endif #define __HAVE_ARCH_MEMMOVEvoid *memmove (void *dest,const void *src,size_t count);
Signature · 1 line
2.39.2.722.g9855ee24e9-goog
Re: [PATCH 3/4] x86: kmsan: use C versions of memset16/memset32/memset64
Quoted 11 lines · Alexander Potapenko' via kasan-dev
KMSAN must see as many memory accesses as possible to prevent false positive reports. Fall back to versions of memset16()/memset32()/memset64() implemented in
lib/string.cinstead of those written in assembly.Cc Geert Uytterhoeven <[email protected]>Cc Daniel Vetter <[email protected]>Cc Helge Deller <[email protected]>Suggested-by Tetsuo Handa <[email protected]>Signed-off-by Alexander Potapenko <[email protected]>
Quoted 35 lines
--- arch/x86/include/asm/string_64.h | 6 ++++++ 1 file changed, 6 insertions(+)arch/x86/include/asm/string_64.h +6
-1@@ -22,6 +22,11 @@ extern void *__memcpy(void *to, const void *from, size_t len);void *memset (void *s,int c,size_t n);void *__memset (void *s,int c,size_t n); +/* +* KMSAN needs to instrument as much code as possible. Use C versions of +* memsetXX() from lib/string.c under KMSAN. +*/ +#if !defined(CONFIG_KMSAN )#define __HAVE_ARCH_MEMSET16static inline void *memset16 (uint16_t *s,uint16_t v,size_t n) {@@ -57,6 +62,7 @@ static inline void *memset64(uint64_t *s, uint64_t v, size_t n) : "memory"); return s; } +#endif #define __HAVE_ARCH_MEMMOVEvoid *memmove (void *dest,const void *src,size_t count); --2.39.2.722.g9855ee24e9-goog
--
You received this message because you are subscribed to the Google Groups "kasan-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email to [email protected]. To view this discussion on the web visit https://groups.google.com/d/msgid/kasan-dev/20230301143933.2374658-3-glider%40google.com.
Alexander Potapenko
maintainerPATCH 4/4 kmsan: add memsetXX tests
In reply to Alexander PotapenkoAdd tests ensuring that memset16()/memset32()/memset64() are instrumented by KMSAN and correctly initialize the memory.
--- mm/kmsan/kmsan_test.c | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+)
mm/kmsan/kmsan_test.c +22 -0
@@ -503,6 +503,25 @@ static void test_memcpy_aligned_to_unaligned2(struct kunit *test)KUNIT_EXPECT_TRUE (test,report_matches (&expect)); } +/* Generate test cases for memset16(), memset32(), memset64(). */ +#define DEFINE_TEST_MEMSETXX (size, var_ty) \ + static void test_memset##size(struct kunit *test) \ + { \ + EXPECTATION_NO_REPORT(expect); \ + volatile var_ty uninit; \ + \ + kunit_info(test, \ + "memset" #size "() should initialize memory\n"); \ + DO_NOT_OPTIMIZE(uninit); \ + memset##size((var_ty *)&uninit, 0, 1); \ + kmsan_check_memory((void *)&uninit, sizeof(uninit)); \ + KUNIT_EXPECT_TRUE(test, report_matches(&expect)); \ + } + +DEFINE_TEST_MEMSETXX(16, uint16_t) +DEFINE_TEST_MEMSETXX(32, uint32_t) +DEFINE_TEST_MEMSETXX(64, uint64_t) + static noinline void fibonacci(int *array, int size, int start) {if (start <2 || (start == size))
@@ -549,6 +568,9 @@ static struct kunit_case kmsan_test_cases[] = {KUNIT_CASE (test_memcpy_aligned_to_aligned),KUNIT_CASE (test_memcpy_aligned_to_unaligned),KUNIT_CASE (test_memcpy_aligned_to_unaligned2), +KUNIT_CASE (test_memset16), +KUNIT_CASE (test_memset32), +KUNIT_CASE (test_memset64), KUNIT_CASE(test_long_origin_chain), {}, };
Signature · 1 line
2.39.2.722.g9855ee24e9-goog
Marco Elver
reviewerRe: [PATCH 4/4] kmsan: add memsetXX tests
Quoted 14 lines · Alexander Potapenko
Add tests ensuring that memset16()/memset32()/memset64() are instrumented by KMSAN and correctly initialize the memory.
Signed-off-by Alexander Potapenko <[email protected]>--- mm/kmsan/kmsan_test.c | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+)mm/kmsan/kmsan_test.c +0
-0
mm/kmsan/kmsan_test.c static void test_memcpy_aligned_to_unaligned2(struct kunit *test) · line 511
Quoted 9 lines
mm/kmsan/kmsan_test.c +6
-0@@ -503,6 +503,25 @@ static void test_memcpy_aligned_to_unaligned2(struct kunit *test)KUNIT_EXPECT_TRUE (test,report_matches (&expect)); } +/* Generate test cases for memset16(), memset32(), memset64(). */ +#define DEFINE_TEST_MEMSETXX (size, var_ty) \ + static void test_memset##size(struct kunit *test) \ + { \ + EXPECTATION_NO_REPORT(expect); \ + volatile var_ty uninit; \
This could just be 'uint##size##_t' and you can drop 'var_ty'.
Quoted 29 lines
mm/kmsan/kmsan_test.c +16
-1+ \ + kunit_info(test, \ + "memset" #size "() should initialize memory\n"); \ + DO_NOT_OPTIMIZE(uninit); \ + memset##size((var_ty *)&uninit, 0, 1); \ + kmsan_check_memory((void *)&uninit, sizeof(uninit)); \ + KUNIT_EXPECT_TRUE(test, report_matches(&expect)); \ + } + +DEFINE_TEST_MEMSETXX(16, uint16_t) +DEFINE_TEST_MEMSETXX(32, uint32_t) +DEFINE_TEST_MEMSETXX(64, uint64_t) + static noinline void fibonacci(int *array, int size, int start) {if (start <2 || (start == size))@@ -549,6 +568,9 @@ static struct kunit_case kmsan_test_cases[] = {KUNIT_CASE (test_memcpy_aligned_to_aligned),KUNIT_CASE (test_memcpy_aligned_to_unaligned),KUNIT_CASE (test_memcpy_aligned_to_unaligned2), +KUNIT_CASE (test_memset16), +KUNIT_CASE (test_memset32), +KUNIT_CASE (test_memset64), KUNIT_CASE(test_long_origin_chain), {}, }; --2.39.2.722.g9855ee24e9-goog
Alexander Potapenko
maintainerRe: [PATCH 4/4] kmsan: add memsetXX tests
Quoted 19 lines · Marco Elver
Quoted 17 lines · Alexander Potapenko
Add tests ensuring that memset16()/memset32()/memset64() are instrumented by KMSAN and correctly initialize the memory.
Signed-off-by Alexander Potapenko <[email protected]>--- mm/kmsan/kmsan_test.c | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+)mm/kmsan/kmsan_test.c +0
-0@@ -503,6 +503,25 @@ static void test_memcpy_aligned_to_unaligned2(struct kunit *test)KUNIT_EXPECT_TRUE (test,report_matches (&expect)); }
Quoted 8 lines
mm/kmsan/kmsan_test.c static void test_memcpy_aligned_to_unaligned2(struct kunit *test) · line 511
Quoted 6 lines
mm/kmsan/kmsan_test.c +6
-0+/* Generate test cases for memset16(), memset32(), memset64(). */ +#define DEFINE_TEST_MEMSETXX (size, var_ty) \ + static void test_memset##size(struct kunit *test) \ + { \ + EXPECTATION_NO_REPORT(expect); \ + volatile var_ty uninit; \This could just be 'uint##size##_t' and you can drop '
var_ty'.
Indeed, thanks!
Quoted 2 lines · Alexander Potapenko
KMSAN should be overriding calls to memset/memcpy/memmove and their
You mean that the compiler will override calls?
All supported compilers that have fsanitize=kernel-memory replace memintrinsics with __msan_mem*() calls, right?
Quoted 8 lines
__builtin_versions in instrumented files, so there is no need to override them. In non-instrumented versions we are now required to leavememset()and friends intact, so we cannot replace them with__msan_XXX()functions.Cc Kees Cook <[email protected]>Suggested-by Marco Elver <[email protected]>Signed-off-by Alexander Potapenko <[email protected]>
Other than that,
Quoted 48 lines
--- arch/x86/include/asm/string_64.h | 17 ----------------- 1 file changed, 17 deletions(-)arch/x86/include/asm/string_64.h +0
-18@@ -15,22 +15,11 @@#endif #define __HAVE_ARCH_MEMCPY 1 -#if defined(__SANITIZE_MEMORY__) && defined(__NO_FORTIFY) -#undef memcpy -#define memcpy __msan_memcpy -#else extern void *memcpy (void *to,const void *from,size_t len); -#endif extern void *__memcpy (void *to,const void *from,size_t len);#define __HAVE_ARCH_MEMSET -#if defined(__SANITIZE_MEMORY__) && defined(__NO_FORTIFY) -extern void *__msan_memset (void *s,int c,size_t n); -#undef memset -#define memset __msan_memset -#else void *memset (void *s,int c,size_t n); -#endif void *__memset (void *s,int c,size_t n);#define __HAVE_ARCH_MEMSET16@@ -70,13 +59,7 @@ static inline void *memset64(uint64_t *s, uint64_t v, size_t n) }#define __HAVE_ARCH_MEMMOVE -#if defined(__SANITIZE_MEMORY__) && defined(__NO_FORTIFY) -#undef memmove -void *__msan_memmove (void *dest,const void *src,size_t len); -#define memmove __msan_memmove -#else void *memmove (void *dest,const void *src,size_t count); -#endif void *__memmove (void *dest,const void *src,size_t count);int memcmp (const void *cs,const void *ct,size_t count); --2.39.2.722.g9855ee24e9-goog
Alexander Potapenko
maintainerQuoted 8 lines · Marco Elver
Quoted 2 lines · Alexander Potapenko
KMSAN should be overriding calls to memset/memcpy/memmove and their
You mean that the compiler will override calls?
All supported compilers that have fsanitize=kernel-memory replace memintrinsics with __msan_mem*() calls, right?
Right. Changed to:
KMSAN already replaces calls to to memset/memcpy/memmove and their __builtin_ versions with __msan_memset/__msan_memcpy/__msan_memmove in instrumented files, so there is no need to override them.
Quoted 6 lines
Quoted 6 lines
__builtin_versions in instrumented files, so there is no need to override them. In non-instrumented versions we are now required to leavememset()and friends intact, so we cannot replace them with__msan_XXX()functions.
Quoted 7 lines
Quoted 3 lines
Cc Kees Cook <[email protected]>Suggested-by Marco Elver <[email protected]>Signed-off-by Alexander Potapenko <[email protected]>Other than that,
Reviewed-by Marco Elver <[email protected]>
Thanks!
Marco Elver
reviewerQuoted 11 lines · Alexander Potapenko
Quoted 8 lines · Marco Elver
Quoted 2 lines · Alexander Potapenko
KMSAN should be overriding calls to memset/memcpy/memmove and their
You mean that the compiler will override calls?
All supported compilers that have fsanitize=kernel-memory replace memintrinsics with __msan_mem*() calls, right?
Quoted 5 lines
Right. Changed to:
KMSAN already replaces calls to to memset/memcpy/memmove and their
__builtin_versions with __msan_memset/__msan_memcpy/__msan_memmove in instrumented files, so there is no need to override them.
But it's not KMSAN - KMSAN is the combined end result of runtime and compiler - in this case we need to be specific and point out it's the compiler that's doing it. There is no code in the Linux kernel that does this replacement.
Quoted 15 lines
Quoted 7 lines
Quoted 7 lines
__builtin_versions in instrumented files, so there is no need to override them. In non-instrumented versions we are now required to leavememset()and friends intact, so we cannot replace them with__msan_XXX()functions.Quoted 7 lines
Quoted 3 lines
Cc Kees Cook <[email protected]>Suggested-by Marco Elver <[email protected]>Signed-off-by Alexander Potapenko <[email protected]>Other than that,
Reviewed-by Marco Elver <[email protected]>Thanks!
Alexander Potapenko
maintainerQuoted 15 lines · Marco Elver
Quoted 13 lines · Alexander Potapenko
Quoted 8 lines · Marco Elver
Quoted 2 lines · Alexander Potapenko
KMSAN should be overriding calls to memset/memcpy/memmove and their
You mean that the compiler will override calls?
All supported compilers that have fsanitize=kernel-memory replace memintrinsics with __msan_mem*() calls, right?Right. Changed to:
Quoted 8 lines
Quoted 3 lines
KMSAN already replaces calls to to memset/memcpy/memmove and their
__builtin_versions with __msan_memset/__msan_memcpy/__msan_memmove in instrumented files, so there is no need to override them.But it's not KMSAN - KMSAN is the combined end result of runtime and compiler - in this case we need to be specific and point out it's the compiler that's doing it. There is no code in the Linux kernel that does this replacement.
Agreed. I'll replace with "clang -fsanitize=kernel-memory"