Skip to contentSkip to conversation

mm/kasan: make kasan=on|off work for all three modes

PATCH Superseded Baoquan He 3 participants 24 messages Aug 12, 2025 – Aug 17, 2025

Subsystems (13)

v2 of 5 Superseded Latest is v5 →

lore
Share & tools
lore

Baoquan He

author
#0 lore raw

v2 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:
====
v1->v2:
- Add __ro_after_init for __ro_after_init, 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.
====

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                   |  6 +++++
 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, 165 insertions(+), 47 deletions(-)
Signature · 1 line
2.41.0
author
#1 lore raw

PATCH v2 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
index d54e89f8c3e7..8daea5892754 100644
@@ -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
index ced6b29fcf76..43d95f329675 100644
@@ -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
index 6958aa713c67..a6dc2c3d8a15 100644
@@ -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
index 62c01b4527eb..884357fa74ed 100644
@@ -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
index d2c70cd2afb1..637f2d02d2a3 100644
@@ -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
index b9382b5b6a37..01f19bc4a326 100644
@@ -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
author
#2 lore raw

PATCH v2 2/12 mm/kasan: move kasan= code to common place

In reply to Baoquan He

This 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
index 6f612d69ea0c..32f2d19f599f 100644
@@ -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
index 9142964ab9c9..69a848f2a8aa 100644
@@ -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
index 9a6927394b54..377e9c285a74 100644
@@ -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
author
#3 lore raw

PATCH v2 3/12 mm/kasan/sw_tags: don't initialize kasan if it's disabled

In reply to Baoquan He

And 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
index 01f19bc4a326..dd963ba4d143 100644
@@ -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
author
#4 lore raw

PATCH v2 4/12 arch/arm: don't initialize kasan if it's disabled

In reply to Baoquan He

And 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
index 0bfd66c7ada0..453a47a4c715 100644
@@ -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
index 111d4f703136..c764e1b9c9c5 100644
@@ -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
author
#5 lore raw

PATCH v2 5/12 arch/arm64: don't initialize kasan if it's disabled

In reply to Baoquan He

And 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
index d541ce45daeb..0e4ffe3f5d0e 100644
@@ -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
author
#6 lore raw

PATCH v2 6/12 arch/loongarch: don't initialize kasan if it's disabled

In reply to Baoquan He

And 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
index d2681272d8f0..0c32eee6910f 100644
@@ -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
author
#7 lore raw

PATCH v2 7/12 arch/powerpc: don't initialize kasan if it's disabled

In reply to Baoquan He

This 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
index 03666d790a53..b0c465f3fbf5 100644
@@ -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
index 60c78aac0f63..1e1c10467a2b 100644
@@ -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
index 7d959544c077..9c5cf2354c8b 100644
@@ -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
author
#8 lore raw

PATCH v2 8/12 arch/riscv: don't initialize kasan if it's disabled

In reply to Baoquan He

And 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
index 41c635d6aca4..ac3ac227c765 100644
@@ -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
author
#9 lore raw

PATCH v2 9/12 arch/x86: don't initialize kasan if it's disabled

In reply to Baoquan He

And 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
index 0539efd0d216..0f2f9311e9df 100644
@@ -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
author
#10 lore raw

PATCH v2 10/12 arch/xtensa: don't initialize kasan if it's disabled

In reply to Baoquan He

And 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
index f72e280363be..aabeb23f41fa 100644
@@ -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
index f39c4d83173a..4a7b77f47225 100644
@@ -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
author
#11 lore raw

PATCH v2 11/12 arch/um: don't initialize kasan if it's disabled

In reply to Baoquan He

And 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.

---
 arch/um/kernel/mem.c | 6 ++++++
 1 file changed, 6 insertions(+)
