arch/Kconfig

   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 #
  10 source "arch/$(SRCARCH)/Kconfig"
  11
  12 menu "General architecture-dependent options"
  13
  14 config ARCH_HAS_SUBPAGE_FAULTS
  15         bool
  16         help
  17           Select if the architecture can check permissions at sub-page
  18           granularity (e.g. arm64 MTE). The probe_user_*() functions
  19           must be implemented.
  20
  21 config HOTPLUG_SMT
  22         bool
  23
  24 config SMT_NUM_THREADS_DYNAMIC
  25         bool
  26
  27 # Selected by HOTPLUG_CORE_SYNC_DEAD or HOTPLUG_CORE_SYNC_FULL
  28 config HOTPLUG_CORE_SYNC
  29         bool
  30
  31 # Basic CPU dead synchronization selected by architecture
  32 config HOTPLUG_CORE_SYNC_DEAD
  33         bool
  34         select HOTPLUG_CORE_SYNC
  35
  36 # Full CPU synchronization with alive state selected by architecture
  37 config HOTPLUG_CORE_SYNC_FULL
  38         bool
  39         select HOTPLUG_CORE_SYNC_DEAD if HOTPLUG_CPU
  40         select HOTPLUG_CORE_SYNC
  41
  42 config HOTPLUG_SPLIT_STARTUP
  43         bool
  44         select HOTPLUG_CORE_SYNC_FULL
  45
  46 config HOTPLUG_PARALLEL
  47         bool
  48         select HOTPLUG_SPLIT_STARTUP
  49
  50 config GENERIC_ENTRY
  51         bool
  52
  53 config KPROBES
  54         bool "Kprobes"
  55         depends on MODULES
  56         depends on HAVE_KPROBES
  57         select KALLSYMS
  58         select TASKS_RCU if PREEMPTION
  59         help
  60           Kprobes allows you to trap at almost any kernel address and
  61           execute a callback function.  register_kprobe() establishes
  62           a probepoint and specifies the callback.  Kprobes is useful
  63           for kernel debugging, non-intrusive instrumentation and testing.
  64           If in doubt, say "N".
  65
  66 config JUMP_LABEL
  67         bool "Optimize very unlikely/likely branches"
  68         depends on HAVE_ARCH_JUMP_LABEL
  69         select OBJTOOL if HAVE_JUMP_LABEL_HACK
  70         help
  71           This option enables a transparent branch optimization that
  72           makes certain almost-always-true or almost-always-false branch
  73           conditions even cheaper to execute within the kernel.
  74
  75           Certain performance-sensitive kernel code, such as trace points,
  76           scheduler functionality, networking code and KVM have such
  77           branches and include support for this optimization technique.
  78
  79           If it is detected that the compiler has support for "asm goto",
  80           the kernel will compile such branches with just a nop
  81           instruction. When the condition flag is toggled to true, the
  82           nop will be converted to a jump instruction to execute the
  83           conditional block of instructions.
  84
  85           This technique lowers overhead and stress on the branch prediction
  86           of the processor and generally makes the kernel faster. The update
  87           of the condition is slower, but those are always very rare.
  88
  89           ( On 32-bit x86, the necessary options added to the compiler
  90             flags may increase the size of the kernel slightly. )
  91
  92 config STATIC_KEYS_SELFTEST
  93         bool "Static key selftest"
  94         depends on JUMP_LABEL
  95         help
  96           Boot time self-test of the branch patching code.
  97
  98 config STATIC_CALL_SELFTEST
  99         bool "Static call selftest"
 100         depends on HAVE_STATIC_CALL
 101         help
 102           Boot time self-test of the call patching code.
 103
 104 config OPTPROBES
 105         def_bool y
 106         depends on KPROBES && HAVE_OPTPROBES
 107         select TASKS_RCU if PREEMPTION
 108
 109 config KPROBES_ON_FTRACE
 110         def_bool y
 111         depends on KPROBES && HAVE_KPROBES_ON_FTRACE
 112         depends on DYNAMIC_FTRACE_WITH_REGS
 113         help
 114           If function tracer is enabled and the arch supports full
 115           passing of pt_regs to function tracing, then kprobes can
 116           optimize on top of function tracing.
 117
 118 config UPROBES
 119         def_bool n
 120         depends on ARCH_SUPPORTS_UPROBES
 121         help
 122           Uprobes is the user-space counterpart to kprobes: they
 123           enable instrumentation applications (such as 'perf probe')
 124           to establish unintrusive probes in user-space binaries and
 125           libraries, by executing handler functions when the probes
 126           are hit by user-space applications.
 127
 128           ( These probes come in the form of single-byte breakpoints,
 129             managed by the kernel and kept transparent to the probed
 130             application. )
 131
 132 config HAVE_64BIT_ALIGNED_ACCESS
 133         def_bool 64BIT && !HAVE_EFFICIENT_UNALIGNED_ACCESS
 134         help
 135           Some architectures require 64 bit accesses to be 64 bit
 136           aligned, which also requires structs containing 64 bit values
 137           to be 64 bit aligned too. This includes some 32 bit
 138           architectures which can do 64 bit accesses, as well as 64 bit
 139           architectures without unaligned access.
 140
 141           This symbol should be selected by an architecture if 64 bit
 142           accesses are required to be 64 bit aligned in this way even
 143           though it is not a 64 bit architecture.
 144
 145           See Documentation/core-api/unaligned-memory-access.rst for
 146           more information on the topic of unaligned memory accesses.
 147
 148 config HAVE_EFFICIENT_UNALIGNED_ACCESS
 149         bool
 150         help
 151           Some architectures are unable to perform unaligned accesses
 152           without the use of get_unaligned/put_unaligned. Others are
 153           unable to perform such accesses efficiently (e.g. trap on
 154           unaligned access and require fixing it up in the exception
 155           handler.)
 156
 157           This symbol should be selected by an architecture if it can
 158           perform unaligned accesses efficiently to allow different
 159           code paths to be selected for these cases. Some network
 160           drivers, for example, could opt to not fix up alignment
 161           problems with received packets if doing so would not help
 162           much.
 163
 164           See Documentation/core-api/unaligned-memory-access.rst for more
 165           information on the topic of unaligned memory accesses.
 166
 167 config ARCH_USE_BUILTIN_BSWAP
 168         bool
 169         help
 170           Modern versions of GCC (since 4.4) have builtin functions
 171           for handling byte-swapping. Using these, instead of the old
 172           inline assembler that the architecture code provides in the
 173           __arch_bswapXX() macros, allows the compiler to see what's
 174           happening and offers more opportunity for optimisation. In
 175           particular, the compiler will be able to combine the byteswap
 176           with a nearby load or store and use load-and-swap or
 177           store-and-swap instructions if the architecture has them. It
 178           should almost *never* result in code which is worse than the
 179           hand-coded assembler in <asm/swab.h>.  But just in case it
 180           does, the use of the builtins is optional.
 181
 182           Any architecture with load-and-swap or store-and-swap
 183           instructions should set this. And it shouldn't hurt to set it
 184           on architectures that don't have such instructions.
 185
 186 config KRETPROBES
 187         def_bool y
 188         depends on KPROBES && (HAVE_KRETPROBES || HAVE_RETHOOK)
 189
 190 config KRETPROBE_ON_RETHOOK
 191         def_bool y
 192         depends on HAVE_RETHOOK
 193         depends on KRETPROBES
 194         select RETHOOK
 195
 196 config USER_RETURN_NOTIFIER
 197         bool
 198         depends on HAVE_USER_RETURN_NOTIFIER
 199         help
 200           Provide a kernel-internal notification when a cpu is about to
 201           switch to user mode.
 202
 203 config HAVE_IOREMAP_PROT
 204         bool
 205
 206 config HAVE_KPROBES
 207         bool
 208
 209 config HAVE_KRETPROBES
 210         bool
 211
 212 config HAVE_OPTPROBES
 213         bool
 214
 215 config HAVE_KPROBES_ON_FTRACE
 216         bool
 217
 218 config ARCH_CORRECT_STACKTRACE_ON_KRETPROBE
 219         bool
 220         help
 221           Since kretprobes modifies return address on the stack, the
 222           stacktrace may see the kretprobe trampoline address instead
 223           of correct one. If the architecture stacktrace code and
 224           unwinder can adjust such entries, select this configuration.
 225
 226 config HAVE_FUNCTION_ERROR_INJECTION
 227         bool
 228
 229 config HAVE_NMI
 230         bool
 231
 232 config HAVE_FUNCTION_DESCRIPTORS
 233         bool
 234
 235 config TRACE_IRQFLAGS_SUPPORT
 236         bool
 237
 238 config TRACE_IRQFLAGS_NMI_SUPPORT
 239         bool
 240
 241 #
 242 # An arch should select this if it provides all these things:
 243 #
 244 #       task_pt_regs()          in asm/processor.h or asm/ptrace.h
 245 #       arch_has_single_step()  if there is hardware single-step support
 246 #       arch_has_block_step()   if there is hardware block-step support
 247 #       asm/syscall.h           supplying asm-generic/syscall.h interface
 248 #       linux/regset.h          user_regset interfaces
 249 #       CORE_DUMP_USE_REGSET    #define'd in linux/elf.h
 250 #       TIF_SYSCALL_TRACE       calls ptrace_report_syscall_{entry,exit}
 251 #       TIF_NOTIFY_RESUME       calls resume_user_mode_work()
 252 #
 253 config HAVE_ARCH_TRACEHOOK
 254         bool
 255
 256 config HAVE_DMA_CONTIGUOUS
 257         bool
 258
 259 config GENERIC_SMP_IDLE_THREAD
 260         bool
 261
 262 config GENERIC_IDLE_POLL_SETUP
 263         bool
 264
 265 config ARCH_HAS_FORTIFY_SOURCE
 266         bool
 267         help
 268           An architecture should select this when it can successfully
 269           build and run with CONFIG_FORTIFY_SOURCE.
 270
 271 #
 272 # Select if the arch provides a historic keepinit alias for the retain_initrd
 273 # command line option
 274 #
 275 config ARCH_HAS_KEEPINITRD
 276         bool
 277
 278 # Select if arch has all set_memory_ro/rw/x/nx() functions in asm/cacheflush.h
 279 config ARCH_HAS_SET_MEMORY
 280         bool
 281
 282 # Select if arch has all set_direct_map_invalid/default() functions
 283 config ARCH_HAS_SET_DIRECT_MAP
 284         bool
 285
 286 #
 287 # Select if the architecture provides the arch_dma_set_uncached symbol to
 288 # either provide an uncached segment alias for a DMA allocation, or
 289 # to remap the page tables in place.
 290 #
 291 config ARCH_HAS_DMA_SET_UNCACHED
 292         bool
 293
 294 #
 295 # Select if the architectures provides the arch_dma_clear_uncached symbol
 296 # to undo an in-place page table remap for uncached access.
 297 #
 298 config ARCH_HAS_DMA_CLEAR_UNCACHED
 299         bool
 300
 301 config ARCH_HAS_CPU_FINALIZE_INIT
 302         bool
 303
 304 # The architecture has a per-task state that includes the mm's PASID
 305 config ARCH_HAS_CPU_PASID
 306         bool
 307         select IOMMU_MM_DATA
 308
 309 config HAVE_ARCH_THREAD_STRUCT_WHITELIST
 310         bool
 311         help
 312           An architecture should select this to provide hardened usercopy
 313           knowledge about what region of the thread_struct should be
 314           whitelisted for copying to userspace. Normally this is only the
 315           FPU registers. Specifically, arch_thread_struct_whitelist()
 316           should be implemented. Without this, the entire thread_struct
 317           field in task_struct will be left whitelisted.
 318
 319 # Select if arch wants to size task_struct dynamically via arch_task_struct_size:
 320 config ARCH_WANTS_DYNAMIC_TASK_STRUCT
 321         bool
 322
 323 config ARCH_WANTS_NO_INSTR
 324         bool
 325         help
 326           An architecture should select this if the noinstr macro is being used on
 327           functions to denote that the toolchain should avoid instrumenting such
 328           functions and is required for correctness.
 329
 330 config ARCH_32BIT_OFF_T
 331         bool
 332         depends on !64BIT
 333         help
 334           All new 32-bit architectures should have 64-bit off_t type on
 335           userspace side which corresponds to the loff_t kernel type. This
 336           is the requirement for modern ABIs. Some existing architectures
 337           still support 32-bit off_t. This option is enabled for all such
 338           architectures explicitly.
 339
 340 # Selected by 64 bit architectures which have a 32 bit f_tinode in struct ustat
 341 config ARCH_32BIT_USTAT_F_TINODE
 342         bool
 343
 344 config HAVE_ASM_MODVERSIONS
 345         bool
 346         help
 347           This symbol should be selected by an architecture if it provides
 348           <asm/asm-prototypes.h> to support the module versioning for symbols
 349           exported from assembly code.
 350
 351 config HAVE_REGS_AND_STACK_ACCESS_API
 352         bool
 353         help
 354           This symbol should be selected by an architecture if it supports
 355           the API needed to access registers and stack entries from pt_regs,
 356           declared in asm/ptrace.h
 357           For example the kprobes-based event tracer needs this API.
 358
 359 config HAVE_RSEQ
 360         bool
 361         depends on HAVE_REGS_AND_STACK_ACCESS_API
 362         help
 363           This symbol should be selected by an architecture if it
 364           supports an implementation of restartable sequences.
 365
 366 config HAVE_RUST
 367         bool
 368         help
 369           This symbol should be selected by an architecture if it
 370           supports Rust.
 371
 372 config HAVE_FUNCTION_ARG_ACCESS_API
 373         bool
 374         help
 375           This symbol should be selected by an architecture if it supports
 376           the API needed to access function arguments from pt_regs,
 377           declared in asm/ptrace.h
 378
 379 config HAVE_HW_BREAKPOINT
 380         bool
 381         depends on PERF_EVENTS
 382
 383 config HAVE_MIXED_BREAKPOINTS_REGS
 384         bool
 385         depends on HAVE_HW_BREAKPOINT
 386         help
 387           Depending on the arch implementation of hardware breakpoints,
 388           some of them have separate registers for data and instruction
 389           breakpoints addresses, others have mixed registers to store
 390           them but define the access type in a control register.
 391           Select this option if your arch implements breakpoints under the
 392           latter fashion.
 393
 394 config HAVE_USER_RETURN_NOTIFIER
 395         bool
 396
 397 config HAVE_PERF_EVENTS_NMI
 398         bool
 399         help
 400           System hardware can generate an NMI using the perf event
 401           subsystem.  Also has support for calculating CPU cycle events
 402           to determine how many clock cycles in a given period.
 403
 404 config HAVE_HARDLOCKUP_DETECTOR_PERF
 405         bool
 406         depends on HAVE_PERF_EVENTS_NMI
 407         help
 408           The arch chooses to use the generic perf-NMI-based hardlockup
 409           detector. Must define HAVE_PERF_EVENTS_NMI.
 410
 411 config HAVE_HARDLOCKUP_DETECTOR_ARCH
 412         bool
 413         help
 414           The arch provides its own hardlockup detector implementation instead
 415           of the generic ones.
 416
 417           It uses the same command line parameters, and sysctl interface,
 418           as the generic hardlockup detectors.
 419
 420 config HAVE_PERF_REGS
 421         bool
 422         help
 423           Support selective register dumps for perf events. This includes
 424           bit-mapping of each registers and a unique architecture id.
 425
 426 config HAVE_PERF_USER_STACK_DUMP
 427         bool
 428         help
 429           Support user stack dumps for perf event samples. This needs
 430           access to the user stack pointer which is not unified across
 431           architectures.
 432
 433 config HAVE_ARCH_JUMP_LABEL
 434         bool
 435
 436 config HAVE_ARCH_JUMP_LABEL_RELATIVE
 437         bool
 438
 439 config MMU_GATHER_TABLE_FREE
 440         bool
 441
 442 config MMU_GATHER_RCU_TABLE_FREE
 443         bool
 444         select MMU_GATHER_TABLE_FREE
 445
 446 config MMU_GATHER_PAGE_SIZE
 447         bool
 448
 449 config MMU_GATHER_NO_RANGE
 450         bool
 451         select MMU_GATHER_MERGE_VMAS
 452
 453 config MMU_GATHER_NO_FLUSH_CACHE
 454         bool
 455
 456 config MMU_GATHER_MERGE_VMAS
 457         bool
 458
 459 config MMU_GATHER_NO_GATHER
 460         bool
 461         depends on MMU_GATHER_TABLE_FREE
 462
 463 config ARCH_WANT_IRQS_OFF_ACTIVATE_MM
 464         bool
 465         help
 466           Temporary select until all architectures can be converted to have
 467           irqs disabled over activate_mm. Architectures that do IPI based TLB
 468           shootdowns should enable this.
 469
 470 # Use normal mm refcounting for MMU_LAZY_TLB kernel thread references.
 471 # MMU_LAZY_TLB_REFCOUNT=n can improve the scalability of context switching
 472 # to/from kernel threads when the same mm is running on a lot of CPUs (a large
 473 # multi-threaded application), by reducing contention on the mm refcount.
 474 #
 475 # This can be disabled if the architecture ensures no CPUs are using an mm as a
 476 # "lazy tlb" beyond its final refcount (i.e., by the time __mmdrop frees the mm
 477 # or its kernel page tables). This could be arranged by arch_exit_mmap(), or
 478 # final exit(2) TLB flush, for example.
 479 #
 480 # To implement this, an arch *must*:
 481 # Ensure the _lazy_tlb variants of mmgrab/mmdrop are used when manipulating
 482 # the lazy tlb reference of a kthread's ->active_mm (non-arch code has been
 483 # converted already).
 484 config MMU_LAZY_TLB_REFCOUNT
 485         def_bool y
 486         depends on !MMU_LAZY_TLB_SHOOTDOWN
 487
 488 # This option allows MMU_LAZY_TLB_REFCOUNT=n. It ensures no CPUs are using an
 489 # mm as a lazy tlb beyond its last reference count, by shooting down these
 490 # users before the mm is deallocated. __mmdrop() first IPIs all CPUs that may
 491 # be using the mm as a lazy tlb, so that they may switch themselves to using
 492 # init_mm for their active mm. mm_cpumask(mm) is used to determine which CPUs
 493 # may be using mm as a lazy tlb mm.
 494 #
 495 # To implement this, an arch *must*:
 496 # - At the time of the final mmdrop of the mm, ensure mm_cpumask(mm) contains
 497 #   at least all possible CPUs in which the mm is lazy.
 498 # - It must meet the requirements for MMU_LAZY_TLB_REFCOUNT=n (see above).
 499 config MMU_LAZY_TLB_SHOOTDOWN
 500         bool
 501
 502 config ARCH_HAVE_NMI_SAFE_CMPXCHG
 503         bool
 504
 505 config ARCH_HAS_NMI_SAFE_THIS_CPU_OPS
 506         bool
 507
 508 config HAVE_ALIGNED_STRUCT_PAGE
 509         bool
 510         help
 511           This makes sure that struct pages are double word aligned and that
 512           e.g. the SLUB allocator can perform double word atomic operations
 513           on a struct page for better performance. However selecting this
 514           might increase the size of a struct page by a word.
 515
 516 config HAVE_CMPXCHG_LOCAL
 517         bool
 518
 519 config HAVE_CMPXCHG_DOUBLE
 520         bool
 521
 522 config ARCH_WEAK_RELEASE_ACQUIRE
 523         bool
 524
 525 config ARCH_WANT_IPC_PARSE_VERSION
 526         bool
 527
 528 config ARCH_WANT_COMPAT_IPC_PARSE_VERSION
 529         bool
 530
 531 config ARCH_WANT_OLD_COMPAT_IPC
 532         select ARCH_WANT_COMPAT_IPC_PARSE_VERSION
 533         bool
 534
 535 config HAVE_ARCH_SECCOMP
 536         bool
 537         help
 538           An arch should select this symbol to support seccomp mode 1 (the fixed
 539           syscall policy), and must provide an overrides for __NR_seccomp_sigreturn,
 540           and compat syscalls if the asm-generic/seccomp.h defaults need adjustment:
 541           - __NR_seccomp_read_32
 542           - __NR_seccomp_write_32
 543           - __NR_seccomp_exit_32
 544           - __NR_seccomp_sigreturn_32
 545
 546 config HAVE_ARCH_SECCOMP_FILTER
 547         bool
 548         select HAVE_ARCH_SECCOMP
 549         help
 550           An arch should select this symbol if it provides all of these things:
 551           - all the requirements for HAVE_ARCH_SECCOMP
 552           - syscall_get_arch()
 553           - syscall_get_arguments()
 554           - syscall_rollback()
 555           - syscall_set_return_value()
 556           - SIGSYS siginfo_t support
 557           - secure_computing is called from a ptrace_event()-safe context
 558           - secure_computing return value is checked and a return value of -1
 559             results in the system call being skipped immediately.
 560           - seccomp syscall wired up
 561           - if !HAVE_SPARSE_SYSCALL_NR, have SECCOMP_ARCH_NATIVE,
 562             SECCOMP_ARCH_NATIVE_NR, SECCOMP_ARCH_NATIVE_NAME defined. If
 563             COMPAT is supported, have the SECCOMP_ARCH_COMPAT* defines too.
 564
 565 config SECCOMP
 566         prompt "Enable seccomp to safely execute untrusted bytecode"
 567         def_bool y
 568         depends on HAVE_ARCH_SECCOMP
 569         help
 570           This kernel feature is useful for number crunching applications
 571           that may need to handle untrusted bytecode during their
 572           execution. By using pipes or other transports made available
 573           to the process as file descriptors supporting the read/write
 574           syscalls, it's possible to isolate those applications in their
 575           own address space using seccomp. Once seccomp is enabled via
 576           prctl(PR_SET_SECCOMP) or the seccomp() syscall, it cannot be
 577           disabled and the task is only allowed to execute a few safe
 578           syscalls defined by each seccomp mode.
 579
 580           If unsure, say Y.
 581
 582 config SECCOMP_FILTER
 583         def_bool y
 584         depends on HAVE_ARCH_SECCOMP_FILTER && SECCOMP && NET
 585         help
 586           Enable tasks to build secure computing environments defined
 587           in terms of Berkeley Packet Filter programs which implement
 588           task-defined system call filtering polices.
 589
 590           See Documentation/userspace-api/seccomp_filter.rst for details.
 591
 592 config SECCOMP_CACHE_DEBUG
 593         bool "Show seccomp filter cache status in /proc/pid/seccomp_cache"
 594         depends on SECCOMP_FILTER && !HAVE_SPARSE_SYSCALL_NR
 595         depends on PROC_FS
 596         help
 597           This enables the /proc/pid/seccomp_cache interface to monitor
 598           seccomp cache data. The file format is subject to change. Reading
 599           the file requires CAP_SYS_ADMIN.
 600
 601           This option is for debugging only. Enabling presents the risk that
 602           an adversary may be able to infer the seccomp filter logic.
 603
 604           If unsure, say N.
 605
 606 config HAVE_ARCH_STACKLEAK
 607         bool
 608         help
 609           An architecture should select this if it has the code which
 610           fills the used part of the kernel stack with the STACKLEAK_POISON
 611           value before returning from system calls.
 612
 613 config HAVE_STACKPROTECTOR
 614         bool
 615         help
 616           An arch should select this symbol if:
 617           - it has implemented a stack canary (e.g. __stack_chk_guard)
 618
 619 config STACKPROTECTOR
 620         bool "Stack Protector buffer overflow detection"
 621         depends on HAVE_STACKPROTECTOR
 622         depends on $(cc-option,-fstack-protector)
 623         default y
 624         help
 625           This option turns on the "stack-protector" GCC feature. This
 626           feature puts, at the beginning of functions, a canary value on
 627           the stack just before the return address, and validates
 628           the value just before actually returning.  Stack based buffer
 629           overflows (that need to overwrite this return address) now also
 630           overwrite the canary, which gets detected and the attack is then
 631           neutralized via a kernel panic.
 632
 633           Functions will have the stack-protector canary logic added if they
 634           have an 8-byte or larger character array on the stack.
 635
 636           This feature requires gcc version 4.2 or above, or a distribution
 637           gcc with the feature backported ("-fstack-protector").
 638
 639           On an x86 "defconfig" build, this feature adds canary checks to
 640           about 3% of all kernel functions, which increases kernel code size
 641           by about 0.3%.
 642
 643 config STACKPROTECTOR_STRONG
 644         bool "Strong Stack Protector"
 645         depends on STACKPROTECTOR
 646         depends on $(cc-option,-fstack-protector-strong)
 647         default y
 648         help
 649           Functions will have the stack-protector canary logic added in any
 650           of the following conditions:
 651
 652           - local variable's address used as part of the right hand side of an
 653             assignment or function argument
 654           - local variable is an array (or union containing an array),
 655             regardless of array type or length
 656           - uses register local variables
 657
 658           This feature requires gcc version 4.9 or above, or a distribution
 659           gcc with the feature backported ("-fstack-protector-strong").
 660
 661           On an x86 "defconfig" build, this feature adds canary checks to
 662           about 20% of all kernel functions, which increases the kernel code
 663           size by about 2%.
 664
 665 config ARCH_SUPPORTS_SHADOW_CALL_STACK
 666         bool
 667         help
 668           An architecture should select this if it supports the compiler's
 669           Shadow Call Stack and implements runtime support for shadow stack
 670           switching.
 671
 672 config SHADOW_CALL_STACK
 673         bool "Shadow Call Stack"
 674         depends on ARCH_SUPPORTS_SHADOW_CALL_STACK
 675         depends on DYNAMIC_FTRACE_WITH_ARGS || DYNAMIC_FTRACE_WITH_REGS || !FUNCTION_GRAPH_TRACER
 676         help
 677           This option enables the compiler's Shadow Call Stack, which
 678           uses a shadow stack to protect function return addresses from
 679           being overwritten by an attacker. More information can be found
 680           in the compiler's documentation:
 681
 682           - Clang: https://clang.llvm.org/docs/ShadowCallStack.html
 683           - GCC: https://gcc.gnu.org/onlinedocs/gcc/Instrumentation-Options.html#Instrumentation-Options
 684
 685           Note that security guarantees in the kernel differ from the
 686           ones documented for user space. The kernel must store addresses
 687           of shadow stacks in memory, which means an attacker capable of
 688           reading and writing arbitrary memory may be able to locate them
 689           and hijack control flow by modifying the stacks.
 690
 691 config DYNAMIC_SCS
 692         bool
 693         help
 694           Set by the arch code if it relies on code patching to insert the
 695           shadow call stack push and pop instructions rather than on the
 696           compiler.
 697
 698 config LTO
 699         bool
 700         help
 701           Selected if the kernel will be built using the compiler's LTO feature.
 702
 703 config LTO_CLANG
 704         bool
 705         select LTO
 706         help
 707           Selected if the kernel will be built using Clang's LTO feature.
 708
 709 config ARCH_SUPPORTS_LTO_CLANG
 710         bool
 711         help
 712           An architecture should select this option if it supports:
 713           - compiling with Clang,
 714           - compiling inline assembly with Clang's integrated assembler,
 715           - and linking with LLD.
 716
 717 config ARCH_SUPPORTS_LTO_CLANG_THIN
 718         bool
 719         help
 720           An architecture should select this option if it can support Clang's
 721           ThinLTO mode.
 722
 723 config HAS_LTO_CLANG
 724         def_bool y
 725         depends on CC_IS_CLANG && LD_IS_LLD && AS_IS_LLVM
 726         depends on $(success,$(NM) --help | head -n 1 | grep -qi llvm)
 727         depends on $(success,$(AR) --help | head -n 1 | grep -qi llvm)
 728         depends on ARCH_SUPPORTS_LTO_CLANG
 729         depends on !FTRACE_MCOUNT_USE_RECORDMCOUNT
 730         # https://github.com/ClangBuiltLinux/linux/issues/1721
 731         depends on (!KASAN || KASAN_HW_TAGS || CLANG_VERSION >= 170000) || !DEBUG_INFO
 732         depends on (!KCOV || CLANG_VERSION >= 170000) || !DEBUG_INFO
 733         depends on !GCOV_KERNEL
 734         help
 735           The compiler and Kconfig options support building with Clang's
 736           LTO.
 737
 738 choice
 739         prompt "Link Time Optimization (LTO)"
 740         default LTO_NONE
 741         help
 742           This option enables Link Time Optimization (LTO), which allows the
 743           compiler to optimize binaries globally.
 744
 745           If unsure, select LTO_NONE. Note that LTO is very resource-intensive
 746           so it's disabled by default.
 747
 748 config LTO_NONE
 749         bool "None"
 750         help
 751           Build the kernel normally, without Link Time Optimization (LTO).
 752
 753 config LTO_CLANG_FULL
 754         bool "Clang Full LTO (EXPERIMENTAL)"
 755         depends on HAS_LTO_CLANG
 756         depends on !COMPILE_TEST
 757         select LTO_CLANG
 758         help
 759           This option enables Clang's full Link Time Optimization (LTO), which
 760           allows the compiler to optimize the kernel globally. If you enable
 761           this option, the compiler generates LLVM bitcode instead of ELF
 762           object files, and the actual compilation from bitcode happens at
 763           the LTO link step, which may take several minutes depending on the
 764           kernel configuration. More information can be found from LLVM's
 765           documentation:
 766
 767             https://llvm.org/docs/LinkTimeOptimization.html
 768
 769           During link time, this option can use a large amount of RAM, and
 770           may take much longer than the ThinLTO option.
 771
 772 config LTO_CLANG_THIN
 773         bool "Clang ThinLTO (EXPERIMENTAL)"
 774         depends on HAS_LTO_CLANG && ARCH_SUPPORTS_LTO_CLANG_THIN
 775         select LTO_CLANG
 776         help
 777           This option enables Clang's ThinLTO, which allows for parallel
 778           optimization and faster incremental compiles compared to the
 779           CONFIG_LTO_CLANG_FULL option. More information can be found
 780           from Clang's documentation:
 781
 782             https://clang.llvm.org/docs/ThinLTO.html
 783
 784           If unsure, say Y.
 785 endchoice
 786
 787 config ARCH_SUPPORTS_CFI_CLANG
 788         bool
 789         help
 790           An architecture should select this option if it can support Clang's
 791           Control-Flow Integrity (CFI) checking.
 792
 793 config ARCH_USES_CFI_TRAPS
 794         bool
 795
 796 config CFI_CLANG
 797         bool "Use Clang's Control Flow Integrity (CFI)"
 798         depends on ARCH_SUPPORTS_CFI_CLANG
 799         depends on $(cc-option,-fsanitize=kcfi)
 800         help
 801           This option enables Clang’s forward-edge Control Flow Integrity
 802           (CFI) checking, where the compiler injects a runtime check to each
 803           indirect function call to ensure the target is a valid function with
 804           the correct static type. This restricts possible call targets and
 805           makes it more difficult for an attacker to exploit bugs that allow
 806           the modification of stored function pointers. More information can be
 807           found from Clang's documentation:
 808
 809             https://clang.llvm.org/docs/ControlFlowIntegrity.html
 810
 811 config CFI_PERMISSIVE
 812         bool "Use CFI in permissive mode"
 813         depends on CFI_CLANG
 814         help
 815           When selected, Control Flow Integrity (CFI) violations result in a
 816           warning instead of a kernel panic. This option should only be used
 817           for finding indirect call type mismatches during development.
 818
 819           If unsure, say N.
 820
 821 config HAVE_ARCH_WITHIN_STACK_FRAMES
 822         bool
 823         help
 824           An architecture should select this if it can walk the kernel stack
 825           frames to determine if an object is part of either the arguments
 826           or local variables (i.e. that it excludes saved return addresses,
 827           and similar) by implementing an inline arch_within_stack_frames(),
 828           which is used by CONFIG_HARDENED_USERCOPY.
 829
 830 config HAVE_CONTEXT_TRACKING_USER
 831         bool
 832         help
 833           Provide kernel/user boundaries probes necessary for subsystems
 834           that need it, such as userspace RCU extended quiescent state.
 835           Syscalls need to be wrapped inside user_exit()-user_enter(), either
 836           optimized behind static key or through the slow path using TIF_NOHZ
 837           flag. Exceptions handlers must be wrapped as well. Irqs are already
 838           protected inside ct_irq_enter/ct_irq_exit() but preemption or signal
 839           handling on irq exit still need to be protected.
 840
 841 config HAVE_CONTEXT_TRACKING_USER_OFFSTACK
 842         bool
 843         help
 844           Architecture neither relies on exception_enter()/exception_exit()
 845           nor on schedule_user(). Also preempt_schedule_notrace() and
 846           preempt_schedule_irq() can't be called in a preemptible section
 847           while context tracking is CONTEXT_USER. This feature reflects a sane
 848           entry implementation where the following requirements are met on
 849           critical entry code, ie: before user_exit() or after user_enter():
 850
 851           - Critical entry code isn't preemptible (or better yet:
 852             not interruptible).
 853           - No use of RCU read side critical sections, unless ct_nmi_enter()
 854             got called.
 855           - No use of instrumentation, unless instrumentation_begin() got
 856             called.
 857
 858 config HAVE_TIF_NOHZ
 859         bool
 860         help
 861           Arch relies on TIF_NOHZ and syscall slow path to implement context
 862           tracking calls to user_enter()/user_exit().
 863
 864 config HAVE_VIRT_CPU_ACCOUNTING
 865         bool
 866
 867 config HAVE_VIRT_CPU_ACCOUNTING_IDLE
 868         bool
 869         help
 870           Architecture has its own way to account idle CPU time and therefore
 871           doesn't implement vtime_account_idle().
 872
 873 config ARCH_HAS_SCALED_CPUTIME
 874         bool
 875
 876 config HAVE_VIRT_CPU_ACCOUNTING_GEN
 877         bool
 878         default y if 64BIT
 879         help
 880           With VIRT_CPU_ACCOUNTING_GEN, cputime_t becomes 64-bit.
 881           Before enabling this option, arch code must be audited
 882           to ensure there are no races in concurrent read/write of
 883           cputime_t. For example, reading/writing 64-bit cputime_t on
 884           some 32-bit arches may require multiple accesses, so proper
 885           locking is needed to protect against concurrent accesses.
 886
 887 config HAVE_IRQ_TIME_ACCOUNTING
 888         bool
 889         help
 890           Archs need to ensure they use a high enough resolution clock to
 891           support irq time accounting and then call enable_sched_clock_irqtime().
 892
 893 config HAVE_MOVE_PUD
 894         bool
 895         help
 896           Architectures that select this are able to move page tables at the
 897           PUD level. If there are only 3 page table levels, the move effectively
 898           happens at the PGD level.
 899
 900 config HAVE_MOVE_PMD
 901         bool
 902         help
 903           Archs that select this are able to move page tables at the PMD level.
 904
 905 config HAVE_ARCH_TRANSPARENT_HUGEPAGE
 906         bool
 907
 908 config HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD
 909         bool
 910
 911 config HAVE_ARCH_HUGE_VMAP
 912         bool
 913
 914 #
 915 #  Archs that select this would be capable of PMD-sized vmaps (i.e.,
 916 #  arch_vmap_pmd_supported() returns true). The VM_ALLOW_HUGE_VMAP flag
 917 #  must be used to enable allocations to use hugepages.
 918 #
 919 config HAVE_ARCH_HUGE_VMALLOC
 920         depends on HAVE_ARCH_HUGE_VMAP
 921         bool
 922
 923 config ARCH_WANT_HUGE_PMD_SHARE
 924         bool
 925
 926 # Archs that want to use pmd_mkwrite on kernel memory need it defined even
 927 # if there are no userspace memory management features that use it
 928 config ARCH_WANT_KERNEL_PMD_MKWRITE
 929         bool
 930
 931 config ARCH_WANT_PMD_MKWRITE
 932         def_bool TRANSPARENT_HUGEPAGE || ARCH_WANT_KERNEL_PMD_MKWRITE
 933
 934 config HAVE_ARCH_SOFT_DIRTY
 935         bool
 936
 937 config HAVE_MOD_ARCH_SPECIFIC
 938         bool
 939         help
 940           The arch uses struct mod_arch_specific to store data.  Many arches
 941           just need a simple module loader without arch specific data - those
 942           should not enable this.
 943
 944 config MODULES_USE_ELF_RELA
 945         bool
 946         help
 947           Modules only use ELF RELA relocations.  Modules with ELF REL
 948           relocations will give an error.
 949
 950 config MODULES_USE_ELF_REL
 951         bool
 952         help
 953           Modules only use ELF REL relocations.  Modules with ELF RELA
 954           relocations will give an error.
 955
 956 config ARCH_WANTS_MODULES_DATA_IN_VMALLOC
 957         bool
 958         help
 959           For architectures like powerpc/32 which have constraints on module
 960           allocation and need to allocate module data outside of module area.
 961
 962 config HAVE_IRQ_EXIT_ON_IRQ_STACK
 963         bool
 964         help
 965           Architecture doesn't only execute the irq handler on the irq stack
 966           but also irq_exit(). This way we can process softirqs on this irq
 967           stack instead of switching to a new one when we call __do_softirq()
 968           in the end of an hardirq.
 969           This spares a stack switch and improves cache usage on softirq
 970           processing.
 971
 972 config HAVE_SOFTIRQ_ON_OWN_STACK
 973         bool
 974         help
 975           Architecture provides a function to run __do_softirq() on a
 976           separate stack.
 977
 978 config SOFTIRQ_ON_OWN_STACK
 979         def_bool HAVE_SOFTIRQ_ON_OWN_STACK && !PREEMPT_RT
 980
 981 config ALTERNATE_USER_ADDRESS_SPACE
 982         bool
 983         help
 984           Architectures set this when the CPU uses separate address
 985           spaces for kernel and user space pointers. In this case, the
 986           access_ok() check on a __user pointer is skipped.
 987
 988 config PGTABLE_LEVELS
 989         int
 990         default 2
 991
 992 config ARCH_HAS_ELF_RANDOMIZE
 993         bool
 994         help
 995           An architecture supports choosing randomized locations for
 996           stack, mmap, brk, and ET_DYN. Defined functions:
 997           - arch_mmap_rnd()
 998           - arch_randomize_brk()
 999
