proc_sys_vm - virtual memory subsystem - man(5) - [phpMan]

Che Dong

proc_sys_vm(5) File Formats Manual proc_sys_vm(5)

NAME
/proc/sys/vm/ - virtual memory subsystem

DESCRIPTION
/proc/sys/vm/
This directory contains files for memory management tuning, buffer, and cache manage‐
ment.

/proc/sys/vm/admin_reserve_kbytes (since Linux 3.10)
This file defines the amount of free memory (in KiB) on the system that should be re‐
served for users with the capability CAP_SYS_ADMIN.

The default value in this file is the minimum of [3% of free pages, 8MiB] expressed as
KiB. The default is intended to provide enough for the superuser to log in and kill a
process, if necessary, under the default overcommit 'guess' mode (i.e., 0 in
/proc/sys/vm/overcommit_memory).

Systems running in "overcommit never" mode (i.e., 2 in /proc/sys/vm/overcommit_memory)
should increase the value in this file to account for the full virtual memory size of
the programs used to recover (e.g., login(1) ssh(1), and top(1)) Otherwise, the supe‐
ruser may not be able to log in to recover the system. For example, on x86-64 a suit‐
able value is 131072 (128MiB reserved).

Changing the value in this file takes effect whenever an application requests memory.

/proc/sys/vm/compact_memory (since Linux 2.6.35)
When 1 is written to this file, all zones are compacted such that free memory is
available in contiguous blocks where possible. The effect of this action can be seen
by examining /proc/buddyinfo.

Present only if the kernel was configured with CONFIG_COMPACTION.

/proc/sys/vm/drop_caches (since Linux 2.6.16)
Writing to this file causes the kernel to drop clean caches, dentries, and inodes from
memory, causing that memory to become free. This can be useful for memory management
testing and performing reproducible filesystem benchmarks. Because writing to this
file causes the benefits of caching to be lost, it can degrade overall system perfor‐
mance.

To free pagecache, use:

echo 1 > /proc/sys/vm/drop_caches

To free dentries and inodes, use:

echo 2 > /proc/sys/vm/drop_caches

To free pagecache, dentries, and inodes, use:

echo 3 > /proc/sys/vm/drop_caches

Because writing to this file is a nondestructive operation and dirty objects are not
freeable, the user should run sync(1) first.

/proc/sys/vm/sysctl_hugetlb_shm_group (since Linux 2.6.7)
This writable file contains a group ID that is allowed to allocate memory using huge
pages. If a process has a filesystem group ID or any supplementary group ID that
matches this group ID, then it can make huge-page allocations without holding the
CAP_IPC_LOCK capability; see memfd_create(2), mmap(2), and shmget(2).

/proc/sys/vm/legacy_va_layout (since Linux 2.6.9)
If nonzero, this disables the new 32-bit memory-mapping layout; the kernel will use
the legacy (2.4) layout for all processes.

/proc/sys/vm/memory_failure_early_kill (since Linux 2.6.32)
Control how to kill processes when an uncorrected memory error (typically a 2-bit er‐
ror in a memory module) that cannot be handled by the kernel is detected in the back‐
ground by hardware. 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 up-to-date copy of the data, it will kill processes to pre‐
vent any data corruptions from propagating.

The file has one of the following values:

1 Kill all processes that have the corrupted-and-not-reloadable page mapped as
soon as the corruption is detected. Note that this is not supported for a few
types of pages, such as kernel internally allocated data or the swap cache, but
works for the majority of user pages.

0 Unmap the corrupted page from all processes and kill a process only if it tries
to access the page.

The kill is performed using a SIGBUS signal with si_code set to BUS_MCEERR_AO.
Processes can handle this if they want to; see sigaction(2) for more details.

This feature is active only on architectures/platforms with advanced machine check
handling and depends on the hardware capabilities.

Applications can override the memory_failure_early_kill setting individually with the
prctl(2) PR_MCE_KILL operation.

Present only if the kernel was configured with CONFIG_MEMORY_FAILURE.

/proc/sys/vm/memory_failure_recovery (since Linux 2.6.32)
Enable memory failure recovery (when supported by the platform).

1 Attempt recovery.

0 Always panic on a memory failure.

Present only if the kernel was configured with CONFIG_MEMORY_FAILURE.

/proc/sys/vm/oom_dump_tasks (since Linux 2.6.25)
Enables a system-wide task dump (excluding kernel threads) to be produced when the
kernel performs an OOM-killing. The dump includes the following information for each
task (thread, process): thread ID, real user ID, thread group ID (process ID), virtual
memory size, resident set size, the CPU that the task is scheduled on, oom_adj score
(see the description of /proc/pid/oom_adj), and command name. This is helpful to de‐
termine why the OOM-killer was invoked and to identify the rogue task that caused it.

If this contains the value zero, this information is suppressed. On very large sys‐
tems with thousands of tasks, it may not be feasible to dump the memory state informa‐
tion for each one. Such systems should not be forced to incur a performance penalty
in OOM situations when the information may not be desired.

If this is set to nonzero, this information is shown whenever the OOM-killer actually
kills a memory-hogging task.

The default value is 0.

/proc/sys/vm/oom_kill_allocating_task (since Linux 2.6.24)
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 se‐
lect 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 nonzero, the OOM-killer simply kills the task that triggered the
out-of-memory condition. This avoids a possibly expensive tasklist scan.

