systemd.unit(5)

.SH "NAME" systemd.unit - Unit configuration

.SH "SYNOPSIS"

.PP service.service, socket.socket, device.device, mount.mount, automount.automount, swap.swap, target.target, path.path, timer.timer, slice.slice, scope.scope

.SS "System Unit Search Path"

.PP

.SS "User Unit Search Path"

.PP

.SH "DESCRIPTION"

.PP A unit file is a plain text ini-style file that encodes information about a service, a socket, a device, a mount point, an automount point, a swap file or partition, a start-up target, a watched file system path, a timer controlled and supervised by systemd(1), a resource management slice or a group of externally created processes. See systemd.syntax(7) for a general description of the syntax.

.PP This man page lists the common configuration options of all the unit types. These options need to be configured in the [Unit] or [Install] sections of the unit files.

.PP In addition to the generic [Unit] and [Install] sections described here, each unit may have a type-specific section, e.g. [Service] for a service unit. See the respective man pages for more information: systemd.service(5), systemd.socket(5), systemd.device(5), systemd.mount(5), systemd.automount(5), systemd.swap(5), systemd.target(5), systemd.path(5), systemd.timer(5), systemd.slice(5), systemd.scope(5).

.PP Unit files are loaded from a set of paths determined during compilation, described in the next section.

.PP Valid unit names consist of a "unit name prefix", and a suffix specifying the unit type which begins with a dot. The "unit name prefix" must consist of one or more valid characters (ASCII letters, digits, :, -, _, ., and \). The total length of the unit name including the suffix must not exceed 255 characters. The unit type suffix must be one of .service, .socket, .device, .mount, .automount, .swap, .target, .path, .timer, .slice, or .scope.

.PP Unit names can be parameterized by a single argument called the "instance name". The unit is then constructed based on a "template file" which serves as the definition of multiple services or other units. A template unit must have a single @ at the end of the unit name prefix (right before the type suffix). The name of the full unit is formed by inserting the instance name between @ and the unit type suffix. In the unit file itself, the instance parameter may be referred to using %i and other specifiers, see below.

.PP Unit files may contain additional options on top of those listed here. If systemd encounters an unknown option, it will write a warning log message but continue loading the unit. If an option or section name is prefixed with X-, it is ignored completely by systemd. Options within an ignored section do not need the prefix. Applications may use this to include additional information in the unit files. To access those options, applications need to parse the unit files on their own.

.PP Units can be aliased (have an alternative name), by creating a symlink from the new name to the existing name in one of the unit search paths. For example, systemd-networkd.service has the alias dbus-org.freedesktop.network1.service, created during installation as a symlink, so when systemd is asked through D-Bus to load dbus-org.freedesktop.network1.service, it'll load systemd-networkd.service. As another example, default.target — the default system target started at boot — is commonly aliased to either multi-user.target or graphical.target to select what is started by default. Alias names may be used in commands like disable, start, stop, status, and similar, and in all unit dependency directives, including Wants=, Requires=, Before=, After=. Aliases cannot be used with the preset command.

.PP Aliases obey the following restrictions: a unit of a certain type (.service, .socket, ...) can only be aliased by a name with the same type suffix. A plain unit (not a template or an instance), may only be aliased by a plain name. A template instance may only be aliased by another template instance, and the instance part must be identical. A template may be aliased by another template (in which case the alias applies to all instances of the template). As a special case, a template instance (e.g. alias@inst.service) may be a symlink to different template (e.g. template@inst.service). In that case, just this specific instance is aliased, while other instances of the template (e.g. alias@foo.service, alias@bar.service) are not aliased. Those rules preserve the requirement that the instance (if any) is always uniquely defined for a given unit and all its aliases. The target of alias symlink must point to a valid unit file location, i.e. the symlink target name must match the symlink source name as described, and the destination path must be in one of the unit search paths, see UNIT FILE LOAD PATH section below for more details. Note that the target file might not exist, i.e. the symlink may be dangling.

.PP Unit files may specify aliases through the Alias= directive in the [Install] section. When the unit is enabled, symlinks will be created for those names, and removed when the unit is disabled. For example, reboot.target specifies Alias=ctrl-alt-del.target, so when enabled, the symlink /etc/systemd/system/ctrl-alt-del.target pointing to the reboot.target file will be created, and when Ctrl+Alt+Del is invoked, systemd will look for ctrl-alt-del.target, follow the symlink to reboot.target, and execute reboot.service as part of that target. systemd does not look at the [Install] section at all during normal operation, so any directives in that section only have an effect through the symlinks created during enablement.

