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