Commit 7ebfce33 authored by Andrey Konovalov's avatar Andrey Konovalov Committed by Andrew Morton
Browse files

kasan: support kasan.stacktrace for SW_TAGS 

Add support for the kasan.stacktrace command-line argument for Software
Tag-Based KASAN.

The following patch adds a command-line argument for selecting the stack
ring size, and, as the stack ring is supported by both the Software and
the Hardware Tag-Based KASAN modes, it is natural that both of them have
support for kasan.stacktrace too.

Link: https://lkml.kernel.org/r/3b43059103faa7f8796017847b7d674b658f11b5.1662411799.git.andreyknvl@google.com


Signed-off-by: default avatarAndrey Konovalov <andreyknvl@google.com>
Reviewed-by: default avatarMarco Elver <elver@google.com>
Cc: Alexander Potapenko <glider@google.com>
Cc: Andrey Ryabinin <ryabinin.a.a@gmail.com>
Cc: Dmitry Vyukov <dvyukov@google.com>
Cc: Evgenii Stepanov <eugenis@google.com>
Cc: Peter Collingbourne <pcc@google.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
parent 7bc0584e

Documentation/dev-tools/kasan.rst

+9 −6
Original line number Diff line number Diff line
@@ -111,9 +111,15 @@ parameter can be used to control panic and reporting behaviour: 
  report or also panic the kernel (default: ``report``). The panic happens even

  if ``kasan_multi_shot`` is enabled.



Hardware Tag-Based KASAN mode (see the section about various modes below) is

intended for use in production as a security mitigation. Therefore, it supports

additional boot parameters that allow disabling KASAN or controlling features:

Software and Hardware Tag-Based KASAN modes (see the section about various

modes below) support disabling stack trace collection:



- ``kasan.stacktrace=off`` or ``=on`` disables or enables alloc and free stack

  traces collection (default: ``on``).



Hardware Tag-Based KASAN mode is intended for use in production as a security

mitigation. Therefore, it supports additional boot parameters that allow

disabling KASAN altogether or controlling its features:



- ``kasan=off`` or ``=on`` controls whether KASAN is enabled (default: ``on``).
@@ -132,9 +138,6 @@ additional boot parameters that allow disabling KASAN or controlling features: 
- ``kasan.vmalloc=off`` or ``=on`` disables or enables tagging of vmalloc

  allocations (default: ``on``).



- ``kasan.stacktrace=off`` or ``=on`` disables or enables alloc and free stack

  traces collection (default: ``on``).



Error reports

~~~~~~~~~~~~~

mm/kasan/hw_tags.c

+1 −38
Original line number Diff line number Diff line
@@ -38,16 +38,9 @@ enum kasan_arg_vmalloc { 
	KASAN_ARG_VMALLOC_ON,

};



enum kasan_arg_stacktrace {

	KASAN_ARG_STACKTRACE_DEFAULT,

	KASAN_ARG_STACKTRACE_OFF,

	KASAN_ARG_STACKTRACE_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;

static enum kasan_arg_stacktrace kasan_arg_stacktrace __initdata;



/*

 * Whether KASAN is enabled at all.
@@ -66,9 +59,6 @@ EXPORT_SYMBOL_GPL(kasan_mode); 
/* Whether to enable vmalloc tagging. */

DEFINE_STATIC_KEY_TRUE(kasan_flag_vmalloc);



/* Whether to collect alloc/free stack traces. */

DEFINE_STATIC_KEY_TRUE(kasan_flag_stacktrace);



/* kasan=off/on */

static int __init early_kasan_flag(char *arg)

{
@@ -122,23 +112,6 @@ static int __init early_kasan_flag_vmalloc(char *arg) 
}

early_param("kasan.vmalloc", early_kasan_flag_vmalloc);



/* kasan.stacktrace=off/on */

static int __init early_kasan_flag_stacktrace(char *arg)

{

	if (!arg)

		return -EINVAL;



	if (!strcmp(arg, "off"))

		kasan_arg_stacktrace = KASAN_ARG_STACKTRACE_OFF;

	else if (!strcmp(arg, "on"))

		kasan_arg_stacktrace = KASAN_ARG_STACKTRACE_ON;

	else

		return -EINVAL;



	return 0;

}

early_param("kasan.stacktrace", early_kasan_flag_stacktrace);



static inline const char *kasan_mode_info(void)

{

	if (kasan_mode == KASAN_MODE_ASYNC)
@@ -213,17 +186,7 @@ void __init kasan_init_hw_tags(void) 
		break;

	}



	switch (kasan_arg_stacktrace) {

	case KASAN_ARG_STACKTRACE_DEFAULT:

		/* Default is specified by kasan_flag_stacktrace definition. */

		break;

	case KASAN_ARG_STACKTRACE_OFF:

		static_branch_disable(&kasan_flag_stacktrace);

		break;

	case KASAN_ARG_STACKTRACE_ON:

		static_branch_enable(&kasan_flag_stacktrace);

		break;

	}

	kasan_init_tags();



	/* KASAN is now initialized, enable it. */