.PP Along with a unit file foo.service, the directory foo.service.wants/ may exist. All unit files symlinked from such a directory are implicitly added as dependencies of type Wants= to the unit. Similar functionality exists for Requires= type dependencies as well, the directory suffix is .requires/ in this case. This functionality is useful to hook units into the start-up of other units, without having to modify their unit files. For details about the semantics of Wants= and Requires=, see below. The preferred way to create symlinks in the .wants/ or .requires/ directories is by specifying the dependency in [Install] section of the target unit, and creating the symlink in the file system with the enable or preset commands of systemctl(1). The target can be a normal unit (either plain or a specific instance of a template unit). In case when the source unit is a template, the target can also be a template, in which case the instance will be "propagated" to the target unit to form a valid unit instance. The target of symlinks in .wants/ or .requires/ must thus point to a valid unit file location, i.e. the symlink target name must satisfy the described requirements, and the destination path must be in one of the unit search paths, see UNIT FILE LOAD PATH section below for more details. Note that the target file might not exist, i.e. the symlink may be dangling.

.PP Along with a unit file foo.service, a "drop-in" directory foo.service.d/ may exist. All files with the suffix .conf from this directory will be merged in the alphanumeric order and parsed after the main unit file itself has been parsed. This is useful to alter or add configuration settings for a unit, without having to modify unit files. Each drop-in file must contain appropriate section headers. For instantiated units, this logic will first look for the instance .d/ subdirectory (e.g. foo@bar.service.d/) and read its .conf files, followed by the template .d/ subdirectory (e.g. foo@.service.d/) and the .conf files there. Moreover, for unit names containing dashes (-), the set of directories generated by repeatedly truncating the unit name after all dashes is searched too. Specifically, for a unit name foo-bar-baz.service not only the regular drop-in directory foo-bar-baz.service.d/ is searched but also both foo-bar-.service.d/ and foo-.service.d/. This is useful for defining common drop-ins for a set of related units, whose names begin with a common prefix. This scheme is particularly useful for mount, automount and slice units, whose systematic naming structure is built around dashes as component separators. Note that equally named drop-in files further down the prefix hierarchy override those further up, i.e. foo-bar-.service.d/10-override.conf overrides foo-.service.d/10-override.conf.

.PP In cases of unit aliases (described above), dropins for the aliased name and all aliases are loaded. In the example of default.target aliasing graphical.target, default.target.d/, default.target.wants/, default.target.requires/, graphical.target.d/, graphical.target.wants/, graphical.target.requires/ would all be read. For templates, dropins for the template, any template aliases, the template instance, and all alias instances are read. When just a specific template instance is aliased, then the dropins for the target template, the target template instance, and the alias template instance are read.

.PP In addition to /etc/systemd/system, the drop-in .d/ directories for system services can be placed in /usr/lib/systemd/system or /run/systemd/system directories. Drop-in files in /etc/ take precedence over those in /run/ which in turn take precedence over those in /usr/lib/. Drop-in files under any of these directories take precedence over unit files wherever located. Multiple drop-in files with different names are applied in lexicographic order, regardless of which of the directories they reside in.

.PP Units also support a top-level drop-in with type.d/, where type may be e.g. service or socket, that allows altering or adding to the settings of all corresponding unit files on the system. The formatting and precedence of applying drop-in configurations follow what is defined above. Files in type.d/ have lower precedence compared to files in name-specific override directories. The usual rules apply: multiple drop-in files with different names are applied in lexicographic order, regardless of which of the directories they reside in, so a file in type.d/ applies to a unit only if there are no drop-ins or masks with that name in directories with higher precedence. See Examples.

.PP Note that while systemd offers a flexible dependency system between units it is recommended to use this functionality only sparingly and instead rely on techniques such as bus-based or socket-based activation which make dependencies implicit, resulting in a both simpler and more flexible system.

