1# SPDX-License-Identifier: GPL-2.0-only
2
3menu "Memory Management options"
4
5#
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.
8#
9config ARCH_NO_SWAP
10	bool
11
12config ZPOOL
13	bool
14
15menuconfig SWAP
16	bool "Support for paging of anonymous memory (swap)"
17	depends on MMU && BLOCK && !ARCH_NO_SWAP
18	default y
19	help
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.
24
25config ZSWAP
26	bool "Compressed cache for swap pages"
27	depends on SWAP
28	select CRYPTO
29	select ZPOOL
30	help
31	  A lightweight compressed cache for swap pages.  It takes
32	  pages that are in the process of being swapped out and attempts to
33	  compress them into a dynamically allocated RAM-based memory pool.
34	  This can result in a significant I/O reduction on swap device and,
35	  in the case where decompressing from RAM is faster than swap device
36	  reads, can also improve workload performance.
37
38config ZSWAP_DEFAULT_ON
39	bool "Enable the compressed cache for swap pages by default"
40	depends on ZSWAP
41	help
42	  If selected, the compressed cache for swap pages will be enabled
43	  at boot, otherwise it will be disabled.
44
45	  The selection made here can be overridden by using the kernel
46	  command line 'zswap.enabled=' option.
47
48config ZSWAP_SHRINKER_DEFAULT_ON
49	bool "Shrink the zswap pool on memory pressure"
50	depends on ZSWAP
51	default n
52	help
53	  If selected, the zswap shrinker will be enabled, and the pages
54	  stored in the zswap pool will become available for reclaim (i.e
55	  written back to the backing swap device) on memory pressure.
56
57	  This means that zswap writeback could happen even if the pool is
58	  not yet full, or the cgroup zswap limit has not been reached,
59	  reducing the chance that cold pages will reside in the zswap pool
60	  and consume memory indefinitely.
61
62choice
63	prompt "Default compressor"
64	depends on ZSWAP
65	default ZSWAP_COMPRESSOR_DEFAULT_LZO
66	help
67	  Selects the default compression algorithm for the compressed cache
68	  for swap pages.
69
70	  For an overview what kind of performance can be expected from
71	  a particular compression algorithm please refer to the benchmarks
72	  available at the following LWN page:
73	  https://lwn.net/Articles/751795/
74
75	  If in doubt, select 'LZO'.
76
77	  The selection made here can be overridden by using the kernel
78	  command line 'zswap.compressor=' option.
79
80config ZSWAP_COMPRESSOR_DEFAULT_DEFLATE
81	bool "Deflate"
82	select CRYPTO_DEFLATE
83	help
84	  Use the Deflate algorithm as the default compression algorithm.
85
86config ZSWAP_COMPRESSOR_DEFAULT_LZO
87	bool "LZO"
88	select CRYPTO_LZO
89	help
90	  Use the LZO algorithm as the default compression algorithm.
91
92config ZSWAP_COMPRESSOR_DEFAULT_842
93	bool "842"
94	select CRYPTO_842
95	help
96	  Use the 842 algorithm as the default compression algorithm.
97
98config ZSWAP_COMPRESSOR_DEFAULT_LZ4
99	bool "LZ4"
100	select CRYPTO_LZ4
101	help
102	  Use the LZ4 algorithm as the default compression algorithm.
103
104config ZSWAP_COMPRESSOR_DEFAULT_LZ4HC
105	bool "LZ4HC"
106	select CRYPTO_LZ4HC
107	help
108	  Use the LZ4HC algorithm as the default compression algorithm.
109
110config ZSWAP_COMPRESSOR_DEFAULT_ZSTD
111	bool "zstd"
112	select CRYPTO_ZSTD
113	help
114	  Use the zstd algorithm as the default compression algorithm.
115endchoice
116
117config ZSWAP_COMPRESSOR_DEFAULT
118       string
119       depends on ZSWAP
120       default "deflate" if ZSWAP_COMPRESSOR_DEFAULT_DEFLATE
121       default "lzo" if ZSWAP_COMPRESSOR_DEFAULT_LZO
122       default "842" if ZSWAP_COMPRESSOR_DEFAULT_842
123       default "lz4" if ZSWAP_COMPRESSOR_DEFAULT_LZ4
124       default "lz4hc" if ZSWAP_COMPRESSOR_DEFAULT_LZ4HC
125       default "zstd" if ZSWAP_COMPRESSOR_DEFAULT_ZSTD
126       default ""
127
128choice
129	prompt "Default allocator"
130	depends on ZSWAP
131	default ZSWAP_ZPOOL_DEFAULT_ZSMALLOC if MMU
132	help
133	  Selects the default allocator for the compressed cache for
134	  swap pages.
135	  The default is 'zbud' for compatibility, however please do
136	  read the description of each of the allocators below before
137	  making a right choice.
138
139	  The selection made here can be overridden by using the kernel
140	  command line 'zswap.zpool=' option.
141
142config ZSWAP_ZPOOL_DEFAULT_ZSMALLOC
143	bool "zsmalloc"
144	select ZSMALLOC
145	help
146	  Use the zsmalloc allocator as the default allocator.
147endchoice
148
149config ZSWAP_ZPOOL_DEFAULT
150       string
151       depends on ZSWAP
152       default "zsmalloc" if ZSWAP_ZPOOL_DEFAULT_ZSMALLOC
153       default ""
154
155config ZSMALLOC
156	tristate
157	prompt "N:1 compression allocator (zsmalloc)" if (ZSWAP || ZRAM)
158	depends on MMU
159	help
160	  zsmalloc is a slab-based memory allocator designed to store
161	  pages of various compression levels efficiently. It achieves
162	  the highest storage density with the least amount of fragmentation.
163
164config ZSMALLOC_STAT
165	bool "Export zsmalloc statistics"
166	depends on ZSMALLOC
167	select DEBUG_FS
168	help
169	  This option enables code in the zsmalloc to collect various
170	  statistics about what's happening in zsmalloc and exports that
171	  information to userspace via debugfs.
172	  If unsure, say N.
173
174config ZSMALLOC_CHAIN_SIZE
175	int "Maximum number of physical pages per-zspage"
176	default 8
177	range 4 16
178	depends on ZSMALLOC
179	help
180	  This option sets the upper limit on the number of physical pages
181	  that a zmalloc page (zspage) can consist of. The optimal zspage
182	  chain size is calculated for each size class during the
183	  initialization of the pool.
184
185	  Changing this option can alter the characteristics of size classes,
186	  such as the number of pages per zspage and the number of objects
187	  per zspage. This can also result in different configurations of
188	  the pool, as zsmalloc merges size classes with similar
189	  characteristics.
190
191	  For more information, see zsmalloc documentation.
192
193menu "Slab allocator options"
194
195config SLUB
196	def_bool y
197
198config KVFREE_RCU_BATCHED
199	def_bool y
200	depends on !SLUB_TINY && !TINY_RCU
201
202config SLUB_TINY
203	bool "Configure for minimal memory footprint"
204	depends on EXPERT && !COMPILE_TEST
205	select SLAB_MERGE_DEFAULT
206	help
207	   Configures the slab allocator in a way to achieve minimal memory
208	   footprint, sacrificing scalability, debugging and other features.
209	   This is intended only for the smallest system that had used the
210	   SLOB allocator and is not recommended for systems with more than
211	   16MB RAM.
212
213	   If unsure, say N.
214
215config SLAB_MERGE_DEFAULT
216	bool "Allow slab caches to be merged"
217	default y
218	help
219	  For reduced kernel memory fragmentation, slab caches can be
220	  merged when they share the same size and other characteristics.
221	  This carries a risk of kernel heap overflows being able to
222	  overwrite objects from merged caches (and more easily control
223	  cache layout), which makes such heap attacks easier to exploit
224	  by attackers. By keeping caches unmerged, these kinds of exploits
225	  can usually only damage objects in the same cache. To disable
226	  merging at runtime, "slab_nomerge" can be passed on the kernel
227	  command line.
228
229config SLAB_FREELIST_RANDOM
230	bool "Randomize slab freelist"
231	depends on !SLUB_TINY
232	help
233	  Randomizes the freelist order used on creating new pages. This
234	  security feature reduces the predictability of the kernel slab
235	  allocator against heap overflows.
236
237config SLAB_FREELIST_HARDENED
238	bool "Harden slab freelist metadata"
239	depends on !SLUB_TINY
240	help
241	  Many kernel heap attacks try to target slab cache metadata and
242	  other infrastructure. This options makes minor performance
243	  sacrifices to harden the kernel slab allocator against common
244	  freelist exploit methods.
245
246config SLAB_BUCKETS
247	bool "Support allocation from separate kmalloc buckets"
248	depends on !SLUB_TINY
249	default SLAB_FREELIST_HARDENED
250	help
251	  Kernel heap attacks frequently depend on being able to create
252	  specifically-sized allocations with user-controlled contents
253	  that will be allocated into the same kmalloc bucket as a
254	  target object. To avoid sharing these allocation buckets,
255	  provide an explicitly separated set of buckets to be used for
256	  user-controlled allocations. This may very slightly increase
257	  memory fragmentation, though in practice it's only a handful
258	  of extra pages since the bulk of user-controlled allocations
259	  are relatively long-lived.
260
261	  If unsure, say Y.
262
263config SLUB_STATS
264	default n
265	bool "Enable performance statistics"
266	depends on SYSFS && !SLUB_TINY
267	help
268	  The statistics are useful to debug slab allocation behavior in
269	  order find ways to optimize the allocator. This should never be
270	  enabled for production use since keeping statistics slows down
271	  the allocator by a few percentage points. The slabinfo command
272	  supports the determination of the most active slabs to figure
273	  out which slabs are relevant to a particular load.
274	  Try running: slabinfo -DA
275
276config SLUB_CPU_PARTIAL
277	default y
278	depends on SMP && !SLUB_TINY
279	bool "Enable per cpu partial caches"
280	help
281	  Per cpu partial caches accelerate objects allocation and freeing
282	  that is local to a processor at the price of more indeterminism
283	  in the latency of the free. On overflow these caches will be cleared
284	  which requires the taking of locks that may cause latency spikes.
285	  Typically one would choose no for a realtime system.
286
287config RANDOM_KMALLOC_CACHES
288	default n
289	depends on !SLUB_TINY
290	bool "Randomize slab caches for normal kmalloc"
291	help
292	  A hardening feature that creates multiple copies of slab caches for
293	  normal kmalloc allocation and makes kmalloc randomly pick one based
294	  on code address, which makes the attackers more difficult to spray
295	  vulnerable memory objects on the heap for the purpose of exploiting
296	  memory vulnerabilities.
297
298	  Currently the number of copies is set to 16, a reasonably large value
299	  that effectively diverges the memory objects allocated for different
300	  subsystems or modules into different caches, at the expense of a
301	  limited degree of memory and CPU overhead that relates to hardware and
302	  system workload.
303
304endmenu # Slab allocator options
305
306config SHUFFLE_PAGE_ALLOCATOR
307	bool "Page allocator randomization"
308	default SLAB_FREELIST_RANDOM && ACPI_NUMA
309	help
310	  Randomization of the page allocator improves the average
311	  utilization of a direct-mapped memory-side-cache. See section
312	  5.2.27 Heterogeneous Memory Attribute Table (HMAT) in the ACPI
313	  6.2a specification for an example of how a platform advertises
314	  the presence of a memory-side-cache. There are also incidental
315	  security benefits as it reduces the predictability of page
316	  allocations to compliment SLAB_FREELIST_RANDOM, but the
317	  default granularity of shuffling on the MAX_PAGE_ORDER i.e, 10th
318	  order of pages is selected based on cache utilization benefits
319	  on x86.
320
321	  While the randomization improves cache utilization it may
322	  negatively impact workloads on platforms without a cache. For
323	  this reason, by default, the randomization is not enabled even
324	  if SHUFFLE_PAGE_ALLOCATOR=y. The randomization may be force enabled
325	  with the 'page_alloc.shuffle' kernel command line parameter.
326
327	  Say Y if unsure.
328
329config COMPAT_BRK
330	bool "Disable heap randomization"
331	default y
332	help
333	  Randomizing heap placement makes heap exploits harder, but it
334	  also breaks ancient binaries (including anything libc5 based).
335	  This option changes the bootup default to heap randomization
336	  disabled, and can be overridden at runtime by setting
337	  /proc/sys/kernel/randomize_va_space to 2.
338
339	  On non-ancient distros (post-2000 ones) N is usually a safe choice.
340
341config MMAP_ALLOW_UNINITIALIZED
342	bool "Allow mmapped anonymous memory to be uninitialized"
343	depends on EXPERT && !MMU
344	default n
345	help
346	  Normally, and according to the Linux spec, anonymous memory obtained
347	  from mmap() has its contents cleared before it is passed to
348	  userspace.  Enabling this config option allows you to request that
349	  mmap() skip that if it is given an MAP_UNINITIALIZED flag, thus
350	  providing a huge performance boost.  If this option is not enabled,
351	  then the flag will be ignored.
352
353	  This is taken advantage of by uClibc's malloc(), and also by
354	  ELF-FDPIC binfmt's brk and stack allocator.
355
356	  Because of the obvious security issues, this option should only be
357	  enabled on embedded devices where you control what is run in
358	  userspace.  Since that isn't generally a problem on no-MMU systems,
359	  it is normally safe to say Y here.
360
361	  See Documentation/admin-guide/mm/nommu-mmap.rst for more information.
362
363config SELECT_MEMORY_MODEL
364	def_bool y
365	depends on ARCH_SELECT_MEMORY_MODEL
366
367choice
368	prompt "Memory model"
369	depends on SELECT_MEMORY_MODEL
370	default SPARSEMEM_MANUAL if ARCH_SPARSEMEM_DEFAULT
371	default FLATMEM_MANUAL
372	help
373	  This option allows you to change some of the ways that
374	  Linux manages its memory internally. Most users will
375	  only have one option here selected by the architecture
376	  configuration. This is normal.
377
378config FLATMEM_MANUAL
379	bool "Flat Memory"
380	depends on !ARCH_SPARSEMEM_ENABLE || ARCH_FLATMEM_ENABLE
381	help
382	  This option is best suited for non-NUMA systems with
383	  flat address space. The FLATMEM is the most efficient
384	  system in terms of performance and resource consumption
385	  and it is the best option for smaller systems.
386
387	  For systems that have holes in their physical address
388	  spaces and for features like NUMA and memory hotplug,
389	  choose "Sparse Memory".
390
391	  If unsure, choose this option (Flat Memory) over any other.
392
393config SPARSEMEM_MANUAL
394	bool "Sparse Memory"
395	depends on ARCH_SPARSEMEM_ENABLE
396	help
397	  This will be the only option for some systems, including
398	  memory hot-plug systems.  This is normal.
399
400	  This option provides efficient support for systems with
401	  holes is their physical address space and allows memory
402	  hot-plug and hot-remove.
403
404	  If unsure, choose "Flat Memory" over this option.
405
406endchoice
407
408config SPARSEMEM
409	def_bool y
410	depends on (!SELECT_MEMORY_MODEL && ARCH_SPARSEMEM_ENABLE) || SPARSEMEM_MANUAL
411
412config FLATMEM
413	def_bool y
414	depends on !SPARSEMEM || FLATMEM_MANUAL
415
416#
417# SPARSEMEM_EXTREME (which is the default) does some bootmem
418# allocations when sparse_init() is called.  If this cannot
419# be done on your architecture, select this option.  However,
420# statically allocating the mem_section[] array can potentially
421# consume vast quantities of .bss, so be careful.
422#
423# This option will also potentially produce smaller runtime code
424# with gcc 3.4 and later.
425#
426config SPARSEMEM_STATIC
427	bool
428
429#
430# Architecture platforms which require a two level mem_section in SPARSEMEM
431# must select this option. This is usually for architecture platforms with
432# an extremely sparse physical address space.
433#
434config SPARSEMEM_EXTREME
435	def_bool y
436	depends on SPARSEMEM && !SPARSEMEM_STATIC
437
438config SPARSEMEM_VMEMMAP_ENABLE
439	bool
440
441config SPARSEMEM_VMEMMAP
442	bool "Sparse Memory virtual memmap"
443	depends on SPARSEMEM && SPARSEMEM_VMEMMAP_ENABLE
444	default y
445	help
446	  SPARSEMEM_VMEMMAP uses a virtually mapped memmap to optimise
447	  pfn_to_page and page_to_pfn operations.  This is the most
448	  efficient option when sufficient kernel resources are available.
449
450config SPARSEMEM_VMEMMAP_PREINIT
451	bool
452#
453# Select this config option from the architecture Kconfig, if it is preferred
454# to enable the feature of HugeTLB/dev_dax vmemmap optimization.
455#
456config ARCH_WANT_OPTIMIZE_DAX_VMEMMAP
457	bool
458
459config ARCH_WANT_OPTIMIZE_HUGETLB_VMEMMAP
460	bool
461
462config ARCH_WANT_HUGETLB_VMEMMAP_PREINIT
463	bool
464
465config HAVE_MEMBLOCK_PHYS_MAP
466	bool
467
468config HAVE_GUP_FAST
469	depends on MMU
470	bool
471
472# Enable memblock support for scratch memory which is needed for kexec handover
473config MEMBLOCK_KHO_SCRATCH
474	bool
475
476# Don't discard allocated memory used to track "memory" and "reserved" memblocks
477# after early boot, so it can still be used to test for validity of memory.
478# Also, memblocks are updated with memory hot(un)plug.
479config ARCH_KEEP_MEMBLOCK
480	bool
481
482# Keep arch NUMA mapping infrastructure post-init.
483config NUMA_KEEP_MEMINFO
484	bool
485
486config MEMORY_ISOLATION
487	bool
488
489# IORESOURCE_SYSTEM_RAM regions in the kernel resource tree that are marked
490# IORESOURCE_EXCLUSIVE cannot be mapped to user space, for example, via
491# /dev/mem.
492config EXCLUSIVE_SYSTEM_RAM
493	def_bool y
494	depends on !DEVMEM || STRICT_DEVMEM
495
496#
497# Only be set on architectures that have completely implemented memory hotplug
498# feature. If you are not sure, don't touch it.
499#
500config HAVE_BOOTMEM_INFO_NODE
501	def_bool n
502
503config ARCH_ENABLE_MEMORY_HOTPLUG
504	bool
505
506config ARCH_ENABLE_MEMORY_HOTREMOVE
507	bool
508
509# eventually, we can have this option just 'select SPARSEMEM'
510menuconfig MEMORY_HOTPLUG
511	bool "Memory hotplug"
512	select MEMORY_ISOLATION
513	depends on SPARSEMEM
514	depends on ARCH_ENABLE_MEMORY_HOTPLUG
515	depends on 64BIT
516	select NUMA_KEEP_MEMINFO if NUMA
517
518if MEMORY_HOTPLUG
519
520choice
521	prompt "Memory Hotplug Default Online Type"
522	default MHP_DEFAULT_ONLINE_TYPE_OFFLINE
523	help
524	  Default memory type for hotplugged memory.
525
526	  This option sets the default policy setting for memory hotplug
527	  onlining policy (/sys/devices/system/memory/auto_online_blocks) which
528	  determines what happens to newly added memory regions. Policy setting
529	  can always be changed at runtime.
530
531	  The default is 'offline'.
532
533	  Select offline to defer onlining to drivers and user policy.
534	  Select auto to let the kernel choose what zones to utilize.
535	  Select online_kernel to generally allow kernel usage of this memory.
536	  Select online_movable to generally disallow kernel usage of this memory.
537
538	  Example kernel usage would be page structs and page tables.
539
540	  See Documentation/admin-guide/mm/memory-hotplug.rst for more information.
541
542config MHP_DEFAULT_ONLINE_TYPE_OFFLINE
543	bool "offline"
544	help
545	  Hotplugged memory will not be onlined by default.
546	  Choose this for systems with drivers and user policy that
547	  handle onlining of hotplug memory policy.
548
549config MHP_DEFAULT_ONLINE_TYPE_ONLINE_AUTO
550	bool "auto"
551	help
552	  Select this if you want the kernel to automatically online
553	  hotplugged memory into the zone it thinks is reasonable.
554	  This memory may be utilized for kernel data.
555
556config MHP_DEFAULT_ONLINE_TYPE_ONLINE_KERNEL
557	bool "kernel"
558	help
559	  Select this if you want the kernel to automatically online
560	  hotplugged memory into a zone capable of being used for kernel
561	  data. This typically means ZONE_NORMAL.
562
563config MHP_DEFAULT_ONLINE_TYPE_ONLINE_MOVABLE
564	bool "movable"
565	help
566	  Select this if you want the kernel to automatically online
567	  hotplug memory into ZONE_MOVABLE. This memory will generally
568	  not be utilized for kernel data.
569
570	  This should only be used when the admin knows sufficient
571	  ZONE_NORMAL memory is available to describe hotplug memory,
572	  otherwise hotplug memory may fail to online. For example,
573	  sufficient kernel-capable memory (ZONE_NORMAL) must be
574	  available to allocate page structs to describe ZONE_MOVABLE.
575
576endchoice
577
578config MEMORY_HOTREMOVE
579	bool "Allow for memory hot remove"
580	select HAVE_BOOTMEM_INFO_NODE if (X86_64 || PPC64)
581	depends on MEMORY_HOTPLUG && ARCH_ENABLE_MEMORY_HOTREMOVE
582	depends on MIGRATION
583
584config MHP_MEMMAP_ON_MEMORY
585	def_bool y
586	depends on MEMORY_HOTPLUG && SPARSEMEM_VMEMMAP
587	depends on ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE
588
589endif # MEMORY_HOTPLUG
590
591config ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE
592       bool
593
594# Heavily threaded applications may benefit from splitting the mm-wide
595# page_table_lock, so that faults on different parts of the user address
596# space can be handled with less contention: split it at this NR_CPUS.
597# Default to 4 for wider testing, though 8 might be more appropriate.
598# ARM's adjust_pte (unused if VIPT) depends on mm-wide page_table_lock.
599# PA-RISC 7xxx's spinlock_t would enlarge struct page from 32 to 44 bytes.
600# SPARC32 allocates multiple pte tables within a single page, and therefore
601# a per-page lock leads to problems when multiple tables need to be locked
602# at the same time (e.g. copy_page_range()).
603# DEBUG_SPINLOCK and DEBUG_LOCK_ALLOC spinlock_t also enlarge struct page.
604#
605config SPLIT_PTE_PTLOCKS
606	def_bool y
607	depends on MMU
608	depends on SMP
609	depends on NR_CPUS >= 4
610	depends on !ARM || CPU_CACHE_VIPT
611	depends on !PARISC || PA20
612	depends on !SPARC32
613
614config ARCH_ENABLE_SPLIT_PMD_PTLOCK
615	bool
616
617config SPLIT_PMD_PTLOCKS
618	def_bool y
619	depends on SPLIT_PTE_PTLOCKS && ARCH_ENABLE_SPLIT_PMD_PTLOCK
620
621#
622# support for memory balloon
623config MEMORY_BALLOON
624	bool
625
626#
627# support for memory balloon compaction
628config BALLOON_COMPACTION
629	bool "Allow for balloon memory compaction/migration"
630	default y
631	depends on COMPACTION && MEMORY_BALLOON
632	help
633	  Memory fragmentation introduced by ballooning might reduce
634	  significantly the number of 2MB contiguous memory blocks that can be
635	  used within a guest, thus imposing performance penalties associated
636	  with the reduced number of transparent huge pages that could be used
637	  by the guest workload. Allowing the compaction & migration for memory
638	  pages enlisted as being part of memory balloon devices avoids the
639	  scenario aforementioned and helps improving memory defragmentation.
640
641#
642# support for memory compaction
643config COMPACTION
644	bool "Allow for memory compaction"
645	default y
646	select MIGRATION
647	depends on MMU
648	help
649	  Compaction is the only memory management component to form
650	  high order (larger physically contiguous) memory blocks
651	  reliably. The page allocator relies on compaction heavily and
652	  the lack of the feature can lead to unexpected OOM killer
653	  invocations for high order memory requests. You shouldn't
654	  disable this option unless there really is a strong reason for
655	  it and then we would be really interested to hear about that at
656	  linux-mm@kvack.org.
657
658config COMPACT_UNEVICTABLE_DEFAULT
659	int
660	depends on COMPACTION
661	default 0 if PREEMPT_RT
662	default 1
663
664#
665# support for free page reporting
666config PAGE_REPORTING
667	bool "Free page reporting"
668	help
669	  Free page reporting allows for the incremental acquisition of
670	  free pages from the buddy allocator for the purpose of reporting
671	  those pages to another entity, such as a hypervisor, so that the
672	  memory can be freed within the host for other uses.
673
674#
675# support for page migration
676#
677config MIGRATION
678	bool "Page migration"
679	default y
680	depends on (NUMA || ARCH_ENABLE_MEMORY_HOTREMOVE || COMPACTION || CMA) && MMU
681	help
682	  Allows the migration of the physical location of pages of processes
683	  while the virtual addresses are not changed. This is useful in
684	  two situations. The first is on NUMA systems to put pages nearer
685	  to the processors accessing. The second is when allocating huge
686	  pages as migration can relocate pages to satisfy a huge page
687	  allocation instead of reclaiming.
688
689config DEVICE_MIGRATION
690	def_bool MIGRATION && ZONE_DEVICE
691
692config ARCH_ENABLE_HUGEPAGE_MIGRATION
693	bool
694
695config ARCH_ENABLE_THP_MIGRATION
696	bool
697
698config HUGETLB_PAGE_SIZE_VARIABLE
699	def_bool n
700	help
701	  Allows the pageblock_order value to be dynamic instead of just standard
702	  HUGETLB_PAGE_ORDER when there are multiple HugeTLB page sizes available
703	  on a platform.
704
705	  Note that the pageblock_order cannot exceed MAX_PAGE_ORDER and will be
706	  clamped down to MAX_PAGE_ORDER.
707
708config CONTIG_ALLOC
709	def_bool (MEMORY_ISOLATION && COMPACTION) || CMA
710
711config PCP_BATCH_SCALE_MAX
712	int "Maximum scale factor of PCP (Per-CPU pageset) batch allocate/free"
713	default 5
714	range 0 6
715	help
716	  In page allocator, PCP (Per-CPU pageset) is refilled and drained in
717	  batches.  The batch number is scaled automatically to improve page
718	  allocation/free throughput.  But too large scale factor may hurt
719	  latency.  This option sets the upper limit of scale factor to limit
720	  the maximum latency.
721
722config PHYS_ADDR_T_64BIT
723	def_bool 64BIT
724
725config BOUNCE
726	bool "Enable bounce buffers"
727	default y
728	depends on BLOCK && MMU && HIGHMEM
729	help
730	  Enable bounce buffers for devices that cannot access the full range of
731	  memory available to the CPU. Enabled by default when HIGHMEM is
732	  selected, but you may say n to override this.
733
734config MMU_NOTIFIER
735	bool
736	select INTERVAL_TREE
737
738config KSM
739	bool "Enable KSM for page merging"
740	depends on MMU
741	select XXHASH
742	help
743	  Enable Kernel Samepage Merging: KSM periodically scans those areas
744	  of an application's address space that an app has advised may be
745	  mergeable.  When it finds pages of identical content, it replaces
746	  the many instances by a single page with that content, so
747	  saving memory until one or another app needs to modify the content.
748	  Recommended for use with KVM, or with other duplicative applications.
749	  See Documentation/mm/ksm.rst for more information: KSM is inactive
750	  until a program has madvised that an area is MADV_MERGEABLE, and
751	  root has set /sys/kernel/mm/ksm/run to 1 (if CONFIG_SYSFS is set).
752
753config DEFAULT_MMAP_MIN_ADDR
754	int "Low address space to protect from user allocation"
755	depends on MMU
756	default 4096
757	help
758	  This is the portion of low virtual memory which should be protected
759	  from userspace allocation.  Keeping a user from writing to low pages
760	  can help reduce the impact of kernel NULL pointer bugs.
761
762	  For most arm64, ppc64 and x86 users with lots of address space
763	  a value of 65536 is reasonable and should cause no problems.
764	  On arm and other archs it should not be higher than 32768.
765	  Programs which use vm86 functionality or have some need to map
766	  this low address space will need CAP_SYS_RAWIO or disable this
767	  protection by setting the value to 0.
768
769	  This value can be changed after boot using the
770	  /proc/sys/vm/mmap_min_addr tunable.
771
772config ARCH_SUPPORTS_MEMORY_FAILURE
773	bool
774
775config MEMORY_FAILURE
776	depends on MMU
777	depends on ARCH_SUPPORTS_MEMORY_FAILURE
778	bool "Enable recovery from hardware memory errors"
779	select MEMORY_ISOLATION
780	select RAS
781	help
782	  Enables code to recover from some memory failures on systems
783	  with MCA recovery. This allows a system to continue running
784	  even when some of its memory has uncorrected errors. This requires
785	  special hardware support and typically ECC memory.
786
787config HWPOISON_INJECT
788	tristate "HWPoison pages injector"
789	depends on MEMORY_FAILURE && DEBUG_KERNEL && PROC_FS
790	select PROC_PAGE_MONITOR
791
792config NOMMU_INITIAL_TRIM_EXCESS
793	int "Turn on mmap() excess space trimming before booting"
794	depends on !MMU
795	default 1
796	help
797	  The NOMMU mmap() frequently needs to allocate large contiguous chunks
798	  of memory on which to store mappings, but it can only ask the system
799	  allocator for chunks in 2^N*PAGE_SIZE amounts - which is frequently
800	  more than it requires.  To deal with this, mmap() is able to trim off
801	  the excess and return it to the allocator.
802
803	  If trimming is enabled, the excess is trimmed off and returned to the
804	  system allocator, which can cause extra fragmentation, particularly
805	  if there are a lot of transient processes.
806
807	  If trimming is disabled, the excess is kept, but not used, which for
808	  long-term mappings means that the space is wasted.
809
810	  Trimming can be dynamically controlled through a sysctl option
811	  (/proc/sys/vm/nr_trim_pages) which specifies the minimum number of
812	  excess pages there must be before trimming should occur, or zero if
813	  no trimming is to occur.
814
815	  This option specifies the initial value of this option.  The default
816	  of 1 says that all excess pages should be trimmed.
817
818	  See Documentation/admin-guide/mm/nommu-mmap.rst for more information.
819
820config ARCH_WANT_GENERAL_HUGETLB
821	bool
822
823config ARCH_WANTS_THP_SWAP
824	def_bool n
825
826config MM_ID
827	def_bool n
828
829menuconfig TRANSPARENT_HUGEPAGE
830	bool "Transparent Hugepage Support"
831	depends on HAVE_ARCH_TRANSPARENT_HUGEPAGE && !PREEMPT_RT
832	select COMPACTION
833	select XARRAY_MULTI
834	select MM_ID
835	help
836	  Transparent Hugepages allows the kernel to use huge pages and
837	  huge tlb transparently to the applications whenever possible.
838	  This feature can improve computing performance to certain
839	  applications by speeding up page faults during memory
840	  allocation, by reducing the number of tlb misses and by speeding
841	  up the pagetable walking.
842
843	  If memory constrained on embedded, you may want to say N.
844
845if TRANSPARENT_HUGEPAGE
846
847choice
848	prompt "Transparent Hugepage Support sysfs defaults"
849	depends on TRANSPARENT_HUGEPAGE
850	default TRANSPARENT_HUGEPAGE_ALWAYS
851	help
852	  Selects the sysfs defaults for Transparent Hugepage Support.
853
854	config TRANSPARENT_HUGEPAGE_ALWAYS
855		bool "always"
856	help
857	  Enabling Transparent Hugepage always, can increase the
858	  memory footprint of applications without a guaranteed
859	  benefit but it will work automatically for all applications.
860
861	config TRANSPARENT_HUGEPAGE_MADVISE
862		bool "madvise"
863	help
864	  Enabling Transparent Hugepage madvise, will only provide a
865	  performance improvement benefit to the applications using
866	  madvise(MADV_HUGEPAGE) but it won't risk to increase the
867	  memory footprint of applications without a guaranteed
868	  benefit.
869
870	config TRANSPARENT_HUGEPAGE_NEVER
871		bool "never"
872	help
873	  Disable Transparent Hugepage by default. It can still be
874	  enabled at runtime via sysfs.
875endchoice
876
877config THP_SWAP
878	def_bool y
879	depends on TRANSPARENT_HUGEPAGE && ARCH_WANTS_THP_SWAP && SWAP && 64BIT
880	help
881	  Swap transparent huge pages in one piece, without splitting.
882	  XXX: For now, swap cluster backing transparent huge page
883	  will be split after swapout.
884
885	  For selection by architectures with reasonable THP sizes.
886
887config READ_ONLY_THP_FOR_FS
888	bool "Read-only THP for filesystems (EXPERIMENTAL)"
889	depends on TRANSPARENT_HUGEPAGE
890
891	help
892	  Allow khugepaged to put read-only file-backed pages in THP.
893
894	  This is marked experimental because it is a new feature. Write
895	  support of file THPs will be developed in the next few release
896	  cycles.
897
898config NO_PAGE_MAPCOUNT
899	bool "No per-page mapcount (EXPERIMENTAL)"
900	help
901	  Do not maintain per-page mapcounts for pages part of larger
902	  allocations, such as transparent huge pages.
903
904	  When this config option is enabled, some interfaces that relied on
905	  this information will rely on less-precise per-allocation information
906	  instead: for example, using the average per-page mapcount in such
907	  a large allocation instead of the per-page mapcount.
908
909	  EXPERIMENTAL because the impact of some changes is still unclear.
910
911endif # TRANSPARENT_HUGEPAGE
912
913# simple helper to make the code a bit easier to read
914config PAGE_MAPCOUNT
915	def_bool !NO_PAGE_MAPCOUNT
916
917#
918# The architecture supports pgtable leaves that is larger than PAGE_SIZE
919#
920config PGTABLE_HAS_HUGE_LEAVES
921	def_bool TRANSPARENT_HUGEPAGE || HUGETLB_PAGE
922
923# TODO: Allow to be enabled without THP
924config ARCH_SUPPORTS_HUGE_PFNMAP
925	def_bool n
926	depends on TRANSPARENT_HUGEPAGE
927
928config ARCH_SUPPORTS_PMD_PFNMAP
929	def_bool y
930	depends on ARCH_SUPPORTS_HUGE_PFNMAP && HAVE_ARCH_TRANSPARENT_HUGEPAGE
931
932config ARCH_SUPPORTS_PUD_PFNMAP
933	def_bool y
934	depends on ARCH_SUPPORTS_HUGE_PFNMAP && HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD
935
936#
937# UP and nommu archs use km based percpu allocator
938#
939config NEED_PER_CPU_KM
940	depends on !SMP || !MMU
941	bool
942	default y
943
944config NEED_PER_CPU_EMBED_FIRST_CHUNK
945	bool
946
947config NEED_PER_CPU_PAGE_FIRST_CHUNK
948	bool
949
950config USE_PERCPU_NUMA_NODE_ID
951	bool
952
953config HAVE_SETUP_PER_CPU_AREA
954	bool
955
956config CMA
957	bool "Contiguous Memory Allocator"
958	depends on MMU
959	select MIGRATION
960	select MEMORY_ISOLATION
961	help
962	  This enables the Contiguous Memory Allocator which allows other
963	  subsystems to allocate big physically-contiguous blocks of memory.
964	  CMA reserves a region of memory and allows only movable pages to
965	  be allocated from it. This way, the kernel can use the memory for
966	  pagecache and when a subsystem requests for contiguous area, the
967	  allocated pages are migrated away to serve the contiguous request.
968
969	  If unsure, say "n".
970
971config CMA_DEBUGFS
972	bool "CMA debugfs interface"
973	depends on CMA && DEBUG_FS
974	help
975	  Turns on the DebugFS interface for CMA.
976
977config CMA_SYSFS
978	bool "CMA information through sysfs interface"
979	depends on CMA && SYSFS
980	help
981	  This option exposes some sysfs attributes to get information
982	  from CMA.
983
984config CMA_AREAS
985	int "Maximum count of the CMA areas"
986	depends on CMA
987	default 20 if NUMA
988	default 8
989	help
990	  CMA allows to create CMA areas for particular purpose, mainly,
991	  used as device private area. This parameter sets the maximum
992	  number of CMA area in the system.
993
994	  If unsure, leave the default value "8" in UMA and "20" in NUMA.
995
996#
997# Select this config option from the architecture Kconfig, if available, to set
998# the max page order for physically contiguous allocations.
999#
1000config ARCH_FORCE_MAX_ORDER
1001	int
1002
1003#
1004# When ARCH_FORCE_MAX_ORDER is not defined,
1005# the default page block order is MAX_PAGE_ORDER (10) as per
1006# include/linux/mmzone.h.
1007#
1008config PAGE_BLOCK_ORDER
1009	int "Page Block Order"
1010	range 1 10 if ARCH_FORCE_MAX_ORDER = 0
1011	default 10 if ARCH_FORCE_MAX_ORDER = 0
1012	range 1 ARCH_FORCE_MAX_ORDER if ARCH_FORCE_MAX_ORDER != 0
1013	default ARCH_FORCE_MAX_ORDER if ARCH_FORCE_MAX_ORDER != 0
1014	help
1015	  The page block order refers to the power of two number of pages that
1016	  are physically contiguous and can have a migrate type associated to
1017	  them. The maximum size of the page block order is limited by
1018	  ARCH_FORCE_MAX_ORDER.
1019
1020	  This config allows overriding the default page block order when the
1021	  page block order is required to be smaller than ARCH_FORCE_MAX_ORDER
1022	  or MAX_PAGE_ORDER.
1023
1024	  Reducing pageblock order can negatively impact THP generation
1025	  success rate. If your workloads uses THP heavily, please use this
1026	  option with caution.
1027
1028	  Don't change if unsure.
1029
1030config MEM_SOFT_DIRTY
1031	bool "Track memory changes"
1032	depends on CHECKPOINT_RESTORE && HAVE_ARCH_SOFT_DIRTY && PROC_FS
1033	select PROC_PAGE_MONITOR
1034	help
1035	  This option enables memory changes tracking by introducing a
1036	  soft-dirty bit on pte-s. This bit it set when someone writes
1037	  into a page just as regular dirty bit, but unlike the latter
1038	  it can be cleared by hands.
1039
1040	  See Documentation/admin-guide/mm/soft-dirty.rst for more details.
1041
1042config GENERIC_EARLY_IOREMAP
1043	bool
1044
1045config STACK_MAX_DEFAULT_SIZE_MB
1046	int "Default maximum user stack size for 32-bit processes (MB)"
1047	default 100
1048	range 8 2048
1049	depends on STACK_GROWSUP && (!64BIT || COMPAT)
1050	help
1051	  This is the maximum stack size in Megabytes in the VM layout of 32-bit
1052	  user processes when the stack grows upwards (currently only on parisc
1053	  arch) when the RLIMIT_STACK hard limit is unlimited.
1054
1055	  A sane initial value is 100 MB.
1056
1057config DEFERRED_STRUCT_PAGE_INIT
1058	bool "Defer initialisation of struct pages to kthreads"
1059	depends on SPARSEMEM
1060	depends on !NEED_PER_CPU_KM
1061	depends on 64BIT
1062	depends on !KMSAN
1063	select PADATA
1064	help
1065	  Ordinarily all struct pages are initialised during early boot in a
1066	  single thread. On very large machines this can take a considerable
1067	  amount of time. If this option is set, large machines will bring up
1068	  a subset of memmap at boot and then initialise the rest in parallel.
1069	  This has a potential performance impact on tasks running early in the
1070	  lifetime of the system until these kthreads finish the
1071	  initialisation.
1072
1073config PAGE_IDLE_FLAG
1074	bool
1075	select PAGE_EXTENSION if !64BIT
1076	help
1077	  This adds PG_idle and PG_young flags to 'struct page'.  PTE Accessed
1078	  bit writers can set the state of the bit in the flags so that PTE
1079	  Accessed bit readers may avoid disturbance.
1080
1081config IDLE_PAGE_TRACKING
1082	bool "Enable idle page tracking"
1083	depends on SYSFS && MMU
1084	select PAGE_IDLE_FLAG
1085	help
1086	  This feature allows to estimate the amount of user pages that have
1087	  not been touched during a given period of time. This information can
1088	  be useful to tune memory cgroup limits and/or for job placement
1089	  within a compute cluster.
1090
1091	  See Documentation/admin-guide/mm/idle_page_tracking.rst for
1092	  more details.
1093
1094# Architectures which implement cpu_dcache_is_aliasing() to query
1095# whether the data caches are aliased (VIVT or VIPT with dcache
1096# aliasing) need to select this.
1097config ARCH_HAS_CPU_CACHE_ALIASING
1098	bool
1099
1100config ARCH_HAS_CACHE_LINE_SIZE
1101	bool
1102
1103config ARCH_HAS_CURRENT_STACK_POINTER
1104	bool
1105	help
1106	  In support of HARDENED_USERCOPY performing stack variable lifetime
1107	  checking, an architecture-agnostic way to find the stack pointer
1108	  is needed. Once an architecture defines an unsigned long global
1109	  register alias named "current_stack_pointer", this config can be
1110	  selected.
1111
1112config ARCH_HAS_PTE_DEVMAP
1113	bool
1114
1115config ARCH_HAS_ZONE_DMA_SET
1116	bool
1117
1118config ZONE_DMA
1119	bool "Support DMA zone" if ARCH_HAS_ZONE_DMA_SET
1120	default y if ARM64 || X86
1121
1122config ZONE_DMA32
1123	bool "Support DMA32 zone" if ARCH_HAS_ZONE_DMA_SET
1124	depends on !X86_32
1125	default y if ARM64
1126
1127config ZONE_DEVICE
1128	bool "Device memory (pmem, HMM, etc...) hotplug support"
1129	depends on MEMORY_HOTPLUG
1130	depends on MEMORY_HOTREMOVE
1131	depends on SPARSEMEM_VMEMMAP
1132	depends on ARCH_HAS_PTE_DEVMAP
1133	select XARRAY_MULTI
1134
1135	help
1136	  Device memory hotplug support allows for establishing pmem,
1137	  or other device driver discovered memory regions, in the
1138	  memmap. This allows pfn_to_page() lookups of otherwise
1139	  "device-physical" addresses which is needed for using a DAX
1140	  mapping in an O_DIRECT operation, among other things.
1141
1142	  If FS_DAX is enabled, then say Y.
1143
1144#
1145# Helpers to mirror range of the CPU page tables of a process into device page
1146# tables.
1147#
1148config HMM_MIRROR
1149	bool
1150	depends on MMU
1151
1152config GET_FREE_REGION
1153	bool
1154
1155config DEVICE_PRIVATE
1156	bool "Unaddressable device memory (GPU memory, ...)"
1157	depends on ZONE_DEVICE
1158	select GET_FREE_REGION
1159
1160	help
1161	  Allows creation of struct pages to represent unaddressable device
1162	  memory; i.e., memory that is only accessible from the device (or
1163	  group of devices). You likely also want to select HMM_MIRROR.
1164
1165config VMAP_PFN
1166	bool
1167
1168config ARCH_USES_HIGH_VMA_FLAGS
1169	bool
1170config ARCH_HAS_PKEYS
1171	bool
1172
1173config ARCH_USES_PG_ARCH_2
1174	bool
1175config ARCH_USES_PG_ARCH_3
1176	bool
1177
1178config VM_EVENT_COUNTERS
1179	default y
1180	bool "Enable VM event counters for /proc/vmstat" if EXPERT
1181	help
1182	  VM event counters are needed for event counts to be shown.
1183	  This option allows the disabling of the VM event counters
1184	  on EXPERT systems.  /proc/vmstat will only show page counts
1185	  if VM event counters are disabled.
1186
1187config PERCPU_STATS
1188	bool "Collect percpu memory statistics"
1189	help
1190	  This feature collects and exposes statistics via debugfs. The
1191	  information includes global and per chunk statistics, which can
1192	  be used to help understand percpu memory usage.
1193
1194config GUP_TEST
1195	bool "Enable infrastructure for get_user_pages()-related unit tests"
1196	depends on DEBUG_FS
1197	help
1198	  Provides /sys/kernel/debug/gup_test, which in turn provides a way
1199	  to make ioctl calls that can launch kernel-based unit tests for
1200	  the get_user_pages*() and pin_user_pages*() family of API calls.
1201
1202	  These tests include benchmark testing of the _fast variants of
1203	  get_user_pages*() and pin_user_pages*(), as well as smoke tests of
1204	  the non-_fast variants.
1205
1206	  There is also a sub-test that allows running dump_page() on any
1207	  of up to eight pages (selected by command line args) within the
1208	  range of user-space addresses. These pages are either pinned via
1209	  pin_user_pages*(), or pinned via get_user_pages*(), as specified
1210	  by other command line arguments.
1211
1212	  See tools/testing/selftests/mm/gup_test.c
1213
1214comment "GUP_TEST needs to have DEBUG_FS enabled"
1215	depends on !GUP_TEST && !DEBUG_FS
1216
1217config GUP_GET_PXX_LOW_HIGH
1218	bool
1219
1220config DMAPOOL_TEST
1221	tristate "Enable a module to run time tests on dma_pool"
1222	depends on HAS_DMA
1223	help
1224	  Provides a test module that will allocate and free many blocks of
1225	  various sizes and report how long it takes. This is intended to
1226	  provide a consistent way to measure how changes to the
1227	  dma_pool_alloc/free routines affect performance.
1228
1229config ARCH_HAS_PTE_SPECIAL
1230	bool
1231
1232config MAPPING_DIRTY_HELPERS
1233        bool
1234
1235config KMAP_LOCAL
1236	bool
1237
1238config KMAP_LOCAL_NON_LINEAR_PTE_ARRAY
1239	bool
1240
1241# struct io_mapping based helper.  Selected by drivers that need them
1242config IO_MAPPING
1243	bool
1244
1245config MEMFD_CREATE
1246	bool "Enable memfd_create() system call" if EXPERT
1247
1248config SECRETMEM
1249	default y
1250	bool "Enable memfd_secret() system call" if EXPERT
1251	depends on ARCH_HAS_SET_DIRECT_MAP
1252	help
1253	  Enable the memfd_secret() system call with the ability to create
1254	  memory areas visible only in the context of the owning process and
1255	  not mapped to other processes and other kernel page tables.
1256
1257config ANON_VMA_NAME
1258	bool "Anonymous VMA name support"
1259	depends on PROC_FS && ADVISE_SYSCALLS && MMU
1260
1261	help
1262	  Allow naming anonymous virtual memory areas.
1263
1264	  This feature allows assigning names to virtual memory areas. Assigned
1265	  names can be later retrieved from /proc/pid/maps and /proc/pid/smaps
1266	  and help identifying individual anonymous memory areas.
1267	  Assigning a name to anonymous virtual memory area might prevent that
1268	  area from being merged with adjacent virtual memory areas due to the
1269	  difference in their name.
1270
1271config HAVE_ARCH_USERFAULTFD_WP
1272	bool
1273	help
1274	  Arch has userfaultfd write protection support
1275
1276config HAVE_ARCH_USERFAULTFD_MINOR
1277	bool
1278	help
1279	  Arch has userfaultfd minor fault support
1280
1281menuconfig USERFAULTFD
1282	bool "Enable userfaultfd() system call"
1283	depends on MMU
1284	help
1285	  Enable the userfaultfd() system call that allows to intercept and
1286	  handle page faults in userland.
1287
1288if USERFAULTFD
1289config PTE_MARKER_UFFD_WP
1290	bool "Userfaultfd write protection support for shmem/hugetlbfs"
1291	default y
1292	depends on HAVE_ARCH_USERFAULTFD_WP
1293
1294	help
1295	  Allows to create marker PTEs for userfaultfd write protection
1296	  purposes.  It is required to enable userfaultfd write protection on
1297	  file-backed memory types like shmem and hugetlbfs.
1298endif # USERFAULTFD
1299
1300# multi-gen LRU {
1301config LRU_GEN
1302	bool "Multi-Gen LRU"
1303	depends on MMU
1304	# make sure folio->flags has enough spare bits
1305	depends on 64BIT || !SPARSEMEM || SPARSEMEM_VMEMMAP
1306	help
1307	  A high performance LRU implementation to overcommit memory. See
1308	  Documentation/admin-guide/mm/multigen_lru.rst for details.
1309
1310config LRU_GEN_ENABLED
1311	bool "Enable by default"
1312	depends on LRU_GEN
1313	help
1314	  This option enables the multi-gen LRU by default.
1315
1316config LRU_GEN_STATS
1317	bool "Full stats for debugging"
1318	depends on LRU_GEN
1319	help
1320	  Do not enable this option unless you plan to look at historical stats
1321	  from evicted generations for debugging purpose.
1322
1323	  This option has a per-memcg and per-node memory overhead.
1324
1325config LRU_GEN_WALKS_MMU
1326	def_bool y
1327	depends on LRU_GEN && ARCH_HAS_HW_PTE_YOUNG
1328# }
1329
1330config ARCH_SUPPORTS_PER_VMA_LOCK
1331       def_bool n
1332
1333config PER_VMA_LOCK
1334	def_bool y
1335	depends on ARCH_SUPPORTS_PER_VMA_LOCK && MMU && SMP
1336	help
1337	  Allow per-vma locking during page fault handling.
1338
1339	  This feature allows locking each virtual memory area separately when
1340	  handling page faults instead of taking mmap_lock.
1341
1342config LOCK_MM_AND_FIND_VMA
1343	bool
1344	depends on !STACK_GROWSUP
1345
1346config IOMMU_MM_DATA
1347	bool
1348
1349config EXECMEM
1350	bool
1351
1352config NUMA_MEMBLKS
1353	bool
1354
1355config NUMA_EMU
1356	bool "NUMA emulation"
1357	depends on NUMA_MEMBLKS
1358	help
1359	  Enable NUMA emulation. A flat machine will be split
1360	  into virtual nodes when booted with "numa=fake=N", where N is the
1361	  number of nodes. This is only useful for debugging.
1362
1363config ARCH_HAS_USER_SHADOW_STACK
1364	bool
1365	help
1366	  The architecture has hardware support for userspace shadow call
1367          stacks (eg, x86 CET, arm64 GCS or RISC-V Zicfiss).
1368
1369config ARCH_SUPPORTS_PT_RECLAIM
1370	def_bool n
1371
1372config PT_RECLAIM
1373	bool "reclaim empty user page table pages"
1374	default y
1375	depends on ARCH_SUPPORTS_PT_RECLAIM && MMU && SMP
1376	select MMU_GATHER_RCU_TABLE_FREE
1377	help
1378	  Try to reclaim empty user page table pages in paths other than munmap
1379	  and exit_mmap path.
1380
1381	  Note: now only empty user PTE page table pages will be reclaimed.
1382
1383
1384source "mm/damon/Kconfig"
1385
1386endmenu
1387