kmsan: Enable on s390
Subsystems (12)
v3 cover kmsan: Enable on s390
v2: https://lore.kernel.org/lkml/[email protected]/
v2 -> v3: Drop kmsan_memmove_metadata() and strlcpy() patches;
Remove kmsan_get_metadata() stub;
Move kmsan_enable_current() and kmsan_disable_current() to include/linux/kmsan.h, explain why a counter is needed; Drop the memset_no_sanitize_memory() patch;
Use __memset() in the SLAB_POISON patch;
Add kmsan-checks.h to the DFLTCC patch;
Add recursion check to the arch_kmsan_get_meta_or_null() patch (Alexander P.).
Fix inline + __no_kmsan_checks issues.
New patch for s390/irqflags, that resolves a lockdep warning. New patch for s390/diag, that resolves a false positive when running on an LPAR.
New patch for STCCTM, same as above.
New patch for check_bytes_and_report() that resolves a false positive that occurs even on Intel.
v1: https://lore.kernel.org/lkml/[email protected]/
v1 -> v2: Add comments, sort #includes, introduce
memset_no_sanitize_memory() and use it to avoid unpoisoning of redzones, change vmalloc alignment to _REGION3_SIZE, add R-bs (Alexander P.).
Fix building
[PATCH 28/33] s390/string: Add KMSAN support with FORTIFY_SOURCE.
Hi,
This series provides the minimal support for Kernel Memory Sanitizer on s390. Kernel Memory Sanitizer is clang-only instrumentation for finding accesses to uninitialized memory. The clang support for s390 has already been merged [1].
With this series, I can successfully boot s390 defconfig and debug_defconfig with kmsan.panic=1. The tool found one real s390-specific bug (fixed in master).
Best regards,
Ilya
[1] https://reviews.llvm.org/D148596
Ilya Leoshkevich (34):
ftrace: Unpoison ftrace_regs in ftrace_ops_list_func()
kmsan: Make the tests compatible with kmsan.panic=1
kmsan: Disable KMSAN when DEFERRED_STRUCT_PAGE_INIT is enabled
kmsan: Increase the maximum store size to 4096
kmsan: Fix is_bad_asm_addr() on arches with overlapping address spaces
kmsan: Fix kmsan_copy_to_user() on arches with overlapping address
spaces
kmsan: Remove a useless assignment from
kmsan_vmap_pages_range_noflush()
kmsan: Remove an x86-specific #include from kmsan.h
kmsan: Expose kmsan_get_metadata()
kmsan: Export panic_on_kmsan
kmsan: Allow disabling KMSAN checks for the current task
kmsan: Support SLAB_POISON
kmsan: Use ALIGN_DOWN() in kmsan_get_metadata()
mm: slub: Let KMSAN access metadata
mm: slub: Unpoison the memchr_inv() return value
mm: kfence: Disable KMSAN when checking the canary lib/zlib: Unpoison DFLTCC output buffers
kmsan: Accept ranges starting with 0 on s390
s390: Turn off KMSAN for boot, vdso and purgatory
s390: Use a larger stack for KMSAN
s390/boot: Add the KMSAN runtime stub
s390/checksum: Add a KMSAN check
s390/cpacf: Unpoison the results of cpacf_trng() s390/cpumf: Unpoison STCCTM output buffer
s390/diag: Unpoison diag224() output buffer
s390/ftrace: Unpoison ftrace_regs in kprobe_ftrace_handler() s390/irqflags: Do not instrument arch_local_irq_*() with KMSAN s390/mm: Define KMSAN metadata for vmalloc and modules s390/string: Add KMSAN support
s390/traps: Unpoison the kernel_stack_overflow()'s pt_regs s390/uaccess: Add KMSAN support to put_user() and get_user() s390/unwind: Disable KMSAN checks
s390: Implement the architecture-specific kmsan functions
kmsan: Enable on s390
Documentation/dev-tools/kmsan.rst | 4 +- arch/s390/Kconfig | 1 + arch/s390/Makefile | 2 +- arch/s390/boot/Makefile | 3 + arch/s390/boot/kmsan.c | 6 ++ arch/s390/boot/startup.c | 8 ++ arch/s390/boot/string.c | 16 ++++ arch/s390/include/asm/checksum.h | 2 + arch/s390/include/asm/cpacf.h | 3 + arch/s390/include/asm/cpu_mf.h | 6 ++ arch/s390/include/asm/irqflags.h | 18 ++++- arch/s390/include/asm/kmsan.h | 43 +++++++++++ arch/s390/include/asm/pgtable.h | 10 +++ arch/s390/include/asm/string.h | 20 +++-- arch/s390/include/asm/thread_info.h | 2 +- arch/s390/include/asm/uaccess.h | 111 ++++++++++++++++++++-------- arch/s390/kernel/diag.c | 2 + arch/s390/kernel/ftrace.c | 2 + arch/s390/kernel/traps.c | 6 ++ arch/s390/kernel/unwind_bc.c | 4 + arch/s390/kernel/vdso32/Makefile | 3 +- arch/s390/kernel/vdso64/Makefile | 3 +- arch/s390/purgatory/Makefile | 2 + drivers/s390/char/sclp.c | 2 +- include/linux/kmsan.h | 33 +++++++++ include/linux/kmsan_types.h | 2 +- kernel/trace/ftrace.c | 1 + lib/zlib_dfltcc/dfltcc.h | 1 + lib/zlib_dfltcc/dfltcc_util.h | 24 ++++++ mm/Kconfig | 1 + mm/kfence/core.c | 11 ++- mm/kmsan/core.c | 1 - mm/kmsan/hooks.c | 23 ++++-- mm/kmsan/init.c | 5 +- mm/kmsan/instrumentation.c | 11 +-- mm/kmsan/kmsan.h | 9 +-- mm/kmsan/kmsan_test.c | 5 ++ mm/kmsan/report.c | 8 +- mm/kmsan/shadow.c | 9 +-- mm/slub.c | 17 ++++- 40 files changed, 360 insertions(+), 80 deletions(-) create mode 100644 arch/s390/boot/kmsan.c create mode 100644 arch/s390/include/asm/kmsan.h
Signature · 1 line
2.43.0
PATCH v3 1/34 ftrace: Unpoison ftrace_regs in ftrace_ops_list_func()
Architectures use assembly code to initialize ftrace_regs and call ftrace_ops_list_func(). Therefore, from the KMSAN's point of view, ftrace_regs is poisoned on ftrace_ops_list_func entry(). This causes KMSAN warnings when running the ftrace testsuite.
Fix by trusting the architecture-specific assembly code and always unpoisoning ftrace_regs in ftrace_ops_list_func.
--- kernel/trace/ftrace.c | 1 + 1 file changed, 1 insertion(+)
kernel/trace/ftrace.c +1 -0
@@ -7399,6 +7399,7 @@ __ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,void arch_ftrace_ops_list_func (unsigned long ip,unsigned long parent_ip,struct ftrace_ops *op,struct ftrace_regs *fregs) { +kmsan_unpoison_memory (fregs,sizeof (*fregs));__ftrace_ops_list_func (ip, parent_ip,NULL , fregs); }#else
Signature · 1 line
2.43.0
Steven Rostedt
maintainerRe: [PATCH v3 01/34] ftrace: Unpoison ftrace_regs in ftrace_ops_list_func()
Quoted 4 lines · On Thu, 14 Dec 2023 00:24:21 +0100 Ilya Leoshkevich <[email protected]> wrote:
Architectures use assembly code to initialize
ftrace_regsand callftrace_ops_list_func(). Therefore, from the KMSAN's point of view,ftrace_regsis poisoned onftrace_ops_list_funcentry(). This causes KMSAN warnings when running the ftrace testsuite.
BTW, why is this only a problem for s390 and no other architectures?
If it is only a s390 thing, then we should do this instead:
in include/linux/ftrace.h:
/* Add a comment here to why this is needed */
#ifndef ftrace_list_func_unpoison
# define ftrace_list_func_unpoison(fregs) do { } while(0)
#endifIn arch/s390/include/asm/ftrace.h:
/* Add a comment to why s390 is special */
# define ftrace_list_func_unpoison(fregs) kmsan_unpoison_memory(fregs, sizeof(*fregs))
Quoted 5 lines
Fix by trusting the architecture-specific assembly code and always unpoisoning
ftrace_regsinftrace_ops_list_func.
I'm taking my ack away for this change in favor of what I'm suggesting now.
Quoted 11 lines
Reviewed-by Alexander Potapenko <[email protected]>Signed-off-by Ilya Leoshkevich <[email protected]>--- kernel/trace/ftrace.c | 1 + 1 file changed, 1 insertion(+)kernel/trace/ftrace.c +0
-0
kernel/trace/ftrace.c __ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip, · line 7402
Quoted 4 lines
kernel/trace/ftrace.c +1
-0@@ -7399,6 +7399,7 @@ __ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,void arch_ftrace_ops_list_func (unsigned long ip,unsigned long parent_ip,struct ftrace_ops *op,struct ftrace_regs *fregs) { +kmsan_unpoison_memory (fregs,sizeof (*fregs));
And here have:
ftrace_list_func_unpoison(fregs);
That way we only do it for archs that really need it, and do not affect archs that do not.
I want to know why this only affects s390, because if we are just doing this because "it works", it could be just covering up a symptom of something else and not actually doing the "right thing".
-- Steve
Quoted 3 lines
kernel/trace/ftrace.c +0
-0__ftrace_ops_list_func(ip, parent_ip, NULL, fregs); }#else
Re: [PATCH v3 01/34] ftrace: Unpoison ftrace_regs in ftrace_ops_list_func()
Quoted 63 lines · Steven Rostedt
Quoted 5 lines · On Thu, 14 Dec 2023 00:24:21 +0100 Ilya Leoshkevich <[email protected]> wrote:
Architectures use assembly code to initialize
ftrace_regsand callftrace_ops_list_func(). Therefore, from the KMSAN's point of view,ftrace_regsis poisoned onftrace_ops_list_funcentry(). This causes
KMSAN warnings when running the ftrace testsuite.BTW, why is this only a problem for s390 and no other architectures?
If it is only a s390 thing, then we should do this instead:
in
include/linux/ftrace.h:/* Add a comment here to why this is needed */
#ifndefftrace_list_func_unpoison# define ftrace_list_func_unpoison(fregs) do { } while(0) #endifIn
arch/s390/include/asm/ftrace.h:/* Add a comment to why s390 is special */
# define ftrace_list_func_unpoison(fregs) kmsan_unpoison_memory(fregs, sizeof(*fregs))Quoted 5 lines
Fix by trusting the architecture-specific assembly code and always unpoisoning
ftrace_regsinftrace_ops_list_func.I'm taking my ack away for this change in favor of what I'm suggesting now.
Quoted 17 lines
Reviewed-by Alexander Potapenko <[email protected]>Signed-off-by Ilya Leoshkevich <[email protected]>---
kernel/trace/ftrace.c | 1 +1 file changed, 1 insertion(+)kernel/trace/ftrace.c +0
-0@@ -7399,6 +7399,7 @@ __ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,void arch_ftrace_ops_list_func(unsigned long ip, unsigned long
parent_ip,
structftrace_ops*op, structftrace_regs*fregs)
{kernel/trace/ftrace.c __ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip, · line 7402
Quoted 1 line
kernel/trace/ftrace.c +1
-0+kmsan_unpoison_memory (fregs,sizeof (*fregs));And here have:
ftrace_list_func_unpoison(fregs);That way we only do it for archs that really need it, and do not affect
archs that do not.
Quoted 13 lines
I want to know why this only affects s390, because if we are just doing
this because "it works", it could be just covering up a symptom of something else and not actually doing the "right thing".-- Steve
Quoted 3 lines
__ftrace_ops_list_func(ip, parent_ip, NULL, fregs); }
#else
Ok, it has been a while, but I believe I have a good answer now. KMSAN shadow for memory above $rsp is essentially random. Here is an example (you'll need a GDB hack from [1] if you want to try this at home):
(gdb) x/5i do_nanosleep
0xffffffff843607c0 <do_nanosleep>: call 0xffffffffc0201000
Thread 3 hit Breakpoint 1, 0xffffffffc0201000 in ?? () (gdb) x/64bx kmsan_get_metadata($rsp - 64, 0)0xffffd1000087bd38: 0x00 0x00 0x00 0x00 0x00 0x000x00 0x000xffffd1000087bd40: 0x00 0x00 0x00 0x00 0x00 0x000x00 0x000xffffd1000087bd48: 0x00 0x00 0x00 0x00 0x00 0x000x00 0x000xffffd1000087bd50: 0x00 0x00 0x00 0x00 0xff 0xff0xff 0xff0xffffd1000087bd58: 0x00 0x00 0x00 0x00 0x00 0x000x00 0x000xffffd1000087bd60: 0xff 0xff 0xff 0xff 0xff 0xff0xff 0xff0xffffd1000087bd68: 0xff 0xff 0xff 0xff 0xff 0xff0xff 0xff0xffffd1000087bd70: 0xff 0xff 0xff 0xff 0xff 0xff0xff 0xff
So if assembly (in this case ftrace_regs_caller) allocates struct pt_regs on stack, it may or may not be poisoned depending on what was called before. So, by accident, on s390x it's poisoned and trips KMSAN, and on x86_64 it's not. Based on this observation, I'd say we need an unpoison call in all ftrace handlers (e.g., kprobe_ftrace_handler), and not just this one.
But why is this the case? Kernel stacks are created by alloc_thread_stack_node() using __vmalloc_node_range(__GFP_ZERO), so they are fully unpoisoned. Then functions are called and return, their locals are poisoned and unpoisoned. Interestingly enough, on return, they are not poisoned back, even though
commit 37ad4ee8364255c73026a3c343403b5977fa7e79
Author: Alexander Potapenko <[email protected]> Date: Thu Sep 15 17:04:13 2022 +0200
x86: kmsan: don't instrument stack walking functions
says they do. So what if we introduce that [2]?
# echo "p:nanosleep do_nanosleep %di"
Quoted 1 line
/sys/kernel/tracing/kprobe_events
# echo 1 >/sys/kernel/debug/tracing/events/kprobes/nanosleep/enable # sleep 1 ===================================================== BUG: KMSAN: uninit-value in kprobe_ftrace_handler+0x5b9/0x790 kprobe_ftrace_handler+0x5b9/0x790 0xffffffffc02010de do_nanosleep+0x5/0x670 hrtimer_nanosleep+0x169/0x3b0 common_nsleep+0xc7/0x100 __x64_sys_clock_nanosleep+0x4e2/0x650 do_syscall_64+0x6e/0x120 entry_SYSCALL_64_after_hwframe+0x76/0x7e
Local variable nd created at:
do_filp_open+0x3b2/0x5e0
Quite similar to s390. Local variable nd is a random leftover from a different call stack, which the modified instrumentation poisoned on return from do_filp_open().
Alexander, what do you think about adding [2] upstream as an option that can be enabled from the command line? Also, what do you think about poisoning kernel stacks? Formally they are zeroed out, but I think valid code has no business reading these zeroes.
[1] https://sourceware.org/bugzilla/show_bug.cgi?id=31878
[2]
https://github.com/iii-i/llvm-project/commits/msan-poison-allocas-before-returning-2024-06-12/
PATCH v3 2/34 kmsan: Make the tests compatible with kmsan.panic=1
In reply to Ilya LeoshkevichIt's useful to have both tests and kmsan.panic=1 during development, but right now the warnings, that the tests cause, lead to kernel panics.
Temporarily set kmsan.panic=0 for the duration of the KMSAN testing.
--- mm/kmsan/kmsan_test.c | 5 +++++ 1 file changed, 5 insertions(+)
mm/kmsan/kmsan_test.c +5 -0
@@ -659,9 +659,13 @@ static void test_exit(struct kunit *test) { } +static int orig_panic_on_kmsan; +static int kmsan_suite_init (struct kunit_suite *suite) {register_trace_console (probe_console,NULL ); + orig_panic_on_kmsan = panic_on_kmsan; + panic_on_kmsan =0 ;return 0 ; }
@@ -669,6 +673,7 @@ static void kmsan_suite_exit(struct kunit_suite *suite) {unregister_trace_console (probe_console,NULL );tracepoint_synchronize_unregister (); + panic_on_kmsan = orig_panic_on_kmsan; }static struct kunit_suite kmsan_test_suite = {
Signature · 1 line
2.43.0
PATCH v3 3/34 kmsan: Disable KMSAN when DEFERRED_STRUCT_PAGE_INIT is enabled
In reply to Ilya LeoshkevichKMSAN relies on memblock returning all available pages to it (see kmsan_memblock_free_pages()). It partitions these pages into 3
categories: pages available to the buddy allocator, shadow pages and origin pages. This partitioning is static.
If new pages appear after kmsan_init_runtime(), it is considered an error. DEFERRED_STRUCT_PAGE_INIT causes this, so mark it as incompatible with KMSAN.
--- mm/Kconfig | 1 + 1 file changed, 1 insertion(+)
mm/Kconfig +1 -0
@@ -985,6 +985,7 @@ config DEFERRED_STRUCT_PAGE_INIT depends on SPARSEMEM depends on !NEED_PER_CPU_KM depends on 64BIT + depends on !KMSAN select PADATA help Ordinarily all struct pages are initialised during early boot in a
Signature · 1 line
2.43.0
PATCH v3 4/34 kmsan: Increase the maximum store size to 4096
In reply to Ilya LeoshkevichThe inline assembly block in s390's chsc() stores that much.
--- mm/kmsan/instrumentation.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-)
mm/kmsan/instrumentation.c +3 -4
@@ -110,11 +110,10 @@ void __msan_instrument_asm_store(void *addr, uintptr_t size) ua_flags =user_access_save ();/* -* Most of the accesses are below 32 bytes. The two exceptions so far -* are clwb() (64 bytes) and FPU state (512 bytes). -* It's unlikely that the assembly will touch more than 512 bytes. +* Most of the accesses are below 32 bytes. The exceptions so far are +* clwb() (64 bytes), FPU state (512 bytes) and chsc() (4096 bytes). */ -if (size >512 ) { +if (size >4096 ) {WARN_ONCE (1 ,"assembly store size too big: %ld\n" , size); size =8 ; }
Signature · 1 line
2.43.0
PATCH v3 5/34 kmsan: Fix is_bad_asm_addr() on arches with overlapping address spaces
In reply to Ilya LeoshkevichComparing pointers with TASK_SIZE does not make sense when kernel and userspace overlap. Skip the comparison when this is the case.
--- mm/kmsan/instrumentation.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
mm/kmsan/instrumentation.c +2 -1
@@ -20,7 +20,8 @@static inline bool is_bad_asm_addr (void *addr,uintptr_t size,bool is_store) { -if ((u64 )addr <TASK_SIZE ) +if (IS_ENABLED (CONFIG_ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE ) && + (u64 )addr <TASK_SIZE )return true;if (!kmsan_get_metadata (addr,KMSAN_META_SHADOW ))return true;
Signature · 1 line
2.43.0
PATCH v3 6/34 kmsan: Fix kmsan_copy_to_user() on arches with overlapping address spaces
In reply to Ilya LeoshkevichComparing pointers with TASK_SIZE does not make sense when kernel and userspace overlap. Assume that we are handling user memory access in this case.
--- mm/kmsan/hooks.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
mm/kmsan/hooks.c +2 -1
@@ -267,7 +267,8 @@ void kmsan_copy_to_user(void __user *to, const void *from, size_t to_copy,return ; ua_flags =user_access_save (); -if ((u64 )to <TASK_SIZE ) { +if (!IS_ENABLED (CONFIG_ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE ) || + (u64 )to <TASK_SIZE ) {/* This is a user memory access, check it. */ kmsan_internal_check_memory ((void *)from, to_copy - left, to,REASON_COPY_TO_USER );
Signature · 1 line
2.43.0
PATCH v3 7/34 kmsan: Remove a useless assignment from kmsan_vmap_pages_range_noflush()
In reply to Ilya LeoshkevichThe value assigned to prot is immediately overwritten on the next line with PAGE_KERNEL. The right hand side of the assignment has no side-effects.
--- mm/kmsan/shadow.c | 1 - 1 file changed, 1 deletion(-)
mm/kmsan/shadow.c +0 -1
@@ -243,7 +243,6 @@ int kmsan_vmap_pages_range_noflush(unsigned long start, unsigned long end, s_pages[i] =shadow_page_for (pages[i]); o_pages[i] =origin_page_for (pages[i]); } - prot =__pgprot (pgprot_val (prot) | _PAGE_NX); prot =PAGE_KERNEL ; origin_start =vmalloc_meta ((void *)start,KMSAN_META_ORIGIN );
Signature · 1 line
2.43.0
PATCH v3 8/34 kmsan: Remove an x86-specific #include from kmsan.h
In reply to Ilya LeoshkevichReplace the x86-specific asm/pgtable_64_types.h #include with the linux/pgtable.h one, which all architectures have.
While at it, sort the headers alphabetically for the sake of consistency with other KMSAN code.
--- mm/kmsan/kmsan.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
mm/kmsan/kmsan.h +4 -4
@@ -10,14 +10,14 @@#ifndef __MM_KMSAN_KMSAN_H#define __MM_KMSAN_KMSAN_H -#include <asm/pgtable_64_types.h> #include <linux/irqflags.h> +#include <linux/mm.h> +#include <linux/nmi.h> +#include <linux/pgtable.h> +#include <linux/printk.h> #include <linux/sched.h> #include <linux/stackdepot.h> #include <linux/stacktrace.h> -#include <linux/nmi.h> -#include <linux/mm.h> -#include <linux/printk.h> #define KMSAN_ALLOCA_MAGIC_ORIGIN 0xabcd0100#define KMSAN_CHAIN_MAGIC_ORIGIN 0xabcd0200
Signature · 1 line
2.43.0
PATCH v3 9/34 kmsan: Expose kmsan_get_metadata()
In reply to Ilya LeoshkevichEach s390 CPU has lowcore pages associated with it. Each CPU sees its own lowcore at virtual address 0 through a hardware mechanism called prefixing. Additionally, all lowcores are mapped to non-0 virtual addresses stored in the lowcore_ptr[] array.
When lowcore is accessed through virtual address 0, one needs to resolve metadata for lowcore_ptr[raw_smp_processor_id()].
Expose kmsan_get_metadata() to make it possible to do this from the arch code.
--- include/linux/kmsan.h | 9 +++++++++ mm/kmsan/instrumentation.c | 1 + mm/kmsan/kmsan.h | 1 - 3 files changed, 10 insertions(+), 1 deletion(-)
include/linux/kmsan.h +9 -0
@@ -230,6 +230,15 @@ void kmsan_handle_urb(const struct urb *urb, bool is_out);*/ void kmsan_unpoison_entry_regs (const struct pt_regs *regs); +/** +* kmsan_get_metadata() - Return a pointer to KMSAN shadow or origins. +* @addr: kernel address. +* @is_origin: whether to return origins or shadow. +* +* Return NULL if metadata cannot be found. +*/ +void *kmsan_get_metadata (void *addr,bool is_origin); +#else static inline void kmsan_init_shadow (void )
mm/kmsan/instrumentation.c +1 -0
@@ -14,6 +14,7 @@#include "kmsan.h" #include <linux/gfp.h> +#include <linux/kmsan.h> #include <linux/kmsan_string.h> #include <linux/mm.h> #include <linux/uaccess.h>
mm/kmsan/kmsan.h +0 -1
@@ -66,7 +66,6 @@ struct shadow_origin_ptr {struct shadow_origin_ptr kmsan_get_shadow_origin_ptr (void *addr,u64 size,bool store); -void *kmsan_get_metadata (void *addr,bool is_origin);void __init kmsan_init_alloc_meta_for_range (void *start,void *end);enum kmsan_bug_reason {
Signature · 1 line
2.43.0
PATCH v3 10/34 kmsan: Export panic_on_kmsan
In reply to Ilya LeoshkevichWhen building the kmsan test as a module, modpost fails with the following error message:
ERROR: modpost: "panic_on_kmsan" [mm/kmsan/kmsan_test.ko] undefined!
Export panic_on_kmsan in order to improve the KMSAN usability for modules.
--- mm/kmsan/report.c | 1 + 1 file changed, 1 insertion(+)
mm/kmsan/report.c +1 -0
@@ -20,6 +20,7 @@ static DEFINE_RAW_SPINLOCK(kmsan_report_lock);/* Protected by kmsan_report_lock */ static char report_local_descr[DESCR_SIZE ];int panic_on_kmsan__read_mostly ; +EXPORT_SYMBOL_GPL (panic_on_kmsan);#ifdef MODULE_PARAM_PREFIX #undef MODULE_PARAM_PREFIX
Signature · 1 line
2.43.0
PATCH v3 11/34 kmsan: Allow disabling KMSAN checks for the current task
In reply to Ilya LeoshkevichLike 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.
--- Documentation/dev-tools/kmsan.rst | 4 ++-- include/linux/kmsan.h | 24 ++++++++++++++++++++++++ include/linux/kmsan_types.h | 2 +- mm/kmsan/core.c | 1 - mm/kmsan/hooks.c | 18 +++++++++++++++--- mm/kmsan/report.c | 7 ++++--- 6 files changed, 46 insertions(+), 10 deletions(-)
Documentation/dev-tools/kmsan.rst +2 -2
@@ -338,11 +338,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; ... }
include/linux/kmsan.h +24 -0
@@ -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 */
include/linux/kmsan_types.h +1 -1
@@ -29,7 +29,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 */
mm/kmsan/core.c +0 -1
@@ -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); }
mm/kmsan/hooks.c +15 -3
@@ -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)
@@ -423,3 +421,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);
mm/kmsan/report.c +4 -3
@@ -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 (); }
Signature · 1 line
2.43.0
PATCH v3 12/34 kmsan: Support SLAB_POISON
In reply to Ilya LeoshkevichAvoid false KMSAN negatives with SLUB_DEBUG by allowing kmsan_slab_free() to poison the freed memory, and by preventing init_object() from unpoisoning new allocations by using __memset().
There are two alternatives to this approach. First, init_object() can be marked with __no_sanitize_memory. This annotation should be used with great care, because it drops all instrumentation from the function, and any shadow writes will be lost. Even though this is not a concern with the current init_object() implementation, this may change in the future.
Second, kmsan_poison_memory() calls may be added after memset() calls. The downside is that init_object() is called from free_debug_processing(), in which case poisoning will erase the distinction between simply uninitialized memory and UAF.
--- mm/kmsan/hooks.c | 2 +- mm/slub.c | 13 +++++++++---- 2 files changed, 10 insertions(+), 5 deletions(-)
mm/kmsan/hooks.c +1 -1
@@ -74,7 +74,7 @@ void kmsan_slab_free(struct kmem_cache *s, void *object)return ;/* RCU slabs could be legally used after free within the RCU period */ -if (unlikely (s->flags & (SLAB_TYPESAFE_BY_RCU |SLAB_POISON ))) +if (unlikely (s->flags &SLAB_TYPESAFE_BY_RCU ))return ;/* * If there's a constructor, freed memory must remain in the same state
mm/slub.c +9 -4
@@ -1030,7 +1030,12 @@ static void init_object(struct kmem_cache *s, void *object, u8 val)unsigned int poison_size = s->object_size;if (s->flags &SLAB_RED_ZONE ) { -memset (p - s->red_left_pad, val, s->red_left_pad); +/* +* Use __memset() here and below in order to avoid overwriting +* the KMSAN shadow. Keeping the shadow makes it possible to +* distinguish uninit-value from use-after-free. +*/ +__memset (p - s->red_left_pad, val, s->red_left_pad);if (slub_debug_orig_size (s) && val ==SLUB_RED_ACTIVE ) {/*
@@ -1043,12 +1048,12 @@ static void init_object(struct kmem_cache *s, void *object, u8 val) }if (s->flags & __OBJECT_POISON) { -memset (p,POISON_FREE , poison_size -1 ); - p[poison_size -1 ] =POISON_END ; +__memset (p,POISON_FREE , poison_size -1 ); +__memset (p + poison_size -1 ,POISON_END ,1 ); }if (s->flags &SLAB_RED_ZONE ) -memset (p + poison_size, val, s->inuse - poison_size); +__memset (p + poison_size, val, s->inuse - poison_size); } static void restore_bytes(struct kmem_cache *s, char *message, u8 data,
Signature · 1 line
2.43.0
PATCH v3 13/34 kmsan: Use ALIGN_DOWN() in kmsan_get_metadata()
In reply to Ilya LeoshkevichImprove the readability by replacing the custom aligning logic with ALIGN_DOWN(). Unlike other places where a similar sequence is used, there is no size parameter that needs to be adjusted, so the standard macro fits.
--- mm/kmsan/shadow.c | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-)
mm/kmsan/shadow.c +3 -5
@@ -123,14 +123,12 @@ struct shadow_origin_ptr kmsan_get_shadow_origin_ptr(void *address, u64 size,*/ void *kmsan_get_metadata (void *address,bool is_origin) { -u64 addr = (u64 )address, pad, off; +u64 addr = (u64 )address, off;struct page *page;void *ret; -if (is_origin && !IS_ALIGNED (addr,KMSAN_ORIGIN_SIZE )) { - pad = addr %KMSAN_ORIGIN_SIZE ; - addr -= pad; - } +if (is_origin) + addr =ALIGN_DOWN (addr,KMSAN_ORIGIN_SIZE ); address = (void *)addr;if (kmsan_internal_is_vmalloc_addr (address) ||kmsan_internal_is_module_addr (address))
Signature · 1 line
2.43.0
PATCH v3 14/34 mm: slub: Let KMSAN access metadata
In reply to Ilya LeoshkevichBuilding the kernel with CONFIG_SLUB_DEBUG and CONFIG_KMSAN causes KMSAN to complain about touching redzones in kfree().
Fix by extending the existing KASAN-related metadata_access_enable() and metadata_access_disable() functions to KMSAN.
--- mm/slub.c | 2 ++ 1 file changed, 2 insertions(+)
mm/slub.c +2 -0
@@ -700,10 +700,12 @@ static int disable_higher_order_debug;static inline void metadata_access_enable (void ) {kasan_disable_current (); +kmsan_disable_current (); }static inline void metadata_access_disable (void ) { +kmsan_enable_current ();kasan_enable_current (); }
Signature · 1 line
2.43.0
PATCH v3 15/34 mm: slub: Unpoison the memchr_inv() return value
In reply to Ilya LeoshkevichEven though the KMSAN warnings generated by memchr_inv() are suppressed by metadata_access_enable(), its return value may still be poisoned.
The reason is that the last iteration of memchr_inv() returns *start != value ? start : NULL, where *start is poisoned. Because of this, somewhat counterintuitively, the shadow value computed by visitSelectInst() is equal to (uintptr_t)start.
The intention behind guarding memchr_inv() behind metadata_access_enable() is to touch poisoned metadata without triggering KMSAN, so unpoison its return value.
--- mm/slub.c | 2 ++ 1 file changed, 2 insertions(+)
mm/slub.c +2 -0
@@ -1076,6 +1076,7 @@ static int check_bytes_and_report(struct kmem_cache *s, struct slab *slab,metadata_access_enable (); fault =memchr_inv (kasan_reset_tag (start), value, bytes);metadata_access_disable (); +kmsan_unpoison_memory (&fault,sizeof (fault));if (!fault)return 1 ;
@@ -1182,6 +1183,7 @@ static void slab_pad_check(struct kmem_cache *s, struct slab *slab)metadata_access_enable (); fault =memchr_inv (kasan_reset_tag (pad),POISON_INUSE , remainder);metadata_access_disable (); +kmsan_unpoison_memory (&fault,sizeof (fault));if (!fault)return ;while (end > fault && end[-1 ] ==POISON_INUSE )
Signature · 1 line
2.43.0
Re: [PATCH v3 15/34] mm: slub: Unpoison the memchr_inv() return value
Quoted 8 lines · Ilya Leoshkevich
Even though the KMSAN warnings generated by
memchr_inv()are suppressed bymetadata_access_enable(), its return value may still be poisoned.The reason is that the last iteration of
memchr_inv()returns*start != value ? start : NULL, where *start is poisoned. Because of this, somewhat counterintuitively, the shadow value computed byvisitSelectInst()is equal to(uintptr_t)start.
Quoted 5 lines
The intention behind guarding
memchr_inv()behindmetadata_access_enable()is to touch poisoned metadata without triggering KMSAN, so unpoison its return value.Signed-off-by Ilya Leoshkevich <[email protected]>
Quoted 24 lines
--- mm/slub.c | 2 ++ 1 file changed, 2 insertions(+)mm/slub.c +2
-0@@ -1076,6 +1076,7 @@ static int check_bytes_and_report(struct kmem_cache *s, struct slab *slab,metadata_access_enable (); fault =memchr_inv (kasan_reset_tag (start), value, bytes);metadata_access_disable (); +kmsan_unpoison_memory (&fault,sizeof (fault));if (!fault)return 1 ;@@ -1182,6 +1183,7 @@ static void slab_pad_check(struct kmem_cache *s, struct slab *slab)metadata_access_enable (); fault =memchr_inv (kasan_reset_tag (pad),POISON_INUSE , remainder);metadata_access_disable (); +kmsan_unpoison_memory (&fault,sizeof (fault));if (!fault)return ;while (end > fault && end[-1 ] ==POISON_INUSE )
PATCH v3 16/34 mm: kfence: Disable KMSAN when checking the canary
In reply to Ilya LeoshkevichKMSAN warns about check_canary() accessing the canary.
The reason is that, even though set_canary() is properly instrumented and sets shadow, slub explicitly poisons the canary's address range afterwards.
Unpoisoning the canary is not the right thing to do: only check_canary() is supposed to ever touch it. Instead, disable KMSAN checks around canary read accesses.
--- mm/kfence/core.c | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-)
mm/kfence/core.c +9 -2
@@ -305,8 +305,14 @@ metadata_update_state(struct kfence_metadata *meta, enum kfence_object_state nexWRITE_ONCE (meta->state, next); } +#ifdef CONFIG_KMSAN +#define CHECK_CANARY_ATTRIBUTES noinline __no_kmsan_checks +#else +#define CHECK_CANARY_ATTRIBUTES inline +#endif +/* Check canary byte at @addr. */ -static inline bool check_canary_byte (u8 *addr) +static CHECK_CANARY_ATTRIBUTES bool check_canary_byte(u8 *addr) {struct kfence_metadata *meta;unsigned long flags;
@@ -341,7 +347,8 @@ static inline void set_canary(const struct kfence_metadata *meta) *((u64 *)addr) =KFENCE_CANARY_PATTERN_U64 ; } -static inline void check_canary (const struct kfence_metadata *meta) +static CHECK_CANARY_ATTRIBUTES void +check_canary (const struct kfence_metadata *meta) {const unsigned long pageaddr =ALIGN_DOWN (meta->addr,PAGE_SIZE );unsigned long addr = pageaddr;
Signature · 1 line
2.43.0
PATCH v3 17/34 lib/zlib: Unpoison DFLTCC output buffers
In reply to Ilya LeoshkevichThe constraints of the DFLTCC inline assembly are not precise: they do not communicate the size of the output buffers to the compiler, so it cannot automatically instrument it.
Add the manual kmsan_unpoison_memory() calls for the output buffers. The logic is the same as in [1].
[1] https://github.com/zlib-ng/zlib-ng/commit/1f5ddcc009ac3511e99fc88736a9e1a6381168c5
--- lib/zlib_dfltcc/dfltcc.h | 1 + lib/zlib_dfltcc/dfltcc_util.h | 24 ++++++++++++++++++++++++ 2 files changed, 25 insertions(+)
lib/zlib_dfltcc/dfltcc.h +1 -0
@@ -80,6 +80,7 @@ struct dfltcc_param_v0 {uint8_t csb[1152 ]; }; +static_assert (offsetof(struct dfltcc_param_v0 , csb) ==384 );static_assert (sizeof (struct dfltcc_param_v0 ) ==1536 );#define CVT_CRC32 0
lib/zlib_dfltcc/dfltcc_util.h +24 -0
@@ -2,6 +2,8 @@#ifndef DFLTCC_UTIL_H #define DFLTCC_UTIL_H +#include "dfltcc.h" +#include <linux/kmsan-checks.h> #include <linux/zutil.h> /*
@@ -20,6 +22,7 @@ typedef enum {#define DFLTCC_CMPR 2#define DFLTCC_XPND 4#define HBT_CIRCULAR (1 << 7) +#define DFLTCC_FN_MASK ((1 << 7) - 1)#define HB_BITS 15#define HB_SIZE (1 << HB_BITS)
@@ -34,6 +37,7 @@ static inline dfltcc_cc dfltcc( ) {Byte *t2 = op1 ? *op1 :NULL ; +unsigned char *orig_t2 = t2;size_t t3 = len1 ? *len1 :0 ;const Byte *t4 = op2 ? *op2 :NULL ;size_t t5 = len2 ? *len2 :0 ;
@@ -59,6 +63,26 @@ static inline dfltcc_cc dfltcc( : "cc", "memory"); t2 = r2; t3 = r3; t4 = r4; t5 = r5; +switch (fn &DFLTCC_FN_MASK ) { +case DFLTCC_QAF : +kmsan_unpoison_memory (param,sizeof (struct dfltcc_qaf_param )); +break ; +case DFLTCC_GDHT : +kmsan_unpoison_memory (param, offsetof(struct dfltcc_param_v0 , csb)); +break ; +case DFLTCC_CMPR : +kmsan_unpoison_memory (param,sizeof (struct dfltcc_param_v0 )); +kmsan_unpoison_memory ( + orig_t2, + t2 - orig_t2 + + (((struct dfltcc_param_v0 *)param)->sbb ==0 ?0 :1 )); +break ; +case DFLTCC_XPND : +kmsan_unpoison_memory (param,sizeof (struct dfltcc_param_v0 )); +kmsan_unpoison_memory (orig_t2, t2 - orig_t2); +break ; + } +if (op1) *op1 = t2;if (len1)
Signature · 1 line
2.43.0
Re: [PATCH v3 17/34] lib/zlib: Unpoison DFLTCC output buffers
Quoted 5 lines · Ilya Leoshkevich
The constraints of the DFLTCC inline assembly are not precise: they do not communicate the size of the output buffers to the compiler, so it cannot automatically instrument it.
Quoted 7 lines
Add the manual
kmsan_unpoison_memory()calls for the output buffers. The logic is the same as in [1].[1] https://github.com/zlib-ng/zlib-ng/commit/1f5ddcc009ac3511e99fc88736a9e1a6381168c5
Reported-by Alexander Gordeev <[email protected]>Signed-off-by Ilya Leoshkevich <[email protected]>
lib/zlib_dfltcc/dfltcc_util.h static inline dfltcc_cc dfltcc( · line 66
Quoted 13 lines
lib/zlib_dfltcc/dfltcc_util.h +2
-0@@ -34,6 +37,7 @@ static inline dfltcc_cc dfltcc( ) {Byte *t2 = op1 ? *op1 :NULL ; +unsigned char *orig_t2 = t2;size_t t3 = len1 ? *len1 :0 ;const Byte *t4 = op2 ? *op2 :NULL ;size_t t5 = len2 ? *len2 :0 ;@@ -59,6 +63,26 @@ static inline dfltcc_cc dfltcc( : "cc", "memory"); t2 = r2; t3 = r3; t4 = r4; t5 = r5; +switch (fn &DFLTCC_FN_MASK ) {
It might be a good idea to add a comment explaining what this block of code does.
(And that it is no-op in non-KMSAN builds)
PATCH v3 18/34 kmsan: Accept ranges starting with 0 on s390
In reply to Ilya LeoshkevichOn s390 the virtual address 0 is valid (current CPU's lowcore is mapped there), therefore KMSAN should not complain about it.
Disable the respective check on s390. There doesn't seem to be a Kconfig option to describe this situation, so explicitly check for s390.
--- mm/kmsan/init.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
mm/kmsan/init.c +4 -1
@@ -33,7 +33,10 @@ static void __init kmsan_record_future_shadow_range(void *start, void *end)bool merged = false;KMSAN_WARN_ON (future_index ==NUM_FUTURE_RANGES ); -KMSAN_WARN_ON ((nstart >= nend) || !nstart || !nend); +KMSAN_WARN_ON ((nstart >= nend) || +/* Virtual address 0 is valid on s390. */ + (!IS_ENABLED (CONFIG_S390 ) && !nstart) || + !nend); nstart =ALIGN_DOWN (nstart,PAGE_SIZE ); nend =ALIGN (nend,PAGE_SIZE );
Signature · 1 line
2.43.0
PATCH v3 19/34 s390: Turn off KMSAN for boot, vdso and purgatory
In reply to Ilya LeoshkevichAll other sanitizers are disabled for these components as well. While at it, add a comment to boot and purgatory.
--- arch/s390/boot/Makefile | 2 ++ arch/s390/kernel/vdso32/Makefile | 3 ++- arch/s390/kernel/vdso64/Makefile | 3 ++- arch/s390/purgatory/Makefile | 2 ++ 4 files changed, 8 insertions(+), 2 deletions(-)
arch/s390/boot/Makefile +2 -0
@@ -3,11 +3,13 @@ # Makefile for the linux s390-specific parts of the memory manager. # +# Tooling runtimes are unavailable and cannot be linked for early boot code KCOV_INSTRUMENT := n GCOV_PROFILE := n UBSAN_SANITIZE := n KASAN_SANITIZE := n KCSAN_SANITIZE := n +KMSAN_SANITIZE := n KBUILD_AFLAGS := $(KBUILD_AFLAGS_DECOMPRESSOR) KBUILD_CFLAGS := $(KBUILD_CFLAGS_DECOMPRESSOR)
arch/s390/kernel/vdso32/Makefile +2 -1
@@ -32,11 +32,12 @@ obj-y += vdso32_wrapper.o targets += vdso32.lds CPPFLAGS_vdso32.lds += -P -C -U$(ARCH) -# Disable gcov profiling, ubsan and kasan for VDSO code +# Disable gcov profiling, ubsan, kasan and kmsan for VDSO code GCOV_PROFILE := n UBSAN_SANITIZE := n KASAN_SANITIZE := n KCSAN_SANITIZE := n +KMSAN_SANITIZE := n # Force dependency (incbin is bad) $(obj)/vdso32_wrapper.o : $(obj)/vdso32.so
arch/s390/kernel/vdso64/Makefile +2 -1
@@ -36,11 +36,12 @@ obj-y += vdso64_wrapper.o targets += vdso64.lds CPPFLAGS_vdso64.lds += -P -C -U$(ARCH) -# Disable gcov profiling, ubsan and kasan for VDSO code +# Disable gcov profiling, ubsan, kasan and kmsan for VDSO code GCOV_PROFILE := n UBSAN_SANITIZE := n KASAN_SANITIZE := n KCSAN_SANITIZE := n +KMSAN_SANITIZE := n # Force dependency (incbin is bad) $(obj)/vdso64_wrapper.o : $(obj)/vdso64.so
arch/s390/purgatory/Makefile +2 -0
@@ -15,11 +15,13 @@ CFLAGS_sha256.o := -D__DISABLE_EXPORTS -D__NO_FORTIFY $(obj)/mem.o: $(srctree)/arch/s390/lib/mem.S FORCE $(call if_changed_rule,as_o_S) +# Tooling runtimes are unavailable and cannot be linked for purgatory code KCOV_INSTRUMENT := n GCOV_PROFILE := n UBSAN_SANITIZE := n KASAN_SANITIZE := n KCSAN_SANITIZE := n +KMSAN_SANITIZE := n KBUILD_CFLAGS := -fno-strict-aliasing -Wall -Wstrict-prototypes KBUILD_CFLAGS += -Wno-pointer-sign -Wno-sign-compare
Signature · 1 line
2.43.0
PATCH v3 20/34 s390: Use a larger stack for KMSAN
In reply to Ilya LeoshkevichAdjust the stack size for the KMSAN-enabled kernel like it was done for the KASAN-enabled one in commit 7fef92ccadd7 ("s390/kasan: double the stack size"). Both tools have similar requirements.
--- arch/s390/Makefile | 2 +- arch/s390/include/asm/thread_info.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)
arch/s390/Makefile +1 -1
@@ -34,7 +34,7 @@ KBUILD_CFLAGS_DECOMPRESSOR += $(if $(CONFIG_DEBUG_INFO_DWARF4), $(call cc-option KBUILD_CFLAGS_DECOMPRESSOR += $(if $(CONFIG_CC_NO_ARRAY_BOUNDS),-Wno-array-bounds) UTS_MACHINE := s390x -STACK_SIZE := $(if $(CONFIG_KASAN),65536,16384) +STACK_SIZE := $(if $(CONFIG_KASAN),65536,$(if $(CONFIG_KMSAN),65536,16384)) CHECKFLAGS += -D__s390__ -D__s390x__ export LD_BFD
arch/s390/include/asm/thread_info.h +1 -1
@@ -16,7 +16,7 @@/* * General size of kernel stacks */ -#ifdef CONFIG_KASAN +#if defined(CONFIG_KASAN ) || defined(CONFIG_KMSAN )#define THREAD_SIZE_ORDER 4#else #define THREAD_SIZE_ORDER 2
Signature · 1 line
2.43.0
PATCH v3 21/34 s390/boot: Add the KMSAN runtime stub
In reply to Ilya LeoshkevichIt should be possible to have inline functions in the s390 header files, which call kmsan_unpoison_memory(). The problem is that these header files might be included by the decompressor, which does not contain KMSAN runtime, causing linker errors.
Not compiling these calls if __SANITIZE_MEMORY__ is not defined - either by changing kmsan-checks.h or at the call sites - may cause unintended side effects, since calling these functions from an uninstrumented code that is linked into the kernel is valid use case.
One might want to explicitly distinguish between the kernel and the decompressor. Checking for a decompressor-specific #define is quite heavy-handed, and will have to be done at all call sites.
A more generic approach is to provide a dummy kmsan_unpoison_memory() definition. This produces some runtime overhead, but only when building with CONFIG_KMSAN. The benefit is that it does not disturb the existing KMSAN build logic and call sites don't need to be changed.
--- arch/s390/boot/Makefile | 1 + arch/s390/boot/kmsan.c | 6 ++++++ 2 files changed, 7 insertions(+) create mode 100644 arch/s390/boot/kmsan.c
arch/s390/boot/Makefile +1 -0
@@ -44,6 +44,7 @@ obj-$(findstring y, $(CONFIG_PROTECTED_VIRTUALIZATION_GUEST) $(CONFIG_PGSTE)) += obj-$(CONFIG_RANDOMIZE_BASE) += kaslr.o obj-y += $(if $(CONFIG_KERNEL_UNCOMPRESSED),,decompressor.o) info.o obj-$(CONFIG_KERNEL_ZSTD) += clz_ctz.o +obj-$(CONFIG_KMSAN) += kmsan.o obj-all := $(obj-y) piggy.o syms.o targets := bzImage section_cmp.boot.data section_cmp.boot.preserved.data $(obj-y)
arch/s390/boot/kmsan.c new file +6 -0
@@ -0,0 +1,6 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <linux/kmsan-checks.h> + +void kmsan_unpoison_memory (const void *address,size_t size) +{ +}
Signature · 1 line
2.43.0
PATCH v3 22/34 s390/checksum: Add a KMSAN check
In reply to Ilya LeoshkevichAdd a KMSAN check to the CKSM inline assembly, similar to how it was done for ASAN in commit e42ac7789df6 ("s390/checksum: always use cksm instruction").
--- arch/s390/include/asm/checksum.h | 2 ++ 1 file changed, 2 insertions(+)
arch/s390/include/asm/checksum.h +2 -0
@@ -13,6 +13,7 @@#define _S390_CHECKSUM_H#include <linux/kasan-checks.h> +#include <linux/kmsan-checks.h> #include <linux/in6.h> /*
@@ -35,6 +36,7 @@ static inline __wsum csum_partial(const void *buff, int len, __wsum sum) };kasan_check_read (buff, len); +kmsan_check_memory (buff, len); asmvolatile ("0: cksm %[sum],%[rp]\n" " jo 0b\n"
Signature · 1 line
2.43.0
PATCH v3 23/34 s390/cpacf: Unpoison the results of cpacf_trng()
In reply to Ilya LeoshkevichPrevent KMSAN from complaining about buffers filled by cpacf_trng() being uninitialized.
--- arch/s390/include/asm/cpacf.h | 3 +++ 1 file changed, 3 insertions(+)
arch/s390/include/asm/cpacf.h +3 -0
@@ -12,6 +12,7 @@#define _ASM_S390_CPACF_H#include <asm/facility.h> +#include <linux/kmsan-checks.h> /* * Instruction opcodes for the CPACF instructions
@@ -473,6 +474,8 @@ static inline void cpacf_trng(u8 *ucbuf, unsigned long ucbuf_len, : [ucbuf] "+&d" (u.pair), [cbuf] "+&d" (c.pair) : [fc] "K" (CPACF_PRNO_TRNG), [opc] "i" (CPACF_PRNO) : "cc", "memory", "0"); + kmsan_unpoison_memory(ucbuf, ucbuf_len); +kmsan_unpoison_memory (cbuf, cbuf_len); }/**
Signature · 1 line
2.43.0
Re: [PATCH v3 23/34] s390/cpacf: Unpoison the results of cpacf_trng()
Quoted 9 lines · Ilya Leoshkevich
Prevent KMSAN from complaining about buffers filled by
cpacf_trng()being uninitialized.Tested-by Alexander Gordeev <[email protected]>Reviewed-by Alexander Potapenko <[email protected]>Signed-off-by Ilya Leoshkevich <[email protected]>--- arch/s390/include/asm/cpacf.h | 3 +++ 1 file changed, 3 insertions(+)
PATCH v3 24/34 s390/cpumf: Unpoison STCCTM output buffer
In reply to Ilya Leoshkevichstcctm() uses the "Q" constraint for dest, therefore KMSAN does not understand that it fills multiple doublewords pointed to by dest, not just one. This results in false positives.
Unpoison the whole dest manually with kmsan_unpoison_memory().
--- arch/s390/include/asm/cpu_mf.h | 6 ++++++ 1 file changed, 6 insertions(+)
arch/s390/include/asm/cpu_mf.h +6 -0
@@ -10,6 +10,7 @@#define _ASM_S390_CPU_MF_H#include <linux/errno.h> +#include <linux/kmsan-checks.h> #include <asm/asm-extable.h> #include <asm/facility.h>
@@ -239,6 +240,11 @@ static __always_inline int stcctm(enum stcctm_ctr_set set, u64 range, u64 *dest) : "=d" (cc) : "Q" (*dest), "d" (range), "i" (set) : "cc", "memory"); +/* +* If cc == 2, less than RANGE counters are stored, but it's not easy +* to tell how many. Always unpoison the whole range for simplicity. +*/ +kmsan_unpoison_memory (dest, range *sizeof (u64));return cc; }
Signature · 1 line
2.43.0
Re: [PATCH v3 24/34] s390/cpumf: Unpoison STCCTM output buffer
Quoted 9 lines · Ilya Leoshkevich
stcctm()uses the "Q" constraint for dest, therefore KMSAN does not understand that it fills multiple doublewords pointed to by dest, not just one. This results in false positives.Unpoison the whole dest manually with
kmsan_unpoison_memory().Reported-by Alexander Gordeev <[email protected]>Signed-off-by Ilya Leoshkevich <[email protected]>
Re: [PATCH v3 24/34] s390/cpumf: Unpoison STCCTM output buffer
In reply to Ilya LeoshkevichQuoted 11 lines · Ilya Leoshkevich
stcctm()uses the "Q" constraint for dest, therefore KMSAN does not understand that it fills multiple doublewords pointed to by dest, not just one. This results in false positives.Unpoison the whole dest manually with
kmsan_unpoison_memory().Reported-by Alexander Gordeev <[email protected]>Signed-off-by Ilya Leoshkevich <[email protected]>--- arch/s390/include/asm/cpu_mf.h | 6 ++++++ 1 file changed, 6 insertions(+)
PATCH v3 25/34 s390/diag: Unpoison diag224() output buffer
In reply to Ilya LeoshkevichDiagnose 224 stores 4k bytes, which cannot be deduced from the inline assembly constraints. This leads to KMSAN false positives.
Unpoison the output buffer manually with kmsan_unpoison_memory().
--- arch/s390/kernel/diag.c | 2 ++ 1 file changed, 2 insertions(+)
arch/s390/kernel/diag.c +2 -0
@@ -9,6 +9,7 @@#include <linux/export.h> #include <linux/init.h> #include <linux/cpu.h> +#include <linux/kmsan-checks.h> #include <linux/seq_file.h> #include <linux/debugfs.h> #include <linux/vmalloc.h>
@@ -255,6 +256,7 @@ int diag224(void *ptr)"1:\n" EX_TABLE (0b ,1b ) : "+d" (rc) :"d" (0), "d" (addr) : "memory"); + kmsan_unpoison_memory(ptr,PAGE_SIZE );return rc; }EXPORT_SYMBOL (diag224);
Signature · 1 line
2.43.0
Heiko Carstens
maintainerRe: [PATCH v3 25/34] s390/diag: Unpoison diag224() output buffer
Quoted 23 lines · Ilya Leoshkevich
Diagnose 224 stores 4k bytes, which cannot be deduced from the inline assembly constraints. This leads to KMSAN false positives.
Unpoison the output buffer manually with
kmsan_unpoison_memory().Signed-off-by Ilya Leoshkevich <[email protected]>--- arch/s390/kernel/diag.c | 2 ++ 1 file changed, 2 insertions(+)arch/s390/kernel/diag.c +1
-0@@ -9,6 +9,7 @@#include <linux/export.h> #include <linux/init.h> #include <linux/cpu.h> +#include <linux/kmsan-checks.h> #include <linux/seq_file.h> #include <linux/debugfs.h> #include <linux/vmalloc.h>
arch/s390/kernel/diag.c int diag224(void *ptr) · line 259
Quoted 4 lines
arch/s390/kernel/diag.c +1
-0@@ -255,6 +256,7 @@ int diag224(void *ptr)"1:\n" EX_TABLE (0b ,1b ) : "+d" (rc) :"d" (0), "d" (addr) : "memory"); + kmsan_unpoison_memory(ptr,PAGE_SIZE );
Wouldn't it be better to adjust the inline assembly instead? Something like this:
arch/s390/kernel/diag.c +8 -4
@@ -247,14 +247,18 @@ int diag224(void *ptr) {unsigned long addr =__pa (ptr);int rc = -EOPNOTSUPP ; +struct _d { +char _d[4096 ]; + };diag_stat_inc (DIAG_STAT_X224 ); - asmvolatile ( -" diag %1,%2,0x224\n" -"0: lhi %0,0x0\n" + asmvolatile ("\n" +" diag %[type],%[addr],0x224\n" +"0: lhi %[rc],0\n" "1:\n" EX_TABLE(0b,1b) - : "+d" (rc) :"d" (0), "d" (addr) : "memory"); + : [rc] "+d" (rc), "=m" (*(struct _d *)ptr) + : [type] "d" (0), [addr] "d" (addr)); return rc; }EXPORT_SYMBOL (diag224);
PATCH v3 26/34 s390/ftrace: Unpoison ftrace_regs in kprobe_ftrace_handler()
In reply to Ilya Leoshkevichs390 uses assembly code to initialize ftrace_regs and call kprobe_ftrace_handler(). Therefore, from the KMSAN's point of view, ftrace_regs is poisoned on kprobe_ftrace_handler() entry. This causes KMSAN warnings when running the ftrace testsuite.
Fix by trusting the assembly code and always unpoisoning ftrace_regs in kprobe_ftrace_handler().
--- arch/s390/kernel/ftrace.c | 2 ++ 1 file changed, 2 insertions(+)
arch/s390/kernel/ftrace.c +2 -0
@@ -13,6 +13,7 @@#include <linux/ftrace.h> #include <linux/kernel.h> #include <linux/types.h> +#include <linux/kmsan-checks.h> #include <linux/kprobes.h> #include <trace/syscall.h> #include <asm/asm-offsets.h>
@@ -300,6 +301,7 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,if (bit <0 )return ; +kmsan_unpoison_memory (fregs,sizeof (*fregs)); regs =ftrace_get_regs (fregs); p =get_kprobe ((kprobe_opcode_t *)ip);if (!regs ||unlikely (!p) ||kprobe_disabled (p))
Signature · 1 line
2.43.0
Re: [PATCH v3 26/34] s390/ftrace: Unpoison ftrace_regs in kprobe_ftrace_handler()
Quoted 5 lines · Ilya Leoshkevich
s390 uses assembly code to initialize
ftrace_regsand callkprobe_ftrace_handler(). Therefore, from the KMSAN's point of view,ftrace_regsis poisoned onkprobe_ftrace_handler()entry. This causes KMSAN warnings when running the ftrace testsuite.
Quoted 8 lines
Fix by trusting the assembly code and always unpoisoning
ftrace_regsinkprobe_ftrace_handler().Reviewed-by Alexander Potapenko <[email protected]>Signed-off-by Ilya Leoshkevich <[email protected]>--- arch/s390/kernel/ftrace.c | 2 ++ 1 file changed, 2 insertions(+)
PATCH v3 27/34 s390/irqflags: Do not instrument arch_local_irq_*() with KMSAN
In reply to Ilya LeoshkevichKMSAN generates the following false positives on s390x:
[ 6.063666] DEBUG_LOCKS_WARN_ON(lockdep_hardirqs_enabled()) [ ...] [ 6.577050] Call Trace: [ 6.619637] [<000000000690d2de>] check_flags+0x1fe/0x210 [ 6.665411] ([<000000000690d2da>] check_flags+0x1fa/0x210) [ 6.707478] [<00000000006cec1a>] lock_acquire+0x2ca/0xce0 [ 6.749959] [<00000000069820ea>] _raw_spin_lock_irqsave+0xea/0x190 [ 6.794912] [<00000000041fc988>] __stack_depot_save+0x218/0x5b0 [ 6.838420] [<000000000197affe>] __msan_poison_alloca+0xfe/0x1a0 [ 6.882985] [<0000000007c5827c>] start_kernel+0x70c/0xd50 [ 6.927454] [<0000000000100036>] startup_continue+0x36/0x40
Between trace_hardirqs_on() and stosm __mask, 3 lockdep thinks that interrupts are on, but on the CPU they are still off. KMSAN instrumentation takes spinlocks, giving lockdep a chance to see and complain about this discrepancy.
KMSAN instrumentation is inserted in order to poison the __mask variable. Disable instrumentation in the respective functions. They are very small and it's easy to see that no important metadata updates are lost because of this.
--- arch/s390/include/asm/irqflags.h | 18 +++++++++++++++--- drivers/s390/char/sclp.c | 2 +- 2 files changed, 16 insertions(+), 4 deletions(-)
arch/s390/include/asm/irqflags.h +15 -3
@@ -37,12 +37,19 @@ static __always_inline void __arch_local_irq_ssm(unsigned long flags) asmvolatile ("ssm %0" : :"Q" (flags) :"memory" ); } -static __always_inline unsigned long arch_local_save_flags (void ) +#ifdef CONFIG_KMSAN +#define ARCH_LOCAL_IRQ_ATTRIBUTES \ + noinline notrace __no_sanitize_memory __maybe_unused +#else +#define ARCH_LOCAL_IRQ_ATTRIBUTES __always_inline +#endif + +static ARCH_LOCAL_IRQ_ATTRIBUTES unsigned long arch_local_save_flags (void ) {return __arch_local_irq_stnsm (0xff ); } -static __always_inline unsigned long arch_local_irq_save (void ) +static ARCH_LOCAL_IRQ_ATTRIBUTES unsigned long arch_local_irq_save (void ) {return __arch_local_irq_stnsm (0xfc ); }
@@ -52,7 +59,12 @@ static __always_inline void arch_local_irq_disable(void)arch_local_irq_save (); } -static __always_inline void arch_local_irq_enable(void) +static ARCH_LOCAL_IRQ_ATTRIBUTES void arch_local_irq_enable_external(void) +{ +__arch_local_irq_stosm (0x01 ); +} + +static ARCH_LOCAL_IRQ_ATTRIBUTES void arch_local_irq_enable(void) {__arch_local_irq_stosm (0x03 ); }
drivers/s390/char/sclp.c +1 -1
@@ -736,7 +736,7 @@ sclp_sync_wait(void) cr0_sync.val = cr0.val & ~CR0_IRQ_SUBCLASS_MASK ; cr0_sync.val |=1UL << (63 -54 );local_ctl_load (0 , &cr0_sync); -__arch_local_irq_stosm (0x01 ); +arch_local_irq_enable_external ();/* Loop until driver state indicates finished request */ while (sclp_running_state != sclp_running_state_idle) {/* Check for expired request timer */
Signature · 1 line
2.43.0
Re: [PATCH v3 27/34] s390/irqflags: Do not instrument arch_local_irq_*() with KMSAN
Quoted 20 lines · Ilya Leoshkevich
KMSAN generates the following false positives on s390x:
[ 6.063666] DEBUG_LOCKS_WARN_ON(lockdep_hardirqs_enabled()) [ ...] [ 6.577050] Call Trace: [ 6.619637] [<000000000690d2de>] check_flags+0x1fe/0x210 [ 6.665411] ([<000000000690d2da>] check_flags+0x1fa/0x210) [ 6.707478] [<00000000006cec1a>] lock_acquire+0x2ca/0xce0 [ 6.749959] [<00000000069820ea>] _raw_spin_lock_irqsave+0xea/0x190 [ 6.794912] [<00000000041fc988>] __stack_depot_save+0x218/0x5b0 [ 6.838420] [<000000000197affe>] __msan_poison_alloca+0xfe/0x1a0 [ 6.882985] [<0000000007c5827c>] start_kernel+0x70c/0xd50 [ 6.927454] [<0000000000100036>] startup_continue+0x36/0x40Between
trace_hardirqs_on()andstosm __mask, 3lockdep thinks that interrupts are on, but on the CPU they are still off. KMSAN instrumentation takes spinlocks, giving lockdep a chance to see and complain about this discrepancy.
Quoted 6 lines
KMSAN instrumentation is inserted in order to poison the
__maskvariable. Disable instrumentation in the respective functions. They are very small and it's easy to see that no important metadata updates are lost because of this.Signed-off-by Ilya Leoshkevich <[email protected]>
Heiko Carstens
maintainerRe: [PATCH v3 27/34] s390/irqflags: Do not instrument arch_local_irq_*() with KMSAN
In reply to Ilya LeoshkevichQuoted 38 lines · Ilya Leoshkevich
KMSAN generates the following false positives on s390x:
[ 6.063666] DEBUG_LOCKS_WARN_ON(lockdep_hardirqs_enabled()) [ ...] [ 6.577050] Call Trace: [ 6.619637] [<000000000690d2de>] check_flags+0x1fe/0x210 [ 6.665411] ([<000000000690d2da>] check_flags+0x1fa/0x210) [ 6.707478] [<00000000006cec1a>] lock_acquire+0x2ca/0xce0 [ 6.749959] [<00000000069820ea>] _raw_spin_lock_irqsave+0xea/0x190 [ 6.794912] [<00000000041fc988>] __stack_depot_save+0x218/0x5b0 [ 6.838420] [<000000000197affe>] __msan_poison_alloca+0xfe/0x1a0 [ 6.882985] [<0000000007c5827c>] start_kernel+0x70c/0xd50 [ 6.927454] [<0000000000100036>] startup_continue+0x36/0x40Between
trace_hardirqs_on()andstosm __mask, 3lockdep thinks that interrupts are on, but on the CPU they are still off. KMSAN instrumentation takes spinlocks, giving lockdep a chance to see and complain about this discrepancy.KMSAN instrumentation is inserted in order to poison the
__maskvariable. Disable instrumentation in the respective functions. They are very small and it's easy to see that no important metadata updates are lost because of this.Signed-off-by Ilya Leoshkevich <[email protected]>--- arch/s390/include/asm/irqflags.h | 18 +++++++++++++++--- drivers/s390/char/sclp.c | 2 +- 2 files changed, 16 insertions(+), 4 deletions(-)arch/s390/include/asm/irqflags.h +0
-0@@ -37,12 +37,19 @@ static __always_inline void __arch_local_irq_ssm(unsigned long flags) asmvolatile ("ssm %0" : :"Q" (flags) :"memory" ); }
arch/s390/include/asm/irqflags.h static __always_inline void __arch_local_irq_ssm(unsigned long flags) · line 48
Quoted 10 lines
arch/s390/include/asm/irqflags.h +8
-1-static __always_inline unsigned long arch_local_save_flags (void ) +#ifdef CONFIG_KMSAN +#define ARCH_LOCAL_IRQ_ATTRIBUTES \ + noinline notrace __no_sanitize_memory __maybe_unused +#else +#define ARCH_LOCAL_IRQ_ATTRIBUTES __always_inline +#endif + +static ARCH_LOCAL_IRQ_ATTRIBUTES unsigned long arch_local_save_flags (void ) {
Please change this to lower case and long single lines, so it matches the more common patterns:
#ifdef CONFIG_KMSAN
#define __arch_local_irq_attributes noinline notrace __no_sanitize_memory __maybe_unused #else
#define __arch_local_irq_attributes __always_inline
#endif
static __arch_local_irq_attributes unsigned long arch_local_save_flags(void)
...
PATCH v3 28/34 s390/mm: Define KMSAN metadata for vmalloc and modules
In reply to Ilya LeoshkevichThe pages for the KMSAN metadata associated with most kernel mappings are taken from memblock by the common code. However, vmalloc and module metadata needs to be defined by the architectures.
Be a little bit more careful than x86: allocate exactly MODULES_LEN for the module shadow and origins, and then take 2/3 of vmalloc for the vmalloc shadow and origins. This ensures that users passing small vmalloc= values on the command line do not cause module metadata collisions.
--- arch/s390/boot/startup.c | 8 ++++++++ arch/s390/include/asm/pgtable.h | 10 ++++++++++ 2 files changed, 18 insertions(+)
arch/s390/boot/startup.c +8 -0
@@ -253,9 +253,17 @@ static unsigned long setup_kernel_memory_layout(void)MODULES_END =round_down (__abs_lowcore, _SEGMENT_SIZE);MODULES_VADDR =MODULES_END -MODULES_LEN ;VMALLOC_END =MODULES_VADDR ; +#ifdef CONFIG_KMSAN +VMALLOC_END -=MODULES_LEN *2 ; +#endif /* allow vmalloc area to occupy up to about 1/2 of the rest virtual space left */ vmalloc_size =min (vmalloc_size,round_down (VMALLOC_END /2 , _REGION3_SIZE)); +#ifdef CONFIG_KMSAN +/* take 2/3 of vmalloc area for KMSAN shadow and origins */ + vmalloc_size =round_down (vmalloc_size /3 , _REGION3_SIZE); +VMALLOC_END -= vmalloc_size *2 ; +#endif VMALLOC_START =VMALLOC_END - vmalloc_size;/* split remaining virtual space between 1:1 mapping & vmemmap array */
arch/s390/include/asm/pgtable.h +10 -0
@@ -107,6 +107,16 @@ static inline int is_module_addr(void *addr)return 1 ; } +#ifdef CONFIG_KMSAN +#define KMSAN_VMALLOC_SIZE (VMALLOC_END - VMALLOC_START) +#define KMSAN_VMALLOC_SHADOW_START VMALLOC_END +#define KMSAN_VMALLOC_ORIGIN_START (KMSAN_VMALLOC_SHADOW_START + \ + KMSAN_VMALLOC_SIZE) +#define KMSAN_MODULES_SHADOW_START (KMSAN_VMALLOC_ORIGIN_START + \ + KMSAN_VMALLOC_SIZE) +#define KMSAN_MODULES_ORIGIN_START (KMSAN_MODULES_SHADOW_START + MODULES_LEN) +#endif +/* * A 64 bit pagetable entry of S390 has following format: * | PFRA |0IPC| OS |
Signature · 1 line
2.43.0
Re: [PATCH v3 28/34] s390/mm: Define KMSAN metadata for vmalloc and modules
Quoted 22 lines · Ilya Leoshkevich
The pages for the KMSAN metadata associated with most kernel mappings are taken from memblock by the common code. However, vmalloc and module metadata needs to be defined by the architectures.
Be a little bit more careful than x86: allocate exactly
MODULES_LENfor the module shadow and origins, and then take 2/3 of vmalloc for the vmalloc shadow and origins. This ensures that users passing small vmalloc= values on the command line do not cause module metadata collisions.Reviewed-by Alexander Potapenko <[email protected]>Signed-off-by Ilya Leoshkevich <[email protected]>--- arch/s390/boot/startup.c | 8 ++++++++ arch/s390/include/asm/pgtable.h | 10 ++++++++++ 2 files changed, 18 insertions(+)arch/s390/boot/startup.c +0
-0
arch/s390/boot/startup.c static unsigned long setup_kernel_memory_layout(void) · line 261
Quoted 9 lines
arch/s390/boot/startup.c +3
-0@@ -253,9 +253,17 @@ static unsigned long setup_kernel_memory_layout(void)MODULES_END =round_down (__abs_lowcore, _SEGMENT_SIZE);MODULES_VADDR =MODULES_END -MODULES_LEN ;VMALLOC_END =MODULES_VADDR ; +#ifdef CONFIG_KMSAN +VMALLOC_END -=MODULES_LEN *2 ; +#endif /* allow vmalloc area to occupy up to about 1/2 of the rest virtual space left */ vmalloc_size =min (vmalloc_size,round_down (VMALLOC_END /2 , _REGION3_SIZE));
Since commit 2a65c6e1ad06 ("s390/boot: always align vmalloc area on segment boundary") vmalloc_size is aligned on _SEGMENT_SIZE boundary.
arch/s390/boot/startup.c static unsigned long setup_kernel_memory_layout(void) · line 264
Quoted 3 lines
arch/s390/boot/startup.c +3
-0+#ifdef CONFIG_KMSAN +/* take 2/3 of vmalloc area for KMSAN shadow and origins */ + vmalloc_size =round_down (vmalloc_size /3 , _REGION3_SIZE);
And thus, the alignment here should be _SEGMENT_SIZE as well.
arch/s390/boot/startup.c static unsigned long setup_kernel_memory_layout(void) · line 269
Quoted 5 lines
arch/s390/boot/startup.c +2
-0+VMALLOC_END -= vmalloc_size *2 ; +#endif VMALLOC_START =VMALLOC_END - vmalloc_size;/* split remaining virtual space between 1:1 mapping & vmemmap array */
...
With the above fixup:
Thanks!
Re: [PATCH v3 28/34] s390/mm: Define KMSAN metadata for vmalloc and modules
In reply to Ilya LeoshkevichQuoted 26 lines · Ilya Leoshkevich
The pages for the KMSAN metadata associated with most kernel mappings are taken from memblock by the common code. However, vmalloc and module metadata needs to be defined by the architectures.
Be a little bit more careful than x86: allocate exactly
MODULES_LENfor the module shadow and origins, and then take 2/3 of vmalloc for the vmalloc shadow and origins. This ensures that users passing small vmalloc= values on the command line do not cause module metadata collisions.Reviewed-by Alexander Potapenko <[email protected]>Signed-off-by Ilya Leoshkevich <[email protected]>--- arch/s390/boot/startup.c | 8 ++++++++ arch/s390/include/asm/pgtable.h | 10 ++++++++++ 2 files changed, 18 insertions(+)arch/s390/boot/startup.c +1
-0@@ -253,9 +253,17 @@ static unsigned long setup_kernel_memory_layout(void)MODULES_END =round_down (__abs_lowcore, _SEGMENT_SIZE);MODULES_VADDR =MODULES_END -MODULES_LEN ;VMALLOC_END =MODULES_VADDR ; +#ifdef CONFIG_KMSAN
arch/s390/boot/startup.c static unsigned long setup_kernel_memory_layout(void) · line 266
Quoted 10 lines
arch/s390/boot/startup.c +7
-0+VMALLOC_END -=MODULES_LEN *2 ; +#endif /* allow vmalloc area to occupy up to about 1/2 of the rest virtual space left */ vmalloc_size =min (vmalloc_size,round_down (VMALLOC_END /2 , _REGION3_SIZE)); +#ifdef CONFIG_KMSAN +/* take 2/3 of vmalloc area for KMSAN shadow and origins */ + vmalloc_size =round_down (vmalloc_size /3 , _REGION3_SIZE); +VMALLOC_END -= vmalloc_size *2 ; +#endif
Please use
if (IS_ENABLED(CONFIG_KMSAN))
above, since this way we get more compile time checks.
arch/s390/boot/startup.c static unsigned long setup_kernel_memory_layout(void)
Quoted 7 lines
arch/s390/boot/startup.c +7
-0+#ifdef CONFIG_KMSAN +#define KMSAN_VMALLOC_SIZE (VMALLOC_END - VMALLOC_START) +#define KMSAN_VMALLOC_SHADOW_START VMALLOC_END +#define KMSAN_VMALLOC_ORIGIN_START (KMSAN_VMALLOC_SHADOW_START + \ + KMSAN_VMALLOC_SIZE) +#define KMSAN_MODULES_SHADOW_START (KMSAN_VMALLOC_ORIGIN_START + \ + KMSAN_VMALLOC_SIZE)
Long single lines for these, please :)
With that, and Alexander Gordeev's comments addressed:
Alexander Gordeev
maintainerRe: [PATCH v3 28/34] s390/mm: Define KMSAN metadata for vmalloc and modules
On Tue, Jan 02, 2024 at 04:05:31PM +0100, Heiko Carstens wrote:
Hi Heiko,
...
Quoted 18 lines
Quoted 5 lines
arch/s390/boot/startup.c +1
-0@@ -253,9 +253,17 @@ static unsigned long setup_kernel_memory_layout(void)MODULES_END =round_down (__abs_lowcore, _SEGMENT_SIZE);MODULES_VADDR =MODULES_END -MODULES_LEN ;VMALLOC_END =MODULES_VADDR ; +#ifdef CONFIG_KMSAN arch/s390/boot/startup.c static unsigned long setup_kernel_memory_layout(void) · line 266
Quoted 10 lines
arch/s390/boot/startup.c +7
-0+VMALLOC_END -=MODULES_LEN *2 ; +#endif /* allow vmalloc area to occupy up to about 1/2 of the rest virtual space left */ vmalloc_size =min (vmalloc_size,round_down (VMALLOC_END /2 , _REGION3_SIZE)); +#ifdef CONFIG_KMSAN +/* take 2/3 of vmalloc area for KMSAN shadow and origins */ + vmalloc_size =round_down (vmalloc_size /3 , _REGION3_SIZE); +VMALLOC_END -= vmalloc_size *2 ; +#endif Please use
Quoted 3 lines
if (
IS_ENABLED(CONFIG_KMSAN))above, since this way we get more compile time checks.
This way we will get a mixture of CONFIG_KASAN and CONFIG_KMSAN #ifdef vs IS_ENABLED() checks within one function. I guess, we would rather address it with a separate cleanup?
Thanks!
Heiko Carstens
maintainerRe: [PATCH v3 28/34] s390/mm: Define KMSAN metadata for vmalloc and modules
Quoted 21 lines · Alexander Gordeev
On Tue, Jan 02, 2024 at 04:05:31PM +0100, Heiko Carstens wrote:
Hi Heiko,
...Quoted 18 lines
Quoted 5 lines
arch/s390/boot/startup.c +1
-0@@ -253,9 +253,17 @@ static unsigned long setup_kernel_memory_layout(void)MODULES_END =round_down (__abs_lowcore, _SEGMENT_SIZE);MODULES_VADDR =MODULES_END -MODULES_LEN ;VMALLOC_END =MODULES_VADDR ; +#ifdef CONFIG_KMSAN arch/s390/boot/startup.c static unsigned long setup_kernel_memory_layout(void) · line 266
Quoted 10 lines
arch/s390/boot/startup.c +7
-0+VMALLOC_END -=MODULES_LEN *2 ; +#endif /* allow vmalloc area to occupy up to about 1/2 of the rest virtual space left */ vmalloc_size =min (vmalloc_size,round_down (VMALLOC_END /2 , _REGION3_SIZE)); +#ifdef CONFIG_KMSAN +/* take 2/3 of vmalloc area for KMSAN shadow and origins */ + vmalloc_size =round_down (vmalloc_size /3 , _REGION3_SIZE); +VMALLOC_END -= vmalloc_size *2 ; +#endif Please use
Quoted 7 lines
Quoted 3 lines
if (
IS_ENABLED(CONFIG_KMSAN))above, since this way we get more compile time checks.
This way we will get a mixture of
CONFIG_KASANandCONFIG_KMSAN#ifdef vsIS_ENABLED()checks within one function. I guess, we would rather address it with a separate cleanup?
I don't think so, since you can't convert the CONFIG_KASAN ifdef to IS_ENABLED() here: it won't compile.
But IS_ENABLED(CONFIG_KMSAN) should work. I highly prefer IS_ENABLED() over ifdef since it allows for better compile time checks, and you won't be surprised by code that doesn't compile if you just change a config option. We've seen that way too often.
PATCH v3 29/34 s390/string: Add KMSAN support
In reply to Ilya LeoshkevichAdd KMSAN support for the s390 implementations of the string functions. Do this similar to how it's already done for KASAN, except that the optimized memset{16,32,64}() functions need to be disabled: it's important for KMSAN to know that they initialized something.
The way boot code is built with regard to string functions is problematic, since most files think it's configured with sanitizers, but boot/string.c doesn't. This creates various problems with the memset64() definitions, depending on whether the code is built with sanitizers or fortify. This should probably be streamlined, but in the meantime resolve the issues by introducing the IN_BOOT_STRING_C macro, similar to the existing IN_ARCH_STRING_C macro.
--- arch/s390/boot/string.c | 16 ++++++++++++++++ arch/s390/include/asm/string.h | 20 +++++++++++++++----- 2 files changed, 31 insertions(+), 5 deletions(-)
arch/s390/boot/string.c +16 -0
@@ -1,11 +1,18 @@// SPDX-License-Identifier: GPL-2.0 +#define IN_BOOT_STRING_C 1#include <linux/ctype.h> #include <linux/kernel.h> #include <linux/errno.h> #undef CONFIG_KASAN#undef CONFIG_KASAN_GENERIC +#undef CONFIG_KMSAN#include "../lib/string.c" +/* +* Duplicate some functions from the common lib/string.c +* instead of fully including it. +*/ +int strncmp (const char *cs,const char *ct,size_t count) {unsigned char c1, c2;
@@ -22,6 +29,15 @@ int strncmp(const char *cs, const char *ct, size_t count)return 0 ; } +void *memset64 (uint64_t *s,uint64_t v,size_t count) +{ +uint64_t *xs = s; + +while (count--) + *xs++ = v; +return s; +} +char *skip_spaces (const char *str) {while (isspace (*str))
arch/s390/include/asm/string.h +15 -5
@@ -15,15 +15,12 @@#define __HAVE_ARCH_MEMCPY/* gcc builtin & arch function */ #define __HAVE_ARCH_MEMMOVE/* gcc builtin & arch function */ #define __HAVE_ARCH_MEMSET/* gcc builtin & arch function */ -#define __HAVE_ARCH_MEMSET16/* arch function */ -#define __HAVE_ARCH_MEMSET32/* arch function */ -#define __HAVE_ARCH_MEMSET64/* arch function */ void *memcpy (void *dest,const void *src,size_t n);void *memset (void *s,int c,size_t n);void *memmove (void *dest,const void *src,size_t n); -#ifndef CONFIG_KASAN +#if !defined(CONFIG_KASAN ) && !defined(CONFIG_KMSAN )#define __HAVE_ARCH_MEMCHR/* inline & arch function */ #define __HAVE_ARCH_MEMCMP/* arch function */ #define __HAVE_ARCH_MEMSCAN/* inline & arch function */
@@ -36,6 +33,9 @@ void *memmove(void *dest, const void *src, size_t n);#define __HAVE_ARCH_STRNCPY/* arch function */ #define __HAVE_ARCH_STRNLEN/* inline & arch function */ #define __HAVE_ARCH_STRSTR/* arch function */ +#define __HAVE_ARCH_MEMSET16/* arch function */ +#define __HAVE_ARCH_MEMSET32/* arch function */ +#define __HAVE_ARCH_MEMSET64/* arch function */ /* Prototypes for non-inlined arch strings functions. */ int memcmp (const void *s1,const void *s2,size_t n);
@@ -44,7 +44,7 @@ size_t strlcat(char *dest, const char *src, size_t n);char *strncat (char *dest,const char *src,size_t n);char *strncpy (char *dest,const char *src,size_t n);char *strstr (const char *s1,const char *s2); -#endif /* !CONFIG_KASAN */ +#endif /* !defined(CONFIG_KASAN) && !defined(CONFIG_KMSAN) */ #undef __HAVE_ARCH_STRCHR#undef __HAVE_ARCH_STRNCHR
@@ -74,20 +74,30 @@ void *__memset16(uint16_t *s, uint16_t v, size_t count);void *__memset32 (uint32_t *s,uint32_t v,size_t count);void *__memset64 (uint64_t *s,uint64_t v,size_t count); +#ifdef __HAVE_ARCH_MEMSET16static inline void *memset16 (uint16_t *s,uint16_t v,size_t count) {return __memset16 (s, v, count *sizeof (v)); } +#endif +#ifdef __HAVE_ARCH_MEMSET32static inline void *memset32 (uint32_t *s,uint32_t v,size_t count) {return __memset32 (s, v, count *sizeof (v)); } +#endif +#ifdef __HAVE_ARCH_MEMSET64 +#ifdef IN_BOOT_STRING_C +void *memset64 (uint64_t *s,uint64_t v,size_t count); +#else static inline void *memset64 (uint64_t *s,uint64_t v,size_t count) {return __memset64 (s, v, count *sizeof (v)); } +#endif +#endif #if !defined(IN_ARCH_STRING_C ) && (!defined(CONFIG_FORTIFY_SOURCE ) || defined(__NO_FORTIFY))
Signature · 1 line
2.43.0
Re: [PATCH v3 29/34] s390/string: Add KMSAN support
Quoted 13 lines · Ilya Leoshkevich
Add KMSAN support for the s390 implementations of the string functions. Do this similar to how it's already done for KASAN, except that the optimized memset{16,32,64}() functions need to be disabled: it's important for KMSAN to know that they initialized something.
The way boot code is built with regard to string functions is problematic, since most files think it's configured with sanitizers, but
boot/string.cdoesn't. This creates various problems with thememset64()definitions, depending on whether the code is built with sanitizers or fortify. This should probably be streamlined, but in the meantime resolve the issues by introducing theIN_BOOT_STRING_Cmacro, similar to the existingIN_ARCH_STRING_Cmacro.
Quoted 6 lines
Reviewed-by Alexander Potapenko <[email protected]>Signed-off-by Ilya Leoshkevich <[email protected]>--- arch/s390/boot/string.c | 16 ++++++++++++++++ arch/s390/include/asm/string.h | 20 +++++++++++++++----- 2 files changed, 31 insertions(+), 5 deletions(-)
PATCH v3 30/34 s390/traps: Unpoison the kernel_stack_overflow()'s pt_regs
In reply to Ilya LeoshkevichThis is normally done by the generic entry code, but the kernel_stack_overflow() flow bypasses it.
--- arch/s390/kernel/traps.c | 6 ++++++ 1 file changed, 6 insertions(+)
arch/s390/kernel/traps.c +6 -0
@@ -27,6 +27,7 @@#include <linux/uaccess.h> #include <linux/cpu.h> #include <linux/entry-common.h> +#include <linux/kmsan.h> #include <asm/asm-extable.h> #include <asm/fpu/api.h> #include <asm/vtime.h>
@@ -260,6 +261,11 @@ static void monitor_event_exception(struct pt_regs *regs)void kernel_stack_overflow (struct pt_regs *regs) { +/* +* Normally regs are unpoisoned by the generic entry code, but +* kernel_stack_overflow() is a rare case that is called bypassing it. +*/ +kmsan_unpoison_entry_regs (regs);bust_spinlocks (1 );printk ("Kernel stack overflow.\n" );show_regs (regs);
Signature · 1 line
2.43.0
Re: [PATCH v3 30/34] s390/traps: Unpoison the kernel_stack_overflow()'s pt_regs
Quoted 8 lines · Ilya Leoshkevich
This is normally done by the generic entry code, but the
kernel_stack_overflow()flow bypasses it.Reviewed-by Alexander Potapenko <[email protected]>Signed-off-by Ilya Leoshkevich <[email protected]>--- arch/s390/kernel/traps.c | 6 ++++++ 1 file changed, 6 insertions(+)
PATCH v3 31/34 s390/uaccess: Add KMSAN support to put_user() and get_user()
In reply to Ilya Leoshkevichput_user() uses inline assembly with precise constraints, so Clang is in principle capable of instrumenting it automatically. Unfortunately, one of the constraints contains a dereferenced user pointer, and Clang does not currently distinguish user and kernel pointers. Therefore KMSAN attempts to access shadow for user pointers, which is not a right thing to do.
An obvious fix to add __no_sanitize_memory to __put_user_fn() does not work, since it's __always_inline. And __always_inline cannot be removed due to the __put_user_bad() trick.
A different obvious fix of using the "a" instead of the "+Q" constraint degrades the code quality, which is very important here, since it's a hot path.
Instead, repurpose the __put_user_asm() macro to define __put_user_{char,short,int,long}_noinstr() functions and mark them with __no_sanitize_memory. For the non-KMSAN builds make them __always_inline in order to keep the generated code quality. Also define __put_user_{char,short,int,long}() functions, which call the aforementioned ones and which *are* instrumented, because they call KMSAN hooks, which may be implemented as macros.
The same applies to get_user() as well.
--- arch/s390/include/asm/uaccess.h | 111 +++++++++++++++++++++++--------- 1 file changed, 79 insertions(+), 32 deletions(-)
arch/s390/include/asm/uaccess.h +79 -32
@@ -78,13 +78,24 @@ union oac {int __noreturn __put_user_bad (void ); -#define __put_user_asm (to, from, size) \ -({ \ +#ifdef CONFIG_KMSAN +#define GET_PUT_USER_NOINSTR_ATTRIBUTES \ + noinline __maybe_unused __no_sanitize_memory +#else +#define GET_PUT_USER_NOINSTR_ATTRIBUTES __always_inline +#endif + +#define DEFINE_PUT_USER (type) \ +static GET_PUT_USER_NOINSTR_ATTRIBUTES int \ +__put_user_##type##_noinstr(unsigned type __user *to, \ + unsigned type *from, \ + unsigned long size) \ +{ \ union oac __oac_spec = { \ .oac1.as = PSW_BITS_AS_SECONDARY, \ .oac1.a = 1, \ }; \ - int __rc; \ + int rc; \ \ asm volatile( \ " lr 0,%[spec]\n" \
@@ -93,12 +104,28 @@ int __noreturn __put_user_bad(void);"2:\n" \ EX_TABLE_UA_STORE(0b, 2b, %[rc]) \ EX_TABLE_UA_STORE(1b, 2b, %[rc]) \ - : [rc] "=&d" (__rc), [_to] "+Q" (*(to)) \ + : [rc] "=&d" (rc), [_to] "+Q" (*(to)) \: [_size] " d" (size), [_from] " Q " (*(from)), \ [spec] " d" (__oac_spec.val) \ : "cc", "0"); \ -__rc; \ -}) +return rc; \ +} \ +\ +static __always_inline int \ +__put_user_##type(unsigned type __user *to, unsigned type *from, \ +unsigned long size) \ +{ \ +int rc; \ +\ +rc = __put_user_##type##_noinstr(to, from, size); \ +instrument_put_user(*from, to, size); \ +return rc; \ +} + +DEFINE_PUT_USER (char); +DEFINE_PUT_USER (short); +DEFINE_PUT_USER (int); +DEFINE_PUT_USER (long); static __always_inline int __put_user_fn(void *x, void __user *ptr, unsigned long size) {
@@ -106,24 +133,24 @@ static __always_inline int __put_user_fn(void *x, void __user *ptr, unsigned lonswitch (size) {case 1 : - rc =__put_user_asm ((unsigned char __user *)ptr, - (unsigned char *)x, - size); + rc =__put_user_char ((unsigned char __user *)ptr, + (unsigned char *)x, + size);break ;case 2 : - rc =__put_user_asm ((unsigned short __user *)ptr, - (unsigned short *)x, - size); + rc =__put_user_short ((unsigned short __user *)ptr, + (unsigned short *)x, + size);break ;case 4 : - rc =__put_user_asm ((unsigned int __user *)ptr, + rc =__put_user_int ((unsigned int __user *)ptr, (unsigned int *)x, size);break ;case 8 : - rc =__put_user_asm ((unsigned long __user *)ptr, - (unsigned long *)x, - size); + rc =__put_user_long ((unsigned long __user *)ptr, + (unsigned long *)x, + size);break ;default :__put_user_bad ();
@@ -134,13 +161,17 @@ static __always_inline int __put_user_fn(void *x, void __user *ptr, unsigned lonint __noreturn __get_user_bad (void ); -#define __get_user_asm (to, from, size) \ -({ \ +#define DEFINE_GET_USER (type) \ +static GET_PUT_USER_NOINSTR_ATTRIBUTES int \ +__get_user_##type##_noinstr(unsigned type *to, \ + unsigned type __user *from, \ + unsigned long size) \ +{ \ union oac __oac_spec = { \ .oac2.as = PSW_BITS_AS_SECONDARY, \ .oac2.a = 1, \ }; \ - int __rc; \ + int rc; \ \ asm volatile( \ " lr 0,%[spec]\n" \
@@ -149,13 +180,29 @@ int __noreturn __get_user_bad(void);"2:\n" \ EX_TABLE_UA_LOAD_MEM(0b, 2b, %[rc], %[_to], %[_ksize]) \ EX_TABLE_UA_LOAD_MEM(1b, 2b, %[rc], %[_to], %[_ksize]) \ - : [rc] "=&d" (__rc), "=Q" (*(to)) \ + : [rc] "=&d" (rc), "=Q" (*(to)) \: [_size] " d" (size), [_from] " Q " (*(from)), \ [spec] " d" (__oac_spec.val), [_to] " a" (to), \ [_ksize] " K " (size) \ : "cc", "0"); \ -__rc; \ -}) +return rc; \ +} \ +\ +static __always_inline int \ +__get_user_##type(unsigned type *to, unsigned type __user *from, \ +unsigned long size) \ +{ \ +int rc; \ +\ +rc = __get_user_##type##_noinstr(to, from, size); \ +instrument_get_user(*to); \ +return rc; \ +} + +DEFINE_GET_USER (char); +DEFINE_GET_USER (short); +DEFINE_GET_USER (int); +DEFINE_GET_USER (long); static __always_inline int __get_user_fn(void *x, const void __user *ptr, unsigned long size) {
@@ -163,24 +210,24 @@ static __always_inline int __get_user_fn(void *x, const void __user *ptr, unsignswitch (size) {case 1 : - rc =__get_user_asm ((unsigned char *)x, - (unsigned char __user *)ptr, - size); + rc =__get_user_char ((unsigned char *)x, + (unsigned char __user *)ptr, + size);break ;case 2 : - rc =__get_user_asm ((unsigned short *)x, - (unsigned short __user *)ptr, - size); + rc =__get_user_short ((unsigned short *)x, + (unsigned short __user *)ptr, + size);break ;case 4 : - rc =__get_user_asm ((unsigned int *)x, + rc =__get_user_int ((unsigned int *)x, (unsigned int __user *)ptr, size);break ;case 8 : - rc =__get_user_asm ((unsigned long *)x, - (unsigned long __user *)ptr, - size); + rc =__get_user_long ((unsigned long *)x, + (unsigned long __user *)ptr, + size);break ;default :__get_user_bad ();
Signature · 1 line
2.43.0
PATCH v3 32/34 s390/unwind: Disable KMSAN checks
In reply to Ilya LeoshkevichThe unwind code can read uninitialized frames. Furthermore, even in the good case, KMSAN does not emit shadow for backchains. Therefore disable it for the unwinding functions.
--- arch/s390/kernel/unwind_bc.c | 4 ++++ 1 file changed, 4 insertions(+)
arch/s390/kernel/unwind_bc.c +4 -0
@@ -49,6 +49,8 @@ static inline bool is_final_pt_regs(struct unwind_state *state,READ_ONCE_NOCHECK (regs->psw.mask) &PSW_MASK_PSTATE ; } +/* Avoid KMSAN false positives from touching uninitialized frames. */ +__no_kmsan_checks bool unwind_next_frame(struct unwind_state *state) {struct stack_info *info = &state->stack_info;
@@ -118,6 +120,8 @@ bool unwind_next_frame(struct unwind_state *state) }EXPORT_SYMBOL_GPL (unwind_next_frame); +/* Avoid KMSAN false positives from touching uninitialized frames. */ +__no_kmsan_checks void __unwind_start(struct unwind_state *state, struct task_struct *task,struct pt_regs *regs,unsigned long first_frame) {
Signature · 1 line
2.43.0
Re: [PATCH v3 32/34] s390/unwind: Disable KMSAN checks
Quoted 9 lines · Ilya Leoshkevich
The unwind code can read uninitialized frames. Furthermore, even in the good case, KMSAN does not emit shadow for backchains. Therefore disable it for the unwinding functions.
Reviewed-by Alexander Potapenko <[email protected]>Signed-off-by Ilya Leoshkevich <[email protected]>--- arch/s390/kernel/unwind_bc.c | 4 ++++ 1 file changed, 4 insertions(+)
PATCH v3 33/34 s390: Implement the architecture-specific kmsan functions
In reply to Ilya Leoshkevicharch_kmsan_get_meta_or_null() finds the lowcore shadow by querying the prefix and calling kmsan_get_metadata() again.
kmsan_virt_addr_valid() delegates to virt_addr_valid().
--- arch/s390/include/asm/kmsan.h | 43 +++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 arch/s390/include/asm/kmsan.h
arch/s390/include/asm/kmsan.h new file +43 -0
@@ -0,0 +1,43 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _ASM_S390_KMSAN_H +#define _ASM_S390_KMSAN_H + +#include <asm/lowcore.h> +#include <asm/page.h> +#include <linux/kmsan.h> +#include <linux/mmzone.h> +#include <linux/stddef.h> + +#ifndef MODULE + +static inline bool is_lowcore_addr (void *addr) +{ +return addr >= (void *)&S390_lowcore && + addr < (void *)(&S390_lowcore +1 ); +} + +static inline void *arch_kmsan_get_meta_or_null (void *addr,bool is_origin) +{ +if (is_lowcore_addr (addr)) { +/* +* Different lowcores accessed via S390_lowcore are described +* by the same struct page. Resolve the prefix manually in +* order to get a distinct struct page. +*/ + addr += (void *)lowcore_ptr[raw_smp_processor_id ()] - + (void *)&S390_lowcore; +if (WARN_ON_ONCE (is_lowcore_addr (addr))) +return NULL ; +return kmsan_get_metadata (addr, is_origin); + } +return NULL ; +} + +static inline bool kmsan_virt_addr_valid (void *addr) +{ +return virt_addr_valid (addr); +} + +#endif /* !MODULE */ + +#endif /* _ASM_S390_KMSAN_H */
Signature · 1 line
2.43.0
Re: [PATCH v3 33/34] s390: Implement the architecture-specific kmsan functions
Quoted 7 lines · Ilya Leoshkevich
arch_kmsan_get_meta_or_null()finds the lowcore shadow by querying the prefix and callingkmsan_get_metadata()again.
kmsan_virt_addr_valid()delegates tovirt_addr_valid().Signed-off-by Ilya Leoshkevich <[email protected]>
Re: [PATCH v3 33/34] s390: Implement the architecture-specific kmsan functions
In reply to Ilya LeoshkevichQuoted 9 lines · Ilya Leoshkevich
arch_kmsan_get_meta_or_null()finds the lowcore shadow by querying the prefix and callingkmsan_get_metadata()again.
kmsan_virt_addr_valid()delegates tovirt_addr_valid().Signed-off-by Ilya Leoshkevich <[email protected]>--- arch/s390/include/asm/kmsan.h | 43 +++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+)
PATCH v3 34/34 kmsan: Enable on s390
In reply to Ilya LeoshkevichNow that everything else is in place, enable KMSAN in Kconfig.
--- arch/s390/Kconfig | 1 + 1 file changed, 1 insertion(+)
arch/s390/Kconfig +1 -0
@@ -153,6 +153,7 @@ config S390 select HAVE_ARCH_KASAN select HAVE_ARCH_KASAN_VMALLOC select HAVE_ARCH_KCSAN + select HAVE_ARCH_KMSAN select HAVE_ARCH_KFENCE select HAVE_ARCH_RANDOMIZE_KSTACK_OFFSET select HAVE_ARCH_SECCOMP_FILTER
Signature · 1 line
2.43.0
Quoted 6 lines · Ilya Leoshkevich
Now that everything else is in place, enable KMSAN in
Kconfig.Signed-off-by Ilya Leoshkevich <[email protected]>--- arch/s390/Kconfig | 1 + 1 file changed, 1 insertion(+)