Back to home page

LXR

 
 

    


0001 #
0002 # General architecture dependent options
0003 #
0004 
0005 config KEXEC_CORE
0006         bool
0007 
0008 config HAVE_IMA_KEXEC
0009         bool
0010 
0011 config OPROFILE
0012         tristate "OProfile system profiling"
0013         depends on PROFILING
0014         depends on HAVE_OPROFILE
0015         select RING_BUFFER
0016         select RING_BUFFER_ALLOW_SWAP
0017         help
0018           OProfile is a profiling system capable of profiling the
0019           whole system, include the kernel, kernel modules, libraries,
0020           and applications.
0021 
0022           If unsure, say N.
0023 
0024 config OPROFILE_EVENT_MULTIPLEX
0025         bool "OProfile multiplexing support (EXPERIMENTAL)"
0026         default n
0027         depends on OPROFILE && X86
0028         help
0029           The number of hardware counters is limited. The multiplexing
0030           feature enables OProfile to gather more events than counters
0031           are provided by the hardware. This is realized by switching
0032           between events at an user specified time interval.
0033 
0034           If unsure, say N.
0035 
0036 config HAVE_OPROFILE
0037         bool
0038 
0039 config OPROFILE_NMI_TIMER
0040         def_bool y
0041         depends on PERF_EVENTS && HAVE_PERF_EVENTS_NMI && !PPC64
0042 
0043 config KPROBES
0044         bool "Kprobes"
0045         depends on MODULES
0046         depends on HAVE_KPROBES
0047         select KALLSYMS
0048         help
0049           Kprobes allows you to trap at almost any kernel address and
0050           execute a callback function.  register_kprobe() establishes
0051           a probepoint and specifies the callback.  Kprobes is useful
0052           for kernel debugging, non-intrusive instrumentation and testing.
0053           If in doubt, say "N".
0054 
0055 config JUMP_LABEL
0056        bool "Optimize very unlikely/likely branches"
0057        depends on HAVE_ARCH_JUMP_LABEL
0058        help
0059          This option enables a transparent branch optimization that
0060          makes certain almost-always-true or almost-always-false branch
0061          conditions even cheaper to execute within the kernel.
0062 
0063          Certain performance-sensitive kernel code, such as trace points,
0064          scheduler functionality, networking code and KVM have such
0065          branches and include support for this optimization technique.
0066 
0067          If it is detected that the compiler has support for "asm goto",
0068          the kernel will compile such branches with just a nop
0069          instruction. When the condition flag is toggled to true, the
0070          nop will be converted to a jump instruction to execute the
0071          conditional block of instructions.
0072 
0073          This technique lowers overhead and stress on the branch prediction
0074          of the processor and generally makes the kernel faster. The update
0075          of the condition is slower, but those are always very rare.
0076 
0077          ( On 32-bit x86, the necessary options added to the compiler
0078            flags may increase the size of the kernel slightly. )
0079 
0080 config STATIC_KEYS_SELFTEST
0081         bool "Static key selftest"
0082         depends on JUMP_LABEL
0083         help
0084           Boot time self-test of the branch patching code.
0085 
0086 config OPTPROBES
0087         def_bool y
0088         depends on KPROBES && HAVE_OPTPROBES
0089         depends on !PREEMPT
0090 
0091 config KPROBES_ON_FTRACE
0092         def_bool y
0093         depends on KPROBES && HAVE_KPROBES_ON_FTRACE
0094         depends on DYNAMIC_FTRACE_WITH_REGS
0095         help
0096          If function tracer is enabled and the arch supports full
0097          passing of pt_regs to function tracing, then kprobes can
0098          optimize on top of function tracing.
0099 
0100 config UPROBES
0101         def_bool n
0102         depends on ARCH_SUPPORTS_UPROBES
0103         help
0104           Uprobes is the user-space counterpart to kprobes: they
0105           enable instrumentation applications (such as 'perf probe')
0106           to establish unintrusive probes in user-space binaries and
0107           libraries, by executing handler functions when the probes
0108           are hit by user-space applications.
0109 
0110           ( These probes come in the form of single-byte breakpoints,
0111             managed by the kernel and kept transparent to the probed
0112             application. )
0113 
0114 config HAVE_64BIT_ALIGNED_ACCESS
0115         def_bool 64BIT && !HAVE_EFFICIENT_UNALIGNED_ACCESS
0116         help
0117           Some architectures require 64 bit accesses to be 64 bit
0118           aligned, which also requires structs containing 64 bit values
0119           to be 64 bit aligned too. This includes some 32 bit
0120           architectures which can do 64 bit accesses, as well as 64 bit
0121           architectures without unaligned access.
0122 
0123           This symbol should be selected by an architecture if 64 bit
0124           accesses are required to be 64 bit aligned in this way even
0125           though it is not a 64 bit architecture.
0126 
0127           See Documentation/unaligned-memory-access.txt for more
0128           information on the topic of unaligned memory accesses.
0129 
0130 config HAVE_EFFICIENT_UNALIGNED_ACCESS
0131         bool
0132         help
0133           Some architectures are unable to perform unaligned accesses
0134           without the use of get_unaligned/put_unaligned. Others are
0135           unable to perform such accesses efficiently (e.g. trap on
0136           unaligned access and require fixing it up in the exception
0137           handler.)
0138 
0139           This symbol should be selected by an architecture if it can
0140           perform unaligned accesses efficiently to allow different
0141           code paths to be selected for these cases. Some network
0142           drivers, for example, could opt to not fix up alignment
0143           problems with received packets if doing so would not help
0144           much.
0145 
0146           See Documentation/unaligned-memory-access.txt for more
0147           information on the topic of unaligned memory accesses.
0148 
0149 config ARCH_USE_BUILTIN_BSWAP
0150        bool
0151        help
0152          Modern versions of GCC (since 4.4) have builtin functions
0153          for handling byte-swapping. Using these, instead of the old
0154          inline assembler that the architecture code provides in the
0155          __arch_bswapXX() macros, allows the compiler to see what's
0156          happening and offers more opportunity for optimisation. In
0157          particular, the compiler will be able to combine the byteswap
0158          with a nearby load or store and use load-and-swap or
0159          store-and-swap instructions if the architecture has them. It
0160          should almost *never* result in code which is worse than the
0161          hand-coded assembler in <asm/swab.h>.  But just in case it
0162          does, the use of the builtins is optional.
0163 
0164          Any architecture with load-and-swap or store-and-swap
0165          instructions should set this. And it shouldn't hurt to set it
0166          on architectures that don't have such instructions.
0167 
0168 config KRETPROBES
0169         def_bool y
0170         depends on KPROBES && HAVE_KRETPROBES
0171 
0172 config USER_RETURN_NOTIFIER
0173         bool
0174         depends on HAVE_USER_RETURN_NOTIFIER
0175         help
0176           Provide a kernel-internal notification when a cpu is about to
0177           switch to user mode.
0178 
0179 config HAVE_IOREMAP_PROT
0180         bool
0181 
0182 config HAVE_KPROBES
0183         bool
0184 
0185 config HAVE_KRETPROBES
0186         bool
0187 
0188 config HAVE_OPTPROBES
0189         bool
0190 
0191 config HAVE_KPROBES_ON_FTRACE
0192         bool
0193 
0194 config HAVE_NMI
0195         bool
0196 
0197 config HAVE_NMI_WATCHDOG
0198         depends on HAVE_NMI
0199         bool
0200 #
0201 # An arch should select this if it provides all these things:
0202 #
0203 #       task_pt_regs()          in asm/processor.h or asm/ptrace.h
0204 #       arch_has_single_step()  if there is hardware single-step support
0205 #       arch_has_block_step()   if there is hardware block-step support
0206 #       asm/syscall.h           supplying asm-generic/syscall.h interface
0207 #       linux/regset.h          user_regset interfaces
0208 #       CORE_DUMP_USE_REGSET    #define'd in linux/elf.h
0209 #       TIF_SYSCALL_TRACE       calls tracehook_report_syscall_{entry,exit}
0210 #       TIF_NOTIFY_RESUME       calls tracehook_notify_resume()
0211 #       signal delivery         calls tracehook_signal_handler()
0212 #
0213 config HAVE_ARCH_TRACEHOOK
0214         bool
0215 
0216 config HAVE_DMA_CONTIGUOUS
0217         bool
0218 
0219 config GENERIC_SMP_IDLE_THREAD
0220        bool
0221 
0222 config GENERIC_IDLE_POLL_SETUP
0223        bool
0224 
0225 # Select if arch init_task initializer is different to init/init_task.c
0226 config ARCH_INIT_TASK
0227        bool
0228 
0229 # Select if arch has its private alloc_task_struct() function
0230 config ARCH_TASK_STRUCT_ALLOCATOR
0231         bool
0232 
0233 # Select if arch has its private alloc_thread_stack() function
0234 config ARCH_THREAD_STACK_ALLOCATOR
0235         bool
0236 
0237 # Select if arch wants to size task_struct dynamically via arch_task_struct_size:
0238 config ARCH_WANTS_DYNAMIC_TASK_STRUCT
0239         bool
0240 
0241 config HAVE_REGS_AND_STACK_ACCESS_API
0242         bool
0243         help
0244           This symbol should be selected by an architecure if it supports
0245           the API needed to access registers and stack entries from pt_regs,
0246           declared in asm/ptrace.h
0247           For example the kprobes-based event tracer needs this API.
0248 
0249 config HAVE_CLK
0250         bool
0251         help
0252           The <linux/clk.h> calls support software clock gating and
0253           thus are a key power management tool on many systems.
0254 
0255 config HAVE_DMA_API_DEBUG
0256         bool
0257 
0258 config HAVE_HW_BREAKPOINT
0259         bool
0260         depends on PERF_EVENTS
0261 
0262 config HAVE_MIXED_BREAKPOINTS_REGS
0263         bool
0264         depends on HAVE_HW_BREAKPOINT
0265         help
0266           Depending on the arch implementation of hardware breakpoints,
0267           some of them have separate registers for data and instruction
0268           breakpoints addresses, others have mixed registers to store
0269           them but define the access type in a control register.
0270           Select this option if your arch implements breakpoints under the
0271           latter fashion.
0272 
0273 config HAVE_USER_RETURN_NOTIFIER
0274         bool
0275 
0276 config HAVE_PERF_EVENTS_NMI
0277         bool
0278         help
0279           System hardware can generate an NMI using the perf event
0280           subsystem.  Also has support for calculating CPU cycle events
0281           to determine how many clock cycles in a given period.
0282 
0283 config HAVE_PERF_REGS
0284         bool
0285         help
0286           Support selective register dumps for perf events. This includes
0287           bit-mapping of each registers and a unique architecture id.
0288 
0289 config HAVE_PERF_USER_STACK_DUMP
0290         bool
0291         help
0292           Support user stack dumps for perf event samples. This needs
0293           access to the user stack pointer which is not unified across
0294           architectures.
0295 
0296 config HAVE_ARCH_JUMP_LABEL
0297         bool
0298 
0299 config HAVE_RCU_TABLE_FREE
0300         bool
0301 
0302 config ARCH_HAVE_NMI_SAFE_CMPXCHG
0303         bool
0304 
0305 config HAVE_ALIGNED_STRUCT_PAGE
0306         bool
0307         help
0308           This makes sure that struct pages are double word aligned and that
0309           e.g. the SLUB allocator can perform double word atomic operations
0310           on a struct page for better performance. However selecting this
0311           might increase the size of a struct page by a word.
0312 
0313 config HAVE_CMPXCHG_LOCAL
0314         bool
0315 
0316 config HAVE_CMPXCHG_DOUBLE
0317         bool
0318 
0319 config ARCH_WANT_IPC_PARSE_VERSION
0320         bool
0321 
0322 config ARCH_WANT_COMPAT_IPC_PARSE_VERSION
0323         bool
0324 
0325 config ARCH_WANT_OLD_COMPAT_IPC
0326         select ARCH_WANT_COMPAT_IPC_PARSE_VERSION
0327         bool
0328 
0329 config HAVE_ARCH_SECCOMP_FILTER
0330         bool
0331         help
0332           An arch should select this symbol if it provides all of these things:
0333           - syscall_get_arch()
0334           - syscall_get_arguments()
0335           - syscall_rollback()
0336           - syscall_set_return_value()
0337           - SIGSYS siginfo_t support
0338           - secure_computing is called from a ptrace_event()-safe context
0339           - secure_computing return value is checked and a return value of -1
0340             results in the system call being skipped immediately.
0341           - seccomp syscall wired up
0342 
0343 config SECCOMP_FILTER
0344         def_bool y
0345         depends on HAVE_ARCH_SECCOMP_FILTER && SECCOMP && NET
0346         help
0347           Enable tasks to build secure computing environments defined
0348           in terms of Berkeley Packet Filter programs which implement
0349           task-defined system call filtering polices.
0350 
0351           See Documentation/prctl/seccomp_filter.txt for details.
0352 
0353 config HAVE_GCC_PLUGINS
0354         bool
0355         help
0356           An arch should select this symbol if it supports building with
0357           GCC plugins.
0358 
0359 menuconfig GCC_PLUGINS
0360         bool "GCC plugins"
0361         depends on HAVE_GCC_PLUGINS
0362         depends on !COMPILE_TEST
0363         help
0364           GCC plugins are loadable modules that provide extra features to the
0365           compiler. They are useful for runtime instrumentation and static analysis.
0366 
0367           See Documentation/gcc-plugins.txt for details.
0368 
0369 config GCC_PLUGIN_CYC_COMPLEXITY
0370         bool "Compute the cyclomatic complexity of a function" if EXPERT
0371         depends on GCC_PLUGINS
0372         depends on !COMPILE_TEST
0373         help
0374           The complexity M of a function's control flow graph is defined as:
0375            M = E - N + 2P
0376           where
0377 
0378           E = the number of edges
0379           N = the number of nodes
0380           P = the number of connected components (exit nodes).
0381 
0382           Enabling this plugin reports the complexity to stderr during the
0383           build. It mainly serves as a simple example of how to create a
0384           gcc plugin for the kernel.
0385 
0386 config GCC_PLUGIN_SANCOV
0387         bool
0388         depends on GCC_PLUGINS
0389         help
0390           This plugin inserts a __sanitizer_cov_trace_pc() call at the start of
0391           basic blocks. It supports all gcc versions with plugin support (from
0392           gcc-4.5 on). It is based on the commit "Add fuzzing coverage support"
0393           by Dmitry Vyukov <dvyukov@google.com>.
0394 
0395 config GCC_PLUGIN_LATENT_ENTROPY
0396         bool "Generate some entropy during boot and runtime"
0397         depends on GCC_PLUGINS
0398         help
0399           By saying Y here the kernel will instrument some kernel code to
0400           extract some entropy from both original and artificially created
0401           program state.  This will help especially embedded systems where
0402           there is little 'natural' source of entropy normally.  The cost
0403           is some slowdown of the boot process (about 0.5%) and fork and
0404           irq processing.
0405 
0406           Note that entropy extracted this way is not cryptographically
0407           secure!
0408 
0409           This plugin was ported from grsecurity/PaX. More information at:
0410            * https://grsecurity.net/
0411            * https://pax.grsecurity.net/
0412 
0413 config HAVE_CC_STACKPROTECTOR
0414         bool
0415         help
0416           An arch should select this symbol if:
0417           - its compiler supports the -fstack-protector option
0418           - it has implemented a stack canary (e.g. __stack_chk_guard)
0419 
0420 config CC_STACKPROTECTOR
0421         def_bool n
0422         help
0423           Set when a stack-protector mode is enabled, so that the build
0424           can enable kernel-side support for the GCC feature.
0425 
0426 choice
0427         prompt "Stack Protector buffer overflow detection"
0428         depends on HAVE_CC_STACKPROTECTOR
0429         default CC_STACKPROTECTOR_NONE
0430         help
0431           This option turns on the "stack-protector" GCC feature. This
0432           feature puts, at the beginning of functions, a canary value on
0433           the stack just before the return address, and validates
0434           the value just before actually returning.  Stack based buffer
0435           overflows (that need to overwrite this return address) now also
0436           overwrite the canary, which gets detected and the attack is then
0437           neutralized via a kernel panic.
0438 
0439 config CC_STACKPROTECTOR_NONE
0440         bool "None"
0441         help
0442           Disable "stack-protector" GCC feature.
0443 
0444 config CC_STACKPROTECTOR_REGULAR
0445         bool "Regular"
0446         select CC_STACKPROTECTOR
0447         help
0448           Functions will have the stack-protector canary logic added if they
0449           have an 8-byte or larger character array on the stack.
0450 
0451           This feature requires gcc version 4.2 or above, or a distribution
0452           gcc with the feature backported ("-fstack-protector").
0453 
0454           On an x86 "defconfig" build, this feature adds canary checks to
0455           about 3% of all kernel functions, which increases kernel code size
0456           by about 0.3%.
0457 
0458 config CC_STACKPROTECTOR_STRONG
0459         bool "Strong"
0460         select CC_STACKPROTECTOR
0461         help
0462           Functions will have the stack-protector canary logic added in any
0463           of the following conditions:
0464 
0465           - local variable's address used as part of the right hand side of an
0466             assignment or function argument
0467           - local variable is an array (or union containing an array),
0468             regardless of array type or length
0469           - uses register local variables
0470 
0471           This feature requires gcc version 4.9 or above, or a distribution
0472           gcc with the feature backported ("-fstack-protector-strong").
0473 
0474           On an x86 "defconfig" build, this feature adds canary checks to
0475           about 20% of all kernel functions, which increases the kernel code
0476           size by about 2%.
0477 
0478 endchoice
0479 
0480 config THIN_ARCHIVES
0481         bool
0482         help
0483           Select this if the architecture wants to use thin archives
0484           instead of ld -r to create the built-in.o files.
0485 
0486 config LD_DEAD_CODE_DATA_ELIMINATION
0487         bool
0488         help
0489           Select this if the architecture wants to do dead code and
0490           data elimination with the linker by compiling with
0491           -ffunction-sections -fdata-sections and linking with
0492           --gc-sections.
0493 
0494           This requires that the arch annotates or otherwise protects
0495           its external entry points from being discarded. Linker scripts
0496           must also merge .text.*, .data.*, and .bss.* correctly into
0497           output sections. Care must be taken not to pull in unrelated
0498           sections (e.g., '.text.init'). Typically '.' in section names
0499           is used to distinguish them from label names / C identifiers.
0500 
0501 config HAVE_ARCH_WITHIN_STACK_FRAMES
0502         bool
0503         help
0504           An architecture should select this if it can walk the kernel stack
0505           frames to determine if an object is part of either the arguments
0506           or local variables (i.e. that it excludes saved return addresses,
0507           and similar) by implementing an inline arch_within_stack_frames(),
0508           which is used by CONFIG_HARDENED_USERCOPY.
0509 
0510 config HAVE_CONTEXT_TRACKING
0511         bool
0512         help
0513           Provide kernel/user boundaries probes necessary for subsystems
0514           that need it, such as userspace RCU extended quiescent state.
0515           Syscalls need to be wrapped inside user_exit()-user_enter() through
0516           the slow path using TIF_NOHZ flag. Exceptions handlers must be
0517           wrapped as well. Irqs are already protected inside
0518           rcu_irq_enter/rcu_irq_exit() but preemption or signal handling on
0519           irq exit still need to be protected.
0520 
0521 config HAVE_VIRT_CPU_ACCOUNTING
0522         bool
0523 
0524 config ARCH_HAS_SCALED_CPUTIME
0525         bool
0526 
0527 config HAVE_VIRT_CPU_ACCOUNTING_GEN
0528         bool
0529         default y if 64BIT
0530         help
0531           With VIRT_CPU_ACCOUNTING_GEN, cputime_t becomes 64-bit.
0532           Before enabling this option, arch code must be audited
0533           to ensure there are no races in concurrent read/write of
0534           cputime_t. For example, reading/writing 64-bit cputime_t on
0535           some 32-bit arches may require multiple accesses, so proper
0536           locking is needed to protect against concurrent accesses.
0537 
0538 
0539 config HAVE_IRQ_TIME_ACCOUNTING
0540         bool
0541         help
0542           Archs need to ensure they use a high enough resolution clock to
0543           support irq time accounting and then call enable_sched_clock_irqtime().
0544 
0545 config HAVE_ARCH_TRANSPARENT_HUGEPAGE
0546         bool
0547 
0548 config HAVE_ARCH_HUGE_VMAP
0549         bool
0550 
0551 config HAVE_ARCH_SOFT_DIRTY
0552         bool
0553 
0554 config HAVE_MOD_ARCH_SPECIFIC
0555         bool
0556         help
0557           The arch uses struct mod_arch_specific to store data.  Many arches
0558           just need a simple module loader without arch specific data - those
0559           should not enable this.
0560 
0561 config MODULES_USE_ELF_RELA
0562         bool
0563         help
0564           Modules only use ELF RELA relocations.  Modules with ELF REL
0565           relocations will give an error.
0566 
0567 config MODULES_USE_ELF_REL
0568         bool
0569         help
0570           Modules only use ELF REL relocations.  Modules with ELF RELA
0571           relocations will give an error.
0572 
0573 config HAVE_UNDERSCORE_SYMBOL_PREFIX
0574         bool
0575         help
0576           Some architectures generate an _ in front of C symbols; things like
0577           module loading and assembly files need to know about this.
0578 
0579 config HAVE_IRQ_EXIT_ON_IRQ_STACK
0580         bool
0581         help
0582           Architecture doesn't only execute the irq handler on the irq stack
0583           but also irq_exit(). This way we can process softirqs on this irq
0584           stack instead of switching to a new one when we call __do_softirq()
0585           in the end of an hardirq.
0586           This spares a stack switch and improves cache usage on softirq
0587           processing.
0588 
0589 config PGTABLE_LEVELS
0590         int
0591         default 2
0592 
0593 config ARCH_HAS_ELF_RANDOMIZE
0594         bool
0595         help
0596           An architecture supports choosing randomized locations for
0597           stack, mmap, brk, and ET_DYN. Defined functions:
0598           - arch_mmap_rnd()
0599           - arch_randomize_brk()
0600 
0601 config HAVE_ARCH_MMAP_RND_BITS
0602         bool
0603         help
0604           An arch should select this symbol if it supports setting a variable
0605           number of bits for use in establishing the base address for mmap
0606           allocations, has MMU enabled and provides values for both:
0607           - ARCH_MMAP_RND_BITS_MIN
0608           - ARCH_MMAP_RND_BITS_MAX
0609 
0610 config HAVE_EXIT_THREAD
0611         bool
0612         help
0613           An architecture implements exit_thread.
0614 
0615 config ARCH_MMAP_RND_BITS_MIN
0616         int
0617 
0618 config ARCH_MMAP_RND_BITS_MAX
0619         int
0620 
0621 config ARCH_MMAP_RND_BITS_DEFAULT
0622         int
0623 
0624 config ARCH_MMAP_RND_BITS
0625         int "Number of bits to use for ASLR of mmap base address" if EXPERT
0626         range ARCH_MMAP_RND_BITS_MIN ARCH_MMAP_RND_BITS_MAX
0627         default ARCH_MMAP_RND_BITS_DEFAULT if ARCH_MMAP_RND_BITS_DEFAULT
0628         default ARCH_MMAP_RND_BITS_MIN
0629         depends on HAVE_ARCH_MMAP_RND_BITS
0630         help
0631           This value can be used to select the number of bits to use to
0632           determine the random offset to the base address of vma regions
0633           resulting from mmap allocations. This value will be bounded
0634           by the architecture's minimum and maximum supported values.
0635 
0636           This value can be changed after boot using the
0637           /proc/sys/vm/mmap_rnd_bits tunable
0638 
0639 config HAVE_ARCH_MMAP_RND_COMPAT_BITS
0640         bool
0641         help
0642           An arch should select this symbol if it supports running applications
0643           in compatibility mode, supports setting a variable number of bits for
0644           use in establishing the base address for mmap allocations, has MMU
0645           enabled and provides values for both:
0646           - ARCH_MMAP_RND_COMPAT_BITS_MIN
0647           - ARCH_MMAP_RND_COMPAT_BITS_MAX
0648 
0649 config ARCH_MMAP_RND_COMPAT_BITS_MIN
0650         int
0651 
0652 config ARCH_MMAP_RND_COMPAT_BITS_MAX
0653         int
0654 
0655 config ARCH_MMAP_RND_COMPAT_BITS_DEFAULT
0656         int
0657 
0658 config ARCH_MMAP_RND_COMPAT_BITS
0659         int "Number of bits to use for ASLR of mmap base address for compatible applications" if EXPERT
0660         range ARCH_MMAP_RND_COMPAT_BITS_MIN ARCH_MMAP_RND_COMPAT_BITS_MAX
0661         default ARCH_MMAP_RND_COMPAT_BITS_DEFAULT if ARCH_MMAP_RND_COMPAT_BITS_DEFAULT
0662         default ARCH_MMAP_RND_COMPAT_BITS_MIN
0663         depends on HAVE_ARCH_MMAP_RND_COMPAT_BITS
0664         help
0665           This value can be used to select the number of bits to use to
0666           determine the random offset to the base address of vma regions
0667           resulting from mmap allocations for compatible applications This
0668           value will be bounded by the architecture's minimum and maximum
0669           supported values.
0670 
0671           This value can be changed after boot using the
0672           /proc/sys/vm/mmap_rnd_compat_bits tunable
0673 
0674 config HAVE_COPY_THREAD_TLS
0675         bool
0676         help
0677           Architecture provides copy_thread_tls to accept tls argument via
0678           normal C parameter passing, rather than extracting the syscall
0679           argument from pt_regs.
0680 
0681 config HAVE_STACK_VALIDATION
0682         bool
0683         help
0684           Architecture supports the 'objtool check' host tool command, which
0685           performs compile-time stack metadata validation.
0686 
0687 config HAVE_ARCH_HASH
0688         bool
0689         default n
0690         help
0691           If this is set, the architecture provides an <asm/hash.h>
0692           file which provides platform-specific implementations of some
0693           functions in <linux/hash.h> or fs/namei.c.
0694 
0695 config ISA_BUS_API
0696         def_bool ISA
0697 
0698 #
0699 # ABI hall of shame
0700 #
0701 config CLONE_BACKWARDS
0702         bool
0703         help
0704           Architecture has tls passed as the 4th argument of clone(2),
0705           not the 5th one.
0706 
0707 config CLONE_BACKWARDS2
0708         bool
0709         help
0710           Architecture has the first two arguments of clone(2) swapped.
0711 
0712 config CLONE_BACKWARDS3
0713         bool
0714         help
0715           Architecture has tls passed as the 3rd argument of clone(2),
0716           not the 5th one.
0717 
0718 config ODD_RT_SIGACTION
0719         bool
0720         help
0721           Architecture has unusual rt_sigaction(2) arguments
0722 
0723 config OLD_SIGSUSPEND
0724         bool
0725         help
0726           Architecture has old sigsuspend(2) syscall, of one-argument variety
0727 
0728 config OLD_SIGSUSPEND3
0729         bool
0730         help
0731           Even weirder antique ABI - three-argument sigsuspend(2)
0732 
0733 config OLD_SIGACTION
0734         bool
0735         help
0736           Architecture has old sigaction(2) syscall.  Nope, not the same
0737           as OLD_SIGSUSPEND | OLD_SIGSUSPEND3 - alpha has sigsuspend(2),
0738           but fairly different variant of sigaction(2), thanks to OSF/1
0739           compatibility...
0740 
0741 config COMPAT_OLD_SIGACTION
0742         bool
0743 
0744 config ARCH_NO_COHERENT_DMA_MMAP
0745         bool
0746 
0747 config CPU_NO_EFFICIENT_FFS
0748         def_bool n
0749 
0750 config HAVE_ARCH_VMAP_STACK
0751         def_bool n
0752         help
0753           An arch should select this symbol if it can support kernel stacks
0754           in vmalloc space.  This means:
0755 
0756           - vmalloc space must be large enough to hold many kernel stacks.
0757             This may rule out many 32-bit architectures.
0758 
0759           - Stacks in vmalloc space need to work reliably.  For example, if
0760             vmap page tables are created on demand, either this mechanism
0761             needs to work while the stack points to a virtual address with
0762             unpopulated page tables or arch code (switch_to() and switch_mm(),
0763             most likely) needs to ensure that the stack's page table entries
0764             are populated before running on a possibly unpopulated stack.
0765 
0766           - If the stack overflows into a guard page, something reasonable
0767             should happen.  The definition of "reasonable" is flexible, but
0768             instantly rebooting without logging anything would be unfriendly.
0769 
0770 config VMAP_STACK
0771         default y
0772         bool "Use a virtually-mapped stack"
0773         depends on HAVE_ARCH_VMAP_STACK && !KASAN
0774         ---help---
0775           Enable this if you want the use virtually-mapped kernel stacks
0776           with guard pages.  This causes kernel stack overflows to be
0777           caught immediately rather than causing difficult-to-diagnose
0778           corruption.
0779 
0780           This is presently incompatible with KASAN because KASAN expects
0781           the stack to map directly to the KASAN shadow map using a formula
0782           that is incorrect if the stack is in vmalloc space.
0783 
0784 source "kernel/gcov/Kconfig"