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