d2f212dc8e72f9e5197477445e037be843d95846
[sfrench/cifs-2.6.git] / arch / Kconfig
1 # SPDX-License-Identifier: GPL-2.0
2 #
3 # General architecture dependent options
4 #
5
6 #
7 # Note: arch/$(SRCARCH)/Kconfig needs to be included first so that it can
8 # override the default values in this file.
9 #
10 source "arch/$(SRCARCH)/Kconfig"
11
12 menu "General architecture-dependent options"
13
14 config CRASH_CORE
15         bool
16
17 config KEXEC_CORE
18         select CRASH_CORE
19         bool
20
21 config HAVE_IMA_KEXEC
22         bool
23
24 config HOTPLUG_SMT
25         bool
26
27 config OPROFILE
28         tristate "OProfile system profiling"
29         depends on PROFILING
30         depends on HAVE_OPROFILE
31         select RING_BUFFER
32         select RING_BUFFER_ALLOW_SWAP
33         help
34           OProfile is a profiling system capable of profiling the
35           whole system, include the kernel, kernel modules, libraries,
36           and applications.
37
38           If unsure, say N.
39
40 config OPROFILE_EVENT_MULTIPLEX
41         bool "OProfile multiplexing support (EXPERIMENTAL)"
42         default n
43         depends on OPROFILE && X86
44         help
45           The number of hardware counters is limited. The multiplexing
46           feature enables OProfile to gather more events than counters
47           are provided by the hardware. This is realized by switching
48           between events at a user specified time interval.
49
50           If unsure, say N.
51
52 config HAVE_OPROFILE
53         bool
54
55 config OPROFILE_NMI_TIMER
56         def_bool y
57         depends on PERF_EVENTS && HAVE_PERF_EVENTS_NMI && !PPC64
58
59 config KPROBES
60         bool "Kprobes"
61         depends on MODULES
62         depends on HAVE_KPROBES
63         select KALLSYMS
64         help
65           Kprobes allows you to trap at almost any kernel address and
66           execute a callback function.  register_kprobe() establishes
67           a probepoint and specifies the callback.  Kprobes is useful
68           for kernel debugging, non-intrusive instrumentation and testing.
69           If in doubt, say "N".
70
71 config JUMP_LABEL
72        bool "Optimize very unlikely/likely branches"
73        depends on HAVE_ARCH_JUMP_LABEL
74        depends on CC_HAS_ASM_GOTO
75        help
76          This option enables a transparent branch optimization that
77          makes certain almost-always-true or almost-always-false branch
78          conditions even cheaper to execute within the kernel.
79
80          Certain performance-sensitive kernel code, such as trace points,
81          scheduler functionality, networking code and KVM have such
82          branches and include support for this optimization technique.
83
84          If it is detected that the compiler has support for "asm goto",
85          the kernel will compile such branches with just a nop
86          instruction. When the condition flag is toggled to true, the
87          nop will be converted to a jump instruction to execute the
88          conditional block of instructions.
89
90          This technique lowers overhead and stress on the branch prediction
91          of the processor and generally makes the kernel faster. The update
92          of the condition is slower, but those are always very rare.
93
94          ( On 32-bit x86, the necessary options added to the compiler
95            flags may increase the size of the kernel slightly. )
96
97 config STATIC_KEYS_SELFTEST
98         bool "Static key selftest"
99         depends on JUMP_LABEL
100         help
101           Boot time self-test of the branch patching code.
102
103 config OPTPROBES
104         def_bool y
105         depends on KPROBES && HAVE_OPTPROBES
106         select TASKS_RCU if PREEMPT
107
108 config KPROBES_ON_FTRACE
109         def_bool y
110         depends on KPROBES && HAVE_KPROBES_ON_FTRACE
111         depends on DYNAMIC_FTRACE_WITH_REGS
112         help
113          If function tracer is enabled and the arch supports full
114          passing of pt_regs to function tracing, then kprobes can
115          optimize on top of function tracing.
116
117 config UPROBES
118         def_bool n
119         depends on ARCH_SUPPORTS_UPROBES
120         help
121           Uprobes is the user-space counterpart to kprobes: they
122           enable instrumentation applications (such as 'perf probe')
123           to establish unintrusive probes in user-space binaries and
124           libraries, by executing handler functions when the probes
125           are hit by user-space applications.
126
127           ( These probes come in the form of single-byte breakpoints,
128             managed by the kernel and kept transparent to the probed
129             application. )
130
131 config HAVE_64BIT_ALIGNED_ACCESS
132         def_bool 64BIT && !HAVE_EFFICIENT_UNALIGNED_ACCESS
133         help
134           Some architectures require 64 bit accesses to be 64 bit
135           aligned, which also requires structs containing 64 bit values
136           to be 64 bit aligned too. This includes some 32 bit
137           architectures which can do 64 bit accesses, as well as 64 bit
138           architectures without unaligned access.
139
140           This symbol should be selected by an architecture if 64 bit
141           accesses are required to be 64 bit aligned in this way even
142           though it is not a 64 bit architecture.
143
144           See Documentation/unaligned-memory-access.txt for more
145           information on the topic of unaligned memory accesses.
146
147 config HAVE_EFFICIENT_UNALIGNED_ACCESS
148         bool
149         help
150           Some architectures are unable to perform unaligned accesses
151           without the use of get_unaligned/put_unaligned. Others are
152           unable to perform such accesses efficiently (e.g. trap on
153           unaligned access and require fixing it up in the exception
154           handler.)
155
156           This symbol should be selected by an architecture if it can
157           perform unaligned accesses efficiently to allow different
158           code paths to be selected for these cases. Some network
159           drivers, for example, could opt to not fix up alignment
160           problems with received packets if doing so would not help
161           much.
162
163           See Documentation/unaligned-memory-access.txt for more
164           information on the topic of unaligned memory accesses.
165
166 config ARCH_USE_BUILTIN_BSWAP
167        bool
168        help
169          Modern versions of GCC (since 4.4) have builtin functions
170          for handling byte-swapping. Using these, instead of the old
171          inline assembler that the architecture code provides in the
172          __arch_bswapXX() macros, allows the compiler to see what's
173          happening and offers more opportunity for optimisation. In
174          particular, the compiler will be able to combine the byteswap
175          with a nearby load or store and use load-and-swap or
176          store-and-swap instructions if the architecture has them. It
177          should almost *never* result in code which is worse than the
178          hand-coded assembler in <asm/swab.h>.  But just in case it
179          does, the use of the builtins is optional.
180
181          Any architecture with load-and-swap or store-and-swap
182          instructions should set this. And it shouldn't hurt to set it
183          on architectures that don't have such instructions.
184
185 config KRETPROBES
186         def_bool y
187         depends on KPROBES && HAVE_KRETPROBES
188
189 config USER_RETURN_NOTIFIER
190         bool
191         depends on HAVE_USER_RETURN_NOTIFIER
192         help
193           Provide a kernel-internal notification when a cpu is about to
194           switch to user mode.
195
196 config HAVE_IOREMAP_PROT
197         bool
198
199 config HAVE_KPROBES
200         bool
201
202 config HAVE_KRETPROBES
203         bool
204
205 config HAVE_OPTPROBES
206         bool
207
208 config HAVE_KPROBES_ON_FTRACE
209         bool
210
211 config HAVE_FUNCTION_ERROR_INJECTION
212         bool
213
214 config HAVE_NMI
215         bool
216
217 #
218 # An arch should select this if it provides all these things:
219 #
220 #       task_pt_regs()          in asm/processor.h or asm/ptrace.h
221 #       arch_has_single_step()  if there is hardware single-step support
222 #       arch_has_block_step()   if there is hardware block-step support
223 #       asm/syscall.h           supplying asm-generic/syscall.h interface
224 #       linux/regset.h          user_regset interfaces
225 #       CORE_DUMP_USE_REGSET    #define'd in linux/elf.h
226 #       TIF_SYSCALL_TRACE       calls tracehook_report_syscall_{entry,exit}
227 #       TIF_NOTIFY_RESUME       calls tracehook_notify_resume()
228 #       signal delivery         calls tracehook_signal_handler()
229 #
230 config HAVE_ARCH_TRACEHOOK
231         bool
232
233 config HAVE_DMA_CONTIGUOUS
234         bool
235
236 config GENERIC_SMP_IDLE_THREAD
237        bool
238
239 config GENERIC_IDLE_POLL_SETUP
240        bool
241
242 config ARCH_HAS_FORTIFY_SOURCE
243         bool
244         help
245           An architecture should select this when it can successfully
246           build and run with CONFIG_FORTIFY_SOURCE.
247
248 #
249 # Select if the arch provides a historic keepinit alias for the retain_initrd
250 # command line option
251 #
252 config ARCH_HAS_KEEPINITRD
253         bool
254
255 # Select if arch has all set_memory_ro/rw/x/nx() functions in asm/cacheflush.h
256 config ARCH_HAS_SET_MEMORY
257         bool
258
259 # Select if arch has all set_direct_map_invalid/default() functions
260 config ARCH_HAS_SET_DIRECT_MAP
261         bool
262
263 # Select if arch init_task must go in the __init_task_data section
264 config ARCH_TASK_STRUCT_ON_STACK
265        bool
266
267 # Select if arch has its private alloc_task_struct() function
268 config ARCH_TASK_STRUCT_ALLOCATOR
269         bool
270
271 config HAVE_ARCH_THREAD_STRUCT_WHITELIST
272         bool
273         depends on !ARCH_TASK_STRUCT_ALLOCATOR
274         help
275           An architecture should select this to provide hardened usercopy
276           knowledge about what region of the thread_struct should be
277           whitelisted for copying to userspace. Normally this is only the
278           FPU registers. Specifically, arch_thread_struct_whitelist()
279           should be implemented. Without this, the entire thread_struct
280           field in task_struct will be left whitelisted.
281
282 # Select if arch has its private alloc_thread_stack() function
283 config ARCH_THREAD_STACK_ALLOCATOR
284         bool
285
286 # Select if arch wants to size task_struct dynamically via arch_task_struct_size:
287 config ARCH_WANTS_DYNAMIC_TASK_STRUCT
288         bool
289
290 config ARCH_32BIT_OFF_T
291         bool
292         depends on !64BIT
293         help
294           All new 32-bit architectures should have 64-bit off_t type on
295           userspace side which corresponds to the loff_t kernel type. This
296           is the requirement for modern ABIs. Some existing architectures
297           still support 32-bit off_t. This option is enabled for all such
298           architectures explicitly.
299
300 config HAVE_REGS_AND_STACK_ACCESS_API
301         bool
302         help
303           This symbol should be selected by an architecure if it supports
304           the API needed to access registers and stack entries from pt_regs,
305           declared in asm/ptrace.h
306           For example the kprobes-based event tracer needs this API.
307
308 config HAVE_RSEQ
309         bool
310         depends on HAVE_REGS_AND_STACK_ACCESS_API
311         help
312           This symbol should be selected by an architecture if it
313           supports an implementation of restartable sequences.
314
315 config HAVE_FUNCTION_ARG_ACCESS_API
316         bool
317         help
318           This symbol should be selected by an architecure if it supports
319           the API needed to access function arguments from pt_regs,
320           declared in asm/ptrace.h
321
322 config HAVE_CLK
323         bool
324         help
325           The <linux/clk.h> calls support software clock gating and
326           thus are a key power management tool on many systems.
327
328 config HAVE_HW_BREAKPOINT
329         bool
330         depends on PERF_EVENTS
331
332 config HAVE_MIXED_BREAKPOINTS_REGS
333         bool
334         depends on HAVE_HW_BREAKPOINT
335         help
336           Depending on the arch implementation of hardware breakpoints,
337           some of them have separate registers for data and instruction
338           breakpoints addresses, others have mixed registers to store
339           them but define the access type in a control register.
340           Select this option if your arch implements breakpoints under the
341           latter fashion.
342
343 config HAVE_USER_RETURN_NOTIFIER
344         bool
345
346 config HAVE_PERF_EVENTS_NMI
347         bool
348         help
349           System hardware can generate an NMI using the perf event
350           subsystem.  Also has support for calculating CPU cycle events
351           to determine how many clock cycles in a given period.
352
353 config HAVE_HARDLOCKUP_DETECTOR_PERF
354         bool
355         depends on HAVE_PERF_EVENTS_NMI
356         help
357           The arch chooses to use the generic perf-NMI-based hardlockup
358           detector. Must define HAVE_PERF_EVENTS_NMI.
359
360 config HAVE_NMI_WATCHDOG
361         depends on HAVE_NMI
362         bool
363         help
364           The arch provides a low level NMI watchdog. It provides
365           asm/nmi.h, and defines its own arch_touch_nmi_watchdog().
366
367 config HAVE_HARDLOCKUP_DETECTOR_ARCH
368         bool
369         select HAVE_NMI_WATCHDOG
370         help
371           The arch chooses to provide its own hardlockup detector, which is
372           a superset of the HAVE_NMI_WATCHDOG. It also conforms to config
373           interfaces and parameters provided by hardlockup detector subsystem.
374
375 config HAVE_PERF_REGS
376         bool
377         help
378           Support selective register dumps for perf events. This includes
379           bit-mapping of each registers and a unique architecture id.
380
381 config HAVE_PERF_USER_STACK_DUMP
382         bool
383         help
384           Support user stack dumps for perf event samples. This needs
385           access to the user stack pointer which is not unified across
386           architectures.
387
388 config HAVE_ARCH_JUMP_LABEL
389         bool
390
391 config HAVE_ARCH_JUMP_LABEL_RELATIVE
392         bool
393
394 config HAVE_RCU_TABLE_FREE
395         bool
396
397 config HAVE_RCU_TABLE_NO_INVALIDATE
398         bool
399
400 config HAVE_MMU_GATHER_PAGE_SIZE
401         bool
402
403 config HAVE_MMU_GATHER_NO_GATHER
404         bool
405
406 config ARCH_HAVE_NMI_SAFE_CMPXCHG
407         bool
408
409 config HAVE_ALIGNED_STRUCT_PAGE
410         bool
411         help
412           This makes sure that struct pages are double word aligned and that
413           e.g. the SLUB allocator can perform double word atomic operations
414           on a struct page for better performance. However selecting this
415           might increase the size of a struct page by a word.
416
417 config HAVE_CMPXCHG_LOCAL
418         bool
419
420 config HAVE_CMPXCHG_DOUBLE
421         bool
422
423 config ARCH_WEAK_RELEASE_ACQUIRE
424         bool
425
426 config ARCH_WANT_IPC_PARSE_VERSION
427         bool
428
429 config ARCH_WANT_COMPAT_IPC_PARSE_VERSION
430         bool
431
432 config ARCH_WANT_OLD_COMPAT_IPC
433         select ARCH_WANT_COMPAT_IPC_PARSE_VERSION
434         bool
435
436 config HAVE_ARCH_SECCOMP_FILTER
437         bool
438         help
439           An arch should select this symbol if it provides all of these things:
440           - syscall_get_arch()
441           - syscall_get_arguments()
442           - syscall_rollback()
443           - syscall_set_return_value()
444           - SIGSYS siginfo_t support
445           - secure_computing is called from a ptrace_event()-safe context
446           - secure_computing return value is checked and a return value of -1
447             results in the system call being skipped immediately.
448           - seccomp syscall wired up
449
450 config SECCOMP_FILTER
451         def_bool y
452         depends on HAVE_ARCH_SECCOMP_FILTER && SECCOMP && NET
453         help
454           Enable tasks to build secure computing environments defined
455           in terms of Berkeley Packet Filter programs which implement
456           task-defined system call filtering polices.
457
458           See Documentation/userspace-api/seccomp_filter.rst for details.
459
460 config HAVE_ARCH_STACKLEAK
461         bool
462         help
463           An architecture should select this if it has the code which
464           fills the used part of the kernel stack with the STACKLEAK_POISON
465           value before returning from system calls.
466
467 config HAVE_STACKPROTECTOR
468         bool
469         help
470           An arch should select this symbol if:
471           - it has implemented a stack canary (e.g. __stack_chk_guard)
472
473 config CC_HAS_STACKPROTECTOR_NONE
474         def_bool $(cc-option,-fno-stack-protector)
475
476 config STACKPROTECTOR
477         bool "Stack Protector buffer overflow detection"
478         depends on HAVE_STACKPROTECTOR
479         depends on $(cc-option,-fstack-protector)
480         default y
481         help
482           This option turns on the "stack-protector" GCC feature. This
483           feature puts, at the beginning of functions, a canary value on
484           the stack just before the return address, and validates
485           the value just before actually returning.  Stack based buffer
486           overflows (that need to overwrite this return address) now also
487           overwrite the canary, which gets detected and the attack is then
488           neutralized via a kernel panic.
489
490           Functions will have the stack-protector canary logic added if they
491           have an 8-byte or larger character array on the stack.
492
493           This feature requires gcc version 4.2 or above, or a distribution
494           gcc with the feature backported ("-fstack-protector").
495
496           On an x86 "defconfig" build, this feature adds canary checks to
497           about 3% of all kernel functions, which increases kernel code size
498           by about 0.3%.
499
500 config STACKPROTECTOR_STRONG
501         bool "Strong Stack Protector"
502         depends on STACKPROTECTOR
503         depends on $(cc-option,-fstack-protector-strong)
504         default y
505         help
506           Functions will have the stack-protector canary logic added in any
507           of the following conditions:
508
509           - local variable's address used as part of the right hand side of an
510             assignment or function argument
511           - local variable is an array (or union containing an array),
512             regardless of array type or length
513           - uses register local variables
514
515           This feature requires gcc version 4.9 or above, or a distribution
516           gcc with the feature backported ("-fstack-protector-strong").
517
518           On an x86 "defconfig" build, this feature adds canary checks to
519           about 20% of all kernel functions, which increases the kernel code
520           size by about 2%.
521
522 config HAVE_ARCH_WITHIN_STACK_FRAMES
523         bool
524         help
525           An architecture should select this if it can walk the kernel stack
526           frames to determine if an object is part of either the arguments
527           or local variables (i.e. that it excludes saved return addresses,
528           and similar) by implementing an inline arch_within_stack_frames(),
529           which is used by CONFIG_HARDENED_USERCOPY.
530
531 config HAVE_CONTEXT_TRACKING
532         bool
533         help
534           Provide kernel/user boundaries probes necessary for subsystems
535           that need it, such as userspace RCU extended quiescent state.
536           Syscalls need to be wrapped inside user_exit()-user_enter() through
537           the slow path using TIF_NOHZ flag. Exceptions handlers must be
538           wrapped as well. Irqs are already protected inside
539           rcu_irq_enter/rcu_irq_exit() but preemption or signal handling on
540           irq exit still need to be protected.
541
542 config HAVE_VIRT_CPU_ACCOUNTING
543         bool
544
545 config ARCH_HAS_SCALED_CPUTIME
546         bool
547
548 config HAVE_VIRT_CPU_ACCOUNTING_GEN
549         bool
550         default y if 64BIT
551         help
552           With VIRT_CPU_ACCOUNTING_GEN, cputime_t becomes 64-bit.
553           Before enabling this option, arch code must be audited
554           to ensure there are no races in concurrent read/write of
555           cputime_t. For example, reading/writing 64-bit cputime_t on
556           some 32-bit arches may require multiple accesses, so proper
557           locking is needed to protect against concurrent accesses.
558
559
560 config HAVE_IRQ_TIME_ACCOUNTING
561         bool
562         help
563           Archs need to ensure they use a high enough resolution clock to
564           support irq time accounting and then call enable_sched_clock_irqtime().
565
566 config HAVE_MOVE_PMD
567         bool
568         help
569           Archs that select this are able to move page tables at the PMD level.
570
571 config HAVE_ARCH_TRANSPARENT_HUGEPAGE
572         bool
573
574 config HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD
575         bool
576
577 config HAVE_ARCH_HUGE_VMAP
578         bool
579
580 config ARCH_WANT_HUGE_PMD_SHARE
581         bool
582
583 config HAVE_ARCH_SOFT_DIRTY
584         bool
585
586 config HAVE_MOD_ARCH_SPECIFIC
587         bool
588         help
589           The arch uses struct mod_arch_specific to store data.  Many arches
590           just need a simple module loader without arch specific data - those
591           should not enable this.
592
593 config MODULES_USE_ELF_RELA
594         bool
595         help
596           Modules only use ELF RELA relocations.  Modules with ELF REL
597           relocations will give an error.
598
599 config MODULES_USE_ELF_REL
600         bool
601         help
602           Modules only use ELF REL relocations.  Modules with ELF RELA
603           relocations will give an error.
604
605 config HAVE_IRQ_EXIT_ON_IRQ_STACK
606         bool
607         help
608           Architecture doesn't only execute the irq handler on the irq stack
609           but also irq_exit(). This way we can process softirqs on this irq
610           stack instead of switching to a new one when we call __do_softirq()
611           in the end of an hardirq.
612           This spares a stack switch and improves cache usage on softirq
613           processing.
614
615 config PGTABLE_LEVELS
616         int
617         default 2
618
619 config ARCH_HAS_ELF_RANDOMIZE
620         bool
621         help
622           An architecture supports choosing randomized locations for
623           stack, mmap, brk, and ET_DYN. Defined functions:
624           - arch_mmap_rnd()
625           - arch_randomize_brk()
626
627 config HAVE_ARCH_MMAP_RND_BITS
628         bool
629         help
630           An arch should select this symbol if it supports setting a variable
631           number of bits for use in establishing the base address for mmap
632           allocations, has MMU enabled and provides values for both:
633           - ARCH_MMAP_RND_BITS_MIN
634           - ARCH_MMAP_RND_BITS_MAX
635
636 config HAVE_EXIT_THREAD
637         bool
638         help
639           An architecture implements exit_thread.
640
641 config ARCH_MMAP_RND_BITS_MIN
642         int
643
644 config ARCH_MMAP_RND_BITS_MAX
645         int
646
647 config ARCH_MMAP_RND_BITS_DEFAULT
648         int
649
650 config ARCH_MMAP_RND_BITS
651         int "Number of bits to use for ASLR of mmap base address" if EXPERT
652         range ARCH_MMAP_RND_BITS_MIN ARCH_MMAP_RND_BITS_MAX
653         default ARCH_MMAP_RND_BITS_DEFAULT if ARCH_MMAP_RND_BITS_DEFAULT
654         default ARCH_MMAP_RND_BITS_MIN
655         depends on HAVE_ARCH_MMAP_RND_BITS
656         help
657           This value can be used to select the number of bits to use to
658           determine the random offset to the base address of vma regions
659           resulting from mmap allocations. This value will be bounded
660           by the architecture's minimum and maximum supported values.
661
662           This value can be changed after boot using the
663           /proc/sys/vm/mmap_rnd_bits tunable
664
665 config HAVE_ARCH_MMAP_RND_COMPAT_BITS
666         bool
667         help
668           An arch should select this symbol if it supports running applications
669           in compatibility mode, supports setting a variable number of bits for
670           use in establishing the base address for mmap allocations, has MMU
671           enabled and provides values for both:
672           - ARCH_MMAP_RND_COMPAT_BITS_MIN
673           - ARCH_MMAP_RND_COMPAT_BITS_MAX
674
675 config ARCH_MMAP_RND_COMPAT_BITS_MIN
676         int
677
678 config ARCH_MMAP_RND_COMPAT_BITS_MAX
679         int
680
681 config ARCH_MMAP_RND_COMPAT_BITS_DEFAULT
682         int
683
684 config ARCH_MMAP_RND_COMPAT_BITS
685         int "Number of bits to use for ASLR of mmap base address for compatible applications" if EXPERT
686         range ARCH_MMAP_RND_COMPAT_BITS_MIN ARCH_MMAP_RND_COMPAT_BITS_MAX
687         default ARCH_MMAP_RND_COMPAT_BITS_DEFAULT if ARCH_MMAP_RND_COMPAT_BITS_DEFAULT
688         default ARCH_MMAP_RND_COMPAT_BITS_MIN
689         depends on HAVE_ARCH_MMAP_RND_COMPAT_BITS
690         help
691           This value can be used to select the number of bits to use to
692           determine the random offset to the base address of vma regions
693           resulting from mmap allocations for compatible applications This
694           value will be bounded by the architecture's minimum and maximum
695           supported values.
696
697           This value can be changed after boot using the
698           /proc/sys/vm/mmap_rnd_compat_bits tunable
699
700 config HAVE_ARCH_COMPAT_MMAP_BASES
701         bool
702         help
703           This allows 64bit applications to invoke 32-bit mmap() syscall
704           and vice-versa 32-bit applications to call 64-bit mmap().
705           Required for applications doing different bitness syscalls.
706
707 config HAVE_COPY_THREAD_TLS
708         bool
709         help
710           Architecture provides copy_thread_tls to accept tls argument via
711           normal C parameter passing, rather than extracting the syscall
712           argument from pt_regs.
713
714 config HAVE_STACK_VALIDATION
715         bool
716         help
717           Architecture supports the 'objtool check' host tool command, which
718           performs compile-time stack metadata validation.
719
720 config HAVE_RELIABLE_STACKTRACE
721         bool
722         help
723           Architecture has a save_stack_trace_tsk_reliable() function which
724           only returns a stack trace if it can guarantee the trace is reliable.
725
726 config HAVE_ARCH_HASH
727         bool
728         default n
729         help
730           If this is set, the architecture provides an <asm/hash.h>
731           file which provides platform-specific implementations of some
732           functions in <linux/hash.h> or fs/namei.c.
733
734 config HAVE_ARCH_NVRAM_OPS
735         bool
736
737 config ISA_BUS_API
738         def_bool ISA
739
740 #
741 # ABI hall of shame
742 #
743 config CLONE_BACKWARDS
744         bool
745         help
746           Architecture has tls passed as the 4th argument of clone(2),
747           not the 5th one.
748
749 config CLONE_BACKWARDS2
750         bool
751         help
752           Architecture has the first two arguments of clone(2) swapped.
753
754 config CLONE_BACKWARDS3
755         bool
756         help
757           Architecture has tls passed as the 3rd argument of clone(2),
758           not the 5th one.
759
760 config ODD_RT_SIGACTION
761         bool
762         help
763           Architecture has unusual rt_sigaction(2) arguments
764
765 config OLD_SIGSUSPEND
766         bool
767         help
768           Architecture has old sigsuspend(2) syscall, of one-argument variety
769
770 config OLD_SIGSUSPEND3
771         bool
772         help
773           Even weirder antique ABI - three-argument sigsuspend(2)
774
775 config OLD_SIGACTION
776         bool
777         help
778           Architecture has old sigaction(2) syscall.  Nope, not the same
779           as OLD_SIGSUSPEND | OLD_SIGSUSPEND3 - alpha has sigsuspend(2),
780           but fairly different variant of sigaction(2), thanks to OSF/1
781           compatibility...
782
783 config COMPAT_OLD_SIGACTION
784         bool
785
786 config 64BIT_TIME
787         def_bool y
788         help
789           This should be selected by all architectures that need to support
790           new system calls with a 64-bit time_t. This is relevant on all 32-bit
791           architectures, and 64-bit architectures as part of compat syscall
792           handling.
793
794 config COMPAT_32BIT_TIME
795         def_bool !64BIT || COMPAT
796         help
797           This enables 32 bit time_t support in addition to 64 bit time_t support.
798           This is relevant on all 32-bit architectures, and 64-bit architectures
799           as part of compat syscall handling.
800
801 config ARCH_NO_COHERENT_DMA_MMAP
802         bool
803
804 config ARCH_NO_PREEMPT
805         bool
806
807 config CPU_NO_EFFICIENT_FFS
808         def_bool n
809
810 config HAVE_ARCH_VMAP_STACK
811         def_bool n
812         help
813           An arch should select this symbol if it can support kernel stacks
814           in vmalloc space.  This means:
815
816           - vmalloc space must be large enough to hold many kernel stacks.
817             This may rule out many 32-bit architectures.
818
819           - Stacks in vmalloc space need to work reliably.  For example, if
820             vmap page tables are created on demand, either this mechanism
821             needs to work while the stack points to a virtual address with
822             unpopulated page tables or arch code (switch_to() and switch_mm(),
823             most likely) needs to ensure that the stack's page table entries
824             are populated before running on a possibly unpopulated stack.
825
826           - If the stack overflows into a guard page, something reasonable
827             should happen.  The definition of "reasonable" is flexible, but
828             instantly rebooting without logging anything would be unfriendly.
829
830 config VMAP_STACK
831         default y
832         bool "Use a virtually-mapped stack"
833         depends on HAVE_ARCH_VMAP_STACK && !KASAN
834         ---help---
835           Enable this if you want the use virtually-mapped kernel stacks
836           with guard pages.  This causes kernel stack overflows to be
837           caught immediately rather than causing difficult-to-diagnose
838           corruption.
839
840           This is presently incompatible with KASAN because KASAN expects
841           the stack to map directly to the KASAN shadow map using a formula
842           that is incorrect if the stack is in vmalloc space.
843
844 config ARCH_OPTIONAL_KERNEL_RWX
845         def_bool n
846
847 config ARCH_OPTIONAL_KERNEL_RWX_DEFAULT
848         def_bool n
849
850 config ARCH_HAS_STRICT_KERNEL_RWX
851         def_bool n
852
853 config STRICT_KERNEL_RWX
854         bool "Make kernel text and rodata read-only" if ARCH_OPTIONAL_KERNEL_RWX
855         depends on ARCH_HAS_STRICT_KERNEL_RWX
856         default !ARCH_OPTIONAL_KERNEL_RWX || ARCH_OPTIONAL_KERNEL_RWX_DEFAULT
857         help
858           If this is set, kernel text and rodata memory will be made read-only,
859           and non-text memory will be made non-executable. This provides
860           protection against certain security exploits (e.g. executing the heap
861           or modifying text)
862
863           These features are considered standard security practice these days.
864           You should say Y here in almost all cases.
865
866 config ARCH_HAS_STRICT_MODULE_RWX
867         def_bool n
868
869 config STRICT_MODULE_RWX
870         bool "Set loadable kernel module data as NX and text as RO" if ARCH_OPTIONAL_KERNEL_RWX
871         depends on ARCH_HAS_STRICT_MODULE_RWX && MODULES
872         default !ARCH_OPTIONAL_KERNEL_RWX || ARCH_OPTIONAL_KERNEL_RWX_DEFAULT
873         help
874           If this is set, module text and rodata memory will be made read-only,
875           and non-text memory will be made non-executable. This provides
876           protection against certain security exploits (e.g. writing to text)
877
878 # select if the architecture provides an asm/dma-direct.h header
879 config ARCH_HAS_PHYS_TO_DMA
880         bool
881
882 config ARCH_HAS_REFCOUNT
883         bool
884         help
885           An architecture selects this when it has implemented refcount_t
886           using open coded assembly primitives that provide an optimized
887           refcount_t implementation, possibly at the expense of some full
888           refcount state checks of CONFIG_REFCOUNT_FULL=y.
889
890           The refcount overflow check behavior, however, must be retained.
891           Catching overflows is the primary security concern for protecting
892           against bugs in reference counts.
893
894 config REFCOUNT_FULL
895         bool "Perform full reference count validation at the expense of speed"
896         help
897           Enabling this switches the refcounting infrastructure from a fast
898           unchecked atomic_t implementation to a fully state checked
899           implementation, which can be (slightly) slower but provides protections
900           against various use-after-free conditions that can be used in
901           security flaw exploits.
902
903 config HAVE_ARCH_COMPILER_H
904         bool
905         help
906           An architecture can select this if it provides an
907           asm/compiler.h header that should be included after
908           linux/compiler-*.h in order to override macro definitions that those
909           headers generally provide.
910
911 config HAVE_ARCH_PREL32_RELOCATIONS
912         bool
913         help
914           May be selected by an architecture if it supports place-relative
915           32-bit relocations, both in the toolchain and in the module loader,
916           in which case relative references can be used in special sections
917           for PCI fixup, initcalls etc which are only half the size on 64 bit
918           architectures, and don't require runtime relocation on relocatable
919           kernels.
920
921 config ARCH_USE_MEMREMAP_PROT
922         bool
923
924 config LOCK_EVENT_COUNTS
925         bool "Locking event counts collection"
926         depends on DEBUG_FS
927         ---help---
928           Enable light-weight counting of various locking related events
929           in the system with minimal performance impact. This reduces
930           the chance of application behavior change because of timing
931           differences. The counts are reported via debugfs.
932
933 source "kernel/gcov/Kconfig"
934
935 source "scripts/gcc-plugins/Kconfig"
936
937 endmenu