.PP As mentioned above, a unit may be instantiated from a template file. This allows creation of multiple units from a single configuration file. If systemd looks for a unit configuration file, it will first search for the literal unit name in the file system. If that yields no success and the unit name contains an @ character, systemd will look for a unit template that shares the same name but with the instance string (i.e. the part between the @ character and the suffix) removed. Example: if a service getty@tty3.service is requested and no file by that name is found, systemd will look for getty@.service and instantiate a service from that configuration file if it is found.

.PP To refer to the instance string from within the configuration file you may use the special %i specifier in many of the configuration options. See below for details.

.PP If a unit file is empty (i.e. has the file size 0) or is symlinked to /dev/null, its configuration will not be loaded and it appears with a load state of masked, and cannot be activated. Use this as an effective way to fully disable a unit, making it impossible to start it even manually.

.PP Files (including directories) with names that match certain patterns are generally ignored. This includes names that start with a . or end with a .ignore.

.PP When unit aliasing is introduced during reload/reexec (e.g., converting b.service to a symlink pointing to a.service), the running state of the canonical unit (a.service) is preserved. The old serialized state of the now-aliased unit is migrated to a new stub orphaned unit to prevent stale data from corrupting the canonical unit's live state. Dependencies referencing the alias name are automatically resolved to the canonical unit, and the dependency graph is rebuilt from unit files, ensuring consistency. If the now-aliased unit had resources such as running processes, they will now be tracked under the new orphaned unit. Once all resources are gone (e.g. all processes have exited) the orphaned unit will be garbage collected automatically.

.PP The unit file format is covered by the Interface Portability and Stability Promise[1].

.SH "STRING ESCAPING FOR INCLUSION IN UNIT NAMES"

.PP Sometimes it is useful to convert arbitrary strings into unit names. To facilitate this, a method of string escaping is used, in order to map strings containing arbitrary byte values (except NUL) into valid unit names and their restricted character set. A common special case are unit names that reflect paths to objects in the file system hierarchy. Example: a device unit dev-sda.device refers to a device with the device node /dev/sda in the file system.

.PP The escaping algorithm operates as follows: given a string, any / character is replaced by -, and all other characters which are not ASCII alphanumerics, :, _ or . are replaced by C-style \x2d escapes. In addition, . is replaced with such a C-style escape when it would appear as the first character in the escaped string.

.PP When the input qualifies as absolute file system path, this algorithm is extended slightly: the path to the root directory / is encoded as single dash -. In addition, any leading, trailing or duplicate / characters are removed from the string before transformation. Example: /foo//bar/baz/ becomes foo-bar-baz.

.PP This escaping is fully reversible, as long as it is known whether the escaped string was a path (the unescaping results are different for paths and non-path strings). The systemd-escape(1) command may be used to apply and reverse escaping on arbitrary strings. Use systemd-escape --path to escape path strings, and systemd-escape without --path otherwise.

.SH "AUTOMATIC DEPENDENCIES"

.SS "Implicit Dependencies"

.PP A number of unit dependencies are implicitly established, depending on unit type and unit configuration. These implicit dependencies can make unit configuration file cleaner. For the implicit dependencies in each unit type, please refer to section "Implicit Dependencies" in respective man pages.

.PP For example, service units with Type=dbus automatically acquire dependencies of type Requires= and After= on dbus.socket. See systemd.service(5) for details.

.SS "Default Dependencies"

.PP Default dependencies are similar to implicit dependencies, but can be turned on and off by setting DefaultDependencies= to yes (the default) and no, while implicit dependencies are always in effect. See section "Default Dependencies" in respective man pages for the effect of enabling DefaultDependencies= in each unit types.

.PP For example, target units will complement all configured dependencies of type Wants= or Requires= with dependencies of type After=. See systemd.target(5) for details. Note that this behavior can be opted out by setting DefaultDependencies=no in the specified units, or it can be selectively overridden via an explicit Before= dependency.

.SH "UNIT FILE LOAD PATH"

.PP Unit files are loaded from a set of paths determined during compilation, described in the two tables below. Unit files found in directories listed earlier override files with the same name in directories lower in the list [2].

.PP When the variable $SYSTEMD_UNIT_PATH is set, the contents of this variable overrides the unit load path. If $SYSTEMD_UNIT_PATH ends with an empty component (:), the usual unit load path will be appended to the contents of the variable.

.sp
Table 1.  Load path when running in system mode (--system).

