Christoph Hellwig | 59e0b52 | 2018-07-31 13:39:35 +0200 | [diff] [blame] | 1 | |
| 2 | menu "Memory Management options" |
| 3 | |
Dave Hansen | e1785e8 | 2005-06-23 00:07:49 -0700 | [diff] [blame] | 4 | config SELECT_MEMORY_MODEL |
| 5 | def_bool y |
Kees Cook | a8826ee | 2013-01-16 18:54:17 -0800 | [diff] [blame] | 6 | depends on ARCH_SELECT_MEMORY_MODEL |
Dave Hansen | e1785e8 | 2005-06-23 00:07:49 -0700 | [diff] [blame] | 7 | |
Dave Hansen | 3a9da76 | 2005-06-23 00:07:42 -0700 | [diff] [blame] | 8 | choice |
| 9 | prompt "Memory model" |
Dave Hansen | e1785e8 | 2005-06-23 00:07:49 -0700 | [diff] [blame] | 10 | depends on SELECT_MEMORY_MODEL |
| 11 | default DISCONTIGMEM_MANUAL if ARCH_DISCONTIGMEM_DEFAULT |
Andy Whitcroft | d41dee3 | 2005-06-23 00:07:54 -0700 | [diff] [blame] | 12 | default SPARSEMEM_MANUAL if ARCH_SPARSEMEM_DEFAULT |
Dave Hansen | e1785e8 | 2005-06-23 00:07:49 -0700 | [diff] [blame] | 13 | default FLATMEM_MANUAL |
Dave Hansen | 3a9da76 | 2005-06-23 00:07:42 -0700 | [diff] [blame] | 14 | |
Dave Hansen | e1785e8 | 2005-06-23 00:07:49 -0700 | [diff] [blame] | 15 | config FLATMEM_MANUAL |
Dave Hansen | 3a9da76 | 2005-06-23 00:07:42 -0700 | [diff] [blame] | 16 | bool "Flat Memory" |
Anton Blanchard | c898ec1 | 2006-01-06 00:12:07 -0800 | [diff] [blame] | 17 | depends on !(ARCH_DISCONTIGMEM_ENABLE || ARCH_SPARSEMEM_ENABLE) || ARCH_FLATMEM_ENABLE |
Dave Hansen | 3a9da76 | 2005-06-23 00:07:42 -0700 | [diff] [blame] | 18 | help |
| 19 | This option allows you to change some of the ways that |
| 20 | Linux manages its memory internally. Most users will |
| 21 | only have one option here: FLATMEM. This is normal |
| 22 | and a correct option. |
| 23 | |
Andy Whitcroft | d41dee3 | 2005-06-23 00:07:54 -0700 | [diff] [blame] | 24 | Some users of more advanced features like NUMA and |
| 25 | memory hotplug may have different options here. |
Geert Uytterhoeven | 18f6533 | 2013-09-15 12:01:33 +0200 | [diff] [blame] | 26 | DISCONTIGMEM is a more mature, better tested system, |
Andy Whitcroft | d41dee3 | 2005-06-23 00:07:54 -0700 | [diff] [blame] | 27 | but is incompatible with memory hotplug and may suffer |
| 28 | decreased performance over SPARSEMEM. If unsure between |
| 29 | "Sparse Memory" and "Discontiguous Memory", choose |
| 30 | "Discontiguous Memory". |
| 31 | |
| 32 | If unsure, choose this option (Flat Memory) over any other. |
Dave Hansen | 3a9da76 | 2005-06-23 00:07:42 -0700 | [diff] [blame] | 33 | |
Dave Hansen | e1785e8 | 2005-06-23 00:07:49 -0700 | [diff] [blame] | 34 | config DISCONTIGMEM_MANUAL |
Dave Hansen | f3519f9 | 2005-09-16 19:27:54 -0700 | [diff] [blame] | 35 | bool "Discontiguous Memory" |
Dave Hansen | 3a9da76 | 2005-06-23 00:07:42 -0700 | [diff] [blame] | 36 | depends on ARCH_DISCONTIGMEM_ENABLE |
| 37 | help |
Dave Hansen | 785dcd4 | 2005-06-23 00:07:50 -0700 | [diff] [blame] | 38 | This option provides enhanced support for discontiguous |
| 39 | memory systems, over FLATMEM. These systems have holes |
| 40 | in their physical address spaces, and this option provides |
| 41 | more efficient handling of these holes. However, the vast |
| 42 | majority of hardware has quite flat address spaces, and |
Philipp Marek | ad3d0a3 | 2007-10-20 02:46:58 +0200 | [diff] [blame] | 43 | can have degraded performance from the extra overhead that |
Dave Hansen | 785dcd4 | 2005-06-23 00:07:50 -0700 | [diff] [blame] | 44 | this option imposes. |
| 45 | |
| 46 | Many NUMA configurations will have this as the only option. |
| 47 | |
Dave Hansen | 3a9da76 | 2005-06-23 00:07:42 -0700 | [diff] [blame] | 48 | If unsure, choose "Flat Memory" over this option. |
| 49 | |
Andy Whitcroft | d41dee3 | 2005-06-23 00:07:54 -0700 | [diff] [blame] | 50 | config SPARSEMEM_MANUAL |
| 51 | bool "Sparse Memory" |
| 52 | depends on ARCH_SPARSEMEM_ENABLE |
| 53 | help |
| 54 | This will be the only option for some systems, including |
| 55 | memory hotplug systems. This is normal. |
| 56 | |
| 57 | For many other systems, this will be an alternative to |
Dave Hansen | f3519f9 | 2005-09-16 19:27:54 -0700 | [diff] [blame] | 58 | "Discontiguous Memory". This option provides some potential |
Andy Whitcroft | d41dee3 | 2005-06-23 00:07:54 -0700 | [diff] [blame] | 59 | performance benefits, along with decreased code complexity, |
| 60 | but it is newer, and more experimental. |
| 61 | |
| 62 | If unsure, choose "Discontiguous Memory" or "Flat Memory" |
| 63 | over this option. |
| 64 | |
Dave Hansen | 3a9da76 | 2005-06-23 00:07:42 -0700 | [diff] [blame] | 65 | endchoice |
| 66 | |
Dave Hansen | e1785e8 | 2005-06-23 00:07:49 -0700 | [diff] [blame] | 67 | config DISCONTIGMEM |
| 68 | def_bool y |
| 69 | depends on (!SELECT_MEMORY_MODEL && ARCH_DISCONTIGMEM_ENABLE) || DISCONTIGMEM_MANUAL |
| 70 | |
Andy Whitcroft | d41dee3 | 2005-06-23 00:07:54 -0700 | [diff] [blame] | 71 | config SPARSEMEM |
| 72 | def_bool y |
Russell King | 1a83e17 | 2009-10-26 16:50:12 -0700 | [diff] [blame] | 73 | depends on (!SELECT_MEMORY_MODEL && ARCH_SPARSEMEM_ENABLE) || SPARSEMEM_MANUAL |
Andy Whitcroft | d41dee3 | 2005-06-23 00:07:54 -0700 | [diff] [blame] | 74 | |
Dave Hansen | e1785e8 | 2005-06-23 00:07:49 -0700 | [diff] [blame] | 75 | config FLATMEM |
| 76 | def_bool y |
Andy Whitcroft | d41dee3 | 2005-06-23 00:07:54 -0700 | [diff] [blame] | 77 | depends on (!DISCONTIGMEM && !SPARSEMEM) || FLATMEM_MANUAL |
| 78 | |
| 79 | config FLAT_NODE_MEM_MAP |
| 80 | def_bool y |
| 81 | depends on !SPARSEMEM |
Dave Hansen | e1785e8 | 2005-06-23 00:07:49 -0700 | [diff] [blame] | 82 | |
Dave Hansen | 93b7504 | 2005-06-23 00:07:47 -0700 | [diff] [blame] | 83 | # |
| 84 | # Both the NUMA code and DISCONTIGMEM use arrays of pg_data_t's |
| 85 | # to represent different areas of memory. This variable allows |
| 86 | # those dependencies to exist individually. |
| 87 | # |
| 88 | config NEED_MULTIPLE_NODES |
| 89 | def_bool y |
| 90 | depends on DISCONTIGMEM || NUMA |
Andy Whitcroft | af70536 | 2005-06-23 00:07:53 -0700 | [diff] [blame] | 91 | |
| 92 | config HAVE_MEMORY_PRESENT |
| 93 | def_bool y |
Andy Whitcroft | d41dee3 | 2005-06-23 00:07:54 -0700 | [diff] [blame] | 94 | depends on ARCH_HAVE_MEMORY_PRESENT || SPARSEMEM |
Bob Picco | 802f192 | 2005-09-03 15:54:26 -0700 | [diff] [blame] | 95 | |
| 96 | # |
Bob Picco | 3e34726 | 2005-09-03 15:54:28 -0700 | [diff] [blame] | 97 | # SPARSEMEM_EXTREME (which is the default) does some bootmem |
Matt LaPlante | 84eb8d0 | 2006-10-03 22:53:09 +0200 | [diff] [blame] | 98 | # allocations when memory_present() is called. If this cannot |
Bob Picco | 3e34726 | 2005-09-03 15:54:28 -0700 | [diff] [blame] | 99 | # be done on your architecture, select this option. However, |
| 100 | # statically allocating the mem_section[] array can potentially |
| 101 | # consume vast quantities of .bss, so be careful. |
| 102 | # |
| 103 | # This option will also potentially produce smaller runtime code |
| 104 | # with gcc 3.4 and later. |
| 105 | # |
| 106 | config SPARSEMEM_STATIC |
Jan Beulich | 9ba1608 | 2008-10-15 22:01:38 -0700 | [diff] [blame] | 107 | bool |
Bob Picco | 3e34726 | 2005-09-03 15:54:28 -0700 | [diff] [blame] | 108 | |
| 109 | # |
Matt LaPlante | 44c0920 | 2006-10-03 22:34:14 +0200 | [diff] [blame] | 110 | # Architecture platforms which require a two level mem_section in SPARSEMEM |
Bob Picco | 802f192 | 2005-09-03 15:54:26 -0700 | [diff] [blame] | 111 | # must select this option. This is usually for architecture platforms with |
| 112 | # an extremely sparse physical address space. |
| 113 | # |
Bob Picco | 3e34726 | 2005-09-03 15:54:28 -0700 | [diff] [blame] | 114 | config SPARSEMEM_EXTREME |
| 115 | def_bool y |
| 116 | depends on SPARSEMEM && !SPARSEMEM_STATIC |
Hugh Dickins | 4c21e2f | 2005-10-29 18:16:40 -0700 | [diff] [blame] | 117 | |
Andy Whitcroft | 29c7111 | 2007-10-16 01:24:14 -0700 | [diff] [blame] | 118 | config SPARSEMEM_VMEMMAP_ENABLE |
Jan Beulich | 9ba1608 | 2008-10-15 22:01:38 -0700 | [diff] [blame] | 119 | bool |
Andy Whitcroft | 29c7111 | 2007-10-16 01:24:14 -0700 | [diff] [blame] | 120 | |
| 121 | config SPARSEMEM_VMEMMAP |
Geoff Levand | a5ee6da | 2007-12-17 16:19:53 -0800 | [diff] [blame] | 122 | bool "Sparse Memory virtual memmap" |
| 123 | depends on SPARSEMEM && SPARSEMEM_VMEMMAP_ENABLE |
| 124 | default y |
| 125 | help |
| 126 | SPARSEMEM_VMEMMAP uses a virtually mapped memmap to optimise |
| 127 | pfn_to_page and page_to_pfn operations. This is the most |
| 128 | efficient option when sufficient kernel resources are available. |
Andy Whitcroft | 29c7111 | 2007-10-16 01:24:14 -0700 | [diff] [blame] | 129 | |
Yinghai Lu | 95f72d1 | 2010-07-12 14:36:09 +1000 | [diff] [blame] | 130 | config HAVE_MEMBLOCK |
Christoph Jaeger | 6341e62 | 2014-12-20 15:41:11 -0500 | [diff] [blame] | 131 | bool |
Yinghai Lu | 95f72d1 | 2010-07-12 14:36:09 +1000 | [diff] [blame] | 132 | |
Tejun Heo | 7c0caeb | 2011-07-14 11:43:42 +0200 | [diff] [blame] | 133 | config HAVE_MEMBLOCK_NODE_MAP |
Christoph Jaeger | 6341e62 | 2014-12-20 15:41:11 -0500 | [diff] [blame] | 134 | bool |
Tejun Heo | 7c0caeb | 2011-07-14 11:43:42 +0200 | [diff] [blame] | 135 | |
Philipp Hachtmann | 70210ed | 2014-01-29 18:16:01 +0100 | [diff] [blame] | 136 | config HAVE_MEMBLOCK_PHYS_MAP |
Christoph Jaeger | 6341e62 | 2014-12-20 15:41:11 -0500 | [diff] [blame] | 137 | bool |
Philipp Hachtmann | 70210ed | 2014-01-29 18:16:01 +0100 | [diff] [blame] | 138 | |
Kirill A. Shutemov | e585513 | 2017-06-06 14:31:20 +0300 | [diff] [blame] | 139 | config HAVE_GENERIC_GUP |
Christoph Jaeger | 6341e62 | 2014-12-20 15:41:11 -0500 | [diff] [blame] | 140 | bool |
Steve Capper | 2667f50 | 2014-10-09 15:29:14 -0700 | [diff] [blame] | 141 | |
Tejun Heo | c378ddd | 2011-07-14 11:46:03 +0200 | [diff] [blame] | 142 | config ARCH_DISCARD_MEMBLOCK |
Christoph Jaeger | 6341e62 | 2014-12-20 15:41:11 -0500 | [diff] [blame] | 143 | bool |
Tejun Heo | c378ddd | 2011-07-14 11:46:03 +0200 | [diff] [blame] | 144 | |
Sam Ravnborg | 6661672 | 2011-10-31 17:08:20 -0700 | [diff] [blame] | 145 | config NO_BOOTMEM |
Christoph Jaeger | 6341e62 | 2014-12-20 15:41:11 -0500 | [diff] [blame] | 146 | bool |
Sam Ravnborg | 6661672 | 2011-10-31 17:08:20 -0700 | [diff] [blame] | 147 | |
Minchan Kim | ee6f509 | 2012-07-31 16:43:50 -0700 | [diff] [blame] | 148 | config MEMORY_ISOLATION |
Christoph Jaeger | 6341e62 | 2014-12-20 15:41:11 -0500 | [diff] [blame] | 149 | bool |
Minchan Kim | ee6f509 | 2012-07-31 16:43:50 -0700 | [diff] [blame] | 150 | |
Yasuaki Ishimatsu | 46723bf | 2013-02-22 16:33:00 -0800 | [diff] [blame] | 151 | # |
| 152 | # Only be set on architectures that have completely implemented memory hotplug |
| 153 | # feature. If you are not sure, don't touch it. |
| 154 | # |
| 155 | config HAVE_BOOTMEM_INFO_NODE |
| 156 | def_bool n |
| 157 | |
Dave Hansen | 3947be1 | 2005-10-29 18:16:54 -0700 | [diff] [blame] | 158 | # eventually, we can have this option just 'select SPARSEMEM' |
| 159 | config MEMORY_HOTPLUG |
| 160 | bool "Allow for memory hot-add" |
Keith Mannthey | ec69acb | 2006-09-30 23:27:05 -0700 | [diff] [blame] | 161 | depends on SPARSEMEM || X86_64_ACPI_NUMA |
Stephen Rothwell | 40b3136 | 2013-05-21 13:49:35 +1000 | [diff] [blame] | 162 | depends on ARCH_ENABLE_MEMORY_HOTPLUG |
Arun KS | 1697c0c | 2017-09-20 13:20:41 +0530 | [diff] [blame] | 163 | depends on ARM64 |
Dave Hansen | 3947be1 | 2005-10-29 18:16:54 -0700 | [diff] [blame] | 164 | |
Keith Mannthey | ec69acb | 2006-09-30 23:27:05 -0700 | [diff] [blame] | 165 | config MEMORY_HOTPLUG_SPARSE |
| 166 | def_bool y |
| 167 | depends on SPARSEMEM && MEMORY_HOTPLUG |
| 168 | |
Vitaly Kuznetsov | 8604d9e | 2016-05-19 17:13:03 -0700 | [diff] [blame] | 169 | config MEMORY_HOTPLUG_DEFAULT_ONLINE |
| 170 | bool "Online the newly added memory blocks by default" |
| 171 | default n |
| 172 | depends on MEMORY_HOTPLUG |
| 173 | help |
| 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. |
| 179 | |
| 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. |
| 184 | |
Sudarshan Rajagopalan | da65cea | 2018-05-15 19:52:51 -0700 | [diff] [blame] | 185 | config MEMORY_HOTPLUG_MOVABLE_NODE |
| 186 | bool "Add hot-added memory blocks to ZONE_MOVABLE type" |
| 187 | default n |
| 188 | depends on MEMORY_HOTPLUG |
| 189 | depends on QCOM_MEM_OFFLINE |
| 190 | help |
| 191 | When onlining memory blocks, this option helps to add the target |
| 192 | memory block to ZONE_MOVABLE zone type. For successful offlining, |
| 193 | these memory blocks should belong to 'ZONE_MOVABLE' since it carries |
| 194 | only movable pages. When this option is not set, the default zone |
| 195 | policy is to add the blocks to 'ZONE_NORMAL' which may pin pages. |
| 196 | |
| 197 | See Documentation/memory-hotplug.txt for more information. |
| 198 | |
| 199 | Say Y here if you want all hot-added memory blocks to be added to |
| 200 | 'ZONE_MOVABLE' type.state by default. |
| 201 | Say N here if you want the default policy to add all hot-added |
| 202 | memory blocks in 'ZONE_NORMAL' type. |
| 203 | |
KAMEZAWA Hiroyuki | 0c0e619 | 2007-10-16 01:26:12 -0700 | [diff] [blame] | 204 | config MEMORY_HOTREMOVE |
| 205 | bool "Allow for memory hot remove" |
Yasuaki Ishimatsu | 46723bf | 2013-02-22 16:33:00 -0800 | [diff] [blame] | 206 | select MEMORY_ISOLATION |
Nathan Fontenot | f7e3334 | 2013-09-27 10:18:09 -0500 | [diff] [blame] | 207 | select HAVE_BOOTMEM_INFO_NODE if (X86_64 || PPC64) |
KAMEZAWA Hiroyuki | 0c0e619 | 2007-10-16 01:26:12 -0700 | [diff] [blame] | 208 | depends on MEMORY_HOTPLUG && ARCH_ENABLE_MEMORY_HOTREMOVE |
| 209 | depends on MIGRATION |
| 210 | |
Hugh Dickins | 4c21e2f | 2005-10-29 18:16:40 -0700 | [diff] [blame] | 211 | # Heavily threaded applications may benefit from splitting the mm-wide |
| 212 | # page_table_lock, so that faults on different parts of the user address |
| 213 | # space can be handled with less contention: split it at this NR_CPUS. |
| 214 | # Default to 4 for wider testing, though 8 might be more appropriate. |
| 215 | # ARM's adjust_pte (unused if VIPT) depends on mm-wide page_table_lock. |
Hugh Dickins | 7b6ac9d | 2005-11-23 13:37:37 -0800 | [diff] [blame] | 216 | # PA-RISC 7xxx's spinlock_t would enlarge struct page from 32 to 44 bytes. |
Hugh Dickins | a70caa8 | 2009-12-14 17:59:02 -0800 | [diff] [blame] | 217 | # DEBUG_SPINLOCK and DEBUG_LOCK_ALLOC spinlock_t also enlarge struct page. |
Hugh Dickins | 4c21e2f | 2005-10-29 18:16:40 -0700 | [diff] [blame] | 218 | # |
| 219 | config SPLIT_PTLOCK_CPUS |
| 220 | int |
Kirill A. Shutemov | 9164550 | 2014-04-07 15:37:14 -0700 | [diff] [blame] | 221 | default "999999" if !MMU |
Hugh Dickins | a70caa8 | 2009-12-14 17:59:02 -0800 | [diff] [blame] | 222 | default "999999" if ARM && !CPU_CACHE_VIPT |
| 223 | default "999999" if PARISC && !PA20 |
Hugh Dickins | 4c21e2f | 2005-10-29 18:16:40 -0700 | [diff] [blame] | 224 | default "4" |
Christoph Lameter | 7cbe34c | 2006-01-08 01:00:49 -0800 | [diff] [blame] | 225 | |
Kirill A. Shutemov | e009bb3 | 2013-11-14 14:31:07 -0800 | [diff] [blame] | 226 | config ARCH_ENABLE_SPLIT_PMD_PTLOCK |
Christoph Jaeger | 6341e62 | 2014-12-20 15:41:11 -0500 | [diff] [blame] | 227 | bool |
Kirill A. Shutemov | e009bb3 | 2013-11-14 14:31:07 -0800 | [diff] [blame] | 228 | |
Christoph Lameter | 7cbe34c | 2006-01-08 01:00:49 -0800 | [diff] [blame] | 229 | # |
Konstantin Khlebnikov | 09316c0 | 2014-10-09 15:29:32 -0700 | [diff] [blame] | 230 | # support for memory balloon |
| 231 | config MEMORY_BALLOON |
Christoph Jaeger | 6341e62 | 2014-12-20 15:41:11 -0500 | [diff] [blame] | 232 | bool |
Konstantin Khlebnikov | 09316c0 | 2014-10-09 15:29:32 -0700 | [diff] [blame] | 233 | |
| 234 | # |
Rafael Aquini | 18468d9 | 2012-12-11 16:02:38 -0800 | [diff] [blame] | 235 | # support for memory balloon compaction |
| 236 | config BALLOON_COMPACTION |
| 237 | bool "Allow for balloon memory compaction/migration" |
| 238 | def_bool y |
Konstantin Khlebnikov | 09316c0 | 2014-10-09 15:29:32 -0700 | [diff] [blame] | 239 | depends on COMPACTION && MEMORY_BALLOON |
Rafael Aquini | 18468d9 | 2012-12-11 16:02:38 -0800 | [diff] [blame] | 240 | help |
| 241 | Memory fragmentation introduced by ballooning might reduce |
| 242 | significantly the number of 2MB contiguous memory blocks that can be |
| 243 | used within a guest, thus imposing performance penalties associated |
| 244 | with the reduced number of transparent huge pages that could be used |
| 245 | by the guest workload. Allowing the compaction & migration for memory |
| 246 | pages enlisted as being part of memory balloon devices avoids the |
| 247 | scenario aforementioned and helps improving memory defragmentation. |
| 248 | |
| 249 | # |
Mel Gorman | e9e96b3 | 2010-05-24 14:32:21 -0700 | [diff] [blame] | 250 | # support for memory compaction |
| 251 | config COMPACTION |
| 252 | bool "Allow for memory compaction" |
Rik van Riel | 05106e6 | 2012-10-08 16:33:03 -0700 | [diff] [blame] | 253 | def_bool y |
Mel Gorman | e9e96b3 | 2010-05-24 14:32:21 -0700 | [diff] [blame] | 254 | select MIGRATION |
Andrea Arcangeli | 33a9387 | 2011-01-25 15:07:25 -0800 | [diff] [blame] | 255 | depends on MMU |
Mel Gorman | e9e96b3 | 2010-05-24 14:32:21 -0700 | [diff] [blame] | 256 | help |
Michal Hocko | b32eaf7 | 2016-08-25 15:17:05 -0700 | [diff] [blame] | 257 | Compaction is the only memory management component to form |
| 258 | high order (larger physically contiguous) memory blocks |
| 259 | reliably. The page allocator relies on compaction heavily and |
| 260 | the lack of the feature can lead to unexpected OOM killer |
| 261 | invocations for high order memory requests. You shouldn't |
| 262 | disable this option unless there really is a strong reason for |
| 263 | it and then we would be really interested to hear about that at |
| 264 | linux-mm@kvack.org. |
Mel Gorman | e9e96b3 | 2010-05-24 14:32:21 -0700 | [diff] [blame] | 265 | |
| 266 | # |
Christoph Lameter | 7cbe34c | 2006-01-08 01:00:49 -0800 | [diff] [blame] | 267 | # support for page migration |
| 268 | # |
| 269 | config MIGRATION |
Christoph Lameter | b20a350 | 2006-03-22 00:09:12 -0800 | [diff] [blame] | 270 | bool "Page migration" |
Christoph Lameter | 6c5240a | 2006-06-23 02:03:37 -0700 | [diff] [blame] | 271 | def_bool y |
Chen Gang | de32a81 | 2013-09-12 15:14:08 -0700 | [diff] [blame] | 272 | depends on (NUMA || ARCH_ENABLE_MEMORY_HOTREMOVE || COMPACTION || CMA) && MMU |
Christoph Lameter | b20a350 | 2006-03-22 00:09:12 -0800 | [diff] [blame] | 273 | help |
| 274 | Allows the migration of the physical location of pages of processes |
Mel Gorman | e9e96b3 | 2010-05-24 14:32:21 -0700 | [diff] [blame] | 275 | while the virtual addresses are not changed. This is useful in |
| 276 | two situations. The first is on NUMA systems to put pages nearer |
| 277 | to the processors accessing. The second is when allocating huge |
| 278 | pages as migration can relocate pages to satisfy a huge page |
| 279 | allocation instead of reclaiming. |
Greg Kroah-Hartman | 6550e07 | 2006-06-12 17:11:31 -0700 | [diff] [blame] | 280 | |
Naoya Horiguchi | c177c81 | 2014-06-04 16:05:35 -0700 | [diff] [blame] | 281 | config ARCH_ENABLE_HUGEPAGE_MIGRATION |
Christoph Jaeger | 6341e62 | 2014-12-20 15:41:11 -0500 | [diff] [blame] | 282 | bool |
Naoya Horiguchi | c177c81 | 2014-06-04 16:05:35 -0700 | [diff] [blame] | 283 | |
Naoya Horiguchi | 9c670ea | 2017-09-08 16:10:53 -0700 | [diff] [blame] | 284 | config ARCH_ENABLE_THP_MIGRATION |
| 285 | bool |
| 286 | |
Jeremy Fitzhardinge | 600715d | 2008-09-11 01:31:45 -0700 | [diff] [blame] | 287 | config PHYS_ADDR_T_64BIT |
Christoph Hellwig | d4a451d | 2018-04-03 16:24:20 +0200 | [diff] [blame] | 288 | def_bool 64BIT |
Jeremy Fitzhardinge | 600715d | 2008-09-11 01:31:45 -0700 | [diff] [blame] | 289 | |
Christoph Lameter | 2a7326b | 2007-07-17 04:03:37 -0700 | [diff] [blame] | 290 | config BOUNCE |
Vinayak Menon | 9ca24e2 | 2013-04-29 15:08:55 -0700 | [diff] [blame] | 291 | bool "Enable bounce buffers" |
| 292 | default y |
Christoph Lameter | 2a7326b | 2007-07-17 04:03:37 -0700 | [diff] [blame] | 293 | depends on BLOCK && MMU && (ZONE_DMA || HIGHMEM) |
Vinayak Menon | 9ca24e2 | 2013-04-29 15:08:55 -0700 | [diff] [blame] | 294 | help |
| 295 | Enable bounce buffers for devices that cannot access |
| 296 | the full range of memory available to the CPU. Enabled |
| 297 | by default when ZONE_DMA or HIGHMEM is selected, but you |
| 298 | may say n to override this. |
Christoph Lameter | 2a7326b | 2007-07-17 04:03:37 -0700 | [diff] [blame] | 299 | |
Christoph Lameter | 6225e93 | 2007-05-06 14:49:50 -0700 | [diff] [blame] | 300 | config NR_QUICK |
| 301 | int |
| 302 | depends on QUICKLIST |
| 303 | default "1" |
Stephen Rothwell | f057eac | 2007-07-15 23:40:05 -0700 | [diff] [blame] | 304 | |
| 305 | config VIRT_TO_BUS |
Stephen Rothwell | 4febd95 | 2013-03-07 15:48:16 +1100 | [diff] [blame] | 306 | bool |
| 307 | help |
| 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. |
| 311 | |
Andrea Arcangeli | cddb8a5 | 2008-07-28 15:46:29 -0700 | [diff] [blame] | 312 | |
| 313 | config MMU_NOTIFIER |
| 314 | bool |
Pranith Kumar | 83fe27e | 2014-12-05 11:24:45 -0500 | [diff] [blame] | 315 | select SRCU |
David Howells | fc4d5c2 | 2009-05-06 16:03:05 -0700 | [diff] [blame] | 316 | |
Hugh Dickins | f8af4da | 2009-09-21 17:01:57 -0700 | [diff] [blame] | 317 | config KSM |
| 318 | bool "Enable KSM for page merging" |
| 319 | depends on MMU |
| 320 | help |
| 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 |
Hugh Dickins | d0f209f | 2009-12-14 17:59:34 -0800 | [diff] [blame] | 324 | the many instances by a single page with that content, so |
Hugh Dickins | f8af4da | 2009-09-21 17:01:57 -0700 | [diff] [blame] | 325 | saving memory until one or another app needs to modify the content. |
| 326 | Recommended for use with KVM, or with other duplicative applications. |
Mike Rapoport | ad56b73 | 2018-03-21 21:22:47 +0200 | [diff] [blame] | 327 | See Documentation/vm/ksm.rst for more information: KSM is inactive |
Hugh Dickins | c73602a | 2009-10-07 16:32:22 -0700 | [diff] [blame] | 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). |
Hugh Dickins | f8af4da | 2009-09-21 17:01:57 -0700 | [diff] [blame] | 330 | |
Christoph Lameter | e0a94c2 | 2009-06-03 16:04:31 -0400 | [diff] [blame] | 331 | config DEFAULT_MMAP_MIN_ADDR |
| 332 | int "Low address space to protect from user allocation" |
David Howells | 6e14154 | 2009-12-15 19:27:45 +0000 | [diff] [blame] | 333 | depends on MMU |
Christoph Lameter | e0a94c2 | 2009-06-03 16:04:31 -0400 | [diff] [blame] | 334 | default 4096 |
| 335 | help |
| 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. |
| 339 | |
| 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. |
Eric Paris | 788084a | 2009-07-31 12:54:11 -0400 | [diff] [blame] | 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. |
Christoph Lameter | e0a94c2 | 2009-06-03 16:04:31 -0400 | [diff] [blame] | 346 | |
| 347 | This value can be changed after boot using the |
| 348 | /proc/sys/vm/mmap_min_addr tunable. |
| 349 | |
Linus Torvalds | d949f36 | 2009-09-26 09:35:07 -0700 | [diff] [blame] | 350 | config ARCH_SUPPORTS_MEMORY_FAILURE |
| 351 | bool |
Christoph Lameter | e0a94c2 | 2009-06-03 16:04:31 -0400 | [diff] [blame] | 352 | |
Andi Kleen | 6a46079 | 2009-09-16 11:50:15 +0200 | [diff] [blame] | 353 | config MEMORY_FAILURE |
| 354 | depends on MMU |
Linus Torvalds | d949f36 | 2009-09-26 09:35:07 -0700 | [diff] [blame] | 355 | depends on ARCH_SUPPORTS_MEMORY_FAILURE |
Andi Kleen | 6a46079 | 2009-09-16 11:50:15 +0200 | [diff] [blame] | 356 | bool "Enable recovery from hardware memory errors" |
Minchan Kim | ee6f509 | 2012-07-31 16:43:50 -0700 | [diff] [blame] | 357 | select MEMORY_ISOLATION |
Xie XiuQi | 97f0b13 | 2015-06-24 16:57:36 -0700 | [diff] [blame] | 358 | select RAS |
Andi Kleen | 6a46079 | 2009-09-16 11:50:15 +0200 | [diff] [blame] | 359 | help |
| 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. |
| 364 | |
Andi Kleen | cae681f | 2009-09-16 11:50:17 +0200 | [diff] [blame] | 365 | config HWPOISON_INJECT |
Andi Kleen | 413f9ef | 2009-12-16 12:20:00 +0100 | [diff] [blame] | 366 | tristate "HWPoison pages injector" |
Andi Kleen | 27df506 | 2009-12-21 19:56:42 +0100 | [diff] [blame] | 367 | depends on MEMORY_FAILURE && DEBUG_KERNEL && PROC_FS |
Wu Fengguang | 478c5ff | 2009-12-16 12:19:59 +0100 | [diff] [blame] | 368 | select PROC_PAGE_MONITOR |
Andi Kleen | cae681f | 2009-09-16 11:50:17 +0200 | [diff] [blame] | 369 | |
David Howells | fc4d5c2 | 2009-05-06 16:03:05 -0700 | [diff] [blame] | 370 | config NOMMU_INITIAL_TRIM_EXCESS |
| 371 | int "Turn on mmap() excess space trimming before booting" |
| 372 | depends on !MMU |
| 373 | default 1 |
| 374 | help |
| 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. |
| 380 | |
| 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. |
| 384 | |
| 385 | If trimming is disabled, the excess is kept, but not used, which for |
| 386 | long-term mappings means that the space is wasted. |
| 387 | |
| 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. |
| 392 | |
| 393 | This option specifies the initial value of this option. The default |
| 394 | of 1 says that all excess pages should be trimmed. |
| 395 | |
| 396 | See Documentation/nommu-mmap.txt for more information. |
Tejun Heo | bbddff0 | 2010-09-03 18:22:48 +0200 | [diff] [blame] | 397 | |
Andrea Arcangeli | 4c76d9d | 2011-01-13 15:46:39 -0800 | [diff] [blame] | 398 | config TRANSPARENT_HUGEPAGE |
Andrea Arcangeli | 13ece88 | 2011-01-13 15:47:07 -0800 | [diff] [blame] | 399 | bool "Transparent Hugepage Support" |
Gerald Schaefer | 1562606 | 2012-10-08 16:30:04 -0700 | [diff] [blame] | 400 | depends on HAVE_ARCH_TRANSPARENT_HUGEPAGE |
Andrea Arcangeli | 5d68924 | 2011-01-13 15:47:07 -0800 | [diff] [blame] | 401 | select COMPACTION |
Matthew Wilcox | 57578c2 | 2016-05-20 17:01:54 -0700 | [diff] [blame] | 402 | select RADIX_TREE_MULTIORDER |
Andrea Arcangeli | 4c76d9d | 2011-01-13 15:46:39 -0800 | [diff] [blame] | 403 | help |
| 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. |
| 410 | |
| 411 | If memory constrained on embedded, you may want to say N. |
| 412 | |
Andrea Arcangeli | 13ece88 | 2011-01-13 15:47:07 -0800 | [diff] [blame] | 413 | choice |
| 414 | prompt "Transparent Hugepage Support sysfs defaults" |
| 415 | depends on TRANSPARENT_HUGEPAGE |
| 416 | default TRANSPARENT_HUGEPAGE_ALWAYS |
| 417 | help |
| 418 | Selects the sysfs defaults for Transparent Hugepage Support. |
| 419 | |
| 420 | config TRANSPARENT_HUGEPAGE_ALWAYS |
| 421 | bool "always" |
| 422 | help |
| 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. |
| 426 | |
| 427 | config TRANSPARENT_HUGEPAGE_MADVISE |
| 428 | bool "madvise" |
| 429 | help |
| 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 |
| 434 | benefit. |
| 435 | endchoice |
| 436 | |
Huang Ying | 38d8b4e | 2017-07-06 15:37:18 -0700 | [diff] [blame] | 437 | config ARCH_WANTS_THP_SWAP |
| 438 | def_bool n |
| 439 | |
| 440 | config THP_SWAP |
| 441 | def_bool y |
Huang Ying | 14fef28 | 2018-08-17 15:49:41 -0700 | [diff] [blame] | 442 | depends on TRANSPARENT_HUGEPAGE && ARCH_WANTS_THP_SWAP && SWAP |
Huang Ying | 38d8b4e | 2017-07-06 15:37:18 -0700 | [diff] [blame] | 443 | help |
| 444 | Swap transparent huge pages in one piece, without splitting. |
Huang Ying | 14fef28 | 2018-08-17 15:49:41 -0700 | [diff] [blame] | 445 | XXX: For now, swap cluster backing transparent huge page |
| 446 | will be split after swapout. |
Huang Ying | 38d8b4e | 2017-07-06 15:37:18 -0700 | [diff] [blame] | 447 | |
| 448 | For selection by architectures with reasonable THP sizes. |
| 449 | |
Kirill A. Shutemov | e496cf3 | 2016-07-26 15:26:35 -0700 | [diff] [blame] | 450 | config TRANSPARENT_HUGE_PAGECACHE |
| 451 | def_bool y |
Aneesh Kumar K.V | 953c66c | 2016-12-12 16:44:32 -0800 | [diff] [blame] | 452 | depends on TRANSPARENT_HUGEPAGE |
Kirill A. Shutemov | e496cf3 | 2016-07-26 15:26:35 -0700 | [diff] [blame] | 453 | |
| 454 | # |
Tejun Heo | bbddff0 | 2010-09-03 18:22:48 +0200 | [diff] [blame] | 455 | # UP and nommu archs use km based percpu allocator |
| 456 | # |
| 457 | config NEED_PER_CPU_KM |
| 458 | depends on !SMP |
| 459 | bool |
| 460 | default y |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 461 | |
| 462 | config CLEANCACHE |
| 463 | bool "Enable cleancache driver to cache clean pages if tmem is present" |
| 464 | default n |
| 465 | help |
| 466 | Cleancache can be thought of as a page-granularity victim cache |
| 467 | for clean pages that the kernel's pageframe replacement algorithm |
| 468 | (PFRA) would like to keep around, but can't since there isn't enough |
| 469 | memory. So when the PFRA "evicts" a page, it first attempts to use |
Michael Witten | 140a1ef | 2011-06-10 03:57:26 +0000 | [diff] [blame] | 470 | cleancache code to put the data contained in that page into |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 471 | "transcendent memory", memory that is not directly accessible or |
| 472 | addressable by the kernel and is of unknown and possibly |
| 473 | time-varying size. And when a cleancache-enabled |
| 474 | filesystem wishes to access a page in a file on disk, it first |
| 475 | checks cleancache to see if it already contains it; if it does, |
| 476 | the page is copied into the kernel and a disk access is avoided. |
| 477 | When a transcendent memory driver is available (such as zcache or |
| 478 | Xen transcendent memory), a significant I/O reduction |
| 479 | may be achieved. When none is available, all cleancache calls |
| 480 | are reduced to a single pointer-compare-against-NULL resulting |
| 481 | in a negligible performance hit. |
| 482 | |
| 483 | If unsure, say Y to enable cleancache |
Dan Magenheimer | 27c6aec | 2012-04-09 17:10:34 -0600 | [diff] [blame] | 484 | |
| 485 | config FRONTSWAP |
| 486 | bool "Enable frontswap to cache swap pages if tmem is present" |
| 487 | depends on SWAP |
| 488 | default n |
| 489 | help |
| 490 | Frontswap is so named because it can be thought of as the opposite |
| 491 | of a "backing" store for a swap device. The data is stored into |
| 492 | "transcendent memory", memory that is not directly accessible or |
| 493 | addressable by the kernel and is of unknown and possibly |
| 494 | time-varying size. When space in transcendent memory is available, |
| 495 | a significant swap I/O reduction may be achieved. When none is |
| 496 | available, all frontswap calls are reduced to a single pointer- |
| 497 | compare-against-NULL resulting in a negligible performance hit |
| 498 | and swap data is stored as normal on the matching swap device. |
| 499 | |
| 500 | If unsure, say Y to enable frontswap. |
Aneesh Kumar K.V | f825c73 | 2013-07-02 11:15:15 +0530 | [diff] [blame] | 501 | |
| 502 | config CMA |
| 503 | bool "Contiguous Memory Allocator" |
Chen Gang | de32a81 | 2013-09-12 15:14:08 -0700 | [diff] [blame] | 504 | depends on HAVE_MEMBLOCK && MMU |
Aneesh Kumar K.V | f825c73 | 2013-07-02 11:15:15 +0530 | [diff] [blame] | 505 | select MIGRATION |
| 506 | select MEMORY_ISOLATION |
| 507 | help |
| 508 | This enables the Contiguous Memory Allocator which allows other |
| 509 | subsystems to allocate big physically-contiguous blocks of memory. |
| 510 | CMA reserves a region of memory and allows only movable pages to |
| 511 | be allocated from it. This way, the kernel can use the memory for |
| 512 | pagecache and when a subsystem requests for contiguous area, the |
| 513 | allocated pages are migrated away to serve the contiguous request. |
| 514 | |
| 515 | If unsure, say "n". |
| 516 | |
| 517 | config CMA_DEBUG |
| 518 | bool "CMA debug messages (DEVELOPMENT)" |
| 519 | depends on DEBUG_KERNEL && CMA |
| 520 | help |
| 521 | Turns on debug messages in CMA. This produces KERN_DEBUG |
| 522 | messages for every CMA call as well as various messages while |
| 523 | processing calls such as dma_alloc_from_contiguous(). |
| 524 | This option does not affect warning and error messages. |
Alexander Graf | bf550fc | 2013-08-29 00:41:59 +0200 | [diff] [blame] | 525 | |
Sasha Levin | 28b24c1 | 2015-04-14 15:44:57 -0700 | [diff] [blame] | 526 | config CMA_DEBUGFS |
| 527 | bool "CMA debugfs interface" |
| 528 | depends on CMA && DEBUG_FS |
| 529 | help |
| 530 | Turns on the DebugFS interface for CMA. |
| 531 | |
Prakash Gupta | 76adf14 | 2019-07-23 16:46:41 +0530 | [diff] [blame] | 532 | config CMA_ALLOW_WRITE_DEBUGFS |
| 533 | depends on CMA_DEBUGFS |
| 534 | bool "Allow CMA debugfs write" |
| 535 | help |
| 536 | Say 'y' here to allow the CMA debugfs write. |
| 537 | CMA debugfs write could be risky as it allows |
| 538 | cma allocation, so it is not recommended to |
| 539 | enable this option on any production device. |
| 540 | |
Joonsoo Kim | a254129 | 2014-08-06 16:05:25 -0700 | [diff] [blame] | 541 | config CMA_AREAS |
| 542 | int "Maximum count of the CMA areas" |
| 543 | depends on CMA |
| 544 | default 7 |
| 545 | help |
| 546 | CMA allows to create CMA areas for particular purpose, mainly, |
| 547 | used as device private area. This parameter sets the maximum |
| 548 | number of CMA area in the system. |
| 549 | |
| 550 | If unsure, leave the default value "7". |
| 551 | |
Dan Streetman | af8d417 | 2014-08-06 16:08:36 -0700 | [diff] [blame] | 552 | config MEM_SOFT_DIRTY |
| 553 | bool "Track memory changes" |
| 554 | depends on CHECKPOINT_RESTORE && HAVE_ARCH_SOFT_DIRTY && PROC_FS |
| 555 | select PROC_PAGE_MONITOR |
Seth Jennings | 4e2e277 | 2013-07-10 16:04:55 -0700 | [diff] [blame] | 556 | help |
Dan Streetman | af8d417 | 2014-08-06 16:08:36 -0700 | [diff] [blame] | 557 | This option enables memory changes tracking by introducing a |
| 558 | soft-dirty bit on pte-s. This bit it set when someone writes |
| 559 | into a page just as regular dirty bit, but unlike the latter |
| 560 | it can be cleared by hands. |
| 561 | |
Mike Rapoport | 1ad1335 | 2018-04-18 11:07:49 +0300 | [diff] [blame] | 562 | See Documentation/admin-guide/mm/soft-dirty.rst for more details. |
Seth Jennings | 4e2e277 | 2013-07-10 16:04:55 -0700 | [diff] [blame] | 563 | |
Seth Jennings | 2b28111 | 2013-07-10 16:05:03 -0700 | [diff] [blame] | 564 | config ZSWAP |
| 565 | bool "Compressed cache for swap pages (EXPERIMENTAL)" |
| 566 | depends on FRONTSWAP && CRYPTO=y |
| 567 | select CRYPTO_LZO |
Dan Streetman | 12d79d6 | 2014-08-06 16:08:40 -0700 | [diff] [blame] | 568 | select ZPOOL |
Seth Jennings | 2b28111 | 2013-07-10 16:05:03 -0700 | [diff] [blame] | 569 | default n |
| 570 | help |
| 571 | A lightweight compressed cache for swap pages. It takes |
| 572 | pages that are in the process of being swapped out and attempts to |
| 573 | compress them into a dynamically allocated RAM-based memory pool. |
| 574 | This can result in a significant I/O reduction on swap device and, |
| 575 | in the case where decompressing from RAM is faster that swap device |
| 576 | reads, can also improve workload performance. |
| 577 | |
| 578 | This is marked experimental because it is a new feature (as of |
| 579 | v3.11) that interacts heavily with memory reclaim. While these |
| 580 | interactions don't cause any known issues on simple memory setups, |
| 581 | they have not be fully explored on the large set of potential |
| 582 | configurations and workloads that exist. |
| 583 | |
Dan Streetman | af8d417 | 2014-08-06 16:08:36 -0700 | [diff] [blame] | 584 | config ZPOOL |
| 585 | tristate "Common API for compressed memory storage" |
| 586 | default n |
Pavel Emelyanov | 0f8975e | 2013-07-03 15:01:20 -0700 | [diff] [blame] | 587 | help |
Dan Streetman | af8d417 | 2014-08-06 16:08:36 -0700 | [diff] [blame] | 588 | Compressed memory storage API. This allows using either zbud or |
| 589 | zsmalloc. |
Pavel Emelyanov | 0f8975e | 2013-07-03 15:01:20 -0700 | [diff] [blame] | 590 | |
Dan Streetman | af8d417 | 2014-08-06 16:08:36 -0700 | [diff] [blame] | 591 | config ZBUD |
Vitaly Wool | 9a001fc | 2016-05-20 16:58:30 -0700 | [diff] [blame] | 592 | tristate "Low (Up to 2x) density storage for compressed pages" |
Dan Streetman | af8d417 | 2014-08-06 16:08:36 -0700 | [diff] [blame] | 593 | default n |
| 594 | help |
| 595 | A special purpose allocator for storing compressed pages. |
| 596 | It is designed to store up to two compressed pages per physical |
| 597 | page. While this design limits storage density, it has simple and |
| 598 | deterministic reclaim properties that make it preferable to a higher |
| 599 | density approach when reclaim will be used. |
Minchan Kim | bcf1647 | 2014-01-30 15:45:50 -0800 | [diff] [blame] | 600 | |
Vitaly Wool | 9a001fc | 2016-05-20 16:58:30 -0700 | [diff] [blame] | 601 | config Z3FOLD |
| 602 | tristate "Up to 3x density storage for compressed pages" |
| 603 | depends on ZPOOL |
| 604 | default n |
| 605 | help |
| 606 | A special purpose allocator for storing compressed pages. |
| 607 | It is designed to store up to three compressed pages per physical |
| 608 | page. It is a ZBUD derivative so the simplicity and determinism are |
| 609 | still there. |
| 610 | |
Minchan Kim | bcf1647 | 2014-01-30 15:45:50 -0800 | [diff] [blame] | 611 | config ZSMALLOC |
Minchan Kim | d867f20 | 2014-06-04 16:11:10 -0700 | [diff] [blame] | 612 | tristate "Memory allocator for compressed pages" |
Minchan Kim | bcf1647 | 2014-01-30 15:45:50 -0800 | [diff] [blame] | 613 | depends on MMU |
| 614 | default n |
| 615 | help |
| 616 | zsmalloc is a slab-based memory allocator designed to store |
| 617 | compressed RAM pages. zsmalloc uses virtual memory mapping |
| 618 | in order to reduce fragmentation. However, this results in a |
| 619 | non-standard allocator interface where a handle, not a pointer, is |
| 620 | returned by an alloc(). This handle must be mapped in order to |
| 621 | access the allocated space. |
| 622 | |
| 623 | config PGTABLE_MAPPING |
| 624 | bool "Use page table mapping to access object in zsmalloc" |
| 625 | depends on ZSMALLOC |
| 626 | help |
| 627 | By default, zsmalloc uses a copy-based object mapping method to |
| 628 | access allocations that span two pages. However, if a particular |
| 629 | architecture (ex, ARM) performs VM mapping faster than copying, |
| 630 | then you should select this. This causes zsmalloc to use page table |
| 631 | mapping rather than copying for object mapping. |
| 632 | |
Ben Hutchings | 2216ee8 | 2014-03-10 15:49:46 -0700 | [diff] [blame] | 633 | You can check speed with zsmalloc benchmark: |
| 634 | https://github.com/spartacus06/zsmapbench |
Mark Salter | 9e5c33d | 2014-04-07 15:39:48 -0700 | [diff] [blame] | 635 | |
Ganesh Mahendran | 0f050d9 | 2015-02-12 15:00:54 -0800 | [diff] [blame] | 636 | config ZSMALLOC_STAT |
| 637 | bool "Export zsmalloc statistics" |
| 638 | depends on ZSMALLOC |
| 639 | select DEBUG_FS |
| 640 | help |
| 641 | This option enables code in the zsmalloc to collect various |
| 642 | statistics about whats happening in zsmalloc and exports that |
| 643 | information to userspace via debugfs. |
| 644 | If unsure, say N. |
| 645 | |
Zhenhua Huang | 00af848 | 2018-06-21 12:54:40 +0800 | [diff] [blame] | 646 | config VMAP_LAZY_PURGING_FACTOR |
| 647 | int "multiplier to the size of purged vmap areas" |
| 648 | default "8" if ARM |
| 649 | default "32" |
| 650 | help |
| 651 | It is used as a multiplier to the max VA pages purged in a |
| 652 | single attempt. For 32-bit in order to reduce fragmentation |
| 653 | of vmalloc space, we decrease the default value to "8". |
| 654 | |
| 655 | |
Mark Salter | 9e5c33d | 2014-04-07 15:39:48 -0700 | [diff] [blame] | 656 | config GENERIC_EARLY_IOREMAP |
| 657 | bool |
Helge Deller | 042d27a | 2014-04-30 23:26:02 +0200 | [diff] [blame] | 658 | |
| 659 | config MAX_STACK_SIZE_MB |
| 660 | int "Maximum user stack size for 32-bit processes (MB)" |
| 661 | default 80 |
Helge Deller | 042d27a | 2014-04-30 23:26:02 +0200 | [diff] [blame] | 662 | range 8 2048 |
| 663 | depends on STACK_GROWSUP && (!64BIT || COMPAT) |
| 664 | help |
| 665 | This is the maximum stack size in Megabytes in the VM layout of 32-bit |
| 666 | user processes when the stack grows upwards (currently only on parisc |
James Hogan | 5f17157 | 2017-10-24 16:52:32 +0100 | [diff] [blame] | 667 | arch). The stack will be located at the highest memory address minus |
| 668 | the given value, unless the RLIMIT_STACK hard limit is changed to a |
| 669 | smaller value in which case that is used. |
Helge Deller | 042d27a | 2014-04-30 23:26:02 +0200 | [diff] [blame] | 670 | |
| 671 | A sane initial value is 80 MB. |
Mel Gorman | 3a80a7f | 2015-06-30 14:57:02 -0700 | [diff] [blame] | 672 | |
Patrick Daly | b066272 | 2017-03-14 18:30:41 -0700 | [diff] [blame] | 673 | config BALANCE_ANON_FILE_RECLAIM |
| 674 | bool "During reclaim treat anon and file backed pages equally" |
| 675 | depends on SWAP |
| 676 | help |
| 677 | When performing memory reclaim treat anonymous and file backed pages |
| 678 | equally. |
| 679 | Swapping anonymous pages out to memory can be efficient enough to justify |
| 680 | treating anonymous and file backed pages equally. |
| 681 | |
Mel Gorman | 3a80a7f | 2015-06-30 14:57:02 -0700 | [diff] [blame] | 682 | config DEFERRED_STRUCT_PAGE_INIT |
Vlastimil Babka | 1ce2210 | 2016-02-05 15:36:21 -0800 | [diff] [blame] | 683 | bool "Defer initialisation of struct pages to kthreads" |
Mel Gorman | 3a80a7f | 2015-06-30 14:57:02 -0700 | [diff] [blame] | 684 | default n |
Pavel Tatashin | 2e3ca40 | 2018-01-31 16:16:02 -0800 | [diff] [blame] | 685 | depends on NO_BOOTMEM |
Mike Rapoport | d39f8fb | 2018-08-17 15:47:07 -0700 | [diff] [blame] | 686 | depends on SPARSEMEM |
Pavel Tatashin | ab1e8d8 | 2018-05-18 16:09:13 -0700 | [diff] [blame] | 687 | depends on !NEED_PER_CPU_KM |
Pasha Tatashin | 889c695 | 2018-09-20 12:22:30 -0700 | [diff] [blame] | 688 | depends on 64BIT |
Mel Gorman | 3a80a7f | 2015-06-30 14:57:02 -0700 | [diff] [blame] | 689 | help |
| 690 | Ordinarily all struct pages are initialised during early boot in a |
| 691 | single thread. On very large machines this can take a considerable |
| 692 | amount of time. If this option is set, large machines will bring up |
| 693 | a subset of memmap at boot and then initialise the rest in parallel |
Vlastimil Babka | 1ce2210 | 2016-02-05 15:36:21 -0800 | [diff] [blame] | 694 | by starting one-off "pgdatinitX" kernel thread for each node X. This |
| 695 | has a potential performance impact on processes running early in the |
| 696 | lifetime of the system until these kthreads finish the |
| 697 | initialisation. |
Dan Williams | 033fbae | 2015-08-09 15:29:06 -0400 | [diff] [blame] | 698 | |
Vladimir Davydov | 33c3fc7 | 2015-09-09 15:35:45 -0700 | [diff] [blame] | 699 | config IDLE_PAGE_TRACKING |
| 700 | bool "Enable idle page tracking" |
| 701 | depends on SYSFS && MMU |
| 702 | select PAGE_EXTENSION if !64BIT |
| 703 | help |
| 704 | This feature allows to estimate the amount of user pages that have |
| 705 | not been touched during a given period of time. This information can |
| 706 | be useful to tune memory cgroup limits and/or for job placement |
| 707 | within a compute cluster. |
| 708 | |
Mike Rapoport | 1ad1335 | 2018-04-18 11:07:49 +0300 | [diff] [blame] | 709 | See Documentation/admin-guide/mm/idle_page_tracking.rst for |
| 710 | more details. |
Vladimir Davydov | 33c3fc7 | 2015-09-09 15:35:45 -0700 | [diff] [blame] | 711 | |
Oliver O'Halloran | 65f7d04 | 2017-06-28 11:32:31 +1000 | [diff] [blame] | 712 | # arch_add_memory() comprehends device memory |
| 713 | config ARCH_HAS_ZONE_DEVICE |
| 714 | bool |
| 715 | |
Dan Williams | 033fbae | 2015-08-09 15:29:06 -0400 | [diff] [blame] | 716 | config ZONE_DEVICE |
Jérôme Glisse | 5042db4 | 2017-09-08 16:11:43 -0700 | [diff] [blame] | 717 | bool "Device memory (pmem, HMM, etc...) hotplug support" |
Dan Williams | 033fbae | 2015-08-09 15:29:06 -0400 | [diff] [blame] | 718 | depends on MEMORY_HOTPLUG |
| 719 | depends on MEMORY_HOTREMOVE |
Dan Williams | 99490f1 | 2016-03-17 14:19:58 -0700 | [diff] [blame] | 720 | depends on SPARSEMEM_VMEMMAP |
Oliver O'Halloran | 65f7d04 | 2017-06-28 11:32:31 +1000 | [diff] [blame] | 721 | depends on ARCH_HAS_ZONE_DEVICE |
Dan Williams | ab1b597 | 2017-09-06 16:24:13 -0700 | [diff] [blame] | 722 | select RADIX_TREE_MULTIORDER |
Dan Williams | 033fbae | 2015-08-09 15:29:06 -0400 | [diff] [blame] | 723 | |
| 724 | help |
| 725 | Device memory hotplug support allows for establishing pmem, |
| 726 | or other device driver discovered memory regions, in the |
| 727 | memmap. This allows pfn_to_page() lookups of otherwise |
| 728 | "device-physical" addresses which is needed for using a DAX |
| 729 | mapping in an O_DIRECT operation, among other things. |
| 730 | |
| 731 | If FS_DAX is enabled, then say Y. |
Linus Torvalds | 06a660a | 2015-09-11 16:42:39 -0700 | [diff] [blame] | 732 | |
Jérôme Glisse | 133ff0e | 2017-09-08 16:11:23 -0700 | [diff] [blame] | 733 | config ARCH_HAS_HMM |
| 734 | bool |
| 735 | default y |
| 736 | depends on (X86_64 || PPC64) |
| 737 | depends on ZONE_DEVICE |
| 738 | depends on MMU && 64BIT |
| 739 | depends on MEMORY_HOTPLUG |
| 740 | depends on MEMORY_HOTREMOVE |
| 741 | depends on SPARSEMEM_VMEMMAP |
| 742 | |
Jérôme Glisse | 6b368cd | 2017-09-08 16:12:32 -0700 | [diff] [blame] | 743 | config MIGRATE_VMA_HELPER |
| 744 | bool |
| 745 | |
Dan Williams | e7638488 | 2018-05-16 11:46:08 -0700 | [diff] [blame] | 746 | config DEV_PAGEMAP_OPS |
| 747 | bool |
| 748 | |
Jérôme Glisse | 133ff0e | 2017-09-08 16:11:23 -0700 | [diff] [blame] | 749 | config HMM |
| 750 | bool |
Jérôme Glisse | 85e1a6c | 2019-05-13 17:19:45 -0700 | [diff] [blame] | 751 | select MMU_NOTIFIER |
Jérôme Glisse | 6b368cd | 2017-09-08 16:12:32 -0700 | [diff] [blame] | 752 | select MIGRATE_VMA_HELPER |
Jérôme Glisse | 133ff0e | 2017-09-08 16:11:23 -0700 | [diff] [blame] | 753 | |
Jérôme Glisse | c0b1240 | 2017-09-08 16:11:27 -0700 | [diff] [blame] | 754 | config HMM_MIRROR |
| 755 | bool "HMM mirror CPU page table into a device page table" |
| 756 | depends on ARCH_HAS_HMM |
Jérôme Glisse | c0b1240 | 2017-09-08 16:11:27 -0700 | [diff] [blame] | 757 | select HMM |
| 758 | help |
| 759 | Select HMM_MIRROR if you want to mirror range of the CPU page table of a |
| 760 | process into a device page table. Here, mirror means "keep synchronized". |
| 761 | Prerequisites: the device must provide the ability to write-protect its |
| 762 | page tables (at PAGE_SIZE granularity), and must be able to recover from |
| 763 | the resulting potential page faults. |
| 764 | |
Jérôme Glisse | 5042db4 | 2017-09-08 16:11:43 -0700 | [diff] [blame] | 765 | config DEVICE_PRIVATE |
| 766 | bool "Unaddressable device memory (GPU memory, ...)" |
| 767 | depends on ARCH_HAS_HMM |
Jérôme Glisse | df6ad69 | 2017-09-08 16:12:24 -0700 | [diff] [blame] | 768 | select HMM |
Dan Williams | e7638488 | 2018-05-16 11:46:08 -0700 | [diff] [blame] | 769 | select DEV_PAGEMAP_OPS |
Jérôme Glisse | 5042db4 | 2017-09-08 16:11:43 -0700 | [diff] [blame] | 770 | |
| 771 | help |
| 772 | Allows creation of struct pages to represent unaddressable device |
| 773 | memory; i.e., memory that is only accessible from the device (or |
| 774 | group of devices). You likely also want to select HMM_MIRROR. |
| 775 | |
Jérôme Glisse | df6ad69 | 2017-09-08 16:12:24 -0700 | [diff] [blame] | 776 | config DEVICE_PUBLIC |
| 777 | bool "Addressable device memory (like GPU memory)" |
| 778 | depends on ARCH_HAS_HMM |
| 779 | select HMM |
Dan Williams | e7638488 | 2018-05-16 11:46:08 -0700 | [diff] [blame] | 780 | select DEV_PAGEMAP_OPS |
Jérôme Glisse | df6ad69 | 2017-09-08 16:12:24 -0700 | [diff] [blame] | 781 | |
| 782 | help |
| 783 | Allows creation of struct pages to represent addressable device |
| 784 | memory; i.e., memory that is accessible from both the device and |
| 785 | the CPU |
| 786 | |
Jan Kara | 8025e5d | 2015-07-13 11:55:44 -0300 | [diff] [blame] | 787 | config FRAME_VECTOR |
| 788 | bool |
Dave Hansen | 63c17fb | 2016-02-12 13:02:08 -0800 | [diff] [blame] | 789 | |
| 790 | config ARCH_USES_HIGH_VMA_FLAGS |
| 791 | bool |
Dave Hansen | 66d3757 | 2016-02-12 13:02:32 -0800 | [diff] [blame] | 792 | config ARCH_HAS_PKEYS |
| 793 | bool |
Dennis Zhou | 30a5b53 | 2017-06-19 19:28:31 -0400 | [diff] [blame] | 794 | |
| 795 | config PERCPU_STATS |
| 796 | bool "Collect percpu memory statistics" |
| 797 | default n |
| 798 | help |
| 799 | This feature collects and exposes statistics via debugfs. The |
| 800 | information includes global and per chunk statistics, which can |
| 801 | be used to help understand percpu memory usage. |
Kirill A. Shutemov | 64c349f | 2017-11-17 15:31:22 -0800 | [diff] [blame] | 802 | |
Laurent Dufour | fb1b535 | 2018-04-17 16:33:07 +0200 | [diff] [blame] | 803 | config ARCH_SUPPORTS_SPECULATIVE_PAGE_FAULT |
| 804 | def_bool n |
| 805 | |
| 806 | config SPECULATIVE_PAGE_FAULT |
| 807 | bool "Speculative page faults" |
| 808 | default y |
| 809 | depends on ARCH_SUPPORTS_SPECULATIVE_PAGE_FAULT |
| 810 | depends on MMU && SMP |
| 811 | help |
| 812 | Try to handle user space page faults without holding the mmap_sem. |
| 813 | |
| 814 | This should allow better concurrency for massively threaded process |
| 815 | since the page fault handler will not wait for other threads memory |
| 816 | layout change to be done, assuming that this change is done in another |
| 817 | part of the process's memory space. This type of page fault is named |
| 818 | speculative page fault. |
| 819 | |
| 820 | If the speculative page fault fails because of a concurrency is |
| 821 | detected or because underlying PMD or PTE tables are not yet |
| 822 | allocating, it is failing its processing and a classic page fault |
| 823 | is then tried. |
| 824 | |
Patrick Daly | aa9e75a | 2019-02-21 12:55:10 -0800 | [diff] [blame] | 825 | config HAVE_USERSPACE_LOW_MEMORY_KILLER |
| 826 | bool "Have userspace low memory killer" |
| 827 | default n |
| 828 | help |
| 829 | The page allocator cannot directly call into a |
| 830 | userspace low memory killer as it can call into the OOM killer. |
| 831 | Therefore, add a timeout mechanism to give the userspace |
| 832 | low memory killer a chance to run. |
| 833 | |
Kirill A. Shutemov | 64c349f | 2017-11-17 15:31:22 -0800 | [diff] [blame] | 834 | config GUP_BENCHMARK |
| 835 | bool "Enable infrastructure for get_user_pages_fast() benchmarking" |
| 836 | default n |
| 837 | help |
| 838 | Provides /sys/kernel/debug/gup_benchmark that helps with testing |
| 839 | performance of get_user_pages_fast(). |
| 840 | |
| 841 | See tools/testing/selftests/vm/gup_benchmark.c |
Laurent Dufour | 3010a5e | 2018-06-07 17:06:08 -0700 | [diff] [blame] | 842 | |
| 843 | config ARCH_HAS_PTE_SPECIAL |
| 844 | bool |
Christoph Hellwig | 59e0b52 | 2018-07-31 13:39:35 +0200 | [diff] [blame] | 845 | |
| 846 | endmenu |
Minchan Kim | fd3a0c0 | 2013-05-09 16:21:24 +0900 | [diff] [blame] | 847 | |
| 848 | config PROCESS_RECLAIM |
| 849 | bool "Enable process reclaim" |
| 850 | depends on PROC_FS |
| 851 | default y |
| 852 | help |
| 853 | It allows to reclaim pages of the process by /proc/pid/reclaim. |
| 854 | |
| 855 | (echo file > /proc/PID/reclaim) reclaims file-backed pages only. |
| 856 | (echo anon > /proc/PID/reclaim) reclaims anonymous pages only. |
| 857 | (echo all > /proc/PID/reclaim) reclaims all pages. |
| 858 | |
Minchan Kim | 635a7ed | 2013-05-09 16:21:28 +0900 | [diff] [blame] | 859 | (echo addr size-byte > /proc/PID/reclaim) reclaims pages in |
| 860 | (addr, addr + size-bytes) of the process. |
| 861 | |
Minchan Kim | fd3a0c0 | 2013-05-09 16:21:24 +0900 | [diff] [blame] | 862 | Any other value is ignored. |