NAME | SYNOPSIS | DESCRIPTION | OPTIONS | SEE ALSO | NOTES | COLOPHON

SYSTEMD.CGROUP(5)              systemd.cgroup              SYSTEMD.CGROUP(5)

NAME         top

       systemd.cgroup - Control Group configuration unit settings

SYNOPSIS         top

       slice.slice, scope.scope, service.service, socket.socket,
       mount.mount, swap.swap

DESCRIPTION         top

       Unit configuration files for services, slices, scopes, sockets, mount
       points, and swap devices share a subset of configuration options
       which configure the control group settings for spawned processes.

       Control Groups is a concept for organizing processes in a hierarch
       tree of named groups for the purpose of resource management.

       This man page lists the configuration options shared by those six
       unit types. See systemd.unit(5) for the common options of all unit
       configuration files, and systemd.slice(5), systemd.scope(5),
       systemd.service(5), systemd.socket(5), systemd.mount(5), and
       systemd.swap(5) for more information on the specific unit
       configuration files. The execution-specific configuration options are
       configured in the [Slice], [Scope], [Service], [Socket], [Mount], or
       [Swap] sections, depending on the unit type.

OPTIONS         top

       Units of the types listed above can have settings for cgroup
       configuration:

       CPUAccounting=
           Turn on CPU usage accounting for this unit. Takes a boolean
           argument. Note that turning on CPU accounting for one unit might
           also implicitly turn it on for all units contained in the same
           slice and for all its parent slices and the units contained
           therein.

       CPUShares=weight
           Assign the specified overall CPU time share weight to the
           processes executed. Takes an integer value. This controls the
           "cpu.shares" control group attribute, which defaults to 1024. For
           details about this control group attribute, see
           sched-design-CFS.txt[1].

           Implies "CPUAccounting=true".

       MemoryAccounting=
           Turn on process and kernel memory accounting for this unit. Takes
           a boolean argument. Note that turning on memory accounting for
           one unit might also implicitly turn it on for all units contained
           in the same slice and for all its parent slices and the units
           contained therein.

       MemoryLimit=bytes, MemorySoftLimit=bytes
           Specify the hard and soft limits on maximum memory usage of the
           executed processes. The "hard" limit specifies how much process
           and kernel memory can be used by tasks in this unit, when there
           is no memory contention. If the kernel detects memory contention,
           memory reclaim will be performed until the memory usage is within
           the "soft" limit. Takes a memory size in bytes. If the value is
           suffixed with K, M, G or T, the specified memory size is parsed
           as Kilobytes, Megabytes, Gigabytes, or Terabytes (with the base
           1024), respectively. This controls the "memory.limit_in_bytes"
           and "memory.soft_limit_in_bytes" control group attributes. For
           details about these control group attributes, see memory.txt[2].

           Implies "MemoryAccounting=true".

       BlockIOAccounting=
           Turn on Block IO accounting for this unit. Takes a boolean
           argument. Note that turning on block IO accounting for one unit
           might also implicitly turn it on for all units contained in the
           same slice and all for its parent slices and the units contained
           therein.

       BlockIOWeight=weight
           Set the default overall block IO weight for the executed
           processes. Takes a single weight value (between 10 and 1000) to
           set the default block IO weight. This controls the "blkio.weight"
           control group attribute, which defaults to 1000. For details
           about this control group attribute, see blkio-controller.txt[3].

           Implies "BlockIOAccounting=true".

       BlockIODeviceWeight=device weight
           Set the per-device overall block IO weight for the executed
           processes. Takes a space-separated pair of a file path and a
           weight value to specify the device specific weight value, between
           10 and 1000. (Example: "/dev/sda 500"). The file path may be
           specified as path to a block device node or as any other file in
           which case the backing block device of the file system of the
           file is determined. This controls the "blkio.weight_device"
           control group attribute, which defaults to 1000. Use this option
           multiple times to set weights for multiple devices. For details
           about this control group attribute, see blkio-controller.txt[3].

           Implies "BlockIOAccounting=true".

       BlockIOReadBandwidth=device bytes, BlockIOWriteBandwidth=device bytes
           Set the per-device overall block IO bandwidth limit for the
           executed processes. Takes a space-separated pair of a file path
           and a bandwidth value (in bytes per second) to specify the device
           specific bandwidth. The file path may be a path to a block device
           node, or as any other file in which case the backing block device
           of the file system of the file is used. If the bandwidth is
           suffixed with K, M, G, or T, the specified bandwidth is parsed as
           Kilobytes, Megabytes, Gigabytes, or Terabytes, respectively
           (Example: "/dev/disk/by-path/pci-0000:00:1f.2-scsi-0:0:0:0 5M").
           This controls the "blkio.read_bps_device" and
           "blkio.write_bps_device" control group attributes. Use this
           option multiple times to set bandwidth limits for multiple
           devices. For details about these control group attributes, see
           blkio-controller.txt[3].

           Implies "BlockIOAccounting=true".

       DeviceAllow=
           Control access to specific device nodes by the executed
           processes. Takes two space-separated strings: a device node path
           (such as /dev/null) followed by a combination of r, w, m to
           control reading, writing, or creation of the specific device node
           by the unit (mknod), respectively. This controls the
           "devices.allow" and "devices.deny" control group attributes. For
           details about these control group attributes, see devices.txt[4].

       DevicePolicy=auto|closed|strict
           Control the policy for allowing device access:

           strict
               means to only allow types of access that are explicitly
               specified.

           closed
               in addition, allows access to standard pseudo devices
               including /dev/null, /dev/zero, /dev/full, /dev/random, and
               /dev/urandom.

           auto
               in addition, allows access to all devices if no explicit
               DeviceAllow= is present. This is the default.

       Slice=
           The name of the slice unit to place the unit in. Defaults to
           system.slice for all non-instantiated units of all unit types
           (except for slice units themselves see below). Instance units are
           by default placed in a subslice of system.slice that is named
           after the template name.

           This option may be used to arrange systemd units in a hierarchy
           of slices each of which might have resource settings applied.

           For units of type slice, the only accepted value for this setting
           is the parent slice. Since the name of a slice unit implies the
           parent slice, it is hence redundant to ever set this parameter
           directly for slice units.