	static_branch_enable(&kasan_flag_enabled);

mm/kasan/kasan.h

+24 −12
Original line number Diff line number Diff line
@@ -8,13 +8,31 @@ 
#include <linux/kfence.h>

#include <linux/stackdepot.h>



#ifdef CONFIG_KASAN_HW_TAGS

#if defined(CONFIG_KASAN_SW_TAGS) || defined(CONFIG_KASAN_HW_TAGS)



#include <linux/static_key.h>



DECLARE_STATIC_KEY_TRUE(kasan_flag_stacktrace);



static inline bool kasan_stack_collection_enabled(void)

{

	return static_branch_unlikely(&kasan_flag_stacktrace);

}



#else /* CONFIG_KASAN_SW_TAGS || CONFIG_KASAN_HW_TAGS */



static inline bool kasan_stack_collection_enabled(void)

{

	return true;

}



#endif /* CONFIG_KASAN_SW_TAGS || CONFIG_KASAN_HW_TAGS */



#ifdef CONFIG_KASAN_HW_TAGS



#include "../slab.h"



DECLARE_STATIC_KEY_TRUE(kasan_flag_vmalloc);

DECLARE_STATIC_KEY_TRUE(kasan_flag_stacktrace);



enum kasan_mode {

	KASAN_MODE_SYNC,
@@ -29,11 +47,6 @@ static inline bool kasan_vmalloc_enabled(void) 
	return static_branch_likely(&kasan_flag_vmalloc);

}



static inline bool kasan_stack_collection_enabled(void)

{

	return static_branch_unlikely(&kasan_flag_stacktrace);

}



static inline bool kasan_async_fault_possible(void)

{

	return kasan_mode == KASAN_MODE_ASYNC || kasan_mode == KASAN_MODE_ASYMM;
@@ -46,11 +59,6 @@ static inline bool kasan_sync_fault_possible(void) 


#else /* CONFIG_KASAN_HW_TAGS */



static inline bool kasan_stack_collection_enabled(void)

{

	return true;

}



static inline bool kasan_async_fault_possible(void)

{

	return false;
@@ -410,6 +418,10 @@ static inline void kasan_enable_tagging(void) { } 


#endif /* CONFIG_KASAN_HW_TAGS */



#if defined(CONFIG_KASAN_SW_TAGS) || defined(CONFIG_KASAN_HW_TAGS)

void __init kasan_init_tags(void);

#endif /* CONFIG_KASAN_SW_TAGS || CONFIG_KASAN_HW_TAGS */



#if defined(CONFIG_KASAN_HW_TAGS) && IS_ENABLED(CONFIG_KASAN_KUNIT_TEST)



void kasan_force_async_fault(void);

mm/kasan/sw_tags.c

+4 −1
Original line number Diff line number Diff line
@@ -42,7 +42,10 @@ void __init kasan_init_sw_tags(void) 
	for_each_possible_cpu(cpu)

		per_cpu(prng_state, cpu) = (u32)get_cycles();



	pr_info("KernelAddressSanitizer initialized (sw-tags)\n");

	kasan_init_tags();



	pr_info("KernelAddressSanitizer initialized (sw-tags, stacktrace=%s)\n",

		kasan_stack_collection_enabled() ? "on" : "off");

}



/*

mm/kasan/tags.c

+43 −0
Original line number Diff line number Diff line
@@ -19,6 +19,17 @@ 
#include "kasan.h"

#include "../slab.h"



enum kasan_arg_stacktrace {

	KASAN_ARG_STACKTRACE_DEFAULT,

	KASAN_ARG_STACKTRACE_OFF,

	KASAN_ARG_STACKTRACE_ON,

};



static enum kasan_arg_stacktrace kasan_arg_stacktrace __initdata;



/* Whether to collect alloc/free stack traces. */

DEFINE_STATIC_KEY_TRUE(kasan_flag_stacktrace);



/* Non-zero, as initial pointer values are 0. */

#define STACK_RING_BUSY_PTR ((void *)1)
@@ -26,6 +37,38 @@ struct kasan_stack_ring stack_ring = { 
	.lock = __RW_LOCK_UNLOCKED(stack_ring.lock)

};



/* kasan.stacktrace=off/on */

static int __init early_kasan_flag_stacktrace(char *arg)

{

	if (!arg)

		return -EINVAL;



	if (!strcmp(arg, "off"))

		kasan_arg_stacktrace = KASAN_ARG_STACKTRACE_OFF;

	else if (!strcmp(arg, "on"))

		kasan_arg_stacktrace = KASAN_ARG_STACKTRACE_ON;

	else

		return -EINVAL;



	return 0;

}

early_param("kasan.stacktrace", early_kasan_flag_stacktrace);



void __init kasan_init_tags(void)

{

	switch (kasan_arg_stacktrace) {

	case KASAN_ARG_STACKTRACE_DEFAULT:

		/* Default is specified by kasan_flag_stacktrace definition. */

		break;

	case KASAN_ARG_STACKTRACE_OFF:

		static_branch_disable(&kasan_flag_stacktrace);

		break;

	case KASAN_ARG_STACKTRACE_ON:

		static_branch_enable(&kasan_flag_stacktrace);

		break;

	}

}



static void save_stack_info(struct kmem_cache *cache, void *object,

			gfp_t gfp_flags, bool is_free)

{