1SYSTEMCTL(1)                       systemctl                      SYSTEMCTL(1)
2
3
4

NAME

6       systemctl - Control the systemd system and service manager
7

SYNOPSIS

9       systemctl [OPTIONS...] COMMAND [UNIT...]
10

DESCRIPTION

12       systemctl may be used to introspect and control the state of the
13       "systemd" system and service manager. Please refer to systemd(1) for an
14       introduction into the basic concepts and functionality this tool
15       manages.
16

OPTIONS

18       The following options are understood:
19
20       -t, --type=
21           The argument should be a comma-separated list of unit types such as
22           service and socket.
23
24           If one of the arguments is a unit type, when listing units, limit
25           display to certain unit types. Otherwise, units of all types will
26           be shown.
27
28           As a special case, if one of the arguments is help, a list of
29           allowed values will be printed and the program will exit.
30
31       --state=
32           The argument should be a comma-separated list of unit LOAD, SUB, or
33           ACTIVE states. When listing units, show only those in the specified
34           states. Use --state=failed to show only failed units.
35
36           As a special case, if one of the arguments is help, a list of
37           allowed values will be printed and the program will exit.
38
39       -p, --property=
40           When showing unit/job/manager properties with the show command,
41           limit display to properties specified in the argument. The argument
42           should be a comma-separated list of property names, such as
43           "MainPID". Unless specified, all known properties are shown. If
44           specified more than once, all properties with the specified names
45           are shown. Shell completion is implemented for property names.
46
47           For the manager itself, systemctl show will show all available
48           properties. Those properties are documented in systemd-
49           system.conf(5).
50
51           Properties for units vary by unit type, so showing any unit (even a
52           non-existent one) is a way to list properties pertaining to this
53           type. Similarly, showing any job will list properties pertaining to
54           all jobs. Properties for units are documented in systemd.unit(5),
55           and the pages for individual unit types systemd.service(5),
56           systemd.socket(5), etc.
57
58       -a, --all
59           When listing units with list-units, also show inactive units and
60           units which are following other units. When showing
61           unit/job/manager properties, show all properties regardless whether
62           they are set or not.
63
64           To list all units installed in the file system, use the
65           list-unit-files command instead.
66
67           When listing units with list-dependencies, recursively show
68           dependencies of all dependent units (by default only dependencies
69           of target units are shown).
70
71       -r, --recursive
72           When listing units, also show units of local containers. Units of
73           local containers will be prefixed with the container name,
74           separated by a single colon character (":").
75
76       --reverse
77           Show reverse dependencies between units with list-dependencies,
78           i.e. follow dependencies of type WantedBy=, RequiredBy=, PartOf=,
79           BoundBy=, instead of Wants= and similar.
80
81       --after
82           With list-dependencies, show the units that are ordered before the
83           specified unit. In other words, recursively list units following
84           the After= dependency.
85
86           Note that any After= dependency is automatically mirrored to create
87           a Before= dependency. Temporal dependencies may be specified
88           explicitly, but are also created implicitly for units which are
89           WantedBy= targets (see systemd.target(5)), and as a result of other
90           directives (for example RequiresMountsFor=). Both explicitly and
91           implicitly introduced dependencies are shown with
92           list-dependencies.
93
94           When passed to the list-jobs command, for each printed job show
95           which other jobs are waiting for it. May be combined with --before
96           to show both the jobs waiting for each job as well as all jobs each
97           job is waiting for.
98
99       --before
100           With list-dependencies, show the units that are ordered after the
101           specified unit. In other words, recursively list units following
102           the Before= dependency.
103
104           When passed to the list-jobs command, for each printed job show
105           which other jobs it is waiting for. May be combined with --after to
106           show both the jobs waiting for each job as well as all jobs each
107           job is waiting for.
108
109       -l, --full
110           Do not ellipsize unit names, process tree entries, journal output,
111           or truncate unit descriptions in the output of status, list-units,
112           list-jobs, and list-timers.
113
114           Also, show installation targets in the output of is-enabled.
115
116       --value
117           When printing properties with show, only print the value, and skip
118           the property name and "=".
119
120       --show-types
121           When showing sockets, show the type of the socket.
122
123       --job-mode=
124           When queuing a new job, this option controls how to deal with
125           already queued jobs. It takes one of "fail", "replace",
126           "replace-irreversibly", "isolate", "ignore-dependencies",
127           "ignore-requirements" or "flush". Defaults to "replace", except
128           when the isolate command is used which implies the "isolate" job
129           mode.
130
131           If "fail" is specified and a requested operation conflicts with a
132           pending job (more specifically: causes an already pending start job
133           to be reversed into a stop job or vice versa), cause the operation
134           to fail.
135
136           If "replace" (the default) is specified, any conflicting pending
137           job will be replaced, as necessary.
138
139           If "replace-irreversibly" is specified, operate like "replace", but
140           also mark the new jobs as irreversible. This prevents future
141           conflicting transactions from replacing these jobs (or even being
142           enqueued while the irreversible jobs are still pending).
143           Irreversible jobs can still be cancelled using the cancel command.
144           This job mode should be used on any transaction which pulls in
145           shutdown.target.
146
147           "isolate" is only valid for start operations and causes all other
148           units to be stopped when the specified unit is started. This mode
149           is always used when the isolate command is used.
150
151           "flush" will cause all queued jobs to be canceled when the new job
152           is enqueued.
153
154           If "ignore-dependencies" is specified, then all unit dependencies
155           are ignored for this new job and the operation is executed
156           immediately. If passed, no required units of the unit passed will
157           be pulled in, and no ordering dependencies will be honored. This is
158           mostly a debugging and rescue tool for the administrator and should
159           not be used by applications.
160
161           "ignore-requirements" is similar to "ignore-dependencies", but only
162           causes the requirement dependencies to be ignored, the ordering
163           dependencies will still be honored.
164
165       --fail
166           Shorthand for --job-mode=fail.
167
168           When used with the kill command, if no units were killed, the
169           operation results in an error.
170
171       -i, --ignore-inhibitors
172           When system shutdown or a sleep state is requested, ignore
173           inhibitor locks. Applications can establish inhibitor locks to
174           avoid that certain important operations (such as CD burning or
175           suchlike) are interrupted by system shutdown or a sleep state. Any
176           user may take these locks and privileged users may override these
177           locks. If any locks are taken, shutdown and sleep state requests
178           will normally fail (regardless of whether privileged or not) and a
179           list of active locks is printed. However, if --ignore-inhibitors is
180           specified, the locks are ignored and not printed, and the operation
181           attempted anyway, possibly requiring additional privileges.
182
183       --dry-run
184           Just print what would be done. Currently supported by verbs halt,
185           poweroff, reboot, kexec, suspend, hibernate, hybrid-sleep, default,
186           rescue, emergency, and exit.
187
188       -q, --quiet
189           Suppress printing of the results of various commands and also the
190           hints about truncated log lines. This does not suppress output of
191           commands for which the printed output is the only result (like
192           show). Errors are always printed.
193
194       --no-block
195           Do not synchronously wait for the requested operation to finish. If
196           this is not specified, the job will be verified, enqueued and
197           systemctl will wait until the unit's start-up is completed. By
198           passing this argument, it is only verified and enqueued. This
199           option may not be combined with --wait.
200
201       --wait
202           Synchronously wait for started units to terminate again. This
203           option may not be combined with --no-block. Note that this will
204           wait forever if any given unit never terminates (by itself or by
205           getting stopped explicitly); particularly services which use
206           "RemainAfterExit=yes".
207
208       --user
209           Talk to the service manager of the calling user, rather than the
210           service manager of the system.
211
212       --system
213           Talk to the service manager of the system. This is the implied
214           default.
215
216       --failed
217           List units in failed state. This is equivalent to --state=failed.
218
219       --no-wall
220           Do not send wall message before halt, power-off and reboot.
221
222       --global
223           When used with enable and disable, operate on the global user
224           configuration directory, thus enabling or disabling a unit file
225           globally for all future logins of all users.
226
227       --no-reload
228           When used with enable and disable, do not implicitly reload daemon
229           configuration after executing the changes.
230
231       --no-ask-password
232           When used with start and related commands, disables asking for
233           passwords. Background services may require input of a password or
234           passphrase string, for example to unlock system hard disks or
235           cryptographic certificates. Unless this option is specified and the
236           command is invoked from a terminal, systemctl will query the user
237           on the terminal for the necessary secrets. Use this option to
238           switch this behavior off. In this case, the password must be
239           supplied by some other means (for example graphical password
240           agents) or the service might fail. This also disables querying the
241           user for authentication for privileged operations.
242
243       --kill-who=
244           When used with kill, choose which processes to send a signal to.
245           Must be one of main, control or all to select whether to kill only
246           the main process, the control process or all processes of the unit.
247           The main process of the unit is the one that defines the life-time
248           of it. A control process of a unit is one that is invoked by the
249           manager to induce state changes of it. For example, all processes
250           started due to the ExecStartPre=, ExecStop= or ExecReload= settings
251           of service units are control processes. Note that there is only one
252           control process per unit at a time, as only one state change is
253           executed at a time. For services of type Type=forking, the initial
254           process started by the manager for ExecStart= is a control process,
255           while the process ultimately forked off by that one is then
256           considered the main process of the unit (if it can be determined).
257           This is different for service units of other types, where the
258           process forked off by the manager for ExecStart= is always the main
259           process itself. A service unit consists of zero or one main
260           process, zero or one control process plus any number of additional
261           processes. Not all unit types manage processes of these types
262           however. For example, for mount units, control processes are
263           defined (which are the invocations of /usr/bin/mount and
264           /usr/bin/umount), but no main process is defined. If omitted,
265           defaults to all.
266
267       -s, --signal=
268           When used with kill, choose which signal to send to selected
269           processes. Must be one of the well-known signal specifiers such as
270           SIGTERM, SIGINT or SIGSTOP. If omitted, defaults to SIGTERM.
271
272       -f, --force
273           When used with enable, overwrite any existing conflicting symlinks.
274
275           When used with edit, create all of the specified units which do not
276           already exist.
277
278           When used with halt, poweroff, reboot or kexec, execute the
279           selected operation without shutting down all units. However, all
280           processes will be killed forcibly and all file systems are
281           unmounted or remounted read-only. This is hence a drastic but
282           relatively safe option to request an immediate reboot. If --force
283           is specified twice for these operations (with the exception of
284           kexec), they will be executed immediately, without terminating any
285           processes or unmounting any file systems. Warning: specifying
286           --force twice with any of these operations might result in data
287           loss. Note that when --force is specified twice the selected
288           operation is executed by systemctl itself, and the system manager
289           is not contacted. This means the command should succeed even when
290           the system manager has crashed.
291
292       --message=
293           When used with halt, poweroff or reboot, set a short message
294           explaining the reason for the operation. The message will be logged
295           together with the default shutdown message.
296
297       --now
298           When used with enable, the units will also be started. When used
299           with disable or mask, the units will also be stopped. The start or
300           stop operation is only carried out when the respective enable or
301           disable operation has been successful.
302
303       --root=
304           When used with enable/disable/is-enabled (and related commands),
305           use the specified root path when looking for unit files. If this
306           option is present, systemctl will operate on the file system
307           directly, instead of communicating with the systemd daemon to carry
308           out changes.
309
310       --runtime
311           When used with set-property, make changes only temporarily, so that
312           they are lost on the next reboot.
313
314           Similarily, when used with enable, mask, edit and related commands,
315           make temporary changes, which are lost on the next reboot. Changes
316           are not made in subdirectories of /etc, but in /run. The immediate
317           effect is identical, however since the latter is lost on reboot,
318           the changes are lost too.
319
320           Note: this option cannot be used with disable, unmask, preset, or
321           preset-all, because those operations sometimes need to remove
322           symlinks under /etc to have the desired effect, which would cause a
323           persistent change.
324
325       --preset-mode=
326           Takes one of "full" (the default), "enable-only", "disable-only".
327           When used with the preset or preset-all commands, controls whether
328           units shall be disabled and enabled according to the preset rules,
329           or only enabled, or only disabled.
330
331       -n, --lines=
332           When used with status, controls the number of journal lines to
333           show, counting from the most recent ones. Takes a positive integer
334           argument. Defaults to 10.
335
336       -o, --output=
337           When used with status, controls the formatting of the journal
338           entries that are shown. For the available choices, see
339           journalctl(1). Defaults to "short".
340
341       --firmware-setup
342           When used with the reboot command, indicate to the system's
343           firmware to boot into setup mode. Note that this is currently only
344           supported on some EFI systems and only if the system was booted in
345           EFI mode.
346
347       --plain
348           When used with list-dependencies, list-units or list-machines, the
349           output is printed as a list instead of a tree, and the bullet
350           circles are omitted.
351
352       -H, --host=
353           Execute the operation remotely. Specify a hostname, or a username
354           and hostname separated by "@", to connect to. The hostname may
355           optionally be suffixed by a container name, separated by ":", which
356           connects directly to a specific container on the specified host.
357           This will use SSH to talk to the remote machine manager instance.
358           Container names may be enumerated with machinectl -H HOST.
359
360       -M, --machine=
361           Execute operation on a local container. Specify a container name to
362           connect to.
363
364       --no-pager
365           Do not pipe output into a pager.
366
367       --no-legend
368           Do not print the legend, i.e. column headers and the footer with
369           hints.
370
371       -h, --help
372           Print a short help text and exit.
373
374       --version
375           Print a short version string and exit.
376