.sp
Table 2.  Load path when running in user mode (--user).

.PP The set of load paths for the user manager instance may be augmented or changed using various environment variables. And environment variables may in turn be set using environment generators, see systemd.environment-generator(7). In particular, $XDG_DATA_HOME and $XDG_DATA_DIRS may be easily set using systemd-environment-d-generator(8). Thus, directories listed here are just the defaults. To see the actual list that would be used based on compilation options and current environment use

systemd-analyze --user unit-paths

.PP Moreover, additional units might be loaded into systemd from directories not on the unit load path by creating a symlink pointing to a unit file in the directories. You can use systemctl link for this; see systemctl(1). The file system where the linked unit files are located must be accessible when systemd is started (e.g. anything underneath /home/ or /var/ is not allowed, unless those directories are located on the root file system).

.PP It is important to distinguish "linked unit files" from "unit file aliases": any symlink where the symlink target is within the unit load path becomes an alias: the source name and the target file name must satisfy specific constraints listed above in the discussion of aliases, but the symlink target does not have to exist, and in fact the symlink target path is not used, except to check whether the target is within the unit load path. In contrast, a symlink which goes outside of the unit load path signifies a linked unit file. The symlink is followed when loading the file, but the destination name is otherwise unused (and may even not be a valid unit file name). For example, symlinks /etc/systemd/system/alias1.service → service1.service, /etc/systemd/system/alias2.service → /usr/lib/systemd/service1.service, /etc/systemd/system/alias3.service → /etc/systemd/system/service1.service are all valid aliases and service1.service will have four names, even if the unit file is located at /run/systemd/system/service1.service. In contrast, a symlink /etc/systemd/system/link1.service → ../link1_service_file means that link1.service is a "linked unit" and the contents of /etc/systemd/link1_service_file provide its configuration.

.SH "UNIT GARBAGE COLLECTION"

.PP The system and service manager loads a unit's configuration automatically when a unit is referenced for the first time. It will automatically unload the unit configuration and state again when the unit is not needed anymore ("garbage collection"). A unit may be referenced through a number of different mechanisms:

.PP The garbage collection logic may be altered with the CollectMode= option, which allows configuration whether automatic unloading of units that are in failed state is permissible, see below.

.PP Note that when a unit's configuration and state is unloaded, all execution results, such as exit codes, exit signals, resource consumption and other statistics are lost, except for what is stored in the log subsystem.

.PP Use systemctl daemon-reload or an equivalent command to reload unit configuration while the unit is already loaded. In this case, all configuration settings are flushed out and replaced with the new configuration (which however might not be in effect immediately), however all runtime state is saved/restored.

.SH "[UNIT] SECTION OPTIONS"

.PP The unit file may include a [Unit] section, which carries generic information about the unit that is not dependent on the type of unit:

.PP Description=

[Unit]
Description=Foo
[Service]
ExecStart=/usr/sbin/foo-daemon
[Install]
WantedBy=multi-user.target

[Unit]
Description=Some HTTP Server
After=remote-fs.target sqldb.service
Requires=sqldb.service
AssertPathExists=/srv/webserver
[Service]
Type=notify
ExecStart=/usr/sbin/some-fancy-httpd-server
Nice=5
[Install]
WantedBy=multi-user.target

[Unit]
Description=Some HTTP Server
After=remote-fs.target sqldb.service memcached.service
Requires=sqldb.service memcached.service
AssertPathExists=/srv/www
[Service]
Type=notify
ExecStart=/usr/sbin/some-fancy-httpd-server
Nice=0
PrivateTmp=yes
[Install]
WantedBy=multi-user.target

[Unit]
After=memcached.service
Requires=memcached.service
# Reset all assertions and then re-add the condition we want
AssertPathExists=
AssertPathExists=/srv/www
[Service]
Nice=0
PrivateTmp=yes

[Unit]
Description=My Failure Handler For %i
[Service]
Type=oneshot
# Perform some special action for when %i exits unexpectedly.
ExecStart=/usr/sbin/myfailurehandler %i

[Unit]
OnFailure=failure-handler@%N.service

mkdir /etc/systemd/system/failure-handler@.service.d/
ln -s /dev/null /etc/systemd/system/failure-handler@.service.d/10-all.conf
systemctl daemon-reload