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);
304 dual_timestamp_from_monotonic(&m->kernel_timestamp, 0);
306 m->running_as = running_as;
307 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
308 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
309 m->pin_cgroupfs_fd = -1;
310 m->idle_pipe[0] = m->idle_pipe[1] = -1;
312 watch_init(&m->signal_watch);
313 watch_init(&m->mount_watch);
314 watch_init(&m->swap_watch);
315 watch_init(&m->udev_watch);
316 watch_init(&m->time_change_watch);
318 m->epoll_fd = m->dev_autofs_fd = -1;
319 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
321 m->environment = strv_copy(environ);
325 manager_strip_environment(m);
327 if (running_as == SYSTEMD_SYSTEM) {
328 m->default_controllers = strv_new("cpu", NULL);
329 if (!m->default_controllers)
333 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
336 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
339 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
342 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
345 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
348 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
352 r = manager_setup_signals(m);
356 r = manager_setup_cgroup(m);
360 r = manager_setup_notify(m);
364 r = manager_setup_time_change(m);
368 /* Try to connect to the busses, if possible. */
369 r = bus_init(m, running_as != SYSTEMD_SYSTEM);
373 m->taint_usr = dir_is_empty("/usr") > 0;
383 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
389 while ((u = m->cleanup_queue)) {
390 assert(u->in_cleanup_queue);
400 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
401 GC_OFFSET_UNSURE, /* No clue */
402 GC_OFFSET_GOOD, /* We still need this unit */
403 GC_OFFSET_BAD, /* We don't need this unit anymore */
407 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
414 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
415 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
416 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
419 if (u->in_cleanup_queue)
422 if (unit_check_gc(u))
425 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
429 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
430 unit_gc_sweep(other, gc_marker);
432 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
435 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
442 /* We were unable to find anything out about this entry, so
443 * let's investigate it later */
444 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
445 unit_add_to_gc_queue(u);
449 /* We definitely know that this one is not useful anymore, so
450 * let's mark it for deletion */
451 u->gc_marker = gc_marker + GC_OFFSET_BAD;
452 unit_add_to_cleanup_queue(u);
456 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
459 static unsigned manager_dispatch_gc_queue(Manager *m) {
466 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
467 (m->gc_queue_timestamp <= 0 ||
468 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
471 log_debug("Running GC...");
473 m->gc_marker += _GC_OFFSET_MAX;
474 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
477 gc_marker = m->gc_marker;
479 while ((u = m->gc_queue)) {
480 assert(u->in_gc_queue);
482 unit_gc_sweep(u, gc_marker);
484 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
485 u->in_gc_queue = false;
489 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
490 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
491 log_debug_unit(u->id, "Collecting %s", u->id);
492 u->gc_marker = gc_marker + GC_OFFSET_BAD;
493 unit_add_to_cleanup_queue(u);
497 m->n_in_gc_queue = 0;
498 m->gc_queue_timestamp = 0;
503 static void manager_clear_jobs_and_units(Manager *m) {
508 while ((u = hashmap_first(m->units)))
511 manager_dispatch_cleanup_queue(m);
513 assert(!m->load_queue);
514 assert(!m->run_queue);
515 assert(!m->dbus_unit_queue);
516 assert(!m->dbus_job_queue);
517 assert(!m->cleanup_queue);
518 assert(!m->gc_queue);
520 assert(hashmap_isempty(m->jobs));
521 assert(hashmap_isempty(m->units));
524 void manager_free(Manager *m) {
530 manager_clear_jobs_and_units(m);
532 for (c = 0; c < _UNIT_TYPE_MAX; c++)
533 if (unit_vtable[c]->shutdown)
534 unit_vtable[c]->shutdown(m);
536 /* If we reexecute ourselves, we keep the root cgroup
538 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
540 manager_undo_generators(m);
544 hashmap_free(m->units);
545 hashmap_free(m->jobs);
546 hashmap_free(m->watch_pids);
547 hashmap_free(m->watch_bus);
549 if (m->epoll_fd >= 0)
550 close_nointr_nofail(m->epoll_fd);
551 if (m->signal_watch.fd >= 0)
552 close_nointr_nofail(m->signal_watch.fd);
553 if (m->notify_watch.fd >= 0)
554 close_nointr_nofail(m->notify_watch.fd);
555 if (m->time_change_watch.fd >= 0)
556 close_nointr_nofail(m->time_change_watch.fd);
558 free(m->notify_socket);
560 lookup_paths_free(&m->lookup_paths);
561 strv_free(m->environment);
563 strv_free(m->default_controllers);
565 hashmap_free(m->cgroup_bondings);
566 set_free_free(m->unit_path_cache);
568 close_pipe(m->idle_pipe);
570 free(m->switch_root);
571 free(m->switch_root_init);
573 for (i = 0; i < RLIMIT_NLIMITS; i++)
579 int manager_enumerate(Manager *m) {
585 /* Let's ask every type to load all units from disk/kernel
586 * that it might know */
587 for (c = 0; c < _UNIT_TYPE_MAX; c++)
588 if (unit_vtable[c]->enumerate)
589 if ((q = unit_vtable[c]->enumerate(m)) < 0)
592 manager_dispatch_load_queue(m);
596 int manager_coldplug(Manager *m) {
604 /* Then, let's set up their initial state. */
605 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
611 if ((q = unit_coldplug(u)) < 0)
618 static void manager_build_unit_path_cache(Manager *m) {
625 set_free_free(m->unit_path_cache);
627 if (!(m->unit_path_cache = set_new(string_hash_func, string_compare_func))) {
628 log_error("Failed to allocate unit path cache.");
632 /* This simply builds a list of files we know exist, so that
633 * we don't always have to go to disk */
635 STRV_FOREACH(i, m->lookup_paths.unit_path) {
640 log_error("Failed to open directory: %m");
644 while ((de = readdir(d))) {
647 if (ignore_file(de->d_name))
650 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
656 if ((r = set_put(m->unit_path_cache, p)) < 0) {
669 log_error("Failed to build unit path cache: %s", strerror(-r));
671 set_free_free(m->unit_path_cache);
672 m->unit_path_cache = NULL;
678 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
683 manager_run_generators(m);
685 r = lookup_paths_init(
686 &m->lookup_paths, m->running_as, true,
687 m->generator_unit_path,
688 m->generator_unit_path_early,
689 m->generator_unit_path_late);
693 manager_build_unit_path_cache(m);
695 /* If we will deserialize make sure that during enumeration
696 * this is already known, so we increase the counter here
701 /* First, enumerate what we can from all config files */
702 r = manager_enumerate(m);
704 /* Second, deserialize if there is something to deserialize */
706 q = manager_deserialize(m, serialization, fds);
711 /* Any fds left? Find some unit which wants them. This is
712 * useful to allow container managers to pass some file
713 * descriptors to us pre-initialized. This enables
714 * socket-based activation of entire containers. */
715 if (fdset_size(fds) > 0) {
716 q = manager_distribute_fds(m, fds);
721 /* Third, fire things up! */
722 q = manager_coldplug(m);
727 assert(m->n_reloading > 0);
734 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
739 assert(type < _JOB_TYPE_MAX);
741 assert(mode < _JOB_MODE_MAX);
743 if (mode == JOB_ISOLATE && type != JOB_START) {
744 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
748 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
749 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
753 log_debug_unit(unit->id,
754 "Trying to enqueue job %s/%s/%s", unit->id,
755 job_type_to_string(type), job_mode_to_string(mode));
757 job_type_collapse(&type, unit);
759 tr = transaction_new();
763 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
764 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
765 mode == JOB_IGNORE_DEPENDENCIES, e);
769 if (mode == JOB_ISOLATE) {
770 r = transaction_add_isolate_jobs(tr, m);
775 r = transaction_activate(tr, m, mode, e);
779 log_debug_unit(unit->id,
780 "Enqueued job %s/%s as %u", unit->id,
781 job_type_to_string(type), (unsigned) tr->anchor_job->id);
784 *_ret = tr->anchor_job;
786 transaction_free(tr);
790 transaction_abort(tr);
791 transaction_free(tr);
795 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
800 assert(type < _JOB_TYPE_MAX);
802 assert(mode < _JOB_MODE_MAX);
804 r = manager_load_unit(m, name, NULL, NULL, &unit);
808 return manager_add_job(m, type, unit, mode, override, e, _ret);
811 Job *manager_get_job(Manager *m, uint32_t id) {
814 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
817 Unit *manager_get_unit(Manager *m, const char *name) {
821 return hashmap_get(m->units, name);
824 unsigned manager_dispatch_load_queue(Manager *m) {
830 /* Make sure we are not run recursively */
831 if (m->dispatching_load_queue)
834 m->dispatching_load_queue = true;
836 /* Dispatches the load queue. Takes a unit from the queue and
837 * tries to load its data until the queue is empty */
839 while ((u = m->load_queue)) {
840 assert(u->in_load_queue);
846 m->dispatching_load_queue = false;
850 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
856 assert(name || path);
858 /* This will prepare the unit for loading, but not actually
859 * load anything from disk. */
861 if (path && !is_path(path)) {
862 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
867 name = path_get_file_name(path);
869 t = unit_name_to_type(name);
871 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
872 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
876 ret = manager_get_unit(m, name);
882 ret = unit_new(m, unit_vtable[t]->object_size);
887 ret->fragment_path = strdup(path);
888 if (!ret->fragment_path) {
894 if ((r = unit_add_name(ret, name)) < 0) {
899 unit_add_to_load_queue(ret);
900 unit_add_to_dbus_queue(ret);
901 unit_add_to_gc_queue(ret);
909 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
914 /* This will load the service information files, but not actually
915 * start any services or anything. */
917 r = manager_load_unit_prepare(m, name, path, e, _ret);
921 manager_dispatch_load_queue(m);
924 *_ret = unit_follow_merge(*_ret);
929 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
936 HASHMAP_FOREACH(j, s->jobs, i)
937 job_dump(j, f, prefix);
940 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
948 HASHMAP_FOREACH_KEY(u, t, s->units, i)
950 unit_dump(u, f, prefix);
953 void manager_clear_jobs(Manager *m) {
958 while ((j = hashmap_first(m->jobs)))
959 /* No need to recurse. We're cancelling all jobs. */
960 job_finish_and_invalidate(j, JOB_CANCELED, false);
963 unsigned manager_dispatch_run_queue(Manager *m) {
967 if (m->dispatching_run_queue)
970 m->dispatching_run_queue = true;
972 while ((j = m->run_queue)) {
973 assert(j->installed);
974 assert(j->in_run_queue);
976 job_run_and_invalidate(j);
980 m->dispatching_run_queue = false;
984 unsigned manager_dispatch_dbus_queue(Manager *m) {
991 if (m->dispatching_dbus_queue)
994 m->dispatching_dbus_queue = true;
996 while ((u = m->dbus_unit_queue)) {
997 assert(u->in_dbus_queue);
999 bus_unit_send_change_signal(u);
1003 while ((j = m->dbus_job_queue)) {
1004 assert(j->in_dbus_queue);
1006 bus_job_send_change_signal(j);
1010 m->dispatching_dbus_queue = false;
1014 static int manager_process_notify_fd(Manager *m) {
1021 struct msghdr msghdr;
1023 struct ucred *ucred;
1025 struct cmsghdr cmsghdr;
1026 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1032 iovec.iov_base = buf;
1033 iovec.iov_len = sizeof(buf)-1;
1037 msghdr.msg_iov = &iovec;
1038 msghdr.msg_iovlen = 1;
1039 msghdr.msg_control = &control;
1040 msghdr.msg_controllen = sizeof(control);
1042 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1047 if (errno == EAGAIN || errno == EINTR)
1053 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1054 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1055 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1056 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1057 log_warning("Received notify message without credentials. Ignoring.");
1061 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1063 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1065 u = cgroup_unit_by_pid(m, ucred->pid);
1067 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1072 assert((size_t) n < sizeof(buf));
1074 tags = strv_split(buf, "\n\r");
1078 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1080 if (UNIT_VTABLE(u)->notify_message)
1081 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1089 static int manager_dispatch_sigchld(Manager *m) {
1099 /* First we call waitd() for a PID and do not reap the
1100 * zombie. That way we can still access /proc/$PID for
1101 * it while it is a zombie. */
1102 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1104 if (errno == ECHILD)
1116 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1117 char _cleanup_free_ *name = NULL;
1119 get_process_comm(si.si_pid, &name);
1120 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1123 /* Let's flush any message the dying child might still
1124 * have queued for us. This ensures that the process
1125 * still exists in /proc so that we can figure out
1126 * which cgroup and hence unit it belongs to. */
1127 r = manager_process_notify_fd(m);
1131 /* And now figure out the unit this belongs to */
1132 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1134 u = cgroup_unit_by_pid(m, si.si_pid);
1136 /* And now, we actually reap the zombie. */
1137 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1144 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1147 log_debug("Child %lu died (code=%s, status=%i/%s)",
1148 (long unsigned) si.si_pid,
1149 sigchld_code_to_string(si.si_code),
1151 strna(si.si_code == CLD_EXITED
1152 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1153 : signal_to_string(si.si_status)));
1158 log_debug_unit(u->id,
1159 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1161 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1162 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1168 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1172 dbus_error_init(&error);
1174 log_debug_unit(name, "Activating special unit %s", name);
1176 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1178 log_error_unit(name,
1179 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1181 dbus_error_free(&error);
1186 static int manager_process_signal_fd(Manager *m) {
1188 struct signalfd_siginfo sfsi;
1189 bool sigchld = false;
1194 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1195 if (n != sizeof(sfsi)) {
1200 if (errno == EINTR || errno == EAGAIN)
1206 if (sfsi.ssi_pid > 0) {
1209 get_process_comm(sfsi.ssi_pid, &p);
1211 log_debug("Received SIG%s from PID %lu (%s).",
1212 signal_to_string(sfsi.ssi_signo),
1213 (unsigned long) sfsi.ssi_pid, strna(p));
1216 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1218 switch (sfsi.ssi_signo) {
1225 if (m->running_as == SYSTEMD_SYSTEM) {
1226 /* This is for compatibility with the
1227 * original sysvinit */
1228 m->exit_code = MANAGER_REEXECUTE;
1235 if (m->running_as == SYSTEMD_SYSTEM) {
1236 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1240 /* Run the exit target if there is one, if not, just exit. */
1241 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1242 m->exit_code = MANAGER_EXIT;
1249 if (m->running_as == SYSTEMD_SYSTEM)
1250 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1252 /* This is a nop on non-init */
1256 if (m->running_as == SYSTEMD_SYSTEM)
1257 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1259 /* This is a nop on non-init */
1265 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1267 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1268 log_info("Trying to reconnect to bus...");
1272 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1273 log_info("Loading D-Bus service...");
1274 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1285 if (!(f = open_memstream(&dump, &size))) {
1286 log_warning("Failed to allocate memory stream.");
1290 manager_dump_units(m, f, "\t");
1291 manager_dump_jobs(m, f, "\t");
1296 log_warning("Failed to write status stream");
1301 log_dump(LOG_INFO, dump);
1308 m->exit_code = MANAGER_RELOAD;
1313 /* Starting SIGRTMIN+0 */
1314 static const char * const target_table[] = {
1315 [0] = SPECIAL_DEFAULT_TARGET,
1316 [1] = SPECIAL_RESCUE_TARGET,
1317 [2] = SPECIAL_EMERGENCY_TARGET,
1318 [3] = SPECIAL_HALT_TARGET,
1319 [4] = SPECIAL_POWEROFF_TARGET,
1320 [5] = SPECIAL_REBOOT_TARGET,
1321 [6] = SPECIAL_KEXEC_TARGET
1324 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1325 static const ManagerExitCode code_table[] = {
1327 [1] = MANAGER_POWEROFF,
1328 [2] = MANAGER_REBOOT,
1332 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1333 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1334 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1335 manager_start_target(m, target_table[idx],
1336 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1340 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1341 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1342 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1346 switch (sfsi.ssi_signo - SIGRTMIN) {
1349 log_debug("Enabling showing of status.");
1350 manager_set_show_status(m, true);
1354 log_debug("Disabling showing of status.");
1355 manager_set_show_status(m, false);
1359 log_set_max_level(LOG_DEBUG);
1360 log_notice("Setting log level to debug.");
1364 log_set_max_level(LOG_INFO);
1365 log_notice("Setting log level to info.");
1369 if (m->running_as == SYSTEMD_USER) {
1370 m->exit_code = MANAGER_EXIT;
1374 /* This is a nop on init */
1378 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1379 log_notice("Setting log target to journal-or-kmsg.");
1383 log_set_target(LOG_TARGET_CONSOLE);
1384 log_notice("Setting log target to console.");
1388 log_set_target(LOG_TARGET_KMSG);
1389 log_notice("Setting log target to kmsg.");
1393 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1394 log_notice("Setting log target to syslog-or-kmsg.");
1398 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1405 return manager_dispatch_sigchld(m);
1410 static int process_event(Manager *m, struct epoll_event *ev) {
1417 assert_se(w = ev->data.ptr);
1419 if (w->type == WATCH_INVALID)
1426 /* An incoming signal? */
1427 if (ev->events != EPOLLIN)
1430 if ((r = manager_process_signal_fd(m)) < 0)
1437 /* An incoming daemon notification event? */
1438 if (ev->events != EPOLLIN)
1441 if ((r = manager_process_notify_fd(m)) < 0)
1448 /* Some fd event, to be dispatched to the units */
1449 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1452 case WATCH_UNIT_TIMER:
1453 case WATCH_JOB_TIMER: {
1457 /* Some timer event, to be dispatched to the units */
1458 k = read(w->fd, &v, sizeof(v));
1459 if (k != sizeof(v)) {
1461 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1464 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1465 return k < 0 ? -errno : -EIO;
1468 if (w->type == WATCH_UNIT_TIMER)
1469 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1471 job_timer_event(w->data.job, v, w);
1476 /* Some mount table change, intended for the mount subsystem */
1477 mount_fd_event(m, ev->events);
1481 /* Some swap table change, intended for the swap subsystem */
1482 swap_fd_event(m, ev->events);
1486 /* Some notification from udev, intended for the device subsystem */
1487 device_fd_event(m, ev->events);
1490 case WATCH_DBUS_WATCH:
1491 bus_watch_event(m, w, ev->events);
1494 case WATCH_DBUS_TIMEOUT:
1495 bus_timeout_event(m, w, ev->events);
1498 case WATCH_TIME_CHANGE: {
1502 log_struct(LOG_INFO,
1503 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1504 "MESSAGE=Time has been changed",
1507 /* Restart the watch */
1508 close_nointr_nofail(m->time_change_watch.fd);
1509 watch_init(&m->time_change_watch);
1510 manager_setup_time_change(m);
1512 HASHMAP_FOREACH(u, m->units, i) {
1513 if (UNIT_VTABLE(u)->time_change)
1514 UNIT_VTABLE(u)->time_change(u);
1521 log_error("event type=%i", w->type);
1522 assert_not_reached("Unknown epoll event type.");
1528 int manager_loop(Manager *m) {
1531 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1534 m->exit_code = MANAGER_RUNNING;
1536 /* Release the path cache */
1537 set_free_free(m->unit_path_cache);
1538 m->unit_path_cache = NULL;
1540 manager_check_finished(m);
1542 /* There might still be some zombies hanging around from
1543 * before we were exec()'ed. Leat's reap them */
1544 r = manager_dispatch_sigchld(m);
1548 while (m->exit_code == MANAGER_RUNNING) {
1549 struct epoll_event event;
1553 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1556 if (!ratelimit_test(&rl)) {
1557 /* Yay, something is going seriously wrong, pause a little */
1558 log_warning("Looping too fast. Throttling execution a little.");
1563 if (manager_dispatch_load_queue(m) > 0)
1566 if (manager_dispatch_run_queue(m) > 0)
1569 if (bus_dispatch(m) > 0)
1572 if (manager_dispatch_cleanup_queue(m) > 0)
1575 if (manager_dispatch_gc_queue(m) > 0)
1578 if (manager_dispatch_dbus_queue(m) > 0)
1581 if (swap_dispatch_reload(m) > 0)
1584 /* Sleep for half the watchdog time */
1585 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1586 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1592 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1604 r = process_event(m, &event);
1609 return m->exit_code;
1612 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1621 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1624 n = bus_path_unescape(s+31);
1628 r = manager_load_unit(m, n, NULL, e, &u);
1639 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1648 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1651 r = safe_atou(s + 30, &id);
1655 j = manager_get_job(m, id);
1664 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1670 audit_fd = get_audit_fd();
1674 /* Don't generate audit events if the service was already
1675 * started and we're just deserializing */
1676 if (m->n_reloading > 0)
1679 if (m->running_as != SYSTEMD_SYSTEM)
1682 if (u->type != UNIT_SERVICE)
1685 p = unit_name_to_prefix_and_instance(u->id);
1687 log_error_unit(u->id,
1688 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1692 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1693 if (errno == EPERM) {
1694 /* We aren't allowed to send audit messages?
1695 * Then let's not retry again. */
1698 log_warning("Failed to send audit message: %m");
1706 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1708 union sockaddr_union sa;
1710 char *message = NULL;
1712 /* Don't generate plymouth events if the service was already
1713 * started and we're just deserializing */
1714 if (m->n_reloading > 0)
1717 if (m->running_as != SYSTEMD_SYSTEM)
1720 if (u->type != UNIT_SERVICE &&
1721 u->type != UNIT_MOUNT &&
1722 u->type != UNIT_SWAP)
1725 /* We set SOCK_NONBLOCK here so that we rather drop the
1726 * message then wait for plymouth */
1727 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1728 log_error("socket() failed: %m");
1733 sa.sa.sa_family = AF_UNIX;
1734 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1735 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1737 if (errno != EPIPE &&
1740 errno != ECONNREFUSED &&
1741 errno != ECONNRESET &&
1742 errno != ECONNABORTED)
1743 log_error("connect() failed: %m");
1748 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1754 if (write(fd, message, n + 1) != n + 1) {
1756 if (errno != EPIPE &&
1759 errno != ECONNREFUSED &&
1760 errno != ECONNRESET &&
1761 errno != ECONNABORTED)
1762 log_error("Failed to write Plymouth message: %m");
1769 close_nointr_nofail(fd);
1774 void manager_dispatch_bus_name_owner_changed(
1777 const char* old_owner,
1778 const char *new_owner) {
1785 if (!(u = hashmap_get(m->watch_bus, name)))
1788 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1791 void manager_dispatch_bus_query_pid_done(
1802 if (!(u = hashmap_get(m->watch_bus, name)))
1805 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1808 int manager_open_serialization(Manager *m, FILE **_f) {
1816 if (m->running_as == SYSTEMD_SYSTEM)
1817 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1819 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1824 saved_umask = umask(0077);
1825 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1835 log_debug("Serializing state to %s", path);
1838 f = fdopen(fd, "w+");
1847 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
1859 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1860 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1861 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1862 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1864 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1865 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1866 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1867 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1870 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1871 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1876 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1880 if (!unit_can_serialize(u))
1887 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
1893 assert(m->n_reloading > 0);
1899 r = bus_fdset_add_all(m, fds);
1906 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1912 log_debug("Deserializing state...");
1917 char line[LINE_MAX], *l;
1919 if (!fgets(line, sizeof(line), f)) {
1934 if (startswith(l, "current-job-id=")) {
1937 if (safe_atou32(l+15, &id) < 0)
1938 log_debug("Failed to parse current job id value %s", l+15);
1940 m->current_job_id = MAX(m->current_job_id, id);
1941 } else if (startswith(l, "n-installed-jobs=")) {
1944 if (safe_atou32(l+17, &n) < 0)
1945 log_debug("Failed to parse installed jobs counter %s", l+17);
1947 m->n_installed_jobs += n;
1948 } else if (startswith(l, "n-failed-jobs=")) {
1951 if (safe_atou32(l+14, &n) < 0)
1952 log_debug("Failed to parse failed jobs counter %s", l+14);
1954 m->n_failed_jobs += n;
1955 } else if (startswith(l, "taint-usr=")) {
1958 if ((b = parse_boolean(l+10)) < 0)
1959 log_debug("Failed to parse taint /usr flag %s", l+10);
1961 m->taint_usr = m->taint_usr || b;
1962 } else if (startswith(l, "firmware-timestamp="))
1963 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
1964 else if (startswith(l, "loader-timestamp="))
1965 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
1966 else if (startswith(l, "kernel-timestamp="))
1967 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
1968 else if (startswith(l, "initrd-timestamp="))
1969 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1970 else if (startswith(l, "userspace-timestamp="))
1971 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
1972 else if (startswith(l, "finish-timestamp="))
1973 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1975 log_debug("Unknown serialization item '%s'", l);
1980 char name[UNIT_NAME_MAX+2];
1983 if (!fgets(name, sizeof(name), f)) {
1994 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
1998 r = unit_deserialize(u, f, fds);
2009 assert(m->n_reloading > 0);
2015 int manager_distribute_fds(Manager *m, FDSet *fds) {
2022 HASHMAP_FOREACH(u, m->units, i) {
2024 if (fdset_size(fds) <= 0)
2027 if (UNIT_VTABLE(u)->distribute_fds) {
2028 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2037 int manager_reload(Manager *m) {
2044 r = manager_open_serialization(m, &f);
2057 r = manager_serialize(m, f, fds, true);
2063 if (fseeko(f, 0, SEEK_SET) < 0) {
2069 /* From here on there is no way back. */
2070 manager_clear_jobs_and_units(m);
2071 manager_undo_generators(m);
2072 lookup_paths_free(&m->lookup_paths);
2074 /* Find new unit paths */
2075 manager_run_generators(m);
2077 q = lookup_paths_init(
2078 &m->lookup_paths, m->running_as, true,
2079 m->generator_unit_path,
2080 m->generator_unit_path_early,
2081 m->generator_unit_path_late);
2085 manager_build_unit_path_cache(m);
2087 /* First, enumerate what we can from all config files */
2088 q = manager_enumerate(m);
2092 /* Second, deserialize our stored data */
2093 q = manager_deserialize(m, f, fds);
2100 /* Third, fire things up! */
2101 q = manager_coldplug(m);
2105 assert(m->n_reloading > 0);
2118 bool manager_is_booting_or_shutting_down(Manager *m) {
2123 /* Is the initial job still around? */
2124 if (manager_get_job(m, m->default_unit_job_id))
2127 /* Is there a job for the shutdown target? */
2128 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2135 void manager_reset_failed(Manager *m) {
2141 HASHMAP_FOREACH(u, m->units, i)
2142 unit_reset_failed(u);
2145 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2151 /* Returns true if the unit is inactive or going down */
2152 u = manager_get_unit(m, name);
2156 return unit_pending_inactive(u);
2159 void manager_check_finished(Manager *m) {
2160 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2161 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2165 if (hashmap_size(m->jobs) > 0)
2168 /* Notify Type=idle units that we are done now */
2169 close_pipe(m->idle_pipe);
2171 /* Turn off confirm spawn now */
2172 m->confirm_spawn = false;
2174 if (dual_timestamp_is_set(&m->finish_timestamp))
2177 dual_timestamp_get(&m->finish_timestamp);
2179 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2181 /* Note that m->kernel_usec.monotonic is always at 0,
2182 * and m->firmware_usec.monotonic and
2183 * m->loader_usec.monotonic should be considered
2184 * negative values. */
2186 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2187 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2188 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2189 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2191 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2193 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2194 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2196 if (!log_on_console())
2197 log_struct(LOG_INFO,
2198 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2199 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2200 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2201 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2202 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2203 format_timespan(kernel, sizeof(kernel), kernel_usec),
2204 format_timespan(initrd, sizeof(initrd), initrd_usec),
2205 format_timespan(userspace, sizeof(userspace), userspace_usec),
2206 format_timespan(sum, sizeof(sum), total_usec),
2209 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2212 if (!log_on_console())
2213 log_struct(LOG_INFO,
2214 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2215 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2216 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2217 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2218 format_timespan(kernel, sizeof(kernel), kernel_usec),
2219 format_timespan(userspace, sizeof(userspace), userspace_usec),
2220 format_timespan(sum, sizeof(sum), total_usec),
2224 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2225 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2227 if (!log_on_console())
2228 log_struct(LOG_INFO,
2229 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2230 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2231 "MESSAGE=Startup finished in %s.",
2232 format_timespan(sum, sizeof(sum), total_usec),
2236 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2239 "READY=1\nSTATUS=Startup finished in %s.",
2240 format_timespan(sum, sizeof(sum), total_usec));
2243 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2254 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2256 p = strappend("/run/systemd/", name);
2260 r = mkdir_p_label(p, 0755);
2262 log_error("Failed to create generator directory: %s", strerror(-r));
2267 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2273 log_error("Failed to create generator directory: %m");
2282 static void trim_generator_dir(Manager *m, char **generator) {
2289 if (rmdir(*generator) >= 0) {
2297 void manager_run_generators(Manager *m) {
2299 const char *generator_path;
2300 const char *argv[5];
2306 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2307 d = opendir(generator_path);
2309 if (errno == ENOENT)
2312 log_error("Failed to enumerate generator directory: %m");
2316 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2320 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2324 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2328 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2329 argv[1] = m->generator_unit_path;
2330 argv[2] = m->generator_unit_path_early;
2331 argv[3] = m->generator_unit_path_late;
2335 execute_directory(generator_path, d, (char**) argv);
2338 trim_generator_dir(m, &m->generator_unit_path);
2339 trim_generator_dir(m, &m->generator_unit_path_early);
2340 trim_generator_dir(m, &m->generator_unit_path_late);
2347 static void remove_generator_dir(Manager *m, char **generator) {
2354 strv_remove(m->lookup_paths.unit_path, *generator);
2355 rm_rf(*generator, false, true, false);
2361 void manager_undo_generators(Manager *m) {
2364 remove_generator_dir(m, &m->generator_unit_path);
2365 remove_generator_dir(m, &m->generator_unit_path_early);
2366 remove_generator_dir(m, &m->generator_unit_path_late);
2369 int manager_set_default_controllers(Manager *m, char **controllers) {
2374 l = strv_copy(controllers);
2378 strv_free(m->default_controllers);
2379 m->default_controllers = l;
2381 cg_shorten_controllers(m->default_controllers);
2386 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2391 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2392 if (!default_rlimit[i])
2395 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2403 void manager_recheck_journal(Manager *m) {
2408 if (m->running_as != SYSTEMD_SYSTEM)
2411 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2412 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2413 log_close_journal();
2417 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2418 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2419 log_close_journal();
2423 /* Hmm, OK, so the socket is fully up and the service is up
2424 * too, then let's make use of the thing. */
2428 void manager_set_show_status(Manager *m, bool b) {
2431 if (m->running_as != SYSTEMD_SYSTEM)
2437 touch("/run/systemd/show-status");
2439 unlink("/run/systemd/show-status");
2442 bool manager_get_show_status(Manager *m) {
2445 if (m->running_as != SYSTEMD_SYSTEM)
2451 /* If Plymouth is running make sure we show the status, so
2452 * that there's something nice to see when people press Esc */
2454 return plymouth_running();
2457 void watch_init(Watch *w) {
2460 w->type = WATCH_INVALID;