2026-08-24 17:36 @216.73.217.23
CrawledBy Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; ClaudeBot/1.0; +claudebot@anthropic.com)
cgroups - Linux control groups
| Use Case | Command | Description |
|---|---|---|
| Mount a v1 controller | mount -t cgroup -o cpu none /sys/fs/cgroup/cpu | Mount the CPU controller |
| Comount multiple v1 controllers | mount -t cgroup -o cpu,cpuacct none /sys/fs/cgroup/cpu,cpuacct | Mount CPU and CPU accounting together |
| Mount all v1 controllers | mount -t cgroup -o all cgroup /sys/fs/cgroup | Mount all v1 controllers in one hierarchy |
| Mount v2 unified hierarchy | mount -t cgroup2 none /mnt/cgroup2 | Mount cgroups v2 filesystem |
| Create a new cgroup | mkdir /sys/fs/cgroup/cpu/cg1 | Create a new cgroup directory |
| Move a process to a cgroup | echo $$ > /sys/fs/cgroup/cpu/cg1/cgroup.procs | Write PID to cgroup.procs |
| Move a thread (v1) | echo TID > /sys/fs/cgroup/cpu/cg1/tasks | Write thread ID to tasks (v1 only) |
| Enable a v2 controller | echo '+pids -memory' > x/y/cgroup.subtree_control | Enable/disable controllers in subtree |
| Create a threaded subtree | echo 'threaded' > y/z/cgroup.type | Convert cgroup to threaded type |
| Move a thread in v2 threaded subtree | echo TID > /dlgt_grp/cgroup.threads | Write thread ID to move thread |
| Unmount a v1 controller | umount /sys/fs/cgroup/pids | Unmount (only if no child cgroups) |
Control groups, usually referred to as cgroups, are a Linux kernel feature which allow processes to be organized into hierarchical groups whose usage of various types of resources can then be limited and monitored. The kernel's cgroup interface is provided through a pseudo-filesystem called cgroupfs. Grouping is implemented in the core cgroup kernel code, while resource tracking and limits are implemented in a set of per-resource-type subsystems (memory, CPU, and so on).
A cgroup is a collection of processes that are bound to a set of limits or parameters defined via the cgroup filesystem.
A subsystem is a kernel component that modifies the behavior of the processes in a cgroup. Various subsystems have been implemented, making it possible to do things such as limiting the amount of CPU time and memory available to a cgroup, accounting for the CPU time used by a cgroup, and freezing and resuming execution of the processes in a cgroup. Subsystems are sometimes also known as resource controllers (or simply, controllers).
The cgroups for a controller are arranged in a hierarchy. This hierarchy is defined by creating, removing, and renaming subdirectories within the cgroup filesystem. At each level of the hierarchy, attributes (e.g., limits) can be defined. The limits, control, and accounting provided by cgroups generally have effect throughout the subhierarchy underneath the cgroup where the attributes are defined. Thus, for example, the limits placed on a cgroup at a higher level in the hierarchy cannot be exceeded by descendant cgroups.
The initial release of the cgroups implementation was in Linux 2.6.24. Over time, various cgroup controllers have been added to allow the management of various types of resources. However, the development of these controllers was largely uncoordinated, with the result that many inconsistencies arose between controllers and management of the cgroup hierarchies became rather complex. A longer description of these problems can be found in the kernel source file Documentation/admin-guide/cgroup-v2.rst (or Documentation/cgroup-v2.txt in Linux 4.17 and earlier).
Because of the problems with the initial cgroups implementation (cgroups version 1), starting in Linux 3.10, work began on a new, orthogonal implementation to remedy these problems. Initially marked experimental, and hidden behind the -o __DEVEL__sane_behavior mount option, the new version (cgroups version 2) was eventually made official with the release of Linux 4.5. Differences between the two versions are described in the text below. The file cgroup.sane_behavior, present in cgroups v1, is a relic of this mount option. The file always reports "0" and is only retained for backward compatibility.
Although cgroups v2 is intended as a replacement for cgroups v1, the older system continues to exist (and for compatibility reasons is unlikely to be removed). Currently, cgroups v2 implements only a subset of the controllers available in cgroups v1. The two systems are implemented so that both v1 controllers and v2 controllers can be mounted on the same system. Thus, for example, it is possible to use those controllers that are supported under version 2, while also using version 1 controllers where version 2 does not yet support those controllers. The only restriction here is that a controller can't be simultaneously employed in both a cgroups v1 hierarchy and in the cgroups v2 hierarchy.
Under cgroups v1, each controller may be mounted against a separate cgroup filesystem that provides its own hierarchical organization of the processes on the system. It is also possible to comount multiple (or even all) cgroups v1 controllers against the same cgroup filesystem, meaning that the comounted controllers manage the same hierarchical organization of processes.
For each mounted hierarchy, the directory tree mirrors the control group hierarchy. Each control group is represented by a directory, with each of its child control cgroups represented as a child directory. For instance, /user/joe/1.session represents control group 1.session, which is a child of cgroup joe, which is a child of /user. Under each cgroup directory is a set of files which can be read or written to, reflecting resource limits and a few general cgroup properties.
In cgroups v1, a distinction is drawn between processes and tasks. In this view, a process can consist of multiple tasks (more commonly called threads, from a user-space perspective, and called such in the remainder of this man page). In cgroups v1, it is possible to independently manipulate the cgroup memberships of the threads in a process.
The cgroups v1 ability to split threads across different cgroups caused problems in some cases. For example, it made no sense for the memory controller, since all of the threads of a process share a single address space. Because of these problems, the ability to independently manipulate the cgroup memberships of the threads in a process was removed in the initial cgroups v2 implementation, and subsequently restored in a more limited form (see the discussion of "thread mode" below).
The use of cgroups requires a kernel built with the CONFIG_CGROUP option. In addition, each of the v1 controllers has an associated configuration option that must be set in order to employ that controller.
In order to use a v1 controller, it must be mounted against a cgroup filesystem. The usual place for such mounts is under a tmpfs(5) filesystem mounted at /sys/fs/cgroup. Thus, one might mount the cpu controller as follows:
mount -t cgroup -o cpu none /sys/fs/cgroup/cpuIt is possible to comount multiple controllers against the same hierarchy. For example, here the cpu and cpuacct controllers are comounted against a single hierarchy:
mount -t cgroup -o cpu,cpuacct none /sys/fs/cgroup/cpu,cpuacctComounting controllers has the effect that a process is in the same cgroup for all of the comounted controllers. Separately mounting controllers allows a process to be in cgroup /foo1 for one controller while being in /foo2/foo3 for another.
It is possible to comount all v1 controllers against the same hierarchy:
mount -t cgroup -o all cgroup /sys/fs/cgroup(One can achieve the same result by omitting -o all, since it is the default if no controllers are explicitly specified.)
It is not possible to mount the same controller against multiple cgroup hierarchies. For example, it is not possible to mount both the cpu and cpuacct controllers against one hierarchy, and to mount the cpu controller alone against another hierarchy. It is possible to create multiple mount points with exactly the same set of comounted controllers. However, in this case all that results is multiple mount points providing a view of the same hierarchy.
Note that on many systems, the v1 controllers are automatically mounted under /sys/fs/cgroup; in particular, systemd(1) automatically creates such mount points.
A mounted cgroup filesystem can be unmounted using the umount(8) command, as in the following example:
umount /sys/fs/cgroup/pidsBut note well: a cgroup filesystem is unmounted only if it is not busy, that is, it has no child cgroups. If this is not the case, then the only effect of the umount(8) is to make the mount invisible. Thus, to ensure that the mount point is really removed, one must first remove all child cgroups, which in turn can be done only after all member processes have been moved from those cgroups to the root cgroup.
Each of the cgroups version 1 controllers is governed by a kernel configuration option (listed below). Additionally, the availability of the cgroups feature is governed by the CONFIG_CGROUPS kernel configuration option.
A cgroup filesystem initially contains a single root cgroup, '/', which all processes belong to. A new cgroup is created by creating a directory in the cgroup filesystem:
mkdir /sys/fs/cgroup/cpu/cg1This creates a new empty cgroup. A process may be moved to this cgroup by writing its PID into the cgroup's cgroup.procs file:
echo $$ > /sys/fs/cgroup/cpu/cg1/cgroup.procsOnly one PID at a time should be written to this file. Writing the value 0 to a cgroup.procs file causes the writing process to be moved to the corresponding cgroup. When writing a PID into the cgroup.procs, all threads in the process are moved into the new cgroup at once. Within a hierarchy, a process can be a member of exactly one cgroup. Writing a process's PID to a cgroup.procs file automatically removes it from the cgroup of which it was previously a member. The cgroup.procs file can be read to obtain a list of the processes that are members of a cgroup. The returned list of PIDs is not guaranteed to be in order or free of duplicates.
In cgroups v1, an individual thread can be moved to another cgroup by writing its thread ID (i.e., the kernel thread ID returned by clone(2) and gettid(2)) to the tasks file in a cgroup directory. This file can be read to discover the set of threads that are members of the cgroup.
To remove a cgroup, it must first have no child cgroups and contain no (nonzombie) processes. So long as that is the case, one can simply remove the corresponding directory pathname. Note that files in a cgroup directory cannot and need not be removed.
Two files can be used to determine whether the kernel provides notifications when a cgroup becomes empty. A cgroup is considered to be empty when it contains no child cgroups and no member processes. A special file in the root directory of each cgroup hierarchy, release_agent, can be used to register the pathname of a program that may be invoked when a cgroup in the hierarchy becomes empty. The pathname of the newly empty cgroup (relative to the cgroup mount point) is provided as the sole command-line argument when the release_agent program is invoked. The release_agent program might remove the cgroup directory, or perhaps repopulate it with a process. The default value of the release_agent file is empty, meaning that no release agent is invoked. The content of the release_agent file can also be specified via a mount option when the cgroup filesystem is mounted:
mount -o release_agent=pathname ...Whether or not the release_agent program is invoked when a particular cgroup becomes empty is determined by the value in the notify_on_release file in the corresponding cgroup directory. If this file contains the value 0, then the release_agent program is not invoked. If it contains the value 1, the release_agent program is invoked. The default value for this file in the root cgroup is 0. At the time when a new cgroup is created, the value in this file is inherited from the corresponding file in the parent cgroup.
In cgroups v1, it is possible to mount a cgroup hierarchy that has no attached controllers:
mount -t cgroup -o none,name=somename none /some/mount/pointMultiple instances of such hierarchies can be mounted; each hierarchy must have a unique name. The only purpose of such hierarchies is to track processes. (See the discussion of release notification below.) An example of this is the name=systemd cgroup hierarchy that is used by systemd(1) to track services and user sessions. Since Linux 5.0, the cgroup_no_v1 kernel boot option (described below) can be used to disable cgroup v1 named hierarchies, by specifying cgroup_no_v1=named.
In cgroups v2, all mounted controllers reside in a single unified hierarchy. While (different) controllers may be simultaneously mounted under the v1 and v2 hierarchies, it is not possible to mount the same controller simultaneously under both the v1 and the v2 hierarchies.
The new behaviors in cgroups v2 are summarized here:
For more changes, see the Documentation/admin-guide/cgroup-v2.rst file in the kernel source (or Documentation/cgroup-v2.txt in Linux 4.17 and earlier). Some of the new behaviors listed above saw subsequent modification with the addition in Linux 4.14 of "thread mode" (described below).
In cgroups v1, the ability to mount different controllers against different hierarchies was intended to allow great flexibility for application design. In practice, though, the flexibility turned out to be less useful than expected, and in many cases added complexity. Therefore, in cgroups v2, all available controllers are mounted against a single hierarchy. The available controllers are automatically mounted, meaning that it is not necessary (or possible) to specify the controllers when mounting the cgroup v2 filesystem using a command such as the following:
mount -t cgroup2 none /mnt/cgroup2A cgroup v2 controller is available only if it is not currently in use via a mount against a cgroup v1 hierarchy. Or, to put things another way, it is not possible to employ the same controller against both a v1 hierarchy and the unified v2 hierarchy. This means that it may be necessary first to unmount a v1 controller (as described above) before that controller is available in v2. Since systemd(1) makes heavy use of some v1 controllers by default, it can in some cases be simpler to boot the system with selected v1 controllers disabled. To do this, specify the cgroup_no_v1=list option on the kernel boot command line; list is a comma-separated list of the names of the controllers to disable, or the word all to disable all v1 controllers. (This situation is correctly handled by systemd(1), which falls back to operating without the specified controllers.)
Note that on many modern systems, systemd(1) automatically mounts the cgroup2 filesystem at /sys/fs/cgroup/unified during the boot process.
The following options (mount -o) can be specified when mounting the group v2 filesystem:
The following controllers are supported in cgroups version 2:
There is no direct equivalent of the net_cls and net_prio controllers. Instead, support has been added to iptables(8) to allow eBPF filters that hook on cgroup v2 pathnames. The v2 devices controller provides no interface files; instead, device control is gated by attaching an eBPF (BPF_CGROUP_DEVICE) program to a v2 cgroup.
Each cgroup in the v2 hierarchy contains the following two files:
echo '+pids -memory' > x/y/cgroup.subtree_controlAn attempt to enable a controller not present in cgroup.controllers leads to an ENOENT error. Because the list of controllers in cgroup.subtree_control is a subset of those cgroup.controllers, a controller that has been disabled in one cgroup can never be re-enabled in the subtree below that cgroup. A cgroup's cgroup.subtree_control file determines the set of controllers that are exercised in the child cgroups. When a controller is present in the parent's cgroup.subtree_control, then the corresponding controller-interface files (e.g., pids.max) are automatically created in the children.
Cgroups v2 enforces a so-called "no internal processes" rule. Roughly speaking, this rule means that, with the exception of the root cgroup, processes may reside only in leaf nodes (cgroups that do not themselves contain child cgroups). This avoids the need to decide how to partition resources between processes which are members of cgroup A and processes in child cgroups of A. For instance, if cgroup /cg1/cg2 exists, then a process may reside in /cg1/cg2, but not in /cg1. The recommended approach is to create a subdirectory called leaf for any nonleaf cgroup which should contain processes. The "no internal processes" rule is in fact more subtle: a (nonroot) cgroup can't both (1) have member processes, and (2) distribute resources into child cgroups—that is, have a nonempty cgroup.subtree_control file. With the Linux 4.14 addition of "thread mode", the rule has been relaxed in some cases.
Each nonroot cgroup in the v2 hierarchy contains a read-only file, cgroup.events, whose contents are key-value pairs providing state information about the cgroup:
$ cat mygrp/cgroup.events
populated 1
frozen 0The following keys may appear:
The cgroup.events file can be monitored using inotify(7) (as IN_MODIFY events) or poll(2) ( POLLPRI and POLLERR bits).
Cgroups v2 provides a new mechanism for obtaining notification when a cgroup becomes empty. The cgroups v1 release_agent and notify_on_release files are removed, and replaced by the populated key in the cgroup.events file. This key either has the value 0 (cgroup and descendants contain no member processes) or 1 (contains member processes). The cgroups v2 mechanism offers cheaper notification (single process can monitor multiple files) and per-subhierarchy delegation, unlike v1's single release agent per hierarchy.
Each cgroup in the v2 hierarchy contains a read-only cgroup.stat file (since Linux 4.14) with key-value pairs:
Each cgroup in the v2 hierarchy contains the following files to view and set limits on the number of descendant cgroups:
In the context of cgroups, delegation means passing management of some subtree of the cgroup hierarchy to a nonprivileged user. Cgroups v1 provides support for delegation based on file permissions but with less strict containment rules. Cgroups v2 supports delegation with containment by explicit design.
To delegate, the delegater (root) changes ownership of the following files in the delegated subtree root (e.g., /dlgt_grp) to the delegatee's user ID:
The delegater should not change ownership of controller interface files (e.g., pids.max, memory.high). See also the /sys/kernel/cgroup/delegate file for information about further delegatable files.
After delegation, the delegatee can create child cgroups, move processes, and enable controllers (if ownership of cgroup.subtree_control was given or controllers were pre-enabled).
Starting with Linux 4.13, there is a second way to perform cgroup delegation: mount the cgroup v2 filesystem with the nsdelegate option:
mount -t cgroup2 -o remount,nsdelegate none /sys/fs/cgroup/unifiedThis causes cgroup namespaces to automatically become delegation boundaries. Processes inside the namespace cannot write to controller interface files in the root of the namespace, and cannot migrate processes across the namespace boundary. The nsdelegate option only has effect in the initial mount namespace.
A nonprivileged process can write a PID to a cgroup.procs file only if:
One consequence is that the delegatee cannot place the first process into the delegated subtree; the delegater must place the first process.
Among the restrictions imposed by cgroups v2 that were not present in cgroups v1 are:
However, Linux 4.14 added thread mode to allow thread-level granularity for certain controllers. Thread mode allows the creation of threaded subtrees where threads of a process may be spread across cgroups, and the relaxation of the "no internal processes" rule within a threaded subtree. Each nonroot cgroup now contains a cgroup.type file that indicates the cgroup type:
Two types of resource controllers:
Two pathways:
Write "threaded" to the cgroup.type file of a cgroup y/z that is currently domain. This converts y/z to threaded, the parent y becomes domain threaded (threaded root), and all other cgroups under y become domain invalid. Then write "threaded" to each domain invalid cgroup to make them usable.
In an existing cgroup z (type domain), enable one or more threaded controllers and make a process a member of z. This converts z to domain threaded and all descendants become domain invalid. Then convert them to threaded as above.
The threaded root cgroup can only be parent to threaded (or domain invalid) cgroups; a threaded cgroup cannot have a domain sibling.
Within a threaded subtree, threaded controllers can be enabled in each threaded cgroup, and the corresponding interface files appear in children. A process can be moved into the subtree by writing its PID to cgroup.procs in a cgroup inside the tree. Then threads can be spread across the subtree by writing their thread IDs to cgroup.threads files in different cgroups. The cgroup.threads file is present in every cgroup and can be read to list threads. The cgroup.procs in the threaded root shows all PIDs in the subtree; other cgroup.procs files are not readable. Domain controllers cannot be enabled in a threaded subtree. The "no internal processes" rule does not apply inside a threaded subtree.
A cgroup can become domain threaded when a child is written "threaded" or when a threaded controller is enabled and a process is made a member. It can revert to domain if all threaded children are removed and either no threaded controllers are enabled or no member processes remain. When reverting, domain invalid descendants revert to domain (unless in lower-level threaded subtrees), and root cgroups of lower-level threaded subtrees revert to domain threaded.
The root cgroup of the v2 hierarchy can be parent of both domain and threaded cgroups. If "threaded" is written to a child of the root, that child becomes threaded and its descendants become domain invalid. No cgroup becomes domain threaded. This allows a threaded cgroup using the cpu controller to be placed as high as possible.
As of Linux 4.19, the cgroups v2 cpu controller does not support control of realtime threads (SCHED_FIFO, SCHED_RR, SCHED_DEADLINE; see sched(7)). The cpu controller can be enabled in the root cgroup only if all realtime threads are in the root cgroup. On some systems, systemd(1) places realtime threads in nonroot cgroups; they must be moved to the root before enabling the cpu controller.
The following errors can occur for mount(2):
A child process created via fork(2) inherits its parent's cgroup memberships. A process's cgroup memberships are preserved across execve(2). The clone3(2) CLONE_INTO_CGROUP flag can be used to create a child process that begins its life in a different version 2 cgroup.
/proc/cgroups (since Linux 2.6.24): Contains information about controllers compiled into the kernel. Example output:
#subsys_name hierarchy num_cgroups enabled
cpuset 4 1 1
cpu 8 1 1
cpuacct 8 1 1
blkio 6 1 1
memory 3 1 1
devices 10 84 1
freezer 7 1 1
net_cls 9 1 1
perf_event 5 1 1
net_prio 9 1 1
hugetlb 0 1 0
pids 2 1 1Fields: controller name, hierarchy ID (0 if not mounted on v1, or bound to v2, or disabled), number of cgroups, enabled (1/0).
/proc/[pid]/cgroup (since Linux 2.6.24): Describes cgroups for a process. Each entry: hierarchy-ID:controller-list:cgroup-path. For v1 hierarchies, ID matches /proc/cgroups; for v2, ID is 0 and controller list is empty. Example:
5:cpuacct,cpu,cpuset:/daemons/sys/kernel/cgroup/delegate (since Linux 4.15): Lists delegatable cgroup v2 files (one per line). As of Linux 4.15:
$ cat /sys/kernel/cgroup/delegate
cgroup.procs
cgroup.subtree_control
cgroup.threads/sys/kernel/cgroup/features (since Linux 4.15): Lists supported cgroup v2 features. Entries include memory_localevents (since Linux 5.2) and nsdelegate (since Linux 4.15).
prlimit(1), systemd(1), systemd-cgls(1), systemd-cgtop(1), clone(2), ioprio_set(2), perf_event_open(2), setrlimit(2), cgroup_namespaces(7), cpuset(7), namespaces(7), sched(7), user_namespaces(7)
The kernel source file Documentation/admin-guide/cgroup-v2.rst.
This page is part of release 5.10 of the Linux man-pages project. A description of the project, information about reporting bugs, and the latest version of this page, can be found at https://www.kernel.org/doc/man-pages/.
Generated by phpman v4.9.26-5-g7740029 · Markdown · JSON · MCP Author: Che Dong Under GNU General Public License
2026-08-24 17:36 @216.73.217.23
CrawledBy Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; ClaudeBot/1.0; +claudebot@anthropic.com)