Skip to contentSkip to conversation

x86: kmsan: Don't rename memintrinsics in uninstrumented files

PATCH In review Alexander Potapenko 2 participants 13 messages Mar 1, 2023 – Mar 2, 2023

Subsystems (3)
lore
Share & tools
lore

Alexander Potapenko

author maintainer
#0 lore raw

PATCH 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
index 888731ccf1f67..9be401d971a99 100644
@@ -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
author maintainer
#1 lore raw

PATCH 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
index 088e21a48dc4b..cc98a3f4e0899 100644
@@ -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
reviewer
#2 lore raw

Re: [PATCH 2/4] kmsan: another take at fixing memcpy tests

Quoted 26 lines · Alexander Potapenko' via kasan-dev

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 +0 -0
index 088e21a48dc4b..cc98a3f4e0899 100644
@@ -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.

author maintainer
#3 lore raw

Re: [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.

author maintainer
#4 lore raw

PATCH 3/4 x86: kmsan: use C versions of memset16/memset32/memset64

In reply to Alexander Potapenko

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.c instead of those written in assembly.

Cc Geert Uytterhoeven <[email protected]>
Cc Daniel Vetter <[email protected]>
Cc Helge Deller <[email protected]>
---
 arch/x86/include/asm/string_64.h | 6 ++++++
 1 file changed, 6 insertions(+)
arch/x86/include/asm/string_64.h +6 -0
index 9be401d971a99..e9c736f4686f5 100644
@@ -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_MEMSET16
 static 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_MEMMOVE
 void *memmove(void *dest, const void *src, size_t count);
Signature · 1 line
2.39.2.722.g9855ee24e9-goog
reviewer Reviewed-by on v1 3/4
#5 lore raw

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.c instead of those written in assembly.

Cc Geert Uytterhoeven <[email protected]>
Cc Daniel Vetter <[email protected]>
Cc Helge Deller <[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
index 9be401d971a99..e9c736f4686f5 100644
@@ -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_MEMSET16
 static 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_MEMMOVE
 void *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.

author maintainer
#6 lore raw

PATCH 4/4 kmsan: add memsetXX tests

In reply to Alexander Potapenko

Add 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
index cc98a3f4e0899..e450a000441fb 100644
@@ -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
reviewer
#7 lore raw

Re: [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.

---
 mm/kmsan/kmsan_test.c | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
mm/kmsan/kmsan_test.c +0 -0
index cc98a3f4e0899..e450a000441fb 100644

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

author maintainer
#8 lore raw

Re: [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.

---
 mm/kmsan/kmsan_test.c | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
mm/kmsan/kmsan_test.c +0 -0
index cc98a3f4e0899..e450a000441fb 100644
@@ -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!

reviewer Reviewed-by on v1 1/4
#9 lore raw
In reply to Alexander Potapenko
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 leave memset() and friends intact, so we cannot replace them with __msan_XXX() functions.

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
index 888731ccf1f67..9be401d971a99 100644
@@ -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

author maintainer
#10 lore raw
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:

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 leave memset() and friends intact, so we cannot replace them with __msan_XXX() functions.

Quoted 7 lines
Quoted 3 lines

Other than that,

Thanks!

reviewer
#11 lore raw
Quoted 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 leave memset() and friends intact, so we cannot replace them with __msan_XXX() functions.

Quoted 7 lines
Quoted 3 lines

Other than that,

Thanks!

author maintainer
#12 lore raw
Quoted 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"