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 (older) or EINVAL (newer), so
143 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
144 log_warning("Failed to enable ctrl-alt-del handling: %m");
146 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
148 /* Support systems without virtual console */
150 log_warning("Failed to open /dev/tty0: %m");
152 /* Enable that we get SIGWINCH on kbrequest */
153 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
154 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
156 close_nointr_nofail(fd);
162 static int manager_setup_signals(Manager *m) {
164 struct epoll_event ev;
169 /* We are not interested in SIGSTOP and friends. */
171 sa.sa_handler = SIG_DFL;
172 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
173 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
175 assert_se(sigemptyset(&mask) == 0);
177 sigset_add_many(&mask,
178 SIGCHLD, /* Child died */
179 SIGTERM, /* Reexecute daemon */
180 SIGHUP, /* Reload configuration */
181 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
182 SIGUSR2, /* systemd: dump status */
183 SIGINT, /* Kernel sends us this on control-alt-del */
184 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
185 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
186 SIGRTMIN+0, /* systemd: start default.target */
187 SIGRTMIN+1, /* systemd: isolate rescue.target */
188 SIGRTMIN+2, /* systemd: isolate emergency.target */
189 SIGRTMIN+3, /* systemd: start halt.target */
190 SIGRTMIN+4, /* systemd: start poweroff.target */
191 SIGRTMIN+5, /* systemd: start reboot.target */
192 SIGRTMIN+6, /* systemd: start kexec.target */
193 SIGRTMIN+13, /* systemd: Immediate halt */
194 SIGRTMIN+14, /* systemd: Immediate poweroff */
195 SIGRTMIN+15, /* systemd: Immediate reboot */
196 SIGRTMIN+16, /* systemd: Immediate kexec */
197 SIGRTMIN+20, /* systemd: enable status messages */
198 SIGRTMIN+21, /* systemd: disable status messages */
199 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
200 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
201 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
202 SIGRTMIN+27, /* systemd: set log target to console */
203 SIGRTMIN+28, /* systemd: set log target to kmsg */
204 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
206 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
208 m->signal_watch.type = WATCH_SIGNAL;
209 if ((m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC)) < 0)
214 ev.data.ptr = &m->signal_watch;
216 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
219 if (m->running_as == SYSTEMD_SYSTEM)
220 return enable_special_signals(m);
225 static void manager_strip_environment(Manager *m) {
228 /* Remove variables from the inherited set that are part of
229 * the container interface:
230 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
231 strv_remove_prefix(m->environment, "container=");
232 strv_remove_prefix(m->environment, "container_");
234 /* Remove variables from the inherited set that are part of
235 * the initrd interface:
236 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
237 strv_remove_prefix(m->environment, "RD_");
240 int manager_new(SystemdRunningAs running_as, Manager **_m) {
245 assert(running_as >= 0);
246 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
248 m = new0(Manager, 1);
252 dual_timestamp_get(&m->userspace_timestamp);
254 m->running_as = running_as;
255 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
256 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
257 m->pin_cgroupfs_fd = -1;
258 m->idle_pipe[0] = m->idle_pipe[1] = -1;
264 m->signal_watch.fd = m->mount_watch.fd = m->udev_watch.fd = m->epoll_fd = m->dev_autofs_fd = m->swap_watch.fd = -1;
265 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
267 m->environment = strv_copy(environ);
271 manager_strip_environment(m);
273 if (running_as == SYSTEMD_SYSTEM) {
274 m->default_controllers = strv_new("cpu", NULL);
275 if (!m->default_controllers)
279 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
282 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
285 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
288 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
291 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
294 if ((m->epoll_fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
297 if ((r = manager_setup_signals(m)) < 0)
300 if ((r = manager_setup_cgroup(m)) < 0)
303 if ((r = manager_setup_notify(m)) < 0)
306 /* Try to connect to the busses, if possible. */
307 if ((r = bus_init(m, running_as != SYSTEMD_SYSTEM)) < 0)
311 if ((m->audit_fd = audit_open()) < 0 &&
312 /* If the kernel lacks netlink or audit support,
313 * don't worry about it. */
314 errno != EAFNOSUPPORT && errno != EPROTONOSUPPORT)
315 log_error("Failed to connect to audit log: %m");
318 m->taint_usr = dir_is_empty("/usr") > 0;
328 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
334 while ((u = m->cleanup_queue)) {
335 assert(u->in_cleanup_queue);
345 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
346 GC_OFFSET_UNSURE, /* No clue */
347 GC_OFFSET_GOOD, /* We still need this unit */
348 GC_OFFSET_BAD, /* We don't need this unit anymore */
352 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
359 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
360 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
361 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
364 if (u->in_cleanup_queue)
367 if (unit_check_gc(u))
370 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
374 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
375 unit_gc_sweep(other, gc_marker);
377 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
380 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
387 /* We were unable to find anything out about this entry, so
388 * let's investigate it later */
389 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
390 unit_add_to_gc_queue(u);
394 /* We definitely know that this one is not useful anymore, so
395 * let's mark it for deletion */
396 u->gc_marker = gc_marker + GC_OFFSET_BAD;
397 unit_add_to_cleanup_queue(u);
401 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
404 static unsigned manager_dispatch_gc_queue(Manager *m) {
411 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
412 (m->gc_queue_timestamp <= 0 ||
413 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
416 log_debug("Running GC...");
418 m->gc_marker += _GC_OFFSET_MAX;
419 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
422 gc_marker = m->gc_marker;
424 while ((u = m->gc_queue)) {
425 assert(u->in_gc_queue);
427 unit_gc_sweep(u, gc_marker);
429 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
430 u->in_gc_queue = false;
434 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
435 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
436 log_debug("Collecting %s", u->id);
437 u->gc_marker = gc_marker + GC_OFFSET_BAD;
438 unit_add_to_cleanup_queue(u);
442 m->n_in_gc_queue = 0;
443 m->gc_queue_timestamp = 0;
448 static void manager_clear_jobs_and_units(Manager *m) {
453 while ((u = hashmap_first(m->units)))
456 manager_dispatch_cleanup_queue(m);
458 assert(!m->load_queue);
459 assert(!m->run_queue);
460 assert(!m->dbus_unit_queue);
461 assert(!m->dbus_job_queue);
462 assert(!m->cleanup_queue);
463 assert(!m->gc_queue);
465 assert(hashmap_isempty(m->jobs));
466 assert(hashmap_isempty(m->units));
469 void manager_free(Manager *m) {
475 manager_clear_jobs_and_units(m);
477 for (c = 0; c < _UNIT_TYPE_MAX; c++)
478 if (unit_vtable[c]->shutdown)
479 unit_vtable[c]->shutdown(m);
481 /* If we reexecute ourselves, we keep the root cgroup
483 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
485 manager_undo_generators(m);
489 hashmap_free(m->units);
490 hashmap_free(m->jobs);
491 hashmap_free(m->watch_pids);
492 hashmap_free(m->watch_bus);
494 if (m->epoll_fd >= 0)
495 close_nointr_nofail(m->epoll_fd);
496 if (m->signal_watch.fd >= 0)
497 close_nointr_nofail(m->signal_watch.fd);
498 if (m->notify_watch.fd >= 0)
499 close_nointr_nofail(m->notify_watch.fd);
502 if (m->audit_fd >= 0)
503 audit_close(m->audit_fd);
506 free(m->notify_socket);
508 lookup_paths_free(&m->lookup_paths);
509 strv_free(m->environment);
511 strv_free(m->default_controllers);
513 hashmap_free(m->cgroup_bondings);
514 set_free_free(m->unit_path_cache);
516 close_pipe(m->idle_pipe);
518 free(m->switch_root);
519 free(m->switch_root_init);
521 for (i = 0; i < RLIMIT_NLIMITS; i++)
527 int manager_enumerate(Manager *m) {
533 /* Let's ask every type to load all units from disk/kernel
534 * that it might know */
535 for (c = 0; c < _UNIT_TYPE_MAX; c++)
536 if (unit_vtable[c]->enumerate)
537 if ((q = unit_vtable[c]->enumerate(m)) < 0)
540 manager_dispatch_load_queue(m);
544 int manager_coldplug(Manager *m) {
552 /* Then, let's set up their initial state. */
553 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
559 if ((q = unit_coldplug(u)) < 0)
566 static void manager_build_unit_path_cache(Manager *m) {
573 set_free_free(m->unit_path_cache);
575 if (!(m->unit_path_cache = set_new(string_hash_func, string_compare_func))) {
576 log_error("Failed to allocate unit path cache.");
580 /* This simply builds a list of files we know exist, so that
581 * we don't always have to go to disk */
583 STRV_FOREACH(i, m->lookup_paths.unit_path) {
586 if (!(d = opendir(*i))) {
587 log_error("Failed to open directory: %m");
591 while ((de = readdir(d))) {
594 if (ignore_file(de->d_name))
597 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
603 if ((r = set_put(m->unit_path_cache, p)) < 0) {
616 log_error("Failed to build unit path cache: %s", strerror(-r));
618 set_free_free(m->unit_path_cache);
619 m->unit_path_cache = NULL;
625 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
630 manager_run_generators(m);
632 r = lookup_paths_init(
633 &m->lookup_paths, m->running_as, true,
634 m->generator_unit_path,
635 m->generator_unit_path_early,
636 m->generator_unit_path_late);
640 manager_build_unit_path_cache(m);
642 /* If we will deserialize make sure that during enumeration
643 * this is already known, so we increase the counter here
648 /* First, enumerate what we can from all config files */
649 r = manager_enumerate(m);
651 /* Second, deserialize if there is something to deserialize */
653 q = manager_deserialize(m, serialization, fds);
658 /* Third, fire things up! */
659 q = manager_coldplug(m);
664 assert(m->n_reloading > 0);
671 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
676 assert(type < _JOB_TYPE_MAX);
678 assert(mode < _JOB_MODE_MAX);
680 if (mode == JOB_ISOLATE && type != JOB_START) {
681 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
685 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
686 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
690 log_debug("Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
692 job_type_collapse(&type, unit);
694 tr = transaction_new();
698 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
699 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
700 mode == JOB_IGNORE_DEPENDENCIES, e);
704 if (mode == JOB_ISOLATE) {
705 r = transaction_add_isolate_jobs(tr, m);
710 r = transaction_activate(tr, m, mode, e);
714 log_debug("Enqueued job %s/%s as %u", unit->id, job_type_to_string(type), (unsigned) tr->anchor_job->id);
717 *_ret = tr->anchor_job;
719 transaction_free(tr);
723 transaction_abort(tr);
724 transaction_free(tr);
728 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
733 assert(type < _JOB_TYPE_MAX);
735 assert(mode < _JOB_MODE_MAX);
737 r = manager_load_unit(m, name, NULL, NULL, &unit);
741 return manager_add_job(m, type, unit, mode, override, e, _ret);
744 Job *manager_get_job(Manager *m, uint32_t id) {
747 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
750 Unit *manager_get_unit(Manager *m, const char *name) {
754 return hashmap_get(m->units, name);
757 unsigned manager_dispatch_load_queue(Manager *m) {
763 /* Make sure we are not run recursively */
764 if (m->dispatching_load_queue)
767 m->dispatching_load_queue = true;
769 /* Dispatches the load queue. Takes a unit from the queue and
770 * tries to load its data until the queue is empty */
772 while ((u = m->load_queue)) {
773 assert(u->in_load_queue);
779 m->dispatching_load_queue = false;
783 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
789 assert(name || path);
791 /* This will prepare the unit for loading, but not actually
792 * load anything from disk. */
794 if (path && !is_path(path)) {
795 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
800 name = path_get_file_name(path);
802 t = unit_name_to_type(name);
804 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
805 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
809 ret = manager_get_unit(m, name);
815 ret = unit_new(m, unit_vtable[t]->object_size);
820 ret->fragment_path = strdup(path);
821 if (!ret->fragment_path) {
827 if ((r = unit_add_name(ret, name)) < 0) {
832 unit_add_to_load_queue(ret);
833 unit_add_to_dbus_queue(ret);
834 unit_add_to_gc_queue(ret);
842 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
847 /* This will load the service information files, but not actually
848 * start any services or anything. */
850 r = manager_load_unit_prepare(m, name, path, e, _ret);
854 manager_dispatch_load_queue(m);
857 *_ret = unit_follow_merge(*_ret);
862 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
869 HASHMAP_FOREACH(j, s->jobs, i)
870 job_dump(j, f, prefix);
873 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
881 HASHMAP_FOREACH_KEY(u, t, s->units, i)
883 unit_dump(u, f, prefix);
886 void manager_clear_jobs(Manager *m) {
891 while ((j = hashmap_first(m->jobs)))
892 /* No need to recurse. We're cancelling all jobs. */
893 job_finish_and_invalidate(j, JOB_CANCELED, false);
896 unsigned manager_dispatch_run_queue(Manager *m) {
900 if (m->dispatching_run_queue)
903 m->dispatching_run_queue = true;
905 while ((j = m->run_queue)) {
906 assert(j->installed);
907 assert(j->in_run_queue);
909 job_run_and_invalidate(j);
913 m->dispatching_run_queue = false;
917 unsigned manager_dispatch_dbus_queue(Manager *m) {
924 if (m->dispatching_dbus_queue)
927 m->dispatching_dbus_queue = true;
929 while ((u = m->dbus_unit_queue)) {
930 assert(u->in_dbus_queue);
932 bus_unit_send_change_signal(u);
936 while ((j = m->dbus_job_queue)) {
937 assert(j->in_dbus_queue);
939 bus_job_send_change_signal(j);
943 m->dispatching_dbus_queue = false;
947 static int manager_process_notify_fd(Manager *m) {
954 struct msghdr msghdr;
958 struct cmsghdr cmsghdr;
959 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
965 iovec.iov_base = buf;
966 iovec.iov_len = sizeof(buf)-1;
970 msghdr.msg_iov = &iovec;
971 msghdr.msg_iovlen = 1;
972 msghdr.msg_control = &control;
973 msghdr.msg_controllen = sizeof(control);
975 if ((n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT)) <= 0) {
979 if (errno == EAGAIN || errno == EINTR)
985 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
986 control.cmsghdr.cmsg_level != SOL_SOCKET ||
987 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
988 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
989 log_warning("Received notify message without credentials. Ignoring.");
993 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
995 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid))))
996 if (!(u = cgroup_unit_by_pid(m, ucred->pid))) {
997 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1001 assert((size_t) n < sizeof(buf));
1003 if (!(tags = strv_split(buf, "\n\r")))
1006 log_debug("Got notification message for unit %s", u->id);
1008 if (UNIT_VTABLE(u)->notify_message)
1009 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1017 static int manager_dispatch_sigchld(Manager *m) {
1027 /* First we call waitd() for a PID and do not reap the
1028 * zombie. That way we can still access /proc/$PID for
1029 * it while it is a zombie. */
1030 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1032 if (errno == ECHILD)
1044 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1047 get_process_comm(si.si_pid, &name);
1048 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1052 /* Let's flush any message the dying child might still
1053 * have queued for us. This ensures that the process
1054 * still exists in /proc so that we can figure out
1055 * which cgroup and hence unit it belongs to. */
1056 if ((r = manager_process_notify_fd(m)) < 0)
1059 /* And now figure out the unit this belongs to */
1060 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid))))
1061 u = cgroup_unit_by_pid(m, si.si_pid);
1063 /* And now, we actually reap the zombie. */
1064 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1071 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1074 log_debug("Child %lu died (code=%s, status=%i/%s)",
1075 (long unsigned) si.si_pid,
1076 sigchld_code_to_string(si.si_code),
1078 strna(si.si_code == CLD_EXITED
1079 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1080 : signal_to_string(si.si_status)));
1085 log_debug("Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1087 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1088 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1094 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1098 dbus_error_init(&error);
1100 log_debug("Activating special unit %s", name);
1102 if ((r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL)) < 0)
1103 log_error("Failed to enqueue %s job: %s", name, bus_error(&error, r));
1105 dbus_error_free(&error);
1110 static int manager_process_signal_fd(Manager *m) {
1112 struct signalfd_siginfo sfsi;
1113 bool sigchld = false;
1118 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
1123 if (errno == EINTR || errno == EAGAIN)
1129 if (sfsi.ssi_pid > 0) {
1132 get_process_comm(sfsi.ssi_pid, &p);
1134 log_debug("Received SIG%s from PID %lu (%s).",
1135 signal_to_string(sfsi.ssi_signo),
1136 (unsigned long) sfsi.ssi_pid, strna(p));
1139 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1141 switch (sfsi.ssi_signo) {
1148 if (m->running_as == SYSTEMD_SYSTEM) {
1149 /* This is for compatibility with the
1150 * original sysvinit */
1151 m->exit_code = MANAGER_REEXECUTE;
1158 if (m->running_as == SYSTEMD_SYSTEM) {
1159 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1163 /* Run the exit target if there is one, if not, just exit. */
1164 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1165 m->exit_code = MANAGER_EXIT;
1172 if (m->running_as == SYSTEMD_SYSTEM)
1173 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1175 /* This is a nop on non-init */
1179 if (m->running_as == SYSTEMD_SYSTEM)
1180 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1182 /* This is a nop on non-init */
1188 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1190 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1191 log_info("Trying to reconnect to bus...");
1195 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1196 log_info("Loading D-Bus service...");
1197 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1208 if (!(f = open_memstream(&dump, &size))) {
1209 log_warning("Failed to allocate memory stream.");
1213 manager_dump_units(m, f, "\t");
1214 manager_dump_jobs(m, f, "\t");
1219 log_warning("Failed to write status stream");
1224 log_dump(LOG_INFO, dump);
1231 m->exit_code = MANAGER_RELOAD;
1236 /* Starting SIGRTMIN+0 */
1237 static const char * const target_table[] = {
1238 [0] = SPECIAL_DEFAULT_TARGET,
1239 [1] = SPECIAL_RESCUE_TARGET,
1240 [2] = SPECIAL_EMERGENCY_TARGET,
1241 [3] = SPECIAL_HALT_TARGET,
1242 [4] = SPECIAL_POWEROFF_TARGET,
1243 [5] = SPECIAL_REBOOT_TARGET,
1244 [6] = SPECIAL_KEXEC_TARGET
1247 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1248 static const ManagerExitCode code_table[] = {
1250 [1] = MANAGER_POWEROFF,
1251 [2] = MANAGER_REBOOT,
1255 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1256 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1257 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1258 manager_start_target(m, target_table[idx],
1259 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1263 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1264 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1265 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1269 switch (sfsi.ssi_signo - SIGRTMIN) {
1272 log_debug("Enabling showing of status.");
1273 manager_set_show_status(m, true);
1277 log_debug("Disabling showing of status.");
1278 manager_set_show_status(m, false);
1282 log_set_max_level(LOG_DEBUG);
1283 log_notice("Setting log level to debug.");
1287 log_set_max_level(LOG_INFO);
1288 log_notice("Setting log level to info.");
1292 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1293 log_notice("Setting log target to journal-or-kmsg.");
1297 log_set_target(LOG_TARGET_CONSOLE);
1298 log_notice("Setting log target to console.");
1302 log_set_target(LOG_TARGET_KMSG);
1303 log_notice("Setting log target to kmsg.");
1307 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1308 log_notice("Setting log target to syslog-or-kmsg.");
1312 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1319 return manager_dispatch_sigchld(m);
1324 static int process_event(Manager *m, struct epoll_event *ev) {
1331 assert_se(w = ev->data.ptr);
1333 if (w->type == WATCH_INVALID)
1340 /* An incoming signal? */
1341 if (ev->events != EPOLLIN)
1344 if ((r = manager_process_signal_fd(m)) < 0)
1351 /* An incoming daemon notification event? */
1352 if (ev->events != EPOLLIN)
1355 if ((r = manager_process_notify_fd(m)) < 0)
1362 /* Some fd event, to be dispatched to the units */
1363 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1366 case WATCH_UNIT_TIMER:
1367 case WATCH_JOB_TIMER: {
1371 /* Some timer event, to be dispatched to the units */
1372 if ((k = read(w->fd, &v, sizeof(v))) != sizeof(v)) {
1374 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1377 return k < 0 ? -errno : -EIO;
1380 if (w->type == WATCH_UNIT_TIMER)
1381 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1383 job_timer_event(w->data.job, v, w);
1388 /* Some mount table change, intended for the mount subsystem */
1389 mount_fd_event(m, ev->events);
1393 /* Some swap table change, intended for the swap subsystem */
1394 swap_fd_event(m, ev->events);
1398 /* Some notification from udev, intended for the device subsystem */
1399 device_fd_event(m, ev->events);
1402 case WATCH_DBUS_WATCH:
1403 bus_watch_event(m, w, ev->events);
1406 case WATCH_DBUS_TIMEOUT:
1407 bus_timeout_event(m, w, ev->events);
1411 log_error("event type=%i", w->type);
1412 assert_not_reached("Unknown epoll event type.");
1418 int manager_loop(Manager *m) {
1421 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1424 m->exit_code = MANAGER_RUNNING;
1426 /* Release the path cache */
1427 set_free_free(m->unit_path_cache);
1428 m->unit_path_cache = NULL;
1430 manager_check_finished(m);
1432 /* There might still be some zombies hanging around from
1433 * before we were exec()'ed. Leat's reap them */
1434 r = manager_dispatch_sigchld(m);
1438 while (m->exit_code == MANAGER_RUNNING) {
1439 struct epoll_event event;
1443 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1446 if (!ratelimit_test(&rl)) {
1447 /* Yay, something is going seriously wrong, pause a little */
1448 log_warning("Looping too fast. Throttling execution a little.");
1453 if (manager_dispatch_load_queue(m) > 0)
1456 if (manager_dispatch_run_queue(m) > 0)
1459 if (bus_dispatch(m) > 0)
1462 if (manager_dispatch_cleanup_queue(m) > 0)
1465 if (manager_dispatch_gc_queue(m) > 0)
1468 if (manager_dispatch_dbus_queue(m) > 0)
1471 if (swap_dispatch_reload(m) > 0)
1474 /* Sleep for half the watchdog time */
1475 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1476 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1482 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1494 r = process_event(m, &event);
1499 return m->exit_code;
1502 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1511 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1514 n = bus_path_unescape(s+31);
1518 r = manager_load_unit(m, n, NULL, e, &u);
1529 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1538 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1541 if ((r = safe_atou(s + 30, &id)) < 0)
1544 if (!(j = manager_get_job(m, id)))
1552 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1557 if (m->audit_fd < 0)
1560 /* Don't generate audit events if the service was already
1561 * started and we're just deserializing */
1562 if (m->n_reloading > 0)
1565 if (m->running_as != SYSTEMD_SYSTEM)
1568 if (u->type != UNIT_SERVICE)
1571 if (!(p = unit_name_to_prefix_and_instance(u->id))) {
1572 log_error("Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1576 if (audit_log_user_comm_message(m->audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1577 if (errno == EPERM) {
1578 /* We aren't allowed to send audit messages?
1579 * Then let's not retry again. */
1580 audit_close(m->audit_fd);
1583 log_warning("Failed to send audit message: %m");
1591 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1593 union sockaddr_union sa;
1595 char *message = NULL;
1597 /* Don't generate plymouth events if the service was already
1598 * started and we're just deserializing */
1599 if (m->n_reloading > 0)
1602 if (m->running_as != SYSTEMD_SYSTEM)
1605 if (u->type != UNIT_SERVICE &&
1606 u->type != UNIT_MOUNT &&
1607 u->type != UNIT_SWAP)
1610 /* We set SOCK_NONBLOCK here so that we rather drop the
1611 * message then wait for plymouth */
1612 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1613 log_error("socket() failed: %m");
1618 sa.sa.sa_family = AF_UNIX;
1619 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1620 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1622 if (errno != EPIPE &&
1625 errno != ECONNREFUSED &&
1626 errno != ECONNRESET &&
1627 errno != ECONNABORTED)
1628 log_error("connect() failed: %m");
1633 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1639 if (write(fd, message, n + 1) != n + 1) {
1641 if (errno != EPIPE &&
1644 errno != ECONNREFUSED &&
1645 errno != ECONNRESET &&
1646 errno != ECONNABORTED)
1647 log_error("Failed to write Plymouth message: %m");
1654 close_nointr_nofail(fd);
1659 void manager_dispatch_bus_name_owner_changed(
1662 const char* old_owner,
1663 const char *new_owner) {
1670 if (!(u = hashmap_get(m->watch_bus, name)))
1673 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1676 void manager_dispatch_bus_query_pid_done(
1687 if (!(u = hashmap_get(m->watch_bus, name)))
1690 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1693 int manager_open_serialization(Manager *m, FILE **_f) {
1701 if (m->running_as == SYSTEMD_SYSTEM)
1702 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1704 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1709 saved_umask = umask(0077);
1710 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1720 log_debug("Serializing state to %s", path);
1723 if (!(f = fdopen(fd, "w+")))
1731 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
1743 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1744 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1745 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1746 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1748 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1749 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1750 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1751 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1754 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1755 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1760 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1764 if (!unit_can_serialize(u))
1771 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
1777 assert(m->n_reloading > 0);
1783 r = bus_fdset_add_all(m, fds);
1790 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1796 log_debug("Deserializing state...");
1801 char line[LINE_MAX], *l;
1803 if (!fgets(line, sizeof(line), f)) {
1818 if (startswith(l, "current-job-id=")) {
1821 if (safe_atou32(l+15, &id) < 0)
1822 log_debug("Failed to parse current job id value %s", l+15);
1824 m->current_job_id = MAX(m->current_job_id, id);
1825 } else if (startswith(l, "n-installed-jobs=")) {
1828 if (safe_atou32(l+17, &n) < 0)
1829 log_debug("Failed to parse installed jobs counter %s", l+17);
1831 m->n_installed_jobs += n;
1832 } else if (startswith(l, "n-failed-jobs=")) {
1835 if (safe_atou32(l+14, &n) < 0)
1836 log_debug("Failed to parse failed jobs counter %s", l+14);
1838 m->n_failed_jobs += n;
1839 } else if (startswith(l, "taint-usr=")) {
1842 if ((b = parse_boolean(l+10)) < 0)
1843 log_debug("Failed to parse taint /usr flag %s", l+10);
1845 m->taint_usr = m->taint_usr || b;
1846 } else if (startswith(l, "firmware-timestamp="))
1847 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
1848 else if (startswith(l, "loader-timestamp="))
1849 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
1850 else if (startswith(l, "kernel-timestamp="))
1851 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
1852 else if (startswith(l, "initrd-timestamp="))
1853 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1854 else if (startswith(l, "userspace-timestamp="))
1855 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
1856 else if (startswith(l, "finish-timestamp="))
1857 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1859 log_debug("Unknown serialization item '%s'", l);
1864 char name[UNIT_NAME_MAX+2];
1867 if (!fgets(name, sizeof(name), f)) {
1878 if ((r = manager_load_unit(m, strstrip(name), NULL, NULL, &u)) < 0)
1881 if ((r = unit_deserialize(u, f, fds)) < 0)
1891 assert(m->n_reloading > 0);
1897 int manager_reload(Manager *m) {
1904 r = manager_open_serialization(m, &f);
1917 r = manager_serialize(m, f, fds, true);
1923 if (fseeko(f, 0, SEEK_SET) < 0) {
1929 /* From here on there is no way back. */
1930 manager_clear_jobs_and_units(m);
1931 manager_undo_generators(m);
1932 lookup_paths_free(&m->lookup_paths);
1934 /* Find new unit paths */
1935 manager_run_generators(m);
1937 q = lookup_paths_init(
1938 &m->lookup_paths, m->running_as, true,
1939 m->generator_unit_path,
1940 m->generator_unit_path_early,
1941 m->generator_unit_path_late);
1945 manager_build_unit_path_cache(m);
1947 /* First, enumerate what we can from all config files */
1948 q = manager_enumerate(m);
1952 /* Second, deserialize our stored data */
1953 q = manager_deserialize(m, f, fds);
1960 /* Third, fire things up! */
1961 q = manager_coldplug(m);
1965 assert(m->n_reloading > 0);
1978 bool manager_is_booting_or_shutting_down(Manager *m) {
1983 /* Is the initial job still around? */
1984 if (manager_get_job(m, m->default_unit_job_id))
1987 /* Is there a job for the shutdown target? */
1988 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
1995 void manager_reset_failed(Manager *m) {
2001 HASHMAP_FOREACH(u, m->units, i)
2002 unit_reset_failed(u);
2005 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2011 /* Returns true if the unit is inactive or going down */
2012 if (!(u = manager_get_unit(m, name)))
2015 return unit_pending_inactive(u);
2018 void manager_check_finished(Manager *m) {
2019 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2020 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2024 if (hashmap_size(m->jobs) > 0)
2027 /* Notify Type=idle units that we are done now */
2028 close_pipe(m->idle_pipe);
2030 /* Turn off confirm spawn now */
2031 m->confirm_spawn = false;
2033 if (dual_timestamp_is_set(&m->finish_timestamp))
2036 dual_timestamp_get(&m->finish_timestamp);
2038 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2040 /* Note that m->kernel_usec.monotonic is always at 0,
2041 * and m->firmware_usec.monotonic and
2042 * m->loader_usec.monotonic should be considered
2043 * negative values. */
2045 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2046 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2047 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2048 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2050 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2052 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2053 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2055 if (!log_on_console())
2056 log_struct(LOG_INFO,
2057 "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(SD_MESSAGE_STARTUP_FINISHED),
2058 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2059 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2060 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2061 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2062 format_timespan(kernel, sizeof(kernel), kernel_usec),
2063 format_timespan(initrd, sizeof(initrd), initrd_usec),
2064 format_timespan(userspace, sizeof(userspace), userspace_usec),
2065 format_timespan(sum, sizeof(sum), total_usec),
2068 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2071 if (!log_on_console())
2072 log_struct(LOG_INFO,
2073 "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(SD_MESSAGE_STARTUP_FINISHED),
2074 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2075 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2076 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2077 format_timespan(kernel, sizeof(kernel), kernel_usec),
2078 format_timespan(userspace, sizeof(userspace), userspace_usec),
2079 format_timespan(sum, sizeof(sum), total_usec),
2083 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2084 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2086 if (!log_on_console())
2087 log_struct(LOG_INFO,
2088 "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(SD_MESSAGE_STARTUP_FINISHED),
2089 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2090 "MESSAGE=Startup finished in %s.",
2091 format_timespan(sum, sizeof(sum), total_usec),
2095 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2098 "READY=1\nSTATUS=Startup finished in %s.",
2099 format_timespan(sum, sizeof(sum), total_usec));
2102 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2113 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2115 p = strappend("/run/systemd/", name);
2119 r = mkdir_p_label(p, 0755);
2121 log_error("Failed to create generator directory: %s", strerror(-r));
2126 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2132 log_error("Failed to create generator directory: %m");
2141 static void trim_generator_dir(Manager *m, char **generator) {
2148 if (rmdir(*generator) >= 0) {
2156 void manager_run_generators(Manager *m) {
2158 const char *generator_path;
2159 const char *argv[5];
2165 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2166 d = opendir(generator_path);
2168 if (errno == ENOENT)
2171 log_error("Failed to enumerate generator directory: %m");
2175 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2179 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2183 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2187 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2188 argv[1] = m->generator_unit_path;
2189 argv[2] = m->generator_unit_path_early;
2190 argv[3] = m->generator_unit_path_late;
2194 execute_directory(generator_path, d, (char**) argv);
2197 trim_generator_dir(m, &m->generator_unit_path);
2198 trim_generator_dir(m, &m->generator_unit_path_early);
2199 trim_generator_dir(m, &m->generator_unit_path_late);
2206 static void remove_generator_dir(Manager *m, char **generator) {
2213 strv_remove(m->lookup_paths.unit_path, *generator);
2214 rm_rf(*generator, false, true, false);
2220 void manager_undo_generators(Manager *m) {
2223 remove_generator_dir(m, &m->generator_unit_path);
2224 remove_generator_dir(m, &m->generator_unit_path_early);
2225 remove_generator_dir(m, &m->generator_unit_path_late);
2228 int manager_set_default_controllers(Manager *m, char **controllers) {
2233 l = strv_copy(controllers);
2237 strv_free(m->default_controllers);
2238 m->default_controllers = l;
2240 cg_shorten_controllers(m->default_controllers);
2245 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2250 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2251 if (!default_rlimit[i])
2254 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2262 void manager_recheck_journal(Manager *m) {
2267 if (m->running_as != SYSTEMD_SYSTEM)
2270 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2271 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2272 log_close_journal();
2276 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2277 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2278 log_close_journal();
2282 /* Hmm, OK, so the socket is fully up and the service is up
2283 * too, then let's make use of the thing. */
2287 void manager_set_show_status(Manager *m, bool b) {
2290 if (m->running_as != SYSTEMD_SYSTEM)
2296 touch("/run/systemd/show-status");
2298 unlink("/run/systemd/show-status");
2301 bool manager_get_show_status(Manager *m) {
2304 if (m->running_as != SYSTEMD_SYSTEM)
2310 /* If Plymouth is running make sure we show the status, so
2311 * that there's something nice to see when people press Esc */
2313 return plymouth_running();