1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
25 #include <sys/epoll.h>
27 #include <sys/signalfd.h>
31 #include <sys/reboot.h>
32 #include <sys/ioctl.h>
36 #include <sys/types.h>
44 #include "systemd/sd-daemon.h"
45 #include "systemd/sd-id128.h"
46 #include "systemd/sd-messages.h"
49 #include "transaction.h"
56 #include "ratelimit.h"
58 #include "mount-setup.h"
59 #include "unit-name.h"
60 #include "dbus-unit.h"
63 #include "path-lookup.h"
65 #include "bus-errors.h"
66 #include "exit-status.h"
69 #include "cgroup-util.h"
70 #include "path-util.h"
72 /* As soon as 16 units are in our GC queue, make sure to run a gc sweep */
73 #define GC_QUEUE_ENTRIES_MAX 16
75 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
76 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
78 /* Where clients shall send notification messages to */
79 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
81 static int manager_setup_notify(Manager *m) {
84 struct sockaddr_un un;
86 struct epoll_event ev;
91 m->notify_watch.type = WATCH_NOTIFY;
92 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
93 if (m->notify_watch.fd < 0) {
94 log_error("Failed to allocate notification socket: %m");
99 sa.sa.sa_family = AF_UNIX;
101 if (getpid() != 1 || detect_container(NULL) > 0)
102 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
104 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
106 sa.un.sun_path[0] = 0;
108 if (bind(m->notify_watch.fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
109 log_error("bind() failed: %m");
113 if (setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0) {
114 log_error("SO_PASSCRED failed: %m");
120 ev.data.ptr = &m->notify_watch;
122 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev) < 0)
125 sa.un.sun_path[0] = '@';
126 m->notify_socket = strdup(sa.un.sun_path);
127 if (!m->notify_socket)
130 log_debug("Using notification socket %s", m->notify_socket);
135 static int enable_special_signals(Manager *m) {
140 /* Enable that we get SIGINT on control-alt-del. In containers
141 * this will fail with EPERM, so ignore that. */
142 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM)
143 log_warning("Failed to enable ctrl-alt-del handling: %m");
145 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
147 /* Support systems without virtual console */
149 log_warning("Failed to open /dev/tty0: %m");
151 /* Enable that we get SIGWINCH on kbrequest */
152 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
153 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
155 close_nointr_nofail(fd);
161 static int manager_setup_signals(Manager *m) {
163 struct epoll_event ev;
168 /* We are not interested in SIGSTOP and friends. */
170 sa.sa_handler = SIG_DFL;
171 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
172 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
174 assert_se(sigemptyset(&mask) == 0);
176 sigset_add_many(&mask,
177 SIGCHLD, /* Child died */
178 SIGTERM, /* Reexecute daemon */
179 SIGHUP, /* Reload configuration */
180 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
181 SIGUSR2, /* systemd: dump status */
182 SIGINT, /* Kernel sends us this on control-alt-del */
183 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
184 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
185 SIGRTMIN+0, /* systemd: start default.target */
186 SIGRTMIN+1, /* systemd: isolate rescue.target */
187 SIGRTMIN+2, /* systemd: isolate emergency.target */
188 SIGRTMIN+3, /* systemd: start halt.target */
189 SIGRTMIN+4, /* systemd: start poweroff.target */
190 SIGRTMIN+5, /* systemd: start reboot.target */
191 SIGRTMIN+6, /* systemd: start kexec.target */
192 SIGRTMIN+13, /* systemd: Immediate halt */
193 SIGRTMIN+14, /* systemd: Immediate poweroff */
194 SIGRTMIN+15, /* systemd: Immediate reboot */
195 SIGRTMIN+16, /* systemd: Immediate kexec */
196 SIGRTMIN+20, /* systemd: enable status messages */
197 SIGRTMIN+21, /* systemd: disable status messages */
198 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
199 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
200 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
201 SIGRTMIN+27, /* systemd: set log target to console */
202 SIGRTMIN+28, /* systemd: set log target to kmsg */
203 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
205 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
207 m->signal_watch.type = WATCH_SIGNAL;
208 if ((m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC)) < 0)
213 ev.data.ptr = &m->signal_watch;
215 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
218 if (m->running_as == MANAGER_SYSTEM)
219 return enable_special_signals(m);
224 static void manager_strip_environment(Manager *m) {
227 /* Remove variables from the inherited set that are part of
228 * the container interface:
229 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
230 strv_remove_prefix(m->environment, "container=");
231 strv_remove_prefix(m->environment, "container_");
233 /* Remove variables from the inherited set that are part of
234 * the initrd interface:
235 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
236 strv_remove_prefix(m->environment, "RD_");
239 int manager_new(ManagerRunningAs running_as, Manager **_m) {
244 assert(running_as >= 0);
245 assert(running_as < _MANAGER_RUNNING_AS_MAX);
247 m = new0(Manager, 1);
251 dual_timestamp_get(&m->userspace_timestamp);
253 m->running_as = running_as;
254 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
255 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
256 m->pin_cgroupfs_fd = -1;
257 m->idle_pipe[0] = m->idle_pipe[1] = -1;
263 m->signal_watch.fd = m->mount_watch.fd = m->udev_watch.fd = m->epoll_fd = m->dev_autofs_fd = m->swap_watch.fd = -1;
264 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
266 m->environment = strv_copy(environ);
270 manager_strip_environment(m);
272 if (running_as == MANAGER_SYSTEM) {
273 m->default_controllers = strv_new("cpu", NULL);
274 if (!m->default_controllers)
278 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
281 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
284 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
287 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
290 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
293 if ((m->epoll_fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
296 if ((r = manager_setup_signals(m)) < 0)
299 if ((r = manager_setup_cgroup(m)) < 0)
302 if ((r = manager_setup_notify(m)) < 0)
305 /* Try to connect to the busses, if possible. */
306 if ((r = bus_init(m, running_as != MANAGER_SYSTEM)) < 0)
310 if ((m->audit_fd = audit_open()) < 0 &&
311 /* If the kernel lacks netlink or audit support,
312 * don't worry about it. */
313 errno != EAFNOSUPPORT && errno != EPROTONOSUPPORT)
314 log_error("Failed to connect to audit log: %m");
317 m->taint_usr = dir_is_empty("/usr") > 0;
327 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
333 while ((u = m->cleanup_queue)) {
334 assert(u->in_cleanup_queue);
344 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
345 GC_OFFSET_UNSURE, /* No clue */
346 GC_OFFSET_GOOD, /* We still need this unit */
347 GC_OFFSET_BAD, /* We don't need this unit anymore */
351 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
358 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
359 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
360 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
363 if (u->in_cleanup_queue)
366 if (unit_check_gc(u))
369 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
373 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
374 unit_gc_sweep(other, gc_marker);
376 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
379 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
386 /* We were unable to find anything out about this entry, so
387 * let's investigate it later */
388 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
389 unit_add_to_gc_queue(u);
393 /* We definitely know that this one is not useful anymore, so
394 * let's mark it for deletion */
395 u->gc_marker = gc_marker + GC_OFFSET_BAD;
396 unit_add_to_cleanup_queue(u);
400 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
403 static unsigned manager_dispatch_gc_queue(Manager *m) {
410 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
411 (m->gc_queue_timestamp <= 0 ||
412 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
415 log_debug("Running GC...");
417 m->gc_marker += _GC_OFFSET_MAX;
418 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
421 gc_marker = m->gc_marker;
423 while ((u = m->gc_queue)) {
424 assert(u->in_gc_queue);
426 unit_gc_sweep(u, gc_marker);
428 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
429 u->in_gc_queue = false;
433 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
434 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
435 log_debug("Collecting %s", u->id);
436 u->gc_marker = gc_marker + GC_OFFSET_BAD;
437 unit_add_to_cleanup_queue(u);
441 m->n_in_gc_queue = 0;
442 m->gc_queue_timestamp = 0;
447 static void manager_clear_jobs_and_units(Manager *m) {
452 while ((u = hashmap_first(m->units)))
455 manager_dispatch_cleanup_queue(m);
457 assert(!m->load_queue);
458 assert(!m->run_queue);
459 assert(!m->dbus_unit_queue);
460 assert(!m->dbus_job_queue);
461 assert(!m->cleanup_queue);
462 assert(!m->gc_queue);
464 assert(hashmap_isempty(m->jobs));
465 assert(hashmap_isempty(m->units));
468 void manager_free(Manager *m) {
474 manager_clear_jobs_and_units(m);
476 for (c = 0; c < _UNIT_TYPE_MAX; c++)
477 if (unit_vtable[c]->shutdown)
478 unit_vtable[c]->shutdown(m);
480 /* If we reexecute ourselves, we keep the root cgroup
482 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
484 manager_undo_generators(m);
488 hashmap_free(m->units);
489 hashmap_free(m->jobs);
490 hashmap_free(m->watch_pids);
491 hashmap_free(m->watch_bus);
493 if (m->epoll_fd >= 0)
494 close_nointr_nofail(m->epoll_fd);
495 if (m->signal_watch.fd >= 0)
496 close_nointr_nofail(m->signal_watch.fd);
497 if (m->notify_watch.fd >= 0)
498 close_nointr_nofail(m->notify_watch.fd);
501 if (m->audit_fd >= 0)
502 audit_close(m->audit_fd);
505 free(m->notify_socket);
507 lookup_paths_free(&m->lookup_paths);
508 strv_free(m->environment);
510 strv_free(m->default_controllers);
512 hashmap_free(m->cgroup_bondings);
513 set_free_free(m->unit_path_cache);
515 close_pipe(m->idle_pipe);
517 free(m->switch_root);
518 free(m->switch_root_init);
520 for (i = 0; i < RLIMIT_NLIMITS; i++)
526 int manager_enumerate(Manager *m) {
532 /* Let's ask every type to load all units from disk/kernel
533 * that it might know */
534 for (c = 0; c < _UNIT_TYPE_MAX; c++)
535 if (unit_vtable[c]->enumerate)
536 if ((q = unit_vtable[c]->enumerate(m)) < 0)
539 manager_dispatch_load_queue(m);
543 int manager_coldplug(Manager *m) {
551 /* Then, let's set up their initial state. */
552 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
558 if ((q = unit_coldplug(u)) < 0)
565 static void manager_build_unit_path_cache(Manager *m) {
572 set_free_free(m->unit_path_cache);
574 if (!(m->unit_path_cache = set_new(string_hash_func, string_compare_func))) {
575 log_error("Failed to allocate unit path cache.");
579 /* This simply builds a list of files we know exist, so that
580 * we don't always have to go to disk */
582 STRV_FOREACH(i, m->lookup_paths.unit_path) {
585 if (!(d = opendir(*i))) {
586 log_error("Failed to open directory: %m");
590 while ((de = readdir(d))) {
593 if (ignore_file(de->d_name))
596 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
602 if ((r = set_put(m->unit_path_cache, p)) < 0) {
615 log_error("Failed to build unit path cache: %s", strerror(-r));
617 set_free_free(m->unit_path_cache);
618 m->unit_path_cache = NULL;
624 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
629 manager_run_generators(m);
631 r = lookup_paths_init(
632 &m->lookup_paths, m->running_as, true,
633 m->generator_unit_path,
634 m->generator_unit_path_early,
635 m->generator_unit_path_late);
639 manager_build_unit_path_cache(m);
641 /* If we will deserialize make sure that during enumeration
642 * this is already known, so we increase the counter here
647 /* First, enumerate what we can from all config files */
648 r = manager_enumerate(m);
650 /* Second, deserialize if there is something to deserialize */
652 q = manager_deserialize(m, serialization, fds);
657 /* Third, fire things up! */
658 q = manager_coldplug(m);
663 assert(m->n_reloading > 0);
670 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
675 assert(type < _JOB_TYPE_MAX);
677 assert(mode < _JOB_MODE_MAX);
679 if (mode == JOB_ISOLATE && type != JOB_START) {
680 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
684 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
685 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
689 log_debug("Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
691 job_type_collapse(&type, unit);
693 tr = transaction_new();
697 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
698 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
699 mode == JOB_IGNORE_DEPENDENCIES, e);
703 if (mode == JOB_ISOLATE) {
704 r = transaction_add_isolate_jobs(tr, m);
709 r = transaction_activate(tr, m, mode, e);
713 log_debug("Enqueued job %s/%s as %u", unit->id, job_type_to_string(type), (unsigned) tr->anchor_job->id);
716 *_ret = tr->anchor_job;
718 transaction_free(tr);
722 transaction_abort(tr);
723 transaction_free(tr);
727 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
732 assert(type < _JOB_TYPE_MAX);
734 assert(mode < _JOB_MODE_MAX);
736 if ((r = manager_load_unit(m, name, NULL, NULL, &unit)) < 0)
739 return manager_add_job(m, type, unit, mode, override, e, _ret);
742 Job *manager_get_job(Manager *m, uint32_t id) {
745 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
748 Unit *manager_get_unit(Manager *m, const char *name) {
752 return hashmap_get(m->units, name);
755 unsigned manager_dispatch_load_queue(Manager *m) {
761 /* Make sure we are not run recursively */
762 if (m->dispatching_load_queue)
765 m->dispatching_load_queue = true;
767 /* Dispatches the load queue. Takes a unit from the queue and
768 * tries to load its data until the queue is empty */
770 while ((u = m->load_queue)) {
771 assert(u->in_load_queue);
777 m->dispatching_load_queue = false;
781 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
787 assert(name || path);
789 /* This will prepare the unit for loading, but not actually
790 * load anything from disk. */
792 if (path && !is_path(path)) {
793 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
798 name = path_get_file_name(path);
800 t = unit_name_to_type(name);
802 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
803 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
807 ret = manager_get_unit(m, name);
813 ret = unit_new(m, unit_vtable[t]->object_size);
818 ret->fragment_path = strdup(path);
819 if (!ret->fragment_path) {
825 if ((r = unit_add_name(ret, name)) < 0) {
830 unit_add_to_load_queue(ret);
831 unit_add_to_dbus_queue(ret);
832 unit_add_to_gc_queue(ret);
840 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
845 /* This will load the service information files, but not actually
846 * start any services or anything. */
848 if ((r = manager_load_unit_prepare(m, name, path, e, _ret)) != 0)
851 manager_dispatch_load_queue(m);
854 *_ret = unit_follow_merge(*_ret);
859 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
866 HASHMAP_FOREACH(j, s->jobs, i)
867 job_dump(j, f, prefix);
870 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
878 HASHMAP_FOREACH_KEY(u, t, s->units, i)
880 unit_dump(u, f, prefix);
883 void manager_clear_jobs(Manager *m) {
888 while ((j = hashmap_first(m->jobs)))
889 /* No need to recurse. We're cancelling all jobs. */
890 job_finish_and_invalidate(j, JOB_CANCELED, false);
893 unsigned manager_dispatch_run_queue(Manager *m) {
897 if (m->dispatching_run_queue)
900 m->dispatching_run_queue = true;
902 while ((j = m->run_queue)) {
903 assert(j->installed);
904 assert(j->in_run_queue);
906 job_run_and_invalidate(j);
910 m->dispatching_run_queue = false;
914 unsigned manager_dispatch_dbus_queue(Manager *m) {
921 if (m->dispatching_dbus_queue)
924 m->dispatching_dbus_queue = true;
926 while ((u = m->dbus_unit_queue)) {
927 assert(u->in_dbus_queue);
929 bus_unit_send_change_signal(u);
933 while ((j = m->dbus_job_queue)) {
934 assert(j->in_dbus_queue);
936 bus_job_send_change_signal(j);
940 m->dispatching_dbus_queue = false;
944 static int manager_process_notify_fd(Manager *m) {
951 struct msghdr msghdr;
955 struct cmsghdr cmsghdr;
956 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
962 iovec.iov_base = buf;
963 iovec.iov_len = sizeof(buf)-1;
967 msghdr.msg_iov = &iovec;
968 msghdr.msg_iovlen = 1;
969 msghdr.msg_control = &control;
970 msghdr.msg_controllen = sizeof(control);
972 if ((n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT)) <= 0) {
976 if (errno == EAGAIN || errno == EINTR)
982 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
983 control.cmsghdr.cmsg_level != SOL_SOCKET ||
984 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
985 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
986 log_warning("Received notify message without credentials. Ignoring.");
990 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
992 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid))))
993 if (!(u = cgroup_unit_by_pid(m, ucred->pid))) {
994 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
998 assert((size_t) n < sizeof(buf));
1000 if (!(tags = strv_split(buf, "\n\r")))
1003 log_debug("Got notification message for unit %s", u->id);
1005 if (UNIT_VTABLE(u)->notify_message)
1006 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1014 static int manager_dispatch_sigchld(Manager *m) {
1024 /* First we call waitd() for a PID and do not reap the
1025 * zombie. That way we can still access /proc/$PID for
1026 * it while it is a zombie. */
1027 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1029 if (errno == ECHILD)
1041 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1044 get_process_comm(si.si_pid, &name);
1045 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1049 /* Let's flush any message the dying child might still
1050 * have queued for us. This ensures that the process
1051 * still exists in /proc so that we can figure out
1052 * which cgroup and hence unit it belongs to. */
1053 if ((r = manager_process_notify_fd(m)) < 0)
1056 /* And now figure out the unit this belongs to */
1057 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid))))
1058 u = cgroup_unit_by_pid(m, si.si_pid);
1060 /* And now, we actually reap the zombie. */
1061 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1068 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1071 log_debug("Child %lu died (code=%s, status=%i/%s)",
1072 (long unsigned) si.si_pid,
1073 sigchld_code_to_string(si.si_code),
1075 strna(si.si_code == CLD_EXITED
1076 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1077 : signal_to_string(si.si_status)));
1082 log_debug("Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1084 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1085 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1091 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1095 dbus_error_init(&error);
1097 log_debug("Activating special unit %s", name);
1099 if ((r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL)) < 0)
1100 log_error("Failed to enqueue %s job: %s", name, bus_error(&error, r));
1102 dbus_error_free(&error);
1107 static int manager_process_signal_fd(Manager *m) {
1109 struct signalfd_siginfo sfsi;
1110 bool sigchld = false;
1115 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
1120 if (errno == EINTR || errno == EAGAIN)
1126 if (sfsi.ssi_pid > 0) {
1129 get_process_comm(sfsi.ssi_pid, &p);
1131 log_debug("Received SIG%s from PID %lu (%s).",
1132 signal_to_string(sfsi.ssi_signo),
1133 (unsigned long) sfsi.ssi_pid, strna(p));
1136 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1138 switch (sfsi.ssi_signo) {
1145 if (m->running_as == MANAGER_SYSTEM) {
1146 /* This is for compatibility with the
1147 * original sysvinit */
1148 m->exit_code = MANAGER_REEXECUTE;
1155 if (m->running_as == MANAGER_SYSTEM) {
1156 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1160 /* Run the exit target if there is one, if not, just exit. */
1161 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1162 m->exit_code = MANAGER_EXIT;
1169 if (m->running_as == MANAGER_SYSTEM)
1170 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1172 /* This is a nop on non-init */
1176 if (m->running_as == MANAGER_SYSTEM)
1177 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1179 /* This is a nop on non-init */
1185 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1187 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1188 log_info("Trying to reconnect to bus...");
1192 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1193 log_info("Loading D-Bus service...");
1194 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1205 if (!(f = open_memstream(&dump, &size))) {
1206 log_warning("Failed to allocate memory stream.");
1210 manager_dump_units(m, f, "\t");
1211 manager_dump_jobs(m, f, "\t");
1216 log_warning("Failed to write status stream");
1221 log_dump(LOG_INFO, dump);
1228 m->exit_code = MANAGER_RELOAD;
1233 /* Starting SIGRTMIN+0 */
1234 static const char * const target_table[] = {
1235 [0] = SPECIAL_DEFAULT_TARGET,
1236 [1] = SPECIAL_RESCUE_TARGET,
1237 [2] = SPECIAL_EMERGENCY_TARGET,
1238 [3] = SPECIAL_HALT_TARGET,
1239 [4] = SPECIAL_POWEROFF_TARGET,
1240 [5] = SPECIAL_REBOOT_TARGET,
1241 [6] = SPECIAL_KEXEC_TARGET
1244 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1245 static const ManagerExitCode code_table[] = {
1247 [1] = MANAGER_POWEROFF,
1248 [2] = MANAGER_REBOOT,
1252 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1253 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1254 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1255 manager_start_target(m, target_table[idx],
1256 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1260 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1261 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1262 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1266 switch (sfsi.ssi_signo - SIGRTMIN) {
1269 log_debug("Enabling showing of status.");
1270 manager_set_show_status(m, true);
1274 log_debug("Disabling showing of status.");
1275 manager_set_show_status(m, false);
1279 log_set_max_level(LOG_DEBUG);
1280 log_notice("Setting log level to debug.");
1284 log_set_max_level(LOG_INFO);
1285 log_notice("Setting log level to info.");
1289 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1290 log_notice("Setting log target to journal-or-kmsg.");
1294 log_set_target(LOG_TARGET_CONSOLE);
1295 log_notice("Setting log target to console.");
1299 log_set_target(LOG_TARGET_KMSG);
1300 log_notice("Setting log target to kmsg.");
1304 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1305 log_notice("Setting log target to syslog-or-kmsg.");
1309 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1316 return manager_dispatch_sigchld(m);
1321 static int process_event(Manager *m, struct epoll_event *ev) {
1328 assert_se(w = ev->data.ptr);
1330 if (w->type == WATCH_INVALID)
1337 /* An incoming signal? */
1338 if (ev->events != EPOLLIN)
1341 if ((r = manager_process_signal_fd(m)) < 0)
1348 /* An incoming daemon notification event? */
1349 if (ev->events != EPOLLIN)
1352 if ((r = manager_process_notify_fd(m)) < 0)
1359 /* Some fd event, to be dispatched to the units */
1360 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1363 case WATCH_UNIT_TIMER:
1364 case WATCH_JOB_TIMER: {
1368 /* Some timer event, to be dispatched to the units */
1369 if ((k = read(w->fd, &v, sizeof(v))) != sizeof(v)) {
1371 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1374 return k < 0 ? -errno : -EIO;
1377 if (w->type == WATCH_UNIT_TIMER)
1378 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1380 job_timer_event(w->data.job, v, w);
1385 /* Some mount table change, intended for the mount subsystem */
1386 mount_fd_event(m, ev->events);
1390 /* Some swap table change, intended for the swap subsystem */
1391 swap_fd_event(m, ev->events);
1395 /* Some notification from udev, intended for the device subsystem */
1396 device_fd_event(m, ev->events);
1399 case WATCH_DBUS_WATCH:
1400 bus_watch_event(m, w, ev->events);
1403 case WATCH_DBUS_TIMEOUT:
1404 bus_timeout_event(m, w, ev->events);
1408 log_error("event type=%i", w->type);
1409 assert_not_reached("Unknown epoll event type.");
1415 int manager_loop(Manager *m) {
1418 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1421 m->exit_code = MANAGER_RUNNING;
1423 /* Release the path cache */
1424 set_free_free(m->unit_path_cache);
1425 m->unit_path_cache = NULL;
1427 manager_check_finished(m);
1429 /* There might still be some zombies hanging around from
1430 * before we were exec()'ed. Leat's reap them */
1431 r = manager_dispatch_sigchld(m);
1435 while (m->exit_code == MANAGER_RUNNING) {
1436 struct epoll_event event;
1440 if (m->runtime_watchdog > 0 && m->running_as == MANAGER_SYSTEM)
1443 if (!ratelimit_test(&rl)) {
1444 /* Yay, something is going seriously wrong, pause a little */
1445 log_warning("Looping too fast. Throttling execution a little.");
1450 if (manager_dispatch_load_queue(m) > 0)
1453 if (manager_dispatch_run_queue(m) > 0)
1456 if (bus_dispatch(m) > 0)
1459 if (manager_dispatch_cleanup_queue(m) > 0)
1462 if (manager_dispatch_gc_queue(m) > 0)
1465 if (manager_dispatch_dbus_queue(m) > 0)
1468 if (swap_dispatch_reload(m) > 0)
1471 /* Sleep for half the watchdog time */
1472 if (m->runtime_watchdog > 0 && m->running_as == MANAGER_SYSTEM) {
1473 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1479 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1491 r = process_event(m, &event);
1496 return m->exit_code;
1499 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1508 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1511 n = bus_path_unescape(s+31);
1515 r = manager_load_unit(m, n, NULL, e, &u);
1526 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1535 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1538 if ((r = safe_atou(s + 30, &id)) < 0)
1541 if (!(j = manager_get_job(m, id)))
1549 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1554 if (m->audit_fd < 0)
1557 /* Don't generate audit events if the service was already
1558 * started and we're just deserializing */
1559 if (m->n_reloading > 0)
1562 if (m->running_as != MANAGER_SYSTEM)
1565 if (u->type != UNIT_SERVICE)
1568 if (!(p = unit_name_to_prefix_and_instance(u->id))) {
1569 log_error("Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1573 if (audit_log_user_comm_message(m->audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1574 if (errno == EPERM) {
1575 /* We aren't allowed to send audit messages?
1576 * Then let's not retry again. */
1577 audit_close(m->audit_fd);
1580 log_warning("Failed to send audit message: %m");
1588 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1590 union sockaddr_union sa;
1592 char *message = NULL;
1594 /* Don't generate plymouth events if the service was already
1595 * started and we're just deserializing */
1596 if (m->n_reloading > 0)
1599 if (m->running_as != MANAGER_SYSTEM)
1602 if (u->type != UNIT_SERVICE &&
1603 u->type != UNIT_MOUNT &&
1604 u->type != UNIT_SWAP)
1607 /* We set SOCK_NONBLOCK here so that we rather drop the
1608 * message then wait for plymouth */
1609 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1610 log_error("socket() failed: %m");
1615 sa.sa.sa_family = AF_UNIX;
1616 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1617 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1619 if (errno != EPIPE &&
1622 errno != ECONNREFUSED &&
1623 errno != ECONNRESET &&
1624 errno != ECONNABORTED)
1625 log_error("connect() failed: %m");
1630 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1636 if (write(fd, message, n + 1) != n + 1) {
1638 if (errno != EPIPE &&
1641 errno != ECONNREFUSED &&
1642 errno != ECONNRESET &&
1643 errno != ECONNABORTED)
1644 log_error("Failed to write Plymouth message: %m");
1651 close_nointr_nofail(fd);
1656 void manager_dispatch_bus_name_owner_changed(
1659 const char* old_owner,
1660 const char *new_owner) {
1667 if (!(u = hashmap_get(m->watch_bus, name)))
1670 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1673 void manager_dispatch_bus_query_pid_done(
1684 if (!(u = hashmap_get(m->watch_bus, name)))
1687 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1690 int manager_open_serialization(Manager *m, FILE **_f) {
1698 if (m->running_as == MANAGER_SYSTEM)
1699 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1701 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1706 saved_umask = umask(0077);
1707 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1717 log_debug("Serializing state to %s", path);
1720 if (!(f = fdopen(fd, "w+")))
1728 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
1740 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1741 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1742 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1743 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1745 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1746 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1747 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1748 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1751 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1752 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1757 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1761 if (!unit_can_serialize(u))
1768 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
1774 assert(m->n_reloading > 0);
1780 r = bus_fdset_add_all(m, fds);
1787 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1793 log_debug("Deserializing state...");
1798 char line[LINE_MAX], *l;
1800 if (!fgets(line, sizeof(line), f)) {
1815 if (startswith(l, "current-job-id=")) {
1818 if (safe_atou32(l+15, &id) < 0)
1819 log_debug("Failed to parse current job id value %s", l+15);
1821 m->current_job_id = MAX(m->current_job_id, id);
1822 } else if (startswith(l, "n-installed-jobs=")) {
1825 if (safe_atou32(l+17, &n) < 0)
1826 log_debug("Failed to parse installed jobs counter %s", l+17);
1828 m->n_installed_jobs += n;
1829 } else if (startswith(l, "n-failed-jobs=")) {
1832 if (safe_atou32(l+14, &n) < 0)
1833 log_debug("Failed to parse failed jobs counter %s", l+14);
1835 m->n_failed_jobs += n;
1836 } else if (startswith(l, "taint-usr=")) {
1839 if ((b = parse_boolean(l+10)) < 0)
1840 log_debug("Failed to parse taint /usr flag %s", l+10);
1842 m->taint_usr = m->taint_usr || b;
1843 } else if (startswith(l, "firmware-timestamp="))
1844 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
1845 else if (startswith(l, "loader-timestamp="))
1846 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
1847 else if (startswith(l, "kernel-timestamp="))
1848 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
1849 else if (startswith(l, "initrd-timestamp="))
1850 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1851 else if (startswith(l, "userspace-timestamp="))
1852 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
1853 else if (startswith(l, "finish-timestamp="))
1854 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1856 log_debug("Unknown serialization item '%s'", l);
1861 char name[UNIT_NAME_MAX+2];
1864 if (!fgets(name, sizeof(name), f)) {
1875 if ((r = manager_load_unit(m, strstrip(name), NULL, NULL, &u)) < 0)
1878 if ((r = unit_deserialize(u, f, fds)) < 0)
1888 assert(m->n_reloading > 0);
1894 int manager_reload(Manager *m) {
1901 r = manager_open_serialization(m, &f);
1914 r = manager_serialize(m, f, fds, true);
1920 if (fseeko(f, 0, SEEK_SET) < 0) {
1926 /* From here on there is no way back. */
1927 manager_clear_jobs_and_units(m);
1928 manager_undo_generators(m);
1929 lookup_paths_free(&m->lookup_paths);
1931 /* Find new unit paths */
1932 manager_run_generators(m);
1934 q = lookup_paths_init(
1935 &m->lookup_paths, m->running_as, true,
1936 m->generator_unit_path,
1937 m->generator_unit_path_early,
1938 m->generator_unit_path_late);
1942 manager_build_unit_path_cache(m);
1944 /* First, enumerate what we can from all config files */
1945 q = manager_enumerate(m);
1949 /* Second, deserialize our stored data */
1950 q = manager_deserialize(m, f, fds);
1957 /* Third, fire things up! */
1958 q = manager_coldplug(m);
1962 assert(m->n_reloading > 0);
1975 bool manager_is_booting_or_shutting_down(Manager *m) {
1980 /* Is the initial job still around? */
1981 if (manager_get_job(m, m->default_unit_job_id))
1984 /* Is there a job for the shutdown target? */
1985 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
1992 void manager_reset_failed(Manager *m) {
1998 HASHMAP_FOREACH(u, m->units, i)
1999 unit_reset_failed(u);
2002 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2008 /* Returns true if the unit is inactive or going down */
2009 if (!(u = manager_get_unit(m, name)))
2012 return unit_pending_inactive(u);
2015 void manager_check_finished(Manager *m) {
2016 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2017 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2021 if (hashmap_size(m->jobs) > 0)
2024 /* Notify Type=idle units that we are done now */
2025 close_pipe(m->idle_pipe);
2027 /* Turn off confirm spawn now */
2028 m->confirm_spawn = false;
2030 if (dual_timestamp_is_set(&m->finish_timestamp))
2033 dual_timestamp_get(&m->finish_timestamp);
2035 if (m->running_as == MANAGER_SYSTEM && detect_container(NULL) <= 0) {
2037 /* Note that m->kernel_usec.monotonic is always at 0,
2038 * and m->firmware_usec.monotonic and
2039 * m->loader_usec.monotonic should be considered
2040 * negative values. */
2042 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2043 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2044 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2045 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2047 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2049 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2050 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2052 if (!log_on_console())
2053 log_struct(LOG_INFO,
2054 "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(SD_MESSAGE_STARTUP_FINISHED),
2055 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2056 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2057 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2058 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2059 format_timespan(kernel, sizeof(kernel), kernel_usec),
2060 format_timespan(initrd, sizeof(initrd), initrd_usec),
2061 format_timespan(userspace, sizeof(userspace), userspace_usec),
2062 format_timespan(sum, sizeof(sum), total_usec),
2065 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2068 if (!log_on_console())
2069 log_struct(LOG_INFO,
2070 "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(SD_MESSAGE_STARTUP_FINISHED),
2071 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2072 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2073 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2074 format_timespan(kernel, sizeof(kernel), kernel_usec),
2075 format_timespan(userspace, sizeof(userspace), userspace_usec),
2076 format_timespan(sum, sizeof(sum), total_usec),
2080 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2081 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2083 if (!log_on_console())
2084 log_struct(LOG_INFO,
2085 "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(SD_MESSAGE_STARTUP_FINISHED),
2086 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2087 "MESSAGE=Startup finished in %s.",
2088 format_timespan(sum, sizeof(sum), total_usec),
2092 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2095 "READY=1\nSTATUS=Startup finished in %s.",
2096 format_timespan(sum, sizeof(sum), total_usec));
2099 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2110 if (m->running_as == MANAGER_SYSTEM && getpid() == 1) {
2112 p = strappend("/run/systemd/", name);
2116 r = mkdir_p_label(p, 0755);
2118 log_error("Failed to create generator directory: %s", strerror(-r));
2123 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2129 log_error("Failed to create generator directory: %m");
2138 static void trim_generator_dir(Manager *m, char **generator) {
2145 if (rmdir(*generator) >= 0) {
2153 void manager_run_generators(Manager *m) {
2155 const char *generator_path;
2156 const char *argv[5];
2162 generator_path = m->running_as == MANAGER_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2163 d = opendir(generator_path);
2165 if (errno == ENOENT)
2168 log_error("Failed to enumerate generator directory: %m");
2172 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2176 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2180 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2184 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2185 argv[1] = m->generator_unit_path;
2186 argv[2] = m->generator_unit_path_early;
2187 argv[3] = m->generator_unit_path_late;
2191 execute_directory(generator_path, d, (char**) argv);
2194 trim_generator_dir(m, &m->generator_unit_path);
2195 trim_generator_dir(m, &m->generator_unit_path_early);
2196 trim_generator_dir(m, &m->generator_unit_path_late);
2203 static void remove_generator_dir(Manager *m, char **generator) {
2210 strv_remove(m->lookup_paths.unit_path, *generator);
2211 rm_rf(*generator, false, true, false);
2217 void manager_undo_generators(Manager *m) {
2220 remove_generator_dir(m, &m->generator_unit_path);
2221 remove_generator_dir(m, &m->generator_unit_path_early);
2222 remove_generator_dir(m, &m->generator_unit_path_late);
2225 int manager_set_default_controllers(Manager *m, char **controllers) {
2230 l = strv_copy(controllers);
2234 strv_free(m->default_controllers);
2235 m->default_controllers = l;
2237 cg_shorten_controllers(m->default_controllers);
2242 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2247 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2248 if (!default_rlimit[i])
2251 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2259 void manager_recheck_journal(Manager *m) {
2264 if (m->running_as != MANAGER_SYSTEM)
2267 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2268 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2269 log_close_journal();
2273 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2274 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2275 log_close_journal();
2279 /* Hmm, OK, so the socket is fully up and the service is up
2280 * too, then let's make use of the thing. */
2284 void manager_set_show_status(Manager *m, bool b) {
2287 if (m->running_as != MANAGER_SYSTEM)
2293 touch("/run/systemd/show-status");
2295 unlink("/run/systemd/show-status");
2298 bool manager_get_show_status(Manager *m) {
2301 if (m->running_as != MANAGER_SYSTEM)
2307 /* If Plymouth is running make sure we show the status, so
2308 * that there's something nice to see when people press Esc */
2310 return plymouth_running();
2313 static const char* const manager_running_as_table[_MANAGER_RUNNING_AS_MAX] = {
2314 [MANAGER_SYSTEM] = "system",
2315 [MANAGER_USER] = "user"
2318 DEFINE_STRING_TABLE_LOOKUP(manager_running_as, ManagerRunningAs);