1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
25 #include <sys/epoll.h>
27 #include <sys/signalfd.h>
31 #include <sys/reboot.h>
32 #include <sys/ioctl.h>
36 #include <sys/types.h>
39 #include <sys/timerfd.h>
45 #include "systemd/sd-daemon.h"
46 #include "systemd/sd-id128.h"
47 #include "systemd/sd-messages.h"
50 #include "transaction.h"
57 #include "ratelimit.h"
59 #include "mount-setup.h"
60 #include "unit-name.h"
61 #include "dbus-unit.h"
64 #include "path-lookup.h"
66 #include "bus-errors.h"
67 #include "exit-status.h"
70 #include "cgroup-util.h"
71 #include "path-util.h"
74 /* As soon as 16 units are in our GC queue, make sure to run a gc sweep */
75 #define GC_QUEUE_ENTRIES_MAX 16
77 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
78 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
80 /* Where clients shall send notification messages to */
81 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
83 static int manager_setup_notify(Manager *m) {
86 struct sockaddr_un un;
88 struct epoll_event ev;
93 m->notify_watch.type = WATCH_NOTIFY;
94 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
95 if (m->notify_watch.fd < 0) {
96 log_error("Failed to allocate notification socket: %m");
101 sa.sa.sa_family = AF_UNIX;
103 if (getpid() != 1 || detect_container(NULL) > 0)
104 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
106 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
108 sa.un.sun_path[0] = 0;
110 if (bind(m->notify_watch.fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
111 log_error("bind() failed: %m");
115 if (setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0) {
116 log_error("SO_PASSCRED failed: %m");
122 ev.data.ptr = &m->notify_watch;
124 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev) < 0) {
125 log_error("Failed to add timer change fd to epoll: %m");
129 sa.un.sun_path[0] = '@';
130 m->notify_socket = strdup(sa.un.sun_path);
131 if (!m->notify_socket)
134 log_debug("Using notification socket %s", m->notify_socket);
139 static int manager_setup_time_change(Manager *m) {
140 struct epoll_event ev;
141 struct itimerspec its;
144 assert(m->time_change_watch.type == WATCH_INVALID);
146 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
147 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
149 m->time_change_watch.type = WATCH_TIME_CHANGE;
150 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
151 if (m->time_change_watch.fd < 0) {
152 log_error("Failed to create timerfd: %m");
158 /* We only care for the cancellation event, hence we set the
159 * timeout to the latest possible value. */
160 assert_cc(sizeof(time_t) == sizeof(long));
161 its.it_value.tv_sec = LONG_MAX;
163 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
164 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
165 close_nointr_nofail(m->time_change_watch.fd);
166 watch_init(&m->time_change_watch);
172 ev.data.ptr = &m->time_change_watch;
174 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
175 log_error("Failed to add timer change fd to epoll: %m");
179 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
184 static int enable_special_signals(Manager *m) {
189 /* Enable that we get SIGINT on control-alt-del. In containers
190 * this will fail with EPERM (older) or EINVAL (newer), so
192 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
193 log_warning("Failed to enable ctrl-alt-del handling: %m");
195 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
197 /* Support systems without virtual console */
199 log_warning("Failed to open /dev/tty0: %m");
201 /* Enable that we get SIGWINCH on kbrequest */
202 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
203 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
205 close_nointr_nofail(fd);
211 static int manager_setup_signals(Manager *m) {
213 struct epoll_event ev;
218 /* We are not interested in SIGSTOP and friends. */
220 sa.sa_handler = SIG_DFL;
221 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
222 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
224 assert_se(sigemptyset(&mask) == 0);
226 sigset_add_many(&mask,
227 SIGCHLD, /* Child died */
228 SIGTERM, /* Reexecute daemon */
229 SIGHUP, /* Reload configuration */
230 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
231 SIGUSR2, /* systemd: dump status */
232 SIGINT, /* Kernel sends us this on control-alt-del */
233 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
234 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
235 SIGRTMIN+0, /* systemd: start default.target */
236 SIGRTMIN+1, /* systemd: isolate rescue.target */
237 SIGRTMIN+2, /* systemd: isolate emergency.target */
238 SIGRTMIN+3, /* systemd: start halt.target */
239 SIGRTMIN+4, /* systemd: start poweroff.target */
240 SIGRTMIN+5, /* systemd: start reboot.target */
241 SIGRTMIN+6, /* systemd: start kexec.target */
242 SIGRTMIN+13, /* systemd: Immediate halt */
243 SIGRTMIN+14, /* systemd: Immediate poweroff */
244 SIGRTMIN+15, /* systemd: Immediate reboot */
245 SIGRTMIN+16, /* systemd: Immediate kexec */
246 SIGRTMIN+20, /* systemd: enable status messages */
247 SIGRTMIN+21, /* systemd: disable status messages */
248 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
249 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
250 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
251 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
252 SIGRTMIN+27, /* systemd: set log target to console */
253 SIGRTMIN+28, /* systemd: set log target to kmsg */
254 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
256 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
258 m->signal_watch.type = WATCH_SIGNAL;
259 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
260 if (m->signal_watch.fd < 0)
265 ev.data.ptr = &m->signal_watch;
267 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
270 if (m->running_as == SYSTEMD_SYSTEM)
271 return enable_special_signals(m);
276 static void manager_strip_environment(Manager *m) {
279 /* Remove variables from the inherited set that are part of
280 * the container interface:
281 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
282 strv_remove_prefix(m->environment, "container=");
283 strv_remove_prefix(m->environment, "container_");
285 /* Remove variables from the inherited set that are part of
286 * the initrd interface:
287 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
288 strv_remove_prefix(m->environment, "RD_");
291 int manager_new(SystemdRunningAs running_as, Manager **_m) {
296 assert(running_as >= 0);
297 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
299 m = new0(Manager, 1);
303 dual_timestamp_get(&m->userspace_timestamp);
305 m->running_as = running_as;
306 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
307 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
308 m->pin_cgroupfs_fd = -1;
309 m->idle_pipe[0] = m->idle_pipe[1] = -1;
311 watch_init(&m->signal_watch);
312 watch_init(&m->mount_watch);
313 watch_init(&m->swap_watch);
314 watch_init(&m->udev_watch);
315 watch_init(&m->time_change_watch);
317 m->epoll_fd = m->dev_autofs_fd = -1;
318 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
320 m->environment = strv_copy(environ);
324 manager_strip_environment(m);
326 if (running_as == SYSTEMD_SYSTEM) {
327 m->default_controllers = strv_new("cpu", NULL);
328 if (!m->default_controllers)
332 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
335 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
338 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
341 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
344 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
347 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
351 r = manager_setup_signals(m);
355 r = manager_setup_cgroup(m);
359 r = manager_setup_notify(m);
363 r = manager_setup_time_change(m);
367 /* Try to connect to the busses, if possible. */
368 r = bus_init(m, running_as != SYSTEMD_SYSTEM);
372 m->taint_usr = dir_is_empty("/usr") > 0;
382 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
388 while ((u = m->cleanup_queue)) {
389 assert(u->in_cleanup_queue);
399 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
400 GC_OFFSET_UNSURE, /* No clue */
401 GC_OFFSET_GOOD, /* We still need this unit */
402 GC_OFFSET_BAD, /* We don't need this unit anymore */
406 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
413 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
414 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
415 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
418 if (u->in_cleanup_queue)
421 if (unit_check_gc(u))
424 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
428 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
429 unit_gc_sweep(other, gc_marker);
431 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
434 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
441 /* We were unable to find anything out about this entry, so
442 * let's investigate it later */
443 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
444 unit_add_to_gc_queue(u);
448 /* We definitely know that this one is not useful anymore, so
449 * let's mark it for deletion */
450 u->gc_marker = gc_marker + GC_OFFSET_BAD;
451 unit_add_to_cleanup_queue(u);
455 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
458 static unsigned manager_dispatch_gc_queue(Manager *m) {
465 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
466 (m->gc_queue_timestamp <= 0 ||
467 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
470 log_debug("Running GC...");
472 m->gc_marker += _GC_OFFSET_MAX;
473 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
476 gc_marker = m->gc_marker;
478 while ((u = m->gc_queue)) {
479 assert(u->in_gc_queue);
481 unit_gc_sweep(u, gc_marker);
483 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
484 u->in_gc_queue = false;
488 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
489 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
490 log_debug("Collecting %s", u->id);
491 u->gc_marker = gc_marker + GC_OFFSET_BAD;
492 unit_add_to_cleanup_queue(u);
496 m->n_in_gc_queue = 0;
497 m->gc_queue_timestamp = 0;
502 static void manager_clear_jobs_and_units(Manager *m) {
507 while ((u = hashmap_first(m->units)))
510 manager_dispatch_cleanup_queue(m);
512 assert(!m->load_queue);
513 assert(!m->run_queue);
514 assert(!m->dbus_unit_queue);
515 assert(!m->dbus_job_queue);
516 assert(!m->cleanup_queue);
517 assert(!m->gc_queue);
519 assert(hashmap_isempty(m->jobs));
520 assert(hashmap_isempty(m->units));
523 void manager_free(Manager *m) {
529 manager_clear_jobs_and_units(m);
531 for (c = 0; c < _UNIT_TYPE_MAX; c++)
532 if (unit_vtable[c]->shutdown)
533 unit_vtable[c]->shutdown(m);
535 /* If we reexecute ourselves, we keep the root cgroup
537 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
539 manager_undo_generators(m);
543 hashmap_free(m->units);
544 hashmap_free(m->jobs);
545 hashmap_free(m->watch_pids);
546 hashmap_free(m->watch_bus);
548 if (m->epoll_fd >= 0)
549 close_nointr_nofail(m->epoll_fd);
550 if (m->signal_watch.fd >= 0)
551 close_nointr_nofail(m->signal_watch.fd);
552 if (m->notify_watch.fd >= 0)
553 close_nointr_nofail(m->notify_watch.fd);
554 if (m->time_change_watch.fd >= 0)
555 close_nointr_nofail(m->time_change_watch.fd);
557 free(m->notify_socket);
559 lookup_paths_free(&m->lookup_paths);
560 strv_free(m->environment);
562 strv_free(m->default_controllers);
564 hashmap_free(m->cgroup_bondings);
565 set_free_free(m->unit_path_cache);
567 close_pipe(m->idle_pipe);
569 free(m->switch_root);
570 free(m->switch_root_init);
572 for (i = 0; i < RLIMIT_NLIMITS; i++)
578 int manager_enumerate(Manager *m) {
584 /* Let's ask every type to load all units from disk/kernel
585 * that it might know */
586 for (c = 0; c < _UNIT_TYPE_MAX; c++)
587 if (unit_vtable[c]->enumerate)
588 if ((q = unit_vtable[c]->enumerate(m)) < 0)
591 manager_dispatch_load_queue(m);
595 int manager_coldplug(Manager *m) {
603 /* Then, let's set up their initial state. */
604 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
610 if ((q = unit_coldplug(u)) < 0)
617 static void manager_build_unit_path_cache(Manager *m) {
624 set_free_free(m->unit_path_cache);
626 if (!(m->unit_path_cache = set_new(string_hash_func, string_compare_func))) {
627 log_error("Failed to allocate unit path cache.");
631 /* This simply builds a list of files we know exist, so that
632 * we don't always have to go to disk */
634 STRV_FOREACH(i, m->lookup_paths.unit_path) {
637 if (!(d = opendir(*i))) {
638 log_error("Failed to open directory: %m");
642 while ((de = readdir(d))) {
645 if (ignore_file(de->d_name))
648 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
654 if ((r = set_put(m->unit_path_cache, p)) < 0) {
667 log_error("Failed to build unit path cache: %s", strerror(-r));
669 set_free_free(m->unit_path_cache);
670 m->unit_path_cache = NULL;
676 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
681 manager_run_generators(m);
683 r = lookup_paths_init(
684 &m->lookup_paths, m->running_as, true,
685 m->generator_unit_path,
686 m->generator_unit_path_early,
687 m->generator_unit_path_late);
691 manager_build_unit_path_cache(m);
693 /* If we will deserialize make sure that during enumeration
694 * this is already known, so we increase the counter here
699 /* First, enumerate what we can from all config files */
700 r = manager_enumerate(m);
702 /* Second, deserialize if there is something to deserialize */
704 q = manager_deserialize(m, serialization, fds);
709 /* Any fds left? Find some unit which wants them. This is
710 * useful to allow container managers to pass some file
711 * descriptors to us pre-initialized. This enables
712 * socket-based activation of entire containers. */
713 if (fdset_size(fds) > 0) {
714 q = manager_distribute_fds(m, fds);
719 /* Third, fire things up! */
720 q = manager_coldplug(m);
725 assert(m->n_reloading > 0);
732 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
737 assert(type < _JOB_TYPE_MAX);
739 assert(mode < _JOB_MODE_MAX);
741 if (mode == JOB_ISOLATE && type != JOB_START) {
742 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
746 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
747 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
751 log_debug("Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
753 job_type_collapse(&type, unit);
755 tr = transaction_new();
759 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
760 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
761 mode == JOB_IGNORE_DEPENDENCIES, e);
765 if (mode == JOB_ISOLATE) {
766 r = transaction_add_isolate_jobs(tr, m);
771 r = transaction_activate(tr, m, mode, e);
775 log_debug("Enqueued job %s/%s as %u", unit->id, job_type_to_string(type), (unsigned) tr->anchor_job->id);
778 *_ret = tr->anchor_job;
780 transaction_free(tr);
784 transaction_abort(tr);
785 transaction_free(tr);
789 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
794 assert(type < _JOB_TYPE_MAX);
796 assert(mode < _JOB_MODE_MAX);
798 r = manager_load_unit(m, name, NULL, NULL, &unit);
802 return manager_add_job(m, type, unit, mode, override, e, _ret);
805 Job *manager_get_job(Manager *m, uint32_t id) {
808 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
811 Unit *manager_get_unit(Manager *m, const char *name) {
815 return hashmap_get(m->units, name);
818 unsigned manager_dispatch_load_queue(Manager *m) {
824 /* Make sure we are not run recursively */
825 if (m->dispatching_load_queue)
828 m->dispatching_load_queue = true;
830 /* Dispatches the load queue. Takes a unit from the queue and
831 * tries to load its data until the queue is empty */
833 while ((u = m->load_queue)) {
834 assert(u->in_load_queue);
840 m->dispatching_load_queue = false;
844 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
850 assert(name || path);
852 /* This will prepare the unit for loading, but not actually
853 * load anything from disk. */
855 if (path && !is_path(path)) {
856 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
861 name = path_get_file_name(path);
863 t = unit_name_to_type(name);
865 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
866 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
870 ret = manager_get_unit(m, name);
876 ret = unit_new(m, unit_vtable[t]->object_size);
881 ret->fragment_path = strdup(path);
882 if (!ret->fragment_path) {
888 if ((r = unit_add_name(ret, name)) < 0) {
893 unit_add_to_load_queue(ret);
894 unit_add_to_dbus_queue(ret);
895 unit_add_to_gc_queue(ret);
903 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
908 /* This will load the service information files, but not actually
909 * start any services or anything. */
911 r = manager_load_unit_prepare(m, name, path, e, _ret);
915 manager_dispatch_load_queue(m);
918 *_ret = unit_follow_merge(*_ret);
923 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
930 HASHMAP_FOREACH(j, s->jobs, i)
931 job_dump(j, f, prefix);
934 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
942 HASHMAP_FOREACH_KEY(u, t, s->units, i)
944 unit_dump(u, f, prefix);
947 void manager_clear_jobs(Manager *m) {
952 while ((j = hashmap_first(m->jobs)))
953 /* No need to recurse. We're cancelling all jobs. */
954 job_finish_and_invalidate(j, JOB_CANCELED, false);
957 unsigned manager_dispatch_run_queue(Manager *m) {
961 if (m->dispatching_run_queue)
964 m->dispatching_run_queue = true;
966 while ((j = m->run_queue)) {
967 assert(j->installed);
968 assert(j->in_run_queue);
970 job_run_and_invalidate(j);
974 m->dispatching_run_queue = false;
978 unsigned manager_dispatch_dbus_queue(Manager *m) {
985 if (m->dispatching_dbus_queue)
988 m->dispatching_dbus_queue = true;
990 while ((u = m->dbus_unit_queue)) {
991 assert(u->in_dbus_queue);
993 bus_unit_send_change_signal(u);
997 while ((j = m->dbus_job_queue)) {
998 assert(j->in_dbus_queue);
1000 bus_job_send_change_signal(j);
1004 m->dispatching_dbus_queue = false;
1008 static int manager_process_notify_fd(Manager *m) {
1015 struct msghdr msghdr;
1017 struct ucred *ucred;
1019 struct cmsghdr cmsghdr;
1020 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1026 iovec.iov_base = buf;
1027 iovec.iov_len = sizeof(buf)-1;
1031 msghdr.msg_iov = &iovec;
1032 msghdr.msg_iovlen = 1;
1033 msghdr.msg_control = &control;
1034 msghdr.msg_controllen = sizeof(control);
1036 if ((n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT)) <= 0) {
1040 if (errno == EAGAIN || errno == EINTR)
1046 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1047 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1048 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1049 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1050 log_warning("Received notify message without credentials. Ignoring.");
1054 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1056 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid))))
1057 if (!(u = cgroup_unit_by_pid(m, ucred->pid))) {
1058 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1062 assert((size_t) n < sizeof(buf));
1064 if (!(tags = strv_split(buf, "\n\r")))
1067 log_debug("Got notification message for unit %s", u->id);
1069 if (UNIT_VTABLE(u)->notify_message)
1070 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1078 static int manager_dispatch_sigchld(Manager *m) {
1088 /* First we call waitd() for a PID and do not reap the
1089 * zombie. That way we can still access /proc/$PID for
1090 * it while it is a zombie. */
1091 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1093 if (errno == ECHILD)
1105 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1108 get_process_comm(si.si_pid, &name);
1109 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1113 /* Let's flush any message the dying child might still
1114 * have queued for us. This ensures that the process
1115 * still exists in /proc so that we can figure out
1116 * which cgroup and hence unit it belongs to. */
1117 if ((r = manager_process_notify_fd(m)) < 0)
1120 /* And now figure out the unit this belongs to */
1121 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid))))
1122 u = cgroup_unit_by_pid(m, si.si_pid);
1124 /* And now, we actually reap the zombie. */
1125 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1132 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1135 log_debug("Child %lu died (code=%s, status=%i/%s)",
1136 (long unsigned) si.si_pid,
1137 sigchld_code_to_string(si.si_code),
1139 strna(si.si_code == CLD_EXITED
1140 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1141 : signal_to_string(si.si_status)));
1146 log_debug("Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1148 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1149 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1155 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1159 dbus_error_init(&error);
1161 log_debug("Activating special unit %s", name);
1163 if ((r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL)) < 0)
1164 log_error("Failed to enqueue %s job: %s", name, bus_error(&error, r));
1166 dbus_error_free(&error);
1171 static int manager_process_signal_fd(Manager *m) {
1173 struct signalfd_siginfo sfsi;
1174 bool sigchld = false;
1179 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1180 if (n != sizeof(sfsi)) {
1185 if (errno == EINTR || errno == EAGAIN)
1191 if (sfsi.ssi_pid > 0) {
1194 get_process_comm(sfsi.ssi_pid, &p);
1196 log_debug("Received SIG%s from PID %lu (%s).",
1197 signal_to_string(sfsi.ssi_signo),
1198 (unsigned long) sfsi.ssi_pid, strna(p));
1201 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1203 switch (sfsi.ssi_signo) {
1210 if (m->running_as == SYSTEMD_SYSTEM) {
1211 /* This is for compatibility with the
1212 * original sysvinit */
1213 m->exit_code = MANAGER_REEXECUTE;
1220 if (m->running_as == SYSTEMD_SYSTEM) {
1221 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1225 /* Run the exit target if there is one, if not, just exit. */
1226 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1227 m->exit_code = MANAGER_EXIT;
1234 if (m->running_as == SYSTEMD_SYSTEM)
1235 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1237 /* This is a nop on non-init */
1241 if (m->running_as == SYSTEMD_SYSTEM)
1242 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1244 /* This is a nop on non-init */
1250 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1252 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1253 log_info("Trying to reconnect to bus...");
1257 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1258 log_info("Loading D-Bus service...");
1259 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1270 if (!(f = open_memstream(&dump, &size))) {
1271 log_warning("Failed to allocate memory stream.");
1275 manager_dump_units(m, f, "\t");
1276 manager_dump_jobs(m, f, "\t");
1281 log_warning("Failed to write status stream");
1286 log_dump(LOG_INFO, dump);
1293 m->exit_code = MANAGER_RELOAD;
1298 /* Starting SIGRTMIN+0 */
1299 static const char * const target_table[] = {
1300 [0] = SPECIAL_DEFAULT_TARGET,
1301 [1] = SPECIAL_RESCUE_TARGET,
1302 [2] = SPECIAL_EMERGENCY_TARGET,
1303 [3] = SPECIAL_HALT_TARGET,
1304 [4] = SPECIAL_POWEROFF_TARGET,
1305 [5] = SPECIAL_REBOOT_TARGET,
1306 [6] = SPECIAL_KEXEC_TARGET
1309 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1310 static const ManagerExitCode code_table[] = {
1312 [1] = MANAGER_POWEROFF,
1313 [2] = MANAGER_REBOOT,
1317 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1318 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1319 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1320 manager_start_target(m, target_table[idx],
1321 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1325 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1326 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1327 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1331 switch (sfsi.ssi_signo - SIGRTMIN) {
1334 log_debug("Enabling showing of status.");
1335 manager_set_show_status(m, true);
1339 log_debug("Disabling showing of status.");
1340 manager_set_show_status(m, false);
1344 log_set_max_level(LOG_DEBUG);
1345 log_notice("Setting log level to debug.");
1349 log_set_max_level(LOG_INFO);
1350 log_notice("Setting log level to info.");
1354 if (m->running_as == SYSTEMD_USER) {
1355 m->exit_code = MANAGER_EXIT;
1359 /* This is a nop on init */
1363 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1364 log_notice("Setting log target to journal-or-kmsg.");
1368 log_set_target(LOG_TARGET_CONSOLE);
1369 log_notice("Setting log target to console.");
1373 log_set_target(LOG_TARGET_KMSG);
1374 log_notice("Setting log target to kmsg.");
1378 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1379 log_notice("Setting log target to syslog-or-kmsg.");
1383 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1390 return manager_dispatch_sigchld(m);
1395 static int process_event(Manager *m, struct epoll_event *ev) {
1402 assert_se(w = ev->data.ptr);
1404 if (w->type == WATCH_INVALID)
1411 /* An incoming signal? */
1412 if (ev->events != EPOLLIN)
1415 if ((r = manager_process_signal_fd(m)) < 0)
1422 /* An incoming daemon notification event? */
1423 if (ev->events != EPOLLIN)
1426 if ((r = manager_process_notify_fd(m)) < 0)
1433 /* Some fd event, to be dispatched to the units */
1434 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1437 case WATCH_UNIT_TIMER:
1438 case WATCH_JOB_TIMER: {
1442 /* Some timer event, to be dispatched to the units */
1443 k = read(w->fd, &v, sizeof(v));
1444 if (k != sizeof(v)) {
1446 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1449 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1450 return k < 0 ? -errno : -EIO;
1453 if (w->type == WATCH_UNIT_TIMER)
1454 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1456 job_timer_event(w->data.job, v, w);
1461 /* Some mount table change, intended for the mount subsystem */
1462 mount_fd_event(m, ev->events);
1466 /* Some swap table change, intended for the swap subsystem */
1467 swap_fd_event(m, ev->events);
1471 /* Some notification from udev, intended for the device subsystem */
1472 device_fd_event(m, ev->events);
1475 case WATCH_DBUS_WATCH:
1476 bus_watch_event(m, w, ev->events);
1479 case WATCH_DBUS_TIMEOUT:
1480 bus_timeout_event(m, w, ev->events);
1483 case WATCH_TIME_CHANGE: {
1487 log_struct(LOG_INFO,
1488 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1489 "MESSAGE=Time has been changed",
1492 /* Restart the watch */
1493 close_nointr_nofail(m->time_change_watch.fd);
1494 watch_init(&m->time_change_watch);
1495 manager_setup_time_change(m);
1497 HASHMAP_FOREACH(u, m->units, i) {
1498 if (UNIT_VTABLE(u)->time_change)
1499 UNIT_VTABLE(u)->time_change(u);
1506 log_error("event type=%i", w->type);
1507 assert_not_reached("Unknown epoll event type.");
1513 int manager_loop(Manager *m) {
1516 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1519 m->exit_code = MANAGER_RUNNING;
1521 /* Release the path cache */
1522 set_free_free(m->unit_path_cache);
1523 m->unit_path_cache = NULL;
1525 manager_check_finished(m);
1527 /* There might still be some zombies hanging around from
1528 * before we were exec()'ed. Leat's reap them */
1529 r = manager_dispatch_sigchld(m);
1533 while (m->exit_code == MANAGER_RUNNING) {
1534 struct epoll_event event;
1538 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1541 if (!ratelimit_test(&rl)) {
1542 /* Yay, something is going seriously wrong, pause a little */
1543 log_warning("Looping too fast. Throttling execution a little.");
1548 if (manager_dispatch_load_queue(m) > 0)
1551 if (manager_dispatch_run_queue(m) > 0)
1554 if (bus_dispatch(m) > 0)
1557 if (manager_dispatch_cleanup_queue(m) > 0)
1560 if (manager_dispatch_gc_queue(m) > 0)
1563 if (manager_dispatch_dbus_queue(m) > 0)
1566 if (swap_dispatch_reload(m) > 0)
1569 /* Sleep for half the watchdog time */
1570 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1571 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1577 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1589 r = process_event(m, &event);
1594 return m->exit_code;
1597 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1606 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1609 n = bus_path_unescape(s+31);
1613 r = manager_load_unit(m, n, NULL, e, &u);
1624 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1633 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1636 r = safe_atou(s + 30, &id);
1640 j = manager_get_job(m, id);
1649 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1655 audit_fd = get_audit_fd();
1659 /* Don't generate audit events if the service was already
1660 * started and we're just deserializing */
1661 if (m->n_reloading > 0)
1664 if (m->running_as != SYSTEMD_SYSTEM)
1667 if (u->type != UNIT_SERVICE)
1670 if (!(p = unit_name_to_prefix_and_instance(u->id))) {
1671 log_error("Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1675 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1676 if (errno == EPERM) {
1677 /* We aren't allowed to send audit messages?
1678 * Then let's not retry again. */
1681 log_warning("Failed to send audit message: %m");
1689 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1691 union sockaddr_union sa;
1693 char *message = NULL;
1695 /* Don't generate plymouth events if the service was already
1696 * started and we're just deserializing */
1697 if (m->n_reloading > 0)
1700 if (m->running_as != SYSTEMD_SYSTEM)
1703 if (u->type != UNIT_SERVICE &&
1704 u->type != UNIT_MOUNT &&
1705 u->type != UNIT_SWAP)
1708 /* We set SOCK_NONBLOCK here so that we rather drop the
1709 * message then wait for plymouth */
1710 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1711 log_error("socket() failed: %m");
1716 sa.sa.sa_family = AF_UNIX;
1717 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1718 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1720 if (errno != EPIPE &&
1723 errno != ECONNREFUSED &&
1724 errno != ECONNRESET &&
1725 errno != ECONNABORTED)
1726 log_error("connect() failed: %m");
1731 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1737 if (write(fd, message, n + 1) != n + 1) {
1739 if (errno != EPIPE &&
1742 errno != ECONNREFUSED &&
1743 errno != ECONNRESET &&
1744 errno != ECONNABORTED)
1745 log_error("Failed to write Plymouth message: %m");
1752 close_nointr_nofail(fd);
1757 void manager_dispatch_bus_name_owner_changed(
1760 const char* old_owner,
1761 const char *new_owner) {
1768 if (!(u = hashmap_get(m->watch_bus, name)))
1771 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1774 void manager_dispatch_bus_query_pid_done(
1785 if (!(u = hashmap_get(m->watch_bus, name)))
1788 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1791 int manager_open_serialization(Manager *m, FILE **_f) {
1799 if (m->running_as == SYSTEMD_SYSTEM)
1800 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1802 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1807 saved_umask = umask(0077);
1808 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1818 log_debug("Serializing state to %s", path);
1821 f = fdopen(fd, "w+");
1830 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
1842 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1843 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1844 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1845 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1847 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1848 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1849 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1850 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1853 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1854 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1859 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1863 if (!unit_can_serialize(u))
1870 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
1876 assert(m->n_reloading > 0);
1882 r = bus_fdset_add_all(m, fds);
1889 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1895 log_debug("Deserializing state...");
1900 char line[LINE_MAX], *l;
1902 if (!fgets(line, sizeof(line), f)) {
1917 if (startswith(l, "current-job-id=")) {
1920 if (safe_atou32(l+15, &id) < 0)
1921 log_debug("Failed to parse current job id value %s", l+15);
1923 m->current_job_id = MAX(m->current_job_id, id);
1924 } else if (startswith(l, "n-installed-jobs=")) {
1927 if (safe_atou32(l+17, &n) < 0)
1928 log_debug("Failed to parse installed jobs counter %s", l+17);
1930 m->n_installed_jobs += n;
1931 } else if (startswith(l, "n-failed-jobs=")) {
1934 if (safe_atou32(l+14, &n) < 0)
1935 log_debug("Failed to parse failed jobs counter %s", l+14);
1937 m->n_failed_jobs += n;
1938 } else if (startswith(l, "taint-usr=")) {
1941 if ((b = parse_boolean(l+10)) < 0)
1942 log_debug("Failed to parse taint /usr flag %s", l+10);
1944 m->taint_usr = m->taint_usr || b;
1945 } else if (startswith(l, "firmware-timestamp="))
1946 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
1947 else if (startswith(l, "loader-timestamp="))
1948 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
1949 else if (startswith(l, "kernel-timestamp="))
1950 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
1951 else if (startswith(l, "initrd-timestamp="))
1952 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1953 else if (startswith(l, "userspace-timestamp="))
1954 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
1955 else if (startswith(l, "finish-timestamp="))
1956 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1958 log_debug("Unknown serialization item '%s'", l);
1963 char name[UNIT_NAME_MAX+2];
1966 if (!fgets(name, sizeof(name), f)) {
1977 if ((r = manager_load_unit(m, strstrip(name), NULL, NULL, &u)) < 0)
1980 r = unit_deserialize(u, f, fds);
1991 assert(m->n_reloading > 0);
1997 int manager_distribute_fds(Manager *m, FDSet *fds) {
2004 HASHMAP_FOREACH(u, m->units, i) {
2006 if (fdset_size(fds) <= 0)
2009 if (UNIT_VTABLE(u)->distribute_fds) {
2010 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2019 int manager_reload(Manager *m) {
2026 r = manager_open_serialization(m, &f);
2039 r = manager_serialize(m, f, fds, true);
2045 if (fseeko(f, 0, SEEK_SET) < 0) {
2051 /* From here on there is no way back. */
2052 manager_clear_jobs_and_units(m);
2053 manager_undo_generators(m);
2054 lookup_paths_free(&m->lookup_paths);
2056 /* Find new unit paths */
2057 manager_run_generators(m);
2059 q = lookup_paths_init(
2060 &m->lookup_paths, m->running_as, true,
2061 m->generator_unit_path,
2062 m->generator_unit_path_early,
2063 m->generator_unit_path_late);
2067 manager_build_unit_path_cache(m);
2069 /* First, enumerate what we can from all config files */
2070 q = manager_enumerate(m);
2074 /* Second, deserialize our stored data */
2075 q = manager_deserialize(m, f, fds);
2082 /* Third, fire things up! */
2083 q = manager_coldplug(m);
2087 assert(m->n_reloading > 0);
2100 bool manager_is_booting_or_shutting_down(Manager *m) {
2105 /* Is the initial job still around? */
2106 if (manager_get_job(m, m->default_unit_job_id))
2109 /* Is there a job for the shutdown target? */
2110 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2117 void manager_reset_failed(Manager *m) {
2123 HASHMAP_FOREACH(u, m->units, i)
2124 unit_reset_failed(u);
2127 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2133 /* Returns true if the unit is inactive or going down */
2134 if (!(u = manager_get_unit(m, name)))
2137 return unit_pending_inactive(u);
2140 void manager_check_finished(Manager *m) {
2141 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2142 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2146 if (hashmap_size(m->jobs) > 0)
2149 /* Notify Type=idle units that we are done now */
2150 close_pipe(m->idle_pipe);
2152 /* Turn off confirm spawn now */
2153 m->confirm_spawn = false;
2155 if (dual_timestamp_is_set(&m->finish_timestamp))
2158 dual_timestamp_get(&m->finish_timestamp);
2160 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2162 /* Note that m->kernel_usec.monotonic is always at 0,
2163 * and m->firmware_usec.monotonic and
2164 * m->loader_usec.monotonic should be considered
2165 * negative values. */
2167 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2168 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2169 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2170 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2172 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2174 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2175 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2177 if (!log_on_console())
2178 log_struct(LOG_INFO,
2179 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2180 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2181 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2182 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2183 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2184 format_timespan(kernel, sizeof(kernel), kernel_usec),
2185 format_timespan(initrd, sizeof(initrd), initrd_usec),
2186 format_timespan(userspace, sizeof(userspace), userspace_usec),
2187 format_timespan(sum, sizeof(sum), total_usec),
2190 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2193 if (!log_on_console())
2194 log_struct(LOG_INFO,
2195 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2196 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2197 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2198 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2199 format_timespan(kernel, sizeof(kernel), kernel_usec),
2200 format_timespan(userspace, sizeof(userspace), userspace_usec),
2201 format_timespan(sum, sizeof(sum), total_usec),
2205 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2206 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2208 if (!log_on_console())
2209 log_struct(LOG_INFO,
2210 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2211 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2212 "MESSAGE=Startup finished in %s.",
2213 format_timespan(sum, sizeof(sum), total_usec),
2217 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2220 "READY=1\nSTATUS=Startup finished in %s.",
2221 format_timespan(sum, sizeof(sum), total_usec));
2224 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2235 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2237 p = strappend("/run/systemd/", name);
2241 r = mkdir_p_label(p, 0755);
2243 log_error("Failed to create generator directory: %s", strerror(-r));
2248 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2254 log_error("Failed to create generator directory: %m");
2263 static void trim_generator_dir(Manager *m, char **generator) {
2270 if (rmdir(*generator) >= 0) {
2278 void manager_run_generators(Manager *m) {
2280 const char *generator_path;
2281 const char *argv[5];
2287 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2288 d = opendir(generator_path);
2290 if (errno == ENOENT)
2293 log_error("Failed to enumerate generator directory: %m");
2297 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2301 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2305 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2309 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2310 argv[1] = m->generator_unit_path;
2311 argv[2] = m->generator_unit_path_early;
2312 argv[3] = m->generator_unit_path_late;
2316 execute_directory(generator_path, d, (char**) argv);
2319 trim_generator_dir(m, &m->generator_unit_path);
2320 trim_generator_dir(m, &m->generator_unit_path_early);
2321 trim_generator_dir(m, &m->generator_unit_path_late);
2328 static void remove_generator_dir(Manager *m, char **generator) {
2335 strv_remove(m->lookup_paths.unit_path, *generator);
2336 rm_rf(*generator, false, true, false);
2342 void manager_undo_generators(Manager *m) {
2345 remove_generator_dir(m, &m->generator_unit_path);
2346 remove_generator_dir(m, &m->generator_unit_path_early);
2347 remove_generator_dir(m, &m->generator_unit_path_late);
2350 int manager_set_default_controllers(Manager *m, char **controllers) {
2355 l = strv_copy(controllers);
2359 strv_free(m->default_controllers);
2360 m->default_controllers = l;
2362 cg_shorten_controllers(m->default_controllers);
2367 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2372 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2373 if (!default_rlimit[i])
2376 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2384 void manager_recheck_journal(Manager *m) {
2389 if (m->running_as != SYSTEMD_SYSTEM)
2392 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2393 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2394 log_close_journal();
2398 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2399 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2400 log_close_journal();
2404 /* Hmm, OK, so the socket is fully up and the service is up
2405 * too, then let's make use of the thing. */
2409 void manager_set_show_status(Manager *m, bool b) {
2412 if (m->running_as != SYSTEMD_SYSTEM)
2418 touch("/run/systemd/show-status");
2420 unlink("/run/systemd/show-status");
2423 bool manager_get_show_status(Manager *m) {
2426 if (m->running_as != SYSTEMD_SYSTEM)
2432 /* If Plymouth is running make sure we show the status, so
2433 * that there's something nice to see when people press Esc */
2435 return plymouth_running();
2438 void watch_init(Watch *w) {
2441 w->type = WATCH_INVALID;