~ [ 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-4.18.20)


  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 config CRASH_CORE
  7 # Note: arch/$(SRCARCH)/Kconfig needs to be in << 
  8 # override the default values in this file.    << 
  9 #                                              << 
 10 source "arch/$(SRCARCH)/Kconfig"               << 
 11                                                << 
 12 config ARCH_CONFIGURES_CPU_MITIGATIONS         << 
 13         bool                                        7         bool
 14                                                     8 
 15 if !ARCH_CONFIGURES_CPU_MITIGATIONS            !!   9 config KEXEC_CORE
 16 config CPU_MITIGATIONS                         !!  10         select CRASH_CORE
 17         def_bool y                             << 
 18 endif                                          << 
 19                                                << 
 20 menu "General architecture-dependent options"  << 
 21                                                << 
 22 config ARCH_HAS_SUBPAGE_FAULTS                 << 
 23         bool                                       11         bool
 24         help                                   << 
 25           Select if the architecture can check << 
 26           granularity (e.g. arm64 MTE). The pr << 
 27           must be implemented.                 << 
 28                                                    12 
 29 config HOTPLUG_SMT                             !!  13 config HAVE_IMA_KEXEC
 30         bool                                       14         bool
 31                                                    15 
 32 config SMT_NUM_THREADS_DYNAMIC                 !!  16 config HOTPLUG_SMT
 33         bool                                       17         bool
 34                                                    18 
 35 # Selected by HOTPLUG_CORE_SYNC_DEAD or HOTPLU !!  19 config OPROFILE
 36 config HOTPLUG_CORE_SYNC                       !!  20         tristate "OProfile system profiling"
 37         bool                                   !!  21         depends on PROFILING
                                                   >>  22         depends on HAVE_OPROFILE
                                                   >>  23         select RING_BUFFER
                                                   >>  24         select RING_BUFFER_ALLOW_SWAP
                                                   >>  25         help
                                                   >>  26           OProfile is a profiling system capable of profiling the
                                                   >>  27           whole system, include the kernel, kernel modules, libraries,
                                                   >>  28           and applications.
 38                                                    29 
 39 # Basic CPU dead synchronization selected by a !!  30           If unsure, say N.
 40 config HOTPLUG_CORE_SYNC_DEAD                  << 
 41         bool                                   << 
 42         select HOTPLUG_CORE_SYNC               << 
 43                                                    31 
 44 # Full CPU synchronization with alive state se !!  32 config OPROFILE_EVENT_MULTIPLEX
 45 config HOTPLUG_CORE_SYNC_FULL                  !!  33         bool "OProfile multiplexing support (EXPERIMENTAL)"
 46         bool                                   !!  34         default n
 47         select HOTPLUG_CORE_SYNC_DEAD if HOTPL !!  35         depends on OPROFILE && X86
 48         select HOTPLUG_CORE_SYNC               !!  36         help
                                                   >>  37           The number of hardware counters is limited. The multiplexing
                                                   >>  38           feature enables OProfile to gather more events than counters
                                                   >>  39           are provided by the hardware. This is realized by switching
                                                   >>  40           between events at a user specified time interval.
 49                                                    41 
 50 config HOTPLUG_SPLIT_STARTUP                   !!  42           If unsure, say N.
 51         bool                                   << 
 52         select HOTPLUG_CORE_SYNC_FULL          << 
 53                                                    43 
 54 config HOTPLUG_PARALLEL                        !!  44 config HAVE_OPROFILE
 55         bool                                       45         bool
 56         select HOTPLUG_SPLIT_STARTUP           << 
 57                                                    46 
 58 config GENERIC_ENTRY                           !!  47 config OPROFILE_NMI_TIMER
 59         bool                                   !!  48         def_bool y
                                                   >>  49         depends on PERF_EVENTS && HAVE_PERF_EVENTS_NMI && !PPC64
 60                                                    50 
 61 config KPROBES                                     51 config KPROBES
 62         bool "Kprobes"                             52         bool "Kprobes"
                                                   >>  53         depends on MODULES
 63         depends on HAVE_KPROBES                    54         depends on HAVE_KPROBES
 64         select KALLSYMS                            55         select KALLSYMS
 65         select EXECMEM                         << 
 66         select NEED_TASKS_RCU                  << 
 67         help                                       56         help
 68           Kprobes allows you to trap at almost     57           Kprobes allows you to trap at almost any kernel address and
 69           execute a callback function.  regist     58           execute a callback function.  register_kprobe() establishes
 70           a probepoint and specifies the callb     59           a probepoint and specifies the callback.  Kprobes is useful
 71           for kernel debugging, non-intrusive      60           for kernel debugging, non-intrusive instrumentation and testing.
 72           If in doubt, say "N".                    61           If in doubt, say "N".
 73                                                    62 
 74 config JUMP_LABEL                                  63 config JUMP_LABEL
 75         bool "Optimize very unlikely/likely br !!  64        bool "Optimize very unlikely/likely branches"
 76         depends on HAVE_ARCH_JUMP_LABEL        !!  65        depends on HAVE_ARCH_JUMP_LABEL
 77         select OBJTOOL if HAVE_JUMP_LABEL_HACK !!  66        help
 78         help                                   !!  67          This option enables a transparent branch optimization that
 79           This option enables a transparent br !!  68          makes certain almost-always-true or almost-always-false branch
 80           makes certain almost-always-true or  !!  69          conditions even cheaper to execute within the kernel.
 81           conditions even cheaper to execute w !!  70 
 82                                                !!  71          Certain performance-sensitive kernel code, such as trace points,
 83           Certain performance-sensitive kernel !!  72          scheduler functionality, networking code and KVM have such
 84           scheduler functionality, networking  !!  73          branches and include support for this optimization technique.
 85           branches and include support for thi !!  74 
 86                                                !!  75          If it is detected that the compiler has support for "asm goto",
 87           If it is detected that the compiler  !!  76          the kernel will compile such branches with just a nop
 88           the kernel will compile such branche !!  77          instruction. When the condition flag is toggled to true, the
 89           instruction. When the condition flag !!  78          nop will be converted to a jump instruction to execute the
 90           nop will be converted to a jump inst !!  79          conditional block of instructions.
 91           conditional block of instructions.   !!  80 
 92                                                !!  81          This technique lowers overhead and stress on the branch prediction
 93           This technique lowers overhead and s !!  82          of the processor and generally makes the kernel faster. The update
 94           of the processor and generally makes !!  83          of the condition is slower, but those are always very rare.
 95           of the condition is slower, but thos << 
 96                                                    84 
 97           ( On 32-bit x86, the necessary optio !!  85          ( On 32-bit x86, the necessary options added to the compiler
 98             flags may increase the size of the !!  86            flags may increase the size of the kernel slightly. )
 99                                                    87 
100 config STATIC_KEYS_SELFTEST                        88 config STATIC_KEYS_SELFTEST
101         bool "Static key selftest"                 89         bool "Static key selftest"
102         depends on JUMP_LABEL                      90         depends on JUMP_LABEL
103         help                                       91         help
104           Boot time self-test of the branch pa     92           Boot time self-test of the branch patching code.
105                                                    93 
106 config STATIC_CALL_SELFTEST                    << 
107         bool "Static call selftest"            << 
108         depends on HAVE_STATIC_CALL            << 
109         help                                   << 
110           Boot time self-test of the call patc << 
111                                                << 
112 config OPTPROBES                                   94 config OPTPROBES
113         def_bool y                                 95         def_bool y
114         depends on KPROBES && HAVE_OPTPROBES       96         depends on KPROBES && HAVE_OPTPROBES
115         select NEED_TASKS_RCU                  !!  97         select TASKS_RCU if PREEMPT
116                                                    98 
117 config KPROBES_ON_FTRACE                           99 config KPROBES_ON_FTRACE
118         def_bool y                                100         def_bool y
119         depends on KPROBES && HAVE_KPROBES_ON_    101         depends on KPROBES && HAVE_KPROBES_ON_FTRACE
120         depends on DYNAMIC_FTRACE_WITH_REGS       102         depends on DYNAMIC_FTRACE_WITH_REGS
121         help                                      103         help
122           If function tracer is enabled and th !! 104          If function tracer is enabled and the arch supports full
123           passing of pt_regs to function traci !! 105          passing of pt_regs to function tracing, then kprobes can
124           optimize on top of function tracing. !! 106          optimize on top of function tracing.
125                                                   107 
126 config UPROBES                                    108 config UPROBES
127         def_bool n                                109         def_bool n
128         depends on ARCH_SUPPORTS_UPROBES          110         depends on ARCH_SUPPORTS_UPROBES
129         help                                      111         help
130           Uprobes is the user-space counterpar    112           Uprobes is the user-space counterpart to kprobes: they
131           enable instrumentation applications     113           enable instrumentation applications (such as 'perf probe')
132           to establish unintrusive probes in u    114           to establish unintrusive probes in user-space binaries and
133           libraries, by executing handler func    115           libraries, by executing handler functions when the probes
134           are hit by user-space applications.     116           are hit by user-space applications.
135                                                   117 
136           ( These probes come in the form of s    118           ( These probes come in the form of single-byte breakpoints,
137             managed by the kernel and kept tra    119             managed by the kernel and kept transparent to the probed
138             application. )                        120             application. )
139                                                   121 
140 config HAVE_64BIT_ALIGNED_ACCESS                  122 config HAVE_64BIT_ALIGNED_ACCESS
141         def_bool 64BIT && !HAVE_EFFICIENT_UNAL    123         def_bool 64BIT && !HAVE_EFFICIENT_UNALIGNED_ACCESS
142         help                                      124         help
143           Some architectures require 64 bit ac    125           Some architectures require 64 bit accesses to be 64 bit
144           aligned, which also requires structs    126           aligned, which also requires structs containing 64 bit values
145           to be 64 bit aligned too. This inclu    127           to be 64 bit aligned too. This includes some 32 bit
146           architectures which can do 64 bit ac    128           architectures which can do 64 bit accesses, as well as 64 bit
147           architectures without unaligned acce    129           architectures without unaligned access.
148                                                   130 
149           This symbol should be selected by an    131           This symbol should be selected by an architecture if 64 bit
150           accesses are required to be 64 bit a    132           accesses are required to be 64 bit aligned in this way even
151           though it is not a 64 bit architectu    133           though it is not a 64 bit architecture.
152                                                   134 
153           See Documentation/core-api/unaligned !! 135           See Documentation/unaligned-memory-access.txt for more
154           more information on the topic of una !! 136           information on the topic of unaligned memory accesses.
155                                                   137 
156 config HAVE_EFFICIENT_UNALIGNED_ACCESS            138 config HAVE_EFFICIENT_UNALIGNED_ACCESS
157         bool                                      139         bool
158         help                                      140         help
159           Some architectures are unable to per    141           Some architectures are unable to perform unaligned accesses
160           without the use of get_unaligned/put    142           without the use of get_unaligned/put_unaligned. Others are
161           unable to perform such accesses effi    143           unable to perform such accesses efficiently (e.g. trap on
162           unaligned access and require fixing     144           unaligned access and require fixing it up in the exception
163           handler.)                               145           handler.)
164                                                   146 
165           This symbol should be selected by an    147           This symbol should be selected by an architecture if it can
166           perform unaligned accesses efficient    148           perform unaligned accesses efficiently to allow different
167           code paths to be selected for these     149           code paths to be selected for these cases. Some network
168           drivers, for example, could opt to n    150           drivers, for example, could opt to not fix up alignment
169           problems with received packets if do    151           problems with received packets if doing so would not help
170           much.                                   152           much.
171                                                   153 
172           See Documentation/core-api/unaligned !! 154           See Documentation/unaligned-memory-access.txt for more
173           information on the topic of unaligne    155           information on the topic of unaligned memory accesses.
174                                                   156 
175 config ARCH_USE_BUILTIN_BSWAP                     157 config ARCH_USE_BUILTIN_BSWAP
176         bool                                   !! 158        bool
177         help                                   !! 159        help
178           Modern versions of GCC (since 4.4) h !! 160          Modern versions of GCC (since 4.4) have builtin functions
179           for handling byte-swapping. Using th !! 161          for handling byte-swapping. Using these, instead of the old
180           inline assembler that the architectu !! 162          inline assembler that the architecture code provides in the
181           __arch_bswapXX() macros, allows the  !! 163          __arch_bswapXX() macros, allows the compiler to see what's
182           happening and offers more opportunit !! 164          happening and offers more opportunity for optimisation. In
183           particular, the compiler will be abl !! 165          particular, the compiler will be able to combine the byteswap
184           with a nearby load or store and use  !! 166          with a nearby load or store and use load-and-swap or
185           store-and-swap instructions if the a !! 167          store-and-swap instructions if the architecture has them. It
186           should almost *never* result in code !! 168          should almost *never* result in code which is worse than the
187           hand-coded assembler in <asm/swab.h> !! 169          hand-coded assembler in <asm/swab.h>.  But just in case it
188           does, the use of the builtins is opt !! 170          does, the use of the builtins is optional.
189                                                !! 171 
190           Any architecture with load-and-swap  !! 172          Any architecture with load-and-swap or store-and-swap
191           instructions should set this. And it !! 173          instructions should set this. And it shouldn't hurt to set it
192           on architectures that don't have suc !! 174          on architectures that don't have such instructions.
193                                                   175 
194 config KRETPROBES                                 176 config KRETPROBES
195         def_bool y                                177         def_bool y
196         depends on KPROBES && (HAVE_KRETPROBES !! 178         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                                                   179 
204 config USER_RETURN_NOTIFIER                       180 config USER_RETURN_NOTIFIER
205         bool                                      181         bool
206         depends on HAVE_USER_RETURN_NOTIFIER      182         depends on HAVE_USER_RETURN_NOTIFIER
207         help                                      183         help
208           Provide a kernel-internal notificati    184           Provide a kernel-internal notification when a cpu is about to
209           switch to user mode.                    185           switch to user mode.
210                                                   186 
211 config HAVE_IOREMAP_PROT                          187 config HAVE_IOREMAP_PROT
212         bool                                      188         bool
213                                                   189 
214 config HAVE_KPROBES                               190 config HAVE_KPROBES
215         bool                                      191         bool
216                                                   192 
217 config HAVE_KRETPROBES                            193 config HAVE_KRETPROBES
218         bool                                      194         bool
219                                                   195 
220 config HAVE_OPTPROBES                             196 config HAVE_OPTPROBES
221         bool                                      197         bool
222                                                   198 
223 config HAVE_KPROBES_ON_FTRACE                     199 config HAVE_KPROBES_ON_FTRACE
224         bool                                      200         bool
225                                                   201 
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              202 config HAVE_FUNCTION_ERROR_INJECTION
235         bool                                      203         bool
236                                                   204 
237 config HAVE_NMI                                   205 config HAVE_NMI
238         bool                                      206         bool
239                                                   207 
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 #                                                 208 #
250 # An arch should select this if it provides al    209 # An arch should select this if it provides all these things:
251 #                                                 210 #
252 #       task_pt_regs()          in asm/process    211 #       task_pt_regs()          in asm/processor.h or asm/ptrace.h
253 #       arch_has_single_step()  if there is ha    212 #       arch_has_single_step()  if there is hardware single-step support
254 #       arch_has_block_step()   if there is ha    213 #       arch_has_block_step()   if there is hardware block-step support
255 #       asm/syscall.h           supplying asm-    214 #       asm/syscall.h           supplying asm-generic/syscall.h interface
256 #       linux/regset.h          user_regset in    215 #       linux/regset.h          user_regset interfaces
257 #       CORE_DUMP_USE_REGSET    #define'd in l    216 #       CORE_DUMP_USE_REGSET    #define'd in linux/elf.h
258 #       TIF_SYSCALL_TRACE       calls ptrace_r !! 217 #       TIF_SYSCALL_TRACE       calls tracehook_report_syscall_{entry,exit}
259 #       TIF_NOTIFY_RESUME       calls resume_u !! 218 #       TIF_NOTIFY_RESUME       calls tracehook_notify_resume()
                                                   >> 219 #       signal delivery         calls tracehook_signal_handler()
260 #                                                 220 #
261 config HAVE_ARCH_TRACEHOOK                        221 config HAVE_ARCH_TRACEHOOK
262         bool                                      222         bool
263                                                   223 
264 config HAVE_DMA_CONTIGUOUS                        224 config HAVE_DMA_CONTIGUOUS
265         bool                                      225         bool
266                                                   226 
267 config GENERIC_SMP_IDLE_THREAD                    227 config GENERIC_SMP_IDLE_THREAD
268         bool                                   !! 228        bool
269                                                   229 
270 config GENERIC_IDLE_POLL_SETUP                    230 config GENERIC_IDLE_POLL_SETUP
271         bool                                   !! 231        bool
272                                                   232 
273 config ARCH_HAS_FORTIFY_SOURCE                    233 config ARCH_HAS_FORTIFY_SOURCE
274         bool                                      234         bool
275         help                                      235         help
276           An architecture should select this w    236           An architecture should select this when it can successfully
277           build and run with CONFIG_FORTIFY_SO    237           build and run with CONFIG_FORTIFY_SOURCE.
278                                                   238 
279 #                                              << 
280 # Select if the arch provides a historic keepi << 
281 # command line option                          << 
282 #                                              << 
283 config ARCH_HAS_KEEPINITRD                     << 
284         bool                                   << 
285                                                << 
286 # Select if arch has all set_memory_ro/rw/x/nx    239 # Select if arch has all set_memory_ro/rw/x/nx() functions in asm/cacheflush.h
287 config ARCH_HAS_SET_MEMORY                        240 config ARCH_HAS_SET_MEMORY
288         bool                                      241         bool
289                                                   242 
290 # Select if arch has all set_direct_map_invali !! 243 # Select if arch init_task must go in the __init_task_data section
291 config ARCH_HAS_SET_DIRECT_MAP                 !! 244 config ARCH_TASK_STRUCT_ON_STACK
292         bool                                   !! 245        bool
293                                                << 
294 #                                              << 
295 # Select if the architecture provides the arch << 
296 # either provide an uncached segment alias for << 
297 # to remap the page tables in place.           << 
298 #                                              << 
299 config ARCH_HAS_DMA_SET_UNCACHED               << 
300         bool                                   << 
301                                                << 
302 #                                              << 
303 # Select if the architectures provides the arc << 
304 # to undo an in-place page table remap for unc << 
305 #                                              << 
306 config ARCH_HAS_DMA_CLEAR_UNCACHED             << 
307         bool                                   << 
308                                                   246 
309 config ARCH_HAS_CPU_FINALIZE_INIT              !! 247 # Select if arch has its private alloc_task_struct() function
                                                   >> 248 config ARCH_TASK_STRUCT_ALLOCATOR
310         bool                                      249         bool
311                                                   250 
312 # The architecture has a per-task state that i << 
313 config ARCH_HAS_CPU_PASID                      << 
314         bool                                   << 
315         select IOMMU_MM_DATA                   << 
316                                                << 
317 config HAVE_ARCH_THREAD_STRUCT_WHITELIST          251 config HAVE_ARCH_THREAD_STRUCT_WHITELIST
318         bool                                      252         bool
                                                   >> 253         depends on !ARCH_TASK_STRUCT_ALLOCATOR
319         help                                      254         help
320           An architecture should select this t    255           An architecture should select this to provide hardened usercopy
321           knowledge about what region of the t    256           knowledge about what region of the thread_struct should be
322           whitelisted for copying to userspace    257           whitelisted for copying to userspace. Normally this is only the
323           FPU registers. Specifically, arch_th    258           FPU registers. Specifically, arch_thread_struct_whitelist()
324           should be implemented. Without this,    259           should be implemented. Without this, the entire thread_struct
325           field in task_struct will be left wh    260           field in task_struct will be left whitelisted.
326                                                   261 
327 # Select if arch wants to size task_struct dyn !! 262 # Select if arch has its private alloc_thread_stack() function
328 config ARCH_WANTS_DYNAMIC_TASK_STRUCT          !! 263 config ARCH_THREAD_STACK_ALLOCATOR
329         bool                                   << 
330                                                << 
331 config ARCH_WANTS_NO_INSTR                     << 
332         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                                                << 
338 config ARCH_32BIT_OFF_T                        << 
339         bool                                      264         bool
340         depends on !64BIT                      << 
341         help                                   << 
342           All new 32-bit architectures should  << 
343           userspace side which corresponds to  << 
344           is the requirement for modern ABIs.  << 
345           still support 32-bit off_t. This opt << 
346           architectures explicitly.            << 
347                                                   265 
348 # Selected by 64 bit architectures which have  !! 266 # Select if arch wants to size task_struct dynamically via arch_task_struct_size:
349 config ARCH_32BIT_USTAT_F_TINODE               !! 267 config ARCH_WANTS_DYNAMIC_TASK_STRUCT
350         bool                                   << 
351                                                << 
352 config HAVE_ASM_MODVERSIONS                    << 
353         bool                                      268         bool
354         help                                   << 
355           This symbol should be selected by an << 
356           <asm/asm-prototypes.h> to support th << 
357           exported from assembly code.         << 
358                                                   269 
359 config HAVE_REGS_AND_STACK_ACCESS_API             270 config HAVE_REGS_AND_STACK_ACCESS_API
360         bool                                      271         bool
361         help                                      272         help
362           This symbol should be selected by an !! 273           This symbol should be selected by an architecure if it supports
363           the API needed to access registers a    274           the API needed to access registers and stack entries from pt_regs,
364           declared in asm/ptrace.h                275           declared in asm/ptrace.h
365           For example the kprobes-based event     276           For example the kprobes-based event tracer needs this API.
366                                                   277 
367 config HAVE_RSEQ                                  278 config HAVE_RSEQ
368         bool                                      279         bool
369         depends on HAVE_REGS_AND_STACK_ACCESS_    280         depends on HAVE_REGS_AND_STACK_ACCESS_API
370         help                                      281         help
371           This symbol should be selected by an    282           This symbol should be selected by an architecture if it
372           supports an implementation of restar    283           supports an implementation of restartable sequences.
373                                                   284 
374 config HAVE_RUST                               !! 285 config HAVE_CLK
375         bool                                   << 
376         help                                   << 
377           This symbol should be selected by an << 
378           supports Rust.                       << 
379                                                << 
380 config HAVE_FUNCTION_ARG_ACCESS_API            << 
381         bool                                      286         bool
382         help                                      287         help
383           This symbol should be selected by an !! 288           The <linux/clk.h> calls support software clock gating and
384           the API needed to access function ar !! 289           thus are a key power management tool on many systems.
385           declared in asm/ptrace.h             << 
386                                                   290 
387 config HAVE_HW_BREAKPOINT                         291 config HAVE_HW_BREAKPOINT
388         bool                                      292         bool
389         depends on PERF_EVENTS                    293         depends on PERF_EVENTS
390                                                   294 
391 config HAVE_MIXED_BREAKPOINTS_REGS                295 config HAVE_MIXED_BREAKPOINTS_REGS
392         bool                                      296         bool
393         depends on HAVE_HW_BREAKPOINT             297         depends on HAVE_HW_BREAKPOINT
394         help                                      298         help
395           Depending on the arch implementation    299           Depending on the arch implementation of hardware breakpoints,
396           some of them have separate registers    300           some of them have separate registers for data and instruction
397           breakpoints addresses, others have m    301           breakpoints addresses, others have mixed registers to store
398           them but define the access type in a    302           them but define the access type in a control register.
399           Select this option if your arch impl    303           Select this option if your arch implements breakpoints under the
400           latter fashion.                         304           latter fashion.
401                                                   305 
402 config HAVE_USER_RETURN_NOTIFIER                  306 config HAVE_USER_RETURN_NOTIFIER
403         bool                                      307         bool
404                                                   308 
405 config HAVE_PERF_EVENTS_NMI                       309 config HAVE_PERF_EVENTS_NMI
406         bool                                      310         bool
407         help                                      311         help
408           System hardware can generate an NMI     312           System hardware can generate an NMI using the perf event
409           subsystem.  Also has support for cal    313           subsystem.  Also has support for calculating CPU cycle events
410           to determine how many clock cycles i    314           to determine how many clock cycles in a given period.
411                                                   315 
412 config HAVE_HARDLOCKUP_DETECTOR_PERF              316 config HAVE_HARDLOCKUP_DETECTOR_PERF
413         bool                                      317         bool
414         depends on HAVE_PERF_EVENTS_NMI           318         depends on HAVE_PERF_EVENTS_NMI
415         help                                      319         help
416           The arch chooses to use the generic     320           The arch chooses to use the generic perf-NMI-based hardlockup
417           detector. Must define HAVE_PERF_EVEN    321           detector. Must define HAVE_PERF_EVENTS_NMI.
418                                                   322 
419 config HAVE_HARDLOCKUP_DETECTOR_ARCH           !! 323 config HAVE_NMI_WATCHDOG
                                                   >> 324         depends on HAVE_NMI
420         bool                                      325         bool
421         help                                      326         help
422           The arch provides its own hardlockup !! 327           The arch provides a low level NMI watchdog. It provides
423           of the generic ones.                 !! 328           asm/nmi.h, and defines its own arch_touch_nmi_watchdog().
424                                                   329 
425           It uses the same command line parame !! 330 config HAVE_HARDLOCKUP_DETECTOR_ARCH
426           as the generic hardlockup detectors. !! 331         bool
                                                   >> 332         select HAVE_NMI_WATCHDOG
                                                   >> 333         help
                                                   >> 334           The arch chooses to provide its own hardlockup detector, which is
                                                   >> 335           a superset of the HAVE_NMI_WATCHDOG. It also conforms to config
                                                   >> 336           interfaces and parameters provided by hardlockup detector subsystem.
427                                                   337 
428 config HAVE_PERF_REGS                             338 config HAVE_PERF_REGS
429         bool                                      339         bool
430         help                                      340         help
431           Support selective register dumps for    341           Support selective register dumps for perf events. This includes
432           bit-mapping of each registers and a     342           bit-mapping of each registers and a unique architecture id.
433                                                   343 
434 config HAVE_PERF_USER_STACK_DUMP                  344 config HAVE_PERF_USER_STACK_DUMP
435         bool                                      345         bool
436         help                                      346         help
437           Support user stack dumps for perf ev    347           Support user stack dumps for perf event samples. This needs
438           access to the user stack pointer whi    348           access to the user stack pointer which is not unified across
439           architectures.                          349           architectures.
440                                                   350 
441 config HAVE_ARCH_JUMP_LABEL                       351 config HAVE_ARCH_JUMP_LABEL
442         bool                                      352         bool
443                                                   353 
444 config HAVE_ARCH_JUMP_LABEL_RELATIVE           !! 354 config HAVE_RCU_TABLE_FREE
445         bool                                   << 
446                                                << 
447 config MMU_GATHER_TABLE_FREE                   << 
448         bool                                   << 
449                                                << 
450 config MMU_GATHER_RCU_TABLE_FREE               << 
451         bool                                   << 
452         select MMU_GATHER_TABLE_FREE           << 
453                                                << 
454 config MMU_GATHER_PAGE_SIZE                    << 
455         bool                                   << 
456                                                << 
457 config MMU_GATHER_NO_RANGE                     << 
458         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                                                << 
467 config MMU_GATHER_NO_GATHER                    << 
468         bool                                      355         bool
469         depends on MMU_GATHER_TABLE_FREE       << 
470                                                   356 
471 config ARCH_WANT_IRQS_OFF_ACTIVATE_MM          !! 357 config HAVE_RCU_TABLE_INVALIDATE
472         bool                                   << 
473         help                                   << 
474           Temporary select until all architect << 
475           irqs disabled over activate_mm. Arch << 
476           shootdowns should enable this.       << 
477                                                << 
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                                      358         bool
509                                                   359 
510 config ARCH_HAVE_NMI_SAFE_CMPXCHG                 360 config ARCH_HAVE_NMI_SAFE_CMPXCHG
511         bool                                      361         bool
512                                                   362 
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                   363 config HAVE_ALIGNED_STRUCT_PAGE
526         bool                                      364         bool
527         help                                      365         help
528           This makes sure that struct pages ar    366           This makes sure that struct pages are double word aligned and that
529           e.g. the SLUB allocator can perform     367           e.g. the SLUB allocator can perform double word atomic operations
530           on a struct page for better performa    368           on a struct page for better performance. However selecting this
531           might increase the size of a struct     369           might increase the size of a struct page by a word.
532                                                   370 
533 config HAVE_CMPXCHG_LOCAL                         371 config HAVE_CMPXCHG_LOCAL
534         bool                                      372         bool
535                                                   373 
536 config HAVE_CMPXCHG_DOUBLE                        374 config HAVE_CMPXCHG_DOUBLE
537         bool                                      375         bool
538                                                   376 
539 config ARCH_WEAK_RELEASE_ACQUIRE                  377 config ARCH_WEAK_RELEASE_ACQUIRE
540         bool                                      378         bool
541                                                   379 
542 config ARCH_WANT_IPC_PARSE_VERSION                380 config ARCH_WANT_IPC_PARSE_VERSION
543         bool                                      381         bool
544                                                   382 
545 config ARCH_WANT_COMPAT_IPC_PARSE_VERSION         383 config ARCH_WANT_COMPAT_IPC_PARSE_VERSION
546         bool                                      384         bool
547                                                   385 
548 config ARCH_WANT_OLD_COMPAT_IPC                   386 config ARCH_WANT_OLD_COMPAT_IPC
549         select ARCH_WANT_COMPAT_IPC_PARSE_VERS    387         select ARCH_WANT_COMPAT_IPC_PARSE_VERSION
550         bool                                      388         bool
551                                                   389 
552 config HAVE_ARCH_SECCOMP                       << 
553         bool                                   << 
554         help                                   << 
555           An arch should select this symbol to << 
556           syscall policy), and must provide an << 
557           and compat syscalls if the asm-gener << 
558           - __NR_seccomp_read_32               << 
559           - __NR_seccomp_write_32              << 
560           - __NR_seccomp_exit_32               << 
561           - __NR_seccomp_sigreturn_32          << 
562                                                << 
563 config HAVE_ARCH_SECCOMP_FILTER                   390 config HAVE_ARCH_SECCOMP_FILTER
564         bool                                      391         bool
565         select HAVE_ARCH_SECCOMP               << 
566         help                                      392         help
567           An arch should select this symbol if    393           An arch should select this symbol if it provides all of these things:
568           - all the requirements for HAVE_ARCH << 
569           - syscall_get_arch()                    394           - syscall_get_arch()
570           - syscall_get_arguments()               395           - syscall_get_arguments()
571           - syscall_rollback()                    396           - syscall_rollback()
572           - syscall_set_return_value()            397           - syscall_set_return_value()
573           - SIGSYS siginfo_t support              398           - SIGSYS siginfo_t support
574           - secure_computing is called from a     399           - secure_computing is called from a ptrace_event()-safe context
575           - secure_computing return value is c    400           - secure_computing return value is checked and a return value of -1
576             results in the system call being s    401             results in the system call being skipped immediately.
577           - seccomp syscall wired up              402           - seccomp syscall wired up
578           - if !HAVE_SPARSE_SYSCALL_NR, have S << 
579             SECCOMP_ARCH_NATIVE_NR, SECCOMP_AR << 
580             COMPAT is supported, have the SECC << 
581                                                << 
582 config SECCOMP                                 << 
583         prompt "Enable seccomp to safely execu << 
584         def_bool y                             << 
585         depends on HAVE_ARCH_SECCOMP           << 
586         help                                   << 
587           This kernel feature is useful for nu << 
588           that may need to handle untrusted by << 
589           execution. By using pipes or other t << 
590           to the process as file descriptors s << 
591           syscalls, it's possible to isolate t << 
592           own address space using seccomp. Onc << 
593           prctl(PR_SET_SECCOMP) or the seccomp << 
594           disabled and the task is only allowe << 
595           syscalls defined by each seccomp mod << 
596                                                << 
597           If unsure, say Y.                    << 
598                                                   403 
599 config SECCOMP_FILTER                             404 config SECCOMP_FILTER
600         def_bool y                                405         def_bool y
601         depends on HAVE_ARCH_SECCOMP_FILTER &&    406         depends on HAVE_ARCH_SECCOMP_FILTER && SECCOMP && NET
602         help                                      407         help
603           Enable tasks to build secure computi    408           Enable tasks to build secure computing environments defined
604           in terms of Berkeley Packet Filter p    409           in terms of Berkeley Packet Filter programs which implement
605           task-defined system call filtering p    410           task-defined system call filtering polices.
606                                                   411 
607           See Documentation/userspace-api/secc    412           See Documentation/userspace-api/seccomp_filter.rst for details.
608                                                   413 
609 config SECCOMP_CACHE_DEBUG                     !! 414 preferred-plugin-hostcc := $(if-success,[ $(gcc-version) -ge 40800 ],$(HOSTCXX),$(HOSTCC))
610         bool "Show seccomp filter cache status << 
611         depends on SECCOMP_FILTER && !HAVE_SPA << 
612         depends on PROC_FS                     << 
613         help                                   << 
614           This enables the /proc/pid/seccomp_c << 
615           seccomp cache data. The file format  << 
616           the file requires CAP_SYS_ADMIN.     << 
617                                                   415 
618           This option is for debugging only. E !! 416 config PLUGIN_HOSTCC
619           an adversary may be able to infer th !! 417         string
                                                   >> 418         default "$(shell,$(srctree)/scripts/gcc-plugin.sh "$(preferred-plugin-hostcc)" "$(HOSTCXX)" "$(CC)")"
                                                   >> 419         help
                                                   >> 420           Host compiler used to build GCC plugins.  This can be $(HOSTCXX),
                                                   >> 421           $(HOSTCC), or a null string if GCC plugin is unsupported.