arch/um/kernel/mem.c +6 -0
index 76bec7de81b5..392a23d4ef96 100644
@@ -26,6 +26,9 @@
 int kasan_um_is_ready;
 void kasan_init(void)
 {
+
+	if (kasan_arg_disabled)
+		return;
 	/*
 	 * kasan_map_memory will map all of the required address space and
 	 * the host machine will allocate physical memory as necessary.
@@ -58,6 +61,9 @@ static unsigned long brk_end;
 
 void __init arch_mm_preinit(void)
 {
+	/* Safe to call after jump_label_init(). Enables KASAN. */
+	static_branch_enable(&kasan_flag_enabled);
+
 	/* clear the zero-page */
 	memset(empty_zero_page, 0, PAGE_SIZE);
 
Signature · 1 line
2.41.0
author
#12 lore raw

PATCH v2 12/12 mm/kasan: make kasan=on|off take effect for all three modes

In reply to Baoquan He

Now 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
index 32f2d19f599f..21b6233f829c 100644
@@ -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
#13 lore raw

Re: [PATCH v2 12/12] mm/kasan: make kasan=on|off take effect for all three modes

kernel test robot noticed the following build errors:

Hi Baoquan,

kernel test robot noticed the following build errors:

[auto build test ERROR on powerpc/next]
[also build test ERROR on powerpc/fixes jcmvbkbc-xtensa/xtensa-for-next linus/master v6.17-rc1] [cannot apply to akpm-mm/mm-everything next-20250813]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]

url:    https://github.com/intel-lab-lkp/linux/commits/Baoquan-He/mm-kasan-add-conditional-checks-in-functions-to-return-directly-if-kasan-is-disabled/20250812-205253
base:   https://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux.git next
patch link:    https://lore.kernel.org/r/20250812124941.69508-13-bhe%40redhat.com
patch subject: [PATCH v2 12/12] mm/kasan: make kasan=on|off take effect for all three modes
config: um-randconfig-001-20250813 (https://download.01.org/0day-ci/archive/20250813/[email protected]/config)
compiler: gcc-12 (Debian 12.2.0-14+deb12u1) 12.2.0
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20250813/[email protected]/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/

All errors (new ones prefixed by >>):

In file included from include/linux/static_key.h:1,
from include/linux/alloc_tag.h:15, from include/linux/percpu.h:5, from include/linux/percpu_counter.h:14, from include/linux/mm_types.h:21, from include/linux/mmzone.h:22, from include/linux/gfp.h:7, from include/linux/umh.h:4, from include/linux/kmod.h:9, from include/linux/module.h:17, from arch/um/kernel/mem.c:7:
arch/um/kernel/mem.c: In function 'arch_mm_preinit':

>> arch/um/kernel/mem.c:65:31: error: 'kasan_flag_enabled' undeclared (first use in this function); did you mean 'kasan_hw_tags_enabled'?
      65 |         static_branch_enable(&kasan_flag_enabled);
         |                               ^~~~~~~~~~~~~~~~~~
   include/linux/jump_label.h:536:69: note: in definition of macro 'static_branch_enable'
     536 | #define static_branch_enable(x)                 static_key_enable(&(x)->key)
         |                                                                     ^
   arch/um/kernel/mem.c:65:31: note: each undeclared identifier is reported only once for each function it appears in
      65 |         static_branch_enable(&kasan_flag_enabled);
         |                               ^~~~~~~~~~~~~~~~~~
   include/linux/jump_label.h:536:69: note: in definition of macro 'static_branch_enable'
     536 | #define static_branch_enable(x)                 static_key_enable(&(x)->key)
         |                                                                     ^

vim +65 arch/um/kernel/mem.c

^1da177e4c3f41 Linus Torvalds            2005-04-16  61  
0d98484ee3330c Mike Rapoport (Microsoft  2025-03-13  62) void __init arch_mm_preinit(void)
^1da177e4c3f41 Linus Torvalds            2005-04-16  63  {
d44671c927e02c Baoquan He                2025-08-12  64  	/* Safe to call after jump_label_init(). Enables KASAN. */
d44671c927e02c Baoquan He                2025-08-12 @65  	static_branch_enable(&kasan_flag_enabled);
d44671c927e02c Baoquan He                2025-08-12  66  
^1da177e4c3f41 Linus Torvalds            2005-04-16  67  	/* clear the zero-page */
c0a9290ecf0dbb WANG Cong                 2008-02-04  68  	memset(empty_zero_page, 0, PAGE_SIZE);
^1da177e4c3f41 Linus Torvalds            2005-04-16  69  
^1da177e4c3f41 Linus Torvalds            2005-04-16  70  	/* Map in the area just after the brk now that kmalloc is about
^1da177e4c3f41 Linus Torvalds            2005-04-16  71  	 * to be turned on.
^1da177e4c3f41 Linus Torvalds            2005-04-16  72  	 */
^1da177e4c3f41 Linus Torvalds            2005-04-16  73  	brk_end = (unsigned long) UML_ROUND_UP(sbrk(0));
ab26a5276c1b09 Jeff Dike                 2008-02-04  74  	map_memory(brk_end, __pa(brk_end), uml_reserved - brk_end, 1, 1, 0);
4421cca0a3e483 Mike Rapoport             2021-11-05  75  	memblock_free((void *)brk_end, uml_reserved - brk_end);
^1da177e4c3f41 Linus Torvalds            2005-04-16  76  	uml_reserved = brk_end;
e82cf3051e6193 Tiwei Bie                 2025-02-21  77  	min_low_pfn = PFN_UP(__pa(uml_reserved));
0d98484ee3330c Mike Rapoport (Microsoft  2025-03-13  78) 	max_pfn = max_low_pfn;
0d98484ee3330c Mike Rapoport (Microsoft  2025-03-13  79) }
^1da177e4c3f41 Linus Torvalds            2005-04-16  80  
Signature · 2 lines
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
author
#14 lore raw

Re: [PATCH v2 12/12] mm/kasan: make kasan=on|off take effect for all three modes

Quoted 38 lines · kernel test robot

Hi Baoquan,

kernel test robot noticed the following build errors:

[auto build test ERROR on powerpc/next]
[also build test ERROR on powerpc/fixes jcmvbkbc-xtensa/xtensa-for-next linus/master v6.17-rc1] [cannot apply to akpm-mm/mm-everything next-20250813]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]

