1=============================== 2Documentation for /proc/sys/vm/ 3=============================== 4 5kernel version 2.6.29 6 7Copyright (c) 1998, 1999, Rik van Riel <riel@nl.linux.org> 8 9Copyright (c) 2008 Peter W. Morreale <pmorreale@novell.com> 10 11For general info and legal blurb, please look in index.rst. 12 13------------------------------------------------------------------------------ 14 15This file contains the documentation for the sysctl files in 16/proc/sys/vm and is valid for Linux kernel version 2.6.29. 17 18The files in this directory can be used to tune the operation 19of the virtual memory (VM) subsystem of the Linux kernel and 20the writeout of dirty data to disk. 21 22Default values and initialization routines for most of these 23files can be found in mm/swap.c. 24 25Currently, these files are in /proc/sys/vm: 26 27- admin_reserve_kbytes 28- compact_memory 29- compaction_proactiveness 30- compact_unevictable_allowed 31- dirty_background_bytes 32- dirty_background_ratio 33- dirty_bytes 34- dirty_expire_centisecs 35- dirty_ratio 36- dirtytime_expire_seconds 37- dirty_writeback_centisecs 38- drop_caches 39- extfrag_threshold 40- highmem_is_dirtyable 41- hugetlb_shm_group 42- laptop_mode 43- legacy_va_layout 44- lowmem_reserve_ratio 45- max_map_count 46- memory_failure_early_kill 47- memory_failure_recovery 48- min_free_kbytes 49- min_slab_ratio 50- min_unmapped_ratio 51- mmap_min_addr 52- mmap_rnd_bits 53- mmap_rnd_compat_bits 54- nr_hugepages 55- nr_hugepages_mempolicy 56- nr_overcommit_hugepages 57- nr_trim_pages (only if CONFIG_MMU=n) 58- numa_zonelist_order 59- oom_dump_tasks 60- oom_kill_allocating_task 61- overcommit_kbytes 62- overcommit_memory 63- overcommit_ratio 64- page-cluster 65- panic_on_oom 66- percpu_pagelist_fraction 67- stat_interval 68- stat_refresh 69- numa_stat 70- swappiness 71- unprivileged_userfaultfd 72- user_reserve_kbytes 73- vfs_cache_pressure 74- watermark_boost_factor 75- watermark_scale_factor 76- zone_reclaim_mode 77 78 79admin_reserve_kbytes 80==================== 81 82The amount of free memory in the system that should be reserved for users 83with the capability cap_sys_admin. 84 85admin_reserve_kbytes defaults to min(3% of free pages, 8MB) 86 87That should provide enough for the admin to log in and kill a process, 88if necessary, under the default overcommit 'guess' mode. 89 90Systems running under overcommit 'never' should increase this to account 91for the full Virtual Memory Size of programs used to recover. Otherwise, 92root may not be able to log in to recover the system. 93 94How do you calculate a minimum useful reserve? 95 96sshd or login + bash (or some other shell) + top (or ps, kill, etc.) 97 98For overcommit 'guess', we can sum resident set sizes (RSS). 99On x86_64 this is about 8MB. 100 101For overcommit 'never', we can take the max of their virtual sizes (VSZ) 102and add the sum of their RSS. 103On x86_64 this is about 128MB. 104 105Changing this takes effect whenever an application requests memory. 106 107 108compact_memory 109============== 110 111Available only when CONFIG_COMPACTION is set. When 1 is written to the file, 112all zones are compacted such that free memory is available in contiguous 113blocks where possible. This can be important for example in the allocation of 114huge pages although processes will also directly compact memory as required. 115 116compaction_proactiveness 117======================== 118 119This tunable takes a value in the range [0, 100] with a default value of 12020. This tunable determines how aggressively compaction is done in the 121background. Setting it to 0 disables proactive compaction. 122 123Note that compaction has a non-trivial system-wide impact as pages 124belonging to different processes are moved around, which could also lead 125to latency spikes in unsuspecting applications. The kernel employs 126various heuristics to avoid wasting CPU cycles if it detects that 127proactive compaction is not being effective. 128 129Be careful when setting it to extreme values like 100, as that may 130cause excessive background compaction activity. 131 132compact_unevictable_allowed 133=========================== 134 135Available only when CONFIG_COMPACTION is set. When set to 1, compaction is 136allowed to examine the unevictable lru (mlocked pages) for pages to compact. 137This should be used on systems where stalls for minor page faults are an 138acceptable trade for large contiguous free memory. Set to 0 to prevent 139compaction from moving pages that are unevictable. Default value is 1. 140On CONFIG_PREEMPT_RT the default value is 0 in order to avoid a page fault, due 141to compaction, which would block the task from becomming active until the fault 142is resolved. 143 144 145dirty_background_bytes 146====================== 147 148Contains the amount of dirty memory at which the background kernel 149flusher threads will start writeback. 150 151Note: 152 dirty_background_bytes is the counterpart of dirty_background_ratio. Only 153 one of them may be specified at a time. When one sysctl is written it is 154 immediately taken into account to evaluate the dirty memory limits and the 155 other appears as 0 when read. 156 157 158dirty_background_ratio 159====================== 160 161Contains, as a percentage of total available memory that contains free pages 162and reclaimable pages, the number of pages at which the background kernel 163flusher threads will start writing out dirty data. 164 165The total available memory is not equal to total system memory. 166 167 168dirty_bytes 169=========== 170 171Contains the amount of dirty memory at which a process generating disk writes 172will itself start writeback. 173 174Note: dirty_bytes is the counterpart of dirty_ratio. Only one of them may be 175specified at a time. When one sysctl is written it is immediately taken into 176account to evaluate the dirty memory limits and the other appears as 0 when 177read. 178 179Note: the minimum value allowed for dirty_bytes is two pages (in bytes); any 180value lower than this limit will be ignored and the old configuration will be 181retained. 182 183 184dirty_expire_centisecs 185====================== 186 187This tunable is used to define when dirty data is old enough to be eligible 188for writeout by the kernel flusher threads. It is expressed in 100'ths 189of a second. Data which has been dirty in-memory for longer than this 190interval will be written out next time a flusher thread wakes up. 191 192 193dirty_ratio 194=========== 195 196Contains, as a percentage of total available memory that contains free pages 197and reclaimable pages, the number of pages at which a process which is 198generating disk writes will itself start writing out dirty data. 199 200The total available memory is not equal to total system memory. 201 202 203dirtytime_expire_seconds 204======================== 205 206When a lazytime inode is constantly having its pages dirtied, the inode with 207an updated timestamp will never get chance to be written out. And, if the 208only thing that has happened on the file system is a dirtytime inode caused 209by an atime update, a worker will be scheduled to make sure that inode 210eventually gets pushed out to disk. This tunable is used to define when dirty 211inode is old enough to be eligible for writeback by the kernel flusher threads. 212And, it is also used as the interval to wakeup dirtytime_writeback thread. 213 214 215dirty_writeback_centisecs 216========================= 217 218The kernel flusher threads will periodically wake up and write `old` data 219out to disk. This tunable expresses the interval between those wakeups, in 220100'ths of a second. 221 222Setting this to zero disables periodic writeback altogether. 223 224 225drop_caches 226=========== 227 228Writing to this will cause the kernel to drop clean caches, as well as 229reclaimable slab objects like dentries and inodes. Once dropped, their 230memory becomes free. 231 232To free pagecache:: 233 234 echo 1 > /proc/sys/vm/drop_caches 235 236To free reclaimable slab objects (includes dentries and inodes):: 237 238 echo 2 > /proc/sys/vm/drop_caches 239 240To free slab objects and pagecache:: 241 242 echo 3 > /proc/sys/vm/drop_caches 243 244This is a non-destructive operation and will not free any dirty objects. 245To increase the number of objects freed by this operation, the user may run 246`sync` prior to writing to /proc/sys/vm/drop_caches. This will minimize the 247number of dirty objects on the system and create more candidates to be 248dropped. 249 250This file is not a means to control the growth of the various kernel caches 251(inodes, dentries, pagecache, etc...) These objects are automatically 252reclaimed by the kernel when memory is needed elsewhere on the system. 253 254Use of this file can cause performance problems. Since it discards cached 255objects, it may cost a significant amount of I/O and CPU to recreate the 256dropped objects, especially if they were under heavy use. Because of this, 257use outside of a testing or debugging environment is not recommended. 258 259You may see informational messages in your kernel log when this file is 260used:: 261 262 cat (1234): drop_caches: 3 263 264These are informational only. They do not mean that anything is wrong 265with your system. To disable them, echo 4 (bit 2) into drop_caches. 266 267 268extfrag_threshold 269================= 270 271This parameter affects whether the kernel will compact memory or direct 272reclaim to satisfy a high-order allocation. The extfrag/extfrag_index file in 273debugfs shows what the fragmentation index for each order is in each zone in 274the system. Values tending towards 0 imply allocations would fail due to lack 275of memory, values towards 1000 imply failures are due to fragmentation and -1 276implies that the allocation will succeed as long as watermarks are met. 277 278The kernel will not compact memory in a zone if the 279fragmentation index is <= extfrag_threshold. The default value is 500. 280 281 282highmem_is_dirtyable 283==================== 284 285Available only for systems with CONFIG_HIGHMEM enabled (32b systems). 286 287This parameter controls whether the high memory is considered for dirty 288writers throttling. This is not the case by default which means that 289only the amount of memory directly visible/usable by the kernel can 290be dirtied. As a result, on systems with a large amount of memory and 291lowmem basically depleted writers might be throttled too early and 292streaming writes can get very slow. 293 294Changing the value to non zero would allow more memory to be dirtied 295and thus allow writers to write more data which can be flushed to the 296storage more effectively. Note this also comes with a risk of pre-mature 297OOM killer because some writers (e.g. direct block device writes) can 298only use the low memory and they can fill it up with dirty data without 299any throttling. 300 301 302hugetlb_shm_group 303================= 304 305hugetlb_shm_group contains group id that is allowed to create SysV 306shared memory segment using hugetlb page. 307 308 309laptop_mode 310=========== 311 312laptop_mode is a knob that controls "laptop mode". All the things that are 313controlled by this knob are discussed in Documentation/admin-guide/laptops/laptop-mode.rst. 314 315 316legacy_va_layout 317================ 318 319If non-zero, this sysctl disables the new 32-bit mmap layout - the kernel 320will use the legacy (2.4) layout for all processes. 321 322 323lowmem_reserve_ratio 324==================== 325 326For some specialised workloads on highmem machines it is dangerous for 327the kernel to allow process memory to be allocated from the "lowmem" 328zone. This is because that memory could then be pinned via the mlock() 329system call, or by unavailability of swapspace. 330 331And on large highmem machines this lack of reclaimable lowmem memory 332can be fatal. 333 334So the Linux page allocator has a mechanism which prevents allocations 335which *could* use highmem from using too much lowmem. This means that 336a certain amount of lowmem is defended from the possibility of being 337captured into pinned user memory. 338 339(The same argument applies to the old 16 megabyte ISA DMA region. This 340mechanism will also defend that region from allocations which could use 341highmem or lowmem). 342 343The `lowmem_reserve_ratio` tunable determines how aggressive the kernel is 344in defending these lower zones. 345 346If you have a machine which uses highmem or ISA DMA and your 347applications are using mlock(), or if you are running with no swap then 348you probably should change the lowmem_reserve_ratio setting. 349 350The lowmem_reserve_ratio is an array. You can see them by reading this file:: 351 352 % cat /proc/sys/vm/lowmem_reserve_ratio 353 256 256 32 354 355But, these values are not used directly. The kernel calculates # of protection 356pages for each zones from them. These are shown as array of protection pages 357in /proc/zoneinfo like followings. (This is an example of x86-64 box). 358Each zone has an array of protection pages like this:: 359 360 Node 0, zone DMA 361 pages free 1355 362 min 3 363 low 3 364 high 4 365 : 366 : 367 numa_other 0 368 protection: (0, 2004, 2004, 2004) 369 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 370 pagesets 371 cpu: 0 pcp: 0 372 : 373 374These protections are added to score to judge whether this zone should be used 375for page allocation or should be reclaimed. 376 377In this example, if normal pages (index=2) are required to this DMA zone and 378watermark[WMARK_HIGH] is used for watermark, the kernel judges this zone should 379not be used because pages_free(1355) is smaller than watermark + protection[2] 380(4 + 2004 = 2008). If this protection value is 0, this zone would be used for 381normal page requirement. If requirement is DMA zone(index=0), protection[0] 382(=0) is used. 383 384zone[i]'s protection[j] is calculated by following expression:: 385 386 (i < j): 387 zone[i]->protection[j] 388 = (total sums of managed_pages from zone[i+1] to zone[j] on the node) 389 / lowmem_reserve_ratio[i]; 390 (i = j): 391 (should not be protected. = 0; 392 (i > j): 393 (not necessary, but looks 0) 394 395The default values of lowmem_reserve_ratio[i] are 396 397 === ==================================== 398 256 (if zone[i] means DMA or DMA32 zone) 399 32 (others) 400 === ==================================== 401 402As above expression, they are reciprocal number of ratio. 403256 means 1/256. # of protection pages becomes about "0.39%" of total managed 404pages of higher zones on the node. 405 406If you would like to protect more pages, smaller values are effective. 407The minimum value is 1 (1/1 -> 100%). The value less than 1 completely 408disables protection of the pages. 409 410 411max_map_count: 412============== 413 414This file contains the maximum number of memory map areas a process 415may have. Memory map areas are used as a side-effect of calling 416malloc, directly by mmap, mprotect, and madvise, and also when loading 417shared libraries. 418 419While most applications need less than a thousand maps, certain 420programs, particularly malloc debuggers, may consume lots of them, 421e.g., up to one or two maps per allocation. 422 423The default value is 65536. 424 425 426memory_failure_early_kill: 427========================== 428 429Control how to kill processes when uncorrected memory error (typically 430a 2bit error in a memory module) is detected in the background by hardware 431that cannot be handled by the kernel. In some cases (like the page 432still having a valid copy on disk) the kernel will handle the failure 433transparently without affecting any applications. But if there is 434no other uptodate copy of the data it will kill to prevent any data 435corruptions from propagating. 436 4371: Kill all processes that have the corrupted and not reloadable page mapped 438as soon as the corruption is detected. Note this is not supported 439for a few types of pages, like kernel internally allocated data or 440the swap cache, but works for the majority of user pages. 441 4420: Only unmap the corrupted page from all processes and only kill a process 443who tries to access it. 444 445The kill is done using a catchable SIGBUS with BUS_MCEERR_AO, so processes can 446handle this if they want to. 447 448This is only active on architectures/platforms with advanced machine 449check handling and depends on the hardware capabilities. 450 451Applications can override this setting individually with the PR_MCE_KILL prctl 452 453 454memory_failure_recovery 455======================= 456 457Enable memory failure recovery (when supported by the platform) 458 4591: Attempt recovery. 460 4610: Always panic on a memory failure. 462 463 464min_free_kbytes 465=============== 466 467This is used to force the Linux VM to keep a minimum number 468of kilobytes free. The VM uses this number to compute a 469watermark[WMARK_MIN] value for each lowmem zone in the system. 470Each lowmem zone gets a number of reserved free pages based 471proportionally on its size. 472 473Some minimal amount of memory is needed to satisfy PF_MEMALLOC 474allocations; if you set this to lower than 1024KB, your system will 475become subtly broken, and prone to deadlock under high loads. 476 477Setting this too high will OOM your machine instantly. 478 479 480min_slab_ratio 481============== 482 483This is available only on NUMA kernels. 484 485A percentage of the total pages in each zone. On Zone reclaim 486(fallback from the local zone occurs) slabs will be reclaimed if more 487than this percentage of pages in a zone are reclaimable slab pages. 488This insures that the slab growth stays under control even in NUMA 489systems that rarely perform global reclaim. 490 491The default is 5 percent. 492 493Note that slab reclaim is triggered in a per zone / node fashion. 494The process of reclaiming slab memory is currently not node specific 495and may not be fast. 496 497 498min_unmapped_ratio 499================== 500 501This is available only on NUMA kernels. 502 503This is a percentage of the total pages in each zone. Zone reclaim will 504only occur if more than this percentage of pages are in a state that 505zone_reclaim_mode allows to be reclaimed. 506 507If zone_reclaim_mode has the value 4 OR'd, then the percentage is compared 508against all file-backed unmapped pages including swapcache pages and tmpfs 509files. Otherwise, only unmapped pages backed by normal files but not tmpfs 510files and similar are considered. 511 512The default is 1 percent. 513 514 515mmap_min_addr 516============= 517 518This file indicates the amount of address space which a user process will 519be restricted from mmapping. Since kernel null dereference bugs could 520accidentally operate based on the information in the first couple of pages 521of memory userspace processes should not be allowed to write to them. By 522default this value is set to 0 and no protections will be enforced by the 523security module. Setting this value to something like 64k will allow the 524vast majority of applications to work correctly and provide defense in depth 525against future potential kernel bugs. 526 527 528mmap_rnd_bits 529============= 530 531This value can be used to select the number of bits to use to 532determine the random offset to the base address of vma regions 533resulting from mmap allocations on architectures which support 534tuning address space randomization. This value will be bounded 535by the architecture's minimum and maximum supported values. 536 537This value can be changed after boot using the 538/proc/sys/vm/mmap_rnd_bits tunable 539 540 541mmap_rnd_compat_bits 542==================== 543 544This value can be used to select the number of bits to use to 545determine the random offset to the base address of vma regions 546resulting from mmap allocations for applications run in 547compatibility mode on architectures which support tuning address 548space randomization. This value will be bounded by the 549architecture's minimum and maximum supported values. 550 551This value can be changed after boot using the 552/proc/sys/vm/mmap_rnd_compat_bits tunable 553 554 555nr_hugepages 556============ 557 558Change the minimum size of the hugepage pool. 559 560See Documentation/admin-guide/mm/hugetlbpage.rst 561 562 563nr_hugepages_mempolicy 564====================== 565 566Change the size of the hugepage pool at run-time on a specific 567set of NUMA nodes. 568 569See Documentation/admin-guide/mm/hugetlbpage.rst 570 571 572nr_overcommit_hugepages 573======================= 574 575Change the maximum size of the hugepage pool. The maximum is 576nr_hugepages + nr_overcommit_hugepages. 577 578See Documentation/admin-guide/mm/hugetlbpage.rst 579 580 581nr_trim_pages 582============= 583 584This is available only on NOMMU kernels. 585 586This value adjusts the excess page trimming behaviour of power-of-2 aligned 587NOMMU mmap allocations. 588 589A value of 0 disables trimming of allocations entirely, while a value of 1 590trims excess pages aggressively. Any value >= 1 acts as the watermark where 591trimming of allocations is initiated. 592 593The default value is 1. 594 595See Documentation/admin-guide/mm/nommu-mmap.rst for more information. 596 597 598numa_zonelist_order 599=================== 600 601This sysctl is only for NUMA and it is deprecated. Anything but 602Node order will fail! 603 604'where the memory is allocated from' is controlled by zonelists. 605 606(This documentation ignores ZONE_HIGHMEM/ZONE_DMA32 for simple explanation. 607you may be able to read ZONE_DMA as ZONE_DMA32...) 608 609In non-NUMA case, a zonelist for GFP_KERNEL is ordered as following. 610ZONE_NORMAL -> ZONE_DMA 611This means that a memory allocation request for GFP_KERNEL will 612get memory from ZONE_DMA only when ZONE_NORMAL is not available. 613 614In NUMA case, you can think of following 2 types of order. 615Assume 2 node NUMA and below is zonelist of Node(0)'s GFP_KERNEL:: 616 617 (A) Node(0) ZONE_NORMAL -> Node(0) ZONE_DMA -> Node(1) ZONE_NORMAL 618 (B) Node(0) ZONE_NORMAL -> Node(1) ZONE_NORMAL -> Node(0) ZONE_DMA. 619 620Type(A) offers the best locality for processes on Node(0), but ZONE_DMA 621will be used before ZONE_NORMAL exhaustion. This increases possibility of 622out-of-memory(OOM) of ZONE_DMA because ZONE_DMA is tend to be small. 623 624Type(B) cannot offer the best locality but is more robust against OOM of 625the DMA zone. 626 627Type(A) is called as "Node" order. Type (B) is "Zone" order. 628 629"Node order" orders the zonelists by node, then by zone within each node. 630Specify "[Nn]ode" for node order 631 632"Zone Order" orders the zonelists by zone type, then by node within each 633zone. Specify "[Zz]one" for zone order. 634 635Specify "[Dd]efault" to request automatic configuration. 636 637On 32-bit, the Normal zone needs to be preserved for allocations accessible 638by the kernel, so "zone" order will be selected. 639 640On 64-bit, devices that require DMA32/DMA are relatively rare, so "node" 641order will be selected. 642 643Default order is recommended unless this is causing problems for your 644system/application. 645 646 647oom_dump_tasks 648============== 649 650Enables a system-wide task dump (excluding kernel threads) to be produced 651when the kernel performs an OOM-killing and includes such information as 652pid, uid, tgid, vm size, rss, pgtables_bytes, swapents, oom_score_adj 653score, and name. This is helpful to determine why the OOM killer was 654invoked, to identify the rogue task that caused it, and to determine why 655the OOM killer chose the task it did to kill. 656 657If this is set to zero, this information is suppressed. On very 658large systems with thousands of tasks it may not be feasible to dump 659the memory state information for each one. Such systems should not 660be forced to incur a performance penalty in OOM conditions when the 661information may not be desired. 662 663If this is set to non-zero, this information is shown whenever the 664OOM killer actually kills a memory-hogging task. 665 666The default value is 1 (enabled). 667 668 669oom_kill_allocating_task 670======================== 671 672This enables or disables killing the OOM-triggering task in 673out-of-memory situations. 674 675If this is set to zero, the OOM killer will scan through the entire 676tasklist and select a task based on heuristics to kill. This normally 677selects a rogue memory-hogging task that frees up a large amount of 678memory when killed. 679 680If this is set to non-zero, the OOM killer simply kills the task that 681triggered the out-of-memory condition. This avoids the expensive 682tasklist scan. 683 684If panic_on_oom is selected, it takes precedence over whatever value 685is used in oom_kill_allocating_task. 686 687The default value is 0. 688 689 690overcommit_kbytes 691================= 692 693When overcommit_memory is set to 2, the committed address space is not 694permitted to exceed swap plus this amount of physical RAM. See below. 695 696Note: overcommit_kbytes is the counterpart of overcommit_ratio. Only one 697of them may be specified at a time. Setting one disables the other (which 698then appears as 0 when read). 699 700 701overcommit_memory 702================= 703 704This value contains a flag that enables memory overcommitment. 705 706When this flag is 0, the kernel attempts to estimate the amount 707of free memory left when userspace requests more memory. 708 709When this flag is 1, the kernel pretends there is always enough 710memory until it actually runs out. 711 712When this flag is 2, the kernel uses a "never overcommit" 713policy that attempts to prevent any overcommit of memory. 714Note that user_reserve_kbytes affects this policy. 715 716This feature can be very useful because there are a lot of 717programs that malloc() huge amounts of memory "just-in-case" 718and don't use much of it. 719 720The default value is 0. 721 722See Documentation/vm/overcommit-accounting.rst and 723mm/util.c::__vm_enough_memory() for more information. 724 725 726overcommit_ratio 727================ 728 729When overcommit_memory is set to 2, the committed address 730space is not permitted to exceed swap plus this percentage 731of physical RAM. See above. 732 733 734page-cluster 735============ 736 737page-cluster controls the number of pages up to which consecutive pages 738are read in from swap in a single attempt. This is the swap counterpart 739to page cache readahead. 740The mentioned consecutivity is not in terms of virtual/physical addresses, 741but consecutive on swap space - that means they were swapped out together. 742 743It is a logarithmic value - setting it to zero means "1 page", setting 744it to 1 means "2 pages", setting it to 2 means "4 pages", etc. 745Zero disables swap readahead completely. 746 747The default value is three (eight pages at a time). There may be some 748small benefits in tuning this to a different value if your workload is 749swap-intensive. 750 751Lower values mean lower latencies for initial faults, but at the same time 752extra faults and I/O delays for following faults if they would have been part of 753that consecutive pages readahead would have brought in. 754 755 756panic_on_oom 757============ 758 759This enables or disables panic on out-of-memory feature. 760 761If this is set to 0, the kernel will kill some rogue process, 762called oom_killer. Usually, oom_killer can kill rogue processes and 763system will survive. 764 765If this is set to 1, the kernel panics when out-of-memory happens. 766However, if a process limits using nodes by mempolicy/cpusets, 767and those nodes become memory exhaustion status, one process 768may be killed by oom-killer. No panic occurs in this case. 769Because other nodes' memory may be free. This means system total status 770may be not fatal yet. 771 772If this is set to 2, the kernel panics compulsorily even on the 773above-mentioned. Even oom happens under memory cgroup, the whole 774system panics. 775 776The default value is 0. 777 7781 and 2 are for failover of clustering. Please select either 779according to your policy of failover. 780 781panic_on_oom=2+kdump gives you very strong tool to investigate 782why oom happens. You can get snapshot. 783 784 785percpu_pagelist_fraction 786======================== 787 788This is the fraction of pages at most (high mark pcp->high) in each zone that 789are allocated for each per cpu page list. The min value for this is 8. It 790means that we don't allow more than 1/8th of pages in each zone to be 791allocated in any single per_cpu_pagelist. This entry only changes the value 792of hot per cpu pagelists. User can specify a number like 100 to allocate 7931/100th of each zone to each per cpu page list. 794 795The batch value of each per cpu pagelist is also updated as a result. It is 796set to pcp->high/4. The upper limit of batch is (PAGE_SHIFT * 8) 797 798The initial value is zero. Kernel does not use this value at boot time to set 799the high water marks for each per cpu page list. If the user writes '0' to this 800sysctl, it will revert to this default behavior. 801 802 803stat_interval 804============= 805 806The time interval between which vm statistics are updated. The default 807is 1 second. 808 809 810stat_refresh 811============ 812 813Any read or write (by root only) flushes all the per-cpu vm statistics 814into their global totals, for more accurate reports when testing 815e.g. cat /proc/sys/vm/stat_refresh /proc/meminfo 816 817As a side-effect, it also checks for negative totals (elsewhere reported 818as 0) and "fails" with EINVAL if any are found, with a warning in dmesg. 819(At time of writing, a few stats are known sometimes to be found negative, 820with no ill effects: errors and warnings on these stats are suppressed.) 821 822 823numa_stat 824========= 825 826This interface allows runtime configuration of numa statistics. 827 828When page allocation performance becomes a bottleneck and you can tolerate 829some possible tool breakage and decreased numa counter precision, you can 830do:: 831 832 echo 0 > /proc/sys/vm/numa_stat 833 834When page allocation performance is not a bottleneck and you want all 835tooling to work, you can do:: 836 837 echo 1 > /proc/sys/vm/numa_stat 838 839 840swappiness 841========== 842 843This control is used to define the rough relative IO cost of swapping 844and filesystem paging, as a value between 0 and 200. At 100, the VM 845assumes equal IO cost and will thus apply memory pressure to the page 846cache and swap-backed pages equally; lower values signify more 847expensive swap IO, higher values indicates cheaper. 848 849Keep in mind that filesystem IO patterns under memory pressure tend to 850be more efficient than swap's random IO. An optimal value will require 851experimentation and will also be workload-dependent. 852 853The default value is 60. 854 855For in-memory swap, like zram or zswap, as well as hybrid setups that 856have swap on faster devices than the filesystem, values beyond 100 can 857be considered. For example, if the random IO against the swap device 858is on average 2x faster than IO from the filesystem, swappiness should 859be 133 (x + 2x = 200, 2x = 133.33). 860 861At 0, the kernel will not initiate swap until the amount of free and 862file-backed pages is less than the high watermark in a zone. 863 864 865unprivileged_userfaultfd 866======================== 867 868This flag controls whether unprivileged users can use the userfaultfd 869system calls. Set this to 1 to allow unprivileged users to use the 870userfaultfd system calls, or set this to 0 to restrict userfaultfd to only 871privileged users (with SYS_CAP_PTRACE capability). 872 873The default value is 1. 874 875 876user_reserve_kbytes 877=================== 878 879When overcommit_memory is set to 2, "never overcommit" mode, reserve 880min(3% of current process size, user_reserve_kbytes) of free memory. 881This is intended to prevent a user from starting a single memory hogging 882process, such that they cannot recover (kill the hog). 883 884user_reserve_kbytes defaults to min(3% of the current process size, 128MB). 885 886If this is reduced to zero, then the user will be allowed to allocate 887all free memory with a single process, minus admin_reserve_kbytes. 888Any subsequent attempts to execute a command will result in 889"fork: Cannot allocate memory". 890 891Changing this takes effect whenever an application requests memory. 892 893 894vfs_cache_pressure 895================== 896 897This percentage value controls the tendency of the kernel to reclaim 898the memory which is used for caching of directory and inode objects. 899 900At the default value of vfs_cache_pressure=100 the kernel will attempt to 901reclaim dentries and inodes at a "fair" rate with respect to pagecache and 902swapcache reclaim. Decreasing vfs_cache_pressure causes the kernel to prefer 903to retain dentry and inode caches. When vfs_cache_pressure=0, the kernel will 904never reclaim dentries and inodes due to memory pressure and this can easily 905lead to out-of-memory conditions. Increasing vfs_cache_pressure beyond 100 906causes the kernel to prefer to reclaim dentries and inodes. 907 908Increasing vfs_cache_pressure significantly beyond 100 may have negative 909performance impact. Reclaim code needs to take various locks to find freeable 910directory and inode objects. With vfs_cache_pressure=1000, it will look for 911ten times more freeable objects than there are. 912 913 914watermark_boost_factor 915====================== 916 917This factor controls the level of reclaim when memory is being fragmented. 918It defines the percentage of the high watermark of a zone that will be 919reclaimed if pages of different mobility are being mixed within pageblocks. 920The intent is that compaction has less work to do in the future and to 921increase the success rate of future high-order allocations such as SLUB 922allocations, THP and hugetlbfs pages. 923 924To make it sensible with respect to the watermark_scale_factor 925parameter, the unit is in fractions of 10,000. The default value of 92615,000 on !DISCONTIGMEM configurations means that up to 150% of the high 927watermark will be reclaimed in the event of a pageblock being mixed due 928to fragmentation. The level of reclaim is determined by the number of 929fragmentation events that occurred in the recent past. If this value is 930smaller than a pageblock then a pageblocks worth of pages will be reclaimed 931(e.g. 2MB on 64-bit x86). A boost factor of 0 will disable the feature. 932 933 934watermark_scale_factor 935====================== 936 937This factor controls the aggressiveness of kswapd. It defines the 938amount of memory left in a node/system before kswapd is woken up and 939how much memory needs to be free before kswapd goes back to sleep. 940 941The unit is in fractions of 10,000. The default value of 10 means the 942distances between watermarks are 0.1% of the available memory in the 943node/system. The maximum value is 1000, or 10% of memory. 944 945A high rate of threads entering direct reclaim (allocstall) or kswapd 946going to sleep prematurely (kswapd_low_wmark_hit_quickly) can indicate 947that the number of free pages kswapd maintains for latency reasons is 948too small for the allocation bursts occurring in the system. This knob 949can then be used to tune kswapd aggressiveness accordingly. 950 951 952zone_reclaim_mode 953================= 954 955Zone_reclaim_mode allows someone to set more or less aggressive approaches to 956reclaim memory when a zone runs out of memory. If it is set to zero then no 957zone reclaim occurs. Allocations will be satisfied from other zones / nodes 958in the system. 959 960This is value OR'ed together of 961 962= =================================== 9631 Zone reclaim on 9642 Zone reclaim writes dirty pages out 9654 Zone reclaim swaps pages 966= =================================== 967 968zone_reclaim_mode is disabled by default. For file servers or workloads 969that benefit from having their data cached, zone_reclaim_mode should be 970left disabled as the caching effect is likely to be more important than 971data locality. 972 973Consider enabling one or more zone_reclaim mode bits if it's known that the 974workload is partitioned such that each partition fits within a NUMA node 975and that accessing remote memory would cause a measurable performance 976reduction. The page allocator will take additional actions before 977allocating off node pages. 978 979Allowing zone reclaim to write out pages stops processes that are 980writing large amounts of data from dirtying pages on other nodes. Zone 981reclaim will write out dirty pages if a zone fills up and so effectively 982throttle the process. This may decrease the performance of a single process 983since it cannot use all of system memory to buffer the outgoing writes 984anymore but it preserve the memory on other nodes so that the performance 985of other processes running on other nodes will not be affected. 986 987Allowing regular swap effectively restricts allocations to the local 988node unless explicitly overridden by memory policies or cpuset 989configurations. 990