1 config SELECT_MEMORY_MODEL
3 depends on ARCH_SELECT_MEMORY_MODEL
7 depends on SELECT_MEMORY_MODEL
8 default DISCONTIGMEM_MANUAL if ARCH_DISCONTIGMEM_DEFAULT
9 default SPARSEMEM_MANUAL if ARCH_SPARSEMEM_DEFAULT
10 default FLATMEM_MANUAL
14 depends on !(ARCH_DISCONTIGMEM_ENABLE || ARCH_SPARSEMEM_ENABLE) || ARCH_FLATMEM_ENABLE
16 This option allows you to change some of the ways that
17 Linux manages its memory internally. Most users will
18 only have one option here: FLATMEM. This is normal
21 Some users of more advanced features like NUMA and
22 memory hotplug may have different options here.
23 DISCONTIGMEM is a more mature, better tested system,
24 but is incompatible with memory hotplug and may suffer
25 decreased performance over SPARSEMEM. If unsure between
26 "Sparse Memory" and "Discontiguous Memory", choose
27 "Discontiguous Memory".
29 If unsure, choose this option (Flat Memory) over any other.
31 config DISCONTIGMEM_MANUAL
32 bool "Discontiguous Memory"
33 depends on ARCH_DISCONTIGMEM_ENABLE
35 This option provides enhanced support for discontiguous
36 memory systems, over FLATMEM. These systems have holes
37 in their physical address spaces, and this option provides
38 more efficient handling of these holes. However, the vast
39 majority of hardware has quite flat address spaces, and
40 can have degraded performance from the extra overhead that
43 Many NUMA configurations will have this as the only option.
45 If unsure, choose "Flat Memory" over this option.
47 config SPARSEMEM_MANUAL
49 depends on ARCH_SPARSEMEM_ENABLE
51 This will be the only option for some systems, including
52 memory hotplug systems. This is normal.
54 For many other systems, this will be an alternative to
55 "Discontiguous Memory". This option provides some potential
56 performance benefits, along with decreased code complexity,
57 but it is newer, and more experimental.
59 If unsure, choose "Discontiguous Memory" or "Flat Memory"
66 depends on (!SELECT_MEMORY_MODEL && ARCH_DISCONTIGMEM_ENABLE) || DISCONTIGMEM_MANUAL
70 depends on (!SELECT_MEMORY_MODEL && ARCH_SPARSEMEM_ENABLE) || SPARSEMEM_MANUAL
74 depends on (!DISCONTIGMEM && !SPARSEMEM) || FLATMEM_MANUAL
76 config FLAT_NODE_MEM_MAP
81 # Both the NUMA code and DISCONTIGMEM use arrays of pg_data_t's
82 # to represent different areas of memory. This variable allows
83 # those dependencies to exist individually.
85 config NEED_MULTIPLE_NODES
87 depends on DISCONTIGMEM || NUMA
89 config HAVE_MEMORY_PRESENT
91 depends on ARCH_HAVE_MEMORY_PRESENT || SPARSEMEM
94 # SPARSEMEM_EXTREME (which is the default) does some bootmem
95 # allocations when memory_present() is called. If this cannot
96 # be done on your architecture, select this option. However,
97 # statically allocating the mem_section[] array can potentially
98 # consume vast quantities of .bss, so be careful.
100 # This option will also potentially produce smaller runtime code
101 # with gcc 3.4 and later.
103 config SPARSEMEM_STATIC
107 # Architecture platforms which require a two level mem_section in SPARSEMEM
108 # must select this option. This is usually for architecture platforms with
109 # an extremely sparse physical address space.
111 config SPARSEMEM_EXTREME
113 depends on SPARSEMEM && !SPARSEMEM_STATIC
115 config SPARSEMEM_VMEMMAP_ENABLE
118 config SPARSEMEM_ALLOC_MEM_MAP_TOGETHER
120 depends on SPARSEMEM && X86_64
122 config SPARSEMEM_VMEMMAP
123 bool "Sparse Memory virtual memmap"
124 depends on SPARSEMEM && SPARSEMEM_VMEMMAP_ENABLE
127 SPARSEMEM_VMEMMAP uses a virtually mapped memmap to optimise
128 pfn_to_page and page_to_pfn operations. This is the most
129 efficient option when sufficient kernel resources are available.
134 config HAVE_MEMBLOCK_NODE_MAP
137 config HAVE_MEMBLOCK_PHYS_MAP
140 config HAVE_GENERIC_GUP
143 config ARCH_DISCARD_MEMBLOCK
149 config MEMORY_ISOLATION
153 # Only be set on architectures that have completely implemented memory hotplug
154 # feature. If you are not sure, don't touch it.
156 config HAVE_BOOTMEM_INFO_NODE
159 # eventually, we can have this option just 'select SPARSEMEM'
160 config MEMORY_HOTPLUG
161 bool "Allow for memory hot-add"
162 depends on SPARSEMEM || X86_64_ACPI_NUMA
163 depends on ARCH_ENABLE_MEMORY_HOTPLUG
165 config MEMORY_HOTPLUG_SPARSE
167 depends on SPARSEMEM && MEMORY_HOTPLUG
169 config MEMORY_HOTPLUG_DEFAULT_ONLINE
170 bool "Online the newly added memory blocks by default"
172 depends on MEMORY_HOTPLUG
174 This option sets the default policy setting for memory hotplug
175 onlining policy (/sys/devices/system/memory/auto_online_blocks) which
176 determines what happens to newly added memory regions. Policy setting
177 can always be changed at runtime.
178 See Documentation/memory-hotplug.txt for more information.
180 Say Y here if you want all hot-plugged memory blocks to appear in
181 'online' state by default.
182 Say N here if you want the default policy to keep all hot-plugged
183 memory blocks in 'offline' state.
185 config MEMORY_HOTREMOVE
186 bool "Allow for memory hot remove"
187 select MEMORY_ISOLATION
188 select HAVE_BOOTMEM_INFO_NODE if (X86_64 || PPC64)
189 depends on MEMORY_HOTPLUG && ARCH_ENABLE_MEMORY_HOTREMOVE
192 # Heavily threaded applications may benefit from splitting the mm-wide
193 # page_table_lock, so that faults on different parts of the user address
194 # space can be handled with less contention: split it at this NR_CPUS.
195 # Default to 4 for wider testing, though 8 might be more appropriate.
196 # ARM's adjust_pte (unused if VIPT) depends on mm-wide page_table_lock.
197 # PA-RISC 7xxx's spinlock_t would enlarge struct page from 32 to 44 bytes.
198 # DEBUG_SPINLOCK and DEBUG_LOCK_ALLOC spinlock_t also enlarge struct page.
200 config SPLIT_PTLOCK_CPUS
202 default "999999" if !MMU
203 default "999999" if ARM && !CPU_CACHE_VIPT
204 default "999999" if PARISC && !PA20
207 config ARCH_ENABLE_SPLIT_PMD_PTLOCK
211 # support for memory balloon
212 config MEMORY_BALLOON
216 # support for memory balloon compaction
217 config BALLOON_COMPACTION
218 bool "Allow for balloon memory compaction/migration"
220 depends on COMPACTION && MEMORY_BALLOON
222 Memory fragmentation introduced by ballooning might reduce
223 significantly the number of 2MB contiguous memory blocks that can be
224 used within a guest, thus imposing performance penalties associated
225 with the reduced number of transparent huge pages that could be used
226 by the guest workload. Allowing the compaction & migration for memory
227 pages enlisted as being part of memory balloon devices avoids the
228 scenario aforementioned and helps improving memory defragmentation.
231 # support for memory compaction
233 bool "Allow for memory compaction"
238 Compaction is the only memory management component to form
239 high order (larger physically contiguous) memory blocks
240 reliably. The page allocator relies on compaction heavily and
241 the lack of the feature can lead to unexpected OOM killer
242 invocations for high order memory requests. You shouldn't
243 disable this option unless there really is a strong reason for
244 it and then we would be really interested to hear about that at
247 config PROCESS_RECLAIM
248 bool "Enable process reclaim"
252 It allows to reclaim pages of the process by /proc/pid/reclaim.
254 (echo file > /proc/PID/reclaim) reclaims file-backed pages only.
255 (echo anon > /proc/PID/reclaim) reclaims anonymous pages only.
256 (echo all > /proc/PID/reclaim) reclaims all pages.
258 Any other value is ignored.
260 # support for page migration
263 bool "Page migration"
265 depends on (NUMA || ARCH_ENABLE_MEMORY_HOTREMOVE || COMPACTION || CMA) && MMU
267 Allows the migration of the physical location of pages of processes
268 while the virtual addresses are not changed. This is useful in
269 two situations. The first is on NUMA systems to put pages nearer
270 to the processors accessing. The second is when allocating huge
271 pages as migration can relocate pages to satisfy a huge page
272 allocation instead of reclaiming.
274 config ARCH_ENABLE_HUGEPAGE_MIGRATION
277 config ARCH_ENABLE_THP_MIGRATION
280 config PHYS_ADDR_T_64BIT
281 def_bool 64BIT || ARCH_PHYS_ADDR_T_64BIT
284 bool "Enable bounce buffers"
286 depends on BLOCK && MMU && (ZONE_DMA || HIGHMEM)
288 Enable bounce buffers for devices that cannot access
289 the full range of memory available to the CPU. Enabled
290 by default when ZONE_DMA or HIGHMEM is selected, but you
291 may say n to override this.
293 # On the 'tile' arch, USB OHCI needs the bounce pool since tilegx will often
294 # have more than 4GB of memory, but we don't currently use the IOTLB to present
295 # a 32-bit address to OHCI. So we need to use a bounce pool instead.
296 config NEED_BOUNCE_POOL
298 default y if TILE && USB_OHCI_HCD
308 An architecture should select this if it implements the
309 deprecated interface virt_to_bus(). All new architectures
310 should probably not select this.
318 bool "Enable KSM for page merging"
321 Enable Kernel Samepage Merging: KSM periodically scans those areas
322 of an application's address space that an app has advised may be
323 mergeable. When it finds pages of identical content, it replaces
324 the many instances by a single page with that content, so
325 saving memory until one or another app needs to modify the content.
326 Recommended for use with KVM, or with other duplicative applications.
327 See Documentation/vm/ksm.txt for more information: KSM is inactive
328 until a program has madvised that an area is MADV_MERGEABLE, and
329 root has set /sys/kernel/mm/ksm/run to 1 (if CONFIG_SYSFS is set).
331 config DEFAULT_MMAP_MIN_ADDR
332 int "Low address space to protect from user allocation"
336 This is the portion of low virtual memory which should be protected
337 from userspace allocation. Keeping a user from writing to low pages
338 can help reduce the impact of kernel NULL pointer bugs.
340 For most ia64, ppc64 and x86 users with lots of address space
341 a value of 65536 is reasonable and should cause no problems.
342 On arm and other archs it should not be higher than 32768.
343 Programs which use vm86 functionality or have some need to map
344 this low address space will need CAP_SYS_RAWIO or disable this
345 protection by setting the value to 0.
347 This value can be changed after boot using the
348 /proc/sys/vm/mmap_min_addr tunable.
350 config ARCH_SUPPORTS_MEMORY_FAILURE
353 config MEMORY_FAILURE
355 depends on ARCH_SUPPORTS_MEMORY_FAILURE
356 bool "Enable recovery from hardware memory errors"
357 select MEMORY_ISOLATION
360 Enables code to recover from some memory failures on systems
361 with MCA recovery. This allows a system to continue running
362 even when some of its memory has uncorrected errors. This requires
363 special hardware support and typically ECC memory.
365 config HWPOISON_INJECT
366 tristate "HWPoison pages injector"
367 depends on MEMORY_FAILURE && DEBUG_KERNEL && PROC_FS
368 select PROC_PAGE_MONITOR
370 config NOMMU_INITIAL_TRIM_EXCESS
371 int "Turn on mmap() excess space trimming before booting"
375 The NOMMU mmap() frequently needs to allocate large contiguous chunks
376 of memory on which to store mappings, but it can only ask the system
377 allocator for chunks in 2^N*PAGE_SIZE amounts - which is frequently
378 more than it requires. To deal with this, mmap() is able to trim off
379 the excess and return it to the allocator.
381 If trimming is enabled, the excess is trimmed off and returned to the
382 system allocator, which can cause extra fragmentation, particularly
383 if there are a lot of transient processes.
385 If trimming is disabled, the excess is kept, but not used, which for
386 long-term mappings means that the space is wasted.
388 Trimming can be dynamically controlled through a sysctl option
389 (/proc/sys/vm/nr_trim_pages) which specifies the minimum number of
390 excess pages there must be before trimming should occur, or zero if
391 no trimming is to occur.
393 This option specifies the initial value of this option. The default
394 of 1 says that all excess pages should be trimmed.
396 See Documentation/nommu-mmap.txt for more information.
398 config TRANSPARENT_HUGEPAGE
399 bool "Transparent Hugepage Support"
400 depends on HAVE_ARCH_TRANSPARENT_HUGEPAGE
402 select RADIX_TREE_MULTIORDER
404 Transparent Hugepages allows the kernel to use huge pages and
405 huge tlb transparently to the applications whenever possible.
406 This feature can improve computing performance to certain
407 applications by speeding up page faults during memory
408 allocation, by reducing the number of tlb misses and by speeding
409 up the pagetable walking.
411 If memory constrained on embedded, you may want to say N.
414 prompt "Transparent Hugepage Support sysfs defaults"
415 depends on TRANSPARENT_HUGEPAGE
416 default TRANSPARENT_HUGEPAGE_ALWAYS
418 Selects the sysfs defaults for Transparent Hugepage Support.
420 config TRANSPARENT_HUGEPAGE_ALWAYS
423 Enabling Transparent Hugepage always, can increase the
424 memory footprint of applications without a guaranteed
425 benefit but it will work automatically for all applications.
427 config TRANSPARENT_HUGEPAGE_MADVISE
430 Enabling Transparent Hugepage madvise, will only provide a
431 performance improvement benefit to the applications using
432 madvise(MADV_HUGEPAGE) but it won't risk to increase the
433 memory footprint of applications without a guaranteed
437 config ARCH_WANTS_THP_SWAP
442 depends on TRANSPARENT_HUGEPAGE && ARCH_WANTS_THP_SWAP
444 Swap transparent huge pages in one piece, without splitting.
445 XXX: For now this only does clustered swap space allocation.
447 For selection by architectures with reasonable THP sizes.
449 config TRANSPARENT_HUGE_PAGECACHE
451 depends on TRANSPARENT_HUGEPAGE
454 # UP and nommu archs use km based percpu allocator
456 config NEED_PER_CPU_KM
462 bool "Enable cleancache driver to cache clean pages if tmem is present"
465 Cleancache can be thought of as a page-granularity victim cache
466 for clean pages that the kernel's pageframe replacement algorithm
467 (PFRA) would like to keep around, but can't since there isn't enough
468 memory. So when the PFRA "evicts" a page, it first attempts to use
469 cleancache code to put the data contained in that page into
470 "transcendent memory", memory that is not directly accessible or
471 addressable by the kernel and is of unknown and possibly
472 time-varying size. And when a cleancache-enabled
473 filesystem wishes to access a page in a file on disk, it first
474 checks cleancache to see if it already contains it; if it does,
475 the page is copied into the kernel and a disk access is avoided.
476 When a transcendent memory driver is available (such as zcache or
477 Xen transcendent memory), a significant I/O reduction
478 may be achieved. When none is available, all cleancache calls
479 are reduced to a single pointer-compare-against-NULL resulting
480 in a negligible performance hit.
482 If unsure, say Y to enable cleancache
485 bool "Enable frontswap to cache swap pages if tmem is present"
489 Frontswap is so named because it can be thought of as the opposite
490 of a "backing" store for a swap device. The data is stored into
491 "transcendent memory", memory that is not directly accessible or
492 addressable by the kernel and is of unknown and possibly
493 time-varying size. When space in transcendent memory is available,
494 a significant swap I/O reduction may be achieved. When none is
495 available, all frontswap calls are reduced to a single pointer-
496 compare-against-NULL resulting in a negligible performance hit
497 and swap data is stored as normal on the matching swap device.
499 If unsure, say Y to enable frontswap.
502 bool "Contiguous Memory Allocator"
503 depends on HAVE_MEMBLOCK && MMU
505 select MEMORY_ISOLATION
507 This enables the Contiguous Memory Allocator which allows other
508 subsystems to allocate big physically-contiguous blocks of memory.
509 CMA reserves a region of memory and allows only movable pages to
510 be allocated from it. This way, the kernel can use the memory for
511 pagecache and when a subsystem requests for contiguous area, the
512 allocated pages are migrated away to serve the contiguous request.
517 bool "CMA debug messages (DEVELOPMENT)"
518 depends on DEBUG_KERNEL && CMA
520 Turns on debug messages in CMA. This produces KERN_DEBUG
521 messages for every CMA call as well as various messages while
522 processing calls such as dma_alloc_from_contiguous().
523 This option does not affect warning and error messages.
526 bool "CMA debugfs interface"
527 depends on CMA && DEBUG_FS
529 Turns on the DebugFS interface for CMA.
532 int "Maximum count of the CMA areas"
536 CMA allows to create CMA areas for particular purpose, mainly,
537 used as device private area. This parameter sets the maximum
538 number of CMA area in the system.
540 If unsure, leave the default value "7".
542 config MEM_SOFT_DIRTY
543 bool "Track memory changes"
544 depends on CHECKPOINT_RESTORE && HAVE_ARCH_SOFT_DIRTY && PROC_FS
545 select PROC_PAGE_MONITOR
547 This option enables memory changes tracking by introducing a
548 soft-dirty bit on pte-s. This bit it set when someone writes
549 into a page just as regular dirty bit, but unlike the latter
550 it can be cleared by hands.
552 See Documentation/vm/soft-dirty.txt for more details.
555 bool "Compressed cache for swap pages (EXPERIMENTAL)"
556 depends on FRONTSWAP && CRYPTO=y
561 A lightweight compressed cache for swap pages. It takes
562 pages that are in the process of being swapped out and attempts to
563 compress them into a dynamically allocated RAM-based memory pool.
564 This can result in a significant I/O reduction on swap device and,
565 in the case where decompressing from RAM is faster that swap device
566 reads, can also improve workload performance.
568 This is marked experimental because it is a new feature (as of
569 v3.11) that interacts heavily with memory reclaim. While these
570 interactions don't cause any known issues on simple memory setups,
571 they have not be fully explored on the large set of potential
572 configurations and workloads that exist.
575 tristate "Common API for compressed memory storage"
578 Compressed memory storage API. This allows using either zbud or
582 tristate "Low (Up to 2x) density storage for compressed pages"
585 A special purpose allocator for storing compressed pages.
586 It is designed to store up to two compressed pages per physical
587 page. While this design limits storage density, it has simple and
588 deterministic reclaim properties that make it preferable to a higher
589 density approach when reclaim will be used.
592 tristate "Up to 3x density storage for compressed pages"
596 A special purpose allocator for storing compressed pages.
597 It is designed to store up to three compressed pages per physical
598 page. It is a ZBUD derivative so the simplicity and determinism are
602 tristate "Memory allocator for compressed pages"
606 zsmalloc is a slab-based memory allocator designed to store
607 compressed RAM pages. zsmalloc uses virtual memory mapping
608 in order to reduce fragmentation. However, this results in a
609 non-standard allocator interface where a handle, not a pointer, is
610 returned by an alloc(). This handle must be mapped in order to
611 access the allocated space.
613 config PGTABLE_MAPPING
614 bool "Use page table mapping to access object in zsmalloc"
617 By default, zsmalloc uses a copy-based object mapping method to
618 access allocations that span two pages. However, if a particular
619 architecture (ex, ARM) performs VM mapping faster than copying,
620 then you should select this. This causes zsmalloc to use page table
621 mapping rather than copying for object mapping.
623 You can check speed with zsmalloc benchmark:
624 https://github.com/spartacus06/zsmapbench
627 bool "Export zsmalloc statistics"
631 This option enables code in the zsmalloc to collect various
632 statistics about whats happening in zsmalloc and exports that
633 information to userspace via debugfs.
637 bool "Track per-process MM event"
640 This option enables per-process mm event stat(e.g., fault, reclaim,
641 compaction and so on ) with some interval(Default is 0.5sec).
642 Admin can see the stat from trace file via debugfs(e.g.,
643 /sys/kernel/debug/tracing/trace)
645 It includes max/average memory allocation latency for the interval
646 as well as event count so that admin can see what happens in VM side
647 (how many each event happens and how much processes spent time for
648 the MM event). If it's too large, that would be not good situation.
650 System can dump the trace into bugreport when user allows the dump.
652 config GENERIC_EARLY_IOREMAP
655 config MAX_STACK_SIZE_MB
656 int "Maximum user stack size for 32-bit processes (MB)"
660 depends on STACK_GROWSUP && (!64BIT || COMPAT)
662 This is the maximum stack size in Megabytes in the VM layout of 32-bit
663 user processes when the stack grows upwards (currently only on parisc
664 and metag arch). The stack will be located at the highest memory
665 address minus the given value, unless the RLIMIT_STACK hard limit is
666 changed to a smaller value in which case that is used.
668 A sane initial value is 80 MB.
670 config BALANCE_ANON_FILE_RECLAIM
671 bool "During reclaim treat anon and file backed pages equally"
674 When performing memory reclaim treat anonymous and file backed pages
676 Swapping anonymous pages out to memory can be efficient enough to justify
677 treating anonymous and file backed pages equally.
680 bool "High-order Pages Allocator"
683 Turns on High-order Pages Allocator based on page migration.
685 # For architectures that support deferred memory initialisation
686 config ARCH_SUPPORTS_DEFERRED_STRUCT_PAGE_INIT
689 config DEFERRED_STRUCT_PAGE_INIT
690 bool "Defer initialisation of struct pages to kthreads"
692 depends on ARCH_SUPPORTS_DEFERRED_STRUCT_PAGE_INIT
693 depends on NO_BOOTMEM && MEMORY_HOTPLUG
695 depends on !NEED_PER_CPU_KM
697 Ordinarily all struct pages are initialised during early boot in a
698 single thread. On very large machines this can take a considerable
699 amount of time. If this option is set, large machines will bring up
700 a subset of memmap at boot and then initialise the rest in parallel
701 by starting one-off "pgdatinitX" kernel thread for each node X. This
702 has a potential performance impact on processes running early in the
703 lifetime of the system until these kthreads finish the
706 config IDLE_PAGE_TRACKING
707 bool "Enable idle page tracking"
708 depends on SYSFS && MMU
709 select PAGE_EXTENSION if !64BIT
711 This feature allows to estimate the amount of user pages that have
712 not been touched during a given period of time. This information can
713 be useful to tune memory cgroup limits and/or for job placement
714 within a compute cluster.
716 See Documentation/vm/idle_page_tracking.txt for more details.
718 # arch_add_memory() comprehends device memory
719 config ARCH_HAS_ZONE_DEVICE
723 bool "Device memory (pmem, HMM, etc...) hotplug support"
724 depends on MEMORY_HOTPLUG
725 depends on MEMORY_HOTREMOVE
726 depends on SPARSEMEM_VMEMMAP
727 depends on ARCH_HAS_ZONE_DEVICE
728 select RADIX_TREE_MULTIORDER
731 Device memory hotplug support allows for establishing pmem,
732 or other device driver discovered memory regions, in the
733 memmap. This allows pfn_to_page() lookups of otherwise
734 "device-physical" addresses which is needed for using a DAX
735 mapping in an O_DIRECT operation, among other things.
737 If FS_DAX is enabled, then say Y.
742 depends on (X86_64 || PPC64)
743 depends on ZONE_DEVICE
744 depends on MMU && 64BIT
745 depends on MEMORY_HOTPLUG
746 depends on MEMORY_HOTREMOVE
747 depends on SPARSEMEM_VMEMMAP
749 config MIGRATE_VMA_HELPER
754 select MIGRATE_VMA_HELPER
757 bool "HMM mirror CPU page table into a device page table"
758 depends on ARCH_HAS_HMM
762 Select HMM_MIRROR if you want to mirror range of the CPU page table of a
763 process into a device page table. Here, mirror means "keep synchronized".
764 Prerequisites: the device must provide the ability to write-protect its
765 page tables (at PAGE_SIZE granularity), and must be able to recover from
766 the resulting potential page faults.
768 config DEVICE_PRIVATE
769 bool "Unaddressable device memory (GPU memory, ...)"
770 depends on ARCH_HAS_HMM
774 Allows creation of struct pages to represent unaddressable device
775 memory; i.e., memory that is only accessible from the device (or
776 group of devices). You likely also want to select HMM_MIRROR.
779 bool "Addressable device memory (like GPU memory)"
780 depends on ARCH_HAS_HMM
784 Allows creation of struct pages to represent addressable device
785 memory; i.e., memory that is accessible from both the device and
791 config ARCH_USES_HIGH_VMA_FLAGS
793 config ARCH_HAS_PKEYS
797 bool "Collect percpu memory statistics"
800 This feature collects and exposes statistics via debugfs. The
801 information includes global and per chunk statistics, which can
802 be used to help understand percpu memory usage.