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+24, /* systemd: Immediate exit (--user only) */
203 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
204 SIGRTMIN+27, /* systemd: set log target to console */
205 SIGRTMIN+28, /* systemd: set log target to kmsg */
206 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
208 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
210 m->signal_watch.type = WATCH_SIGNAL;
211 if ((m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC)) < 0)
216 ev.data.ptr = &m->signal_watch;
218 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
221 if (m->running_as == SYSTEMD_SYSTEM)
222 return enable_special_signals(m);
227 static void manager_strip_environment(Manager *m) {
230 /* Remove variables from the inherited set that are part of
231 * the container interface:
232 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
233 strv_remove_prefix(m->environment, "container=");
234 strv_remove_prefix(m->environment, "container_");
236 /* Remove variables from the inherited set that are part of
237 * the initrd interface:
238 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
239 strv_remove_prefix(m->environment, "RD_");
242 int manager_new(SystemdRunningAs running_as, Manager **_m) {
247 assert(running_as >= 0);
248 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
250 m = new0(Manager, 1);
254 dual_timestamp_get(&m->userspace_timestamp);
256 m->running_as = running_as;
257 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
258 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
259 m->pin_cgroupfs_fd = -1;
260 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 == SYSTEMD_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 != SYSTEMD_SYSTEM)) < 0)
308 m->taint_usr = dir_is_empty("/usr") > 0;
318 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
324 while ((u = m->cleanup_queue)) {
325 assert(u->in_cleanup_queue);
335 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
336 GC_OFFSET_UNSURE, /* No clue */
337 GC_OFFSET_GOOD, /* We still need this unit */
338 GC_OFFSET_BAD, /* We don't need this unit anymore */
342 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
349 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
350 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
351 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
354 if (u->in_cleanup_queue)
357 if (unit_check_gc(u))
360 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
364 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
365 unit_gc_sweep(other, gc_marker);
367 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
370 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
377 /* We were unable to find anything out about this entry, so
378 * let's investigate it later */
379 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
380 unit_add_to_gc_queue(u);
384 /* We definitely know that this one is not useful anymore, so
385 * let's mark it for deletion */
386 u->gc_marker = gc_marker + GC_OFFSET_BAD;
387 unit_add_to_cleanup_queue(u);
391 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
394 static unsigned manager_dispatch_gc_queue(Manager *m) {
401 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
402 (m->gc_queue_timestamp <= 0 ||
403 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
406 log_debug("Running GC...");
408 m->gc_marker += _GC_OFFSET_MAX;
409 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
412 gc_marker = m->gc_marker;
414 while ((u = m->gc_queue)) {
415 assert(u->in_gc_queue);
417 unit_gc_sweep(u, gc_marker);
419 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
420 u->in_gc_queue = false;
424 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
425 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
426 log_debug("Collecting %s", u->id);
427 u->gc_marker = gc_marker + GC_OFFSET_BAD;
428 unit_add_to_cleanup_queue(u);
432 m->n_in_gc_queue = 0;
433 m->gc_queue_timestamp = 0;
438 static void manager_clear_jobs_and_units(Manager *m) {
443 while ((u = hashmap_first(m->units)))
446 manager_dispatch_cleanup_queue(m);
448 assert(!m->load_queue);
449 assert(!m->run_queue);
450 assert(!m->dbus_unit_queue);
451 assert(!m->dbus_job_queue);
452 assert(!m->cleanup_queue);
453 assert(!m->gc_queue);
455 assert(hashmap_isempty(m->jobs));
456 assert(hashmap_isempty(m->units));
459 void manager_free(Manager *m) {
465 manager_clear_jobs_and_units(m);
467 for (c = 0; c < _UNIT_TYPE_MAX; c++)
468 if (unit_vtable[c]->shutdown)
469 unit_vtable[c]->shutdown(m);
471 /* If we reexecute ourselves, we keep the root cgroup
473 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
475 manager_undo_generators(m);
479 hashmap_free(m->units);
480 hashmap_free(m->jobs);
481 hashmap_free(m->watch_pids);
482 hashmap_free(m->watch_bus);
484 if (m->epoll_fd >= 0)
485 close_nointr_nofail(m->epoll_fd);
486 if (m->signal_watch.fd >= 0)
487 close_nointr_nofail(m->signal_watch.fd);
488 if (m->notify_watch.fd >= 0)
489 close_nointr_nofail(m->notify_watch.fd);
491 free(m->notify_socket);
493 lookup_paths_free(&m->lookup_paths);
494 strv_free(m->environment);
496 strv_free(m->default_controllers);
498 hashmap_free(m->cgroup_bondings);
499 set_free_free(m->unit_path_cache);
501 close_pipe(m->idle_pipe);
503 free(m->switch_root);
504 free(m->switch_root_init);
506 for (i = 0; i < RLIMIT_NLIMITS; i++)
512 int manager_enumerate(Manager *m) {
518 /* Let's ask every type to load all units from disk/kernel
519 * that it might know */
520 for (c = 0; c < _UNIT_TYPE_MAX; c++)
521 if (unit_vtable[c]->enumerate)
522 if ((q = unit_vtable[c]->enumerate(m)) < 0)
525 manager_dispatch_load_queue(m);
529 int manager_coldplug(Manager *m) {
537 /* Then, let's set up their initial state. */
538 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
544 if ((q = unit_coldplug(u)) < 0)
551 static void manager_build_unit_path_cache(Manager *m) {
558 set_free_free(m->unit_path_cache);
560 if (!(m->unit_path_cache = set_new(string_hash_func, string_compare_func))) {
561 log_error("Failed to allocate unit path cache.");
565 /* This simply builds a list of files we know exist, so that
566 * we don't always have to go to disk */
568 STRV_FOREACH(i, m->lookup_paths.unit_path) {
571 if (!(d = opendir(*i))) {
572 log_error("Failed to open directory: %m");
576 while ((de = readdir(d))) {
579 if (ignore_file(de->d_name))
582 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
588 if ((r = set_put(m->unit_path_cache, p)) < 0) {
601 log_error("Failed to build unit path cache: %s", strerror(-r));
603 set_free_free(m->unit_path_cache);
604 m->unit_path_cache = NULL;
610 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
615 manager_run_generators(m);
617 r = lookup_paths_init(
618 &m->lookup_paths, m->running_as, true,
619 m->generator_unit_path,
620 m->generator_unit_path_early,
621 m->generator_unit_path_late);
625 manager_build_unit_path_cache(m);
627 /* If we will deserialize make sure that during enumeration
628 * this is already known, so we increase the counter here
633 /* First, enumerate what we can from all config files */
634 r = manager_enumerate(m);
636 /* Second, deserialize if there is something to deserialize */
638 q = manager_deserialize(m, serialization, fds);
643 /* Third, fire things up! */
644 q = manager_coldplug(m);
649 assert(m->n_reloading > 0);
656 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
661 assert(type < _JOB_TYPE_MAX);
663 assert(mode < _JOB_MODE_MAX);
665 if (mode == JOB_ISOLATE && type != JOB_START) {
666 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
670 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
671 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
675 log_debug("Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
677 job_type_collapse(&type, unit);
679 tr = transaction_new();
683 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
684 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
685 mode == JOB_IGNORE_DEPENDENCIES, e);
689 if (mode == JOB_ISOLATE) {
690 r = transaction_add_isolate_jobs(tr, m);
695 r = transaction_activate(tr, m, mode, e);
699 log_debug("Enqueued job %s/%s as %u", unit->id, job_type_to_string(type), (unsigned) tr->anchor_job->id);
702 *_ret = tr->anchor_job;
704 transaction_free(tr);
708 transaction_abort(tr);
709 transaction_free(tr);
713 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
718 assert(type < _JOB_TYPE_MAX);
720 assert(mode < _JOB_MODE_MAX);
722 r = manager_load_unit(m, name, NULL, NULL, &unit);
726 return manager_add_job(m, type, unit, mode, override, e, _ret);
729 Job *manager_get_job(Manager *m, uint32_t id) {
732 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
735 Unit *manager_get_unit(Manager *m, const char *name) {
739 return hashmap_get(m->units, name);
742 unsigned manager_dispatch_load_queue(Manager *m) {
748 /* Make sure we are not run recursively */
749 if (m->dispatching_load_queue)
752 m->dispatching_load_queue = true;
754 /* Dispatches the load queue. Takes a unit from the queue and
755 * tries to load its data until the queue is empty */
757 while ((u = m->load_queue)) {
758 assert(u->in_load_queue);
764 m->dispatching_load_queue = false;
768 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
774 assert(name || path);
776 /* This will prepare the unit for loading, but not actually
777 * load anything from disk. */
779 if (path && !is_path(path)) {
780 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
785 name = path_get_file_name(path);
787 t = unit_name_to_type(name);
789 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
790 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
794 ret = manager_get_unit(m, name);
800 ret = unit_new(m, unit_vtable[t]->object_size);
805 ret->fragment_path = strdup(path);
806 if (!ret->fragment_path) {
812 if ((r = unit_add_name(ret, name)) < 0) {
817 unit_add_to_load_queue(ret);
818 unit_add_to_dbus_queue(ret);
819 unit_add_to_gc_queue(ret);
827 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
832 /* This will load the service information files, but not actually
833 * start any services or anything. */
835 r = manager_load_unit_prepare(m, name, path, e, _ret);
839 manager_dispatch_load_queue(m);
842 *_ret = unit_follow_merge(*_ret);
847 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
854 HASHMAP_FOREACH(j, s->jobs, i)
855 job_dump(j, f, prefix);
858 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
866 HASHMAP_FOREACH_KEY(u, t, s->units, i)
868 unit_dump(u, f, prefix);
871 void manager_clear_jobs(Manager *m) {
876 while ((j = hashmap_first(m->jobs)))
877 /* No need to recurse. We're cancelling all jobs. */
878 job_finish_and_invalidate(j, JOB_CANCELED, false);
881 unsigned manager_dispatch_run_queue(Manager *m) {
885 if (m->dispatching_run_queue)
888 m->dispatching_run_queue = true;
890 while ((j = m->run_queue)) {
891 assert(j->installed);
892 assert(j->in_run_queue);
894 job_run_and_invalidate(j);
898 m->dispatching_run_queue = false;
902 unsigned manager_dispatch_dbus_queue(Manager *m) {
909 if (m->dispatching_dbus_queue)
912 m->dispatching_dbus_queue = true;
914 while ((u = m->dbus_unit_queue)) {
915 assert(u->in_dbus_queue);
917 bus_unit_send_change_signal(u);
921 while ((j = m->dbus_job_queue)) {
922 assert(j->in_dbus_queue);
924 bus_job_send_change_signal(j);
928 m->dispatching_dbus_queue = false;
932 static int manager_process_notify_fd(Manager *m) {
939 struct msghdr msghdr;
943 struct cmsghdr cmsghdr;
944 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
950 iovec.iov_base = buf;
951 iovec.iov_len = sizeof(buf)-1;
955 msghdr.msg_iov = &iovec;
956 msghdr.msg_iovlen = 1;
957 msghdr.msg_control = &control;
958 msghdr.msg_controllen = sizeof(control);
960 if ((n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT)) <= 0) {
964 if (errno == EAGAIN || errno == EINTR)
970 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
971 control.cmsghdr.cmsg_level != SOL_SOCKET ||
972 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
973 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
974 log_warning("Received notify message without credentials. Ignoring.");
978 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
980 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid))))
981 if (!(u = cgroup_unit_by_pid(m, ucred->pid))) {
982 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
986 assert((size_t) n < sizeof(buf));
988 if (!(tags = strv_split(buf, "\n\r")))
991 log_debug("Got notification message for unit %s", u->id);
993 if (UNIT_VTABLE(u)->notify_message)
994 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1002 static int manager_dispatch_sigchld(Manager *m) {
1012 /* First we call waitd() for a PID and do not reap the
1013 * zombie. That way we can still access /proc/$PID for
1014 * it while it is a zombie. */
1015 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1017 if (errno == ECHILD)
1029 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1032 get_process_comm(si.si_pid, &name);
1033 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1037 /* Let's flush any message the dying child might still
1038 * have queued for us. This ensures that the process
1039 * still exists in /proc so that we can figure out
1040 * which cgroup and hence unit it belongs to. */
1041 if ((r = manager_process_notify_fd(m)) < 0)
1044 /* And now figure out the unit this belongs to */
1045 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid))))
1046 u = cgroup_unit_by_pid(m, si.si_pid);
1048 /* And now, we actually reap the zombie. */
1049 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1056 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1059 log_debug("Child %lu died (code=%s, status=%i/%s)",
1060 (long unsigned) si.si_pid,
1061 sigchld_code_to_string(si.si_code),
1063 strna(si.si_code == CLD_EXITED
1064 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1065 : signal_to_string(si.si_status)));
1070 log_debug("Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1072 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1073 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1079 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1083 dbus_error_init(&error);
1085 log_debug("Activating special unit %s", name);
1087 if ((r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL)) < 0)
1088 log_error("Failed to enqueue %s job: %s", name, bus_error(&error, r));
1090 dbus_error_free(&error);
1095 static int manager_process_signal_fd(Manager *m) {
1097 struct signalfd_siginfo sfsi;
1098 bool sigchld = false;
1103 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
1108 if (errno == EINTR || errno == EAGAIN)
1114 if (sfsi.ssi_pid > 0) {
1117 get_process_comm(sfsi.ssi_pid, &p);
1119 log_debug("Received SIG%s from PID %lu (%s).",
1120 signal_to_string(sfsi.ssi_signo),
1121 (unsigned long) sfsi.ssi_pid, strna(p));
1124 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1126 switch (sfsi.ssi_signo) {
1133 if (m->running_as == SYSTEMD_SYSTEM) {
1134 /* This is for compatibility with the
1135 * original sysvinit */
1136 m->exit_code = MANAGER_REEXECUTE;
1143 if (m->running_as == SYSTEMD_SYSTEM) {
1144 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1148 /* Run the exit target if there is one, if not, just exit. */
1149 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1150 m->exit_code = MANAGER_EXIT;
1157 if (m->running_as == SYSTEMD_SYSTEM)
1158 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1160 /* This is a nop on non-init */
1164 if (m->running_as == SYSTEMD_SYSTEM)
1165 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1167 /* This is a nop on non-init */
1173 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1175 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1176 log_info("Trying to reconnect to bus...");
1180 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1181 log_info("Loading D-Bus service...");
1182 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1193 if (!(f = open_memstream(&dump, &size))) {
1194 log_warning("Failed to allocate memory stream.");
1198 manager_dump_units(m, f, "\t");
1199 manager_dump_jobs(m, f, "\t");
1204 log_warning("Failed to write status stream");
1209 log_dump(LOG_INFO, dump);
1216 m->exit_code = MANAGER_RELOAD;
1221 /* Starting SIGRTMIN+0 */
1222 static const char * const target_table[] = {
1223 [0] = SPECIAL_DEFAULT_TARGET,
1224 [1] = SPECIAL_RESCUE_TARGET,
1225 [2] = SPECIAL_EMERGENCY_TARGET,
1226 [3] = SPECIAL_HALT_TARGET,
1227 [4] = SPECIAL_POWEROFF_TARGET,
1228 [5] = SPECIAL_REBOOT_TARGET,
1229 [6] = SPECIAL_KEXEC_TARGET
1232 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1233 static const ManagerExitCode code_table[] = {
1235 [1] = MANAGER_POWEROFF,
1236 [2] = MANAGER_REBOOT,
1240 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1241 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1242 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1243 manager_start_target(m, target_table[idx],
1244 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1248 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1249 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1250 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1254 switch (sfsi.ssi_signo - SIGRTMIN) {
1257 log_debug("Enabling showing of status.");
1258 manager_set_show_status(m, true);
1262 log_debug("Disabling showing of status.");
1263 manager_set_show_status(m, false);
1267 log_set_max_level(LOG_DEBUG);
1268 log_notice("Setting log level to debug.");
1272 log_set_max_level(LOG_INFO);
1273 log_notice("Setting log level to info.");
1277 if (m->running_as == SYSTEMD_USER) {
1278 m->exit_code = MANAGER_EXIT;
1282 /* This is a nop on init */
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 == SYSTEMD_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 == SYSTEMD_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) {
1552 audit_fd = get_audit_fd();
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 != SYSTEMD_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(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. */
1578 log_warning("Failed to send audit message: %m");
1586 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1588 union sockaddr_union sa;
1590 char *message = NULL;
1592 /* Don't generate plymouth events if the service was already
1593 * started and we're just deserializing */
1594 if (m->n_reloading > 0)
1597 if (m->running_as != SYSTEMD_SYSTEM)
1600 if (u->type != UNIT_SERVICE &&
1601 u->type != UNIT_MOUNT &&
1602 u->type != UNIT_SWAP)
1605 /* We set SOCK_NONBLOCK here so that we rather drop the
1606 * message then wait for plymouth */
1607 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1608 log_error("socket() failed: %m");
1613 sa.sa.sa_family = AF_UNIX;
1614 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1615 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1617 if (errno != EPIPE &&
1620 errno != ECONNREFUSED &&
1621 errno != ECONNRESET &&
1622 errno != ECONNABORTED)
1623 log_error("connect() failed: %m");
1628 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1634 if (write(fd, message, n + 1) != n + 1) {
1636 if (errno != EPIPE &&
1639 errno != ECONNREFUSED &&
1640 errno != ECONNRESET &&
1641 errno != ECONNABORTED)
1642 log_error("Failed to write Plymouth message: %m");
1649 close_nointr_nofail(fd);
1654 void manager_dispatch_bus_name_owner_changed(
1657 const char* old_owner,
1658 const char *new_owner) {
1665 if (!(u = hashmap_get(m->watch_bus, name)))
1668 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1671 void manager_dispatch_bus_query_pid_done(
1682 if (!(u = hashmap_get(m->watch_bus, name)))
1685 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1688 int manager_open_serialization(Manager *m, FILE **_f) {
1696 if (m->running_as == SYSTEMD_SYSTEM)
1697 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1699 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1704 saved_umask = umask(0077);
1705 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1715 log_debug("Serializing state to %s", path);
1718 if (!(f = fdopen(fd, "w+")))
1726 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
1738 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1739 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1740 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1741 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1743 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1744 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1745 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1746 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1749 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1750 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1755 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1759 if (!unit_can_serialize(u))
1766 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
1772 assert(m->n_reloading > 0);
1778 r = bus_fdset_add_all(m, fds);
1785 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1791 log_debug("Deserializing state...");
1796 char line[LINE_MAX], *l;
1798 if (!fgets(line, sizeof(line), f)) {
1813 if (startswith(l, "current-job-id=")) {
1816 if (safe_atou32(l+15, &id) < 0)
1817 log_debug("Failed to parse current job id value %s", l+15);
1819 m->current_job_id = MAX(m->current_job_id, id);
1820 } else if (startswith(l, "n-installed-jobs=")) {
1823 if (safe_atou32(l+17, &n) < 0)
1824 log_debug("Failed to parse installed jobs counter %s", l+17);
1826 m->n_installed_jobs += n;
1827 } else if (startswith(l, "n-failed-jobs=")) {
1830 if (safe_atou32(l+14, &n) < 0)
1831 log_debug("Failed to parse failed jobs counter %s", l+14);
1833 m->n_failed_jobs += n;
1834 } else if (startswith(l, "taint-usr=")) {
1837 if ((b = parse_boolean(l+10)) < 0)
1838 log_debug("Failed to parse taint /usr flag %s", l+10);
1840 m->taint_usr = m->taint_usr || b;
1841 } else if (startswith(l, "firmware-timestamp="))
1842 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
1843 else if (startswith(l, "loader-timestamp="))
1844 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
1845 else if (startswith(l, "kernel-timestamp="))
1846 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
1847 else if (startswith(l, "initrd-timestamp="))
1848 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1849 else if (startswith(l, "userspace-timestamp="))
1850 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
1851 else if (startswith(l, "finish-timestamp="))
1852 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1854 log_debug("Unknown serialization item '%s'", l);
1859 char name[UNIT_NAME_MAX+2];
1862 if (!fgets(name, sizeof(name), f)) {
1873 if ((r = manager_load_unit(m, strstrip(name), NULL, NULL, &u)) < 0)
1876 if ((r = unit_deserialize(u, f, fds)) < 0)
1886 assert(m->n_reloading > 0);
1892 int manager_reload(Manager *m) {
1899 r = manager_open_serialization(m, &f);
1912 r = manager_serialize(m, f, fds, true);
1918 if (fseeko(f, 0, SEEK_SET) < 0) {
1924 /* From here on there is no way back. */
1925 manager_clear_jobs_and_units(m);
1926 manager_undo_generators(m);
1927 lookup_paths_free(&m->lookup_paths);
1929 /* Find new unit paths */
1930 manager_run_generators(m);
1932 q = lookup_paths_init(
1933 &m->lookup_paths, m->running_as, true,
1934 m->generator_unit_path,
1935 m->generator_unit_path_early,
1936 m->generator_unit_path_late);
1940 manager_build_unit_path_cache(m);
1942 /* First, enumerate what we can from all config files */
1943 q = manager_enumerate(m);
1947 /* Second, deserialize our stored data */
1948 q = manager_deserialize(m, f, fds);
1955 /* Third, fire things up! */
1956 q = manager_coldplug(m);
1960 assert(m->n_reloading > 0);
1973 bool manager_is_booting_or_shutting_down(Manager *m) {
1978 /* Is the initial job still around? */
1979 if (manager_get_job(m, m->default_unit_job_id))
1982 /* Is there a job for the shutdown target? */
1983 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
1990 void manager_reset_failed(Manager *m) {
1996 HASHMAP_FOREACH(u, m->units, i)
1997 unit_reset_failed(u);
2000 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2006 /* Returns true if the unit is inactive or going down */
2007 if (!(u = manager_get_unit(m, name)))
2010 return unit_pending_inactive(u);
2013 void manager_check_finished(Manager *m) {
2014 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2015 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2019 if (hashmap_size(m->jobs) > 0)
2022 /* Notify Type=idle units that we are done now */
2023 close_pipe(m->idle_pipe);
2025 /* Turn off confirm spawn now */
2026 m->confirm_spawn = false;
2028 if (dual_timestamp_is_set(&m->finish_timestamp))
2031 dual_timestamp_get(&m->finish_timestamp);
2033 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2035 /* Note that m->kernel_usec.monotonic is always at 0,
2036 * and m->firmware_usec.monotonic and
2037 * m->loader_usec.monotonic should be considered
2038 * negative values. */
2040 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2041 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2042 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2043 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2045 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2047 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2048 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2050 if (!log_on_console())
2051 log_struct(LOG_INFO,
2052 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2053 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2054 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2055 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2056 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2057 format_timespan(kernel, sizeof(kernel), kernel_usec),
2058 format_timespan(initrd, sizeof(initrd), initrd_usec),
2059 format_timespan(userspace, sizeof(userspace), userspace_usec),
2060 format_timespan(sum, sizeof(sum), total_usec),
2063 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2066 if (!log_on_console())
2067 log_struct(LOG_INFO,
2068 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2069 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2070 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2071 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2072 format_timespan(kernel, sizeof(kernel), kernel_usec),
2073 format_timespan(userspace, sizeof(userspace), userspace_usec),
2074 format_timespan(sum, sizeof(sum), total_usec),
2078 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2079 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2081 if (!log_on_console())
2082 log_struct(LOG_INFO,
2083 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2084 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2085 "MESSAGE=Startup finished in %s.",
2086 format_timespan(sum, sizeof(sum), total_usec),
2090 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2093 "READY=1\nSTATUS=Startup finished in %s.",
2094 format_timespan(sum, sizeof(sum), total_usec));
2097 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2108 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2110 p = strappend("/run/systemd/", name);
2114 r = mkdir_p_label(p, 0755);
2116 log_error("Failed to create generator directory: %s", strerror(-r));
2121 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2127 log_error("Failed to create generator directory: %m");
2136 static void trim_generator_dir(Manager *m, char **generator) {
2143 if (rmdir(*generator) >= 0) {
2151 void manager_run_generators(Manager *m) {
2153 const char *generator_path;
2154 const char *argv[5];
2160 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2161 d = opendir(generator_path);
2163 if (errno == ENOENT)
2166 log_error("Failed to enumerate generator directory: %m");
2170 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2174 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2178 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2182 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2183 argv[1] = m->generator_unit_path;
2184 argv[2] = m->generator_unit_path_early;
2185 argv[3] = m->generator_unit_path_late;
2189 execute_directory(generator_path, d, (char**) argv);
2192 trim_generator_dir(m, &m->generator_unit_path);
2193 trim_generator_dir(m, &m->generator_unit_path_early);
2194 trim_generator_dir(m, &m->generator_unit_path_late);
2201 static void remove_generator_dir(Manager *m, char **generator) {
2208 strv_remove(m->lookup_paths.unit_path, *generator);
2209 rm_rf(*generator, false, true, false);
2215 void manager_undo_generators(Manager *m) {
2218 remove_generator_dir(m, &m->generator_unit_path);
2219 remove_generator_dir(m, &m->generator_unit_path_early);
2220 remove_generator_dir(m, &m->generator_unit_path_late);
2223 int manager_set_default_controllers(Manager *m, char **controllers) {
2228 l = strv_copy(controllers);
2232 strv_free(m->default_controllers);
2233 m->default_controllers = l;
2235 cg_shorten_controllers(m->default_controllers);
2240 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2245 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2246 if (!default_rlimit[i])
2249 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2257 void manager_recheck_journal(Manager *m) {
2262 if (m->running_as != SYSTEMD_SYSTEM)
2265 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2266 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2267 log_close_journal();
2271 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2272 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2273 log_close_journal();
2277 /* Hmm, OK, so the socket is fully up and the service is up
2278 * too, then let's make use of the thing. */
2282 void manager_set_show_status(Manager *m, bool b) {
2285 if (m->running_as != SYSTEMD_SYSTEM)
2291 touch("/run/systemd/show-status");
2293 unlink("/run/systemd/show-status");
2296 bool manager_get_show_status(Manager *m) {
2299 if (m->running_as != SYSTEMD_SYSTEM)
2305 /* If Plymouth is running make sure we show the status, so
2306 * that there's something nice to see when people press Esc */
2308 return plymouth_running();