1 # SPDX-License-Identifier: GPL-2.0-only
3 menu "Memory Management options"
5 config SELECT_MEMORY_MODEL
7 depends on ARCH_SELECT_MEMORY_MODEL
11 depends on SELECT_MEMORY_MODEL
12 default SPARSEMEM_MANUAL if ARCH_SPARSEMEM_DEFAULT
13 default FLATMEM_MANUAL
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.
22 depends on !ARCH_SPARSEMEM_ENABLE || ARCH_FLATMEM_ENABLE
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.
29 For systems that have holes in their physical address
30 spaces and for features like NUMA and memory hotplug,
31 choose "Sparse Memory".
33 If unsure, choose this option (Flat Memory) over any other.
35 config SPARSEMEM_MANUAL
37 depends on ARCH_SPARSEMEM_ENABLE
39 This will be the only option for some systems, including
40 memory hot-plug systems. This is normal.
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.
46 If unsure, choose "Flat Memory" over this option.
52 depends on (!SELECT_MEMORY_MODEL && ARCH_SPARSEMEM_ENABLE) || SPARSEMEM_MANUAL
56 depends on !SPARSEMEM || FLATMEM_MANUAL
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.
65 # This option will also potentially produce smaller runtime code
66 # with gcc 3.4 and later.
68 config SPARSEMEM_STATIC
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.
76 config SPARSEMEM_EXTREME
78 depends on SPARSEMEM && !SPARSEMEM_STATIC
80 config SPARSEMEM_VMEMMAP_ENABLE
83 config SPARSEMEM_VMEMMAP
84 bool "Sparse Memory virtual memmap"
85 depends on SPARSEMEM && SPARSEMEM_VMEMMAP_ENABLE
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.
92 config HAVE_MEMBLOCK_PHYS_MAP
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.
102 config ARCH_KEEP_MEMBLOCK
105 # Keep arch NUMA mapping infrastructure post-init.
106 config NUMA_KEEP_MEMINFO
109 config MEMORY_ISOLATION
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
115 config EXCLUSIVE_SYSTEM_RAM
117 depends on !DEVMEM || STRICT_DEVMEM
120 # Only be set on architectures that have completely implemented memory hotplug
121 # feature. If you are not sure, don't touch it.
123 config HAVE_BOOTMEM_INFO_NODE
126 config ARCH_ENABLE_MEMORY_HOTPLUG
129 # eventually, we can have this option just 'select SPARSEMEM'
130 config MEMORY_HOTPLUG
131 bool "Allow for memory hot-add"
132 select MEMORY_ISOLATION
134 depends on ARCH_ENABLE_MEMORY_HOTPLUG
136 select NUMA_KEEP_MEMINFO if NUMA
138 config MEMORY_HOTPLUG_DEFAULT_ONLINE
139 bool "Online the newly added memory blocks by default"
140 depends on MEMORY_HOTPLUG
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.
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.
153 config ARCH_ENABLE_MEMORY_HOTREMOVE
156 config 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
162 config MHP_MEMMAP_ON_MEMORY
164 depends on MEMORY_HOTPLUG && SPARSEMEM_VMEMMAP
165 depends on ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE
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.
178 config SPLIT_PTLOCK_CPUS
180 default "999999" if !MMU
181 default "999999" if ARM && !CPU_CACHE_VIPT
182 default "999999" if PARISC && !PA20
183 default "999999" if SPARC32
186 config ARCH_ENABLE_SPLIT_PMD_PTLOCK
190 # support for memory balloon
191 config MEMORY_BALLOON
195 # support for memory balloon compaction
196 config BALLOON_COMPACTION
197 bool "Allow for balloon memory compaction/migration"
199 depends on COMPACTION && MEMORY_BALLOON
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.
210 # support for memory compaction
212 bool "Allow for memory compaction"
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
227 # support for free page reporting
228 config PAGE_REPORTING
229 bool "Free page reporting"
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.
238 # support for page migration
241 bool "Page migration"
243 depends on (NUMA || ARCH_ENABLE_MEMORY_HOTREMOVE || COMPACTION || CMA) && MMU
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.
252 config DEVICE_MIGRATION
253 def_bool MIGRATION && ZONE_DEVICE
255 config ARCH_ENABLE_HUGEPAGE_MIGRATION
258 config ARCH_ENABLE_THP_MIGRATION
261 config HUGETLB_PAGE_SIZE_VARIABLE
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
268 Note that the pageblock_order cannot exceed MAX_ORDER - 1 and will be
269 clamped down to MAX_ORDER - 1.
272 def_bool (MEMORY_ISOLATION && COMPACTION) || CMA
274 config PHYS_ADDR_T_64BIT
278 bool "Enable bounce buffers"
280 depends on BLOCK && MMU && HIGHMEM
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.
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.
300 bool "Enable KSM for page merging"
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).
314 config DEFAULT_MMAP_MIN_ADDR
315 int "Low address space to protect from user allocation"
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.
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.
330 This value can be changed after boot using the
331 /proc/sys/vm/mmap_min_addr tunable.
333 config ARCH_SUPPORTS_MEMORY_FAILURE
336 config MEMORY_FAILURE
338 depends on ARCH_SUPPORTS_MEMORY_FAILURE
339 bool "Enable recovery from hardware memory errors"
340 select MEMORY_ISOLATION
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.
348 config HWPOISON_INJECT
349 tristate "HWPoison pages injector"
350 depends on MEMORY_FAILURE && DEBUG_KERNEL && PROC_FS
351 select PROC_PAGE_MONITOR
353 config NOMMU_INITIAL_TRIM_EXCESS
354 int "Turn on mmap() excess space trimming before booting"
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.
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.
368 If trimming is disabled, the excess is kept, but not used, which for
369 long-term mappings means that the space is wasted.
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.
376 This option specifies the initial value of this option. The default
377 of 1 says that all excess pages should be trimmed.
379 See Documentation/admin-guide/mm/nommu-mmap.rst for more information.
381 config TRANSPARENT_HUGEPAGE
382 bool "Transparent Hugepage Support"
383 depends on HAVE_ARCH_TRANSPARENT_HUGEPAGE && !PREEMPT_RT
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.
394 If memory constrained on embedded, you may want to say N.
397 prompt "Transparent Hugepage Support sysfs defaults"
398 depends on TRANSPARENT_HUGEPAGE
399 default TRANSPARENT_HUGEPAGE_ALWAYS
401 Selects the sysfs defaults for Transparent Hugepage Support.
403 config TRANSPARENT_HUGEPAGE_ALWAYS
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.
410 config TRANSPARENT_HUGEPAGE_MADVISE
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
420 config ARCH_WANT_GENERAL_HUGETLB
423 config ARCH_WANTS_THP_SWAP
428 depends on TRANSPARENT_HUGEPAGE && ARCH_WANTS_THP_SWAP && SWAP
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.
434 For selection by architectures with reasonable THP sizes.
437 # UP and nommu archs use km based percpu allocator
439 config NEED_PER_CPU_KM
440 depends on !SMP || !MMU
444 config NEED_PER_CPU_EMBED_FIRST_CHUNK
447 config NEED_PER_CPU_PAGE_FIRST_CHUNK
450 config USE_PERCPU_NUMA_NODE_ID
453 config HAVE_SETUP_PER_CPU_AREA
460 bool "Contiguous Memory Allocator"
463 select MEMORY_ISOLATION
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.
475 bool "CMA debug messages (DEVELOPMENT)"
476 depends on DEBUG_KERNEL && CMA
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.
484 bool "CMA debugfs interface"
485 depends on CMA && DEBUG_FS
487 Turns on the DebugFS interface for CMA.
490 bool "CMA information through sysfs interface"
491 depends on CMA && SYSFS
493 This option exposes some sysfs attributes to get information
497 int "Maximum count of the CMA areas"
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.
506 If unsure, leave the default value "7" in UMA and "19" in NUMA.
508 config MEM_SOFT_DIRTY
509 bool "Track memory changes"
510 depends on CHECKPOINT_RESTORE && HAVE_ARCH_SOFT_DIRTY && PROC_FS
511 select PROC_PAGE_MONITOR
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.
518 See Documentation/admin-guide/mm/soft-dirty.rst for more details.
521 bool "Compressed cache for swap pages (EXPERIMENTAL)"
522 depends on SWAP && CRYPTO=y
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.
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.
540 prompt "Compressed cache for swap pages default compressor"
542 default ZSWAP_COMPRESSOR_DEFAULT_LZO
544 Selects the default compression algorithm for the compressed cache
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/
552 If in doubt, select 'LZO'.
554 The selection made here can be overridden by using the kernel
555 command line 'zswap.compressor=' option.
557 config ZSWAP_COMPRESSOR_DEFAULT_DEFLATE
559 select CRYPTO_DEFLATE
561 Use the Deflate algorithm as the default compression algorithm.
563 config ZSWAP_COMPRESSOR_DEFAULT_LZO
567 Use the LZO algorithm as the default compression algorithm.
569 config ZSWAP_COMPRESSOR_DEFAULT_842
573 Use the 842 algorithm as the default compression algorithm.
575 config ZSWAP_COMPRESSOR_DEFAULT_LZ4
579 Use the LZ4 algorithm as the default compression algorithm.
581 config ZSWAP_COMPRESSOR_DEFAULT_LZ4HC
585 Use the LZ4HC algorithm as the default compression algorithm.
587 config ZSWAP_COMPRESSOR_DEFAULT_ZSTD
591 Use the zstd algorithm as the default compression algorithm.
594 config ZSWAP_COMPRESSOR_DEFAULT
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
606 prompt "Compressed cache for swap pages default allocator"
608 default ZSWAP_ZPOOL_DEFAULT_ZBUD
610 Selects the default allocator for the compressed cache for
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.
616 The selection made here can be overridden by using the kernel
617 command line 'zswap.zpool=' option.
619 config ZSWAP_ZPOOL_DEFAULT_ZBUD
623 Use the zbud allocator as the default allocator.
625 config ZSWAP_ZPOOL_DEFAULT_Z3FOLD
629 Use the z3fold allocator as the default allocator.
631 config ZSWAP_ZPOOL_DEFAULT_ZSMALLOC
635 Use the zsmalloc allocator as the default allocator.
638 config ZSWAP_ZPOOL_DEFAULT
641 default "zbud" if ZSWAP_ZPOOL_DEFAULT_ZBUD
642 default "z3fold" if ZSWAP_ZPOOL_DEFAULT_Z3FOLD
643 default "zsmalloc" if ZSWAP_ZPOOL_DEFAULT_ZSMALLOC
646 config ZSWAP_DEFAULT_ON
647 bool "Enable the compressed cache for swap pages by default"
650 If selected, the compressed cache for swap pages will be enabled
651 at boot, otherwise it will be disabled.
653 The selection made here can be overridden by using the kernel
654 command line 'zswap.enabled=' option.
657 tristate "Common API for compressed memory storage"
659 Compressed memory storage API. This allows using either zbud or
663 tristate "Low (Up to 2x) density storage for compressed pages"
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.
673 tristate "Up to 3x density storage for compressed pages"
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
682 tristate "Memory allocator for compressed pages"
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.
693 bool "Export zsmalloc statistics"
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.
702 config GENERIC_EARLY_IOREMAP
705 config STACK_MAX_DEFAULT_SIZE_MB
706 int "Default maximum user stack size for 32-bit processes (MB)"
709 depends on STACK_GROWSUP && (!64BIT || COMPAT)
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.
715 A sane initial value is 100 MB.
717 config DEFERRED_STRUCT_PAGE_INIT
718 bool "Defer initialisation of struct pages to kthreads"
720 depends on !NEED_PER_CPU_KM
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
732 config PAGE_IDLE_FLAG
734 select PAGE_EXTENSION if !64BIT
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.
740 config IDLE_PAGE_TRACKING
741 bool "Enable idle page tracking"
742 depends on SYSFS && MMU
743 select PAGE_IDLE_FLAG
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.
750 See Documentation/admin-guide/mm/idle_page_tracking.rst for
753 config ARCH_HAS_CACHE_LINE_SIZE
756 config ARCH_HAS_CURRENT_STACK_POINTER
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
765 config ARCH_HAS_FILTER_PGPROT
768 config ARCH_HAS_PTE_DEVMAP
771 config ARCH_HAS_ZONE_DMA_SET
775 bool "Support DMA zone" if ARCH_HAS_ZONE_DMA_SET
776 default y if ARM64 || X86
779 bool "Support DMA32 zone" if ARCH_HAS_ZONE_DMA_SET
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
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.
798 If FS_DAX is enabled, then say Y.
801 # Helpers to mirror range of the CPU page tables of a process into device page
808 config DEVICE_PRIVATE
809 bool "Unaddressable device memory (GPU memory, ...)"
810 depends on ZONE_DEVICE
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.
820 config ARCH_USES_HIGH_VMA_FLAGS
822 config ARCH_HAS_PKEYS
826 bool "Collect percpu memory statistics"
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.
833 bool "Enable infrastructure for get_user_pages()-related unit tests"
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.
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.
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.
850 See tools/testing/selftests/vm/gup_test.c
852 comment "GUP_TEST needs to have DEBUG_FS enabled"
853 depends on !GUP_TEST && !DEBUG_FS
855 config GUP_GET_PTE_LOW_HIGH
858 config READ_ONLY_THP_FOR_FS
859 bool "Read-only THP for filesystems (EXPERIMENTAL)"
860 depends on TRANSPARENT_HUGEPAGE && SHMEM
863 Allow khugepaged to put read-only file-backed pages in THP.
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
869 config ARCH_HAS_PTE_SPECIAL
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
879 config ARCH_HAS_HUGEPD
882 config MAPPING_DIRTY_HELPERS
888 config KMAP_LOCAL_NON_LINEAR_PTE_ARRAY
891 # struct io_mapping based helper. Selected by drivers that need them
896 def_bool ARCH_HAS_SET_DIRECT_MAP && !EMBEDDED
899 bool "Anonymous VMA name support"
900 depends on PROC_FS && ADVISE_SYSCALLS && MMU
903 Allow naming anonymous virtual memory areas.
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.
912 source "mm/damon/Kconfig"