1# SPDX-License-Identifier: GPL-2.0-only 2 3menu "Memory Management options" 4 5config SELECT_MEMORY_MODEL 6 def_bool y 7 depends on ARCH_SELECT_MEMORY_MODEL 8 9choice 10 prompt "Memory model" 11 depends on SELECT_MEMORY_MODEL 12 default DISCONTIGMEM_MANUAL if ARCH_DISCONTIGMEM_DEFAULT 13 default SPARSEMEM_MANUAL if ARCH_SPARSEMEM_DEFAULT 14 default FLATMEM_MANUAL 15 help 16 This option allows you to change some of the ways that 17 Linux manages its memory internally. Most users will 18 only have one option here selected by the architecture 19 configuration. This is normal. 20 21config FLATMEM_MANUAL 22 bool "Flat Memory" 23 depends on !(ARCH_DISCONTIGMEM_ENABLE || ARCH_SPARSEMEM_ENABLE) || ARCH_FLATMEM_ENABLE 24 help 25 This option is best suited for non-NUMA systems with 26 flat address space. The FLATMEM is the most efficient 27 system in terms of performance and resource consumption 28 and it is the best option for smaller systems. 29 30 For systems that have holes in their physical address 31 spaces and for features like NUMA and memory hotplug, 32 choose "Sparse Memory". 33 34 If unsure, choose this option (Flat Memory) over any other. 35 36config DISCONTIGMEM_MANUAL 37 bool "Discontiguous Memory" 38 depends on ARCH_DISCONTIGMEM_ENABLE 39 help 40 This option provides enhanced support for discontiguous 41 memory systems, over FLATMEM. These systems have holes 42 in their physical address spaces, and this option provides 43 more efficient handling of these holes. 44 45 Although "Discontiguous Memory" is still used by several 46 architectures, it is considered deprecated in favor of 47 "Sparse Memory". 48 49 If unsure, choose "Sparse Memory" over this option. 50 51config SPARSEMEM_MANUAL 52 bool "Sparse Memory" 53 depends on ARCH_SPARSEMEM_ENABLE 54 help 55 This will be the only option for some systems, including 56 memory hot-plug systems. This is normal. 57 58 This option provides efficient support for systems with 59 holes is their physical address space and allows memory 60 hot-plug and hot-remove. 61 62 If unsure, choose "Flat Memory" over this option. 63 64endchoice 65 66config DISCONTIGMEM 67 def_bool y 68 depends on (!SELECT_MEMORY_MODEL && ARCH_DISCONTIGMEM_ENABLE) || DISCONTIGMEM_MANUAL 69 70config SPARSEMEM 71 def_bool y 72 depends on (!SELECT_MEMORY_MODEL && ARCH_SPARSEMEM_ENABLE) || SPARSEMEM_MANUAL 73 74config FLATMEM 75 def_bool y 76 depends on (!DISCONTIGMEM && !SPARSEMEM) || FLATMEM_MANUAL 77 78config FLAT_NODE_MEM_MAP 79 def_bool y 80 depends on !SPARSEMEM 81 82# 83# Both the NUMA code and DISCONTIGMEM use arrays of pg_data_t's 84# to represent different areas of memory. This variable allows 85# those dependencies to exist individually. 86# 87config NEED_MULTIPLE_NODES 88 def_bool y 89 depends on DISCONTIGMEM || NUMA 90 91config HAVE_MEMORY_PRESENT 92 def_bool y 93 depends on ARCH_HAVE_MEMORY_PRESENT || SPARSEMEM 94 95# 96# SPARSEMEM_EXTREME (which is the default) does some bootmem 97# allocations when memory_present() is called. If this cannot 98# be done on your architecture, select this option. However, 99# statically allocating the mem_section[] array can potentially 100# consume vast quantities of .bss, so be careful. 101# 102# This option will also potentially produce smaller runtime code 103# with gcc 3.4 and later. 104# 105config SPARSEMEM_STATIC 106 bool 107 108# 109# Architecture platforms which require a two level mem_section in SPARSEMEM 110# must select this option. This is usually for architecture platforms with 111# an extremely sparse physical address space. 112# 113config SPARSEMEM_EXTREME 114 def_bool y 115 depends on SPARSEMEM && !SPARSEMEM_STATIC 116 117config SPARSEMEM_VMEMMAP_ENABLE 118 bool 119 120config SPARSEMEM_VMEMMAP 121 bool "Sparse Memory virtual memmap" 122 depends on SPARSEMEM && SPARSEMEM_VMEMMAP_ENABLE 123 default y 124 help 125 SPARSEMEM_VMEMMAP uses a virtually mapped memmap to optimise 126 pfn_to_page and page_to_pfn operations. This is the most 127 efficient option when sufficient kernel resources are available. 128 129config HAVE_MEMBLOCK_PHYS_MAP 130 bool 131 132config HAVE_FAST_GUP 133 depends on MMU 134 bool 135 136# Don't discard allocated memory used to track "memory" and "reserved" memblocks 137# after early boot, so it can still be used to test for validity of memory. 138# Also, memblocks are updated with memory hot(un)plug. 139config ARCH_KEEP_MEMBLOCK 140 bool 141 142# Keep arch NUMA mapping infrastructure post-init. 143config NUMA_KEEP_MEMINFO 144 bool 145 146config MEMORY_ISOLATION 147 bool 148 149# 150# Only be set on architectures that have completely implemented memory hotplug 151# feature. If you are not sure, don't touch it. 152# 153config HAVE_BOOTMEM_INFO_NODE 154 def_bool n 155 156# eventually, we can have this option just 'select SPARSEMEM' 157config MEMORY_HOTPLUG 158 bool "Allow for memory hot-add" 159 depends on SPARSEMEM || X86_64_ACPI_NUMA 160 depends on ARCH_ENABLE_MEMORY_HOTPLUG 161 depends on 64BIT || BROKEN 162 select NUMA_KEEP_MEMINFO if NUMA 163 164config MEMORY_HOTPLUG_SPARSE 165 def_bool y 166 depends on SPARSEMEM && MEMORY_HOTPLUG 167 168config MEMORY_HOTPLUG_DEFAULT_ONLINE 169 bool "Online the newly added memory blocks by default" 170 depends on MEMORY_HOTPLUG 171 help 172 This option sets the default policy setting for memory hotplug 173 onlining policy (/sys/devices/system/memory/auto_online_blocks) which 174 determines what happens to newly added memory regions. Policy setting 175 can always be changed at runtime. 176 See Documentation/admin-guide/mm/memory-hotplug.rst for more information. 177 178 Say Y here if you want all hot-plugged memory blocks to appear in 179 'online' state by default. 180 Say N here if you want the default policy to keep all hot-plugged 181 memory blocks in 'offline' state. 182 183config MEMORY_HOTREMOVE 184 bool "Allow for memory hot remove" 185 select MEMORY_ISOLATION 186 select HAVE_BOOTMEM_INFO_NODE if (X86_64 || PPC64) 187 depends on MEMORY_HOTPLUG && ARCH_ENABLE_MEMORY_HOTREMOVE 188 depends on MIGRATION 189 190# Heavily threaded applications may benefit from splitting the mm-wide 191# page_table_lock, so that faults on different parts of the user address 192# space can be handled with less contention: split it at this NR_CPUS. 193# Default to 4 for wider testing, though 8 might be more appropriate. 194# ARM's adjust_pte (unused if VIPT) depends on mm-wide page_table_lock. 195# PA-RISC 7xxx's spinlock_t would enlarge struct page from 32 to 44 bytes. 196# SPARC32 allocates multiple pte tables within a single page, and therefore 197# a per-page lock leads to problems when multiple tables need to be locked 198# at the same time (e.g. copy_page_range()). 199# DEBUG_SPINLOCK and DEBUG_LOCK_ALLOC spinlock_t also enlarge struct page. 200# 201config SPLIT_PTLOCK_CPUS 202 int 203 default "999999" if !MMU 204 default "999999" if ARM && !CPU_CACHE_VIPT 205 default "999999" if PARISC && !PA20 206 default "999999" if SPARC32 207 default "4" 208 209config ARCH_ENABLE_SPLIT_PMD_PTLOCK 210 bool 211 212# 213# support for memory balloon 214config MEMORY_BALLOON 215 bool 216 217# 218# support for memory balloon compaction 219config BALLOON_COMPACTION 220 bool "Allow for balloon memory compaction/migration" 221 def_bool y 222 depends on COMPACTION && MEMORY_BALLOON 223 help 224 Memory fragmentation introduced by ballooning might reduce 225 significantly the number of 2MB contiguous memory blocks that can be 226 used within a guest, thus imposing performance penalties associated 227 with the reduced number of transparent huge pages that could be used 228 by the guest workload. Allowing the compaction & migration for memory 229 pages enlisted as being part of memory balloon devices avoids the 230 scenario aforementioned and helps improving memory defragmentation. 231 232# 233# support for memory compaction 234config COMPACTION 235 bool "Allow for memory compaction" 236 def_bool y 237 select MIGRATION 238 depends on MMU 239 help 240 Compaction is the only memory management component to form 241 high order (larger physically contiguous) memory blocks 242 reliably. The page allocator relies on compaction heavily and 243 the lack of the feature can lead to unexpected OOM killer 244 invocations for high order memory requests. You shouldn't 245 disable this option unless there really is a strong reason for 246 it and then we would be really interested to hear about that at 247 linux-mm@kvack.org. 248 249# 250# support for free page reporting 251config PAGE_REPORTING 252 bool "Free page reporting" 253 def_bool n 254 help 255 Free page reporting allows for the incremental acquisition of 256 free pages from the buddy allocator for the purpose of reporting 257 those pages to another entity, such as a hypervisor, so that the 258 memory can be freed within the host for other uses. 259 260# 261# support for page migration 262# 263config MIGRATION 264 bool "Page migration" 265 def_bool y 266 depends on (NUMA || ARCH_ENABLE_MEMORY_HOTREMOVE || COMPACTION || CMA) && MMU 267 help 268 Allows the migration of the physical location of pages of processes 269 while the virtual addresses are not changed. This is useful in 270 two situations. The first is on NUMA systems to put pages nearer 271 to the processors accessing. The second is when allocating huge 272 pages as migration can relocate pages to satisfy a huge page 273 allocation instead of reclaiming. 274 275config ARCH_ENABLE_HUGEPAGE_MIGRATION 276 bool 277 278config ARCH_ENABLE_THP_MIGRATION 279 bool 280 281config CONTIG_ALLOC 282 def_bool (MEMORY_ISOLATION && COMPACTION) || CMA 283 284config PHYS_ADDR_T_64BIT 285 def_bool 64BIT 286 287config BOUNCE 288 bool "Enable bounce buffers" 289 default y 290 depends on BLOCK && MMU && (ZONE_DMA || HIGHMEM) 291 help 292 Enable bounce buffers for devices that cannot access 293 the full range of memory available to the CPU. Enabled 294 by default when ZONE_DMA or HIGHMEM is selected, but you 295 may say n to override this. 296 297config VIRT_TO_BUS 298 bool 299 help 300 An architecture should select this if it implements the 301 deprecated interface virt_to_bus(). All new architectures 302 should probably not select this. 303 304 305config MMU_NOTIFIER 306 bool 307 select SRCU 308 select INTERVAL_TREE 309 310config KSM 311 bool "Enable KSM for page merging" 312 depends on MMU 313 select XXHASH 314 help 315 Enable Kernel Samepage Merging: KSM periodically scans those areas 316 of an application's address space that an app has advised may be 317 mergeable. When it finds pages of identical content, it replaces 318 the many instances by a single page with that content, so 319 saving memory until one or another app needs to modify the content. 320 Recommended for use with KVM, or with other duplicative applications. 321 See Documentation/vm/ksm.rst for more information: KSM is inactive 322 until a program has madvised that an area is MADV_MERGEABLE, and 323 root has set /sys/kernel/mm/ksm/run to 1 (if CONFIG_SYSFS is set). 324 325config DEFAULT_MMAP_MIN_ADDR 326 int "Low address space to protect from user allocation" 327 depends on MMU 328 default 4096 329 help 330 This is the portion of low virtual memory which should be protected 331 from userspace allocation. Keeping a user from writing to low pages 332 can help reduce the impact of kernel NULL pointer bugs. 333 334 For most ia64, ppc64 and x86 users with lots of address space 335 a value of 65536 is reasonable and should cause no problems. 336 On arm and other archs it should not be higher than 32768. 337 Programs which use vm86 functionality or have some need to map 338 this low address space will need CAP_SYS_RAWIO or disable this 339 protection by setting the value to 0. 340 341 This value can be changed after boot using the 342 /proc/sys/vm/mmap_min_addr tunable. 343 344config ARCH_SUPPORTS_MEMORY_FAILURE 345 bool 346 347config MEMORY_FAILURE 348 depends on MMU 349 depends on ARCH_SUPPORTS_MEMORY_FAILURE 350 bool "Enable recovery from hardware memory errors" 351 select MEMORY_ISOLATION 352 select RAS 353 help 354 Enables code to recover from some memory failures on systems 355 with MCA recovery. This allows a system to continue running 356 even when some of its memory has uncorrected errors. This requires 357 special hardware support and typically ECC memory. 358 359config HWPOISON_INJECT 360 tristate "HWPoison pages injector" 361 depends on MEMORY_FAILURE && DEBUG_KERNEL && PROC_FS 362 select PROC_PAGE_MONITOR 363 364config NOMMU_INITIAL_TRIM_EXCESS 365 int "Turn on mmap() excess space trimming before booting" 366 depends on !MMU 367 default 1 368 help 369 The NOMMU mmap() frequently needs to allocate large contiguous chunks 370 of memory on which to store mappings, but it can only ask the system 371 allocator for chunks in 2^N*PAGE_SIZE amounts - which is frequently 372 more than it requires. To deal with this, mmap() is able to trim off 373 the excess and return it to the allocator. 374 375 If trimming is enabled, the excess is trimmed off and returned to the 376 system allocator, which can cause extra fragmentation, particularly 377 if there are a lot of transient processes. 378 379 If trimming is disabled, the excess is kept, but not used, which for 380 long-term mappings means that the space is wasted. 381 382 Trimming can be dynamically controlled through a sysctl option 383 (/proc/sys/vm/nr_trim_pages) which specifies the minimum number of 384 excess pages there must be before trimming should occur, or zero if 385 no trimming is to occur. 386 387 This option specifies the initial value of this option. The default 388 of 1 says that all excess pages should be trimmed. 389 390 See Documentation/nommu-mmap.txt for more information. 391 392config TRANSPARENT_HUGEPAGE 393 bool "Transparent Hugepage Support" 394 depends on HAVE_ARCH_TRANSPARENT_HUGEPAGE 395 select COMPACTION 396 select XARRAY_MULTI 397 help 398 Transparent Hugepages allows the kernel to use huge pages and 399 huge tlb transparently to the applications whenever possible. 400 This feature can improve computing performance to certain 401 applications by speeding up page faults during memory 402 allocation, by reducing the number of tlb misses and by speeding 403 up the pagetable walking. 404 405 If memory constrained on embedded, you may want to say N. 406 407choice 408 prompt "Transparent Hugepage Support sysfs defaults" 409 depends on TRANSPARENT_HUGEPAGE 410 default TRANSPARENT_HUGEPAGE_ALWAYS 411 help 412 Selects the sysfs defaults for Transparent Hugepage Support. 413 414 config TRANSPARENT_HUGEPAGE_ALWAYS 415 bool "always" 416 help 417 Enabling Transparent Hugepage always, can increase the 418 memory footprint of applications without a guaranteed 419 benefit but it will work automatically for all applications. 420 421 config TRANSPARENT_HUGEPAGE_MADVISE 422 bool "madvise" 423 help 424 Enabling Transparent Hugepage madvise, will only provide a 425 performance improvement benefit to the applications using 426 madvise(MADV_HUGEPAGE) but it won't risk to increase the 427 memory footprint of applications without a guaranteed 428 benefit. 429endchoice 430 431config ARCH_WANTS_THP_SWAP 432 def_bool n 433 434config THP_SWAP 435 def_bool y 436 depends on TRANSPARENT_HUGEPAGE && ARCH_WANTS_THP_SWAP && SWAP 437 help 438 Swap transparent huge pages in one piece, without splitting. 439 XXX: For now, swap cluster backing transparent huge page 440 will be split after swapout. 441 442 For selection by architectures with reasonable THP sizes. 443 444# 445# UP and nommu archs use km based percpu allocator 446# 447config NEED_PER_CPU_KM 448 depends on !SMP 449 bool 450 default y 451 452config CLEANCACHE 453 bool "Enable cleancache driver to cache clean pages if tmem is present" 454 help 455 Cleancache can be thought of as a page-granularity victim cache 456 for clean pages that the kernel's pageframe replacement algorithm 457 (PFRA) would like to keep around, but can't since there isn't enough 458 memory. So when the PFRA "evicts" a page, it first attempts to use 459 cleancache code to put the data contained in that page into 460 "transcendent memory", memory that is not directly accessible or 461 addressable by the kernel and is of unknown and possibly 462 time-varying size. And when a cleancache-enabled 463 filesystem wishes to access a page in a file on disk, it first 464 checks cleancache to see if it already contains it; if it does, 465 the page is copied into the kernel and a disk access is avoided. 466 When a transcendent memory driver is available (such as zcache or 467 Xen transcendent memory), a significant I/O reduction 468 may be achieved. When none is available, all cleancache calls 469 are reduced to a single pointer-compare-against-NULL resulting 470 in a negligible performance hit. 471 472 If unsure, say Y to enable cleancache 473 474config FRONTSWAP 475 bool "Enable frontswap to cache swap pages if tmem is present" 476 depends on SWAP 477 help 478 Frontswap is so named because it can be thought of as the opposite 479 of a "backing" store for a swap device. The data is stored into 480 "transcendent memory", memory that is not directly accessible or 481 addressable by the kernel and is of unknown and possibly 482 time-varying size. When space in transcendent memory is available, 483 a significant swap I/O reduction may be achieved. When none is 484 available, all frontswap calls are reduced to a single pointer- 485 compare-against-NULL resulting in a negligible performance hit 486 and swap data is stored as normal on the matching swap device. 487 488 If unsure, say Y to enable frontswap. 489 490config CMA 491 bool "Contiguous Memory Allocator" 492 depends on MMU 493 select MIGRATION 494 select MEMORY_ISOLATION 495 help 496 This enables the Contiguous Memory Allocator which allows other 497 subsystems to allocate big physically-contiguous blocks of memory. 498 CMA reserves a region of memory and allows only movable pages to 499 be allocated from it. This way, the kernel can use the memory for 500 pagecache and when a subsystem requests for contiguous area, the 501 allocated pages are migrated away to serve the contiguous request. 502 503 If unsure, say "n". 504 505config CMA_DEBUG 506 bool "CMA debug messages (DEVELOPMENT)" 507 depends on DEBUG_KERNEL && CMA 508 help 509 Turns on debug messages in CMA. This produces KERN_DEBUG 510 messages for every CMA call as well as various messages while 511 processing calls such as dma_alloc_from_contiguous(). 512 This option does not affect warning and error messages. 513 514config CMA_DEBUGFS 515 bool "CMA debugfs interface" 516 depends on CMA && DEBUG_FS 517 help 518 Turns on the DebugFS interface for CMA. 519 520config CMA_AREAS 521 int "Maximum count of the CMA areas" 522 depends on CMA 523 default 7 524 help 525 CMA allows to create CMA areas for particular purpose, mainly, 526 used as device private area. This parameter sets the maximum 527 number of CMA area in the system. 528 529 If unsure, leave the default value "7". 530 531config MEM_SOFT_DIRTY 532 bool "Track memory changes" 533 depends on CHECKPOINT_RESTORE && HAVE_ARCH_SOFT_DIRTY && PROC_FS 534 select PROC_PAGE_MONITOR 535 help 536 This option enables memory changes tracking by introducing a 537 soft-dirty bit on pte-s. This bit it set when someone writes 538 into a page just as regular dirty bit, but unlike the latter 539 it can be cleared by hands. 540 541 See Documentation/admin-guide/mm/soft-dirty.rst for more details. 542 543config ZSWAP 544 bool "Compressed cache for swap pages (EXPERIMENTAL)" 545 depends on FRONTSWAP && CRYPTO=y 546 select ZPOOL 547 help 548 A lightweight compressed cache for swap pages. It takes 549 pages that are in the process of being swapped out and attempts to 550 compress them into a dynamically allocated RAM-based memory pool. 551 This can result in a significant I/O reduction on swap device and, 552 in the case where decompressing from RAM is faster that swap device 553 reads, can also improve workload performance. 554 555 This is marked experimental because it is a new feature (as of 556 v3.11) that interacts heavily with memory reclaim. While these 557 interactions don't cause any known issues on simple memory setups, 558 they have not be fully explored on the large set of potential 559 configurations and workloads that exist. 560 561choice 562 prompt "Compressed cache for swap pages default compressor" 563 depends on ZSWAP 564 default ZSWAP_COMPRESSOR_DEFAULT_LZO 565 help 566 Selects the default compression algorithm for the compressed cache 567 for swap pages. 568 569 For an overview what kind of performance can be expected from 570 a particular compression algorithm please refer to the benchmarks 571 available at the following LWN page: 572 https://lwn.net/Articles/751795/ 573 574 If in doubt, select 'LZO'. 575 576 The selection made here can be overridden by using the kernel 577 command line 'zswap.compressor=' option. 578 579config ZSWAP_COMPRESSOR_DEFAULT_DEFLATE 580 bool "Deflate" 581 select CRYPTO_DEFLATE 582 help 583 Use the Deflate algorithm as the default compression algorithm. 584 585config ZSWAP_COMPRESSOR_DEFAULT_LZO 586 bool "LZO" 587 select CRYPTO_LZO 588 help 589 Use the LZO algorithm as the default compression algorithm. 590 591config ZSWAP_COMPRESSOR_DEFAULT_842 592 bool "842" 593 select CRYPTO_842 594 help 595 Use the 842 algorithm as the default compression algorithm. 596 597config ZSWAP_COMPRESSOR_DEFAULT_LZ4 598 bool "LZ4" 599 select CRYPTO_LZ4 600 help 601 Use the LZ4 algorithm as the default compression algorithm. 602 603config ZSWAP_COMPRESSOR_DEFAULT_LZ4HC 604 bool "LZ4HC" 605 select CRYPTO_LZ4HC 606 help 607 Use the LZ4HC algorithm as the default compression algorithm. 608 609config ZSWAP_COMPRESSOR_DEFAULT_ZSTD 610 bool "zstd" 611 select CRYPTO_ZSTD 612 help 613 Use the zstd algorithm as the default compression algorithm. 614endchoice 615 616config ZSWAP_COMPRESSOR_DEFAULT 617 string 618 depends on ZSWAP 619 default "deflate" if ZSWAP_COMPRESSOR_DEFAULT_DEFLATE 620 default "lzo" if ZSWAP_COMPRESSOR_DEFAULT_LZO 621 default "842" if ZSWAP_COMPRESSOR_DEFAULT_842 622 default "lz4" if ZSWAP_COMPRESSOR_DEFAULT_LZ4 623 default "lz4hc" if ZSWAP_COMPRESSOR_DEFAULT_LZ4HC 624 default "zstd" if ZSWAP_COMPRESSOR_DEFAULT_ZSTD 625 default "" 626 627choice 628 prompt "Compressed cache for swap pages default allocator" 629 depends on ZSWAP 630 default ZSWAP_ZPOOL_DEFAULT_ZBUD 631 help 632 Selects the default allocator for the compressed cache for 633 swap pages. 634 The default is 'zbud' for compatibility, however please do 635 read the description of each of the allocators below before 636 making a right choice. 637 638 The selection made here can be overridden by using the kernel 639 command line 'zswap.zpool=' option. 640 641config ZSWAP_ZPOOL_DEFAULT_ZBUD 642 bool "zbud" 643 select ZBUD 644 help 645 Use the zbud allocator as the default allocator. 646 647config ZSWAP_ZPOOL_DEFAULT_Z3FOLD 648 bool "z3fold" 649 select Z3FOLD 650 help 651 Use the z3fold allocator as the default allocator. 652 653config ZSWAP_ZPOOL_DEFAULT_ZSMALLOC 654 bool "zsmalloc" 655 select ZSMALLOC 656 help 657 Use the zsmalloc allocator as the default allocator. 658endchoice 659 660config ZSWAP_ZPOOL_DEFAULT 661 string 662 depends on ZSWAP 663 default "zbud" if ZSWAP_ZPOOL_DEFAULT_ZBUD 664 default "z3fold" if ZSWAP_ZPOOL_DEFAULT_Z3FOLD 665 default "zsmalloc" if ZSWAP_ZPOOL_DEFAULT_ZSMALLOC 666 default "" 667 668config ZSWAP_DEFAULT_ON 669 bool "Enable the compressed cache for swap pages by default" 670 depends on ZSWAP 671 help 672 If selected, the compressed cache for swap pages will be enabled 673 at boot, otherwise it will be disabled. 674 675 The selection made here can be overridden by using the kernel 676 command line 'zswap.enabled=' option. 677 678config ZPOOL 679 tristate "Common API for compressed memory storage" 680 help 681 Compressed memory storage API. This allows using either zbud or 682 zsmalloc. 683 684config ZBUD 685 tristate "Low (Up to 2x) density storage for compressed pages" 686 help 687 A special purpose allocator for storing compressed pages. 688 It is designed to store up to two compressed pages per physical 689 page. While this design limits storage density, it has simple and 690 deterministic reclaim properties that make it preferable to a higher 691 density approach when reclaim will be used. 692 693config Z3FOLD 694 tristate "Up to 3x density storage for compressed pages" 695 depends on ZPOOL 696 help 697 A special purpose allocator for storing compressed pages. 698 It is designed to store up to three compressed pages per physical 699 page. It is a ZBUD derivative so the simplicity and determinism are 700 still there. 701 702config ZSMALLOC 703 tristate "Memory allocator for compressed pages" 704 depends on MMU 705 help 706 zsmalloc is a slab-based memory allocator designed to store 707 compressed RAM pages. zsmalloc uses virtual memory mapping 708 in order to reduce fragmentation. However, this results in a 709 non-standard allocator interface where a handle, not a pointer, is 710 returned by an alloc(). This handle must be mapped in order to 711 access the allocated space. 712 713config ZSMALLOC_PGTABLE_MAPPING 714 bool "Use page table mapping to access object in zsmalloc" 715 depends on ZSMALLOC=y 716 help 717 By default, zsmalloc uses a copy-based object mapping method to 718 access allocations that span two pages. However, if a particular 719 architecture (ex, ARM) performs VM mapping faster than copying, 720 then you should select this. This causes zsmalloc to use page table 721 mapping rather than copying for object mapping. 722 723 You can check speed with zsmalloc benchmark: 724 https://github.com/spartacus06/zsmapbench 725 726config ZSMALLOC_STAT 727 bool "Export zsmalloc statistics" 728 depends on ZSMALLOC 729 select DEBUG_FS 730 help 731 This option enables code in the zsmalloc to collect various 732 statistics about whats happening in zsmalloc and exports that 733 information to userspace via debugfs. 734 If unsure, say N. 735 736config GENERIC_EARLY_IOREMAP 737 bool 738 739config MAX_STACK_SIZE_MB 740 int "Maximum user stack size for 32-bit processes (MB)" 741 default 80 742 range 8 2048 743 depends on STACK_GROWSUP && (!64BIT || COMPAT) 744 help 745 This is the maximum stack size in Megabytes in the VM layout of 32-bit 746 user processes when the stack grows upwards (currently only on parisc 747 arch). The stack will be located at the highest memory address minus 748 the given value, unless the RLIMIT_STACK hard limit is changed to a 749 smaller value in which case that is used. 750 751 A sane initial value is 80 MB. 752 753config DEFERRED_STRUCT_PAGE_INIT 754 bool "Defer initialisation of struct pages to kthreads" 755 depends on SPARSEMEM 756 depends on !NEED_PER_CPU_KM 757 depends on 64BIT 758 select PADATA 759 help 760 Ordinarily all struct pages are initialised during early boot in a 761 single thread. On very large machines this can take a considerable 762 amount of time. If this option is set, large machines will bring up 763 a subset of memmap at boot and then initialise the rest in parallel. 764 This has a potential performance impact on tasks running early in the 765 lifetime of the system until these kthreads finish the 766 initialisation. 767 768config IDLE_PAGE_TRACKING 769 bool "Enable idle page tracking" 770 depends on SYSFS && MMU 771 select PAGE_EXTENSION if !64BIT 772 help 773 This feature allows to estimate the amount of user pages that have 774 not been touched during a given period of time. This information can 775 be useful to tune memory cgroup limits and/or for job placement 776 within a compute cluster. 777 778 See Documentation/admin-guide/mm/idle_page_tracking.rst for 779 more details. 780 781config ARCH_HAS_PTE_DEVMAP 782 bool 783 784config ZONE_DEVICE 785 bool "Device memory (pmem, HMM, etc...) hotplug support" 786 depends on MEMORY_HOTPLUG 787 depends on MEMORY_HOTREMOVE 788 depends on SPARSEMEM_VMEMMAP 789 depends on ARCH_HAS_PTE_DEVMAP 790 select XARRAY_MULTI 791 792 help 793 Device memory hotplug support allows for establishing pmem, 794 or other device driver discovered memory regions, in the 795 memmap. This allows pfn_to_page() lookups of otherwise 796 "device-physical" addresses which is needed for using a DAX 797 mapping in an O_DIRECT operation, among other things. 798 799 If FS_DAX is enabled, then say Y. 800 801config DEV_PAGEMAP_OPS 802 bool 803 804# 805# Helpers to mirror range of the CPU page tables of a process into device page 806# tables. 807# 808config HMM_MIRROR 809 bool 810 depends on MMU 811 812config DEVICE_PRIVATE 813 bool "Unaddressable device memory (GPU memory, ...)" 814 depends on ZONE_DEVICE 815 select DEV_PAGEMAP_OPS 816 817 help 818 Allows creation of struct pages to represent unaddressable device 819 memory; i.e., memory that is only accessible from the device (or 820 group of devices). You likely also want to select HMM_MIRROR. 821 822config FRAME_VECTOR 823 bool 824 825config ARCH_USES_HIGH_VMA_FLAGS 826 bool 827config ARCH_HAS_PKEYS 828 bool 829 830config PERCPU_STATS 831 bool "Collect percpu memory statistics" 832 help 833 This feature collects and exposes statistics via debugfs. The 834 information includes global and per chunk statistics, which can 835 be used to help understand percpu memory usage. 836 837config GUP_BENCHMARK 838 bool "Enable infrastructure for get_user_pages_fast() benchmarking" 839 help 840 Provides /sys/kernel/debug/gup_benchmark that helps with testing 841 performance of get_user_pages_fast(). 842 843 See tools/testing/selftests/vm/gup_benchmark.c 844 845config GUP_GET_PTE_LOW_HIGH 846 bool 847 848config READ_ONLY_THP_FOR_FS 849 bool "Read-only THP for filesystems (EXPERIMENTAL)" 850 depends on TRANSPARENT_HUGEPAGE && SHMEM 851 852 help 853 Allow khugepaged to put read-only file-backed pages in THP. 854 855 This is marked experimental because it is a new feature. Write 856 support of file THPs will be developed in the next few release 857 cycles. 858 859config ARCH_HAS_PTE_SPECIAL 860 bool 861 862# 863# Some architectures require a special hugepage directory format that is 864# required to support multiple hugepage sizes. For example a4fe3ce76 865# "powerpc/mm: Allow more flexible layouts for hugepage pagetables" 866# introduced it on powerpc. This allows for a more flexible hugepage 867# pagetable layouts. 868# 869config ARCH_HAS_HUGEPD 870 bool 871 872config MAPPING_DIRTY_HELPERS 873 bool 874 875endmenu 876