1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
25 #include <sys/epoll.h>
27 #include <sys/signalfd.h>
31 #include <sys/reboot.h>
32 #include <sys/ioctl.h>
36 #include <sys/types.h>
44 #include <systemd/sd-daemon.h>
47 #include "transaction.h"
54 #include "ratelimit.h"
56 #include "mount-setup.h"
57 #include "unit-name.h"
58 #include "dbus-unit.h"
61 #include "path-lookup.h"
63 #include "bus-errors.h"
64 #include "exit-status.h"
67 #include "cgroup-util.h"
68 #include "path-util.h"
70 /* As soon as 16 units are in our GC queue, make sure to run a gc sweep */
71 #define GC_QUEUE_ENTRIES_MAX 16
73 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
74 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
76 /* Where clients shall send notification messages to */
77 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
79 static int manager_setup_notify(Manager *m) {
82 struct sockaddr_un un;
84 struct epoll_event ev;
89 m->notify_watch.type = WATCH_NOTIFY;
90 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
91 if (m->notify_watch.fd < 0) {
92 log_error("Failed to allocate notification socket: %m");
97 sa.sa.sa_family = AF_UNIX;
100 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
102 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
104 sa.un.sun_path[0] = 0;
106 if (bind(m->notify_watch.fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
107 log_error("bind() failed: %m");
111 if (setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0) {
112 log_error("SO_PASSCRED failed: %m");
118 ev.data.ptr = &m->notify_watch;
120 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev) < 0)
123 sa.un.sun_path[0] = '@';
124 m->notify_socket = strdup(sa.un.sun_path);
125 if (!m->notify_socket)
128 log_debug("Using notification socket %s", m->notify_socket);
133 static int enable_special_signals(Manager *m) {
138 /* Enable that we get SIGINT on control-alt-del. In containers
139 * this will fail with EPERM, so ignore that. */
140 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM)
141 log_warning("Failed to enable ctrl-alt-del handling: %m");
143 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
145 /* Support systems without virtual console */
147 log_warning("Failed to open /dev/tty0: %m");
149 /* Enable that we get SIGWINCH on kbrequest */
150 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
151 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
153 close_nointr_nofail(fd);
159 static int manager_setup_signals(Manager *m) {
161 struct epoll_event ev;
166 /* We are not interested in SIGSTOP and friends. */
168 sa.sa_handler = SIG_DFL;
169 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
170 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
172 assert_se(sigemptyset(&mask) == 0);
174 sigset_add_many(&mask,
175 SIGCHLD, /* Child died */
176 SIGTERM, /* Reexecute daemon */
177 SIGHUP, /* Reload configuration */
178 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
179 SIGUSR2, /* systemd: dump status */
180 SIGINT, /* Kernel sends us this on control-alt-del */
181 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
182 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
183 SIGRTMIN+0, /* systemd: start default.target */
184 SIGRTMIN+1, /* systemd: isolate rescue.target */
185 SIGRTMIN+2, /* systemd: isolate emergency.target */
186 SIGRTMIN+3, /* systemd: start halt.target */
187 SIGRTMIN+4, /* systemd: start poweroff.target */
188 SIGRTMIN+5, /* systemd: start reboot.target */
189 SIGRTMIN+6, /* systemd: start kexec.target */
190 SIGRTMIN+13, /* systemd: Immediate halt */
191 SIGRTMIN+14, /* systemd: Immediate poweroff */
192 SIGRTMIN+15, /* systemd: Immediate reboot */
193 SIGRTMIN+16, /* systemd: Immediate kexec */
194 SIGRTMIN+20, /* systemd: enable status messages */
195 SIGRTMIN+21, /* systemd: disable status messages */
196 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
197 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
198 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
199 SIGRTMIN+27, /* systemd: set log target to console */
200 SIGRTMIN+28, /* systemd: set log target to kmsg */
201 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
203 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
205 m->signal_watch.type = WATCH_SIGNAL;
206 if ((m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC)) < 0)
211 ev.data.ptr = &m->signal_watch;
213 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
216 if (m->running_as == MANAGER_SYSTEM)
217 return enable_special_signals(m);
222 static void manager_strip_environment(Manager *m) {
225 /* Remove variables from the inherited set that are part of
226 * the container interface:
227 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
228 strv_remove_prefix(m->environment, "container=");
229 strv_remove_prefix(m->environment, "container_");
231 /* Remove variables from the inherited set that are part of
232 * the initrd interface:
233 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
234 strv_remove_prefix(m->environment, "RD_");
237 int manager_new(ManagerRunningAs running_as, Manager **_m) {
242 assert(running_as >= 0);
243 assert(running_as < _MANAGER_RUNNING_AS_MAX);
245 if (!(m = new0(Manager, 1)))
248 dual_timestamp_get(&m->startup_timestamp);
250 m->running_as = running_as;
251 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
252 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
253 m->pin_cgroupfs_fd = -1;
254 m->idle_pipe[0] = m->idle_pipe[1] = -1;
260 m->signal_watch.fd = m->mount_watch.fd = m->udev_watch.fd = m->epoll_fd = m->dev_autofs_fd = m->swap_watch.fd = -1;
261 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
263 m->environment = strv_copy(environ);
267 manager_strip_environment(m);
269 if (running_as == MANAGER_SYSTEM) {
270 m->default_controllers = strv_new("cpu", NULL);
271 if (!m->default_controllers)
275 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
278 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
281 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
284 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
287 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
290 if ((m->epoll_fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
293 if ((r = manager_setup_signals(m)) < 0)
296 if ((r = manager_setup_cgroup(m)) < 0)
299 if ((r = manager_setup_notify(m)) < 0)
302 /* Try to connect to the busses, if possible. */
303 if ((r = bus_init(m, running_as != MANAGER_SYSTEM)) < 0)
307 if ((m->audit_fd = audit_open()) < 0 &&
308 /* If the kernel lacks netlink or audit support,
309 * don't worry about it. */
310 errno != EAFNOSUPPORT && errno != EPROTONOSUPPORT)
311 log_error("Failed to connect to audit log: %m");
314 m->taint_usr = dir_is_empty("/usr") > 0;
324 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
330 while ((u = m->cleanup_queue)) {
331 assert(u->in_cleanup_queue);
341 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
342 GC_OFFSET_UNSURE, /* No clue */
343 GC_OFFSET_GOOD, /* We still need this unit */
344 GC_OFFSET_BAD, /* We don't need this unit anymore */
348 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
355 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
356 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
357 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
360 if (u->in_cleanup_queue)
363 if (unit_check_gc(u))
366 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
370 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
371 unit_gc_sweep(other, gc_marker);
373 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
376 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
383 /* We were unable to find anything out about this entry, so
384 * let's investigate it later */
385 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
386 unit_add_to_gc_queue(u);
390 /* We definitely know that this one is not useful anymore, so
391 * let's mark it for deletion */
392 u->gc_marker = gc_marker + GC_OFFSET_BAD;
393 unit_add_to_cleanup_queue(u);
397 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
400 static unsigned manager_dispatch_gc_queue(Manager *m) {
407 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
408 (m->gc_queue_timestamp <= 0 ||
409 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
412 log_debug("Running GC...");
414 m->gc_marker += _GC_OFFSET_MAX;
415 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
418 gc_marker = m->gc_marker;
420 while ((u = m->gc_queue)) {
421 assert(u->in_gc_queue);
423 unit_gc_sweep(u, gc_marker);
425 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
426 u->in_gc_queue = false;
430 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
431 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
432 log_debug("Collecting %s", u->id);
433 u->gc_marker = gc_marker + GC_OFFSET_BAD;
434 unit_add_to_cleanup_queue(u);
438 m->n_in_gc_queue = 0;
439 m->gc_queue_timestamp = 0;
444 static void manager_clear_jobs_and_units(Manager *m) {
449 while ((u = hashmap_first(m->units)))
452 manager_dispatch_cleanup_queue(m);
454 assert(!m->load_queue);
455 assert(!m->run_queue);
456 assert(!m->dbus_unit_queue);
457 assert(!m->dbus_job_queue);
458 assert(!m->cleanup_queue);
459 assert(!m->gc_queue);
461 assert(hashmap_isempty(m->jobs));
462 assert(hashmap_isempty(m->units));
465 void manager_free(Manager *m) {
471 manager_clear_jobs_and_units(m);
473 for (c = 0; c < _UNIT_TYPE_MAX; c++)
474 if (unit_vtable[c]->shutdown)
475 unit_vtable[c]->shutdown(m);
477 /* If we reexecute ourselves, we keep the root cgroup
479 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
481 manager_undo_generators(m);
485 hashmap_free(m->units);
486 hashmap_free(m->jobs);
487 hashmap_free(m->watch_pids);
488 hashmap_free(m->watch_bus);
490 if (m->epoll_fd >= 0)
491 close_nointr_nofail(m->epoll_fd);
492 if (m->signal_watch.fd >= 0)
493 close_nointr_nofail(m->signal_watch.fd);
494 if (m->notify_watch.fd >= 0)
495 close_nointr_nofail(m->notify_watch.fd);
498 if (m->audit_fd >= 0)
499 audit_close(m->audit_fd);
502 free(m->notify_socket);
504 lookup_paths_free(&m->lookup_paths);
505 strv_free(m->environment);
507 strv_free(m->default_controllers);
509 hashmap_free(m->cgroup_bondings);
510 set_free_free(m->unit_path_cache);
512 close_pipe(m->idle_pipe);
514 free(m->switch_root);
515 free(m->switch_root_init);
517 for (i = 0; i < RLIMIT_NLIMITS; i++)
523 int manager_enumerate(Manager *m) {
529 /* Let's ask every type to load all units from disk/kernel
530 * that it might know */
531 for (c = 0; c < _UNIT_TYPE_MAX; c++)
532 if (unit_vtable[c]->enumerate)
533 if ((q = unit_vtable[c]->enumerate(m)) < 0)
536 manager_dispatch_load_queue(m);
540 int manager_coldplug(Manager *m) {
548 /* Then, let's set up their initial state. */
549 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
555 if ((q = unit_coldplug(u)) < 0)
562 static void manager_build_unit_path_cache(Manager *m) {
569 set_free_free(m->unit_path_cache);
571 if (!(m->unit_path_cache = set_new(string_hash_func, string_compare_func))) {
572 log_error("Failed to allocate unit path cache.");
576 /* This simply builds a list of files we know exist, so that
577 * we don't always have to go to disk */
579 STRV_FOREACH(i, m->lookup_paths.unit_path) {
582 if (!(d = opendir(*i))) {
583 log_error("Failed to open directory: %m");
587 while ((de = readdir(d))) {
590 if (ignore_file(de->d_name))
593 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
599 if ((r = set_put(m->unit_path_cache, p)) < 0) {
612 log_error("Failed to build unit path cache: %s", strerror(-r));
614 set_free_free(m->unit_path_cache);
615 m->unit_path_cache = NULL;
621 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
626 manager_run_generators(m);
628 r = lookup_paths_init(
629 &m->lookup_paths, m->running_as, true,
630 m->generator_unit_path,
631 m->generator_unit_path_early,
632 m->generator_unit_path_late);
636 manager_build_unit_path_cache(m);
638 /* If we will deserialize make sure that during enumeration
639 * this is already known, so we increase the counter here
644 /* First, enumerate what we can from all config files */
645 r = manager_enumerate(m);
647 /* Second, deserialize if there is something to deserialize */
649 q = manager_deserialize(m, serialization, fds);
654 /* Third, fire things up! */
655 q = manager_coldplug(m);
660 assert(m->n_reloading > 0);
667 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
672 assert(type < _JOB_TYPE_MAX);
674 assert(mode < _JOB_MODE_MAX);
676 if (mode == JOB_ISOLATE && type != JOB_START) {
677 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
681 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
682 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
686 log_debug("Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
688 job_type_collapse(&type, unit);
690 tr = transaction_new();
694 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
695 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
696 mode == JOB_IGNORE_DEPENDENCIES, e);
700 if (mode == JOB_ISOLATE) {
701 r = transaction_add_isolate_jobs(tr, m);
706 r = transaction_activate(tr, m, mode, e);
710 log_debug("Enqueued job %s/%s as %u", unit->id, job_type_to_string(type), (unsigned) tr->anchor_job->id);
713 *_ret = tr->anchor_job;
715 transaction_free(tr);
719 transaction_abort(tr);
720 transaction_free(tr);
724 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
729 assert(type < _JOB_TYPE_MAX);
731 assert(mode < _JOB_MODE_MAX);
733 if ((r = manager_load_unit(m, name, NULL, NULL, &unit)) < 0)
736 return manager_add_job(m, type, unit, mode, override, e, _ret);
739 Job *manager_get_job(Manager *m, uint32_t id) {
742 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
745 Unit *manager_get_unit(Manager *m, const char *name) {
749 return hashmap_get(m->units, name);
752 unsigned manager_dispatch_load_queue(Manager *m) {
758 /* Make sure we are not run recursively */
759 if (m->dispatching_load_queue)
762 m->dispatching_load_queue = true;
764 /* Dispatches the load queue. Takes a unit from the queue and
765 * tries to load its data until the queue is empty */
767 while ((u = m->load_queue)) {
768 assert(u->in_load_queue);
774 m->dispatching_load_queue = false;
778 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
784 assert(name || path);
786 /* This will prepare the unit for loading, but not actually
787 * load anything from disk. */
789 if (path && !is_path(path)) {
790 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
795 name = path_get_file_name(path);
797 t = unit_name_to_type(name);
799 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
800 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
804 ret = manager_get_unit(m, name);
810 ret = unit_new(m, unit_vtable[t]->object_size);
815 ret->fragment_path = strdup(path);
816 if (!ret->fragment_path) {
822 if ((r = unit_add_name(ret, name)) < 0) {
827 unit_add_to_load_queue(ret);
828 unit_add_to_dbus_queue(ret);
829 unit_add_to_gc_queue(ret);
837 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
842 /* This will load the service information files, but not actually
843 * start any services or anything. */
845 if ((r = manager_load_unit_prepare(m, name, path, e, _ret)) != 0)
848 manager_dispatch_load_queue(m);
851 *_ret = unit_follow_merge(*_ret);
856 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
863 HASHMAP_FOREACH(j, s->jobs, i)
864 job_dump(j, f, prefix);
867 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
875 HASHMAP_FOREACH_KEY(u, t, s->units, i)
877 unit_dump(u, f, prefix);
880 void manager_clear_jobs(Manager *m) {
885 while ((j = hashmap_first(m->jobs)))
886 /* No need to recurse. We're cancelling all jobs. */
887 job_finish_and_invalidate(j, JOB_CANCELED, false);
890 unsigned manager_dispatch_run_queue(Manager *m) {
894 if (m->dispatching_run_queue)
897 m->dispatching_run_queue = true;
899 while ((j = m->run_queue)) {
900 assert(j->installed);
901 assert(j->in_run_queue);
903 job_run_and_invalidate(j);
907 m->dispatching_run_queue = false;
911 unsigned manager_dispatch_dbus_queue(Manager *m) {
918 if (m->dispatching_dbus_queue)
921 m->dispatching_dbus_queue = true;
923 while ((u = m->dbus_unit_queue)) {
924 assert(u->in_dbus_queue);
926 bus_unit_send_change_signal(u);
930 while ((j = m->dbus_job_queue)) {
931 assert(j->in_dbus_queue);
933 bus_job_send_change_signal(j);
937 m->dispatching_dbus_queue = false;
941 static int manager_process_notify_fd(Manager *m) {
948 struct msghdr msghdr;
952 struct cmsghdr cmsghdr;
953 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
959 iovec.iov_base = buf;
960 iovec.iov_len = sizeof(buf)-1;
964 msghdr.msg_iov = &iovec;
965 msghdr.msg_iovlen = 1;
966 msghdr.msg_control = &control;
967 msghdr.msg_controllen = sizeof(control);
969 if ((n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT)) <= 0) {
973 if (errno == EAGAIN || errno == EINTR)
979 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
980 control.cmsghdr.cmsg_level != SOL_SOCKET ||
981 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
982 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
983 log_warning("Received notify message without credentials. Ignoring.");
987 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
989 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid))))
990 if (!(u = cgroup_unit_by_pid(m, ucred->pid))) {
991 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
995 assert((size_t) n < sizeof(buf));
997 if (!(tags = strv_split(buf, "\n\r")))
1000 log_debug("Got notification message for unit %s", u->id);
1002 if (UNIT_VTABLE(u)->notify_message)
1003 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1011 static int manager_dispatch_sigchld(Manager *m) {
1021 /* First we call waitd() for a PID and do not reap the
1022 * zombie. That way we can still access /proc/$PID for
1023 * it while it is a zombie. */
1024 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1026 if (errno == ECHILD)
1038 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1041 get_process_comm(si.si_pid, &name);
1042 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1046 /* Let's flush any message the dying child might still
1047 * have queued for us. This ensures that the process
1048 * still exists in /proc so that we can figure out
1049 * which cgroup and hence unit it belongs to. */
1050 if ((r = manager_process_notify_fd(m)) < 0)
1053 /* And now figure out the unit this belongs to */
1054 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid))))
1055 u = cgroup_unit_by_pid(m, si.si_pid);
1057 /* And now, we actually reap the zombie. */
1058 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1065 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1068 log_debug("Child %lu died (code=%s, status=%i/%s)",
1069 (long unsigned) si.si_pid,
1070 sigchld_code_to_string(si.si_code),
1072 strna(si.si_code == CLD_EXITED
1073 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1074 : signal_to_string(si.si_status)));
1079 log_debug("Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1081 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1082 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1088 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1092 dbus_error_init(&error);
1094 log_debug("Activating special unit %s", name);
1096 if ((r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL)) < 0)
1097 log_error("Failed to enqueue %s job: %s", name, bus_error(&error, r));
1099 dbus_error_free(&error);
1104 static int manager_process_signal_fd(Manager *m) {
1106 struct signalfd_siginfo sfsi;
1107 bool sigchld = false;
1112 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
1117 if (errno == EINTR || errno == EAGAIN)
1123 if (sfsi.ssi_pid > 0) {
1126 get_process_comm(sfsi.ssi_pid, &p);
1128 log_debug("Received SIG%s from PID %lu (%s).",
1129 signal_to_string(sfsi.ssi_signo),
1130 (unsigned long) sfsi.ssi_pid, strna(p));
1133 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1135 switch (sfsi.ssi_signo) {
1142 if (m->running_as == MANAGER_SYSTEM) {
1143 /* This is for compatibility with the
1144 * original sysvinit */
1145 m->exit_code = MANAGER_REEXECUTE;
1152 if (m->running_as == MANAGER_SYSTEM) {
1153 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1157 /* Run the exit target if there is one, if not, just exit. */
1158 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1159 m->exit_code = MANAGER_EXIT;
1166 if (m->running_as == MANAGER_SYSTEM)
1167 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1169 /* This is a nop on non-init */
1173 if (m->running_as == MANAGER_SYSTEM)
1174 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1176 /* This is a nop on non-init */
1182 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1184 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1185 log_info("Trying to reconnect to bus...");
1189 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1190 log_info("Loading D-Bus service...");
1191 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1202 if (!(f = open_memstream(&dump, &size))) {
1203 log_warning("Failed to allocate memory stream.");
1207 manager_dump_units(m, f, "\t");
1208 manager_dump_jobs(m, f, "\t");
1213 log_warning("Failed to write status stream");
1218 log_dump(LOG_INFO, dump);
1225 m->exit_code = MANAGER_RELOAD;
1230 /* Starting SIGRTMIN+0 */
1231 static const char * const target_table[] = {
1232 [0] = SPECIAL_DEFAULT_TARGET,
1233 [1] = SPECIAL_RESCUE_TARGET,
1234 [2] = SPECIAL_EMERGENCY_TARGET,
1235 [3] = SPECIAL_HALT_TARGET,
1236 [4] = SPECIAL_POWEROFF_TARGET,
1237 [5] = SPECIAL_REBOOT_TARGET,
1238 [6] = SPECIAL_KEXEC_TARGET
1241 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1242 static const ManagerExitCode code_table[] = {
1244 [1] = MANAGER_POWEROFF,
1245 [2] = MANAGER_REBOOT,
1249 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1250 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1251 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1252 manager_start_target(m, target_table[idx],
1253 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1257 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1258 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1259 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1263 switch (sfsi.ssi_signo - SIGRTMIN) {
1266 log_debug("Enabling showing of status.");
1267 manager_set_show_status(m, true);
1271 log_debug("Disabling showing of status.");
1272 manager_set_show_status(m, false);
1276 log_set_max_level(LOG_DEBUG);
1277 log_notice("Setting log level to debug.");
1281 log_set_max_level(LOG_INFO);
1282 log_notice("Setting log level to info.");
1286 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1287 log_notice("Setting log target to journal-or-kmsg.");
1291 log_set_target(LOG_TARGET_CONSOLE);
1292 log_notice("Setting log target to console.");
1296 log_set_target(LOG_TARGET_KMSG);
1297 log_notice("Setting log target to kmsg.");
1301 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1302 log_notice("Setting log target to syslog-or-kmsg.");
1306 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1313 return manager_dispatch_sigchld(m);
1318 static int process_event(Manager *m, struct epoll_event *ev) {
1325 assert_se(w = ev->data.ptr);
1327 if (w->type == WATCH_INVALID)
1334 /* An incoming signal? */
1335 if (ev->events != EPOLLIN)
1338 if ((r = manager_process_signal_fd(m)) < 0)
1345 /* An incoming daemon notification event? */
1346 if (ev->events != EPOLLIN)
1349 if ((r = manager_process_notify_fd(m)) < 0)
1356 /* Some fd event, to be dispatched to the units */
1357 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1360 case WATCH_UNIT_TIMER:
1361 case WATCH_JOB_TIMER: {
1365 /* Some timer event, to be dispatched to the units */
1366 if ((k = read(w->fd, &v, sizeof(v))) != sizeof(v)) {
1368 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1371 return k < 0 ? -errno : -EIO;
1374 if (w->type == WATCH_UNIT_TIMER)
1375 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1377 job_timer_event(w->data.job, v, w);
1382 /* Some mount table change, intended for the mount subsystem */
1383 mount_fd_event(m, ev->events);
1387 /* Some swap table change, intended for the swap subsystem */
1388 swap_fd_event(m, ev->events);
1392 /* Some notification from udev, intended for the device subsystem */
1393 device_fd_event(m, ev->events);
1396 case WATCH_DBUS_WATCH:
1397 bus_watch_event(m, w, ev->events);
1400 case WATCH_DBUS_TIMEOUT:
1401 bus_timeout_event(m, w, ev->events);
1405 log_error("event type=%i", w->type);
1406 assert_not_reached("Unknown epoll event type.");
1412 int manager_loop(Manager *m) {
1415 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1418 m->exit_code = MANAGER_RUNNING;
1420 /* Release the path cache */
1421 set_free_free(m->unit_path_cache);
1422 m->unit_path_cache = NULL;
1424 manager_check_finished(m);
1426 /* There might still be some zombies hanging around from
1427 * before we were exec()'ed. Leat's reap them */
1428 r = manager_dispatch_sigchld(m);
1432 while (m->exit_code == MANAGER_RUNNING) {
1433 struct epoll_event event;
1437 if (m->runtime_watchdog > 0 && m->running_as == MANAGER_SYSTEM)
1440 if (!ratelimit_test(&rl)) {
1441 /* Yay, something is going seriously wrong, pause a little */
1442 log_warning("Looping too fast. Throttling execution a little.");
1447 if (manager_dispatch_load_queue(m) > 0)
1450 if (manager_dispatch_run_queue(m) > 0)
1453 if (bus_dispatch(m) > 0)
1456 if (manager_dispatch_cleanup_queue(m) > 0)
1459 if (manager_dispatch_gc_queue(m) > 0)
1462 if (manager_dispatch_dbus_queue(m) > 0)
1465 if (swap_dispatch_reload(m) > 0)
1468 /* Sleep for half the watchdog time */
1469 if (m->runtime_watchdog > 0 && m->running_as == MANAGER_SYSTEM) {
1470 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1476 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1488 r = process_event(m, &event);
1493 return m->exit_code;
1496 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1505 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1508 n = bus_path_unescape(s+31);
1512 r = manager_load_unit(m, n, NULL, e, &u);
1523 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1532 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1535 if ((r = safe_atou(s + 30, &id)) < 0)
1538 if (!(j = manager_get_job(m, id)))
1546 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1551 if (m->audit_fd < 0)
1554 /* Don't generate audit events if the service was already
1555 * started and we're just deserializing */
1556 if (m->n_reloading > 0)
1559 if (m->running_as != MANAGER_SYSTEM)
1562 if (u->type != UNIT_SERVICE)
1565 if (!(p = unit_name_to_prefix_and_instance(u->id))) {
1566 log_error("Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1570 if (audit_log_user_comm_message(m->audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1571 if (errno == EPERM) {
1572 /* We aren't allowed to send audit messages?
1573 * Then let's not retry again. */
1574 audit_close(m->audit_fd);
1577 log_warning("Failed to send audit message: %m");
1585 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1587 union sockaddr_union sa;
1589 char *message = NULL;
1591 /* Don't generate plymouth events if the service was already
1592 * started and we're just deserializing */
1593 if (m->n_reloading > 0)
1596 if (m->running_as != MANAGER_SYSTEM)
1599 if (u->type != UNIT_SERVICE &&
1600 u->type != UNIT_MOUNT &&
1601 u->type != UNIT_SWAP)
1604 /* We set SOCK_NONBLOCK here so that we rather drop the
1605 * message then wait for plymouth */
1606 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1607 log_error("socket() failed: %m");
1612 sa.sa.sa_family = AF_UNIX;
1613 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1614 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1616 if (errno != EPIPE &&
1619 errno != ECONNREFUSED &&
1620 errno != ECONNRESET &&
1621 errno != ECONNABORTED)
1622 log_error("connect() failed: %m");
1627 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1628 log_error("Out of memory");
1633 if (write(fd, message, n + 1) != n + 1) {
1635 if (errno != EPIPE &&
1638 errno != ECONNREFUSED &&
1639 errno != ECONNRESET &&
1640 errno != ECONNABORTED)
1641 log_error("Failed to write Plymouth message: %m");
1648 close_nointr_nofail(fd);
1653 void manager_dispatch_bus_name_owner_changed(
1656 const char* old_owner,
1657 const char *new_owner) {
1664 if (!(u = hashmap_get(m->watch_bus, name)))
1667 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1670 void manager_dispatch_bus_query_pid_done(
1681 if (!(u = hashmap_get(m->watch_bus, name)))
1684 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1687 int manager_open_serialization(Manager *m, FILE **_f) {
1695 if (m->running_as == MANAGER_SYSTEM)
1696 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1698 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1703 saved_umask = umask(0077);
1704 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1714 log_debug("Serializing state to %s", path);
1717 if (!(f = fdopen(fd, "w+")))
1725 int manager_serialize(Manager *m, FILE *f, FDSet *fds) {
1737 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1738 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1739 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1740 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1742 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1745 dual_timestamp_serialize(f, "startup-timestamp", &m->startup_timestamp);
1746 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1751 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1755 if (!unit_can_serialize(u))
1762 if ((r = unit_serialize(u, f, fds)) < 0) {
1768 assert(m->n_reloading > 0);
1774 r = bus_fdset_add_all(m, fds);
1781 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1787 log_debug("Deserializing state...");
1792 char line[LINE_MAX], *l;
1794 if (!fgets(line, sizeof(line), f)) {
1809 if (startswith(l, "current-job-id=")) {
1812 if (safe_atou32(l+15, &id) < 0)
1813 log_debug("Failed to parse current job id value %s", l+15);
1815 m->current_job_id = MAX(m->current_job_id, id);
1816 } else if (startswith(l, "n-installed-jobs=")) {
1819 if (safe_atou32(l+17, &n) < 0)
1820 log_debug("Failed to parse installed jobs counter %s", l+17);
1822 m->n_installed_jobs += n;
1823 } else if (startswith(l, "n-failed-jobs=")) {
1826 if (safe_atou32(l+14, &n) < 0)
1827 log_debug("Failed to parse failed jobs counter %s", l+14);
1829 m->n_failed_jobs += n;
1830 } else if (startswith(l, "taint-usr=")) {
1833 if ((b = parse_boolean(l+10)) < 0)
1834 log_debug("Failed to parse taint /usr flag %s", l+10);
1836 m->taint_usr = m->taint_usr || b;
1837 } else if (startswith(l, "initrd-timestamp="))
1838 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1839 else if (startswith(l, "startup-timestamp="))
1840 dual_timestamp_deserialize(l+18, &m->startup_timestamp);
1841 else if (startswith(l, "finish-timestamp="))
1842 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1844 log_debug("Unknown serialization item '%s'", l);
1849 char name[UNIT_NAME_MAX+2];
1852 if (!fgets(name, sizeof(name), f)) {
1863 if ((r = manager_load_unit(m, strstrip(name), NULL, NULL, &u)) < 0)
1866 if ((r = unit_deserialize(u, f, fds)) < 0)
1876 assert(m->n_reloading > 0);
1882 int manager_reload(Manager *m) {
1889 r = manager_open_serialization(m, &f);
1902 r = manager_serialize(m, f, fds);
1908 if (fseeko(f, 0, SEEK_SET) < 0) {
1914 /* From here on there is no way back. */
1915 manager_clear_jobs_and_units(m);
1916 manager_undo_generators(m);
1917 lookup_paths_free(&m->lookup_paths);
1919 /* Find new unit paths */
1920 manager_run_generators(m);
1922 q = lookup_paths_init(
1923 &m->lookup_paths, m->running_as, true,
1924 m->generator_unit_path,
1925 m->generator_unit_path_early,
1926 m->generator_unit_path_late);
1930 manager_build_unit_path_cache(m);
1932 /* First, enumerate what we can from all config files */
1933 q = manager_enumerate(m);
1937 /* Second, deserialize our stored data */
1938 q = manager_deserialize(m, f, fds);
1945 /* Third, fire things up! */
1946 q = manager_coldplug(m);
1950 assert(m->n_reloading > 0);
1963 bool manager_is_booting_or_shutting_down(Manager *m) {
1968 /* Is the initial job still around? */
1969 if (manager_get_job(m, m->default_unit_job_id))
1972 /* Is there a job for the shutdown target? */
1973 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
1980 void manager_reset_failed(Manager *m) {
1986 HASHMAP_FOREACH(u, m->units, i)
1987 unit_reset_failed(u);
1990 bool manager_unit_pending_inactive(Manager *m, const char *name) {
1996 /* Returns true if the unit is inactive or going down */
1997 if (!(u = manager_get_unit(m, name)))
2000 return unit_pending_inactive(u);
2003 void manager_check_finished(Manager *m) {
2004 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2005 usec_t kernel_usec, initrd_usec, userspace_usec, total_usec;
2009 if (hashmap_size(m->jobs) > 0)
2012 /* Notify Type=idle units that we are done now */
2013 close_pipe(m->idle_pipe);
2015 /* Turn off confirm spawn now */
2016 m->confirm_spawn = false;
2018 if (dual_timestamp_is_set(&m->finish_timestamp))
2021 dual_timestamp_get(&m->finish_timestamp);
2023 if (m->running_as == MANAGER_SYSTEM && detect_container(NULL) <= 0) {
2025 userspace_usec = m->finish_timestamp.monotonic - m->startup_timestamp.monotonic;
2026 total_usec = m->finish_timestamp.monotonic;
2028 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2030 kernel_usec = m->initrd_timestamp.monotonic;
2031 initrd_usec = m->startup_timestamp.monotonic - m->initrd_timestamp.monotonic;
2033 log_info("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2034 format_timespan(kernel, sizeof(kernel), kernel_usec),
2035 format_timespan(initrd, sizeof(initrd), initrd_usec),
2036 format_timespan(userspace, sizeof(userspace), userspace_usec),
2037 format_timespan(sum, sizeof(sum), total_usec));
2039 kernel_usec = m->startup_timestamp.monotonic;
2042 log_info("Startup finished in %s (kernel) + %s (userspace) = %s.",
2043 format_timespan(kernel, sizeof(kernel), kernel_usec),
2044 format_timespan(userspace, sizeof(userspace), userspace_usec),
2045 format_timespan(sum, sizeof(sum), total_usec));
2048 userspace_usec = initrd_usec = kernel_usec = 0;
2049 total_usec = m->finish_timestamp.monotonic - m->startup_timestamp.monotonic;
2051 log_debug("Startup finished in %s.",
2052 format_timespan(sum, sizeof(sum), total_usec));
2055 bus_broadcast_finished(m, kernel_usec, initrd_usec, userspace_usec, total_usec);
2058 "READY=1\nSTATUS=Startup finished in %s.",
2059 format_timespan(sum, sizeof(sum), total_usec));
2062 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2073 if (m->running_as == MANAGER_SYSTEM && getpid() == 1) {
2075 p = strappend("/run/systemd/", name);
2077 log_error("Out of memory");
2081 r = mkdir_p_label(p, 0755);
2083 log_error("Failed to create generator directory: %s", strerror(-r));
2088 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2090 log_error("Out of memory");
2096 log_error("Failed to create generator directory: %m");
2105 static void trim_generator_dir(Manager *m, char **generator) {
2112 if (rmdir(*generator) >= 0) {
2120 void manager_run_generators(Manager *m) {
2122 const char *generator_path;
2123 const char *argv[5];
2129 generator_path = m->running_as == MANAGER_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2130 d = opendir(generator_path);
2132 if (errno == ENOENT)
2135 log_error("Failed to enumerate generator directory: %m");
2139 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2143 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2147 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2151 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2152 argv[1] = m->generator_unit_path;
2153 argv[2] = m->generator_unit_path_early;
2154 argv[3] = m->generator_unit_path_late;
2158 execute_directory(generator_path, d, (char**) argv);
2161 trim_generator_dir(m, &m->generator_unit_path);
2162 trim_generator_dir(m, &m->generator_unit_path_early);
2163 trim_generator_dir(m, &m->generator_unit_path_late);
2170 static void remove_generator_dir(Manager *m, char **generator) {
2177 strv_remove(m->lookup_paths.unit_path, *generator);
2178 rm_rf(*generator, false, true, false);
2184 void manager_undo_generators(Manager *m) {
2187 remove_generator_dir(m, &m->generator_unit_path);
2188 remove_generator_dir(m, &m->generator_unit_path_early);
2189 remove_generator_dir(m, &m->generator_unit_path_late);
2192 int manager_set_default_controllers(Manager *m, char **controllers) {
2197 l = strv_copy(controllers);
2201 strv_free(m->default_controllers);
2202 m->default_controllers = l;
2204 cg_shorten_controllers(m->default_controllers);
2209 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2214 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2215 if (!default_rlimit[i])
2218 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2226 void manager_recheck_journal(Manager *m) {
2231 if (m->running_as != MANAGER_SYSTEM)
2234 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2235 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2236 log_close_journal();
2240 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2241 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2242 log_close_journal();
2246 /* Hmm, OK, so the socket is fully up and the service is up
2247 * too, then let's make use of the thing. */
2251 void manager_set_show_status(Manager *m, bool b) {
2254 if (m->running_as != MANAGER_SYSTEM)
2260 touch("/run/systemd/show-status");
2262 unlink("/run/systemd/show-status");
2265 bool manager_get_show_status(Manager *m) {
2268 if (m->running_as != MANAGER_SYSTEM)
2274 /* If Plymouth is running make sure we show the status, so
2275 * that there's something nice to see when people press Esc */
2277 return plymouth_running();
2280 static const char* const manager_running_as_table[_MANAGER_RUNNING_AS_MAX] = {
2281 [MANAGER_SYSTEM] = "system",
2282 [MANAGER_USER] = "user"
2285 DEFINE_STRING_TABLE_LOOKUP(manager_running_as, ManagerRunningAs);