620                                                   422 
621           If unsure, say N.                    !! 423 config HAVE_GCC_PLUGINS
                                                   >> 424         bool
                                                   >> 425         help
                                                   >> 426           An arch should select this symbol if it supports building with
                                                   >> 427           GCC plugins.
                                                   >> 428 
                                                   >> 429 menuconfig GCC_PLUGINS
                                                   >> 430         bool "GCC plugins"
                                                   >> 431         depends on HAVE_GCC_PLUGINS
                                                   >> 432         depends on PLUGIN_HOSTCC != ""
                                                   >> 433         help
                                                   >> 434           GCC plugins are loadable modules that provide extra features to the
                                                   >> 435           compiler. They are useful for runtime instrumentation and static analysis.
                                                   >> 436 
                                                   >> 437           See Documentation/gcc-plugins.txt for details.
622                                                   438 
623 config HAVE_ARCH_STACKLEAK                     !! 439 config GCC_PLUGIN_CYC_COMPLEXITY
                                                   >> 440         bool "Compute the cyclomatic complexity of a function" if EXPERT
                                                   >> 441         depends on GCC_PLUGINS
                                                   >> 442         depends on !COMPILE_TEST        # too noisy
                                                   >> 443         help
                                                   >> 444           The complexity M of a function's control flow graph is defined as:
                                                   >> 445            M = E - N + 2P
                                                   >> 446           where
                                                   >> 447 
                                                   >> 448           E = the number of edges
                                                   >> 449           N = the number of nodes
                                                   >> 450           P = the number of connected components (exit nodes).
                                                   >> 451 
                                                   >> 452           Enabling this plugin reports the complexity to stderr during the
                                                   >> 453           build. It mainly serves as a simple example of how to create a
                                                   >> 454           gcc plugin for the kernel.
                                                   >> 455 
                                                   >> 456 config GCC_PLUGIN_SANCOV
