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"
45 #include "systemd/sd-id128.h"
46 #include "systemd/sd-messages.h"
49 #include "transaction.h"
56 #include "ratelimit.h"
58 #include "mount-setup.h"
59 #include "unit-name.h"
60 #include "dbus-unit.h"
63 #include "path-lookup.h"
65 #include "bus-errors.h"
66 #include "exit-status.h"
69 #include "cgroup-util.h"
70 #include "path-util.h"
72 /* As soon as 16 units are in our GC queue, make sure to run a gc sweep */
73 #define GC_QUEUE_ENTRIES_MAX 16
75 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
76 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
78 /* Where clients shall send notification messages to */
79 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
81 static int manager_setup_notify(Manager *m) {
84 struct sockaddr_un un;
86 struct epoll_event ev;
91 m->notify_watch.type = WATCH_NOTIFY;
92 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
93 if (m->notify_watch.fd < 0) {
94 log_error("Failed to allocate notification socket: %m");
99 sa.sa.sa_family = AF_UNIX;
101 if (getpid() != 1 || detect_container(NULL) > 0)
102 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
104 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
106 sa.un.sun_path[0] = 0;
108 if (bind(m->notify_watch.fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
109 log_error("bind() failed: %m");
113 if (setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0) {
114 log_error("SO_PASSCRED failed: %m");
120 ev.data.ptr = &m->notify_watch;
122 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev) < 0)
125 sa.un.sun_path[0] = '@';
126 m->notify_socket = strdup(sa.un.sun_path);
127 if (!m->notify_socket)
130 log_debug("Using notification socket %s", m->notify_socket);
135 static int enable_special_signals(Manager *m) {
140 /* Enable that we get SIGINT on control-alt-del. In containers
141 * this will fail with EPERM, so ignore that. */
142 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM)
143 log_warning("Failed to enable ctrl-alt-del handling: %m");
145 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
147 /* Support systems without virtual console */
149 log_warning("Failed to open /dev/tty0: %m");
151 /* Enable that we get SIGWINCH on kbrequest */
152 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
153 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
155 close_nointr_nofail(fd);
161 static int manager_setup_signals(Manager *m) {
163 struct epoll_event ev;
168 /* We are not interested in SIGSTOP and friends. */
170 sa.sa_handler = SIG_DFL;
171 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
172 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
174 assert_se(sigemptyset(&mask) == 0);
176 sigset_add_many(&mask,
177 SIGCHLD, /* Child died */
178 SIGTERM, /* Reexecute daemon */
179 SIGHUP, /* Reload configuration */
180 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
181 SIGUSR2, /* systemd: dump status */
182 SIGINT, /* Kernel sends us this on control-alt-del */
183 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
184 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
185 SIGRTMIN+0, /* systemd: start default.target */
186 SIGRTMIN+1, /* systemd: isolate rescue.target */
187 SIGRTMIN+2, /* systemd: isolate emergency.target */
188 SIGRTMIN+3, /* systemd: start halt.target */
189 SIGRTMIN+4, /* systemd: start poweroff.target */
190 SIGRTMIN+5, /* systemd: start reboot.target */
191 SIGRTMIN+6, /* systemd: start kexec.target */
192 SIGRTMIN+13, /* systemd: Immediate halt */
193 SIGRTMIN+14, /* systemd: Immediate poweroff */
194 SIGRTMIN+15, /* systemd: Immediate reboot */
195 SIGRTMIN+16, /* systemd: Immediate kexec */
196 SIGRTMIN+20, /* systemd: enable status messages */
197 SIGRTMIN+21, /* systemd: disable status messages */
198 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
199 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
200 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
201 SIGRTMIN+27, /* systemd: set log target to console */
202 SIGRTMIN+28, /* systemd: set log target to kmsg */
203 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
205 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
207 m->signal_watch.type = WATCH_SIGNAL;
208 if ((m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC)) < 0)
213 ev.data.ptr = &m->signal_watch;
215 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
218 if (m->running_as == MANAGER_SYSTEM)
219 return enable_special_signals(m);
224 static void manager_strip_environment(Manager *m) {
227 /* Remove variables from the inherited set that are part of
228 * the container interface:
229 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
230 strv_remove_prefix(m->environment, "container=");
231 strv_remove_prefix(m->environment, "container_");
233 /* Remove variables from the inherited set that are part of
234 * the initrd interface:
235 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
236 strv_remove_prefix(m->environment, "RD_");
239 int manager_new(ManagerRunningAs running_as, Manager **_m) {
244 assert(running_as >= 0);
245 assert(running_as < _MANAGER_RUNNING_AS_MAX);
247 if (!(m = new0(Manager, 1)))
250 dual_timestamp_get(&m->startup_timestamp);
252 m->running_as = running_as;
253 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
254 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
255 m->pin_cgroupfs_fd = -1;
256 m->idle_pipe[0] = m->idle_pipe[1] = -1;
262 m->signal_watch.fd = m->mount_watch.fd = m->udev_watch.fd = m->epoll_fd = m->dev_autofs_fd = m->swap_watch.fd = -1;
263 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
265 m->environment = strv_copy(environ);
269 manager_strip_environment(m);
271 if (running_as == MANAGER_SYSTEM) {
272 m->default_controllers = strv_new("cpu", NULL);
273 if (!m->default_controllers)
277 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
280 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
283 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
286 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
289 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
292 if ((m->epoll_fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
295 if ((r = manager_setup_signals(m)) < 0)
298 if ((r = manager_setup_cgroup(m)) < 0)
301 if ((r = manager_setup_notify(m)) < 0)
304 /* Try to connect to the busses, if possible. */
305 if ((r = bus_init(m, running_as != MANAGER_SYSTEM)) < 0)
309 if ((m->audit_fd = audit_open()) < 0 &&
310 /* If the kernel lacks netlink or audit support,
311 * don't worry about it. */
312 errno != EAFNOSUPPORT && errno != EPROTONOSUPPORT)
313 log_error("Failed to connect to audit log: %m");
316 m->taint_usr = dir_is_empty("/usr") > 0;
326 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
332 while ((u = m->cleanup_queue)) {
333 assert(u->in_cleanup_queue);
343 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
344 GC_OFFSET_UNSURE, /* No clue */
345 GC_OFFSET_GOOD, /* We still need this unit */
346 GC_OFFSET_BAD, /* We don't need this unit anymore */
350 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
357 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
358 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
359 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
362 if (u->in_cleanup_queue)
365 if (unit_check_gc(u))
368 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
372 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
373 unit_gc_sweep(other, gc_marker);
375 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
378 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
385 /* We were unable to find anything out about this entry, so
386 * let's investigate it later */
387 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
388 unit_add_to_gc_queue(u);
392 /* We definitely know that this one is not useful anymore, so
393 * let's mark it for deletion */
394 u->gc_marker = gc_marker + GC_OFFSET_BAD;
395 unit_add_to_cleanup_queue(u);
399 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
402 static unsigned manager_dispatch_gc_queue(Manager *m) {
409 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
410 (m->gc_queue_timestamp <= 0 ||
411 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
414 log_debug("Running GC...");
416 m->gc_marker += _GC_OFFSET_MAX;
417 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
420 gc_marker = m->gc_marker;
422 while ((u = m->gc_queue)) {
423 assert(u->in_gc_queue);
425 unit_gc_sweep(u, gc_marker);
427 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
428 u->in_gc_queue = false;
432 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
433 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
434 log_debug("Collecting %s", u->id);
435 u->gc_marker = gc_marker + GC_OFFSET_BAD;
436 unit_add_to_cleanup_queue(u);
440 m->n_in_gc_queue = 0;
441 m->gc_queue_timestamp = 0;
446 static void manager_clear_jobs_and_units(Manager *m) {
451 while ((u = hashmap_first(m->units)))
454 manager_dispatch_cleanup_queue(m);
456 assert(!m->load_queue);
457 assert(!m->run_queue);
458 assert(!m->dbus_unit_queue);
459 assert(!m->dbus_job_queue);
460 assert(!m->cleanup_queue);
461 assert(!m->gc_queue);
463 assert(hashmap_isempty(m->jobs));
464 assert(hashmap_isempty(m->units));
467 void manager_free(Manager *m) {
473 manager_clear_jobs_and_units(m);
475 for (c = 0; c < _UNIT_TYPE_MAX; c++)
476 if (unit_vtable[c]->shutdown)
477 unit_vtable[c]->shutdown(m);
479 /* If we reexecute ourselves, we keep the root cgroup
481 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
483 manager_undo_generators(m);
487 hashmap_free(m->units);
488 hashmap_free(m->jobs);
489 hashmap_free(m->watch_pids);
490 hashmap_free(m->watch_bus);
492 if (m->epoll_fd >= 0)
493 close_nointr_nofail(m->epoll_fd);
494 if (m->signal_watch.fd >= 0)
495 close_nointr_nofail(m->signal_watch.fd);
496 if (m->notify_watch.fd >= 0)
497 close_nointr_nofail(m->notify_watch.fd);
500 if (m->audit_fd >= 0)
501 audit_close(m->audit_fd);
504 free(m->notify_socket);
506 lookup_paths_free(&m->lookup_paths);
507 strv_free(m->environment);
509 strv_free(m->default_controllers);
511 hashmap_free(m->cgroup_bondings);
512 set_free_free(m->unit_path_cache);
514 close_pipe(m->idle_pipe);
516 free(m->switch_root);
517 free(m->switch_root_init);
519 for (i = 0; i < RLIMIT_NLIMITS; i++)
525 int manager_enumerate(Manager *m) {
531 /* Let's ask every type to load all units from disk/kernel
532 * that it might know */
533 for (c = 0; c < _UNIT_TYPE_MAX; c++)
534 if (unit_vtable[c]->enumerate)
535 if ((q = unit_vtable[c]->enumerate(m)) < 0)
538 manager_dispatch_load_queue(m);
542 int manager_coldplug(Manager *m) {
550 /* Then, let's set up their initial state. */
551 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
557 if ((q = unit_coldplug(u)) < 0)
564 static void manager_build_unit_path_cache(Manager *m) {
571 set_free_free(m->unit_path_cache);
573 if (!(m->unit_path_cache = set_new(string_hash_func, string_compare_func))) {
574 log_error("Failed to allocate unit path cache.");
578 /* This simply builds a list of files we know exist, so that
579 * we don't always have to go to disk */
581 STRV_FOREACH(i, m->lookup_paths.unit_path) {
584 if (!(d = opendir(*i))) {
585 log_error("Failed to open directory: %m");
589 while ((de = readdir(d))) {
592 if (ignore_file(de->d_name))
595 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
601 if ((r = set_put(m->unit_path_cache, p)) < 0) {
614 log_error("Failed to build unit path cache: %s", strerror(-r));
616 set_free_free(m->unit_path_cache);
617 m->unit_path_cache = NULL;
623 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
628 manager_run_generators(m);
630 r = lookup_paths_init(
631 &m->lookup_paths, m->running_as, true,
632 m->generator_unit_path,
633 m->generator_unit_path_early,
634 m->generator_unit_path_late);
638 manager_build_unit_path_cache(m);
640 /* If we will deserialize make sure that during enumeration
641 * this is already known, so we increase the counter here
646 /* First, enumerate what we can from all config files */
647 r = manager_enumerate(m);
649 /* Second, deserialize if there is something to deserialize */
651 q = manager_deserialize(m, serialization, fds);
656 /* Third, fire things up! */
657 q = manager_coldplug(m);
662 assert(m->n_reloading > 0);
669 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
674 assert(type < _JOB_TYPE_MAX);
676 assert(mode < _JOB_MODE_MAX);
678 if (mode == JOB_ISOLATE && type != JOB_START) {
679 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
683 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
684 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
688 log_debug("Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
690 job_type_collapse(&type, unit);
692 tr = transaction_new();
696 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
697 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
698 mode == JOB_IGNORE_DEPENDENCIES, e);
702 if (mode == JOB_ISOLATE) {
703 r = transaction_add_isolate_jobs(tr, m);
708 r = transaction_activate(tr, m, mode, e);
712 log_debug("Enqueued job %s/%s as %u", unit->id, job_type_to_string(type), (unsigned) tr->anchor_job->id);
715 *_ret = tr->anchor_job;
717 transaction_free(tr);
721 transaction_abort(tr);
722 transaction_free(tr);
726 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
731 assert(type < _JOB_TYPE_MAX);
733 assert(mode < _JOB_MODE_MAX);
735 if ((r = manager_load_unit(m, name, NULL, NULL, &unit)) < 0)
738 return manager_add_job(m, type, unit, mode, override, e, _ret);
741 Job *manager_get_job(Manager *m, uint32_t id) {
744 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
747 Unit *manager_get_unit(Manager *m, const char *name) {
751 return hashmap_get(m->units, name);
754 unsigned manager_dispatch_load_queue(Manager *m) {
760 /* Make sure we are not run recursively */
761 if (m->dispatching_load_queue)
764 m->dispatching_load_queue = true;
766 /* Dispatches the load queue. Takes a unit from the queue and
767 * tries to load its data until the queue is empty */
769 while ((u = m->load_queue)) {
770 assert(u->in_load_queue);
776 m->dispatching_load_queue = false;
780 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
786 assert(name || path);
788 /* This will prepare the unit for loading, but not actually
789 * load anything from disk. */
791 if (path && !is_path(path)) {
792 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
797 name = path_get_file_name(path);
799 t = unit_name_to_type(name);
801 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
802 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
806 ret = manager_get_unit(m, name);
812 ret = unit_new(m, unit_vtable[t]->object_size);
817 ret->fragment_path = strdup(path);
818 if (!ret->fragment_path) {
824 if ((r = unit_add_name(ret, name)) < 0) {
829 unit_add_to_load_queue(ret);
830 unit_add_to_dbus_queue(ret);
831 unit_add_to_gc_queue(ret);
839 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
844 /* This will load the service information files, but not actually
845 * start any services or anything. */
847 if ((r = manager_load_unit_prepare(m, name, path, e, _ret)) != 0)
850 manager_dispatch_load_queue(m);
853 *_ret = unit_follow_merge(*_ret);
858 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
865 HASHMAP_FOREACH(j, s->jobs, i)
866 job_dump(j, f, prefix);
869 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
877 HASHMAP_FOREACH_KEY(u, t, s->units, i)
879 unit_dump(u, f, prefix);
882 void manager_clear_jobs(Manager *m) {
887 while ((j = hashmap_first(m->jobs)))
888 /* No need to recurse. We're cancelling all jobs. */
889 job_finish_and_invalidate(j, JOB_CANCELED, false);
892 unsigned manager_dispatch_run_queue(Manager *m) {
896 if (m->dispatching_run_queue)
899 m->dispatching_run_queue = true;
901 while ((j = m->run_queue)) {
902 assert(j->installed);
903 assert(j->in_run_queue);
905 job_run_and_invalidate(j);
909 m->dispatching_run_queue = false;
913 unsigned manager_dispatch_dbus_queue(Manager *m) {
920 if (m->dispatching_dbus_queue)
923 m->dispatching_dbus_queue = true;
925 while ((u = m->dbus_unit_queue)) {
926 assert(u->in_dbus_queue);
928 bus_unit_send_change_signal(u);
932 while ((j = m->dbus_job_queue)) {
933 assert(j->in_dbus_queue);
935 bus_job_send_change_signal(j);
939 m->dispatching_dbus_queue = false;
943 static int manager_process_notify_fd(Manager *m) {
950 struct msghdr msghdr;
954 struct cmsghdr cmsghdr;
955 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
961 iovec.iov_base = buf;
962 iovec.iov_len = sizeof(buf)-1;
966 msghdr.msg_iov = &iovec;
967 msghdr.msg_iovlen = 1;
968 msghdr.msg_control = &control;
969 msghdr.msg_controllen = sizeof(control);
971 if ((n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT)) <= 0) {
975 if (errno == EAGAIN || errno == EINTR)
981 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
982 control.cmsghdr.cmsg_level != SOL_SOCKET ||
983 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
984 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
985 log_warning("Received notify message without credentials. Ignoring.");
989 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
991 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid))))
992 if (!(u = cgroup_unit_by_pid(m, ucred->pid))) {
993 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
997 assert((size_t) n < sizeof(buf));
999 if (!(tags = strv_split(buf, "\n\r")))
1002 log_debug("Got notification message for unit %s", u->id);
1004 if (UNIT_VTABLE(u)->notify_message)
1005 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1013 static int manager_dispatch_sigchld(Manager *m) {
1023 /* First we call waitd() for a PID and do not reap the
1024 * zombie. That way we can still access /proc/$PID for
1025 * it while it is a zombie. */
1026 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1028 if (errno == ECHILD)
1040 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1043 get_process_comm(si.si_pid, &name);
1044 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1048 /* Let's flush any message the dying child might still
1049 * have queued for us. This ensures that the process
1050 * still exists in /proc so that we can figure out
1051 * which cgroup and hence unit it belongs to. */
1052 if ((r = manager_process_notify_fd(m)) < 0)
1055 /* And now figure out the unit this belongs to */
1056 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid))))
1057 u = cgroup_unit_by_pid(m, si.si_pid);
1059 /* And now, we actually reap the zombie. */
1060 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1067 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1070 log_debug("Child %lu died (code=%s, status=%i/%s)",
1071 (long unsigned) si.si_pid,
1072 sigchld_code_to_string(si.si_code),
1074 strna(si.si_code == CLD_EXITED
1075 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1076 : signal_to_string(si.si_status)));
1081 log_debug("Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1083 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1084 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1090 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1094 dbus_error_init(&error);
1096 log_debug("Activating special unit %s", name);
1098 if ((r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL)) < 0)
1099 log_error("Failed to enqueue %s job: %s", name, bus_error(&error, r));
1101 dbus_error_free(&error);
1106 static int manager_process_signal_fd(Manager *m) {
1108 struct signalfd_siginfo sfsi;
1109 bool sigchld = false;
1114 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
1119 if (errno == EINTR || errno == EAGAIN)
1125 if (sfsi.ssi_pid > 0) {
1128 get_process_comm(sfsi.ssi_pid, &p);
1130 log_debug("Received SIG%s from PID %lu (%s).",
1131 signal_to_string(sfsi.ssi_signo),
1132 (unsigned long) sfsi.ssi_pid, strna(p));
1135 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1137 switch (sfsi.ssi_signo) {
1144 if (m->running_as == MANAGER_SYSTEM) {
1145 /* This is for compatibility with the
1146 * original sysvinit */
1147 m->exit_code = MANAGER_REEXECUTE;
1154 if (m->running_as == MANAGER_SYSTEM) {
1155 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1159 /* Run the exit target if there is one, if not, just exit. */
1160 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1161 m->exit_code = MANAGER_EXIT;
1168 if (m->running_as == MANAGER_SYSTEM)
1169 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1171 /* This is a nop on non-init */
1175 if (m->running_as == MANAGER_SYSTEM)
1176 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1178 /* This is a nop on non-init */
1184 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1186 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1187 log_info("Trying to reconnect to bus...");
1191 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1192 log_info("Loading D-Bus service...");
1193 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1204 if (!(f = open_memstream(&dump, &size))) {
1205 log_warning("Failed to allocate memory stream.");
1209 manager_dump_units(m, f, "\t");
1210 manager_dump_jobs(m, f, "\t");
1215 log_warning("Failed to write status stream");
1220 log_dump(LOG_INFO, dump);
1227 m->exit_code = MANAGER_RELOAD;
1232 /* Starting SIGRTMIN+0 */
1233 static const char * const target_table[] = {
1234 [0] = SPECIAL_DEFAULT_TARGET,
1235 [1] = SPECIAL_RESCUE_TARGET,
1236 [2] = SPECIAL_EMERGENCY_TARGET,
1237 [3] = SPECIAL_HALT_TARGET,
1238 [4] = SPECIAL_POWEROFF_TARGET,
1239 [5] = SPECIAL_REBOOT_TARGET,
1240 [6] = SPECIAL_KEXEC_TARGET
1243 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1244 static const ManagerExitCode code_table[] = {
1246 [1] = MANAGER_POWEROFF,
1247 [2] = MANAGER_REBOOT,
1251 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1252 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1253 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1254 manager_start_target(m, target_table[idx],
1255 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1259 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1260 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1261 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1265 switch (sfsi.ssi_signo - SIGRTMIN) {
1268 log_debug("Enabling showing of status.");
1269 manager_set_show_status(m, true);
1273 log_debug("Disabling showing of status.");
1274 manager_set_show_status(m, false);
1278 log_set_max_level(LOG_DEBUG);
1279 log_notice("Setting log level to debug.");
1283 log_set_max_level(LOG_INFO);
1284 log_notice("Setting log level to info.");
1288 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1289 log_notice("Setting log target to journal-or-kmsg.");
1293 log_set_target(LOG_TARGET_CONSOLE);
1294 log_notice("Setting log target to console.");
1298 log_set_target(LOG_TARGET_KMSG);
1299 log_notice("Setting log target to kmsg.");
1303 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1304 log_notice("Setting log target to syslog-or-kmsg.");
1308 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1315 return manager_dispatch_sigchld(m);
1320 static int process_event(Manager *m, struct epoll_event *ev) {
1327 assert_se(w = ev->data.ptr);
1329 if (w->type == WATCH_INVALID)
1336 /* An incoming signal? */
1337 if (ev->events != EPOLLIN)
1340 if ((r = manager_process_signal_fd(m)) < 0)
1347 /* An incoming daemon notification event? */
1348 if (ev->events != EPOLLIN)
1351 if ((r = manager_process_notify_fd(m)) < 0)
1358 /* Some fd event, to be dispatched to the units */
1359 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1362 case WATCH_UNIT_TIMER:
1363 case WATCH_JOB_TIMER: {
1367 /* Some timer event, to be dispatched to the units */
1368 if ((k = read(w->fd, &v, sizeof(v))) != sizeof(v)) {
1370 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1373 return k < 0 ? -errno : -EIO;
1376 if (w->type == WATCH_UNIT_TIMER)
1377 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1379 job_timer_event(w->data.job, v, w);
1384 /* Some mount table change, intended for the mount subsystem */
1385 mount_fd_event(m, ev->events);
1389 /* Some swap table change, intended for the swap subsystem */
1390 swap_fd_event(m, ev->events);
1394 /* Some notification from udev, intended for the device subsystem */
1395 device_fd_event(m, ev->events);
1398 case WATCH_DBUS_WATCH:
1399 bus_watch_event(m, w, ev->events);
1402 case WATCH_DBUS_TIMEOUT:
1403 bus_timeout_event(m, w, ev->events);
1407 log_error("event type=%i", w->type);
1408 assert_not_reached("Unknown epoll event type.");
1414 int manager_loop(Manager *m) {
1417 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1420 m->exit_code = MANAGER_RUNNING;
1422 /* Release the path cache */
1423 set_free_free(m->unit_path_cache);
1424 m->unit_path_cache = NULL;
1426 manager_check_finished(m);
1428 /* There might still be some zombies hanging around from
1429 * before we were exec()'ed. Leat's reap them */
1430 r = manager_dispatch_sigchld(m);
1434 while (m->exit_code == MANAGER_RUNNING) {
1435 struct epoll_event event;
1439 if (m->runtime_watchdog > 0 && m->running_as == MANAGER_SYSTEM)
1442 if (!ratelimit_test(&rl)) {
1443 /* Yay, something is going seriously wrong, pause a little */
1444 log_warning("Looping too fast. Throttling execution a little.");
1449 if (manager_dispatch_load_queue(m) > 0)
1452 if (manager_dispatch_run_queue(m) > 0)
1455 if (bus_dispatch(m) > 0)
1458 if (manager_dispatch_cleanup_queue(m) > 0)
1461 if (manager_dispatch_gc_queue(m) > 0)
1464 if (manager_dispatch_dbus_queue(m) > 0)
1467 if (swap_dispatch_reload(m) > 0)
1470 /* Sleep for half the watchdog time */
1471 if (m->runtime_watchdog > 0 && m->running_as == MANAGER_SYSTEM) {
1472 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1478 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1490 r = process_event(m, &event);
1495 return m->exit_code;
1498 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1507 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1510 n = bus_path_unescape(s+31);
1514 r = manager_load_unit(m, n, NULL, e, &u);
1525 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1534 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1537 if ((r = safe_atou(s + 30, &id)) < 0)
1540 if (!(j = manager_get_job(m, id)))
1548 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1553 if (m->audit_fd < 0)
1556 /* Don't generate audit events if the service was already
1557 * started and we're just deserializing */
1558 if (m->n_reloading > 0)
1561 if (m->running_as != MANAGER_SYSTEM)
1564 if (u->type != UNIT_SERVICE)
1567 if (!(p = unit_name_to_prefix_and_instance(u->id))) {
1568 log_error("Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1572 if (audit_log_user_comm_message(m->audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1573 if (errno == EPERM) {
1574 /* We aren't allowed to send audit messages?
1575 * Then let's not retry again. */
1576 audit_close(m->audit_fd);
1579 log_warning("Failed to send audit message: %m");
1587 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1589 union sockaddr_union sa;
1591 char *message = NULL;
1593 /* Don't generate plymouth events if the service was already
1594 * started and we're just deserializing */
1595 if (m->n_reloading > 0)
1598 if (m->running_as != MANAGER_SYSTEM)
1601 if (u->type != UNIT_SERVICE &&
1602 u->type != UNIT_MOUNT &&
1603 u->type != UNIT_SWAP)
1606 /* We set SOCK_NONBLOCK here so that we rather drop the
1607 * message then wait for plymouth */
1608 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1609 log_error("socket() failed: %m");
1614 sa.sa.sa_family = AF_UNIX;
1615 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1616 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1618 if (errno != EPIPE &&
1621 errno != ECONNREFUSED &&
1622 errno != ECONNRESET &&
1623 errno != ECONNABORTED)
1624 log_error("connect() failed: %m");
1629 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1635 if (write(fd, message, n + 1) != n + 1) {
1637 if (errno != EPIPE &&
1640 errno != ECONNREFUSED &&
1641 errno != ECONNRESET &&
1642 errno != ECONNABORTED)
1643 log_error("Failed to write Plymouth message: %m");
1650 close_nointr_nofail(fd);
1655 void manager_dispatch_bus_name_owner_changed(
1658 const char* old_owner,
1659 const char *new_owner) {
1666 if (!(u = hashmap_get(m->watch_bus, name)))
1669 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1672 void manager_dispatch_bus_query_pid_done(
1683 if (!(u = hashmap_get(m->watch_bus, name)))
1686 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1689 int manager_open_serialization(Manager *m, FILE **_f) {
1697 if (m->running_as == MANAGER_SYSTEM)
1698 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1700 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1705 saved_umask = umask(0077);
1706 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1716 log_debug("Serializing state to %s", path);
1719 if (!(f = fdopen(fd, "w+")))
1727 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
1739 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1740 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1741 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1742 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1744 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1747 dual_timestamp_serialize(f, "startup-timestamp", &m->startup_timestamp);
1748 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1753 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1757 if (!unit_can_serialize(u))
1764 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
1770 assert(m->n_reloading > 0);
1776 r = bus_fdset_add_all(m, fds);
1783 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1789 log_debug("Deserializing state...");
1794 char line[LINE_MAX], *l;
1796 if (!fgets(line, sizeof(line), f)) {
1811 if (startswith(l, "current-job-id=")) {
1814 if (safe_atou32(l+15, &id) < 0)
1815 log_debug("Failed to parse current job id value %s", l+15);
1817 m->current_job_id = MAX(m->current_job_id, id);
1818 } else if (startswith(l, "n-installed-jobs=")) {
1821 if (safe_atou32(l+17, &n) < 0)
1822 log_debug("Failed to parse installed jobs counter %s", l+17);
1824 m->n_installed_jobs += n;
1825 } else if (startswith(l, "n-failed-jobs=")) {
1828 if (safe_atou32(l+14, &n) < 0)
1829 log_debug("Failed to parse failed jobs counter %s", l+14);
1831 m->n_failed_jobs += n;
1832 } else if (startswith(l, "taint-usr=")) {
1835 if ((b = parse_boolean(l+10)) < 0)
1836 log_debug("Failed to parse taint /usr flag %s", l+10);
1838 m->taint_usr = m->taint_usr || b;
1839 } else if (startswith(l, "initrd-timestamp="))
1840 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1841 else if (startswith(l, "startup-timestamp="))
1842 dual_timestamp_deserialize(l+18, &m->startup_timestamp);
1843 else if (startswith(l, "finish-timestamp="))
1844 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1846 log_debug("Unknown serialization item '%s'", l);
1851 char name[UNIT_NAME_MAX+2];
1854 if (!fgets(name, sizeof(name), f)) {
1865 if ((r = manager_load_unit(m, strstrip(name), NULL, NULL, &u)) < 0)
1868 if ((r = unit_deserialize(u, f, fds)) < 0)
1878 assert(m->n_reloading > 0);
1884 int manager_reload(Manager *m) {
1891 r = manager_open_serialization(m, &f);
1904 r = manager_serialize(m, f, fds, true);
1910 if (fseeko(f, 0, SEEK_SET) < 0) {
1916 /* From here on there is no way back. */
1917 manager_clear_jobs_and_units(m);
1918 manager_undo_generators(m);
1919 lookup_paths_free(&m->lookup_paths);
1921 /* Find new unit paths */
1922 manager_run_generators(m);
1924 q = lookup_paths_init(
1925 &m->lookup_paths, m->running_as, true,
1926 m->generator_unit_path,
1927 m->generator_unit_path_early,
1928 m->generator_unit_path_late);
1932 manager_build_unit_path_cache(m);
1934 /* First, enumerate what we can from all config files */
1935 q = manager_enumerate(m);
1939 /* Second, deserialize our stored data */
1940 q = manager_deserialize(m, f, fds);
1947 /* Third, fire things up! */
1948 q = manager_coldplug(m);
1952 assert(m->n_reloading > 0);
1965 bool manager_is_booting_or_shutting_down(Manager *m) {
1970 /* Is the initial job still around? */
1971 if (manager_get_job(m, m->default_unit_job_id))
1974 /* Is there a job for the shutdown target? */
1975 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
1982 void manager_reset_failed(Manager *m) {
1988 HASHMAP_FOREACH(u, m->units, i)
1989 unit_reset_failed(u);
1992 bool manager_unit_pending_inactive(Manager *m, const char *name) {
1998 /* Returns true if the unit is inactive or going down */
1999 if (!(u = manager_get_unit(m, name)))
2002 return unit_pending_inactive(u);
2005 void manager_check_finished(Manager *m) {
2006 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2007 usec_t kernel_usec, initrd_usec, userspace_usec, total_usec;
2011 if (hashmap_size(m->jobs) > 0)
2014 /* Notify Type=idle units that we are done now */
2015 close_pipe(m->idle_pipe);
2017 /* Turn off confirm spawn now */
2018 m->confirm_spawn = false;
2020 if (dual_timestamp_is_set(&m->finish_timestamp))
2023 dual_timestamp_get(&m->finish_timestamp);
2025 if (m->running_as == MANAGER_SYSTEM && detect_container(NULL) <= 0) {
2027 userspace_usec = m->finish_timestamp.monotonic - m->startup_timestamp.monotonic;
2028 total_usec = m->finish_timestamp.monotonic;
2030 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2032 kernel_usec = m->initrd_timestamp.monotonic;
2033 initrd_usec = m->startup_timestamp.monotonic - m->initrd_timestamp.monotonic;
2035 if (!log_on_console())
2036 log_struct(LOG_INFO,
2037 "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(SD_MESSAGE_STARTUP_FINISHED),
2038 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2039 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2040 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2041 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2042 format_timespan(kernel, sizeof(kernel), kernel_usec),
2043 format_timespan(initrd, sizeof(initrd), initrd_usec),
2044 format_timespan(userspace, sizeof(userspace), userspace_usec),
2045 format_timespan(sum, sizeof(sum), total_usec),
2048 kernel_usec = m->startup_timestamp.monotonic;
2051 if (!log_on_console())
2052 log_struct(LOG_INFO,
2053 "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(SD_MESSAGE_STARTUP_FINISHED),
2054 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2055 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2056 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2057 format_timespan(kernel, sizeof(kernel), kernel_usec),
2058 format_timespan(userspace, sizeof(userspace), userspace_usec),
2059 format_timespan(sum, sizeof(sum), total_usec),
2063 initrd_usec = kernel_usec = 0;
2064 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->startup_timestamp.monotonic;
2066 if (!log_on_console())
2067 log_struct(LOG_INFO,
2068 "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(SD_MESSAGE_STARTUP_FINISHED),
2069 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2070 "MESSAGE=Startup finished in %s.",
2071 format_timespan(sum, sizeof(sum), total_usec),
2075 bus_broadcast_finished(m, kernel_usec, initrd_usec, userspace_usec, total_usec);
2078 "READY=1\nSTATUS=Startup finished in %s.",
2079 format_timespan(sum, sizeof(sum), total_usec));
2082 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2093 if (m->running_as == MANAGER_SYSTEM && getpid() == 1) {
2095 p = strappend("/run/systemd/", name);
2099 r = mkdir_p_label(p, 0755);
2101 log_error("Failed to create generator directory: %s", strerror(-r));
2106 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2112 log_error("Failed to create generator directory: %m");
2121 static void trim_generator_dir(Manager *m, char **generator) {
2128 if (rmdir(*generator) >= 0) {
2136 void manager_run_generators(Manager *m) {
2138 const char *generator_path;
2139 const char *argv[5];
2145 generator_path = m->running_as == MANAGER_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2146 d = opendir(generator_path);
2148 if (errno == ENOENT)
2151 log_error("Failed to enumerate generator directory: %m");
2155 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2159 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2163 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2167 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2168 argv[1] = m->generator_unit_path;
2169 argv[2] = m->generator_unit_path_early;
2170 argv[3] = m->generator_unit_path_late;
2174 execute_directory(generator_path, d, (char**) argv);
2177 trim_generator_dir(m, &m->generator_unit_path);
2178 trim_generator_dir(m, &m->generator_unit_path_early);
2179 trim_generator_dir(m, &m->generator_unit_path_late);
2186 static void remove_generator_dir(Manager *m, char **generator) {
2193 strv_remove(m->lookup_paths.unit_path, *generator);
2194 rm_rf(*generator, false, true, false);
2200 void manager_undo_generators(Manager *m) {
2203 remove_generator_dir(m, &m->generator_unit_path);
2204 remove_generator_dir(m, &m->generator_unit_path_early);
2205 remove_generator_dir(m, &m->generator_unit_path_late);
2208 int manager_set_default_controllers(Manager *m, char **controllers) {
2213 l = strv_copy(controllers);
2217 strv_free(m->default_controllers);
2218 m->default_controllers = l;
2220 cg_shorten_controllers(m->default_controllers);
2225 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2230 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2231 if (!default_rlimit[i])
2234 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2242 void manager_recheck_journal(Manager *m) {
2247 if (m->running_as != MANAGER_SYSTEM)
2250 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2251 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2252 log_close_journal();
2256 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2257 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2258 log_close_journal();
2262 /* Hmm, OK, so the socket is fully up and the service is up
2263 * too, then let's make use of the thing. */
2267 void manager_set_show_status(Manager *m, bool b) {
2270 if (m->running_as != MANAGER_SYSTEM)
2276 touch("/run/systemd/show-status");
2278 unlink("/run/systemd/show-status");
2281 bool manager_get_show_status(Manager *m) {
2284 if (m->running_as != MANAGER_SYSTEM)
2290 /* If Plymouth is running make sure we show the status, so
2291 * that there's something nice to see when people press Esc */
2293 return plymouth_running();
2296 static const char* const manager_running_as_table[_MANAGER_RUNNING_AS_MAX] = {
2297 [MANAGER_SYSTEM] = "system",
2298 [MANAGER_USER] = "user"
2301 DEFINE_STRING_TABLE_LOOKUP(manager_running_as, ManagerRunningAs);