xref: /linux/arch/Kconfig (revision c61f13eaa1ee17728c41370100d2d45c254ce76f)
1#
2# General architecture dependent options
3#
4
5config KEXEC_CORE
6	bool
7
8config HAVE_IMA_KEXEC
9	bool
10
11config OPROFILE
12	tristate "OProfile system profiling"
13	depends on PROFILING
14	depends on HAVE_OPROFILE
15	select RING_BUFFER
16	select RING_BUFFER_ALLOW_SWAP
17	help
18	  OProfile is a profiling system capable of profiling the
19	  whole system, include the kernel, kernel modules, libraries,
20	  and applications.
21
22	  If unsure, say N.
23
24config OPROFILE_EVENT_MULTIPLEX
25	bool "OProfile multiplexing support (EXPERIMENTAL)"
26	default n
27	depends on OPROFILE && X86
28	help
29	  The number of hardware counters is limited. The multiplexing
30	  feature enables OProfile to gather more events than counters
31	  are provided by the hardware. This is realized by switching
32	  between events at an user specified time interval.
33
34	  If unsure, say N.
35
36config HAVE_OPROFILE
37	bool
38
39config OPROFILE_NMI_TIMER
40	def_bool y
41	depends on PERF_EVENTS && HAVE_PERF_EVENTS_NMI && !PPC64
42
43config KPROBES
44	bool "Kprobes"
45	depends on MODULES
46	depends on HAVE_KPROBES
47	select KALLSYMS
48	help
49	  Kprobes allows you to trap at almost any kernel address and
50	  execute a callback function.  register_kprobe() establishes
51	  a probepoint and specifies the callback.  Kprobes is useful
52	  for kernel debugging, non-intrusive instrumentation and testing.
53	  If in doubt, say "N".
54
55config JUMP_LABEL
56       bool "Optimize very unlikely/likely branches"
57       depends on HAVE_ARCH_JUMP_LABEL
58       help
59         This option enables a transparent branch optimization that
60	 makes certain almost-always-true or almost-always-false branch
61	 conditions even cheaper to execute within the kernel.
62
63	 Certain performance-sensitive kernel code, such as trace points,
64	 scheduler functionality, networking code and KVM have such
65	 branches and include support for this optimization technique.
66
67         If it is detected that the compiler has support for "asm goto",
68	 the kernel will compile such branches with just a nop
69	 instruction. When the condition flag is toggled to true, the
70	 nop will be converted to a jump instruction to execute the
71	 conditional block of instructions.
72
73	 This technique lowers overhead and stress on the branch prediction
74	 of the processor and generally makes the kernel faster. The update
75	 of the condition is slower, but those are always very rare.
76
77	 ( On 32-bit x86, the necessary options added to the compiler
78	   flags may increase the size of the kernel slightly. )
79
80config STATIC_KEYS_SELFTEST
81	bool "Static key selftest"
82	depends on JUMP_LABEL
83	help
84	  Boot time self-test of the branch patching code.
85
86config OPTPROBES
87	def_bool y
88	depends on KPROBES && HAVE_OPTPROBES
89	depends on !PREEMPT
90
91config KPROBES_ON_FTRACE
92	def_bool y
93	depends on KPROBES && HAVE_KPROBES_ON_FTRACE
94	depends on DYNAMIC_FTRACE_WITH_REGS
95	help
96	 If function tracer is enabled and the arch supports full
97	 passing of pt_regs to function tracing, then kprobes can
98	 optimize on top of function tracing.
99
100config UPROBES
101	def_bool n
102	depends on ARCH_SUPPORTS_UPROBES
103	help
104	  Uprobes is the user-space counterpart to kprobes: they
105	  enable instrumentation applications (such as 'perf probe')
106	  to establish unintrusive probes in user-space binaries and
107	  libraries, by executing handler functions when the probes
108	  are hit by user-space applications.
109
110	  ( These probes come in the form of single-byte breakpoints,
111	    managed by the kernel and kept transparent to the probed
112	    application. )
113
114config HAVE_64BIT_ALIGNED_ACCESS
115	def_bool 64BIT && !HAVE_EFFICIENT_UNALIGNED_ACCESS
116	help
117	  Some architectures require 64 bit accesses to be 64 bit
118	  aligned, which also requires structs containing 64 bit values
119	  to be 64 bit aligned too. This includes some 32 bit
120	  architectures which can do 64 bit accesses, as well as 64 bit
121	  architectures without unaligned access.
122
123	  This symbol should be selected by an architecture if 64 bit
124	  accesses are required to be 64 bit aligned in this way even
125	  though it is not a 64 bit architecture.
126
127	  See Documentation/unaligned-memory-access.txt for more
128	  information on the topic of unaligned memory accesses.
129
130config HAVE_EFFICIENT_UNALIGNED_ACCESS
131	bool
132	help
133	  Some architectures are unable to perform unaligned accesses
134	  without the use of get_unaligned/put_unaligned. Others are
135	  unable to perform such accesses efficiently (e.g. trap on
136	  unaligned access and require fixing it up in the exception
137	  handler.)
138
139	  This symbol should be selected by an architecture if it can
140	  perform unaligned accesses efficiently to allow different
141	  code paths to be selected for these cases. Some network
142	  drivers, for example, could opt to not fix up alignment
143	  problems with received packets if doing so would not help
144	  much.
145
146	  See Documentation/unaligned-memory-access.txt for more
147	  information on the topic of unaligned memory accesses.
148
149config ARCH_USE_BUILTIN_BSWAP
150       bool
151       help
152	 Modern versions of GCC (since 4.4) have builtin functions
153	 for handling byte-swapping. Using these, instead of the old
154	 inline assembler that the architecture code provides in the
155	 __arch_bswapXX() macros, allows the compiler to see what's
156	 happening and offers more opportunity for optimisation. In
157	 particular, the compiler will be able to combine the byteswap
158	 with a nearby load or store and use load-and-swap or
159	 store-and-swap instructions if the architecture has them. It
160	 should almost *never* result in code which is worse than the
161	 hand-coded assembler in <asm/swab.h>.  But just in case it
162	 does, the use of the builtins is optional.
163
164	 Any architecture with load-and-swap or store-and-swap
165	 instructions should set this. And it shouldn't hurt to set it
166	 on architectures that don't have such instructions.
167
168config KRETPROBES
169	def_bool y
170	depends on KPROBES && HAVE_KRETPROBES
171
172config USER_RETURN_NOTIFIER
173	bool
174	depends on HAVE_USER_RETURN_NOTIFIER
175	help
176	  Provide a kernel-internal notification when a cpu is about to
177	  switch to user mode.
178
179config HAVE_IOREMAP_PROT
180	bool
181
182config HAVE_KPROBES
183	bool
184
185config HAVE_KRETPROBES
186	bool
187
188config HAVE_OPTPROBES
189	bool
190
191config HAVE_KPROBES_ON_FTRACE
192	bool
193
194config HAVE_NMI
195	bool
196
197config HAVE_NMI_WATCHDOG
198	depends on HAVE_NMI
199	bool
200#
201# An arch should select this if it provides all these things:
202#
203#	task_pt_regs()		in asm/processor.h or asm/ptrace.h
204#	arch_has_single_step()	if there is hardware single-step support
205#	arch_has_block_step()	if there is hardware block-step support
206#	asm/syscall.h		supplying asm-generic/syscall.h interface
207#	linux/regset.h		user_regset interfaces
208#	CORE_DUMP_USE_REGSET	#define'd in linux/elf.h
209#	TIF_SYSCALL_TRACE	calls tracehook_report_syscall_{entry,exit}
210#	TIF_NOTIFY_RESUME	calls tracehook_notify_resume()
211#	signal delivery		calls tracehook_signal_handler()
212#
213config HAVE_ARCH_TRACEHOOK
214	bool
215
216config HAVE_DMA_CONTIGUOUS
217	bool
218
219config GENERIC_SMP_IDLE_THREAD
220       bool
221
222config GENERIC_IDLE_POLL_SETUP
223       bool
224
225# Select if arch init_task initializer is different to init/init_task.c
226config ARCH_INIT_TASK
227       bool
228
229# Select if arch has its private alloc_task_struct() function
230config ARCH_TASK_STRUCT_ALLOCATOR
231	bool
232
233# Select if arch has its private alloc_thread_stack() function
234config ARCH_THREAD_STACK_ALLOCATOR
235	bool
236
237# Select if arch wants to size task_struct dynamically via arch_task_struct_size:
238config ARCH_WANTS_DYNAMIC_TASK_STRUCT
239	bool
240
241config HAVE_REGS_AND_STACK_ACCESS_API
242	bool
243	help
244	  This symbol should be selected by an architecure if it supports
245	  the API needed to access registers and stack entries from pt_regs,
246	  declared in asm/ptrace.h
247	  For example the kprobes-based event tracer needs this API.
248
249config HAVE_CLK
250	bool
251	help
252	  The <linux/clk.h> calls support software clock gating and
253	  thus are a key power management tool on many systems.
254
255config HAVE_DMA_API_DEBUG
256	bool
257
258config HAVE_HW_BREAKPOINT
259	bool
260	depends on PERF_EVENTS
261
262config HAVE_MIXED_BREAKPOINTS_REGS
263	bool
264	depends on HAVE_HW_BREAKPOINT
265	help
266	  Depending on the arch implementation of hardware breakpoints,
267	  some of them have separate registers for data and instruction
268	  breakpoints addresses, others have mixed registers to store
269	  them but define the access type in a control register.
270	  Select this option if your arch implements breakpoints under the
271	  latter fashion.
272
273config HAVE_USER_RETURN_NOTIFIER
274	bool
275
276config HAVE_PERF_EVENTS_NMI
277	bool
278	help
279	  System hardware can generate an NMI using the perf event
280	  subsystem.  Also has support for calculating CPU cycle events
281	  to determine how many clock cycles in a given period.
282
283config HAVE_PERF_REGS
284	bool
285	help
286	  Support selective register dumps for perf events. This includes
287	  bit-mapping of each registers and a unique architecture id.
288
289config HAVE_PERF_USER_STACK_DUMP
290	bool
291	help
292	  Support user stack dumps for perf event samples. This needs
293	  access to the user stack pointer which is not unified across
294	  architectures.
295
296config HAVE_ARCH_JUMP_LABEL
297	bool
298
299config HAVE_RCU_TABLE_FREE
300	bool
301
302config ARCH_HAVE_NMI_SAFE_CMPXCHG
303	bool
304
305config HAVE_ALIGNED_STRUCT_PAGE
306	bool
307	help
308	  This makes sure that struct pages are double word aligned and that
309	  e.g. the SLUB allocator can perform double word atomic operations
310	  on a struct page for better performance. However selecting this
311	  might increase the size of a struct page by a word.
312
313config HAVE_CMPXCHG_LOCAL
314	bool
315
316config HAVE_CMPXCHG_DOUBLE
317	bool
318
319config ARCH_WANT_IPC_PARSE_VERSION
320	bool
321
322config ARCH_WANT_COMPAT_IPC_PARSE_VERSION
323	bool
324
325config ARCH_WANT_OLD_COMPAT_IPC
326	select ARCH_WANT_COMPAT_IPC_PARSE_VERSION
327	bool
328
329config HAVE_ARCH_SECCOMP_FILTER
330	bool
331	help
332	  An arch should select this symbol if it provides all of these things:
333	  - syscall_get_arch()
334	  - syscall_get_arguments()
335	  - syscall_rollback()
336	  - syscall_set_return_value()
337	  - SIGSYS siginfo_t support
338	  - secure_computing is called from a ptrace_event()-safe context
339	  - secure_computing return value is checked and a return value of -1
340	    results in the system call being skipped immediately.
341	  - seccomp syscall wired up
342
343config SECCOMP_FILTER
344	def_bool y
345	depends on HAVE_ARCH_SECCOMP_FILTER && SECCOMP && NET
346	help
347	  Enable tasks to build secure computing environments defined
348	  in terms of Berkeley Packet Filter programs which implement
349	  task-defined system call filtering polices.
350
351	  See Documentation/prctl/seccomp_filter.txt for details.
352
353config HAVE_GCC_PLUGINS
354	bool
355	help
356	  An arch should select this symbol if it supports building with
357	  GCC plugins.
358
359menuconfig GCC_PLUGINS
360	bool "GCC plugins"
361	depends on HAVE_GCC_PLUGINS
362	depends on !COMPILE_TEST
363	help
364	  GCC plugins are loadable modules that provide extra features to the
365	  compiler. They are useful for runtime instrumentation and static analysis.
366
367	  See Documentation/gcc-plugins.txt for details.
368
369config GCC_PLUGIN_CYC_COMPLEXITY
370	bool "Compute the cyclomatic complexity of a function" if EXPERT
371	depends on GCC_PLUGINS
372	depends on !COMPILE_TEST
373	help
374	  The complexity M of a function's control flow graph is defined as:
375	   M = E - N + 2P
376	  where
377
378	  E = the number of edges
379	  N = the number of nodes
380	  P = the number of connected components (exit nodes).
381
382	  Enabling this plugin reports the complexity to stderr during the
383	  build. It mainly serves as a simple example of how to create a
384	  gcc plugin for the kernel.
385
386config GCC_PLUGIN_SANCOV
387	bool
388	depends on GCC_PLUGINS
389	help
390	  This plugin inserts a __sanitizer_cov_trace_pc() call at the start of
391	  basic blocks. It supports all gcc versions with plugin support (from
392	  gcc-4.5 on). It is based on the commit "Add fuzzing coverage support"
393	  by Dmitry Vyukov <dvyukov@google.com>.
394
395config GCC_PLUGIN_LATENT_ENTROPY
396	bool "Generate some entropy during boot and runtime"
397	depends on GCC_PLUGINS
398	help
399	  By saying Y here the kernel will instrument some kernel code to
400	  extract some entropy from both original and artificially created
401	  program state.  This will help especially embedded systems where
402	  there is little 'natural' source of entropy normally.  The cost
403	  is some slowdown of the boot process (about 0.5%) and fork and
404	  irq processing.
405
406	  Note that entropy extracted this way is not cryptographically
407	  secure!
408
409	  This plugin was ported from grsecurity/PaX. More information at:
410	   * https://grsecurity.net/
411	   * https://pax.grsecurity.net/
412
413config GCC_PLUGIN_STRUCTLEAK
414	bool "Force initialization of variables containing userspace addresses"
415	depends on GCC_PLUGINS
416	help
417	  This plugin zero-initializes any structures that containing a
418	  __user attribute. This can prevent some classes of information
419	  exposures.
420
421	  This plugin was ported from grsecurity/PaX. More information at:
422	   * https://grsecurity.net/
423	   * https://pax.grsecurity.net/
424
425config GCC_PLUGIN_STRUCTLEAK_VERBOSE
426	bool "Report forcefully initialized variables"
427	depends on GCC_PLUGIN_STRUCTLEAK
428	depends on !COMPILE_TEST
429	help
430	  This option will cause a warning to be printed each time the
431	  structleak plugin finds a variable it thinks needs to be
432	  initialized. Since not all existing initializers are detected
433	  by the plugin, this can produce false positive warnings.
434
435config HAVE_CC_STACKPROTECTOR
436	bool
437	help
438	  An arch should select this symbol if:
439	  - its compiler supports the -fstack-protector option
440	  - it has implemented a stack canary (e.g. __stack_chk_guard)
441
442config CC_STACKPROTECTOR
443	def_bool n
444	help
445	  Set when a stack-protector mode is enabled, so that the build
446	  can enable kernel-side support for the GCC feature.
447
448choice
449	prompt "Stack Protector buffer overflow detection"
450	depends on HAVE_CC_STACKPROTECTOR
451	default CC_STACKPROTECTOR_NONE
452	help
453	  This option turns on the "stack-protector" GCC feature. This
454	  feature puts, at the beginning of functions, a canary value on
455	  the stack just before the return address, and validates
456	  the value just before actually returning.  Stack based buffer
457	  overflows (that need to overwrite this return address) now also
458	  overwrite the canary, which gets detected and the attack is then
459	  neutralized via a kernel panic.
460
461config CC_STACKPROTECTOR_NONE
462	bool "None"
463	help
464	  Disable "stack-protector" GCC feature.
465
466config CC_STACKPROTECTOR_REGULAR
467	bool "Regular"
468	select CC_STACKPROTECTOR
469	help
470	  Functions will have the stack-protector canary logic added if they
471	  have an 8-byte or larger character array on the stack.
472
473	  This feature requires gcc version 4.2 or above, or a distribution
474	  gcc with the feature backported ("-fstack-protector").
475
476	  On an x86 "defconfig" build, this feature adds canary checks to
477	  about 3% of all kernel functions, which increases kernel code size
478	  by about 0.3%.
479
480config CC_STACKPROTECTOR_STRONG
481	bool "Strong"
482	select CC_STACKPROTECTOR
483	help
484	  Functions will have the stack-protector canary logic added in any
485	  of the following conditions:
486
487	  - local variable's address used as part of the right hand side of an
488	    assignment or function argument
489	  - local variable is an array (or union containing an array),
490	    regardless of array type or length
491	  - uses register local variables
492
493	  This feature requires gcc version 4.9 or above, or a distribution
494	  gcc with the feature backported ("-fstack-protector-strong").
495
496	  On an x86 "defconfig" build, this feature adds canary checks to
497	  about 20% of all kernel functions, which increases the kernel code
498	  size by about 2%.
499
500endchoice
501
502config THIN_ARCHIVES
503	bool
504	help
505	  Select this if the architecture wants to use thin archives
506	  instead of ld -r to create the built-in.o files.
507
508config LD_DEAD_CODE_DATA_ELIMINATION
509	bool
510	help
511	  Select this if the architecture wants to do dead code and
512	  data elimination with the linker by compiling with
513	  -ffunction-sections -fdata-sections and linking with
514	  --gc-sections.
515
516	  This requires that the arch annotates or otherwise protects
517	  its external entry points from being discarded. Linker scripts
518	  must also merge .text.*, .data.*, and .bss.* correctly into
519	  output sections. Care must be taken not to pull in unrelated
520	  sections (e.g., '.text.init'). Typically '.' in section names
521	  is used to distinguish them from label names / C identifiers.
522
523config HAVE_ARCH_WITHIN_STACK_FRAMES
524	bool
525	help
526	  An architecture should select this if it can walk the kernel stack
527	  frames to determine if an object is part of either the arguments
528	  or local variables (i.e. that it excludes saved return addresses,
529	  and similar) by implementing an inline arch_within_stack_frames(),
530	  which is used by CONFIG_HARDENED_USERCOPY.
531
532config HAVE_CONTEXT_TRACKING
533	bool
534	help
535	  Provide kernel/user boundaries probes necessary for subsystems
536	  that need it, such as userspace RCU extended quiescent state.
537	  Syscalls need to be wrapped inside user_exit()-user_enter() through
538	  the slow path using TIF_NOHZ flag. Exceptions handlers must be
539	  wrapped as well. Irqs are already protected inside
540	  rcu_irq_enter/rcu_irq_exit() but preemption or signal handling on
541	  irq exit still need to be protected.
542
543config HAVE_VIRT_CPU_ACCOUNTING
544	bool
545
546config ARCH_HAS_SCALED_CPUTIME
547	bool
548
549config HAVE_VIRT_CPU_ACCOUNTING_GEN
550	bool
551	default y if 64BIT
552	help
553	  With VIRT_CPU_ACCOUNTING_GEN, cputime_t becomes 64-bit.
554	  Before enabling this option, arch code must be audited
555	  to ensure there are no races in concurrent read/write of
556	  cputime_t. For example, reading/writing 64-bit cputime_t on
557	  some 32-bit arches may require multiple accesses, so proper
558	  locking is needed to protect against concurrent accesses.
559
560
561config HAVE_IRQ_TIME_ACCOUNTING
562	bool
563	help
564	  Archs need to ensure they use a high enough resolution clock to
565	  support irq time accounting and then call enable_sched_clock_irqtime().
566
567config HAVE_ARCH_TRANSPARENT_HUGEPAGE
568	bool
569
570config HAVE_ARCH_HUGE_VMAP
571	bool
572
573config HAVE_ARCH_SOFT_DIRTY
574	bool
575
576config HAVE_MOD_ARCH_SPECIFIC
577	bool
578	help
579	  The arch uses struct mod_arch_specific to store data.  Many arches
580	  just need a simple module loader without arch specific data - those
581	  should not enable this.
582
583config MODULES_USE_ELF_RELA
584	bool
585	help
586	  Modules only use ELF RELA relocations.  Modules with ELF REL
587	  relocations will give an error.
588
589config MODULES_USE_ELF_REL
590	bool
591	help
592	  Modules only use ELF REL relocations.  Modules with ELF RELA
593	  relocations will give an error.
594
595config HAVE_UNDERSCORE_SYMBOL_PREFIX
596	bool
597	help
598	  Some architectures generate an _ in front of C symbols; things like
599	  module loading and assembly files need to know about this.
600
601config HAVE_IRQ_EXIT_ON_IRQ_STACK
602	bool
603	help
604	  Architecture doesn't only execute the irq handler on the irq stack
605	  but also irq_exit(). This way we can process softirqs on this irq
606	  stack instead of switching to a new one when we call __do_softirq()
607	  in the end of an hardirq.
608	  This spares a stack switch and improves cache usage on softirq
609	  processing.
610
611config PGTABLE_LEVELS
612	int
613	default 2
614
615config ARCH_HAS_ELF_RANDOMIZE
616	bool
617	help
618	  An architecture supports choosing randomized locations for
619	  stack, mmap, brk, and ET_DYN. Defined functions:
620	  - arch_mmap_rnd()
621	  - arch_randomize_brk()
622
623config HAVE_ARCH_MMAP_RND_BITS
624	bool
625	help
626	  An arch should select this symbol if it supports setting a variable
627	  number of bits for use in establishing the base address for mmap
628	  allocations, has MMU enabled and provides values for both:
629	  - ARCH_MMAP_RND_BITS_MIN
630	  - ARCH_MMAP_RND_BITS_MAX
631
632config HAVE_EXIT_THREAD
633	bool
634	help
635	  An architecture implements exit_thread.
636
637config ARCH_MMAP_RND_BITS_MIN
638	int
639
640config ARCH_MMAP_RND_BITS_MAX
641	int
642
643config ARCH_MMAP_RND_BITS_DEFAULT
644	int
645
646config ARCH_MMAP_RND_BITS
647	int "Number of bits to use for ASLR of mmap base address" if EXPERT
648	range ARCH_MMAP_RND_BITS_MIN ARCH_MMAP_RND_BITS_MAX
649	default ARCH_MMAP_RND_BITS_DEFAULT if ARCH_MMAP_RND_BITS_DEFAULT
650	default ARCH_MMAP_RND_BITS_MIN
651	depends on HAVE_ARCH_MMAP_RND_BITS
652	help
653	  This value can be used to select the number of bits to use to
654	  determine the random offset to the base address of vma regions
655	  resulting from mmap allocations. This value will be bounded
656	  by the architecture's minimum and maximum supported values.
657
658	  This value can be changed after boot using the
659	  /proc/sys/vm/mmap_rnd_bits tunable
660
661config HAVE_ARCH_MMAP_RND_COMPAT_BITS
662	bool
663	help
664	  An arch should select this symbol if it supports running applications
665	  in compatibility mode, supports setting a variable number of bits for
666	  use in establishing the base address for mmap allocations, has MMU
667	  enabled and provides values for both:
668	  - ARCH_MMAP_RND_COMPAT_BITS_MIN
669	  - ARCH_MMAP_RND_COMPAT_BITS_MAX
670
671config ARCH_MMAP_RND_COMPAT_BITS_MIN
672	int
673
674config ARCH_MMAP_RND_COMPAT_BITS_MAX
675	int
676
677config ARCH_MMAP_RND_COMPAT_BITS_DEFAULT
678	int
679
680config ARCH_MMAP_RND_COMPAT_BITS
681	int "Number of bits to use for ASLR of mmap base address for compatible applications" if EXPERT
682	range ARCH_MMAP_RND_COMPAT_BITS_MIN ARCH_MMAP_RND_COMPAT_BITS_MAX
683	default ARCH_MMAP_RND_COMPAT_BITS_DEFAULT if ARCH_MMAP_RND_COMPAT_BITS_DEFAULT
684	default ARCH_MMAP_RND_COMPAT_BITS_MIN
685	depends on HAVE_ARCH_MMAP_RND_COMPAT_BITS
686	help
687	  This value can be used to select the number of bits to use to
688	  determine the random offset to the base address of vma regions
689	  resulting from mmap allocations for compatible applications This
690	  value will be bounded by the architecture's minimum and maximum
691	  supported values.
692
693	  This value can be changed after boot using the
694	  /proc/sys/vm/mmap_rnd_compat_bits tunable
695
696config HAVE_COPY_THREAD_TLS
697	bool
698	help
699	  Architecture provides copy_thread_tls to accept tls argument via
700	  normal C parameter passing, rather than extracting the syscall
701	  argument from pt_regs.
702
703config HAVE_STACK_VALIDATION
704	bool
705	help
706	  Architecture supports the 'objtool check' host tool command, which
707	  performs compile-time stack metadata validation.
708
709config HAVE_ARCH_HASH
710	bool
711	default n
712	help
713	  If this is set, the architecture provides an <asm/hash.h>
714	  file which provides platform-specific implementations of some
715	  functions in <linux/hash.h> or fs/namei.c.
716
717config ISA_BUS_API
718	def_bool ISA
719
720#
721# ABI hall of shame
722#
723config CLONE_BACKWARDS
724	bool
725	help
726	  Architecture has tls passed as the 4th argument of clone(2),
727	  not the 5th one.
728
729config CLONE_BACKWARDS2
730	bool
731	help
732	  Architecture has the first two arguments of clone(2) swapped.
733
734config CLONE_BACKWARDS3
735	bool
736	help
737	  Architecture has tls passed as the 3rd argument of clone(2),
738	  not the 5th one.
739
740config ODD_RT_SIGACTION
741	bool
742	help
743	  Architecture has unusual rt_sigaction(2) arguments
744
745config OLD_SIGSUSPEND
746	bool
747	help
748	  Architecture has old sigsuspend(2) syscall, of one-argument variety
749
750config OLD_SIGSUSPEND3
751	bool
752	help
753	  Even weirder antique ABI - three-argument sigsuspend(2)
754
755config OLD_SIGACTION
756	bool
757	help
758	  Architecture has old sigaction(2) syscall.  Nope, not the same
759	  as OLD_SIGSUSPEND | OLD_SIGSUSPEND3 - alpha has sigsuspend(2),
760	  but fairly different variant of sigaction(2), thanks to OSF/1
761	  compatibility...
762
763config COMPAT_OLD_SIGACTION
764	bool
765
766config ARCH_NO_COHERENT_DMA_MMAP
767	bool
768
769config CPU_NO_EFFICIENT_FFS
770	def_bool n
771
772config HAVE_ARCH_VMAP_STACK
773	def_bool n
774	help
775	  An arch should select this symbol if it can support kernel stacks
776	  in vmalloc space.  This means:
777
778	  - vmalloc space must be large enough to hold many kernel stacks.
779	    This may rule out many 32-bit architectures.
780
781	  - Stacks in vmalloc space need to work reliably.  For example, if
782	    vmap page tables are created on demand, either this mechanism
783	    needs to work while the stack points to a virtual address with
784	    unpopulated page tables or arch code (switch_to() and switch_mm(),
785	    most likely) needs to ensure that the stack's page table entries
786	    are populated before running on a possibly unpopulated stack.
787
788	  - If the stack overflows into a guard page, something reasonable
789	    should happen.  The definition of "reasonable" is flexible, but
790	    instantly rebooting without logging anything would be unfriendly.
791
792config VMAP_STACK
793	default y
794	bool "Use a virtually-mapped stack"
795	depends on HAVE_ARCH_VMAP_STACK && !KASAN
796	---help---
797	  Enable this if you want the use virtually-mapped kernel stacks
798	  with guard pages.  This causes kernel stack overflows to be
799	  caught immediately rather than causing difficult-to-diagnose
800	  corruption.
801
802	  This is presently incompatible with KASAN because KASAN expects
803	  the stack to map directly to the KASAN shadow map using a formula
804	  that is incorrect if the stack is in vmalloc space.
805
806source "kernel/gcov/Kconfig"
807