mm/Kconfig

   1 # SPDX-License-Identifier: GPL-2.0-only
   2
   3 menu "Memory Management options"
   4
   5 #
   6 # For some reason microblaze and nios2 hard code SWAP=n.  Hopefully we can
   7 # add proper SWAP support to them, in which case this can be remove.
   8 #
   9 config ARCH_NO_SWAP
  10         bool
  11
  12 config ZPOOL
  13         bool
  14
  15 menuconfig SWAP
  16         bool "Support for paging of anonymous memory (swap)"
  17         depends on MMU && BLOCK && !ARCH_NO_SWAP
  18         default y
  19         help
  20           This option allows you to choose whether you want to have support
  21           for so called swap devices or swap files in your kernel that are
  22           used to provide more virtual memory than the actual RAM present
  23           in your computer.  If unsure say Y.
  24
  25 config ZSWAP
  26         bool "Compressed cache for swap pages"
  27         depends on SWAP
  28         select CRYPTO
  29         select ZPOOL
  30         help
  31           A lightweight compressed cache for swap pages.  It takes
  32           pages that are in the process of being swapped out and attempts to
  33           compress them into a dynamically allocated RAM-based memory pool.
  34           This can result in a significant I/O reduction on swap device and,
  35           in the case where decompressing from RAM is faster than swap device
  36           reads, can also improve workload performance.
  37
  38 config ZSWAP_DEFAULT_ON
  39         bool "Enable the compressed cache for swap pages by default"
  40         depends on ZSWAP
  41         help
  42           If selected, the compressed cache for swap pages will be enabled
  43           at boot, otherwise it will be disabled.
  44
  45           The selection made here can be overridden by using the kernel
  46           command line 'zswap.enabled=' option.
  47
  48 config ZSWAP_SHRINKER_DEFAULT_ON
  49         bool "Shrink the zswap pool on memory pressure"
  50         depends on ZSWAP
  51         default n
  52         help
  53           If selected, the zswap shrinker will be enabled, and the pages
  54           stored in the zswap pool will become available for reclaim (i.e
  55           written back to the backing swap device) on memory pressure.
  56
  57           This means that zswap writeback could happen even if the pool is
  58           not yet full, or the cgroup zswap limit has not been reached,
  59           reducing the chance that cold pages will reside in the zswap pool
  60           and consume memory indefinitely.
  61
  62 choice
  63         prompt "Default compressor"
  64         depends on ZSWAP
  65         default ZSWAP_COMPRESSOR_DEFAULT_LZO
  66         help
  67           Selects the default compression algorithm for the compressed cache
  68           for swap pages.
  69
  70           For an overview what kind of performance can be expected from
  71           a particular compression algorithm please refer to the benchmarks
  72           available at the following LWN page:
  73           https://lwn.net/Articles/751795/
  74
  75           If in doubt, select 'LZO'.
  76
  77           The selection made here can be overridden by using the kernel
  78           command line 'zswap.compressor=' option.
  79
  80 config ZSWAP_COMPRESSOR_DEFAULT_DEFLATE
  81         bool "Deflate"
  82         select CRYPTO_DEFLATE
  83         help
  84           Use the Deflate algorithm as the default compression algorithm.
  85
  86 config ZSWAP_COMPRESSOR_DEFAULT_LZO
  87         bool "LZO"
  88         select CRYPTO_LZO
  89         help
  90           Use the LZO algorithm as the default compression algorithm.
  91
  92 config ZSWAP_COMPRESSOR_DEFAULT_842
  93         bool "842"
  94         select CRYPTO_842
  95         help
  96           Use the 842 algorithm as the default compression algorithm.
  97
  98 config ZSWAP_COMPRESSOR_DEFAULT_LZ4
  99         bool "LZ4"
 100         select CRYPTO_LZ4
 101         help
 102           Use the LZ4 algorithm as the default compression algorithm.
 103
 104 config ZSWAP_COMPRESSOR_DEFAULT_LZ4HC
 105         bool "LZ4HC"
 106         select CRYPTO_LZ4HC
 107         help
 108           Use the LZ4HC algorithm as the default compression algorithm.
 109
 110 config ZSWAP_COMPRESSOR_DEFAULT_ZSTD
 111         bool "zstd"
 112         select CRYPTO_ZSTD
 113         help
 114           Use the zstd algorithm as the default compression algorithm.
 115 endchoice
 116
 117 config ZSWAP_COMPRESSOR_DEFAULT
 118        string
 119        depends on ZSWAP
 120        default "deflate" if ZSWAP_COMPRESSOR_DEFAULT_DEFLATE
 121        default "lzo" if ZSWAP_COMPRESSOR_DEFAULT_LZO
 122        default "842" if ZSWAP_COMPRESSOR_DEFAULT_842
 123        default "lz4" if ZSWAP_COMPRESSOR_DEFAULT_LZ4
 124        default "lz4hc" if ZSWAP_COMPRESSOR_DEFAULT_LZ4HC
 125        default "zstd" if ZSWAP_COMPRESSOR_DEFAULT_ZSTD
 126        default ""
 127
 128 choice
 129         prompt "Default allocator"
 130         depends on ZSWAP
 131         default ZSWAP_ZPOOL_DEFAULT_ZSMALLOC if MMU
 132         default ZSWAP_ZPOOL_DEFAULT_ZBUD
 133         help
 134           Selects the default allocator for the compressed cache for
 135           swap pages.
 136           The default is 'zbud' for compatibility, however please do
 137           read the description of each of the allocators below before
 138           making a right choice.
 139
 140           The selection made here can be overridden by using the kernel
 141           command line 'zswap.zpool=' option.
 142
 143 config ZSWAP_ZPOOL_DEFAULT_ZBUD
 144         bool "zbud"
 145         select ZBUD
 146         help
 147           Use the zbud allocator as the default allocator.
 148
 149 config ZSWAP_ZPOOL_DEFAULT_Z3FOLD_DEPRECATED
 150         bool "z3foldi (DEPRECATED)"
 151         select Z3FOLD_DEPRECATED
 152         help
 153           Use the z3fold allocator as the default allocator.
 154
 155           Deprecated and scheduled for removal in a few cycles,
 156           see CONFIG_Z3FOLD_DEPRECATED.
 157
 158 config ZSWAP_ZPOOL_DEFAULT_ZSMALLOC
 159         bool "zsmalloc"
 160         select ZSMALLOC
 161         help
 162           Use the zsmalloc allocator as the default allocator.
 163 endchoice
 164
 165 config ZSWAP_ZPOOL_DEFAULT
 166        string
 167        depends on ZSWAP
 168        default "zbud" if ZSWAP_ZPOOL_DEFAULT_ZBUD
 169        default "z3fold" if ZSWAP_ZPOOL_DEFAULT_Z3FOLD_DEPRECATED
 170        default "zsmalloc" if ZSWAP_ZPOOL_DEFAULT_ZSMALLOC
 171        default ""
 172
 173 config ZBUD
 174         tristate "2:1 compression allocator (zbud)"
 175         depends on ZSWAP
 176         help
 177           A special purpose allocator for storing compressed pages.
 178           It is designed to store up to two compressed pages per physical
 179           page.  While this design limits storage density, it has simple and
 180           deterministic reclaim properties that make it preferable to a higher
 181           density approach when reclaim will be used.
 182
 183 config Z3FOLD_DEPRECATED
 184         tristate "3:1 compression allocator (z3fold) (DEPRECATED)"
 185         depends on ZSWAP
 186         help
 187           Deprecated and scheduled for removal in a few cycles. If you have
 188           a good reason for using Z3FOLD over ZSMALLOC, please contact
 189           linux-mm@kvack.org and the zswap maintainers.
 190
 191           A special purpose allocator for storing compressed pages.
 192           It is designed to store up to three compressed pages per physical
 193           page. It is a ZBUD derivative so the simplicity and determinism are
 194           still there.
 195
 196 config Z3FOLD
 197         tristate
 198         default y if Z3FOLD_DEPRECATED=y
 199         default m if Z3FOLD_DEPRECATED=m
 200         depends on Z3FOLD_DEPRECATED
 201
 202 config ZSMALLOC
 203         tristate
 204         prompt "N:1 compression allocator (zsmalloc)" if (ZSWAP || ZRAM)
 205         depends on MMU
 206         help
 207           zsmalloc is a slab-based memory allocator designed to store
 208           pages of various compression levels efficiently. It achieves
 209           the highest storage density with the least amount of fragmentation.
 210
 211 config ZSMALLOC_STAT
 212         bool "Export zsmalloc statistics"
 213         depends on ZSMALLOC
 214         select DEBUG_FS
 215         help
 216           This option enables code in the zsmalloc to collect various
 217           statistics about what's happening in zsmalloc and exports that
 218           information to userspace via debugfs.
 219           If unsure, say N.
 220
 221 config ZSMALLOC_CHAIN_SIZE
 222         int "Maximum number of physical pages per-zspage"
 223         default 8
 224         range 4 16
 225         depends on ZSMALLOC
 226         help
 227           This option sets the upper limit on the number of physical pages
 228           that a zmalloc page (zspage) can consist of. The optimal zspage
 229           chain size is calculated for each size class during the
 230           initialization of the pool.
 231
 232           Changing this option can alter the characteristics of size classes,
 233           such as the number of pages per zspage and the number of objects
 234           per zspage. This can also result in different configurations of
 235           the pool, as zsmalloc merges size classes with similar
 236           characteristics.
 237
 238           For more information, see zsmalloc documentation.
 239
 240 menu "Slab allocator options"
 241
 242 config SLUB
 243         def_bool y
 244
 245 config SLUB_TINY
 246         bool "Configure for minimal memory footprint"
 247         depends on EXPERT
 248         select SLAB_MERGE_DEFAULT
 249         help
 250            Configures the slab allocator in a way to achieve minimal memory
 251            footprint, sacrificing scalability, debugging and other features.
 252            This is intended only for the smallest system that had used the
 253            SLOB allocator and is not recommended for systems with more than
 254            16MB RAM.
 255
 256            If unsure, say N.
 257
 258 config SLAB_MERGE_DEFAULT
 259         bool "Allow slab caches to be merged"
 260         default y
 261         help
 262           For reduced kernel memory fragmentation, slab caches can be
 263           merged when they share the same size and other characteristics.
 264           This carries a risk of kernel heap overflows being able to
 265           overwrite objects from merged caches (and more easily control
 266           cache layout), which makes such heap attacks easier to exploit
 267           by attackers. By keeping caches unmerged, these kinds of exploits
 268           can usually only damage objects in the same cache. To disable
 269           merging at runtime, "slab_nomerge" can be passed on the kernel
 270           command line.
 271
 272 config SLAB_FREELIST_RANDOM
 273         bool "Randomize slab freelist"
 274         depends on !SLUB_TINY
 275         help
 276           Randomizes the freelist order used on creating new pages. This
 277           security feature reduces the predictability of the kernel slab
 278           allocator against heap overflows.
 279
 280 config SLAB_FREELIST_HARDENED
 281         bool "Harden slab freelist metadata"
 282         depends on !SLUB_TINY
 283         help
 284           Many kernel heap attacks try to target slab cache metadata and
 285           other infrastructure. This options makes minor performance
 286           sacrifices to harden the kernel slab allocator against common
 287           freelist exploit methods.
 288
 289 config SLAB_BUCKETS
 290         bool "Support allocation from separate kmalloc buckets"
 291         depends on !SLUB_TINY
 292         default SLAB_FREELIST_HARDENED
 293         help
 294           Kernel heap attacks frequently depend on being able to create
 295           specifically-sized allocations with user-controlled contents
 296           that will be allocated into the same kmalloc bucket as a
 297           target object. To avoid sharing these allocation buckets,
 298           provide an explicitly separated set of buckets to be used for
 299           user-controlled allocations. This may very slightly increase
 300           memory fragmentation, though in practice it's only a handful
 301           of extra pages since the bulk of user-controlled allocations
 302           are relatively long-lived.
 303
 304           If unsure, say Y.
 305
 306 config SLUB_STATS
 307         default n
 308         bool "Enable performance statistics"
 309         depends on SYSFS && !SLUB_TINY
 310         help
 311           The statistics are useful to debug slab allocation behavior in
 312           order find ways to optimize the allocator. This should never be
 313           enabled for production use since keeping statistics slows down
 314           the allocator by a few percentage points. The slabinfo command
 315           supports the determination of the most active slabs to figure
 316           out which slabs are relevant to a particular load.
 317           Try running: slabinfo -DA
 318
 319 config SLUB_CPU_PARTIAL
 320         default y
 321         depends on SMP && !SLUB_TINY
 322         bool "Enable per cpu partial caches"
 323         help
 324           Per cpu partial caches accelerate objects allocation and freeing
 325           that is local to a processor at the price of more indeterminism
 326           in the latency of the free. On overflow these caches will be cleared
 327           which requires the taking of locks that may cause latency spikes.
 328           Typically one would choose no for a realtime system.
 329
 330 config RANDOM_KMALLOC_CACHES
 331         default n
 332         depends on !SLUB_TINY
 333         bool "Randomize slab caches for normal kmalloc"
 334         help
 335           A hardening feature that creates multiple copies of slab caches for
 336           normal kmalloc allocation and makes kmalloc randomly pick one based
 337           on code address, which makes the attackers more difficult to spray
 338           vulnerable memory objects on the heap for the purpose of exploiting
 339           memory vulnerabilities.
 340
 341           Currently the number of copies is set to 16, a reasonably large value
 342           that effectively diverges the memory objects allocated for different
 343           subsystems or modules into different caches, at the expense of a
 344           limited degree of memory and CPU overhead that relates to hardware and
 345           system workload.
 346
 347 endmenu # Slab allocator options
 348
 349 config SHUFFLE_PAGE_ALLOCATOR
 350         bool "Page allocator randomization"
 351         default SLAB_FREELIST_RANDOM && ACPI_NUMA
 352         help
 353           Randomization of the page allocator improves the average
 354           utilization of a direct-mapped memory-side-cache. See section
 355           5.2.27 Heterogeneous Memory Attribute Table (HMAT) in the ACPI
 356           6.2a specification for an example of how a platform advertises
 357           the presence of a memory-side-cache. There are also incidental
 358           security benefits as it reduces the predictability of page
 359           allocations to compliment SLAB_FREELIST_RANDOM, but the
 360           default granularity of shuffling on the MAX_PAGE_ORDER i.e, 10th
 361           order of pages is selected based on cache utilization benefits
 362           on x86.
 363
 364           While the randomization improves cache utilization it may
 365           negatively impact workloads on platforms without a cache. For
 366           this reason, by default, the randomization is not enabled even
 367           if SHUFFLE_PAGE_ALLOCATOR=y. The randomization may be force enabled
 368           with the 'page_alloc.shuffle' kernel command line parameter.
 369
 370           Say Y if unsure.
 371
 372 config COMPAT_BRK
 373         bool "Disable heap randomization"
 374         default y
 375         help
 376           Randomizing heap placement makes heap exploits harder, but it
 377           also breaks ancient binaries (including anything libc5 based).
 378           This option changes the bootup default to heap randomization
 379           disabled, and can be overridden at runtime by setting
 380           /proc/sys/kernel/randomize_va_space to 2.
 381
 382           On non-ancient distros (post-2000 ones) N is usually a safe choice.
 383
 384 config MMAP_ALLOW_UNINITIALIZED
 385         bool "Allow mmapped anonymous memory to be uninitialized"
 386         depends on EXPERT && !MMU
 387         default n
 388         help
 389           Normally, and according to the Linux spec, anonymous memory obtained
 390           from mmap() has its contents cleared before it is passed to
 391           userspace.  Enabling this config option allows you to request that
 392           mmap() skip that if it is given an MAP_UNINITIALIZED flag, thus
 393           providing a huge performance boost.  If this option is not enabled,
 394           then the flag will be ignored.
 395
 396           This is taken advantage of by uClibc's malloc(), and also by
 397           ELF-FDPIC binfmt's brk and stack allocator.
 398
 399           Because of the obvious security issues, this option should only be
 400           enabled on embedded devices where you control what is run in
 401           userspace.  Since that isn't generally a problem on no-MMU systems,
 402           it is normally safe to say Y here.
 403
 404           See Documentation/admin-guide/mm/nommu-mmap.rst for more information.
 405
 406 config SELECT_MEMORY_MODEL
 407         def_bool y
 408         depends on ARCH_SELECT_MEMORY_MODEL
 409
 410 choice
 411         prompt "Memory model"
 412         depends on SELECT_MEMORY_MODEL
 413         default SPARSEMEM_MANUAL if ARCH_SPARSEMEM_DEFAULT
 414         default FLATMEM_MANUAL
 415         help
 416           This option allows you to change some of the ways that
 417           Linux manages its memory internally. Most users will
 418           only have one option here selected by the architecture
 419           configuration. This is normal.
 420
 421 config FLATMEM_MANUAL
 422         bool "Flat Memory"
 423         depends on !ARCH_SPARSEMEM_ENABLE || ARCH_FLATMEM_ENABLE
 424         help
 425           This option is best suited for non-NUMA systems with
 426           flat address space. The FLATMEM is the most efficient
 427           system in terms of performance and resource consumption
 428           and it is the best option for smaller systems.
 429
 430           For systems that have holes in their physical address
 431           spaces and for features like NUMA and memory hotplug,
 432           choose "Sparse Memory".
 433
 434           If unsure, choose this option (Flat Memory) over any other.
 435
 436 config SPARSEMEM_MANUAL
 437         bool "Sparse Memory"
 438         depends on ARCH_SPARSEMEM_ENABLE
 439         help
 440           This will be the only option for some systems, including
 441           memory hot-plug systems.  This is normal.
 442
 443           This option provides efficient support for systems with
 444           holes is their physical address space and allows memory
 445           hot-plug and hot-remove.
 446
 447           If unsure, choose "Flat Memory" over this option.
 448
 449 endchoice
 450
 451 config SPARSEMEM
 452         def_bool y
 453         depends on (!SELECT_MEMORY_MODEL && ARCH_SPARSEMEM_ENABLE) || SPARSEMEM_MANUAL
 454
 455 config FLATMEM
 456         def_bool y
 457         depends on !SPARSEMEM || FLATMEM_MANUAL
 458
 459 #
 460 # SPARSEMEM_EXTREME (which is the default) does some bootmem
 461 # allocations when sparse_init() is called.  If this cannot
 462 # be done on your architecture, select this option.  However,
 463 # statically allocating the mem_section[] array can potentially
 464 # consume vast quantities of .bss, so be careful.
 465 #
 466 # This option will also potentially produce smaller runtime code
 467 # with gcc 3.4 and later.
 468 #
 469 config SPARSEMEM_STATIC
 470         bool
 471
 472 #
 473 # Architecture platforms which require a two level mem_section in SPARSEMEM
 474 # must select this option. This is usually for architecture platforms with
 475 # an extremely sparse physical address space.
 476 #
 477 config SPARSEMEM_EXTREME
 478         def_bool y
 479         depends on SPARSEMEM && !SPARSEMEM_STATIC
 480
 481 config SPARSEMEM_VMEMMAP_ENABLE
 482         bool
 483
 484 config SPARSEMEM_VMEMMAP
 485         bool "Sparse Memory virtual memmap"
 486         depends on SPARSEMEM && SPARSEMEM_VMEMMAP_ENABLE
 487         default y
 488         help
 489           SPARSEMEM_VMEMMAP uses a virtually mapped memmap to optimise
 490           pfn_to_page and page_to_pfn operations.  This is the most
 491           efficient option when sufficient kernel resources are available.
 492 #
 493 # Select this config option from the architecture Kconfig, if it is preferred
 494 # to enable the feature of HugeTLB/dev_dax vmemmap optimization.
 495 #
 496 config ARCH_WANT_OPTIMIZE_DAX_VMEMMAP
 497         bool
 498
 499 config ARCH_WANT_OPTIMIZE_HUGETLB_VMEMMAP
 500         bool
 501
 502 config HAVE_MEMBLOCK_PHYS_MAP
 503         bool
 504
 505 config HAVE_GUP_FAST
 506         depends on MMU
 507         bool
 508
 509 # Don't discard allocated memory used to track "memory" and "reserved" memblocks
 510 # after early boot, so it can still be used to test for validity of memory.
 511 # Also, memblocks are updated with memory hot(un)plug.
 512 config ARCH_KEEP_MEMBLOCK
 513         bool
 514
 515 # Keep arch NUMA mapping infrastructure post-init.
 516 config NUMA_KEEP_MEMINFO
 517         bool
 518
 519 config MEMORY_ISOLATION
 520         bool
 521
 522 # IORESOURCE_SYSTEM_RAM regions in the kernel resource tree that are marked
 523 # IORESOURCE_EXCLUSIVE cannot be mapped to user space, for example, via
 524 # /dev/mem.
 525 config EXCLUSIVE_SYSTEM_RAM
 526         def_bool y
 527         depends on !DEVMEM || STRICT_DEVMEM
 528
 529 #
 530 # Only be set on architectures that have completely implemented memory hotplug
 531 # feature. If you are not sure, don't touch it.
 532 #
 533 config HAVE_BOOTMEM_INFO_NODE
 534         def_bool n
 535
 536 config ARCH_ENABLE_MEMORY_HOTPLUG
 537         bool
 538
 539 config ARCH_ENABLE_MEMORY_HOTREMOVE
 540         bool
 541
 542 # eventually, we can have this option just 'select SPARSEMEM'
 543 menuconfig MEMORY_HOTPLUG
 544         bool "Memory hotplug"
 545         select MEMORY_ISOLATION
 546         depends on SPARSEMEM
 547         depends on ARCH_ENABLE_MEMORY_HOTPLUG
 548         depends on 64BIT
 549         select NUMA_KEEP_MEMINFO if NUMA
 550
 551 if MEMORY_HOTPLUG
 552
 553 config MEMORY_HOTPLUG_DEFAULT_ONLINE
 554         bool "Online the newly added memory blocks by default"
 555         depends on MEMORY_HOTPLUG
 556         help
 557           This option sets the default policy setting for memory hotplug
 558           onlining policy (/sys/devices/system/memory/auto_online_blocks) which
 559           determines what happens to newly added memory regions. Policy setting
 560           can always be changed at runtime.
 561           See Documentation/admin-guide/mm/memory-hotplug.rst for more information.
 562
 563           Say Y here if you want all hot-plugged memory blocks to appear in
 564           'online' state by default.
 565           Say N here if you want the default policy to keep all hot-plugged
 566           memory blocks in 'offline' state.
 567
 568 config MEMORY_HOTREMOVE
 569         bool "Allow for memory hot remove"
 570         select HAVE_BOOTMEM_INFO_NODE if (X86_64 || PPC64)
 571         depends on MEMORY_HOTPLUG && ARCH_ENABLE_MEMORY_HOTREMOVE
 572         depends on MIGRATION
 573
 574 config MHP_MEMMAP_ON_MEMORY
 575         def_bool y
 576         depends on MEMORY_HOTPLUG && SPARSEMEM_VMEMMAP
 577         depends on ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE
 578
 579 endif # MEMORY_HOTPLUG
 580
 581 config ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE
 582        bool
 583
 584 # Heavily threaded applications may benefit from splitting the mm-wide
 585 # page_table_lock, so that faults on different parts of the user address
 586 # space can be handled with less contention: split it at this NR_CPUS.
 587 # Default to 4 for wider testing, though 8 might be more appropriate.
 588 # ARM's adjust_pte (unused if VIPT) depends on mm-wide page_table_lock.
 589 # PA-RISC 7xxx's spinlock_t would enlarge struct page from 32 to 44 bytes.
 590 # SPARC32 allocates multiple pte tables within a single page, and therefore
 591 # a per-page lock leads to problems when multiple tables need to be locked
 592 # at the same time (e.g. copy_page_range()).
 593 # DEBUG_SPINLOCK and DEBUG_LOCK_ALLOC spinlock_t also enlarge struct page.
 594 #
 595 config SPLIT_PTE_PTLOCKS
 596         def_bool y
 597         depends on MMU
 598         depends on NR_CPUS >= 4
 599         depends on !ARM || CPU_CACHE_VIPT
 600         depends on !PARISC || PA20
 601         depends on !SPARC32
 602
 603 config ARCH_ENABLE_SPLIT_PMD_PTLOCK
 604         bool
 605
 606 config SPLIT_PMD_PTLOCKS
 607         def_bool y
 608         depends on SPLIT_PTE_PTLOCKS && ARCH_ENABLE_SPLIT_PMD_PTLOCK
 609
 610 #
 611 # support for memory balloon
 612 config MEMORY_BALLOON
 613         bool
 614
 615 #
 616 # support for memory balloon compaction
 617 config BALLOON_COMPACTION
 618         bool "Allow for balloon memory compaction/migration"
 619         default y
 620         depends on COMPACTION && MEMORY_BALLOON
 621         help
 622           Memory fragmentation introduced by ballooning might reduce
 623           significantly the number of 2MB contiguous memory blocks that can be
 624           used within a guest, thus imposing performance penalties associated
 625           with the reduced number of transparent huge pages that could be used
 626           by the guest workload. Allowing the compaction & migration for memory
 627           pages enlisted as being part of memory balloon devices avoids the
 628           scenario aforementioned and helps improving memory defragmentation.
 629
 630 #
 631 # support for memory compaction
 632 config COMPACTION
 633         bool "Allow for memory compaction"
 634         default y
 635         select MIGRATION
 636         depends on MMU
 637         help
 638           Compaction is the only memory management component to form
 639           high order (larger physically contiguous) memory blocks
 640           reliably. The page allocator relies on compaction heavily and
 641           the lack of the feature can lead to unexpected OOM killer
 642           invocations for high order memory requests. You shouldn't
 643           disable this option unless there really is a strong reason for
 644           it and then we would be really interested to hear about that at
 645           linux-mm@kvack.org.
 646
 647 config COMPACT_UNEVICTABLE_DEFAULT
 648         int
 649         depends on COMPACTION
 650         default 0 if PREEMPT_RT
 651         default 1
 652
 653 #
 654 # support for free page reporting
 655 config PAGE_REPORTING
 656         bool "Free page reporting"
 657         help
 658           Free page reporting allows for the incremental acquisition of
 659           free pages from the buddy allocator for the purpose of reporting
 660           those pages to another entity, such as a hypervisor, so that the
 661           memory can be freed within the host for other uses.
 662
 663 #
 664 # support for page migration
 665 #
 666 config MIGRATION
 667         bool "Page migration"
 668         default y
 669         depends on (NUMA || ARCH_ENABLE_MEMORY_HOTREMOVE || COMPACTION || CMA) && MMU
 670         help
 671           Allows the migration of the physical location of pages of processes
 672           while the virtual addresses are not changed. This is useful in
 673           two situations. The first is on NUMA systems to put pages nearer
 674           to the processors accessing. The second is when allocating huge
 675           pages as migration can relocate pages to satisfy a huge page
 676           allocation instead of reclaiming.
 677
 678 config DEVICE_MIGRATION
 679         def_bool MIGRATION && ZONE_DEVICE
 680
 681 config ARCH_ENABLE_HUGEPAGE_MIGRATION
 682         bool
 683
 684 config ARCH_ENABLE_THP_MIGRATION
 685         bool
 686
 687 config HUGETLB_PAGE_SIZE_VARIABLE
 688         def_bool n
 689         help
 690           Allows the pageblock_order value to be dynamic instead of just standard
 691           HUGETLB_PAGE_ORDER when there are multiple HugeTLB page sizes available
 692           on a platform.
 693
 694           Note that the pageblock_order cannot exceed MAX_PAGE_ORDER and will be
 695           clamped down to MAX_PAGE_ORDER.
 696
 697 config CONTIG_ALLOC
 698         def_bool (MEMORY_ISOLATION && COMPACTION) || CMA
 699
 700 config PCP_BATCH_SCALE_MAX
 701         int "Maximum scale factor of PCP (Per-CPU pageset) batch allocate/free"
 702         default 5
 703         range 0 6
 704         help
 705           In page allocator, PCP (Per-CPU pageset) is refilled and drained in
 706           batches.  The batch number is scaled automatically to improve page
 707           allocation/free throughput.  But too large scale factor may hurt
 708           latency.  This option sets the upper limit of scale factor to limit
 709           the maximum latency.
 710
 711 config PHYS_ADDR_T_64BIT
 712         def_bool 64BIT
 713
 714 config BOUNCE
 715         bool "Enable bounce buffers"
 716         default y
 717         depends on BLOCK && MMU && HIGHMEM
 718         help
 719           Enable bounce buffers for devices that cannot access the full range of
 720           memory available to the CPU. Enabled by default when HIGHMEM is
 721           selected, but you may say n to override this.
 722
 723 config MMU_NOTIFIER
 724         bool
 725         select INTERVAL_TREE
 726
 727 config KSM
 728         bool "Enable KSM for page merging"
 729         depends on MMU
 730         select XXHASH
 731         help
 732           Enable Kernel Samepage Merging: KSM periodically scans those areas
 733           of an application's address space that an app has advised may be
 734           mergeable.  When it finds pages of identical content, it replaces
 735           the many instances by a single page with that content, so
 736           saving memory until one or another app needs to modify the content.
 737           Recommended for use with KVM, or with other duplicative applications.
 738           See Documentation/mm/ksm.rst for more information: KSM is inactive
 739           until a program has madvised that an area is MADV_MERGEABLE, and
 740           root has set /sys/kernel/mm/ksm/run to 1 (if CONFIG_SYSFS is set).
 741
 742 config DEFAULT_MMAP_MIN_ADDR
 743         int "Low address space to protect from user allocation"
 744         depends on MMU
 745         default 4096
 746         help
 747           This is the portion of low virtual memory which should be protected
 748           from userspace allocation.  Keeping a user from writing to low pages
 749           can help reduce the impact of kernel NULL pointer bugs.
 750
 751           For most arm64, ppc64 and x86 users with lots of address space
 752           a value of 65536 is reasonable and should cause no problems.
 753           On arm and other archs it should not be higher than 32768.
 754           Programs which use vm86 functionality or have some need to map
 755           this low address space will need CAP_SYS_RAWIO or disable this
 756           protection by setting the value to 0.
 757
 758           This value can be changed after boot using the
 759           /proc/sys/vm/mmap_min_addr tunable.
 760
 761 config ARCH_SUPPORTS_MEMORY_FAILURE
 762         bool
 763
 764 config MEMORY_FAILURE
 765         depends on MMU
 766         depends on ARCH_SUPPORTS_MEMORY_FAILURE
 767         bool "Enable recovery from hardware memory errors"
 768         select MEMORY_ISOLATION
 769         select RAS
 770         help
 771           Enables code to recover from some memory failures on systems
 772           with MCA recovery. This allows a system to continue running
 773           even when some of its memory has uncorrected errors. This requires
 774           special hardware support and typically ECC memory.
 775
 776 config HWPOISON_INJECT
 777         tristate "HWPoison pages injector"
 778         depends on MEMORY_FAILURE && DEBUG_KERNEL && PROC_FS
 779         select PROC_PAGE_MONITOR
 780
 781 config NOMMU_INITIAL_TRIM_EXCESS
 782         int "Turn on mmap() excess space trimming before booting"
 783         depends on !MMU
 784         default 1
 785         help
 786           The NOMMU mmap() frequently needs to allocate large contiguous chunks
 787           of memory on which to store mappings, but it can only ask the system
 788           allocator for chunks in 2^N*PAGE_SIZE amounts - which is frequently
 789           more than it requires.  To deal with this, mmap() is able to trim off
 790           the excess and return it to the allocator.
 791
 792           If trimming is enabled, the excess is trimmed off and returned to the
 793           system allocator, which can cause extra fragmentation, particularly
 794           if there are a lot of transient processes.
 795
 796           If trimming is disabled, the excess is kept, but not used, which for
 797           long-term mappings means that the space is wasted.
 798
 799           Trimming can be dynamically controlled through a sysctl option
 800           (/proc/sys/vm/nr_trim_pages) which specifies the minimum number of
 801           excess pages there must be before trimming should occur, or zero if
 802           no trimming is to occur.
 803
 804           This option specifies the initial value of this option.  The default
 805           of 1 says that all excess pages should be trimmed.
 806
 807           See Documentation/admin-guide/mm/nommu-mmap.rst for more information.
 808
 809 config ARCH_WANT_GENERAL_HUGETLB
 810         bool
 811
 812 config ARCH_WANTS_THP_SWAP
 813         def_bool n
 814
 815 menuconfig TRANSPARENT_HUGEPAGE
 816         bool "Transparent Hugepage Support"
 817         depends on HAVE_ARCH_TRANSPARENT_HUGEPAGE && !PREEMPT_RT
 818         select COMPACTION
 819         select XARRAY_MULTI
 820         help
 821           Transparent Hugepages allows the kernel to use huge pages and
 822           huge tlb transparently to the applications whenever possible.
 823           This feature can improve computing performance to certain
 824           applications by speeding up page faults during memory
 825           allocation, by reducing the number of tlb misses and by speeding
 826           up the pagetable walking.
 827
 828           If memory constrained on embedded, you may want to say N.
 829
 830 if TRANSPARENT_HUGEPAGE
 831
 832 choice
 833         prompt "Transparent Hugepage Support sysfs defaults"
 834         depends on TRANSPARENT_HUGEPAGE
 835         default TRANSPARENT_HUGEPAGE_ALWAYS
 836         help
 837           Selects the sysfs defaults for Transparent Hugepage Support.
 838
 839         config TRANSPARENT_HUGEPAGE_ALWAYS
 840                 bool "always"
 841         help
 842           Enabling Transparent Hugepage always, can increase the
 843           memory footprint of applications without a guaranteed
 844           benefit but it will work automatically for all applications.
 845
 846         config TRANSPARENT_HUGEPAGE_MADVISE
 847                 bool "madvise"
 848         help
 849           Enabling Transparent Hugepage madvise, will only provide a
 850           performance improvement benefit to the applications using
 851           madvise(MADV_HUGEPAGE) but it won't risk to increase the
 852           memory footprint of applications without a guaranteed
 853           benefit.
 854
 855         config TRANSPARENT_HUGEPAGE_NEVER
 856                 bool "never"
 857         help
 858           Disable Transparent Hugepage by default. It can still be
 859           enabled at runtime via sysfs.
 860 endchoice
 861
 862 config THP_SWAP
 863         def_bool y
 864         depends on TRANSPARENT_HUGEPAGE && ARCH_WANTS_THP_SWAP && SWAP && 64BIT
 865         help
 866           Swap transparent huge pages in one piece, without splitting.
 867           XXX: For now, swap cluster backing transparent huge page
 868           will be split after swapout.
 869
 870           For selection by architectures with reasonable THP sizes.
 871
 872 config READ_ONLY_THP_FOR_FS
 873         bool "Read-only THP for filesystems (EXPERIMENTAL)"
 874         depends on TRANSPARENT_HUGEPAGE && SHMEM
 875
 876         help
 877           Allow khugepaged to put read-only file-backed pages in THP.
 878
 879           This is marked experimental because it is a new feature. Write
 880           support of file THPs will be developed in the next few release
 881           cycles.
 882
 883 endif # TRANSPARENT_HUGEPAGE
 884
 885 #
 886 # The architecture supports pgtable leaves that is larger than PAGE_SIZE
 887 #
 888 config PGTABLE_HAS_HUGE_LEAVES
 889         def_bool TRANSPARENT_HUGEPAGE || HUGETLB_PAGE
 890
 891 # TODO: Allow to be enabled without THP
 892 config ARCH_SUPPORTS_HUGE_PFNMAP
 893         def_bool n
 894         depends on TRANSPARENT_HUGEPAGE
 895
 896 config ARCH_SUPPORTS_PMD_PFNMAP
 897         def_bool y
 898         depends on ARCH_SUPPORTS_HUGE_PFNMAP && HAVE_ARCH_TRANSPARENT_HUGEPAGE
 899
 900 config ARCH_SUPPORTS_PUD_PFNMAP
 901         def_bool y
 902         depends on ARCH_SUPPORTS_HUGE_PFNMAP && HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD
 903
 904 #
 905 # UP and nommu archs use km based percpu allocator
 906 #
 907 config NEED_PER_CPU_KM
 908         depends on !SMP || !MMU
 909         bool
 910         default y
 911
 912 config NEED_PER_CPU_EMBED_FIRST_CHUNK
 913         bool
 914
 915 config NEED_PER_CPU_PAGE_FIRST_CHUNK
 916         bool
 917
 918 config USE_PERCPU_NUMA_NODE_ID
 919         bool
 920
 921 config HAVE_SETUP_PER_CPU_AREA
 922         bool
 923
 924 config CMA
 925         bool "Contiguous Memory Allocator"
 926         depends on MMU
 927         select MIGRATION
 928         select MEMORY_ISOLATION
 929         help
 930           This enables the Contiguous Memory Allocator which allows other
 931           subsystems to allocate big physically-contiguous blocks of memory.
 932           CMA reserves a region of memory and allows only movable pages to
 933           be allocated from it. This way, the kernel can use the memory for
 934           pagecache and when a subsystem requests for contiguous area, the
 935           allocated pages are migrated away to serve the contiguous request.
 936
 937           If unsure, say "n".
 938
 939 config CMA_DEBUGFS
 940         bool "CMA debugfs interface"
 941         depends on CMA && DEBUG_FS
 942         help
 943           Turns on the DebugFS interface for CMA.
 944
 945 config CMA_SYSFS
 946         bool "CMA information through sysfs interface"
 947         depends on CMA && SYSFS
 948         help
 949           This option exposes some sysfs attributes to get information
 950           from CMA.
 951
 952 config CMA_AREAS
 953         int "Maximum count of the CMA areas"
 954         depends on CMA
 955         default 20 if NUMA
 956         default 8
 957         help
 958           CMA allows to create CMA areas for particular purpose, mainly,
 959           used as device private area. This parameter sets the maximum
 960           number of CMA area in the system.
 961
 962           If unsure, leave the default value "8" in UMA and "20" in NUMA.
 963
 964 config MEM_SOFT_DIRTY
 965         bool "Track memory changes"
 966         depends on CHECKPOINT_RESTORE && HAVE_ARCH_SOFT_DIRTY && PROC_FS
 967         select PROC_PAGE_MONITOR
 968         help
 969           This option enables memory changes tracking by introducing a
 970           soft-dirty bit on pte-s. This bit it set when someone writes
 971           into a page just as regular dirty bit, but unlike the latter
 972           it can be cleared by hands.
 973
 974           See Documentation/admin-guide/mm/soft-dirty.rst for more details.
 975
 976 config GENERIC_EARLY_IOREMAP
 977         bool
 978
 979 config STACK_MAX_DEFAULT_SIZE_MB
 980         int "Default maximum user stack size for 32-bit processes (MB)"
 981         default 100
 982         range 8 2048
 983         depends on STACK_GROWSUP && (!64BIT || COMPAT)
 984         help
 985           This is the maximum stack size in Megabytes in the VM layout of 32-bit
 986           user processes when the stack grows upwards (currently only on parisc
 987           arch) when the RLIMIT_STACK hard limit is unlimited.
 988
 989           A sane initial value is 100 MB.
 990
 991 config DEFERRED_STRUCT_PAGE_INIT
 992         bool "Defer initialisation of struct pages to kthreads"
 993         depends on SPARSEMEM
 994         depends on !NEED_PER_CPU_KM
 995         depends on 64BIT
 996         depends on !KMSAN
 997         select PADATA
 998         help
 999           Ordinarily all struct pages are initialised during early boot in a
