xref: /openbmc/linux/arch/Kconfig (revision 565485b8)
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#
10source "arch/$(SRCARCH)/Kconfig"
11
12menu "General architecture-dependent options"
13
14config CRASH_CORE
15	bool
16
17config KEXEC_CORE
18	select CRASH_CORE
19	bool
20
21config HAVE_IMA_KEXEC
22	bool
23
24config HOTPLUG_SMT
25	bool
26
27config 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
40config 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
52config HAVE_OPROFILE
53	bool
54
55config OPROFILE_NMI_TIMER
56	def_bool y
57	depends on PERF_EVENTS && HAVE_PERF_EVENTS_NMI && !PPC64
58
59config 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
71config 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
97config 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
103config OPTPROBES
104	def_bool y
105	depends on KPROBES && HAVE_OPTPROBES
106	select TASKS_RCU if PREEMPT
107
108config 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
117config 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
131config 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
147config 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
166config 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
185config KRETPROBES
186	def_bool y
187	depends on KPROBES && HAVE_KRETPROBES
188
189config 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
196config HAVE_IOREMAP_PROT
197	bool
198
199config HAVE_KPROBES
200	bool
201
202config HAVE_KRETPROBES
203	bool
204
205config HAVE_OPTPROBES
206	bool
207
208config HAVE_KPROBES_ON_FTRACE
209	bool
210
211config HAVE_FUNCTION_ERROR_INJECTION
212	bool
213
214config 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#
230config HAVE_ARCH_TRACEHOOK
231	bool
232
233config HAVE_DMA_CONTIGUOUS
234	bool
235
236config GENERIC_SMP_IDLE_THREAD
237       bool
238
239config GENERIC_IDLE_POLL_SETUP
240       bool
241
242config 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# Select if arch has all set_memory_ro/rw/x/nx() functions in asm/cacheflush.h
249config ARCH_HAS_SET_MEMORY
250	bool
251
252# Select if arch init_task must go in the __init_task_data section
253config ARCH_TASK_STRUCT_ON_STACK
254       bool
255
256# Select if arch has its private alloc_task_struct() function
257config ARCH_TASK_STRUCT_ALLOCATOR
258	bool
259
260config HAVE_ARCH_THREAD_STRUCT_WHITELIST
261	bool
262	depends on !ARCH_TASK_STRUCT_ALLOCATOR
263	help
264	  An architecture should select this to provide hardened usercopy
265	  knowledge about what region of the thread_struct should be
266	  whitelisted for copying to userspace. Normally this is only the
267	  FPU registers. Specifically, arch_thread_struct_whitelist()
268	  should be implemented. Without this, the entire thread_struct
269	  field in task_struct will be left whitelisted.
270
271# Select if arch has its private alloc_thread_stack() function
272config ARCH_THREAD_STACK_ALLOCATOR
273	bool
274
275# Select if arch wants to size task_struct dynamically via arch_task_struct_size:
276config ARCH_WANTS_DYNAMIC_TASK_STRUCT
277	bool
278
279config HAVE_REGS_AND_STACK_ACCESS_API
280	bool
281	help
282	  This symbol should be selected by an architecure if it supports
283	  the API needed to access registers and stack entries from pt_regs,
284	  declared in asm/ptrace.h
285	  For example the kprobes-based event tracer needs this API.
286
287config HAVE_RSEQ
288	bool
289	depends on HAVE_REGS_AND_STACK_ACCESS_API
290	help
291	  This symbol should be selected by an architecture if it
292	  supports an implementation of restartable sequences.
293
294config HAVE_FUNCTION_ARG_ACCESS_API
295	bool
296	help
297	  This symbol should be selected by an architecure if it supports
298	  the API needed to access function arguments from pt_regs,
299	  declared in asm/ptrace.h
300
301config HAVE_CLK
302	bool
303	help
304	  The <linux/clk.h> calls support software clock gating and
305	  thus are a key power management tool on many systems.
306
307config HAVE_HW_BREAKPOINT
308	bool
309	depends on PERF_EVENTS
310
311config HAVE_MIXED_BREAKPOINTS_REGS
312	bool
313	depends on HAVE_HW_BREAKPOINT
314	help
315	  Depending on the arch implementation of hardware breakpoints,
316	  some of them have separate registers for data and instruction
317	  breakpoints addresses, others have mixed registers to store
318	  them but define the access type in a control register.
319	  Select this option if your arch implements breakpoints under the
320	  latter fashion.
321
322config HAVE_USER_RETURN_NOTIFIER
323	bool
324
325config HAVE_PERF_EVENTS_NMI
326	bool
327	help
328	  System hardware can generate an NMI using the perf event
329	  subsystem.  Also has support for calculating CPU cycle events
330	  to determine how many clock cycles in a given period.
331
332config HAVE_HARDLOCKUP_DETECTOR_PERF
333	bool
334	depends on HAVE_PERF_EVENTS_NMI
335	help
336	  The arch chooses to use the generic perf-NMI-based hardlockup
337	  detector. Must define HAVE_PERF_EVENTS_NMI.
338
339config HAVE_NMI_WATCHDOG
340	depends on HAVE_NMI
341	bool
342	help
343	  The arch provides a low level NMI watchdog. It provides
344	  asm/nmi.h, and defines its own arch_touch_nmi_watchdog().
345
346config HAVE_HARDLOCKUP_DETECTOR_ARCH
347	bool
348	select HAVE_NMI_WATCHDOG
349	help
350	  The arch chooses to provide its own hardlockup detector, which is
351	  a superset of the HAVE_NMI_WATCHDOG. It also conforms to config
352	  interfaces and parameters provided by hardlockup detector subsystem.
353
354config HAVE_PERF_REGS
355	bool
356	help
357	  Support selective register dumps for perf events. This includes
358	  bit-mapping of each registers and a unique architecture id.
359
360config HAVE_PERF_USER_STACK_DUMP
361	bool
362	help
363	  Support user stack dumps for perf event samples. This needs
364	  access to the user stack pointer which is not unified across
365	  architectures.
366
367config HAVE_ARCH_JUMP_LABEL
368	bool
369
370config HAVE_ARCH_JUMP_LABEL_RELATIVE
371	bool
372
373config HAVE_RCU_TABLE_FREE
374	bool
375
376config HAVE_RCU_TABLE_INVALIDATE
377	bool
378
379config ARCH_HAVE_NMI_SAFE_CMPXCHG
380	bool
381
382config HAVE_ALIGNED_STRUCT_PAGE
383	bool
384	help
385	  This makes sure that struct pages are double word aligned and that
386	  e.g. the SLUB allocator can perform double word atomic operations
387	  on a struct page for better performance. However selecting this
388	  might increase the size of a struct page by a word.
389
390config HAVE_CMPXCHG_LOCAL
391	bool
392
393config HAVE_CMPXCHG_DOUBLE
394	bool
395
396config ARCH_WEAK_RELEASE_ACQUIRE
397	bool
398
399config ARCH_WANT_IPC_PARSE_VERSION
400	bool
401
402config ARCH_WANT_COMPAT_IPC_PARSE_VERSION
403	bool
404
405config ARCH_WANT_OLD_COMPAT_IPC
406	select ARCH_WANT_COMPAT_IPC_PARSE_VERSION
407	bool
408
409config HAVE_ARCH_SECCOMP_FILTER
410	bool
411	help
412	  An arch should select this symbol if it provides all of these things:
413	  - syscall_get_arch()
414	  - syscall_get_arguments()
415	  - syscall_rollback()
416	  - syscall_set_return_value()
417	  - SIGSYS siginfo_t support
418	  - secure_computing is called from a ptrace_event()-safe context
419	  - secure_computing return value is checked and a return value of -1
420	    results in the system call being skipped immediately.
421	  - seccomp syscall wired up
422
423config SECCOMP_FILTER
424	def_bool y
425	depends on HAVE_ARCH_SECCOMP_FILTER && SECCOMP && NET
426	help
427	  Enable tasks to build secure computing environments defined
428	  in terms of Berkeley Packet Filter programs which implement
429	  task-defined system call filtering polices.
430
431	  See Documentation/userspace-api/seccomp_filter.rst for details.
432
433config HAVE_ARCH_STACKLEAK
434	bool
435	help
436	  An architecture should select this if it has the code which
437	  fills the used part of the kernel stack with the STACKLEAK_POISON
438	  value before returning from system calls.
439
440config HAVE_STACKPROTECTOR
441	bool
442	help
443	  An arch should select this symbol if:
444	  - it has implemented a stack canary (e.g. __stack_chk_guard)
445
446config CC_HAS_STACKPROTECTOR_NONE
447	def_bool $(cc-option,-fno-stack-protector)
448
449config STACKPROTECTOR
450	bool "Stack Protector buffer overflow detection"
451	depends on HAVE_STACKPROTECTOR
452	depends on $(cc-option,-fstack-protector)
453	default y
454	help
455	  This option turns on the "stack-protector" GCC feature. This
456	  feature puts, at the beginning of functions, a canary value on
457	  the stack just before the return address, and validates
458	  the value just before actually returning.  Stack based buffer
459	  overflows (that need to overwrite this return address) now also
460	  overwrite the canary, which gets detected and the attack is then
461	  neutralized via a kernel panic.
462
463	  Functions will have the stack-protector canary logic added if they
464	  have an 8-byte or larger character array on the stack.
465
466	  This feature requires gcc version 4.2 or above, or a distribution
467	  gcc with the feature backported ("-fstack-protector").
468
469	  On an x86 "defconfig" build, this feature adds canary checks to
470	  about 3% of all kernel functions, which increases kernel code size
471	  by about 0.3%.
472
473config STACKPROTECTOR_STRONG
474	bool "Strong Stack Protector"
475	depends on STACKPROTECTOR
476	depends on $(cc-option,-fstack-protector-strong)
477	default y
478	help
479	  Functions will have the stack-protector canary logic added in any
480	  of the following conditions:
481
482	  - local variable's address used as part of the right hand side of an
483	    assignment or function argument
484	  - local variable is an array (or union containing an array),
485	    regardless of array type or length
486	  - uses register local variables
487
488	  This feature requires gcc version 4.9 or above, or a distribution
489	  gcc with the feature backported ("-fstack-protector-strong").
490
491	  On an x86 "defconfig" build, this feature adds canary checks to
492	  about 20% of all kernel functions, which increases the kernel code
493	  size by about 2%.
494
495config HAVE_ARCH_WITHIN_STACK_FRAMES
496	bool
497	help
498	  An architecture should select this if it can walk the kernel stack
499	  frames to determine if an object is part of either the arguments
500	  or local variables (i.e. that it excludes saved return addresses,
501	  and similar) by implementing an inline arch_within_stack_frames(),
502	  which is used by CONFIG_HARDENED_USERCOPY.
503
504config HAVE_CONTEXT_TRACKING
505	bool
506	help
507	  Provide kernel/user boundaries probes necessary for subsystems
508	  that need it, such as userspace RCU extended quiescent state.
509	  Syscalls need to be wrapped inside user_exit()-user_enter() through
510	  the slow path using TIF_NOHZ flag. Exceptions handlers must be
511	  wrapped as well. Irqs are already protected inside
512	  rcu_irq_enter/rcu_irq_exit() but preemption or signal handling on
513	  irq exit still need to be protected.
514
515config HAVE_VIRT_CPU_ACCOUNTING
516	bool
517
518config ARCH_HAS_SCALED_CPUTIME
519	bool
520
521config HAVE_VIRT_CPU_ACCOUNTING_GEN
522	bool
523	default y if 64BIT
524	help
525	  With VIRT_CPU_ACCOUNTING_GEN, cputime_t becomes 64-bit.
526	  Before enabling this option, arch code must be audited
527	  to ensure there are no races in concurrent read/write of
528	  cputime_t. For example, reading/writing 64-bit cputime_t on
529	  some 32-bit arches may require multiple accesses, so proper
530	  locking is needed to protect against concurrent accesses.
531
532
533config HAVE_IRQ_TIME_ACCOUNTING
534	bool
535	help
536	  Archs need to ensure they use a high enough resolution clock to
537	  support irq time accounting and then call enable_sched_clock_irqtime().
538
539config HAVE_MOVE_PMD
540	bool
541	help
542	  Archs that select this are able to move page tables at the PMD level.
543
544config HAVE_ARCH_TRANSPARENT_HUGEPAGE
545	bool
546
547config HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD
548	bool
549
550config HAVE_ARCH_HUGE_VMAP
551	bool
552
553config HAVE_ARCH_SOFT_DIRTY
554	bool
555
556config HAVE_MOD_ARCH_SPECIFIC
557	bool
558	help
559	  The arch uses struct mod_arch_specific to store data.  Many arches
560	  just need a simple module loader without arch specific data - those
561	  should not enable this.
562
563config MODULES_USE_ELF_RELA
564	bool
565	help
566	  Modules only use ELF RELA relocations.  Modules with ELF REL
567	  relocations will give an error.
568
569config MODULES_USE_ELF_REL
570	bool
571	help
572	  Modules only use ELF REL relocations.  Modules with ELF RELA
573	  relocations will give an error.
574
575config HAVE_IRQ_EXIT_ON_IRQ_STACK
576	bool
577	help
578	  Architecture doesn't only execute the irq handler on the irq stack
579	  but also irq_exit(). This way we can process softirqs on this irq
580	  stack instead of switching to a new one when we call __do_softirq()
581	  in the end of an hardirq.
582	  This spares a stack switch and improves cache usage on softirq
583	  processing.
584
585config PGTABLE_LEVELS
586	int
587	default 2
588
589config ARCH_HAS_ELF_RANDOMIZE
590	bool
591	help
592	  An architecture supports choosing randomized locations for
593	  stack, mmap, brk, and ET_DYN. Defined functions:
594	  - arch_mmap_rnd()
595	  - arch_randomize_brk()
596
597config HAVE_ARCH_MMAP_RND_BITS
598	bool
599	help
600	  An arch should select this symbol if it supports setting a variable
601	  number of bits for use in establishing the base address for mmap
602	  allocations, has MMU enabled and provides values for both:
603	  - ARCH_MMAP_RND_BITS_MIN
604	  - ARCH_MMAP_RND_BITS_MAX
605
606config HAVE_EXIT_THREAD
607	bool
608	help
609	  An architecture implements exit_thread.
610
611config ARCH_MMAP_RND_BITS_MIN
612	int
613
614config ARCH_MMAP_RND_BITS_MAX
615	int
616
617config ARCH_MMAP_RND_BITS_DEFAULT
618	int
619
620config ARCH_MMAP_RND_BITS
621	int "Number of bits to use for ASLR of mmap base address" if EXPERT
622	range ARCH_MMAP_RND_BITS_MIN ARCH_MMAP_RND_BITS_MAX
623	default ARCH_MMAP_RND_BITS_DEFAULT if ARCH_MMAP_RND_BITS_DEFAULT
624	default ARCH_MMAP_RND_BITS_MIN
625	depends on HAVE_ARCH_MMAP_RND_BITS
626	help
627	  This value can be used to select the number of bits to use to
628	  determine the random offset to the base address of vma regions
629	  resulting from mmap allocations. This value will be bounded
630	  by the architecture's minimum and maximum supported values.
631
632	  This value can be changed after boot using the
633	  /proc/sys/vm/mmap_rnd_bits tunable
634
635config HAVE_ARCH_MMAP_RND_COMPAT_BITS
636	bool
637	help
638	  An arch should select this symbol if it supports running applications
639	  in compatibility mode, supports setting a variable number of bits for
640	  use in establishing the base address for mmap allocations, has MMU
641	  enabled and provides values for both:
642	  - ARCH_MMAP_RND_COMPAT_BITS_MIN
643	  - ARCH_MMAP_RND_COMPAT_BITS_MAX
644
645config ARCH_MMAP_RND_COMPAT_BITS_MIN
646	int
647
648config ARCH_MMAP_RND_COMPAT_BITS_MAX
649	int
650
651config ARCH_MMAP_RND_COMPAT_BITS_DEFAULT
652	int
653
654config ARCH_MMAP_RND_COMPAT_BITS
655	int "Number of bits to use for ASLR of mmap base address for compatible applications" if EXPERT
656	range ARCH_MMAP_RND_COMPAT_BITS_MIN ARCH_MMAP_RND_COMPAT_BITS_MAX
657	default ARCH_MMAP_RND_COMPAT_BITS_DEFAULT if ARCH_MMAP_RND_COMPAT_BITS_DEFAULT
658	default ARCH_MMAP_RND_COMPAT_BITS_MIN
659	depends on HAVE_ARCH_MMAP_RND_COMPAT_BITS
660	help
661	  This value can be used to select the number of bits to use to
662	  determine the random offset to the base address of vma regions
663	  resulting from mmap allocations for compatible applications This
664	  value will be bounded by the architecture's minimum and maximum
665	  supported values.
666
667	  This value can be changed after boot using the
668	  /proc/sys/vm/mmap_rnd_compat_bits tunable
669
670config HAVE_ARCH_COMPAT_MMAP_BASES
671	bool
672	help
673	  This allows 64bit applications to invoke 32-bit mmap() syscall
674	  and vice-versa 32-bit applications to call 64-bit mmap().
675	  Required for applications doing different bitness syscalls.
676
677config HAVE_COPY_THREAD_TLS
678	bool
679	help
680	  Architecture provides copy_thread_tls to accept tls argument via
681	  normal C parameter passing, rather than extracting the syscall
682	  argument from pt_regs.
683
684config HAVE_STACK_VALIDATION
685	bool
686	help
687	  Architecture supports the 'objtool check' host tool command, which
688	  performs compile-time stack metadata validation.
689
690config HAVE_RELIABLE_STACKTRACE
691	bool
692	help
693	  Architecture has a save_stack_trace_tsk_reliable() function which
694	  only returns a stack trace if it can guarantee the trace is reliable.
695
696config HAVE_ARCH_HASH
697	bool
698	default n
699	help
700	  If this is set, the architecture provides an <asm/hash.h>
701	  file which provides platform-specific implementations of some
702	  functions in <linux/hash.h> or fs/namei.c.
703
704config ISA_BUS_API
705	def_bool ISA
706
707#
708# ABI hall of shame
709#
710config CLONE_BACKWARDS
711	bool
712	help
713	  Architecture has tls passed as the 4th argument of clone(2),
714	  not the 5th one.
715
716config CLONE_BACKWARDS2
717	bool
718	help
719	  Architecture has the first two arguments of clone(2) swapped.
720
721config CLONE_BACKWARDS3
722	bool
723	help
724	  Architecture has tls passed as the 3rd argument of clone(2),
725	  not the 5th one.
726
727config ODD_RT_SIGACTION
728	bool
729	help
730	  Architecture has unusual rt_sigaction(2) arguments
731
732config OLD_SIGSUSPEND
733	bool
734	help
735	  Architecture has old sigsuspend(2) syscall, of one-argument variety
736
737config OLD_SIGSUSPEND3
738	bool
739	help
740	  Even weirder antique ABI - three-argument sigsuspend(2)
741
742config OLD_SIGACTION
743	bool
744	help
745	  Architecture has old sigaction(2) syscall.  Nope, not the same
746	  as OLD_SIGSUSPEND | OLD_SIGSUSPEND3 - alpha has sigsuspend(2),
747	  but fairly different variant of sigaction(2), thanks to OSF/1
748	  compatibility...
749
750config COMPAT_OLD_SIGACTION
751	bool
752
753config 64BIT_TIME
754	def_bool ARCH_HAS_64BIT_TIME
755	help
756	  This should be selected by all architectures that need to support
757	  new system calls with a 64-bit time_t. This is relevant on all 32-bit
758	  architectures, and 64-bit architectures as part of compat syscall
759	  handling.
760
761config COMPAT_32BIT_TIME
762	def_bool (!64BIT && 64BIT_TIME) || COMPAT
763	help
764	  This enables 32 bit time_t support in addition to 64 bit time_t support.
765	  This is relevant on all 32-bit architectures, and 64-bit architectures
766	  as part of compat syscall handling.
767
768config ARCH_NO_COHERENT_DMA_MMAP
769	bool
770
771config ARCH_NO_PREEMPT
772	bool
773
774config CPU_NO_EFFICIENT_FFS
775	def_bool n
776
777config HAVE_ARCH_VMAP_STACK
778	def_bool n
779	help
780	  An arch should select this symbol if it can support kernel stacks
781	  in vmalloc space.  This means:
782
783	  - vmalloc space must be large enough to hold many kernel stacks.
784	    This may rule out many 32-bit architectures.
785
786	  - Stacks in vmalloc space need to work reliably.  For example, if
787	    vmap page tables are created on demand, either this mechanism
788	    needs to work while the stack points to a virtual address with
789	    unpopulated page tables or arch code (switch_to() and switch_mm(),
790	    most likely) needs to ensure that the stack's page table entries
791	    are populated before running on a possibly unpopulated stack.
792
793	  - If the stack overflows into a guard page, something reasonable
794	    should happen.  The definition of "reasonable" is flexible, but
795	    instantly rebooting without logging anything would be unfriendly.
796
797config VMAP_STACK
798	default y
799	bool "Use a virtually-mapped stack"
800	depends on HAVE_ARCH_VMAP_STACK && !KASAN
801	---help---
802	  Enable this if you want the use virtually-mapped kernel stacks
803	  with guard pages.  This causes kernel stack overflows to be
804	  caught immediately rather than causing difficult-to-diagnose
805	  corruption.
806
807	  This is presently incompatible with KASAN because KASAN expects
808	  the stack to map directly to the KASAN shadow map using a formula
809	  that is incorrect if the stack is in vmalloc space.
810
811config ARCH_OPTIONAL_KERNEL_RWX
812	def_bool n
813
814config ARCH_OPTIONAL_KERNEL_RWX_DEFAULT
815	def_bool n
816
817config ARCH_HAS_STRICT_KERNEL_RWX
818	def_bool n
819
820config STRICT_KERNEL_RWX
821	bool "Make kernel text and rodata read-only" if ARCH_OPTIONAL_KERNEL_RWX
822	depends on ARCH_HAS_STRICT_KERNEL_RWX
823	default !ARCH_OPTIONAL_KERNEL_RWX || ARCH_OPTIONAL_KERNEL_RWX_DEFAULT
824	help
825	  If this is set, kernel text and rodata memory will be made read-only,
826	  and non-text memory will be made non-executable. This provides
827	  protection against certain security exploits (e.g. executing the heap
828	  or modifying text)
829
830	  These features are considered standard security practice these days.
831	  You should say Y here in almost all cases.
832
833config ARCH_HAS_STRICT_MODULE_RWX
834	def_bool n
835
836config STRICT_MODULE_RWX
837	bool "Set loadable kernel module data as NX and text as RO" if ARCH_OPTIONAL_KERNEL_RWX
838	depends on ARCH_HAS_STRICT_MODULE_RWX && MODULES
839	default !ARCH_OPTIONAL_KERNEL_RWX || ARCH_OPTIONAL_KERNEL_RWX_DEFAULT
840	help
841	  If this is set, module text and rodata memory will be made read-only,
842	  and non-text memory will be made non-executable. This provides
843	  protection against certain security exploits (e.g. writing to text)
844
845# select if the architecture provides an asm/dma-direct.h header
846config ARCH_HAS_PHYS_TO_DMA
847	bool
848
849config ARCH_HAS_REFCOUNT
850	bool
851	help
852	  An architecture selects this when it has implemented refcount_t
853	  using open coded assembly primitives that provide an optimized
854	  refcount_t implementation, possibly at the expense of some full
855	  refcount state checks of CONFIG_REFCOUNT_FULL=y.
856
857	  The refcount overflow check behavior, however, must be retained.
858	  Catching overflows is the primary security concern for protecting
859	  against bugs in reference counts.
860
861config REFCOUNT_FULL
862	bool "Perform full reference count validation at the expense of speed"
863	help
864	  Enabling this switches the refcounting infrastructure from a fast
865	  unchecked atomic_t implementation to a fully state checked
866	  implementation, which can be (slightly) slower but provides protections
867	  against various use-after-free conditions that can be used in
868	  security flaw exploits.
869
870config HAVE_ARCH_COMPILER_H
871	bool
872	help
873	  An architecture can select this if it provides an
874	  asm/compiler.h header that should be included after
875	  linux/compiler-*.h in order to override macro definitions that those
876	  headers generally provide.
877
878config HAVE_ARCH_PREL32_RELOCATIONS
879	bool
880	help
881	  May be selected by an architecture if it supports place-relative
882	  32-bit relocations, both in the toolchain and in the module loader,
883	  in which case relative references can be used in special sections
884	  for PCI fixup, initcalls etc which are only half the size on 64 bit
885	  architectures, and don't require runtime relocation on relocatable
886	  kernels.
887
888source "kernel/gcov/Kconfig"
889
890source "scripts/gcc-plugins/Kconfig"
891
892endmenu
893