COMMANDS

378       The following commands are understood:
379
380   Unit Commands
381       list-units [PATTERN...]
382           List units that systemd currently has in memory. This includes
383           units that are either referenced directly or through a dependency,
384           units that are pinned by applications programmatically, or units
385           that were active in the past and have failed. By default only units
386           which are active, have pending jobs, or have failed are shown; this
387           can be changed with option --all. If one or more PATTERNs are
388           specified, only units matching one of them are shown. The units
389           that are shown are additionally filtered by --type= and --state= if
390           those options are specified.
391
392           Produces output similar to
393
394                 UNIT                         LOAD   ACTIVE SUB     DESCRIPTION
395                 sys-module-fuse.device       loaded active plugged /sys/module/fuse
396                 -.mount                      loaded active mounted Root Mount
397                 boot-efi.mount               loaded active mounted /boot/efi
398                 systemd-journald.service     loaded active running Journal Service
399                 systemd-logind.service       loaded active running Login Service
400               ● user@1000.service            loaded active running User Manager for UID 1000
401               ...
402                 systemd-tmpfiles-clean.timer loaded active waiting Daily Cleanup of Temporary Directories
403
404               LOAD   = Reflects whether the unit definition was properly loaded.
405               ACTIVE = The high-level unit activation state, i.e. generalization of SUB.
406               SUB    = The low-level unit activation state, values depend on unit type.
407
408               123 loaded units listed. Pass --all to see loaded but inactive units, too.
409               To show all installed unit files use 'systemctl list-unit-files'.
410
411
412           The header and the last unit of a given type are underlined if the
413           terminal supports that. A colored dot is shown next to services
414           which were masked, not found, or otherwise failed.
415
416           The LOAD column shows the load state, one of loaded, not-found,
417           bad-setting, error, masked. The ACTIVE columns shows the general
418           unit state, one of active, reloading, inactive, failed, activating,
419           deactivating. The SUB column shows the unit-type-specific detailed
420           state of the unit, possible values vary by unit type. The list of
421           possible LOAD, ACTIVE, and SUB states is not constant and new
422           systemd releases may both add and remove values.
423
424               systemctl --state=help
425
426           command maybe be used to display the current set of possible
427           values.
428
429           This is the default command.
430
431       list-sockets [PATTERN...]
432           List socket units currently in memory, ordered by listening
433           address. If one or more PATTERNs are specified, only socket units
434           matching one of them are shown. Produces output similar to
435
436               LISTEN           UNIT                        ACTIVATES
437               /dev/initctl     systemd-initctl.socket      systemd-initctl.service
438               ...
439               [::]:22          sshd.socket                 sshd.service
440               kobject-uevent 1 systemd-udevd-kernel.socket systemd-udevd.service
441
442               5 sockets listed.
443
444           Note: because the addresses might contains spaces, this output is
445           not suitable for programmatic consumption.
446
447           Also see --show-types, --all, and --state=.
448
449       list-timers [PATTERN...]
450           List timer units currently in memory, ordered by the time they
451           elapse next. If one or more PATTERNs are specified, only units
452           matching one of them are shown. Produces output similar to
453
454               NEXT                         LEFT          LAST                         PASSED     UNIT                         ACTIVATES
455               n/a                          n/a           Thu 2017-02-23 13:40:29 EST  3 days ago ureadahead-stop.timer        ureadahead-stop.service
456               Sun 2017-02-26 18:55:42 EST  1min 14s left Thu 2017-02-23 13:54:44 EST  3 days ago systemd-tmpfiles-clean.timer systemd-tmpfiles-clean.service
457               Sun 2017-02-26 20:37:16 EST  1h 42min left Sun 2017-02-26 11:56:36 EST  6h ago     apt-daily.timer              apt-daily.service
458               Sun 2017-02-26 20:57:49 EST  2h 3min left  Sun 2017-02-26 11:56:36 EST  6h ago     snapd.refresh.timer          snapd.refresh.service
459
460
461           NEXT shows the next time the timer will run.
462
463           LEFT shows how long till the next time the timer runs.
464
465           LAST shows the last time the timer ran.
466
467           PASSED shows how long has passed since the timer last ran.
468
469           UNIT shows the name of the timer
470
471           ACTIVATES shows the name the service the timer activates when it
472           runs.
473
474           Also see --all and --state=.
475
476       start PATTERN...
477           Start (activate) one or more units specified on the command line.
478
479           Note that glob patterns operate on the set of primary names of
480           units currently in memory. Units which are not active and are not
481           in a failed state usually are not in memory, and will not be
482           matched by any pattern. In addition, in case of instantiated units,
483           systemd is often unaware of the instance name until the instance
484           has been started. Therefore, using glob patterns with start has
485           limited usefulness. Also, secondary alias names of units are not
486           considered.
487
488       stop PATTERN...
489           Stop (deactivate) one or more units specified on the command line.
490
491       reload PATTERN...
492           Asks all units listed on the command line to reload their
493           configuration. Note that this will reload the service-specific
494           configuration, not the unit configuration file of systemd. If you
495           want systemd to reload the configuration file of a unit, use the
496           daemon-reload command. In other words: for the example case of
497           Apache, this will reload Apache's httpd.conf in the web server, not
498           the apache.service systemd unit file.
499
500           This command should not be confused with the daemon-reload command.
501
502       restart PATTERN...
503           Stop and then start one or more units specified on the command
504           line. If the units are not running yet, they will be started.
505
506           Note that restarting a unit with this command does not necessarily
507           flush out all of the unit's resources before it is started again.
508           For example, the per-service file descriptor storage facility (see
509           FileDescriptoreStoreMax= in systemd.service(5)) will remain intact
510           as long as the unit has a job pending, and is only cleared when the
511           unit is fully stopped and no jobs are pending anymore. If it is
512           intended that the file descriptor store is flushed out, too, during
513           a restart operation an explicit systemctl stop command followed by
514           systemctl start should be issued.
515
516       try-restart PATTERN...
517           Stop and then start one or more units specified on the command line
518           if the units are running. This does nothing if units are not
519           running.
520
521       reload-or-restart PATTERN...
522           Reload one or more units if they support it. If not, stop and then
523           start them instead. If the units are not running yet, they will be
524           started.
525
526       try-reload-or-restart PATTERN...
527           Reload one or more units if they support it. If not, stop and then
528           start them instead. This does nothing if the units are not running.
529
530       isolate UNIT
531           Start the unit specified on the command line and its dependencies
532           and stop all others, unless they have IgnoreOnIsolate=yes (see
533           systemd.unit(5)). If a unit name with no extension is given, an
534           extension of ".target" will be assumed.
535
536           This is similar to changing the runlevel in a traditional init
537           system. The isolate command will immediately stop processes that
538           are not enabled in the new unit, possibly including the graphical
539           environment or terminal you are currently using.
540
541           Note that this is allowed only on units where AllowIsolate= is
542           enabled. See systemd.unit(5) for details.
543
544       kill PATTERN...
545           Send a signal to one or more processes of the unit. Use --kill-who=
546           to select which process to kill. Use --signal= to select the signal
547           to send.
548
549       is-active PATTERN...
550           Check whether any of the specified units are active (i.e. running).
551           Returns an exit code 0 if at least one is active, or non-zero
552           otherwise. Unless --quiet is specified, this will also print the
553           current unit state to standard output.
554
555       is-failed PATTERN...
556           Check whether any of the specified units are in a "failed" state.
557           Returns an exit code 0 if at least one has failed, non-zero
558           otherwise. Unless --quiet is specified, this will also print the
559           current unit state to standard output.
560
561       status [PATTERN...|PID...]]
562           Show terse runtime status information about one or more units,
563           followed by most recent log data from the journal. If no units are
564           specified, show system status. If combined with --all, also show
565           the status of all units (subject to limitations specified with -t).
566           If a PID is passed, show information about the unit the process
567           belongs to.
568
569           This function is intended to generate human-readable output. If you
570           are looking for computer-parsable output, use show instead. By
571           default, this function only shows 10 lines of output and ellipsizes
572           lines to fit in the terminal window. This can be changed with
573           --lines and --full, see above. In addition, journalctl --unit=NAME
574           or journalctl --user-unit=NAME use a similar filter for messages
575           and might be more convenient.
576
577           systemd implicitly loads units as necessary, so just running the
578           status will attempt to load a file. The command is thus not useful
579           for determining if something was already loaded or not. The units
580           may possibly also be quickly unloaded after the operation is
581           completed if there's no reason to keep it in memory thereafter.
582
583           Example 1. Example output from systemctl status
584
585               $ systemctl status bluetooth
586               ● bluetooth.service - Bluetooth service
587                  Loaded: loaded (/usr/lib/systemd/system/bluetooth.service; enabled; vendor preset: enabled)
588                  Active: active (running) since Wed 2017-01-04 13:54:04 EST; 1 weeks 0 days ago
589                    Docs: man:bluetoothd(8)
590                Main PID: 930 (bluetoothd)
591                  Status: "Running"
592                   Tasks: 1
593                  Memory: 648.0K
594                     CPU: 435ms
595                  CGroup: /system.slice/bluetooth.service
596                          └─930 /usr/lib/bluetooth/bluetoothd
597
598               Jan 12 10:46:45 example.com bluetoothd[8900]: Not enough free handles to register service
599               Jan 12 10:46:45 example.com bluetoothd[8900]: Current Time Service could not be registered
600               Jan 12 10:46:45 example.com bluetoothd[8900]: gatt-time-server: Input/output error (5)
601
602           The dot ("●") uses color on supported terminals to summarize the
603           unit state at a glance. White indicates an "inactive" or
604           "deactivating" state. Red indicates a "failed" or "error" state and
605           green indicates an "active", "reloading" or "activating" state.
606
607           The "Loaded:" line in the output will show "loaded" if the unit has
608           been loaded into memory. Other possible values for "Loaded:"
609           include: "error" if there was a problem loading it, "not-found" if
610           not unit file was found for this unit, "bad-setting" if an
611           essential unit file setting could not be parsed and "masked" if the
612           unit file has been masked. Along with showing the path to the unit
613           file, this line will also show the enablement state. Enabled
614           commands start at boot. See the full table of possible enablement
615           states — including the definition of "masked" — in the
616           documentation for the is-enabled command.
617
618           The "Active:" line shows active state. The value is usually
619           "active" or "inactive". Active could mean started, bound, plugged
620           in, etc depending on the unit type. The unit could also be in
621           process of changing states, reporting a state of "activating" or
622           "deactivating". A special "failed" state is entered when the
623           service failed in some way, such as a crash, exiting with an error
624           code or timing out. If the failed state is entered the cause will
625           be logged for later reference.
626
627       show [PATTERN...|JOB...]
628           Show properties of one or more units, jobs, or the manager itself.
629           If no argument is specified, properties of the manager will be
630           shown. If a unit name is specified, properties of the unit are
631           shown, and if a job ID is specified, properties of the job are
632           shown. By default, empty properties are suppressed. Use --all to
633           show those too. To select specific properties to show, use
634           --property=. This command is intended to be used whenever
635           computer-parsable output is required. Use status if you are looking
636           for formatted human-readable output.
637
638           Many properties shown by systemctl show map directly to
639           configuration settings of the system and service manager and its
640           unit files. Note that the properties shown by the command are
641           generally more low-level, normalized versions of the original
642           configuration settings and expose runtime state in addition to
643           configuration. For example, properties shown for service units
644           include the service's current main process identifier as "MainPID"
645           (which is runtime state), and time settings are always exposed as
646           properties ending in the "...USec" suffix even if a matching
647           configuration options end in "...Sec", because microseconds is the
648           normalized time unit used by the system and service manager.
649
650       cat PATTERN...
651           Show backing files of one or more units. Prints the "fragment" and
652           "drop-ins" (source files) of units. Each file is preceded by a
653           comment which includes the file name. Note that this shows the
654           contents of the backing files on disk, which may not match the
655           system manager's understanding of these units if any unit files
656           were updated on disk and the daemon-reload command wasn't issued
657           since.
658
659       set-property UNIT PROPERTY=VALUE...
660           Set the specified unit properties at runtime where this is
661           supported. This allows changing configuration parameter properties
662           such as resource control settings at runtime. Not all properties
663           may be changed at runtime, but many resource control settings
664           (primarily those in systemd.resource-control(5)) may. The changes
665           are applied immediately, and stored on disk for future boots,
666           unless --runtime is passed, in which case the settings only apply
667           until the next reboot. The syntax of the property assignment
668           follows closely the syntax of assignments in unit files.
669
670           Example: systemctl set-property foobar.service CPUShares=777
671
672           If the specified unit appears to be inactive, the changes will be
673           only stored on disk as described previously hence they will be
674           effective when the unit will be started.
675
676           Note that this command allows changing multiple properties at the
677           same time, which is preferable over setting them individually. Like
678           with unit file configuration settings, assigning an empty list will
679           reset the property.
680
681       help PATTERN...|PID...
682           Show manual pages for one or more units, if available. If a PID is
683           given, the manual pages for the unit the process belongs to are
684           shown.
685
686       reset-failed [PATTERN...]
687           Reset the "failed" state of the specified units, or if no unit name
688           is passed, reset the state of all units. When a unit fails in some
689           way (i.e. process exiting with non-zero error code, terminating
690           abnormally or timing out), it will automatically enter the "failed"
691           state and its exit code and status is recorded for introspection by
692           the administrator until the service is stopped/re-started or reset
693           with this command.
694
695       list-dependencies [UNIT]
696           Shows units required and wanted by the specified unit. This
697           recursively lists units following the Requires=, Requisite=,
698           ConsistsOf=, Wants=, BindsTo= dependencies. If no unit is
699           specified, default.target is implied.
700
701           By default, only target units are recursively expanded. When --all
702           is passed, all other units are recursively expanded as well.
703
704           Options --reverse, --after, --before may be used to change what
705           types of dependencies are shown.
706
707   Unit File Commands
708       list-unit-files [PATTERN...]
709           List unit files installed on the system, in combination with their
710           enablement state (as reported by is-enabled). If one or more
711           PATTERNs are specified, only unit files whose name matches one of
712           them are shown (patterns matching unit file system paths are not
713           supported).
714
715       enable UNIT..., enable PATH...
716           Enable one or more units or unit instances. This will create a set
717           of symlinks, as encoded in the "[Install]" sections of the
718           indicated unit files. After the symlinks have been created, the
719           system manager configuration is reloaded (in a way equivalent to
720           daemon-reload), in order to ensure the changes are taken into
721           account immediately. Note that this does not have the effect of
722           also starting any of the units being enabled. If this is desired,
723           combine this command with the --now switch, or invoke start with
724           appropriate arguments later. Note that in case of unit instance
725           enablement (i.e. enablement of units of the form foo@bar.service),
726           symlinks named the same as instances are created in the unit
727           configuration directory, however they point to the single template
728           unit file they are instantiated from.
729
730           This command expects either valid unit names (in which case various
731           unit file directories are automatically searched for unit files
732           with appropriate names), or absolute paths to unit files (in which
733           case these files are read directly). If a specified unit file is
734           located outside of the usual unit file directories, an additional
735           symlink is created, linking it into the unit configuration path,
736           thus ensuring it is found when requested by commands such as start.
737           The file system where the linked unit files are located must be
738           accessible when systemd is started (e.g. anything underneath /home
739           or /var is not allowed, unless those directories are located on the
740           root file system).
741
742           This command will print the file system operations executed. This
743           output may be suppressed by passing --quiet.
744
745           Note that this operation creates only the symlinks suggested in the
746           "[Install]" section of the unit files. While this command is the
747           recommended way to manipulate the unit configuration directory, the
748           administrator is free to make additional changes manually by
749           placing or removing symlinks below this directory. This is
750           particularly useful to create configurations that deviate from the
751           suggested default installation. In this case, the administrator
752           must make sure to invoke daemon-reload manually as necessary, in
753           order to ensure the changes are taken into account.
754
755           Enabling units should not be confused with starting (activating)
756           units, as done by the start command. Enabling and starting units is
757           orthogonal: units may be enabled without being started and started
758           without being enabled. Enabling simply hooks the unit into various
759           suggested places (for example, so that the unit is automatically
760           started on boot or when a particular kind of hardware is plugged
761           in). Starting actually spawns the daemon process (in case of
762           service units), or binds the socket (in case of socket units), and
763           so on.
764
765           Depending on whether --system, --user, --runtime, or --global is
766           specified, this enables the unit for the system, for the calling
767           user only, for only this boot of the system, or for all future
768           logins of all users. Note that in the last case, no systemd daemon
769           configuration is reloaded.
770
771           Using enable on masked units is not supported and results in an
772           error.
773
774       disable UNIT...
775           Disables one or more units. This removes all symlinks to the unit
776           files backing the specified units from the unit configuration
777           directory, and hence undoes any changes made by enable or link.
778           Note that this removes all symlinks to matching unit files,
779           including manually created symlinks, and not just those actually
780           created by enable or link. Note that while disable undoes the
781           effect of enable, the two commands are otherwise not symmetric, as
782           disable may remove more symlinks than a prior enable invocation of
783           the same unit created.
784
785           This command expects valid unit names only, it does not accept
786           paths to unit files.
787
788           In addition to the units specified as arguments, all units are
789           disabled that are listed in the Also= setting contained in the
790           "[Install]" section of any of the unit files being operated on.
791
792           This command implicitly reloads the system manager configuration
793           after completing the operation. Note that this command does not
794           implicitly stop the units that are being disabled. If this is
795           desired, either combine this command with the --now switch, or
796           invoke the stop command with appropriate arguments later.
797
798           This command will print information about the file system
799           operations (symlink removals) executed. This output may be
800           suppressed by passing --quiet.
801
802           This command honors --system, --user, --runtime and --global in a
803           similar way as enable.
804
805       reenable UNIT...
806           Reenable one or more units, as specified on the command line. This
807           is a combination of disable and enable and is useful to reset the
808           symlinks a unit file is enabled with to the defaults configured in
809           its "[Install]" section. This command expects a unit name only, it
810           does not accept paths to unit files.
811
812       preset UNIT...
813           Reset the enable/disable status one or more unit files, as
814           specified on the command line, to the defaults configured in the
815           preset policy files. This has the same effect as disable or enable,
816           depending how the unit is listed in the preset files.
817
818           Use --preset-mode= to control whether units shall be enabled and
819           disabled, or only enabled, or only disabled.
820
821           If the unit carries no install information, it will be silently
822           ignored by this command.  UNIT must be the real unit name, any
823           alias names are ignored silently.
824
825           For more information on the preset policy format, see
826           systemd.preset(5). For more information on the concept of presets,
827           please consult the Preset[1] document.
828
829       preset-all
830           Resets all installed unit files to the defaults configured in the
831           preset policy file (see above).
832
833           Use --preset-mode= to control whether units shall be enabled and
834           disabled, or only enabled, or only disabled.
835
836       is-enabled UNIT...
837           Checks whether any of the specified unit files are enabled (as with
838           enable). Returns an exit code of 0 if at least one is enabled,
839           non-zero otherwise. Prints the current enable status (see table).
840           To suppress this output, use --quiet. To show installation targets,
841           use --full.
842
843           Table 1.  is-enabled output
844           ┌──────────────────┬─────────────────────────┬───────────┐
845Name              Description             Exit Code 
846           ├──────────────────┼─────────────────────────┼───────────┤
847           │"enabled"         │ Enabled via             │           │
848           ├──────────────────┤ .wants/, .requires/     │           │
849           │"enabled-runtime" │ or Alias= symlinks      │           │
850           │                  │ (permanently in         │ 0         │
851           │                  │ /etc/systemd/system/,   │           │
852           │                  │ or transiently in       │           │
853           │                  │ /run/systemd/system/).  │           │
854           ├──────────────────┼─────────────────────────┼───────────┤
855           │"linked"          │ Made available through  │           │
856           ├──────────────────┤ one or more symlinks    │           │
857           │"linked-runtime"  │ to the unit file        │           │
858           │                  │ (permanently in         │           │
859           │                  │ /etc/systemd/system/    │           │
860           │                  │ or transiently in       │ > 0       │
861           │                  │ /run/systemd/system/),  │           │
862           │                  │ even though the unit    │           │
863           │                  │ file might reside       │           │
864           │                  │ outside of the unit     │           │
865           │                  │ file search path.       │           │
866           ├──────────────────┼─────────────────────────┼───────────┤
867           │"masked"          │ Completely disabled,    │           │
868           ├──────────────────┤ so that any start       │           │
869           │"masked-runtime"  │ operation on it fails   │           │
870           │                  │ (permanently in         │ > 0       │
871           │                  │ /etc/systemd/system/    │           │
872           │                  │ or transiently in       │           │
873           │                  │ /run/systemd/systemd/). │           │
874           ├──────────────────┼─────────────────────────┼───────────┤
875           │"static"          │ The unit file is not    │ 0         │
876           │                  │ enabled, and has no     │           │
877           │                  │ provisions for enabling │           │
878           │                  │ in the "[Install]" unit │           │
879           │                  │ file section.           │           │
880           ├──────────────────┼─────────────────────────┼───────────┤
881           │"indirect"        │ The unit file itself is │ 0         │
882           │                  │ not enabled, but it has │           │
883           │                  │ a non-empty Also=       │           │
884           │                  │ setting in the          │           │
885           │                  │ "[Install]" unit file   │           │
886           │                  │ section, listing other  │           │
887           │                  │ unit files that might   │           │
888           │                  │ be enabled, or it has   │           │
889           │                  │ an alias under a        │           │
890           │                  │ different name through  │           │
891           │                  │ a symlink that is not   │           │
892           │                  │ specified in Also=. For │           │
893           │                  │ template unit file, an  │           │
894           │                  │ instance different than │           │
895           │                  │ the one specified in    │           │
896           │                  │ DefaultInstance= is     │           │
897           │                  │ enabled.                │           │
898           ├──────────────────┼─────────────────────────┼───────────┤
899           │"disabled"        │ The unit file is not    │ > 0       │
900           │                  │ enabled, but contains   │           │
901           │                  │ an "[Install]" section  │           │
902           │                  │ with installation       │           │
903           │                  │ instructions.           │           │
904           ├──────────────────┼─────────────────────────┼───────────┤
905           │"generated"       │ The unit file was       │ 0         │
906           │                  │ generated dynamically   │           │
907           │                  │ via a generator tool.   │           │
908           │                  │ See                     │           │
909           │                  │ systemd.generator(7).   │           │
910           │                  │ Generated unit files    │           │
911           │                  │ may not be enabled,     │           │
912           │                  │ they are enabled        │           │
913           │                  │ implicitly by their     │           │
914           │                  │ generator.              │           │
915           ├──────────────────┼─────────────────────────┼───────────┤
916           │"transient"       │ The unit file has been  │ 0         │
917           │                  │ created dynamically     │           │
918           │                  │ with the runtime API.   │           │
919           │                  │ Transient units may not │           │
920           │                  │ be enabled.             │           │
921           ├──────────────────┼─────────────────────────┼───────────┤
922           │"bad"             │ The unit file is        │ > 0       │
923           │                  │ invalid or another      │           │
924           │                  │ error occurred. Note    │           │
925           │                  │ that is-enabled will    │           │
926           │                  │ not actually return     │           │
927           │                  │ this state, but print   │           │
928           │                  │ an error message        │           │
929           │                  │ instead. However the    │           │
930           │                  │ unit file listing       │           │
931           │                  │ printed by              │           │
932           │                  │ list-unit-files might   │           │
933           │                  │ show it.                │           │
934           └──────────────────┴─────────────────────────┴───────────┘
935
936       mask UNIT...
937           Mask one or more units, as specified on the command line. This will
938           link these unit files to /dev/null, making it impossible to start
939           them. This is a stronger version of disable, since it prohibits all
940           kinds of activation of the unit, including enablement and manual
941           activation. Use this option with care. This honors the --runtime
942           option to only mask temporarily until the next reboot of the
943           system. The --now option may be used to ensure that the units are
944           also stopped. This command expects valid unit names only, it does
945           not accept unit file paths.
946
947       unmask UNIT...
948           Unmask one or more unit files, as specified on the command line.
949           This will undo the effect of mask. This command expects valid unit
950           names only, it does not accept unit file paths.
951
952       link PATH...
953           Link a unit file that is not in the unit file search paths into the
954           unit file search path. This command expects an absolute path to a
955           unit file. The effect of this may be undone with disable. The
956           effect of this command is that a unit file is made available for
957           commands such as start, even though it is not installed directly in
958           the unit search path. The file system where the linked unit files
959           are located must be accessible when systemd is started (e.g.
960           anything underneath /home or /var is not allowed, unless those
961           directories are located on the root file system).
962
963       revert UNIT...
964           Revert one or more unit files to their vendor versions. This
965           command removes drop-in configuration files that modify the
966           specified units, as well as any user-configured unit file that
967           overrides a matching vendor supplied unit file. Specifically, for a
968           unit "foo.service" the matching directories "foo.service.d/" with
969           all their contained files are removed, both below the persistent
970           and runtime configuration directories (i.e. below
971           /etc/systemd/system and /run/systemd/system); if the unit file has
972           a vendor-supplied version (i.e. a unit file located below /usr) any
973           matching persistent or runtime unit file that overrides it is
974           removed, too. Note that if a unit file has no vendor-supplied
975           version (i.e. is only defined below /etc/systemd/system or
976           /run/systemd/system, but not in a unit file stored below /usr),
977           then it is not removed. Also, if a unit is masked, it is unmasked.
978
979           Effectively, this command may be used to undo all changes made with
980           systemctl edit, systemctl set-property and systemctl mask and puts
981           the original unit file with its settings back in effect.
982
983       add-wants TARGET UNIT..., add-requires TARGET UNIT...
984           Adds "Wants=" or "Requires=" dependencies, respectively, to the
985           specified TARGET for one or more units.
986
987           This command honors --system, --user, --runtime and --global in a
988           way similar to enable.
989
990       edit UNIT...
991           Edit a drop-in snippet or a whole replacement file if --full is
992           specified, to extend or override the specified unit.
993
994           Depending on whether --system (the default), --user, or --global is
995           specified, this command creates a drop-in file for each unit either
996           for the system, for the calling user, or for all futures logins of
997           all users. Then, the editor (see the "Environment" section below)
998           is invoked on temporary files which will be written to the real
999           location if the editor exits successfully.
1000
1001           If --full is specified, this will copy the original units instead
1002           of creating drop-in files.
1003
1004           If --force is specified and any units do not already exist, new
1005           unit files will be opened for editing.
1006
1007           If --runtime is specified, the changes will be made temporarily in
1008           /run and they will be lost on the next reboot.
1009
1010           If the temporary file is empty upon exit, the modification of the
1011           related unit is canceled.
1012
1013           After the units have been edited, systemd configuration is reloaded
1014           (in a way that is equivalent to daemon-reload).
1015
1016           Note that this command cannot be used to remotely edit units and
1017           that you cannot temporarily edit units which are in /etc, since
1018           they take precedence over /run.
1019
1020       get-default
1021           Return the default target to boot into. This returns the target
1022           unit name default.target is aliased (symlinked) to.
1023
1024       set-default TARGET
1025           Set the default target to boot into. This sets (symlinks) the
1026           default.target alias to the given target unit.
1027
1028   Machine Commands
1029       list-machines [PATTERN...]
1030           List the host and all running local containers with their state. If
1031           one or more PATTERNs are specified, only containers matching one of
1032           them are shown.
1033
1034   Job Commands
1035       list-jobs [PATTERN...]
1036           List jobs that are in progress. If one or more PATTERNs are
1037           specified, only jobs for units matching one of them are shown.
1038
1039           When combined with --after or --before the list is augmented with
1040           information on which other job each job is waiting for, and which
1041           other jobs are waiting for it, see above.
1042
1043       cancel JOB...
1044           Cancel one or more jobs specified on the command line by their
1045           numeric job IDs. If no job ID is specified, cancel all pending
1046           jobs.
1047
1048   Environment Commands
1049       show-environment
1050           Dump the systemd manager environment block. This is the environment
1051           block that is passed to all processes the manager spawns. The
1052           environment block will be dumped in straight-forward form suitable
1053           for sourcing into most shells. If no special characters or
1054           whitespace is present in the variable values, no escaping is
1055           performed, and the assignments have the form "VARIABLE=value". If
1056           whitespace or characters which have special meaning to the shell
1057           are present, dollar-single-quote escaping is used, and assignments
1058           have the form "VARIABLE=$'value'". This syntax is known to be
1059           supported by bash(1), zsh(1), ksh(1), and busybox(1)'s ash(1), but
1060           not dash(1) or fish(1).
1061
1062       set-environment VARIABLE=VALUE...
1063           Set one or more systemd manager environment variables, as specified
1064           on the command line.
1065
1066       unset-environment VARIABLE...
1067           Unset one or more systemd manager environment variables. If only a
1068           variable name is specified, it will be removed regardless of its
1069           value. If a variable and a value are specified, the variable is
1070           only removed if it has the specified value.
1071
1072       import-environment [VARIABLE...]
1073           Import all, one or more environment variables set on the client
1074           into the systemd manager environment block. If no arguments are
1075           passed, the entire environment block is imported. Otherwise, a list
1076           of one or more environment variable names should be passed, whose
1077           client-side values are then imported into the manager's environment
1078           block.
1079
1080   Manager Lifecycle Commands
1081       daemon-reload
1082           Reload the systemd manager configuration. This will rerun all
1083           generators (see systemd.generator(7)), reload all unit files, and
1084           recreate the entire dependency tree. While the daemon is being
1085           reloaded, all sockets systemd listens on behalf of user
1086           configuration will stay accessible.
1087
1088           This command should not be confused with the reload command.
1089
1090       daemon-reexec
1091           Reexecute the systemd manager. This will serialize the manager
1092           state, reexecute the process and deserialize the state again. This
1093           command is of little use except for debugging and package upgrades.
1094           Sometimes, it might be helpful as a heavy-weight daemon-reload.
1095           While the daemon is being reexecuted, all sockets systemd listening
1096           on behalf of user configuration will stay accessible.
1097
1098   System Commands
1099       is-system-running
1100           Checks whether the system is operational. This returns success
1101           (exit code 0) when the system is fully up and running, specifically
1102           not in startup, shutdown or maintenance mode, and with no failed
1103           services. Failure is returned otherwise (exit code non-zero). In
1104           addition, the current state is printed in a short string to
1105           standard output, see the table below. Use --quiet to suppress this
1106           output.
1107
1108           Table 2. is-system-running output
1109           ┌─────────────┬─────────────────────┬───────────┐
1110Name         Description         Exit Code 
1111           ├─────────────┼─────────────────────┼───────────┤
1112initializing │ Early bootup,       │ > 0       │
1113           │             │ before basic.target │           │
1114           │             │ is reached or the   │           │
1115           │             │ maintenance state   │           │
1116           │             │ entered.            │           │
1117           ├─────────────┼─────────────────────┼───────────┤
1118starting     │ Late bootup, before │ > 0       │
1119           │             │ the job queue       │           │
1120           │             │ becomes idle for    │           │
1121           │             │ the first time, or  │           │
1122           │             │ one of the rescue   │           │
1123           │             │ targets are         │           │
1124           │             │ reached.            │           │
1125           ├─────────────┼─────────────────────┼───────────┤
1126running      │ The system is fully │ 0         │
1127           │             │ operational.        │           │
1128           ├─────────────┼─────────────────────┼───────────┤
1129degraded     │ The system is       │ > 0       │
1130           │             │ operational but one │           │
1131           │             │ or more units       │           │
1132           │             │ failed.             │           │
1133           ├─────────────┼─────────────────────┼───────────┤
1134maintenance  │ The rescue or       │ > 0       │
1135           │             │ emergency target is │           │
1136           │             │ active.             │           │
1137           ├─────────────┼─────────────────────┼───────────┤
1138stopping     │ The manager is      │ > 0       │
1139           │             │ shutting down.      │           │
1140           ├─────────────┼─────────────────────┼───────────┤
1141offline      │ The manager is not  │ > 0       │
1142           │             │ running.            │           │
1143           │             │ Specifically, this  │           │
1144           │             │ is the operational  │           │
1145           │             │ state if an         │           │
1146           │             │ incompatible        │           │
1147           │             │ program is running  │           │
1148           │             │ as system manager   │           │
1149           │             │ (PID 1).            │           │
1150           ├─────────────┼─────────────────────┼───────────┤
1151unknown      │ The operational     │ > 0       │
1152           │             │ state could not be  │           │
1153           │             │ determined, due to  │           │
1154           │             │ lack of resources   │           │
1155           │             │ or another error    │           │
1156           │             │ cause.              │           │
1157           └─────────────┴─────────────────────┴───────────┘
1158
1159       default
1160           Enter default mode. This is equivalent to systemctl isolate
1161           default.target. This operation is blocking by default, use
1162           --no-block to request asynchronous behavior.
1163
1164       rescue
1165           Enter rescue mode. This is equivalent to systemctl isolate
1166           rescue.target. This operation is blocking by default, use
1167           --no-block to request asynchronous behavior.
1168
1169       emergency
1170           Enter emergency mode. This is equivalent to systemctl isolate
1171           emergency.target. This operation is blocking by default, use
1172           --no-block to request asynchronous behavior.
1173
1174       halt
1175           Shut down and halt the system. This is mostly equivalent to
1176           systemctl start halt.target --job-mode=replace-irreversibly
1177           --no-block, but also prints a wall message to all users. This
1178           command is asynchronous; it will return after the halt operation is
1179           enqueued, without waiting for it to complete. Note that this
1180           operation will simply halt the OS kernel after shutting down,
1181           leaving the hardware powered on. Use systemctl poweroff for
1182           powering off the system (see below).
1183
1184           If combined with --force, shutdown of all running services is
1185           skipped, however all processes are killed and all file systems are
1186           unmounted or mounted read-only, immediately followed by the system
1187           halt. If --force is specified twice, the operation is immediately
1188           executed without terminating any processes or unmounting any file
1189           systems. This may result in data loss. Note that when --force is
1190           specified twice the halt operation is executed by systemctl itself,
1191           and the system manager is not contacted. This means the command
1192           should succeed even when the system manager has crashed.
1193
1194       poweroff
1195           Shut down and power-off the system. This is mostly equivalent to
1196           systemctl start poweroff.target --job-mode=replace-irreversibly
1197           --no-block, but also prints a wall message to all users. This
1198           command is asynchronous; it will return after the power-off
1199           operation is enqueued, without waiting for it to complete.
1200
1201           If combined with --force, shutdown of all running services is
1202           skipped, however all processes are killed and all file systems are
1203           unmounted or mounted read-only, immediately followed by the
1204           powering off. If --force is specified twice, the operation is
1205           immediately executed without terminating any processes or
1206           unmounting any file systems. This may result in data loss. Note
1207           that when --force is specified twice the power-off operation is
1208           executed by systemctl itself, and the system manager is not
1209           contacted. This means the command should succeed even when the
1210           system manager has crashed.
1211
1212       reboot [arg]
1213           Shut down and reboot the system. This is mostly equivalent to
1214           systemctl start reboot.target --job-mode=replace-irreversibly
1215           --no-block, but also prints a wall message to all users. This
1216           command is asynchronous; it will return after the reboot operation
1217           is enqueued, without waiting for it to complete.
1218
1219           If combined with --force, shutdown of all running services is
1220           skipped, however all processes are killed and all file systems are
1221           unmounted or mounted read-only, immediately followed by the reboot.
1222           If --force is specified twice, the operation is immediately
1223           executed without terminating any processes or unmounting any file
1224           systems. This may result in data loss. Note that when --force is
1225           specified twice the reboot operation is executed by systemctl
1226           itself, and the system manager is not contacted. This means the
1227           command should succeed even when the system manager has crashed.
1228
1229           If the optional argument arg is given, it will be passed as the
1230           optional argument to the reboot(2) system call. The value is
1231           architecture and firmware specific. As an example, "recovery" might
1232           be used to trigger system recovery, and "fota" might be used to
1233           trigger a “firmware over the air” update.
1234
1235       kexec
1236           Shut down and reboot the system via kexec. This is equivalent to
1237           systemctl start kexec.target --job-mode=replace-irreversibly
1238           --no-block. This command is asynchronous; it will return after the
1239           reboot operation is enqueued, without waiting for it to complete.
1240
1241           If combined with --force, shutdown of all running services is
1242           skipped, however all processes are killed and all file systems are
1243           unmounted or mounted read-only, immediately followed by the reboot.
1244
1245       exit [EXIT_CODE]
1246           Ask the service manager to quit. This is only supported for user
1247           service managers (i.e. in conjunction with the --user option) or in
1248           containers and is equivalent to poweroff otherwise. This command is
1249           asynchronous; it will return after the exit operation is enqueued,
1250           without waiting for it to complete.
1251
1252           The service manager will exit with the specified exit code, if
1253           EXIT_CODE is passed.
1254
1255       switch-root ROOT [INIT]
1256           Switches to a different root directory and executes a new system
1257           manager process below it. This is intended for usage in initial RAM
1258           disks ("initrd"), and will transition from the initrd's system
1259           manager process (a.k.a. "init" process) to the main system manager
1260           process which is loaded from the actual host volume. This call
1261           takes two arguments: the directory that is to become the new root
1262           directory, and the path to the new system manager binary below it
1263           to execute as PID 1. If the latter is omitted or the empty string,
1264           a systemd binary will automatically be searched for and used as
1265           init. If the system manager path is omitted, equal to the empty
1266           string or identical to the path to the systemd binary, the state of
1267           the initrd's system manager process is passed to the main system
1268           manager, which allows later introspection of the state of the
1269           services involved in the initrd boot phase.
1270
1271       suspend
1272           Suspend the system. This will trigger activation of the special
1273           target unit suspend.target. This command is asynchronous, and will
1274           return after the suspend operation is successfully enqueued. It
1275           will not wait for the suspend/resume cycle to complete.
1276
1277       hibernate
1278           Hibernate the system. This will trigger activation of the special
1279           target unit hibernate.target. This command is asynchronous, and
1280           will return after the hibernation operation is successfully
1281           enqueued. It will not wait for the hibernate/thaw cycle to
1282           complete.
1283
1284       hybrid-sleep
1285           Hibernate and suspend the system. This will trigger activation of
1286           the special target unit hybrid-sleep.target. This command is
1287           asynchronous, and will return after the hybrid sleep operation is
1288           successfully enqueued. It will not wait for the sleep/wake-up cycle
1289           to complete.
1290
1291   Parameter Syntax
1292       Unit commands listed above take either a single unit name (designated
1293       as UNIT), or multiple unit specifications (designated as PATTERN...).
1294       In the first case, the unit name with or without a suffix must be
1295       given. If the suffix is not specified (unit name is "abbreviated"),
1296       systemctl will append a suitable suffix, ".service" by default, and a
1297       type-specific suffix in case of commands which operate only on specific
1298       unit types. For example,
1299
1300           # systemctl start sshd
1301
1302       and
1303
1304           # systemctl start sshd.service
1305
1306       are equivalent, as are
1307
1308           # systemctl isolate default
1309
1310       and
1311
1312           # systemctl isolate default.target
1313
1314       Note that (absolute) paths to device nodes are automatically converted
1315       to device unit names, and other (absolute) paths to mount unit names.
1316
1317           # systemctl status /dev/sda
1318           # systemctl status /home
1319
1320       are equivalent to:
1321
1322           # systemctl status dev-sda.device
1323           # systemctl status home.mount
1324
1325       In the second case, shell-style globs will be matched against the
1326       primary names of all units currently in memory; literal unit names,
1327       with or without a suffix, will be treated as in the first case. This
1328       means that literal unit names always refer to exactly one unit, but
1329       globs may match zero units and this is not considered an error.
1330
1331       Glob patterns use fnmatch(3), so normal shell-style globbing rules are
1332       used, and "*", "?", "[]" may be used. See glob(7) for more details. The
1333       patterns are matched against the primary names of units currently in
1334       memory, and patterns which do not match anything are silently skipped.
1335       For example:
1336
1337           # systemctl stop sshd@*.service
1338
1339       will stop all sshd@.service instances. Note that alias names of units,
1340       and units that aren't in memory are not considered for glob expansion.
1341
1342       For unit file commands, the specified UNIT should be the name of the
1343       unit file (possibly abbreviated, see above), or the absolute path to
1344       the unit file:
1345
1346           # systemctl enable foo.service
1347
1348       or
1349
1350           # systemctl link /path/to/foo.service
1351
1352