1000           single thread. On very large machines this can take a considerable
1001           amount of time. If this option is set, large machines will bring up
1002           a subset of memmap at boot and then initialise the rest in parallel.
1003           This has a potential performance impact on tasks running early in the
1004           lifetime of the system until these kthreads finish the
1005           initialisation.
1006
1007 config PAGE_IDLE_FLAG
1008         bool
1009         select PAGE_EXTENSION if !64BIT
1010         help
1011           This adds PG_idle and PG_young flags to 'struct page'.  PTE Accessed
1012           bit writers can set the state of the bit in the flags so that PTE
1013           Accessed bit readers may avoid disturbance.
1014
1015 config IDLE_PAGE_TRACKING
1016         bool "Enable idle page tracking"
1017         depends on SYSFS && MMU
1018         select PAGE_IDLE_FLAG
1019         help
1020           This feature allows to estimate the amount of user pages that have
1021           not been touched during a given period of time. This information can
1022           be useful to tune memory cgroup limits and/or for job placement
1023           within a compute cluster.
1024
1025           See Documentation/admin-guide/mm/idle_page_tracking.rst for
1026           more details.
1027
1028 # Architectures which implement cpu_dcache_is_aliasing() to query
1029 # whether the data caches are aliased (VIVT or VIPT with dcache
1030 # aliasing) need to select this.
1031 config ARCH_HAS_CPU_CACHE_ALIASING
1032         bool
1033
1034 config ARCH_HAS_CACHE_LINE_SIZE
1035         bool
1036
1037 config ARCH_HAS_CURRENT_STACK_POINTER
1038         bool
1039         help
1040           In support of HARDENED_USERCOPY performing stack variable lifetime
1041           checking, an architecture-agnostic way to find the stack pointer
1042           is needed. Once an architecture defines an unsigned long global
1043           register alias named "current_stack_pointer", this config can be
1044           selected.
1045
1046 config ARCH_HAS_PTE_DEVMAP
1047         bool
1048
1049 config ARCH_HAS_ZONE_DMA_SET
1050         bool
1051
1052 config ZONE_DMA
1053         bool "Support DMA zone" if ARCH_HAS_ZONE_DMA_SET
1054         default y if ARM64 || X86
1055
1056 config ZONE_DMA32
1057         bool "Support DMA32 zone" if ARCH_HAS_ZONE_DMA_SET
1058         depends on !X86_32
1059         default y if ARM64
1060
1061 config ZONE_DEVICE
1062         bool "Device memory (pmem, HMM, etc...) hotplug support"
1063         depends on MEMORY_HOTPLUG
1064         depends on MEMORY_HOTREMOVE
1065         depends on SPARSEMEM_VMEMMAP
1066         depends on ARCH_HAS_PTE_DEVMAP
1067         select XARRAY_MULTI
1068
1069         help
1070           Device memory hotplug support allows for establishing pmem,
1071           or other device driver discovered memory regions, in the
1072           memmap. This allows pfn_to_page() lookups of otherwise
1073           "device-physical" addresses which is needed for using a DAX
1074           mapping in an O_DIRECT operation, among other things.
1075
1076           If FS_DAX is enabled, then say Y.
1077
1078 #
1079 # Helpers to mirror range of the CPU page tables of a process into device page
1080 # tables.
1081 #
1082 config HMM_MIRROR
1083         bool
1084         depends on MMU
1085
1086 config GET_FREE_REGION
1087         depends on SPARSEMEM
1088         bool
1089
1090 config DEVICE_PRIVATE
1091         bool "Unaddressable device memory (GPU memory, ...)"
1092         depends on ZONE_DEVICE
1093         select GET_FREE_REGION
1094
1095         help
1096           Allows creation of struct pages to represent unaddressable device
1097           memory; i.e., memory that is only accessible from the device (or
1098           group of devices). You likely also want to select HMM_MIRROR.
1099
1100 config VMAP_PFN
1101         bool
1102
1103 config ARCH_USES_HIGH_VMA_FLAGS
1104         bool
1105 config ARCH_HAS_PKEYS
1106         bool
1107
1108 config ARCH_USES_PG_ARCH_2
1109         bool
1110 config ARCH_USES_PG_ARCH_3
1111         bool
1112
1113 config VM_EVENT_COUNTERS
1114         default y
1115         bool "Enable VM event counters for /proc/vmstat" if EXPERT
1116         help
1117           VM event counters are needed for event counts to be shown.
1118           This option allows the disabling of the VM event counters
1119           on EXPERT systems.  /proc/vmstat will only show page counts
1120           if VM event counters are disabled.
1121
1122 config PERCPU_STATS
1123         bool "Collect percpu memory statistics"
1124         help
1125           This feature collects and exposes statistics via debugfs. The
1126           information includes global and per chunk statistics, which can
1127           be used to help understand percpu memory usage.
1128
1129 config GUP_TEST
1130         bool "Enable infrastructure for get_user_pages()-related unit tests"
1131         depends on DEBUG_FS
1132         help
1133           Provides /sys/kernel/debug/gup_test, which in turn provides a way
1134           to make ioctl calls that can launch kernel-based unit tests for
1135           the get_user_pages*() and pin_user_pages*() family of API calls.
1136
1137           These tests include benchmark testing of the _fast variants of
1138           get_user_pages*() and pin_user_pages*(), as well as smoke tests of
1139           the non-_fast variants.
1140
1141           There is also a sub-test that allows running dump_page() on any
1142           of up to eight pages (selected by command line args) within the
1143           range of user-space addresses. These pages are either pinned via
1144           pin_user_pages*(), or pinned via get_user_pages*(), as specified
1145           by other command line arguments.
1146
1147           See tools/testing/selftests/mm/gup_test.c
1148
1149 comment "GUP_TEST needs to have DEBUG_FS enabled"
1150         depends on !GUP_TEST && !DEBUG_FS
1151
1152 config GUP_GET_PXX_LOW_HIGH
1153         bool
1154
1155 config DMAPOOL_TEST
1156         tristate "Enable a module to run time tests on dma_pool"
1157         depends on HAS_DMA
1158         help
1159           Provides a test module that will allocate and free many blocks of
1160           various sizes and report how long it takes. This is intended to
1161           provide a consistent way to measure how changes to the
1162           dma_pool_alloc/free routines affect performance.
1163
1164 config ARCH_HAS_PTE_SPECIAL
1165         bool
1166
1167 config MAPPING_DIRTY_HELPERS
1168         bool
1169
1170 config KMAP_LOCAL
1171         bool
1172
1173 config KMAP_LOCAL_NON_LINEAR_PTE_ARRAY
1174         bool
1175
1176 # struct io_mapping based helper.  Selected by drivers that need them
1177 config IO_MAPPING
1178         bool
1179
1180 config MEMFD_CREATE
1181         bool "Enable memfd_create() system call" if EXPERT
1182
1183 config SECRETMEM
1184         default y
1185         bool "Enable memfd_secret() system call" if EXPERT
1186         depends on ARCH_HAS_SET_DIRECT_MAP
1187         help
1188           Enable the memfd_secret() system call with the ability to create
1189           memory areas visible only in the context of the owning process and
1190           not mapped to other processes and other kernel page tables.
1191
1192 config ANON_VMA_NAME
1193         bool "Anonymous VMA name support"
1194         depends on PROC_FS && ADVISE_SYSCALLS && MMU
1195
1196         help
1197           Allow naming anonymous virtual memory areas.
1198
1199           This feature allows assigning names to virtual memory areas. Assigned
1200           names can be later retrieved from /proc/pid/maps and /proc/pid/smaps
1201           and help identifying individual anonymous memory areas.
1202           Assigning a name to anonymous virtual memory area might prevent that
1203           area from being merged with adjacent virtual memory areas due to the
1204           difference in their name.
1205
1206 config HAVE_ARCH_USERFAULTFD_WP
1207         bool
1208         help
1209           Arch has userfaultfd write protection support
1210
1211 config HAVE_ARCH_USERFAULTFD_MINOR
1212         bool
1213         help
1214           Arch has userfaultfd minor fault support
1215
1216 menuconfig USERFAULTFD
1217         bool "Enable userfaultfd() system call"
1218         depends on MMU
1219         help
1220           Enable the userfaultfd() system call that allows to intercept and
1221           handle page faults in userland.
1222
1223 if USERFAULTFD
1224 config PTE_MARKER_UFFD_WP
1225         bool "Userfaultfd write protection support for shmem/hugetlbfs"
1226         default y
1227         depends on HAVE_ARCH_USERFAULTFD_WP
1228
1229         help
1230           Allows to create marker PTEs for userfaultfd write protection
1231           purposes.  It is required to enable userfaultfd write protection on
1232           file-backed memory types like shmem and hugetlbfs.
1233 endif # USERFAULTFD
1234
1235 # multi-gen LRU {
1236 config LRU_GEN
1237         bool "Multi-Gen LRU"
1238         depends on MMU
1239         # make sure folio->flags has enough spare bits
1240         depends on 64BIT || !SPARSEMEM || SPARSEMEM_VMEMMAP
1241         help
1242           A high performance LRU implementation to overcommit memory. See
1243           Documentation/admin-guide/mm/multigen_lru.rst for details.
1244
1245 config LRU_GEN_ENABLED
1246         bool "Enable by default"
1247         depends on LRU_GEN
1248         help
1249           This option enables the multi-gen LRU by default.
1250
1251 config LRU_GEN_STATS
1252         bool "Full stats for debugging"
1253         depends on LRU_GEN
1254         help
1255           Do not enable this option unless you plan to look at historical stats
1256           from evicted generations for debugging purpose.
1257
1258           This option has a per-memcg and per-node memory overhead.
1259
1260 config LRU_GEN_WALKS_MMU
1261         def_bool y
1262         depends on LRU_GEN && ARCH_HAS_HW_PTE_YOUNG
1263 # }
1264
1265 config ARCH_SUPPORTS_PER_VMA_LOCK
1266        def_bool n
1267
1268 config PER_VMA_LOCK
1269         def_bool y
1270         depends on ARCH_SUPPORTS_PER_VMA_LOCK && MMU && SMP
1271         help
1272           Allow per-vma locking during page fault handling.
1273
1274           This feature allows locking each virtual memory area separately when
1275           handling page faults instead of taking mmap_lock.
1276
1277 config LOCK_MM_AND_FIND_VMA
1278         bool
1279         depends on !STACK_GROWSUP
1280
1281 config IOMMU_MM_DATA
1282         bool
1283
1284 config EXECMEM
1285         bool
1286
1287 config NUMA_MEMBLKS
1288         bool
1289
1290 config NUMA_EMU
1291         bool "NUMA emulation"
1292         depends on NUMA_MEMBLKS
1293         help
1294           Enable NUMA emulation. A flat machine will be split
1295           into virtual nodes when booted with "numa=fake=N", where N is the
1296           number of nodes. This is only useful for debugging.
1297
1298 source "mm/damon/Kconfig"
1299
1300 endmenu