search..
No manual entry for -- in section 5
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 management.

       /proc/sys/vm/admin_reserve_kbytes (since Linux 3.10)
	      This file defines the amount of free memory (in KiB) on the  sys-
	      tem  that	 should	 be  reserved  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 pro-
	      vide 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  superuser  may  not be able to log in to recover the system.
	      For example, on x86-64 a suitable value  is  131072  (128MiB  re-
	      served).

	      Changing the value in this file takes effect whenever an applica-
	      tion 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/buddy-
	      info.

	      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, den-
	      tries,  and  inodes  from	 memory,  causing that memory to become
	      free.  This can be useful for memory management testing and  per-
	      forming  reproducible  filesystem benchmarks.  Because writing to
	      this file causes the benefits of caching to be lost, it  can  de-
	      grade overall system performance.

	      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 allo-
	      cate 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 error in a memory module) that cannot be  han-
	      dled by the kernel is detected in the background 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 prevent any data corruptions
	      from propagating.

	      The file has one of the following values:

	      1	     Kill all processes that have the corrupted-and-not-reload-
		     able 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  ad-
	      vanced  machine  check handling and depends on the hardware capa-
	      bilities.

	      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_MEM-
	      ORY_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_MEM-
	      ORY_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  in-
	      cludes 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	 sched-
	      uled    on,    oom_adj	score	 (see	 the   description   of
	      /proc/pid/oom_adj), and command name.  This is helpful to	 deter-
	      mine  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 systems with thousands of tasks, it may not be fea-
	      sible  to	 dump  the memory state information 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  en-
	      tire  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 nonzero, the OOM-killer simply kills  the  task
	      that triggered the out-of-memory condition.  This avoids a possi-
	      bly 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/over-
	      commit_ratio    for    controlling    the	   CommitLimit	   when
	      /proc/sys/vm/overcommit_memory  has  the	value 2.  It allows the
	      amount of memory overcommitting to be specified  as  an  absolute
	      value (in kB), rather than as a percentage, as is done with over-
	      commit_ratio.   This  allows  for	 finer-grained	control of Com-
	      mitLimit on systems with extremely large memory sizes.

	      Only one of overcommit_kbytes or overcommit_ratio can have an ef-
	      fect: if overcommit_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 get-
	      ting a process "OOM-killed".

	      In mode 1, the kernel pretends there is always enough memory, un-
	      til memory actually runs out.  One use case for this mode is sci-
	      entific 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 allocated  (CommitLimit	 in  /proc/meminfo)  is
	      calculated as

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

	      where:

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

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

	      o	 overcommit_ratio is the value	in  /proc/sys/vm/overcommit_ra-
		 tio; and

	      o	 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 CommitLimit 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 default value in the file is 50.  See the de-
	      scription 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 situ-
	      ation.

	      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 pan-
	      ics when out-of-memory happens.  However, if a process limits al-
	      locations	 to  certain  nodes  using  memory  policies  (mbind(2)
	      MPOL_BIND)  or  cpusets  (cpuset(7)) and those nodes reach memory
	      exhaustion 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 according 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 default 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  intended 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_re-
	      serve_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 al-
	      lowed to allocate all free memory with a	single	process	 (minus
	      the  amount  reserved by /proc/sys/vm/admin_reserve_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 applica-
	      tion requests memory.

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

SEE ALSO
       proc(5), proc_sys(5)

Linux man-pages 6.9.1		   2024-05-02			 proc_sys_vm(5)