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>
39 #include <sys/timerfd.h>
45 #include "systemd/sd-daemon.h"
46 #include "systemd/sd-id128.h"
47 #include "systemd/sd-messages.h"
50 #include "transaction.h"
57 #include "ratelimit.h"
59 #include "mount-setup.h"
60 #include "unit-name.h"
61 #include "dbus-unit.h"
64 #include "path-lookup.h"
66 #include "bus-errors.h"
67 #include "exit-status.h"
70 #include "cgroup-util.h"
71 #include "path-util.h"
74 /* As soon as 16 units are in our GC queue, make sure to run a gc sweep */
75 #define GC_QUEUE_ENTRIES_MAX 16
77 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
78 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
80 /* Where clients shall send notification messages to */
81 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
83 static int manager_setup_notify(Manager *m) {
86 struct sockaddr_un un;
88 struct epoll_event ev;
93 m->notify_watch.type = WATCH_NOTIFY;
94 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
95 if (m->notify_watch.fd < 0) {
96 log_error("Failed to allocate notification socket: %m");
101 sa.sa.sa_family = AF_UNIX;
103 if (getpid() != 1 || detect_container(NULL) > 0)
104 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
106 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
108 sa.un.sun_path[0] = 0;
110 if (bind(m->notify_watch.fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
111 log_error("bind() failed: %m");
115 if (setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0) {
116 log_error("SO_PASSCRED failed: %m");
122 ev.data.ptr = &m->notify_watch;
124 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev) < 0) {
125 log_error("Failed to add timer change fd to epoll: %m");
129 sa.un.sun_path[0] = '@';
130 m->notify_socket = strdup(sa.un.sun_path);
131 if (!m->notify_socket)
134 log_debug("Using notification socket %s", m->notify_socket);
139 static int manager_setup_time_change(Manager *m) {
140 struct epoll_event ev;
141 struct itimerspec its;
144 assert(m->time_change_watch.type == WATCH_INVALID);
146 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
147 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
149 m->time_change_watch.type = WATCH_TIME_CHANGE;
150 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
151 if (m->time_change_watch.fd < 0) {
152 log_error("Failed to create timerfd: %m");
158 /* We only care for the cancellation event, hence we set the
159 * timeout to the latest possible value. */
160 assert_cc(sizeof(time_t) == sizeof(long));
161 its.it_value.tv_sec = LONG_MAX;
163 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
164 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
165 close_nointr_nofail(m->time_change_watch.fd);
166 watch_init(&m->time_change_watch);
172 ev.data.ptr = &m->time_change_watch;
174 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
175 log_error("Failed to add timer change fd to epoll: %m");
179 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
184 static int enable_special_signals(Manager *m) {
189 /* Enable that we get SIGINT on control-alt-del. In containers
190 * this will fail with EPERM (older) or EINVAL (newer), so
192 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
193 log_warning("Failed to enable ctrl-alt-del handling: %m");
195 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
197 /* Support systems without virtual console */
199 log_warning("Failed to open /dev/tty0: %m");
201 /* Enable that we get SIGWINCH on kbrequest */
202 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
203 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
205 close_nointr_nofail(fd);
211 static int manager_setup_signals(Manager *m) {
213 struct epoll_event ev;
218 /* We are not interested in SIGSTOP and friends. */
220 sa.sa_handler = SIG_DFL;
221 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
222 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
224 assert_se(sigemptyset(&mask) == 0);
226 sigset_add_many(&mask,
227 SIGCHLD, /* Child died */
228 SIGTERM, /* Reexecute daemon */
229 SIGHUP, /* Reload configuration */
230 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
231 SIGUSR2, /* systemd: dump status */
232 SIGINT, /* Kernel sends us this on control-alt-del */
233 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
234 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
235 SIGRTMIN+0, /* systemd: start default.target */
236 SIGRTMIN+1, /* systemd: isolate rescue.target */
237 SIGRTMIN+2, /* systemd: isolate emergency.target */
238 SIGRTMIN+3, /* systemd: start halt.target */
239 SIGRTMIN+4, /* systemd: start poweroff.target */
240 SIGRTMIN+5, /* systemd: start reboot.target */
241 SIGRTMIN+6, /* systemd: start kexec.target */
242 SIGRTMIN+13, /* systemd: Immediate halt */
243 SIGRTMIN+14, /* systemd: Immediate poweroff */
244 SIGRTMIN+15, /* systemd: Immediate reboot */
245 SIGRTMIN+16, /* systemd: Immediate kexec */
246 SIGRTMIN+20, /* systemd: enable status messages */
247 SIGRTMIN+21, /* systemd: disable status messages */
248 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
249 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
250 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
251 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
252 SIGRTMIN+27, /* systemd: set log target to console */
253 SIGRTMIN+28, /* systemd: set log target to kmsg */
254 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
256 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
258 m->signal_watch.type = WATCH_SIGNAL;
259 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
260 if (m->signal_watch.fd < 0)
265 ev.data.ptr = &m->signal_watch;
267 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
270 if (m->running_as == SYSTEMD_SYSTEM)
271 return enable_special_signals(m);
276 static void manager_strip_environment(Manager *m) {
279 /* Remove variables from the inherited set that are part of
280 * the container interface:
281 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
282 strv_remove_prefix(m->environment, "container=");
283 strv_remove_prefix(m->environment, "container_");
285 /* Remove variables from the inherited set that are part of
286 * the initrd interface:
287 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
288 strv_remove_prefix(m->environment, "RD_");
291 int manager_new(SystemdRunningAs running_as, Manager **_m) {
296 assert(running_as >= 0);
297 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
299 m = new0(Manager, 1);
303 dual_timestamp_get(&m->userspace_timestamp);
305 m->running_as = running_as;
306 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
307 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
308 m->pin_cgroupfs_fd = -1;
309 m->idle_pipe[0] = m->idle_pipe[1] = -1;
311 watch_init(&m->signal_watch);
312 watch_init(&m->mount_watch);
313 watch_init(&m->swap_watch);
314 watch_init(&m->udev_watch);
315 watch_init(&m->time_change_watch);
317 m->epoll_fd = m->dev_autofs_fd = -1;
318 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
320 m->environment = strv_copy(environ);
324 manager_strip_environment(m);
326 if (running_as == SYSTEMD_SYSTEM) {
327 m->default_controllers = strv_new("cpu", NULL);
328 if (!m->default_controllers)
332 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
335 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
338 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
341 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
344 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
347 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
351 r = manager_setup_signals(m);
355 r = manager_setup_cgroup(m);
359 r = manager_setup_notify(m);
363 r = manager_setup_time_change(m);
367 /* Try to connect to the busses, if possible. */
368 r = bus_init(m, running_as != SYSTEMD_SYSTEM);
372 m->taint_usr = dir_is_empty("/usr") > 0;
382 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
388 while ((u = m->cleanup_queue)) {
389 assert(u->in_cleanup_queue);
399 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
400 GC_OFFSET_UNSURE, /* No clue */
401 GC_OFFSET_GOOD, /* We still need this unit */
402 GC_OFFSET_BAD, /* We don't need this unit anymore */
406 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
413 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
414 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
415 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
418 if (u->in_cleanup_queue)
421 if (unit_check_gc(u))
424 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
428 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
429 unit_gc_sweep(other, gc_marker);
431 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
434 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
441 /* We were unable to find anything out about this entry, so
442 * let's investigate it later */
443 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
444 unit_add_to_gc_queue(u);
448 /* We definitely know that this one is not useful anymore, so
449 * let's mark it for deletion */
450 u->gc_marker = gc_marker + GC_OFFSET_BAD;
451 unit_add_to_cleanup_queue(u);
455 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
458 static unsigned manager_dispatch_gc_queue(Manager *m) {
465 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
466 (m->gc_queue_timestamp <= 0 ||
467 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
470 log_debug("Running GC...");
472 m->gc_marker += _GC_OFFSET_MAX;
473 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
476 gc_marker = m->gc_marker;
478 while ((u = m->gc_queue)) {
479 assert(u->in_gc_queue);
481 unit_gc_sweep(u, gc_marker);
483 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
484 u->in_gc_queue = false;
488 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
489 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
490 log_debug("Collecting %s", u->id);
491 u->gc_marker = gc_marker + GC_OFFSET_BAD;
492 unit_add_to_cleanup_queue(u);
496 m->n_in_gc_queue = 0;
497 m->gc_queue_timestamp = 0;
502 static void manager_clear_jobs_and_units(Manager *m) {
507 while ((u = hashmap_first(m->units)))
510 manager_dispatch_cleanup_queue(m);
512 assert(!m->load_queue);
513 assert(!m->run_queue);
514 assert(!m->dbus_unit_queue);
515 assert(!m->dbus_job_queue);
516 assert(!m->cleanup_queue);
517 assert(!m->gc_queue);
519 assert(hashmap_isempty(m->jobs));
520 assert(hashmap_isempty(m->units));
523 void manager_free(Manager *m) {
529 manager_clear_jobs_and_units(m);
531 for (c = 0; c < _UNIT_TYPE_MAX; c++)
532 if (unit_vtable[c]->shutdown)
533 unit_vtable[c]->shutdown(m);
535 /* If we reexecute ourselves, we keep the root cgroup
537 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
539 manager_undo_generators(m);
543 hashmap_free(m->units);
544 hashmap_free(m->jobs);
545 hashmap_free(m->watch_pids);
546 hashmap_free(m->watch_bus);
548 if (m->epoll_fd >= 0)
549 close_nointr_nofail(m->epoll_fd);
550 if (m->signal_watch.fd >= 0)
551 close_nointr_nofail(m->signal_watch.fd);
552 if (m->notify_watch.fd >= 0)
553 close_nointr_nofail(m->notify_watch.fd);
554 if (m->time_change_watch.fd >= 0)
555 close_nointr_nofail(m->time_change_watch.fd);
557 free(m->notify_socket);
559 lookup_paths_free(&m->lookup_paths);
560 strv_free(m->environment);
562 strv_free(m->default_controllers);
564 hashmap_free(m->cgroup_bondings);
565 set_free_free(m->unit_path_cache);
567 close_pipe(m->idle_pipe);
569 free(m->switch_root);
570 free(m->switch_root_init);
572 for (i = 0; i < RLIMIT_NLIMITS; i++)
578 int manager_enumerate(Manager *m) {
584 /* Let's ask every type to load all units from disk/kernel
585 * that it might know */
586 for (c = 0; c < _UNIT_TYPE_MAX; c++)
587 if (unit_vtable[c]->enumerate)
588 if ((q = unit_vtable[c]->enumerate(m)) < 0)
591 manager_dispatch_load_queue(m);
595 int manager_coldplug(Manager *m) {
603 /* Then, let's set up their initial state. */
604 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
610 if ((q = unit_coldplug(u)) < 0)
617 static void manager_build_unit_path_cache(Manager *m) {
624 set_free_free(m->unit_path_cache);
626 if (!(m->unit_path_cache = set_new(string_hash_func, string_compare_func))) {
627 log_error("Failed to allocate unit path cache.");
631 /* This simply builds a list of files we know exist, so that
632 * we don't always have to go to disk */
634 STRV_FOREACH(i, m->lookup_paths.unit_path) {
637 if (!(d = opendir(*i))) {
638 log_error("Failed to open directory: %m");
642 while ((de = readdir(d))) {
645 if (ignore_file(de->d_name))
648 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
654 if ((r = set_put(m->unit_path_cache, p)) < 0) {
667 log_error("Failed to build unit path cache: %s", strerror(-r));
669 set_free_free(m->unit_path_cache);
670 m->unit_path_cache = NULL;
676 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
681 manager_run_generators(m);
683 r = lookup_paths_init(
684 &m->lookup_paths, m->running_as, true,
685 m->generator_unit_path,
686 m->generator_unit_path_early,
687 m->generator_unit_path_late);
691 manager_build_unit_path_cache(m);
693 /* If we will deserialize make sure that during enumeration
694 * this is already known, so we increase the counter here
699 /* First, enumerate what we can from all config files */
700 r = manager_enumerate(m);
702 /* Second, deserialize if there is something to deserialize */
704 q = manager_deserialize(m, serialization, fds);
709 /* Third, fire things up! */
710 q = manager_coldplug(m);
715 assert(m->n_reloading > 0);
722 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
727 assert(type < _JOB_TYPE_MAX);
729 assert(mode < _JOB_MODE_MAX);
731 if (mode == JOB_ISOLATE && type != JOB_START) {
732 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
736 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
737 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
741 log_debug("Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
743 job_type_collapse(&type, unit);
745 tr = transaction_new();
749 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
750 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
751 mode == JOB_IGNORE_DEPENDENCIES, e);
755 if (mode == JOB_ISOLATE) {
756 r = transaction_add_isolate_jobs(tr, m);
761 r = transaction_activate(tr, m, mode, e);
765 log_debug("Enqueued job %s/%s as %u", unit->id, job_type_to_string(type), (unsigned) tr->anchor_job->id);
768 *_ret = tr->anchor_job;
770 transaction_free(tr);
774 transaction_abort(tr);
775 transaction_free(tr);
779 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
784 assert(type < _JOB_TYPE_MAX);
786 assert(mode < _JOB_MODE_MAX);
788 r = manager_load_unit(m, name, NULL, NULL, &unit);
792 return manager_add_job(m, type, unit, mode, override, e, _ret);
795 Job *manager_get_job(Manager *m, uint32_t id) {
798 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
801 Unit *manager_get_unit(Manager *m, const char *name) {
805 return hashmap_get(m->units, name);
808 unsigned manager_dispatch_load_queue(Manager *m) {
814 /* Make sure we are not run recursively */
815 if (m->dispatching_load_queue)
818 m->dispatching_load_queue = true;
820 /* Dispatches the load queue. Takes a unit from the queue and
821 * tries to load its data until the queue is empty */
823 while ((u = m->load_queue)) {
824 assert(u->in_load_queue);
830 m->dispatching_load_queue = false;
834 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
840 assert(name || path);
842 /* This will prepare the unit for loading, but not actually
843 * load anything from disk. */
845 if (path && !is_path(path)) {
846 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
851 name = path_get_file_name(path);
853 t = unit_name_to_type(name);
855 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
856 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
860 ret = manager_get_unit(m, name);
866 ret = unit_new(m, unit_vtable[t]->object_size);
871 ret->fragment_path = strdup(path);
872 if (!ret->fragment_path) {
878 if ((r = unit_add_name(ret, name)) < 0) {
883 unit_add_to_load_queue(ret);
884 unit_add_to_dbus_queue(ret);
885 unit_add_to_gc_queue(ret);
893 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
898 /* This will load the service information files, but not actually
899 * start any services or anything. */
901 r = manager_load_unit_prepare(m, name, path, e, _ret);
905 manager_dispatch_load_queue(m);
908 *_ret = unit_follow_merge(*_ret);
913 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
920 HASHMAP_FOREACH(j, s->jobs, i)
921 job_dump(j, f, prefix);
924 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
932 HASHMAP_FOREACH_KEY(u, t, s->units, i)
934 unit_dump(u, f, prefix);
937 void manager_clear_jobs(Manager *m) {
942 while ((j = hashmap_first(m->jobs)))
943 /* No need to recurse. We're cancelling all jobs. */
944 job_finish_and_invalidate(j, JOB_CANCELED, false);
947 unsigned manager_dispatch_run_queue(Manager *m) {
951 if (m->dispatching_run_queue)
954 m->dispatching_run_queue = true;
956 while ((j = m->run_queue)) {
957 assert(j->installed);
958 assert(j->in_run_queue);
960 job_run_and_invalidate(j);
964 m->dispatching_run_queue = false;
968 unsigned manager_dispatch_dbus_queue(Manager *m) {
975 if (m->dispatching_dbus_queue)
978 m->dispatching_dbus_queue = true;
980 while ((u = m->dbus_unit_queue)) {
981 assert(u->in_dbus_queue);
983 bus_unit_send_change_signal(u);
987 while ((j = m->dbus_job_queue)) {
988 assert(j->in_dbus_queue);
990 bus_job_send_change_signal(j);
994 m->dispatching_dbus_queue = false;
998 static int manager_process_notify_fd(Manager *m) {
1005 struct msghdr msghdr;
1007 struct ucred *ucred;
1009 struct cmsghdr cmsghdr;
1010 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1016 iovec.iov_base = buf;
1017 iovec.iov_len = sizeof(buf)-1;
1021 msghdr.msg_iov = &iovec;
1022 msghdr.msg_iovlen = 1;
1023 msghdr.msg_control = &control;
1024 msghdr.msg_controllen = sizeof(control);
1026 if ((n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT)) <= 0) {
1030 if (errno == EAGAIN || errno == EINTR)
1036 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1037 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1038 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1039 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1040 log_warning("Received notify message without credentials. Ignoring.");
1044 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1046 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid))))
1047 if (!(u = cgroup_unit_by_pid(m, ucred->pid))) {
1048 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1052 assert((size_t) n < sizeof(buf));
1054 if (!(tags = strv_split(buf, "\n\r")))
1057 log_debug("Got notification message for unit %s", u->id);
1059 if (UNIT_VTABLE(u)->notify_message)
1060 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1068 static int manager_dispatch_sigchld(Manager *m) {
1078 /* First we call waitd() for a PID and do not reap the
1079 * zombie. That way we can still access /proc/$PID for
1080 * it while it is a zombie. */
1081 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1083 if (errno == ECHILD)
1095 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1098 get_process_comm(si.si_pid, &name);
1099 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1103 /* Let's flush any message the dying child might still
1104 * have queued for us. This ensures that the process
1105 * still exists in /proc so that we can figure out
1106 * which cgroup and hence unit it belongs to. */
1107 if ((r = manager_process_notify_fd(m)) < 0)
1110 /* And now figure out the unit this belongs to */
1111 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid))))
1112 u = cgroup_unit_by_pid(m, si.si_pid);
1114 /* And now, we actually reap the zombie. */
1115 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1122 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1125 log_debug("Child %lu died (code=%s, status=%i/%s)",
1126 (long unsigned) si.si_pid,
1127 sigchld_code_to_string(si.si_code),
1129 strna(si.si_code == CLD_EXITED
1130 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1131 : signal_to_string(si.si_status)));
1136 log_debug("Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1138 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1139 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1145 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1149 dbus_error_init(&error);
1151 log_debug("Activating special unit %s", name);
1153 if ((r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL)) < 0)
1154 log_error("Failed to enqueue %s job: %s", name, bus_error(&error, r));
1156 dbus_error_free(&error);
1161 static int manager_process_signal_fd(Manager *m) {
1163 struct signalfd_siginfo sfsi;
1164 bool sigchld = false;
1169 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
1174 if (errno == EINTR || errno == EAGAIN)
1180 if (sfsi.ssi_pid > 0) {
1183 get_process_comm(sfsi.ssi_pid, &p);
1185 log_debug("Received SIG%s from PID %lu (%s).",
1186 signal_to_string(sfsi.ssi_signo),
1187 (unsigned long) sfsi.ssi_pid, strna(p));
1190 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1192 switch (sfsi.ssi_signo) {
1199 if (m->running_as == SYSTEMD_SYSTEM) {
1200 /* This is for compatibility with the
1201 * original sysvinit */
1202 m->exit_code = MANAGER_REEXECUTE;
1209 if (m->running_as == SYSTEMD_SYSTEM) {
1210 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1214 /* Run the exit target if there is one, if not, just exit. */
1215 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1216 m->exit_code = MANAGER_EXIT;
1223 if (m->running_as == SYSTEMD_SYSTEM)
1224 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1226 /* This is a nop on non-init */
1230 if (m->running_as == SYSTEMD_SYSTEM)
1231 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1233 /* This is a nop on non-init */
1239 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1241 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1242 log_info("Trying to reconnect to bus...");
1246 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1247 log_info("Loading D-Bus service...");
1248 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1259 if (!(f = open_memstream(&dump, &size))) {
1260 log_warning("Failed to allocate memory stream.");
1264 manager_dump_units(m, f, "\t");
1265 manager_dump_jobs(m, f, "\t");
1270 log_warning("Failed to write status stream");
1275 log_dump(LOG_INFO, dump);
1282 m->exit_code = MANAGER_RELOAD;
1287 /* Starting SIGRTMIN+0 */
1288 static const char * const target_table[] = {
1289 [0] = SPECIAL_DEFAULT_TARGET,
1290 [1] = SPECIAL_RESCUE_TARGET,
1291 [2] = SPECIAL_EMERGENCY_TARGET,
1292 [3] = SPECIAL_HALT_TARGET,
1293 [4] = SPECIAL_POWEROFF_TARGET,
1294 [5] = SPECIAL_REBOOT_TARGET,
1295 [6] = SPECIAL_KEXEC_TARGET
1298 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1299 static const ManagerExitCode code_table[] = {
1301 [1] = MANAGER_POWEROFF,
1302 [2] = MANAGER_REBOOT,
1306 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1307 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1308 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1309 manager_start_target(m, target_table[idx],
1310 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1314 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1315 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1316 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1320 switch (sfsi.ssi_signo - SIGRTMIN) {
1323 log_debug("Enabling showing of status.");
1324 manager_set_show_status(m, true);
1328 log_debug("Disabling showing of status.");
1329 manager_set_show_status(m, false);
1333 log_set_max_level(LOG_DEBUG);
1334 log_notice("Setting log level to debug.");
1338 log_set_max_level(LOG_INFO);
1339 log_notice("Setting log level to info.");
1343 if (m->running_as == SYSTEMD_USER) {
1344 m->exit_code = MANAGER_EXIT;
1348 /* This is a nop on init */
1352 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1353 log_notice("Setting log target to journal-or-kmsg.");
1357 log_set_target(LOG_TARGET_CONSOLE);
1358 log_notice("Setting log target to console.");
1362 log_set_target(LOG_TARGET_KMSG);
1363 log_notice("Setting log target to kmsg.");
1367 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1368 log_notice("Setting log target to syslog-or-kmsg.");
1372 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1379 return manager_dispatch_sigchld(m);
1384 static int process_event(Manager *m, struct epoll_event *ev) {
1391 assert_se(w = ev->data.ptr);
1393 if (w->type == WATCH_INVALID)
1400 /* An incoming signal? */
1401 if (ev->events != EPOLLIN)
1404 if ((r = manager_process_signal_fd(m)) < 0)
1411 /* An incoming daemon notification event? */
1412 if (ev->events != EPOLLIN)
1415 if ((r = manager_process_notify_fd(m)) < 0)
1422 /* Some fd event, to be dispatched to the units */
1423 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1426 case WATCH_UNIT_TIMER:
1427 case WATCH_JOB_TIMER: {
1431 /* Some timer event, to be dispatched to the units */
1432 k = read(w->fd, &v, sizeof(v));
1433 if (k != sizeof(v)) {
1435 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1438 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1439 return k < 0 ? -errno : -EIO;
1442 if (w->type == WATCH_UNIT_TIMER)
1443 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1445 job_timer_event(w->data.job, v, w);
1450 /* Some mount table change, intended for the mount subsystem */
1451 mount_fd_event(m, ev->events);
1455 /* Some swap table change, intended for the swap subsystem */
1456 swap_fd_event(m, ev->events);
1460 /* Some notification from udev, intended for the device subsystem */
1461 device_fd_event(m, ev->events);
1464 case WATCH_DBUS_WATCH:
1465 bus_watch_event(m, w, ev->events);
1468 case WATCH_DBUS_TIMEOUT:
1469 bus_timeout_event(m, w, ev->events);
1472 case WATCH_TIME_CHANGE: {
1476 log_struct(LOG_INFO,
1477 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1478 "MESSAGE=Time has been changed",
1481 /* Restart the watch */
1482 close_nointr_nofail(m->time_change_watch.fd);
1483 watch_init(&m->time_change_watch);
1484 manager_setup_time_change(m);
1486 HASHMAP_FOREACH(u, m->units, i) {
1487 if (UNIT_VTABLE(u)->time_change)
1488 UNIT_VTABLE(u)->time_change(u);
1495 log_error("event type=%i", w->type);
1496 assert_not_reached("Unknown epoll event type.");
1502 int manager_loop(Manager *m) {
1505 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1508 m->exit_code = MANAGER_RUNNING;
1510 /* Release the path cache */
1511 set_free_free(m->unit_path_cache);
1512 m->unit_path_cache = NULL;
1514 manager_check_finished(m);
1516 /* There might still be some zombies hanging around from
1517 * before we were exec()'ed. Leat's reap them */
1518 r = manager_dispatch_sigchld(m);
1522 while (m->exit_code == MANAGER_RUNNING) {
1523 struct epoll_event event;
1527 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1530 if (!ratelimit_test(&rl)) {
1531 /* Yay, something is going seriously wrong, pause a little */
1532 log_warning("Looping too fast. Throttling execution a little.");
1537 if (manager_dispatch_load_queue(m) > 0)
1540 if (manager_dispatch_run_queue(m) > 0)
1543 if (bus_dispatch(m) > 0)
1546 if (manager_dispatch_cleanup_queue(m) > 0)
1549 if (manager_dispatch_gc_queue(m) > 0)
1552 if (manager_dispatch_dbus_queue(m) > 0)
1555 if (swap_dispatch_reload(m) > 0)
1558 /* Sleep for half the watchdog time */
1559 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1560 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1566 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1578 r = process_event(m, &event);
1583 return m->exit_code;
1586 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1595 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1598 n = bus_path_unescape(s+31);
1602 r = manager_load_unit(m, n, NULL, e, &u);
1613 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1622 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1625 r = safe_atou(s + 30, &id);
1629 j = manager_get_job(m, id);
1638 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1644 audit_fd = get_audit_fd();
1648 /* Don't generate audit events if the service was already
1649 * started and we're just deserializing */
1650 if (m->n_reloading > 0)
1653 if (m->running_as != SYSTEMD_SYSTEM)
1656 if (u->type != UNIT_SERVICE)
1659 if (!(p = unit_name_to_prefix_and_instance(u->id))) {
1660 log_error("Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1664 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1665 if (errno == EPERM) {
1666 /* We aren't allowed to send audit messages?
1667 * Then let's not retry again. */
1670 log_warning("Failed to send audit message: %m");
1678 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1680 union sockaddr_union sa;
1682 char *message = NULL;
1684 /* Don't generate plymouth events if the service was already
1685 * started and we're just deserializing */
1686 if (m->n_reloading > 0)
1689 if (m->running_as != SYSTEMD_SYSTEM)
1692 if (u->type != UNIT_SERVICE &&
1693 u->type != UNIT_MOUNT &&
1694 u->type != UNIT_SWAP)
1697 /* We set SOCK_NONBLOCK here so that we rather drop the
1698 * message then wait for plymouth */
1699 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1700 log_error("socket() failed: %m");
1705 sa.sa.sa_family = AF_UNIX;
1706 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1707 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1709 if (errno != EPIPE &&
1712 errno != ECONNREFUSED &&
1713 errno != ECONNRESET &&
1714 errno != ECONNABORTED)
1715 log_error("connect() failed: %m");
1720 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1726 if (write(fd, message, n + 1) != n + 1) {
1728 if (errno != EPIPE &&
1731 errno != ECONNREFUSED &&
1732 errno != ECONNRESET &&
1733 errno != ECONNABORTED)
1734 log_error("Failed to write Plymouth message: %m");
1741 close_nointr_nofail(fd);
1746 void manager_dispatch_bus_name_owner_changed(
1749 const char* old_owner,
1750 const char *new_owner) {
1757 if (!(u = hashmap_get(m->watch_bus, name)))
1760 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1763 void manager_dispatch_bus_query_pid_done(
1774 if (!(u = hashmap_get(m->watch_bus, name)))
1777 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1780 int manager_open_serialization(Manager *m, FILE **_f) {
1788 if (m->running_as == SYSTEMD_SYSTEM)
1789 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1791 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1796 saved_umask = umask(0077);
1797 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1807 log_debug("Serializing state to %s", path);
1810 if (!(f = fdopen(fd, "w+")))
1818 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
1830 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1831 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1832 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1833 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1835 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1836 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1837 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1838 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1841 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1842 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1847 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1851 if (!unit_can_serialize(u))
1858 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
1864 assert(m->n_reloading > 0);
1870 r = bus_fdset_add_all(m, fds);
1877 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1883 log_debug("Deserializing state...");
1888 char line[LINE_MAX], *l;
1890 if (!fgets(line, sizeof(line), f)) {
1905 if (startswith(l, "current-job-id=")) {
1908 if (safe_atou32(l+15, &id) < 0)
1909 log_debug("Failed to parse current job id value %s", l+15);
1911 m->current_job_id = MAX(m->current_job_id, id);
1912 } else if (startswith(l, "n-installed-jobs=")) {
1915 if (safe_atou32(l+17, &n) < 0)
1916 log_debug("Failed to parse installed jobs counter %s", l+17);
1918 m->n_installed_jobs += n;
1919 } else if (startswith(l, "n-failed-jobs=")) {
1922 if (safe_atou32(l+14, &n) < 0)
1923 log_debug("Failed to parse failed jobs counter %s", l+14);
1925 m->n_failed_jobs += n;
1926 } else if (startswith(l, "taint-usr=")) {
1929 if ((b = parse_boolean(l+10)) < 0)
1930 log_debug("Failed to parse taint /usr flag %s", l+10);
1932 m->taint_usr = m->taint_usr || b;
1933 } else if (startswith(l, "firmware-timestamp="))
1934 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
1935 else if (startswith(l, "loader-timestamp="))
1936 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
1937 else if (startswith(l, "kernel-timestamp="))
1938 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
1939 else if (startswith(l, "initrd-timestamp="))
1940 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1941 else if (startswith(l, "userspace-timestamp="))
1942 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
1943 else if (startswith(l, "finish-timestamp="))
1944 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1946 log_debug("Unknown serialization item '%s'", l);
1951 char name[UNIT_NAME_MAX+2];
1954 if (!fgets(name, sizeof(name), f)) {
1965 if ((r = manager_load_unit(m, strstrip(name), NULL, NULL, &u)) < 0)
1968 if ((r = unit_deserialize(u, f, fds)) < 0)
1978 assert(m->n_reloading > 0);
1984 int manager_reload(Manager *m) {
1991 r = manager_open_serialization(m, &f);
2004 r = manager_serialize(m, f, fds, true);
2010 if (fseeko(f, 0, SEEK_SET) < 0) {
2016 /* From here on there is no way back. */
2017 manager_clear_jobs_and_units(m);
2018 manager_undo_generators(m);
2019 lookup_paths_free(&m->lookup_paths);
2021 /* Find new unit paths */
2022 manager_run_generators(m);
2024 q = lookup_paths_init(
2025 &m->lookup_paths, m->running_as, true,
2026 m->generator_unit_path,
2027 m->generator_unit_path_early,
2028 m->generator_unit_path_late);
2032 manager_build_unit_path_cache(m);
2034 /* First, enumerate what we can from all config files */
2035 q = manager_enumerate(m);
2039 /* Second, deserialize our stored data */
2040 q = manager_deserialize(m, f, fds);
2047 /* Third, fire things up! */
2048 q = manager_coldplug(m);
2052 assert(m->n_reloading > 0);
2065 bool manager_is_booting_or_shutting_down(Manager *m) {
2070 /* Is the initial job still around? */
2071 if (manager_get_job(m, m->default_unit_job_id))
2074 /* Is there a job for the shutdown target? */
2075 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2082 void manager_reset_failed(Manager *m) {
2088 HASHMAP_FOREACH(u, m->units, i)
2089 unit_reset_failed(u);
2092 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2098 /* Returns true if the unit is inactive or going down */
2099 if (!(u = manager_get_unit(m, name)))
2102 return unit_pending_inactive(u);
2105 void manager_check_finished(Manager *m) {
2106 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2107 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2111 if (hashmap_size(m->jobs) > 0)
2114 /* Notify Type=idle units that we are done now */
2115 close_pipe(m->idle_pipe);
2117 /* Turn off confirm spawn now */
2118 m->confirm_spawn = false;
2120 if (dual_timestamp_is_set(&m->finish_timestamp))
2123 dual_timestamp_get(&m->finish_timestamp);
2125 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2127 /* Note that m->kernel_usec.monotonic is always at 0,
2128 * and m->firmware_usec.monotonic and
2129 * m->loader_usec.monotonic should be considered
2130 * negative values. */
2132 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2133 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2134 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2135 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2137 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2139 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2140 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2142 if (!log_on_console())
2143 log_struct(LOG_INFO,
2144 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2145 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2146 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2147 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2148 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2149 format_timespan(kernel, sizeof(kernel), kernel_usec),
2150 format_timespan(initrd, sizeof(initrd), initrd_usec),
2151 format_timespan(userspace, sizeof(userspace), userspace_usec),
2152 format_timespan(sum, sizeof(sum), total_usec),
2155 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2158 if (!log_on_console())
2159 log_struct(LOG_INFO,
2160 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2161 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2162 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2163 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2164 format_timespan(kernel, sizeof(kernel), kernel_usec),
2165 format_timespan(userspace, sizeof(userspace), userspace_usec),
2166 format_timespan(sum, sizeof(sum), total_usec),
2170 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2171 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2173 if (!log_on_console())
2174 log_struct(LOG_INFO,
2175 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2176 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2177 "MESSAGE=Startup finished in %s.",
2178 format_timespan(sum, sizeof(sum), total_usec),
2182 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2185 "READY=1\nSTATUS=Startup finished in %s.",
2186 format_timespan(sum, sizeof(sum), total_usec));
2189 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2200 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2202 p = strappend("/run/systemd/", name);
2206 r = mkdir_p_label(p, 0755);
2208 log_error("Failed to create generator directory: %s", strerror(-r));
2213 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2219 log_error("Failed to create generator directory: %m");
2228 static void trim_generator_dir(Manager *m, char **generator) {
2235 if (rmdir(*generator) >= 0) {
2243 void manager_run_generators(Manager *m) {
2245 const char *generator_path;
2246 const char *argv[5];
2252 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2253 d = opendir(generator_path);
2255 if (errno == ENOENT)
2258 log_error("Failed to enumerate generator directory: %m");
2262 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2266 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2270 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2274 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2275 argv[1] = m->generator_unit_path;
2276 argv[2] = m->generator_unit_path_early;
2277 argv[3] = m->generator_unit_path_late;
2281 execute_directory(generator_path, d, (char**) argv);
2284 trim_generator_dir(m, &m->generator_unit_path);
2285 trim_generator_dir(m, &m->generator_unit_path_early);
2286 trim_generator_dir(m, &m->generator_unit_path_late);
2293 static void remove_generator_dir(Manager *m, char **generator) {
2300 strv_remove(m->lookup_paths.unit_path, *generator);
2301 rm_rf(*generator, false, true, false);
2307 void manager_undo_generators(Manager *m) {
2310 remove_generator_dir(m, &m->generator_unit_path);
2311 remove_generator_dir(m, &m->generator_unit_path_early);
2312 remove_generator_dir(m, &m->generator_unit_path_late);
2315 int manager_set_default_controllers(Manager *m, char **controllers) {
2320 l = strv_copy(controllers);
2324 strv_free(m->default_controllers);
2325 m->default_controllers = l;
2327 cg_shorten_controllers(m->default_controllers);
2332 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2337 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2338 if (!default_rlimit[i])
2341 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2349 void manager_recheck_journal(Manager *m) {
2354 if (m->running_as != SYSTEMD_SYSTEM)
2357 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2358 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2359 log_close_journal();
2363 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2364 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2365 log_close_journal();
2369 /* Hmm, OK, so the socket is fully up and the service is up
2370 * too, then let's make use of the thing. */
2374 void manager_set_show_status(Manager *m, bool b) {
2377 if (m->running_as != SYSTEMD_SYSTEM)
2383 touch("/run/systemd/show-status");
2385 unlink("/run/systemd/show-status");
2388 bool manager_get_show_status(Manager *m) {
2391 if (m->running_as != SYSTEMD_SYSTEM)
2397 /* If Plymouth is running make sure we show the status, so
2398 * that there's something nice to see when people press Esc */
2400 return plymouth_running();
2403 void watch_init(Watch *w) {
2406 w->type = WATCH_INVALID;