kmsan: allow disabling KMSAN checks for the current task

Like for KASAN, it's useful to temporarily disable KMSAN checks around,
e.g., redzone accesses.  Introduce kmsan_disable_current() and
kmsan_enable_current(), which are similar to their KASAN counterparts.

Make them reentrant in order to handle memory allocations in interrupt
context.  Repurpose the allow_reporting field for this.

Link: https://lkml.kernel.org/r/20240621113706.315500-12-iii@linux.ibm.com
Signed-off-by: Ilya Leoshkevich <iii@linux.ibm.com>
Reviewed-by: Alexander Potapenko <glider@google.com>
Cc: Alexander Gordeev <agordeev@linux.ibm.com>
Cc: Christian Borntraeger <borntraeger@linux.ibm.com>
Cc: Christoph Lameter <cl@linux.com>
Cc: David Rientjes <rientjes@google.com>
Cc: Dmitry Vyukov <dvyukov@google.com>
Cc: Heiko Carstens <hca@linux.ibm.com>
Cc: Hyeonggon Yoo <42.hyeyoo@gmail.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: <kasan-dev@googlegroups.com>
Cc: Marco Elver <elver@google.com>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Masami Hiramatsu (Google) <mhiramat@kernel.org>
Cc: Pekka Enberg <penberg@kernel.org>
Cc: Roman Gushchin <roman.gushchin@linux.dev>
Cc: Steven Rostedt (Google) <rostedt@goodmis.org>
Cc: Sven Schnelle <svens@linux.ibm.com>
Cc: Vasily Gorbik <gor@linux.ibm.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/Documentation/dev-tools/kmsan.rst b/Documentation/dev-tools/kmsan.rst
index 323eedad53cd3b94cc2107f7cdaaf2a4bd1d391a..6a48d96c5c85b31d3c34d74a390355dd3c66a77d 100644 (file)
--- a/Documentation/dev-tools/kmsan.rst
+++ b/Documentation/dev-tools/kmsan.rst
@@ -110,6 +110,13 @@ in the Makefile. Think of this as applying ``__no_sanitize_memory`` to every
 function in the file or directory. Most users won't need KMSAN_SANITIZE, unless
 their code gets broken by KMSAN (e.g. runs at early boot time).
 
+KMSAN checks can also be temporarily disabled for the current task using
+``kmsan_disable_current()`` and ``kmsan_enable_current()`` calls. Each
+``kmsan_enable_current()`` call must be preceded by a
+``kmsan_disable_current()`` call; these call pairs may be nested. One needs to
+be careful with these calls, keeping the regions short and preferring other
+ways to disable instrumentation, where possible.
+
 Support
 =======
 
@@ -338,11 +345,11 @@ Per-task KMSAN state
 ~~~~~~~~~~~~~~~~~~~~
 
 Every task_struct has an associated KMSAN task state that holds the KMSAN
-context (see above) and a per-task flag disallowing KMSAN reports::
+context (see above) and a per-task counter disallowing KMSAN reports::
 
   struct kmsan_context {
     ...
-    bool allow_reporting;
+    unsigned int depth;
     struct kmsan_context_state cstate;
     ...
   }

diff --git a/include/linux/kmsan.h b/include/linux/kmsan.h
index fe6c2212bdb1bded6fb48ce387f85020da357884..14b5ea6d3a43d7d8a7a10664181f0e6cedbaf679 100644 (file)
--- a/include/linux/kmsan.h
+++ b/include/linux/kmsan.h
@@ -239,6 +239,22 @@ void kmsan_unpoison_entry_regs(const struct pt_regs *regs);
  */
 void *kmsan_get_metadata(void *addr, bool is_origin);
 
+/**
+ * kmsan_enable_current(): Enable KMSAN for the current task.
+ *
+ * Each kmsan_enable_current() current call must be preceded by a
+ * kmsan_disable_current() call. These call pairs may be nested.
+ */
+void kmsan_enable_current(void);
+
+/**
+ * kmsan_disable_current(): Disable KMSAN for the current task.
+ *
+ * Each kmsan_disable_current() current call must be followed by a
+ * kmsan_enable_current() call. These call pairs may be nested.
+ */
+void kmsan_disable_current(void);
+
 #else
 
 static inline void kmsan_init_shadow(void)
@@ -338,6 +354,14 @@ static inline void kmsan_unpoison_entry_regs(const struct pt_regs *regs)
 {
 }
 
+static inline void kmsan_enable_current(void)
+{
+}
+
+static inline void kmsan_disable_current(void)
+{
+}
+
 #endif
 
 #endif /* _LINUX_KMSAN_H */

