1SYSTEMD.SPECIAL(7)              systemd.special             SYSTEMD.SPECIAL(7)
2
3
4

NAME

6       systemd.special - Special systemd units
7

SYNOPSIS

9       basic.target, bluetooth.target, cryptsetup-pre.target,
10       cryptsetup.target, ctrl-alt-del.target, blockdev@.target,
11       boot-complete.target, default.target, emergency.target, exit.target,
12       final.target, getty.target, getty-pre.target, graphical.target,
13       halt.target, hibernate.target, hybrid-sleep.target,
14       suspend-then-hibernate.target, initrd.target, initrd-fs.target,
15       initrd-root-device.target, initrd-root-fs.target, kbrequest.target,
16       kexec.target, local-fs-pre.target, local-fs.target, machines.target
17       multi-user.target, network-online.target, network-pre.target,
18       network.target, nss-lookup.target, nss-user-lookup.target,
19       paths.target, poweroff.target, printer.target, reboot.target,
20       remote-cryptsetup.target, remote-fs-pre.target, remote-fs.target,
21       rescue.target, rpcbind.target, runlevel2.target, runlevel3.target,
22       runlevel4.target, runlevel5.target, shutdown.target, sigpwr.target,
23       sleep.target, slices.target, smartcard.target, sockets.target,
24       sound.target, suspend.target, swap.target, sysinit.target,
25       system-update.target, system-update-pre.target, time-set.target,
26       time-sync.target, timers.target, umount.target, usb-gadget.target,
27       -.slice, system.slice, user.slice, machine.slice, -.mount,
28       dbus.service, dbus.socket, display-manager.service, init.scope,
29       syslog.socket, system-update-cleanup.service
30

DESCRIPTION

32       A few units are treated specially by systemd. Many of them have special
33       internal semantics and cannot be renamed, while others simply have a
34       standard meaning and should be present on all systems.
35

UNITS MANAGED BY THE SYSTEM SERVICE MANAGER

