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 268 Note that the pageblock_order cannot exceed MAX_ORDER - 1 and will be 269 clamped down to MAX_ORDER - 1. 270 271config CONTIG_ALLOC 272 def_bool (MEMORY_ISOLATION && COMPACTION) || CMA 273 274config PHYS_ADDR_T_64BIT 275 def_bool 64BIT 276 277config BOUNCE 278 bool "Enable bounce buffers" 279 default y 280 depends on BLOCK && MMU && HIGHMEM 281 help 282 Enable bounce buffers for devices that cannot access the full range of 283 memory available to the CPU. Enabled by default when HIGHMEM is 284 selected, but you may say n to override this. 285 286config VIRT_TO_BUS 287 bool 288 help 289 An architecture should select this if it implements the 290 deprecated interface virt_to_bus(). All new architectures 291 should probably not select this. 292 293 294config MMU_NOTIFIER 295 bool 296 select SRCU 297 select INTERVAL_TREE 298 299config KSM 300 bool "Enable KSM for page merging" 301 depends on MMU 302 select XXHASH 303 help 304 Enable Kernel Samepage Merging: KSM periodically scans those areas 305 of an application's address space that an app has advised may be 306 mergeable. When it finds pages of identical content, it replaces 307 the many instances by a single page with that content, so 308 saving memory until one or another app needs to modify the content. 309 Recommended for use with KVM, or with other duplicative applications. 310 See Documentation/vm/ksm.rst for more information: KSM is inactive 311 until a program has madvised that an area is MADV_MERGEABLE, and 312 root has set /sys/kernel/mm/ksm/run to 1 (if CONFIG_SYSFS is set). 313 314config DEFAULT_MMAP_MIN_ADDR 315 int "Low address space to protect from user allocation" 316 depends on MMU 317 default 4096 318 help 319 This is the portion of low virtual memory which should be protected 320 from userspace allocation. Keeping a user from writing to low pages 321 can help reduce the impact of kernel NULL pointer bugs. 322 323 For most ia64, ppc64 and x86 users with lots of address space 324 a value of 65536 is reasonable and should cause no problems. 325 On arm and other archs it should not be higher than 32768. 326 Programs which use vm86 functionality or have some need to map 327 this low address space will need CAP_SYS_RAWIO or disable this 328 protection by setting the value to 0. 329 330 This value can be changed after boot using the 331 /proc/sys/vm/mmap_min_addr tunable. 332 333config ARCH_SUPPORTS_MEMORY_FAILURE 334 bool 335 336config MEMORY_FAILURE 337 depends on MMU 338 depends on ARCH_SUPPORTS_MEMORY_FAILURE 339 bool "Enable recovery from hardware memory errors" 340 select MEMORY_ISOLATION 341 select RAS 342 help 343 Enables code to recover from some memory failures on systems 344 with MCA recovery. This allows a system to continue running 345 even when some of its memory has uncorrected errors. This requires 346 special hardware support and typically ECC memory. 347 348config HWPOISON_INJECT 349 tristate "HWPoison pages injector" 350 depends on MEMORY_FAILURE && DEBUG_KERNEL && PROC_FS 351 select PROC_PAGE_MONITOR 352 353config NOMMU_INITIAL_TRIM_EXCESS 354 int "Turn on mmap() excess space trimming before booting" 355 depends on !MMU 356 default 1 357 help 358 The NOMMU mmap() frequently needs to allocate large contiguous chunks 359 of memory on which to store mappings, but it can only ask the system 360 allocator for chunks in 2^N*PAGE_SIZE amounts - which is frequently 361 more than it requires. To deal with this, mmap() is able to trim off 362 the excess and return it to the allocator. 363 364 If trimming is enabled, the excess is trimmed off and returned to the 365 system allocator, which can cause extra fragmentation, particularly 366 if there are a lot of transient processes. 367 368 If trimming is disabled, the excess is kept, but not used, which for 369 long-term mappings means that the space is wasted. 370 371 Trimming can be dynamically controlled through a sysctl option 372 (/proc/sys/vm/nr_trim_pages) which specifies the minimum number of 373 excess pages there must be before trimming should occur, or zero if 374 no trimming is to occur. 375 376 This option specifies the initial value of this option. The default 377 of 1 says that all excess pages should be trimmed. 378 379 See Documentation/admin-guide/mm/nommu-mmap.rst for more information. 380 381config TRANSPARENT_HUGEPAGE 382 bool "Transparent Hugepage Support" 383 depends on HAVE_ARCH_TRANSPARENT_HUGEPAGE && !PREEMPT_RT 384 select COMPACTION 385 select XARRAY_MULTI 386 help 387 Transparent Hugepages allows the kernel to use huge pages and 388 huge tlb transparently to the applications whenever possible. 389 This feature can improve computing performance to certain 390 applications by speeding up page faults during memory 391 allocation, by reducing the number of tlb misses and by speeding 392 up the pagetable walking. 393 394 If memory constrained on embedded, you may want to say N. 395 396choice 397 prompt "Transparent Hugepage Support sysfs defaults" 398 depends on TRANSPARENT_HUGEPAGE 399 default TRANSPARENT_HUGEPAGE_ALWAYS 400 help 401 Selects the sysfs defaults for Transparent Hugepage Support. 402 403 config TRANSPARENT_HUGEPAGE_ALWAYS 404 bool "always" 405 help 406 Enabling Transparent Hugepage always, can increase the 407 memory footprint of applications without a guaranteed 408 benefit but it will work automatically for all applications. 409 410 config TRANSPARENT_HUGEPAGE_MADVISE 411 bool "madvise" 412 help 413 Enabling Transparent Hugepage madvise, will only provide a 414 performance improvement benefit to the applications using 415 madvise(MADV_HUGEPAGE) but it won't risk to increase the 416 memory footprint of applications without a guaranteed 417 benefit. 418endchoice 419 420config ARCH_WANT_GENERAL_HUGETLB 421 bool 422 423config ARCH_WANTS_THP_SWAP 424 def_bool n 425 426config THP_SWAP 427 def_bool y 428 depends on TRANSPARENT_HUGEPAGE && ARCH_WANTS_THP_SWAP && SWAP 429 help 430 Swap transparent huge pages in one piece, without splitting. 431 XXX: For now, swap cluster backing transparent huge page 432 will be split after swapout. 433 434 For selection by architectures with reasonable THP sizes. 435 436# 437# UP and nommu archs use km based percpu allocator 438# 439config NEED_PER_CPU_KM 440 depends on !SMP || !MMU 441 bool 442 default y 443 444config NEED_PER_CPU_EMBED_FIRST_CHUNK 445 bool 446 447config NEED_PER_CPU_PAGE_FIRST_CHUNK 448 bool 449 450config USE_PERCPU_NUMA_NODE_ID 451 bool 452 453config HAVE_SETUP_PER_CPU_AREA 454 bool 455 456config FRONTSWAP 457 bool 458 459config CMA 460 bool "Contiguous Memory Allocator" 461 depends on MMU 462 select MIGRATION 463 select MEMORY_ISOLATION 464 help 465 This enables the Contiguous Memory Allocator which allows other 466 subsystems to allocate big physically-contiguous blocks of memory. 467 CMA reserves a region of memory and allows only movable pages to 468 be allocated from it. This way, the kernel can use the memory for 469 pagecache and when a subsystem requests for contiguous area, the 470 allocated pages are migrated away to serve the contiguous request. 471 472 If unsure, say "n". 473 474config CMA_DEBUG 475 bool "CMA debug messages (DEVELOPMENT)" 476 depends on DEBUG_KERNEL && CMA 477 help 478 Turns on debug messages in CMA. This produces KERN_DEBUG 479 messages for every CMA call as well as various messages while 480 processing calls such as dma_alloc_from_contiguous(). 481 This option does not affect warning and error messages. 482 483config CMA_DEBUGFS 484 bool "CMA debugfs interface" 485 depends on CMA && DEBUG_FS 486 help 487 Turns on the DebugFS interface for CMA. 488 489config CMA_SYSFS 490 bool "CMA information through sysfs interface" 491 depends on CMA && SYSFS 492 help 493 This option exposes some sysfs attributes to get information 494 from CMA. 495 496config CMA_AREAS 497 int "Maximum count of the CMA areas" 498 depends on CMA 499 default 19 if NUMA 500 default 7 501 help 502 CMA allows to create CMA areas for particular purpose, mainly, 503 used as device private area. This parameter sets the maximum 504 number of CMA area in the system. 505 506 If unsure, leave the default value "7" in UMA and "19" in NUMA. 507 508config MEM_SOFT_DIRTY 509 bool "Track memory changes" 510 depends on CHECKPOINT_RESTORE && HAVE_ARCH_SOFT_DIRTY && PROC_FS 511 select PROC_PAGE_MONITOR 512 help 513 This option enables memory changes tracking by introducing a 514 soft-dirty bit on pte-s. This bit it set when someone writes 515 into a page just as regular dirty bit, but unlike the latter 516 it can be cleared by hands. 517 518 See Documentation/admin-guide/mm/soft-dirty.rst for more details. 519 520config ZSWAP 521 bool "Compressed cache for swap pages (EXPERIMENTAL)" 522 depends on SWAP && CRYPTO=y 523 select FRONTSWAP 524 select ZPOOL 525 help 526 A lightweight compressed cache for swap pages. It takes 527 pages that are in the process of being swapped out and attempts to 528 compress them into a dynamically allocated RAM-based memory pool. 529 This can result in a significant I/O reduction on swap device and, 530 in the case where decompressing from RAM is faster that swap device 531 reads, can also improve workload performance. 532 533 This is marked experimental because it is a new feature (as of 534 v3.11) that interacts heavily with memory reclaim. While these 535 interactions don't cause any known issues on simple memory setups, 536 they have not be fully explored on the large set of potential 537 configurations and workloads that exist. 538 539choice 540 prompt "Compressed cache for swap pages default compressor" 541 depends on ZSWAP 542 default ZSWAP_COMPRESSOR_DEFAULT_LZO 543 help 544 Selects the default compression algorithm for the compressed cache 545 for swap pages. 546 547 For an overview what kind of performance can be expected from 548 a particular compression algorithm please refer to the benchmarks 549 available at the following LWN page: 550 https://lwn.net/Articles/751795/ 551 552 If in doubt, select 'LZO'. 553 554 The selection made here can be overridden by using the kernel 555 command line 'zswap.compressor=' option. 556 557config ZSWAP_COMPRESSOR_DEFAULT_DEFLATE 558 bool "Deflate" 559 select CRYPTO_DEFLATE 560 help 561 Use the Deflate algorithm as the default compression algorithm. 562 563config ZSWAP_COMPRESSOR_DEFAULT_LZO 564 bool "LZO" 565 select CRYPTO_LZO 566 help 567 Use the LZO algorithm as the default compression algorithm. 568 569config ZSWAP_COMPRESSOR_DEFAULT_842 570 bool "842" 571 select CRYPTO_842 572 help 573 Use the 842 algorithm as the default compression algorithm. 574 575config ZSWAP_COMPRESSOR_DEFAULT_LZ4 576 bool "LZ4" 577 select CRYPTO_LZ4 578 help 579 Use the LZ4 algorithm as the default compression algorithm. 580 581config ZSWAP_COMPRESSOR_DEFAULT_LZ4HC 582 bool "LZ4HC" 583 select CRYPTO_LZ4HC 584 help 585 Use the LZ4HC algorithm as the default compression algorithm. 586 587config ZSWAP_COMPRESSOR_DEFAULT_ZSTD 588 bool "zstd" 589 select CRYPTO_ZSTD 590 help 591 Use the zstd algorithm as the default compression algorithm. 592endchoice 593 594config ZSWAP_COMPRESSOR_DEFAULT 595 string 596 depends on ZSWAP 597 default "deflate" if ZSWAP_COMPRESSOR_DEFAULT_DEFLATE 598 default "lzo" if ZSWAP_COMPRESSOR_DEFAULT_LZO 599 default "842" if ZSWAP_COMPRESSOR_DEFAULT_842 600 default "lz4" if ZSWAP_COMPRESSOR_DEFAULT_LZ4 601 default "lz4hc" if ZSWAP_COMPRESSOR_DEFAULT_LZ4HC 602 default "zstd" if ZSWAP_COMPRESSOR_DEFAULT_ZSTD 603 default "" 604 605choice 606 prompt "Compressed cache for swap pages default allocator" 607 depends on ZSWAP 608 default ZSWAP_ZPOOL_DEFAULT_ZBUD 609 help 610 Selects the default allocator for the compressed cache for 611 swap pages. 612 The default is 'zbud' for compatibility, however please do 613 read the description of each of the allocators below before 614 making a right choice. 615 616 The selection made here can be overridden by using the kernel 617 command line 'zswap.zpool=' option. 618 619config ZSWAP_ZPOOL_DEFAULT_ZBUD 620 bool "zbud" 621 select ZBUD 622 help 623 Use the zbud allocator as the default allocator. 624 625config ZSWAP_ZPOOL_DEFAULT_Z3FOLD 626 bool "z3fold" 627 select Z3FOLD 628 help 629 Use the z3fold allocator as the default allocator. 630 631config ZSWAP_ZPOOL_DEFAULT_ZSMALLOC 632 bool "zsmalloc" 633 select ZSMALLOC 634 help 635 Use the zsmalloc allocator as the default allocator. 636endchoice 637 638config ZSWAP_ZPOOL_DEFAULT 639 string 640 depends on ZSWAP 641 default "zbud" if ZSWAP_ZPOOL_DEFAULT_ZBUD 642 default "z3fold" if ZSWAP_ZPOOL_DEFAULT_Z3FOLD 643 default "zsmalloc" if ZSWAP_ZPOOL_DEFAULT_ZSMALLOC 644 default "" 645 646config ZSWAP_DEFAULT_ON 647 bool "Enable the compressed cache for swap pages by default" 648 depends on ZSWAP 649 help 650 If selected, the compressed cache for swap pages will be enabled 651 at boot, otherwise it will be disabled. 652 653 The selection made here can be overridden by using the kernel 654 command line 'zswap.enabled=' option. 655 656config ZPOOL 657 tristate "Common API for compressed memory storage" 658 help 659 Compressed memory storage API. This allows using either zbud or 660 zsmalloc. 661 662config ZBUD 663 tristate "Low (Up to 2x) density storage for compressed pages" 664 depends on ZPOOL 665 help 666 A special purpose allocator for storing compressed pages. 667 It is designed to store up to two compressed pages per physical 668 page. While this design limits storage density, it has simple and 669 deterministic reclaim properties that make it preferable to a higher 670 density approach when reclaim will be used. 671 672config Z3FOLD 673 tristate "Up to 3x density storage for compressed pages" 674 depends on ZPOOL 675 help 676 A special purpose allocator for storing compressed pages. 677 It is designed to store up to three compressed pages per physical 678 page. It is a ZBUD derivative so the simplicity and determinism are 679 still there. 680 681config ZSMALLOC 682 tristate "Memory allocator for compressed pages" 683 depends on MMU 684 help 685 zsmalloc is a slab-based memory allocator designed to store 686 compressed RAM pages. zsmalloc uses virtual memory mapping 687 in order to reduce fragmentation. However, this results in a 688 non-standard allocator interface where a handle, not a pointer, is 689 returned by an alloc(). This handle must be mapped in order to 690 access the allocated space. 691 692config ZSMALLOC_STAT 693 bool "Export zsmalloc statistics" 694 depends on ZSMALLOC 695 select DEBUG_FS 696 help 697 This option enables code in the zsmalloc to collect various 698 statistics about what's happening in zsmalloc and exports that 699 information to userspace via debugfs. 700 If unsure, say N. 701 702config GENERIC_EARLY_IOREMAP 703 bool 704 705config STACK_MAX_DEFAULT_SIZE_MB 706 int "Default maximum user stack size for 32-bit processes (MB)" 707 default 100 708 range 8 2048 709 depends on STACK_GROWSUP && (!64BIT || COMPAT) 710 help 711 This is the maximum stack size in Megabytes in the VM layout of 32-bit 712 user processes when the stack grows upwards (currently only on parisc 713 arch) when the RLIMIT_STACK hard limit is unlimited. 714 715 A sane initial value is 100 MB. 716 717config DEFERRED_STRUCT_PAGE_INIT 718 bool "Defer initialisation of struct pages to kthreads" 719 depends on SPARSEMEM 720 depends on !NEED_PER_CPU_KM 721 depends on 64BIT 722 select PADATA 723 help 724 Ordinarily all struct pages are initialised during early boot in a 725 single thread. On very large machines this can take a considerable 726 amount of time. If this option is set, large machines will bring up 727 a subset of memmap at boot and then initialise the rest in parallel. 728 This has a potential performance impact on tasks running early in the 729 lifetime of the system until these kthreads finish the 730 initialisation. 731 732config PAGE_IDLE_FLAG 733 bool 734 select PAGE_EXTENSION if !64BIT 735 help 736 This adds PG_idle and PG_young flags to 'struct page'. PTE Accessed 737 bit writers can set the state of the bit in the flags so that PTE 738 Accessed bit readers may avoid disturbance. 739 740config IDLE_PAGE_TRACKING 741 bool "Enable idle page tracking" 742 depends on SYSFS && MMU 743 select PAGE_IDLE_FLAG 744 help 745 This feature allows to estimate the amount of user pages that have 746 not been touched during a given period of time. This information can 747 be useful to tune memory cgroup limits and/or for job placement 748 within a compute cluster. 749 750 See Documentation/admin-guide/mm/idle_page_tracking.rst for 751 more details. 752 753config ARCH_HAS_CACHE_LINE_SIZE 754 bool 755 756config ARCH_HAS_CURRENT_STACK_POINTER 757 bool 758 help 759 In support of HARDENED_USERCOPY performing stack variable lifetime 760 checking, an architecture-agnostic way to find the stack pointer 761 is needed. Once an architecture defines an unsigned long global 762 register alias named "current_stack_pointer", this config can be 763 selected. 764 765config ARCH_HAS_FILTER_PGPROT 766 bool 767 768config ARCH_HAS_PTE_DEVMAP 769 bool 770 771config ARCH_HAS_ZONE_DMA_SET 772 bool 773 774config ZONE_DMA 775 bool "Support DMA zone" if ARCH_HAS_ZONE_DMA_SET 776 default y if ARM64 || X86 777 778config ZONE_DMA32 779 bool "Support DMA32 zone" if ARCH_HAS_ZONE_DMA_SET 780 depends on !X86_32 781 default y if ARM64 782 783config ZONE_DEVICE 784 bool "Device memory (pmem, HMM, etc...) hotplug support" 785 depends on MEMORY_HOTPLUG 786 depends on MEMORY_HOTREMOVE 787 depends on SPARSEMEM_VMEMMAP 788 depends on ARCH_HAS_PTE_DEVMAP 789 select XARRAY_MULTI 790 791 help 792 Device memory hotplug support allows for establishing pmem, 793 or other device driver discovered memory regions, in the 794 memmap. This allows pfn_to_page() lookups of otherwise 795 "device-physical" addresses which is needed for using a DAX 796 mapping in an O_DIRECT operation, among other things. 797 798 If FS_DAX is enabled, then say Y. 799 800# 801# Helpers to mirror range of the CPU page tables of a process into device page 802# tables. 803# 804config HMM_MIRROR 805 bool 806 depends on MMU 807 808config DEVICE_PRIVATE 809 bool "Unaddressable device memory (GPU memory, ...)" 810 depends on ZONE_DEVICE 811 812 help 813 Allows creation of struct pages to represent unaddressable device 814 memory; i.e., memory that is only accessible from the device (or 815 group of devices). You likely also want to select HMM_MIRROR. 816 817config VMAP_PFN 818 bool 819 820config ARCH_USES_HIGH_VMA_FLAGS 821 bool 822config ARCH_HAS_PKEYS 823 bool 824 825config PERCPU_STATS 826 bool "Collect percpu memory statistics" 827 help 828 This feature collects and exposes statistics via debugfs. The 829 information includes global and per chunk statistics, which can 830 be used to help understand percpu memory usage. 831 832config GUP_TEST 833 bool "Enable infrastructure for get_user_pages()-related unit tests" 834 depends on DEBUG_FS 835 help 836 Provides /sys/kernel/debug/gup_test, which in turn provides a way 837 to make ioctl calls that can launch kernel-based unit tests for 838 the get_user_pages*() and pin_user_pages*() family of API calls. 839 840 These tests include benchmark testing of the _fast variants of 841 get_user_pages*() and pin_user_pages*(), as well as smoke tests of 842 the non-_fast variants. 843 844 There is also a sub-test that allows running dump_page() on any 845 of up to eight pages (selected by command line args) within the 846 range of user-space addresses. These pages are either pinned via 847 pin_user_pages*(), or pinned via get_user_pages*(), as specified 848 by other command line arguments. 849 850 See tools/testing/selftests/vm/gup_test.c 851 852comment "GUP_TEST needs to have DEBUG_FS enabled" 853 depends on !GUP_TEST && !DEBUG_FS 854 855config GUP_GET_PTE_LOW_HIGH 856 bool 857 858config READ_ONLY_THP_FOR_FS 859 bool "Read-only THP for filesystems (EXPERIMENTAL)" 860 depends on TRANSPARENT_HUGEPAGE && SHMEM 861 862 help 863 Allow khugepaged to put read-only file-backed pages in THP. 864 865 This is marked experimental because it is a new feature. Write 866 support of file THPs will be developed in the next few release 867 cycles. 868 869config ARCH_HAS_PTE_SPECIAL 870 bool 871 872# 873# Some architectures require a special hugepage directory format that is 874# required to support multiple hugepage sizes. For example a4fe3ce76 875# "powerpc/mm: Allow more flexible layouts for hugepage pagetables" 876# introduced it on powerpc. This allows for a more flexible hugepage 877# pagetable layouts. 878# 879config ARCH_HAS_HUGEPD 880 bool 881 882config MAPPING_DIRTY_HELPERS 883 bool 884 885config KMAP_LOCAL 886 bool 887 888config KMAP_LOCAL_NON_LINEAR_PTE_ARRAY 889 bool 890 891# struct io_mapping based helper. Selected by drivers that need them 892config IO_MAPPING 893 bool 894 895config SECRETMEM 896 def_bool ARCH_HAS_SET_DIRECT_MAP && !EMBEDDED 897 898config ANON_VMA_NAME 899 bool "Anonymous VMA name support" 900 depends on PROC_FS && ADVISE_SYSCALLS && MMU 901 902 help 903 Allow naming anonymous virtual memory areas. 904 905 This feature allows assigning names to virtual memory areas. Assigned 906 names can be later retrieved from /proc/pid/maps and /proc/pid/smaps 907 and help identifying individual anonymous memory areas. 908 Assigning a name to anonymous virtual memory area might prevent that 909 area from being merged with adjacent virtual memory areas due to the 910 difference in their name. 911 912source "mm/damon/Kconfig" 913 914endmenu 915