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"
73 /* As soon as 16 units are in our GC queue, make sure to run a gc sweep */
74 #define GC_QUEUE_ENTRIES_MAX 16
76 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
77 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
79 /* Where clients shall send notification messages to */
80 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
82 static int manager_setup_notify(Manager *m) {
85 struct sockaddr_un un;
87 struct epoll_event ev;
92 m->notify_watch.type = WATCH_NOTIFY;
93 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
94 if (m->notify_watch.fd < 0) {
95 log_error("Failed to allocate notification socket: %m");
100 sa.sa.sa_family = AF_UNIX;
102 if (getpid() != 1 || detect_container(NULL) > 0)
103 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
105 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
107 sa.un.sun_path[0] = 0;
109 if (bind(m->notify_watch.fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
110 log_error("bind() failed: %m");
114 if (setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0) {
115 log_error("SO_PASSCRED failed: %m");
121 ev.data.ptr = &m->notify_watch;
123 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev) < 0)
126 sa.un.sun_path[0] = '@';
127 m->notify_socket = strdup(sa.un.sun_path);
128 if (!m->notify_socket)
131 log_debug("Using notification socket %s", m->notify_socket);
136 static int enable_special_signals(Manager *m) {
141 /* Enable that we get SIGINT on control-alt-del. In containers
142 * this will fail with EPERM (older) or EINVAL (newer), so
144 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
145 log_warning("Failed to enable ctrl-alt-del handling: %m");
147 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
149 /* Support systems without virtual console */
151 log_warning("Failed to open /dev/tty0: %m");
153 /* Enable that we get SIGWINCH on kbrequest */
154 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
155 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
157 close_nointr_nofail(fd);
163 static int manager_setup_signals(Manager *m) {
165 struct epoll_event ev;
170 /* We are not interested in SIGSTOP and friends. */
172 sa.sa_handler = SIG_DFL;
173 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
174 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
176 assert_se(sigemptyset(&mask) == 0);
178 sigset_add_many(&mask,
179 SIGCHLD, /* Child died */
180 SIGTERM, /* Reexecute daemon */
181 SIGHUP, /* Reload configuration */
182 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
183 SIGUSR2, /* systemd: dump status */
184 SIGINT, /* Kernel sends us this on control-alt-del */
185 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
186 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
187 SIGRTMIN+0, /* systemd: start default.target */
188 SIGRTMIN+1, /* systemd: isolate rescue.target */
189 SIGRTMIN+2, /* systemd: isolate emergency.target */
190 SIGRTMIN+3, /* systemd: start halt.target */
191 SIGRTMIN+4, /* systemd: start poweroff.target */
192 SIGRTMIN+5, /* systemd: start reboot.target */
193 SIGRTMIN+6, /* systemd: start kexec.target */
194 SIGRTMIN+13, /* systemd: Immediate halt */
195 SIGRTMIN+14, /* systemd: Immediate poweroff */
196 SIGRTMIN+15, /* systemd: Immediate reboot */
197 SIGRTMIN+16, /* systemd: Immediate kexec */
198 SIGRTMIN+20, /* systemd: enable status messages */
199 SIGRTMIN+21, /* systemd: disable status messages */
200 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
201 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
202 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
203 SIGRTMIN+27, /* systemd: set log target to console */
204 SIGRTMIN+28, /* systemd: set log target to kmsg */
205 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
207 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
209 m->signal_watch.type = WATCH_SIGNAL;
210 if ((m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC)) < 0)
215 ev.data.ptr = &m->signal_watch;
217 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
220 if (m->running_as == SYSTEMD_SYSTEM)
221 return enable_special_signals(m);
226 static void manager_strip_environment(Manager *m) {
229 /* Remove variables from the inherited set that are part of
230 * the container interface:
231 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
232 strv_remove_prefix(m->environment, "container=");
233 strv_remove_prefix(m->environment, "container_");
235 /* Remove variables from the inherited set that are part of
236 * the initrd interface:
237 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
238 strv_remove_prefix(m->environment, "RD_");
241 int manager_new(SystemdRunningAs running_as, Manager **_m) {
246 assert(running_as >= 0);
247 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
249 m = new0(Manager, 1);
253 dual_timestamp_get(&m->userspace_timestamp);
255 m->running_as = running_as;
256 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
257 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
258 m->pin_cgroupfs_fd = -1;
259 m->idle_pipe[0] = m->idle_pipe[1] = -1;
261 m->signal_watch.fd = m->mount_watch.fd = m->udev_watch.fd = m->epoll_fd = m->dev_autofs_fd = m->swap_watch.fd = -1;
262 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
264 m->environment = strv_copy(environ);
268 manager_strip_environment(m);
270 if (running_as == SYSTEMD_SYSTEM) {
271 m->default_controllers = strv_new("cpu", NULL);
272 if (!m->default_controllers)
276 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
279 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
282 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
285 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
288 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
291 if ((m->epoll_fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
294 if ((r = manager_setup_signals(m)) < 0)
297 if ((r = manager_setup_cgroup(m)) < 0)
300 if ((r = manager_setup_notify(m)) < 0)
303 /* Try to connect to the busses, if possible. */
304 if ((r = bus_init(m, running_as != SYSTEMD_SYSTEM)) < 0)
307 m->taint_usr = dir_is_empty("/usr") > 0;
317 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
323 while ((u = m->cleanup_queue)) {
324 assert(u->in_cleanup_queue);
334 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
335 GC_OFFSET_UNSURE, /* No clue */
336 GC_OFFSET_GOOD, /* We still need this unit */
337 GC_OFFSET_BAD, /* We don't need this unit anymore */
341 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
348 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
349 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
350 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
353 if (u->in_cleanup_queue)
356 if (unit_check_gc(u))
359 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
363 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
364 unit_gc_sweep(other, gc_marker);
366 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
369 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
376 /* We were unable to find anything out about this entry, so
377 * let's investigate it later */
378 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
379 unit_add_to_gc_queue(u);
383 /* We definitely know that this one is not useful anymore, so
384 * let's mark it for deletion */
385 u->gc_marker = gc_marker + GC_OFFSET_BAD;
386 unit_add_to_cleanup_queue(u);
390 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
393 static unsigned manager_dispatch_gc_queue(Manager *m) {
400 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
401 (m->gc_queue_timestamp <= 0 ||
402 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
405 log_debug("Running GC...");
407 m->gc_marker += _GC_OFFSET_MAX;
408 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
411 gc_marker = m->gc_marker;
413 while ((u = m->gc_queue)) {
414 assert(u->in_gc_queue);
416 unit_gc_sweep(u, gc_marker);
418 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
419 u->in_gc_queue = false;
423 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
424 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
425 log_debug("Collecting %s", u->id);
426 u->gc_marker = gc_marker + GC_OFFSET_BAD;
427 unit_add_to_cleanup_queue(u);
431 m->n_in_gc_queue = 0;
432 m->gc_queue_timestamp = 0;
437 static void manager_clear_jobs_and_units(Manager *m) {
442 while ((u = hashmap_first(m->units)))
445 manager_dispatch_cleanup_queue(m);
447 assert(!m->load_queue);
448 assert(!m->run_queue);
449 assert(!m->dbus_unit_queue);
450 assert(!m->dbus_job_queue);
451 assert(!m->cleanup_queue);
452 assert(!m->gc_queue);
454 assert(hashmap_isempty(m->jobs));
455 assert(hashmap_isempty(m->units));
458 void manager_free(Manager *m) {
464 manager_clear_jobs_and_units(m);
466 for (c = 0; c < _UNIT_TYPE_MAX; c++)
467 if (unit_vtable[c]->shutdown)
468 unit_vtable[c]->shutdown(m);
470 /* If we reexecute ourselves, we keep the root cgroup
472 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
474 manager_undo_generators(m);
478 hashmap_free(m->units);
479 hashmap_free(m->jobs);
480 hashmap_free(m->watch_pids);
481 hashmap_free(m->watch_bus);
483 if (m->epoll_fd >= 0)
484 close_nointr_nofail(m->epoll_fd);
485 if (m->signal_watch.fd >= 0)
486 close_nointr_nofail(m->signal_watch.fd);
487 if (m->notify_watch.fd >= 0)
488 close_nointr_nofail(m->notify_watch.fd);
490 free(m->notify_socket);
492 lookup_paths_free(&m->lookup_paths);
493 strv_free(m->environment);
495 strv_free(m->default_controllers);
497 hashmap_free(m->cgroup_bondings);
498 set_free_free(m->unit_path_cache);
500 close_pipe(m->idle_pipe);
502 free(m->switch_root);
503 free(m->switch_root_init);
505 for (i = 0; i < RLIMIT_NLIMITS; i++)
511 int manager_enumerate(Manager *m) {
517 /* Let's ask every type to load all units from disk/kernel
518 * that it might know */
519 for (c = 0; c < _UNIT_TYPE_MAX; c++)
520 if (unit_vtable[c]->enumerate)
521 if ((q = unit_vtable[c]->enumerate(m)) < 0)
524 manager_dispatch_load_queue(m);
528 int manager_coldplug(Manager *m) {
536 /* Then, let's set up their initial state. */
537 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
543 if ((q = unit_coldplug(u)) < 0)
550 static void manager_build_unit_path_cache(Manager *m) {
557 set_free_free(m->unit_path_cache);
559 if (!(m->unit_path_cache = set_new(string_hash_func, string_compare_func))) {
560 log_error("Failed to allocate unit path cache.");
564 /* This simply builds a list of files we know exist, so that
565 * we don't always have to go to disk */
567 STRV_FOREACH(i, m->lookup_paths.unit_path) {
570 if (!(d = opendir(*i))) {
571 log_error("Failed to open directory: %m");
575 while ((de = readdir(d))) {
578 if (ignore_file(de->d_name))
581 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
587 if ((r = set_put(m->unit_path_cache, p)) < 0) {
600 log_error("Failed to build unit path cache: %s", strerror(-r));
602 set_free_free(m->unit_path_cache);
603 m->unit_path_cache = NULL;
609 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
614 manager_run_generators(m);
616 r = lookup_paths_init(
617 &m->lookup_paths, m->running_as, true,
618 m->generator_unit_path,
619 m->generator_unit_path_early,
620 m->generator_unit_path_late);
624 manager_build_unit_path_cache(m);
626 /* If we will deserialize make sure that during enumeration
627 * this is already known, so we increase the counter here
632 /* First, enumerate what we can from all config files */
633 r = manager_enumerate(m);
635 /* Second, deserialize if there is something to deserialize */
637 q = manager_deserialize(m, serialization, fds);
642 /* Third, fire things up! */
643 q = manager_coldplug(m);
648 assert(m->n_reloading > 0);
655 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
660 assert(type < _JOB_TYPE_MAX);
662 assert(mode < _JOB_MODE_MAX);
664 if (mode == JOB_ISOLATE && type != JOB_START) {
665 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
669 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
670 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
674 log_debug("Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
676 job_type_collapse(&type, unit);
678 tr = transaction_new();
682 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
683 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
684 mode == JOB_IGNORE_DEPENDENCIES, e);
688 if (mode == JOB_ISOLATE) {
689 r = transaction_add_isolate_jobs(tr, m);
694 r = transaction_activate(tr, m, mode, e);
698 log_debug("Enqueued job %s/%s as %u", unit->id, job_type_to_string(type), (unsigned) tr->anchor_job->id);
701 *_ret = tr->anchor_job;
703 transaction_free(tr);
707 transaction_abort(tr);
708 transaction_free(tr);
712 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
717 assert(type < _JOB_TYPE_MAX);
719 assert(mode < _JOB_MODE_MAX);
721 r = manager_load_unit(m, name, NULL, NULL, &unit);
725 return manager_add_job(m, type, unit, mode, override, e, _ret);
728 Job *manager_get_job(Manager *m, uint32_t id) {
731 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
734 Unit *manager_get_unit(Manager *m, const char *name) {
738 return hashmap_get(m->units, name);
741 unsigned manager_dispatch_load_queue(Manager *m) {
747 /* Make sure we are not run recursively */
748 if (m->dispatching_load_queue)
751 m->dispatching_load_queue = true;
753 /* Dispatches the load queue. Takes a unit from the queue and
754 * tries to load its data until the queue is empty */
756 while ((u = m->load_queue)) {
757 assert(u->in_load_queue);
763 m->dispatching_load_queue = false;
767 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
773 assert(name || path);
775 /* This will prepare the unit for loading, but not actually
776 * load anything from disk. */
778 if (path && !is_path(path)) {
779 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
784 name = path_get_file_name(path);
786 t = unit_name_to_type(name);
788 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
789 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
793 ret = manager_get_unit(m, name);
799 ret = unit_new(m, unit_vtable[t]->object_size);
804 ret->fragment_path = strdup(path);
805 if (!ret->fragment_path) {
811 if ((r = unit_add_name(ret, name)) < 0) {
816 unit_add_to_load_queue(ret);
817 unit_add_to_dbus_queue(ret);
818 unit_add_to_gc_queue(ret);
826 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
831 /* This will load the service information files, but not actually
832 * start any services or anything. */
834 r = manager_load_unit_prepare(m, name, path, e, _ret);
838 manager_dispatch_load_queue(m);
841 *_ret = unit_follow_merge(*_ret);
846 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
853 HASHMAP_FOREACH(j, s->jobs, i)
854 job_dump(j, f, prefix);
857 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
865 HASHMAP_FOREACH_KEY(u, t, s->units, i)
867 unit_dump(u, f, prefix);
870 void manager_clear_jobs(Manager *m) {
875 while ((j = hashmap_first(m->jobs)))
876 /* No need to recurse. We're cancelling all jobs. */
877 job_finish_and_invalidate(j, JOB_CANCELED, false);
880 unsigned manager_dispatch_run_queue(Manager *m) {
884 if (m->dispatching_run_queue)
887 m->dispatching_run_queue = true;
889 while ((j = m->run_queue)) {
890 assert(j->installed);
891 assert(j->in_run_queue);
893 job_run_and_invalidate(j);
897 m->dispatching_run_queue = false;
901 unsigned manager_dispatch_dbus_queue(Manager *m) {
908 if (m->dispatching_dbus_queue)
911 m->dispatching_dbus_queue = true;
913 while ((u = m->dbus_unit_queue)) {
914 assert(u->in_dbus_queue);
916 bus_unit_send_change_signal(u);
920 while ((j = m->dbus_job_queue)) {
921 assert(j->in_dbus_queue);
923 bus_job_send_change_signal(j);
927 m->dispatching_dbus_queue = false;
931 static int manager_process_notify_fd(Manager *m) {
938 struct msghdr msghdr;
942 struct cmsghdr cmsghdr;
943 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
949 iovec.iov_base = buf;
950 iovec.iov_len = sizeof(buf)-1;
954 msghdr.msg_iov = &iovec;
955 msghdr.msg_iovlen = 1;
956 msghdr.msg_control = &control;
957 msghdr.msg_controllen = sizeof(control);
959 if ((n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT)) <= 0) {
963 if (errno == EAGAIN || errno == EINTR)
969 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
970 control.cmsghdr.cmsg_level != SOL_SOCKET ||
971 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
972 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
973 log_warning("Received notify message without credentials. Ignoring.");
977 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
979 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid))))
980 if (!(u = cgroup_unit_by_pid(m, ucred->pid))) {
981 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
985 assert((size_t) n < sizeof(buf));
987 if (!(tags = strv_split(buf, "\n\r")))
990 log_debug("Got notification message for unit %s", u->id);
992 if (UNIT_VTABLE(u)->notify_message)
993 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1001 static int manager_dispatch_sigchld(Manager *m) {
1011 /* First we call waitd() for a PID and do not reap the
1012 * zombie. That way we can still access /proc/$PID for
1013 * it while it is a zombie. */
1014 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1016 if (errno == ECHILD)
1028 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1031 get_process_comm(si.si_pid, &name);
1032 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1036 /* Let's flush any message the dying child might still
1037 * have queued for us. This ensures that the process
1038 * still exists in /proc so that we can figure out
1039 * which cgroup and hence unit it belongs to. */
1040 if ((r = manager_process_notify_fd(m)) < 0)
1043 /* And now figure out the unit this belongs to */
1044 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid))))
1045 u = cgroup_unit_by_pid(m, si.si_pid);
1047 /* And now, we actually reap the zombie. */
1048 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1055 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1058 log_debug("Child %lu died (code=%s, status=%i/%s)",
1059 (long unsigned) si.si_pid,
1060 sigchld_code_to_string(si.si_code),
1062 strna(si.si_code == CLD_EXITED
1063 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1064 : signal_to_string(si.si_status)));
1069 log_debug("Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1071 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1072 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1078 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1082 dbus_error_init(&error);
1084 log_debug("Activating special unit %s", name);
1086 if ((r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL)) < 0)
1087 log_error("Failed to enqueue %s job: %s", name, bus_error(&error, r));
1089 dbus_error_free(&error);
1094 static int manager_process_signal_fd(Manager *m) {
1096 struct signalfd_siginfo sfsi;
1097 bool sigchld = false;
1102 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
1107 if (errno == EINTR || errno == EAGAIN)
1113 if (sfsi.ssi_pid > 0) {
1116 get_process_comm(sfsi.ssi_pid, &p);
1118 log_debug("Received SIG%s from PID %lu (%s).",
1119 signal_to_string(sfsi.ssi_signo),
1120 (unsigned long) sfsi.ssi_pid, strna(p));
1123 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1125 switch (sfsi.ssi_signo) {
1132 if (m->running_as == SYSTEMD_SYSTEM) {
1133 /* This is for compatibility with the
1134 * original sysvinit */
1135 m->exit_code = MANAGER_REEXECUTE;
1142 if (m->running_as == SYSTEMD_SYSTEM) {
1143 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1147 /* Run the exit target if there is one, if not, just exit. */
1148 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1149 m->exit_code = MANAGER_EXIT;
1156 if (m->running_as == SYSTEMD_SYSTEM)
1157 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1159 /* This is a nop on non-init */
1163 if (m->running_as == SYSTEMD_SYSTEM)
1164 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1166 /* This is a nop on non-init */
1172 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1174 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1175 log_info("Trying to reconnect to bus...");
1179 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1180 log_info("Loading D-Bus service...");
1181 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1192 if (!(f = open_memstream(&dump, &size))) {
1193 log_warning("Failed to allocate memory stream.");
1197 manager_dump_units(m, f, "\t");
1198 manager_dump_jobs(m, f, "\t");
1203 log_warning("Failed to write status stream");
1208 log_dump(LOG_INFO, dump);
1215 m->exit_code = MANAGER_RELOAD;
1220 /* Starting SIGRTMIN+0 */
1221 static const char * const target_table[] = {
1222 [0] = SPECIAL_DEFAULT_TARGET,
1223 [1] = SPECIAL_RESCUE_TARGET,
1224 [2] = SPECIAL_EMERGENCY_TARGET,
1225 [3] = SPECIAL_HALT_TARGET,
1226 [4] = SPECIAL_POWEROFF_TARGET,
1227 [5] = SPECIAL_REBOOT_TARGET,
1228 [6] = SPECIAL_KEXEC_TARGET
1231 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1232 static const ManagerExitCode code_table[] = {
1234 [1] = MANAGER_POWEROFF,
1235 [2] = MANAGER_REBOOT,
1239 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1240 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1241 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1242 manager_start_target(m, target_table[idx],
1243 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1247 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1248 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1249 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1253 switch (sfsi.ssi_signo - SIGRTMIN) {
1256 log_debug("Enabling showing of status.");
1257 manager_set_show_status(m, true);
1261 log_debug("Disabling showing of status.");
1262 manager_set_show_status(m, false);
1266 log_set_max_level(LOG_DEBUG);
1267 log_notice("Setting log level to debug.");
1271 log_set_max_level(LOG_INFO);
1272 log_notice("Setting log level to info.");
1276 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1277 log_notice("Setting log target to journal-or-kmsg.");
1281 log_set_target(LOG_TARGET_CONSOLE);
1282 log_notice("Setting log target to console.");
1286 log_set_target(LOG_TARGET_KMSG);
1287 log_notice("Setting log target to kmsg.");
1291 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1292 log_notice("Setting log target to syslog-or-kmsg.");
1296 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1303 return manager_dispatch_sigchld(m);
1308 static int process_event(Manager *m, struct epoll_event *ev) {
1315 assert_se(w = ev->data.ptr);
1317 if (w->type == WATCH_INVALID)
1324 /* An incoming signal? */
1325 if (ev->events != EPOLLIN)
1328 if ((r = manager_process_signal_fd(m)) < 0)
1335 /* An incoming daemon notification event? */
1336 if (ev->events != EPOLLIN)
1339 if ((r = manager_process_notify_fd(m)) < 0)
1346 /* Some fd event, to be dispatched to the units */
1347 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1350 case WATCH_UNIT_TIMER:
1351 case WATCH_JOB_TIMER: {
1355 /* Some timer event, to be dispatched to the units */
1356 if ((k = read(w->fd, &v, sizeof(v))) != sizeof(v)) {
1358 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1361 return k < 0 ? -errno : -EIO;
1364 if (w->type == WATCH_UNIT_TIMER)
1365 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1367 job_timer_event(w->data.job, v, w);
1372 /* Some mount table change, intended for the mount subsystem */
1373 mount_fd_event(m, ev->events);
1377 /* Some swap table change, intended for the swap subsystem */
1378 swap_fd_event(m, ev->events);
1382 /* Some notification from udev, intended for the device subsystem */
1383 device_fd_event(m, ev->events);
1386 case WATCH_DBUS_WATCH:
1387 bus_watch_event(m, w, ev->events);
1390 case WATCH_DBUS_TIMEOUT:
1391 bus_timeout_event(m, w, ev->events);
1395 log_error("event type=%i", w->type);
1396 assert_not_reached("Unknown epoll event type.");
1402 int manager_loop(Manager *m) {
1405 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1408 m->exit_code = MANAGER_RUNNING;
1410 /* Release the path cache */
1411 set_free_free(m->unit_path_cache);
1412 m->unit_path_cache = NULL;
1414 manager_check_finished(m);
1416 /* There might still be some zombies hanging around from
1417 * before we were exec()'ed. Leat's reap them */
1418 r = manager_dispatch_sigchld(m);
1422 while (m->exit_code == MANAGER_RUNNING) {
1423 struct epoll_event event;
1427 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1430 if (!ratelimit_test(&rl)) {
1431 /* Yay, something is going seriously wrong, pause a little */
1432 log_warning("Looping too fast. Throttling execution a little.");
1437 if (manager_dispatch_load_queue(m) > 0)
1440 if (manager_dispatch_run_queue(m) > 0)
1443 if (bus_dispatch(m) > 0)
1446 if (manager_dispatch_cleanup_queue(m) > 0)
1449 if (manager_dispatch_gc_queue(m) > 0)
1452 if (manager_dispatch_dbus_queue(m) > 0)
1455 if (swap_dispatch_reload(m) > 0)
1458 /* Sleep for half the watchdog time */
1459 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1460 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1466 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1478 r = process_event(m, &event);
1483 return m->exit_code;
1486 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1495 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1498 n = bus_path_unescape(s+31);
1502 r = manager_load_unit(m, n, NULL, e, &u);
1513 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1522 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1525 if ((r = safe_atou(s + 30, &id)) < 0)
1528 if (!(j = manager_get_job(m, id)))
1536 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1542 audit_fd = get_audit_fd();
1546 /* Don't generate audit events if the service was already
1547 * started and we're just deserializing */
1548 if (m->n_reloading > 0)
1551 if (m->running_as != SYSTEMD_SYSTEM)
1554 if (u->type != UNIT_SERVICE)
1557 if (!(p = unit_name_to_prefix_and_instance(u->id))) {
1558 log_error("Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1562 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1563 if (errno == EPERM) {
1564 /* We aren't allowed to send audit messages?
1565 * Then let's not retry again. */
1568 log_warning("Failed to send audit message: %m");
1576 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1578 union sockaddr_union sa;
1580 char *message = NULL;
1582 /* Don't generate plymouth events if the service was already
1583 * started and we're just deserializing */
1584 if (m->n_reloading > 0)
1587 if (m->running_as != SYSTEMD_SYSTEM)
1590 if (u->type != UNIT_SERVICE &&
1591 u->type != UNIT_MOUNT &&
1592 u->type != UNIT_SWAP)
1595 /* We set SOCK_NONBLOCK here so that we rather drop the
1596 * message then wait for plymouth */
1597 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1598 log_error("socket() failed: %m");
1603 sa.sa.sa_family = AF_UNIX;
1604 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1605 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1607 if (errno != EPIPE &&
1610 errno != ECONNREFUSED &&
1611 errno != ECONNRESET &&
1612 errno != ECONNABORTED)
1613 log_error("connect() failed: %m");
1618 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1624 if (write(fd, message, n + 1) != n + 1) {
1626 if (errno != EPIPE &&
1629 errno != ECONNREFUSED &&
1630 errno != ECONNRESET &&
1631 errno != ECONNABORTED)
1632 log_error("Failed to write Plymouth message: %m");
1639 close_nointr_nofail(fd);
1644 void manager_dispatch_bus_name_owner_changed(
1647 const char* old_owner,
1648 const char *new_owner) {
1655 if (!(u = hashmap_get(m->watch_bus, name)))
1658 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1661 void manager_dispatch_bus_query_pid_done(
1672 if (!(u = hashmap_get(m->watch_bus, name)))
1675 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1678 int manager_open_serialization(Manager *m, FILE **_f) {
1686 if (m->running_as == SYSTEMD_SYSTEM)
1687 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1689 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1694 saved_umask = umask(0077);
1695 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1705 log_debug("Serializing state to %s", path);
1708 if (!(f = fdopen(fd, "w+")))
1716 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
1728 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1729 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1730 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1731 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1733 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1734 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1735 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1736 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1739 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1740 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1745 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1749 if (!unit_can_serialize(u))
1756 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
1762 assert(m->n_reloading > 0);
1768 r = bus_fdset_add_all(m, fds);
1775 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1781 log_debug("Deserializing state...");
1786 char line[LINE_MAX], *l;
1788 if (!fgets(line, sizeof(line), f)) {
1803 if (startswith(l, "current-job-id=")) {
1806 if (safe_atou32(l+15, &id) < 0)
1807 log_debug("Failed to parse current job id value %s", l+15);
1809 m->current_job_id = MAX(m->current_job_id, id);
1810 } else if (startswith(l, "n-installed-jobs=")) {
1813 if (safe_atou32(l+17, &n) < 0)
1814 log_debug("Failed to parse installed jobs counter %s", l+17);
1816 m->n_installed_jobs += n;
1817 } else if (startswith(l, "n-failed-jobs=")) {
1820 if (safe_atou32(l+14, &n) < 0)
1821 log_debug("Failed to parse failed jobs counter %s", l+14);
1823 m->n_failed_jobs += n;
1824 } else if (startswith(l, "taint-usr=")) {
1827 if ((b = parse_boolean(l+10)) < 0)
1828 log_debug("Failed to parse taint /usr flag %s", l+10);
1830 m->taint_usr = m->taint_usr || b;
1831 } else if (startswith(l, "firmware-timestamp="))
1832 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
1833 else if (startswith(l, "loader-timestamp="))
1834 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
1835 else if (startswith(l, "kernel-timestamp="))
1836 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
1837 else if (startswith(l, "initrd-timestamp="))
1838 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1839 else if (startswith(l, "userspace-timestamp="))
1840 dual_timestamp_deserialize(l+20, &m->userspace_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, true);
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 firmware_usec, loader_usec, 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 == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2025 /* Note that m->kernel_usec.monotonic is always at 0,
2026 * and m->firmware_usec.monotonic and
2027 * m->loader_usec.monotonic should be considered
2028 * negative values. */
2030 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2031 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2032 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2033 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2035 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2037 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2038 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2040 if (!log_on_console())
2041 log_struct(LOG_INFO,
2042 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2043 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2044 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2045 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2046 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2047 format_timespan(kernel, sizeof(kernel), kernel_usec),
2048 format_timespan(initrd, sizeof(initrd), initrd_usec),
2049 format_timespan(userspace, sizeof(userspace), userspace_usec),
2050 format_timespan(sum, sizeof(sum), total_usec),
2053 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2056 if (!log_on_console())
2057 log_struct(LOG_INFO,
2058 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2059 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2060 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2061 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2062 format_timespan(kernel, sizeof(kernel), kernel_usec),
2063 format_timespan(userspace, sizeof(userspace), userspace_usec),
2064 format_timespan(sum, sizeof(sum), total_usec),
2068 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2069 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2071 if (!log_on_console())
2072 log_struct(LOG_INFO,
2073 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2074 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2075 "MESSAGE=Startup finished in %s.",
2076 format_timespan(sum, sizeof(sum), total_usec),
2080 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2083 "READY=1\nSTATUS=Startup finished in %s.",
2084 format_timespan(sum, sizeof(sum), total_usec));
2087 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2098 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2100 p = strappend("/run/systemd/", name);
2104 r = mkdir_p_label(p, 0755);
2106 log_error("Failed to create generator directory: %s", strerror(-r));
2111 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2117 log_error("Failed to create generator directory: %m");
2126 static void trim_generator_dir(Manager *m, char **generator) {
2133 if (rmdir(*generator) >= 0) {
2141 void manager_run_generators(Manager *m) {
2143 const char *generator_path;
2144 const char *argv[5];
2150 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2151 d = opendir(generator_path);
2153 if (errno == ENOENT)
2156 log_error("Failed to enumerate generator directory: %m");
2160 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2164 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2168 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2172 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2173 argv[1] = m->generator_unit_path;
2174 argv[2] = m->generator_unit_path_early;
2175 argv[3] = m->generator_unit_path_late;
2179 execute_directory(generator_path, d, (char**) argv);
2182 trim_generator_dir(m, &m->generator_unit_path);
2183 trim_generator_dir(m, &m->generator_unit_path_early);
2184 trim_generator_dir(m, &m->generator_unit_path_late);
2191 static void remove_generator_dir(Manager *m, char **generator) {
2198 strv_remove(m->lookup_paths.unit_path, *generator);
2199 rm_rf(*generator, false, true, false);
2205 void manager_undo_generators(Manager *m) {
2208 remove_generator_dir(m, &m->generator_unit_path);
2209 remove_generator_dir(m, &m->generator_unit_path_early);
2210 remove_generator_dir(m, &m->generator_unit_path_late);
2213 int manager_set_default_controllers(Manager *m, char **controllers) {
2218 l = strv_copy(controllers);
2222 strv_free(m->default_controllers);
2223 m->default_controllers = l;
2225 cg_shorten_controllers(m->default_controllers);
2230 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2235 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2236 if (!default_rlimit[i])
2239 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2247 void manager_recheck_journal(Manager *m) {
2252 if (m->running_as != SYSTEMD_SYSTEM)
2255 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2256 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2257 log_close_journal();
2261 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2262 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2263 log_close_journal();
2267 /* Hmm, OK, so the socket is fully up and the service is up
2268 * too, then let's make use of the thing. */
2272 void manager_set_show_status(Manager *m, bool b) {
2275 if (m->running_as != SYSTEMD_SYSTEM)
2281 touch("/run/systemd/show-status");
2283 unlink("/run/systemd/show-status");
2286 bool manager_get_show_status(Manager *m) {
2289 if (m->running_as != SYSTEMD_SYSTEM)
2295 /* If Plymouth is running make sure we show the status, so
2296 * that there's something nice to see when people press Esc */
2298 return plymouth_running();