1000 config HAVE_ARCH_MMAP_RND_BITS
1001         bool
1002         help
1003           An arch should select this symbol if it supports setting a variable
1004           number of bits for use in establishing the base address for mmap
1005           allocations, has MMU enabled and provides values for both:
1006           - ARCH_MMAP_RND_BITS_MIN
1007           - ARCH_MMAP_RND_BITS_MAX
1008
1009 config HAVE_EXIT_THREAD
1010         bool
1011         help
1012           An architecture implements exit_thread.
1013
1014 config ARCH_MMAP_RND_BITS_MIN
1015         int
1016
1017 config ARCH_MMAP_RND_BITS_MAX
1018         int
1019
1020 config ARCH_MMAP_RND_BITS_DEFAULT
1021         int
1022
1023 config ARCH_MMAP_RND_BITS
1024         int "Number of bits to use for ASLR of mmap base address" if EXPERT
1025         range ARCH_MMAP_RND_BITS_MIN ARCH_MMAP_RND_BITS_MAX
1026         default ARCH_MMAP_RND_BITS_DEFAULT if ARCH_MMAP_RND_BITS_DEFAULT
1027         default ARCH_MMAP_RND_BITS_MIN
1028         depends on HAVE_ARCH_MMAP_RND_BITS
1029         help
1030           This value can be used to select the number of bits to use to
1031           determine the random offset to the base address of vma regions
1032           resulting from mmap allocations. This value will be bounded
1033           by the architecture's minimum and maximum supported values.
1034
1035           This value can be changed after boot using the
1036           /proc/sys/vm/mmap_rnd_bits tunable
1037
1038 config HAVE_ARCH_MMAP_RND_COMPAT_BITS
1039         bool
1040         help
1041           An arch should select this symbol if it supports running applications
1042           in compatibility mode, supports setting a variable number of bits for
1043           use in establishing the base address for mmap allocations, has MMU
1044           enabled and provides values for both:
1045           - ARCH_MMAP_RND_COMPAT_BITS_MIN
1046           - ARCH_MMAP_RND_COMPAT_BITS_MAX
1047
1048 config ARCH_MMAP_RND_COMPAT_BITS_MIN
1049         int
1050
1051 config ARCH_MMAP_RND_COMPAT_BITS_MAX
1052         int
1053
1054 config ARCH_MMAP_RND_COMPAT_BITS_DEFAULT
1055         int
1056
1057 config ARCH_MMAP_RND_COMPAT_BITS
1058         int "Number of bits to use for ASLR of mmap base address for compatible applications" if EXPERT
1059         range ARCH_MMAP_RND_COMPAT_BITS_MIN ARCH_MMAP_RND_COMPAT_BITS_MAX
1060         default ARCH_MMAP_RND_COMPAT_BITS_DEFAULT if ARCH_MMAP_RND_COMPAT_BITS_DEFAULT
1061         default ARCH_MMAP_RND_COMPAT_BITS_MIN
1062         depends on HAVE_ARCH_MMAP_RND_COMPAT_BITS
1063         help
1064           This value can be used to select the number of bits to use to
1065           determine the random offset to the base address of vma regions
1066           resulting from mmap allocations for compatible applications This
1067           value will be bounded by the architecture's minimum and maximum
1068           supported values.
1069
1070           This value can be changed after boot using the
1071           /proc/sys/vm/mmap_rnd_compat_bits tunable
1072
1073 config HAVE_ARCH_COMPAT_MMAP_BASES
1074         bool
1075         help
1076           This allows 64bit applications to invoke 32-bit mmap() syscall
1077           and vice-versa 32-bit applications to call 64-bit mmap().
1078           Required for applications doing different bitness syscalls.
1079
1080 config PAGE_SIZE_LESS_THAN_64KB
1081         def_bool y
1082         depends on !ARM64_64K_PAGES
1083         depends on !PAGE_SIZE_64KB
1084         depends on !PARISC_PAGE_SIZE_64KB
1085         depends on PAGE_SIZE_LESS_THAN_256KB
1086
1087 config PAGE_SIZE_LESS_THAN_256KB
1088         def_bool y
1089         depends on !PAGE_SIZE_256KB
1090
1091 # This allows to use a set of generic functions to determine mmap base
1092 # address by giving priority to top-down scheme only if the process
1093 # is not in legacy mode (compat task, unlimited stack size or
1094 # sysctl_legacy_va_layout).
1095 # Architecture that selects this option can provide its own version of:
1096 # - STACK_RND_MASK
1097 config ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT
1098         bool
1099         depends on MMU
1100         select ARCH_HAS_ELF_RANDOMIZE
1101
1102 config HAVE_OBJTOOL
1103         bool
1104
1105 config HAVE_JUMP_LABEL_HACK
1106         bool
1107
1108 config HAVE_NOINSTR_HACK
1109         bool
1110
1111 config HAVE_NOINSTR_VALIDATION
1112         bool
1113
1114 config HAVE_UACCESS_VALIDATION
1115         bool
1116         select OBJTOOL
1117
1118 config HAVE_STACK_VALIDATION
1119         bool
1120         help
1121           Architecture supports objtool compile-time frame pointer rule
1122           validation.
1123
1124 config HAVE_RELIABLE_STACKTRACE
1125         bool
1126         help
1127           Architecture has either save_stack_trace_tsk_reliable() or
1128           arch_stack_walk_reliable() function which only returns a stack trace
1129           if it can guarantee the trace is reliable.
1130
1131 config HAVE_ARCH_HASH
1132         bool
1133         default n
1134         help
1135           If this is set, the architecture provides an <asm/hash.h>
1136           file which provides platform-specific implementations of some
1137           functions in <linux/hash.h> or fs/namei.c.
1138
1139 config HAVE_ARCH_NVRAM_OPS
1140         bool
1141
1142 config ISA_BUS_API
1143         def_bool ISA
1144
1145 #
1146 # ABI hall of shame
1147 #
1148 config CLONE_BACKWARDS
1149         bool
1150         help
1151           Architecture has tls passed as the 4th argument of clone(2),
1152           not the 5th one.
1153
1154 config CLONE_BACKWARDS2
1155         bool
1156         help
1157           Architecture has the first two arguments of clone(2) swapped.
1158
1159 config CLONE_BACKWARDS3
1160         bool
1161         help
1162           Architecture has tls passed as the 3rd argument of clone(2),
1163           not the 5th one.
1164
1165 config ODD_RT_SIGACTION
1166         bool
1167         help
1168           Architecture has unusual rt_sigaction(2) arguments
1169
1170 config OLD_SIGSUSPEND
1171         bool
1172         help
1173           Architecture has old sigsuspend(2) syscall, of one-argument variety
1174
1175 config OLD_SIGSUSPEND3
1176         bool
1177         help
1178           Even weirder antique ABI - three-argument sigsuspend(2)
1179
1180 config OLD_SIGACTION
1181         bool
1182         help
1183           Architecture has old sigaction(2) syscall.  Nope, not the same
1184           as OLD_SIGSUSPEND | OLD_SIGSUSPEND3 - alpha has sigsuspend(2),
1185           but fairly different variant of sigaction(2), thanks to OSF/1
1186           compatibility...
1187
1188 config COMPAT_OLD_SIGACTION
1189         bool
1190
1191 config COMPAT_32BIT_TIME
1192         bool "Provide system calls for 32-bit time_t"
1193         default !64BIT || COMPAT
1194         help
1195           This enables 32 bit time_t support in addition to 64 bit time_t support.
1196           This is relevant on all 32-bit architectures, and 64-bit architectures
1197           as part of compat syscall handling.
1198
1199 config ARCH_NO_PREEMPT
1200         bool
1201
1202 config ARCH_SUPPORTS_RT
1203         bool
1204
1205 config CPU_NO_EFFICIENT_FFS
1206         def_bool n
1207
1208 config HAVE_ARCH_VMAP_STACK
1209         def_bool n
1210         help
1211           An arch should select this symbol if it can support kernel stacks
1212           in vmalloc space.  This means:
1213
1214           - vmalloc space must be large enough to hold many kernel stacks.
1215             This may rule out many 32-bit architectures.
1216
1217           - Stacks in vmalloc space need to work reliably.  For example, if
1218             vmap page tables are created on demand, either this mechanism
1219             needs to work while the stack points to a virtual address with
1220             unpopulated page tables or arch code (switch_to() and switch_mm(),
1221             most likely) needs to ensure that the stack's page table entries
1222             are populated before running on a possibly unpopulated stack.
1223
1224           - If the stack overflows into a guard page, something reasonable
1225             should happen.  The definition of "reasonable" is flexible, but
1226             instantly rebooting without logging anything would be unfriendly.
1227
1228 config VMAP_STACK
1229         default y
1230         bool "Use a virtually-mapped stack"
1231         depends on HAVE_ARCH_VMAP_STACK
1232         depends on !KASAN || KASAN_HW_TAGS || KASAN_VMALLOC
1233         help
1234           Enable this if you want the use virtually-mapped kernel stacks
1235           with guard pages.  This causes kernel stack overflows to be
1236           caught immediately rather than causing difficult-to-diagnose
1237           corruption.
1238
1239           To use this with software KASAN modes, the architecture must support
1240           backing virtual mappings with real shadow memory, and KASAN_VMALLOC
1241           must be enabled.
1242
1243 config HAVE_ARCH_RANDOMIZE_KSTACK_OFFSET
1244         def_bool n
1245         help
1246           An arch should select this symbol if it can support kernel stack
1247           offset randomization with calls to add_random_kstack_offset()
1248           during syscall entry and choose_random_kstack_offset() during
1249           syscall exit. Careful removal of -fstack-protector-strong and
1250           -fstack-protector should also be applied to the entry code and
1251           closely examined, as the artificial stack bump looks like an array
1252           to the compiler, so it will attempt to add canary checks regardless
1253           of the static branch state.
1254
1255 config RANDOMIZE_KSTACK_OFFSET
1256         bool "Support for randomizing kernel stack offset on syscall entry" if EXPERT
1257         default y
1258         depends on HAVE_ARCH_RANDOMIZE_KSTACK_OFFSET
1259         depends on INIT_STACK_NONE || !CC_IS_CLANG || CLANG_VERSION >= 140000
1260         help
1261           The kernel stack offset can be randomized (after pt_regs) by
1262           roughly 5 bits of entropy, frustrating memory corruption
1263           attacks that depend on stack address determinism or
1264           cross-syscall address exposures.
1265
1266           The feature is controlled via the "randomize_kstack_offset=on/off"
1267           kernel boot param, and if turned off has zero overhead due to its use
1268           of static branches (see JUMP_LABEL).
1269
1270           If unsure, say Y.
1271
1272 config RANDOMIZE_KSTACK_OFFSET_DEFAULT
1273         bool "Default state of kernel stack offset randomization"
1274         depends on RANDOMIZE_KSTACK_OFFSET
1275         help
1276           Kernel stack offset randomization is controlled by kernel boot param
1277           "randomize_kstack_offset=on/off", and this config chooses the default
1278           boot state.
1279
1280 config ARCH_OPTIONAL_KERNEL_RWX
1281         def_bool n
1282
1283 config ARCH_OPTIONAL_KERNEL_RWX_DEFAULT
1284         def_bool n
1285
1286 config ARCH_HAS_STRICT_KERNEL_RWX
1287         def_bool n
1288
1289 config STRICT_KERNEL_RWX
1290         bool "Make kernel text and rodata read-only" if ARCH_OPTIONAL_KERNEL_RWX
1291         depends on ARCH_HAS_STRICT_KERNEL_RWX
1292         default !ARCH_OPTIONAL_KERNEL_RWX || ARCH_OPTIONAL_KERNEL_RWX_DEFAULT
1293         help
1294           If this is set, kernel text and rodata memory will be made read-only,
1295           and non-text memory will be made non-executable. This provides
1296           protection against certain security exploits (e.g. executing the heap
1297           or modifying text)
1298
1299           These features are considered standard security practice these days.
1300           You should say Y here in almost all cases.
1301
1302 config ARCH_HAS_STRICT_MODULE_RWX
1303         def_bool n
1304
1305 config STRICT_MODULE_RWX
1306         bool "Set loadable kernel module data as NX and text as RO" if ARCH_OPTIONAL_KERNEL_RWX
1307         depends on ARCH_HAS_STRICT_MODULE_RWX && MODULES
1308         default !ARCH_OPTIONAL_KERNEL_RWX || ARCH_OPTIONAL_KERNEL_RWX_DEFAULT
1309         help
1310           If this is set, module text and rodata memory will be made read-only,
1311           and non-text memory will be made non-executable. This provides
1312           protection against certain security exploits (e.g. writing to text)
1313
1314 # select if the architecture provides an asm/dma-direct.h header
1315 config ARCH_HAS_PHYS_TO_DMA
1316         bool
1317
1318 config HAVE_ARCH_COMPILER_H
1319         bool
1320         help
1321           An architecture can select this if it provides an
1322           asm/compiler.h header that should be included after
1323           linux/compiler-*.h in order to override macro definitions that those
1324           headers generally provide.
1325
1326 config HAVE_ARCH_PREL32_RELOCATIONS
1327         bool
1328         help
1329           May be selected by an architecture if it supports place-relative
1330           32-bit relocations, both in the toolchain and in the module loader,
1331           in which case relative references can be used in special sections
1332           for PCI fixup, initcalls etc which are only half the size on 64 bit
1333           architectures, and don't require runtime relocation on relocatable
1334           kernels.
1335
1336 config ARCH_USE_MEMREMAP_PROT
1337         bool
1338
1339 config LOCK_EVENT_COUNTS
1340         bool "Locking event counts collection"
1341         depends on DEBUG_FS
1342         help
1343           Enable light-weight counting of various locking related events
1344           in the system with minimal performance impact. This reduces
1345           the chance of application behavior change because of timing
1346           differences. The counts are reported via debugfs.
1347
1348 # Select if the architecture has support for applying RELR relocations.
1349 config ARCH_HAS_RELR
1350         bool
1351
1352 config RELR
1353         bool "Use RELR relocation packing"
1354         depends on ARCH_HAS_RELR && TOOLS_SUPPORT_RELR
1355         default y
1356         help
1357           Store the kernel's dynamic relocations in the RELR relocation packing
1358           format. Requires a compatible linker (LLD supports this feature), as
1359           well as compatible NM and OBJCOPY utilities (llvm-nm and llvm-objcopy
1360           are compatible).
1361
1362 config ARCH_HAS_MEM_ENCRYPT
1363         bool
1364
1365 config ARCH_HAS_CC_PLATFORM
1366         bool
1367
1368 config HAVE_SPARSE_SYSCALL_NR
1369         bool
1370         help
1371           An architecture should select this if its syscall numbering is sparse
1372           to save space. For example, MIPS architecture has a syscall array with
1373           entries at 4000, 5000 and 6000 locations. This option turns on syscall
1374           related optimizations for a given architecture.
1375
1376 config ARCH_HAS_VDSO_DATA
1377         bool
1378
1379 config HAVE_STATIC_CALL
1380         bool
1381
1382 config HAVE_STATIC_CALL_INLINE
1383         bool
1384         depends on HAVE_STATIC_CALL
1385         select OBJTOOL
1386
1387 config HAVE_PREEMPT_DYNAMIC
1388         bool
1389
1390 config HAVE_PREEMPT_DYNAMIC_CALL
1391         bool
1392         depends on HAVE_STATIC_CALL
1393         select HAVE_PREEMPT_DYNAMIC
1394         help
1395           An architecture should select this if it can handle the preemption
1396           model being selected at boot time using static calls.
1397
1398           Where an architecture selects HAVE_STATIC_CALL_INLINE, any call to a
1399           preemption function will be patched directly.
1400
1401           Where an architecture does not select HAVE_STATIC_CALL_INLINE, any
1402           call to a preemption function will go through a trampoline, and the
1403           trampoline will be patched.
1404
1405           It is strongly advised to support inline static call to avoid any
1406           overhead.
1407
1408 config HAVE_PREEMPT_DYNAMIC_KEY
1409         bool
1410         depends on HAVE_ARCH_JUMP_LABEL
1411         select HAVE_PREEMPT_DYNAMIC
1412         help
1413           An architecture should select this if it can handle the preemption
1414           model being selected at boot time using static keys.
1415
1416           Each preemption function will be given an early return based on a
1417           static key. This should have slightly lower overhead than non-inline
1418           static calls, as this effectively inlines each trampoline into the
1419           start of its callee. This may avoid redundant work, and may
1420           integrate better with CFI schemes.
1421
1422           This will have greater overhead than using inline static calls as
1423           the call to the preemption function cannot be entirely elided.
1424
1425 config ARCH_WANT_LD_ORPHAN_WARN
1426         bool
1427         help
1428           An arch should select this symbol once all linker sections are explicitly
1429           included, size-asserted, or discarded in the linker scripts. This is
1430           important because we never want expected sections to be placed heuristically
1431           by the linker, since the locations of such sections can change between linker
1432           versions.
1433
1434 config HAVE_ARCH_PFN_VALID
1435         bool
1436
1437 config ARCH_SUPPORTS_DEBUG_PAGEALLOC
1438         bool
1439
1440 config ARCH_SUPPORTS_PAGE_TABLE_CHECK
1441         bool
1442
1443 config ARCH_SPLIT_ARG64
1444         bool
1445         help
1446           If a 32-bit architecture requires 64-bit arguments to be split into
1447           pairs of 32-bit arguments, select this option.
1448
1449 config ARCH_HAS_ELFCORE_COMPAT
1450         bool
1451
1452 config ARCH_HAS_PARANOID_L1D_FLUSH
1453         bool
1454
1455 config ARCH_HAVE_TRACE_MMIO_ACCESS
1456         bool
1457
1458 config DYNAMIC_SIGFRAME
1459         bool
1460
1461 # Select, if arch has a named attribute group bound to NUMA device nodes.
1462 config HAVE_ARCH_NODE_DEV_GROUP
1463         bool
1464
1465 config ARCH_HAS_HW_PTE_YOUNG
1466         bool
1467         help
1468           Architectures that select this option are capable of setting the
1469           accessed bit in PTE entries when using them as part of linear address
1470           translations. Architectures that require runtime check should select
1471           this option and override arch_has_hw_pte_young().
1472
1473 config ARCH_HAS_NONLEAF_PMD_YOUNG
1474         bool
1475         help
1476           Architectures that select this option are capable of setting the
1477           accessed bit in non-leaf PMD entries when using them as part of linear
1478           address translations. Page table walkers that clear the accessed bit
1479           may use this capability to reduce their search space.
1480
1481 source "kernel/gcov/Kconfig"
1482
1483 source "scripts/gcc-plugins/Kconfig"
1484
1485 config FUNCTION_ALIGNMENT_4B
1486         bool
1487
1488 config FUNCTION_ALIGNMENT_8B
1489         bool
1490
1491 config FUNCTION_ALIGNMENT_16B
1492         bool
1493
1494 config FUNCTION_ALIGNMENT_32B
1495         bool
1496
1497 config FUNCTION_ALIGNMENT_64B
1498         bool
1499
1500 config FUNCTION_ALIGNMENT
1501         int
1502         default 64 if FUNCTION_ALIGNMENT_64B
1503         default 32 if FUNCTION_ALIGNMENT_32B
1504         default 16 if FUNCTION_ALIGNMENT_16B
1505         default 8 if FUNCTION_ALIGNMENT_8B
1506         default 4 if FUNCTION_ALIGNMENT_4B
1507         default 0
1508
1509 endmenu