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");
157 its.it_value.tv_sec = 10000000000; /* Year 2287 or so... */
158 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
159 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
160 close_nointr_nofail(m->time_change_watch.fd);
161 watch_init(&m->time_change_watch);
167 ev.data.ptr = &m->time_change_watch;
169 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
170 log_error("Failed to add timer change fd to epoll: %m");
174 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
179 static int enable_special_signals(Manager *m) {
184 /* Enable that we get SIGINT on control-alt-del. In containers
185 * this will fail with EPERM (older) or EINVAL (newer), so
187 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
188 log_warning("Failed to enable ctrl-alt-del handling: %m");
190 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
192 /* Support systems without virtual console */
194 log_warning("Failed to open /dev/tty0: %m");
196 /* Enable that we get SIGWINCH on kbrequest */
197 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
198 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
200 close_nointr_nofail(fd);
206 static int manager_setup_signals(Manager *m) {
208 struct epoll_event ev;
213 /* We are not interested in SIGSTOP and friends. */
215 sa.sa_handler = SIG_DFL;
216 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
217 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
219 assert_se(sigemptyset(&mask) == 0);
221 sigset_add_many(&mask,
222 SIGCHLD, /* Child died */
223 SIGTERM, /* Reexecute daemon */
224 SIGHUP, /* Reload configuration */
225 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
226 SIGUSR2, /* systemd: dump status */
227 SIGINT, /* Kernel sends us this on control-alt-del */
228 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
229 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
230 SIGRTMIN+0, /* systemd: start default.target */
231 SIGRTMIN+1, /* systemd: isolate rescue.target */
232 SIGRTMIN+2, /* systemd: isolate emergency.target */
233 SIGRTMIN+3, /* systemd: start halt.target */
234 SIGRTMIN+4, /* systemd: start poweroff.target */
235 SIGRTMIN+5, /* systemd: start reboot.target */
236 SIGRTMIN+6, /* systemd: start kexec.target */
237 SIGRTMIN+13, /* systemd: Immediate halt */
238 SIGRTMIN+14, /* systemd: Immediate poweroff */
239 SIGRTMIN+15, /* systemd: Immediate reboot */
240 SIGRTMIN+16, /* systemd: Immediate kexec */
241 SIGRTMIN+20, /* systemd: enable status messages */
242 SIGRTMIN+21, /* systemd: disable status messages */
243 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
244 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
245 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
246 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
247 SIGRTMIN+27, /* systemd: set log target to console */
248 SIGRTMIN+28, /* systemd: set log target to kmsg */
249 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
251 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
253 m->signal_watch.type = WATCH_SIGNAL;
254 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
255 if (m->signal_watch.fd < 0)
260 ev.data.ptr = &m->signal_watch;
262 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
265 if (m->running_as == SYSTEMD_SYSTEM)
266 return enable_special_signals(m);
271 static void manager_strip_environment(Manager *m) {
274 /* Remove variables from the inherited set that are part of
275 * the container interface:
276 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
277 strv_remove_prefix(m->environment, "container=");
278 strv_remove_prefix(m->environment, "container_");
280 /* Remove variables from the inherited set that are part of
281 * the initrd interface:
282 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
283 strv_remove_prefix(m->environment, "RD_");
286 int manager_new(SystemdRunningAs running_as, Manager **_m) {
291 assert(running_as >= 0);
292 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
294 m = new0(Manager, 1);
298 dual_timestamp_get(&m->userspace_timestamp);
300 m->running_as = running_as;
301 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
302 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
303 m->pin_cgroupfs_fd = -1;
304 m->idle_pipe[0] = m->idle_pipe[1] = -1;
306 watch_init(&m->signal_watch);
307 watch_init(&m->mount_watch);
308 watch_init(&m->swap_watch);
309 watch_init(&m->udev_watch);
310 watch_init(&m->time_change_watch);
312 m->epoll_fd = m->dev_autofs_fd = -1;
313 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
315 m->environment = strv_copy(environ);
319 manager_strip_environment(m);
321 if (running_as == SYSTEMD_SYSTEM) {
322 m->default_controllers = strv_new("cpu", NULL);
323 if (!m->default_controllers)
327 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
330 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
333 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
336 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
339 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
342 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
346 r = manager_setup_signals(m);
350 r = manager_setup_cgroup(m);
354 r = manager_setup_notify(m);
358 r = manager_setup_time_change(m);
362 /* Try to connect to the busses, if possible. */
363 r = bus_init(m, running_as != SYSTEMD_SYSTEM);
367 m->taint_usr = dir_is_empty("/usr") > 0;
377 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
383 while ((u = m->cleanup_queue)) {
384 assert(u->in_cleanup_queue);
394 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
395 GC_OFFSET_UNSURE, /* No clue */
396 GC_OFFSET_GOOD, /* We still need this unit */
397 GC_OFFSET_BAD, /* We don't need this unit anymore */
401 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
408 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
409 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
410 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
413 if (u->in_cleanup_queue)
416 if (unit_check_gc(u))
419 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
423 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
424 unit_gc_sweep(other, gc_marker);
426 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
429 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
436 /* We were unable to find anything out about this entry, so
437 * let's investigate it later */
438 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
439 unit_add_to_gc_queue(u);
443 /* We definitely know that this one is not useful anymore, so
444 * let's mark it for deletion */
445 u->gc_marker = gc_marker + GC_OFFSET_BAD;
446 unit_add_to_cleanup_queue(u);
450 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
453 static unsigned manager_dispatch_gc_queue(Manager *m) {
460 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
461 (m->gc_queue_timestamp <= 0 ||
462 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
465 log_debug("Running GC...");
467 m->gc_marker += _GC_OFFSET_MAX;
468 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
471 gc_marker = m->gc_marker;
473 while ((u = m->gc_queue)) {
474 assert(u->in_gc_queue);
476 unit_gc_sweep(u, gc_marker);
478 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
479 u->in_gc_queue = false;
483 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
484 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
485 log_debug("Collecting %s", u->id);
486 u->gc_marker = gc_marker + GC_OFFSET_BAD;
487 unit_add_to_cleanup_queue(u);
491 m->n_in_gc_queue = 0;
492 m->gc_queue_timestamp = 0;
497 static void manager_clear_jobs_and_units(Manager *m) {
502 while ((u = hashmap_first(m->units)))
505 manager_dispatch_cleanup_queue(m);
507 assert(!m->load_queue);
508 assert(!m->run_queue);
509 assert(!m->dbus_unit_queue);
510 assert(!m->dbus_job_queue);
511 assert(!m->cleanup_queue);
512 assert(!m->gc_queue);
514 assert(hashmap_isempty(m->jobs));
515 assert(hashmap_isempty(m->units));
518 void manager_free(Manager *m) {
524 manager_clear_jobs_and_units(m);
526 for (c = 0; c < _UNIT_TYPE_MAX; c++)
527 if (unit_vtable[c]->shutdown)
528 unit_vtable[c]->shutdown(m);
530 /* If we reexecute ourselves, we keep the root cgroup
532 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
534 manager_undo_generators(m);
538 hashmap_free(m->units);
539 hashmap_free(m->jobs);
540 hashmap_free(m->watch_pids);
541 hashmap_free(m->watch_bus);
543 if (m->epoll_fd >= 0)
544 close_nointr_nofail(m->epoll_fd);
545 if (m->signal_watch.fd >= 0)
546 close_nointr_nofail(m->signal_watch.fd);
547 if (m->notify_watch.fd >= 0)
548 close_nointr_nofail(m->notify_watch.fd);
549 if (m->time_change_watch.fd >= 0)
550 close_nointr_nofail(m->time_change_watch.fd);
552 free(m->notify_socket);
554 lookup_paths_free(&m->lookup_paths);
555 strv_free(m->environment);
557 strv_free(m->default_controllers);
559 hashmap_free(m->cgroup_bondings);
560 set_free_free(m->unit_path_cache);
562 close_pipe(m->idle_pipe);
564 free(m->switch_root);
565 free(m->switch_root_init);
567 for (i = 0; i < RLIMIT_NLIMITS; i++)
573 int manager_enumerate(Manager *m) {
579 /* Let's ask every type to load all units from disk/kernel
580 * that it might know */
581 for (c = 0; c < _UNIT_TYPE_MAX; c++)
582 if (unit_vtable[c]->enumerate)
583 if ((q = unit_vtable[c]->enumerate(m)) < 0)
586 manager_dispatch_load_queue(m);
590 int manager_coldplug(Manager *m) {
598 /* Then, let's set up their initial state. */
599 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
605 if ((q = unit_coldplug(u)) < 0)
612 static void manager_build_unit_path_cache(Manager *m) {
619 set_free_free(m->unit_path_cache);
621 if (!(m->unit_path_cache = set_new(string_hash_func, string_compare_func))) {
622 log_error("Failed to allocate unit path cache.");
626 /* This simply builds a list of files we know exist, so that
627 * we don't always have to go to disk */
629 STRV_FOREACH(i, m->lookup_paths.unit_path) {
632 if (!(d = opendir(*i))) {
633 log_error("Failed to open directory: %m");
637 while ((de = readdir(d))) {
640 if (ignore_file(de->d_name))
643 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
649 if ((r = set_put(m->unit_path_cache, p)) < 0) {
662 log_error("Failed to build unit path cache: %s", strerror(-r));
664 set_free_free(m->unit_path_cache);
665 m->unit_path_cache = NULL;
671 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
676 manager_run_generators(m);
678 r = lookup_paths_init(
679 &m->lookup_paths, m->running_as, true,
680 m->generator_unit_path,
681 m->generator_unit_path_early,
682 m->generator_unit_path_late);
686 manager_build_unit_path_cache(m);
688 /* If we will deserialize make sure that during enumeration
689 * this is already known, so we increase the counter here
694 /* First, enumerate what we can from all config files */
695 r = manager_enumerate(m);
697 /* Second, deserialize if there is something to deserialize */
699 q = manager_deserialize(m, serialization, fds);
704 /* Third, fire things up! */
705 q = manager_coldplug(m);
710 assert(m->n_reloading > 0);
717 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
722 assert(type < _JOB_TYPE_MAX);
724 assert(mode < _JOB_MODE_MAX);
726 if (mode == JOB_ISOLATE && type != JOB_START) {
727 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
731 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
732 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
736 log_debug("Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
738 job_type_collapse(&type, unit);
740 tr = transaction_new();
744 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
745 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
746 mode == JOB_IGNORE_DEPENDENCIES, e);
750 if (mode == JOB_ISOLATE) {
751 r = transaction_add_isolate_jobs(tr, m);
756 r = transaction_activate(tr, m, mode, e);
760 log_debug("Enqueued job %s/%s as %u", unit->id, job_type_to_string(type), (unsigned) tr->anchor_job->id);
763 *_ret = tr->anchor_job;
765 transaction_free(tr);
769 transaction_abort(tr);
770 transaction_free(tr);
774 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
779 assert(type < _JOB_TYPE_MAX);
781 assert(mode < _JOB_MODE_MAX);
783 r = manager_load_unit(m, name, NULL, NULL, &unit);
787 return manager_add_job(m, type, unit, mode, override, e, _ret);
790 Job *manager_get_job(Manager *m, uint32_t id) {
793 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
796 Unit *manager_get_unit(Manager *m, const char *name) {
800 return hashmap_get(m->units, name);
803 unsigned manager_dispatch_load_queue(Manager *m) {
809 /* Make sure we are not run recursively */
810 if (m->dispatching_load_queue)
813 m->dispatching_load_queue = true;
815 /* Dispatches the load queue. Takes a unit from the queue and
816 * tries to load its data until the queue is empty */
818 while ((u = m->load_queue)) {
819 assert(u->in_load_queue);
825 m->dispatching_load_queue = false;
829 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
835 assert(name || path);
837 /* This will prepare the unit for loading, but not actually
838 * load anything from disk. */
840 if (path && !is_path(path)) {
841 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
846 name = path_get_file_name(path);
848 t = unit_name_to_type(name);
850 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
851 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
855 ret = manager_get_unit(m, name);
861 ret = unit_new(m, unit_vtable[t]->object_size);
866 ret->fragment_path = strdup(path);
867 if (!ret->fragment_path) {
873 if ((r = unit_add_name(ret, name)) < 0) {
878 unit_add_to_load_queue(ret);
879 unit_add_to_dbus_queue(ret);
880 unit_add_to_gc_queue(ret);
888 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
893 /* This will load the service information files, but not actually
894 * start any services or anything. */
896 r = manager_load_unit_prepare(m, name, path, e, _ret);
900 manager_dispatch_load_queue(m);
903 *_ret = unit_follow_merge(*_ret);
908 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
915 HASHMAP_FOREACH(j, s->jobs, i)
916 job_dump(j, f, prefix);
919 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
927 HASHMAP_FOREACH_KEY(u, t, s->units, i)
929 unit_dump(u, f, prefix);
932 void manager_clear_jobs(Manager *m) {
937 while ((j = hashmap_first(m->jobs)))
938 /* No need to recurse. We're cancelling all jobs. */
939 job_finish_and_invalidate(j, JOB_CANCELED, false);
942 unsigned manager_dispatch_run_queue(Manager *m) {
946 if (m->dispatching_run_queue)
949 m->dispatching_run_queue = true;
951 while ((j = m->run_queue)) {
952 assert(j->installed);
953 assert(j->in_run_queue);
955 job_run_and_invalidate(j);
959 m->dispatching_run_queue = false;
963 unsigned manager_dispatch_dbus_queue(Manager *m) {
970 if (m->dispatching_dbus_queue)
973 m->dispatching_dbus_queue = true;
975 while ((u = m->dbus_unit_queue)) {
976 assert(u->in_dbus_queue);
978 bus_unit_send_change_signal(u);
982 while ((j = m->dbus_job_queue)) {
983 assert(j->in_dbus_queue);
985 bus_job_send_change_signal(j);
989 m->dispatching_dbus_queue = false;
993 static int manager_process_notify_fd(Manager *m) {
1000 struct msghdr msghdr;
1002 struct ucred *ucred;
1004 struct cmsghdr cmsghdr;
1005 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1011 iovec.iov_base = buf;
1012 iovec.iov_len = sizeof(buf)-1;
1016 msghdr.msg_iov = &iovec;
1017 msghdr.msg_iovlen = 1;
1018 msghdr.msg_control = &control;
1019 msghdr.msg_controllen = sizeof(control);
1021 if ((n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT)) <= 0) {
1025 if (errno == EAGAIN || errno == EINTR)
1031 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1032 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1033 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1034 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1035 log_warning("Received notify message without credentials. Ignoring.");
1039 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1041 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid))))
1042 if (!(u = cgroup_unit_by_pid(m, ucred->pid))) {
1043 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1047 assert((size_t) n < sizeof(buf));
1049 if (!(tags = strv_split(buf, "\n\r")))
1052 log_debug("Got notification message for unit %s", u->id);
1054 if (UNIT_VTABLE(u)->notify_message)
1055 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1063 static int manager_dispatch_sigchld(Manager *m) {
1073 /* First we call waitd() for a PID and do not reap the
1074 * zombie. That way we can still access /proc/$PID for
1075 * it while it is a zombie. */
1076 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1078 if (errno == ECHILD)
1090 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1093 get_process_comm(si.si_pid, &name);
1094 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1098 /* Let's flush any message the dying child might still
1099 * have queued for us. This ensures that the process
1100 * still exists in /proc so that we can figure out
1101 * which cgroup and hence unit it belongs to. */
1102 if ((r = manager_process_notify_fd(m)) < 0)
1105 /* And now figure out the unit this belongs to */
1106 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid))))
1107 u = cgroup_unit_by_pid(m, si.si_pid);
1109 /* And now, we actually reap the zombie. */
1110 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1117 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1120 log_debug("Child %lu died (code=%s, status=%i/%s)",
1121 (long unsigned) si.si_pid,
1122 sigchld_code_to_string(si.si_code),
1124 strna(si.si_code == CLD_EXITED
1125 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1126 : signal_to_string(si.si_status)));
1131 log_debug("Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1133 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1134 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1140 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1144 dbus_error_init(&error);
1146 log_debug("Activating special unit %s", name);
1148 if ((r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL)) < 0)
1149 log_error("Failed to enqueue %s job: %s", name, bus_error(&error, r));
1151 dbus_error_free(&error);
1156 static int manager_process_signal_fd(Manager *m) {
1158 struct signalfd_siginfo sfsi;
1159 bool sigchld = false;
1164 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
1169 if (errno == EINTR || errno == EAGAIN)
1175 if (sfsi.ssi_pid > 0) {
1178 get_process_comm(sfsi.ssi_pid, &p);
1180 log_debug("Received SIG%s from PID %lu (%s).",
1181 signal_to_string(sfsi.ssi_signo),
1182 (unsigned long) sfsi.ssi_pid, strna(p));
1185 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1187 switch (sfsi.ssi_signo) {
1194 if (m->running_as == SYSTEMD_SYSTEM) {
1195 /* This is for compatibility with the
1196 * original sysvinit */
1197 m->exit_code = MANAGER_REEXECUTE;
1204 if (m->running_as == SYSTEMD_SYSTEM) {
1205 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1209 /* Run the exit target if there is one, if not, just exit. */
1210 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1211 m->exit_code = MANAGER_EXIT;
1218 if (m->running_as == SYSTEMD_SYSTEM)
1219 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1221 /* This is a nop on non-init */
1225 if (m->running_as == SYSTEMD_SYSTEM)
1226 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1228 /* This is a nop on non-init */
1234 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1236 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1237 log_info("Trying to reconnect to bus...");
1241 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1242 log_info("Loading D-Bus service...");
1243 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1254 if (!(f = open_memstream(&dump, &size))) {
1255 log_warning("Failed to allocate memory stream.");
1259 manager_dump_units(m, f, "\t");
1260 manager_dump_jobs(m, f, "\t");
1265 log_warning("Failed to write status stream");
1270 log_dump(LOG_INFO, dump);
1277 m->exit_code = MANAGER_RELOAD;
1282 /* Starting SIGRTMIN+0 */
1283 static const char * const target_table[] = {
1284 [0] = SPECIAL_DEFAULT_TARGET,
1285 [1] = SPECIAL_RESCUE_TARGET,
1286 [2] = SPECIAL_EMERGENCY_TARGET,
1287 [3] = SPECIAL_HALT_TARGET,
1288 [4] = SPECIAL_POWEROFF_TARGET,
1289 [5] = SPECIAL_REBOOT_TARGET,
1290 [6] = SPECIAL_KEXEC_TARGET
1293 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1294 static const ManagerExitCode code_table[] = {
1296 [1] = MANAGER_POWEROFF,
1297 [2] = MANAGER_REBOOT,
1301 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1302 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1303 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1304 manager_start_target(m, target_table[idx],
1305 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1309 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1310 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1311 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1315 switch (sfsi.ssi_signo - SIGRTMIN) {
1318 log_debug("Enabling showing of status.");
1319 manager_set_show_status(m, true);
1323 log_debug("Disabling showing of status.");
1324 manager_set_show_status(m, false);
1328 log_set_max_level(LOG_DEBUG);
1329 log_notice("Setting log level to debug.");
1333 log_set_max_level(LOG_INFO);
1334 log_notice("Setting log level to info.");
1338 if (m->running_as == SYSTEMD_USER) {
1339 m->exit_code = MANAGER_EXIT;
1343 /* This is a nop on init */
1347 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1348 log_notice("Setting log target to journal-or-kmsg.");
1352 log_set_target(LOG_TARGET_CONSOLE);
1353 log_notice("Setting log target to console.");
1357 log_set_target(LOG_TARGET_KMSG);
1358 log_notice("Setting log target to kmsg.");
1362 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1363 log_notice("Setting log target to syslog-or-kmsg.");
1367 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1374 return manager_dispatch_sigchld(m);
1379 static int process_event(Manager *m, struct epoll_event *ev) {
1386 assert_se(w = ev->data.ptr);
1388 if (w->type == WATCH_INVALID)
1395 /* An incoming signal? */
1396 if (ev->events != EPOLLIN)
1399 if ((r = manager_process_signal_fd(m)) < 0)
1406 /* An incoming daemon notification event? */
1407 if (ev->events != EPOLLIN)
1410 if ((r = manager_process_notify_fd(m)) < 0)
1417 /* Some fd event, to be dispatched to the units */
1418 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1421 case WATCH_UNIT_TIMER:
1422 case WATCH_JOB_TIMER: {
1426 /* Some timer event, to be dispatched to the units */
1427 k = read(w->fd, &v, sizeof(v));
1428 if (k != sizeof(v)) {
1430 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1433 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1434 return k < 0 ? -errno : -EIO;
1437 if (w->type == WATCH_UNIT_TIMER)
1438 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1440 job_timer_event(w->data.job, v, w);
1445 /* Some mount table change, intended for the mount subsystem */
1446 mount_fd_event(m, ev->events);
1450 /* Some swap table change, intended for the swap subsystem */
1451 swap_fd_event(m, ev->events);
1455 /* Some notification from udev, intended for the device subsystem */
1456 device_fd_event(m, ev->events);
1459 case WATCH_DBUS_WATCH:
1460 bus_watch_event(m, w, ev->events);
1463 case WATCH_DBUS_TIMEOUT:
1464 bus_timeout_event(m, w, ev->events);
1467 case WATCH_TIME_CHANGE: {
1471 log_struct(LOG_INFO,
1472 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1473 "MESSAGE=Time has been changed",
1476 /* Restart the watch */
1477 close_nointr_nofail(m->time_change_watch.fd);
1478 watch_init(&m->time_change_watch);
1479 manager_setup_time_change(m);
1481 HASHMAP_FOREACH(u, m->units, i) {
1482 if (UNIT_VTABLE(u)->time_change)
1483 UNIT_VTABLE(u)->time_change(u);
1490 log_error("event type=%i", w->type);
1491 assert_not_reached("Unknown epoll event type.");
1497 int manager_loop(Manager *m) {
1500 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1503 m->exit_code = MANAGER_RUNNING;
1505 /* Release the path cache */
1506 set_free_free(m->unit_path_cache);
1507 m->unit_path_cache = NULL;
1509 manager_check_finished(m);
1511 /* There might still be some zombies hanging around from
1512 * before we were exec()'ed. Leat's reap them */
1513 r = manager_dispatch_sigchld(m);
1517 while (m->exit_code == MANAGER_RUNNING) {
1518 struct epoll_event event;
1522 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1525 if (!ratelimit_test(&rl)) {
1526 /* Yay, something is going seriously wrong, pause a little */
1527 log_warning("Looping too fast. Throttling execution a little.");
1532 if (manager_dispatch_load_queue(m) > 0)
1535 if (manager_dispatch_run_queue(m) > 0)
1538 if (bus_dispatch(m) > 0)
1541 if (manager_dispatch_cleanup_queue(m) > 0)
1544 if (manager_dispatch_gc_queue(m) > 0)
1547 if (manager_dispatch_dbus_queue(m) > 0)
1550 if (swap_dispatch_reload(m) > 0)
1553 /* Sleep for half the watchdog time */
1554 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1555 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1561 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1573 r = process_event(m, &event);
1578 return m->exit_code;
1581 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1590 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1593 n = bus_path_unescape(s+31);
1597 r = manager_load_unit(m, n, NULL, e, &u);
1608 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1617 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1620 r = safe_atou(s + 30, &id);
1624 j = manager_get_job(m, id);
1633 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1639 audit_fd = get_audit_fd();
1643 /* Don't generate audit events if the service was already
1644 * started and we're just deserializing */
1645 if (m->n_reloading > 0)
1648 if (m->running_as != SYSTEMD_SYSTEM)
1651 if (u->type != UNIT_SERVICE)
1654 if (!(p = unit_name_to_prefix_and_instance(u->id))) {
1655 log_error("Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1659 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1660 if (errno == EPERM) {
1661 /* We aren't allowed to send audit messages?
1662 * Then let's not retry again. */
1665 log_warning("Failed to send audit message: %m");
1673 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1675 union sockaddr_union sa;
1677 char *message = NULL;
1679 /* Don't generate plymouth events if the service was already
1680 * started and we're just deserializing */
1681 if (m->n_reloading > 0)
1684 if (m->running_as != SYSTEMD_SYSTEM)
1687 if (u->type != UNIT_SERVICE &&
1688 u->type != UNIT_MOUNT &&
1689 u->type != UNIT_SWAP)
1692 /* We set SOCK_NONBLOCK here so that we rather drop the
1693 * message then wait for plymouth */
1694 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1695 log_error("socket() failed: %m");
1700 sa.sa.sa_family = AF_UNIX;
1701 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1702 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1704 if (errno != EPIPE &&
1707 errno != ECONNREFUSED &&
1708 errno != ECONNRESET &&
1709 errno != ECONNABORTED)
1710 log_error("connect() failed: %m");
1715 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1721 if (write(fd, message, n + 1) != n + 1) {
1723 if (errno != EPIPE &&
1726 errno != ECONNREFUSED &&
1727 errno != ECONNRESET &&
1728 errno != ECONNABORTED)
1729 log_error("Failed to write Plymouth message: %m");
1736 close_nointr_nofail(fd);
1741 void manager_dispatch_bus_name_owner_changed(
1744 const char* old_owner,
1745 const char *new_owner) {
1752 if (!(u = hashmap_get(m->watch_bus, name)))
1755 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1758 void manager_dispatch_bus_query_pid_done(
1769 if (!(u = hashmap_get(m->watch_bus, name)))
1772 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1775 int manager_open_serialization(Manager *m, FILE **_f) {
1783 if (m->running_as == SYSTEMD_SYSTEM)
1784 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1786 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1791 saved_umask = umask(0077);
1792 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1802 log_debug("Serializing state to %s", path);
1805 if (!(f = fdopen(fd, "w+")))
1813 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
1825 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1826 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1827 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1828 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1830 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1831 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1832 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1833 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1836 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1837 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1842 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1846 if (!unit_can_serialize(u))
1853 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
1859 assert(m->n_reloading > 0);
1865 r = bus_fdset_add_all(m, fds);
1872 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1878 log_debug("Deserializing state...");
1883 char line[LINE_MAX], *l;
1885 if (!fgets(line, sizeof(line), f)) {
1900 if (startswith(l, "current-job-id=")) {
1903 if (safe_atou32(l+15, &id) < 0)
1904 log_debug("Failed to parse current job id value %s", l+15);
1906 m->current_job_id = MAX(m->current_job_id, id);
1907 } else if (startswith(l, "n-installed-jobs=")) {
1910 if (safe_atou32(l+17, &n) < 0)
1911 log_debug("Failed to parse installed jobs counter %s", l+17);
1913 m->n_installed_jobs += n;
1914 } else if (startswith(l, "n-failed-jobs=")) {
1917 if (safe_atou32(l+14, &n) < 0)
1918 log_debug("Failed to parse failed jobs counter %s", l+14);
1920 m->n_failed_jobs += n;
1921 } else if (startswith(l, "taint-usr=")) {
1924 if ((b = parse_boolean(l+10)) < 0)
1925 log_debug("Failed to parse taint /usr flag %s", l+10);
1927 m->taint_usr = m->taint_usr || b;
1928 } else if (startswith(l, "firmware-timestamp="))
1929 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
1930 else if (startswith(l, "loader-timestamp="))
1931 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
1932 else if (startswith(l, "kernel-timestamp="))
1933 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
1934 else if (startswith(l, "initrd-timestamp="))
1935 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1936 else if (startswith(l, "userspace-timestamp="))
1937 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
1938 else if (startswith(l, "finish-timestamp="))
1939 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1941 log_debug("Unknown serialization item '%s'", l);
1946 char name[UNIT_NAME_MAX+2];
1949 if (!fgets(name, sizeof(name), f)) {
1960 if ((r = manager_load_unit(m, strstrip(name), NULL, NULL, &u)) < 0)
1963 if ((r = unit_deserialize(u, f, fds)) < 0)
1973 assert(m->n_reloading > 0);
1979 int manager_reload(Manager *m) {
1986 r = manager_open_serialization(m, &f);
1999 r = manager_serialize(m, f, fds, true);
2005 if (fseeko(f, 0, SEEK_SET) < 0) {
2011 /* From here on there is no way back. */
2012 manager_clear_jobs_and_units(m);
2013 manager_undo_generators(m);
2014 lookup_paths_free(&m->lookup_paths);
2016 /* Find new unit paths */
2017 manager_run_generators(m);
2019 q = lookup_paths_init(
2020 &m->lookup_paths, m->running_as, true,
2021 m->generator_unit_path,
2022 m->generator_unit_path_early,
2023 m->generator_unit_path_late);
2027 manager_build_unit_path_cache(m);
2029 /* First, enumerate what we can from all config files */
2030 q = manager_enumerate(m);
2034 /* Second, deserialize our stored data */
2035 q = manager_deserialize(m, f, fds);
2042 /* Third, fire things up! */
2043 q = manager_coldplug(m);
2047 assert(m->n_reloading > 0);
2060 bool manager_is_booting_or_shutting_down(Manager *m) {
2065 /* Is the initial job still around? */
2066 if (manager_get_job(m, m->default_unit_job_id))
2069 /* Is there a job for the shutdown target? */
2070 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2077 void manager_reset_failed(Manager *m) {
2083 HASHMAP_FOREACH(u, m->units, i)
2084 unit_reset_failed(u);
2087 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2093 /* Returns true if the unit is inactive or going down */
2094 if (!(u = manager_get_unit(m, name)))
2097 return unit_pending_inactive(u);
2100 void manager_check_finished(Manager *m) {
2101 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2102 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2106 if (hashmap_size(m->jobs) > 0)
2109 /* Notify Type=idle units that we are done now */
2110 close_pipe(m->idle_pipe);
2112 /* Turn off confirm spawn now */
2113 m->confirm_spawn = false;
2115 if (dual_timestamp_is_set(&m->finish_timestamp))
2118 dual_timestamp_get(&m->finish_timestamp);
2120 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2122 /* Note that m->kernel_usec.monotonic is always at 0,
2123 * and m->firmware_usec.monotonic and
2124 * m->loader_usec.monotonic should be considered
2125 * negative values. */
2127 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2128 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2129 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2130 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2132 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2134 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2135 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2137 if (!log_on_console())
2138 log_struct(LOG_INFO,
2139 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2140 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2141 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2142 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2143 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2144 format_timespan(kernel, sizeof(kernel), kernel_usec),
2145 format_timespan(initrd, sizeof(initrd), initrd_usec),
2146 format_timespan(userspace, sizeof(userspace), userspace_usec),
2147 format_timespan(sum, sizeof(sum), total_usec),
2150 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2153 if (!log_on_console())
2154 log_struct(LOG_INFO,
2155 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2156 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2157 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2158 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2159 format_timespan(kernel, sizeof(kernel), kernel_usec),
2160 format_timespan(userspace, sizeof(userspace), userspace_usec),
2161 format_timespan(sum, sizeof(sum), total_usec),
2165 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2166 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2168 if (!log_on_console())
2169 log_struct(LOG_INFO,
2170 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2171 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2172 "MESSAGE=Startup finished in %s.",
2173 format_timespan(sum, sizeof(sum), total_usec),
2177 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2180 "READY=1\nSTATUS=Startup finished in %s.",
2181 format_timespan(sum, sizeof(sum), total_usec));
2184 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2195 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2197 p = strappend("/run/systemd/", name);
2201 r = mkdir_p_label(p, 0755);
2203 log_error("Failed to create generator directory: %s", strerror(-r));
2208 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2214 log_error("Failed to create generator directory: %m");
2223 static void trim_generator_dir(Manager *m, char **generator) {
2230 if (rmdir(*generator) >= 0) {
2238 void manager_run_generators(Manager *m) {
2240 const char *generator_path;
2241 const char *argv[5];
2247 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2248 d = opendir(generator_path);
2250 if (errno == ENOENT)
2253 log_error("Failed to enumerate generator directory: %m");
2257 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2261 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2265 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2269 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2270 argv[1] = m->generator_unit_path;
2271 argv[2] = m->generator_unit_path_early;
2272 argv[3] = m->generator_unit_path_late;
2276 execute_directory(generator_path, d, (char**) argv);
2279 trim_generator_dir(m, &m->generator_unit_path);
2280 trim_generator_dir(m, &m->generator_unit_path_early);
2281 trim_generator_dir(m, &m->generator_unit_path_late);
2288 static void remove_generator_dir(Manager *m, char **generator) {
2295 strv_remove(m->lookup_paths.unit_path, *generator);
2296 rm_rf(*generator, false, true, false);
2302 void manager_undo_generators(Manager *m) {
2305 remove_generator_dir(m, &m->generator_unit_path);
2306 remove_generator_dir(m, &m->generator_unit_path_early);
2307 remove_generator_dir(m, &m->generator_unit_path_late);
2310 int manager_set_default_controllers(Manager *m, char **controllers) {
2315 l = strv_copy(controllers);
2319 strv_free(m->default_controllers);
2320 m->default_controllers = l;
2322 cg_shorten_controllers(m->default_controllers);
2327 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2332 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2333 if (!default_rlimit[i])
2336 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2344 void manager_recheck_journal(Manager *m) {
2349 if (m->running_as != SYSTEMD_SYSTEM)
2352 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2353 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2354 log_close_journal();
2358 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2359 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2360 log_close_journal();
2364 /* Hmm, OK, so the socket is fully up and the service is up
2365 * too, then let's make use of the thing. */
2369 void manager_set_show_status(Manager *m, bool b) {
2372 if (m->running_as != SYSTEMD_SYSTEM)
2378 touch("/run/systemd/show-status");
2380 unlink("/run/systemd/show-status");
2383 bool manager_get_show_status(Manager *m) {
2386 if (m->running_as != SYSTEMD_SYSTEM)
2392 /* If Plymouth is running make sure we show the status, so
2393 * that there's something nice to see when people press Esc */
2395 return plymouth_running();
2398 void watch_init(Watch *w) {
2401 w->type = WATCH_INVALID;