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"
76 /* As soon as 16 units are in our GC queue, make sure to run a gc sweep */
77 #define GC_QUEUE_ENTRIES_MAX 16
79 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
80 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
82 /* Where clients shall send notification messages to */
83 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
85 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
87 static int manager_setup_notify(Manager *m) {
90 struct sockaddr_un un;
92 struct epoll_event ev;
97 m->notify_watch.type = WATCH_NOTIFY;
98 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
99 if (m->notify_watch.fd < 0) {
100 log_error("Failed to allocate notification socket: %m");
105 sa.sa.sa_family = AF_UNIX;
107 if (getpid() != 1 || detect_container(NULL) > 0)
108 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
110 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
112 sa.un.sun_path[0] = 0;
114 if (bind(m->notify_watch.fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
115 log_error("bind() failed: %m");
119 if (setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0) {
120 log_error("SO_PASSCRED failed: %m");
126 ev.data.ptr = &m->notify_watch;
128 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev) < 0) {
129 log_error("Failed to add notification socket fd to epoll: %m");
133 sa.un.sun_path[0] = '@';
134 m->notify_socket = strdup(sa.un.sun_path);
135 if (!m->notify_socket)
138 log_debug("Using notification socket %s", m->notify_socket);
143 static int manager_setup_time_change(Manager *m) {
144 struct epoll_event ev;
145 struct itimerspec its;
148 assert(m->time_change_watch.type == WATCH_INVALID);
150 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
151 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
153 m->time_change_watch.type = WATCH_TIME_CHANGE;
154 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
155 if (m->time_change_watch.fd < 0) {
156 log_error("Failed to create timerfd: %m");
162 /* We only care for the cancellation event, hence we set the
163 * timeout to the latest possible value. */
164 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
165 its.it_value.tv_sec = TIME_T_MAX;
167 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
168 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
169 close_nointr_nofail(m->time_change_watch.fd);
170 watch_init(&m->time_change_watch);
176 ev.data.ptr = &m->time_change_watch;
178 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
179 log_error("Failed to add timer change fd to epoll: %m");
183 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
188 static int enable_special_signals(Manager *m) {
193 /* Enable that we get SIGINT on control-alt-del. In containers
194 * this will fail with EPERM (older) or EINVAL (newer), so
196 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
197 log_warning("Failed to enable ctrl-alt-del handling: %m");
199 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
201 /* Support systems without virtual console */
203 log_warning("Failed to open /dev/tty0: %m");
205 /* Enable that we get SIGWINCH on kbrequest */
206 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
207 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
209 close_nointr_nofail(fd);
215 static int manager_setup_signals(Manager *m) {
217 struct epoll_event ev;
222 /* We are not interested in SIGSTOP and friends. */
224 sa.sa_handler = SIG_DFL;
225 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
226 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
228 assert_se(sigemptyset(&mask) == 0);
230 sigset_add_many(&mask,
231 SIGCHLD, /* Child died */
232 SIGTERM, /* Reexecute daemon */
233 SIGHUP, /* Reload configuration */
234 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
235 SIGUSR2, /* systemd: dump status */
236 SIGINT, /* Kernel sends us this on control-alt-del */
237 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
238 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
239 SIGRTMIN+0, /* systemd: start default.target */
240 SIGRTMIN+1, /* systemd: isolate rescue.target */
241 SIGRTMIN+2, /* systemd: isolate emergency.target */
242 SIGRTMIN+3, /* systemd: start halt.target */
243 SIGRTMIN+4, /* systemd: start poweroff.target */
244 SIGRTMIN+5, /* systemd: start reboot.target */
245 SIGRTMIN+6, /* systemd: start kexec.target */
246 SIGRTMIN+13, /* systemd: Immediate halt */
247 SIGRTMIN+14, /* systemd: Immediate poweroff */
248 SIGRTMIN+15, /* systemd: Immediate reboot */
249 SIGRTMIN+16, /* systemd: Immediate kexec */
250 SIGRTMIN+20, /* systemd: enable status messages */
251 SIGRTMIN+21, /* systemd: disable status messages */
252 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
253 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
254 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
255 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
256 SIGRTMIN+27, /* systemd: set log target to console */
257 SIGRTMIN+28, /* systemd: set log target to kmsg */
258 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
260 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
262 m->signal_watch.type = WATCH_SIGNAL;
263 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
264 if (m->signal_watch.fd < 0)
269 ev.data.ptr = &m->signal_watch;
271 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
274 if (m->running_as == SYSTEMD_SYSTEM)
275 return enable_special_signals(m);
280 static void manager_strip_environment(Manager *m) {
283 /* Remove variables from the inherited set that are part of
284 * the container interface:
285 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
286 strv_remove_prefix(m->environment, "container=");
287 strv_remove_prefix(m->environment, "container_");
289 /* Remove variables from the inherited set that are part of
290 * the initrd interface:
291 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
292 strv_remove_prefix(m->environment, "RD_");
294 /* Drop invalid entries */
295 strv_env_clean(m->environment);
298 int manager_new(SystemdRunningAs running_as, Manager **_m) {
303 assert(running_as >= 0);
304 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
306 m = new0(Manager, 1);
310 dual_timestamp_get(&m->userspace_timestamp);
311 dual_timestamp_from_monotonic(&m->kernel_timestamp, 0);
313 efi_get_boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
316 m->running_as = running_as;
317 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
318 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
319 m->pin_cgroupfs_fd = -1;
320 m->idle_pipe[0] = m->idle_pipe[1] = -1;
322 watch_init(&m->signal_watch);
323 watch_init(&m->mount_watch);
324 watch_init(&m->swap_watch);
325 watch_init(&m->udev_watch);
326 watch_init(&m->time_change_watch);
328 m->epoll_fd = m->dev_autofs_fd = -1;
329 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
331 m->environment = strv_copy(environ);
335 manager_strip_environment(m);
337 if (running_as == SYSTEMD_SYSTEM) {
338 m->default_controllers = strv_new("cpu", NULL);
339 if (!m->default_controllers)
343 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
346 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
349 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
352 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
355 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
358 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
362 r = manager_setup_signals(m);
366 r = manager_setup_cgroup(m);
370 r = manager_setup_notify(m);
374 r = manager_setup_time_change(m);
378 /* Try to connect to the busses, if possible. */
379 r = bus_init(m, running_as != SYSTEMD_SYSTEM);
383 m->taint_usr = dir_is_empty("/usr") > 0;
393 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
399 while ((u = m->cleanup_queue)) {
400 assert(u->in_cleanup_queue);
410 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
411 GC_OFFSET_UNSURE, /* No clue */
412 GC_OFFSET_GOOD, /* We still need this unit */
413 GC_OFFSET_BAD, /* We don't need this unit anymore */
417 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
424 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
425 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
426 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
429 if (u->in_cleanup_queue)
432 if (unit_check_gc(u))
435 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
439 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
440 unit_gc_sweep(other, gc_marker);
442 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
445 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
452 /* We were unable to find anything out about this entry, so
453 * let's investigate it later */
454 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
455 unit_add_to_gc_queue(u);
459 /* We definitely know that this one is not useful anymore, so
460 * let's mark it for deletion */
461 u->gc_marker = gc_marker + GC_OFFSET_BAD;
462 unit_add_to_cleanup_queue(u);
466 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
469 static unsigned manager_dispatch_gc_queue(Manager *m) {
476 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
477 (m->gc_queue_timestamp <= 0 ||
478 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
481 log_debug("Running GC...");
483 m->gc_marker += _GC_OFFSET_MAX;
484 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
487 gc_marker = m->gc_marker;
489 while ((u = m->gc_queue)) {
490 assert(u->in_gc_queue);
492 unit_gc_sweep(u, gc_marker);
494 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
495 u->in_gc_queue = false;
499 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
500 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
501 log_debug_unit(u->id, "Collecting %s", u->id);
502 u->gc_marker = gc_marker + GC_OFFSET_BAD;
503 unit_add_to_cleanup_queue(u);
507 m->n_in_gc_queue = 0;
508 m->gc_queue_timestamp = 0;
513 static void manager_clear_jobs_and_units(Manager *m) {
518 while ((u = hashmap_first(m->units)))
521 manager_dispatch_cleanup_queue(m);
523 assert(!m->load_queue);
524 assert(!m->run_queue);
525 assert(!m->dbus_unit_queue);
526 assert(!m->dbus_job_queue);
527 assert(!m->cleanup_queue);
528 assert(!m->gc_queue);
530 assert(hashmap_isempty(m->jobs));
531 assert(hashmap_isempty(m->units));
534 void manager_free(Manager *m) {
540 manager_clear_jobs_and_units(m);
542 for (c = 0; c < _UNIT_TYPE_MAX; c++)
543 if (unit_vtable[c]->shutdown)
544 unit_vtable[c]->shutdown(m);
546 /* If we reexecute ourselves, we keep the root cgroup
548 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
550 manager_undo_generators(m);
554 hashmap_free(m->units);
555 hashmap_free(m->jobs);
556 hashmap_free(m->watch_pids);
557 hashmap_free(m->watch_bus);
559 if (m->epoll_fd >= 0)
560 close_nointr_nofail(m->epoll_fd);
561 if (m->signal_watch.fd >= 0)
562 close_nointr_nofail(m->signal_watch.fd);
563 if (m->notify_watch.fd >= 0)
564 close_nointr_nofail(m->notify_watch.fd);
565 if (m->time_change_watch.fd >= 0)
566 close_nointr_nofail(m->time_change_watch.fd);
568 free(m->notify_socket);
570 lookup_paths_free(&m->lookup_paths);
571 strv_free(m->environment);
573 strv_free(m->default_controllers);
575 hashmap_free(m->cgroup_bondings);
576 set_free_free(m->unit_path_cache);
578 close_pipe(m->idle_pipe);
580 free(m->switch_root);
581 free(m->switch_root_init);
583 for (i = 0; i < RLIMIT_NLIMITS; i++)
589 int manager_enumerate(Manager *m) {
595 /* Let's ask every type to load all units from disk/kernel
596 * that it might know */
597 for (c = 0; c < _UNIT_TYPE_MAX; c++)
598 if (unit_vtable[c]->enumerate)
599 if ((q = unit_vtable[c]->enumerate(m)) < 0)
602 manager_dispatch_load_queue(m);
606 int manager_coldplug(Manager *m) {
614 /* Then, let's set up their initial state. */
615 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
621 if ((q = unit_coldplug(u)) < 0)
628 static void manager_build_unit_path_cache(Manager *m) {
630 DIR _cleanup_free_ *d = NULL;
635 set_free_free(m->unit_path_cache);
637 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
638 if (!m->unit_path_cache) {
639 log_error("Failed to allocate unit path cache.");
643 /* This simply builds a list of files we know exist, so that
644 * we don't always have to go to disk */
646 STRV_FOREACH(i, m->lookup_paths.unit_path) {
652 log_error("Failed to open directory %s: %m", *i);
656 while ((de = readdir(d))) {
659 if (ignore_file(de->d_name))
662 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
668 r = set_put(m->unit_path_cache, p);
682 log_error("Failed to build unit path cache: %s", strerror(-r));
684 set_free_free(m->unit_path_cache);
685 m->unit_path_cache = NULL;
688 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
693 manager_run_generators(m);
695 r = lookup_paths_init(
696 &m->lookup_paths, m->running_as, true,
697 m->generator_unit_path,
698 m->generator_unit_path_early,
699 m->generator_unit_path_late);
703 manager_build_unit_path_cache(m);
705 /* If we will deserialize make sure that during enumeration
706 * this is already known, so we increase the counter here
711 /* First, enumerate what we can from all config files */
712 r = manager_enumerate(m);
714 /* Second, deserialize if there is something to deserialize */
716 q = manager_deserialize(m, serialization, fds);
721 /* Any fds left? Find some unit which wants them. This is
722 * useful to allow container managers to pass some file
723 * descriptors to us pre-initialized. This enables
724 * socket-based activation of entire containers. */
725 if (fdset_size(fds) > 0) {
726 q = manager_distribute_fds(m, fds);
731 /* Third, fire things up! */
732 q = manager_coldplug(m);
737 assert(m->n_reloading > 0);
744 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
749 assert(type < _JOB_TYPE_MAX);
751 assert(mode < _JOB_MODE_MAX);
753 if (mode == JOB_ISOLATE && type != JOB_START) {
754 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
758 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
759 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
763 log_debug_unit(unit->id,
764 "Trying to enqueue job %s/%s/%s", unit->id,
765 job_type_to_string(type), job_mode_to_string(mode));
767 job_type_collapse(&type, unit);
769 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
773 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
774 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
775 mode == JOB_IGNORE_DEPENDENCIES, e);
779 if (mode == JOB_ISOLATE) {
780 r = transaction_add_isolate_jobs(tr, m);
785 r = transaction_activate(tr, m, mode, e);
789 log_debug_unit(unit->id,
790 "Enqueued job %s/%s as %u", unit->id,
791 job_type_to_string(type), (unsigned) tr->anchor_job->id);
794 *_ret = tr->anchor_job;
796 transaction_free(tr);
800 transaction_abort(tr);
801 transaction_free(tr);
805 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
810 assert(type < _JOB_TYPE_MAX);
812 assert(mode < _JOB_MODE_MAX);
814 r = manager_load_unit(m, name, NULL, NULL, &unit);
818 return manager_add_job(m, type, unit, mode, override, e, _ret);
821 Job *manager_get_job(Manager *m, uint32_t id) {
824 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
827 Unit *manager_get_unit(Manager *m, const char *name) {
831 return hashmap_get(m->units, name);
834 unsigned manager_dispatch_load_queue(Manager *m) {
840 /* Make sure we are not run recursively */
841 if (m->dispatching_load_queue)
844 m->dispatching_load_queue = true;
846 /* Dispatches the load queue. Takes a unit from the queue and
847 * tries to load its data until the queue is empty */
849 while ((u = m->load_queue)) {
850 assert(u->in_load_queue);
856 m->dispatching_load_queue = false;
860 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
866 assert(name || path);
868 /* This will prepare the unit for loading, but not actually
869 * load anything from disk. */
871 if (path && !is_path(path)) {
872 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
877 name = path_get_file_name(path);
879 t = unit_name_to_type(name);
881 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
882 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
886 ret = manager_get_unit(m, name);
892 ret = unit_new(m, unit_vtable[t]->object_size);
897 ret->fragment_path = strdup(path);
898 if (!ret->fragment_path) {
904 if ((r = unit_add_name(ret, name)) < 0) {
909 unit_add_to_load_queue(ret);
910 unit_add_to_dbus_queue(ret);
911 unit_add_to_gc_queue(ret);
919 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
924 /* This will load the service information files, but not actually
925 * start any services or anything. */
927 r = manager_load_unit_prepare(m, name, path, e, _ret);
931 manager_dispatch_load_queue(m);
934 *_ret = unit_follow_merge(*_ret);
939 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
946 HASHMAP_FOREACH(j, s->jobs, i)
947 job_dump(j, f, prefix);
950 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
958 HASHMAP_FOREACH_KEY(u, t, s->units, i)
960 unit_dump(u, f, prefix);
963 void manager_clear_jobs(Manager *m) {
968 while ((j = hashmap_first(m->jobs)))
969 /* No need to recurse. We're cancelling all jobs. */
970 job_finish_and_invalidate(j, JOB_CANCELED, false);
973 unsigned manager_dispatch_run_queue(Manager *m) {
977 if (m->dispatching_run_queue)
980 m->dispatching_run_queue = true;
982 while ((j = m->run_queue)) {
983 assert(j->installed);
984 assert(j->in_run_queue);
986 job_run_and_invalidate(j);
990 m->dispatching_run_queue = false;
994 unsigned manager_dispatch_dbus_queue(Manager *m) {
1001 if (m->dispatching_dbus_queue)
1004 m->dispatching_dbus_queue = true;
1006 while ((u = m->dbus_unit_queue)) {
1007 assert(u->in_dbus_queue);
1009 bus_unit_send_change_signal(u);
1013 while ((j = m->dbus_job_queue)) {
1014 assert(j->in_dbus_queue);
1016 bus_job_send_change_signal(j);
1020 m->dispatching_dbus_queue = false;
1024 static int manager_process_notify_fd(Manager *m) {
1031 struct msghdr msghdr;
1033 struct ucred *ucred;
1035 struct cmsghdr cmsghdr;
1036 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1042 iovec.iov_base = buf;
1043 iovec.iov_len = sizeof(buf)-1;
1047 msghdr.msg_iov = &iovec;
1048 msghdr.msg_iovlen = 1;
1049 msghdr.msg_control = &control;
1050 msghdr.msg_controllen = sizeof(control);
1052 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1057 if (errno == EAGAIN || errno == EINTR)
1063 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1064 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1065 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1066 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1067 log_warning("Received notify message without credentials. Ignoring.");
1071 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1073 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1075 u = cgroup_unit_by_pid(m, ucred->pid);
1077 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1082 assert((size_t) n < sizeof(buf));
1084 tags = strv_split(buf, "\n\r");
1088 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1090 if (UNIT_VTABLE(u)->notify_message)
1091 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1099 static int manager_dispatch_sigchld(Manager *m) {
1109 /* First we call waitd() for a PID and do not reap the
1110 * zombie. That way we can still access /proc/$PID for
1111 * it while it is a zombie. */
1112 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1114 if (errno == ECHILD)
1126 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1127 char _cleanup_free_ *name = NULL;
1129 get_process_comm(si.si_pid, &name);
1130 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1133 /* Let's flush any message the dying child might still
1134 * have queued for us. This ensures that the process
1135 * still exists in /proc so that we can figure out
1136 * which cgroup and hence unit it belongs to. */
1137 r = manager_process_notify_fd(m);
1141 /* And now figure out the unit this belongs to */
1142 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1144 u = cgroup_unit_by_pid(m, si.si_pid);
1146 /* And now, we actually reap the zombie. */
1147 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1154 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1157 log_debug("Child %lu died (code=%s, status=%i/%s)",
1158 (long unsigned) si.si_pid,
1159 sigchld_code_to_string(si.si_code),
1161 strna(si.si_code == CLD_EXITED
1162 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1163 : signal_to_string(si.si_status)));
1168 log_debug_unit(u->id,
1169 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1171 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1172 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1178 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1182 dbus_error_init(&error);
1184 log_debug_unit(name, "Activating special unit %s", name);
1186 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1188 log_error_unit(name,
1189 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1191 dbus_error_free(&error);
1196 static int manager_process_signal_fd(Manager *m) {
1198 struct signalfd_siginfo sfsi;
1199 bool sigchld = false;
1204 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1205 if (n != sizeof(sfsi)) {
1210 if (errno == EINTR || errno == EAGAIN)
1216 if (sfsi.ssi_pid > 0) {
1219 get_process_comm(sfsi.ssi_pid, &p);
1221 log_debug("Received SIG%s from PID %lu (%s).",
1222 signal_to_string(sfsi.ssi_signo),
1223 (unsigned long) sfsi.ssi_pid, strna(p));
1226 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1228 switch (sfsi.ssi_signo) {
1235 if (m->running_as == SYSTEMD_SYSTEM) {
1236 /* This is for compatibility with the
1237 * original sysvinit */
1238 m->exit_code = MANAGER_REEXECUTE;
1245 if (m->running_as == SYSTEMD_SYSTEM) {
1246 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1250 /* Run the exit target if there is one, if not, just exit. */
1251 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1252 m->exit_code = MANAGER_EXIT;
1259 if (m->running_as == SYSTEMD_SYSTEM)
1260 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1262 /* This is a nop on non-init */
1266 if (m->running_as == SYSTEMD_SYSTEM)
1267 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1269 /* This is a nop on non-init */
1275 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1277 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1278 log_info("Trying to reconnect to bus...");
1282 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1283 log_info("Loading D-Bus service...");
1284 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1295 if (!(f = open_memstream(&dump, &size))) {
1296 log_warning("Failed to allocate memory stream.");
1300 manager_dump_units(m, f, "\t");
1301 manager_dump_jobs(m, f, "\t");
1306 log_warning("Failed to write status stream");
1311 log_dump(LOG_INFO, dump);
1318 m->exit_code = MANAGER_RELOAD;
1323 /* Starting SIGRTMIN+0 */
1324 static const char * const target_table[] = {
1325 [0] = SPECIAL_DEFAULT_TARGET,
1326 [1] = SPECIAL_RESCUE_TARGET,
1327 [2] = SPECIAL_EMERGENCY_TARGET,
1328 [3] = SPECIAL_HALT_TARGET,
1329 [4] = SPECIAL_POWEROFF_TARGET,
1330 [5] = SPECIAL_REBOOT_TARGET,
1331 [6] = SPECIAL_KEXEC_TARGET
1334 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1335 static const ManagerExitCode code_table[] = {
1337 [1] = MANAGER_POWEROFF,
1338 [2] = MANAGER_REBOOT,
1342 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1343 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1344 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1345 manager_start_target(m, target_table[idx],
1346 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1350 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1351 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1352 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1356 switch (sfsi.ssi_signo - SIGRTMIN) {
1359 log_debug("Enabling showing of status.");
1360 manager_set_show_status(m, true);
1364 log_debug("Disabling showing of status.");
1365 manager_set_show_status(m, false);
1369 log_set_max_level(LOG_DEBUG);
1370 log_notice("Setting log level to debug.");
1374 log_set_max_level(LOG_INFO);
1375 log_notice("Setting log level to info.");
1379 if (m->running_as == SYSTEMD_USER) {
1380 m->exit_code = MANAGER_EXIT;
1384 /* This is a nop on init */
1388 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1389 log_notice("Setting log target to journal-or-kmsg.");
1393 log_set_target(LOG_TARGET_CONSOLE);
1394 log_notice("Setting log target to console.");
1398 log_set_target(LOG_TARGET_KMSG);
1399 log_notice("Setting log target to kmsg.");
1403 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1404 log_notice("Setting log target to syslog-or-kmsg.");
1408 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1415 return manager_dispatch_sigchld(m);
1420 static int process_event(Manager *m, struct epoll_event *ev) {
1427 assert_se(w = ev->data.ptr);
1429 if (w->type == WATCH_INVALID)
1436 /* An incoming signal? */
1437 if (ev->events != EPOLLIN)
1440 if ((r = manager_process_signal_fd(m)) < 0)
1447 /* An incoming daemon notification event? */
1448 if (ev->events != EPOLLIN)
1451 if ((r = manager_process_notify_fd(m)) < 0)
1458 /* Some fd event, to be dispatched to the units */
1459 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1462 case WATCH_UNIT_TIMER:
1463 case WATCH_JOB_TIMER: {
1467 /* Some timer event, to be dispatched to the units */
1468 k = read(w->fd, &v, sizeof(v));
1469 if (k != sizeof(v)) {
1471 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1474 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1475 return k < 0 ? -errno : -EIO;
1478 if (w->type == WATCH_UNIT_TIMER)
1479 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1481 job_timer_event(w->data.job, v, w);
1486 /* Some mount table change, intended for the mount subsystem */
1487 mount_fd_event(m, ev->events);
1491 /* Some swap table change, intended for the swap subsystem */
1492 swap_fd_event(m, ev->events);
1496 /* Some notification from udev, intended for the device subsystem */
1497 device_fd_event(m, ev->events);
1500 case WATCH_DBUS_WATCH:
1501 bus_watch_event(m, w, ev->events);
1504 case WATCH_DBUS_TIMEOUT:
1505 bus_timeout_event(m, w, ev->events);
1508 case WATCH_TIME_CHANGE: {
1512 log_struct(LOG_INFO,
1513 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1514 "MESSAGE=Time has been changed",
1517 /* Restart the watch */
1518 close_nointr_nofail(m->time_change_watch.fd);
1519 watch_init(&m->time_change_watch);
1520 manager_setup_time_change(m);
1522 HASHMAP_FOREACH(u, m->units, i) {
1523 if (UNIT_VTABLE(u)->time_change)
1524 UNIT_VTABLE(u)->time_change(u);
1531 log_error("event type=%i", w->type);
1532 assert_not_reached("Unknown epoll event type.");
1538 int manager_loop(Manager *m) {
1541 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1544 m->exit_code = MANAGER_RUNNING;
1546 /* Release the path cache */
1547 set_free_free(m->unit_path_cache);
1548 m->unit_path_cache = NULL;
1550 manager_check_finished(m);
1552 /* There might still be some zombies hanging around from
1553 * before we were exec()'ed. Leat's reap them */
1554 r = manager_dispatch_sigchld(m);
1558 while (m->exit_code == MANAGER_RUNNING) {
1559 struct epoll_event event;
1563 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1566 if (!ratelimit_test(&rl)) {
1567 /* Yay, something is going seriously wrong, pause a little */
1568 log_warning("Looping too fast. Throttling execution a little.");
1573 if (manager_dispatch_load_queue(m) > 0)
1576 if (manager_dispatch_run_queue(m) > 0)
1579 if (bus_dispatch(m) > 0)
1582 if (manager_dispatch_cleanup_queue(m) > 0)
1585 if (manager_dispatch_gc_queue(m) > 0)
1588 if (manager_dispatch_dbus_queue(m) > 0)
1591 if (swap_dispatch_reload(m) > 0)
1594 /* Sleep for half the watchdog time */
1595 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1596 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1602 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1614 r = process_event(m, &event);
1619 return m->exit_code;
1622 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1631 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1634 n = bus_path_unescape(s+31);
1638 r = manager_load_unit(m, n, NULL, e, &u);
1649 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1658 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1661 r = safe_atou(s + 30, &id);
1665 j = manager_get_job(m, id);
1674 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1680 audit_fd = get_audit_fd();
1684 /* Don't generate audit events if the service was already
1685 * started and we're just deserializing */
1686 if (m->n_reloading > 0)
1689 if (m->running_as != SYSTEMD_SYSTEM)
1692 if (u->type != UNIT_SERVICE)
1695 p = unit_name_to_prefix_and_instance(u->id);
1697 log_error_unit(u->id,
1698 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1702 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1703 if (errno == EPERM) {
1704 /* We aren't allowed to send audit messages?
1705 * Then let's not retry again. */
1708 log_warning("Failed to send audit message: %m");
1716 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1718 union sockaddr_union sa;
1720 char *message = NULL;
1722 /* Don't generate plymouth events if the service was already
1723 * started and we're just deserializing */
1724 if (m->n_reloading > 0)
1727 if (m->running_as != SYSTEMD_SYSTEM)
1730 if (u->type != UNIT_SERVICE &&
1731 u->type != UNIT_MOUNT &&
1732 u->type != UNIT_SWAP)
1735 /* We set SOCK_NONBLOCK here so that we rather drop the
1736 * message then wait for plymouth */
1737 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1738 log_error("socket() failed: %m");
1743 sa.sa.sa_family = AF_UNIX;
1744 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1745 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1747 if (errno != EPIPE &&
1750 errno != ECONNREFUSED &&
1751 errno != ECONNRESET &&
1752 errno != ECONNABORTED)
1753 log_error("connect() failed: %m");
1758 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1764 if (write(fd, message, n + 1) != n + 1) {
1766 if (errno != EPIPE &&
1769 errno != ECONNREFUSED &&
1770 errno != ECONNRESET &&
1771 errno != ECONNABORTED)
1772 log_error("Failed to write Plymouth message: %m");
1779 close_nointr_nofail(fd);
1784 void manager_dispatch_bus_name_owner_changed(
1787 const char* old_owner,
1788 const char *new_owner) {
1795 if (!(u = hashmap_get(m->watch_bus, name)))
1798 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1801 void manager_dispatch_bus_query_pid_done(
1812 if (!(u = hashmap_get(m->watch_bus, name)))
1815 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1818 int manager_open_serialization(Manager *m, FILE **_f) {
1826 if (m->running_as == SYSTEMD_SYSTEM)
1827 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1829 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1834 saved_umask = umask(0077);
1835 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1845 log_debug("Serializing state to %s", path);
1848 f = fdopen(fd, "w+");
1857 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
1870 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1871 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1872 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1873 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1875 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1876 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1877 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1878 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1881 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1882 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1885 STRV_FOREACH(e, m->environment) {
1886 _cleanup_free_ char *ce;
1890 fprintf(f, "env=%s\n", *e);
1895 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1899 if (!unit_can_serialize(u))
1906 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
1912 assert(m->n_reloading > 0);
1918 r = bus_fdset_add_all(m, fds);
1925 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1931 log_debug("Deserializing state...");
1936 char line[LINE_MAX], *l;
1938 if (!fgets(line, sizeof(line), f)) {
1953 if (startswith(l, "current-job-id=")) {
1956 if (safe_atou32(l+15, &id) < 0)
1957 log_debug("Failed to parse current job id value %s", l+15);
1959 m->current_job_id = MAX(m->current_job_id, id);
1960 } else if (startswith(l, "n-installed-jobs=")) {
1963 if (safe_atou32(l+17, &n) < 0)
1964 log_debug("Failed to parse installed jobs counter %s", l+17);
1966 m->n_installed_jobs += n;
1967 } else if (startswith(l, "n-failed-jobs=")) {
1970 if (safe_atou32(l+14, &n) < 0)
1971 log_debug("Failed to parse failed jobs counter %s", l+14);
1973 m->n_failed_jobs += n;
1974 } else if (startswith(l, "taint-usr=")) {
1977 if ((b = parse_boolean(l+10)) < 0)
1978 log_debug("Failed to parse taint /usr flag %s", l+10);
1980 m->taint_usr = m->taint_usr || b;
1981 } else if (startswith(l, "firmware-timestamp="))
1982 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
1983 else if (startswith(l, "loader-timestamp="))
1984 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
1985 else if (startswith(l, "kernel-timestamp="))
1986 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
1987 else if (startswith(l, "initrd-timestamp="))
1988 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1989 else if (startswith(l, "userspace-timestamp="))
1990 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
1991 else if (startswith(l, "finish-timestamp="))
1992 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1993 else if (startswith(l, "env=")) {
1994 _cleanup_free_ char *uce = NULL;
1997 uce = cunescape(l+4);
2003 e = strv_env_set(m->environment, uce);
2009 strv_free(m->environment);
2012 log_debug("Unknown serialization item '%s'", l);
2017 char name[UNIT_NAME_MAX+2];
2020 if (!fgets(name, sizeof(name), f)) {
2031 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2035 r = unit_deserialize(u, f, fds);
2046 assert(m->n_reloading > 0);
2052 int manager_distribute_fds(Manager *m, FDSet *fds) {
2059 HASHMAP_FOREACH(u, m->units, i) {
2061 if (fdset_size(fds) <= 0)
2064 if (UNIT_VTABLE(u)->distribute_fds) {
2065 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2074 int manager_reload(Manager *m) {
2081 r = manager_open_serialization(m, &f);
2094 r = manager_serialize(m, f, fds, true);
2100 if (fseeko(f, 0, SEEK_SET) < 0) {
2106 /* From here on there is no way back. */
2107 manager_clear_jobs_and_units(m);
2108 manager_undo_generators(m);
2109 lookup_paths_free(&m->lookup_paths);
2111 /* Find new unit paths */
2112 manager_run_generators(m);
2114 q = lookup_paths_init(
2115 &m->lookup_paths, m->running_as, true,
2116 m->generator_unit_path,
2117 m->generator_unit_path_early,
2118 m->generator_unit_path_late);
2122 manager_build_unit_path_cache(m);
2124 /* First, enumerate what we can from all config files */
2125 q = manager_enumerate(m);
2129 /* Second, deserialize our stored data */
2130 q = manager_deserialize(m, f, fds);
2137 /* Third, fire things up! */
2138 q = manager_coldplug(m);
2142 assert(m->n_reloading > 0);
2155 bool manager_is_booting_or_shutting_down(Manager *m) {
2160 /* Is the initial job still around? */
2161 if (manager_get_job(m, m->default_unit_job_id))
2164 /* Is there a job for the shutdown target? */
2165 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2172 void manager_reset_failed(Manager *m) {
2178 HASHMAP_FOREACH(u, m->units, i)
2179 unit_reset_failed(u);
2182 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2188 /* Returns true if the unit is inactive or going down */
2189 u = manager_get_unit(m, name);
2193 return unit_pending_inactive(u);
2196 void manager_check_finished(Manager *m) {
2197 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2198 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2202 if (hashmap_size(m->jobs) > 0)
2205 /* Notify Type=idle units that we are done now */
2206 close_pipe(m->idle_pipe);
2208 /* Turn off confirm spawn now */
2209 m->confirm_spawn = false;
2211 if (dual_timestamp_is_set(&m->finish_timestamp))
2214 dual_timestamp_get(&m->finish_timestamp);
2216 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2218 /* Note that m->kernel_usec.monotonic is always at 0,
2219 * and m->firmware_usec.monotonic and
2220 * m->loader_usec.monotonic should be considered
2221 * negative values. */
2223 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2224 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2225 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2226 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2228 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2230 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2231 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2233 if (!log_on_console())
2234 log_struct(LOG_INFO,
2235 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2236 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2237 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2238 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2239 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2240 format_timespan(kernel, sizeof(kernel), kernel_usec),
2241 format_timespan(initrd, sizeof(initrd), initrd_usec),
2242 format_timespan(userspace, sizeof(userspace), userspace_usec),
2243 format_timespan(sum, sizeof(sum), total_usec),
2246 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2249 if (!log_on_console())
2250 log_struct(LOG_INFO,
2251 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2252 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2253 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2254 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2255 format_timespan(kernel, sizeof(kernel), kernel_usec),
2256 format_timespan(userspace, sizeof(userspace), userspace_usec),
2257 format_timespan(sum, sizeof(sum), total_usec),
2261 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2262 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2264 if (!log_on_console())
2265 log_struct(LOG_INFO,
2266 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2267 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2268 "MESSAGE=Startup finished in %s.",
2269 format_timespan(sum, sizeof(sum), total_usec),
2273 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2276 "READY=1\nSTATUS=Startup finished in %s.",
2277 format_timespan(sum, sizeof(sum), total_usec));
2280 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2291 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2293 p = strappend("/run/systemd/", name);
2297 r = mkdir_p_label(p, 0755);
2299 log_error("Failed to create generator directory %s: %s",
2305 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2311 log_error("Failed to create generator directory %s: %m",
2321 static void trim_generator_dir(Manager *m, char **generator) {
2328 if (rmdir(*generator) >= 0) {
2336 void manager_run_generators(Manager *m) {
2338 const char *generator_path;
2339 const char *argv[5];
2345 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2346 d = opendir(generator_path);
2348 if (errno == ENOENT)
2351 log_error("Failed to enumerate generator directory %s: %m",
2356 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2360 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2364 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2368 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2369 argv[1] = m->generator_unit_path;
2370 argv[2] = m->generator_unit_path_early;
2371 argv[3] = m->generator_unit_path_late;
2375 execute_directory(generator_path, d, (char**) argv);
2378 trim_generator_dir(m, &m->generator_unit_path);
2379 trim_generator_dir(m, &m->generator_unit_path_early);
2380 trim_generator_dir(m, &m->generator_unit_path_late);
2387 static void remove_generator_dir(Manager *m, char **generator) {
2394 strv_remove(m->lookup_paths.unit_path, *generator);
2395 rm_rf(*generator, false, true, false);
2401 void manager_undo_generators(Manager *m) {
2404 remove_generator_dir(m, &m->generator_unit_path);
2405 remove_generator_dir(m, &m->generator_unit_path_early);
2406 remove_generator_dir(m, &m->generator_unit_path_late);
2409 int manager_set_default_controllers(Manager *m, char **controllers) {
2414 l = strv_copy(controllers);
2418 strv_free(m->default_controllers);
2419 m->default_controllers = l;
2421 cg_shorten_controllers(m->default_controllers);
2426 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2431 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2432 if (!default_rlimit[i])
2435 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2443 void manager_recheck_journal(Manager *m) {
2448 if (m->running_as != SYSTEMD_SYSTEM)
2451 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2452 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2453 log_close_journal();
2457 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2458 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2459 log_close_journal();
2463 /* Hmm, OK, so the socket is fully up and the service is up
2464 * too, then let's make use of the thing. */
2468 void manager_set_show_status(Manager *m, bool b) {
2471 if (m->running_as != SYSTEMD_SYSTEM)
2477 touch("/run/systemd/show-status");
2479 unlink("/run/systemd/show-status");
2482 bool manager_get_show_status(Manager *m) {
2485 if (m->running_as != SYSTEMD_SYSTEM)
2491 /* If Plymouth is running make sure we show the status, so
2492 * that there's something nice to see when people press Esc */
2494 return plymouth_running();
2497 void watch_init(Watch *w) {
2500 w->type = WATCH_INVALID;