lib/Kconfig.kasan

   1 # SPDX-License-Identifier: GPL-2.0-only
   2 # This config refers to the generic KASAN mode.
   3 config HAVE_ARCH_KASAN
   4         bool
   5
   6 config HAVE_ARCH_KASAN_SW_TAGS
   7         bool
   8
   9 config  HAVE_ARCH_KASAN_VMALLOC
  10         bool
  11
  12 config CC_HAS_KASAN_GENERIC
  13         def_bool $(cc-option, -fsanitize=kernel-address)
  14
  15 config CC_HAS_KASAN_SW_TAGS
  16         def_bool $(cc-option, -fsanitize=kernel-hwaddress)
  17
  18 config CC_HAS_WORKING_NOSANITIZE_ADDRESS
  19         def_bool !CC_IS_GCC || GCC_VERSION >= 80300
  20
  21 menuconfig KASAN
  22         bool "KASAN: runtime memory debugger"
  23         depends on (HAVE_ARCH_KASAN && CC_HAS_KASAN_GENERIC) || \
  24                    (HAVE_ARCH_KASAN_SW_TAGS && CC_HAS_KASAN_SW_TAGS)
  25         depends on (SLUB && SYSFS) || (SLAB && !DEBUG_SLAB)
  26         depends on CC_HAS_WORKING_NOSANITIZE_ADDRESS
  27         select CONSTRUCTORS
  28         select STACKDEPOT
  29         help
  30           Enables KASAN (KernelAddressSANitizer) - runtime memory debugger,
  31           designed to find out-of-bounds accesses and use-after-free bugs.
  32           See Documentation/dev-tools/kasan.rst for details.
  33
  34 if KASAN
  35
  36 choice
  37         prompt "KASAN mode"
  38         default KASAN_GENERIC
  39         help
  40           KASAN has two modes: generic KASAN (similar to userspace ASan,
  41           x86_64/arm64/xtensa, enabled with CONFIG_KASAN_GENERIC) and
  42           software tag-based KASAN (a version based on software memory
  43           tagging, arm64 only, similar to userspace HWASan, enabled with
  44           CONFIG_KASAN_SW_TAGS).
  45
  46           Both generic and tag-based KASAN are strictly debugging features.
  47
  48 config KASAN_GENERIC
  49         bool "Generic mode"
  50         depends on HAVE_ARCH_KASAN && CC_HAS_KASAN_GENERIC
  51         select SLUB_DEBUG if SLUB
  52         help
  53           Enables generic KASAN mode.
  54
  55           This mode is supported in both GCC and Clang. With GCC it requires
  56           version 8.3.0 or later. Any supported Clang version is compatible,
  57           but detection of out-of-bounds accesses for global variables is
  58           supported only since Clang 11.
  59
  60           This mode consumes about 1/8th of available memory at kernel start
  61           and introduces an overhead of ~x1.5 for the rest of the allocations.
  62           The performance slowdown is ~x3.
  63
  64           For better error detection enable CONFIG_STACKTRACE.
  65
  66           Currently CONFIG_KASAN_GENERIC doesn't work with CONFIG_DEBUG_SLAB
  67           (the resulting kernel does not boot).
  68
  69 config KASAN_SW_TAGS
  70         bool "Software tag-based mode"
  71         depends on HAVE_ARCH_KASAN_SW_TAGS && CC_HAS_KASAN_SW_TAGS
  72         select SLUB_DEBUG if SLUB
  73         help
  74           Enables software tag-based KASAN mode.
  75
  76           This mode requires Top Byte Ignore support by the CPU and therefore
  77           is only supported for arm64. This mode requires Clang.
  78
  79           This mode consumes about 1/16th of available memory at kernel start
  80           and introduces an overhead of ~20% for the rest of the allocations.
  81           This mode may potentially introduce problems relating to pointer
  82           casting and comparison, as it embeds tags into the top byte of each
  83           pointer.
  84
  85           For better error detection enable CONFIG_STACKTRACE.
  86
  87           Currently CONFIG_KASAN_SW_TAGS doesn't work with CONFIG_DEBUG_SLAB
  88           (the resulting kernel does not boot).
  89
  90 endchoice
  91
  92 choice
  93         prompt "Instrumentation type"
  94         default KASAN_OUTLINE
  95
  96 config KASAN_OUTLINE
  97         bool "Outline instrumentation"
  98         help
  99           Before every memory access compiler insert function call
 100           __asan_load*/__asan_store*. These functions performs check
 101           of shadow memory. This is slower than inline instrumentation,
 102           however it doesn't bloat size of kernel's .text section so
 103           much as inline does.
 104
 105 config KASAN_INLINE
 106         bool "Inline instrumentation"
 107         help
 108           Compiler directly inserts code checking shadow memory before
 109           memory accesses. This is faster than outline (in some workloads
 110           it gives about x2 boost over outline instrumentation), but
 111           make kernel's .text size much bigger.
 112
 113 endchoice
 114
 115 config KASAN_STACK_ENABLE
 116         bool "Enable stack instrumentation (unsafe)" if CC_IS_CLANG && !COMPILE_TEST
 117         help
 118           The LLVM stack address sanitizer has a know problem that
 119           causes excessive stack usage in a lot of functions, see
 120           https://bugs.llvm.org/show_bug.cgi?id=38809
 121           Disabling asan-stack makes it safe to run kernels build
 122           with clang-8 with KASAN enabled, though it loses some of
 123           the functionality.
 124           This feature is always disabled when compile-testing with clang
 125           to avoid cluttering the output in stack overflow warnings,
 126           but clang users can still enable it for builds without
 127           CONFIG_COMPILE_TEST.  On gcc it is assumed to always be safe
 128           to use and enabled by default.
 129
 130 config KASAN_STACK
 131         int
 132         default 1 if KASAN_STACK_ENABLE || CC_IS_GCC
 133         default 0
 134
 135 config KASAN_SW_TAGS_IDENTIFY
 136         bool "Enable memory corruption identification"
 137         depends on KASAN_SW_TAGS
 138         help
 139           This option enables best-effort identification of bug type
 140           (use-after-free or out-of-bounds) at the cost of increased
 141           memory consumption.
 142
 143 config KASAN_VMALLOC
 144         bool "Back mappings in vmalloc space with real shadow memory"
 145         depends on KASAN_GENERIC && HAVE_ARCH_KASAN_VMALLOC
 146         help
 147           By default, the shadow region for vmalloc space is the read-only
 148           zero page. This means that KASAN cannot detect errors involving
 149           vmalloc space.
 150
 151           Enabling this option will hook in to vmap/vmalloc and back those
 152           mappings with real shadow memory allocated on demand. This allows
 153           for KASAN to detect more sorts of errors (and to support vmapped
 154           stacks), but at the cost of higher memory usage.
 155
 156 config KASAN_KUNIT_TEST
 157         tristate "KUnit-compatible tests of KASAN bug detection capabilities" if !KUNIT_ALL_TESTS
 158         depends on KASAN && KUNIT
 159         default KUNIT_ALL_TESTS
 160         help
 161           This is a KUnit test suite doing various nasty things like
 162           out of bounds and use after free accesses. It is useful for testing
 163           kernel debugging features like KASAN.
 164
 165           For more information on KUnit and unit tests in general, please refer
 166           to the KUnit documentation in Documentation/dev-tools/kunit
 167
 168 config TEST_KASAN_MODULE
 169         tristate "KUnit-incompatible tests of KASAN bug detection capabilities"
 170         depends on m && KASAN
 171         help
 172           This is a part of the KASAN test suite that is incompatible with
 173           KUnit. Currently includes tests that do bad copy_from/to_user
 174           accesses.
 175
 176 endif # KASAN