url:    https://github.com/intel-lab-lkp/linux/commits/Baoquan-He/mm-kasan-add-conditional-checks-in-functions-to-return-directly-if-kasan-is-disabled/20250812-205253
base:   https://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux.git next
patch link:    https://lore.kernel.org/r/20250812124941.69508-13-bhe%40redhat.com
patch subject: [PATCH v2 12/12] mm/kasan: make kasan=on|off take effect for all three modes
config: um-randconfig-001-20250813 (https://download.01.org/0day-ci/archive/20250813/[email protected]/config)
compiler: gcc-12 (Debian 12.2.0-14+deb12u1) 12.2.0
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20250813/[email protected]/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/

All errors (new ones prefixed by >>):

In file included from include/linux/static_key.h:1,
from include/linux/alloc_tag.h:15, from include/linux/percpu.h:5, from include/linux/percpu_counter.h:14, from include/linux/mm_types.h:21, from include/linux/mmzone.h:22, from include/linux/gfp.h:7, from include/linux/umh.h:4, from include/linux/kmod.h:9, from include/linux/module.h:17, from arch/um/kernel/mem.c:7:
arch/um/kernel/mem.c: In function 'arch_mm_preinit':

Quoted 3 lines
Quoted 1 line
Quoted 1 line

arch/um/kernel/mem.c:65:31: error: 'kasan_flag_enabled' undeclared (first use in this function); did you mean 'kasan_hw_tags_enabled'?

      65 |         static_branch_enable(&kasan_flag_enabled);
         |                               ^~~~~~~~~~~~~~~~~~

Thanks for reporting this error. I reproduced it and fix it with below change. While this change should be appended into patch 11.

It's because CONFIG_KASAN is unset, the static key kasan_flag_enabled enabling is added in arch_mm_preinit() which is not in CONFIG_KASAN scope. So here wrap it up within CONFIG_KASAN ifdeffery scope.

And also move the kasan_arg_disabled chekcing before kasan_flag_enabled enabling because kasan_init() is called before main(). So in kasan_init(), kernel parameter kasan=on|off hasn't been parsed.

arch/um/kernel/mem.c +5 -4
index d62f494e0808..2395ca33112a 100644
@@ -26,9 +26,6 @@
 int kasan_um_is_ready;
 void kasan_init(void)
 {
-
-	if (kasan_arg_disabled)
-		return;
 	/*
 	 * kasan_map_memory will map all of the required address space and
 	 * the host machine will allocate physical memory as necessary.
@@ -65,8 +62,12 @@ static unsigned long brk_end;
 
 void __init arch_mm_preinit(void)
 {
+
+#ifdef CONFIG_KASAN
 	/* Safe to call after jump_label_init(). Enables KASAN. */
-	static_branch_enable(&kasan_flag_enabled);
+	if (!kasan_arg_disabled)
+		static_branch_enable(&kasan_flag_enabled);
+#endif
 
 	/* clear the zero-page */
 	memset(empty_zero_page, 0, PAGE_SIZE);
author
#15 lore raw
In reply to Baoquan He

Forgot adding related ARCH mailing list or people to CC, add them.

Quoted 102 lines · Baoquan He

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:
====
v1->v2:
- Add __ro_after_init for __ro_after_init, 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.
====

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                   |  6 +++++
 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, 165 insertions(+), 47 deletions(-)
Signature · 1 line
2.41.0
author
#16 lore raw
In reply to Baoquan He
Quoted 14 lines · Baoquan He

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.

Quoted 4 lines

Changelog:
====
v1->v2:
- Add __ro_after_init for __ro_after_init, and remove redundant blank

~~~~~~~~~~~~~ s/__ro_after_init/kasan_arg_disabled/ Sorry for typo here.

Quoted 1 line

lines in mm/kasan/common.c. Thanks to Marco.

#17 lore raw
In reply to Baoquan He
Quoted 10 lines · Baoquan He

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.

Quoted 4 lines

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.

Hi Baoquan,

Could you clarify what are you trying to achieve by disabling Generic/SW_TAGS KASAN via command-line? Do you want not to see any KASAN reports produced? Or gain back the performance?

Because for the no reports goal, it would be much easier to add a command-line parameter to silent the reports.

And the performance goal can only be partially achieved, as you cannot remove the compiler instrumentation without rebuilding the kernel. (What are the boot times for KASAN_GENERIC=n vs KASAN_GENERIC=y + kasan=off vs KASAN_GENERIC=y btw?)

Thank you!

#18 lore raw
Quoted 26 lines · Andrey Konovalov
Quoted 10 lines · Baoquan He

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.

Quoted 4 lines

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.

Hi Baoquan,

Could you clarify what are you trying to achieve by disabling Generic/SW_TAGS KASAN via command-line? Do you want not to see any KASAN reports produced? Or gain back the performance?

Because for the no reports goal, it would be much easier to add a command-line parameter to silent the reports.

Quoted 6 lines

And the performance goal can only be partially achieved, as you cannot remove the compiler instrumentation without rebuilding the kernel. (What are the boot times for KASAN_GENERIC=n vs KASAN_GENERIC=y + kasan=off vs KASAN_GENERIC=y btw?)

Thank you!

Ah, you don't want the shadow memory for kdump, sorry, I somehow missed that.

I'm not familiar with the internals of kdump, but would it be possible/reasonable to teach kdump to ignore the KASAN shadow region?

author
#19 lore raw
Quoted 24 lines · Andrey Konovalov
Quoted 23 lines · Andrey Konovalov
Quoted 10 lines · Baoquan He

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.

Quoted 4 lines

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.

Hi Baoquan,

Could you clarify what are you trying to achieve by disabling Generic/SW_TAGS KASAN via command-line? Do you want not to see any KASAN reports produced? Or gain back the performance?

Quoted 8 lines
Quoted 8 lines

Because for the no reports goal, it would be much easier to add a command-line parameter to silent the reports.

And the performance goal can only be partially achieved, as you cannot remove the compiler instrumentation without rebuilding the kernel. (What are the boot times for KASAN_GENERIC=n vs KASAN_GENERIC=y + kasan=off vs KASAN_GENERIC=y btw?)

Thanks a lot for checking this.

Quoted 2 lines

Ah, you don't want the shadow memory for kdump, sorry, I somehow missed that.

Yeah, for kdump kernel, the shadow is a heavy burden, and most importantly kasan is useless for kdump. We don't want to capture a kernel memory bug through kdump kernel running becuase kdump is a debugging mechanism.

Quoted 3 lines

I'm not familiar with the internals of kdump, but would it be possible/reasonable to teach kdump to ignore the KASAN shadow region?

Yes, we can teach kdump to do that. Then people may hate those conditional check "if (is_kdump_kernel())" being added in kasan code. E.g even though we skip kasan_init(), we still need to check is_kdump_kernel() in kasan_populate_vmalloc(), right?

Combined with the existing kasan_arch_is_ready(), it will make kasan code ugly. I planned to add kasan_enabled() via static key kasan_flag_enabled, then it can also easily remove kasan_arch_is_ready() cleanly.

#20 lore raw
Quoted 9 lines · Baoquan He' via kasan-dev
Quoted 3 lines

I'm not familiar with the internals of kdump, but would it be possible/reasonable to teach kdump to ignore the KASAN shadow region?

Yes, we can teach kdump to do that. Then people may hate those conditional check "if (is_kdump_kernel())" being added in kasan code. E.g even though we skip kasan_init(), we still need to check is_kdump_kernel() in kasan_populate_vmalloc(), right?

Quoted 4 lines

Combined with the existing kasan_arch_is_ready(), it will make kasan code ugly. I planned to add kasan_enabled() via static key kasan_flag_enabled, then it can also easily remove kasan_arch_is_ready() cleanly.

What I had in mind was something different: into the kdump code, we add a check whether the region of memory it's trying to dump is the KASAN shadow, and make kdump not to dump this region.

Would this work? Would this help with the issue you have?

(I assume the problem is with the virtual region that is the shadow memory, as kdump would dump all RAM either way? If not, please clarify what how does the "heavy burden" that the shadow memory causes manifests.)

Thank you!

author
#21 lore raw
Quoted 11 lines · Andrey Konovalov
Quoted 9 lines · Baoquan He' via kasan-dev
Quoted 3 lines

I'm not familiar with the internals of kdump, but would it be possible/reasonable to teach kdump to ignore the KASAN shadow region?

Yes, we can teach kdump to do that. Then people may hate those conditional check "if (is_kdump_kernel())" being added in kasan code. E.g even though we skip kasan_init(), we still need to check is_kdump_kernel() in kasan_populate_vmalloc(), right?

Quoted 8 lines
Quoted 4 lines

Combined with the existing kasan_arch_is_ready(), it will make kasan code ugly. I planned to add kasan_enabled() via static key kasan_flag_enabled, then it can also easily remove kasan_arch_is_ready() cleanly.

What I had in mind was something different: into the kdump code, we add a check whether the region of memory it's trying to dump is the KASAN shadow, and make kdump not to dump this region.

Ah, I got what you mean. We probably are saying different things.

In order to record memory content of a corrupted kernel, we need reserve a memory region during bootup of a normal kernel (usually called 1st kernel) via kernel parameter crashkernel=nMB in advance. Then load kernel into the crashkernel memory region, that means the region is not usable for 1st kernel. When 1st kernel collapsed, we stop the 1st kernel cpu/irq and warmly switch to the loaded kernel in the crashkernel memory region (usually called kdump kernel). In kdump kernel, it boots up and enable necessary features to read out the 1st kernel's memory content, we usually use user space tool like makeudmpfile to filter out unwanted memory content.

So this patchset intends to disable KASAN to decrease the crashkernel meomry value because crashkernel is not usable for 1st kernel. As for shadow memory of 1st kernel, we need recognize it and filter it away in makedumpfile.

Quoted 10 lines

Would this work? Would this help with the issue you have?

(I assume the problem is with the virtual region that is the shadow memory, as kdump would dump all RAM either way? If not, please clarify what how does the "heavy burden" that the shadow memory causes manifests.)

Thank you!

#22 lore raw
Quoted 14 lines · Baoquan He

Ah, I got what you mean. We probably are saying different things.

In order to record memory content of a corrupted kernel, we need reserve a memory region during bootup of a normal kernel (usually called 1st kernel) via kernel parameter crashkernel=nMB in advance. Then load kernel into the crashkernel memory region, that means the region is not usable for 1st kernel. When 1st kernel collapsed, we stop the 1st kernel cpu/irq and warmly switch to the loaded kernel in the crashkernel memory region (usually called kdump kernel). In kdump kernel, it boots up and enable necessary features to read out the 1st kernel's memory content, we usually use user space tool like makeudmpfile to filter out unwanted memory content.

Quoted 4 lines

So this patchset intends to disable KASAN to decrease the crashkernel meomry value because crashkernel is not usable for 1st kernel. As for shadow memory of 1st kernel, we need recognize it and filter it away in makedumpfile.

Ah, I see, thank you for the explanation!

So kdump kernel runs with the amount of RAM specified by crashkernel=. And KASAN's shadow memory increases RAM usage, which means crashkernel= needs to be set to a higher value for KASAN kernels. Is my understanding of the problem correct?

author
#23 lore raw
Quoted 20 lines · Andrey Konovalov
Quoted 14 lines · Baoquan He

Ah, I got what you mean. We probably are saying different things.

In order to record memory content of a corrupted kernel, we need reserve a memory region during bootup of a normal kernel (usually called 1st kernel) via kernel parameter crashkernel=nMB in advance. Then load kernel into the crashkernel memory region, that means the region is not usable for 1st kernel. When 1st kernel collapsed, we stop the 1st kernel cpu/irq and warmly switch to the loaded kernel in the crashkernel memory region (usually called kdump kernel). In kdump kernel, it boots up and enable necessary features to read out the 1st kernel's memory content, we usually use user space tool like makeudmpfile to filter out unwanted memory content.

Quoted 4 lines

So this patchset intends to disable KASAN to decrease the crashkernel meomry value because crashkernel is not usable for 1st kernel. As for shadow memory of 1st kernel, we need recognize it and filter it away in makedumpfile.

Quoted 6 lines

Ah, I see, thank you for the explanation!

So kdump kernel runs with the amount of RAM specified by crashkernel=. And KASAN's shadow memory increases RAM usage, which means crashkernel= needs to be set to a higher value for KASAN kernels. Is my understanding of the problem correct?

Yeah, you are quite right.

When I tested it, on x86_64 and arm64, usually I set crashkernel=256M and it's sufficient. However, when KASAN is enabled and generic mode is taken, I need set crashkernel=768M to make vmcore dumping succeed. In kdump kernel, read_vmcore() uses ioremap to map the old memory of collapsed kernel for reading out, those vmalloc-ed areas are lazily freed and cause more shadow memory than what we usually think shadow memory only costs 1/8 of physical RAM.