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_unit(u->id, "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) {
639 log_error("Failed to open directory: %m");
643 while ((de = readdir(d))) {
646 if (ignore_file(de->d_name))
649 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
655 if ((r = set_put(m->unit_path_cache, p)) < 0) {
668 log_error("Failed to build unit path cache: %s", strerror(-r));
670 set_free_free(m->unit_path_cache);
671 m->unit_path_cache = NULL;
677 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
682 manager_run_generators(m);
684 r = lookup_paths_init(
685 &m->lookup_paths, m->running_as, true,
686 m->generator_unit_path,
687 m->generator_unit_path_early,
688 m->generator_unit_path_late);
692 manager_build_unit_path_cache(m);
694 /* If we will deserialize make sure that during enumeration
695 * this is already known, so we increase the counter here
700 /* First, enumerate what we can from all config files */
701 r = manager_enumerate(m);
703 /* Second, deserialize if there is something to deserialize */
705 q = manager_deserialize(m, serialization, fds);
710 /* Any fds left? Find some unit which wants them. This is
711 * useful to allow container managers to pass some file
712 * descriptors to us pre-initialized. This enables
713 * socket-based activation of entire containers. */
714 if (fdset_size(fds) > 0) {
715 q = manager_distribute_fds(m, fds);
720 /* Third, fire things up! */
721 q = manager_coldplug(m);
726 assert(m->n_reloading > 0);
733 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
738 assert(type < _JOB_TYPE_MAX);
740 assert(mode < _JOB_MODE_MAX);
742 if (mode == JOB_ISOLATE && type != JOB_START) {
743 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
747 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
748 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
752 log_debug_unit(unit->id,
753 "Trying to enqueue job %s/%s/%s", unit->id,
754 job_type_to_string(type), job_mode_to_string(mode));
756 job_type_collapse(&type, unit);
758 tr = transaction_new();
762 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
763 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
764 mode == JOB_IGNORE_DEPENDENCIES, e);
768 if (mode == JOB_ISOLATE) {
769 r = transaction_add_isolate_jobs(tr, m);
774 r = transaction_activate(tr, m, mode, e);
778 log_debug_unit(unit->id,
779 "Enqueued job %s/%s as %u", unit->id,
780 job_type_to_string(type), (unsigned) tr->anchor_job->id);
783 *_ret = tr->anchor_job;
785 transaction_free(tr);
789 transaction_abort(tr);
790 transaction_free(tr);
794 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
799 assert(type < _JOB_TYPE_MAX);
801 assert(mode < _JOB_MODE_MAX);
803 r = manager_load_unit(m, name, NULL, NULL, &unit);
807 return manager_add_job(m, type, unit, mode, override, e, _ret);
810 Job *manager_get_job(Manager *m, uint32_t id) {
813 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
816 Unit *manager_get_unit(Manager *m, const char *name) {
820 return hashmap_get(m->units, name);
823 unsigned manager_dispatch_load_queue(Manager *m) {
829 /* Make sure we are not run recursively */
830 if (m->dispatching_load_queue)
833 m->dispatching_load_queue = true;
835 /* Dispatches the load queue. Takes a unit from the queue and
836 * tries to load its data until the queue is empty */
838 while ((u = m->load_queue)) {
839 assert(u->in_load_queue);
845 m->dispatching_load_queue = false;
849 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
855 assert(name || path);
857 /* This will prepare the unit for loading, but not actually
858 * load anything from disk. */
860 if (path && !is_path(path)) {
861 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
866 name = path_get_file_name(path);
868 t = unit_name_to_type(name);
870 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
871 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
875 ret = manager_get_unit(m, name);
881 ret = unit_new(m, unit_vtable[t]->object_size);
886 ret->fragment_path = strdup(path);
887 if (!ret->fragment_path) {
893 if ((r = unit_add_name(ret, name)) < 0) {
898 unit_add_to_load_queue(ret);
899 unit_add_to_dbus_queue(ret);
900 unit_add_to_gc_queue(ret);
908 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
913 /* This will load the service information files, but not actually
914 * start any services or anything. */
916 r = manager_load_unit_prepare(m, name, path, e, _ret);
920 manager_dispatch_load_queue(m);
923 *_ret = unit_follow_merge(*_ret);
928 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
935 HASHMAP_FOREACH(j, s->jobs, i)
936 job_dump(j, f, prefix);
939 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
947 HASHMAP_FOREACH_KEY(u, t, s->units, i)
949 unit_dump(u, f, prefix);
952 void manager_clear_jobs(Manager *m) {
957 while ((j = hashmap_first(m->jobs)))
958 /* No need to recurse. We're cancelling all jobs. */
959 job_finish_and_invalidate(j, JOB_CANCELED, false);
962 unsigned manager_dispatch_run_queue(Manager *m) {
966 if (m->dispatching_run_queue)
969 m->dispatching_run_queue = true;
971 while ((j = m->run_queue)) {
972 assert(j->installed);
973 assert(j->in_run_queue);
975 job_run_and_invalidate(j);
979 m->dispatching_run_queue = false;
983 unsigned manager_dispatch_dbus_queue(Manager *m) {
990 if (m->dispatching_dbus_queue)
993 m->dispatching_dbus_queue = true;
995 while ((u = m->dbus_unit_queue)) {
996 assert(u->in_dbus_queue);
998 bus_unit_send_change_signal(u);
1002 while ((j = m->dbus_job_queue)) {
1003 assert(j->in_dbus_queue);
1005 bus_job_send_change_signal(j);
1009 m->dispatching_dbus_queue = false;
1013 static int manager_process_notify_fd(Manager *m) {
1020 struct msghdr msghdr;
1022 struct ucred *ucred;
1024 struct cmsghdr cmsghdr;
1025 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1031 iovec.iov_base = buf;
1032 iovec.iov_len = sizeof(buf)-1;
1036 msghdr.msg_iov = &iovec;
1037 msghdr.msg_iovlen = 1;
1038 msghdr.msg_control = &control;
1039 msghdr.msg_controllen = sizeof(control);
1041 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1046 if (errno == EAGAIN || errno == EINTR)
1052 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1053 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1054 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1055 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1056 log_warning("Received notify message without credentials. Ignoring.");
1060 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1062 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1064 u = cgroup_unit_by_pid(m, ucred->pid);
1066 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1071 assert((size_t) n < sizeof(buf));
1073 tags = strv_split(buf, "\n\r");
1077 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1079 if (UNIT_VTABLE(u)->notify_message)
1080 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1088 static int manager_dispatch_sigchld(Manager *m) {
1098 /* First we call waitd() for a PID and do not reap the
1099 * zombie. That way we can still access /proc/$PID for
1100 * it while it is a zombie. */
1101 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1103 if (errno == ECHILD)
1115 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1116 char _cleanup_free_ *name = NULL;
1118 get_process_comm(si.si_pid, &name);
1119 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1122 /* Let's flush any message the dying child might still
1123 * have queued for us. This ensures that the process
1124 * still exists in /proc so that we can figure out
1125 * which cgroup and hence unit it belongs to. */
1126 r = manager_process_notify_fd(m);
1130 /* And now figure out the unit this belongs to */
1131 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1133 u = cgroup_unit_by_pid(m, si.si_pid);
1135 /* And now, we actually reap the zombie. */
1136 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1143 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1146 log_debug("Child %lu died (code=%s, status=%i/%s)",
1147 (long unsigned) si.si_pid,
1148 sigchld_code_to_string(si.si_code),
1150 strna(si.si_code == CLD_EXITED
1151 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1152 : signal_to_string(si.si_status)));
1157 log_debug_unit(u->id,
1158 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1160 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1161 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1167 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1171 dbus_error_init(&error);
1173 log_debug_unit(name, "Activating special unit %s", name);
1175 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1177 log_error_unit(name,
1178 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1180 dbus_error_free(&error);
1185 static int manager_process_signal_fd(Manager *m) {
1187 struct signalfd_siginfo sfsi;
1188 bool sigchld = false;
1193 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1194 if (n != sizeof(sfsi)) {
1199 if (errno == EINTR || errno == EAGAIN)
1205 if (sfsi.ssi_pid > 0) {
1208 get_process_comm(sfsi.ssi_pid, &p);
1210 log_debug("Received SIG%s from PID %lu (%s).",
1211 signal_to_string(sfsi.ssi_signo),
1212 (unsigned long) sfsi.ssi_pid, strna(p));
1215 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1217 switch (sfsi.ssi_signo) {
1224 if (m->running_as == SYSTEMD_SYSTEM) {
1225 /* This is for compatibility with the
1226 * original sysvinit */
1227 m->exit_code = MANAGER_REEXECUTE;
1234 if (m->running_as == SYSTEMD_SYSTEM) {
1235 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1239 /* Run the exit target if there is one, if not, just exit. */
1240 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1241 m->exit_code = MANAGER_EXIT;
1248 if (m->running_as == SYSTEMD_SYSTEM)
1249 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1251 /* This is a nop on non-init */
1255 if (m->running_as == SYSTEMD_SYSTEM)
1256 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1258 /* This is a nop on non-init */
1264 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1266 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1267 log_info("Trying to reconnect to bus...");
1271 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1272 log_info("Loading D-Bus service...");
1273 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1284 if (!(f = open_memstream(&dump, &size))) {
1285 log_warning("Failed to allocate memory stream.");
1289 manager_dump_units(m, f, "\t");
1290 manager_dump_jobs(m, f, "\t");
1295 log_warning("Failed to write status stream");
1300 log_dump(LOG_INFO, dump);
1307 m->exit_code = MANAGER_RELOAD;
1312 /* Starting SIGRTMIN+0 */
1313 static const char * const target_table[] = {
1314 [0] = SPECIAL_DEFAULT_TARGET,
1315 [1] = SPECIAL_RESCUE_TARGET,
1316 [2] = SPECIAL_EMERGENCY_TARGET,
1317 [3] = SPECIAL_HALT_TARGET,
1318 [4] = SPECIAL_POWEROFF_TARGET,
1319 [5] = SPECIAL_REBOOT_TARGET,
1320 [6] = SPECIAL_KEXEC_TARGET
1323 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1324 static const ManagerExitCode code_table[] = {
1326 [1] = MANAGER_POWEROFF,
1327 [2] = MANAGER_REBOOT,
1331 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1332 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1333 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1334 manager_start_target(m, target_table[idx],
1335 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1339 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1340 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1341 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1345 switch (sfsi.ssi_signo - SIGRTMIN) {
1348 log_debug("Enabling showing of status.");
1349 manager_set_show_status(m, true);
1353 log_debug("Disabling showing of status.");
1354 manager_set_show_status(m, false);
1358 log_set_max_level(LOG_DEBUG);
1359 log_notice("Setting log level to debug.");
1363 log_set_max_level(LOG_INFO);
1364 log_notice("Setting log level to info.");
1368 if (m->running_as == SYSTEMD_USER) {
1369 m->exit_code = MANAGER_EXIT;
1373 /* This is a nop on init */
1377 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1378 log_notice("Setting log target to journal-or-kmsg.");
1382 log_set_target(LOG_TARGET_CONSOLE);
1383 log_notice("Setting log target to console.");
1387 log_set_target(LOG_TARGET_KMSG);
1388 log_notice("Setting log target to kmsg.");
1392 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1393 log_notice("Setting log target to syslog-or-kmsg.");
1397 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1404 return manager_dispatch_sigchld(m);
1409 static int process_event(Manager *m, struct epoll_event *ev) {
1416 assert_se(w = ev->data.ptr);
1418 if (w->type == WATCH_INVALID)
1425 /* An incoming signal? */
1426 if (ev->events != EPOLLIN)
1429 if ((r = manager_process_signal_fd(m)) < 0)
1436 /* An incoming daemon notification event? */
1437 if (ev->events != EPOLLIN)
1440 if ((r = manager_process_notify_fd(m)) < 0)
1447 /* Some fd event, to be dispatched to the units */
1448 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1451 case WATCH_UNIT_TIMER:
1452 case WATCH_JOB_TIMER: {
1456 /* Some timer event, to be dispatched to the units */
1457 k = read(w->fd, &v, sizeof(v));
1458 if (k != sizeof(v)) {
1460 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1463 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1464 return k < 0 ? -errno : -EIO;
1467 if (w->type == WATCH_UNIT_TIMER)
1468 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1470 job_timer_event(w->data.job, v, w);
1475 /* Some mount table change, intended for the mount subsystem */
1476 mount_fd_event(m, ev->events);
1480 /* Some swap table change, intended for the swap subsystem */
1481 swap_fd_event(m, ev->events);
1485 /* Some notification from udev, intended for the device subsystem */
1486 device_fd_event(m, ev->events);
1489 case WATCH_DBUS_WATCH:
1490 bus_watch_event(m, w, ev->events);
1493 case WATCH_DBUS_TIMEOUT:
1494 bus_timeout_event(m, w, ev->events);
1497 case WATCH_TIME_CHANGE: {
1501 log_struct(LOG_INFO,
1502 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1503 "MESSAGE=Time has been changed",
1506 /* Restart the watch */
1507 close_nointr_nofail(m->time_change_watch.fd);
1508 watch_init(&m->time_change_watch);
1509 manager_setup_time_change(m);
1511 HASHMAP_FOREACH(u, m->units, i) {
1512 if (UNIT_VTABLE(u)->time_change)
1513 UNIT_VTABLE(u)->time_change(u);
1520 log_error("event type=%i", w->type);
1521 assert_not_reached("Unknown epoll event type.");
1527 int manager_loop(Manager *m) {
1530 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1533 m->exit_code = MANAGER_RUNNING;
1535 /* Release the path cache */
1536 set_free_free(m->unit_path_cache);
1537 m->unit_path_cache = NULL;
1539 manager_check_finished(m);
1541 /* There might still be some zombies hanging around from
1542 * before we were exec()'ed. Leat's reap them */
1543 r = manager_dispatch_sigchld(m);
1547 while (m->exit_code == MANAGER_RUNNING) {
1548 struct epoll_event event;
1552 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1555 if (!ratelimit_test(&rl)) {
1556 /* Yay, something is going seriously wrong, pause a little */
1557 log_warning("Looping too fast. Throttling execution a little.");
1562 if (manager_dispatch_load_queue(m) > 0)
1565 if (manager_dispatch_run_queue(m) > 0)
1568 if (bus_dispatch(m) > 0)
1571 if (manager_dispatch_cleanup_queue(m) > 0)
1574 if (manager_dispatch_gc_queue(m) > 0)
1577 if (manager_dispatch_dbus_queue(m) > 0)
1580 if (swap_dispatch_reload(m) > 0)
1583 /* Sleep for half the watchdog time */
1584 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1585 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1591 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1603 r = process_event(m, &event);
1608 return m->exit_code;
1611 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1620 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1623 n = bus_path_unescape(s+31);
1627 r = manager_load_unit(m, n, NULL, e, &u);
1638 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1647 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1650 r = safe_atou(s + 30, &id);
1654 j = manager_get_job(m, id);
1663 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1669 audit_fd = get_audit_fd();
1673 /* Don't generate audit events if the service was already
1674 * started and we're just deserializing */
1675 if (m->n_reloading > 0)
1678 if (m->running_as != SYSTEMD_SYSTEM)
1681 if (u->type != UNIT_SERVICE)
1684 p = unit_name_to_prefix_and_instance(u->id);
1686 log_error_unit(u->id,
1687 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1691 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1692 if (errno == EPERM) {
1693 /* We aren't allowed to send audit messages?
1694 * Then let's not retry again. */
1697 log_warning("Failed to send audit message: %m");
1705 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1707 union sockaddr_union sa;
1709 char *message = NULL;
1711 /* Don't generate plymouth events if the service was already
1712 * started and we're just deserializing */
1713 if (m->n_reloading > 0)
1716 if (m->running_as != SYSTEMD_SYSTEM)
1719 if (u->type != UNIT_SERVICE &&
1720 u->type != UNIT_MOUNT &&
1721 u->type != UNIT_SWAP)
1724 /* We set SOCK_NONBLOCK here so that we rather drop the
1725 * message then wait for plymouth */
1726 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1727 log_error("socket() failed: %m");
1732 sa.sa.sa_family = AF_UNIX;
1733 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1734 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1736 if (errno != EPIPE &&
1739 errno != ECONNREFUSED &&
1740 errno != ECONNRESET &&
1741 errno != ECONNABORTED)
1742 log_error("connect() failed: %m");
1747 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1753 if (write(fd, message, n + 1) != n + 1) {
1755 if (errno != EPIPE &&
1758 errno != ECONNREFUSED &&
1759 errno != ECONNRESET &&
1760 errno != ECONNABORTED)
1761 log_error("Failed to write Plymouth message: %m");
1768 close_nointr_nofail(fd);
1773 void manager_dispatch_bus_name_owner_changed(
1776 const char* old_owner,
1777 const char *new_owner) {
1784 if (!(u = hashmap_get(m->watch_bus, name)))
1787 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1790 void manager_dispatch_bus_query_pid_done(
1801 if (!(u = hashmap_get(m->watch_bus, name)))
1804 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1807 int manager_open_serialization(Manager *m, FILE **_f) {
1815 if (m->running_as == SYSTEMD_SYSTEM)
1816 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1818 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1823 saved_umask = umask(0077);
1824 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1834 log_debug("Serializing state to %s", path);
1837 f = fdopen(fd, "w+");
1846 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
1858 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1859 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1860 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1861 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1863 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1864 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1865 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1866 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1869 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1870 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1875 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1879 if (!unit_can_serialize(u))
1886 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
1892 assert(m->n_reloading > 0);
1898 r = bus_fdset_add_all(m, fds);
1905 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1911 log_debug("Deserializing state...");
1916 char line[LINE_MAX], *l;
1918 if (!fgets(line, sizeof(line), f)) {
1933 if (startswith(l, "current-job-id=")) {
1936 if (safe_atou32(l+15, &id) < 0)
1937 log_debug("Failed to parse current job id value %s", l+15);
1939 m->current_job_id = MAX(m->current_job_id, id);
1940 } else if (startswith(l, "n-installed-jobs=")) {
1943 if (safe_atou32(l+17, &n) < 0)
1944 log_debug("Failed to parse installed jobs counter %s", l+17);
1946 m->n_installed_jobs += n;
1947 } else if (startswith(l, "n-failed-jobs=")) {
1950 if (safe_atou32(l+14, &n) < 0)
1951 log_debug("Failed to parse failed jobs counter %s", l+14);
1953 m->n_failed_jobs += n;
1954 } else if (startswith(l, "taint-usr=")) {
1957 if ((b = parse_boolean(l+10)) < 0)
1958 log_debug("Failed to parse taint /usr flag %s", l+10);
1960 m->taint_usr = m->taint_usr || b;
1961 } else if (startswith(l, "firmware-timestamp="))
1962 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
1963 else if (startswith(l, "loader-timestamp="))
1964 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
1965 else if (startswith(l, "kernel-timestamp="))
1966 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
1967 else if (startswith(l, "initrd-timestamp="))
1968 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1969 else if (startswith(l, "userspace-timestamp="))
1970 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
1971 else if (startswith(l, "finish-timestamp="))
1972 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1974 log_debug("Unknown serialization item '%s'", l);
1979 char name[UNIT_NAME_MAX+2];
1982 if (!fgets(name, sizeof(name), f)) {
1993 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
1997 r = unit_deserialize(u, f, fds);
2008 assert(m->n_reloading > 0);
2014 int manager_distribute_fds(Manager *m, FDSet *fds) {
2021 HASHMAP_FOREACH(u, m->units, i) {
2023 if (fdset_size(fds) <= 0)
2026 if (UNIT_VTABLE(u)->distribute_fds) {
2027 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2036 int manager_reload(Manager *m) {
2043 r = manager_open_serialization(m, &f);
2056 r = manager_serialize(m, f, fds, true);
2062 if (fseeko(f, 0, SEEK_SET) < 0) {
2068 /* From here on there is no way back. */
2069 manager_clear_jobs_and_units(m);
2070 manager_undo_generators(m);
2071 lookup_paths_free(&m->lookup_paths);
2073 /* Find new unit paths */
2074 manager_run_generators(m);
2076 q = lookup_paths_init(
2077 &m->lookup_paths, m->running_as, true,
2078 m->generator_unit_path,
2079 m->generator_unit_path_early,
2080 m->generator_unit_path_late);
2084 manager_build_unit_path_cache(m);
2086 /* First, enumerate what we can from all config files */
2087 q = manager_enumerate(m);
2091 /* Second, deserialize our stored data */
2092 q = manager_deserialize(m, f, fds);
2099 /* Third, fire things up! */
2100 q = manager_coldplug(m);
2104 assert(m->n_reloading > 0);
2117 bool manager_is_booting_or_shutting_down(Manager *m) {
2122 /* Is the initial job still around? */
2123 if (manager_get_job(m, m->default_unit_job_id))
2126 /* Is there a job for the shutdown target? */
2127 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2134 void manager_reset_failed(Manager *m) {
2140 HASHMAP_FOREACH(u, m->units, i)
2141 unit_reset_failed(u);
2144 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2150 /* Returns true if the unit is inactive or going down */
2151 u = manager_get_unit(m, name);
2155 return unit_pending_inactive(u);
2158 void manager_check_finished(Manager *m) {
2159 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2160 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2164 if (hashmap_size(m->jobs) > 0)
2167 /* Notify Type=idle units that we are done now */
2168 close_pipe(m->idle_pipe);
2170 /* Turn off confirm spawn now */
2171 m->confirm_spawn = false;
2173 if (dual_timestamp_is_set(&m->finish_timestamp))
2176 dual_timestamp_get(&m->finish_timestamp);
2178 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2180 /* Note that m->kernel_usec.monotonic is always at 0,
2181 * and m->firmware_usec.monotonic and
2182 * m->loader_usec.monotonic should be considered
2183 * negative values. */
2185 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2186 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2187 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2188 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2190 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2192 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2193 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2195 if (!log_on_console())
2196 log_struct(LOG_INFO,
2197 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2198 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2199 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2200 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2201 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2202 format_timespan(kernel, sizeof(kernel), kernel_usec),
2203 format_timespan(initrd, sizeof(initrd), initrd_usec),
2204 format_timespan(userspace, sizeof(userspace), userspace_usec),
2205 format_timespan(sum, sizeof(sum), total_usec),
2208 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2211 if (!log_on_console())
2212 log_struct(LOG_INFO,
2213 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2214 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2215 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2216 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2217 format_timespan(kernel, sizeof(kernel), kernel_usec),
2218 format_timespan(userspace, sizeof(userspace), userspace_usec),
2219 format_timespan(sum, sizeof(sum), total_usec),
2223 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2224 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2226 if (!log_on_console())
2227 log_struct(LOG_INFO,
2228 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2229 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2230 "MESSAGE=Startup finished in %s.",
2231 format_timespan(sum, sizeof(sum), total_usec),
2235 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2238 "READY=1\nSTATUS=Startup finished in %s.",
2239 format_timespan(sum, sizeof(sum), total_usec));
2242 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2253 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2255 p = strappend("/run/systemd/", name);
2259 r = mkdir_p_label(p, 0755);
2261 log_error("Failed to create generator directory: %s", strerror(-r));
2266 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2272 log_error("Failed to create generator directory: %m");
2281 static void trim_generator_dir(Manager *m, char **generator) {
2288 if (rmdir(*generator) >= 0) {
2296 void manager_run_generators(Manager *m) {
2298 const char *generator_path;
2299 const char *argv[5];
2305 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2306 d = opendir(generator_path);
2308 if (errno == ENOENT)
2311 log_error("Failed to enumerate generator directory: %m");
2315 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2319 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2323 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2327 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2328 argv[1] = m->generator_unit_path;
2329 argv[2] = m->generator_unit_path_early;
2330 argv[3] = m->generator_unit_path_late;
2334 execute_directory(generator_path, d, (char**) argv);
2337 trim_generator_dir(m, &m->generator_unit_path);
2338 trim_generator_dir(m, &m->generator_unit_path_early);
2339 trim_generator_dir(m, &m->generator_unit_path_late);
2346 static void remove_generator_dir(Manager *m, char **generator) {
2353 strv_remove(m->lookup_paths.unit_path, *generator);
2354 rm_rf(*generator, false, true, false);
2360 void manager_undo_generators(Manager *m) {
2363 remove_generator_dir(m, &m->generator_unit_path);
2364 remove_generator_dir(m, &m->generator_unit_path_early);
2365 remove_generator_dir(m, &m->generator_unit_path_late);
2368 int manager_set_default_controllers(Manager *m, char **controllers) {
2373 l = strv_copy(controllers);
2377 strv_free(m->default_controllers);
2378 m->default_controllers = l;
2380 cg_shorten_controllers(m->default_controllers);
2385 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2390 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2391 if (!default_rlimit[i])
2394 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2402 void manager_recheck_journal(Manager *m) {
2407 if (m->running_as != SYSTEMD_SYSTEM)
2410 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2411 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2412 log_close_journal();
2416 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2417 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2418 log_close_journal();
2422 /* Hmm, OK, so the socket is fully up and the service is up
2423 * too, then let's make use of the thing. */
2427 void manager_set_show_status(Manager *m, bool b) {
2430 if (m->running_as != SYSTEMD_SYSTEM)
2436 touch("/run/systemd/show-status");
2438 unlink("/run/systemd/show-status");
2441 bool manager_get_show_status(Manager *m) {
2444 if (m->running_as != SYSTEMD_SYSTEM)
2450 /* If Plymouth is running make sure we show the status, so
2451 * that there's something nice to see when people press Esc */
2453 return plymouth_running();
2456 void watch_init(Watch *w) {
2459 w->type = WATCH_INVALID;