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