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