37   Special System Units
38       -.mount
39           The root mount point, i.e. the mount unit for the / path. This unit
40           is unconditionally active, during the entire time the system is up,
41           as this mount point is where the basic userspace is running from.
42
43       basic.target
44           A special target unit covering basic boot-up.
45
46           systemd automatically adds dependency of the type After= for this
47           target unit to all services (except for those with
48           DefaultDependencies=no).
49
50           Usually, this should pull-in all local mount points plus /var, /tmp
51           and /var/tmp, swap devices, sockets, timers, path units and other
52           basic initialization necessary for general purpose daemons. The
53           mentioned mount points are special cased to allow them to be
54           remote.
55
56           This target usually does not pull in any non-target units directly,
57           but rather does so indirectly via other early boot targets. It is
58           instead meant as a synchronization point for late boot services.
59           Refer to bootup(7) for details on the targets involved.
60
61       boot-complete.target
62           This target is intended as generic synchronization point for
63           services that shall determine or act on whether the boot process
64           completed successfully. Order units that are required to succeed
65           for a boot process to be considered successful before this unit,
66           and add a Requires= dependency from the target unit to them. Order
67           units that shall only run when the boot process is considered
68           successful after the target unit and pull in the target from it,
69           also with Requires=. Note that by default this target unit is not
70           part of the initial boot transaction, but is supposed to be pulled
71           in only if required by units that want to run only on successful
72           boots.
73
74           See systemd-boot-check-no-failures.service(8) for a service that
75           implements a generic system health check and orders itself before
76           boot-complete.target.
77
78           See systemd-bless-boot.service(8) for a service that propagates
79           boot success information to the boot loader, and orders itself
80           after boot-complete.target.
81
82       ctrl-alt-del.target
83           systemd starts this target whenever Control+Alt+Del is pressed on
84           the console. Usually, this should be aliased (symlinked) to
85           reboot.target.
86
87       cryptsetup.target
88           A target that pulls in setup services for all encrypted block
89           devices.
90
91       dbus.service
92           A special unit for the D-Bus bus daemon. As soon as this service is
93           fully started up systemd will connect to it and register its
94           service.
95
96       dbus.socket
97           A special unit for the D-Bus system bus socket. All units with
98           Type=dbus automatically gain a dependency on this unit.
99
100       default.target
101           The default unit systemd starts at bootup. Usually, this should be
102           aliased (symlinked) to multi-user.target or graphical.target. See
103           bootup(7) for more discussion.
104
105           The default unit systemd starts at bootup can be overridden with
106           the systemd.unit= kernel command line option, or more conveniently,
107           with the short names like single, rescue, 1, 3, 5, ...; see
108           systemd(1).
109
110       display-manager.service
111           The display manager service. Usually, this should be aliased
112           (symlinked) to gdm.service or a similar display manager service.
113
114       emergency.target
115           A special target unit that starts an emergency shell on the main
116           console. This target does not pull in other services or mounts. It
117           is the most minimal version of starting the system in order to
118           acquire an interactive shell; the only processes running are
119           usually just the system manager (PID 1) and the shell process. This
120           unit may be used by specifying emergency on the kernel command
121           line; it is also used when a file system check on a required file
122           system fails and boot-up cannot continue. Compare with
123           rescue.target, which serves a similar purpose, but also starts the
124           most basic services and mounts all file systems.
125
126           In many ways booting into emergency.target is similar to the effect
127           of booting with "init=/bin/sh" on the kernel command line, except
128           that emergency mode provides you with the full system and service
129           manager, and allows starting individual units in order to continue
130           the boot process in steps.
131
132           Note that depending on how emergency.target is reached, the root
133           file system might be mounted read-only or read-write (no remounting
134           is done specially for this target). For example, the system may
135           boot with root mounted read-only when ro is used on the kernel
136           command line and remain this way for emergency.target, or the
137           system may transition to emergency.target after the system has been
138           partially booted and disks have already been remounted read-write.
139
140       exit.target
141           A special service unit for shutting down the system or user service
142           manager. It is equivalent to poweroff.target on non-container
143           systems, and also works in containers.
144
145           systemd will start this unit when it receives the SIGTERM or SIGINT
146           signal when running as user service daemon.
147
148           Normally, this (indirectly) pulls in shutdown.target, which in turn
149           should be conflicted by all units that want to be scheduled for
150           shutdown when the service manager starts to exit.
151
152       final.target
153           A special target unit that is used during the shutdown logic and
154           may be used to pull in late services after all normal services are
155           already terminated and all mounts unmounted.
156
157       getty.target
158           A special target unit that pulls in statically configured local TTY
159           getty instances.
160
161       graphical.target
162           A special target unit for setting up a graphical login screen. This
163           pulls in multi-user.target.
164
165           Units that are needed for graphical logins shall add Wants=
166           dependencies for their unit to this unit (or multi-user.target)
167           during installation. This is best configured via
168           WantedBy=graphical.target in the unit's [Install] section.
169
170       hibernate.target
171           A special target unit for hibernating the system. This pulls in
172           sleep.target.
173
174       hybrid-sleep.target
175           A special target unit for hibernating and suspending the system at
176           the same time. This pulls in sleep.target.
177
178       suspend-then-hibernate.target
179           A special target unit for suspending the system for a period of
180           time, waking it and putting it into hibernate. This pulls in
181           sleep.target.
182
183       halt.target
184           A special target unit for shutting down and halting the system.
185           Note that this target is distinct from poweroff.target in that it
186           generally really just halts the system rather than powering it
187           down.
188
189           Applications wanting to halt the system should not start this unit
190           directly, but should instead execute systemctl halt (possibly with
191           the --no-block option) or call systemd(1)'s
192           org.freedesktop.systemd1.Manager.Halt D-Bus method directly.
193
194       init.scope
195           This scope unit is where the system and service manager (PID 1)
196           itself resides. It is active as long as the system is running.
197
198       initrd.target
199           This is the default target in the initramfs, similar to
200           default.target in the main system. It is used to mount the real
201           root and transition to it. See bootup(7) for more discussion.
202
203       initrd-fs.target
204           systemd-fstab-generator(3) automatically adds dependencies of type
205           Before= to sysroot-usr.mount and all mount points found in
206           /etc/fstab that have x-initrd.mount and not have noauto mount
207           options set.
208
209       initrd-root-device.target
210           A special initrd target unit that is reached when the root
211           filesystem device is available, but before it has been mounted.
212           systemd-fstab-generator(3) and systemd-gpt-auto-generator(3)
213           automatically setup the appropriate dependencies to make this
214           happen.
215
216       initrd-root-fs.target
217           systemd-fstab-generator(3) automatically adds dependencies of type
218           Before= to the sysroot.mount unit, which is generated from the
219           kernel command line.
220
221       kbrequest.target
222           systemd starts this target whenever Alt+ArrowUp is pressed on the
223           console. Note that any user with physical access to the machine
224           will be able to do this, without authentication, so this should be
225           used carefully.
226
227       kexec.target
228           A special target unit for shutting down and rebooting the system
229           via kexec.
230
231           Applications wanting to reboot the system should not start this
232           unit directly, but should instead execute systemctl kexec (possibly
233           with the --no-block option) or call systemd(1)'s
234           org.freedesktop.systemd1.Manager.KExec D-Bus method directly.
235
236       local-fs.target
237           systemd-fstab-generator(3) automatically adds dependencies of type
238           Before= to all mount units that refer to local mount points for
239           this target unit. In addition, it adds dependencies of type Wants=
240           to this target unit for those mounts listed in /etc/fstab that have
241           the auto mount option set.
242
243       machines.target
244           A standard target unit for starting all the containers and other
245           virtual machines. See systemd-nspawn@.service for an example.
246
247       multi-user.target
248           A special target unit for setting up a multi-user system
249           (non-graphical). This is pulled in by graphical.target.
250
251           Units that are needed for a multi-user system shall add Wants=
252           dependencies for their unit to this unit during installation. This
253           is best configured via WantedBy=multi-user.target in the unit's
254           [Install] section.
255
256       network-online.target
257           Units that strictly require a configured network connection should
258           pull in network-online.target (via a Wants= type dependency) and
259           order themselves after it. This target unit is intended to pull in
260           a service that delays further execution until the network is
261           sufficiently set up. What precisely this requires is left to the
262           implementation of the network managing service.
263
264           Note the distinction between this unit and network.target. This
265           unit is an active unit (i.e. pulled in by the consumer rather than
266           the provider of this functionality) and pulls in a service which
267           possibly adds substantial delays to further execution. In contrast,
268           network.target is a passive unit (i.e. pulled in by the provider of
269           the functionality, rather than the consumer) that usually does not
270           delay execution much. Usually, network.target is part of the boot
271           of most systems, while network-online.target is not, except when at
272           least one unit requires it. Also see Running Services After the
273           Network is up[1] for more information.
274
275           All mount units for remote network file systems automatically pull
276           in this unit, and order themselves after it. Note that networking
277           daemons that simply provide functionality to other hosts generally
278           do not need to pull this in.
279
280           systemd automatically adds dependencies of type Wants= and After=
281           for this target unit to all SysV init script service units with an
282           LSB header referring to the "$network" facility.
283
284           Note that this unit is only useful during the original system
285           start-up logic. After the system has completed booting up, it will
286           not track the online state of the system anymore. Due to this it
287           cannot be used as a network connection monitor concept, it is
288           purely a one-time system start-up concept.
289
290       paths.target
291           A special target unit that sets up all path units (see
292           systemd.path(5) for details) that shall be active after boot.
293
294           It is recommended that path units installed by applications get
295           pulled in via Wants= dependencies from this unit. This is best
296           configured via a WantedBy=paths.target in the path unit's [Install]
297           section.
298
299       poweroff.target
300           A special target unit for shutting down and powering off the
301           system.
302
303           Applications wanting to power off the system should not start this
304           unit directly, but should instead execute systemctl poweroff
305           (possibly with the --no-block option) or call systemd-logind(8)'s
306           org.freedesktop.login1.Manager.PowerOff D-Bus method directly.
307
308           runlevel0.target is an alias for this target unit, for
309           compatibility with SysV.
310
311       reboot.target
312           A special target unit for shutting down and rebooting the system.
313
314           Applications wanting to reboot the system should not start this
315           unit directly, but should instead execute systemctl reboot
316           (possibly with the --no-block option) or call systemd-logind(8)'s
317           org.freedesktop.login1.Manager.Reboot D-Bus method directly.
318
319           runlevel6.target is an alias for this target unit, for
320           compatibility with SysV.
321
322       remote-cryptsetup.target
323           Similar to cryptsetup.target, but for encrypted devices which are
324           accessed over the network. It is used for crypttab(8) entries
325           marked with _netdev.
326
327       remote-fs.target
328           Similar to local-fs.target, but for remote mount points.
329
330           systemd automatically adds dependencies of type After= for this
331           target unit to all SysV init script service units with an LSB
332           header referring to the "$remote_fs" facility.
333
334       rescue.target
335           A special target unit that pulls in the base system (including
336           system mounts) and spawns a rescue shell. Isolate to this target in
337           order to administer the system in single-user mode with all file
338           systems mounted but with no services running, except for the most
339           basic. Compare with emergency.target, which is much more reduced
340           and does not provide the file systems or most basic services.
341           Compare with multi-user.target, this target could be seen as
342           single-user.target.
343
344           runlevel1.target is an alias for this target unit, for
345           compatibility with SysV.
346
347           Use the "systemd.unit=rescue.target" kernel command line option to
348           boot into this mode. A short alias for this kernel command line
349           option is "1", for compatibility with SysV.
350
351       runlevel2.target, runlevel3.target, runlevel4.target, runlevel5.target
352           These are targets that are called whenever the SysV compatibility
353           code asks for runlevel 2, 3, 4, 5, respectively. It is a good idea
354           to make this an alias for (i.e. symlink to) graphical.target (for
355           runlevel 5) or multi-user.target (the others).
356
357       shutdown.target
358           A special target unit that terminates the services on system
359           shutdown.
360
361           Services that shall be terminated on system shutdown shall add
362           Conflicts= and Before= dependencies to this unit for their service
363           unit, which is implicitly done when DefaultDependencies=yes is set
364           (the default).
365
366       sigpwr.target
367           A special target that is started when systemd receives the SIGPWR
368           process signal, which is normally sent by the kernel or UPS daemons
369           when power fails.
370
371       sleep.target
372           A special target unit that is pulled in by suspend.target,
373           hibernate.target and hybrid-sleep.target and may be used to hook
374           units into the sleep state logic.
375
376       slices.target
377           A special target unit that sets up all slice units (see
378           systemd.slice(5) for details) that shall always be active after
379           boot. By default the generic system.slice slice unit as well as the
380           root slice unit -.slice are pulled in and ordered before this unit
381           (see below).
382
383           Adding slice units to slices.target is generally not necessary.
384           Instead, when some unit that uses Slice= is started, the specified
385           slice will be started automatically. Adding WantedBy=slices.target
386           lines to the [Install] section should only be done for units that
387           need to be always active. In that case care needs to be taken to
388           avoid creating a loop through the automatic dependencies on
389           "parent" slices.
390
391       sockets.target
392           A special target unit that sets up all socket units (see
393           systemd.socket(5) for details) that shall be active after boot.
394
395           Services that can be socket-activated shall add Wants= dependencies
396           to this unit for their socket unit during installation. This is
397           best configured via a WantedBy=sockets.target in the socket unit's
398           [Install] section.
399
400       suspend.target
401           A special target unit for suspending the system. This pulls in
402           sleep.target.
403
404       swap.target
405           Similar to local-fs.target, but for swap partitions and swap files.
406
407       sysinit.target
408           systemd automatically adds dependencies of the types Requires= and
409           After= for this target unit to all services (except for those with
410           DefaultDependencies=no).
411
412           This target pulls in the services required for system
413           initialization. System services pulled in by this target should
414           declare DefaultDependencies=no and specify all their dependencies
415           manually, including access to anything more than a read only root
416           filesystem. For details on the dependencies of this target, refer
417           to bootup(7).
418
419       syslog.socket
420           The socket unit syslog implementations should listen on. All
421           userspace log messages will be made available on this socket. For
422           more information about syslog integration, please consult the
423           Syslog Interface[2] document.
424
425       system-update.target, system-update-pre.target,
426       system-update-cleanup.service
427           A special target unit that is used for offline system updates.
428           systemd-system-update-generator(8) will redirect the boot process
429           to this target if /system-update exists. For more information see
430           systemd.offline-updates(7).
431
432           Updates should happen before the system-update.target is reached,
433           and the services which implement them should cause the machine to
434           reboot. The main units executing the update should order themselves
435           after system-update-pre.target but not pull it in. Services which
436           want to run during system updates only, but before the actual
437           system update is executed should order themselves before this unit
438           and pull it in. As a safety measure, if this does not happen, and
439           /system-update still exists after system-update.target is reached,
440           system-update-cleanup.service will remove this symlink and reboot
441           the machine.
442
443       timers.target
444           A special target unit that sets up all timer units (see
445           systemd.timer(5) for details) that shall be active after boot.
446
447           It is recommended that timer units installed by applications get
448           pulled in via Wants= dependencies from this unit. This is best
449           configured via WantedBy=timers.target in the timer unit's [Install]
450           section.
451
452       umount.target
453           A special target unit that unmounts all mount and automount points
454           on system shutdown.
455
456           Mounts that shall be unmounted on system shutdown shall add
457           Conflicts dependencies to this unit for their mount unit, which is
458           implicitly done when DefaultDependencies=yes is set (the default).
459
460   Special System Units for Devices
461       Some target units are automatically pulled in as devices of certain
462       kinds show up in the system. These may be used to automatically
463       activate various services based on the specific type of the available
464       hardware.
465
466       bluetooth.target
467           This target is started automatically as soon as a Bluetooth
468           controller is plugged in or becomes available at boot.
469
470           This may be used to pull in Bluetooth management daemons
471           dynamically when Bluetooth hardware is found.
472
473       printer.target
474           This target is started automatically as soon as a printer is
475           plugged in or becomes available at boot.
476
477           This may be used to pull in printer management daemons dynamically
478           when printer hardware is found.
479
480       smartcard.target
481           This target is started automatically as soon as a smartcard
482           controller is plugged in or becomes available at boot.
483
484           This may be used to pull in smartcard management daemons
485           dynamically when smartcard hardware is found.
486
487       sound.target
488           This target is started automatically as soon as a sound card is
489           plugged in or becomes available at boot.
490
491           This may be used to pull in audio management daemons dynamically
492           when audio hardware is found.
493
494       usb-gadget.target
495           This target is started automatically as soon as a USB Device
496           Controller becomes available at boot.
497
498           This may be used to pull in usb gadget dynamically when UDC
499           hardware is found.
500
501   Special Passive System Units
502       A number of special system targets are defined that can be used to
503       properly order boot-up of optional services. These targets are
504       generally not part of the initial boot transaction, unless they are
505       explicitly pulled in by one of the implementing services. Note
506       specifically that these passive target units are generally not pulled
507       in by the consumer of a service, but by the provider of the service.
508       This means: a consuming service should order itself after these targets
509       (as appropriate), but not pull it in. A providing service should order
510       itself before these targets (as appropriate) and pull it in (via a
511       Wants= type dependency).
512
513       Note that these passive units cannot be started manually, i.e.
514       "systemctl start time-sync.target" will fail with an error. They can
515       only be pulled in by dependency. This is enforced since they exist for
516       ordering purposes only and thus are not useful as only unit within a
517       transaction.
518
519       blockdev@.target
520           This template unit is used to order mount units and other consumers
521           of block devices after services that synthesize these block
522           devices. In particular, this is intended to be used with storage
523           services (such as systemd-cryptsetup@.service(5)) that allocate and
524           manage a virtual block device. Storage services are ordered before
525           an instance of blockdev@.target, and the consumer units after it.
526           The ordering is particularly relevant during shutdown, as it
527           ensures that the mount is deactivated first and the service backing
528           the mount later. The blockdev@.target instance should be pulled in
529           via a Wants= dependency of the storage daemon and thus generally
530           not be part of any transaction unless a storage daemon is used. The
531           instance name for instances of this template unit must be a
532           properly escaped block device node path, e.g.
533           blockdev@dev-mapper-foobar.target for the storage device
534           /dev/mapper/foobar.
535
536       cryptsetup-pre.target
537           This passive target unit may be pulled in by services that want to
538           run before any encrypted block device is set up. All encrypted
539           block devices are set up after this target has been reached. Since
540           the shutdown order is implicitly the reverse start-up order between
541           units, this target is particularly useful to ensure that a service
542           is shut down only after all encrypted block devices are fully
543           stopped.
544
545       getty-pre.target
546           A special passive target unit. Users of this target are expected to
547           pull it in the boot transaction via a dependency (e.g.  Wants=).
548           Order your unit before this unit if you want to make use of the
549           console just before getty is started.
550
551       local-fs-pre.target
552           This target unit is automatically ordered before all local mount
553           points marked with auto (see above). It can be used to execute
554           certain units before all local mounts.
555
556       network.target
557           This unit is supposed to indicate when network functionality is
558           available, but it is only very weakly defined what that is supposed
559           to mean, with one exception: at shutdown, a unit that is ordered
560           after network.target will be stopped before the network — to
561           whatever level it might be set up then — is shut down. It is hence
562           useful when writing service files that require network access on
563           shutdown, which should order themselves after this target, but not
564           pull it in. Also see Running Services After the Network is up[1]
565           for more information. Also see network-online.target described
566           above.
567
568       network-pre.target
569           This passive target unit may be pulled in by services that want to
570           run before any network is set up, for example for the purpose of
571           setting up a firewall. All network management software orders
572           itself after this target, but does not pull it in.
573
574       nss-lookup.target
575           A target that should be used as synchronization point for all
576           host/network name service lookups. Note that this is independent of
577           UNIX user/group name lookups for which nss-user-lookup.target
578           should be used. All services for which the availability of full
579           host/network name resolution is essential should be ordered after
580           this target, but not pull it in. systemd automatically adds
581           dependencies of type After= for this target unit to all SysV init
582           script service units with an LSB header referring to the "$named"
583           facility.
584
585       nss-user-lookup.target
586           A target that should be used as synchronization point for all
587           regular UNIX user/group name service lookups. Note that this is
588           independent of host/network name lookups for which
589           nss-lookup.target should be used. All services for which the
590           availability of the full user/group database is essential should be
591           ordered after this target, but not pull it in. All services which
592           provide parts of the user/group database should be ordered before
593           this target, and pull it in. Note that this unit is only relevant
594           for regular users and groups — system users and groups are required
595           to be resolvable during earliest boot already, and hence do not
596           need any special ordering against this target.
597
598       remote-fs-pre.target
599           This target unit is automatically ordered before all mount point
600           units (see above) and cryptsetup devices marked with the _netdev.
601           It can be used to run certain units before remote encrypted devices
602           and mounts are established. Note that this unit is generally not
603           part of the initial transaction, unless the unit that wants to be
604           ordered before all remote mounts pulls it in via a Wants= type
605           dependency. If the unit wants to be pulled in by the first remote
606           mount showing up, it should use network-online.target (see above).
607
608       rpcbind.target
609           The portmapper/rpcbind pulls in this target and orders itself
610           before it, to indicate its availability. systemd automatically adds
611           dependencies of type After= for this target unit to all SysV init
612           script service units with an LSB header referring to the "$portmap"
613           facility.
614
615       time-set.target
616           Services responsible for setting the system clock from a local
617           source (such as a maintained timestamp file or imprecise real-time
618           clock) should pull in this target and order themselves before it.
619           Services where approximate time is desired should be ordered after
620           this unit, but not pull it in. This target does not provide the
621           accuracy guarantees of time-sync.target.
622
623       time-sync.target
624           Services responsible for synchronizing the system clock from a
625           remote source (such as NTP client implementations) should pull in
626           this target and order themselves before it. All services where
627           correct time is essential should be ordered after this unit, but
628           not pull it in. systemd automatically adds dependencies of type
629           After= for this target unit to all SysV init script service units
630           with an LSB header referring to the "$time" facility.
631
632   Special Slice Units
633       There are four ".slice" units which form the basis of the hierarchy for
634       assignment of resources for services, users, and virtual machines or
635       containers. See systemd.slice(7) for details about slice units.
636
637       -.slice
638           The root slice is the root of the slice hierarchy. It usually does
639           not contain units directly, but may be used to set defaults for the
640           whole tree.
641
642       system.slice
643           By default, all system services started by systemd are found in
644           this slice.
645
646       user.slice
647           By default, all user processes and services started on behalf of
648           the user, including the per-user systemd instance are found in this
649           slice. This is pulled in by systemd-logind.service.
650
651       machine.slice
652           By default, all virtual machines and containers registered with
653           systemd-machined are found in this slice. This is pulled in by
654           systemd-machined.service.
655

