~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/Kconfig

Version: ~ [ linux-6.11.5 ] ~ [ linux-6.10.14 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.58 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.114 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.169 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.228 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.284 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.322 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

Diff markup

Differences between /arch/Kconfig (Version linux-6.11.5) and /arch/Kconfig (Version linux-5.12.19)


  1 # SPDX-License-Identifier: GPL-2.0                  1 # SPDX-License-Identifier: GPL-2.0
  2 #                                                   2 #
  3 # General architecture dependent options            3 # General architecture dependent options
  4 #                                                   4 #
  5                                                     5 
  6 #                                                   6 #
  7 # Note: arch/$(SRCARCH)/Kconfig needs to be in      7 # Note: arch/$(SRCARCH)/Kconfig needs to be included first so that it can
  8 # override the default values in this file.         8 # override the default values in this file.
  9 #                                                   9 #
 10 source "arch/$(SRCARCH)/Kconfig"                   10 source "arch/$(SRCARCH)/Kconfig"
 11                                                    11 
 12 config ARCH_CONFIGURES_CPU_MITIGATIONS         << 
 13         bool                                   << 
 14                                                << 
 15 if !ARCH_CONFIGURES_CPU_MITIGATIONS            << 
 16 config CPU_MITIGATIONS                         << 
 17         def_bool y                             << 
 18 endif                                          << 
 19                                                << 
 20 menu "General architecture-dependent options"      12 menu "General architecture-dependent options"
 21                                                    13 
 22 config ARCH_HAS_SUBPAGE_FAULTS                 !!  14 config CRASH_CORE
 23         bool                                   << 
 24         help                                   << 
 25           Select if the architecture can check << 
 26           granularity (e.g. arm64 MTE). The pr << 
 27           must be implemented.                 << 
 28                                                << 
 29 config HOTPLUG_SMT                             << 
 30         bool                                   << 
 31                                                << 
 32 config SMT_NUM_THREADS_DYNAMIC                 << 
 33         bool                                       15         bool
 34                                                    16 
 35 # Selected by HOTPLUG_CORE_SYNC_DEAD or HOTPLU !!  17 config KEXEC_CORE
 36 config HOTPLUG_CORE_SYNC                       !!  18         select CRASH_CORE
 37         bool                                       19         bool
 38                                                    20 
 39 # Basic CPU dead synchronization selected by a !!  21 config KEXEC_ELF
 40 config HOTPLUG_CORE_SYNC_DEAD                  << 
 41         bool                                       22         bool
 42         select HOTPLUG_CORE_SYNC               << 
 43                                                    23 
 44 # Full CPU synchronization with alive state se !!  24 config HAVE_IMA_KEXEC
 45 config HOTPLUG_CORE_SYNC_FULL                  << 
 46         bool                                       25         bool
 47         select HOTPLUG_CORE_SYNC_DEAD if HOTPL << 
 48         select HOTPLUG_CORE_SYNC               << 
 49                                                    26 
 50 config HOTPLUG_SPLIT_STARTUP                   !!  27 config SET_FS
 51         bool                                       28         bool
 52         select HOTPLUG_CORE_SYNC_FULL          << 
 53                                                    29 
 54 config HOTPLUG_PARALLEL                        !!  30 config HOTPLUG_SMT
 55         bool                                       31         bool
 56         select HOTPLUG_SPLIT_STARTUP           << 
 57                                                    32 
 58 config GENERIC_ENTRY                               33 config GENERIC_ENTRY
 59         bool                                   !!  34        bool
 60                                                    35 
 61 config KPROBES                                     36 config KPROBES
 62         bool "Kprobes"                             37         bool "Kprobes"
                                                   >>  38         depends on MODULES
 63         depends on HAVE_KPROBES                    39         depends on HAVE_KPROBES
 64         select KALLSYMS                            40         select KALLSYMS
 65         select EXECMEM                         << 
 66         select NEED_TASKS_RCU                  << 
 67         help                                       41         help
 68           Kprobes allows you to trap at almost     42           Kprobes allows you to trap at almost any kernel address and
 69           execute a callback function.  regist     43           execute a callback function.  register_kprobe() establishes
 70           a probepoint and specifies the callb     44           a probepoint and specifies the callback.  Kprobes is useful
 71           for kernel debugging, non-intrusive      45           for kernel debugging, non-intrusive instrumentation and testing.
 72           If in doubt, say "N".                    46           If in doubt, say "N".
 73                                                    47 
 74 config JUMP_LABEL                                  48 config JUMP_LABEL
 75         bool "Optimize very unlikely/likely br     49         bool "Optimize very unlikely/likely branches"
 76         depends on HAVE_ARCH_JUMP_LABEL            50         depends on HAVE_ARCH_JUMP_LABEL
 77         select OBJTOOL if HAVE_JUMP_LABEL_HACK !!  51         depends on CC_HAS_ASM_GOTO
 78         help                                       52         help
 79           This option enables a transparent br !!  53          This option enables a transparent branch optimization that
 80           makes certain almost-always-true or  !!  54          makes certain almost-always-true or almost-always-false branch
 81           conditions even cheaper to execute w !!  55          conditions even cheaper to execute within the kernel.
 82                                                !!  56 
 83           Certain performance-sensitive kernel !!  57          Certain performance-sensitive kernel code, such as trace points,
 84           scheduler functionality, networking  !!  58          scheduler functionality, networking code and KVM have such
 85           branches and include support for thi !!  59          branches and include support for this optimization technique.
 86                                                !!  60 
 87           If it is detected that the compiler  !!  61          If it is detected that the compiler has support for "asm goto",
 88           the kernel will compile such branche !!  62          the kernel will compile such branches with just a nop
 89           instruction. When the condition flag !!  63          instruction. When the condition flag is toggled to true, the
 90           nop will be converted to a jump inst !!  64          nop will be converted to a jump instruction to execute the
 91           conditional block of instructions.   !!  65          conditional block of instructions.
 92                                                !!  66 
 93           This technique lowers overhead and s !!  67          This technique lowers overhead and stress on the branch prediction
 94           of the processor and generally makes !!  68          of the processor and generally makes the kernel faster. The update
 95           of the condition is slower, but thos !!  69          of the condition is slower, but those are always very rare.
 96                                                    70 
 97           ( On 32-bit x86, the necessary optio !!  71          ( On 32-bit x86, the necessary options added to the compiler
 98             flags may increase the size of the !!  72            flags may increase the size of the kernel slightly. )
 99                                                    73 
100 config STATIC_KEYS_SELFTEST                        74 config STATIC_KEYS_SELFTEST
101         bool "Static key selftest"                 75         bool "Static key selftest"
102         depends on JUMP_LABEL                      76         depends on JUMP_LABEL
103         help                                       77         help
104           Boot time self-test of the branch pa     78           Boot time self-test of the branch patching code.
105                                                    79 
106 config STATIC_CALL_SELFTEST                        80 config STATIC_CALL_SELFTEST
107         bool "Static call selftest"                81         bool "Static call selftest"
108         depends on HAVE_STATIC_CALL                82         depends on HAVE_STATIC_CALL
109         help                                       83         help
110           Boot time self-test of the call patc     84           Boot time self-test of the call patching code.
111                                                    85 
112 config OPTPROBES                                   86 config OPTPROBES
113         def_bool y                                 87         def_bool y
114         depends on KPROBES && HAVE_OPTPROBES       88         depends on KPROBES && HAVE_OPTPROBES
115         select NEED_TASKS_RCU                  !!  89         select TASKS_RCU if PREEMPTION
116                                                    90 
117 config KPROBES_ON_FTRACE                           91 config KPROBES_ON_FTRACE
118         def_bool y                                 92         def_bool y
119         depends on KPROBES && HAVE_KPROBES_ON_     93         depends on KPROBES && HAVE_KPROBES_ON_FTRACE
120         depends on DYNAMIC_FTRACE_WITH_REGS        94         depends on DYNAMIC_FTRACE_WITH_REGS
121         help                                       95         help
122           If function tracer is enabled and th !!  96          If function tracer is enabled and the arch supports full
123           passing of pt_regs to function traci !!  97          passing of pt_regs to function tracing, then kprobes can
124           optimize on top of function tracing. !!  98          optimize on top of function tracing.
125                                                    99 
126 config UPROBES                                    100 config UPROBES
127         def_bool n                                101         def_bool n
128         depends on ARCH_SUPPORTS_UPROBES          102         depends on ARCH_SUPPORTS_UPROBES
129         help                                      103         help
130           Uprobes is the user-space counterpar    104           Uprobes is the user-space counterpart to kprobes: they
131           enable instrumentation applications     105           enable instrumentation applications (such as 'perf probe')
132           to establish unintrusive probes in u    106           to establish unintrusive probes in user-space binaries and
133           libraries, by executing handler func    107           libraries, by executing handler functions when the probes
134           are hit by user-space applications.     108           are hit by user-space applications.
135                                                   109 
136           ( These probes come in the form of s    110           ( These probes come in the form of single-byte breakpoints,
137             managed by the kernel and kept tra    111             managed by the kernel and kept transparent to the probed
138             application. )                        112             application. )
139                                                   113 
140 config HAVE_64BIT_ALIGNED_ACCESS                  114 config HAVE_64BIT_ALIGNED_ACCESS
141         def_bool 64BIT && !HAVE_EFFICIENT_UNAL    115         def_bool 64BIT && !HAVE_EFFICIENT_UNALIGNED_ACCESS
142         help                                      116         help
143           Some architectures require 64 bit ac    117           Some architectures require 64 bit accesses to be 64 bit
144           aligned, which also requires structs    118           aligned, which also requires structs containing 64 bit values
145           to be 64 bit aligned too. This inclu    119           to be 64 bit aligned too. This includes some 32 bit
146           architectures which can do 64 bit ac    120           architectures which can do 64 bit accesses, as well as 64 bit
147           architectures without unaligned acce    121           architectures without unaligned access.
148                                                   122 
149           This symbol should be selected by an    123           This symbol should be selected by an architecture if 64 bit
150           accesses are required to be 64 bit a    124           accesses are required to be 64 bit aligned in this way even
151           though it is not a 64 bit architectu    125           though it is not a 64 bit architecture.
152                                                   126 
153           See Documentation/core-api/unaligned    127           See Documentation/core-api/unaligned-memory-access.rst for
154           more information on the topic of una    128           more information on the topic of unaligned memory accesses.
155                                                   129 
156 config HAVE_EFFICIENT_UNALIGNED_ACCESS            130 config HAVE_EFFICIENT_UNALIGNED_ACCESS
157         bool                                      131         bool
158         help                                      132         help
159           Some architectures are unable to per    133           Some architectures are unable to perform unaligned accesses
160           without the use of get_unaligned/put    134           without the use of get_unaligned/put_unaligned. Others are
161           unable to perform such accesses effi    135           unable to perform such accesses efficiently (e.g. trap on
162           unaligned access and require fixing     136           unaligned access and require fixing it up in the exception
163           handler.)                               137           handler.)
164                                                   138 
165           This symbol should be selected by an    139           This symbol should be selected by an architecture if it can
166           perform unaligned accesses efficient    140           perform unaligned accesses efficiently to allow different
167           code paths to be selected for these     141           code paths to be selected for these cases. Some network
168           drivers, for example, could opt to n    142           drivers, for example, could opt to not fix up alignment
169           problems with received packets if do    143           problems with received packets if doing so would not help
170           much.                                   144           much.
171                                                   145 
172           See Documentation/core-api/unaligned    146           See Documentation/core-api/unaligned-memory-access.rst for more
173           information on the topic of unaligne    147           information on the topic of unaligned memory accesses.
174                                                   148 
175 config ARCH_USE_BUILTIN_BSWAP                     149 config ARCH_USE_BUILTIN_BSWAP
176         bool                                      150         bool
177         help                                      151         help
178           Modern versions of GCC (since 4.4) h !! 152          Modern versions of GCC (since 4.4) have builtin functions
179           for handling byte-swapping. Using th !! 153          for handling byte-swapping. Using these, instead of the old
180           inline assembler that the architectu !! 154          inline assembler that the architecture code provides in the
181           __arch_bswapXX() macros, allows the  !! 155          __arch_bswapXX() macros, allows the compiler to see what's
182           happening and offers more opportunit !! 156          happening and offers more opportunity for optimisation. In
183           particular, the compiler will be abl !! 157          particular, the compiler will be able to combine the byteswap
184           with a nearby load or store and use  !! 158          with a nearby load or store and use load-and-swap or
185           store-and-swap instructions if the a !! 159          store-and-swap instructions if the architecture has them. It
186           should almost *never* result in code !! 160          should almost *never* result in code which is worse than the
187           hand-coded assembler in <asm/swab.h> !! 161          hand-coded assembler in <asm/swab.h>.  But just in case it
188           does, the use of the builtins is opt !! 162          does, the use of the builtins is optional.
189                                                !! 163 
190           Any architecture with load-and-swap  !! 164          Any architecture with load-and-swap or store-and-swap
191           instructions should set this. And it !! 165          instructions should set this. And it shouldn't hurt to set it
192           on architectures that don't have suc !! 166          on architectures that don't have such instructions.
193                                                   167 
194 config KRETPROBES                                 168 config KRETPROBES
195         def_bool y                                169         def_bool y
196         depends on KPROBES && (HAVE_KRETPROBES !! 170         depends on KPROBES && HAVE_KRETPROBES
197                                                << 
198 config KRETPROBE_ON_RETHOOK                    << 
199         def_bool y                             << 
200         depends on HAVE_RETHOOK                << 
201         depends on KRETPROBES                  << 
202         select RETHOOK                         << 
203                                                   171 
204 config USER_RETURN_NOTIFIER                       172 config USER_RETURN_NOTIFIER
205         bool                                      173         bool
206         depends on HAVE_USER_RETURN_NOTIFIER      174         depends on HAVE_USER_RETURN_NOTIFIER
207         help                                      175         help
208           Provide a kernel-internal notificati    176           Provide a kernel-internal notification when a cpu is about to
209           switch to user mode.                    177           switch to user mode.
210                                                   178 
211 config HAVE_IOREMAP_PROT                          179 config HAVE_IOREMAP_PROT
212         bool                                      180         bool
213                                                   181 
214 config HAVE_KPROBES                               182 config HAVE_KPROBES
215         bool                                      183         bool
216                                                   184 
217 config HAVE_KRETPROBES                            185 config HAVE_KRETPROBES
218         bool                                      186         bool
219                                                   187 
220 config HAVE_OPTPROBES                             188 config HAVE_OPTPROBES
221         bool                                      189         bool
222                                                   190 
223 config HAVE_KPROBES_ON_FTRACE                     191 config HAVE_KPROBES_ON_FTRACE
224         bool                                      192         bool
225                                                   193 
226 config ARCH_CORRECT_STACKTRACE_ON_KRETPROBE    << 
227         bool                                   << 
228         help                                   << 
229           Since kretprobes modifies return add << 
230           stacktrace may see the kretprobe tra << 
231           of correct one. If the architecture  << 
232           unwinder can adjust such entries, se << 
233                                                << 
234 config HAVE_FUNCTION_ERROR_INJECTION              194 config HAVE_FUNCTION_ERROR_INJECTION
235         bool                                      195         bool
236                                                   196 
237 config HAVE_NMI                                   197 config HAVE_NMI
238         bool                                      198         bool
239                                                   199 
240 config HAVE_FUNCTION_DESCRIPTORS               << 
241         bool                                   << 
242                                                << 
243 config TRACE_IRQFLAGS_SUPPORT                  << 
244         bool                                   << 
245                                                << 
246 config TRACE_IRQFLAGS_NMI_SUPPORT              << 
247         bool                                   << 
248                                                << 
249 #                                                 200 #
250 # An arch should select this if it provides al    201 # An arch should select this if it provides all these things:
251 #                                                 202 #
252 #       task_pt_regs()          in asm/process    203 #       task_pt_regs()          in asm/processor.h or asm/ptrace.h
253 #       arch_has_single_step()  if there is ha    204 #       arch_has_single_step()  if there is hardware single-step support
254 #       arch_has_block_step()   if there is ha    205 #       arch_has_block_step()   if there is hardware block-step support
255 #       asm/syscall.h           supplying asm-    206 #       asm/syscall.h           supplying asm-generic/syscall.h interface
256 #       linux/regset.h          user_regset in    207 #       linux/regset.h          user_regset interfaces
257 #       CORE_DUMP_USE_REGSET    #define'd in l    208 #       CORE_DUMP_USE_REGSET    #define'd in linux/elf.h
258 #       TIF_SYSCALL_TRACE       calls ptrace_r !! 209 #       TIF_SYSCALL_TRACE       calls tracehook_report_syscall_{entry,exit}
259 #       TIF_NOTIFY_RESUME       calls resume_u !! 210 #       TIF_NOTIFY_RESUME       calls tracehook_notify_resume()
                                                   >> 211 #       signal delivery         calls tracehook_signal_handler()
260 #                                                 212 #
261 config HAVE_ARCH_TRACEHOOK                        213 config HAVE_ARCH_TRACEHOOK
262         bool                                      214         bool
263                                                   215 
264 config HAVE_DMA_CONTIGUOUS                        216 config HAVE_DMA_CONTIGUOUS
265         bool                                      217         bool
266                                                   218 
267 config GENERIC_SMP_IDLE_THREAD                    219 config GENERIC_SMP_IDLE_THREAD
268         bool                                      220         bool
269                                                   221 
270 config GENERIC_IDLE_POLL_SETUP                    222 config GENERIC_IDLE_POLL_SETUP
271         bool                                      223         bool
272                                                   224 
273 config ARCH_HAS_FORTIFY_SOURCE                    225 config ARCH_HAS_FORTIFY_SOURCE
274         bool                                      226         bool
275         help                                      227         help
276           An architecture should select this w    228           An architecture should select this when it can successfully
277           build and run with CONFIG_FORTIFY_SO    229           build and run with CONFIG_FORTIFY_SOURCE.
278                                                   230 
279 #                                                 231 #
280 # Select if the arch provides a historic keepi    232 # Select if the arch provides a historic keepinit alias for the retain_initrd
281 # command line option                             233 # command line option
282 #                                                 234 #
283 config ARCH_HAS_KEEPINITRD                        235 config ARCH_HAS_KEEPINITRD
284         bool                                      236         bool
285                                                   237 
286 # Select if arch has all set_memory_ro/rw/x/nx    238 # Select if arch has all set_memory_ro/rw/x/nx() functions in asm/cacheflush.h
287 config ARCH_HAS_SET_MEMORY                        239 config ARCH_HAS_SET_MEMORY
288         bool                                      240         bool
289                                                   241 
290 # Select if arch has all set_direct_map_invali    242 # Select if arch has all set_direct_map_invalid/default() functions
291 config ARCH_HAS_SET_DIRECT_MAP                    243 config ARCH_HAS_SET_DIRECT_MAP
292         bool                                      244         bool
293                                                   245 
294 #                                                 246 #
295 # Select if the architecture provides the arch    247 # Select if the architecture provides the arch_dma_set_uncached symbol to
296 # either provide an uncached segment alias for    248 # either provide an uncached segment alias for a DMA allocation, or
297 # to remap the page tables in place.              249 # to remap the page tables in place.
298 #                                                 250 #
299 config ARCH_HAS_DMA_SET_UNCACHED                  251 config ARCH_HAS_DMA_SET_UNCACHED
300         bool                                      252         bool
301                                                   253 
302 #                                                 254 #
303 # Select if the architectures provides the arc    255 # Select if the architectures provides the arch_dma_clear_uncached symbol
304 # to undo an in-place page table remap for unc    256 # to undo an in-place page table remap for uncached access.
305 #                                                 257 #
306 config ARCH_HAS_DMA_CLEAR_UNCACHED                258 config ARCH_HAS_DMA_CLEAR_UNCACHED
307         bool                                      259         bool
308                                                   260 
309 config ARCH_HAS_CPU_FINALIZE_INIT              !! 261 # Select if arch init_task must go in the __init_task_data section
                                                   >> 262 config ARCH_TASK_STRUCT_ON_STACK
310         bool                                      263         bool
311                                                   264 
312 # The architecture has a per-task state that i !! 265 # Select if arch has its private alloc_task_struct() function
313 config ARCH_HAS_CPU_PASID                      !! 266 config ARCH_TASK_STRUCT_ALLOCATOR
314         bool                                      267         bool
315         select IOMMU_MM_DATA                   << 
316                                                   268 
317 config HAVE_ARCH_THREAD_STRUCT_WHITELIST          269 config HAVE_ARCH_THREAD_STRUCT_WHITELIST
318         bool                                      270         bool
                                                   >> 271         depends on !ARCH_TASK_STRUCT_ALLOCATOR
319         help                                      272         help
320           An architecture should select this t    273           An architecture should select this to provide hardened usercopy
321           knowledge about what region of the t    274           knowledge about what region of the thread_struct should be
322           whitelisted for copying to userspace    275           whitelisted for copying to userspace. Normally this is only the
323           FPU registers. Specifically, arch_th    276           FPU registers. Specifically, arch_thread_struct_whitelist()
324           should be implemented. Without this,    277           should be implemented. Without this, the entire thread_struct
325           field in task_struct will be left wh    278           field in task_struct will be left whitelisted.
326                                                   279 
327 # Select if arch wants to size task_struct dyn !! 280 # Select if arch has its private alloc_thread_stack() function
328 config ARCH_WANTS_DYNAMIC_TASK_STRUCT          !! 281 config ARCH_THREAD_STACK_ALLOCATOR
329         bool                                      282         bool
330                                                   283 
331 config ARCH_WANTS_NO_INSTR                     !! 284 # Select if arch wants to size task_struct dynamically via arch_task_struct_size:
                                                   >> 285 config ARCH_WANTS_DYNAMIC_TASK_STRUCT
332         bool                                      286         bool
333         help                                   << 
334           An architecture should select this i << 
335           functions to denote that the toolcha << 
336           functions and is required for correc << 
337                                                   287 
338 config ARCH_32BIT_OFF_T                           288 config ARCH_32BIT_OFF_T
339         bool                                      289         bool
340         depends on !64BIT                         290         depends on !64BIT
341         help                                      291         help
342           All new 32-bit architectures should     292           All new 32-bit architectures should have 64-bit off_t type on
343           userspace side which corresponds to     293           userspace side which corresponds to the loff_t kernel type. This
344           is the requirement for modern ABIs.     294           is the requirement for modern ABIs. Some existing architectures
345           still support 32-bit off_t. This opt    295           still support 32-bit off_t. This option is enabled for all such
346           architectures explicitly.               296           architectures explicitly.
347                                                   297 
348 # Selected by 64 bit architectures which have     298 # Selected by 64 bit architectures which have a 32 bit f_tinode in struct ustat
349 config ARCH_32BIT_USTAT_F_TINODE                  299 config ARCH_32BIT_USTAT_F_TINODE
350         bool                                      300         bool
351                                                   301 
352 config HAVE_ASM_MODVERSIONS                       302 config HAVE_ASM_MODVERSIONS
353         bool                                      303         bool
354         help                                      304         help
355           This symbol should be selected by an    305           This symbol should be selected by an architecture if it provides
356           <asm/asm-prototypes.h> to support th    306           <asm/asm-prototypes.h> to support the module versioning for symbols
357           exported from assembly code.            307           exported from assembly code.
358                                                   308 
359 config HAVE_REGS_AND_STACK_ACCESS_API             309 config HAVE_REGS_AND_STACK_ACCESS_API
360         bool                                      310         bool
361         help                                      311         help
362           This symbol should be selected by an    312           This symbol should be selected by an architecture if it supports
363           the API needed to access registers a    313           the API needed to access registers and stack entries from pt_regs,
364           declared in asm/ptrace.h                314           declared in asm/ptrace.h
365           For example the kprobes-based event     315           For example the kprobes-based event tracer needs this API.
366                                                   316 
367 config HAVE_RSEQ                                  317 config HAVE_RSEQ
368         bool                                      318         bool
369         depends on HAVE_REGS_AND_STACK_ACCESS_    319         depends on HAVE_REGS_AND_STACK_ACCESS_API
370         help                                      320         help
371           This symbol should be selected by an    321           This symbol should be selected by an architecture if it
372           supports an implementation of restar    322           supports an implementation of restartable sequences.
373                                                   323 
374 config HAVE_RUST                               << 
375         bool                                   << 
376         help                                   << 
377           This symbol should be selected by an << 
378           supports Rust.                       << 
379                                                << 
380 config HAVE_FUNCTION_ARG_ACCESS_API               324 config HAVE_FUNCTION_ARG_ACCESS_API
381         bool                                      325         bool
382         help                                      326         help
383           This symbol should be selected by an    327           This symbol should be selected by an architecture if it supports
384           the API needed to access function ar    328           the API needed to access function arguments from pt_regs,
385           declared in asm/ptrace.h                329           declared in asm/ptrace.h
386                                                   330 
387 config HAVE_HW_BREAKPOINT                         331 config HAVE_HW_BREAKPOINT
388         bool                                      332         bool
389         depends on PERF_EVENTS                    333         depends on PERF_EVENTS
390                                                   334 
391 config HAVE_MIXED_BREAKPOINTS_REGS                335 config HAVE_MIXED_BREAKPOINTS_REGS
392         bool                                      336         bool
393         depends on HAVE_HW_BREAKPOINT             337         depends on HAVE_HW_BREAKPOINT
394         help                                      338         help
395           Depending on the arch implementation    339           Depending on the arch implementation of hardware breakpoints,
396           some of them have separate registers    340           some of them have separate registers for data and instruction
397           breakpoints addresses, others have m    341           breakpoints addresses, others have mixed registers to store
398           them but define the access type in a    342           them but define the access type in a control register.
399           Select this option if your arch impl    343           Select this option if your arch implements breakpoints under the
400           latter fashion.                         344           latter fashion.
401                                                   345 
402 config HAVE_USER_RETURN_NOTIFIER                  346 config HAVE_USER_RETURN_NOTIFIER
403         bool                                      347         bool
404                                                   348 
405 config HAVE_PERF_EVENTS_NMI                       349 config HAVE_PERF_EVENTS_NMI
406         bool                                      350         bool
407         help                                      351         help
408           System hardware can generate an NMI     352           System hardware can generate an NMI using the perf event
409           subsystem.  Also has support for cal    353           subsystem.  Also has support for calculating CPU cycle events
410           to determine how many clock cycles i    354           to determine how many clock cycles in a given period.
411                                                   355 
412 config HAVE_HARDLOCKUP_DETECTOR_PERF              356 config HAVE_HARDLOCKUP_DETECTOR_PERF
413         bool                                      357         bool
414         depends on HAVE_PERF_EVENTS_NMI           358         depends on HAVE_PERF_EVENTS_NMI
415         help                                      359         help
416           The arch chooses to use the generic     360           The arch chooses to use the generic perf-NMI-based hardlockup
417           detector. Must define HAVE_PERF_EVEN    361           detector. Must define HAVE_PERF_EVENTS_NMI.
418                                                   362 
419 config HAVE_HARDLOCKUP_DETECTOR_ARCH           !! 363 config HAVE_NMI_WATCHDOG
                                                   >> 364         depends on HAVE_NMI
420         bool                                      365         bool
421         help                                      366         help
422           The arch provides its own hardlockup !! 367           The arch provides a low level NMI watchdog. It provides
423           of the generic ones.                 !! 368           asm/nmi.h, and defines its own arch_touch_nmi_watchdog().
424                                                   369 
425           It uses the same command line parame !! 370 config HAVE_HARDLOCKUP_DETECTOR_ARCH
426           as the generic hardlockup detectors. !! 371         bool
                                                   >> 372         select HAVE_NMI_WATCHDOG
                                                   >> 373         help
                                                   >> 374           The arch chooses to provide its own hardlockup detector, which is
                                                   >> 375           a superset of the HAVE_NMI_WATCHDOG. It also conforms to config
                                                   >> 376           interfaces and parameters provided by hardlockup detector subsystem.
427                                                   377 
428 config HAVE_PERF_REGS                             378 config HAVE_PERF_REGS
429         bool                                      379         bool
430         help                                      380         help
431           Support selective register dumps for    381           Support selective register dumps for perf events. This includes
432           bit-mapping of each registers and a     382           bit-mapping of each registers and a unique architecture id.
433                                                   383 
434 config HAVE_PERF_USER_STACK_DUMP                  384 config HAVE_PERF_USER_STACK_DUMP
435         bool                                      385         bool
436         help                                      386         help
437           Support user stack dumps for perf ev    387           Support user stack dumps for perf event samples. This needs
438           access to the user stack pointer whi    388           access to the user stack pointer which is not unified across
439           architectures.                          389           architectures.
440                                                   390 
441 config HAVE_ARCH_JUMP_LABEL                       391 config HAVE_ARCH_JUMP_LABEL
442         bool                                      392         bool
443                                                   393 
444 config HAVE_ARCH_JUMP_LABEL_RELATIVE              394 config HAVE_ARCH_JUMP_LABEL_RELATIVE
445         bool                                      395         bool
446                                                   396 
447 config MMU_GATHER_TABLE_FREE                      397 config MMU_GATHER_TABLE_FREE
448         bool                                      398         bool
449                                                   399 
450 config MMU_GATHER_RCU_TABLE_FREE                  400 config MMU_GATHER_RCU_TABLE_FREE
451         bool                                      401         bool
452         select MMU_GATHER_TABLE_FREE              402         select MMU_GATHER_TABLE_FREE
453                                                   403 
454 config MMU_GATHER_PAGE_SIZE                       404 config MMU_GATHER_PAGE_SIZE
455         bool                                      405         bool
456                                                   406 
457 config MMU_GATHER_NO_RANGE                        407 config MMU_GATHER_NO_RANGE
458         bool                                      408         bool
459         select MMU_GATHER_MERGE_VMAS           << 
460                                                << 
461 config MMU_GATHER_NO_FLUSH_CACHE               << 
462         bool                                   << 
463                                                << 
464 config MMU_GATHER_MERGE_VMAS                   << 
465         bool                                   << 
466                                                   409 
467 config MMU_GATHER_NO_GATHER                       410 config MMU_GATHER_NO_GATHER
468         bool                                      411         bool
469         depends on MMU_GATHER_TABLE_FREE          412         depends on MMU_GATHER_TABLE_FREE
470                                                   413 
471 config ARCH_WANT_IRQS_OFF_ACTIVATE_MM             414 config ARCH_WANT_IRQS_OFF_ACTIVATE_MM
472         bool                                      415         bool
473         help                                      416         help
474           Temporary select until all architect    417           Temporary select until all architectures can be converted to have
475           irqs disabled over activate_mm. Arch    418           irqs disabled over activate_mm. Architectures that do IPI based TLB
476           shootdowns should enable this.          419           shootdowns should enable this.
477                                                   420 
478 # Use normal mm refcounting for MMU_LAZY_TLB k << 
479 # MMU_LAZY_TLB_REFCOUNT=n can improve the scal << 
480 # to/from kernel threads when the same mm is r << 
481 # multi-threaded application), by reducing con << 
482 #                                              << 
483 # This can be disabled if the architecture ens << 
484 # "lazy tlb" beyond its final refcount (i.e.,  << 
485 # or its kernel page tables). This could be ar << 
486 # final exit(2) TLB flush, for example.        << 
487 #                                              << 
488 # To implement this, an arch *must*:           << 
489 # Ensure the _lazy_tlb variants of mmgrab/mmdr << 
490 # the lazy tlb reference of a kthread's ->acti << 
491 # converted already).                          << 
492 config MMU_LAZY_TLB_REFCOUNT                   << 
493         def_bool y                             << 
494         depends on !MMU_LAZY_TLB_SHOOTDOWN     << 
495                                                << 
496 # This option allows MMU_LAZY_TLB_REFCOUNT=n.  << 
497 # mm as a lazy tlb beyond its last reference c << 
498 # users before the mm is deallocated. __mmdrop << 
499 # be using the mm as a lazy tlb, so that they  << 
500 # init_mm for their active mm. mm_cpumask(mm)  << 
501 # may be using mm as a lazy tlb mm.            << 
502 #                                              << 
503 # To implement this, an arch *must*:           << 
504 # - At the time of the final mmdrop of the mm, << 
505 #   at least all possible CPUs in which the mm << 
506 # - It must meet the requirements for MMU_LAZY << 
507 config MMU_LAZY_TLB_SHOOTDOWN                  << 
508         bool                                   << 
509                                                << 
510 config ARCH_HAVE_NMI_SAFE_CMPXCHG                 421 config ARCH_HAVE_NMI_SAFE_CMPXCHG
511         bool                                      422         bool
512                                                   423 
513 config ARCH_HAVE_EXTRA_ELF_NOTES               << 
514         bool                                   << 
515         help                                   << 
516           An architecture should select this i << 
517           arch-specific ELF note section to co << 
518           functions: elf_coredump_extra_notes_ << 
519           elf_coredump_extra_notes_write() whi << 
520           dumper.                              << 
521                                                << 
522 config ARCH_HAS_NMI_SAFE_THIS_CPU_OPS          << 
523         bool                                   << 
524                                                << 
525 config HAVE_ALIGNED_STRUCT_PAGE                   424 config HAVE_ALIGNED_STRUCT_PAGE
526         bool                                      425         bool
527         help                                      426         help
528           This makes sure that struct pages ar    427           This makes sure that struct pages are double word aligned and that
529           e.g. the SLUB allocator can perform     428           e.g. the SLUB allocator can perform double word atomic operations
530           on a struct page for better performa    429           on a struct page for better performance. However selecting this
531           might increase the size of a struct     430           might increase the size of a struct page by a word.
532                                                   431 
533 config HAVE_CMPXCHG_LOCAL                         432 config HAVE_CMPXCHG_LOCAL
534         bool                                      433         bool
535                                                   434 
536 config HAVE_CMPXCHG_DOUBLE                        435 config HAVE_CMPXCHG_DOUBLE
537         bool                                      436         bool
538                                                   437 
539 config ARCH_WEAK_RELEASE_ACQUIRE                  438 config ARCH_WEAK_RELEASE_ACQUIRE
540         bool                                      439         bool
541                                                   440 
542 config ARCH_WANT_IPC_PARSE_VERSION                441 config ARCH_WANT_IPC_PARSE_VERSION
543         bool                                      442         bool
544                                                   443 
545 config ARCH_WANT_COMPAT_IPC_PARSE_VERSION         444 config ARCH_WANT_COMPAT_IPC_PARSE_VERSION
546         bool                                      445         bool
547                                                   446 
548 config ARCH_WANT_OLD_COMPAT_IPC                   447 config ARCH_WANT_OLD_COMPAT_IPC
549         select ARCH_WANT_COMPAT_IPC_PARSE_VERS    448         select ARCH_WANT_COMPAT_IPC_PARSE_VERSION
550         bool                                      449         bool
551                                                   450 
552 config HAVE_ARCH_SECCOMP                          451 config HAVE_ARCH_SECCOMP
553         bool                                      452         bool
554         help                                      453         help
555           An arch should select this symbol to    454           An arch should select this symbol to support seccomp mode 1 (the fixed
556           syscall policy), and must provide an    455           syscall policy), and must provide an overrides for __NR_seccomp_sigreturn,
557           and compat syscalls if the asm-gener    456           and compat syscalls if the asm-generic/seccomp.h defaults need adjustment:
558           - __NR_seccomp_read_32                  457           - __NR_seccomp_read_32
559           - __NR_seccomp_write_32                 458           - __NR_seccomp_write_32
560           - __NR_seccomp_exit_32                  459           - __NR_seccomp_exit_32
561           - __NR_seccomp_sigreturn_32             460           - __NR_seccomp_sigreturn_32
562                                                   461 
563 config HAVE_ARCH_SECCOMP_FILTER                   462 config HAVE_ARCH_SECCOMP_FILTER
564         bool                                      463         bool
565         select HAVE_ARCH_SECCOMP                  464         select HAVE_ARCH_SECCOMP
566         help                                      465         help
567           An arch should select this symbol if    466           An arch should select this symbol if it provides all of these things:
568           - all the requirements for HAVE_ARCH    467           - all the requirements for HAVE_ARCH_SECCOMP
569           - syscall_get_arch()                    468           - syscall_get_arch()
570           - syscall_get_arguments()               469           - syscall_get_arguments()
571           - syscall_rollback()                    470           - syscall_rollback()
572           - syscall_set_return_value()            471           - syscall_set_return_value()
573           - SIGSYS siginfo_t support              472           - SIGSYS siginfo_t support
574           - secure_computing is called from a     473           - secure_computing is called from a ptrace_event()-safe context
575           - secure_computing return value is c    474           - secure_computing return value is checked and a return value of -1
576             results in the system call being s    475             results in the system call being skipped immediately.
577           - seccomp syscall wired up              476           - seccomp syscall wired up
578           - if !HAVE_SPARSE_SYSCALL_NR, have S    477           - if !HAVE_SPARSE_SYSCALL_NR, have SECCOMP_ARCH_NATIVE,
579             SECCOMP_ARCH_NATIVE_NR, SECCOMP_AR    478             SECCOMP_ARCH_NATIVE_NR, SECCOMP_ARCH_NATIVE_NAME defined. If
580             COMPAT is supported, have the SECC    479             COMPAT is supported, have the SECCOMP_ARCH_COMPAT* defines too.
581                                                   480 
582 config SECCOMP                                    481 config SECCOMP
583         prompt "Enable seccomp to safely execu    482         prompt "Enable seccomp to safely execute untrusted bytecode"
584         def_bool y                                483         def_bool y
585         depends on HAVE_ARCH_SECCOMP              484         depends on HAVE_ARCH_SECCOMP
586         help                                      485         help
587           This kernel feature is useful for nu    486           This kernel feature is useful for number crunching applications
588           that may need to handle untrusted by    487           that may need to handle untrusted bytecode during their
589           execution. By using pipes or other t    488           execution. By using pipes or other transports made available
590           to the process as file descriptors s    489           to the process as file descriptors supporting the read/write
591           syscalls, it's possible to isolate t    490           syscalls, it's possible to isolate those applications in their
592           own address space using seccomp. Onc    491           own address space using seccomp. Once seccomp is enabled via
593           prctl(PR_SET_SECCOMP) or the seccomp    492           prctl(PR_SET_SECCOMP) or the seccomp() syscall, it cannot be
594           disabled and the task is only allowe    493           disabled and the task is only allowed to execute a few safe
595           syscalls defined by each seccomp mod    494           syscalls defined by each seccomp mode.
596                                                   495 
597           If unsure, say Y.                       496           If unsure, say Y.
598                                                   497 
599 config SECCOMP_FILTER                             498 config SECCOMP_FILTER
600         def_bool y                                499         def_bool y
601         depends on HAVE_ARCH_SECCOMP_FILTER &&    500         depends on HAVE_ARCH_SECCOMP_FILTER && SECCOMP && NET
602         help                                      501         help
603           Enable tasks to build secure computi    502           Enable tasks to build secure computing environments defined
604           in terms of Berkeley Packet Filter p    503           in terms of Berkeley Packet Filter programs which implement
605           task-defined system call filtering p    504           task-defined system call filtering polices.
606                                                   505 
607           See Documentation/userspace-api/secc    506           See Documentation/userspace-api/seccomp_filter.rst for details.
608                                                   507 
609 config SECCOMP_CACHE_DEBUG                        508 config SECCOMP_CACHE_DEBUG
610         bool "Show seccomp filter cache status    509         bool "Show seccomp filter cache status in /proc/pid/seccomp_cache"
611         depends on SECCOMP_FILTER && !HAVE_SPA    510         depends on SECCOMP_FILTER && !HAVE_SPARSE_SYSCALL_NR
612         depends on PROC_FS                        511         depends on PROC_FS
613         help                                      512         help
614           This enables the /proc/pid/seccomp_c    513           This enables the /proc/pid/seccomp_cache interface to monitor
615           seccomp cache data. The file format     514           seccomp cache data. The file format is subject to change. Reading
616           the file requires CAP_SYS_ADMIN.        515           the file requires CAP_SYS_ADMIN.
617                                                   516 
618           This option is for debugging only. E    517           This option is for debugging only. Enabling presents the risk that
619           an adversary may be able to infer th    518           an adversary may be able to infer the seccomp filter logic.
620                                                   519 
621           If unsure, say N.                       520           If unsure, say N.
622                                                   521 
623 config HAVE_ARCH_STACKLEAK                        522 config HAVE_ARCH_STACKLEAK
624         bool                                      523         bool
625         help                                      524         help
626           An architecture should select this i    525           An architecture should select this if it has the code which
627           fills the used part of the kernel st    526           fills the used part of the kernel stack with the STACKLEAK_POISON
628           value before returning from system c    527           value before returning from system calls.
629                                                   528 
630 config HAVE_STACKPROTECTOR                        529 config HAVE_STACKPROTECTOR
631         bool                                      530         bool
632         help                                      531         help
633           An arch should select this symbol if    532           An arch should select this symbol if:
634           - it has implemented a stack canary     533           - it has implemented a stack canary (e.g. __stack_chk_guard)
635                                                   534 
636 config STACKPROTECTOR                             535 config STACKPROTECTOR
637         bool "Stack Protector buffer overflow     536         bool "Stack Protector buffer overflow detection"
638         depends on HAVE_STACKPROTECTOR            537         depends on HAVE_STACKPROTECTOR
639         depends on $(cc-option,-fstack-protect    538         depends on $(cc-option,-fstack-protector)
640         default y                                 539         default y
641         help                                      540         help
642           This option turns on the "stack-prot    541           This option turns on the "stack-protector" GCC feature. This
643           feature puts, at the beginning of fu    542           feature puts, at the beginning of functions, a canary value on
644           the stack just before the return add    543           the stack just before the return address, and validates
645           the value just before actually retur    544           the value just before actually returning.  Stack based buffer
646           overflows (that need to overwrite th    545           overflows (that need to overwrite this return address) now also
647           overwrite the canary, which gets det    546           overwrite the canary, which gets detected and the attack is then
648           neutralized via a kernel panic.         547           neutralized via a kernel panic.
649                                                   548 
650           Functions will have the stack-protec    549           Functions will have the stack-protector canary logic added if they
651           have an 8-byte or larger character a    550           have an 8-byte or larger character array on the stack.
652                                                   551 
653           This feature requires gcc version 4.    552           This feature requires gcc version 4.2 or above, or a distribution
654           gcc with the feature backported ("-f    553           gcc with the feature backported ("-fstack-protector").
655                                                   554 
656           On an x86 "defconfig" build, this fe    555           On an x86 "defconfig" build, this feature adds canary checks to
657           about 3% of all kernel functions, wh    556           about 3% of all kernel functions, which increases kernel code size
658           by about 0.3%.                          557           by about 0.3%.
659                                                   558 
660 config STACKPROTECTOR_STRONG                      559 config STACKPROTECTOR_STRONG
661         bool "Strong Stack Protector"             560         bool "Strong Stack Protector"
662         depends on STACKPROTECTOR                 561         depends on STACKPROTECTOR
663         depends on $(cc-option,-fstack-protect    562         depends on $(cc-option,-fstack-protector-strong)
664         default y                                 563         default y
665         help                                      564         help
666           Functions will have the stack-protec    565           Functions will have the stack-protector canary logic added in any
667           of the following conditions:            566           of the following conditions:
668                                                   567 
669           - local variable's address used as p    568           - local variable's address used as part of the right hand side of an
670             assignment or function argument       569             assignment or function argument
671           - local variable is an array (or uni    570           - local variable is an array (or union containing an array),
672             regardless of array type or length    571             regardless of array type or length
673           - uses register local variables         572           - uses register local variables
674                                                   573 
675           This feature requires gcc version 4.    574           This feature requires gcc version 4.9 or above, or a distribution
676           gcc with the feature backported ("-f    575           gcc with the feature backported ("-fstack-protector-strong").
677                                                   576 
678           On an x86 "defconfig" build, this fe    577           On an x86 "defconfig" build, this feature adds canary checks to
679           about 20% of all kernel functions, w    578           about 20% of all kernel functions, which increases the kernel code
680           size by about 2%.                       579           size by about 2%.
681                                                   580 
682 config ARCH_SUPPORTS_SHADOW_CALL_STACK            581 config ARCH_SUPPORTS_SHADOW_CALL_STACK
683         bool                                      582         bool
684         help                                      583         help
685           An architecture should select this i !! 584           An architecture should select this if it supports Clang's Shadow
686           Shadow Call Stack and implements run !! 585           Call Stack and implements runtime support for shadow stack
687           switching.                              586           switching.
688                                                   587 
689 config SHADOW_CALL_STACK                          588 config SHADOW_CALL_STACK
690         bool "Shadow Call Stack"               !! 589         bool "Clang Shadow Call Stack"
691         depends on ARCH_SUPPORTS_SHADOW_CALL_S !! 590         depends on CC_IS_CLANG && ARCH_SUPPORTS_SHADOW_CALL_STACK
692         depends on DYNAMIC_FTRACE_WITH_ARGS || !! 591         depends on DYNAMIC_FTRACE_WITH_REGS || !FUNCTION_GRAPH_TRACER
693         depends on MMU                         !! 592         help
694         help                                   !! 593           This option enables Clang's Shadow Call Stack, which uses a
695           This option enables the compiler's S !! 594           shadow stack to protect function return addresses from being
696           uses a shadow stack to protect funct !! 595           overwritten by an attacker. More information can be found in
697           being overwritten by an attacker. Mo !! 596           Clang's documentation:
698           in the compiler's documentation:     << 
699                                                   597 
700           - Clang: https://clang.llvm.org/docs !! 598             https://clang.llvm.org/docs/ShadowCallStack.html
701           - GCC: https://gcc.gnu.org/onlinedoc << 
702                                                   599 
703           Note that security guarantees in the    600           Note that security guarantees in the kernel differ from the
704           ones documented for user space. The     601           ones documented for user space. The kernel must store addresses
705           of shadow stacks in memory, which me    602           of shadow stacks in memory, which means an attacker capable of
706           reading and writing arbitrary memory    603           reading and writing arbitrary memory may be able to locate them
707           and hijack control flow by modifying    604           and hijack control flow by modifying the stacks.
708                                                   605 
709 config DYNAMIC_SCS                             << 
710         bool                                   << 
711         help                                   << 
712           Set by the arch code if it relies on << 
713           shadow call stack push and pop instr << 
714           compiler.                            << 
715                                                << 
716 config LTO                                        606 config LTO
717         bool                                      607         bool
718         help                                      608         help
719           Selected if the kernel will be built    609           Selected if the kernel will be built using the compiler's LTO feature.
720                                                   610 
721 config LTO_CLANG                                  611 config LTO_CLANG
722         bool                                      612         bool
723         select LTO                                613         select LTO
724         help                                      614         help
725           Selected if the kernel will be built    615           Selected if the kernel will be built using Clang's LTO feature.
726                                                   616 
727 config ARCH_SUPPORTS_LTO_CLANG                    617 config ARCH_SUPPORTS_LTO_CLANG
728         bool                                      618         bool
729         help                                      619         help
730           An architecture should select this o    620           An architecture should select this option if it supports:
731           - compiling with Clang,                 621           - compiling with Clang,
732           - compiling inline assembly with Cla    622           - compiling inline assembly with Clang's integrated assembler,
733           - and linking with LLD.                 623           - and linking with LLD.
734                                                   624 
735 config ARCH_SUPPORTS_LTO_CLANG_THIN               625 config ARCH_SUPPORTS_LTO_CLANG_THIN
736         bool                                      626         bool
737         help                                      627         help
738           An architecture should select this o    628           An architecture should select this option if it can support Clang's
739           ThinLTO mode.                           629           ThinLTO mode.
740                                                   630 
741 config HAS_LTO_CLANG                              631 config HAS_LTO_CLANG
742         def_bool y                                632         def_bool y
743         depends on CC_IS_CLANG && LD_IS_LLD && !! 633         # Clang >= 11: https://github.com/ClangBuiltLinux/linux/issues/510
                                                   >> 634         depends on CC_IS_CLANG && CLANG_VERSION >= 110000 && LD_IS_LLD
                                                   >> 635         depends on $(success,test $(LLVM_IAS) -eq 1)
744         depends on $(success,$(NM) --help | he    636         depends on $(success,$(NM) --help | head -n 1 | grep -qi llvm)
745         depends on $(success,$(AR) --help | he    637         depends on $(success,$(AR) --help | head -n 1 | grep -qi llvm)
746         depends on ARCH_SUPPORTS_LTO_CLANG        638         depends on ARCH_SUPPORTS_LTO_CLANG
747         depends on !FTRACE_MCOUNT_USE_RECORDMC    639         depends on !FTRACE_MCOUNT_USE_RECORDMCOUNT
748         # https://github.com/ClangBuiltLinux/l !! 640         depends on !KASAN || KASAN_HW_TAGS
749         depends on (!KASAN || KASAN_HW_TAGS || << 
750         depends on (!KCOV || CLANG_VERSION >=  << 
751         depends on !GCOV_KERNEL                   641         depends on !GCOV_KERNEL
752         help                                      642         help
753           The compiler and Kconfig options sup    643           The compiler and Kconfig options support building with Clang's
754           LTO.                                    644           LTO.
755                                                   645 
756 choice                                            646 choice
757         prompt "Link Time Optimization (LTO)"     647         prompt "Link Time Optimization (LTO)"
758         default LTO_NONE                          648         default LTO_NONE
759         help                                      649         help
760           This option enables Link Time Optimi    650           This option enables Link Time Optimization (LTO), which allows the
761           compiler to optimize binaries global    651           compiler to optimize binaries globally.
762                                                   652 
763           If unsure, select LTO_NONE. Note tha    653           If unsure, select LTO_NONE. Note that LTO is very resource-intensive
764           so it's disabled by default.            654           so it's disabled by default.
765                                                   655 
766 config LTO_NONE                                   656 config LTO_NONE
767         bool "None"                               657         bool "None"
768         help                                      658         help
769           Build the kernel normally, without L    659           Build the kernel normally, without Link Time Optimization (LTO).
770                                                   660 
771 config LTO_CLANG_FULL                             661 config LTO_CLANG_FULL
772         bool "Clang Full LTO (EXPERIMENTAL)"      662         bool "Clang Full LTO (EXPERIMENTAL)"
773         depends on HAS_LTO_CLANG                  663         depends on HAS_LTO_CLANG
774         depends on !COMPILE_TEST                  664         depends on !COMPILE_TEST
775         select LTO_CLANG                          665         select LTO_CLANG
776         help                                      666         help
777           This option enables Clang's full Lin !! 667           This option enables Clang's full Link Time Optimization (LTO), which
778           allows the compiler to optimize the  !! 668           allows the compiler to optimize the kernel globally. If you enable
779           this option, the compiler generates  !! 669           this option, the compiler generates LLVM bitcode instead of ELF
780           object files, and the actual compila !! 670           object files, and the actual compilation from bitcode happens at
781           the LTO link step, which may take se !! 671           the LTO link step, which may take several minutes depending on the
782           kernel configuration. More informati !! 672           kernel configuration. More information can be found from LLVM's
783           documentation:                       !! 673           documentation:
784                                                   674 
785             https://llvm.org/docs/LinkTimeOpti    675             https://llvm.org/docs/LinkTimeOptimization.html
786                                                   676 
787           During link time, this option can us    677           During link time, this option can use a large amount of RAM, and
788           may take much longer than the ThinLT    678           may take much longer than the ThinLTO option.
789                                                   679 
790 config LTO_CLANG_THIN                             680 config LTO_CLANG_THIN
791         bool "Clang ThinLTO (EXPERIMENTAL)"       681         bool "Clang ThinLTO (EXPERIMENTAL)"
792         depends on HAS_LTO_CLANG && ARCH_SUPPO    682         depends on HAS_LTO_CLANG && ARCH_SUPPORTS_LTO_CLANG_THIN
793         select LTO_CLANG                          683         select LTO_CLANG
794         help                                      684         help
795           This option enables Clang's ThinLTO,    685           This option enables Clang's ThinLTO, which allows for parallel
796           optimization and faster incremental     686           optimization and faster incremental compiles compared to the
797           CONFIG_LTO_CLANG_FULL option. More i    687           CONFIG_LTO_CLANG_FULL option. More information can be found
798           from Clang's documentation:             688           from Clang's documentation:
799                                                   689 
800             https://clang.llvm.org/docs/ThinLT    690             https://clang.llvm.org/docs/ThinLTO.html
801                                                   691 
802           If unsure, say Y.                       692           If unsure, say Y.
803 endchoice                                         693 endchoice
804                                                   694 
805 config ARCH_SUPPORTS_CFI_CLANG                 << 
806         bool                                   << 
807         help                                   << 
808           An architecture should select this o << 
809           Control-Flow Integrity (CFI) checkin << 
810                                                << 
811 config ARCH_USES_CFI_TRAPS                     << 
812         bool                                   << 
813                                                << 
814 config CFI_CLANG                               << 
815         bool "Use Clang's Control Flow Integri << 
816         depends on ARCH_SUPPORTS_CFI_CLANG     << 
817         depends on $(cc-option,-fsanitize=kcfi << 
818         help                                   << 
819           This option enables Clang's forward- << 
820           (CFI) checking, where the compiler i << 
821           indirect function call to ensure the << 
822           the correct static type. This restri << 
823           makes it more difficult for an attac << 
824           the modification of stored function  << 
825           found from Clang's documentation:    << 
826                                                << 
827             https://clang.llvm.org/docs/Contro << 
828                                                << 
829 config CFI_PERMISSIVE                          << 
830         bool "Use CFI in permissive mode"      << 
831         depends on CFI_CLANG                   << 
832         help                                   << 
833           When selected, Control Flow Integrit << 
834           warning instead of a kernel panic. T << 
835           for finding indirect call type misma << 
836                                                << 
837           If unsure, say N.                    << 
838                                                << 
839 config HAVE_ARCH_WITHIN_STACK_FRAMES              695 config HAVE_ARCH_WITHIN_STACK_FRAMES
840         bool                                      696         bool
841         help                                      697         help
842           An architecture should select this i    698           An architecture should select this if it can walk the kernel stack
843           frames to determine if an object is     699           frames to determine if an object is part of either the arguments
844           or local variables (i.e. that it exc    700           or local variables (i.e. that it excludes saved return addresses,
845           and similar) by implementing an inli    701           and similar) by implementing an inline arch_within_stack_frames(),
846           which is used by CONFIG_HARDENED_USE    702           which is used by CONFIG_HARDENED_USERCOPY.
847                                                   703 
848 config HAVE_CONTEXT_TRACKING_USER              !! 704 config HAVE_CONTEXT_TRACKING
849         bool                                      705         bool
850         help                                      706         help
851           Provide kernel/user boundaries probe    707           Provide kernel/user boundaries probes necessary for subsystems
852           that need it, such as userspace RCU     708           that need it, such as userspace RCU extended quiescent state.
853           Syscalls need to be wrapped inside u    709           Syscalls need to be wrapped inside user_exit()-user_enter(), either
854           optimized behind static key or throu    710           optimized behind static key or through the slow path using TIF_NOHZ
855           flag. Exceptions handlers must be wr    711           flag. Exceptions handlers must be wrapped as well. Irqs are already
856           protected inside ct_irq_enter/ct_irq !! 712           protected inside rcu_irq_enter/rcu_irq_exit() but preemption or signal
857           handling on irq exit still need to b    713           handling on irq exit still need to be protected.
858                                                   714 
859 config HAVE_CONTEXT_TRACKING_USER_OFFSTACK     !! 715 config HAVE_CONTEXT_TRACKING_OFFSTACK
860         bool                                      716         bool
861         help                                      717         help
862           Architecture neither relies on excep    718           Architecture neither relies on exception_enter()/exception_exit()
863           nor on schedule_user(). Also preempt    719           nor on schedule_user(). Also preempt_schedule_notrace() and
864           preempt_schedule_irq() can't be call    720           preempt_schedule_irq() can't be called in a preemptible section
865           while context tracking is CONTEXT_US    721           while context tracking is CONTEXT_USER. This feature reflects a sane
866           entry implementation where the follo    722           entry implementation where the following requirements are met on
867           critical entry code, ie: before user    723           critical entry code, ie: before user_exit() or after user_enter():
868                                                   724 
869           - Critical entry code isn't preempti    725           - Critical entry code isn't preemptible (or better yet:
870             not interruptible).                   726             not interruptible).
871           - No use of RCU read side critical s !! 727           - No use of RCU read side critical sections, unless rcu_nmi_enter()
872             got called.                           728             got called.
873           - No use of instrumentation, unless     729           - No use of instrumentation, unless instrumentation_begin() got
874             called.                               730             called.
875                                                   731 
876 config HAVE_TIF_NOHZ                              732 config HAVE_TIF_NOHZ
877         bool                                      733         bool
878         help                                      734         help
879           Arch relies on TIF_NOHZ and syscall     735           Arch relies on TIF_NOHZ and syscall slow path to implement context
880           tracking calls to user_enter()/user_    736           tracking calls to user_enter()/user_exit().
881                                                   737 
882 config HAVE_VIRT_CPU_ACCOUNTING                   738 config HAVE_VIRT_CPU_ACCOUNTING
883         bool                                      739         bool
884                                                   740 
885 config HAVE_VIRT_CPU_ACCOUNTING_IDLE              741 config HAVE_VIRT_CPU_ACCOUNTING_IDLE
886         bool                                      742         bool
887         help                                      743         help
888           Architecture has its own way to acco    744           Architecture has its own way to account idle CPU time and therefore
889           doesn't implement vtime_account_idle    745           doesn't implement vtime_account_idle().
890                                                   746 
891 config ARCH_HAS_SCALED_CPUTIME                    747 config ARCH_HAS_SCALED_CPUTIME
892         bool                                      748         bool
893                                                   749 
894 config HAVE_VIRT_CPU_ACCOUNTING_GEN               750 config HAVE_VIRT_CPU_ACCOUNTING_GEN
895         bool                                      751         bool
896         default y if 64BIT                        752         default y if 64BIT
897         help                                      753         help
898           With VIRT_CPU_ACCOUNTING_GEN, cputim    754           With VIRT_CPU_ACCOUNTING_GEN, cputime_t becomes 64-bit.
899           Before enabling this option, arch co    755           Before enabling this option, arch code must be audited
900           to ensure there are no races in conc    756           to ensure there are no races in concurrent read/write of
901           cputime_t. For example, reading/writ    757           cputime_t. For example, reading/writing 64-bit cputime_t on
902           some 32-bit arches may require multi    758           some 32-bit arches may require multiple accesses, so proper
903           locking is needed to protect against    759           locking is needed to protect against concurrent accesses.
904                                                   760 
905 config HAVE_IRQ_TIME_ACCOUNTING                   761 config HAVE_IRQ_TIME_ACCOUNTING
906         bool                                      762         bool
907         help                                      763         help
908           Archs need to ensure they use a high    764           Archs need to ensure they use a high enough resolution clock to
909           support irq time accounting and then    765           support irq time accounting and then call enable_sched_clock_irqtime().
910                                                   766 
911 config HAVE_MOVE_PUD                              767 config HAVE_MOVE_PUD
912         bool                                      768         bool
913         help                                      769         help
914           Architectures that select this are a    770           Architectures that select this are able to move page tables at the
915           PUD level. If there are only 3 page     771           PUD level. If there are only 3 page table levels, the move effectively
916           happens at the PGD level.               772           happens at the PGD level.
917                                                   773 
918 config HAVE_MOVE_PMD                              774 config HAVE_MOVE_PMD
919         bool                                      775         bool
920         help                                      776         help
921           Archs that select this are able to m    777           Archs that select this are able to move page tables at the PMD level.
922                                                   778 
923 config HAVE_ARCH_TRANSPARENT_HUGEPAGE             779 config HAVE_ARCH_TRANSPARENT_HUGEPAGE
924         bool                                      780         bool
925                                                   781 
926 config HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD         782 config HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD
927         bool                                      783         bool
928                                                   784 
929 config HAVE_ARCH_HUGE_VMAP                        785 config HAVE_ARCH_HUGE_VMAP
930         bool                                      786         bool
931                                                   787 
932 #                                              << 
933 #  Archs that select this would be capable of  << 
934 #  arch_vmap_pmd_supported() returns true). Th << 
935 #  must be used to enable allocations to use h << 
936 #                                              << 
937 config HAVE_ARCH_HUGE_VMALLOC                  << 
938         depends on HAVE_ARCH_HUGE_VMAP         << 
939         bool                                   << 
940                                                << 
941 config ARCH_WANT_HUGE_PMD_SHARE                   788 config ARCH_WANT_HUGE_PMD_SHARE
942         bool                                      789         bool
943                                                   790 
944 # Archs that want to use pmd_mkwrite on kernel << 
945 # if there are no userspace memory management  << 
946 config ARCH_WANT_KERNEL_PMD_MKWRITE            << 
947         bool                                   << 
948                                                << 
949 config ARCH_WANT_PMD_MKWRITE                   << 
950         def_bool TRANSPARENT_HUGEPAGE || ARCH_ << 
951                                                << 
952 config HAVE_ARCH_SOFT_DIRTY                       791 config HAVE_ARCH_SOFT_DIRTY
953         bool                                      792         bool
954                                                   793 
955 config HAVE_MOD_ARCH_SPECIFIC                     794 config HAVE_MOD_ARCH_SPECIFIC
956         bool                                      795         bool
957         help                                      796         help
958           The arch uses struct mod_arch_specif    797           The arch uses struct mod_arch_specific to store data.  Many arches
959           just need a simple module loader wit    798           just need a simple module loader without arch specific data - those
960           should not enable this.                 799           should not enable this.
961                                                   800 
962 config MODULES_USE_ELF_RELA                       801 config MODULES_USE_ELF_RELA
963         bool                                      802         bool
964         help                                      803         help
965           Modules only use ELF RELA relocation    804           Modules only use ELF RELA relocations.  Modules with ELF REL
966           relocations will give an error.         805           relocations will give an error.
967                                                   806 
968 config MODULES_USE_ELF_REL                        807 config MODULES_USE_ELF_REL
969         bool                                      808         bool
970         help                                      809         help
971           Modules only use ELF REL relocations    810           Modules only use ELF REL relocations.  Modules with ELF RELA
972           relocations will give an error.         811           relocations will give an error.
973                                                   812 
974 config ARCH_WANTS_MODULES_DATA_IN_VMALLOC      << 
975         bool                                   << 
976         help                                   << 
977           For architectures like powerpc/32 wh << 
978           allocation and need to allocate modu << 
979                                                << 
980 config ARCH_WANTS_EXECMEM_LATE                 << 
981         bool                                   << 
982         help                                   << 
983           For architectures that do not alloca << 
984           boot, but rather require its initial << 
985           enough entropy for module space rand << 
986           arm64.                               << 
987                                                << 
988 config HAVE_IRQ_EXIT_ON_IRQ_STACK                 813 config HAVE_IRQ_EXIT_ON_IRQ_STACK
989         bool                                      814         bool
990         help                                      815         help
991           Architecture doesn't only execute th    816           Architecture doesn't only execute the irq handler on the irq stack
992           but also irq_exit(). This way we can    817           but also irq_exit(). This way we can process softirqs on this irq
993           stack instead of switching to a new     818           stack instead of switching to a new one when we call __do_softirq()
994           in the end of an hardirq.               819           in the end of an hardirq.
995           This spares a stack switch and impro    820           This spares a stack switch and improves cache usage on softirq
996           processing.                             821           processing.
997                                                   822 
998 config HAVE_SOFTIRQ_ON_OWN_STACK                  823 config HAVE_SOFTIRQ_ON_OWN_STACK
999         bool                                      824         bool
1000         help                                     825         help
1001           Architecture provides a function to    826           Architecture provides a function to run __do_softirq() on a
1002           separate stack.                     !! 827           seperate stack.
1003                                               << 
1004 config SOFTIRQ_ON_OWN_STACK                   << 
1005         def_bool HAVE_SOFTIRQ_ON_OWN_STACK && << 
1006                                               << 
1007 config ALTERNATE_USER_ADDRESS_SPACE           << 
1008         bool                                  << 
1009         help                                  << 
1010           Architectures set this when the CPU << 
1011           spaces for kernel and user space po << 
1012           access_ok() check on a __user point << 
1013                                                  828 
1014 config PGTABLE_LEVELS                            829 config PGTABLE_LEVELS
1015         int                                      830         int
1016         default 2                                831         default 2
1017                                                  832 
1018 config ARCH_HAS_ELF_RANDOMIZE                    833 config ARCH_HAS_ELF_RANDOMIZE
1019         bool                                     834         bool
1020         help                                     835         help
1021           An architecture supports choosing r    836           An architecture supports choosing randomized locations for
1022           stack, mmap, brk, and ET_DYN. Defin    837           stack, mmap, brk, and ET_DYN. Defined functions:
1023           - arch_mmap_rnd()                      838           - arch_mmap_rnd()
1024           - arch_randomize_brk()                 839           - arch_randomize_brk()
1025                                                  840 
1026 config HAVE_ARCH_MMAP_RND_BITS                   841 config HAVE_ARCH_MMAP_RND_BITS
1027         bool                                     842         bool
1028         help                                     843         help
1029           An arch should select this symbol i    844           An arch should select this symbol if it supports setting a variable
1030           number of bits for use in establish    845           number of bits for use in establishing the base address for mmap
1031           allocations, has MMU enabled and pr    846           allocations, has MMU enabled and provides values for both:
1032           - ARCH_MMAP_RND_BITS_MIN               847           - ARCH_MMAP_RND_BITS_MIN
1033           - ARCH_MMAP_RND_BITS_MAX               848           - ARCH_MMAP_RND_BITS_MAX
1034                                                  849 
1035 config HAVE_EXIT_THREAD                          850 config HAVE_EXIT_THREAD
1036         bool                                     851         bool
1037         help                                     852         help
1038           An architecture implements exit_thr    853           An architecture implements exit_thread.
1039                                                  854 
1040 config ARCH_MMAP_RND_BITS_MIN                    855 config ARCH_MMAP_RND_BITS_MIN
1041         int                                      856         int
1042                                                  857 
1043 config ARCH_MMAP_RND_BITS_MAX                    858 config ARCH_MMAP_RND_BITS_MAX
1044         int                                      859         int
1045                                                  860 
1046 config ARCH_MMAP_RND_BITS_DEFAULT                861 config ARCH_MMAP_RND_BITS_DEFAULT
1047         int                                      862         int
1048                                                  863 
1049 config ARCH_MMAP_RND_BITS                        864 config ARCH_MMAP_RND_BITS
1050         int "Number of bits to use for ASLR o    865         int "Number of bits to use for ASLR of mmap base address" if EXPERT
1051         range ARCH_MMAP_RND_BITS_MIN ARCH_MMA    866         range ARCH_MMAP_RND_BITS_MIN ARCH_MMAP_RND_BITS_MAX
1052         default ARCH_MMAP_RND_BITS_DEFAULT if    867         default ARCH_MMAP_RND_BITS_DEFAULT if ARCH_MMAP_RND_BITS_DEFAULT
1053         default ARCH_MMAP_RND_BITS_MIN           868         default ARCH_MMAP_RND_BITS_MIN
1054         depends on HAVE_ARCH_MMAP_RND_BITS       869         depends on HAVE_ARCH_MMAP_RND_BITS
1055         help                                     870         help
1056           This value can be used to select th    871           This value can be used to select the number of bits to use to
1057           determine the random offset to the     872           determine the random offset to the base address of vma regions
1058           resulting from mmap allocations. Th    873           resulting from mmap allocations. This value will be bounded
1059           by the architecture's minimum and m    874           by the architecture's minimum and maximum supported values.
1060                                                  875 
1061           This value can be changed after boo    876           This value can be changed after boot using the
1062           /proc/sys/vm/mmap_rnd_bits tunable     877           /proc/sys/vm/mmap_rnd_bits tunable
1063                                                  878 
1064 config HAVE_ARCH_MMAP_RND_COMPAT_BITS            879 config HAVE_ARCH_MMAP_RND_COMPAT_BITS
1065         bool                                     880         bool
1066         help                                     881         help
1067           An arch should select this symbol i    882           An arch should select this symbol if it supports running applications
1068           in compatibility mode, supports set    883           in compatibility mode, supports setting a variable number of bits for
1069           use in establishing the base addres    884           use in establishing the base address for mmap allocations, has MMU
1070           enabled and provides values for bot    885           enabled and provides values for both:
1071           - ARCH_MMAP_RND_COMPAT_BITS_MIN        886           - ARCH_MMAP_RND_COMPAT_BITS_MIN
1072           - ARCH_MMAP_RND_COMPAT_BITS_MAX        887           - ARCH_MMAP_RND_COMPAT_BITS_MAX
1073                                                  888 
1074 config ARCH_MMAP_RND_COMPAT_BITS_MIN             889 config ARCH_MMAP_RND_COMPAT_BITS_MIN
1075         int                                      890         int
1076                                                  891 
1077 config ARCH_MMAP_RND_COMPAT_BITS_MAX             892 config ARCH_MMAP_RND_COMPAT_BITS_MAX
1078         int                                      893         int
1079                                                  894 
1080 config ARCH_MMAP_RND_COMPAT_BITS_DEFAULT         895 config ARCH_MMAP_RND_COMPAT_BITS_DEFAULT
1081         int                                      896         int
1082                                                  897 
1083 config ARCH_MMAP_RND_COMPAT_BITS                 898 config ARCH_MMAP_RND_COMPAT_BITS
1084         int "Number of bits to use for ASLR o    899         int "Number of bits to use for ASLR of mmap base address for compatible applications" if EXPERT
1085         range ARCH_MMAP_RND_COMPAT_BITS_MIN A    900         range ARCH_MMAP_RND_COMPAT_BITS_MIN ARCH_MMAP_RND_COMPAT_BITS_MAX
1086         default ARCH_MMAP_RND_COMPAT_BITS_DEF    901         default ARCH_MMAP_RND_COMPAT_BITS_DEFAULT if ARCH_MMAP_RND_COMPAT_BITS_DEFAULT
1087         default ARCH_MMAP_RND_COMPAT_BITS_MIN    902         default ARCH_MMAP_RND_COMPAT_BITS_MIN
1088         depends on HAVE_ARCH_MMAP_RND_COMPAT_    903         depends on HAVE_ARCH_MMAP_RND_COMPAT_BITS
1089         help                                     904         help
1090           This value can be used to select th    905           This value can be used to select the number of bits to use to
1091           determine the random offset to the     906           determine the random offset to the base address of vma regions
1092           resulting from mmap allocations for    907           resulting from mmap allocations for compatible applications This
1093           value will be bounded by the archit    908           value will be bounded by the architecture's minimum and maximum
1094           supported values.                      909           supported values.
1095                                                  910 
1096           This value can be changed after boo    911           This value can be changed after boot using the
1097           /proc/sys/vm/mmap_rnd_compat_bits t    912           /proc/sys/vm/mmap_rnd_compat_bits tunable
1098                                                  913 
1099 config HAVE_ARCH_COMPAT_MMAP_BASES               914 config HAVE_ARCH_COMPAT_MMAP_BASES
1100         bool                                     915         bool
1101         help                                     916         help
1102           This allows 64bit applications to i    917           This allows 64bit applications to invoke 32-bit mmap() syscall
1103           and vice-versa 32-bit applications     918           and vice-versa 32-bit applications to call 64-bit mmap().
1104           Required for applications doing dif    919           Required for applications doing different bitness syscalls.
1105                                                  920 
1106 config HAVE_PAGE_SIZE_4KB                     << 
1107         bool                                  << 
1108                                               << 
1109 config HAVE_PAGE_SIZE_8KB                     << 
1110         bool                                  << 
1111                                               << 
1112 config HAVE_PAGE_SIZE_16KB                    << 
1113         bool                                  << 
1114                                               << 
1115 config HAVE_PAGE_SIZE_32KB                    << 
1116         bool                                  << 
1117                                               << 
1118 config HAVE_PAGE_SIZE_64KB                    << 
1119         bool                                  << 
1120                                               << 
1121 config HAVE_PAGE_SIZE_256KB                   << 
1122         bool                                  << 
1123                                               << 
1124 choice                                        << 
1125         prompt "MMU page size"                << 
1126                                               << 
1127 config PAGE_SIZE_4KB                          << 
1128         bool "4KiB pages"                     << 
1129         depends on HAVE_PAGE_SIZE_4KB         << 
1130         help                                  << 
1131           This option select the standard 4Ki << 
1132           available option on many architectu << 
1133           minimize memory consumption and is  << 
1134           memory systems.                     << 
1135           Some software that is written for x << 
1136           assumptions about the page size and << 
1137                                               << 
1138 config PAGE_SIZE_8KB                          << 
1139         bool "8KiB pages"                     << 
1140         depends on HAVE_PAGE_SIZE_8KB         << 
1141         help                                  << 
1142           This option is the only supported p << 
1143           processors, and can be slightly fas << 
1144                                               << 
1145 config PAGE_SIZE_16KB                         << 
1146         bool "16KiB pages"                    << 
1147         depends on HAVE_PAGE_SIZE_16KB        << 
1148         help                                  << 
1149           This option is usually a good compr << 
1150           consumption and performance for typ << 
1151           workloads, often saving a level of  << 
1152           to 4KB pages as well as reducing TL << 
1153           per-page operations in the kernel a << 
1154           page cache.                         << 
1155                                               << 
1156 config PAGE_SIZE_32KB                         << 
1157         bool "32KiB pages"                    << 
1158         depends on HAVE_PAGE_SIZE_32KB        << 
1159         help                                  << 
1160           Using 32KiB page size will result i << 
1161           kernel at the price of higher memor << 
1162           16KiB pages.  This option is availa << 
1163           Note that you will need a suitable  << 
1164           support this.                       << 
1165                                               << 
1166 config PAGE_SIZE_64KB                         << 
1167         bool "64KiB pages"                    << 
1168         depends on HAVE_PAGE_SIZE_64KB        << 
1169         help                                  << 
1170           Using 64KiB page size will result i << 
1171           kernel at the price of much higher  << 
1172           4KiB or 16KiB pages.                << 
1173           This is not suitable for general-pu << 
1174           better performance may be worth the << 
1175           supercomputing or database applicat << 
1176           large in-memory data rather than sm << 
1177                                               << 
1178 config PAGE_SIZE_256KB                        << 
1179         bool "256KiB pages"                   << 
1180         depends on HAVE_PAGE_SIZE_256KB       << 
1181         help                                  << 
1182           256KiB pages have little practical  << 
1183           memory usage.  The kernel will only << 
1184           that have been compiled with '-zmax << 
1185           (the default is 64KiB or 4KiB on mo << 
1186                                               << 
1187 endchoice                                     << 
1188                                               << 
1189 config PAGE_SIZE_LESS_THAN_64KB               << 
1190         def_bool y                            << 
1191         depends on !PAGE_SIZE_64KB            << 
1192         depends on PAGE_SIZE_LESS_THAN_256KB  << 
1193                                               << 
1194 config PAGE_SIZE_LESS_THAN_256KB              << 
1195         def_bool y                            << 
1196         depends on !PAGE_SIZE_256KB           << 
1197                                               << 
1198 config PAGE_SHIFT                             << 
1199         int                                   << 
1200         default 12 if PAGE_SIZE_4KB           << 
1201         default 13 if PAGE_SIZE_8KB           << 
1202         default 14 if PAGE_SIZE_16KB          << 
1203         default 15 if PAGE_SIZE_32KB          << 
1204         default 16 if PAGE_SIZE_64KB          << 
1205         default 18 if PAGE_SIZE_256KB         << 
1206                                               << 
1207 # This allows to use a set of generic functio    921 # This allows to use a set of generic functions to determine mmap base
1208 # address by giving priority to top-down sche    922 # address by giving priority to top-down scheme only if the process
1209 # is not in legacy mode (compat task, unlimit    923 # is not in legacy mode (compat task, unlimited stack size or
1210 # sysctl_legacy_va_layout).                      924 # sysctl_legacy_va_layout).
1211 # Architecture that selects this option can p    925 # Architecture that selects this option can provide its own version of:
1212 # - STACK_RND_MASK                               926 # - STACK_RND_MASK
1213 config ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT     927 config ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT
1214         bool                                     928         bool
1215         depends on MMU                           929         depends on MMU
1216         select ARCH_HAS_ELF_RANDOMIZE            930         select ARCH_HAS_ELF_RANDOMIZE
1217                                                  931 
1218 config HAVE_OBJTOOL                           << 
1219         bool                                  << 
1220                                               << 
1221 config HAVE_JUMP_LABEL_HACK                   << 
1222         bool                                  << 
1223                                               << 
1224 config HAVE_NOINSTR_HACK                      << 
1225         bool                                  << 
1226                                               << 
1227 config HAVE_NOINSTR_VALIDATION                << 
1228         bool                                  << 
1229                                               << 
1230 config HAVE_UACCESS_VALIDATION                << 
1231         bool                                  << 
1232         select OBJTOOL                        << 
1233                                               << 
1234 config HAVE_STACK_VALIDATION                     932 config HAVE_STACK_VALIDATION
1235         bool                                     933         bool
1236         help                                     934         help
1237           Architecture supports objtool compi !! 935           Architecture supports the 'objtool check' host tool command, which
1238           validation.                         !! 936           performs compile-time stack metadata validation.
1239                                                  937 
1240 config HAVE_RELIABLE_STACKTRACE                  938 config HAVE_RELIABLE_STACKTRACE
1241         bool                                     939         bool
1242         help                                     940         help
1243           Architecture has either save_stack_    941           Architecture has either save_stack_trace_tsk_reliable() or
1244           arch_stack_walk_reliable() function    942           arch_stack_walk_reliable() function which only returns a stack trace
1245           if it can guarantee the trace is re    943           if it can guarantee the trace is reliable.
1246                                                  944 
1247 config HAVE_ARCH_HASH                            945 config HAVE_ARCH_HASH
1248         bool                                     946         bool
1249         default n                                947         default n
1250         help                                     948         help
1251           If this is set, the architecture pr    949           If this is set, the architecture provides an <asm/hash.h>
1252           file which provides platform-specif    950           file which provides platform-specific implementations of some
1253           functions in <linux/hash.h> or fs/n    951           functions in <linux/hash.h> or fs/namei.c.
1254                                                  952 
1255 config HAVE_ARCH_NVRAM_OPS                       953 config HAVE_ARCH_NVRAM_OPS
1256         bool                                     954         bool
1257                                                  955 
1258 config ISA_BUS_API                               956 config ISA_BUS_API
1259         def_bool ISA                             957         def_bool ISA
1260                                                  958 
1261 #                                                959 #
1262 # ABI hall of shame                              960 # ABI hall of shame
1263 #                                                961 #
1264 config CLONE_BACKWARDS                           962 config CLONE_BACKWARDS
1265         bool                                     963         bool
1266         help                                     964         help
1267           Architecture has tls passed as the     965           Architecture has tls passed as the 4th argument of clone(2),
1268           not the 5th one.                       966           not the 5th one.
1269                                                  967 
1270 config CLONE_BACKWARDS2                          968 config CLONE_BACKWARDS2
1271         bool                                     969         bool
1272         help                                     970         help
1273           Architecture has the first two argu    971           Architecture has the first two arguments of clone(2) swapped.
1274                                                  972 
1275 config CLONE_BACKWARDS3                          973 config CLONE_BACKWARDS3
1276         bool                                     974         bool
1277         help                                     975         help
1278           Architecture has tls passed as the     976           Architecture has tls passed as the 3rd argument of clone(2),
1279           not the 5th one.                       977           not the 5th one.
1280                                                  978 
1281 config ODD_RT_SIGACTION                          979 config ODD_RT_SIGACTION
1282         bool                                     980         bool
1283         help                                     981         help
1284           Architecture has unusual rt_sigacti    982           Architecture has unusual rt_sigaction(2) arguments
1285                                                  983 
1286 config OLD_SIGSUSPEND                            984 config OLD_SIGSUSPEND
1287         bool                                     985         bool
1288         help                                     986         help
1289           Architecture has old sigsuspend(2)     987           Architecture has old sigsuspend(2) syscall, of one-argument variety
1290                                                  988 
1291 config OLD_SIGSUSPEND3                           989 config OLD_SIGSUSPEND3
1292         bool                                     990         bool
1293         help                                     991         help
1294           Even weirder antique ABI - three-ar    992           Even weirder antique ABI - three-argument sigsuspend(2)
1295                                                  993 
1296 config OLD_SIGACTION                             994 config OLD_SIGACTION
1297         bool                                     995         bool
1298         help                                     996         help
1299           Architecture has old sigaction(2) s    997           Architecture has old sigaction(2) syscall.  Nope, not the same
1300           as OLD_SIGSUSPEND | OLD_SIGSUSPEND3    998           as OLD_SIGSUSPEND | OLD_SIGSUSPEND3 - alpha has sigsuspend(2),
1301           but fairly different variant of sig    999           but fairly different variant of sigaction(2), thanks to OSF/1
1302           compatibility...                       1000           compatibility...
1303                                                  1001 
1304 config COMPAT_OLD_SIGACTION                      1002 config COMPAT_OLD_SIGACTION
1305         bool                                     1003         bool
1306                                                  1004 
1307 config COMPAT_32BIT_TIME                         1005 config COMPAT_32BIT_TIME
1308         bool "Provide system calls for 32-bit    1006         bool "Provide system calls for 32-bit time_t"
1309         default !64BIT || COMPAT                 1007         default !64BIT || COMPAT
1310         help                                     1008         help
1311           This enables 32 bit time_t support     1009           This enables 32 bit time_t support in addition to 64 bit time_t support.
1312           This is relevant on all 32-bit arch    1010           This is relevant on all 32-bit architectures, and 64-bit architectures
1313           as part of compat syscall handling.    1011           as part of compat syscall handling.
1314                                                  1012 
1315 config ARCH_NO_PREEMPT                           1013 config ARCH_NO_PREEMPT
1316         bool                                     1014         bool
1317                                                  1015 
1318 config ARCH_SUPPORTS_RT                          1016 config ARCH_SUPPORTS_RT
1319         bool                                     1017         bool
1320                                                  1018 
1321 config CPU_NO_EFFICIENT_FFS                      1019 config CPU_NO_EFFICIENT_FFS
1322         def_bool n                               1020         def_bool n
1323                                                  1021 
1324 config HAVE_ARCH_VMAP_STACK                      1022 config HAVE_ARCH_VMAP_STACK
1325         def_bool n                               1023         def_bool n
1326         help                                     1024         help
1327           An arch should select this symbol i    1025           An arch should select this symbol if it can support kernel stacks
1328           in vmalloc space.  This means:         1026           in vmalloc space.  This means:
1329                                                  1027 
1330           - vmalloc space must be large enoug    1028           - vmalloc space must be large enough to hold many kernel stacks.
1331             This may rule out many 32-bit arc    1029             This may rule out many 32-bit architectures.
1332                                                  1030 
1333           - Stacks in vmalloc space need to w    1031           - Stacks in vmalloc space need to work reliably.  For example, if
1334             vmap page tables are created on d    1032             vmap page tables are created on demand, either this mechanism
1335             needs to work while the stack poi    1033             needs to work while the stack points to a virtual address with
1336             unpopulated page tables or arch c    1034             unpopulated page tables or arch code (switch_to() and switch_mm(),
1337             most likely) needs to ensure that    1035             most likely) needs to ensure that the stack's page table entries
1338             are populated before running on a    1036             are populated before running on a possibly unpopulated stack.
1339                                                  1037 
1340           - If the stack overflows into a gua    1038           - If the stack overflows into a guard page, something reasonable
1341             should happen.  The definition of    1039             should happen.  The definition of "reasonable" is flexible, but
1342             instantly rebooting without loggi    1040             instantly rebooting without logging anything would be unfriendly.
1343                                                  1041 
1344 config VMAP_STACK                                1042 config VMAP_STACK
1345         default y                                1043         default y
1346         bool "Use a virtually-mapped stack"      1044         bool "Use a virtually-mapped stack"
1347         depends on HAVE_ARCH_VMAP_STACK          1045         depends on HAVE_ARCH_VMAP_STACK
1348         depends on !KASAN || KASAN_HW_TAGS ||    1046         depends on !KASAN || KASAN_HW_TAGS || KASAN_VMALLOC
1349         help                                     1047         help
1350           Enable this if you want the use vir    1048           Enable this if you want the use virtually-mapped kernel stacks
1351           with guard pages.  This causes kern    1049           with guard pages.  This causes kernel stack overflows to be
1352           caught immediately rather than caus    1050           caught immediately rather than causing difficult-to-diagnose
1353           corruption.                            1051           corruption.
1354                                                  1052 
1355           To use this with software KASAN mod    1053           To use this with software KASAN modes, the architecture must support
1356           backing virtual mappings with real     1054           backing virtual mappings with real shadow memory, and KASAN_VMALLOC
1357           must be enabled.                       1055           must be enabled.
1358                                                  1056 
1359 config HAVE_ARCH_RANDOMIZE_KSTACK_OFFSET      << 
1360         def_bool n                            << 
1361         help                                  << 
1362           An arch should select this symbol i << 
1363           offset randomization with calls to  << 
1364           during syscall entry and choose_ran << 
1365           syscall exit. Careful removal of -f << 
1366           -fstack-protector should also be ap << 
1367           closely examined, as the artificial << 
1368           to the compiler, so it will attempt << 
1369           of the static branch state.         << 
1370                                               << 
1371 config RANDOMIZE_KSTACK_OFFSET                << 
1372         bool "Support for randomizing kernel  << 
1373         default y                             << 
1374         depends on HAVE_ARCH_RANDOMIZE_KSTACK << 
1375         depends on INIT_STACK_NONE || !CC_IS_ << 
1376         help                                  << 
1377           The kernel stack offset can be rand << 
1378           roughly 5 bits of entropy, frustrat << 
1379           attacks that depend on stack addres << 
1380           cross-syscall address exposures.    << 
1381                                               << 
1382           The feature is controlled via the " << 
1383           kernel boot param, and if turned of << 
1384           of static branches (see JUMP_LABEL) << 
1385                                               << 
1386           If unsure, say Y.                   << 
1387                                               << 
1388 config RANDOMIZE_KSTACK_OFFSET_DEFAULT        << 
1389         bool "Default state of kernel stack o << 
1390         depends on RANDOMIZE_KSTACK_OFFSET    << 
1391         help                                  << 
1392           Kernel stack offset randomization i << 
1393           "randomize_kstack_offset=on/off", a << 
1394           boot state.                         << 
1395                                               << 
1396 config ARCH_OPTIONAL_KERNEL_RWX                  1057 config ARCH_OPTIONAL_KERNEL_RWX
1397         def_bool n                               1058         def_bool n
1398                                                  1059 
1399 config ARCH_OPTIONAL_KERNEL_RWX_DEFAULT          1060 config ARCH_OPTIONAL_KERNEL_RWX_DEFAULT
1400         def_bool n                               1061         def_bool n
1401                                                  1062 
1402 config ARCH_HAS_STRICT_KERNEL_RWX                1063 config ARCH_HAS_STRICT_KERNEL_RWX
1403         def_bool n                               1064         def_bool n
1404                                                  1065 
1405 config STRICT_KERNEL_RWX                         1066 config STRICT_KERNEL_RWX
1406         bool "Make kernel text and rodata rea    1067         bool "Make kernel text and rodata read-only" if ARCH_OPTIONAL_KERNEL_RWX
1407         depends on ARCH_HAS_STRICT_KERNEL_RWX    1068         depends on ARCH_HAS_STRICT_KERNEL_RWX
1408         default !ARCH_OPTIONAL_KERNEL_RWX ||     1069         default !ARCH_OPTIONAL_KERNEL_RWX || ARCH_OPTIONAL_KERNEL_RWX_DEFAULT
1409         help                                     1070         help
1410           If this is set, kernel text and rod    1071           If this is set, kernel text and rodata memory will be made read-only,
1411           and non-text memory will be made no    1072           and non-text memory will be made non-executable. This provides
1412           protection against certain security    1073           protection against certain security exploits (e.g. executing the heap
1413           or modifying text)                     1074           or modifying text)
1414                                                  1075 
1415           These features are considered stand    1076           These features are considered standard security practice these days.
1416           You should say Y here in almost all    1077           You should say Y here in almost all cases.
1417                                                  1078 
1418 config ARCH_HAS_STRICT_MODULE_RWX                1079 config ARCH_HAS_STRICT_MODULE_RWX
1419         def_bool n                               1080         def_bool n
1420                                                  1081 
1421 config STRICT_MODULE_RWX                         1082 config STRICT_MODULE_RWX
1422         bool "Set loadable kernel module data    1083         bool "Set loadable kernel module data as NX and text as RO" if ARCH_OPTIONAL_KERNEL_RWX
1423         depends on ARCH_HAS_STRICT_MODULE_RWX    1084         depends on ARCH_HAS_STRICT_MODULE_RWX && MODULES
1424         default !ARCH_OPTIONAL_KERNEL_RWX ||     1085         default !ARCH_OPTIONAL_KERNEL_RWX || ARCH_OPTIONAL_KERNEL_RWX_DEFAULT
1425         help                                     1086         help
1426           If this is set, module text and rod    1087           If this is set, module text and rodata memory will be made read-only,
1427           and non-text memory will be made no    1088           and non-text memory will be made non-executable. This provides
1428           protection against certain security    1089           protection against certain security exploits (e.g. writing to text)
1429                                                  1090 
1430 # select if the architecture provides an asm/    1091 # select if the architecture provides an asm/dma-direct.h header
1431 config ARCH_HAS_PHYS_TO_DMA                      1092 config ARCH_HAS_PHYS_TO_DMA
1432         bool                                     1093         bool
1433                                                  1094 
1434 config HAVE_ARCH_COMPILER_H                      1095 config HAVE_ARCH_COMPILER_H
1435         bool                                     1096         bool
1436         help                                     1097         help
1437           An architecture can select this if     1098           An architecture can select this if it provides an
1438           asm/compiler.h header that should b    1099           asm/compiler.h header that should be included after
1439           linux/compiler-*.h in order to over    1100           linux/compiler-*.h in order to override macro definitions that those
1440           headers generally provide.             1101           headers generally provide.
1441                                                  1102 
1442 config HAVE_ARCH_PREL32_RELOCATIONS              1103 config HAVE_ARCH_PREL32_RELOCATIONS
1443         bool                                     1104         bool
1444         help                                     1105         help
1445           May be selected by an architecture     1106           May be selected by an architecture if it supports place-relative
1446           32-bit relocations, both in the too    1107           32-bit relocations, both in the toolchain and in the module loader,
1447           in which case relative references c    1108           in which case relative references can be used in special sections
1448           for PCI fixup, initcalls etc which     1109           for PCI fixup, initcalls etc which are only half the size on 64 bit
1449           architectures, and don't require ru    1110           architectures, and don't require runtime relocation on relocatable
1450           kernels.                               1111           kernels.
1451                                                  1112 
1452 config ARCH_USE_MEMREMAP_PROT                    1113 config ARCH_USE_MEMREMAP_PROT
1453         bool                                     1114         bool
1454                                                  1115 
1455 config LOCK_EVENT_COUNTS                         1116 config LOCK_EVENT_COUNTS
1456         bool "Locking event counts collection    1117         bool "Locking event counts collection"
1457         depends on DEBUG_FS                      1118         depends on DEBUG_FS
1458         help                                     1119         help
1459           Enable light-weight counting of var    1120           Enable light-weight counting of various locking related events
1460           in the system with minimal performa    1121           in the system with minimal performance impact. This reduces
1461           the chance of application behavior     1122           the chance of application behavior change because of timing
1462           differences. The counts are reporte    1123           differences. The counts are reported via debugfs.
1463                                                  1124 
1464 # Select if the architecture has support for     1125 # Select if the architecture has support for applying RELR relocations.
1465 config ARCH_HAS_RELR                             1126 config ARCH_HAS_RELR
1466         bool                                     1127         bool
1467                                                  1128 
1468 config RELR                                      1129 config RELR
1469         bool "Use RELR relocation packing"       1130         bool "Use RELR relocation packing"
1470         depends on ARCH_HAS_RELR && TOOLS_SUP    1131         depends on ARCH_HAS_RELR && TOOLS_SUPPORT_RELR
1471         default y                                1132         default y
1472         help                                     1133         help
1473           Store the kernel's dynamic relocati    1134           Store the kernel's dynamic relocations in the RELR relocation packing
1474           format. Requires a compatible linke    1135           format. Requires a compatible linker (LLD supports this feature), as
1475           well as compatible NM and OBJCOPY u    1136           well as compatible NM and OBJCOPY utilities (llvm-nm and llvm-objcopy
1476           are compatible).                       1137           are compatible).
1477                                                  1138 
1478 config ARCH_HAS_MEM_ENCRYPT                      1139 config ARCH_HAS_MEM_ENCRYPT
1479         bool                                     1140         bool
1480                                                  1141 
1481 config ARCH_HAS_CC_PLATFORM                   << 
1482         bool                                  << 
1483                                               << 
1484 config HAVE_SPARSE_SYSCALL_NR                    1142 config HAVE_SPARSE_SYSCALL_NR
1485         bool                                  !! 1143        bool
1486         help                                  !! 1144        help
1487           An architecture should select this  !! 1145           An architecture should select this if its syscall numbering is sparse
1488           to save space. For example, MIPS ar    1146           to save space. For example, MIPS architecture has a syscall array with
1489           entries at 4000, 5000 and 6000 loca    1147           entries at 4000, 5000 and 6000 locations. This option turns on syscall
1490           related optimizations for a given a    1148           related optimizations for a given architecture.
1491                                                  1149 
1492 config ARCH_HAS_VDSO_DATA                        1150 config ARCH_HAS_VDSO_DATA
1493         bool                                     1151         bool
1494                                                  1152 
1495 config HAVE_STATIC_CALL                          1153 config HAVE_STATIC_CALL
1496         bool                                     1154         bool
1497                                                  1155 
1498 config HAVE_STATIC_CALL_INLINE                   1156 config HAVE_STATIC_CALL_INLINE
1499         bool                                     1157         bool
1500         depends on HAVE_STATIC_CALL              1158         depends on HAVE_STATIC_CALL
1501         select OBJTOOL                        << 
1502                                                  1159 
1503 config HAVE_PREEMPT_DYNAMIC                      1160 config HAVE_PREEMPT_DYNAMIC
1504         bool                                     1161         bool
1505                                               << 
1506 config HAVE_PREEMPT_DYNAMIC_CALL              << 
1507         bool                                  << 
1508         depends on HAVE_STATIC_CALL              1162         depends on HAVE_STATIC_CALL
1509         select HAVE_PREEMPT_DYNAMIC           !! 1163         depends on GENERIC_ENTRY
1510         help                                     1164         help
1511           An architecture should select this  !! 1165            Select this if the architecture support boot time preempt setting
1512           model being selected at boot time u !! 1166            on top of static calls. It is strongly advised to support inline
1513                                               !! 1167            static call to avoid any overhead.
1514           Where an architecture selects HAVE_ << 
1515           preemption function will be patched << 
1516                                               << 
1517           Where an architecture does not sele << 
1518           call to a preemption function will  << 
1519           trampoline will be patched.         << 
1520                                               << 
1521           It is strongly advised to support i << 
1522           overhead.                           << 
1523                                               << 
1524 config HAVE_PREEMPT_DYNAMIC_KEY               << 
1525         bool                                  << 
1526         depends on HAVE_ARCH_JUMP_LABEL       << 
1527         select HAVE_PREEMPT_DYNAMIC           << 
1528         help                                  << 
1529           An architecture should select this  << 
1530           model being selected at boot time u << 
1531                                               << 
1532           Each preemption function will be gi << 
1533           static key. This should have slight << 
1534           static calls, as this effectively i << 
1535           start of its callee. This may avoid << 
1536           integrate better with CFI schemes.  << 
1537                                               << 
1538           This will have greater overhead tha << 
1539           the call to the preemption function << 
1540                                                  1168 
1541 config ARCH_WANT_LD_ORPHAN_WARN                  1169 config ARCH_WANT_LD_ORPHAN_WARN
1542         bool                                     1170         bool
1543         help                                     1171         help
1544           An arch should select this symbol o    1172           An arch should select this symbol once all linker sections are explicitly
1545           included, size-asserted, or discard    1173           included, size-asserted, or discarded in the linker scripts. This is
1546           important because we never want exp    1174           important because we never want expected sections to be placed heuristically
1547           by the linker, since the locations     1175           by the linker, since the locations of such sections can change between linker
1548           versions.                              1176           versions.
1549                                                  1177 
1550 config HAVE_ARCH_PFN_VALID                       1178 config HAVE_ARCH_PFN_VALID
1551         bool                                     1179         bool
1552                                                  1180 
1553 config ARCH_SUPPORTS_DEBUG_PAGEALLOC             1181 config ARCH_SUPPORTS_DEBUG_PAGEALLOC
1554         bool                                     1182         bool
1555                                                  1183 
1556 config ARCH_SUPPORTS_PAGE_TABLE_CHECK         << 
1557         bool                                  << 
1558                                               << 
1559 config ARCH_SPLIT_ARG64                          1184 config ARCH_SPLIT_ARG64
1560         bool                                     1185         bool
1561         help                                     1186         help
1562           If a 32-bit architecture requires 6 !! 1187            If a 32-bit architecture requires 64-bit arguments to be split into
1563           pairs of 32-bit arguments, select t !! 1188            pairs of 32-bit arguments, select this option.
1564                                                  1189 
1565 config ARCH_HAS_ELFCORE_COMPAT                   1190 config ARCH_HAS_ELFCORE_COMPAT
1566         bool                                     1191         bool
1567                                                  1192 
1568 config ARCH_HAS_PARANOID_L1D_FLUSH            << 
1569         bool                                  << 
1570                                               << 
1571 config ARCH_HAVE_TRACE_MMIO_ACCESS            << 
1572         bool                                  << 
1573                                               << 
1574 config DYNAMIC_SIGFRAME                       << 
1575         bool                                  << 
1576                                               << 
1577 # Select, if arch has a named attribute group << 
1578 config HAVE_ARCH_NODE_DEV_GROUP               << 
1579         bool                                  << 
1580                                               << 
1581 config ARCH_HAS_HW_PTE_YOUNG                  << 
1582         bool                                  << 
1583         help                                  << 
1584           Architectures that select this opti << 
1585           accessed bit in PTE entries when us << 
1586           translations. Architectures that re << 
1587           this option and override arch_has_h << 
1588                                               << 
1589 config ARCH_HAS_NONLEAF_PMD_YOUNG             << 
1590         bool                                  << 
1591         help                                  << 
1592           Architectures that select this opti << 
1593           accessed bit in non-leaf PMD entrie << 
1594           address translations. Page table wa << 
1595           may use this capability to reduce t << 
1596                                               << 
1597 config ARCH_HAS_KERNEL_FPU_SUPPORT            << 
1598         bool                                  << 
1599         help                                  << 
1600           Architectures that select this opti << 
1601           the kernel, as described in Documen << 
1602                                               << 
1603 source "kernel/gcov/Kconfig"                     1193 source "kernel/gcov/Kconfig"
1604                                                  1194 
1605 source "scripts/gcc-plugins/Kconfig"             1195 source "scripts/gcc-plugins/Kconfig"
1606                                               << 
1607 config FUNCTION_ALIGNMENT_4B                  << 
1608         bool                                  << 
1609                                               << 
1610 config FUNCTION_ALIGNMENT_8B                  << 
1611         bool                                  << 
1612                                               << 
1613 config FUNCTION_ALIGNMENT_16B                 << 
1614         bool                                  << 
1615                                               << 
1616 config FUNCTION_ALIGNMENT_32B                 << 
1617         bool                                  << 
1618                                               << 
1619 config FUNCTION_ALIGNMENT_64B                 << 
1620         bool                                  << 
1621                                               << 
1622 config FUNCTION_ALIGNMENT                     << 
1623         int                                   << 
1624         default 64 if FUNCTION_ALIGNMENT_64B  << 
1625         default 32 if FUNCTION_ALIGNMENT_32B  << 
1626         default 16 if FUNCTION_ALIGNMENT_16B  << 
1627         default 8 if FUNCTION_ALIGNMENT_8B    << 
1628         default 4 if FUNCTION_ALIGNMENT_4B    << 
1629         default 0                             << 
1630                                               << 
1631 config CC_HAS_MIN_FUNCTION_ALIGNMENT          << 
1632         # Detect availability of the GCC opti << 
1633         # guarantees minimal alignment for al << 
1634         # -falign-functions which the compile << 
1635         def_bool $(cc-option, -fmin-function- << 
1636                                               << 
1637 config CC_HAS_SANE_FUNCTION_ALIGNMENT         << 
1638         # Set if the guaranteed alignment wit << 
1639         # available or extra care is required << 
1640         # strict alignment always, even with  << 
1641         def_bool CC_HAS_MIN_FUNCTION_ALIGNMEN << 
1642                                               << 
1643 config ARCH_NEED_CMPXCHG_1_EMU                << 
1644         bool                                  << 
1645                                                  1196 
1646 endmenu                                          1197 endmenu
                                                      

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

sflogo.php