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