624         bool                                      457         bool
                                                   >> 458         depends on GCC_PLUGINS
                                                   >> 459         help
                                                   >> 460           This plugin inserts a __sanitizer_cov_trace_pc() call at the start of
                                                   >> 461           basic blocks. It supports all gcc versions with plugin support (from
                                                   >> 462           gcc-4.5 on). It is based on the commit "Add fuzzing coverage support"
                                                   >> 463           by Dmitry Vyukov <dvyukov@google.com>.
                                                   >> 464 
                                                   >> 465 config GCC_PLUGIN_LATENT_ENTROPY
                                                   >> 466         bool "Generate some entropy during boot and runtime"
                                                   >> 467         depends on GCC_PLUGINS
625         help                                      468         help
626           An architecture should select this i !! 469           By saying Y here the kernel will instrument some kernel code to
627           fills the used part of the kernel st !! 470           extract some entropy from both original and artificially created
628           value before returning from system c !! 471           program state.  This will help especially embedded systems where
                                                   >> 472           there is little 'natural' source of entropy normally.  The cost
                                                   >> 473           is some slowdown of the boot process (about 0.5%) and fork and
                                                   >> 474           irq processing.
                                                   >> 475 
                                                   >> 476           Note that entropy extracted this way is not cryptographically
                                                   >> 477           secure!
                                                   >> 478 
                                                   >> 479           This plugin was ported from grsecurity/PaX. More information at:
                                                   >> 480            * https://grsecurity.net/
                                                   >> 481            * https://pax.grsecurity.net/
                                                   >> 482 
                                                   >> 483 config GCC_PLUGIN_STRUCTLEAK
                                                   >> 484         bool "Force initialization of variables containing userspace addresses"
                                                   >> 485         depends on GCC_PLUGINS
                                                   >> 486         # Currently STRUCTLEAK inserts initialization out of live scope of
                                                   >> 487         # variables from KASAN point of view. This leads to KASAN false
                                                   >> 488         # positive reports. Prohibit this combination for now.
                                                   >> 489         depends on !KASAN_EXTRA
                                                   >> 490         help
                                                   >> 491           This plugin zero-initializes any structures containing a
                                                   >> 492           __user attribute. This can prevent some classes of information
                                                   >> 493           exposures.
                                                   >> 494 
                                                   >> 495           This plugin was ported from grsecurity/PaX. More information at:
                                                   >> 496            * https://grsecurity.net/
                                                   >> 497            * https://pax.grsecurity.net/
                                                   >> 498 
                                                   >> 499 config GCC_PLUGIN_STRUCTLEAK_BYREF_ALL
                                                   >> 500         bool "Force initialize all struct type variables passed by reference"
                                                   >> 501         depends on GCC_PLUGIN_STRUCTLEAK
                                                   >> 502         depends on !COMPILE_TEST
                                                   >> 503         help
                                                   >> 504           Zero initialize any struct type local variable that may be passed by
                                                   >> 505           reference without having been initialized.
                                                   >> 506 
                                                   >> 507 config GCC_PLUGIN_STRUCTLEAK_VERBOSE
                                                   >> 508         bool "Report forcefully initialized variables"
                                                   >> 509         depends on GCC_PLUGIN_STRUCTLEAK
                                                   >> 510         depends on !COMPILE_TEST        # too noisy
                                                   >> 511         help
                                                   >> 512           This option will cause a warning to be printed each time the
                                                   >> 513           structleak plugin finds a variable it thinks needs to be
                                                   >> 514           initialized. Since not all existing initializers are detected
                                                   >> 515           by the plugin, this can produce false positive warnings.
                                                   >> 516 
                                                   >> 517 config GCC_PLUGIN_RANDSTRUCT
                                                   >> 518         bool "Randomize layout of sensitive kernel structures"
                                                   >> 519         depends on GCC_PLUGINS
                                                   >> 520         select MODVERSIONS if MODULES
                                                   >> 521         help
                                                   >> 522           If you say Y here, the layouts of structures that are entirely
                                                   >> 523           function pointers (and have not been manually annotated with
                                                   >> 524           __no_randomize_layout), or structures that have been explicitly
                                                   >> 525           marked with __randomize_layout, will be randomized at compile-time.
                                                   >> 526           This can introduce the requirement of an additional information
                                                   >> 527           exposure vulnerability for exploits targeting these structure
                                                   >> 528           types.
                                                   >> 529 
                                                   >> 530           Enabling this feature will introduce some performance impact,
                                                   >> 531           slightly increase memory usage, and prevent the use of forensic
                                                   >> 532           tools like Volatility against the system (unless the kernel
                                                   >> 533           source tree isn't cleaned after kernel installation).
                                                   >> 534 
                                                   >> 535           The seed used for compilation is located at
                                                   >> 536           scripts/gcc-plgins/randomize_layout_seed.h.  It remains after
                                                   >> 537           a make clean to allow for external modules to be compiled with
                                                   >> 538           the existing seed and will be removed by a make mrproper or
                                                   >> 539           make distclean.
                                                   >> 540 
                                                   >> 541           Note that the implementation requires gcc 4.7 or newer.
                                                   >> 542 
                                                   >> 543           This plugin was ported from grsecurity/PaX. More information at:
                                                   >> 544            * https://grsecurity.net/
                                                   >> 545            * https://pax.grsecurity.net/
                                                   >> 546 
                                                   >> 547 config GCC_PLUGIN_RANDSTRUCT_PERFORMANCE
                                                   >> 548         bool "Use cacheline-aware structure randomization"
                                                   >> 549         depends on GCC_PLUGIN_RANDSTRUCT
                                                   >> 550         depends on !COMPILE_TEST        # do not reduce test coverage
                                                   >> 551         help
                                                   >> 552           If you say Y here, the RANDSTRUCT randomization will make a
                                                   >> 553           best effort at restricting randomization to cacheline-sized
                                                   >> 554           groups of elements.  It will further not randomize bitfields
                                                   >> 555           in structures.  This reduces the performance hit of RANDSTRUCT
                                                   >> 556           at the cost of weakened randomization.
629                                                   557 
630 config HAVE_STACKPROTECTOR                        558 config HAVE_STACKPROTECTOR
631         bool                                      559         bool
632         help                                      560         help
633           An arch should select this symbol if    561           An arch should select this symbol if:
634           - it has implemented a stack canary     562           - it has implemented a stack canary (e.g. __stack_chk_guard)
635                                                   563 
                                                   >> 564 config CC_HAS_STACKPROTECTOR_NONE
                                                   >> 565         def_bool $(cc-option,-fno-stack-protector)
                                                   >> 566 
636 config STACKPROTECTOR                             567 config STACKPROTECTOR
637         bool "Stack Protector buffer overflow     568         bool "Stack Protector buffer overflow detection"
638         depends on HAVE_STACKPROTECTOR            569         depends on HAVE_STACKPROTECTOR
639         depends on $(cc-option,-fstack-protect    570         depends on $(cc-option,-fstack-protector)
640         default y                                 571         default y
641         help                                      572         help
642           This option turns on the "stack-prot    573           This option turns on the "stack-protector" GCC feature. This
643           feature puts, at the beginning of fu    574           feature puts, at the beginning of functions, a canary value on
644           the stack just before the return add    575           the stack just before the return address, and validates
645           the value just before actually retur    576           the value just before actually returning.  Stack based buffer
646           overflows (that need to overwrite th    577           overflows (that need to overwrite this return address) now also
647           overwrite the canary, which gets det    578           overwrite the canary, which gets detected and the attack is then
648           neutralized via a kernel panic.         579           neutralized via a kernel panic.
649                                                   580 
650           Functions will have the stack-protec    581           Functions will have the stack-protector canary logic added if they
651           have an 8-byte or larger character a    582           have an 8-byte or larger character array on the stack.
652                                                   583 
653           This feature requires gcc version 4.    584           This feature requires gcc version 4.2 or above, or a distribution
654           gcc with the feature backported ("-f    585           gcc with the feature backported ("-fstack-protector").
655                                                   586 
656           On an x86 "defconfig" build, this fe    587           On an x86 "defconfig" build, this feature adds canary checks to
657           about 3% of all kernel functions, wh    588           about 3% of all kernel functions, which increases kernel code size
658           by about 0.3%.                          589           by about 0.3%.
659                                                   590 
660 config STACKPROTECTOR_STRONG                      591 config STACKPROTECTOR_STRONG
661         bool "Strong Stack Protector"             592         bool "Strong Stack Protector"
662         depends on STACKPROTECTOR                 593         depends on STACKPROTECTOR
663         depends on $(cc-option,-fstack-protect    594         depends on $(cc-option,-fstack-protector-strong)
664         default y                                 595         default y
665         help                                      596         help
666           Functions will have the stack-protec    597           Functions will have the stack-protector canary logic added in any
667           of the following conditions:            598           of the following conditions:
668                                                   599 
669           - local variable's address used as p    600           - local variable's address used as part of the right hand side of an
670             assignment or function argument       601             assignment or function argument
671           - local variable is an array (or uni    602           - local variable is an array (or union containing an array),
672             regardless of array type or length    603             regardless of array type or length
673           - uses register local variables         604           - uses register local variables
674                                                   605 
675           This feature requires gcc version 4.    606           This feature requires gcc version 4.9 or above, or a distribution
676           gcc with the feature backported ("-f    607           gcc with the feature backported ("-fstack-protector-strong").
677                                                   608 
678           On an x86 "defconfig" build, this fe    609           On an x86 "defconfig" build, this feature adds canary checks to
679           about 20% of all kernel functions, w    610           about 20% of all kernel functions, which increases the kernel code
680           size by about 2%.                       611           size by about 2%.
681                                                   612 
682 config ARCH_SUPPORTS_SHADOW_CALL_STACK         << 
683         bool                                   << 
684         help                                   << 
685           An architecture should select this i << 
686           Shadow Call Stack and implements run << 
687           switching.                           << 
688                                                << 
689 config SHADOW_CALL_STACK                       << 
690         bool "Shadow Call Stack"               << 
691         depends on ARCH_SUPPORTS_SHADOW_CALL_S << 
692         depends on DYNAMIC_FTRACE_WITH_ARGS || << 
693         depends on MMU                         << 
694         help                                   << 
695           This option enables the compiler's S << 
696           uses a shadow stack to protect funct << 
697           being overwritten by an attacker. Mo << 
698           in the compiler's documentation:     << 
699                                                << 
700           - Clang: https://clang.llvm.org/docs << 
701           - GCC: https://gcc.gnu.org/onlinedoc << 
702                                                << 
703           Note that security guarantees in the << 
704           ones documented for user space. The  << 
705           of shadow stacks in memory, which me << 
706           reading and writing arbitrary memory << 
707           and hijack control flow by modifying << 
708                                                << 
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                                     << 
717         bool                                   << 
718         help                                   << 
719           Selected if the kernel will be built << 
720                                                << 
721 config LTO_CLANG                               << 
722         bool                                   << 
723         select LTO                             << 
724         help                                   << 
725           Selected if the kernel will be built << 
726                                                << 
727 config ARCH_SUPPORTS_LTO_CLANG                 << 
728         bool                                   << 
729         help                                   << 
730           An architecture should select this o << 
731           - compiling with Clang,              << 
732           - compiling inline assembly with Cla << 
733           - and linking with LLD.              << 
734                                                << 
735 config ARCH_SUPPORTS_LTO_CLANG_THIN            << 
736         bool                                   << 
737         help                                   << 
738           An architecture should select this o << 
739           ThinLTO mode.                        << 
740                                                << 
741 config HAS_LTO_CLANG                           << 
742         def_bool y                             << 
743         depends on CC_IS_CLANG && LD_IS_LLD && << 
744         depends on $(success,$(NM) --help | he << 
745         depends on $(success,$(AR) --help | he << 
746         depends on ARCH_SUPPORTS_LTO_CLANG     << 
747         depends on !FTRACE_MCOUNT_USE_RECORDMC << 
748         # https://github.com/ClangBuiltLinux/l << 
749         depends on (!KASAN || KASAN_HW_TAGS || << 
750         depends on (!KCOV || CLANG_VERSION >=  << 
751         depends on !GCOV_KERNEL                << 
752         help                                   << 
753           The compiler and Kconfig options sup << 
754           LTO.                                 << 
755                                                << 
756 choice                                         << 
757         prompt "Link Time Optimization (LTO)"  << 
758         default LTO_NONE                       << 
759         help                                   << 
760           This option enables Link Time Optimi << 
761           compiler to optimize binaries global << 
762                                                << 
763           If unsure, select LTO_NONE. Note tha << 
764           so it's disabled by default.         << 
765                                                << 
766 config LTO_NONE                                << 
767         bool "None"                            << 
768         help                                   << 
769           Build the kernel normally, without L << 
770                                                << 
771 config LTO_CLANG_FULL                          << 
772         bool "Clang Full LTO (EXPERIMENTAL)"   << 
773         depends on HAS_LTO_CLANG               << 
774         depends on !COMPILE_TEST               << 
775         select LTO_CLANG                       << 
776         help                                   << 
777           This option enables Clang's full Lin << 
778           allows the compiler to optimize the  << 
779           this option, the compiler generates  << 
780           object files, and the actual compila << 
781           the LTO link step, which may take se << 
782           kernel configuration. More informati << 
783           documentation:                       << 
784                                                << 
785             https://llvm.org/docs/LinkTimeOpti << 
786                                                << 
787           During link time, this option can us << 
788           may take much longer than the ThinLT << 
789                                                << 
790 config LTO_CLANG_THIN                          << 
791         bool "Clang ThinLTO (EXPERIMENTAL)"    << 
792         depends on HAS_LTO_CLANG && ARCH_SUPPO << 
793         select LTO_CLANG                       << 
794         help                                   << 
795           This option enables Clang's ThinLTO, << 
796           optimization and faster incremental  << 
797           CONFIG_LTO_CLANG_FULL option. More i << 
798           from Clang's documentation:          << 
799                                                << 
800             https://clang.llvm.org/docs/ThinLT << 
801                                                << 
802           If unsure, say Y.                    << 
803 endchoice                                      << 
804                                                << 
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              613 config HAVE_ARCH_WITHIN_STACK_FRAMES
840         bool                                      614         bool
841         help                                      615         help
842           An architecture should select this i    616           An architecture should select this if it can walk the kernel stack
843           frames to determine if an object is     617           frames to determine if an object is part of either the arguments
844           or local variables (i.e. that it exc    618           or local variables (i.e. that it excludes saved return addresses,
845           and similar) by implementing an inli    619           and similar) by implementing an inline arch_within_stack_frames(),
846           which is used by CONFIG_HARDENED_USE    620           which is used by CONFIG_HARDENED_USERCOPY.
847                                                   621 
848 config HAVE_CONTEXT_TRACKING_USER              !! 622 config HAVE_CONTEXT_TRACKING
849         bool                                      623         bool
850         help                                      624         help
851           Provide kernel/user boundaries probe    625           Provide kernel/user boundaries probes necessary for subsystems
852           that need it, such as userspace RCU     626           that need it, such as userspace RCU extended quiescent state.
853           Syscalls need to be wrapped inside u !! 627           Syscalls need to be wrapped inside user_exit()-user_enter() through
854           optimized behind static key or throu !! 628           the slow path using TIF_NOHZ flag. Exceptions handlers must be
855           flag. Exceptions handlers must be wr !! 629           wrapped as well. Irqs are already protected inside
856           protected inside ct_irq_enter/ct_irq !! 630           rcu_irq_enter/rcu_irq_exit() but preemption or signal handling on
857           handling on irq exit still need to b !! 631           irq exit still need to be protected.
858                                                << 
859 config HAVE_CONTEXT_TRACKING_USER_OFFSTACK     << 
860         bool                                   << 
861         help                                   << 
862           Architecture neither relies on excep << 
863           nor on schedule_user(). Also preempt << 
864           preempt_schedule_irq() can't be call << 
865           while context tracking is CONTEXT_US << 
866           entry implementation where the follo << 
867           critical entry code, ie: before user << 
868                                                << 
869           - Critical entry code isn't preempti << 
870             not interruptible).                << 
871           - No use of RCU read side critical s << 
872             got called.                        << 
873           - No use of instrumentation, unless  << 
874             called.                            << 
875                                                << 
876 config HAVE_TIF_NOHZ                           << 
877         bool                                   << 
878         help                                   << 
879           Arch relies on TIF_NOHZ and syscall  << 
880           tracking calls to user_enter()/user_ << 
881                                                   632 
882 config HAVE_VIRT_CPU_ACCOUNTING                   633 config HAVE_VIRT_CPU_ACCOUNTING
883         bool                                      634         bool
884                                                   635 
885 config HAVE_VIRT_CPU_ACCOUNTING_IDLE           << 
886         bool                                   << 
887         help                                   << 
888           Architecture has its own way to acco << 
889           doesn't implement vtime_account_idle << 
890                                                << 
891 config ARCH_HAS_SCALED_CPUTIME                    636 config ARCH_HAS_SCALED_CPUTIME
892         bool                                      637         bool
893                                                   638 
894 config HAVE_VIRT_CPU_ACCOUNTING_GEN               639 config HAVE_VIRT_CPU_ACCOUNTING_GEN
895         bool                                      640         bool
896         default y if 64BIT                        641         default y if 64BIT
897         help                                      642         help
898           With VIRT_CPU_ACCOUNTING_GEN, cputim    643           With VIRT_CPU_ACCOUNTING_GEN, cputime_t becomes 64-bit.
899           Before enabling this option, arch co    644           Before enabling this option, arch code must be audited
900           to ensure there are no races in conc    645           to ensure there are no races in concurrent read/write of
901           cputime_t. For example, reading/writ    646           cputime_t. For example, reading/writing 64-bit cputime_t on
902           some 32-bit arches may require multi    647           some 32-bit arches may require multiple accesses, so proper
903           locking is needed to protect against    648           locking is needed to protect against concurrent accesses.
904                                                   649 
                                                   >> 650 
905 config HAVE_IRQ_TIME_ACCOUNTING                   651 config HAVE_IRQ_TIME_ACCOUNTING
906         bool                                      652         bool
907         help                                      653         help
908           Archs need to ensure they use a high    654           Archs need to ensure they use a high enough resolution clock to
909           support irq time accounting and then    655           support irq time accounting and then call enable_sched_clock_irqtime().
910                                                   656 
911 config HAVE_MOVE_PUD                           << 
912         bool                                   << 
913         help                                   << 
914           Architectures that select this are a << 
915           PUD level. If there are only 3 page  << 
916           happens at the PGD level.            << 
917                                                << 
918 config HAVE_MOVE_PMD                           << 
919         bool                                   << 
920         help                                   << 
921           Archs that select this are able to m << 
922                                                << 
923 config HAVE_ARCH_TRANSPARENT_HUGEPAGE             657 config HAVE_ARCH_TRANSPARENT_HUGEPAGE
924         bool                                      658         bool
925                                                   659 
926 config HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD         660 config HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD
927         bool                                      661         bool
928                                                   662 
929 config HAVE_ARCH_HUGE_VMAP                        663 config HAVE_ARCH_HUGE_VMAP
930         bool                                      664         bool
931                                                   665 
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                << 
942         bool                                   << 
943                                                << 
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                       666 config HAVE_ARCH_SOFT_DIRTY
953         bool                                      667         bool
954                                                   668 
955 config HAVE_MOD_ARCH_SPECIFIC                     669 config HAVE_MOD_ARCH_SPECIFIC
956         bool                                      670         bool
957         help                                      671         help
958           The arch uses struct mod_arch_specif    672           The arch uses struct mod_arch_specific to store data.  Many arches
959           just need a simple module loader wit    673           just need a simple module loader without arch specific data - those
960           should not enable this.                 674           should not enable this.
961                                                   675 
962 config MODULES_USE_ELF_RELA                       676 config MODULES_USE_ELF_RELA
963         bool                                      677         bool
964         help                                      678         help
965           Modules only use ELF RELA relocation    679           Modules only use ELF RELA relocations.  Modules with ELF REL
966           relocations will give an error.         680           relocations will give an error.
967                                                   681 
968 config MODULES_USE_ELF_REL                        682 config MODULES_USE_ELF_REL
969         bool                                      683         bool
970         help                                      684         help
971           Modules only use ELF REL relocations    685           Modules only use ELF REL relocations.  Modules with ELF RELA
972           relocations will give an error.         686           relocations will give an error.
973                                                   687 
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                 688 config HAVE_IRQ_EXIT_ON_IRQ_STACK
989         bool                                      689         bool
990         help                                      690         help
991           Architecture doesn't only execute th    691           Architecture doesn't only execute the irq handler on the irq stack
992           but also irq_exit(). This way we can    692           but also irq_exit(). This way we can process softirqs on this irq
993           stack instead of switching to a new     693           stack instead of switching to a new one when we call __do_softirq()
994           in the end of an hardirq.               694           in the end of an hardirq.
995           This spares a stack switch and impro    695           This spares a stack switch and improves cache usage on softirq
996           processing.                             696           processing.
997                                                   697 
998 config HAVE_SOFTIRQ_ON_OWN_STACK               << 
999         bool                                   << 
1000         help                                  << 
1001           Architecture provides a function to << 
1002           separate 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                                               << 
1014 config PGTABLE_LEVELS                            698 config PGTABLE_LEVELS
1015         int                                      699         int
1016         default 2                                700         default 2
1017                                                  701 
1018 config ARCH_HAS_ELF_RANDOMIZE                    702 config ARCH_HAS_ELF_RANDOMIZE
1019         bool                                     703         bool
1020         help                                     704         help
1021           An architecture supports choosing r    705           An architecture supports choosing randomized locations for
1022           stack, mmap, brk, and ET_DYN. Defin    706           stack, mmap, brk, and ET_DYN. Defined functions:
1023           - arch_mmap_rnd()                      707           - arch_mmap_rnd()
1024           - arch_randomize_brk()                 708           - arch_randomize_brk()
1025                                                  709 
1026 config HAVE_ARCH_MMAP_RND_BITS                   710 config HAVE_ARCH_MMAP_RND_BITS
1027         bool                                     711         bool
1028         help                                     712         help
1029           An arch should select this symbol i    713           An arch should select this symbol if it supports setting a variable
1030           number of bits for use in establish    714           number of bits for use in establishing the base address for mmap
1031           allocations, has MMU enabled and pr    715           allocations, has MMU enabled and provides values for both:
1032           - ARCH_MMAP_RND_BITS_MIN               716           - ARCH_MMAP_RND_BITS_MIN
1033           - ARCH_MMAP_RND_BITS_MAX               717           - ARCH_MMAP_RND_BITS_MAX
1034                                                  718 
1035 config HAVE_EXIT_THREAD                          719 config HAVE_EXIT_THREAD
1036         bool                                     720         bool
1037         help                                     721         help
1038           An architecture implements exit_thr    722           An architecture implements exit_thread.
1039                                                  723 
1040 config ARCH_MMAP_RND_BITS_MIN                    724 config ARCH_MMAP_RND_BITS_MIN
1041         int                                      725         int
1042                                                  726 
1043 config ARCH_MMAP_RND_BITS_MAX                    727 config ARCH_MMAP_RND_BITS_MAX
1044         int                                      728         int
1045                                                  729 
1046 config ARCH_MMAP_RND_BITS_DEFAULT                730 config ARCH_MMAP_RND_BITS_DEFAULT
1047         int                                      731         int
1048                                                  732 
1049 config ARCH_MMAP_RND_BITS                        733 config ARCH_MMAP_RND_BITS
1050         int "Number of bits to use for ASLR o    734         int "Number of bits to use for ASLR of mmap base address" if EXPERT
1051         range ARCH_MMAP_RND_BITS_MIN ARCH_MMA    735         range ARCH_MMAP_RND_BITS_MIN ARCH_MMAP_RND_BITS_MAX
1052         default ARCH_MMAP_RND_BITS_DEFAULT if    736         default ARCH_MMAP_RND_BITS_DEFAULT if ARCH_MMAP_RND_BITS_DEFAULT
1053         default ARCH_MMAP_RND_BITS_MIN           737         default ARCH_MMAP_RND_BITS_MIN
1054         depends on HAVE_ARCH_MMAP_RND_BITS       738         depends on HAVE_ARCH_MMAP_RND_BITS
1055         help                                     739         help
1056           This value can be used to select th    740           This value can be used to select the number of bits to use to
1057           determine the random offset to the     741           determine the random offset to the base address of vma regions
1058           resulting from mmap allocations. Th    742           resulting from mmap allocations. This value will be bounded
1059           by the architecture's minimum and m    743           by the architecture's minimum and maximum supported values.
1060                                                  744 
1061           This value can be changed after boo    745           This value can be changed after boot using the
1062           /proc/sys/vm/mmap_rnd_bits tunable     746           /proc/sys/vm/mmap_rnd_bits tunable
1063                                                  747 
1064 config HAVE_ARCH_MMAP_RND_COMPAT_BITS            748 config HAVE_ARCH_MMAP_RND_COMPAT_BITS
1065         bool                                     749         bool
1066         help                                     750         help
1067           An arch should select this symbol i    751           An arch should select this symbol if it supports running applications
1068           in compatibility mode, supports set    752           in compatibility mode, supports setting a variable number of bits for
1069           use in establishing the base addres    753           use in establishing the base address for mmap allocations, has MMU
1070           enabled and provides values for bot    754           enabled and provides values for both:
1071           - ARCH_MMAP_RND_COMPAT_BITS_MIN        755           - ARCH_MMAP_RND_COMPAT_BITS_MIN
1072           - ARCH_MMAP_RND_COMPAT_BITS_MAX        756           - ARCH_MMAP_RND_COMPAT_BITS_MAX
1073                                                  757 
1074 config ARCH_MMAP_RND_COMPAT_BITS_MIN             758 config ARCH_MMAP_RND_COMPAT_BITS_MIN
1075         int                                      759         int
1076                                                  760 
1077 config ARCH_MMAP_RND_COMPAT_BITS_MAX             761 config ARCH_MMAP_RND_COMPAT_BITS_MAX
1078         int                                      762         int
1079                                                  763 
1080 config ARCH_MMAP_RND_COMPAT_BITS_DEFAULT         764 config ARCH_MMAP_RND_COMPAT_BITS_DEFAULT
1081         int                                      765         int
1082                                                  766 
1083 config ARCH_MMAP_RND_COMPAT_BITS                 767 config ARCH_MMAP_RND_COMPAT_BITS
1084         int "Number of bits to use for ASLR o    768         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    769         range ARCH_MMAP_RND_COMPAT_BITS_MIN ARCH_MMAP_RND_COMPAT_BITS_MAX
1086         default ARCH_MMAP_RND_COMPAT_BITS_DEF    770         default ARCH_MMAP_RND_COMPAT_BITS_DEFAULT if ARCH_MMAP_RND_COMPAT_BITS_DEFAULT
1087         default ARCH_MMAP_RND_COMPAT_BITS_MIN    771         default ARCH_MMAP_RND_COMPAT_BITS_MIN
1088         depends on HAVE_ARCH_MMAP_RND_COMPAT_    772         depends on HAVE_ARCH_MMAP_RND_COMPAT_BITS
1089         help                                     773         help
1090           This value can be used to select th    774           This value can be used to select the number of bits to use to
1091           determine the random offset to the     775           determine the random offset to the base address of vma regions
1092           resulting from mmap allocations for    776           resulting from mmap allocations for compatible applications This
1093           value will be bounded by the archit    777           value will be bounded by the architecture's minimum and maximum
1094           supported values.                      778           supported values.
1095                                                  779 
1096           This value can be changed after boo    780           This value can be changed after boot using the
1097           /proc/sys/vm/mmap_rnd_compat_bits t    781           /proc/sys/vm/mmap_rnd_compat_bits tunable
1098                                                  782 
1099 config HAVE_ARCH_COMPAT_MMAP_BASES               783 config HAVE_ARCH_COMPAT_MMAP_BASES
1100         bool                                     784         bool
1101         help                                     785         help
1102           This allows 64bit applications to i    786           This allows 64bit applications to invoke 32-bit mmap() syscall
1103           and vice-versa 32-bit applications     787           and vice-versa 32-bit applications to call 64-bit mmap().
1104           Required for applications doing dif    788           Required for applications doing different bitness syscalls.
1105                                                  789 
1106 config HAVE_PAGE_SIZE_4KB                     !! 790 config HAVE_COPY_THREAD_TLS
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                                     791         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                                     792         help
1182           256KiB pages have little practical  !! 793           Architecture provides copy_thread_tls to accept tls argument via
1183           memory usage.  The kernel will only !! 794           normal C parameter passing, rather than extracting the syscall
1184           that have been compiled with '-zmax !! 795           argument from pt_regs.
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 << 
1208 # address by giving priority to top-down sche << 
1209 # is not in legacy mode (compat task, unlimit << 
1210 # sysctl_legacy_va_layout).                   << 
1211 # Architecture that selects this option can p << 
1212 # - STACK_RND_MASK                            << 
1213 config ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT  << 
1214         bool                                  << 
1215         depends on MMU                        << 
1216         select ARCH_HAS_ELF_RANDOMIZE         << 
1217                                               << 
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                                                  796 
1234 config HAVE_STACK_VALIDATION                     797 config HAVE_STACK_VALIDATION
1235         bool                                     798         bool
1236         help                                     799         help
1237           Architecture supports objtool compi !! 800           Architecture supports the 'objtool check' host tool command, which
1238           validation.                         !! 801           performs compile-time stack metadata validation.
1239                                                  802 
1240 config HAVE_RELIABLE_STACKTRACE                  803 config HAVE_RELIABLE_STACKTRACE
1241         bool                                     804         bool
1242         help                                     805         help
1243           Architecture has either save_stack_ !! 806           Architecture has a save_stack_trace_tsk_reliable() function which
1244           arch_stack_walk_reliable() function !! 807           only returns a stack trace if it can guarantee the trace is reliable.
1245           if it can guarantee the trace is re << 
1246                                                  808 
1247 config HAVE_ARCH_HASH                            809 config HAVE_ARCH_HASH
1248         bool                                     810         bool
1249         default n                                811         default n
1250         help                                     812         help
1251           If this is set, the architecture pr    813           If this is set, the architecture provides an <asm/hash.h>
1252           file which provides platform-specif    814           file which provides platform-specific implementations of some
1253           functions in <linux/hash.h> or fs/n    815           functions in <linux/hash.h> or fs/namei.c.
1254                                                  816 
1255 config HAVE_ARCH_NVRAM_OPS                    << 
1256         bool                                  << 
1257                                               << 
1258 config ISA_BUS_API                               817 config ISA_BUS_API
1259         def_bool ISA                             818         def_bool ISA
1260                                                  819 
1261 #                                                820 #
1262 # ABI hall of shame                              821 # ABI hall of shame
1263 #                                                822 #
1264 config CLONE_BACKWARDS                           823 config CLONE_BACKWARDS
1265         bool                                     824         bool
1266         help                                     825         help
1267           Architecture has tls passed as the     826           Architecture has tls passed as the 4th argument of clone(2),
1268           not the 5th one.                       827           not the 5th one.
1269                                                  828 
1270 config CLONE_BACKWARDS2                          829 config CLONE_BACKWARDS2
1271         bool                                     830         bool
1272         help                                     831         help
1273           Architecture has the first two argu    832           Architecture has the first two arguments of clone(2) swapped.
1274                                                  833 
1275 config CLONE_BACKWARDS3                          834 config CLONE_BACKWARDS3
1276         bool                                     835         bool
1277         help                                     836         help
1278           Architecture has tls passed as the     837           Architecture has tls passed as the 3rd argument of clone(2),
1279           not the 5th one.                       838           not the 5th one.
1280                                                  839 
1281 config ODD_RT_SIGACTION                          840 config ODD_RT_SIGACTION
1282         bool                                     841         bool
1283         help                                     842         help
1284           Architecture has unusual rt_sigacti    843           Architecture has unusual rt_sigaction(2) arguments
1285                                                  844 
1286 config OLD_SIGSUSPEND                            845 config OLD_SIGSUSPEND
1287         bool                                     846         bool
1288         help                                     847         help
1289           Architecture has old sigsuspend(2)     848           Architecture has old sigsuspend(2) syscall, of one-argument variety
1290                                                  849 
1291 config OLD_SIGSUSPEND3                           850 config OLD_SIGSUSPEND3
1292         bool                                     851         bool
1293         help                                     852         help
1294           Even weirder antique ABI - three-ar    853           Even weirder antique ABI - three-argument sigsuspend(2)
1295                                                  854 
1296 config OLD_SIGACTION                             855 config OLD_SIGACTION
1297         bool                                     856         bool
1298         help                                     857         help
1299           Architecture has old sigaction(2) s    858           Architecture has old sigaction(2) syscall.  Nope, not the same
1300           as OLD_SIGSUSPEND | OLD_SIGSUSPEND3    859           as OLD_SIGSUSPEND | OLD_SIGSUSPEND3 - alpha has sigsuspend(2),
1301           but fairly different variant of sig    860           but fairly different variant of sigaction(2), thanks to OSF/1
1302           compatibility...                       861           compatibility...
1303                                                  862 
1304 config COMPAT_OLD_SIGACTION                      863 config COMPAT_OLD_SIGACTION
1305         bool                                     864         bool
1306                                                  865 
                                                   >> 866 config 64BIT_TIME
                                                   >> 867         def_bool ARCH_HAS_64BIT_TIME
                                                   >> 868         help
                                                   >> 869           This should be selected by all architectures that need to support
                                                   >> 870           new system calls with a 64-bit time_t. This is relevant on all 32-bit
                                                   >> 871           architectures, and 64-bit architectures as part of compat syscall
                                                   >> 872           handling.
                                                   >> 873 
1307 config COMPAT_32BIT_TIME                         874 config COMPAT_32BIT_TIME
1308         bool "Provide system calls for 32-bit !! 875         def_bool (!64BIT && 64BIT_TIME) || COMPAT
1309         default !64BIT || COMPAT              << 
1310         help                                     876         help
1311           This enables 32 bit time_t support     877           This enables 32 bit time_t support in addition to 64 bit time_t support.
1312           This is relevant on all 32-bit arch    878           This is relevant on all 32-bit architectures, and 64-bit architectures
1313           as part of compat syscall handling.    879           as part of compat syscall handling.
1314                                                  880 
1315 config ARCH_NO_PREEMPT                        !! 881 config ARCH_NO_COHERENT_DMA_MMAP
1316         bool                                  << 
1317                                               << 
1318 config ARCH_SUPPORTS_RT                       << 
1319         bool                                     882         bool
1320                                                  883 
1321 config CPU_NO_EFFICIENT_FFS                      884 config CPU_NO_EFFICIENT_FFS
1322         def_bool n                               885         def_bool n
1323                                                  886 
1324 config HAVE_ARCH_VMAP_STACK                      887 config HAVE_ARCH_VMAP_STACK
1325         def_bool n                               888         def_bool n
1326         help                                     889         help
1327           An arch should select this symbol i    890           An arch should select this symbol if it can support kernel stacks
1328           in vmalloc space.  This means:         891           in vmalloc space.  This means:
1329                                                  892 
1330           - vmalloc space must be large enoug    893           - vmalloc space must be large enough to hold many kernel stacks.
1331             This may rule out many 32-bit arc    894             This may rule out many 32-bit architectures.
1332                                                  895 
1333           - Stacks in vmalloc space need to w    896           - Stacks in vmalloc space need to work reliably.  For example, if
1334             vmap page tables are created on d    897             vmap page tables are created on demand, either this mechanism
1335             needs to work while the stack poi    898             needs to work while the stack points to a virtual address with
1336             unpopulated page tables or arch c    899             unpopulated page tables or arch code (switch_to() and switch_mm(),
1337             most likely) needs to ensure that    900             most likely) needs to ensure that the stack's page table entries
1338             are populated before running on a    901             are populated before running on a possibly unpopulated stack.
1339                                                  902 
1340           - If the stack overflows into a gua    903           - If the stack overflows into a guard page, something reasonable
1341             should happen.  The definition of    904             should happen.  The definition of "reasonable" is flexible, but
1342             instantly rebooting without loggi    905             instantly rebooting without logging anything would be unfriendly.
1343                                                  906 
1344 config VMAP_STACK                                907 config VMAP_STACK
1345         default y                                908         default y
1346         bool "Use a virtually-mapped stack"      909         bool "Use a virtually-mapped stack"
1347         depends on HAVE_ARCH_VMAP_STACK       !! 910         depends on HAVE_ARCH_VMAP_STACK && !KASAN
1348         depends on !KASAN || KASAN_HW_TAGS || !! 911         ---help---
1349         help                                  << 
1350           Enable this if you want the use vir    912           Enable this if you want the use virtually-mapped kernel stacks
1351           with guard pages.  This causes kern    913           with guard pages.  This causes kernel stack overflows to be
1352           caught immediately rather than caus    914           caught immediately rather than causing difficult-to-diagnose
1353           corruption.                            915           corruption.
1354                                                  916 
1355           To use this with software KASAN mod !! 917           This is presently incompatible with KASAN because KASAN expects
1356           backing virtual mappings with real  !! 918           the stack to map directly to the KASAN shadow map using a formula
1357           must be enabled.                    !! 919           that is incorrect if the stack is in vmalloc space.
1358                                               << 
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                                                  920 
1396 config ARCH_OPTIONAL_KERNEL_RWX                  921 config ARCH_OPTIONAL_KERNEL_RWX
1397         def_bool n                               922         def_bool n
1398                                                  923 
1399 config ARCH_OPTIONAL_KERNEL_RWX_DEFAULT          924 config ARCH_OPTIONAL_KERNEL_RWX_DEFAULT
1400         def_bool n                               925         def_bool n
1401                                                  926 
1402 config ARCH_HAS_STRICT_KERNEL_RWX                927 config ARCH_HAS_STRICT_KERNEL_RWX
1403         def_bool n                               928         def_bool n
1404                                                  929 
1405 config STRICT_KERNEL_RWX                         930 config STRICT_KERNEL_RWX
1406         bool "Make kernel text and rodata rea    931         bool "Make kernel text and rodata read-only" if ARCH_OPTIONAL_KERNEL_RWX
1407         depends on ARCH_HAS_STRICT_KERNEL_RWX    932         depends on ARCH_HAS_STRICT_KERNEL_RWX
1408         default !ARCH_OPTIONAL_KERNEL_RWX ||     933         default !ARCH_OPTIONAL_KERNEL_RWX || ARCH_OPTIONAL_KERNEL_RWX_DEFAULT
1409         help                                     934         help
1410           If this is set, kernel text and rod    935           If this is set, kernel text and rodata memory will be made read-only,
1411           and non-text memory will be made no    936           and non-text memory will be made non-executable. This provides
1412           protection against certain security    937           protection against certain security exploits (e.g. executing the heap
1413           or modifying text)                     938           or modifying text)
1414                                                  939 
1415           These features are considered stand    940           These features are considered standard security practice these days.
1416           You should say Y here in almost all    941           You should say Y here in almost all cases.
1417                                                  942 
1418 config ARCH_HAS_STRICT_MODULE_RWX                943 config ARCH_HAS_STRICT_MODULE_RWX
1419         def_bool n                               944         def_bool n
1420                                                  945 
1421 config STRICT_MODULE_RWX                         946 config STRICT_MODULE_RWX
1422         bool "Set loadable kernel module data    947         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    948         depends on ARCH_HAS_STRICT_MODULE_RWX && MODULES
1424         default !ARCH_OPTIONAL_KERNEL_RWX ||     949         default !ARCH_OPTIONAL_KERNEL_RWX || ARCH_OPTIONAL_KERNEL_RWX_DEFAULT
1425         help                                     950         help
1426           If this is set, module text and rod    951           If this is set, module text and rodata memory will be made read-only,
1427           and non-text memory will be made no    952           and non-text memory will be made non-executable. This provides
1428           protection against certain security    953           protection against certain security exploits (e.g. writing to text)
1429                                                  954 
1430 # select if the architecture provides an asm/    955 # select if the architecture provides an asm/dma-direct.h header
1431 config ARCH_HAS_PHYS_TO_DMA                      956 config ARCH_HAS_PHYS_TO_DMA
1432         bool                                     957         bool
1433                                                  958 
                                                   >> 959 config ARCH_HAS_REFCOUNT
                                                   >> 960         bool
                                                   >> 961         help
                                                   >> 962           An architecture selects this when it has implemented refcount_t
                                                   >> 963           using open coded assembly primitives that provide an optimized
                                                   >> 964           refcount_t implementation, possibly at the expense of some full
                                                   >> 965           refcount state checks of CONFIG_REFCOUNT_FULL=y.
                                                   >> 966 
                                                   >> 967           The refcount overflow check behavior, however, must be retained.
                                                   >> 968           Catching overflows is the primary security concern for protecting
                                                   >> 969           against bugs in reference counts.
                                                   >> 970 
                                                   >> 971 config REFCOUNT_FULL
                                                   >> 972         bool "Perform full reference count validation at the expense of speed"
                                                   >> 973         help
                                                   >> 974           Enabling this switches the refcounting infrastructure from a fast
                                                   >> 975           unchecked atomic_t implementation to a fully state checked
                                                   >> 976           implementation, which can be (slightly) slower but provides protections
                                                   >> 977           against various use-after-free conditions that can be used in
                                                   >> 978           security flaw exploits.
                                                   >> 979 
1434 config HAVE_ARCH_COMPILER_H                      980 config HAVE_ARCH_COMPILER_H
1435         bool                                     981         bool
1436         help                                     982         help
1437           An architecture can select this if     983           An architecture can select this if it provides an
1438           asm/compiler.h header that should b    984           asm/compiler.h header that should be included after
1439           linux/compiler-*.h in order to over    985           linux/compiler-*.h in order to override macro definitions that those
1440           headers generally provide.             986           headers generally provide.
1441                                                  987 
1442 config HAVE_ARCH_PREL32_RELOCATIONS           << 
1443         bool                                  << 
1444         help                                  << 
1445           May be selected by an architecture  << 
1446           32-bit relocations, both in the too << 
1447           in which case relative references c << 
1448           for PCI fixup, initcalls etc which  << 
1449           architectures, and don't require ru << 
1450           kernels.                            << 
1451                                               << 
1452 config ARCH_USE_MEMREMAP_PROT                 << 
1453         bool                                  << 
1454                                               << 
1455 config LOCK_EVENT_COUNTS                      << 
1456         bool "Locking event counts collection << 
1457         depends on DEBUG_FS                   << 
1458         help                                  << 
1459           Enable light-weight counting of var << 
1460           in the system with minimal performa << 
1461           the chance of application behavior  << 
1462           differences. The counts are reporte << 
1463                                               << 
1464 # Select if the architecture has support for  << 
1465 config ARCH_HAS_RELR                          << 
1466         bool                                  << 
1467                                               << 
1468 config RELR                                   << 
1469         bool "Use RELR relocation packing"    << 
1470         depends on ARCH_HAS_RELR && TOOLS_SUP << 
1471         default y                             << 
1472         help                                  << 
1473           Store the kernel's dynamic relocati << 
1474           format. Requires a compatible linke << 
1475           well as compatible NM and OBJCOPY u << 
1476           are compatible).                    << 
1477                                               << 
1478 config ARCH_HAS_MEM_ENCRYPT                   << 
1479         bool                                  << 
1480                                               << 
1481 config ARCH_HAS_CC_PLATFORM                   << 
1482         bool                                  << 
1483                                               << 
1484 config HAVE_SPARSE_SYSCALL_NR                 << 
1485         bool                                  << 
1486         help                                  << 
1487           An architecture should select this  << 
1488           to save space. For example, MIPS ar << 
1489           entries at 4000, 5000 and 6000 loca << 
1490           related optimizations for a given a << 
1491                                               << 
1492 config ARCH_HAS_VDSO_DATA                     << 
1493         bool                                  << 
1494                                               << 
1495 config HAVE_STATIC_CALL                       << 
1496         bool                                  << 
1497                                               << 
1498 config HAVE_STATIC_CALL_INLINE                << 
1499         bool                                  << 
1500         depends on HAVE_STATIC_CALL           << 
1501         select OBJTOOL                        << 
1502                                               << 
1503 config HAVE_PREEMPT_DYNAMIC                   << 
1504         bool                                  << 
1505                                               << 
1506 config HAVE_PREEMPT_DYNAMIC_CALL              << 
1507         bool                                  << 
1508         depends on HAVE_STATIC_CALL           << 
1509         select HAVE_PREEMPT_DYNAMIC           << 
1510         help                                  << 
1511           An architecture should select this  << 
1512           model being selected at boot time u << 
1513                                               << 
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                                               << 
1541 config ARCH_WANT_LD_ORPHAN_WARN               << 
1542         bool                                  << 
1543         help                                  << 
1544           An arch should select this symbol o << 
1545           included, size-asserted, or discard << 
1546           important because we never want exp << 
1547           by the linker, since the locations  << 
1548           versions.                           << 
1549                                               << 
1550 config HAVE_ARCH_PFN_VALID                    << 
1551         bool                                  << 
1552                                               << 
1553 config ARCH_SUPPORTS_DEBUG_PAGEALLOC          << 
1554         bool                                  << 
1555                                               << 
1556 config ARCH_SUPPORTS_PAGE_TABLE_CHECK         << 
1557         bool                                  << 
1558                                               << 
1559 config ARCH_SPLIT_ARG64                       << 
1560         bool                                  << 
1561         help                                  << 
1562           If a 32-bit architecture requires 6 << 
1563           pairs of 32-bit arguments, select t << 
1564                                               << 
1565 config ARCH_HAS_ELFCORE_COMPAT                << 
1566         bool                                  << 
1567                                               << 
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"                     988 source "kernel/gcov/Kconfig"
1604                                               << 
1605 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                                               << 
1646 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