diff --git a/include/linux/kmsan_types.h b/include/linux/kmsan_types.h
index 929287981afe4f08c74e4ba2bc725db82af85951..dfc59918b3c0341f450f6440043bc667fc778241 100644 (file)
--- a/include/linux/kmsan_types.h
+++ b/include/linux/kmsan_types.h
@@ -31,7 +31,7 @@ struct kmsan_context_state {
 struct kmsan_ctx {
        struct kmsan_context_state cstate;
        int kmsan_in_runtime;
-       bool allow_reporting;
+       unsigned int depth;
 };
 
 #endif /* _LINUX_KMSAN_TYPES_H */

diff --git a/mm/kmsan/core.c b/mm/kmsan/core.c
index 95f859e38c533d57f5ae637d69ad95bea4a1029e..81b22220711a40ad582c46a71eb0e714c8208c80 100644 (file)
--- a/mm/kmsan/core.c
+++ b/mm/kmsan/core.c
@@ -43,7 +43,6 @@ void kmsan_internal_task_create(struct task_struct *task)
        struct thread_info *info = current_thread_info();
 
        __memset(ctx, 0, sizeof(*ctx));
-       ctx->allow_reporting = true;
        kmsan_internal_unpoison_memory(info, sizeof(*info), false);
 }
 

diff --git a/mm/kmsan/hooks.c b/mm/kmsan/hooks.c
index b408714f9ba31d6f3e6fc5df668204e7651bb167..267d0afa2e8ba49da770a599c7767062bee32192 100644 (file)
--- a/mm/kmsan/hooks.c
+++ b/mm/kmsan/hooks.c
@@ -39,12 +39,10 @@ void kmsan_task_create(struct task_struct *task)
 
 void kmsan_task_exit(struct task_struct *task)
 {
-       struct kmsan_ctx *ctx = &task->kmsan_ctx;
-
        if (!kmsan_enabled || kmsan_in_runtime())
                return;
 
-       ctx->allow_reporting = false;
+       kmsan_disable_current();
 }
 
 void kmsan_slab_alloc(struct kmem_cache *s, void *object, gfp_t flags)
@@ -424,3 +422,17 @@ void kmsan_check_memory(const void *addr, size_t size)
                                           REASON_ANY);
 }
 EXPORT_SYMBOL(kmsan_check_memory);
+
+void kmsan_enable_current(void)
+{
+       KMSAN_WARN_ON(current->kmsan_ctx.depth == 0);
+       current->kmsan_ctx.depth--;
+}
+EXPORT_SYMBOL(kmsan_enable_current);
+
+void kmsan_disable_current(void)
+{
+       current->kmsan_ctx.depth++;
+       KMSAN_WARN_ON(current->kmsan_ctx.depth == 0);
+}
+EXPORT_SYMBOL(kmsan_disable_current);

diff --git a/mm/kmsan/report.c b/mm/kmsan/report.c
index c79d3b0d2d0d26645aaa441c874ee1322fc2d691..92e73ec6143529ac8b5983fb333c0127af4d2a24 100644 (file)
--- a/mm/kmsan/report.c
+++ b/mm/kmsan/report.c
@@ -8,6 +8,7 @@
  */
 
 #include <linux/console.h>
+#include <linux/kmsan.h>
 #include <linux/moduleparam.h>
 #include <linux/stackdepot.h>
 #include <linux/stacktrace.h>
@@ -158,12 +159,12 @@ void kmsan_report(depot_stack_handle_t origin, void *address, int size,
 
        if (!kmsan_enabled)
                return;
-       if (!current->kmsan_ctx.allow_reporting)
+       if (current->kmsan_ctx.depth)
                return;
        if (!origin)
                return;
 
-       current->kmsan_ctx.allow_reporting = false;
+       kmsan_disable_current();
        ua_flags = user_access_save();
        raw_spin_lock(&kmsan_report_lock);
        pr_err("=====================================================\n");
@@ -216,5 +217,5 @@ void kmsan_report(depot_stack_handle_t origin, void *address, int size,
        if (panic_on_kmsan)
                panic("kmsan.panic set ...\n");
        user_access_restore(ua_flags);
-       current->kmsan_ctx.allow_reporting = true;
+       kmsan_enable_current();
 }

diff --git a/tools/objtool/check.c b/tools/objtool/check.c
index 0a33d9195b7a9112df7824899d7564081e3d8782..01237d16722387ed5167803540cde442be63185e 100644 (file)
--- a/tools/objtool/check.c
+++ b/tools/objtool/check.c
@@ -1202,6 +1202,8 @@ static const char *uaccess_safe_builtin[] = {
        "__sanitizer_cov_trace_switch",
        /* KMSAN */
        "kmsan_copy_to_user",
+       "kmsan_disable_current",
+       "kmsan_enable_current",
        "kmsan_report",
        "kmsan_unpoison_entry_regs",
        "kmsan_unpoison_memory",