UNITS MANAGED BY THE USER SERVICE MANAGER

657   Special User Units
658       When systemd runs as a user instance, the following special units are
659       available:
660
661       default.target
662           This is the main target of the user session, started by default.
663           Various services that compose the normal user session should be
664           pulled into this target. In this regard, default.target is similar
665           to multi-user.target in the system instance, but it is a real unit,
666           not an alias.
667
668       In addition, the following units are available which have definitions
669       similar to their system counterparts: exit.target, shutdown.target,
670       sockets.target, timers.target, paths.target, bluetooth.target,
671       printer.target, smartcard.target, sound.target.
672
673   Special Passive User Units
674       graphical-session.target
675           This target is active whenever any graphical session is running. It
676           is used to stop user services which only apply to a graphical (X,
677           Wayland, etc.) session when the session is terminated. Such
678           services should have "PartOf=graphical-session.target" in their
679           [Unit] section. A target for a particular session (e. g.
680           gnome-session.target) starts and stops "graphical-session.target"
681           with "BindsTo=graphical-session.target".
682
683           Which services are started by a session target is determined by the
684           "Wants=" and "Requires=" dependencies. For services that can be
685           enabled independently, symlinks in ".wants/" and ".requires/"
686           should be used, see systemd.unit(5). Those symlinks should either
687           be shipped in packages, or should be added dynamically after
688           installation, for example using "systemctl add-wants", see
689           systemctl(1).
690
691           Example 1. Nautilus as part of a GNOME session
692           "gnome-session.target" pulls in Nautilus as top-level service:
693
694               [Unit]
695                 Description=User systemd services for GNOME graphical session
696                 Wants=nautilus.service
697                 BindsTo=graphical-session.target
698
699           "nautilus.service" gets stopped when the session stops:
700
701               [Unit]
702                 Description=Render the desktop icons with Nautilus
703                 PartOf=graphical-session.target
704
705                 [Service]
706                 ...
707
708       graphical-session-pre.target
709           This target contains services which set up the environment or
710           global configuration of a graphical session, such as SSH/GPG agents
711           (which need to export an environment variable into all desktop
712           processes) or migration of obsolete d-conf keys after an OS upgrade
713           (which needs to happen before starting any process that might use
714           them). This target must be started before starting a graphical
715           session like gnome-session.target.
716
717       xdg-desktop-autostart.target
718           The XDG specification defines a way to autostart applications using
719           XDG desktop files. systemd ships systemd-xdg-autostart-generator(8)
720           for the XDG desktop files in autostart directories. Desktop
721           Environments can opt-in to use this service by adding a Wants=
722           dependency on "xdg-desktop-autostart.target" .
723                     .RE
724

SEE ALSO

726       systemd(1), systemd.unit(5), systemd.service(5), systemd.socket(5),
727       systemd.target(5), systemd.slice(5), bootup(7), systemd-fstab-
728       generator(8), user@.service(5)
729

NOTES

731        1. Running Services After the Network is up
732           https://www.freedesktop.org/wiki/Software/systemd/NetworkTarget
733
734        2. Syslog Interface
735           https://www.freedesktop.org/wiki/Software/systemd/syslog
736
737
738
739systemd 246                                                 SYSTEMD.SPECIAL(7)
Impressum