mm/kasan: make kasan=on|off work for all three modes
Subsystems (13)
v3 cover mm/kasan: make kasan=on|off work for all three modes
Currently only hw_tags mode of kasan can be enabled or disabled with kernel parameter kasan=on|off for built kernel. For kasan generic and sw_tags mode, there's no way to disable them once kernel is built. This is not convenient sometime, e.g in system kdump is configured. When the 1st kernel has KASAN enabled and crash triggered to switch to kdump kernel, the generic or sw_tags mode will cost much extra memory for kasan shadow while in fact it's meaningless to have kasan in kdump kernel.
So this patchset moves the kasan=on|off out of hw_tags scope and into common code to make it visible in generic and sw_tags mode too. Then we can add kasan=off in kdump kernel to reduce the unneeded meomry cost for kasan.
Changelog:
====v2->v3:
- Fix a building error on UML ARCH when CONFIG_KASAN is not set. The change of fixing is appended into patch patch 11. This is reported by LKP, thanks to them.
v1->v2:
- Add __ro_after_init for kasan_arg_disabled, and remove redundant blank lines in mm/kasan/common.c. Thanks to Marco.
- Fix a code bug in <linux/kasan-enabled.h> when CONFIG_KASAN is unset, this is found out by SeongJae and Lorenzo, and also reported by LKP report, thanks to them.
- Add a missing kasan_enabled() checking in kasan_report(). This will cause below KASAN report info even though kasan=off is set:
==================================================================
BUG: KASAN: stack-out-of-bounds in tick_program_event+0x130/0x150
Read of size 4 at addr ffff00005f747778 by task swapper/0/1
CPU: 0 UID: 0 PID: 1 Comm: swapper/0 Not tainted 6.16.0+ #8 PREEMPT(voluntary)
Hardware name: GIGABYTE R272-P30-JG/MP32-AR0-JG, BIOS F31n (SCP: 2.10.20220810) 09/30/2022
Call trace:
show_stack+0x30/0x90 (C)
dump_stack_lvl+0x7c/0xa0
print_address_description.constprop.0+0x90/0x310
print_report+0x104/0x1f0
kasan_report+0xc8/0x110
__asan_report_load4_noabort+0x20/0x30
tick_program_event+0x130/0x150
......snip...
==================================================================- Add jump_label_init() calling before kasan_init() in setup_arch() in these
architectures: xtensa, arm. Because they currenly rely on jump_label_init() in main() which is a little late. Then the early static key kasan_flag_enabled in kasan_init() won't work.
- In UML architecture, change to enable kasan_flag_enabled in arch_mm_preinit() because kasan_init() is enabled before main(), there's no chance to operate on static key in kasan_init().
Test:
=====
In v1, I took test on x86_64 for generic mode, and on arm64 for generic, sw_tags and hw_tags mode. All of them works well.
In v2, I only tested on arm64 for generic, sw_tags and hw_tags mode, it works. For powerpc, I got a BOOK3S/64 machine, while it says 'KASAN not enabled as it requires radix' and KASAN is disabled. Will look for other POWER machine to test this.
In v3, I only built UML kernel successfully w and w/o CONFIG_KASAN setting with LKP's testing steps.
====
Baoquan He (12):
mm/kasan: add conditional checks in functions to return directly if
kasan is disabled
mm/kasan: move kasan= code to common place mm/kasan/sw_tags: don't initialize kasan if it's disabled arch/arm: don't initialize kasan if it's disabled arch/arm64: don't initialize kasan if it's disabled arch/loongarch: don't initialize kasan if it's disabled arch/powerpc: don't initialize kasan if it's disabled arch/riscv: don't initialize kasan if it's disabled arch/x86: don't initialize kasan if it's disabled arch/xtensa: don't initialize kasan if it's disabled arch/um: don't initialize kasan if it's disabled mm/kasan: make kasan=on|off take effect for all three modes
arch/arm/kernel/setup.c | 6 +++++ arch/arm/mm/kasan_init.c | 6 +++++ arch/arm64/mm/kasan_init.c | 7 ++++++ arch/loongarch/mm/kasan_init.c | 5 ++++ arch/powerpc/mm/kasan/init_32.c | 8 +++++- arch/powerpc/mm/kasan/init_book3e_64.c | 6 +++++ arch/powerpc/mm/kasan/init_book3s_64.c | 6 +++++ arch/riscv/mm/kasan_init.c | 6 +++++ arch/um/kernel/mem.c | 7 ++++++ arch/x86/mm/kasan_init_64.c | 6 +++++ arch/xtensa/kernel/setup.c | 1 + arch/xtensa/mm/kasan_init.c | 6 +++++ include/linux/kasan-enabled.h | 18 ++++++------- mm/kasan/common.c | 25 ++++++++++++++++++ mm/kasan/generic.c | 20 +++++++++++++-- mm/kasan/hw_tags.c | 35 ++------------------------ mm/kasan/init.c | 6 +++++ mm/kasan/quarantine.c | 3 +++ mm/kasan/report.c | 4 ++- mm/kasan/shadow.c | 23 ++++++++++++++++- mm/kasan/sw_tags.c | 9 +++++++ 21 files changed, 166 insertions(+), 47 deletions(-)
Signature · 1 line
2.41.0
PATCH v3 1/12 mm/kasan: add conditional checks in functions to return directly if kasan is disabled
The current code only does the check if kasan is disabled for hw_tags mode. Here add the conditional checks for functional functions of generic mode and sw_tags mode.
This is prepared for later adding kernel parameter kasan=on|off for all kasan modes.
--- mm/kasan/generic.c | 20 ++++++++++++++++++-- mm/kasan/init.c | 6 ++++++ mm/kasan/quarantine.c | 3 +++ mm/kasan/report.c | 4 +++- mm/kasan/shadow.c | 23 ++++++++++++++++++++++- mm/kasan/sw_tags.c | 3 +++ 6 files changed, 55 insertions(+), 4 deletions(-)
mm/kasan/generic.c +18 -2
@@ -165,6 +165,9 @@ static __always_inline bool check_region_inline(const void *addr, size_t size, bool write, unsigned long ret_ip) { + if (!kasan_enabled()) + return true; +if (!kasan_arch_is_ready ())return true;
@@ -203,12 +206,13 @@ bool kasan_byte_accessible(const void *addr)void kasan_cache_shrink (struct kmem_cache *cache) { -kasan_quarantine_remove_cache (cache); +if (kasan_enabled ()) +kasan_quarantine_remove_cache (cache); }void kasan_cache_shutdown (struct kmem_cache *cache) { -if (!__kmem_cache_empty (cache)) +if (kasan_enabled () && !__kmem_cache_empty (cache))kasan_quarantine_remove_cache (cache); }
@@ -228,6 +232,9 @@ void __asan_register_globals(void *ptr, ssize_t size)int i;struct kasan_global *globals = ptr; +if (!kasan_enabled ()) +return ; +for (i =0 ; i < size; i++)register_global (&globals[i]); }
@@ -358,6 +365,9 @@ void kasan_cache_create(struct kmem_cache *cache, unsigned int *size,unsigned int rem_free_meta_size;unsigned int orig_alloc_meta_offset; +if (!kasan_enabled ()) +return ; +if (!kasan_requires_meta ())return ;
@@ -510,6 +520,9 @@ size_t kasan_metadata_size(struct kmem_cache *cache, bool in_object) {struct kasan_cache *info = &cache->kasan_info; +if (!kasan_enabled ()) +return 0 ; +if (!kasan_requires_meta ())return 0 ;
@@ -535,6 +548,9 @@ void kasan_record_aux_stack(void *addr)struct kasan_alloc_meta *alloc_meta;void *object; +if (!kasan_enabled ()) +return ; +if (is_kfence_address (addr) || !slab)return ;
mm/kasan/init.c +6 -0
@@ -449,6 +449,9 @@ void kasan_remove_zero_shadow(void *start, unsigned long size)unsigned long addr, end, next;pgd_t *pgd; +if (!kasan_enabled ()) +return ; + addr = (unsigned long )kasan_mem_to_shadow (start); end = addr + (size >>KASAN_SHADOW_SCALE_SHIFT );
@@ -484,6 +487,9 @@ int kasan_add_zero_shadow(void *start, unsigned long size)int ret;void *shadow_start, *shadow_end; +if (!kasan_enabled ()) +return 0 ; + shadow_start =kasan_mem_to_shadow (start); shadow_end = shadow_start + (size >>KASAN_SHADOW_SCALE_SHIFT );
mm/kasan/quarantine.c +3 -0
@@ -405,6 +405,9 @@ static int __init kasan_cpu_quarantine_init(void) {int ret =0 ; +if (!kasan_enabled ()) +return 0 ; + ret =cpuhp_setup_state (CPUHP_AP_ONLINE_DYN ,"mm/kasan:online" , kasan_cpu_online, kasan_cpu_offline);if (ret <0 )
mm/kasan/report.c +3 -1
@@ -576,7 +576,9 @@ bool kasan_report(const void *addr, size_t size, bool is_write,unsigned long irq_flags;struct kasan_report_info info; -if (unlikely (report_suppressed_sw ()) ||unlikely (!report_enabled ())) { +if (unlikely (report_suppressed_sw ()) || +unlikely (!report_enabled ()) || + !kasan_enabled ()) { ret = false; goto out; }
mm/kasan/shadow.c +22 -1
@@ -125,6 +125,9 @@ void kasan_poison(const void *addr, size_t size, u8 value, bool init) {void *shadow_start, *shadow_end; +if (!kasan_enabled ()) +return ; +if (!kasan_arch_is_ready ())return ;
@@ -150,6 +153,9 @@ EXPORT_SYMBOL_GPL(kasan_poison);#ifdef CONFIG_KASAN_GENERIC void kasan_poison_last_granule (const void *addr,size_t size) { +if (!kasan_enabled ()) +return ; +if (!kasan_arch_is_ready ())return ;
@@ -164,6 +170,8 @@ void kasan_unpoison(const void *addr, size_t size, bool init) {u8 tag =get_tag (addr); +if (!kasan_enabled ()) +return ;/* * Perform shadow offset calculation based on untagged address, as * some of the callers (e.g. kasan_unpoison_new_object) pass tagged
@@ -277,7 +285,8 @@ static int __meminit kasan_mem_notifier(struct notifier_block *nb,static int __init kasan_memhotplug_init (void ) { -hotplug_memory_notifier (kasan_mem_notifier,DEFAULT_CALLBACK_PRI ); +if (kasan_enabled ()) +hotplug_memory_notifier (kasan_mem_notifier,DEFAULT_CALLBACK_PRI );return 0 ; }
@@ -390,6 +399,9 @@ int kasan_populate_vmalloc(unsigned long addr, unsigned long size)unsigned long shadow_start, shadow_end;int ret; +if (!kasan_enabled ()) +return 0 ; +if (!kasan_arch_is_ready ())return 0 ;
@@ -560,6 +572,9 @@ void kasan_release_vmalloc(unsigned long start, unsigned long end,unsigned long region_start, region_end;unsigned long size; +if (!kasan_enabled ()) +return ; +if (!kasan_arch_is_ready ())return ;
@@ -655,6 +670,9 @@ int kasan_alloc_module_shadow(void *addr, size_t size, gfp_t gfp_mask)size_t shadow_size;unsigned long shadow_start; +if (!kasan_enabled ()) +return 0 ; + shadow_start = (unsigned long )kasan_mem_to_shadow (addr); scaled_size = (size +KASAN_GRANULE_SIZE -1 ) >>KASAN_SHADOW_SCALE_SHIFT ;
@@ -691,6 +709,9 @@ int kasan_alloc_module_shadow(void *addr, size_t size, gfp_t gfp_mask)void kasan_free_module_shadow (const struct vm_struct *vm) { +if (!kasan_enabled ()) +return ; +if (IS_ENABLED (CONFIG_UML ))return ;
mm/kasan/sw_tags.c +3 -0
@@ -78,6 +78,9 @@ bool kasan_check_range(const void *addr, size_t size, bool write,u8 *shadow_first, *shadow_last, *shadow;void *untagged_addr; +if (!kasan_enabled ()) +return true; +if (unlikely (size ==0 ))return true;
Signature · 1 line
2.41.0
PATCH v3 2/12 mm/kasan: move kasan= code to common place
In reply to Baoquan HeThis allows generic and sw_tags to be set in kernel cmdline too.
When at it, rename 'kasan_arg' to 'kasan_arg_disabled' as a bool variable. And expose 'kasan_flag_enabled' to kasan common place too.
This is prepared for later adding kernel parameter kasan=on|off for all kasan modes.
--- include/linux/kasan-enabled.h | 4 +++- mm/kasan/common.c | 25 +++++++++++++++++++++++++ mm/kasan/hw_tags.c | 35 ++--------------------------------- 3 files changed, 30 insertions(+), 34 deletions(-)
include/linux/kasan-enabled.h +3 -1
@@ -4,10 +4,12 @@#include <linux/static_key.h> -#ifdef CONFIG_KASAN_HW_TAGS +extern bool kasan_arg_disabled;DECLARE_STATIC_KEY_FALSE (kasan_flag_enabled); +#ifdef CONFIG_KASAN_HW_TAGS + static __always_inline bool kasan_enabled(void) {return static_branch_likely (&kasan_flag_enabled);
mm/kasan/common.c +25 -0
@@ -32,6 +32,31 @@#include "kasan.h" #include "../slab.h" +/* +* Whether KASAN is enabled at all. +* The value remains false until KASAN is initialized. +*/ +DEFINE_STATIC_KEY_FALSE (kasan_flag_enabled); +EXPORT_SYMBOL (kasan_flag_enabled); + +bool kasan_arg_disabled__ro_after_init ; +/* kasan=off/on */ +static int __init early_kasan_flag (char *arg) +{ +if (!arg) +return -EINVAL ; + +if (!strcmp (arg,"off" )) + kasan_arg_disabled = true; +else if (!strcmp (arg,"on" )) + kasan_arg_disabled = false; +else +return -EINVAL ; + +return 0 ; +} +early_param ("kasan" , early_kasan_flag); +struct slab *kasan_addr_to_slab (const void *addr) {if (virt_addr_valid (addr))
mm/kasan/hw_tags.c +2 -33
@@ -22,12 +22,6 @@#include "kasan.h" -enum kasan_arg { -KASAN_ARG_DEFAULT , -KASAN_ARG_OFF , -KASAN_ARG_ON , -}; -enum kasan_arg_mode {KASAN_ARG_MODE_DEFAULT ,KASAN_ARG_MODE_SYNC ,
@@ -41,17 +35,9 @@ enum kasan_arg_vmalloc { KASAN_ARG_VMALLOC_ON, }; -static enum kasan_arg kasan_arg__ro_after_init ;static enum kasan_arg_mode kasan_arg_mode__ro_after_init ;static enum kasan_arg_vmalloc kasan_arg_vmalloc__initdata ; -/* -* Whether KASAN is enabled at all. -* The value remains false until KASAN is initialized by kasan_init_hw_tags(). -*/ -DEFINE_STATIC_KEY_FALSE (kasan_flag_enabled); -EXPORT_SYMBOL (kasan_flag_enabled); -/* * Whether the selected mode is synchronous, asynchronous, or asymmetric. * Defaults to KASAN_MODE_SYNC.
@@ -85,23 +71,6 @@ unsigned int kasan_page_alloc_sample_order = PAGE_ALLOC_SAMPLE_ORDER_DEFAULT;DEFINE_PER_CPU (long, kasan_page_alloc_skip); -/* kasan=off/on */ -static int __init early_kasan_flag (char *arg) -{ -if (!arg) -return -EINVAL ; - -if (!strcmp (arg,"off" )) - kasan_arg =KASAN_ARG_OFF ; -else if (!strcmp (arg,"on" )) - kasan_arg =KASAN_ARG_ON ; -else -return -EINVAL ; - -return 0 ; -} -early_param ("kasan" , early_kasan_flag); -/* kasan.mode=sync/async/asymm */ static int __init early_kasan_mode (char *arg) {
@@ -209,7 +178,7 @@ void kasan_init_hw_tags_cpu(void)* When this function is called, kasan_flag_enabled is not yet * set by kasan_init_hw_tags(). Thus, check kasan_arg instead. */ -if (kasan_arg ==KASAN_ARG_OFF ) +if (kasan_arg_disabled)return ;/*
@@ -227,7 +196,7 @@ void __init kasan_init_hw_tags(void)return ;/* If KASAN is disabled via command line, don't initialize it. */ -if (kasan_arg ==KASAN_ARG_OFF ) +if (kasan_arg_disabled)return ;switch (kasan_arg_mode) {
Signature · 1 line
2.41.0
PATCH v3 3/12 mm/kasan/sw_tags: don't initialize kasan if it's disabled
In reply to Baoquan HeAnd also add code to enable kasan_flag_enabled, this is for later usage.
--- mm/kasan/sw_tags.c | 6 ++++++ 1 file changed, 6 insertions(+)
mm/kasan/sw_tags.c +6 -0
@@ -40,11 +40,17 @@ void __init kasan_init_sw_tags(void) {int cpu; +if (kasan_arg_disabled) +return ; +for_each_possible_cpu (cpu)per_cpu (prng_state, cpu) = (u32 )get_cycles ();kasan_init_tags (); +/* KASAN is now initialized, enable it. */ +static_branch_enable (&kasan_flag_enabled); +pr_info ("KernelAddressSanitizer initialized (sw-tags, stacktrace=%s)\n" ,str_on_off (kasan_stack_collection_enabled ())); }
Signature · 1 line
2.41.0
PATCH v3 4/12 arch/arm: don't initialize kasan if it's disabled
In reply to Baoquan HeAnd also add code to enable kasan_flag_enabled, this is for later usage.
Here call jump_label_init() early in setup_arch() so that later kasan_init() can enable static key kasan_flag_enabled. Put jump_label_init() beofre parse_early_param() as other architectures do.
--- arch/arm/kernel/setup.c | 6 ++++++ arch/arm/mm/kasan_init.c | 6 ++++++ 2 files changed, 12 insertions(+)
arch/arm/kernel/setup.c +6 -0
@@ -1135,6 +1135,12 @@ void __init setup_arch(char **cmdline_p)early_fixmap_init ();early_ioremap_init (); +/* +* Initialise the static keys early as they may be enabled by the +* kasan_init() or early parameters. +*/ +jump_label_init (); +parse_early_param ();#ifdef CONFIG_MMU
arch/arm/mm/kasan_init.c +6 -0
@@ -212,6 +212,8 @@ void __init kasan_init(void)phys_addr_t pa_start, pa_end;u64 i; +if (kasan_arg_disabled) +return ;/* * We are going to perform proper setup of shadow memory. *
@@ -300,6 +302,10 @@ void __init kasan_init(void)local_flush_tlb_all ();memset (kasan_early_shadow_page,0 ,PAGE_SIZE ); + +/* KASAN is now initialized, enable it. */ +static_branch_enable (&kasan_flag_enabled); +pr_info ("Kernel address sanitizer initialized\n" ); init_task.kasan_depth =0 ; }
Signature · 1 line
2.41.0
PATCH v3 5/12 arch/arm64: don't initialize kasan if it's disabled
In reply to Baoquan HeAnd also add code to enable kasan_flag_enabled, this is for later usage.
And also need skip kasan_populate_early_vm_area_shadow() if kasan is disabled.
--- arch/arm64/mm/kasan_init.c | 7 +++++++ 1 file changed, 7 insertions(+)
arch/arm64/mm/kasan_init.c +7 -0
@@ -384,6 +384,9 @@ void __init kasan_populate_early_vm_area_shadow(void *start, unsigned long size) {unsigned long shadow_start, shadow_end; +if (!kasan_enabled ()) +return ; +if (!is_vmalloc_or_module_addr (start))return ;
@@ -397,6 +400,9 @@ void __init kasan_populate_early_vm_area_shadow(void *start, unsigned long size)void __init kasan_init (void ) { +if (kasan_arg_disabled) +return ; +kasan_init_shadow ();kasan_init_depth ();#if defined(CONFIG_KASAN_GENERIC )
@@ -405,6 +411,7 @@ void __init kasan_init(void)* Software and Hardware Tag-Based modes still require * kasan_init_sw_tags() and kasan_init_hw_tags() correspondingly. */ +static_branch_enable (&kasan_flag_enabled);pr_info ("KernelAddressSanitizer initialized (generic)\n" );#endif }
Signature · 1 line
2.41.0
PATCH v3 6/12 arch/loongarch: don't initialize kasan if it's disabled
In reply to Baoquan HeAnd also add code to enable kasan_flag_enabled, this is for later usage.
--- arch/loongarch/mm/kasan_init.c | 5 +++++ 1 file changed, 5 insertions(+)
arch/loongarch/mm/kasan_init.c +5 -0
@@ -267,6 +267,8 @@ void __init kasan_init(void)u64 i;phys_addr_t pa_start, pa_end; +if (kasan_arg_disabled) +return ;/* * If PGDIR_SIZE is too large for cpu_vabits, KASAN_SHADOW_END will * overflow UINTPTR_MAX and then looks like a user space address.
@@ -327,6 +329,9 @@ void __init kasan_init(void)csr_write64 (__pa_symbol (swapper_pg_dir),LOONGARCH_CSR_PGDH );local_flush_tlb_all (); +/* KASAN is now initialized, enable it. */ +static_branch_enable (&kasan_flag_enabled); +/* At this point kasan is fully initialized. Enable error messages */ init_task.kasan_depth =0 ;pr_info ("KernelAddressSanitizer initialized.\n" );
Signature · 1 line
2.41.0
PATCH v3 7/12 arch/powerpc: don't initialize kasan if it's disabled
In reply to Baoquan HeThis includes 32bit, book3s/64 and book3e/64.
And also add code to enable kasan_flag_enabled, this is for later usage.
--- arch/powerpc/mm/kasan/init_32.c | 8 +++++++- arch/powerpc/mm/kasan/init_book3e_64.c | 6 ++++++ arch/powerpc/mm/kasan/init_book3s_64.c | 6 ++++++ 3 files changed, 19 insertions(+), 1 deletion(-)
arch/powerpc/mm/kasan/init_32.c +7 -1
@@ -141,6 +141,9 @@ void __init kasan_init(void)u64 i;int ret; +if (kasan_arg_disabled) +return ; +for_each_mem_range (i, &base, &end) {phys_addr_t top =min (end, total_lowmem);
@@ -163,6 +166,9 @@ void __init kasan_init(void)clear_page (kasan_early_shadow_page); +/* KASAN is now initialized, enable it. */ +static_branch_enable (&kasan_flag_enabled); +/* At this point kasan is fully initialized. Enable error messages */ init_task.kasan_depth =0 ;pr_info ("KASAN init done\n" );
@@ -170,7 +176,7 @@ void __init kasan_init(void)void __init kasan_late_init (void ) { -if (IS_ENABLED (CONFIG_KASAN_VMALLOC )) +if (IS_ENABLED (CONFIG_KASAN_VMALLOC ) &&kasan_enabled ())kasan_unmap_early_shadow_vmalloc (); }
arch/powerpc/mm/kasan/init_book3e_64.c +6 -0
@@ -111,6 +111,9 @@ void __init kasan_init(void)u64 i;pte_t zero_pte =pfn_pte (virt_to_pfn (kasan_early_shadow_page),PAGE_KERNEL_RO ); +if (kasan_arg_disabled) +return ; +for_each_mem_range (i, &start, &end)kasan_init_phys_region (phys_to_virt (start),phys_to_virt (end));
@@ -125,6 +128,9 @@ void __init kasan_init(void)memset (kasan_early_shadow_page,0 ,PAGE_SIZE ); +/* KASAN is now initialized, enable it. */ +static_branch_enable (&kasan_flag_enabled); +/* Enable error messages */ init_task.kasan_depth =0 ;pr_info ("KASAN init done\n" );
arch/powerpc/mm/kasan/init_book3s_64.c +6 -0
@@ -56,6 +56,9 @@ void __init kasan_init(void)u64 i;pte_t zero_pte =pfn_pte (virt_to_pfn (kasan_early_shadow_page),PAGE_KERNEL ); +if (kasan_arg_disabled) +return ; +if (!early_radix_enabled ()) {pr_warn ("KASAN not enabled as it requires radix!" );return ;
@@ -94,6 +97,9 @@ void __init kasan_init(void)static_branch_inc (&powerpc_kasan_enabled_key); +/* KASAN is now initialized, enable it. */ +static_branch_enable (&kasan_flag_enabled); +/* Enable error messages */ init_task.kasan_depth =0 ;pr_info ("KASAN init done\n" );
Signature · 1 line
2.41.0
PATCH v3 8/12 arch/riscv: don't initialize kasan if it's disabled
In reply to Baoquan HeAnd also add code to enable kasan_flag_enabled, this is for later usage.
--- arch/riscv/mm/kasan_init.c | 6 ++++++ 1 file changed, 6 insertions(+)
arch/riscv/mm/kasan_init.c +6 -0
@@ -485,6 +485,9 @@ void __init kasan_init(void)phys_addr_t p_start, p_end;u64 i; +if (kasan_arg_disabled) +return ; +create_tmp_mapping ();csr_write (CSR_SATP ,PFN_DOWN (__pa (tmp_pg_dir)) | satp_mode);
@@ -531,6 +534,9 @@ void __init kasan_init(void)memset (kasan_early_shadow_page,KASAN_SHADOW_INIT ,PAGE_SIZE ); init_task.kasan_depth =0 ; +/* KASAN is now initialized, enable it. */ +static_branch_enable (&kasan_flag_enabled); +csr_write (CSR_SATP ,PFN_DOWN (__pa (swapper_pg_dir)) | satp_mode);local_flush_tlb_all (); }
Signature · 1 line
2.41.0
PATCH v3 9/12 arch/x86: don't initialize kasan if it's disabled
In reply to Baoquan HeAnd also add code to enable kasan_flag_enabled, this is for later usage.
--- arch/x86/mm/kasan_init_64.c | 6 ++++++ 1 file changed, 6 insertions(+)
arch/x86/mm/kasan_init_64.c +6 -0
@@ -343,6 +343,9 @@ void __init kasan_init(void)unsigned long shadow_cea_begin, shadow_cea_per_cpu_begin, shadow_cea_end;int i; +if (kasan_arg_disabled) +return ; +memcpy (early_top_pgt, init_top_pgt,sizeof (early_top_pgt));/*
@@ -450,6 +453,9 @@ void __init kasan_init(void)/* Flush TLBs again to be sure that write protection applied. */ __flush_tlb_all (); +/* KASAN is now initialized, enable it. */ +static_branch_enable (&kasan_flag_enabled); + init_task.kasan_depth =0 ;pr_info ("KernelAddressSanitizer initialized\n" ); }
Signature · 1 line
2.41.0
PATCH v3 10/12 arch/xtensa: don't initialize kasan if it's disabled
In reply to Baoquan HeAnd also add code to enable kasan_flag_enabled, this is for later usage.
Here call jump_label_init() early in setup_arch() so that later kasan_init() can enable static key kasan_flag_enabled. Put jump_label_init() beofre parse_early_param() as other architectures do.
--- arch/xtensa/kernel/setup.c | 1 + arch/xtensa/mm/kasan_init.c | 6 ++++++ 2 files changed, 7 insertions(+)
arch/xtensa/kernel/setup.c +1 -0
@@ -352,6 +352,7 @@ void __init setup_arch(char **cmdline_p)mem_reserve (__pa (_SecondaryResetVector_text_start),__pa (_SecondaryResetVector_text_end));#endif +jump_label_init ();parse_early_param ();bootmem_init ();kasan_init ();
arch/xtensa/mm/kasan_init.c +6 -0
@@ -70,6 +70,9 @@ void __init kasan_init(void) {int i; +if (kasan_arg_disabled) +return ; +BUILD_BUG_ON (KASAN_SHADOW_OFFSET !=KASAN_SHADOW_START - (KASAN_START_VADDR >>KASAN_SHADOW_SCALE_SHIFT ));BUILD_BUG_ON (VMALLOC_START <KASAN_START_VADDR );
@@ -92,6 +95,9 @@ void __init kasan_init(void)local_flush_tlb_all ();memset (kasan_early_shadow_page,0 ,PAGE_SIZE ); +/* KASAN is now initialized, enable it. */ +static_branch_enable (&kasan_flag_enabled); +/* At this point kasan is fully initialized. Enable error messages. */ current->kasan_depth =0 ;pr_info ("KernelAddressSanitizer initialized\n" );
Signature · 1 line
2.41.0
PATCH v3 11/12 arch/um: don't initialize kasan if it's disabled
In reply to Baoquan HeAnd also add code to enable kasan_flag_enabled, this is for later usage. Since kasan_init() is called before main(), enabling kasan_flag_enabled is done in arch_mm_preinit() which is after jump_label_init() invocation.
And also do the kasan_arg_disabled chekcing before kasan_flag_enabled enabling to make sure kernel parameter kasan=on|off has been parsed.
--- arch/um/kernel/mem.c | 7 +++++++ 1 file changed, 7 insertions(+)
arch/um/kernel/mem.c +7 -0
@@ -58,6 +58,13 @@ static unsigned long brk_end;void __init arch_mm_preinit (void ) { + +#ifdef CONFIG_KASAN +/* Safe to call after jump_label_init(). Enables KASAN. */ +if (!kasan_arg_disabled) +static_branch_enable (&kasan_flag_enabled); +#endif +/* clear the zero-page */ memset (empty_zero_page,0 ,PAGE_SIZE );
Signature · 1 line
2.41.0
PATCH v3 12/12 mm/kasan: make kasan=on|off take effect for all three modes
In reply to Baoquan HeNow everything is ready, set kasan=off can disable kasan for all three modes.
--- include/linux/kasan-enabled.h | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-)
include/linux/kasan-enabled.h +8 -10
@@ -4,34 +4,32 @@#include <linux/static_key.h> +#ifdef CONFIG_KASAN extern bool kasan_arg_disabled;DECLARE_STATIC_KEY_FALSE (kasan_flag_enabled); -#ifdef CONFIG_KASAN_HW_TAGS - static __always_inline bool kasan_enabled(void) {return static_branch_likely (&kasan_flag_enabled); } +#else /* CONFIG_KASAN */ +static inline bool kasan_enabled (void ) +{ +return false; +} +#endif +#ifdef CONFIG_KASAN_HW_TAGS static inline bool kasan_hw_tags_enabled (void ) {return kasan_enabled (); } -#else /* CONFIG_KASAN_HW_TAGS */ - -static inline bool kasan_enabled (void ) -{ -return IS_ENABLED (CONFIG_KASAN ); -} -static inline bool kasan_hw_tags_enabled (void ) {return false; } -#endif /* CONFIG_KASAN_HW_TAGS */ #endif /* LINUX_KASAN_ENABLED_H */
Signature · 1 line
2.41.0
Andrey Konovalov
reviewerQuoted 10 lines · Baoquan He
Currently only
hw_tagsmode of kasan can be enabled or disabled with kernel parameter kasan=on|off for built kernel. For kasan generic andsw_tagsmode, there's no way to disable them once kernel is built. This is not convenient sometime, e.g in system kdump is configured. When the 1st kernel has KASAN enabled and crash triggered to switch to kdump kernel, the generic orsw_tagsmode will cost much extra memory for kasan shadow while in fact it's meaningless to have kasan in kdump kernel.
Quoted 4 lines
So this patchset moves the kasan=on|off out of
hw_tagsscope and into common code to make it visible in generic andsw_tagsmode too. Then we can add kasan=off in kdump kernel to reduce the unneeded meomry cost for kasan.
Continuing the discussion on the previous version: so the unwanted extra memory usage is caused by the shadow memory for vmalloc allocations (as they get freed lazily)? This needs to be explained in the commit message.
If so, would it help if we make the kasan.vmalloc command-line parameter work with the non-HW_TAGS modes (and make it do the same thing as disabling CONFIG_KASAN_VMALLOC)?
What I don't like about introducing kasan=off for non-HW_TAGS modes is that this parameter does not actually disable KASAN. It just suppresses KASAN code for mapping proper shadow memory. But the compiler-added instrumentation is still executing (and I suspect this might break the inline instrumentation mode).
Perhaps, we could instead add a new kasan.shadow=on/off parameter to make it more explicit that KASAN is not off, it's just that it stops mapping shadow memory.
Dmitry, Alexander, Marco, do you have any opinion on kasan=off for non-HW_TAGS modes?
On a side note, this series will need to be rebased onto Sabyrzhan's patches [1] - those are close to being ready. But perhaps let's wait for v7 first.
Quoted 16 lines · Andrey Konovalov
Quoted 10 lines · Baoquan He
Currently only
hw_tagsmode of kasan can be enabled or disabled with kernel parameter kasan=on|off for built kernel. For kasan generic andsw_tagsmode, there's no way to disable them once kernel is built. This is not convenient sometime, e.g in system kdump is configured. When the 1st kernel has KASAN enabled and crash triggered to switch to kdump kernel, the generic orsw_tagsmode will cost much extra memory for kasan shadow while in fact it's meaningless to have kasan in kdump kernel.Quoted 4 lines
So this patchset moves the kasan=on|off out of
hw_tagsscope and into common code to make it visible in generic andsw_tagsmode too. Then we can add kasan=off in kdump kernel to reduce the unneeded meomry cost for kasan.
Quoted 4 lines
Continuing the discussion on the previous version: so the unwanted extra memory usage is caused by the shadow memory for vmalloc allocations (as they get freed lazily)? This needs to be explained in the commit message.
Hmm, up to now, there are two parts of big amount of memory requiring for kernel as I observed. One is the direct memory mapping shadow of kasan, which is 1/8 of system RAM in generic mode and 1/16 of system RAM in sw_tags mode; the other is the shadow meomry for vmalloc which causes meomry big meomry usage in kdump kernel because of lazy vmap freeing. By introducing "kasan=off|on", if we specify 'kasan=off', the former is avoided by skipping the kasan_init(), and the latter is avoided by not build the vmalloc shadow for vmalloc.
Yes, I totally agree with you, I should have put this in cover letter and the main patch log to explain it better.
Quoted 10 lines
If so, would it help if we make the kasan.vmalloc command-line parameter work with the non-HW_TAGS modes (and make it do the same thing as disabling
CONFIG_KASAN_VMALLOC)?What I don't like about introducing kasan=off for non-HW_TAGS modes is that this parameter does not actually disable KASAN. It just suppresses KASAN code for mapping proper shadow memory. But the compiler-added instrumentation is still executing (and I suspect this might break the inline instrumentation mode).
I may not follow your saying it doesn't disable KASAN. In this patchset, not only do I disable the code for mapping shadow memory, but also I skip any KASAN checking. Please see change of check_region_inline() in mm/kasan/generic.c and kasan_check_range() in mm/kasan/sw_tags.c. It will skip any KASAN checking when accessing memory.
Yeah, the compiler added instrumentation will be called, but the if (!kasan_enabled()) checking will decide if going further into KASAN code or just return directly. I tried inline mode on x86_64 and arm64, it works well when one reviewer said inline mode could cost much more memory, I don't see any breakage w or w/o kasan=off when this patchset applied..
Quoted 4 lines
Perhaps, we could instead add a new kasan.shadow=on/off parameter to make it more explicit that KASAN is not off, it's just that it stops mapping shadow memory.
Hmm, as I explained at above, kasan=off will stop mapping shadow memory, and also stop executing KASAN code to poison/unpoison memory and check the shadow. It may be inappropriate to say it only stops mapping shadow.
Quoted 7 lines
Dmitry, Alexander, Marco, do you have any opinion on kasan=off for non-HW_TAGS modes?
On a side note, this series will need to be rebased onto Sabyrzhan's patches [1] - those are close to being ready. But perhaps let's wait for v7 first.
I replied to Sabyrzhan's patchset, on top of this patchset, it's much easier and cleaner to remove kasan_arch_is_ready(). We don't need introduce CONFIG_ARCH_DEFER_KASAN. Please see below patchset which is based on this patchset introducing 'kasan=off|on' to genric|sw_tags mode.
[PATCH 0/4] mm/kasan: remove kasan_arch_is_ready()
https://lore.kernel.org/all/[email protected]/T/#u
Quoted 3 lines
Thanks a lot for reviewing and feedback.
Andrey Konovalov
reviewerQuoted 17 lines · Baoquan He
Quoted 10 lines
If so, would it help if we make the kasan.vmalloc command-line parameter work with the non-HW_TAGS modes (and make it do the same thing as disabling
CONFIG_KASAN_VMALLOC)?What I don't like about introducing kasan=off for non-HW_TAGS modes is that this parameter does not actually disable KASAN. It just suppresses KASAN code for mapping proper shadow memory. But the compiler-added instrumentation is still executing (and I suspect this might break the inline instrumentation mode).
I may not follow your saying it doesn't disable KASAN. In this patchset, not only do I disable the code for mapping shadow memory, but also I skip any KASAN checking. Please see change of
check_region_inline()inmm/kasan/generic.candkasan_check_range()inmm/kasan/sw_tags.c. It will skip any KASAN checking when accessing memory.
Quoted 3 lines
Yeah, the compiler added instrumentation will be called, but the if (!kasan_enabled()) checking will decide if going further into KASAN code or just return directly.
This all is true for the outline instrumentation mode.
However, with the inline instrumentation, check_region_inline() is not called (in many cases, at least) and instead the compiler embeds the instructions to calculate the shadow memory address and check its value directly (this is why we have CONFIG_KASAN_SHADOW_OFFSET, whose value has to be known at compile time).
Quoted 4 lines
I tried inline mode on
x86_64and arm64, it
works well when one reviewer said inline mode could cost much more memory, I don't see any breakage w or w/o kasan=off when this patchset applied..
This is interesting. I guess what happens is that we still have the early shadow memory mapped so the shadow memory accesses inserted by the inline instrumentation do not crash.
But have you tried running kasan=off + CONFIG_KASAN_STACK=y + CONFIG_VMAP_STACK=y (+ CONFIG_KASAN_VMALLOC=y)? I would expect this should causes crashes, as the early shadow is mapped as read-only and the inline stack instrumentation will try writing into it (or do the writes into the early shadow somehow get ignored?..).
Quoted 7 lines
Quoted 3 lines
Perhaps, we could instead add a new kasan.shadow=on/off parameter to make it more explicit that KASAN is not off, it's just that it stops mapping shadow memory.
Hmm, as I explained at above, kasan=off will stop mapping shadow memory, and also stop executing KASAN code to poison/unpoison memory and check the shadow. It may be inappropriate to say it only stops mapping shadow.
That's true, but we can only achieve this for the outline instrumentation mode.
With the inline instrumentation mode, the (early) shadow memory would still get accessed all the time even with kasan=off. Which can be considered inappropriate, as you pointed out (though this is what happens for vmalloc allocations when CONFIG_KASAN_VMALLOC is disabled and it does seem to work; but the inline stack instrumentation might be a problem).
We could limit kasan=off to only the outline instrumentation mode, but I guess that defeats the purpose.
I'm not completely opposed to making kasan=off work with all KASAN modes (assuming it works with the inline instrumentation), but then we will need to thoroughly document the behavior it creates.
And let's also wait for an opinion from the other KASAN maintainers on this.
Quoted 7 lines
Quoted 6 lines
Dmitry, Alexander, Marco, do you have any opinion on kasan=off for non-HW_TAGS modes?
On a side note, this series will need to be rebased onto Sabyrzhan's patches [1] - those are close to being ready. But perhaps let's wait for v7 first.
Quoted 5 lines
I replied to Sabyrzhan's patchset, on top of this patchset, it's much easier and cleaner to remove
kasan_arch_is_ready(). We don't need introduceCONFIG_ARCH_DEFER_KASAN. Please see below patchset which is based on this patchset introducing 'kasan=off|on' to genric|sw_tags mode.
Based on a brief look, both patch series seem to be doing similar things (except yours also allows using kasan=off for all modes).
But I like the Sabyrzhan's approach of hiding the explicit static_branch_enable() calls under CONFIG_ARCH_DEFER_KASAN for the architectures where they are actually required.
So I propose we moved forward with the Sabyrzhan's series and then apply additional patches for supporting kasan=off on top (but again, assuming they work with the inline instrumentation).
Thank you!
Andrey Ryabinin
maintainerQuoted 39 lines · Andrey Konovalov
Quoted 17 lines · Baoquan He
Quoted 10 lines
If so, would it help if we make the kasan.vmalloc command-line parameter work with the non-HW_TAGS modes (and make it do the same thing as disabling
CONFIG_KASAN_VMALLOC)?What I don't like about introducing kasan=off for non-HW_TAGS modes is that this parameter does not actually disable KASAN. It just suppresses KASAN code for mapping proper shadow memory. But the compiler-added instrumentation is still executing (and I suspect this might break the inline instrumentation mode).
I may not follow your saying it doesn't disable KASAN. In this patchset, not only do I disable the code for mapping shadow memory, but also I skip any KASAN checking. Please see change of
check_region_inline()inmm/kasan/generic.candkasan_check_range()inmm/kasan/sw_tags.c. It will skip any KASAN checking when accessing memory.Quoted 3 lines
Yeah, the compiler added instrumentation will be called, but the if (!kasan_enabled()) checking will decide if going further into KASAN code or just return directly.
This all is true for the outline instrumentation mode.
However, with the inline instrumentation,
check_region_inline()is not called (in many cases, at least) and instead the compiler embeds the instructions to calculate the shadow memory address and check its value directly (this is why we haveCONFIG_KASAN_SHADOW_OFFSET, whose value has to be known at compile time).Quoted 4 lines
I tried inline mode on
x86_64and arm64, it
works well when one reviewer said inline mode could cost much more memory, I don't see any breakage w or w/o kasan=off when this patchset applied..This is interesting. I guess what happens is that we still have the early shadow memory mapped so the shadow memory accesses inserted by the inline instrumentation do not crash.
Quoted 6 lines
But have you tried running kasan=off +
CONFIG_KASAN_STACK=y+CONFIG_VMAP_STACK=y(+CONFIG_KASAN_VMALLOC=y)? I would expect this should causes crashes, as the early shadow is mapped as read-only and the inline stack instrumentation will try writing into it (or do the writes into the early shadow somehow get ignored?..).
It's not read-only, otherwise we would crash very early before full shadow setup and won't be able to boot at all. So writes still happen, and shadow checked, but reports are disabled.
So the patchset should work, but it's a little bit odd feature. With kasan=off we still pay x2-x3 performance penalty of compiler instrumentation and get nothing in return. So the usecase for this is if you don't want to compile and manage additional kernel binary (with CONFIG_KASAN=n) and don't care about performance at all.
Andrey Konovalov
reviewerQuoted 11 lines · Andrey Ryabinin
Quoted 7 lines
But have you tried running kasan=off +
CONFIG_KASAN_STACK=y+CONFIG_VMAP_STACK=y(+CONFIG_KASAN_VMALLOC=y)? I would expect this should causes crashes, as the early shadow is mapped as read-only and the inline stack instrumentation will try writing into it (or do the writes into the early shadow somehow get ignored?..).It's not read-only, otherwise we would crash very early before full shadow setup and won't be able to boot at all. So writes still happen, and shadow checked, but reports are disabled.
Hm, I thought it worked like that, but then what threw me off just now was seeing that zero_pte_populate()->pte_wrprotect() (on arm64) resets the PTE_WRITE bit and sets the PTE_RDONLY bit. So I thought the kasan_early_shadow_page is marked as read-only and then the instrumentation is disabled for all early code that might write into the page before the proper shadow is set up. Or am I reading this bit-setting code wrong?
Le 05/09/2025 à 20:08, Andrey Konovalov a écrit :
Quoted 13 lines · Andrey Ryabinin
Quoted 11 lines
Quoted 7 lines
But have you tried running kasan=off +
CONFIG_KASAN_STACK=y+CONFIG_VMAP_STACK=y(+CONFIG_KASAN_VMALLOC=y)? I would expect this should causes crashes, as the early shadow is mapped as read-only and the inline stack instrumentation will try writing into it (or do the writes into the early shadow somehow get ignored?..).It's not read-only, otherwise we would crash very early before full shadow setup and won't be able to boot at all. So writes still happen, and shadow checked, but reports are disabled.
Quoted 7 lines
Hm, I thought it worked like that, but then what threw me off just now was seeing that zero_pte_populate()->pte_wrprotect() (on arm64) resets the
PTE_WRITEbit and sets thePTE_RDONLYbit. So I thought thekasan_early_shadow_pageis marked as read-only and then the instrumentation is disabled for all early code that might write into the page before the proper shadow is set up. Or am I reading this bit-setting code wrong?
But that zero_pte_populate() is called by kasan_init() when everything is ready.
kasan_init()->kasan_init_shadow()->kasan_populate_early_shadow()->zero_p4d_populate()->zero_pud_populate()->zero_pmd_populate()->zero_pte_populate()
Here we are talking about the shadow set at startup kasan_early_init(), aren't we ?
Christophe
Andrey Konovalov
reviewerQuoted 9 lines · Christophe Leroy
Quoted 8 lines
Hm, I thought it worked like that, but then what threw me off just now was seeing that zero_pte_populate()->pte_wrprotect() (on arm64) resets the
PTE_WRITEbit and sets thePTE_RDONLYbit. So I thought thekasan_early_shadow_pageis marked as read-only and then the instrumentation is disabled for all early code that might write into the page before the proper shadow is set up. Or am I reading this bit-setting code wrong?
Quoted 7 lines
But that
zero_pte_populate()is called bykasan_init()when everything is ready.kasan_init()->kasan_init_shadow()->kasan_populate_early_shadow()->zero_p4d_populate()->zero_pud_populate()->zero_pmd_populate()->zero_pte_populate()
Here we are talking about the shadow set at startup
kasan_early_init(), aren't we ?
Ah, you're right, thanks!
I was confused by the name of kasan_populate_early_shadow(). I think we should rename it to kasan_populate_shadow_read_only() or something like that and also update the comment. As this function is not intended for populating early shadow (that is done via kasan_early_init() in the arch code instead), we're populating normal shadow for pages that can be accessed but whose shadow won't be written to. Perhaps it makes sense to come up with a better name for the kasan_early_shadow_page variable too to point out its dual purpose.
Andrey Konovalov
reviewerQuoted 7 lines · Andrey Ryabinin
Quoted 6 lines
But have you tried running kasan=off +
CONFIG_KASAN_STACK=y+CONFIG_VMAP_STACK=y(+CONFIG_KASAN_VMALLOC=y)? I would expect this should causes crashes, as the early shadow is mapped as read-only and the inline stack instrumentation will try writing into it (or do the writes into the early shadow somehow get ignored?..).
Quoted 8 lines
It's not read-only, otherwise we would crash very early before full shadow setup and won't be able to boot at all. So writes still happen, and shadow checked, but reports are disabled.
So the patchset should work, but it's a little bit odd feature. With kasan=off we still pay x2-x3 performance penalty of compiler instrumentation and get nothing in return. So the usecase for this is if you don't want to compile and manage additional kernel binary (with
CONFIG_KASAN=n) and don't care about performance at all.
Ack. So kasan=off would work but it's only benefit would be to avoid the RAM overhead.
Baoquan, I'd be in favor of implementing kasan.vmalloc=off instead of kasan=off. This seems to both (almost) solve the RAM overhead problem you're having (AFAIU) and also seems like a useful feature on its own (similar to CONFIG_KASAN_VMALLOC=n but via command-line). The patches to support kasan.vmalloc=off should also be orthogonal to the Sabyrzhan's series.
If you feel strongly that the ~1/8th RAM overhead (coming from the physmap shadow and the slab redzones) is still unacceptable for your use case (noting that the performance overhead (and the constant silent detection of false-positive bugs) would still be there), I think you can proceed with your series (unless someone else is against).
I also now get what you meant that with your patches for the kasan=off support, Sabyrzhan's CONFIG_ARCH_DEFER_KASAN would not be required
anymore: as every architecture would need a kasan_enabled() check, every architecture would effectively need the CONFIG_ARCH_DEFER_KASAN functionality (i.e. the static key to switch off KASAN).
Nevertheless, I still like the unification of the static keys usage and the KASAN initialization calls that the Sabyrzhan's series introduces, so I would propose to rebase your patches on top of his (even though you would remove CONFIG_ARCH_DEFER_KASAN, but that seems like a simple change) or pick out the related parts from his patches (but this might not be the best approach in case someone discovers a reason why kasan=off is a bad idea and we need to abandon the kasan=off series).
Andrey Konovalov
reviewerQuoted 8 lines · Andrey Konovalov
Baoquan, I'd be in favor of implementing kasan.vmalloc=off instead of kasan=off. This seems to both (almost) solve the RAM overhead problem you're having (AFAIU) and also seems like a useful feature on its own (similar to
CONFIG_KASAN_VMALLOC=nbut via command-line). The patches to support kasan.vmalloc=off should also be orthogonal to the Sabyrzhan's series.
Quoted 6 lines
If you feel strongly that the ~1/8th RAM overhead (coming from the physmap shadow and the slab redzones) is still unacceptable for your use case (noting that the performance overhead (and the constant silent detection of false-positive bugs) would still be there), I think you can proceed with your series (unless someone else is against).
Hm, just realized that kasan.vmalloc=off would probably break if CONFIG_VMAP_STACK is enabled: read-only shadow for vmalloc => read-only shadow for stacks => stack instrumentation will try writing into read-only shadow and crash.
So I wonder if there's a way to avoid the lazy vmap freeing to deal with the RAM overhead.
Quoted 16 lines · Andrey Konovalov
Quoted 8 lines · Andrey Konovalov
Baoquan, I'd be in favor of implementing kasan.vmalloc=off instead of kasan=off. This seems to both (almost) solve the RAM overhead problem you're having (AFAIU) and also seems like a useful feature on its own (similar to
CONFIG_KASAN_VMALLOC=nbut via command-line). The patches to support kasan.vmalloc=off should also be orthogonal to the Sabyrzhan's series.Quoted 6 lines
If you feel strongly that the ~1/8th RAM overhead (coming from the physmap shadow and the slab redzones) is still unacceptable for your use case (noting that the performance overhead (and the constant silent detection of false-positive bugs) would still be there), I think you can proceed with your series (unless someone else is against).
Quoted 7 lines
Hm, just realized that kasan.vmalloc=off would probably break if
CONFIG_VMAP_STACKis enabled: read-only shadow for vmalloc => read-only shadow for stacks => stack instrumentation will try writing into read-only shadow and crash.So I wonder if there's a way to avoid the lazy vmap freeing to deal with the RAM overhead.
That's a very key feature of vmalloc, lazy vmap freeing not only integrate the virtual area freeing on one cpu at one time, but also merge the areas and flush tlb at one time too. Please see __purge_vmap_area_lazy() for the details. This can avoid performance degradation when many vfree() are called.
Quoted 8 lines · Andrey Konovalov
Quoted 7 lines · Andrey Ryabinin
Quoted 6 lines
But have you tried running kasan=off +
CONFIG_KASAN_STACK=y+CONFIG_VMAP_STACK=y(+CONFIG_KASAN_VMALLOC=y)? I would expect this should causes crashes, as the early shadow is mapped as read-only and the inline stack instrumentation will try writing into it (or do the writes into the early shadow somehow get ignored?..).
Quoted 8 lines
Quoted 8 lines
It's not read-only, otherwise we would crash very early before full shadow setup and won't be able to boot at all. So writes still happen, and shadow checked, but reports are disabled.
So the patchset should work, but it's a little bit odd feature. With kasan=off we still pay x2-x3 performance penalty of compiler instrumentation and get nothing in return. So the usecase for this is if you don't want to compile and manage additional kernel binary (with
CONFIG_KASAN=n) and don't care about performance at all.
Thanks a lot for your careful reviewing, and sorry for late reply.
About kasan=off, we use static key to detect that, wondering if we will have x2-x3 performance penalty. Not only can kdump get the benefit, but I can think of one case where people may use kasan enabled kernel to detect MM issues, while use kasan=off to make sure kasan code itself won't make trouble. E.g you tested a normal kernel and it has no problem, while kasan enabled kernel will trigger issue, sometime do we doubt kasan code? In this case, kasan=off can prove its inonence?
This could be trivial, while I don't see much kasan=off introducing will impact the old kasan performance and stir the current kasan implementation code. We have got the kasan_arch_is_ready() anyway.
Quoted 3 lines
Ack. So kasan=off would work but it's only benefit would be to avoid the RAM overhead.
Right, I built kernel with below configs on, kasan=off|on works very well.
=====CONFIG_KASAN=yCONFIG_CC_HAS_KASAN_MEMINTRINSIC_PREFIX=yCONFIG_KASAN_GENERIC=yCONFIG_KASAN_INLINE=yCONFIG_KASAN_STACK=yCONFIG_KASAN_VMALLOC=yCONFIG_KASAN_KUNIT_TEST=m
...CONFIG_VMAP_STACK=y
=====
Quoted 8 lines
Baoquan, I'd be in favor of implementing kasan.vmalloc=off instead of kasan=off. This seems to both (almost) solve the RAM overhead problem you're having (AFAIU) and also seems like a useful feature on its own (similar to
CONFIG_KASAN_VMALLOC=nbut via command-line). The patches to support kasan.vmalloc=off should also be orthogonal to the Sabyrzhan's series.
Quoted 6 lines
If you feel strongly that the ~1/8th RAM overhead (coming from the physmap shadow and the slab redzones) is still unacceptable for your use case (noting that the performance overhead (and the constant silent detection of false-positive bugs) would still be there), I think you can proceed with your series (unless someone else is against).
Yeah, that would be great if we can also avoid any not needed memory consumption for kdump.
Quoted 6 lines
I also now get what you meant that with your patches for the kasan=off support, Sabyrzhan's
CONFIG_ARCH_DEFER_KASANwould not be required
anymore: as every architecture would need akasan_enabled()check, every architecture would effectively need theCONFIG_ARCH_DEFER_KASANfunctionality (i.e. the static key to switch off KASAN).
Exactly. In this case, the code with the static key enabling or disabling is clearer than CONFIG_ARCH_DEFER_KASAN setting or not.
Quoted 9 lines
Nevertheless, I still like the unification of the static keys usage and the KASAN initialization calls that the Sabyrzhan's series introduces, so I would propose to rebase your patches on top of his (even though you would remove
CONFIG_ARCH_DEFER_KASAN, but that seems like a simple change) or pick out the related parts from his patches (but this might not be the best approach in case someone discovers a reason why kasan=off is a bad idea and we need to abandon the kasan=off series).
Here I understand your reviewing policy. While I would like to explain a little about my posting. I planned to do this job in 2023, made draft patches on x86 for generic kasan, I dind't go further to try sw_tags mode on arm64 because other things interrupted me. This year, I made plan to disable some kernel features not necessary for kdump kernel, mainly by adding kernel parameter like ima= I made, and later the kasan=off.
aa9bb1b32594 ima: add a knob ima= to allow disabling IMA in kdump kernel
When I made patch and posted, I didn't see Sabyrzhan's patches because I usually don't go through mm mailing list. If I saw his patch earlier, I would have suggested him to solve this at the same time.
About Sabyrzhan's patch sereis, I have picked up part of his patches and credit the author to Sabyrzhan in below patchset.
[PATCH 0/4] mm/kasan: remove kasan_arch_is_ready()
https://lore.kernel.org/all/[email protected]/T/#u
About reposting of this series, do you think which one is preferred:
1) Firstly merge Sabyrzhan's patch series, I reverted them and apply for my patchset.
2) Credit the author of patch 1,2,3 of this patch series to Sabyrzhan too as below, because Sabyrzhan do the unification of the static keys usage and the KASAN initialization calls earlier:
[PATCH v3 01/12] mm/kasan: add conditional checks in functions to return directly if kasan is disabled [PATCH v3 02/12] mm/kasan: move kasan= code to common place
[PATCH v3 03/12] mm/kasan/sw_tags: don't initialize kasan if it's disabled
commit ac4004af0e1e8798d11c9310e500a88116d90271
Author: Baoquan He <[email protected]> Date: Mon Jan 2 08:58:36 2023 +0800
x86/kasan: check if kasan is available
commit cddd343bdbf5d0331695da8100380fc4b8b47464
Author: Baoquan He <[email protected]> Date: Sun Jan 1 20:57:51 2023 +0800
mm/kasan: allow generic and sw_tags to be set in kernel cmdline
commit b149886995ecb2e464fee0cdd3a814035fc87226
Author: Baoquan He <[email protected]> Date: Sun Jan 1 21:07:29 2023 +0800
x86/kasan: allow to disable kasan during boot time
Andrey Konovalov
reviewerQuoted 10 lines · Baoquan He
Quoted 7 lines
If you feel strongly that the ~1/8th RAM overhead (coming from the physmap shadow and the slab redzones) is still unacceptable for your use case (noting that the performance overhead (and the constant silent detection of false-positive bugs) would still be there), I think you can proceed with your series (unless someone else is against).
Yeah, that would be great if we can also avoid any not needed memory consumption for kdump.
Ack. Let's add support for kasan=off then.
But please describe it in detail in the KASAN documentation.
[...]
Quoted 10 lines
When I made patch and posted, I didn't see Sabyrzhan's patches because I usually don't go through mm mailing list. If I saw his patch earlier, I would have suggested him to solve this at the same time.
About Sabyrzhan's patch sereis, I have picked up part of his patches and credit the author to Sabyrzhan in below patchset.
[PATCH 0/4] mm/kasan: remove
kasan_arch_is_ready()
https://lore.kernel.org/all/[email protected]/T/#u
Quoted 8 lines
About reposting of this series, do you think which one is preferred:
1) Firstly merge Sabyrzhan's patch series, I reverted them and apply for my patchset.
2) Credit the author of patch 1,2,3 of this patch series to Sabyrzhan too as below, because Sabyrzhan do the unification of the static keys usage and the KASAN initialization calls earlier:
Since the Sabyrzhan's patches are already in mm-stable (and I assume will be merged during the next merge window), just rebase your changes on top.
But also note that Sabyrzhan is planning to move out the kasan_enabled() checks into include/linux/kasan.h (which is a clean-up I would have also asked you to do with the kasan=off patches), so maybe you should sync up with him wrt these changes.
Thanks!
Quoted 9 lines · Andrey Konovalov
Quoted 8 lines · Baoquan He
Quoted 7 lines
If you feel strongly that the ~1/8th RAM overhead (coming from the physmap shadow and the slab redzones) is still unacceptable for your use case (noting that the performance overhead (and the constant silent detection of false-positive bugs) would still be there), I think you can proceed with your series (unless someone else is against).
Quoted 4 lines
Quoted 2 lines
Yeah, that would be great if we can also avoid any not needed memory consumption for kdump.
Ack. Let's add support for kasan=off then.
Thanks.
Quoted 2 lines
But please describe it in detail in the KASAN documentation.
Will do in next round.
Quoted 18 lines
[...]
Quoted 15 lines
When I made patch and posted, I didn't see Sabyrzhan's patches because I usually don't go through mm mailing list. If I saw his patch earlier, I would have suggested him to solve this at the same time.
About Sabyrzhan's patch sereis, I have picked up part of his patches and credit the author to Sabyrzhan in below patchset.
[PATCH 0/4] mm/kasan: remove
kasan_arch_is_ready()
https://lore.kernel.org/all/[email protected]/T/#uAbout reposting of this series, do you think which one is preferred:
1) Firstly merge Sabyrzhan's patch series, I reverted them and apply for my patchset.
Quoted 7 lines
Quoted 3 lines
2) Credit the author of patch 1,2,3 of this patch series to Sabyrzhan too as below, because Sabyrzhan do the unification of the static keys usage and the KASAN initialization calls earlier:
Since the Sabyrzhan's patches are already in mm-stable (and I assume will be merged during the next merge window), just rebase your changes on top.
That's fine, I will rebase.
Quoted 5 lines
But also note that Sabyrzhan is planning to move out the
kasan_enabled()checks intoinclude/linux/kasan.h(which is a clean-up I would have also asked you to do with the kasan=off patches), so maybe you should sync up with him wrt these changes.
Hi Sabyrzhan,
What's your thought? You want to do the cleanup after my rebasing on your merged patches or you prefer to do it ahead of time? Please let me know so that I can adjust my posting accordingly. Thanks.
Thanks
Baoquan
Quoted 14 lines · Baoquan He
Quoted 3 lines · Andrey Konovalov
Since the Sabyrzhan's patches are already in mm-stable (and I assume will be merged during the next merge window), just rebase your changes on top.
That's fine, I will rebase.
Quoted 5 lines
But also note that Sabyrzhan is planning to move out the
kasan_enabled()checks intoinclude/linux/kasan.h(which is a clean-up I would have also asked you to do with the kasan=off patches), so maybe you should sync up with him wrt these changes.
Quoted 6 lines
Hi Sabyrzhan,
What's your thought? You want to do the cleanup after my rebasing on your merged patches or you prefer to do it ahead of time? Please let me know so that I can adjust my posting accordingly. Thanks.
Hello,
I can make all necessary changes only next week. Currently, traveling. I will send the fix-up patch Andrey has described somewhere next week. Please let me know if it's ok.
Quoted 3 lines
Thanks
Baoquan
Quoted 22 lines · Sabyrzhan Tasbolatov
Quoted 14 lines · Baoquan He
Quoted 3 lines · Andrey Konovalov
Since the Sabyrzhan's patches are already in mm-stable (and I assume will be merged during the next merge window), just rebase your changes on top.
That's fine, I will rebase.
Quoted 5 lines
But also note that Sabyrzhan is planning to move out the
kasan_enabled()checks intoinclude/linux/kasan.h(which is a clean-up I would have also asked you to do with the kasan=off patches), so maybe you should sync up with him wrt these changes.Quoted 6 lines
Hi Sabyrzhan,
What's your thought? You want to do the cleanup after my rebasing on your merged patches or you prefer to do it ahead of time? Please let me know so that I can adjust my posting accordingly. Thanks.
Quoted 5 lines
Hello,
I can make all necessary changes only next week. Currently, traveling. I will send the fix-up patch Andrey has described somewhere next week. Please let me know if it's ok.
Please take it easy, today is Thursday, I will wait for your clean up patch next week and post. I can do some preparation work for rebasing on your merged patches. Thanks.
Quoted 5 lines
Quoted 4 lines
Thanks
Baoquan
Quoted 26 lines · Baoquan He
Quoted 24 lines · Sabyrzhan Tasbolatov
Quoted 14 lines · Baoquan He
Quoted 3 lines · Andrey Konovalov
Since the Sabyrzhan's patches are already in mm-stable (and I assume will be merged during the next merge window), just rebase your changes on top.
That's fine, I will rebase.
Quoted 5 lines
But also note that Sabyrzhan is planning to move out the
kasan_enabled()checks intoinclude/linux/kasan.h(which is a clean-up I would have also asked you to do with the kasan=off patches), so maybe you should sync up with him wrt these changes.Quoted 6 lines
Hi Sabyrzhan,
What's your thought? You want to do the cleanup after my rebasing on your merged patches or you prefer to do it ahead of time? Please let me know so that I can adjust my posting accordingly. Thanks.
Hello,
Quoted 7 lines
Quoted 3 lines
I can make all necessary changes only next week. Currently, traveling. I will send the fix-up patch Andrey has described somewhere next week. Please let me know if it's ok.
Please take it easy, today is Thursday, I will wait for your clean up patch next week and post. I can do some preparation work for rebasing on your merged patches. Thanks.
Hello,
Just heads up that I've already sent cleanup patches [1] and Andrew has merged them into mm-new tree. Hopefully, one week's delay wasn't a problem.
Quoted 35 lines · Sabyrzhan Tasbolatov
Quoted 26 lines · Baoquan He
Quoted 24 lines · Sabyrzhan Tasbolatov
Quoted 14 lines · Baoquan He
Quoted 3 lines · Andrey Konovalov
Since the Sabyrzhan's patches are already in mm-stable (and I assume will be merged during the next merge window), just rebase your changes on top.
That's fine, I will rebase.
Quoted 5 lines
But also note that Sabyrzhan is planning to move out the
kasan_enabled()checks intoinclude/linux/kasan.h(which is a clean-up I would have also asked you to do with the kasan=off patches), so maybe you should sync up with him wrt these changes.Quoted 6 lines
Hi Sabyrzhan,
What's your thought? You want to do the cleanup after my rebasing on your merged patches or you prefer to do it ahead of time? Please let me know so that I can adjust my posting accordingly. Thanks.
Hello,
Quoted 7 lines
Quoted 3 lines
I can make all necessary changes only next week. Currently, traveling. I will send the fix-up patch Andrey has described somewhere next week. Please let me know if it's ok.
Please take it easy, today is Thursday, I will wait for your clean up patch next week and post. I can do some preparation work for rebasing on your merged patches. Thanks.
Quoted 5 lines
Hello,
Just heads up that I've already sent cleanup patches [1] and Andrew has merged them into mm-new tree. Hopefully, one week's delay wasn't a problem.
Thanks for telling. I planned to rebase on top of that and repost in one week or two weeks. I am doing some patch back porting for RHEL.