12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019 |
- ===============================
- Documentation for /proc/sys/vm/
- ===============================
- kernel version 2.6.29
- Copyright (c) 1998, 1999, Rik van Riel <riel@nl.linux.org>
- Copyright (c) 2008 Peter W. Morreale <pmorreale@novell.com>
- For general info and legal blurb, please look in index.rst.
- ------------------------------------------------------------------------------
- This file contains the documentation for the sysctl files in
- /proc/sys/vm and is valid for Linux kernel version 2.6.29.
- The files in this directory can be used to tune the operation
- of the virtual memory (VM) subsystem of the Linux kernel and
- the writeout of dirty data to disk.
- Default values and initialization routines for most of these
- files can be found in mm/swap.c.
- Currently, these files are in /proc/sys/vm:
- - admin_reserve_kbytes
- - block_dump
- - compact_memory
- - compaction_proactiveness
- - compact_unevictable_allowed
- - dirty_background_bytes
- - dirty_background_ratio
- - dirty_bytes
- - dirty_expire_centisecs
- - dirty_ratio
- - dirtytime_expire_seconds
- - dirty_writeback_centisecs
- - drop_caches
- - extfrag_threshold
- - extra_free_kbytes
- - highmem_is_dirtyable
- - hugetlb_shm_group
- - laptop_mode
- - legacy_va_layout
- - lowmem_reserve_ratio
- - max_map_count
- - memory_failure_early_kill
- - memory_failure_recovery
- - min_free_kbytes
- - min_slab_ratio
- - min_unmapped_ratio
- - mmap_min_addr
- - mmap_rnd_bits
- - mmap_rnd_compat_bits
- - nr_hugepages
- - nr_hugepages_mempolicy
- - nr_overcommit_hugepages
- - nr_trim_pages (only if CONFIG_MMU=n)
- - numa_zonelist_order
- - oom_dump_tasks
- - oom_kill_allocating_task
- - overcommit_kbytes
- - overcommit_memory
- - overcommit_ratio
- - page-cluster
- - panic_on_oom
- - percpu_pagelist_fraction
- - stat_interval
- - stat_refresh
- - numa_stat
- - swappiness
- - unprivileged_userfaultfd
- - user_reserve_kbytes
- - vfs_cache_pressure
- - watermark_boost_factor
- - watermark_scale_factor
- - zone_reclaim_mode
- admin_reserve_kbytes
- ====================
- The amount of free memory in the system that should be reserved for users
- with the capability cap_sys_admin.
- admin_reserve_kbytes defaults to min(3% of free pages, 8MB)
- That should provide enough for the admin to log in and kill a process,
- if necessary, under the default overcommit 'guess' mode.
- Systems running under overcommit 'never' should increase this to account
- for the full Virtual Memory Size of programs used to recover. Otherwise,
- root may not be able to log in to recover the system.
- How do you calculate a minimum useful reserve?
- sshd or login + bash (or some other shell) + top (or ps, kill, etc.)
- For overcommit 'guess', we can sum resident set sizes (RSS).
- On x86_64 this is about 8MB.
- For overcommit 'never', we can take the max of their virtual sizes (VSZ)
- and add the sum of their RSS.
- On x86_64 this is about 128MB.
- Changing this takes effect whenever an application requests memory.
- block_dump
- ==========
- block_dump enables block I/O debugging when set to a nonzero value. More
- information on block I/O debugging is in Documentation/admin-guide/laptops/laptop-mode.rst.
- compact_memory
- ==============
- Available only when CONFIG_COMPACTION is set. When 1 is written to the file,
- all zones are compacted such that free memory is available in contiguous
- blocks where possible. This can be important for example in the allocation of
- huge pages although processes will also directly compact memory as required.
- compaction_proactiveness
- ========================
- This tunable takes a value in the range [0, 100] with a default value of
- 20. This tunable determines how aggressively compaction is done in the
- background. On write of non zero value to this tunable will immediately
- trigger the proactive compaction. Setting it to 0 disables proactive compaction.
- Note that compaction has a non-trivial system-wide impact as pages
- belonging to different processes are moved around, which could also lead
- to latency spikes in unsuspecting applications. The kernel employs
- various heuristics to avoid wasting CPU cycles if it detects that
- proactive compaction is not being effective.
- Be careful when setting it to extreme values like 100, as that may
- cause excessive background compaction activity.
- compact_unevictable_allowed
- ===========================
- Available only when CONFIG_COMPACTION is set. When set to 1, compaction is
- allowed to examine the unevictable lru (mlocked pages) for pages to compact.
- This should be used on systems where stalls for minor page faults are an
- acceptable trade for large contiguous free memory. Set to 0 to prevent
- compaction from moving pages that are unevictable. Default value is 1.
- On CONFIG_PREEMPT_RT the default value is 0 in order to avoid a page fault, due
- to compaction, which would block the task from becomming active until the fault
- is resolved.
- dirty_background_bytes
- ======================
- Contains the amount of dirty memory at which the background kernel
- flusher threads will start writeback.
- Note:
- dirty_background_bytes is the counterpart of dirty_background_ratio. Only
- one of them may be specified at a time. When one sysctl is written it is
- immediately taken into account to evaluate the dirty memory limits and the
- other appears as 0 when read.
- dirty_background_ratio
- ======================
- Contains, as a percentage of total available memory that contains free pages
- and reclaimable pages, the number of pages at which the background kernel
- flusher threads will start writing out dirty data.
- The total available memory is not equal to total system memory.
- dirty_bytes
- ===========
- Contains the amount of dirty memory at which a process generating disk writes
- will itself start writeback.
- Note: dirty_bytes is the counterpart of dirty_ratio. Only one of them may be
- specified at a time. When one sysctl is written it is immediately taken into
- account to evaluate the dirty memory limits and the other appears as 0 when
- read.
- Note: the minimum value allowed for dirty_bytes is two pages (in bytes); any
- value lower than this limit will be ignored and the old configuration will be
- retained.
- dirty_expire_centisecs
- ======================
- This tunable is used to define when dirty data is old enough to be eligible
- for writeout by the kernel flusher threads. It is expressed in 100'ths
- of a second. Data which has been dirty in-memory for longer than this
- interval will be written out next time a flusher thread wakes up.
- dirty_ratio
- ===========
- Contains, as a percentage of total available memory that contains free pages
- and reclaimable pages, the number of pages at which a process which is
- generating disk writes will itself start writing out dirty data.
- The total available memory is not equal to total system memory.
- dirtytime_expire_seconds
- ========================
- When a lazytime inode is constantly having its pages dirtied, the inode with
- an updated timestamp will never get chance to be written out. And, if the
- only thing that has happened on the file system is a dirtytime inode caused
- by an atime update, a worker will be scheduled to make sure that inode
- eventually gets pushed out to disk. This tunable is used to define when dirty
- inode is old enough to be eligible for writeback by the kernel flusher threads.
- And, it is also used as the interval to wakeup dirtytime_writeback thread.
- dirty_writeback_centisecs
- =========================
- The kernel flusher threads will periodically wake up and write `old` data
- out to disk. This tunable expresses the interval between those wakeups, in
- 100'ths of a second.
- Setting this to zero disables periodic writeback altogether.
- drop_caches
- ===========
- Writing to this will cause the kernel to drop clean caches, as well as
- reclaimable slab objects like dentries and inodes. Once dropped, their
- memory becomes free.
- To free pagecache::
- echo 1 > /proc/sys/vm/drop_caches
- To free reclaimable slab objects (includes dentries and inodes)::
- echo 2 > /proc/sys/vm/drop_caches
- To free slab objects and pagecache::
- echo 3 > /proc/sys/vm/drop_caches
- This is a non-destructive operation and will not free any dirty objects.
- To increase the number of objects freed by this operation, the user may run
- `sync` prior to writing to /proc/sys/vm/drop_caches. This will minimize the
- number of dirty objects on the system and create more candidates to be
- dropped.
- This file is not a means to control the growth of the various kernel caches
- (inodes, dentries, pagecache, etc...) These objects are automatically
- reclaimed by the kernel when memory is needed elsewhere on the system.
- Use of this file can cause performance problems. Since it discards cached
- objects, it may cost a significant amount of I/O and CPU to recreate the
- dropped objects, especially if they were under heavy use. Because of this,
- use outside of a testing or debugging environment is not recommended.
- You may see informational messages in your kernel log when this file is
- used::
- cat (1234): drop_caches: 3
- These are informational only. They do not mean that anything is wrong
- with your system. To disable them, echo 4 (bit 2) into drop_caches.
- extfrag_threshold
- =================
- This parameter affects whether the kernel will compact memory or direct
- reclaim to satisfy a high-order allocation. The extfrag/extfrag_index file in
- debugfs shows what the fragmentation index for each order is in each zone in
- the system. Values tending towards 0 imply allocations would fail due to lack
- of memory, values towards 1000 imply failures are due to fragmentation and -1
- implies that the allocation will succeed as long as watermarks are met.
- The kernel will not compact memory in a zone if the
- fragmentation index is <= extfrag_threshold. The default value is 500.
- highmem_is_dirtyable
- ====================
- Available only for systems with CONFIG_HIGHMEM enabled (32b systems).
- This parameter controls whether the high memory is considered for dirty
- writers throttling. This is not the case by default which means that
- only the amount of memory directly visible/usable by the kernel can
- be dirtied. As a result, on systems with a large amount of memory and
- lowmem basically depleted writers might be throttled too early and
- streaming writes can get very slow.
- Changing the value to non zero would allow more memory to be dirtied
- and thus allow writers to write more data which can be flushed to the
- storage more effectively. Note this also comes with a risk of pre-mature
- OOM killer because some writers (e.g. direct block device writes) can
- only use the low memory and they can fill it up with dirty data without
- any throttling.
- extra_free_kbytes
- This parameter tells the VM to keep extra free memory between the threshold
- where background reclaim (kswapd) kicks in, and the threshold where direct
- reclaim (by allocating processes) kicks in.
- This is useful for workloads that require low latency memory allocations
- and have a bounded burstiness in memory allocations, for example a
- realtime application that receives and transmits network traffic
- (causing in-kernel memory allocations) with a maximum total message burst
- size of 200MB may need 200MB of extra free memory to avoid direct reclaim
- related latencies.
- ==============================================================
- hugetlb_shm_group
- =================
- hugetlb_shm_group contains group id that is allowed to create SysV
- shared memory segment using hugetlb page.
- laptop_mode
- ===========
- laptop_mode is a knob that controls "laptop mode". All the things that are
- controlled by this knob are discussed in Documentation/admin-guide/laptops/laptop-mode.rst.
- legacy_va_layout
- ================
- If non-zero, this sysctl disables the new 32-bit mmap layout - the kernel
- will use the legacy (2.4) layout for all processes.
- lowmem_reserve_ratio
- ====================
- For some specialised workloads on highmem machines it is dangerous for
- the kernel to allow process memory to be allocated from the "lowmem"
- zone. This is because that memory could then be pinned via the mlock()
- system call, or by unavailability of swapspace.
- And on large highmem machines this lack of reclaimable lowmem memory
- can be fatal.
- So the Linux page allocator has a mechanism which prevents allocations
- which *could* use highmem from using too much lowmem. This means that
- a certain amount of lowmem is defended from the possibility of being
- captured into pinned user memory.
- (The same argument applies to the old 16 megabyte ISA DMA region. This
- mechanism will also defend that region from allocations which could use
- highmem or lowmem).
- The `lowmem_reserve_ratio` tunable determines how aggressive the kernel is
- in defending these lower zones.
- If you have a machine which uses highmem or ISA DMA and your
- applications are using mlock(), or if you are running with no swap then
- you probably should change the lowmem_reserve_ratio setting.
- The lowmem_reserve_ratio is an array. You can see them by reading this file::
- % cat /proc/sys/vm/lowmem_reserve_ratio
- 256 256 32
- But, these values are not used directly. The kernel calculates # of protection
- pages for each zones from them. These are shown as array of protection pages
- in /proc/zoneinfo like followings. (This is an example of x86-64 box).
- Each zone has an array of protection pages like this::
- Node 0, zone DMA
- pages free 1355
- min 3
- low 3
- high 4
- :
- :
- numa_other 0
- protection: (0, 2004, 2004, 2004)
- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- pagesets
- cpu: 0 pcp: 0
- :
- These protections are added to score to judge whether this zone should be used
- for page allocation or should be reclaimed.
- In this example, if normal pages (index=2) are required to this DMA zone and
- watermark[WMARK_HIGH] is used for watermark, the kernel judges this zone should
- not be used because pages_free(1355) is smaller than watermark + protection[2]
- (4 + 2004 = 2008). If this protection value is 0, this zone would be used for
- normal page requirement. If requirement is DMA zone(index=0), protection[0]
- (=0) is used.
- zone[i]'s protection[j] is calculated by following expression::
- (i < j):
- zone[i]->protection[j]
- = (total sums of managed_pages from zone[i+1] to zone[j] on the node)
- / lowmem_reserve_ratio[i];
- (i = j):
- (should not be protected. = 0;
- (i > j):
- (not necessary, but looks 0)
- The default values of lowmem_reserve_ratio[i] are
- === ====================================
- 256 (if zone[i] means DMA or DMA32 zone)
- 32 (others)
- === ====================================
- As above expression, they are reciprocal number of ratio.
- 256 means 1/256. # of protection pages becomes about "0.39%" of total managed
- pages of higher zones on the node.
- If you would like to protect more pages, smaller values are effective.
- The minimum value is 1 (1/1 -> 100%). The value less than 1 completely
- disables protection of the pages.
- max_map_count:
- ==============
- This file contains the maximum number of memory map areas a process
- may have. Memory map areas are used as a side-effect of calling
- malloc, directly by mmap, mprotect, and madvise, and also when loading
- shared libraries.
- While most applications need less than a thousand maps, certain
- programs, particularly malloc debuggers, may consume lots of them,
- e.g., up to one or two maps per allocation.
- The default value is 65536.
- memory_failure_early_kill:
- ==========================
- Control how to kill processes when uncorrected memory error (typically
- a 2bit error in a memory module) is detected in the background by hardware
- that cannot be handled by the kernel. In some cases (like the page
- still having a valid copy on disk) the kernel will handle the failure
- transparently without affecting any applications. But if there is
- no other uptodate copy of the data it will kill to prevent any data
- corruptions from propagating.
- 1: Kill all processes that have the corrupted and not reloadable page mapped
- as soon as the corruption is detected. Note this is not supported
- for a few types of pages, like kernel internally allocated data or
- the swap cache, but works for the majority of user pages.
- 0: Only unmap the corrupted page from all processes and only kill a process
- who tries to access it.
- The kill is done using a catchable SIGBUS with BUS_MCEERR_AO, so processes can
- handle this if they want to.
- This is only active on architectures/platforms with advanced machine
- check handling and depends on the hardware capabilities.
- Applications can override this setting individually with the PR_MCE_KILL prctl
- memory_failure_recovery
- =======================
- Enable memory failure recovery (when supported by the platform)
- 1: Attempt recovery.
- 0: Always panic on a memory failure.
- min_free_kbytes
- ===============
- This is used to force the Linux VM to keep a minimum number
- of kilobytes free. The VM uses this number to compute a
- watermark[WMARK_MIN] value for each lowmem zone in the system.
- Each lowmem zone gets a number of reserved free pages based
- proportionally on its size.
- Some minimal amount of memory is needed to satisfy PF_MEMALLOC
- allocations; if you set this to lower than 1024KB, your system will
- become subtly broken, and prone to deadlock under high loads.
- Setting this too high will OOM your machine instantly.
- min_slab_ratio
- ==============
- This is available only on NUMA kernels.
- A percentage of the total pages in each zone. On Zone reclaim
- (fallback from the local zone occurs) slabs will be reclaimed if more
- than this percentage of pages in a zone are reclaimable slab pages.
- This insures that the slab growth stays under control even in NUMA
- systems that rarely perform global reclaim.
- The default is 5 percent.
- Note that slab reclaim is triggered in a per zone / node fashion.
- The process of reclaiming slab memory is currently not node specific
- and may not be fast.
- min_unmapped_ratio
- ==================
- This is available only on NUMA kernels.
- This is a percentage of the total pages in each zone. Zone reclaim will
- only occur if more than this percentage of pages are in a state that
- zone_reclaim_mode allows to be reclaimed.
- If zone_reclaim_mode has the value 4 OR'd, then the percentage is compared
- against all file-backed unmapped pages including swapcache pages and tmpfs
- files. Otherwise, only unmapped pages backed by normal files but not tmpfs
- files and similar are considered.
- The default is 1 percent.
- mmap_min_addr
- =============
- This file indicates the amount of address space which a user process will
- be restricted from mmapping. Since kernel null dereference bugs could
- accidentally operate based on the information in the first couple of pages
- of memory userspace processes should not be allowed to write to them. By
- default this value is set to 0 and no protections will be enforced by the
- security module. Setting this value to something like 64k will allow the
- vast majority of applications to work correctly and provide defense in depth
- against future potential kernel bugs.
- mmap_rnd_bits
- =============
- This value can be used to select the number of bits to use to
- determine the random offset to the base address of vma regions
- resulting from mmap allocations on architectures which support
- tuning address space randomization. This value will be bounded
- by the architecture's minimum and maximum supported values.
- This value can be changed after boot using the
- /proc/sys/vm/mmap_rnd_bits tunable
- mmap_rnd_compat_bits
- ====================
- This value can be used to select the number of bits to use to
- determine the random offset to the base address of vma regions
- resulting from mmap allocations for applications run in
- compatibility mode on architectures which support tuning address
- space randomization. This value will be bounded by the
- architecture's minimum and maximum supported values.
- This value can be changed after boot using the
- /proc/sys/vm/mmap_rnd_compat_bits tunable
- nr_hugepages
- ============
- Change the minimum size of the hugepage pool.
- See Documentation/admin-guide/mm/hugetlbpage.rst
- nr_hugepages_mempolicy
- ======================
- Change the size of the hugepage pool at run-time on a specific
- set of NUMA nodes.
- See Documentation/admin-guide/mm/hugetlbpage.rst
- nr_overcommit_hugepages
- =======================
- Change the maximum size of the hugepage pool. The maximum is
- nr_hugepages + nr_overcommit_hugepages.
- See Documentation/admin-guide/mm/hugetlbpage.rst
- nr_trim_pages
- =============
- This is available only on NOMMU kernels.
- This value adjusts the excess page trimming behaviour of power-of-2 aligned
- NOMMU mmap allocations.
- A value of 0 disables trimming of allocations entirely, while a value of 1
- trims excess pages aggressively. Any value >= 1 acts as the watermark where
- trimming of allocations is initiated.
- The default value is 1.
- See Documentation/admin-guide/mm/nommu-mmap.rst for more information.
- numa_zonelist_order
- ===================
- This sysctl is only for NUMA and it is deprecated. Anything but
- Node order will fail!
- 'where the memory is allocated from' is controlled by zonelists.
- (This documentation ignores ZONE_HIGHMEM/ZONE_DMA32 for simple explanation.
- you may be able to read ZONE_DMA as ZONE_DMA32...)
- In non-NUMA case, a zonelist for GFP_KERNEL is ordered as following.
- ZONE_NORMAL -> ZONE_DMA
- This means that a memory allocation request for GFP_KERNEL will
- get memory from ZONE_DMA only when ZONE_NORMAL is not available.
- In NUMA case, you can think of following 2 types of order.
- Assume 2 node NUMA and below is zonelist of Node(0)'s GFP_KERNEL::
- (A) Node(0) ZONE_NORMAL -> Node(0) ZONE_DMA -> Node(1) ZONE_NORMAL
- (B) Node(0) ZONE_NORMAL -> Node(1) ZONE_NORMAL -> Node(0) ZONE_DMA.
- Type(A) offers the best locality for processes on Node(0), but ZONE_DMA
- will be used before ZONE_NORMAL exhaustion. This increases possibility of
- out-of-memory(OOM) of ZONE_DMA because ZONE_DMA is tend to be small.
- Type(B) cannot offer the best locality but is more robust against OOM of
- the DMA zone.
- Type(A) is called as "Node" order. Type (B) is "Zone" order.
- "Node order" orders the zonelists by node, then by zone within each node.
- Specify "[Nn]ode" for node order
- "Zone Order" orders the zonelists by zone type, then by node within each
- zone. Specify "[Zz]one" for zone order.
- Specify "[Dd]efault" to request automatic configuration.
- On 32-bit, the Normal zone needs to be preserved for allocations accessible
- by the kernel, so "zone" order will be selected.
- On 64-bit, devices that require DMA32/DMA are relatively rare, so "node"
- order will be selected.
- Default order is recommended unless this is causing problems for your
- system/application.
- oom_dump_tasks
- ==============
- Enables a system-wide task dump (excluding kernel threads) to be produced
- when the kernel performs an OOM-killing and includes such information as
- pid, uid, tgid, vm size, rss, pgtables_bytes, swapents, oom_score_adj
- score, and name. This is helpful to determine why the OOM killer was
- invoked, to identify the rogue task that caused it, and to determine why
- the OOM killer chose the task it did to kill.
- If this is set to zero, this information is suppressed. On very
- large systems with thousands of tasks it may not be feasible to dump
- the memory state information for each one. Such systems should not
- be forced to incur a performance penalty in OOM conditions when the
- information may not be desired.
- If this is set to non-zero, this information is shown whenever the
- OOM killer actually kills a memory-hogging task.
- The default value is 1 (enabled).
- oom_kill_allocating_task
- ========================
- This enables or disables killing the OOM-triggering task in
- out-of-memory situations.
- If this is set to zero, the OOM killer will scan through the entire
- tasklist and select a task based on heuristics to kill. This normally
- selects a rogue memory-hogging task that frees up a large amount of
- memory when killed.
- If this is set to non-zero, the OOM killer simply kills the task that
- triggered the out-of-memory condition. This avoids the expensive
- tasklist scan.
- If panic_on_oom is selected, it takes precedence over whatever value
- is used in oom_kill_allocating_task.
- The default value is 0.
- overcommit_kbytes
- =================
- When overcommit_memory is set to 2, the committed address space is not
- permitted to exceed swap plus this amount of physical RAM. See below.
- Note: overcommit_kbytes is the counterpart of overcommit_ratio. Only one
- of them may be specified at a time. Setting one disables the other (which
- then appears as 0 when read).
- overcommit_memory
- =================
- This value contains a flag that enables memory overcommitment.
- When this flag is 0, the kernel attempts to estimate the amount
- of free memory left when userspace requests more memory.
- When this flag is 1, the kernel pretends there is always enough
- memory until it actually runs out.
- When this flag is 2, the kernel uses a "never overcommit"
- policy that attempts to prevent any overcommit of memory.
- Note that user_reserve_kbytes affects this policy.
- This feature can be very useful because there are a lot of
- programs that malloc() huge amounts of memory "just-in-case"
- and don't use much of it.
- The default value is 0.
- See Documentation/vm/overcommit-accounting.rst and
- mm/util.c::__vm_enough_memory() for more information.
- overcommit_ratio
- ================
- When overcommit_memory is set to 2, the committed address
- space is not permitted to exceed swap plus this percentage
- of physical RAM. See above.
- page-cluster
- ============
- page-cluster controls the number of pages up to which consecutive pages
- are read in from swap in a single attempt. This is the swap counterpart
- to page cache readahead.
- The mentioned consecutivity is not in terms of virtual/physical addresses,
- but consecutive on swap space - that means they were swapped out together.
- It is a logarithmic value - setting it to zero means "1 page", setting
- it to 1 means "2 pages", setting it to 2 means "4 pages", etc.
- Zero disables swap readahead completely.
- The default value is three (eight pages at a time). There may be some
- small benefits in tuning this to a different value if your workload is
- swap-intensive.
- Lower values mean lower latencies for initial faults, but at the same time
- extra faults and I/O delays for following faults if they would have been part of
- that consecutive pages readahead would have brought in.
- panic_on_oom
- ============
- This enables or disables panic on out-of-memory feature.
- If this is set to 0, the kernel will kill some rogue process,
- called oom_killer. Usually, oom_killer can kill rogue processes and
- system will survive.
- If this is set to 1, the kernel panics when out-of-memory happens.
- However, if a process limits using nodes by mempolicy/cpusets,
- and those nodes become memory exhaustion status, one process
- may be killed by oom-killer. No panic occurs in this case.
- Because other nodes' memory may be free. This means system total status
- may be not fatal yet.
- If this is set to 2, the kernel panics compulsorily even on the
- above-mentioned. Even oom happens under memory cgroup, the whole
- system panics.
- The default value is 0.
- 1 and 2 are for failover of clustering. Please select either
- according to your policy of failover.
- panic_on_oom=2+kdump gives you very strong tool to investigate
- why oom happens. You can get snapshot.
- percpu_pagelist_fraction
- ========================
- This is the fraction of pages at most (high mark pcp->high) in each zone that
- are allocated for each per cpu page list. The min value for this is 8. It
- means that we don't allow more than 1/8th of pages in each zone to be
- allocated in any single per_cpu_pagelist. This entry only changes the value
- of hot per cpu pagelists. User can specify a number like 100 to allocate
- 1/100th of each zone to each per cpu page list.
- The batch value of each per cpu pagelist is also updated as a result. It is
- set to pcp->high/4. The upper limit of batch is (PAGE_SHIFT * 8)
- The initial value is zero. Kernel does not use this value at boot time to set
- the high water marks for each per cpu page list. If the user writes '0' to this
- sysctl, it will revert to this default behavior.
- stat_interval
- =============
- The time interval between which vm statistics are updated. The default
- is 1 second.
- stat_refresh
- ============
- Any read or write (by root only) flushes all the per-cpu vm statistics
- into their global totals, for more accurate reports when testing
- e.g. cat /proc/sys/vm/stat_refresh /proc/meminfo
- As a side-effect, it also checks for negative totals (elsewhere reported
- as 0) and "fails" with EINVAL if any are found, with a warning in dmesg.
- (At time of writing, a few stats are known sometimes to be found negative,
- with no ill effects: errors and warnings on these stats are suppressed.)
- numa_stat
- =========
- This interface allows runtime configuration of numa statistics.
- When page allocation performance becomes a bottleneck and you can tolerate
- some possible tool breakage and decreased numa counter precision, you can
- do::
- echo 0 > /proc/sys/vm/numa_stat
- When page allocation performance is not a bottleneck and you want all
- tooling to work, you can do::
- echo 1 > /proc/sys/vm/numa_stat
- swappiness
- ==========
- This control is used to define the rough relative IO cost of swapping
- and filesystem paging, as a value between 0 and 200. At 100, the VM
- assumes equal IO cost and will thus apply memory pressure to the page
- cache and swap-backed pages equally; lower values signify more
- expensive swap IO, higher values indicates cheaper.
- Keep in mind that filesystem IO patterns under memory pressure tend to
- be more efficient than swap's random IO. An optimal value will require
- experimentation and will also be workload-dependent.
- The default value is 60.
- For in-memory swap, like zram or zswap, as well as hybrid setups that
- have swap on faster devices than the filesystem, values beyond 100 can
- be considered. For example, if the random IO against the swap device
- is on average 2x faster than IO from the filesystem, swappiness should
- be 133 (x + 2x = 200, 2x = 133.33).
- At 0, the kernel will not initiate swap until the amount of free and
- file-backed pages is less than the high watermark in a zone.
- unprivileged_userfaultfd
- ========================
- This flag controls the mode in which unprivileged users can use the
- userfaultfd system calls. Set this to 0 to restrict unprivileged users
- to handle page faults in user mode only. In this case, users without
- SYS_CAP_PTRACE must pass UFFD_USER_MODE_ONLY in order for userfaultfd to
- succeed. Prohibiting use of userfaultfd for handling faults from kernel
- mode may make certain vulnerabilities more difficult to exploit.
- Set this to 1 to allow unprivileged users to use the userfaultfd system
- calls without any restrictions.
- The default value is 0.
- user_reserve_kbytes
- ===================
- When overcommit_memory is set to 2, "never overcommit" mode, reserve
- min(3% of current process size, user_reserve_kbytes) of free memory.
- This is intended to prevent a user from starting a single memory hogging
- process, such that they cannot recover (kill the hog).
- user_reserve_kbytes defaults to min(3% of the current process size, 128MB).
- If this is reduced to zero, then the user will be allowed to allocate
- all free memory with a single process, minus admin_reserve_kbytes.
- Any subsequent attempts to execute a command will result in
- "fork: Cannot allocate memory".
- Changing this takes effect whenever an application requests memory.
- vfs_cache_pressure
- ==================
- This percentage value controls the tendency of the kernel to reclaim
- the memory which is used for caching of directory and inode objects.
- At the default value of vfs_cache_pressure=100 the kernel will attempt to
- reclaim dentries and inodes at a "fair" rate with respect to pagecache and
- swapcache reclaim. Decreasing vfs_cache_pressure causes the kernel to prefer
- to retain dentry and inode caches. When vfs_cache_pressure=0, the kernel will
- never reclaim dentries and inodes due to memory pressure and this can easily
- lead to out-of-memory conditions. Increasing vfs_cache_pressure beyond 100
- causes the kernel to prefer to reclaim dentries and inodes.
- Increasing vfs_cache_pressure significantly beyond 100 may have negative
- performance impact. Reclaim code needs to take various locks to find freeable
- directory and inode objects. With vfs_cache_pressure=1000, it will look for
- ten times more freeable objects than there are.
- watermark_boost_factor
- ======================
- This factor controls the level of reclaim when memory is being fragmented.
- It defines the percentage of the high watermark of a zone that will be
- reclaimed if pages of different mobility are being mixed within pageblocks.
- The intent is that compaction has less work to do in the future and to
- increase the success rate of future high-order allocations such as SLUB
- allocations, THP and hugetlbfs pages.
- To make it sensible with respect to the watermark_scale_factor
- parameter, the unit is in fractions of 10,000. The default value of
- 15,000 on !DISCONTIGMEM configurations means that up to 150% of the high
- watermark will be reclaimed in the event of a pageblock being mixed due
- to fragmentation. The level of reclaim is determined by the number of
- fragmentation events that occurred in the recent past. If this value is
- smaller than a pageblock then a pageblocks worth of pages will be reclaimed
- (e.g. 2MB on 64-bit x86). A boost factor of 0 will disable the feature.
- watermark_scale_factor
- ======================
- This factor controls the aggressiveness of kswapd. It defines the
- amount of memory left in a node/system before kswapd is woken up and
- how much memory needs to be free before kswapd goes back to sleep.
- The unit is in fractions of 10,000. The default value of 10 means the
- distances between watermarks are 0.1% of the available memory in the
- node/system. The maximum value is 1000, or 10% of memory.
- A high rate of threads entering direct reclaim (allocstall) or kswapd
- going to sleep prematurely (kswapd_low_wmark_hit_quickly) can indicate
- that the number of free pages kswapd maintains for latency reasons is
- too small for the allocation bursts occurring in the system. This knob
- can then be used to tune kswapd aggressiveness accordingly.
- zone_reclaim_mode
- =================
- Zone_reclaim_mode allows someone to set more or less aggressive approaches to
- reclaim memory when a zone runs out of memory. If it is set to zero then no
- zone reclaim occurs. Allocations will be satisfied from other zones / nodes
- in the system.
- This is value OR'ed together of
- = ===================================
- 1 Zone reclaim on
- 2 Zone reclaim writes dirty pages out
- 4 Zone reclaim swaps pages
- = ===================================
- zone_reclaim_mode is disabled by default. For file servers or workloads
- that benefit from having their data cached, zone_reclaim_mode should be
- left disabled as the caching effect is likely to be more important than
- data locality.
- Consider enabling one or more zone_reclaim mode bits if it's known that the
- workload is partitioned such that each partition fits within a NUMA node
- and that accessing remote memory would cause a measurable performance
- reduction. The page allocator will take additional actions before
- allocating off node pages.
- Allowing zone reclaim to write out pages stops processes that are
- writing large amounts of data from dirtying pages on other nodes. Zone
- reclaim will write out dirty pages if a zone fills up and so effectively
- throttle the process. This may decrease the performance of a single process
- since it cannot use all of system memory to buffer the outgoing writes
- anymore but it preserve the memory on other nodes so that the performance
- of other processes running on other nodes will not be affected.
- Allowing regular swap effectively restricts allocations to the local
- node unless explicitly overridden by memory policies or cpuset
- configurations.
|