zh-CN:Systemd Template:Article summary start Template:Article summary text Template:Article summary heading Template:Article summary wiki Template:Article summary wiki Template:Article summary wiki Template:Article summary wiki Template:Article summary wiki Template:Article summary end From the project web page:
systemd is a system and service manager for Linux, compatible with SysV and LSB init scripts. systemd provides aggressive parallelization capabilities, uses socket and D-Bus activation for starting services, offers on-demand starting of daemons, keeps track of processes using Linux control groups, supports snapshotting and restoring of the system state, maintains mount and automount points and implements an elaborate transactional dependency-based service control logic. It can work as a drop-in replacement for sysvinit.
See also the Wikipedia article.
- 1 Considerations before switching
- 2 Installation
- 3 Native configuration
- 3.1 Hostname
- 3.2 Locale
- 3.3 Virtual console
- 3.4 Time zone
- 3.5 Hardware clock
- 3.6 Kernel modules
- 3.7 Filesystem mounts
- 3.8 ACPI power management
- 3.9 Temporary files
- 3.10 Units
- 4 Transitioning from initscripts to systemd
- 5 Basic systemctl usage
- 6 Running DEs under systemd
- 7 Writing custom .service files
- 8 Targets
- 9 Journal
- 10 Optimization
- 11 Troubleshooting
- 12 See also
Considerations before switching
- It is highly recommended to switch to the new initscripts configuration system described in the rc.conf article. Once you have this configuration established, you will have done most of the work needed to make the switch to systemd.
- Do some reading about systemd.
- Note the fact that systemd has a journal system that replaces syslog, although the two can co-exist. See the section on the journal below.
- While systemd can replace some of the functionality of cron, acpid, or xinetd, there is no need to switch away from using the traditional daemons unless you want to.
- Interactive initscripts are not working with systemd. In particular, netcfg-menu cannot be used at system start-up.
The following section is aimed at Arch Linux installations which still rely onand which have not migrated to .
and append the following to your kernel command line:
- Once completed you may enable any desired services via the use of
systemctl enable <service_name>(this roughly equates to what you included in the
- Reboot your system and verify that
systemdis currently active by using the following command:
$ cat /proc/1/comm. This should return the string
- Proceed to remove and from your system and install .
- Finally, remove the
init=/usr/lib/systemd/systemdparameter as it is no longer required.
- If you have
quietin your kernel parameters, you might want to remove it for your first couple of systemd boots, to assist with identifying any issues during boot.
- Adding your user to groups (
scanner, etc.) is not necessary for most use cases with systemd. The groups can even cause some functionality to break. For example, the audio group will break fast user switching and allows applications to block software mixing. Every PAM login provides a logind session, which for a local session will give you permissions via POSIX ACLs on audio/video devices, and allow certain operations like mounting removable storage via udisks.
The hostname is configured in
/etc/hostname. The file should not contain the system's domain, if any. To set the hostname, do:
# hostnamectl set-hostname myhostname
man 5 hostname and
man 1 hostnamectl for details.
Here is an example file:
The default system locale is configured in
/etc/locale.conf. To set the default locale, do:
# localectl set-locale LANG="de_DE.utf8"
/etc/locale.genand then executing
locale-genas root. The locale set via
localectlmust be one of the uncommented locales in
man 1 localectl and
man 5 locale.conf for details.
- For more information, see Locale.
Here is an example file:
The virtual console (keyboard mapping, console font and console map) is configured in
KEYMAP=us FONT=lat9w-16 FONT_MAP=8859-1_to_uni
FONT=are empty or not set.
Another way to set the keyboard mapping (keymap) is doing:
# localectl set-keymap de
This has the advantage that it will also set the same keymap for use in X11.
man 1 localectl and
man 5 vconsole.conf for details.
The time zone is configured by creating an appropriate
/etc/localtime symlink, pointing to a zoneinfo file under
/usr/share/zoneinfo/. To do this automatically:
# timedatectl set-timezone America/Toronto
man 1 timedatectl and
man 5 localtime for more details.
Alternatively, create the symlink yourself:
# ln -sf /usr/share/zoneinfo/America/Toronto /etc/localtime
Systemd will use UTC for the hardware clock by default.
Hardware clock in localtime
If you want to change the hardware clock to use local time (STRONGLY DISCOURAGED) do:
# timedatectl set-local-rtc true
If you want to revert to the hardware clock being in UTC, do:
# timedatectl set-local-rtc false
Be warned that, if the hardware clock is set to localtime, dealing with daylight saving time is messy. If the DST changes when your computer is off, your clock will be wrong on next boot (there is a lot more to it). Recent kernels set the system time from the RTC directly on boot, assuming that the RTC is in UTC. This means that if the RTC is in local time, then the system time will first be set up wrongly and then corrected shortly afterwards on every boot. This is the root of certain weird bugs (time going backwards is rarely a good thing).
One reason for allowing the RTC to be in local time is to allow dual boot with Windows (which uses localtime). However, Windows is able to deal with the RTC being in UTC with a simple registry fix. There, it is recommended that Windows are changed to use UTC, rather than Linux to use localtime. If you make Windows use UTC, also remember to disable the "Internet Time Update" Windows feature, so that Windows don't mess with the hardware clock, trying to sync it with internet time. You should instead leave touching the RTC and syncing it to internet time to Linux, by enabling an NTP daemon, as suggested previously.
- For more information, see Time.
Today, all necessary module loading is handled automatically by udev, so that, if you don't want/need to use any out-of-tree kernel modules, there is no need to put modules that should be loaded at boot in any config file. However, there are cases where you might want to load an extra module during the boot process, or blacklist another one for your computer to function properly.
Extra modules to load at boot
Extra kernel modules to be loaded during boot are configured as a static list in files under
/etc/modules-load.d/. Each configuration file is named in the style of
/etc/modules-load.d/<program>.conf. Configuration files simply contain a list of kernel module names to load, separated by newlines. Empty lines and lines whose first non-whitespace character is
; are ignored.
# Load virtio-net.ko at boot virtio-net
man 5 modules-load.d for more details.
Module blacklisting works the same way as with Module Blacklisting for details.since it is actually handled by . See
The default setup will automatically fsck and mount filesystems before starting services that need them to be mounted. For example, systemd automatically makes sure that remote filesystem mounts like NFS or Samba are only started after the network has been set up. Therefore, local and remote filesystem mounts specified in
/etc/fstab should work out of the box.
man 5 systemd.mount for details.
- If you have a large
/homepartition, it might be better to allow services that do not depend on
/hometo start while
/homeis being fsck'ed. This can be achieved by adding the following options to the
/etc/fstabentry of your
This will fsck and mount
/home when it is first accessed, and the kernel will buffer all file access to
/home until it is ready.
- The same applies to remote filesystem mounts. If you want them to be mounted only upon access, you will need to use the
noauto,x-systemd.automountparameters. In addition, you can use the
x-systemd.device-timeout=#option to specify a timeout in case the network resource is not available.
- If you have encrypted filesystems with keyfiles, you can also add the
noautoparameter to the corresponding entries in
/etc/crypttab. Systemd will then not open the encrypted device on boot, but instead wait until it is actually accessed and then automatically open it with the specified keyfile before mounting it. This might save a few seconds on boot if you are using an encrypted RAID device for example, because systemd doesn't have to wait for the device to become available. For example:
data /dev/md0 /root/key noauto
If you have LVM volumes not activated via the initramfs, enable
lvm.service (provided by the package):
# systemctl enable lvm
Similarly, if you have LVM on encrypted devices mounted later during boot (e.g. from
lvm-on-crypt.service (also provided by the package):
# systemctl enable lvm-on-crypt
ACPI power management
Systemd handles some power-related ACPI events. They can be configured via the following options from
HandlePowerKey: specifies which action is invoked when the power key is pressed.
HandleSuspendKey: specifies which action is invoked when the suspend key is pressed.
HandleHibernateKey: specifies which action is invoked when the hibernate key is pressed.
HandleLidSwitch: specifies which action is invoked when the lid is closed.
The specified action can be one of
If these options are not configured, systemd will use its defaults:
In the current version of systemd, the
Handle options will apply throughout the system unless they are "inhibited" (temporarily turned off) by a program, such as a power manager inside a desktop environment. If these inhibits are not taken, you can end up with a situation where systemd suspends your system, then when it wakes up the other power manager suspends it again.
ignoreif you want your ACPI events to be handled by Xfce, acpid or other programs. New versions are on the way that will include this functionality.
Systemd does not use pm-utils to put the machine to sleep when using
systemctl suspend or
systemctl hibernate; pm-utils hooks, including any custom hooks, will not be run. However, systemd provides a similar mechanism to run custom scripts on these events. Systemd runs all executables in
/usr/lib/systemd/system-sleep/, passing two arguments to each of them:
- Argument 1: either
post, depending on whether the machine is going to sleep or waking up
- Argument 2: either
hibernate, depending on which is being invoked
In contrast to pm-utils, systemd will run these scripts concurrently and not one after another.
The output of any custom script will be logged by
systemd-hibernate.service. You can see its output in systemd's journal:
# journalctl -b -u systemd-suspend
Note that you can also use
hibernate.target to hook units into the sleep state logic instead of using custom scripts.
An example of a custom sleep script:
#!/bin/sh case $1/$2 in pre/*) echo "Going to $2..." ;; post/*) echo "Waking up from $2..." ;; esac
man 7 systemd.special and
man 8 systemd-sleep for more details.
Systemd-tmpfiles uses configuration files in
/etc/tmpfiles.d/ to describe the creation, cleaning and removal of volatile and temporary files and directories which usually reside in directories such as
/tmp. Each configuration file is named in the style of
/etc/tmpfiles.d/<program>.conf. This will also override any files in
/usr/lib/tmpfiles.d/ with the same name.
tmpfiles are usually provided together with service files to create directories which are expected to exist by certain daemons. For example the Samba daemon expects the directory
/var/run/samba to exist and to have the correct permissions. The corresponding tmpfile looks like this:
D /var/run/samba 0755 root root
However, tmpfiles may also be used to write values into certain files on boot. For example, if you use
/etc/rc.local to disable wakeup from USB devices with
echo USBE > /proc/acpi/wakeup, you may use the following tmpfile instead:
w /proc/acpi/wakeup - - - - USBE
The tmpfiles method is recommended in this case since systemd doesn't actually support
man 5 tmpfiles.d for details.
A unit configuration file 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 file system path or a timer controlled and supervised by systemd. The syntax is inspired by XDG Desktop Entry Specification .desktop files, which are in turn inspired by Microsoft Windows .ini files.
man 5 systemd.unit for details.
Transitioning from initscripts to systemd
Integration with Arch's classic configuration is provided by thepackage. When are installed in parallel with systemd, with the system running on systemd, systemd will do the following:
- Parse the
/etc/rc.confand start all listed daemons at boot
Initscripts emulation is simply meant as a transitional measure to ease users' move to systemd, and will eventually go away. Native systemd does not rely on
rc.conf centralised configuration, so it is recommended to use native systemd configuration files, which will take precedence over
/etc/rc.localis to write the custom service files for any things you want to run on the system startup. See the corresponding section.
/etc/inittab, you will have to reconfigure this setting for systemd by running
systemctl mask ctrl-alt-del.targetas root.
Moving away from the DAEMONS array
For a pure systemd setup, you should remove the
/etc/rc.conf file entirely and enable services only via
systemctl. For each
<service_name> in the
DAEMONS array in
# systemctl enable <service_name>
<service_name>.service does not exist:
- Most probably, systemd uses a different name. For example,
alsainit daemon. Another important instance is the
networkdaemon, which is replaced with another set of service files (see Configuring Network for more details.)
- Otherwise, a service file may not be available for systemd. In that case, you'll need to keep
rc.confto start the service during boot up.
$ pacman -Ql cronie [...] cronie /etc/rc.d/crond #Daemon initscript listed in the DAEMONS array (unused in a "pure" systemd configuration) [...] cronie /usr/lib/systemd/system/cronie.service #Corresponding systemd daemon service [...]
- Finally, some services do not need to be explicitly enabled by the user. For instance,
dbus.servicewill automatically be enabled when
alsa-restore.serviceare also enabled automatically by systemd. Check the list of available services and their state using the
systemctlcommand like this:
systemctl status <service_name>.
Basic systemctl usage
The main command used to introspect and control systemd is
systemctl. Some of its uses are examining the system state and managing the system and services. See
man 1 systemctl for more details.
systemctlcommands with the
-H <user>@<host>switch to control a systemd instance on a remote machine. This will use SSH to connect to the remote systemd instance.
systemadmis the official graphical frontend for
systemctl. It is provided by the AUR package from the AUR.
Analyzing the system state
List running units:
$ systemctl list-units
List failed units:
$ systemctl --failed
The available unit files can be seen in
/etc/systemd/system/ (the latter takes precedence). You can see list installed unit files by:
$ systemctl list-unit-files
Units can be, for example, services (
.service), mount points (
.mount), devices (
.device) or sockets (
systemctl, you generally have to specify the complete name of the unit file, including its suffix, for example
sshd.socket. There are however a few shortforms when specifying the unit in the following
- If you don't specify the suffix, systemctl will assume
.service. For example,
netcfg.serviceare treated equivalent.
- Mount points will automatically be translated into the appropriate
.mountunit. For example, specifying
/homeis equivalent to
- Similiar to mount points, devices are automatically translated into the appropriate
.deviceunit, therefore specifying
/dev/sda2is equivalent to
man systemd.unit for details.
Activate a unit immediately:
# systemctl start <unit>
Deactivate a unit immediately:
# systemctl stop <unit>
Restart a unit:
# systemctl restart <unit>
Ask a unit to reload its configuration:
# systemctl reload <unit>
Show the status of a unit, including whether it is running or not:
$ systemctl status <unit>
Check whether a unit is already enabled or not:
$ systemctl is-enabled <unit>
Enable a unit to be started on bootup:
# systemctl enable <unit>
Installsection, it usually means they are called automatically by other services. But if you need to install them manually, use the following command, replacing
foowith the name of the service.
# ln -s /usr/lib/systemd/system/foo.service /etc/systemd/system/graphical.target.wants/
Disable a unit to not start during bootup:
# systemctl disable <unit>
Show the manual page associated with a unit (this has to be supported by the unit file):
$ systemctl help <unit>
If you are in a local
systemd-logind user session and no other session is active, the following commands will work without root privileges. If not (for example, because another user is logged into a tty), systemd will automatically ask you for the root password.
Shut down and reboot the system:
$ systemctl reboot
Shut down and power-off the system:
$ systemctl poweroff
Shut down and halt the system:
$ systemctl halt
Suspend the system:
$ systemctl suspend
Put the system into hibernation:
$ systemctl hibernate
Running DEs under systemd
# systemctl enable kdm
This should work out of the box. If not, you might have a
default.target set manually or from a older install:
# ls -l /etc/systemd/system/default.target
/etc/systemd/system/default.target -> /usr/lib/systemd/system/graphical.target
Simply delete the symlink and systemd will use its stock
# rm /etc/systemd/system/default.target
In order to check the status of your user session, you can use
loginctl. All PolicyKit actions like suspending the system or mounting external drives will work out of the box.
$ loginctl show-session $XDG_SESSION_ID
Writing custom .service files
With systemd, dependencies can be resolved by designing the unit files correctly. The most typical case is that the unit
A requires the unit
B to be running before
A is started. In that case add
After=B to the
[Unit] section of
A. If the dependency is optional, add
After=B instead. Note that
Requires= do not imply
After=, meaning that if
After= is not specified, the two units will be started in parallel.
Dependencies are typically placed on services and not on targets. For example,
network.target is pulled in by whatever service configures your network interfaces, therefore ordering your custom unit after it is sufficient since
network.target is started anyway.
There are several different start-up types to consider when writing a custom service file. This is set with the
Type= parameter in the
[Service] section. See
man systemd.service for a more detailed explanation.
Type=simple: systemd considers the service to be started up immediately. The process must not fork. Do not use this type if other services need to be ordered on this service, unless it is socket activated.
Type=forking: systemd considers the service started up once the process forks and the parent has exited. For classic daemons use this type unless you know that it is not necessary. You should specify
PIDFile=as well so systemd can keep track of the main process.
Type=oneshot: This is useful for scripts that do a single job and then exit. You may want to set
RemainAfterExit=as well so that systemd still considers the service as active after the process has exited.
Type=notify: Identical to
Type=simple, but with the stipulation that the daemon will send a signal to systemd when it is ready. The reference implementation for this notification is provided by
Type=dbus: The service is considered ready when the specified
BusNameappears on DBus's system bus.
Replacing provided unit files
The unit files in
/etc/systemd/system/ take precedence over the ones in
To make your own version of a unit (which will not be destroyed by an upgrade), copy the old unit file from
/etc/ and make your changes there. Alternatively you can use
.include to parse an existing service file and then override or add new options. For example, if you simply want to add an additional dependency to a service file, you may use:
.include /usr/lib/systemd/system/<service-name>.service [Unit] Requires=<new dependency> After=<new dependency>
Then run the following for your changes to take effect:
# systemctl reenable <unit> # systemctl restart <unit>
systemd-deltato see which unit files have been overridden and what exactly has been changed.
Syntax highlighting for units within Vim
Systemd uses targets which serve a similar purpose as runlevels but act a little different. Each target is named instead of numbered and is intended to serve a specific purpose with the possibility of having multiple ones active at the same time. Some targets are implemented by inheriting all of the services of another target and adding additional services to it. There are systemd targets that mimic the common SystemVinit runlevels so you can still switch targets using the familiar
telinit RUNLEVEL command.
Get current targets
The following should be used under systemd instead of
$ systemctl list-units --type=target
Create custom target
The runlevels that are assigned a specific purpose on vanilla Fedora installs; 0, 1, 3, 5, and 6; have a 1:1 mapping with a specific systemd target. Unfortunately, there is no good way to do the same for the user-defined runlevels like 2 and 4. If you make use of those it is suggested that you make a new named systemd target as
/etc/systemd/system/<your target> that takes one of the existing runlevels as a base (you can look at
/usr/lib/systemd/system/graphical.target as an example), make a directory
/etc/systemd/system/<your target>.wants, and then symlink the additional services from
/usr/lib/systemd/system/ that you wish to enable.
|SysV Runlevel||systemd Target||Notes|
|0||runlevel0.target, poweroff.target||Halt the system.|
|1, s, single||runlevel1.target, rescue.target||Single user mode.|
|2, 4||runlevel2.target, runlevel4.target, multi-user.target||User-defined/Site-specific runlevels. By default, identical to 3.|
|3||runlevel3.target, multi-user.target||Multi-user, non-graphical. Users can usually login via multiple consoles or via the network.|
|5||runlevel5.target, graphical.target||Multi-user, graphical. Usually has all the services of runlevel 3 plus a graphical login.|
Change current target
In systemd targets are exposed via "target units". You can change them like this:
# systemctl isolate graphical.target
This will only change the current target, and has no effect on the next boot. This is equivalent to commands such as
telinit 3 or
telinit 5 in Sysvinit.
Change default target to boot into
The standard target is
default.target, which is aliased by default to
graphical.target (which roughly corresponds to the old runlevel 5). To change the default target at boot-time, append one of the following kernel parameters to your bootloader:
.targetextension can be left out.
systemd.unit=multi-user.target(which roughly corresponds to the old runlevel 3),
systemd.unit=rescue.target(which roughly corresponds to the old runlevel 1).
Alternatively, you may leave the bootloader alone and change
default.target. This can be done using
# systemctl enable multi-user.target
The effect of this command is outputted by
systemctl; a symlink to the new default target is made at
/etc/systemd/system/default.target. This works if, and only if:
is in the target's configuration file. Currently,
graphical.target both have it.
Since version 38, systemd has its own logging system, the journal. Therefore, running a syslog daemon is no longer required. To read the log, use:
By default (when
Storage= is set to
/etc/systemd/journald.conf), the journal writes to
/var/log/journal/. If the directory
/var/log/journal/ does not exist (e.g. if you or some program delete it), systemd will not create it automatically, but instead write its logs to
/run/systemd/journal. This means that logs will be lost on reboot.
journalctl allows you to filter the output by specific fields.
Show all messages from this boot:
# journalctl -b
Follow new messages:
# journalctl -f
Show all messages by a specific executable:
# journalctl /usr/lib/systemd/systemd
Show all messages by a specific process:
# journalctl _PID=1
Show all messages by a specific unit:
# journalctl -u netcfg
systemd.journal-fields or Lennert's blog post for details.
Journal size limit
If the journal is persistent (non-volatile), its size limit is set to a default value of 10% of the size of the respective file system. E.g. with
/var/log/journal located on a 50 GiB root partition this would lead to 5 GiB of journal data. The maximum size of the persistent journal can be controlled by
/etc/systemd/journald.conf, so to limit it for example to 50 MiB uncomment and edit the corresponding line to:
man journald.conf for more info.
Journald in conjunction with syslog
Compatibility with classic syslog implementations is provided via a socket
/run/systemd/journal/syslog, to which all messages are forwarded. To make the syslog daemon work with the journal, it has to bind to this socket instead of
/dev/log (official announcement). The package in the repositories automatically provides the necessary configuration.
# systemctl enable syslog-ng
Analyzing the boot process
Systemd provides a tool called
systemd-analyze that allows you to analyze your boot process so you can see which unit files are causing your boot process to slow down. You can then optimize your system accordingly. You have to install and to use it.
To see how much time was spent in kernelspace and userspace on boot, simply use:
timestamphook to your
/etc/mkinitcpio.confand as root, rebuild your initramfs with
mkinitcpio -p linux
To list the started unit files, sorted by the time each of them took to start up:
$ systemd-analyze blame
You can also create a SVG file which describes your boot process graphically, similiar to Bootchart:
$ systemd-analyze plot > plot.svg
You could also use a version of bootchart to visualize the boot sequence. Since you are not able to put a second init into the kernel command line you won't be able to use any of the standard bootchart setups. However the AUR comes with an undocumented systemd service. After you've installed bootchart2 do:AUR package from
# systemctl enable bootchart
Read the bootchart documentation for further details on using this version of bootchart.
Systemd comes with its own readahead implementation, this should in principle improve boot time. However, depending on your kernel version and the type of your hard drive, your mileage may vary (i.e. it might be slower). To enable, do:
# systemctl enable systemd-readahead-collect systemd-readahead-replay
Remember that in order for the readahead to work its magic, you should reboot a couple of times.
Early start for services
One central feature of systemd is D-Bus and socket activation. This causes services to be started when they are first accessed and is generally a good thing. However, if you know that a service (like UPower) will always be started during boot, then the overall boot time might be reduced by starting it as early as possible. This can be achieved (if the service file is set up for it, which in most cases it is) by issuing:
# systemctl enable upower
This will cause systemd to start UPower as soon as possible, without causing races with the socket or D-Bus activation.
Less output during boot
quiet on the bootloader's kernel line. For some systems, particularly those with an SSD, the slow performance of the TTY is actually a bottleneck, and so less output means faster booting.
Shutdown/reboot takes terribly long
If the shutdown process takes a very long time (or seems to freeze) most likely a service not exiting is to blame. Systemd waits some time for each service to exit before trying to kill it. To find out if you are affected, see this article.
- Official Web Site
- Manual Pages
- systemd Optimizations
- Tips And Tricks
- systemd for Administrators (PDF)
- About systemd on Fedora Project
- How to debug systemd problems
- Booting up: Tools and tips for systemd, a Linux init tool. In The H
- Lennart's blog story
- status update
- status update2
- status update3
- most recent summary
- Fedora's SysVinit to systemd cheatsheet