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