EXIT STATUS

1354       On success, 0 is returned, a non-zero failure code otherwise.
1355

ENVIRONMENT

1357       $SYSTEMD_EDITOR
1358           Editor to use when editing units; overrides $EDITOR and $VISUAL. If
1359           neither $SYSTEMD_EDITOR nor $EDITOR nor $VISUAL are present or if
1360           it is set to an empty string or if their execution failed,
1361           systemctl will try to execute well known editors in this order:
1362           editor(1), nano(1), vim(1), vi(1).
1363
1364       $SYSTEMD_PAGER
1365           Pager to use when --no-pager is not given; overrides $PAGER. If
1366           neither $SYSTEMD_PAGER nor $PAGER are set, a set of well-known
1367           pager implementations are tried in turn, including less(1) and
1368           more(1), until one is found. If no pager implementation is
1369           discovered no pager is invoked. Setting this environment variable
1370           to an empty string or the value "cat" is equivalent to passing
1371           --no-pager.
1372
1373       $SYSTEMD_LESS
1374           Override the options passed to less (by default "FRSXMK").
1375
1376       $SYSTEMD_LESSCHARSET
1377           Override the charset passed to less (by default "utf-8", if the
1378           invoking terminal is determined to be UTF-8 compatible).
1379

SEE ALSO

1381       systemd(1), journalctl(1), loginctl(1), machinectl(1), systemd.unit(5),
1382       systemd.resource-control(5), systemd.special(7), wall(1),
1383       systemd.preset(5), systemd.generator(7), glob(7)
1384

NOTES

1386        1. Preset
1387           https://www.freedesktop.org/wiki/Software/systemd/Preset
1388
1389
1390
1391systemd 239                                                       SYSTEMCTL(1)
Impressum