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"
75 /* As soon as 16 units are in our GC queue, make sure to run a gc sweep */
76 #define GC_QUEUE_ENTRIES_MAX 16
78 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
79 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
81 /* Where clients shall send notification messages to */
82 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
84 static int manager_setup_notify(Manager *m) {
87 struct sockaddr_un un;
89 struct epoll_event ev;
94 m->notify_watch.type = WATCH_NOTIFY;
95 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
96 if (m->notify_watch.fd < 0) {
97 log_error("Failed to allocate notification socket: %m");
102 sa.sa.sa_family = AF_UNIX;
104 if (getpid() != 1 || detect_container(NULL) > 0)
105 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
107 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
109 sa.un.sun_path[0] = 0;
111 if (bind(m->notify_watch.fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
112 log_error("bind() failed: %m");
116 if (setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0) {
117 log_error("SO_PASSCRED failed: %m");
123 ev.data.ptr = &m->notify_watch;
125 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev) < 0) {
126 log_error("Failed to add timer change fd to epoll: %m");
130 sa.un.sun_path[0] = '@';
131 m->notify_socket = strdup(sa.un.sun_path);
132 if (!m->notify_socket)
135 log_debug("Using notification socket %s", m->notify_socket);
140 static int manager_setup_time_change(Manager *m) {
141 struct epoll_event ev;
142 struct itimerspec its;
145 assert(m->time_change_watch.type == WATCH_INVALID);
147 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
148 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
150 m->time_change_watch.type = WATCH_TIME_CHANGE;
151 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
152 if (m->time_change_watch.fd < 0) {
153 log_error("Failed to create timerfd: %m");
159 /* We only care for the cancellation event, hence we set the
160 * timeout to the latest possible value. */
161 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
162 its.it_value.tv_sec = TIME_T_MAX;
164 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
165 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
166 close_nointr_nofail(m->time_change_watch.fd);
167 watch_init(&m->time_change_watch);
173 ev.data.ptr = &m->time_change_watch;
175 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
176 log_error("Failed to add timer change fd to epoll: %m");
180 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
185 static int enable_special_signals(Manager *m) {
190 /* Enable that we get SIGINT on control-alt-del. In containers
191 * this will fail with EPERM (older) or EINVAL (newer), so
193 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
194 log_warning("Failed to enable ctrl-alt-del handling: %m");
196 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
198 /* Support systems without virtual console */
200 log_warning("Failed to open /dev/tty0: %m");
202 /* Enable that we get SIGWINCH on kbrequest */
203 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
204 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
206 close_nointr_nofail(fd);
212 static int manager_setup_signals(Manager *m) {
214 struct epoll_event ev;
219 /* We are not interested in SIGSTOP and friends. */
221 sa.sa_handler = SIG_DFL;
222 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
223 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
225 assert_se(sigemptyset(&mask) == 0);
227 sigset_add_many(&mask,
228 SIGCHLD, /* Child died */
229 SIGTERM, /* Reexecute daemon */
230 SIGHUP, /* Reload configuration */
231 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
232 SIGUSR2, /* systemd: dump status */
233 SIGINT, /* Kernel sends us this on control-alt-del */
234 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
235 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
236 SIGRTMIN+0, /* systemd: start default.target */
237 SIGRTMIN+1, /* systemd: isolate rescue.target */
238 SIGRTMIN+2, /* systemd: isolate emergency.target */
239 SIGRTMIN+3, /* systemd: start halt.target */
240 SIGRTMIN+4, /* systemd: start poweroff.target */
241 SIGRTMIN+5, /* systemd: start reboot.target */
242 SIGRTMIN+6, /* systemd: start kexec.target */
243 SIGRTMIN+13, /* systemd: Immediate halt */
244 SIGRTMIN+14, /* systemd: Immediate poweroff */
245 SIGRTMIN+15, /* systemd: Immediate reboot */
246 SIGRTMIN+16, /* systemd: Immediate kexec */
247 SIGRTMIN+20, /* systemd: enable status messages */
248 SIGRTMIN+21, /* systemd: disable status messages */
249 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
250 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
251 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
252 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
253 SIGRTMIN+27, /* systemd: set log target to console */
254 SIGRTMIN+28, /* systemd: set log target to kmsg */
255 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
257 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
259 m->signal_watch.type = WATCH_SIGNAL;
260 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
261 if (m->signal_watch.fd < 0)
266 ev.data.ptr = &m->signal_watch;
268 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
271 if (m->running_as == SYSTEMD_SYSTEM)
272 return enable_special_signals(m);
277 static void manager_strip_environment(Manager *m) {
280 /* Remove variables from the inherited set that are part of
281 * the container interface:
282 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
283 strv_remove_prefix(m->environment, "container=");
284 strv_remove_prefix(m->environment, "container_");
286 /* Remove variables from the inherited set that are part of
287 * the initrd interface:
288 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
289 strv_remove_prefix(m->environment, "RD_");
292 int manager_new(SystemdRunningAs running_as, Manager **_m) {
297 assert(running_as >= 0);
298 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
300 m = new0(Manager, 1);
304 dual_timestamp_get(&m->userspace_timestamp);
305 dual_timestamp_from_monotonic(&m->kernel_timestamp, 0);
306 efi_get_boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
308 m->running_as = running_as;
309 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
310 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
311 m->pin_cgroupfs_fd = -1;
312 m->idle_pipe[0] = m->idle_pipe[1] = -1;
314 watch_init(&m->signal_watch);
315 watch_init(&m->mount_watch);
316 watch_init(&m->swap_watch);
317 watch_init(&m->udev_watch);
318 watch_init(&m->time_change_watch);
320 m->epoll_fd = m->dev_autofs_fd = -1;
321 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
323 m->environment = strv_copy(environ);
327 manager_strip_environment(m);
329 if (running_as == SYSTEMD_SYSTEM) {
330 m->default_controllers = strv_new("cpu", NULL);
331 if (!m->default_controllers)
335 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
338 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
341 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
344 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
347 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
350 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
354 r = manager_setup_signals(m);
358 r = manager_setup_cgroup(m);
362 r = manager_setup_notify(m);
366 r = manager_setup_time_change(m);
370 /* Try to connect to the busses, if possible. */
371 r = bus_init(m, running_as != SYSTEMD_SYSTEM);
375 m->taint_usr = dir_is_empty("/usr") > 0;
385 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
391 while ((u = m->cleanup_queue)) {
392 assert(u->in_cleanup_queue);
402 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
403 GC_OFFSET_UNSURE, /* No clue */
404 GC_OFFSET_GOOD, /* We still need this unit */
405 GC_OFFSET_BAD, /* We don't need this unit anymore */
409 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
416 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
417 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
418 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
421 if (u->in_cleanup_queue)
424 if (unit_check_gc(u))
427 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
431 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
432 unit_gc_sweep(other, gc_marker);
434 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
437 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
444 /* We were unable to find anything out about this entry, so
445 * let's investigate it later */
446 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
447 unit_add_to_gc_queue(u);
451 /* We definitely know that this one is not useful anymore, so
452 * let's mark it for deletion */
453 u->gc_marker = gc_marker + GC_OFFSET_BAD;
454 unit_add_to_cleanup_queue(u);
458 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
461 static unsigned manager_dispatch_gc_queue(Manager *m) {
468 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
469 (m->gc_queue_timestamp <= 0 ||
470 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
473 log_debug("Running GC...");
475 m->gc_marker += _GC_OFFSET_MAX;
476 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
479 gc_marker = m->gc_marker;
481 while ((u = m->gc_queue)) {
482 assert(u->in_gc_queue);
484 unit_gc_sweep(u, gc_marker);
486 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
487 u->in_gc_queue = false;
491 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
492 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
493 log_debug_unit(u->id, "Collecting %s", u->id);
494 u->gc_marker = gc_marker + GC_OFFSET_BAD;
495 unit_add_to_cleanup_queue(u);
499 m->n_in_gc_queue = 0;
500 m->gc_queue_timestamp = 0;
505 static void manager_clear_jobs_and_units(Manager *m) {
510 while ((u = hashmap_first(m->units)))
513 manager_dispatch_cleanup_queue(m);
515 assert(!m->load_queue);
516 assert(!m->run_queue);
517 assert(!m->dbus_unit_queue);
518 assert(!m->dbus_job_queue);
519 assert(!m->cleanup_queue);
520 assert(!m->gc_queue);
522 assert(hashmap_isempty(m->jobs));
523 assert(hashmap_isempty(m->units));
526 void manager_free(Manager *m) {
532 manager_clear_jobs_and_units(m);
534 for (c = 0; c < _UNIT_TYPE_MAX; c++)
535 if (unit_vtable[c]->shutdown)
536 unit_vtable[c]->shutdown(m);
538 /* If we reexecute ourselves, we keep the root cgroup
540 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
542 manager_undo_generators(m);
546 hashmap_free(m->units);
547 hashmap_free(m->jobs);
548 hashmap_free(m->watch_pids);
549 hashmap_free(m->watch_bus);
551 if (m->epoll_fd >= 0)
552 close_nointr_nofail(m->epoll_fd);
553 if (m->signal_watch.fd >= 0)
554 close_nointr_nofail(m->signal_watch.fd);
555 if (m->notify_watch.fd >= 0)
556 close_nointr_nofail(m->notify_watch.fd);
557 if (m->time_change_watch.fd >= 0)
558 close_nointr_nofail(m->time_change_watch.fd);
560 free(m->notify_socket);
562 lookup_paths_free(&m->lookup_paths);
563 strv_free(m->environment);
565 strv_free(m->default_controllers);
567 hashmap_free(m->cgroup_bondings);
568 set_free_free(m->unit_path_cache);
570 close_pipe(m->idle_pipe);
572 free(m->switch_root);
573 free(m->switch_root_init);
575 for (i = 0; i < RLIMIT_NLIMITS; i++)
581 int manager_enumerate(Manager *m) {
587 /* Let's ask every type to load all units from disk/kernel
588 * that it might know */
589 for (c = 0; c < _UNIT_TYPE_MAX; c++)
590 if (unit_vtable[c]->enumerate)
591 if ((q = unit_vtable[c]->enumerate(m)) < 0)
594 manager_dispatch_load_queue(m);
598 int manager_coldplug(Manager *m) {
606 /* Then, let's set up their initial state. */
607 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
613 if ((q = unit_coldplug(u)) < 0)
620 static void manager_build_unit_path_cache(Manager *m) {
627 set_free_free(m->unit_path_cache);
629 if (!(m->unit_path_cache = set_new(string_hash_func, string_compare_func))) {
630 log_error("Failed to allocate unit path cache.");
634 /* This simply builds a list of files we know exist, so that
635 * we don't always have to go to disk */
637 STRV_FOREACH(i, m->lookup_paths.unit_path) {
642 log_error("Failed to open directory: %m");
646 while ((de = readdir(d))) {
649 if (ignore_file(de->d_name))
652 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
658 if ((r = set_put(m->unit_path_cache, p)) < 0) {
671 log_error("Failed to build unit path cache: %s", strerror(-r));
673 set_free_free(m->unit_path_cache);
674 m->unit_path_cache = NULL;
680 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
685 manager_run_generators(m);
687 r = lookup_paths_init(
688 &m->lookup_paths, m->running_as, true,
689 m->generator_unit_path,
690 m->generator_unit_path_early,
691 m->generator_unit_path_late);
695 manager_build_unit_path_cache(m);
697 /* If we will deserialize make sure that during enumeration
698 * this is already known, so we increase the counter here
703 /* First, enumerate what we can from all config files */
704 r = manager_enumerate(m);
706 /* Second, deserialize if there is something to deserialize */
708 q = manager_deserialize(m, serialization, fds);
713 /* Any fds left? Find some unit which wants them. This is
714 * useful to allow container managers to pass some file
715 * descriptors to us pre-initialized. This enables
716 * socket-based activation of entire containers. */
717 if (fdset_size(fds) > 0) {
718 q = manager_distribute_fds(m, fds);
723 /* Third, fire things up! */
724 q = manager_coldplug(m);
729 assert(m->n_reloading > 0);
736 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
741 assert(type < _JOB_TYPE_MAX);
743 assert(mode < _JOB_MODE_MAX);
745 if (mode == JOB_ISOLATE && type != JOB_START) {
746 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
750 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
751 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
755 log_debug_unit(unit->id,
756 "Trying to enqueue job %s/%s/%s", unit->id,
757 job_type_to_string(type), job_mode_to_string(mode));
759 job_type_collapse(&type, unit);
761 tr = transaction_new();
765 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
766 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
767 mode == JOB_IGNORE_DEPENDENCIES, e);
771 if (mode == JOB_ISOLATE) {
772 r = transaction_add_isolate_jobs(tr, m);
777 r = transaction_activate(tr, m, mode, e);
781 log_debug_unit(unit->id,
782 "Enqueued job %s/%s as %u", unit->id,
783 job_type_to_string(type), (unsigned) tr->anchor_job->id);
786 *_ret = tr->anchor_job;
788 transaction_free(tr);
792 transaction_abort(tr);
793 transaction_free(tr);
797 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
802 assert(type < _JOB_TYPE_MAX);
804 assert(mode < _JOB_MODE_MAX);
806 r = manager_load_unit(m, name, NULL, NULL, &unit);
810 return manager_add_job(m, type, unit, mode, override, e, _ret);
813 Job *manager_get_job(Manager *m, uint32_t id) {
816 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
819 Unit *manager_get_unit(Manager *m, const char *name) {
823 return hashmap_get(m->units, name);
826 unsigned manager_dispatch_load_queue(Manager *m) {
832 /* Make sure we are not run recursively */
833 if (m->dispatching_load_queue)
836 m->dispatching_load_queue = true;
838 /* Dispatches the load queue. Takes a unit from the queue and
839 * tries to load its data until the queue is empty */
841 while ((u = m->load_queue)) {
842 assert(u->in_load_queue);
848 m->dispatching_load_queue = false;
852 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
858 assert(name || path);
860 /* This will prepare the unit for loading, but not actually
861 * load anything from disk. */
863 if (path && !is_path(path)) {
864 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
869 name = path_get_file_name(path);
871 t = unit_name_to_type(name);
873 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
874 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
878 ret = manager_get_unit(m, name);
884 ret = unit_new(m, unit_vtable[t]->object_size);
889 ret->fragment_path = strdup(path);
890 if (!ret->fragment_path) {
896 if ((r = unit_add_name(ret, name)) < 0) {
901 unit_add_to_load_queue(ret);
902 unit_add_to_dbus_queue(ret);
903 unit_add_to_gc_queue(ret);
911 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
916 /* This will load the service information files, but not actually
917 * start any services or anything. */
919 r = manager_load_unit_prepare(m, name, path, e, _ret);
923 manager_dispatch_load_queue(m);
926 *_ret = unit_follow_merge(*_ret);
931 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
938 HASHMAP_FOREACH(j, s->jobs, i)
939 job_dump(j, f, prefix);
942 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
950 HASHMAP_FOREACH_KEY(u, t, s->units, i)
952 unit_dump(u, f, prefix);
955 void manager_clear_jobs(Manager *m) {
960 while ((j = hashmap_first(m->jobs)))
961 /* No need to recurse. We're cancelling all jobs. */
962 job_finish_and_invalidate(j, JOB_CANCELED, false);
965 unsigned manager_dispatch_run_queue(Manager *m) {
969 if (m->dispatching_run_queue)
972 m->dispatching_run_queue = true;
974 while ((j = m->run_queue)) {
975 assert(j->installed);
976 assert(j->in_run_queue);
978 job_run_and_invalidate(j);
982 m->dispatching_run_queue = false;
986 unsigned manager_dispatch_dbus_queue(Manager *m) {
993 if (m->dispatching_dbus_queue)
996 m->dispatching_dbus_queue = true;
998 while ((u = m->dbus_unit_queue)) {
999 assert(u->in_dbus_queue);
1001 bus_unit_send_change_signal(u);
1005 while ((j = m->dbus_job_queue)) {
1006 assert(j->in_dbus_queue);
1008 bus_job_send_change_signal(j);
1012 m->dispatching_dbus_queue = false;
1016 static int manager_process_notify_fd(Manager *m) {
1023 struct msghdr msghdr;
1025 struct ucred *ucred;
1027 struct cmsghdr cmsghdr;
1028 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1034 iovec.iov_base = buf;
1035 iovec.iov_len = sizeof(buf)-1;
1039 msghdr.msg_iov = &iovec;
1040 msghdr.msg_iovlen = 1;
1041 msghdr.msg_control = &control;
1042 msghdr.msg_controllen = sizeof(control);
1044 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1049 if (errno == EAGAIN || errno == EINTR)
1055 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1056 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1057 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1058 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1059 log_warning("Received notify message without credentials. Ignoring.");
1063 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1065 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1067 u = cgroup_unit_by_pid(m, ucred->pid);
1069 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1074 assert((size_t) n < sizeof(buf));
1076 tags = strv_split(buf, "\n\r");
1080 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1082 if (UNIT_VTABLE(u)->notify_message)
1083 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1091 static int manager_dispatch_sigchld(Manager *m) {
1101 /* First we call waitd() for a PID and do not reap the
1102 * zombie. That way we can still access /proc/$PID for
1103 * it while it is a zombie. */
1104 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1106 if (errno == ECHILD)
1118 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1119 char _cleanup_free_ *name = NULL;
1121 get_process_comm(si.si_pid, &name);
1122 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1125 /* Let's flush any message the dying child might still
1126 * have queued for us. This ensures that the process
1127 * still exists in /proc so that we can figure out
1128 * which cgroup and hence unit it belongs to. */
1129 r = manager_process_notify_fd(m);
1133 /* And now figure out the unit this belongs to */
1134 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1136 u = cgroup_unit_by_pid(m, si.si_pid);
1138 /* And now, we actually reap the zombie. */
1139 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1146 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1149 log_debug("Child %lu died (code=%s, status=%i/%s)",
1150 (long unsigned) si.si_pid,
1151 sigchld_code_to_string(si.si_code),
1153 strna(si.si_code == CLD_EXITED
1154 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1155 : signal_to_string(si.si_status)));
1160 log_debug_unit(u->id,
1161 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1163 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1164 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1170 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1174 dbus_error_init(&error);
1176 log_debug_unit(name, "Activating special unit %s", name);
1178 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1180 log_error_unit(name,
1181 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1183 dbus_error_free(&error);
1188 static int manager_process_signal_fd(Manager *m) {
1190 struct signalfd_siginfo sfsi;
1191 bool sigchld = false;
1196 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1197 if (n != sizeof(sfsi)) {
1202 if (errno == EINTR || errno == EAGAIN)
1208 if (sfsi.ssi_pid > 0) {
1211 get_process_comm(sfsi.ssi_pid, &p);
1213 log_debug("Received SIG%s from PID %lu (%s).",
1214 signal_to_string(sfsi.ssi_signo),
1215 (unsigned long) sfsi.ssi_pid, strna(p));
1218 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1220 switch (sfsi.ssi_signo) {
1227 if (m->running_as == SYSTEMD_SYSTEM) {
1228 /* This is for compatibility with the
1229 * original sysvinit */
1230 m->exit_code = MANAGER_REEXECUTE;
1237 if (m->running_as == SYSTEMD_SYSTEM) {
1238 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1242 /* Run the exit target if there is one, if not, just exit. */
1243 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1244 m->exit_code = MANAGER_EXIT;
1251 if (m->running_as == SYSTEMD_SYSTEM)
1252 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1254 /* This is a nop on non-init */
1258 if (m->running_as == SYSTEMD_SYSTEM)
1259 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1261 /* This is a nop on non-init */
1267 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1269 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1270 log_info("Trying to reconnect to bus...");
1274 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1275 log_info("Loading D-Bus service...");
1276 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1287 if (!(f = open_memstream(&dump, &size))) {
1288 log_warning("Failed to allocate memory stream.");
1292 manager_dump_units(m, f, "\t");
1293 manager_dump_jobs(m, f, "\t");
1298 log_warning("Failed to write status stream");
1303 log_dump(LOG_INFO, dump);
1310 m->exit_code = MANAGER_RELOAD;
1315 /* Starting SIGRTMIN+0 */
1316 static const char * const target_table[] = {
1317 [0] = SPECIAL_DEFAULT_TARGET,
1318 [1] = SPECIAL_RESCUE_TARGET,
1319 [2] = SPECIAL_EMERGENCY_TARGET,
1320 [3] = SPECIAL_HALT_TARGET,
1321 [4] = SPECIAL_POWEROFF_TARGET,
1322 [5] = SPECIAL_REBOOT_TARGET,
1323 [6] = SPECIAL_KEXEC_TARGET
1326 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1327 static const ManagerExitCode code_table[] = {
1329 [1] = MANAGER_POWEROFF,
1330 [2] = MANAGER_REBOOT,
1334 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1335 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1336 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1337 manager_start_target(m, target_table[idx],
1338 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1342 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1343 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1344 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1348 switch (sfsi.ssi_signo - SIGRTMIN) {
1351 log_debug("Enabling showing of status.");
1352 manager_set_show_status(m, true);
1356 log_debug("Disabling showing of status.");
1357 manager_set_show_status(m, false);
1361 log_set_max_level(LOG_DEBUG);
1362 log_notice("Setting log level to debug.");
1366 log_set_max_level(LOG_INFO);
1367 log_notice("Setting log level to info.");
1371 if (m->running_as == SYSTEMD_USER) {
1372 m->exit_code = MANAGER_EXIT;
1376 /* This is a nop on init */
1380 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1381 log_notice("Setting log target to journal-or-kmsg.");
1385 log_set_target(LOG_TARGET_CONSOLE);
1386 log_notice("Setting log target to console.");
1390 log_set_target(LOG_TARGET_KMSG);
1391 log_notice("Setting log target to kmsg.");
1395 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1396 log_notice("Setting log target to syslog-or-kmsg.");
1400 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1407 return manager_dispatch_sigchld(m);
1412 static int process_event(Manager *m, struct epoll_event *ev) {
1419 assert_se(w = ev->data.ptr);
1421 if (w->type == WATCH_INVALID)
1428 /* An incoming signal? */
1429 if (ev->events != EPOLLIN)
1432 if ((r = manager_process_signal_fd(m)) < 0)
1439 /* An incoming daemon notification event? */
1440 if (ev->events != EPOLLIN)
1443 if ((r = manager_process_notify_fd(m)) < 0)
1450 /* Some fd event, to be dispatched to the units */
1451 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1454 case WATCH_UNIT_TIMER:
1455 case WATCH_JOB_TIMER: {
1459 /* Some timer event, to be dispatched to the units */
1460 k = read(w->fd, &v, sizeof(v));
1461 if (k != sizeof(v)) {
1463 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1466 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1467 return k < 0 ? -errno : -EIO;
1470 if (w->type == WATCH_UNIT_TIMER)
1471 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1473 job_timer_event(w->data.job, v, w);
1478 /* Some mount table change, intended for the mount subsystem */
1479 mount_fd_event(m, ev->events);
1483 /* Some swap table change, intended for the swap subsystem */
1484 swap_fd_event(m, ev->events);
1488 /* Some notification from udev, intended for the device subsystem */
1489 device_fd_event(m, ev->events);
1492 case WATCH_DBUS_WATCH:
1493 bus_watch_event(m, w, ev->events);
1496 case WATCH_DBUS_TIMEOUT:
1497 bus_timeout_event(m, w, ev->events);
1500 case WATCH_TIME_CHANGE: {
1504 log_struct(LOG_INFO,
1505 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1506 "MESSAGE=Time has been changed",
1509 /* Restart the watch */
1510 close_nointr_nofail(m->time_change_watch.fd);
1511 watch_init(&m->time_change_watch);
1512 manager_setup_time_change(m);
1514 HASHMAP_FOREACH(u, m->units, i) {
1515 if (UNIT_VTABLE(u)->time_change)
1516 UNIT_VTABLE(u)->time_change(u);
1523 log_error("event type=%i", w->type);
1524 assert_not_reached("Unknown epoll event type.");
1530 int manager_loop(Manager *m) {
1533 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1536 m->exit_code = MANAGER_RUNNING;
1538 /* Release the path cache */
1539 set_free_free(m->unit_path_cache);
1540 m->unit_path_cache = NULL;
1542 manager_check_finished(m);
1544 /* There might still be some zombies hanging around from
1545 * before we were exec()'ed. Leat's reap them */
1546 r = manager_dispatch_sigchld(m);
1550 while (m->exit_code == MANAGER_RUNNING) {
1551 struct epoll_event event;
1555 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1558 if (!ratelimit_test(&rl)) {
1559 /* Yay, something is going seriously wrong, pause a little */
1560 log_warning("Looping too fast. Throttling execution a little.");
1565 if (manager_dispatch_load_queue(m) > 0)
1568 if (manager_dispatch_run_queue(m) > 0)
1571 if (bus_dispatch(m) > 0)
1574 if (manager_dispatch_cleanup_queue(m) > 0)
1577 if (manager_dispatch_gc_queue(m) > 0)
1580 if (manager_dispatch_dbus_queue(m) > 0)
1583 if (swap_dispatch_reload(m) > 0)
1586 /* Sleep for half the watchdog time */
1587 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1588 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1594 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1606 r = process_event(m, &event);
1611 return m->exit_code;
1614 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1623 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1626 n = bus_path_unescape(s+31);
1630 r = manager_load_unit(m, n, NULL, e, &u);
1641 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1650 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1653 r = safe_atou(s + 30, &id);
1657 j = manager_get_job(m, id);
1666 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1672 audit_fd = get_audit_fd();
1676 /* Don't generate audit events if the service was already
1677 * started and we're just deserializing */
1678 if (m->n_reloading > 0)
1681 if (m->running_as != SYSTEMD_SYSTEM)
1684 if (u->type != UNIT_SERVICE)
1687 p = unit_name_to_prefix_and_instance(u->id);
1689 log_error_unit(u->id,
1690 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1694 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1695 if (errno == EPERM) {
1696 /* We aren't allowed to send audit messages?
1697 * Then let's not retry again. */
1700 log_warning("Failed to send audit message: %m");
1708 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1710 union sockaddr_union sa;
1712 char *message = NULL;
1714 /* Don't generate plymouth events if the service was already
1715 * started and we're just deserializing */
1716 if (m->n_reloading > 0)
1719 if (m->running_as != SYSTEMD_SYSTEM)
1722 if (u->type != UNIT_SERVICE &&
1723 u->type != UNIT_MOUNT &&
1724 u->type != UNIT_SWAP)
1727 /* We set SOCK_NONBLOCK here so that we rather drop the
1728 * message then wait for plymouth */
1729 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1730 log_error("socket() failed: %m");
1735 sa.sa.sa_family = AF_UNIX;
1736 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1737 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1739 if (errno != EPIPE &&
1742 errno != ECONNREFUSED &&
1743 errno != ECONNRESET &&
1744 errno != ECONNABORTED)
1745 log_error("connect() failed: %m");
1750 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1756 if (write(fd, message, n + 1) != n + 1) {
1758 if (errno != EPIPE &&
1761 errno != ECONNREFUSED &&
1762 errno != ECONNRESET &&
1763 errno != ECONNABORTED)
1764 log_error("Failed to write Plymouth message: %m");
1771 close_nointr_nofail(fd);
1776 void manager_dispatch_bus_name_owner_changed(
1779 const char* old_owner,
1780 const char *new_owner) {
1787 if (!(u = hashmap_get(m->watch_bus, name)))
1790 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1793 void manager_dispatch_bus_query_pid_done(
1804 if (!(u = hashmap_get(m->watch_bus, name)))
1807 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1810 int manager_open_serialization(Manager *m, FILE **_f) {
1818 if (m->running_as == SYSTEMD_SYSTEM)
1819 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1821 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1826 saved_umask = umask(0077);
1827 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1837 log_debug("Serializing state to %s", path);
1840 f = fdopen(fd, "w+");
1849 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
1861 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1862 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1863 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1864 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1866 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1867 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1868 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1869 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1872 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1873 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1878 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1882 if (!unit_can_serialize(u))
1889 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
1895 assert(m->n_reloading > 0);
1901 r = bus_fdset_add_all(m, fds);
1908 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1914 log_debug("Deserializing state...");
1919 char line[LINE_MAX], *l;
1921 if (!fgets(line, sizeof(line), f)) {
1936 if (startswith(l, "current-job-id=")) {
1939 if (safe_atou32(l+15, &id) < 0)
1940 log_debug("Failed to parse current job id value %s", l+15);
1942 m->current_job_id = MAX(m->current_job_id, id);
1943 } else if (startswith(l, "n-installed-jobs=")) {
1946 if (safe_atou32(l+17, &n) < 0)
1947 log_debug("Failed to parse installed jobs counter %s", l+17);
1949 m->n_installed_jobs += n;
1950 } else if (startswith(l, "n-failed-jobs=")) {
1953 if (safe_atou32(l+14, &n) < 0)
1954 log_debug("Failed to parse failed jobs counter %s", l+14);
1956 m->n_failed_jobs += n;
1957 } else if (startswith(l, "taint-usr=")) {
1960 if ((b = parse_boolean(l+10)) < 0)
1961 log_debug("Failed to parse taint /usr flag %s", l+10);
1963 m->taint_usr = m->taint_usr || b;
1964 } else if (startswith(l, "firmware-timestamp="))
1965 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
1966 else if (startswith(l, "loader-timestamp="))
1967 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
1968 else if (startswith(l, "kernel-timestamp="))
1969 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
1970 else if (startswith(l, "initrd-timestamp="))
1971 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1972 else if (startswith(l, "userspace-timestamp="))
1973 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
1974 else if (startswith(l, "finish-timestamp="))
1975 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1977 log_debug("Unknown serialization item '%s'", l);
1982 char name[UNIT_NAME_MAX+2];
1985 if (!fgets(name, sizeof(name), f)) {
1996 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2000 r = unit_deserialize(u, f, fds);
2011 assert(m->n_reloading > 0);
2017 int manager_distribute_fds(Manager *m, FDSet *fds) {
2024 HASHMAP_FOREACH(u, m->units, i) {
2026 if (fdset_size(fds) <= 0)
2029 if (UNIT_VTABLE(u)->distribute_fds) {
2030 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2039 int manager_reload(Manager *m) {
2046 r = manager_open_serialization(m, &f);
2059 r = manager_serialize(m, f, fds, true);
2065 if (fseeko(f, 0, SEEK_SET) < 0) {
2071 /* From here on there is no way back. */
2072 manager_clear_jobs_and_units(m);
2073 manager_undo_generators(m);
2074 lookup_paths_free(&m->lookup_paths);
2076 /* Find new unit paths */
2077 manager_run_generators(m);
2079 q = lookup_paths_init(
2080 &m->lookup_paths, m->running_as, true,
2081 m->generator_unit_path,
2082 m->generator_unit_path_early,
2083 m->generator_unit_path_late);
2087 manager_build_unit_path_cache(m);
2089 /* First, enumerate what we can from all config files */
2090 q = manager_enumerate(m);
2094 /* Second, deserialize our stored data */
2095 q = manager_deserialize(m, f, fds);
2102 /* Third, fire things up! */
2103 q = manager_coldplug(m);
2107 assert(m->n_reloading > 0);
2120 bool manager_is_booting_or_shutting_down(Manager *m) {
2125 /* Is the initial job still around? */
2126 if (manager_get_job(m, m->default_unit_job_id))
2129 /* Is there a job for the shutdown target? */
2130 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2137 void manager_reset_failed(Manager *m) {
2143 HASHMAP_FOREACH(u, m->units, i)
2144 unit_reset_failed(u);
2147 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2153 /* Returns true if the unit is inactive or going down */
2154 u = manager_get_unit(m, name);
2158 return unit_pending_inactive(u);
2161 void manager_check_finished(Manager *m) {
2162 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2163 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2167 if (hashmap_size(m->jobs) > 0)
2170 /* Notify Type=idle units that we are done now */
2171 close_pipe(m->idle_pipe);
2173 /* Turn off confirm spawn now */
2174 m->confirm_spawn = false;
2176 if (dual_timestamp_is_set(&m->finish_timestamp))
2179 dual_timestamp_get(&m->finish_timestamp);
2181 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2183 /* Note that m->kernel_usec.monotonic is always at 0,
2184 * and m->firmware_usec.monotonic and
2185 * m->loader_usec.monotonic should be considered
2186 * negative values. */
2188 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2189 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2190 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2191 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2193 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2195 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2196 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2198 if (!log_on_console())
2199 log_struct(LOG_INFO,
2200 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2201 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2202 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2203 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2204 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2205 format_timespan(kernel, sizeof(kernel), kernel_usec),
2206 format_timespan(initrd, sizeof(initrd), initrd_usec),
2207 format_timespan(userspace, sizeof(userspace), userspace_usec),
2208 format_timespan(sum, sizeof(sum), total_usec),
2211 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2214 if (!log_on_console())
2215 log_struct(LOG_INFO,
2216 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2217 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2218 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2219 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2220 format_timespan(kernel, sizeof(kernel), kernel_usec),
2221 format_timespan(userspace, sizeof(userspace), userspace_usec),
2222 format_timespan(sum, sizeof(sum), total_usec),
2226 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2227 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2229 if (!log_on_console())
2230 log_struct(LOG_INFO,
2231 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2232 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2233 "MESSAGE=Startup finished in %s.",
2234 format_timespan(sum, sizeof(sum), total_usec),
2238 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2241 "READY=1\nSTATUS=Startup finished in %s.",
2242 format_timespan(sum, sizeof(sum), total_usec));
2245 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2256 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2258 p = strappend("/run/systemd/", name);
2262 r = mkdir_p_label(p, 0755);
2264 log_error("Failed to create generator directory: %s", strerror(-r));
2269 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2275 log_error("Failed to create generator directory: %m");
2284 static void trim_generator_dir(Manager *m, char **generator) {
2291 if (rmdir(*generator) >= 0) {
2299 void manager_run_generators(Manager *m) {
2301 const char *generator_path;
2302 const char *argv[5];
2308 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2309 d = opendir(generator_path);
2311 if (errno == ENOENT)
2314 log_error("Failed to enumerate generator directory: %m");
2318 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2322 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2326 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2330 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2331 argv[1] = m->generator_unit_path;
2332 argv[2] = m->generator_unit_path_early;
2333 argv[3] = m->generator_unit_path_late;
2337 execute_directory(generator_path, d, (char**) argv);
2340 trim_generator_dir(m, &m->generator_unit_path);
2341 trim_generator_dir(m, &m->generator_unit_path_early);
2342 trim_generator_dir(m, &m->generator_unit_path_late);
2349 static void remove_generator_dir(Manager *m, char **generator) {
2356 strv_remove(m->lookup_paths.unit_path, *generator);
2357 rm_rf(*generator, false, true, false);
2363 void manager_undo_generators(Manager *m) {
2366 remove_generator_dir(m, &m->generator_unit_path);
2367 remove_generator_dir(m, &m->generator_unit_path_early);
2368 remove_generator_dir(m, &m->generator_unit_path_late);
2371 int manager_set_default_controllers(Manager *m, char **controllers) {
2376 l = strv_copy(controllers);
2380 strv_free(m->default_controllers);
2381 m->default_controllers = l;
2383 cg_shorten_controllers(m->default_controllers);
2388 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2393 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2394 if (!default_rlimit[i])
2397 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2405 void manager_recheck_journal(Manager *m) {
2410 if (m->running_as != SYSTEMD_SYSTEM)
2413 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2414 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2415 log_close_journal();
2419 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2420 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2421 log_close_journal();
2425 /* Hmm, OK, so the socket is fully up and the service is up
2426 * too, then let's make use of the thing. */
2430 void manager_set_show_status(Manager *m, bool b) {
2433 if (m->running_as != SYSTEMD_SYSTEM)
2439 touch("/run/systemd/show-status");
2441 unlink("/run/systemd/show-status");
2444 bool manager_get_show_status(Manager *m) {
2447 if (m->running_as != SYSTEMD_SYSTEM)
2453 /* If Plymouth is running make sure we show the status, so
2454 * that there's something nice to see when people press Esc */
2456 return plymouth_running();
2459 void watch_init(Watch *w) {
2462 w->type = WATCH_INVALID;