1 # SPDX-License-Identifier: GPL-2.0-only
3 menu "Memory Management options"
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.
16 bool "Support for paging of anonymous memory (swap)"
17 depends on MMU && BLOCK && !ARCH_NO_SWAP
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.
26 bool "Compressed cache for swap pages (EXPERIMENTAL)"
32 A lightweight compressed cache for swap pages. It takes
33 pages that are in the process of being swapped out and attempts to
34 compress them into a dynamically allocated RAM-based memory pool.
35 This can result in a significant I/O reduction on swap device and,
36 in the case where decompressing from RAM is faster that swap device
37 reads, can also improve workload performance.
39 This is marked experimental because it is a new feature (as of
40 v3.11) that interacts heavily with memory reclaim. While these
41 interactions don't cause any known issues on simple memory setups,
42 they have not be fully explored on the large set of potential
43 configurations and workloads that exist.
45 config ZSWAP_DEFAULT_ON
46 bool "Enable the compressed cache for swap pages by default"
49 If selected, the compressed cache for swap pages will be enabled
50 at boot, otherwise it will be disabled.
52 The selection made here can be overridden by using the kernel
53 command line 'zswap.enabled=' option.
56 prompt "Default compressor"
58 default ZSWAP_COMPRESSOR_DEFAULT_LZO
60 Selects the default compression algorithm for the compressed cache
63 For an overview what kind of performance can be expected from
64 a particular compression algorithm please refer to the benchmarks
65 available at the following LWN page:
66 https://lwn.net/Articles/751795/
68 If in doubt, select 'LZO'.
70 The selection made here can be overridden by using the kernel
71 command line 'zswap.compressor=' option.
73 config ZSWAP_COMPRESSOR_DEFAULT_DEFLATE
77 Use the Deflate algorithm as the default compression algorithm.
79 config ZSWAP_COMPRESSOR_DEFAULT_LZO
83 Use the LZO algorithm as the default compression algorithm.
85 config ZSWAP_COMPRESSOR_DEFAULT_842
89 Use the 842 algorithm as the default compression algorithm.
91 config ZSWAP_COMPRESSOR_DEFAULT_LZ4
95 Use the LZ4 algorithm as the default compression algorithm.
97 config ZSWAP_COMPRESSOR_DEFAULT_LZ4HC
101 Use the LZ4HC algorithm as the default compression algorithm.
103 config ZSWAP_COMPRESSOR_DEFAULT_ZSTD
107 Use the zstd algorithm as the default compression algorithm.
110 config ZSWAP_COMPRESSOR_DEFAULT
113 default "deflate" if ZSWAP_COMPRESSOR_DEFAULT_DEFLATE
114 default "lzo" if ZSWAP_COMPRESSOR_DEFAULT_LZO
115 default "842" if ZSWAP_COMPRESSOR_DEFAULT_842
116 default "lz4" if ZSWAP_COMPRESSOR_DEFAULT_LZ4
117 default "lz4hc" if ZSWAP_COMPRESSOR_DEFAULT_LZ4HC
118 default "zstd" if ZSWAP_COMPRESSOR_DEFAULT_ZSTD
122 prompt "Default allocator"
124 default ZSWAP_ZPOOL_DEFAULT_ZBUD
126 Selects the default allocator for the compressed cache for
128 The default is 'zbud' for compatibility, however please do
129 read the description of each of the allocators below before
130 making a right choice.
132 The selection made here can be overridden by using the kernel
133 command line 'zswap.zpool=' option.
135 config ZSWAP_ZPOOL_DEFAULT_ZBUD
139 Use the zbud allocator as the default allocator.
141 config ZSWAP_ZPOOL_DEFAULT_Z3FOLD
145 Use the z3fold allocator as the default allocator.
147 config ZSWAP_ZPOOL_DEFAULT_ZSMALLOC
151 Use the zsmalloc allocator as the default allocator.
154 config ZSWAP_ZPOOL_DEFAULT
157 default "zbud" if ZSWAP_ZPOOL_DEFAULT_ZBUD
158 default "z3fold" if ZSWAP_ZPOOL_DEFAULT_Z3FOLD
159 default "zsmalloc" if ZSWAP_ZPOOL_DEFAULT_ZSMALLOC
163 tristate "2:1 compression allocator (zbud)"
166 A special purpose allocator for storing compressed pages.
167 It is designed to store up to two compressed pages per physical
168 page. While this design limits storage density, it has simple and
169 deterministic reclaim properties that make it preferable to a higher
170 density approach when reclaim will be used.
173 tristate "3:1 compression allocator (z3fold)"
176 A special purpose allocator for storing compressed pages.
177 It is designed to store up to three compressed pages per physical
178 page. It is a ZBUD derivative so the simplicity and determinism are
183 prompt "N:1 compression allocator (zsmalloc)" if ZSWAP
186 zsmalloc is a slab-based memory allocator designed to store
187 pages of various compression levels efficiently. It achieves
188 the highest storage density with the least amount of fragmentation.
191 bool "Export zsmalloc statistics"
195 This option enables code in the zsmalloc to collect various
196 statistics about what's happening in zsmalloc and exports that
197 information to userspace via debugfs.
200 menu "SLAB allocator options"
203 prompt "Choose SLAB allocator"
206 This option allows to select a slab allocator.
210 depends on !PREEMPT_RT
211 select HAVE_HARDENED_USERCOPY_ALLOCATOR
213 The regular slab allocator that is established and known to work
214 well in all environments. It organizes cache hot objects in
215 per cpu and per node queues.
218 bool "SLUB (Unqueued Allocator)"
219 select HAVE_HARDENED_USERCOPY_ALLOCATOR
221 SLUB is a slab allocator that minimizes cache line usage
222 instead of managing queues of cached objects (SLAB approach).
223 Per cpu caching is realized using slabs of objects instead
224 of queues of objects. SLUB can use memory efficiently
225 and has enhanced diagnostics. SLUB is the default choice for
230 bool "SLOB (Simple Allocator)"
231 depends on !PREEMPT_RT
233 SLOB replaces the stock allocator with a drastically simpler
234 allocator. SLOB is generally more space efficient but
235 does not perform as well on large systems.
239 config SLAB_MERGE_DEFAULT
240 bool "Allow slab caches to be merged"
242 depends on SLAB || SLUB
244 For reduced kernel memory fragmentation, slab caches can be
245 merged when they share the same size and other characteristics.
246 This carries a risk of kernel heap overflows being able to
247 overwrite objects from merged caches (and more easily control
248 cache layout), which makes such heap attacks easier to exploit
249 by attackers. By keeping caches unmerged, these kinds of exploits
250 can usually only damage objects in the same cache. To disable
251 merging at runtime, "slab_nomerge" can be passed on the kernel
254 config SLAB_FREELIST_RANDOM
255 bool "Randomize slab freelist"
256 depends on SLAB || SLUB
258 Randomizes the freelist order used on creating new pages. This
259 security feature reduces the predictability of the kernel slab
260 allocator against heap overflows.
262 config SLAB_FREELIST_HARDENED
263 bool "Harden slab freelist metadata"
264 depends on SLAB || SLUB
266 Many kernel heap attacks try to target slab cache metadata and
267 other infrastructure. This options makes minor performance
268 sacrifices to harden the kernel slab allocator against common
269 freelist exploit methods. Some slab implementations have more
270 sanity-checking than others. This option is most effective with
273 config SLUB_CPU_PARTIAL
275 depends on SLUB && SMP
276 bool "SLUB per cpu partial cache"
278 Per cpu partial caches accelerate objects allocation and freeing
279 that is local to a processor at the price of more indeterminism
280 in the latency of the free. On overflow these caches will be cleared
281 which requires the taking of locks that may cause latency spikes.
282 Typically one would choose no for a realtime system.
284 endmenu # SLAB allocator options
286 config SHUFFLE_PAGE_ALLOCATOR
287 bool "Page allocator randomization"
288 default SLAB_FREELIST_RANDOM && ACPI_NUMA
290 Randomization of the page allocator improves the average
291 utilization of a direct-mapped memory-side-cache. See section
292 5.2.27 Heterogeneous Memory Attribute Table (HMAT) in the ACPI
293 6.2a specification for an example of how a platform advertises
294 the presence of a memory-side-cache. There are also incidental
295 security benefits as it reduces the predictability of page
296 allocations to compliment SLAB_FREELIST_RANDOM, but the
297 default granularity of shuffling on the "MAX_ORDER - 1" i.e,
298 10th order of pages is selected based on cache utilization
301 While the randomization improves cache utilization it may
302 negatively impact workloads on platforms without a cache. For
303 this reason, by default, the randomization is enabled only
304 after runtime detection of a direct-mapped memory-side-cache.
305 Otherwise, the randomization may be force enabled with the
306 'page_alloc.shuffle' kernel command line parameter.
310 config SELECT_MEMORY_MODEL
312 depends on ARCH_SELECT_MEMORY_MODEL
315 prompt "Memory model"
316 depends on SELECT_MEMORY_MODEL
317 default SPARSEMEM_MANUAL if ARCH_SPARSEMEM_DEFAULT
318 default FLATMEM_MANUAL
320 This option allows you to change some of the ways that
321 Linux manages its memory internally. Most users will
322 only have one option here selected by the architecture
323 configuration. This is normal.
325 config FLATMEM_MANUAL
327 depends on !ARCH_SPARSEMEM_ENABLE || ARCH_FLATMEM_ENABLE
329 This option is best suited for non-NUMA systems with
330 flat address space. The FLATMEM is the most efficient
331 system in terms of performance and resource consumption
332 and it is the best option for smaller systems.
334 For systems that have holes in their physical address
335 spaces and for features like NUMA and memory hotplug,
336 choose "Sparse Memory".
338 If unsure, choose this option (Flat Memory) over any other.
340 config SPARSEMEM_MANUAL
342 depends on ARCH_SPARSEMEM_ENABLE
344 This will be the only option for some systems, including
345 memory hot-plug systems. This is normal.
347 This option provides efficient support for systems with
348 holes is their physical address space and allows memory
349 hot-plug and hot-remove.
351 If unsure, choose "Flat Memory" over this option.
357 depends on (!SELECT_MEMORY_MODEL && ARCH_SPARSEMEM_ENABLE) || SPARSEMEM_MANUAL
361 depends on !SPARSEMEM || FLATMEM_MANUAL
364 # SPARSEMEM_EXTREME (which is the default) does some bootmem
365 # allocations when sparse_init() is called. If this cannot
366 # be done on your architecture, select this option. However,
367 # statically allocating the mem_section[] array can potentially
368 # consume vast quantities of .bss, so be careful.
370 # This option will also potentially produce smaller runtime code
371 # with gcc 3.4 and later.
373 config SPARSEMEM_STATIC
377 # Architecture platforms which require a two level mem_section in SPARSEMEM
378 # must select this option. This is usually for architecture platforms with
379 # an extremely sparse physical address space.
381 config SPARSEMEM_EXTREME
383 depends on SPARSEMEM && !SPARSEMEM_STATIC
385 config SPARSEMEM_VMEMMAP_ENABLE
388 config SPARSEMEM_VMEMMAP
389 bool "Sparse Memory virtual memmap"
390 depends on SPARSEMEM && SPARSEMEM_VMEMMAP_ENABLE
393 SPARSEMEM_VMEMMAP uses a virtually mapped memmap to optimise
394 pfn_to_page and page_to_pfn operations. This is the most
395 efficient option when sufficient kernel resources are available.
397 config HAVE_MEMBLOCK_PHYS_MAP
404 # Don't discard allocated memory used to track "memory" and "reserved" memblocks
405 # after early boot, so it can still be used to test for validity of memory.
406 # Also, memblocks are updated with memory hot(un)plug.
407 config ARCH_KEEP_MEMBLOCK
410 # Keep arch NUMA mapping infrastructure post-init.
411 config NUMA_KEEP_MEMINFO
414 config MEMORY_ISOLATION
417 # IORESOURCE_SYSTEM_RAM regions in the kernel resource tree that are marked
418 # IORESOURCE_EXCLUSIVE cannot be mapped to user space, for example, via
420 config EXCLUSIVE_SYSTEM_RAM
422 depends on !DEVMEM || STRICT_DEVMEM
425 # Only be set on architectures that have completely implemented memory hotplug
426 # feature. If you are not sure, don't touch it.
428 config HAVE_BOOTMEM_INFO_NODE
431 config ARCH_ENABLE_MEMORY_HOTPLUG
434 config ARCH_ENABLE_MEMORY_HOTREMOVE
437 # eventually, we can have this option just 'select SPARSEMEM'
438 menuconfig MEMORY_HOTPLUG
439 bool "Memory hotplug"
440 select MEMORY_ISOLATION
442 depends on ARCH_ENABLE_MEMORY_HOTPLUG
444 select NUMA_KEEP_MEMINFO if NUMA
448 config MEMORY_HOTPLUG_DEFAULT_ONLINE
449 bool "Online the newly added memory blocks by default"
450 depends on MEMORY_HOTPLUG
452 This option sets the default policy setting for memory hotplug
453 onlining policy (/sys/devices/system/memory/auto_online_blocks) which
454 determines what happens to newly added memory regions. Policy setting
455 can always be changed at runtime.
456 See Documentation/admin-guide/mm/memory-hotplug.rst for more information.
458 Say Y here if you want all hot-plugged memory blocks to appear in
459 'online' state by default.
460 Say N here if you want the default policy to keep all hot-plugged
461 memory blocks in 'offline' state.
463 config MEMORY_HOTREMOVE
464 bool "Allow for memory hot remove"
465 select HAVE_BOOTMEM_INFO_NODE if (X86_64 || PPC64)
466 depends on MEMORY_HOTPLUG && ARCH_ENABLE_MEMORY_HOTREMOVE
469 config MHP_MEMMAP_ON_MEMORY
471 depends on MEMORY_HOTPLUG && SPARSEMEM_VMEMMAP
472 depends on ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE
474 endif # MEMORY_HOTPLUG
476 # Heavily threaded applications may benefit from splitting the mm-wide
477 # page_table_lock, so that faults on different parts of the user address
478 # space can be handled with less contention: split it at this NR_CPUS.
479 # Default to 4 for wider testing, though 8 might be more appropriate.
480 # ARM's adjust_pte (unused if VIPT) depends on mm-wide page_table_lock.
481 # PA-RISC 7xxx's spinlock_t would enlarge struct page from 32 to 44 bytes.
482 # SPARC32 allocates multiple pte tables within a single page, and therefore
483 # a per-page lock leads to problems when multiple tables need to be locked
484 # at the same time (e.g. copy_page_range()).
485 # DEBUG_SPINLOCK and DEBUG_LOCK_ALLOC spinlock_t also enlarge struct page.
487 config SPLIT_PTLOCK_CPUS
489 default "999999" if !MMU
490 default "999999" if ARM && !CPU_CACHE_VIPT
491 default "999999" if PARISC && !PA20
492 default "999999" if SPARC32
495 config ARCH_ENABLE_SPLIT_PMD_PTLOCK
499 # support for memory balloon
500 config MEMORY_BALLOON
504 # support for memory balloon compaction
505 config BALLOON_COMPACTION
506 bool "Allow for balloon memory compaction/migration"
508 depends on COMPACTION && MEMORY_BALLOON
510 Memory fragmentation introduced by ballooning might reduce
511 significantly the number of 2MB contiguous memory blocks that can be
512 used within a guest, thus imposing performance penalties associated
513 with the reduced number of transparent huge pages that could be used
514 by the guest workload. Allowing the compaction & migration for memory
515 pages enlisted as being part of memory balloon devices avoids the
516 scenario aforementioned and helps improving memory defragmentation.
519 # support for memory compaction
521 bool "Allow for memory compaction"
526 Compaction is the only memory management component to form
527 high order (larger physically contiguous) memory blocks
528 reliably. The page allocator relies on compaction heavily and
529 the lack of the feature can lead to unexpected OOM killer
530 invocations for high order memory requests. You shouldn't
531 disable this option unless there really is a strong reason for
532 it and then we would be really interested to hear about that at
536 # support for free page reporting
537 config PAGE_REPORTING
538 bool "Free page reporting"
541 Free page reporting allows for the incremental acquisition of
542 free pages from the buddy allocator for the purpose of reporting
543 those pages to another entity, such as a hypervisor, so that the
544 memory can be freed within the host for other uses.
547 # support for page migration
550 bool "Page migration"
552 depends on (NUMA || ARCH_ENABLE_MEMORY_HOTREMOVE || COMPACTION || CMA) && MMU
554 Allows the migration of the physical location of pages of processes
555 while the virtual addresses are not changed. This is useful in
556 two situations. The first is on NUMA systems to put pages nearer
557 to the processors accessing. The second is when allocating huge
558 pages as migration can relocate pages to satisfy a huge page
559 allocation instead of reclaiming.
561 config DEVICE_MIGRATION
562 def_bool MIGRATION && ZONE_DEVICE
564 config ARCH_ENABLE_HUGEPAGE_MIGRATION
567 config ARCH_ENABLE_THP_MIGRATION
570 config HUGETLB_PAGE_SIZE_VARIABLE
573 Allows the pageblock_order value to be dynamic instead of just standard
574 HUGETLB_PAGE_ORDER when there are multiple HugeTLB page sizes available
577 Note that the pageblock_order cannot exceed MAX_ORDER - 1 and will be
578 clamped down to MAX_ORDER - 1.
581 def_bool (MEMORY_ISOLATION && COMPACTION) || CMA
583 config PHYS_ADDR_T_64BIT
587 bool "Enable bounce buffers"
589 depends on BLOCK && MMU && HIGHMEM
591 Enable bounce buffers for devices that cannot access the full range of
592 memory available to the CPU. Enabled by default when HIGHMEM is
593 selected, but you may say n to override this.
598 An architecture should select this if it implements the
599 deprecated interface virt_to_bus(). All new architectures
600 should probably not select this.
609 bool "Enable KSM for page merging"
613 Enable Kernel Samepage Merging: KSM periodically scans those areas
614 of an application's address space that an app has advised may be
615 mergeable. When it finds pages of identical content, it replaces
616 the many instances by a single page with that content, so
617 saving memory until one or another app needs to modify the content.
618 Recommended for use with KVM, or with other duplicative applications.
619 See Documentation/vm/ksm.rst for more information: KSM is inactive
620 until a program has madvised that an area is MADV_MERGEABLE, and
621 root has set /sys/kernel/mm/ksm/run to 1 (if CONFIG_SYSFS is set).
623 config DEFAULT_MMAP_MIN_ADDR
624 int "Low address space to protect from user allocation"
628 This is the portion of low virtual memory which should be protected
629 from userspace allocation. Keeping a user from writing to low pages
630 can help reduce the impact of kernel NULL pointer bugs.
632 For most ia64, ppc64 and x86 users with lots of address space
633 a value of 65536 is reasonable and should cause no problems.
634 On arm and other archs it should not be higher than 32768.
635 Programs which use vm86 functionality or have some need to map
636 this low address space will need CAP_SYS_RAWIO or disable this
637 protection by setting the value to 0.
639 This value can be changed after boot using the
640 /proc/sys/vm/mmap_min_addr tunable.
642 config ARCH_SUPPORTS_MEMORY_FAILURE
645 config MEMORY_FAILURE
647 depends on ARCH_SUPPORTS_MEMORY_FAILURE
648 bool "Enable recovery from hardware memory errors"
649 select MEMORY_ISOLATION
652 Enables code to recover from some memory failures on systems
653 with MCA recovery. This allows a system to continue running
654 even when some of its memory has uncorrected errors. This requires
655 special hardware support and typically ECC memory.
657 config HWPOISON_INJECT
658 tristate "HWPoison pages injector"
659 depends on MEMORY_FAILURE && DEBUG_KERNEL && PROC_FS
660 select PROC_PAGE_MONITOR
662 config NOMMU_INITIAL_TRIM_EXCESS
663 int "Turn on mmap() excess space trimming before booting"
667 The NOMMU mmap() frequently needs to allocate large contiguous chunks
668 of memory on which to store mappings, but it can only ask the system
669 allocator for chunks in 2^N*PAGE_SIZE amounts - which is frequently
670 more than it requires. To deal with this, mmap() is able to trim off
671 the excess and return it to the allocator.
673 If trimming is enabled, the excess is trimmed off and returned to the
674 system allocator, which can cause extra fragmentation, particularly
675 if there are a lot of transient processes.
677 If trimming is disabled, the excess is kept, but not used, which for
678 long-term mappings means that the space is wasted.
680 Trimming can be dynamically controlled through a sysctl option
681 (/proc/sys/vm/nr_trim_pages) which specifies the minimum number of
682 excess pages there must be before trimming should occur, or zero if
683 no trimming is to occur.
685 This option specifies the initial value of this option. The default
686 of 1 says that all excess pages should be trimmed.
688 See Documentation/admin-guide/mm/nommu-mmap.rst for more information.
690 config ARCH_WANT_GENERAL_HUGETLB
693 config ARCH_WANTS_THP_SWAP
696 menuconfig TRANSPARENT_HUGEPAGE
697 bool "Transparent Hugepage Support"
698 depends on HAVE_ARCH_TRANSPARENT_HUGEPAGE && !PREEMPT_RT
702 Transparent Hugepages allows the kernel to use huge pages and
703 huge tlb transparently to the applications whenever possible.
704 This feature can improve computing performance to certain
705 applications by speeding up page faults during memory
706 allocation, by reducing the number of tlb misses and by speeding
707 up the pagetable walking.
709 If memory constrained on embedded, you may want to say N.
711 if TRANSPARENT_HUGEPAGE
714 prompt "Transparent Hugepage Support sysfs defaults"
715 depends on TRANSPARENT_HUGEPAGE
716 default TRANSPARENT_HUGEPAGE_ALWAYS
718 Selects the sysfs defaults for Transparent Hugepage Support.
720 config TRANSPARENT_HUGEPAGE_ALWAYS
723 Enabling Transparent Hugepage always, can increase the
724 memory footprint of applications without a guaranteed
725 benefit but it will work automatically for all applications.
727 config TRANSPARENT_HUGEPAGE_MADVISE
730 Enabling Transparent Hugepage madvise, will only provide a
731 performance improvement benefit to the applications using
732 madvise(MADV_HUGEPAGE) but it won't risk to increase the
733 memory footprint of applications without a guaranteed
739 depends on TRANSPARENT_HUGEPAGE && ARCH_WANTS_THP_SWAP && SWAP
741 Swap transparent huge pages in one piece, without splitting.
742 XXX: For now, swap cluster backing transparent huge page
743 will be split after swapout.
745 For selection by architectures with reasonable THP sizes.
747 config READ_ONLY_THP_FOR_FS
748 bool "Read-only THP for filesystems (EXPERIMENTAL)"
749 depends on TRANSPARENT_HUGEPAGE && SHMEM
752 Allow khugepaged to put read-only file-backed pages in THP.
754 This is marked experimental because it is a new feature. Write
755 support of file THPs will be developed in the next few release
758 endif # TRANSPARENT_HUGEPAGE
761 # UP and nommu archs use km based percpu allocator
763 config NEED_PER_CPU_KM
764 depends on !SMP || !MMU
768 config NEED_PER_CPU_EMBED_FIRST_CHUNK
771 config NEED_PER_CPU_PAGE_FIRST_CHUNK
774 config USE_PERCPU_NUMA_NODE_ID
777 config HAVE_SETUP_PER_CPU_AREA
784 bool "Contiguous Memory Allocator"
787 select MEMORY_ISOLATION
789 This enables the Contiguous Memory Allocator which allows other
790 subsystems to allocate big physically-contiguous blocks of memory.
791 CMA reserves a region of memory and allows only movable pages to
792 be allocated from it. This way, the kernel can use the memory for
793 pagecache and when a subsystem requests for contiguous area, the
794 allocated pages are migrated away to serve the contiguous request.
799 bool "CMA debug messages (DEVELOPMENT)"
800 depends on DEBUG_KERNEL && CMA
802 Turns on debug messages in CMA. This produces KERN_DEBUG
803 messages for every CMA call as well as various messages while
804 processing calls such as dma_alloc_from_contiguous().
805 This option does not affect warning and error messages.
808 bool "CMA debugfs interface"
809 depends on CMA && DEBUG_FS
811 Turns on the DebugFS interface for CMA.
814 bool "CMA information through sysfs interface"
815 depends on CMA && SYSFS
817 This option exposes some sysfs attributes to get information
821 int "Maximum count of the CMA areas"
826 CMA allows to create CMA areas for particular purpose, mainly,
827 used as device private area. This parameter sets the maximum
828 number of CMA area in the system.
830 If unsure, leave the default value "7" in UMA and "19" in NUMA.
832 config MEM_SOFT_DIRTY
833 bool "Track memory changes"
834 depends on CHECKPOINT_RESTORE && HAVE_ARCH_SOFT_DIRTY && PROC_FS
835 select PROC_PAGE_MONITOR
837 This option enables memory changes tracking by introducing a
838 soft-dirty bit on pte-s. This bit it set when someone writes
839 into a page just as regular dirty bit, but unlike the latter
840 it can be cleared by hands.
842 See Documentation/admin-guide/mm/soft-dirty.rst for more details.
844 config GENERIC_EARLY_IOREMAP
847 config STACK_MAX_DEFAULT_SIZE_MB
848 int "Default maximum user stack size for 32-bit processes (MB)"
851 depends on STACK_GROWSUP && (!64BIT || COMPAT)
853 This is the maximum stack size in Megabytes in the VM layout of 32-bit
854 user processes when the stack grows upwards (currently only on parisc
855 arch) when the RLIMIT_STACK hard limit is unlimited.
857 A sane initial value is 100 MB.
859 config DEFERRED_STRUCT_PAGE_INIT
860 bool "Defer initialisation of struct pages to kthreads"
862 depends on !NEED_PER_CPU_KM
866 Ordinarily all struct pages are initialised during early boot in a
867 single thread. On very large machines this can take a considerable
868 amount of time. If this option is set, large machines will bring up
869 a subset of memmap at boot and then initialise the rest in parallel.
870 This has a potential performance impact on tasks running early in the
871 lifetime of the system until these kthreads finish the
874 config PAGE_IDLE_FLAG
876 select PAGE_EXTENSION if !64BIT
878 This adds PG_idle and PG_young flags to 'struct page'. PTE Accessed
879 bit writers can set the state of the bit in the flags so that PTE
880 Accessed bit readers may avoid disturbance.
882 config IDLE_PAGE_TRACKING
883 bool "Enable idle page tracking"
884 depends on SYSFS && MMU
885 select PAGE_IDLE_FLAG
887 This feature allows to estimate the amount of user pages that have
888 not been touched during a given period of time. This information can
889 be useful to tune memory cgroup limits and/or for job placement
890 within a compute cluster.
892 See Documentation/admin-guide/mm/idle_page_tracking.rst for
895 config ARCH_HAS_CACHE_LINE_SIZE
898 config ARCH_HAS_CURRENT_STACK_POINTER
901 In support of HARDENED_USERCOPY performing stack variable lifetime
902 checking, an architecture-agnostic way to find the stack pointer
903 is needed. Once an architecture defines an unsigned long global
904 register alias named "current_stack_pointer", this config can be
907 config ARCH_HAS_VM_GET_PAGE_PROT
910 config ARCH_HAS_PTE_DEVMAP
913 config ARCH_HAS_ZONE_DMA_SET
917 bool "Support DMA zone" if ARCH_HAS_ZONE_DMA_SET
918 default y if ARM64 || X86
921 bool "Support DMA32 zone" if ARCH_HAS_ZONE_DMA_SET
926 bool "Device memory (pmem, HMM, etc...) hotplug support"
927 depends on MEMORY_HOTPLUG
928 depends on MEMORY_HOTREMOVE
929 depends on SPARSEMEM_VMEMMAP
930 depends on ARCH_HAS_PTE_DEVMAP
934 Device memory hotplug support allows for establishing pmem,
935 or other device driver discovered memory regions, in the
936 memmap. This allows pfn_to_page() lookups of otherwise
937 "device-physical" addresses which is needed for using a DAX
938 mapping in an O_DIRECT operation, among other things.
940 If FS_DAX is enabled, then say Y.
943 # Helpers to mirror range of the CPU page tables of a process into device page
950 config DEVICE_PRIVATE
951 bool "Unaddressable device memory (GPU memory, ...)"
952 depends on ZONE_DEVICE
955 Allows creation of struct pages to represent unaddressable device
956 memory; i.e., memory that is only accessible from the device (or
957 group of devices). You likely also want to select HMM_MIRROR.
962 config ARCH_USES_HIGH_VMA_FLAGS
964 config ARCH_HAS_PKEYS
968 bool "Collect percpu memory statistics"
970 This feature collects and exposes statistics via debugfs. The
971 information includes global and per chunk statistics, which can
972 be used to help understand percpu memory usage.
975 bool "Enable infrastructure for get_user_pages()-related unit tests"
978 Provides /sys/kernel/debug/gup_test, which in turn provides a way
979 to make ioctl calls that can launch kernel-based unit tests for
980 the get_user_pages*() and pin_user_pages*() family of API calls.
982 These tests include benchmark testing of the _fast variants of
983 get_user_pages*() and pin_user_pages*(), as well as smoke tests of
984 the non-_fast variants.
986 There is also a sub-test that allows running dump_page() on any
987 of up to eight pages (selected by command line args) within the
988 range of user-space addresses. These pages are either pinned via
989 pin_user_pages*(), or pinned via get_user_pages*(), as specified
990 by other command line arguments.
992 See tools/testing/selftests/vm/gup_test.c
994 comment "GUP_TEST needs to have DEBUG_FS enabled"
995 depends on !GUP_TEST && !DEBUG_FS
997 config GUP_GET_PTE_LOW_HIGH
1000 config ARCH_HAS_PTE_SPECIAL
1004 # Some architectures require a special hugepage directory format that is
1005 # required to support multiple hugepage sizes. For example a4fe3ce76
1006 # "powerpc/mm: Allow more flexible layouts for hugepage pagetables"
1007 # introduced it on powerpc. This allows for a more flexible hugepage
1008 # pagetable layouts.
1010 config ARCH_HAS_HUGEPD
1013 config MAPPING_DIRTY_HELPERS
1019 config KMAP_LOCAL_NON_LINEAR_PTE_ARRAY
1022 # struct io_mapping based helper. Selected by drivers that need them
1027 def_bool ARCH_HAS_SET_DIRECT_MAP && !EMBEDDED
1029 config ANON_VMA_NAME
1030 bool "Anonymous VMA name support"
1031 depends on PROC_FS && ADVISE_SYSCALLS && MMU
1034 Allow naming anonymous virtual memory areas.
1036 This feature allows assigning names to virtual memory areas. Assigned
1037 names can be later retrieved from /proc/pid/maps and /proc/pid/smaps
1038 and help identifying individual anonymous memory areas.
1039 Assigning a name to anonymous virtual memory area might prevent that
1040 area from being merged with adjacent virtual memory areas due to the
1041 difference in their name.
1044 bool "Enable userfaultfd() system call"
1047 Enable the userfaultfd() system call that allows to intercept and
1048 handle page faults in userland.
1050 config HAVE_ARCH_USERFAULTFD_WP
1053 Arch has userfaultfd write protection support
1055 config HAVE_ARCH_USERFAULTFD_MINOR
1058 Arch has userfaultfd minor fault support
1064 Allows to create marker PTEs for file-backed memory.
1066 config PTE_MARKER_UFFD_WP
1067 bool "Userfaultfd write protection support for shmem/hugetlbfs"
1069 depends on HAVE_ARCH_USERFAULTFD_WP
1073 Allows to create marker PTEs for userfaultfd write protection
1074 purposes. It is required to enable userfaultfd write protection on
1075 file-backed memory types like shmem and hugetlbfs.
1077 source "mm/damon/Kconfig"