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