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