Dave Hansen | e1785e8 | 2005-06-23 00:07:49 -0700 | [diff] [blame] | 1 | config SELECT_MEMORY_MODEL |
| 2 | def_bool y |
Kees Cook | a8826ee | 2013-01-16 18:54:17 -0800 | [diff] [blame] | 3 | depends on ARCH_SELECT_MEMORY_MODEL |
Dave Hansen | e1785e8 | 2005-06-23 00:07:49 -0700 | [diff] [blame] | 4 | |
Dave Hansen | 3a9da76 | 2005-06-23 00:07:42 -0700 | [diff] [blame] | 5 | choice |
| 6 | prompt "Memory model" |
Dave Hansen | e1785e8 | 2005-06-23 00:07:49 -0700 | [diff] [blame] | 7 | depends on SELECT_MEMORY_MODEL |
| 8 | default DISCONTIGMEM_MANUAL if ARCH_DISCONTIGMEM_DEFAULT |
Andy Whitcroft | d41dee3 | 2005-06-23 00:07:54 -0700 | [diff] [blame] | 9 | default SPARSEMEM_MANUAL if ARCH_SPARSEMEM_DEFAULT |
Dave Hansen | e1785e8 | 2005-06-23 00:07:49 -0700 | [diff] [blame] | 10 | default FLATMEM_MANUAL |
Dave Hansen | 3a9da76 | 2005-06-23 00:07:42 -0700 | [diff] [blame] | 11 | |
Dave Hansen | e1785e8 | 2005-06-23 00:07:49 -0700 | [diff] [blame] | 12 | config FLATMEM_MANUAL |
Dave Hansen | 3a9da76 | 2005-06-23 00:07:42 -0700 | [diff] [blame] | 13 | bool "Flat Memory" |
Anton Blanchard | c898ec1 | 2006-01-06 00:12:07 -0800 | [diff] [blame] | 14 | depends on !(ARCH_DISCONTIGMEM_ENABLE || ARCH_SPARSEMEM_ENABLE) || ARCH_FLATMEM_ENABLE |
Dave Hansen | 3a9da76 | 2005-06-23 00:07:42 -0700 | [diff] [blame] | 15 | help |
| 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 |
| 19 | and a correct option. |
| 20 | |
Andy Whitcroft | d41dee3 | 2005-06-23 00:07:54 -0700 | [diff] [blame] | 21 | Some users of more advanced features like NUMA and |
| 22 | memory hotplug may have different options here. |
| 23 | DISCONTIGMEM is an 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". |
| 28 | |
| 29 | If unsure, choose this option (Flat Memory) over any other. |
Dave Hansen | 3a9da76 | 2005-06-23 00:07:42 -0700 | [diff] [blame] | 30 | |
Dave Hansen | e1785e8 | 2005-06-23 00:07:49 -0700 | [diff] [blame] | 31 | config DISCONTIGMEM_MANUAL |
Dave Hansen | f3519f9 | 2005-09-16 19:27:54 -0700 | [diff] [blame] | 32 | bool "Discontiguous Memory" |
Dave Hansen | 3a9da76 | 2005-06-23 00:07:42 -0700 | [diff] [blame] | 33 | depends on ARCH_DISCONTIGMEM_ENABLE |
| 34 | help |
Dave Hansen | 785dcd4 | 2005-06-23 00:07:50 -0700 | [diff] [blame] | 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 |
Philipp Marek | ad3d0a3 | 2007-10-20 02:46:58 +0200 | [diff] [blame] | 40 | can have degraded performance from the extra overhead that |
Dave Hansen | 785dcd4 | 2005-06-23 00:07:50 -0700 | [diff] [blame] | 41 | this option imposes. |
| 42 | |
| 43 | Many NUMA configurations will have this as the only option. |
| 44 | |
Dave Hansen | 3a9da76 | 2005-06-23 00:07:42 -0700 | [diff] [blame] | 45 | If unsure, choose "Flat Memory" over this option. |
| 46 | |
Andy Whitcroft | d41dee3 | 2005-06-23 00:07:54 -0700 | [diff] [blame] | 47 | config SPARSEMEM_MANUAL |
| 48 | bool "Sparse Memory" |
| 49 | depends on ARCH_SPARSEMEM_ENABLE |
| 50 | help |
| 51 | This will be the only option for some systems, including |
| 52 | memory hotplug systems. This is normal. |
| 53 | |
| 54 | For many other systems, this will be an alternative to |
Dave Hansen | f3519f9 | 2005-09-16 19:27:54 -0700 | [diff] [blame] | 55 | "Discontiguous Memory". This option provides some potential |
Andy Whitcroft | d41dee3 | 2005-06-23 00:07:54 -0700 | [diff] [blame] | 56 | performance benefits, along with decreased code complexity, |
| 57 | but it is newer, and more experimental. |
| 58 | |
| 59 | If unsure, choose "Discontiguous Memory" or "Flat Memory" |
| 60 | over this option. |
| 61 | |
Dave Hansen | 3a9da76 | 2005-06-23 00:07:42 -0700 | [diff] [blame] | 62 | endchoice |
| 63 | |
Dave Hansen | e1785e8 | 2005-06-23 00:07:49 -0700 | [diff] [blame] | 64 | config DISCONTIGMEM |
| 65 | def_bool y |
| 66 | depends on (!SELECT_MEMORY_MODEL && ARCH_DISCONTIGMEM_ENABLE) || DISCONTIGMEM_MANUAL |
| 67 | |
Andy Whitcroft | d41dee3 | 2005-06-23 00:07:54 -0700 | [diff] [blame] | 68 | config SPARSEMEM |
| 69 | def_bool y |
Russell King | 1a83e17 | 2009-10-26 16:50:12 -0700 | [diff] [blame] | 70 | depends on (!SELECT_MEMORY_MODEL && ARCH_SPARSEMEM_ENABLE) || SPARSEMEM_MANUAL |
Andy Whitcroft | d41dee3 | 2005-06-23 00:07:54 -0700 | [diff] [blame] | 71 | |
Dave Hansen | e1785e8 | 2005-06-23 00:07:49 -0700 | [diff] [blame] | 72 | config FLATMEM |
| 73 | def_bool y |
Andy Whitcroft | d41dee3 | 2005-06-23 00:07:54 -0700 | [diff] [blame] | 74 | depends on (!DISCONTIGMEM && !SPARSEMEM) || FLATMEM_MANUAL |
| 75 | |
| 76 | config FLAT_NODE_MEM_MAP |
| 77 | def_bool y |
| 78 | depends on !SPARSEMEM |
Dave Hansen | e1785e8 | 2005-06-23 00:07:49 -0700 | [diff] [blame] | 79 | |
Dave Hansen | 93b7504 | 2005-06-23 00:07:47 -0700 | [diff] [blame] | 80 | # |
| 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. |
| 84 | # |
| 85 | config NEED_MULTIPLE_NODES |
| 86 | def_bool y |
| 87 | depends on DISCONTIGMEM || NUMA |
Andy Whitcroft | af70536 | 2005-06-23 00:07:53 -0700 | [diff] [blame] | 88 | |
| 89 | config HAVE_MEMORY_PRESENT |
| 90 | def_bool y |
Andy Whitcroft | d41dee3 | 2005-06-23 00:07:54 -0700 | [diff] [blame] | 91 | depends on ARCH_HAVE_MEMORY_PRESENT || SPARSEMEM |
Bob Picco | 802f192 | 2005-09-03 15:54:26 -0700 | [diff] [blame] | 92 | |
| 93 | # |
Bob Picco | 3e34726 | 2005-09-03 15:54:28 -0700 | [diff] [blame] | 94 | # SPARSEMEM_EXTREME (which is the default) does some bootmem |
Matt LaPlante | 84eb8d0 | 2006-10-03 22:53:09 +0200 | [diff] [blame] | 95 | # allocations when memory_present() is called. If this cannot |
Bob Picco | 3e34726 | 2005-09-03 15:54:28 -0700 | [diff] [blame] | 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. |
| 99 | # |
| 100 | # This option will also potentially produce smaller runtime code |
| 101 | # with gcc 3.4 and later. |
| 102 | # |
| 103 | config SPARSEMEM_STATIC |
Jan Beulich | 9ba1608 | 2008-10-15 22:01:38 -0700 | [diff] [blame] | 104 | bool |
Bob Picco | 3e34726 | 2005-09-03 15:54:28 -0700 | [diff] [blame] | 105 | |
| 106 | # |
Matt LaPlante | 44c0920 | 2006-10-03 22:34:14 +0200 | [diff] [blame] | 107 | # Architecture platforms which require a two level mem_section in SPARSEMEM |
Bob Picco | 802f192 | 2005-09-03 15:54:26 -0700 | [diff] [blame] | 108 | # must select this option. This is usually for architecture platforms with |
| 109 | # an extremely sparse physical address space. |
| 110 | # |
Bob Picco | 3e34726 | 2005-09-03 15:54:28 -0700 | [diff] [blame] | 111 | config SPARSEMEM_EXTREME |
| 112 | def_bool y |
| 113 | depends on SPARSEMEM && !SPARSEMEM_STATIC |
Hugh Dickins | 4c21e2f | 2005-10-29 18:16:40 -0700 | [diff] [blame] | 114 | |
Andy Whitcroft | 29c7111 | 2007-10-16 01:24:14 -0700 | [diff] [blame] | 115 | config SPARSEMEM_VMEMMAP_ENABLE |
Jan Beulich | 9ba1608 | 2008-10-15 22:01:38 -0700 | [diff] [blame] | 116 | bool |
Andy Whitcroft | 29c7111 | 2007-10-16 01:24:14 -0700 | [diff] [blame] | 117 | |
Yinghai Lu | 9bdac91 | 2010-02-10 01:20:22 -0800 | [diff] [blame] | 118 | config SPARSEMEM_ALLOC_MEM_MAP_TOGETHER |
| 119 | def_bool y |
| 120 | depends on SPARSEMEM && X86_64 |
| 121 | |
Andy Whitcroft | 29c7111 | 2007-10-16 01:24:14 -0700 | [diff] [blame] | 122 | config SPARSEMEM_VMEMMAP |
Geoff Levand | a5ee6da | 2007-12-17 16:19:53 -0800 | [diff] [blame] | 123 | bool "Sparse Memory virtual memmap" |
| 124 | depends on SPARSEMEM && SPARSEMEM_VMEMMAP_ENABLE |
| 125 | default y |
| 126 | help |
| 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. |
Andy Whitcroft | 29c7111 | 2007-10-16 01:24:14 -0700 | [diff] [blame] | 130 | |
Yinghai Lu | 95f72d1 | 2010-07-12 14:36:09 +1000 | [diff] [blame] | 131 | config HAVE_MEMBLOCK |
| 132 | boolean |
| 133 | |
Tejun Heo | 7c0caeb | 2011-07-14 11:43:42 +0200 | [diff] [blame] | 134 | config HAVE_MEMBLOCK_NODE_MAP |
| 135 | boolean |
| 136 | |
Tejun Heo | c378ddd | 2011-07-14 11:46:03 +0200 | [diff] [blame] | 137 | config ARCH_DISCARD_MEMBLOCK |
| 138 | boolean |
| 139 | |
Sam Ravnborg | 6661672 | 2011-10-31 17:08:20 -0700 | [diff] [blame] | 140 | config NO_BOOTMEM |
| 141 | boolean |
| 142 | |
Minchan Kim | ee6f509 | 2012-07-31 16:43:50 -0700 | [diff] [blame] | 143 | config MEMORY_ISOLATION |
| 144 | boolean |
| 145 | |
Lai Jiangshan | 20b2f52 | 2012-12-12 13:52:00 -0800 | [diff] [blame] | 146 | config MOVABLE_NODE |
| 147 | boolean "Enable to assign a node which has only movable memory" |
| 148 | depends on HAVE_MEMBLOCK |
| 149 | depends on NO_BOOTMEM |
| 150 | depends on X86_64 |
| 151 | depends on NUMA |
Tang Chen | c297405 | 2012-12-18 14:21:33 -0800 | [diff] [blame] | 152 | default n |
| 153 | help |
| 154 | Allow a node to have only movable memory. Pages used by the kernel, |
| 155 | such as direct mapping pages cannot be migrated. So the corresponding |
Tang Chen | c532092 | 2013-11-12 15:08:10 -0800 | [diff] [blame] | 156 | memory device cannot be hotplugged. This option allows the following |
| 157 | two things: |
| 158 | - When the system is booting, node full of hotpluggable memory can |
| 159 | be arranged to have only movable memory so that the whole node can |
| 160 | be hot-removed. (need movable_node boot option specified). |
| 161 | - After the system is up, the option allows users to online all the |
| 162 | memory of a node as movable memory so that the whole node can be |
| 163 | hot-removed. |
| 164 | |
| 165 | Users who don't use the memory hotplug feature are fine with this |
| 166 | option on since they don't specify movable_node boot option or they |
| 167 | don't online memory as movable. |
Tang Chen | c297405 | 2012-12-18 14:21:33 -0800 | [diff] [blame] | 168 | |
| 169 | Say Y here if you want to hotplug a whole node. |
| 170 | Say N here if you want kernel to use memory on all nodes evenly. |
Lai Jiangshan | 20b2f52 | 2012-12-12 13:52:00 -0800 | [diff] [blame] | 171 | |
Yasuaki Ishimatsu | 46723bf | 2013-02-22 16:33:00 -0800 | [diff] [blame] | 172 | # |
| 173 | # Only be set on architectures that have completely implemented memory hotplug |
| 174 | # feature. If you are not sure, don't touch it. |
| 175 | # |
| 176 | config HAVE_BOOTMEM_INFO_NODE |
| 177 | def_bool n |
| 178 | |
Dave Hansen | 3947be1 | 2005-10-29 18:16:54 -0700 | [diff] [blame] | 179 | # eventually, we can have this option just 'select SPARSEMEM' |
| 180 | config MEMORY_HOTPLUG |
| 181 | bool "Allow for memory hot-add" |
Keith Mannthey | ec69acb | 2006-09-30 23:27:05 -0700 | [diff] [blame] | 182 | depends on SPARSEMEM || X86_64_ACPI_NUMA |
Stephen Rothwell | 40b3136 | 2013-05-21 13:49:35 +1000 | [diff] [blame] | 183 | depends on ARCH_ENABLE_MEMORY_HOTPLUG |
Kumar Gala | ed84a07 | 2009-10-16 07:21:36 +0000 | [diff] [blame] | 184 | depends on (IA64 || X86 || PPC_BOOK3S_64 || SUPERH || S390) |
Dave Hansen | 3947be1 | 2005-10-29 18:16:54 -0700 | [diff] [blame] | 185 | |
Keith Mannthey | ec69acb | 2006-09-30 23:27:05 -0700 | [diff] [blame] | 186 | config MEMORY_HOTPLUG_SPARSE |
| 187 | def_bool y |
| 188 | depends on SPARSEMEM && MEMORY_HOTPLUG |
| 189 | |
KAMEZAWA Hiroyuki | 0c0e619 | 2007-10-16 01:26:12 -0700 | [diff] [blame] | 190 | config MEMORY_HOTREMOVE |
| 191 | bool "Allow for memory hot remove" |
Yasuaki Ishimatsu | 46723bf | 2013-02-22 16:33:00 -0800 | [diff] [blame] | 192 | select MEMORY_ISOLATION |
Nathan Fontenot | f7e3334 | 2013-09-27 10:18:09 -0500 | [diff] [blame] | 193 | select HAVE_BOOTMEM_INFO_NODE if (X86_64 || PPC64) |
KAMEZAWA Hiroyuki | 0c0e619 | 2007-10-16 01:26:12 -0700 | [diff] [blame] | 194 | depends on MEMORY_HOTPLUG && ARCH_ENABLE_MEMORY_HOTREMOVE |
| 195 | depends on MIGRATION |
| 196 | |
Christoph Lameter | e20b8cc | 2008-04-28 02:12:55 -0700 | [diff] [blame] | 197 | # |
| 198 | # If we have space for more page flags then we can enable additional |
| 199 | # optimizations and functionality. |
| 200 | # |
| 201 | # Regular Sparsemem takes page flag bits for the sectionid if it does not |
| 202 | # use a virtual memmap. Disable extended page flags for 32 bit platforms |
| 203 | # that require the use of a sectionid in the page flags. |
| 204 | # |
| 205 | config PAGEFLAGS_EXTENDED |
| 206 | def_bool y |
H. Peter Anvin | a269cca | 2009-08-31 11:17:44 -0700 | [diff] [blame] | 207 | depends on 64BIT || SPARSEMEM_VMEMMAP || !SPARSEMEM |
Christoph Lameter | e20b8cc | 2008-04-28 02:12:55 -0700 | [diff] [blame] | 208 | |
Hugh Dickins | 4c21e2f | 2005-10-29 18:16:40 -0700 | [diff] [blame] | 209 | # Heavily threaded applications may benefit from splitting the mm-wide |
| 210 | # page_table_lock, so that faults on different parts of the user address |
| 211 | # space can be handled with less contention: split it at this NR_CPUS. |
| 212 | # Default to 4 for wider testing, though 8 might be more appropriate. |
| 213 | # 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] | 214 | # 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] | 215 | # DEBUG_SPINLOCK and DEBUG_LOCK_ALLOC spinlock_t also enlarge struct page. |
Hugh Dickins | 4c21e2f | 2005-10-29 18:16:40 -0700 | [diff] [blame] | 216 | # |
| 217 | config SPLIT_PTLOCK_CPUS |
| 218 | int |
Hugh Dickins | a70caa8 | 2009-12-14 17:59:02 -0800 | [diff] [blame] | 219 | default "999999" if ARM && !CPU_CACHE_VIPT |
| 220 | default "999999" if PARISC && !PA20 |
| 221 | default "999999" if DEBUG_SPINLOCK || DEBUG_LOCK_ALLOC |
Kirill A. Shutemov | e9bb18c | 2013-11-14 14:30:42 -0800 | [diff] [blame] | 222 | default "999999" if !64BIT && GENERIC_LOCKBREAK |
Hugh Dickins | 4c21e2f | 2005-10-29 18:16:40 -0700 | [diff] [blame] | 223 | default "4" |
Christoph Lameter | 7cbe34c | 2006-01-08 01:00:49 -0800 | [diff] [blame] | 224 | |
Kirill A. Shutemov | e009bb3 | 2013-11-14 14:31:07 -0800 | [diff] [blame^] | 225 | config ARCH_ENABLE_SPLIT_PMD_PTLOCK |
| 226 | boolean |
| 227 | |
Christoph Lameter | 7cbe34c | 2006-01-08 01:00:49 -0800 | [diff] [blame] | 228 | # |
Rafael Aquini | 18468d9 | 2012-12-11 16:02:38 -0800 | [diff] [blame] | 229 | # support for memory balloon compaction |
| 230 | config BALLOON_COMPACTION |
| 231 | bool "Allow for balloon memory compaction/migration" |
| 232 | def_bool y |
| 233 | depends on COMPACTION && VIRTIO_BALLOON |
| 234 | help |
| 235 | Memory fragmentation introduced by ballooning might reduce |
| 236 | significantly the number of 2MB contiguous memory blocks that can be |
| 237 | used within a guest, thus imposing performance penalties associated |
| 238 | with the reduced number of transparent huge pages that could be used |
| 239 | by the guest workload. Allowing the compaction & migration for memory |
| 240 | pages enlisted as being part of memory balloon devices avoids the |
| 241 | scenario aforementioned and helps improving memory defragmentation. |
| 242 | |
| 243 | # |
Mel Gorman | e9e96b3 | 2010-05-24 14:32:21 -0700 | [diff] [blame] | 244 | # support for memory compaction |
| 245 | config COMPACTION |
| 246 | bool "Allow for memory compaction" |
Rik van Riel | 05106e6 | 2012-10-08 16:33:03 -0700 | [diff] [blame] | 247 | def_bool y |
Mel Gorman | e9e96b3 | 2010-05-24 14:32:21 -0700 | [diff] [blame] | 248 | select MIGRATION |
Andrea Arcangeli | 33a9387 | 2011-01-25 15:07:25 -0800 | [diff] [blame] | 249 | depends on MMU |
Mel Gorman | e9e96b3 | 2010-05-24 14:32:21 -0700 | [diff] [blame] | 250 | help |
| 251 | Allows the compaction of memory for the allocation of huge pages. |
| 252 | |
| 253 | # |
Christoph Lameter | 7cbe34c | 2006-01-08 01:00:49 -0800 | [diff] [blame] | 254 | # support for page migration |
| 255 | # |
| 256 | config MIGRATION |
Christoph Lameter | b20a350 | 2006-03-22 00:09:12 -0800 | [diff] [blame] | 257 | bool "Page migration" |
Christoph Lameter | 6c5240a | 2006-06-23 02:03:37 -0700 | [diff] [blame] | 258 | def_bool y |
Chen Gang | de32a81 | 2013-09-12 15:14:08 -0700 | [diff] [blame] | 259 | depends on (NUMA || ARCH_ENABLE_MEMORY_HOTREMOVE || COMPACTION || CMA) && MMU |
Christoph Lameter | b20a350 | 2006-03-22 00:09:12 -0800 | [diff] [blame] | 260 | help |
| 261 | Allows the migration of the physical location of pages of processes |
Mel Gorman | e9e96b3 | 2010-05-24 14:32:21 -0700 | [diff] [blame] | 262 | while the virtual addresses are not changed. This is useful in |
| 263 | two situations. The first is on NUMA systems to put pages nearer |
| 264 | to the processors accessing. The second is when allocating huge |
| 265 | pages as migration can relocate pages to satisfy a huge page |
| 266 | allocation instead of reclaiming. |
Greg Kroah-Hartman | 6550e07 | 2006-06-12 17:11:31 -0700 | [diff] [blame] | 267 | |
Jeremy Fitzhardinge | 600715d | 2008-09-11 01:31:45 -0700 | [diff] [blame] | 268 | config PHYS_ADDR_T_64BIT |
| 269 | def_bool 64BIT || ARCH_PHYS_ADDR_T_64BIT |
| 270 | |
Christoph Lameter | 4b51d66 | 2007-02-10 01:43:10 -0800 | [diff] [blame] | 271 | config ZONE_DMA_FLAG |
| 272 | int |
| 273 | default "0" if !ZONE_DMA |
| 274 | default "1" |
| 275 | |
Christoph Lameter | 2a7326b | 2007-07-17 04:03:37 -0700 | [diff] [blame] | 276 | config BOUNCE |
Vinayak Menon | 9ca24e2 | 2013-04-29 15:08:55 -0700 | [diff] [blame] | 277 | bool "Enable bounce buffers" |
| 278 | default y |
Christoph Lameter | 2a7326b | 2007-07-17 04:03:37 -0700 | [diff] [blame] | 279 | depends on BLOCK && MMU && (ZONE_DMA || HIGHMEM) |
Vinayak Menon | 9ca24e2 | 2013-04-29 15:08:55 -0700 | [diff] [blame] | 280 | help |
| 281 | Enable bounce buffers for devices that cannot access |
| 282 | the full range of memory available to the CPU. Enabled |
| 283 | by default when ZONE_DMA or HIGHMEM is selected, but you |
| 284 | may say n to override this. |
Christoph Lameter | 2a7326b | 2007-07-17 04:03:37 -0700 | [diff] [blame] | 285 | |
Darrick J. Wong | ffecfd1 | 2013-02-21 16:42:55 -0800 | [diff] [blame] | 286 | # On the 'tile' arch, USB OHCI needs the bounce pool since tilegx will often |
| 287 | # have more than 4GB of memory, but we don't currently use the IOTLB to present |
| 288 | # a 32-bit address to OHCI. So we need to use a bounce pool instead. |
| 289 | # |
| 290 | # We also use the bounce pool to provide stable page writes for jbd. jbd |
| 291 | # initiates buffer writeback without locking the page or setting PG_writeback, |
| 292 | # and fixing that behavior (a second time; jbd2 doesn't have this problem) is |
| 293 | # a major rework effort. Instead, use the bounce buffer to snapshot pages |
| 294 | # (until jbd goes away). The only jbd user is ext3. |
| 295 | config NEED_BOUNCE_POOL |
| 296 | bool |
| 297 | default y if (TILE && USB_OHCI_HCD) || (BLK_DEV_INTEGRITY && JBD) |
| 298 | |
Christoph Lameter | 6225e93 | 2007-05-06 14:49:50 -0700 | [diff] [blame] | 299 | config NR_QUICK |
| 300 | int |
| 301 | depends on QUICKLIST |
Paul Mundt | 0176bd3 | 2010-01-05 12:35:00 +0900 | [diff] [blame] | 302 | default "2" if AVR32 |
Christoph Lameter | 6225e93 | 2007-05-06 14:49:50 -0700 | [diff] [blame] | 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 |
David Howells | fc4d5c2 | 2009-05-06 16:03:05 -0700 | [diff] [blame] | 315 | |
Hugh Dickins | f8af4da | 2009-09-21 17:01:57 -0700 | [diff] [blame] | 316 | config KSM |
| 317 | bool "Enable KSM for page merging" |
| 318 | depends on MMU |
| 319 | help |
| 320 | Enable Kernel Samepage Merging: KSM periodically scans those areas |
| 321 | of an application's address space that an app has advised may be |
| 322 | mergeable. When it finds pages of identical content, it replaces |
Hugh Dickins | d0f209f | 2009-12-14 17:59:34 -0800 | [diff] [blame] | 323 | the many instances by a single page with that content, so |
Hugh Dickins | f8af4da | 2009-09-21 17:01:57 -0700 | [diff] [blame] | 324 | saving memory until one or another app needs to modify the content. |
| 325 | Recommended for use with KVM, or with other duplicative applications. |
Hugh Dickins | c73602a | 2009-10-07 16:32:22 -0700 | [diff] [blame] | 326 | See Documentation/vm/ksm.txt for more information: KSM is inactive |
| 327 | until a program has madvised that an area is MADV_MERGEABLE, and |
| 328 | 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] | 329 | |
Christoph Lameter | e0a94c2 | 2009-06-03 16:04:31 -0400 | [diff] [blame] | 330 | config DEFAULT_MMAP_MIN_ADDR |
| 331 | int "Low address space to protect from user allocation" |
David Howells | 6e14154 | 2009-12-15 19:27:45 +0000 | [diff] [blame] | 332 | depends on MMU |
Christoph Lameter | e0a94c2 | 2009-06-03 16:04:31 -0400 | [diff] [blame] | 333 | default 4096 |
| 334 | help |
| 335 | This is the portion of low virtual memory which should be protected |
| 336 | from userspace allocation. Keeping a user from writing to low pages |
| 337 | can help reduce the impact of kernel NULL pointer bugs. |
| 338 | |
| 339 | For most ia64, ppc64 and x86 users with lots of address space |
| 340 | a value of 65536 is reasonable and should cause no problems. |
| 341 | On arm and other archs it should not be higher than 32768. |
Eric Paris | 788084a | 2009-07-31 12:54:11 -0400 | [diff] [blame] | 342 | Programs which use vm86 functionality or have some need to map |
| 343 | this low address space will need CAP_SYS_RAWIO or disable this |
| 344 | protection by setting the value to 0. |
Christoph Lameter | e0a94c2 | 2009-06-03 16:04:31 -0400 | [diff] [blame] | 345 | |
| 346 | This value can be changed after boot using the |
| 347 | /proc/sys/vm/mmap_min_addr tunable. |
| 348 | |
Linus Torvalds | d949f36 | 2009-09-26 09:35:07 -0700 | [diff] [blame] | 349 | config ARCH_SUPPORTS_MEMORY_FAILURE |
| 350 | bool |
Christoph Lameter | e0a94c2 | 2009-06-03 16:04:31 -0400 | [diff] [blame] | 351 | |
Andi Kleen | 6a46079 | 2009-09-16 11:50:15 +0200 | [diff] [blame] | 352 | config MEMORY_FAILURE |
| 353 | depends on MMU |
Linus Torvalds | d949f36 | 2009-09-26 09:35:07 -0700 | [diff] [blame] | 354 | depends on ARCH_SUPPORTS_MEMORY_FAILURE |
Andi Kleen | 6a46079 | 2009-09-16 11:50:15 +0200 | [diff] [blame] | 355 | bool "Enable recovery from hardware memory errors" |
Minchan Kim | ee6f509 | 2012-07-31 16:43:50 -0700 | [diff] [blame] | 356 | select MEMORY_ISOLATION |
Andi Kleen | 6a46079 | 2009-09-16 11:50:15 +0200 | [diff] [blame] | 357 | help |
| 358 | Enables code to recover from some memory failures on systems |
| 359 | with MCA recovery. This allows a system to continue running |
| 360 | even when some of its memory has uncorrected errors. This requires |
| 361 | special hardware support and typically ECC memory. |
| 362 | |
Andi Kleen | cae681f | 2009-09-16 11:50:17 +0200 | [diff] [blame] | 363 | config HWPOISON_INJECT |
Andi Kleen | 413f9ef | 2009-12-16 12:20:00 +0100 | [diff] [blame] | 364 | tristate "HWPoison pages injector" |
Andi Kleen | 27df506 | 2009-12-21 19:56:42 +0100 | [diff] [blame] | 365 | depends on MEMORY_FAILURE && DEBUG_KERNEL && PROC_FS |
Wu Fengguang | 478c5ff | 2009-12-16 12:19:59 +0100 | [diff] [blame] | 366 | select PROC_PAGE_MONITOR |
Andi Kleen | cae681f | 2009-09-16 11:50:17 +0200 | [diff] [blame] | 367 | |
David Howells | fc4d5c2 | 2009-05-06 16:03:05 -0700 | [diff] [blame] | 368 | config NOMMU_INITIAL_TRIM_EXCESS |
| 369 | int "Turn on mmap() excess space trimming before booting" |
| 370 | depends on !MMU |
| 371 | default 1 |
| 372 | help |
| 373 | The NOMMU mmap() frequently needs to allocate large contiguous chunks |
| 374 | of memory on which to store mappings, but it can only ask the system |
| 375 | allocator for chunks in 2^N*PAGE_SIZE amounts - which is frequently |
| 376 | more than it requires. To deal with this, mmap() is able to trim off |
| 377 | the excess and return it to the allocator. |
| 378 | |
| 379 | If trimming is enabled, the excess is trimmed off and returned to the |
| 380 | system allocator, which can cause extra fragmentation, particularly |
| 381 | if there are a lot of transient processes. |
| 382 | |
| 383 | If trimming is disabled, the excess is kept, but not used, which for |
| 384 | long-term mappings means that the space is wasted. |
| 385 | |
| 386 | Trimming can be dynamically controlled through a sysctl option |
| 387 | (/proc/sys/vm/nr_trim_pages) which specifies the minimum number of |
| 388 | excess pages there must be before trimming should occur, or zero if |
| 389 | no trimming is to occur. |
| 390 | |
| 391 | This option specifies the initial value of this option. The default |
| 392 | of 1 says that all excess pages should be trimmed. |
| 393 | |
| 394 | See Documentation/nommu-mmap.txt for more information. |
Tejun Heo | bbddff0 | 2010-09-03 18:22:48 +0200 | [diff] [blame] | 395 | |
Andrea Arcangeli | 4c76d9d | 2011-01-13 15:46:39 -0800 | [diff] [blame] | 396 | config TRANSPARENT_HUGEPAGE |
Andrea Arcangeli | 13ece88 | 2011-01-13 15:47:07 -0800 | [diff] [blame] | 397 | bool "Transparent Hugepage Support" |
Gerald Schaefer | 1562606 | 2012-10-08 16:30:04 -0700 | [diff] [blame] | 398 | depends on HAVE_ARCH_TRANSPARENT_HUGEPAGE |
Andrea Arcangeli | 5d68924 | 2011-01-13 15:47:07 -0800 | [diff] [blame] | 399 | select COMPACTION |
Andrea Arcangeli | 4c76d9d | 2011-01-13 15:46:39 -0800 | [diff] [blame] | 400 | help |
| 401 | Transparent Hugepages allows the kernel to use huge pages and |
| 402 | huge tlb transparently to the applications whenever possible. |
| 403 | This feature can improve computing performance to certain |
| 404 | applications by speeding up page faults during memory |
| 405 | allocation, by reducing the number of tlb misses and by speeding |
| 406 | up the pagetable walking. |
| 407 | |
| 408 | If memory constrained on embedded, you may want to say N. |
| 409 | |
Andrea Arcangeli | 13ece88 | 2011-01-13 15:47:07 -0800 | [diff] [blame] | 410 | choice |
| 411 | prompt "Transparent Hugepage Support sysfs defaults" |
| 412 | depends on TRANSPARENT_HUGEPAGE |
| 413 | default TRANSPARENT_HUGEPAGE_ALWAYS |
| 414 | help |
| 415 | Selects the sysfs defaults for Transparent Hugepage Support. |
| 416 | |
| 417 | config TRANSPARENT_HUGEPAGE_ALWAYS |
| 418 | bool "always" |
| 419 | help |
| 420 | Enabling Transparent Hugepage always, can increase the |
| 421 | memory footprint of applications without a guaranteed |
| 422 | benefit but it will work automatically for all applications. |
| 423 | |
| 424 | config TRANSPARENT_HUGEPAGE_MADVISE |
| 425 | bool "madvise" |
| 426 | help |
| 427 | Enabling Transparent Hugepage madvise, will only provide a |
| 428 | performance improvement benefit to the applications using |
| 429 | madvise(MADV_HUGEPAGE) but it won't risk to increase the |
| 430 | memory footprint of applications without a guaranteed |
| 431 | benefit. |
| 432 | endchoice |
| 433 | |
Christopher Yeoh | 5febcbe | 2012-05-29 15:06:27 -0700 | [diff] [blame] | 434 | config CROSS_MEMORY_ATTACH |
| 435 | bool "Cross Memory Support" |
| 436 | depends on MMU |
| 437 | default y |
| 438 | help |
| 439 | Enabling this option adds the system calls process_vm_readv and |
| 440 | process_vm_writev which allow a process with the correct privileges |
| 441 | to directly read from or write to to another process's address space. |
| 442 | See the man page for more details. |
| 443 | |
Tejun Heo | bbddff0 | 2010-09-03 18:22:48 +0200 | [diff] [blame] | 444 | # |
| 445 | # UP and nommu archs use km based percpu allocator |
| 446 | # |
| 447 | config NEED_PER_CPU_KM |
| 448 | depends on !SMP |
| 449 | bool |
| 450 | default y |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 451 | |
| 452 | config CLEANCACHE |
| 453 | bool "Enable cleancache driver to cache clean pages if tmem is present" |
| 454 | default n |
| 455 | help |
| 456 | Cleancache can be thought of as a page-granularity victim cache |
| 457 | for clean pages that the kernel's pageframe replacement algorithm |
| 458 | (PFRA) would like to keep around, but can't since there isn't enough |
| 459 | 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] | 460 | cleancache code to put the data contained in that page into |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 461 | "transcendent memory", memory that is not directly accessible or |
| 462 | addressable by the kernel and is of unknown and possibly |
| 463 | time-varying size. And when a cleancache-enabled |
| 464 | filesystem wishes to access a page in a file on disk, it first |
| 465 | checks cleancache to see if it already contains it; if it does, |
| 466 | the page is copied into the kernel and a disk access is avoided. |
| 467 | When a transcendent memory driver is available (such as zcache or |
| 468 | Xen transcendent memory), a significant I/O reduction |
| 469 | may be achieved. When none is available, all cleancache calls |
| 470 | are reduced to a single pointer-compare-against-NULL resulting |
| 471 | in a negligible performance hit. |
| 472 | |
| 473 | If unsure, say Y to enable cleancache |
Dan Magenheimer | 27c6aec | 2012-04-09 17:10:34 -0600 | [diff] [blame] | 474 | |
| 475 | config FRONTSWAP |
| 476 | bool "Enable frontswap to cache swap pages if tmem is present" |
| 477 | depends on SWAP |
| 478 | default n |
| 479 | help |
| 480 | Frontswap is so named because it can be thought of as the opposite |
| 481 | of a "backing" store for a swap device. The data is stored into |
| 482 | "transcendent memory", memory that is not directly accessible or |
| 483 | addressable by the kernel and is of unknown and possibly |
| 484 | time-varying size. When space in transcendent memory is available, |
| 485 | a significant swap I/O reduction may be achieved. When none is |
| 486 | available, all frontswap calls are reduced to a single pointer- |
| 487 | compare-against-NULL resulting in a negligible performance hit |
| 488 | and swap data is stored as normal on the matching swap device. |
| 489 | |
| 490 | If unsure, say Y to enable frontswap. |
Aneesh Kumar K.V | f825c73 | 2013-07-02 11:15:15 +0530 | [diff] [blame] | 491 | |
| 492 | config CMA |
| 493 | bool "Contiguous Memory Allocator" |
Chen Gang | de32a81 | 2013-09-12 15:14:08 -0700 | [diff] [blame] | 494 | depends on HAVE_MEMBLOCK && MMU |
Aneesh Kumar K.V | f825c73 | 2013-07-02 11:15:15 +0530 | [diff] [blame] | 495 | select MIGRATION |
| 496 | select MEMORY_ISOLATION |
| 497 | help |
| 498 | This enables the Contiguous Memory Allocator which allows other |
| 499 | subsystems to allocate big physically-contiguous blocks of memory. |
| 500 | CMA reserves a region of memory and allows only movable pages to |
| 501 | be allocated from it. This way, the kernel can use the memory for |
| 502 | pagecache and when a subsystem requests for contiguous area, the |
| 503 | allocated pages are migrated away to serve the contiguous request. |
| 504 | |
| 505 | If unsure, say "n". |
| 506 | |
| 507 | config CMA_DEBUG |
| 508 | bool "CMA debug messages (DEVELOPMENT)" |
| 509 | depends on DEBUG_KERNEL && CMA |
| 510 | help |
| 511 | Turns on debug messages in CMA. This produces KERN_DEBUG |
| 512 | messages for every CMA call as well as various messages while |
| 513 | processing calls such as dma_alloc_from_contiguous(). |
| 514 | This option does not affect warning and error messages. |
Alexander Graf | bf550fc | 2013-08-29 00:41:59 +0200 | [diff] [blame] | 515 | |
Seth Jennings | 4e2e277 | 2013-07-10 16:04:55 -0700 | [diff] [blame] | 516 | config ZBUD |
| 517 | tristate |
| 518 | default n |
| 519 | help |
| 520 | A special purpose allocator for storing compressed pages. |
| 521 | It is designed to store up to two compressed pages per physical |
| 522 | page. While this design limits storage density, it has simple and |
| 523 | deterministic reclaim properties that make it preferable to a higher |
| 524 | density approach when reclaim will be used. |
| 525 | |
Seth Jennings | 2b28111 | 2013-07-10 16:05:03 -0700 | [diff] [blame] | 526 | config ZSWAP |
| 527 | bool "Compressed cache for swap pages (EXPERIMENTAL)" |
| 528 | depends on FRONTSWAP && CRYPTO=y |
| 529 | select CRYPTO_LZO |
| 530 | select ZBUD |
| 531 | default n |
| 532 | help |
| 533 | A lightweight compressed cache for swap pages. It takes |
| 534 | pages that are in the process of being swapped out and attempts to |
| 535 | compress them into a dynamically allocated RAM-based memory pool. |
| 536 | This can result in a significant I/O reduction on swap device and, |
| 537 | in the case where decompressing from RAM is faster that swap device |
| 538 | reads, can also improve workload performance. |
| 539 | |
| 540 | This is marked experimental because it is a new feature (as of |
| 541 | v3.11) that interacts heavily with memory reclaim. While these |
| 542 | interactions don't cause any known issues on simple memory setups, |
| 543 | they have not be fully explored on the large set of potential |
| 544 | configurations and workloads that exist. |
| 545 | |
Pavel Emelyanov | 0f8975e | 2013-07-03 15:01:20 -0700 | [diff] [blame] | 546 | config MEM_SOFT_DIRTY |
| 547 | bool "Track memory changes" |
| 548 | depends on CHECKPOINT_RESTORE && HAVE_ARCH_SOFT_DIRTY |
| 549 | select PROC_PAGE_MONITOR |
| 550 | help |
| 551 | This option enables memory changes tracking by introducing a |
| 552 | soft-dirty bit on pte-s. This bit it set when someone writes |
| 553 | into a page just as regular dirty bit, but unlike the latter |
| 554 | it can be cleared by hands. |
| 555 | |
| 556 | See Documentation/vm/soft-dirty.txt for more details. |