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 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
86 static int manager_setup_notify(Manager *m) {
89 struct sockaddr_un un;
91 struct epoll_event ev;
96 m->notify_watch.type = WATCH_NOTIFY;
97 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
98 if (m->notify_watch.fd < 0) {
99 log_error("Failed to allocate notification socket: %m");
104 sa.sa.sa_family = AF_UNIX;
106 if (getpid() != 1 || detect_container(NULL) > 0)
107 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
109 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
111 sa.un.sun_path[0] = 0;
113 if (bind(m->notify_watch.fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
114 log_error("bind() failed: %m");
118 if (setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0) {
119 log_error("SO_PASSCRED failed: %m");
125 ev.data.ptr = &m->notify_watch;
127 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev) < 0) {
128 log_error("Failed to add notification socket fd to epoll: %m");
132 sa.un.sun_path[0] = '@';
133 m->notify_socket = strdup(sa.un.sun_path);
134 if (!m->notify_socket)
137 log_debug("Using notification socket %s", m->notify_socket);
142 static int manager_setup_time_change(Manager *m) {
143 struct epoll_event ev;
144 struct itimerspec its;
147 assert(m->time_change_watch.type == WATCH_INVALID);
149 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
150 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
152 m->time_change_watch.type = WATCH_TIME_CHANGE;
153 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
154 if (m->time_change_watch.fd < 0) {
155 log_error("Failed to create timerfd: %m");
161 /* We only care for the cancellation event, hence we set the
162 * timeout to the latest possible value. */
163 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
164 its.it_value.tv_sec = TIME_T_MAX;
166 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
167 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
168 close_nointr_nofail(m->time_change_watch.fd);
169 watch_init(&m->time_change_watch);
175 ev.data.ptr = &m->time_change_watch;
177 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
178 log_error("Failed to add timer change fd to epoll: %m");
182 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
187 static int enable_special_signals(Manager *m) {
192 /* Enable that we get SIGINT on control-alt-del. In containers
193 * this will fail with EPERM (older) or EINVAL (newer), so
195 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
196 log_warning("Failed to enable ctrl-alt-del handling: %m");
198 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
200 /* Support systems without virtual console */
202 log_warning("Failed to open /dev/tty0: %m");
204 /* Enable that we get SIGWINCH on kbrequest */
205 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
206 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
208 close_nointr_nofail(fd);
214 static int manager_setup_signals(Manager *m) {
216 struct epoll_event ev;
221 /* We are not interested in SIGSTOP and friends. */
223 sa.sa_handler = SIG_DFL;
224 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
225 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
227 assert_se(sigemptyset(&mask) == 0);
229 sigset_add_many(&mask,
230 SIGCHLD, /* Child died */
231 SIGTERM, /* Reexecute daemon */
232 SIGHUP, /* Reload configuration */
233 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
234 SIGUSR2, /* systemd: dump status */
235 SIGINT, /* Kernel sends us this on control-alt-del */
236 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
237 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
238 SIGRTMIN+0, /* systemd: start default.target */
239 SIGRTMIN+1, /* systemd: isolate rescue.target */
240 SIGRTMIN+2, /* systemd: isolate emergency.target */
241 SIGRTMIN+3, /* systemd: start halt.target */
242 SIGRTMIN+4, /* systemd: start poweroff.target */
243 SIGRTMIN+5, /* systemd: start reboot.target */
244 SIGRTMIN+6, /* systemd: start kexec.target */
245 SIGRTMIN+13, /* systemd: Immediate halt */
246 SIGRTMIN+14, /* systemd: Immediate poweroff */
247 SIGRTMIN+15, /* systemd: Immediate reboot */
248 SIGRTMIN+16, /* systemd: Immediate kexec */
249 SIGRTMIN+20, /* systemd: enable status messages */
250 SIGRTMIN+21, /* systemd: disable status messages */
251 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
252 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
253 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
254 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
255 SIGRTMIN+27, /* systemd: set log target to console */
256 SIGRTMIN+28, /* systemd: set log target to kmsg */
257 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
259 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
261 m->signal_watch.type = WATCH_SIGNAL;
262 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
263 if (m->signal_watch.fd < 0)
268 ev.data.ptr = &m->signal_watch;
270 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
273 if (m->running_as == SYSTEMD_SYSTEM)
274 return enable_special_signals(m);
279 static void manager_strip_environment(Manager *m) {
282 /* Remove variables from the inherited set that are part of
283 * the container interface:
284 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
285 strv_remove_prefix(m->environment, "container=");
286 strv_remove_prefix(m->environment, "container_");
288 /* Remove variables from the inherited set that are part of
289 * the initrd interface:
290 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
291 strv_remove_prefix(m->environment, "RD_");
294 int manager_new(SystemdRunningAs running_as, Manager **_m) {
299 assert(running_as >= 0);
300 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
302 m = new0(Manager, 1);
306 dual_timestamp_get(&m->userspace_timestamp);
307 dual_timestamp_from_monotonic(&m->kernel_timestamp, 0);
308 efi_get_boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
310 m->running_as = running_as;
311 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
312 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
313 m->pin_cgroupfs_fd = -1;
314 m->idle_pipe[0] = m->idle_pipe[1] = -1;
316 watch_init(&m->signal_watch);
317 watch_init(&m->mount_watch);
318 watch_init(&m->swap_watch);
319 watch_init(&m->udev_watch);
320 watch_init(&m->time_change_watch);
322 m->epoll_fd = m->dev_autofs_fd = -1;
323 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
325 m->environment = strv_copy(environ);
329 manager_strip_environment(m);
331 if (running_as == SYSTEMD_SYSTEM) {
332 m->default_controllers = strv_new("cpu", NULL);
333 if (!m->default_controllers)
337 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
340 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
343 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
346 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
349 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
352 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
356 r = manager_setup_signals(m);
360 r = manager_setup_cgroup(m);
364 r = manager_setup_notify(m);
368 r = manager_setup_time_change(m);
372 /* Try to connect to the busses, if possible. */
373 r = bus_init(m, running_as != SYSTEMD_SYSTEM);
377 m->taint_usr = dir_is_empty("/usr") > 0;
387 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
393 while ((u = m->cleanup_queue)) {
394 assert(u->in_cleanup_queue);
404 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
405 GC_OFFSET_UNSURE, /* No clue */
406 GC_OFFSET_GOOD, /* We still need this unit */
407 GC_OFFSET_BAD, /* We don't need this unit anymore */
411 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
418 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
419 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
420 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
423 if (u->in_cleanup_queue)
426 if (unit_check_gc(u))
429 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
433 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
434 unit_gc_sweep(other, gc_marker);
436 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
439 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
446 /* We were unable to find anything out about this entry, so
447 * let's investigate it later */
448 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
449 unit_add_to_gc_queue(u);
453 /* We definitely know that this one is not useful anymore, so
454 * let's mark it for deletion */
455 u->gc_marker = gc_marker + GC_OFFSET_BAD;
456 unit_add_to_cleanup_queue(u);
460 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
463 static unsigned manager_dispatch_gc_queue(Manager *m) {
470 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
471 (m->gc_queue_timestamp <= 0 ||
472 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
475 log_debug("Running GC...");
477 m->gc_marker += _GC_OFFSET_MAX;
478 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
481 gc_marker = m->gc_marker;
483 while ((u = m->gc_queue)) {
484 assert(u->in_gc_queue);
486 unit_gc_sweep(u, gc_marker);
488 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
489 u->in_gc_queue = false;
493 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
494 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
495 log_debug_unit(u->id, "Collecting %s", u->id);
496 u->gc_marker = gc_marker + GC_OFFSET_BAD;
497 unit_add_to_cleanup_queue(u);
501 m->n_in_gc_queue = 0;
502 m->gc_queue_timestamp = 0;
507 static void manager_clear_jobs_and_units(Manager *m) {
512 while ((u = hashmap_first(m->units)))
515 manager_dispatch_cleanup_queue(m);
517 assert(!m->load_queue);
518 assert(!m->run_queue);
519 assert(!m->dbus_unit_queue);
520 assert(!m->dbus_job_queue);
521 assert(!m->cleanup_queue);
522 assert(!m->gc_queue);
524 assert(hashmap_isempty(m->jobs));
525 assert(hashmap_isempty(m->units));
528 void manager_free(Manager *m) {
534 manager_clear_jobs_and_units(m);
536 for (c = 0; c < _UNIT_TYPE_MAX; c++)
537 if (unit_vtable[c]->shutdown)
538 unit_vtable[c]->shutdown(m);
540 /* If we reexecute ourselves, we keep the root cgroup
542 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
544 manager_undo_generators(m);
548 hashmap_free(m->units);
549 hashmap_free(m->jobs);
550 hashmap_free(m->watch_pids);
551 hashmap_free(m->watch_bus);
553 if (m->epoll_fd >= 0)
554 close_nointr_nofail(m->epoll_fd);
555 if (m->signal_watch.fd >= 0)
556 close_nointr_nofail(m->signal_watch.fd);
557 if (m->notify_watch.fd >= 0)
558 close_nointr_nofail(m->notify_watch.fd);
559 if (m->time_change_watch.fd >= 0)
560 close_nointr_nofail(m->time_change_watch.fd);
562 free(m->notify_socket);
564 lookup_paths_free(&m->lookup_paths);
565 strv_free(m->environment);
567 strv_free(m->default_controllers);
569 hashmap_free(m->cgroup_bondings);
570 set_free_free(m->unit_path_cache);
572 close_pipe(m->idle_pipe);
574 free(m->switch_root);
575 free(m->switch_root_init);
577 for (i = 0; i < RLIMIT_NLIMITS; i++)
583 int manager_enumerate(Manager *m) {
589 /* Let's ask every type to load all units from disk/kernel
590 * that it might know */
591 for (c = 0; c < _UNIT_TYPE_MAX; c++)
592 if (unit_vtable[c]->enumerate)
593 if ((q = unit_vtable[c]->enumerate(m)) < 0)
596 manager_dispatch_load_queue(m);
600 int manager_coldplug(Manager *m) {
608 /* Then, let's set up their initial state. */
609 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
615 if ((q = unit_coldplug(u)) < 0)
622 static void manager_build_unit_path_cache(Manager *m) {
629 set_free_free(m->unit_path_cache);
631 if (!(m->unit_path_cache = set_new(string_hash_func, string_compare_func))) {
632 log_error("Failed to allocate unit path cache.");
636 /* This simply builds a list of files we know exist, so that
637 * we don't always have to go to disk */
639 STRV_FOREACH(i, m->lookup_paths.unit_path) {
644 log_error("Failed to open directory: %m");
648 while ((de = readdir(d))) {
651 if (ignore_file(de->d_name))
654 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
660 if ((r = set_put(m->unit_path_cache, p)) < 0) {
673 log_error("Failed to build unit path cache: %s", strerror(-r));
675 set_free_free(m->unit_path_cache);
676 m->unit_path_cache = NULL;
682 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
687 manager_run_generators(m);
689 r = lookup_paths_init(
690 &m->lookup_paths, m->running_as, true,
691 m->generator_unit_path,
692 m->generator_unit_path_early,
693 m->generator_unit_path_late);
697 manager_build_unit_path_cache(m);
699 /* If we will deserialize make sure that during enumeration
700 * this is already known, so we increase the counter here
705 /* First, enumerate what we can from all config files */
706 r = manager_enumerate(m);
708 /* Second, deserialize if there is something to deserialize */
710 q = manager_deserialize(m, serialization, fds);
715 /* Any fds left? Find some unit which wants them. This is
716 * useful to allow container managers to pass some file
717 * descriptors to us pre-initialized. This enables
718 * socket-based activation of entire containers. */
719 if (fdset_size(fds) > 0) {
720 q = manager_distribute_fds(m, fds);
725 /* Third, fire things up! */
726 q = manager_coldplug(m);
731 assert(m->n_reloading > 0);
738 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
743 assert(type < _JOB_TYPE_MAX);
745 assert(mode < _JOB_MODE_MAX);
747 if (mode == JOB_ISOLATE && type != JOB_START) {
748 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
752 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
753 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
757 log_debug_unit(unit->id,
758 "Trying to enqueue job %s/%s/%s", unit->id,
759 job_type_to_string(type), job_mode_to_string(mode));
761 job_type_collapse(&type, unit);
763 tr = transaction_new();
767 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
768 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
769 mode == JOB_IGNORE_DEPENDENCIES, e);
773 if (mode == JOB_ISOLATE) {
774 r = transaction_add_isolate_jobs(tr, m);
779 r = transaction_activate(tr, m, mode, e);
783 log_debug_unit(unit->id,
784 "Enqueued job %s/%s as %u", unit->id,
785 job_type_to_string(type), (unsigned) tr->anchor_job->id);
788 *_ret = tr->anchor_job;
790 transaction_free(tr);
794 transaction_abort(tr);
795 transaction_free(tr);
799 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
804 assert(type < _JOB_TYPE_MAX);
806 assert(mode < _JOB_MODE_MAX);
808 r = manager_load_unit(m, name, NULL, NULL, &unit);
812 return manager_add_job(m, type, unit, mode, override, e, _ret);
815 Job *manager_get_job(Manager *m, uint32_t id) {
818 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
821 Unit *manager_get_unit(Manager *m, const char *name) {
825 return hashmap_get(m->units, name);
828 unsigned manager_dispatch_load_queue(Manager *m) {
834 /* Make sure we are not run recursively */
835 if (m->dispatching_load_queue)
838 m->dispatching_load_queue = true;
840 /* Dispatches the load queue. Takes a unit from the queue and
841 * tries to load its data until the queue is empty */
843 while ((u = m->load_queue)) {
844 assert(u->in_load_queue);
850 m->dispatching_load_queue = false;
854 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
860 assert(name || path);
862 /* This will prepare the unit for loading, but not actually
863 * load anything from disk. */
865 if (path && !is_path(path)) {
866 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
871 name = path_get_file_name(path);
873 t = unit_name_to_type(name);
875 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
876 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
880 ret = manager_get_unit(m, name);
886 ret = unit_new(m, unit_vtable[t]->object_size);
891 ret->fragment_path = strdup(path);
892 if (!ret->fragment_path) {
898 if ((r = unit_add_name(ret, name)) < 0) {
903 unit_add_to_load_queue(ret);
904 unit_add_to_dbus_queue(ret);
905 unit_add_to_gc_queue(ret);
913 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
918 /* This will load the service information files, but not actually
919 * start any services or anything. */
921 r = manager_load_unit_prepare(m, name, path, e, _ret);
925 manager_dispatch_load_queue(m);
928 *_ret = unit_follow_merge(*_ret);
933 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
940 HASHMAP_FOREACH(j, s->jobs, i)
941 job_dump(j, f, prefix);
944 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
952 HASHMAP_FOREACH_KEY(u, t, s->units, i)
954 unit_dump(u, f, prefix);
957 void manager_clear_jobs(Manager *m) {
962 while ((j = hashmap_first(m->jobs)))
963 /* No need to recurse. We're cancelling all jobs. */
964 job_finish_and_invalidate(j, JOB_CANCELED, false);
967 unsigned manager_dispatch_run_queue(Manager *m) {
971 if (m->dispatching_run_queue)
974 m->dispatching_run_queue = true;
976 while ((j = m->run_queue)) {
977 assert(j->installed);
978 assert(j->in_run_queue);
980 job_run_and_invalidate(j);
984 m->dispatching_run_queue = false;
988 unsigned manager_dispatch_dbus_queue(Manager *m) {
995 if (m->dispatching_dbus_queue)
998 m->dispatching_dbus_queue = true;
1000 while ((u = m->dbus_unit_queue)) {
1001 assert(u->in_dbus_queue);
1003 bus_unit_send_change_signal(u);
1007 while ((j = m->dbus_job_queue)) {
1008 assert(j->in_dbus_queue);
1010 bus_job_send_change_signal(j);
1014 m->dispatching_dbus_queue = false;
1018 static int manager_process_notify_fd(Manager *m) {
1025 struct msghdr msghdr;
1027 struct ucred *ucred;
1029 struct cmsghdr cmsghdr;
1030 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1036 iovec.iov_base = buf;
1037 iovec.iov_len = sizeof(buf)-1;
1041 msghdr.msg_iov = &iovec;
1042 msghdr.msg_iovlen = 1;
1043 msghdr.msg_control = &control;
1044 msghdr.msg_controllen = sizeof(control);
1046 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1051 if (errno == EAGAIN || errno == EINTR)
1057 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1058 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1059 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1060 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1061 log_warning("Received notify message without credentials. Ignoring.");
1065 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1067 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1069 u = cgroup_unit_by_pid(m, ucred->pid);
1071 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1076 assert((size_t) n < sizeof(buf));
1078 tags = strv_split(buf, "\n\r");
1082 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1084 if (UNIT_VTABLE(u)->notify_message)
1085 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1093 static int manager_dispatch_sigchld(Manager *m) {
1103 /* First we call waitd() for a PID and do not reap the
1104 * zombie. That way we can still access /proc/$PID for
1105 * it while it is a zombie. */
1106 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1108 if (errno == ECHILD)
1120 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1121 char _cleanup_free_ *name = NULL;
1123 get_process_comm(si.si_pid, &name);
1124 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1127 /* Let's flush any message the dying child might still
1128 * have queued for us. This ensures that the process
1129 * still exists in /proc so that we can figure out
1130 * which cgroup and hence unit it belongs to. */
1131 r = manager_process_notify_fd(m);
1135 /* And now figure out the unit this belongs to */
1136 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1138 u = cgroup_unit_by_pid(m, si.si_pid);
1140 /* And now, we actually reap the zombie. */
1141 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1148 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1151 log_debug("Child %lu died (code=%s, status=%i/%s)",
1152 (long unsigned) si.si_pid,
1153 sigchld_code_to_string(si.si_code),
1155 strna(si.si_code == CLD_EXITED
1156 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1157 : signal_to_string(si.si_status)));
1162 log_debug_unit(u->id,
1163 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1165 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1166 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1172 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1176 dbus_error_init(&error);
1178 log_debug_unit(name, "Activating special unit %s", name);
1180 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1182 log_error_unit(name,
1183 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1185 dbus_error_free(&error);
1190 static int manager_process_signal_fd(Manager *m) {
1192 struct signalfd_siginfo sfsi;
1193 bool sigchld = false;
1198 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1199 if (n != sizeof(sfsi)) {
1204 if (errno == EINTR || errno == EAGAIN)
1210 if (sfsi.ssi_pid > 0) {
1213 get_process_comm(sfsi.ssi_pid, &p);
1215 log_debug("Received SIG%s from PID %lu (%s).",
1216 signal_to_string(sfsi.ssi_signo),
1217 (unsigned long) sfsi.ssi_pid, strna(p));
1220 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1222 switch (sfsi.ssi_signo) {
1229 if (m->running_as == SYSTEMD_SYSTEM) {
1230 /* This is for compatibility with the
1231 * original sysvinit */
1232 m->exit_code = MANAGER_REEXECUTE;
1239 if (m->running_as == SYSTEMD_SYSTEM) {
1240 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1244 /* Run the exit target if there is one, if not, just exit. */
1245 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1246 m->exit_code = MANAGER_EXIT;
1253 if (m->running_as == SYSTEMD_SYSTEM)
1254 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1256 /* This is a nop on non-init */
1260 if (m->running_as == SYSTEMD_SYSTEM)
1261 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1263 /* This is a nop on non-init */
1269 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1271 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1272 log_info("Trying to reconnect to bus...");
1276 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1277 log_info("Loading D-Bus service...");
1278 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1289 if (!(f = open_memstream(&dump, &size))) {
1290 log_warning("Failed to allocate memory stream.");
1294 manager_dump_units(m, f, "\t");
1295 manager_dump_jobs(m, f, "\t");
1300 log_warning("Failed to write status stream");
1305 log_dump(LOG_INFO, dump);
1312 m->exit_code = MANAGER_RELOAD;
1317 /* Starting SIGRTMIN+0 */
1318 static const char * const target_table[] = {
1319 [0] = SPECIAL_DEFAULT_TARGET,
1320 [1] = SPECIAL_RESCUE_TARGET,
1321 [2] = SPECIAL_EMERGENCY_TARGET,
1322 [3] = SPECIAL_HALT_TARGET,
1323 [4] = SPECIAL_POWEROFF_TARGET,
1324 [5] = SPECIAL_REBOOT_TARGET,
1325 [6] = SPECIAL_KEXEC_TARGET
1328 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1329 static const ManagerExitCode code_table[] = {
1331 [1] = MANAGER_POWEROFF,
1332 [2] = MANAGER_REBOOT,
1336 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1337 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1338 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1339 manager_start_target(m, target_table[idx],
1340 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1344 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1345 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1346 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1350 switch (sfsi.ssi_signo - SIGRTMIN) {
1353 log_debug("Enabling showing of status.");
1354 manager_set_show_status(m, true);
1358 log_debug("Disabling showing of status.");
1359 manager_set_show_status(m, false);
1363 log_set_max_level(LOG_DEBUG);
1364 log_notice("Setting log level to debug.");
1368 log_set_max_level(LOG_INFO);
1369 log_notice("Setting log level to info.");
1373 if (m->running_as == SYSTEMD_USER) {
1374 m->exit_code = MANAGER_EXIT;
1378 /* This is a nop on init */
1382 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1383 log_notice("Setting log target to journal-or-kmsg.");
1387 log_set_target(LOG_TARGET_CONSOLE);
1388 log_notice("Setting log target to console.");
1392 log_set_target(LOG_TARGET_KMSG);
1393 log_notice("Setting log target to kmsg.");
1397 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1398 log_notice("Setting log target to syslog-or-kmsg.");
1402 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1409 return manager_dispatch_sigchld(m);
1414 static int process_event(Manager *m, struct epoll_event *ev) {
1421 assert_se(w = ev->data.ptr);
1423 if (w->type == WATCH_INVALID)
1430 /* An incoming signal? */
1431 if (ev->events != EPOLLIN)
1434 if ((r = manager_process_signal_fd(m)) < 0)
1441 /* An incoming daemon notification event? */
1442 if (ev->events != EPOLLIN)
1445 if ((r = manager_process_notify_fd(m)) < 0)
1452 /* Some fd event, to be dispatched to the units */
1453 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1456 case WATCH_UNIT_TIMER:
1457 case WATCH_JOB_TIMER: {
1461 /* Some timer event, to be dispatched to the units */
1462 k = read(w->fd, &v, sizeof(v));
1463 if (k != sizeof(v)) {
1465 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1468 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1469 return k < 0 ? -errno : -EIO;
1472 if (w->type == WATCH_UNIT_TIMER)
1473 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1475 job_timer_event(w->data.job, v, w);
1480 /* Some mount table change, intended for the mount subsystem */
1481 mount_fd_event(m, ev->events);
1485 /* Some swap table change, intended for the swap subsystem */
1486 swap_fd_event(m, ev->events);
1490 /* Some notification from udev, intended for the device subsystem */
1491 device_fd_event(m, ev->events);
1494 case WATCH_DBUS_WATCH:
1495 bus_watch_event(m, w, ev->events);
1498 case WATCH_DBUS_TIMEOUT:
1499 bus_timeout_event(m, w, ev->events);
1502 case WATCH_TIME_CHANGE: {
1506 log_struct(LOG_INFO,
1507 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1508 "MESSAGE=Time has been changed",
1511 /* Restart the watch */
1512 close_nointr_nofail(m->time_change_watch.fd);
1513 watch_init(&m->time_change_watch);
1514 manager_setup_time_change(m);
1516 HASHMAP_FOREACH(u, m->units, i) {
1517 if (UNIT_VTABLE(u)->time_change)
1518 UNIT_VTABLE(u)->time_change(u);
1525 log_error("event type=%i", w->type);
1526 assert_not_reached("Unknown epoll event type.");
1532 int manager_loop(Manager *m) {
1535 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1538 m->exit_code = MANAGER_RUNNING;
1540 /* Release the path cache */
1541 set_free_free(m->unit_path_cache);
1542 m->unit_path_cache = NULL;
1544 manager_check_finished(m);
1546 /* There might still be some zombies hanging around from
1547 * before we were exec()'ed. Leat's reap them */
1548 r = manager_dispatch_sigchld(m);
1552 while (m->exit_code == MANAGER_RUNNING) {
1553 struct epoll_event event;
1557 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1560 if (!ratelimit_test(&rl)) {
1561 /* Yay, something is going seriously wrong, pause a little */
1562 log_warning("Looping too fast. Throttling execution a little.");
1567 if (manager_dispatch_load_queue(m) > 0)
1570 if (manager_dispatch_run_queue(m) > 0)
1573 if (bus_dispatch(m) > 0)
1576 if (manager_dispatch_cleanup_queue(m) > 0)
1579 if (manager_dispatch_gc_queue(m) > 0)
1582 if (manager_dispatch_dbus_queue(m) > 0)
1585 if (swap_dispatch_reload(m) > 0)
1588 /* Sleep for half the watchdog time */
1589 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1590 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1596 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1608 r = process_event(m, &event);
1613 return m->exit_code;
1616 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1625 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1628 n = bus_path_unescape(s+31);
1632 r = manager_load_unit(m, n, NULL, e, &u);
1643 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1652 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1655 r = safe_atou(s + 30, &id);
1659 j = manager_get_job(m, id);
1668 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1674 audit_fd = get_audit_fd();
1678 /* Don't generate audit events if the service was already
1679 * started and we're just deserializing */
1680 if (m->n_reloading > 0)
1683 if (m->running_as != SYSTEMD_SYSTEM)
1686 if (u->type != UNIT_SERVICE)
1689 p = unit_name_to_prefix_and_instance(u->id);
1691 log_error_unit(u->id,
1692 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1696 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1697 if (errno == EPERM) {
1698 /* We aren't allowed to send audit messages?
1699 * Then let's not retry again. */
1702 log_warning("Failed to send audit message: %m");
1710 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1712 union sockaddr_union sa;
1714 char *message = NULL;
1716 /* Don't generate plymouth events if the service was already
1717 * started and we're just deserializing */
1718 if (m->n_reloading > 0)
1721 if (m->running_as != SYSTEMD_SYSTEM)
1724 if (u->type != UNIT_SERVICE &&
1725 u->type != UNIT_MOUNT &&
1726 u->type != UNIT_SWAP)
1729 /* We set SOCK_NONBLOCK here so that we rather drop the
1730 * message then wait for plymouth */
1731 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1732 log_error("socket() failed: %m");
1737 sa.sa.sa_family = AF_UNIX;
1738 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1739 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1741 if (errno != EPIPE &&
1744 errno != ECONNREFUSED &&
1745 errno != ECONNRESET &&
1746 errno != ECONNABORTED)
1747 log_error("connect() failed: %m");
1752 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1758 if (write(fd, message, n + 1) != n + 1) {
1760 if (errno != EPIPE &&
1763 errno != ECONNREFUSED &&
1764 errno != ECONNRESET &&
1765 errno != ECONNABORTED)
1766 log_error("Failed to write Plymouth message: %m");
1773 close_nointr_nofail(fd);
1778 void manager_dispatch_bus_name_owner_changed(
1781 const char* old_owner,
1782 const char *new_owner) {
1789 if (!(u = hashmap_get(m->watch_bus, name)))
1792 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1795 void manager_dispatch_bus_query_pid_done(
1806 if (!(u = hashmap_get(m->watch_bus, name)))
1809 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1812 int manager_open_serialization(Manager *m, FILE **_f) {
1820 if (m->running_as == SYSTEMD_SYSTEM)
1821 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1823 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1828 saved_umask = umask(0077);
1829 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1839 log_debug("Serializing state to %s", path);
1842 f = fdopen(fd, "w+");
1851 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
1863 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1864 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1865 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1866 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1868 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1869 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1870 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1871 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1874 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1875 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1880 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1884 if (!unit_can_serialize(u))
1891 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
1897 assert(m->n_reloading > 0);
1903 r = bus_fdset_add_all(m, fds);
1910 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1916 log_debug("Deserializing state...");
1921 char line[LINE_MAX], *l;
1923 if (!fgets(line, sizeof(line), f)) {
1938 if (startswith(l, "current-job-id=")) {
1941 if (safe_atou32(l+15, &id) < 0)
1942 log_debug("Failed to parse current job id value %s", l+15);
1944 m->current_job_id = MAX(m->current_job_id, id);
1945 } else if (startswith(l, "n-installed-jobs=")) {
1948 if (safe_atou32(l+17, &n) < 0)
1949 log_debug("Failed to parse installed jobs counter %s", l+17);
1951 m->n_installed_jobs += n;
1952 } else if (startswith(l, "n-failed-jobs=")) {
1955 if (safe_atou32(l+14, &n) < 0)
1956 log_debug("Failed to parse failed jobs counter %s", l+14);
1958 m->n_failed_jobs += n;
1959 } else if (startswith(l, "taint-usr=")) {
1962 if ((b = parse_boolean(l+10)) < 0)
1963 log_debug("Failed to parse taint /usr flag %s", l+10);
1965 m->taint_usr = m->taint_usr || b;
1966 } else if (startswith(l, "firmware-timestamp="))
1967 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
1968 else if (startswith(l, "loader-timestamp="))
1969 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
1970 else if (startswith(l, "kernel-timestamp="))
1971 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
1972 else if (startswith(l, "initrd-timestamp="))
1973 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1974 else if (startswith(l, "userspace-timestamp="))
1975 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
1976 else if (startswith(l, "finish-timestamp="))
1977 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1979 log_debug("Unknown serialization item '%s'", l);
1984 char name[UNIT_NAME_MAX+2];
1987 if (!fgets(name, sizeof(name), f)) {
1998 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2002 r = unit_deserialize(u, f, fds);
2013 assert(m->n_reloading > 0);
2019 int manager_distribute_fds(Manager *m, FDSet *fds) {
2026 HASHMAP_FOREACH(u, m->units, i) {
2028 if (fdset_size(fds) <= 0)
2031 if (UNIT_VTABLE(u)->distribute_fds) {
2032 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2041 int manager_reload(Manager *m) {
2048 r = manager_open_serialization(m, &f);
2061 r = manager_serialize(m, f, fds, true);
2067 if (fseeko(f, 0, SEEK_SET) < 0) {
2073 /* From here on there is no way back. */
2074 manager_clear_jobs_and_units(m);
2075 manager_undo_generators(m);
2076 lookup_paths_free(&m->lookup_paths);
2078 /* Find new unit paths */
2079 manager_run_generators(m);
2081 q = lookup_paths_init(
2082 &m->lookup_paths, m->running_as, true,
2083 m->generator_unit_path,
2084 m->generator_unit_path_early,
2085 m->generator_unit_path_late);
2089 manager_build_unit_path_cache(m);
2091 /* First, enumerate what we can from all config files */
2092 q = manager_enumerate(m);
2096 /* Second, deserialize our stored data */
2097 q = manager_deserialize(m, f, fds);
2104 /* Third, fire things up! */
2105 q = manager_coldplug(m);
2109 assert(m->n_reloading > 0);
2122 bool manager_is_booting_or_shutting_down(Manager *m) {
2127 /* Is the initial job still around? */
2128 if (manager_get_job(m, m->default_unit_job_id))
2131 /* Is there a job for the shutdown target? */
2132 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2139 void manager_reset_failed(Manager *m) {
2145 HASHMAP_FOREACH(u, m->units, i)
2146 unit_reset_failed(u);
2149 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2155 /* Returns true if the unit is inactive or going down */
2156 u = manager_get_unit(m, name);
2160 return unit_pending_inactive(u);
2163 void manager_check_finished(Manager *m) {
2164 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2165 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2169 if (hashmap_size(m->jobs) > 0)
2172 /* Notify Type=idle units that we are done now */
2173 close_pipe(m->idle_pipe);
2175 /* Turn off confirm spawn now */
2176 m->confirm_spawn = false;
2178 if (dual_timestamp_is_set(&m->finish_timestamp))
2181 dual_timestamp_get(&m->finish_timestamp);
2183 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2185 /* Note that m->kernel_usec.monotonic is always at 0,
2186 * and m->firmware_usec.monotonic and
2187 * m->loader_usec.monotonic should be considered
2188 * negative values. */
2190 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2191 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2192 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2193 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2195 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2197 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2198 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2200 if (!log_on_console())
2201 log_struct(LOG_INFO,
2202 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2203 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2204 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2205 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2206 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2207 format_timespan(kernel, sizeof(kernel), kernel_usec),
2208 format_timespan(initrd, sizeof(initrd), initrd_usec),
2209 format_timespan(userspace, sizeof(userspace), userspace_usec),
2210 format_timespan(sum, sizeof(sum), total_usec),
2213 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2216 if (!log_on_console())
2217 log_struct(LOG_INFO,
2218 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2219 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2220 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2221 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2222 format_timespan(kernel, sizeof(kernel), kernel_usec),
2223 format_timespan(userspace, sizeof(userspace), userspace_usec),
2224 format_timespan(sum, sizeof(sum), total_usec),
2228 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2229 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2231 if (!log_on_console())
2232 log_struct(LOG_INFO,
2233 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2234 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2235 "MESSAGE=Startup finished in %s.",
2236 format_timespan(sum, sizeof(sum), total_usec),
2240 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2243 "READY=1\nSTATUS=Startup finished in %s.",
2244 format_timespan(sum, sizeof(sum), total_usec));
2247 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2258 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2260 p = strappend("/run/systemd/", name);
2264 r = mkdir_p_label(p, 0755);
2266 log_error("Failed to create generator directory: %s", strerror(-r));
2271 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2277 log_error("Failed to create generator directory: %m");
2286 static void trim_generator_dir(Manager *m, char **generator) {
2293 if (rmdir(*generator) >= 0) {
2301 void manager_run_generators(Manager *m) {
2303 const char *generator_path;
2304 const char *argv[5];
2310 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2311 d = opendir(generator_path);
2313 if (errno == ENOENT)
2316 log_error("Failed to enumerate generator directory: %m");
2320 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2324 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2328 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2332 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2333 argv[1] = m->generator_unit_path;
2334 argv[2] = m->generator_unit_path_early;
2335 argv[3] = m->generator_unit_path_late;
2339 execute_directory(generator_path, d, (char**) argv);
2342 trim_generator_dir(m, &m->generator_unit_path);
2343 trim_generator_dir(m, &m->generator_unit_path_early);
2344 trim_generator_dir(m, &m->generator_unit_path_late);
2351 static void remove_generator_dir(Manager *m, char **generator) {
2358 strv_remove(m->lookup_paths.unit_path, *generator);
2359 rm_rf(*generator, false, true, false);
2365 void manager_undo_generators(Manager *m) {
2368 remove_generator_dir(m, &m->generator_unit_path);
2369 remove_generator_dir(m, &m->generator_unit_path_early);
2370 remove_generator_dir(m, &m->generator_unit_path_late);
2373 int manager_set_default_controllers(Manager *m, char **controllers) {
2378 l = strv_copy(controllers);
2382 strv_free(m->default_controllers);
2383 m->default_controllers = l;
2385 cg_shorten_controllers(m->default_controllers);
2390 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2395 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2396 if (!default_rlimit[i])
2399 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2407 void manager_recheck_journal(Manager *m) {
2412 if (m->running_as != SYSTEMD_SYSTEM)
2415 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2416 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2417 log_close_journal();
2421 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2422 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2423 log_close_journal();
2427 /* Hmm, OK, so the socket is fully up and the service is up
2428 * too, then let's make use of the thing. */
2432 void manager_set_show_status(Manager *m, bool b) {
2435 if (m->running_as != SYSTEMD_SYSTEM)
2441 touch("/run/systemd/show-status");
2443 unlink("/run/systemd/show-status");
2446 bool manager_get_show_status(Manager *m) {
2449 if (m->running_as != SYSTEMD_SYSTEM)
2455 /* If Plymouth is running make sure we show the status, so
2456 * that there's something nice to see when people press Esc */
2458 return plymouth_running();
2461 void watch_init(Watch *w) {
2464 w->type = WATCH_INVALID;