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_CLK 332 bool 333 help 334 The <linux/clk.h> calls support software clock gating and 335 thus are a key power management tool on many systems. 336 337config HAVE_HW_BREAKPOINT 338 bool 339 depends on PERF_EVENTS 340 341config HAVE_MIXED_BREAKPOINTS_REGS 342 bool 343 depends on HAVE_HW_BREAKPOINT 344 help 345 Depending on the arch implementation of hardware breakpoints, 346 some of them have separate registers for data and instruction 347 breakpoints addresses, others have mixed registers to store 348 them but define the access type in a control register. 349 Select this option if your arch implements breakpoints under the 350 latter fashion. 351 352config HAVE_USER_RETURN_NOTIFIER 353 bool 354 355config HAVE_PERF_EVENTS_NMI 356 bool 357 help 358 System hardware can generate an NMI using the perf event 359 subsystem. Also has support for calculating CPU cycle events 360 to determine how many clock cycles in a given period. 361 362config HAVE_HARDLOCKUP_DETECTOR_PERF 363 bool 364 depends on HAVE_PERF_EVENTS_NMI 365 help 366 The arch chooses to use the generic perf-NMI-based hardlockup 367 detector. Must define HAVE_PERF_EVENTS_NMI. 368 369config HAVE_NMI_WATCHDOG 370 depends on HAVE_NMI 371 bool 372 help 373 The arch provides a low level NMI watchdog. It provides 374 asm/nmi.h, and defines its own arch_touch_nmi_watchdog(). 375 376config HAVE_HARDLOCKUP_DETECTOR_ARCH 377 bool 378 select HAVE_NMI_WATCHDOG 379 help 380 The arch chooses to provide its own hardlockup detector, which is 381 a superset of the HAVE_NMI_WATCHDOG. It also conforms to config 382 interfaces and parameters provided by hardlockup detector subsystem. 383 384config HAVE_PERF_REGS 385 bool 386 help 387 Support selective register dumps for perf events. This includes 388 bit-mapping of each registers and a unique architecture id. 389 390config HAVE_PERF_USER_STACK_DUMP 391 bool 392 help 393 Support user stack dumps for perf event samples. This needs 394 access to the user stack pointer which is not unified across 395 architectures. 396 397config HAVE_ARCH_JUMP_LABEL 398 bool 399 400config HAVE_ARCH_JUMP_LABEL_RELATIVE 401 bool 402 403config MMU_GATHER_TABLE_FREE 404 bool 405 406config MMU_GATHER_RCU_TABLE_FREE 407 bool 408 select MMU_GATHER_TABLE_FREE 409 410config MMU_GATHER_PAGE_SIZE 411 bool 412 413config MMU_GATHER_NO_RANGE 414 bool 415 416config MMU_GATHER_NO_GATHER 417 bool 418 depends on MMU_GATHER_TABLE_FREE 419 420config ARCH_HAVE_NMI_SAFE_CMPXCHG 421 bool 422 423config HAVE_ALIGNED_STRUCT_PAGE 424 bool 425 help 426 This makes sure that struct pages are double word aligned and that 427 e.g. the SLUB allocator can perform double word atomic operations 428 on a struct page for better performance. However selecting this 429 might increase the size of a struct page by a word. 430 431config HAVE_CMPXCHG_LOCAL 432 bool 433 434config HAVE_CMPXCHG_DOUBLE 435 bool 436 437config ARCH_WEAK_RELEASE_ACQUIRE 438 bool 439 440config ARCH_WANT_IPC_PARSE_VERSION 441 bool 442 443config ARCH_WANT_COMPAT_IPC_PARSE_VERSION 444 bool 445 446config ARCH_WANT_OLD_COMPAT_IPC 447 select ARCH_WANT_COMPAT_IPC_PARSE_VERSION 448 bool 449 450config HAVE_ARCH_SECCOMP_FILTER 451 bool 452 help 453 An arch should select this symbol if it provides all of these things: 454 - syscall_get_arch() 455 - syscall_get_arguments() 456 - syscall_rollback() 457 - syscall_set_return_value() 458 - SIGSYS siginfo_t support 459 - secure_computing is called from a ptrace_event()-safe context 460 - secure_computing return value is checked and a return value of -1 461 results in the system call being skipped immediately. 462 - seccomp syscall wired up 463 464config SECCOMP_FILTER 465 def_bool y 466 depends on HAVE_ARCH_SECCOMP_FILTER && SECCOMP && NET 467 help 468 Enable tasks to build secure computing environments defined 469 in terms of Berkeley Packet Filter programs which implement 470 task-defined system call filtering polices. 471 472 See Documentation/userspace-api/seccomp_filter.rst for details. 473 474config HAVE_ARCH_STACKLEAK 475 bool 476 help 477 An architecture should select this if it has the code which 478 fills the used part of the kernel stack with the STACKLEAK_POISON 479 value before returning from system calls. 480 481config HAVE_STACKPROTECTOR 482 bool 483 help 484 An arch should select this symbol if: 485 - it has implemented a stack canary (e.g. __stack_chk_guard) 486 487config CC_HAS_STACKPROTECTOR_NONE 488 def_bool $(cc-option,-fno-stack-protector) 489 490config STACKPROTECTOR 491 bool "Stack Protector buffer overflow detection" 492 depends on HAVE_STACKPROTECTOR 493 depends on $(cc-option,-fstack-protector) 494 default y 495 help 496 This option turns on the "stack-protector" GCC feature. This 497 feature puts, at the beginning of functions, a canary value on 498 the stack just before the return address, and validates 499 the value just before actually returning. Stack based buffer 500 overflows (that need to overwrite this return address) now also 501 overwrite the canary, which gets detected and the attack is then 502 neutralized via a kernel panic. 503 504 Functions will have the stack-protector canary logic added if they 505 have an 8-byte or larger character array on the stack. 506 507 This feature requires gcc version 4.2 or above, or a distribution 508 gcc with the feature backported ("-fstack-protector"). 509 510 On an x86 "defconfig" build, this feature adds canary checks to 511 about 3% of all kernel functions, which increases kernel code size 512 by about 0.3%. 513 514config STACKPROTECTOR_STRONG 515 bool "Strong Stack Protector" 516 depends on STACKPROTECTOR 517 depends on $(cc-option,-fstack-protector-strong) 518 default y 519 help 520 Functions will have the stack-protector canary logic added in any 521 of the following conditions: 522 523 - local variable's address used as part of the right hand side of an 524 assignment or function argument 525 - local variable is an array (or union containing an array), 526 regardless of array type or length 527 - uses register local variables 528 529 This feature requires gcc version 4.9 or above, or a distribution 530 gcc with the feature backported ("-fstack-protector-strong"). 531 532 On an x86 "defconfig" build, this feature adds canary checks to 533 about 20% of all kernel functions, which increases the kernel code 534 size by about 2%. 535 536config ARCH_SUPPORTS_SHADOW_CALL_STACK 537 bool 538 help 539 An architecture should select this if it supports Clang's Shadow 540 Call Stack and implements runtime support for shadow stack 541 switching. 542 543config SHADOW_CALL_STACK 544 bool "Clang Shadow Call Stack" 545 depends on CC_IS_CLANG && ARCH_SUPPORTS_SHADOW_CALL_STACK 546 depends on DYNAMIC_FTRACE_WITH_REGS || !FUNCTION_GRAPH_TRACER 547 help 548 This option enables Clang's Shadow Call Stack, which uses a 549 shadow stack to protect function return addresses from being 550 overwritten by an attacker. More information can be found in 551 Clang's documentation: 552 553 https://clang.llvm.org/docs/ShadowCallStack.html 554 555 Note that security guarantees in the kernel differ from the 556 ones documented for user space. The kernel must store addresses 557 of shadow stacks in memory, which means an attacker capable of 558 reading and writing arbitrary memory may be able to locate them 559 and hijack control flow by modifying the stacks. 560 561config HAVE_ARCH_WITHIN_STACK_FRAMES 562 bool 563 help 564 An architecture should select this if it can walk the kernel stack 565 frames to determine if an object is part of either the arguments 566 or local variables (i.e. that it excludes saved return addresses, 567 and similar) by implementing an inline arch_within_stack_frames(), 568 which is used by CONFIG_HARDENED_USERCOPY. 569 570config HAVE_CONTEXT_TRACKING 571 bool 572 help 573 Provide kernel/user boundaries probes necessary for subsystems 574 that need it, such as userspace RCU extended quiescent state. 575 Syscalls need to be wrapped inside user_exit()-user_enter(), either 576 optimized behind static key or through the slow path using TIF_NOHZ 577 flag. Exceptions handlers must be wrapped as well. Irqs are already 578 protected inside rcu_irq_enter/rcu_irq_exit() but preemption or signal 579 handling on irq exit still need to be protected. 580 581config HAVE_TIF_NOHZ 582 bool 583 help 584 Arch relies on TIF_NOHZ and syscall slow path to implement context 585 tracking calls to user_enter()/user_exit(). 586 587config HAVE_VIRT_CPU_ACCOUNTING 588 bool 589 590config ARCH_HAS_SCALED_CPUTIME 591 bool 592 593config HAVE_VIRT_CPU_ACCOUNTING_GEN 594 bool 595 default y if 64BIT 596 help 597 With VIRT_CPU_ACCOUNTING_GEN, cputime_t becomes 64-bit. 598 Before enabling this option, arch code must be audited 599 to ensure there are no races in concurrent read/write of 600 cputime_t. For example, reading/writing 64-bit cputime_t on 601 some 32-bit arches may require multiple accesses, so proper 602 locking is needed to protect against concurrent accesses. 603 604 605config HAVE_IRQ_TIME_ACCOUNTING 606 bool 607 help 608 Archs need to ensure they use a high enough resolution clock to 609 support irq time accounting and then call enable_sched_clock_irqtime(). 610 611config HAVE_MOVE_PMD 612 bool 613 help 614 Archs that select this are able to move page tables at the PMD level. 615 616config HAVE_ARCH_TRANSPARENT_HUGEPAGE 617 bool 618 619config HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD 620 bool 621 622config HAVE_ARCH_HUGE_VMAP 623 bool 624 625config ARCH_WANT_HUGE_PMD_SHARE 626 bool 627 628config HAVE_ARCH_SOFT_DIRTY 629 bool 630 631config HAVE_MOD_ARCH_SPECIFIC 632 bool 633 help 634 The arch uses struct mod_arch_specific to store data. Many arches 635 just need a simple module loader without arch specific data - those 636 should not enable this. 637 638config MODULES_USE_ELF_RELA 639 bool 640 help 641 Modules only use ELF RELA relocations. Modules with ELF REL 642 relocations will give an error. 643 644config MODULES_USE_ELF_REL 645 bool 646 help 647 Modules only use ELF REL relocations. Modules with ELF RELA 648 relocations will give an error. 649 650config HAVE_IRQ_EXIT_ON_IRQ_STACK 651 bool 652 help 653 Architecture doesn't only execute the irq handler on the irq stack 654 but also irq_exit(). This way we can process softirqs on this irq 655 stack instead of switching to a new one when we call __do_softirq() 656 in the end of an hardirq. 657 This spares a stack switch and improves cache usage on softirq 658 processing. 659 660config PGTABLE_LEVELS 661 int 662 default 2 663 664config ARCH_HAS_ELF_RANDOMIZE 665 bool 666 help 667 An architecture supports choosing randomized locations for 668 stack, mmap, brk, and ET_DYN. Defined functions: 669 - arch_mmap_rnd() 670 - arch_randomize_brk() 671 672config HAVE_ARCH_MMAP_RND_BITS 673 bool 674 help 675 An arch should select this symbol if it supports setting a variable 676 number of bits for use in establishing the base address for mmap 677 allocations, has MMU enabled and provides values for both: 678 - ARCH_MMAP_RND_BITS_MIN 679 - ARCH_MMAP_RND_BITS_MAX 680 681config HAVE_EXIT_THREAD 682 bool 683 help 684 An architecture implements exit_thread. 685 686config ARCH_MMAP_RND_BITS_MIN 687 int 688 689config ARCH_MMAP_RND_BITS_MAX 690 int 691 692config ARCH_MMAP_RND_BITS_DEFAULT 693 int 694 695config ARCH_MMAP_RND_BITS 696 int "Number of bits to use for ASLR of mmap base address" if EXPERT 697 range ARCH_MMAP_RND_BITS_MIN ARCH_MMAP_RND_BITS_MAX 698 default ARCH_MMAP_RND_BITS_DEFAULT if ARCH_MMAP_RND_BITS_DEFAULT 699 default ARCH_MMAP_RND_BITS_MIN 700 depends on HAVE_ARCH_MMAP_RND_BITS 701 help 702 This value can be used to select the number of bits to use to 703 determine the random offset to the base address of vma regions 704 resulting from mmap allocations. This value will be bounded 705 by the architecture's minimum and maximum supported values. 706 707 This value can be changed after boot using the 708 /proc/sys/vm/mmap_rnd_bits tunable 709 710config HAVE_ARCH_MMAP_RND_COMPAT_BITS 711 bool 712 help 713 An arch should select this symbol if it supports running applications 714 in compatibility mode, supports setting a variable number of bits for 715 use in establishing the base address for mmap allocations, has MMU 716 enabled and provides values for both: 717 - ARCH_MMAP_RND_COMPAT_BITS_MIN 718 - ARCH_MMAP_RND_COMPAT_BITS_MAX 719 720config ARCH_MMAP_RND_COMPAT_BITS_MIN 721 int 722 723config ARCH_MMAP_RND_COMPAT_BITS_MAX 724 int 725 726config ARCH_MMAP_RND_COMPAT_BITS_DEFAULT 727 int 728 729config ARCH_MMAP_RND_COMPAT_BITS 730 int "Number of bits to use for ASLR of mmap base address for compatible applications" if EXPERT 731 range ARCH_MMAP_RND_COMPAT_BITS_MIN ARCH_MMAP_RND_COMPAT_BITS_MAX 732 default ARCH_MMAP_RND_COMPAT_BITS_DEFAULT if ARCH_MMAP_RND_COMPAT_BITS_DEFAULT 733 default ARCH_MMAP_RND_COMPAT_BITS_MIN 734 depends on HAVE_ARCH_MMAP_RND_COMPAT_BITS 735 help 736 This value can be used to select the number of bits to use to 737 determine the random offset to the base address of vma regions 738 resulting from mmap allocations for compatible applications This 739 value will be bounded by the architecture's minimum and maximum 740 supported values. 741 742 This value can be changed after boot using the 743 /proc/sys/vm/mmap_rnd_compat_bits tunable 744 745config HAVE_ARCH_COMPAT_MMAP_BASES 746 bool 747 help 748 This allows 64bit applications to invoke 32-bit mmap() syscall 749 and vice-versa 32-bit applications to call 64-bit mmap(). 750 Required for applications doing different bitness syscalls. 751 752# This allows to use a set of generic functions to determine mmap base 753# address by giving priority to top-down scheme only if the process 754# is not in legacy mode (compat task, unlimited stack size or 755# sysctl_legacy_va_layout). 756# Architecture that selects this option can provide its own version of: 757# - STACK_RND_MASK 758config ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT 759 bool 760 depends on MMU 761 select ARCH_HAS_ELF_RANDOMIZE 762 763config HAVE_COPY_THREAD_TLS 764 bool 765 help 766 Architecture provides copy_thread_tls to accept tls argument via 767 normal C parameter passing, rather than extracting the syscall 768 argument from pt_regs. 769 770config HAVE_STACK_VALIDATION 771 bool 772 help 773 Architecture supports the 'objtool check' host tool command, which 774 performs compile-time stack metadata validation. 775 776config HAVE_RELIABLE_STACKTRACE 777 bool 778 help 779 Architecture has either save_stack_trace_tsk_reliable() or 780 arch_stack_walk_reliable() function which only returns a stack trace 781 if it can guarantee the trace is reliable. 782 783config HAVE_ARCH_HASH 784 bool 785 default n 786 help 787 If this is set, the architecture provides an <asm/hash.h> 788 file which provides platform-specific implementations of some 789 functions in <linux/hash.h> or fs/namei.c. 790 791config HAVE_ARCH_NVRAM_OPS 792 bool 793 794config ISA_BUS_API 795 def_bool ISA 796 797# 798# ABI hall of shame 799# 800config CLONE_BACKWARDS 801 bool 802 help 803 Architecture has tls passed as the 4th argument of clone(2), 804 not the 5th one. 805 806config CLONE_BACKWARDS2 807 bool 808 help 809 Architecture has the first two arguments of clone(2) swapped. 810 811config CLONE_BACKWARDS3 812 bool 813 help 814 Architecture has tls passed as the 3rd argument of clone(2), 815 not the 5th one. 816 817config ODD_RT_SIGACTION 818 bool 819 help 820 Architecture has unusual rt_sigaction(2) arguments 821 822config OLD_SIGSUSPEND 823 bool 824 help 825 Architecture has old sigsuspend(2) syscall, of one-argument variety 826 827config OLD_SIGSUSPEND3 828 bool 829 help 830 Even weirder antique ABI - three-argument sigsuspend(2) 831 832config OLD_SIGACTION 833 bool 834 help 835 Architecture has old sigaction(2) syscall. Nope, not the same 836 as OLD_SIGSUSPEND | OLD_SIGSUSPEND3 - alpha has sigsuspend(2), 837 but fairly different variant of sigaction(2), thanks to OSF/1 838 compatibility... 839 840config COMPAT_OLD_SIGACTION 841 bool 842 843config COMPAT_32BIT_TIME 844 bool "Provide system calls for 32-bit time_t" 845 default !64BIT || COMPAT 846 help 847 This enables 32 bit time_t support in addition to 64 bit time_t support. 848 This is relevant on all 32-bit architectures, and 64-bit architectures 849 as part of compat syscall handling. 850 851config ARCH_NO_PREEMPT 852 bool 853 854config ARCH_SUPPORTS_RT 855 bool 856 857config CPU_NO_EFFICIENT_FFS 858 def_bool n 859 860config HAVE_ARCH_VMAP_STACK 861 def_bool n 862 help 863 An arch should select this symbol if it can support kernel stacks 864 in vmalloc space. This means: 865 866 - vmalloc space must be large enough to hold many kernel stacks. 867 This may rule out many 32-bit architectures. 868 869 - Stacks in vmalloc space need to work reliably. For example, if 870 vmap page tables are created on demand, either this mechanism 871 needs to work while the stack points to a virtual address with 872 unpopulated page tables or arch code (switch_to() and switch_mm(), 873 most likely) needs to ensure that the stack's page table entries 874 are populated before running on a possibly unpopulated stack. 875 876 - If the stack overflows into a guard page, something reasonable 877 should happen. The definition of "reasonable" is flexible, but 878 instantly rebooting without logging anything would be unfriendly. 879 880config VMAP_STACK 881 default y 882 bool "Use a virtually-mapped stack" 883 depends on HAVE_ARCH_VMAP_STACK 884 depends on !KASAN || KASAN_VMALLOC 885 ---help--- 886 Enable this if you want the use virtually-mapped kernel stacks 887 with guard pages. This causes kernel stack overflows to be 888 caught immediately rather than causing difficult-to-diagnose 889 corruption. 890 891 To use this with KASAN, the architecture must support backing 892 virtual mappings with real shadow memory, and KASAN_VMALLOC must 893 be enabled. 894 895config ARCH_OPTIONAL_KERNEL_RWX 896 def_bool n 897 898config ARCH_OPTIONAL_KERNEL_RWX_DEFAULT 899 def_bool n 900 901config ARCH_HAS_STRICT_KERNEL_RWX 902 def_bool n 903 904config STRICT_KERNEL_RWX 905 bool "Make kernel text and rodata read-only" if ARCH_OPTIONAL_KERNEL_RWX 906 depends on ARCH_HAS_STRICT_KERNEL_RWX 907 default !ARCH_OPTIONAL_KERNEL_RWX || ARCH_OPTIONAL_KERNEL_RWX_DEFAULT 908 help 909 If this is set, kernel text and rodata memory will be made read-only, 910 and non-text memory will be made non-executable. This provides 911 protection against certain security exploits (e.g. executing the heap 912 or modifying text) 913 914 These features are considered standard security practice these days. 915 You should say Y here in almost all cases. 916 917config ARCH_HAS_STRICT_MODULE_RWX 918 def_bool n 919 920config STRICT_MODULE_RWX 921 bool "Set loadable kernel module data as NX and text as RO" if ARCH_OPTIONAL_KERNEL_RWX 922 depends on ARCH_HAS_STRICT_MODULE_RWX && MODULES 923 default !ARCH_OPTIONAL_KERNEL_RWX || ARCH_OPTIONAL_KERNEL_RWX_DEFAULT 924 help 925 If this is set, module text and rodata memory will be made read-only, 926 and non-text memory will be made non-executable. This provides 927 protection against certain security exploits (e.g. writing to text) 928 929# select if the architecture provides an asm/dma-direct.h header 930config ARCH_HAS_PHYS_TO_DMA 931 bool 932 933config HAVE_ARCH_COMPILER_H 934 bool 935 help 936 An architecture can select this if it provides an 937 asm/compiler.h header that should be included after 938 linux/compiler-*.h in order to override macro definitions that those 939 headers generally provide. 940 941config HAVE_ARCH_PREL32_RELOCATIONS 942 bool 943 help 944 May be selected by an architecture if it supports place-relative 945 32-bit relocations, both in the toolchain and in the module loader, 946 in which case relative references can be used in special sections 947 for PCI fixup, initcalls etc which are only half the size on 64 bit 948 architectures, and don't require runtime relocation on relocatable 949 kernels. 950 951config ARCH_USE_MEMREMAP_PROT 952 bool 953 954config LOCK_EVENT_COUNTS 955 bool "Locking event counts collection" 956 depends on DEBUG_FS 957 ---help--- 958 Enable light-weight counting of various locking related events 959 in the system with minimal performance impact. This reduces 960 the chance of application behavior change because of timing 961 differences. The counts are reported via debugfs. 962 963# Select if the architecture has support for applying RELR relocations. 964config ARCH_HAS_RELR 965 bool 966 967config RELR 968 bool "Use RELR relocation packing" 969 depends on ARCH_HAS_RELR && TOOLS_SUPPORT_RELR 970 default y 971 help 972 Store the kernel's dynamic relocations in the RELR relocation packing 973 format. Requires a compatible linker (LLD supports this feature), as 974 well as compatible NM and OBJCOPY utilities (llvm-nm and llvm-objcopy 975 are compatible). 976 977config ARCH_HAS_MEM_ENCRYPT 978 bool 979 980config HAVE_SPARSE_SYSCALL_NR 981 bool 982 help 983 An architecture should select this if its syscall numbering is sparse 984 to save space. For example, MIPS architecture has a syscall array with 985 entries at 4000, 5000 and 6000 locations. This option turns on syscall 986 related optimizations for a given architecture. 987 988source "kernel/gcov/Kconfig" 989 990source "scripts/gcc-plugins/Kconfig" 991 992endmenu 993