If /proc/sys/vm/panic_on_oom is nonzero, it takes precedence over whatever value is
used in /proc/sys/vm/oom_kill_allocating_task.

The default value is 0.

/proc/sys/vm/overcommit_kbytes (since Linux 3.14)
This writable file provides an alternative to /proc/sys/vm/overcommit_ratio for con‐
trolling the CommitLimit when /proc/sys/vm/overcommit_memory has the value 2. It al‐
lows the amount of memory overcommitting to be specified as an absolute value (in kB),
rather than as a percentage, as is done with overcommit_ratio. This allows for finer-
grained control of CommitLimit on systems with extremely large memory sizes.

Only one of overcommit_kbytes or overcommit_ratio can have an effect: if overcom‐
mit_kbytes has a nonzero value, then it is used to calculate CommitLimit, otherwise
overcommit_ratio is used. Writing a value to either of these files causes the value
in the other file to be set to zero.

/proc/sys/vm/overcommit_memory
This file contains the kernel virtual memory accounting mode. Values are:

0: heuristic overcommit (this is the default)
1: always overcommit, never check
2: always check, never overcommit

In mode 0, calls of mmap(2) with MAP_NORESERVE are not checked, and the default check
is very weak, leading to the risk of getting a process "OOM-killed".

In mode 1, the kernel pretends there is always enough memory, until memory actually
runs out. One use case for this mode is scientific computing applications that employ
large sparse arrays. Before Linux 2.6.0, any nonzero value implies mode 1.

In mode 2 (available since Linux 2.6), the total virtual address space that can be al‐
located (CommitLimit in /proc/meminfo) is calculated as

CommitLimit = (total_RAM - total_huge_TLB) *
overcommit_ratio / 100 + total_swap

where:

• total_RAM is the total amount of RAM on the system;

• total_huge_TLB is the amount of memory set aside for huge pages;

• overcommit_ratio is the value in /proc/sys/vm/overcommit_ratio; and

• total_swap is the amount of swap space.

For example, on a system with 16 GB of physical RAM, 16 GB of swap, no space dedicated
to huge pages, and an overcommit_ratio of 50, this formula yields a CommitLimit of 24
GB.

Since Linux 3.14, if the value in /proc/sys/vm/overcommit_kbytes is nonzero, then Com‐
mitLimit is instead calculated as:

CommitLimit = overcommit_kbytes + total_swap

See also the description of /proc/sys/vm/admin_reserve_kbytes and
/proc/sys/vm/user_reserve_kbytes.

/proc/sys/vm/overcommit_ratio (since Linux 2.6.0)
This writable file defines a percentage by which memory can be overcommitted. The de‐
fault value in the file is 50. See the description of /proc/sys/vm/overcommit_memory.

/proc/sys/vm/panic_on_oom (since Linux 2.6.18)
This enables or disables a kernel panic in an out-of-memory situation.

If this file is set to the value 0, the kernel's OOM-killer will kill some rogue
process. Usually, the OOM-killer is able to kill a rogue process and the system will
survive.

If this file is set to the value 1, then the kernel normally panics when out-of-memory
happens. However, if a process limits allocations to certain nodes using memory poli‐
cies (mbind(2) MPOL_BIND) or cpusets (cpuset(7)) and those nodes reach memory exhaus‐
tion status, one process may be killed by the OOM-killer. No panic occurs in this
case: because other nodes' memory may be free, this means the system as a whole may
not have reached an out-of-memory situation yet.

If this file is set to the value 2, the kernel always panics when an out-of-memory
condition occurs.

The default value is 0. 1 and 2 are for failover of clustering. Select either ac‐
cording to your policy of failover.

/proc/sys/vm/swappiness
The value in this file controls how aggressively the kernel will swap memory pages.
Higher values increase aggressiveness, lower values decrease aggressiveness. The de‐
fault value is 60.

/proc/sys/vm/user_reserve_kbytes (since Linux 3.10)
Specifies an amount of memory (in KiB) to reserve for user processes. This is in‐
tended to prevent a user from starting a single memory hogging process, such that they
cannot recover (kill the hog). The value in this file has an effect only when
/proc/sys/vm/overcommit_memory is set to 2 ("overcommit never" mode). In this case,
the system reserves an amount of memory that is the minimum of [3% of current process
size, user_reserve_kbytes].

The default value in this file is the minimum of [3% of free pages, 128MiB] expressed
as KiB.

If the value in this file is set to zero, then a user will be allowed to allocate all
free memory with a single process (minus the amount reserved by /proc/sys/vm/admin_re‐
serve_kbytes). Any subsequent attempts to execute a command will result in "fork:
Cannot allocate memory".

Changing the value in this file takes effect whenever an application requests memory.

/proc/sys/vm/unprivileged_userfaultfd (since Linux 5.2)
This (writable) file exposes a flag that controls whether unprivileged processes are
allowed to employ userfaultfd(2). If this file has the value 1, then unprivileged
processes may use userfaultfd(2). If this file has the value 0, then only processes
that have the CAP_SYS_PTRACE capability may employ userfaultfd(2). The default value
in this file is 1.

man > proc_sys_vm(5)