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_HW_TAGS
  10         bool
  11
  12 config HAVE_ARCH_KASAN_VMALLOC
  13         bool
  14
  15 config ARCH_DISABLE_KASAN_INLINE
  16         bool
  17         help
  18           An architecture might not support inline instrumentation.
  19           When this option is selected, inline and stack instrumentation are
  20           disabled.
  21
  22 config CC_HAS_KASAN_GENERIC
  23         def_bool $(cc-option, -fsanitize=kernel-address)
  24
  25 config CC_HAS_KASAN_SW_TAGS
  26         def_bool $(cc-option, -fsanitize=kernel-hwaddress)
  27
  28 # This option is only required for software KASAN modes.
  29 # Old GCC versions don't have proper support for no_sanitize_address.
  30 # See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=89124 for details.
  31 config CC_HAS_WORKING_NOSANITIZE_ADDRESS
  32         def_bool !CC_IS_GCC || GCC_VERSION >= 80300
  33
  34 menuconfig KASAN
  35         bool "KASAN: runtime memory debugger"
  36         depends on (((HAVE_ARCH_KASAN && CC_HAS_KASAN_GENERIC) || \
  37                      (HAVE_ARCH_KASAN_SW_TAGS && CC_HAS_KASAN_SW_TAGS)) && \
  38                     CC_HAS_WORKING_NOSANITIZE_ADDRESS) || \
  39                    HAVE_ARCH_KASAN_HW_TAGS
  40         depends on (SLUB && SYSFS) || (SLAB && !DEBUG_SLAB)
  41         select STACKDEPOT_ALWAYS_INIT
  42         help
  43           Enables KASAN (KernelAddressSANitizer) - runtime memory debugger,
  44           designed to find out-of-bounds accesses and use-after-free bugs.
  45           See Documentation/dev-tools/kasan.rst for details.
  46
  47 if KASAN
  48
  49 choice
  50         prompt "KASAN mode"
  51         default KASAN_GENERIC
  52         help
  53           KASAN has three modes:
  54           1. generic KASAN (similar to userspace ASan,
  55              x86_64/arm64/xtensa, enabled with CONFIG_KASAN_GENERIC),
  56           2. software tag-based KASAN (arm64 only, based on software
  57              memory tagging (similar to userspace HWASan), enabled with
  58              CONFIG_KASAN_SW_TAGS), and
  59           3. hardware tag-based KASAN (arm64 only, based on hardware
  60              memory tagging, enabled with CONFIG_KASAN_HW_TAGS).
  61
  62           All KASAN modes are strictly debugging features.
  63
  64           For better error reports enable CONFIG_STACKTRACE.
  65
  66 config KASAN_GENERIC
  67         bool "Generic mode"
  68         depends on HAVE_ARCH_KASAN && CC_HAS_KASAN_GENERIC
  69         depends on CC_HAS_WORKING_NOSANITIZE_ADDRESS
  70         select SLUB_DEBUG if SLUB
  71         select CONSTRUCTORS
  72         help
  73           Enables generic KASAN mode.
  74
  75           This mode is supported in both GCC and Clang. With GCC it requires
  76           version 8.3.0 or later. Any supported Clang version is compatible,
  77           but detection of out-of-bounds accesses for global variables is
  78           supported only since Clang 11.
  79
  80           This mode consumes about 1/8th of available memory at kernel start
  81           and introduces an overhead of ~x1.5 for the rest of the allocations.
  82           The performance slowdown is ~x3.
  83
  84           Currently CONFIG_KASAN_GENERIC doesn't work with CONFIG_DEBUG_SLAB
  85           (the resulting kernel does not boot).
  86
  87 config KASAN_SW_TAGS
  88         bool "Software tag-based mode"
  89         depends on HAVE_ARCH_KASAN_SW_TAGS && CC_HAS_KASAN_SW_TAGS
  90         depends on CC_HAS_WORKING_NOSANITIZE_ADDRESS
  91         select SLUB_DEBUG if SLUB
  92         select CONSTRUCTORS
  93         help
  94           Enables software tag-based KASAN mode.
  95
  96           This mode require software memory tagging support in the form of
  97           HWASan-like compiler instrumentation.
  98
  99           Currently this mode is only implemented for arm64 CPUs and relies on
 100           Top Byte Ignore. This mode requires Clang.
 101
 102           This mode consumes about 1/16th of available memory at kernel start
 103           and introduces an overhead of ~20% for the rest of the allocations.
 104           This mode may potentially introduce problems relating to pointer
 105           casting and comparison, as it embeds tags into the top byte of each
 106           pointer.
 107
 108           Currently CONFIG_KASAN_SW_TAGS doesn't work with CONFIG_DEBUG_SLAB
 109           (the resulting kernel does not boot).
 110
 111 config KASAN_HW_TAGS
 112         bool "Hardware tag-based mode"
 113         depends on HAVE_ARCH_KASAN_HW_TAGS
 114         depends on SLUB
 115         help
 116           Enables hardware tag-based KASAN mode.
 117
 118           This mode requires hardware memory tagging support, and can be used
 119           by any architecture that provides it.
 120
 121           Currently this mode is only implemented for arm64 CPUs starting from
 122           ARMv8.5 and relies on Memory Tagging Extension and Top Byte Ignore.
 123
 124 endchoice
 125
 126 choice
 127         prompt "Instrumentation type"
 128         depends on KASAN_GENERIC || KASAN_SW_TAGS
 129         default KASAN_OUTLINE
 130
 131 config KASAN_OUTLINE
 132         bool "Outline instrumentation"
 133         help
 134           Before every memory access compiler insert function call
 135           __asan_load*/__asan_store*. These functions performs check
 136           of shadow memory. This is slower than inline instrumentation,
 137           however it doesn't bloat size of kernel's .text section so
 138           much as inline does.
 139
 140 config KASAN_INLINE
 141         bool "Inline instrumentation"
 142         depends on !ARCH_DISABLE_KASAN_INLINE
 143         help
 144           Compiler directly inserts code checking shadow memory before
 145           memory accesses. This is faster than outline (in some workloads
 146           it gives about x2 boost over outline instrumentation), but
 147           make kernel's .text size much bigger.
 148
 149 endchoice
 150
 151 config KASAN_STACK
 152         bool "Enable stack instrumentation (unsafe)" if CC_IS_CLANG && !COMPILE_TEST
 153         depends on KASAN_GENERIC || KASAN_SW_TAGS
 154         depends on !ARCH_DISABLE_KASAN_INLINE
 155         default y if CC_IS_GCC
 156         help
 157           The LLVM stack address sanitizer has a know problem that
 158           causes excessive stack usage in a lot of functions, see
 159           https://bugs.llvm.org/show_bug.cgi?id=38809
 160           Disabling asan-stack makes it safe to run kernels build
 161           with clang-8 with KASAN enabled, though it loses some of
 162           the functionality.
 163           This feature is always disabled when compile-testing with clang
 164           to avoid cluttering the output in stack overflow warnings,
 165           but clang users can still enable it for builds without
 166           CONFIG_COMPILE_TEST.  On gcc it is assumed to always be safe
 167           to use and enabled by default.
 168           If the architecture disables inline instrumentation, stack
 169           instrumentation is also disabled as it adds inline-style
 170           instrumentation that is run unconditionally.
 171
 172 config KASAN_TAGS_IDENTIFY
 173         bool "Enable memory corruption identification"
 174         depends on KASAN_SW_TAGS || KASAN_HW_TAGS
 175         help
 176           This option enables best-effort identification of bug type
 177           (use-after-free or out-of-bounds) at the cost of increased
 178           memory consumption.
 179
 180 config KASAN_VMALLOC
 181         bool "Check accesses to vmalloc allocations"
 182         depends on HAVE_ARCH_KASAN_VMALLOC
 183         help
 184           This mode makes KASAN check accesses to vmalloc allocations for
 185           validity.
 186
 187           With software KASAN modes, checking is done for all types of vmalloc
 188           allocations. Enabling this option leads to higher memory usage.
 189
 190           With hardware tag-based KASAN, only VM_ALLOC mappings are checked.
 191           There is no additional memory usage.
 192
 193 config KASAN_KUNIT_TEST
 194         tristate "KUnit-compatible tests of KASAN bug detection capabilities" if !KUNIT_ALL_TESTS
 195         depends on KASAN && KUNIT
 196         default KUNIT_ALL_TESTS
 197         help
 198           This is a KUnit test suite doing various nasty things like
 199           out of bounds and use after free accesses. It is useful for testing
 200           kernel debugging features like KASAN.
 201
 202           For more information on KUnit and unit tests in general, please refer
 203           to the KUnit documentation in Documentation/dev-tools/kunit.
 204
 205 config KASAN_MODULE_TEST
 206         tristate "KUnit-incompatible tests of KASAN bug detection capabilities"
 207         depends on m && KASAN && !KASAN_HW_TAGS
 208         help
 209           This is a part of the KASAN test suite that is incompatible with
 210           KUnit. Currently includes tests that do bad copy_from/to_user
 211           accesses.
 212
 213 endif # KASAN