SEE ALSO         top

       systemd(1), systemd.unit(5), systemd.service(5), systemd.slice(5),
       systemd.scope(5), systemd.socket(5), systemd.mount(5),
       systemd.swap(5), systemd.directives(7), systemd.special(7), The
       documentation for control groups and specific controllers in the
       Linux kernel: cgroups.txt[5], cpuacct.txt[6], memory.txt[2],
       blkio-controller.txt[3].

NOTES         top

        1. sched-design-CFS.txt
           https://www.kernel.org/doc/Documentation/scheduler/sched-design-CFS.txt

        2. memory.txt
           https://www.kernel.org/doc/Documentation/cgroups/memory.txt

        3. blkio-controller.txt
           https://www.kernel.org/doc/Documentation/cgroups/blkio-controller.txt

        4. devices.txt
           https://www.kernel.org/doc/Documentation/cgroups/devices.txt

        5. cgroups.txt
           https://www.kernel.org/doc/Documentation/cgroups/cgroups.txt

        6. cpuacct.txt
           https://www.kernel.org/doc/Documentation/cgroups/cpuacct.txt

COLOPHON         top

       This page is part of the systemd (systemd system and service manager)
       project.  Information about the project can be found at 
       ⟨http://www.freedesktop.org/wiki/Software/systemd⟩.  If you have a bug
       report for this manual page, see 
       ⟨http://www.freedesktop.org/wiki/Software/systemd/#bugreports⟩.  This
       page was obtained from the project's upstream Git repository
       (git://anongit.freedesktop.org/systemd/systemd) on 2015-12-05.  If
       you discover any rendering problems in this HTML version of the page,
       or you believe there is a better or more up-to-date source for the
       page, or you have corrections or improvements to the information in
       this COLOPHON (which is not part of the original manual page), send a
       mail to man-pages@man7.org

systemd 207                                                SYSTEMD.CGROUP(5)