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 == MANAGER_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(ManagerRunningAs running_as, Manager **_m) {
245 assert(running_as >= 0);
246 assert(running_as < _MANAGER_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 == MANAGER_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 != MANAGER_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 if ((r = manager_load_unit(m, name, NULL, NULL, &unit)) < 0)
740 return manager_add_job(m, type, unit, mode, override, e, _ret);
743 Job *manager_get_job(Manager *m, uint32_t id) {
746 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
749 Unit *manager_get_unit(Manager *m, const char *name) {
753 return hashmap_get(m->units, name);
756 unsigned manager_dispatch_load_queue(Manager *m) {
762 /* Make sure we are not run recursively */
763 if (m->dispatching_load_queue)
766 m->dispatching_load_queue = true;
768 /* Dispatches the load queue. Takes a unit from the queue and
769 * tries to load its data until the queue is empty */
771 while ((u = m->load_queue)) {
772 assert(u->in_load_queue);
778 m->dispatching_load_queue = false;
782 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
788 assert(name || path);
790 /* This will prepare the unit for loading, but not actually
791 * load anything from disk. */
793 if (path && !is_path(path)) {
794 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
799 name = path_get_file_name(path);
801 t = unit_name_to_type(name);
803 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
804 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
808 ret = manager_get_unit(m, name);
814 ret = unit_new(m, unit_vtable[t]->object_size);
819 ret->fragment_path = strdup(path);
820 if (!ret->fragment_path) {
826 if ((r = unit_add_name(ret, name)) < 0) {
831 unit_add_to_load_queue(ret);
832 unit_add_to_dbus_queue(ret);
833 unit_add_to_gc_queue(ret);
841 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
846 /* This will load the service information files, but not actually
847 * start any services or anything. */
849 if ((r = manager_load_unit_prepare(m, name, path, e, _ret)) != 0)
852 manager_dispatch_load_queue(m);
855 *_ret = unit_follow_merge(*_ret);
860 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
867 HASHMAP_FOREACH(j, s->jobs, i)
868 job_dump(j, f, prefix);
871 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
879 HASHMAP_FOREACH_KEY(u, t, s->units, i)
881 unit_dump(u, f, prefix);
884 void manager_clear_jobs(Manager *m) {
889 while ((j = hashmap_first(m->jobs)))
890 /* No need to recurse. We're cancelling all jobs. */
891 job_finish_and_invalidate(j, JOB_CANCELED, false);
894 unsigned manager_dispatch_run_queue(Manager *m) {
898 if (m->dispatching_run_queue)
901 m->dispatching_run_queue = true;
903 while ((j = m->run_queue)) {
904 assert(j->installed);
905 assert(j->in_run_queue);
907 job_run_and_invalidate(j);
911 m->dispatching_run_queue = false;
915 unsigned manager_dispatch_dbus_queue(Manager *m) {
922 if (m->dispatching_dbus_queue)
925 m->dispatching_dbus_queue = true;
927 while ((u = m->dbus_unit_queue)) {
928 assert(u->in_dbus_queue);
930 bus_unit_send_change_signal(u);
934 while ((j = m->dbus_job_queue)) {
935 assert(j->in_dbus_queue);
937 bus_job_send_change_signal(j);
941 m->dispatching_dbus_queue = false;
945 static int manager_process_notify_fd(Manager *m) {
952 struct msghdr msghdr;
956 struct cmsghdr cmsghdr;
957 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
963 iovec.iov_base = buf;
964 iovec.iov_len = sizeof(buf)-1;
968 msghdr.msg_iov = &iovec;
969 msghdr.msg_iovlen = 1;
970 msghdr.msg_control = &control;
971 msghdr.msg_controllen = sizeof(control);
973 if ((n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT)) <= 0) {
977 if (errno == EAGAIN || errno == EINTR)
983 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
984 control.cmsghdr.cmsg_level != SOL_SOCKET ||
985 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
986 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
987 log_warning("Received notify message without credentials. Ignoring.");
991 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
993 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid))))
994 if (!(u = cgroup_unit_by_pid(m, ucred->pid))) {
995 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
999 assert((size_t) n < sizeof(buf));
1001 if (!(tags = strv_split(buf, "\n\r")))
1004 log_debug("Got notification message for unit %s", u->id);
1006 if (UNIT_VTABLE(u)->notify_message)
1007 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1015 static int manager_dispatch_sigchld(Manager *m) {
1025 /* First we call waitd() for a PID and do not reap the
1026 * zombie. That way we can still access /proc/$PID for
1027 * it while it is a zombie. */
1028 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1030 if (errno == ECHILD)
1042 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1045 get_process_comm(si.si_pid, &name);
1046 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1050 /* Let's flush any message the dying child might still
1051 * have queued for us. This ensures that the process
1052 * still exists in /proc so that we can figure out
1053 * which cgroup and hence unit it belongs to. */
1054 if ((r = manager_process_notify_fd(m)) < 0)
1057 /* And now figure out the unit this belongs to */
1058 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid))))
1059 u = cgroup_unit_by_pid(m, si.si_pid);
1061 /* And now, we actually reap the zombie. */
1062 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1069 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1072 log_debug("Child %lu died (code=%s, status=%i/%s)",
1073 (long unsigned) si.si_pid,
1074 sigchld_code_to_string(si.si_code),
1076 strna(si.si_code == CLD_EXITED
1077 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1078 : signal_to_string(si.si_status)));
1083 log_debug("Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1085 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1086 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1092 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1096 dbus_error_init(&error);
1098 log_debug("Activating special unit %s", name);
1100 if ((r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL)) < 0)
1101 log_error("Failed to enqueue %s job: %s", name, bus_error(&error, r));
1103 dbus_error_free(&error);
1108 static int manager_process_signal_fd(Manager *m) {
1110 struct signalfd_siginfo sfsi;
1111 bool sigchld = false;
1116 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
1121 if (errno == EINTR || errno == EAGAIN)
1127 if (sfsi.ssi_pid > 0) {
1130 get_process_comm(sfsi.ssi_pid, &p);
1132 log_debug("Received SIG%s from PID %lu (%s).",
1133 signal_to_string(sfsi.ssi_signo),
1134 (unsigned long) sfsi.ssi_pid, strna(p));
1137 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1139 switch (sfsi.ssi_signo) {
1146 if (m->running_as == MANAGER_SYSTEM) {
1147 /* This is for compatibility with the
1148 * original sysvinit */
1149 m->exit_code = MANAGER_REEXECUTE;
1156 if (m->running_as == MANAGER_SYSTEM) {
1157 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1161 /* Run the exit target if there is one, if not, just exit. */
1162 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1163 m->exit_code = MANAGER_EXIT;
1170 if (m->running_as == MANAGER_SYSTEM)
1171 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1173 /* This is a nop on non-init */
1177 if (m->running_as == MANAGER_SYSTEM)
1178 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1180 /* This is a nop on non-init */
1186 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1188 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1189 log_info("Trying to reconnect to bus...");
1193 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1194 log_info("Loading D-Bus service...");
1195 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1206 if (!(f = open_memstream(&dump, &size))) {
1207 log_warning("Failed to allocate memory stream.");
1211 manager_dump_units(m, f, "\t");
1212 manager_dump_jobs(m, f, "\t");
1217 log_warning("Failed to write status stream");
1222 log_dump(LOG_INFO, dump);
1229 m->exit_code = MANAGER_RELOAD;
1234 /* Starting SIGRTMIN+0 */
1235 static const char * const target_table[] = {
1236 [0] = SPECIAL_DEFAULT_TARGET,
1237 [1] = SPECIAL_RESCUE_TARGET,
1238 [2] = SPECIAL_EMERGENCY_TARGET,
1239 [3] = SPECIAL_HALT_TARGET,
1240 [4] = SPECIAL_POWEROFF_TARGET,
1241 [5] = SPECIAL_REBOOT_TARGET,
1242 [6] = SPECIAL_KEXEC_TARGET
1245 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1246 static const ManagerExitCode code_table[] = {
1248 [1] = MANAGER_POWEROFF,
1249 [2] = MANAGER_REBOOT,
1253 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1254 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1255 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1256 manager_start_target(m, target_table[idx],
1257 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1261 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1262 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1263 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1267 switch (sfsi.ssi_signo - SIGRTMIN) {
1270 log_debug("Enabling showing of status.");
1271 manager_set_show_status(m, true);
1275 log_debug("Disabling showing of status.");
1276 manager_set_show_status(m, false);
1280 log_set_max_level(LOG_DEBUG);
1281 log_notice("Setting log level to debug.");
1285 log_set_max_level(LOG_INFO);
1286 log_notice("Setting log level to info.");
1290 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1291 log_notice("Setting log target to journal-or-kmsg.");
1295 log_set_target(LOG_TARGET_CONSOLE);
1296 log_notice("Setting log target to console.");
1300 log_set_target(LOG_TARGET_KMSG);
1301 log_notice("Setting log target to kmsg.");
1305 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1306 log_notice("Setting log target to syslog-or-kmsg.");
1310 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1317 return manager_dispatch_sigchld(m);
1322 static int process_event(Manager *m, struct epoll_event *ev) {
1329 assert_se(w = ev->data.ptr);
1331 if (w->type == WATCH_INVALID)
1338 /* An incoming signal? */
1339 if (ev->events != EPOLLIN)
1342 if ((r = manager_process_signal_fd(m)) < 0)
1349 /* An incoming daemon notification event? */
1350 if (ev->events != EPOLLIN)
1353 if ((r = manager_process_notify_fd(m)) < 0)
1360 /* Some fd event, to be dispatched to the units */
1361 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1364 case WATCH_UNIT_TIMER:
1365 case WATCH_JOB_TIMER: {
1369 /* Some timer event, to be dispatched to the units */
1370 if ((k = read(w->fd, &v, sizeof(v))) != sizeof(v)) {
1372 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1375 return k < 0 ? -errno : -EIO;
1378 if (w->type == WATCH_UNIT_TIMER)
1379 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1381 job_timer_event(w->data.job, v, w);
1386 /* Some mount table change, intended for the mount subsystem */
1387 mount_fd_event(m, ev->events);
1391 /* Some swap table change, intended for the swap subsystem */
1392 swap_fd_event(m, ev->events);
1396 /* Some notification from udev, intended for the device subsystem */
1397 device_fd_event(m, ev->events);
1400 case WATCH_DBUS_WATCH:
1401 bus_watch_event(m, w, ev->events);
1404 case WATCH_DBUS_TIMEOUT:
1405 bus_timeout_event(m, w, ev->events);
1409 log_error("event type=%i", w->type);
1410 assert_not_reached("Unknown epoll event type.");
1416 int manager_loop(Manager *m) {
1419 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1422 m->exit_code = MANAGER_RUNNING;
1424 /* Release the path cache */
1425 set_free_free(m->unit_path_cache);
1426 m->unit_path_cache = NULL;
1428 manager_check_finished(m);
1430 /* There might still be some zombies hanging around from
1431 * before we were exec()'ed. Leat's reap them */
1432 r = manager_dispatch_sigchld(m);
1436 while (m->exit_code == MANAGER_RUNNING) {
1437 struct epoll_event event;
1441 if (m->runtime_watchdog > 0 && m->running_as == MANAGER_SYSTEM)
1444 if (!ratelimit_test(&rl)) {
1445 /* Yay, something is going seriously wrong, pause a little */
1446 log_warning("Looping too fast. Throttling execution a little.");
1451 if (manager_dispatch_load_queue(m) > 0)
1454 if (manager_dispatch_run_queue(m) > 0)
1457 if (bus_dispatch(m) > 0)
1460 if (manager_dispatch_cleanup_queue(m) > 0)
1463 if (manager_dispatch_gc_queue(m) > 0)
1466 if (manager_dispatch_dbus_queue(m) > 0)
1469 if (swap_dispatch_reload(m) > 0)
1472 /* Sleep for half the watchdog time */
1473 if (m->runtime_watchdog > 0 && m->running_as == MANAGER_SYSTEM) {
1474 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1480 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1492 r = process_event(m, &event);
1497 return m->exit_code;
1500 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1509 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1512 n = bus_path_unescape(s+31);
1516 r = manager_load_unit(m, n, NULL, e, &u);
1527 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1536 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1539 if ((r = safe_atou(s + 30, &id)) < 0)
1542 if (!(j = manager_get_job(m, id)))
1550 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1555 if (m->audit_fd < 0)
1558 /* Don't generate audit events if the service was already
1559 * started and we're just deserializing */
1560 if (m->n_reloading > 0)
1563 if (m->running_as != MANAGER_SYSTEM)
1566 if (u->type != UNIT_SERVICE)
1569 if (!(p = unit_name_to_prefix_and_instance(u->id))) {
1570 log_error("Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1574 if (audit_log_user_comm_message(m->audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1575 if (errno == EPERM) {
1576 /* We aren't allowed to send audit messages?
1577 * Then let's not retry again. */
1578 audit_close(m->audit_fd);
1581 log_warning("Failed to send audit message: %m");
1589 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1591 union sockaddr_union sa;
1593 char *message = NULL;
1595 /* Don't generate plymouth events if the service was already
1596 * started and we're just deserializing */
1597 if (m->n_reloading > 0)
1600 if (m->running_as != MANAGER_SYSTEM)
1603 if (u->type != UNIT_SERVICE &&
1604 u->type != UNIT_MOUNT &&
1605 u->type != UNIT_SWAP)
1608 /* We set SOCK_NONBLOCK here so that we rather drop the
1609 * message then wait for plymouth */
1610 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1611 log_error("socket() failed: %m");
1616 sa.sa.sa_family = AF_UNIX;
1617 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1618 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1620 if (errno != EPIPE &&
1623 errno != ECONNREFUSED &&
1624 errno != ECONNRESET &&
1625 errno != ECONNABORTED)
1626 log_error("connect() failed: %m");
1631 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1637 if (write(fd, message, n + 1) != n + 1) {
1639 if (errno != EPIPE &&
1642 errno != ECONNREFUSED &&
1643 errno != ECONNRESET &&
1644 errno != ECONNABORTED)
1645 log_error("Failed to write Plymouth message: %m");
1652 close_nointr_nofail(fd);
1657 void manager_dispatch_bus_name_owner_changed(
1660 const char* old_owner,
1661 const char *new_owner) {
1668 if (!(u = hashmap_get(m->watch_bus, name)))
1671 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1674 void manager_dispatch_bus_query_pid_done(
1685 if (!(u = hashmap_get(m->watch_bus, name)))
1688 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1691 int manager_open_serialization(Manager *m, FILE **_f) {
1699 if (m->running_as == MANAGER_SYSTEM)
1700 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1702 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1707 saved_umask = umask(0077);
1708 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1718 log_debug("Serializing state to %s", path);
1721 if (!(f = fdopen(fd, "w+")))
1729 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
1741 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1742 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1743 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1744 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1746 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1747 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1748 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1749 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1752 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1753 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1758 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1762 if (!unit_can_serialize(u))
1769 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
1775 assert(m->n_reloading > 0);
1781 r = bus_fdset_add_all(m, fds);
1788 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1794 log_debug("Deserializing state...");
1799 char line[LINE_MAX], *l;
1801 if (!fgets(line, sizeof(line), f)) {
1816 if (startswith(l, "current-job-id=")) {
1819 if (safe_atou32(l+15, &id) < 0)
1820 log_debug("Failed to parse current job id value %s", l+15);
1822 m->current_job_id = MAX(m->current_job_id, id);
1823 } else if (startswith(l, "n-installed-jobs=")) {
1826 if (safe_atou32(l+17, &n) < 0)
1827 log_debug("Failed to parse installed jobs counter %s", l+17);
1829 m->n_installed_jobs += n;
1830 } else if (startswith(l, "n-failed-jobs=")) {
1833 if (safe_atou32(l+14, &n) < 0)
1834 log_debug("Failed to parse failed jobs counter %s", l+14);
1836 m->n_failed_jobs += n;
1837 } else if (startswith(l, "taint-usr=")) {
1840 if ((b = parse_boolean(l+10)) < 0)
1841 log_debug("Failed to parse taint /usr flag %s", l+10);
1843 m->taint_usr = m->taint_usr || b;
1844 } else if (startswith(l, "firmware-timestamp="))
1845 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
1846 else if (startswith(l, "loader-timestamp="))
1847 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
1848 else if (startswith(l, "kernel-timestamp="))
1849 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
1850 else if (startswith(l, "initrd-timestamp="))
1851 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1852 else if (startswith(l, "userspace-timestamp="))
1853 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
1854 else if (startswith(l, "finish-timestamp="))
1855 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1857 log_debug("Unknown serialization item '%s'", l);
1862 char name[UNIT_NAME_MAX+2];
1865 if (!fgets(name, sizeof(name), f)) {
1876 if ((r = manager_load_unit(m, strstrip(name), NULL, NULL, &u)) < 0)
1879 if ((r = unit_deserialize(u, f, fds)) < 0)
1889 assert(m->n_reloading > 0);
1895 int manager_reload(Manager *m) {
1902 r = manager_open_serialization(m, &f);
1915 r = manager_serialize(m, f, fds, true);
1921 if (fseeko(f, 0, SEEK_SET) < 0) {
1927 /* From here on there is no way back. */
1928 manager_clear_jobs_and_units(m);
1929 manager_undo_generators(m);
1930 lookup_paths_free(&m->lookup_paths);
1932 /* Find new unit paths */
1933 manager_run_generators(m);
1935 q = lookup_paths_init(
1936 &m->lookup_paths, m->running_as, true,
1937 m->generator_unit_path,
1938 m->generator_unit_path_early,
1939 m->generator_unit_path_late);
1943 manager_build_unit_path_cache(m);
1945 /* First, enumerate what we can from all config files */
1946 q = manager_enumerate(m);
1950 /* Second, deserialize our stored data */
1951 q = manager_deserialize(m, f, fds);
1958 /* Third, fire things up! */
1959 q = manager_coldplug(m);
1963 assert(m->n_reloading > 0);
1976 bool manager_is_booting_or_shutting_down(Manager *m) {
1981 /* Is the initial job still around? */
1982 if (manager_get_job(m, m->default_unit_job_id))
1985 /* Is there a job for the shutdown target? */
1986 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
1993 void manager_reset_failed(Manager *m) {
1999 HASHMAP_FOREACH(u, m->units, i)
2000 unit_reset_failed(u);
2003 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2009 /* Returns true if the unit is inactive or going down */
2010 if (!(u = manager_get_unit(m, name)))
2013 return unit_pending_inactive(u);
2016 void manager_check_finished(Manager *m) {
2017 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2018 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2022 if (hashmap_size(m->jobs) > 0)
2025 /* Notify Type=idle units that we are done now */
2026 close_pipe(m->idle_pipe);
2028 /* Turn off confirm spawn now */
2029 m->confirm_spawn = false;
2031 if (dual_timestamp_is_set(&m->finish_timestamp))
2034 dual_timestamp_get(&m->finish_timestamp);
2036 if (m->running_as == MANAGER_SYSTEM && detect_container(NULL) <= 0) {
2038 /* Note that m->kernel_usec.monotonic is always at 0,
2039 * and m->firmware_usec.monotonic and
2040 * m->loader_usec.monotonic should be considered
2041 * negative values. */
2043 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2044 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2045 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2046 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2048 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2050 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2051 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2053 if (!log_on_console())
2054 log_struct(LOG_INFO,
2055 "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(SD_MESSAGE_STARTUP_FINISHED),
2056 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2057 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2058 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2059 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2060 format_timespan(kernel, sizeof(kernel), kernel_usec),
2061 format_timespan(initrd, sizeof(initrd), initrd_usec),
2062 format_timespan(userspace, sizeof(userspace), userspace_usec),
2063 format_timespan(sum, sizeof(sum), total_usec),
2066 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2069 if (!log_on_console())
2070 log_struct(LOG_INFO,
2071 "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(SD_MESSAGE_STARTUP_FINISHED),
2072 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2073 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2074 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2075 format_timespan(kernel, sizeof(kernel), kernel_usec),
2076 format_timespan(userspace, sizeof(userspace), userspace_usec),
2077 format_timespan(sum, sizeof(sum), total_usec),
2081 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2082 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2084 if (!log_on_console())
2085 log_struct(LOG_INFO,
2086 "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(SD_MESSAGE_STARTUP_FINISHED),
2087 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2088 "MESSAGE=Startup finished in %s.",
2089 format_timespan(sum, sizeof(sum), total_usec),
2093 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2096 "READY=1\nSTATUS=Startup finished in %s.",
2097 format_timespan(sum, sizeof(sum), total_usec));
2100 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2111 if (m->running_as == MANAGER_SYSTEM && getpid() == 1) {
2113 p = strappend("/run/systemd/", name);
2117 r = mkdir_p_label(p, 0755);
2119 log_error("Failed to create generator directory: %s", strerror(-r));
2124 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2130 log_error("Failed to create generator directory: %m");
2139 static void trim_generator_dir(Manager *m, char **generator) {
2146 if (rmdir(*generator) >= 0) {
2154 void manager_run_generators(Manager *m) {
2156 const char *generator_path;
2157 const char *argv[5];
2163 generator_path = m->running_as == MANAGER_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2164 d = opendir(generator_path);
2166 if (errno == ENOENT)
2169 log_error("Failed to enumerate generator directory: %m");
2173 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2177 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2181 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2185 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2186 argv[1] = m->generator_unit_path;
2187 argv[2] = m->generator_unit_path_early;
2188 argv[3] = m->generator_unit_path_late;
2192 execute_directory(generator_path, d, (char**) argv);
2195 trim_generator_dir(m, &m->generator_unit_path);
2196 trim_generator_dir(m, &m->generator_unit_path_early);
2197 trim_generator_dir(m, &m->generator_unit_path_late);
2204 static void remove_generator_dir(Manager *m, char **generator) {
2211 strv_remove(m->lookup_paths.unit_path, *generator);
2212 rm_rf(*generator, false, true, false);
2218 void manager_undo_generators(Manager *m) {
2221 remove_generator_dir(m, &m->generator_unit_path);
2222 remove_generator_dir(m, &m->generator_unit_path_early);
2223 remove_generator_dir(m, &m->generator_unit_path_late);
2226 int manager_set_default_controllers(Manager *m, char **controllers) {
2231 l = strv_copy(controllers);
2235 strv_free(m->default_controllers);
2236 m->default_controllers = l;
2238 cg_shorten_controllers(m->default_controllers);
2243 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2248 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2249 if (!default_rlimit[i])
2252 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2260 void manager_recheck_journal(Manager *m) {
2265 if (m->running_as != MANAGER_SYSTEM)
2268 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2269 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2270 log_close_journal();
2274 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2275 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2276 log_close_journal();
2280 /* Hmm, OK, so the socket is fully up and the service is up
2281 * too, then let's make use of the thing. */
2285 void manager_set_show_status(Manager *m, bool b) {
2288 if (m->running_as != MANAGER_SYSTEM)
2294 touch("/run/systemd/show-status");
2296 unlink("/run/systemd/show-status");
2299 bool manager_get_show_status(Manager *m) {
2302 if (m->running_as != MANAGER_SYSTEM)
2308 /* If Plymouth is running make sure we show the status, so
2309 * that there's something nice to see when people press Esc */
2311 return plymouth_running();
2314 static const char* const manager_running_as_table[_MANAGER_RUNNING_AS_MAX] = {
2315 [MANAGER_SYSTEM] = "system",
2316 [MANAGER_USER] = "user"
2319 DEFINE_STRING_TABLE_LOOKUP(manager_running_as, ManagerRunningAs);