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);
312 efi_get_boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
314 m->running_as = running_as;
315 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
316 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
317 m->pin_cgroupfs_fd = -1;
318 m->idle_pipe[0] = m->idle_pipe[1] = -1;
320 watch_init(&m->signal_watch);
321 watch_init(&m->mount_watch);
322 watch_init(&m->swap_watch);
323 watch_init(&m->udev_watch);
324 watch_init(&m->time_change_watch);
326 m->epoll_fd = m->dev_autofs_fd = -1;
327 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
329 m->environment = strv_copy(environ);
333 manager_strip_environment(m);
335 if (running_as == SYSTEMD_SYSTEM) {
336 m->default_controllers = strv_new("cpu", NULL);
337 if (!m->default_controllers)
341 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
344 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
347 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
350 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
353 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
356 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
360 r = manager_setup_signals(m);
364 r = manager_setup_cgroup(m);
368 r = manager_setup_notify(m);
372 r = manager_setup_time_change(m);
376 /* Try to connect to the busses, if possible. */
377 r = bus_init(m, running_as != SYSTEMD_SYSTEM);
381 m->taint_usr = dir_is_empty("/usr") > 0;
391 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
397 while ((u = m->cleanup_queue)) {
398 assert(u->in_cleanup_queue);
408 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
409 GC_OFFSET_UNSURE, /* No clue */
410 GC_OFFSET_GOOD, /* We still need this unit */
411 GC_OFFSET_BAD, /* We don't need this unit anymore */
415 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
422 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
423 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
424 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
427 if (u->in_cleanup_queue)
430 if (unit_check_gc(u))
433 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
437 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
438 unit_gc_sweep(other, gc_marker);
440 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
443 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
450 /* We were unable to find anything out about this entry, so
451 * let's investigate it later */
452 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
453 unit_add_to_gc_queue(u);
457 /* We definitely know that this one is not useful anymore, so
458 * let's mark it for deletion */
459 u->gc_marker = gc_marker + GC_OFFSET_BAD;
460 unit_add_to_cleanup_queue(u);
464 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
467 static unsigned manager_dispatch_gc_queue(Manager *m) {
474 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
475 (m->gc_queue_timestamp <= 0 ||
476 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
479 log_debug("Running GC...");
481 m->gc_marker += _GC_OFFSET_MAX;
482 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
485 gc_marker = m->gc_marker;
487 while ((u = m->gc_queue)) {
488 assert(u->in_gc_queue);
490 unit_gc_sweep(u, gc_marker);
492 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
493 u->in_gc_queue = false;
497 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
498 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
499 log_debug_unit(u->id, "Collecting %s", u->id);
500 u->gc_marker = gc_marker + GC_OFFSET_BAD;
501 unit_add_to_cleanup_queue(u);
505 m->n_in_gc_queue = 0;
506 m->gc_queue_timestamp = 0;
511 static void manager_clear_jobs_and_units(Manager *m) {
516 while ((u = hashmap_first(m->units)))
519 manager_dispatch_cleanup_queue(m);
521 assert(!m->load_queue);
522 assert(!m->run_queue);
523 assert(!m->dbus_unit_queue);
524 assert(!m->dbus_job_queue);
525 assert(!m->cleanup_queue);
526 assert(!m->gc_queue);
528 assert(hashmap_isempty(m->jobs));
529 assert(hashmap_isempty(m->units));
532 void manager_free(Manager *m) {
538 manager_clear_jobs_and_units(m);
540 for (c = 0; c < _UNIT_TYPE_MAX; c++)
541 if (unit_vtable[c]->shutdown)
542 unit_vtable[c]->shutdown(m);
544 /* If we reexecute ourselves, we keep the root cgroup
546 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
548 manager_undo_generators(m);
552 hashmap_free(m->units);
553 hashmap_free(m->jobs);
554 hashmap_free(m->watch_pids);
555 hashmap_free(m->watch_bus);
557 if (m->epoll_fd >= 0)
558 close_nointr_nofail(m->epoll_fd);
559 if (m->signal_watch.fd >= 0)
560 close_nointr_nofail(m->signal_watch.fd);
561 if (m->notify_watch.fd >= 0)
562 close_nointr_nofail(m->notify_watch.fd);
563 if (m->time_change_watch.fd >= 0)
564 close_nointr_nofail(m->time_change_watch.fd);
566 free(m->notify_socket);
568 lookup_paths_free(&m->lookup_paths);
569 strv_free(m->environment);
571 strv_free(m->default_controllers);
573 hashmap_free(m->cgroup_bondings);
574 set_free_free(m->unit_path_cache);
576 close_pipe(m->idle_pipe);
578 free(m->switch_root);
579 free(m->switch_root_init);
581 for (i = 0; i < RLIMIT_NLIMITS; i++)
587 int manager_enumerate(Manager *m) {
593 /* Let's ask every type to load all units from disk/kernel
594 * that it might know */
595 for (c = 0; c < _UNIT_TYPE_MAX; c++)
596 if (unit_vtable[c]->enumerate)
597 if ((q = unit_vtable[c]->enumerate(m)) < 0)
600 manager_dispatch_load_queue(m);
604 int manager_coldplug(Manager *m) {
612 /* Then, let's set up their initial state. */
613 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
619 if ((q = unit_coldplug(u)) < 0)
626 static void manager_build_unit_path_cache(Manager *m) {
628 DIR _cleanup_free_ *d = NULL;
633 set_free_free(m->unit_path_cache);
635 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
636 if (!m->unit_path_cache) {
637 log_error("Failed to allocate unit path cache.");
641 /* This simply builds a list of files we know exist, so that
642 * we don't always have to go to disk */
644 STRV_FOREACH(i, m->lookup_paths.unit_path) {
650 log_error("Failed to open directory %s: %m", *i);
654 while ((de = readdir(d))) {
657 if (ignore_file(de->d_name))
660 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
666 r = set_put(m->unit_path_cache, p);
680 log_error("Failed to build unit path cache: %s", strerror(-r));
682 set_free_free(m->unit_path_cache);
683 m->unit_path_cache = NULL;
686 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
691 manager_run_generators(m);
693 r = lookup_paths_init(
694 &m->lookup_paths, m->running_as, true,
695 m->generator_unit_path,
696 m->generator_unit_path_early,
697 m->generator_unit_path_late);
701 manager_build_unit_path_cache(m);
703 /* If we will deserialize make sure that during enumeration
704 * this is already known, so we increase the counter here
709 /* First, enumerate what we can from all config files */
710 r = manager_enumerate(m);
712 /* Second, deserialize if there is something to deserialize */
714 q = manager_deserialize(m, serialization, fds);
719 /* Any fds left? Find some unit which wants them. This is
720 * useful to allow container managers to pass some file
721 * descriptors to us pre-initialized. This enables
722 * socket-based activation of entire containers. */
723 if (fdset_size(fds) > 0) {
724 q = manager_distribute_fds(m, fds);
729 /* Third, fire things up! */
730 q = manager_coldplug(m);
735 assert(m->n_reloading > 0);
742 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
747 assert(type < _JOB_TYPE_MAX);
749 assert(mode < _JOB_MODE_MAX);
751 if (mode == JOB_ISOLATE && type != JOB_START) {
752 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
756 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
757 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
761 log_debug_unit(unit->id,
762 "Trying to enqueue job %s/%s/%s", unit->id,
763 job_type_to_string(type), job_mode_to_string(mode));
765 job_type_collapse(&type, unit);
767 tr = transaction_new();
771 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
772 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
773 mode == JOB_IGNORE_DEPENDENCIES, e);
777 if (mode == JOB_ISOLATE) {
778 r = transaction_add_isolate_jobs(tr, m);
783 r = transaction_activate(tr, m, mode, e);
787 log_debug_unit(unit->id,
788 "Enqueued job %s/%s as %u", unit->id,
789 job_type_to_string(type), (unsigned) tr->anchor_job->id);
792 *_ret = tr->anchor_job;
794 transaction_free(tr);
798 transaction_abort(tr);
799 transaction_free(tr);
803 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
808 assert(type < _JOB_TYPE_MAX);
810 assert(mode < _JOB_MODE_MAX);
812 r = manager_load_unit(m, name, NULL, NULL, &unit);
816 return manager_add_job(m, type, unit, mode, override, e, _ret);
819 Job *manager_get_job(Manager *m, uint32_t id) {
822 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
825 Unit *manager_get_unit(Manager *m, const char *name) {
829 return hashmap_get(m->units, name);
832 unsigned manager_dispatch_load_queue(Manager *m) {
838 /* Make sure we are not run recursively */
839 if (m->dispatching_load_queue)
842 m->dispatching_load_queue = true;
844 /* Dispatches the load queue. Takes a unit from the queue and
845 * tries to load its data until the queue is empty */
847 while ((u = m->load_queue)) {
848 assert(u->in_load_queue);
854 m->dispatching_load_queue = false;
858 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
864 assert(name || path);
866 /* This will prepare the unit for loading, but not actually
867 * load anything from disk. */
869 if (path && !is_path(path)) {
870 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
875 name = path_get_file_name(path);
877 t = unit_name_to_type(name);
879 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
880 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
884 ret = manager_get_unit(m, name);
890 ret = unit_new(m, unit_vtable[t]->object_size);
895 ret->fragment_path = strdup(path);
896 if (!ret->fragment_path) {
902 if ((r = unit_add_name(ret, name)) < 0) {
907 unit_add_to_load_queue(ret);
908 unit_add_to_dbus_queue(ret);
909 unit_add_to_gc_queue(ret);
917 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
922 /* This will load the service information files, but not actually
923 * start any services or anything. */
925 r = manager_load_unit_prepare(m, name, path, e, _ret);
929 manager_dispatch_load_queue(m);
932 *_ret = unit_follow_merge(*_ret);
937 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
944 HASHMAP_FOREACH(j, s->jobs, i)
945 job_dump(j, f, prefix);
948 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
956 HASHMAP_FOREACH_KEY(u, t, s->units, i)
958 unit_dump(u, f, prefix);
961 void manager_clear_jobs(Manager *m) {
966 while ((j = hashmap_first(m->jobs)))
967 /* No need to recurse. We're cancelling all jobs. */
968 job_finish_and_invalidate(j, JOB_CANCELED, false);
971 unsigned manager_dispatch_run_queue(Manager *m) {
975 if (m->dispatching_run_queue)
978 m->dispatching_run_queue = true;
980 while ((j = m->run_queue)) {
981 assert(j->installed);
982 assert(j->in_run_queue);
984 job_run_and_invalidate(j);
988 m->dispatching_run_queue = false;
992 unsigned manager_dispatch_dbus_queue(Manager *m) {
999 if (m->dispatching_dbus_queue)
1002 m->dispatching_dbus_queue = true;
1004 while ((u = m->dbus_unit_queue)) {
1005 assert(u->in_dbus_queue);
1007 bus_unit_send_change_signal(u);
1011 while ((j = m->dbus_job_queue)) {
1012 assert(j->in_dbus_queue);
1014 bus_job_send_change_signal(j);
1018 m->dispatching_dbus_queue = false;
1022 static int manager_process_notify_fd(Manager *m) {
1029 struct msghdr msghdr;
1031 struct ucred *ucred;
1033 struct cmsghdr cmsghdr;
1034 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1040 iovec.iov_base = buf;
1041 iovec.iov_len = sizeof(buf)-1;
1045 msghdr.msg_iov = &iovec;
1046 msghdr.msg_iovlen = 1;
1047 msghdr.msg_control = &control;
1048 msghdr.msg_controllen = sizeof(control);
1050 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1055 if (errno == EAGAIN || errno == EINTR)
1061 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1062 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1063 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1064 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1065 log_warning("Received notify message without credentials. Ignoring.");
1069 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1071 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1073 u = cgroup_unit_by_pid(m, ucred->pid);
1075 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1080 assert((size_t) n < sizeof(buf));
1082 tags = strv_split(buf, "\n\r");
1086 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1088 if (UNIT_VTABLE(u)->notify_message)
1089 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1097 static int manager_dispatch_sigchld(Manager *m) {
1107 /* First we call waitd() for a PID and do not reap the
1108 * zombie. That way we can still access /proc/$PID for
1109 * it while it is a zombie. */
1110 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1112 if (errno == ECHILD)
1124 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1125 char _cleanup_free_ *name = NULL;
1127 get_process_comm(si.si_pid, &name);
1128 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1131 /* Let's flush any message the dying child might still
1132 * have queued for us. This ensures that the process
1133 * still exists in /proc so that we can figure out
1134 * which cgroup and hence unit it belongs to. */
1135 r = manager_process_notify_fd(m);
1139 /* And now figure out the unit this belongs to */
1140 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1142 u = cgroup_unit_by_pid(m, si.si_pid);
1144 /* And now, we actually reap the zombie. */
1145 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1152 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1155 log_debug("Child %lu died (code=%s, status=%i/%s)",
1156 (long unsigned) si.si_pid,
1157 sigchld_code_to_string(si.si_code),
1159 strna(si.si_code == CLD_EXITED
1160 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1161 : signal_to_string(si.si_status)));
1166 log_debug_unit(u->id,
1167 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1169 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1170 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1176 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1180 dbus_error_init(&error);
1182 log_debug_unit(name, "Activating special unit %s", name);
1184 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1186 log_error_unit(name,
1187 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1189 dbus_error_free(&error);
1194 static int manager_process_signal_fd(Manager *m) {
1196 struct signalfd_siginfo sfsi;
1197 bool sigchld = false;
1202 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1203 if (n != sizeof(sfsi)) {
1208 if (errno == EINTR || errno == EAGAIN)
1214 if (sfsi.ssi_pid > 0) {
1217 get_process_comm(sfsi.ssi_pid, &p);
1219 log_debug("Received SIG%s from PID %lu (%s).",
1220 signal_to_string(sfsi.ssi_signo),
1221 (unsigned long) sfsi.ssi_pid, strna(p));
1224 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1226 switch (sfsi.ssi_signo) {
1233 if (m->running_as == SYSTEMD_SYSTEM) {
1234 /* This is for compatibility with the
1235 * original sysvinit */
1236 m->exit_code = MANAGER_REEXECUTE;
1243 if (m->running_as == SYSTEMD_SYSTEM) {
1244 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1248 /* Run the exit target if there is one, if not, just exit. */
1249 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1250 m->exit_code = MANAGER_EXIT;
1257 if (m->running_as == SYSTEMD_SYSTEM)
1258 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1260 /* This is a nop on non-init */
1264 if (m->running_as == SYSTEMD_SYSTEM)
1265 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1267 /* This is a nop on non-init */
1273 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1275 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1276 log_info("Trying to reconnect to bus...");
1280 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1281 log_info("Loading D-Bus service...");
1282 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1293 if (!(f = open_memstream(&dump, &size))) {
1294 log_warning("Failed to allocate memory stream.");
1298 manager_dump_units(m, f, "\t");
1299 manager_dump_jobs(m, f, "\t");
1304 log_warning("Failed to write status stream");
1309 log_dump(LOG_INFO, dump);
1316 m->exit_code = MANAGER_RELOAD;
1321 /* Starting SIGRTMIN+0 */
1322 static const char * const target_table[] = {
1323 [0] = SPECIAL_DEFAULT_TARGET,
1324 [1] = SPECIAL_RESCUE_TARGET,
1325 [2] = SPECIAL_EMERGENCY_TARGET,
1326 [3] = SPECIAL_HALT_TARGET,
1327 [4] = SPECIAL_POWEROFF_TARGET,
1328 [5] = SPECIAL_REBOOT_TARGET,
1329 [6] = SPECIAL_KEXEC_TARGET
1332 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1333 static const ManagerExitCode code_table[] = {
1335 [1] = MANAGER_POWEROFF,
1336 [2] = MANAGER_REBOOT,
1340 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1341 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1342 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1343 manager_start_target(m, target_table[idx],
1344 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1348 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1349 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1350 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1354 switch (sfsi.ssi_signo - SIGRTMIN) {
1357 log_debug("Enabling showing of status.");
1358 manager_set_show_status(m, true);
1362 log_debug("Disabling showing of status.");
1363 manager_set_show_status(m, false);
1367 log_set_max_level(LOG_DEBUG);
1368 log_notice("Setting log level to debug.");
1372 log_set_max_level(LOG_INFO);
1373 log_notice("Setting log level to info.");
1377 if (m->running_as == SYSTEMD_USER) {
1378 m->exit_code = MANAGER_EXIT;
1382 /* This is a nop on init */
1386 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1387 log_notice("Setting log target to journal-or-kmsg.");
1391 log_set_target(LOG_TARGET_CONSOLE);
1392 log_notice("Setting log target to console.");
1396 log_set_target(LOG_TARGET_KMSG);
1397 log_notice("Setting log target to kmsg.");
1401 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1402 log_notice("Setting log target to syslog-or-kmsg.");
1406 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1413 return manager_dispatch_sigchld(m);
1418 static int process_event(Manager *m, struct epoll_event *ev) {
1425 assert_se(w = ev->data.ptr);
1427 if (w->type == WATCH_INVALID)
1434 /* An incoming signal? */
1435 if (ev->events != EPOLLIN)
1438 if ((r = manager_process_signal_fd(m)) < 0)
1445 /* An incoming daemon notification event? */
1446 if (ev->events != EPOLLIN)
1449 if ((r = manager_process_notify_fd(m)) < 0)
1456 /* Some fd event, to be dispatched to the units */
1457 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1460 case WATCH_UNIT_TIMER:
1461 case WATCH_JOB_TIMER: {
1465 /* Some timer event, to be dispatched to the units */
1466 k = read(w->fd, &v, sizeof(v));
1467 if (k != sizeof(v)) {
1469 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1472 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1473 return k < 0 ? -errno : -EIO;
1476 if (w->type == WATCH_UNIT_TIMER)
1477 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1479 job_timer_event(w->data.job, v, w);
1484 /* Some mount table change, intended for the mount subsystem */
1485 mount_fd_event(m, ev->events);
1489 /* Some swap table change, intended for the swap subsystem */
1490 swap_fd_event(m, ev->events);
1494 /* Some notification from udev, intended for the device subsystem */
1495 device_fd_event(m, ev->events);
1498 case WATCH_DBUS_WATCH:
1499 bus_watch_event(m, w, ev->events);
1502 case WATCH_DBUS_TIMEOUT:
1503 bus_timeout_event(m, w, ev->events);
1506 case WATCH_TIME_CHANGE: {
1510 log_struct(LOG_INFO,
1511 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1512 "MESSAGE=Time has been changed",
1515 /* Restart the watch */
1516 close_nointr_nofail(m->time_change_watch.fd);
1517 watch_init(&m->time_change_watch);
1518 manager_setup_time_change(m);
1520 HASHMAP_FOREACH(u, m->units, i) {
1521 if (UNIT_VTABLE(u)->time_change)
1522 UNIT_VTABLE(u)->time_change(u);
1529 log_error("event type=%i", w->type);
1530 assert_not_reached("Unknown epoll event type.");
1536 int manager_loop(Manager *m) {
1539 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1542 m->exit_code = MANAGER_RUNNING;
1544 /* Release the path cache */
1545 set_free_free(m->unit_path_cache);
1546 m->unit_path_cache = NULL;
1548 manager_check_finished(m);
1550 /* There might still be some zombies hanging around from
1551 * before we were exec()'ed. Leat's reap them */
1552 r = manager_dispatch_sigchld(m);
1556 while (m->exit_code == MANAGER_RUNNING) {
1557 struct epoll_event event;
1561 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1564 if (!ratelimit_test(&rl)) {
1565 /* Yay, something is going seriously wrong, pause a little */
1566 log_warning("Looping too fast. Throttling execution a little.");
1571 if (manager_dispatch_load_queue(m) > 0)
1574 if (manager_dispatch_run_queue(m) > 0)
1577 if (bus_dispatch(m) > 0)
1580 if (manager_dispatch_cleanup_queue(m) > 0)
1583 if (manager_dispatch_gc_queue(m) > 0)
1586 if (manager_dispatch_dbus_queue(m) > 0)
1589 if (swap_dispatch_reload(m) > 0)
1592 /* Sleep for half the watchdog time */
1593 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1594 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1600 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1612 r = process_event(m, &event);
1617 return m->exit_code;
1620 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1629 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1632 n = bus_path_unescape(s+31);
1636 r = manager_load_unit(m, n, NULL, e, &u);
1647 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1656 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1659 r = safe_atou(s + 30, &id);
1663 j = manager_get_job(m, id);
1672 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1678 audit_fd = get_audit_fd();
1682 /* Don't generate audit events if the service was already
1683 * started and we're just deserializing */
1684 if (m->n_reloading > 0)
1687 if (m->running_as != SYSTEMD_SYSTEM)
1690 if (u->type != UNIT_SERVICE)
1693 p = unit_name_to_prefix_and_instance(u->id);
1695 log_error_unit(u->id,
1696 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1700 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1701 if (errno == EPERM) {
1702 /* We aren't allowed to send audit messages?
1703 * Then let's not retry again. */
1706 log_warning("Failed to send audit message: %m");
1714 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1716 union sockaddr_union sa;
1718 char *message = NULL;
1720 /* Don't generate plymouth events if the service was already
1721 * started and we're just deserializing */
1722 if (m->n_reloading > 0)
1725 if (m->running_as != SYSTEMD_SYSTEM)
1728 if (u->type != UNIT_SERVICE &&
1729 u->type != UNIT_MOUNT &&
1730 u->type != UNIT_SWAP)
1733 /* We set SOCK_NONBLOCK here so that we rather drop the
1734 * message then wait for plymouth */
1735 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1736 log_error("socket() failed: %m");
1741 sa.sa.sa_family = AF_UNIX;
1742 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1743 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1745 if (errno != EPIPE &&
1748 errno != ECONNREFUSED &&
1749 errno != ECONNRESET &&
1750 errno != ECONNABORTED)
1751 log_error("connect() failed: %m");
1756 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1762 if (write(fd, message, n + 1) != n + 1) {
1764 if (errno != EPIPE &&
1767 errno != ECONNREFUSED &&
1768 errno != ECONNRESET &&
1769 errno != ECONNABORTED)
1770 log_error("Failed to write Plymouth message: %m");
1777 close_nointr_nofail(fd);
1782 void manager_dispatch_bus_name_owner_changed(
1785 const char* old_owner,
1786 const char *new_owner) {
1793 if (!(u = hashmap_get(m->watch_bus, name)))
1796 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1799 void manager_dispatch_bus_query_pid_done(
1810 if (!(u = hashmap_get(m->watch_bus, name)))
1813 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1816 int manager_open_serialization(Manager *m, FILE **_f) {
1824 if (m->running_as == SYSTEMD_SYSTEM)
1825 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1827 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1832 saved_umask = umask(0077);
1833 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1843 log_debug("Serializing state to %s", path);
1846 f = fdopen(fd, "w+");
1855 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
1868 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1869 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1870 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1871 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1873 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1874 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1875 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1876 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1879 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1880 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1883 STRV_FOREACH(e, m->environment) {
1884 _cleanup_free_ char *ce;
1888 fprintf(f, "env=%s\n", *e);
1893 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1897 if (!unit_can_serialize(u))
1904 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
1910 assert(m->n_reloading > 0);
1916 r = bus_fdset_add_all(m, fds);
1923 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1929 log_debug("Deserializing state...");
1934 char line[LINE_MAX], *l;
1936 if (!fgets(line, sizeof(line), f)) {
1951 if (startswith(l, "current-job-id=")) {
1954 if (safe_atou32(l+15, &id) < 0)
1955 log_debug("Failed to parse current job id value %s", l+15);
1957 m->current_job_id = MAX(m->current_job_id, id);
1958 } else if (startswith(l, "n-installed-jobs=")) {
1961 if (safe_atou32(l+17, &n) < 0)
1962 log_debug("Failed to parse installed jobs counter %s", l+17);
1964 m->n_installed_jobs += n;
1965 } else if (startswith(l, "n-failed-jobs=")) {
1968 if (safe_atou32(l+14, &n) < 0)
1969 log_debug("Failed to parse failed jobs counter %s", l+14);
1971 m->n_failed_jobs += n;
1972 } else if (startswith(l, "taint-usr=")) {
1975 if ((b = parse_boolean(l+10)) < 0)
1976 log_debug("Failed to parse taint /usr flag %s", l+10);
1978 m->taint_usr = m->taint_usr || b;
1979 } else if (startswith(l, "firmware-timestamp="))
1980 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
1981 else if (startswith(l, "loader-timestamp="))
1982 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
1983 else if (startswith(l, "kernel-timestamp="))
1984 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
1985 else if (startswith(l, "initrd-timestamp="))
1986 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1987 else if (startswith(l, "userspace-timestamp="))
1988 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
1989 else if (startswith(l, "finish-timestamp="))
1990 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1991 else if (startswith(l, "env=")) {
1992 _cleanup_free_ char *uce = NULL;
1995 uce = cunescape(l+4);
2001 e = strv_env_set(m->environment, uce);
2007 strv_free(m->environment);
2010 log_debug("Unknown serialization item '%s'", l);
2015 char name[UNIT_NAME_MAX+2];
2018 if (!fgets(name, sizeof(name), f)) {
2029 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2033 r = unit_deserialize(u, f, fds);
2044 assert(m->n_reloading > 0);
2050 int manager_distribute_fds(Manager *m, FDSet *fds) {
2057 HASHMAP_FOREACH(u, m->units, i) {
2059 if (fdset_size(fds) <= 0)
2062 if (UNIT_VTABLE(u)->distribute_fds) {
2063 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2072 int manager_reload(Manager *m) {
2079 r = manager_open_serialization(m, &f);
2092 r = manager_serialize(m, f, fds, true);
2098 if (fseeko(f, 0, SEEK_SET) < 0) {
2104 /* From here on there is no way back. */
2105 manager_clear_jobs_and_units(m);
2106 manager_undo_generators(m);
2107 lookup_paths_free(&m->lookup_paths);
2109 /* Find new unit paths */
2110 manager_run_generators(m);
2112 q = lookup_paths_init(
2113 &m->lookup_paths, m->running_as, true,
2114 m->generator_unit_path,
2115 m->generator_unit_path_early,
2116 m->generator_unit_path_late);
2120 manager_build_unit_path_cache(m);
2122 /* First, enumerate what we can from all config files */
2123 q = manager_enumerate(m);
2127 /* Second, deserialize our stored data */
2128 q = manager_deserialize(m, f, fds);
2135 /* Third, fire things up! */
2136 q = manager_coldplug(m);
2140 assert(m->n_reloading > 0);
2153 bool manager_is_booting_or_shutting_down(Manager *m) {
2158 /* Is the initial job still around? */
2159 if (manager_get_job(m, m->default_unit_job_id))
2162 /* Is there a job for the shutdown target? */
2163 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2170 void manager_reset_failed(Manager *m) {
2176 HASHMAP_FOREACH(u, m->units, i)
2177 unit_reset_failed(u);
2180 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2186 /* Returns true if the unit is inactive or going down */
2187 u = manager_get_unit(m, name);
2191 return unit_pending_inactive(u);
2194 void manager_check_finished(Manager *m) {
2195 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2196 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2200 if (hashmap_size(m->jobs) > 0)
2203 /* Notify Type=idle units that we are done now */
2204 close_pipe(m->idle_pipe);
2206 /* Turn off confirm spawn now */
2207 m->confirm_spawn = false;
2209 if (dual_timestamp_is_set(&m->finish_timestamp))
2212 dual_timestamp_get(&m->finish_timestamp);
2214 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2216 /* Note that m->kernel_usec.monotonic is always at 0,
2217 * and m->firmware_usec.monotonic and
2218 * m->loader_usec.monotonic should be considered
2219 * negative values. */
2221 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2222 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2223 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2224 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2226 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2228 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2229 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2231 if (!log_on_console())
2232 log_struct(LOG_INFO,
2233 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2234 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2235 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2236 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2237 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2238 format_timespan(kernel, sizeof(kernel), kernel_usec),
2239 format_timespan(initrd, sizeof(initrd), initrd_usec),
2240 format_timespan(userspace, sizeof(userspace), userspace_usec),
2241 format_timespan(sum, sizeof(sum), total_usec),
2244 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2247 if (!log_on_console())
2248 log_struct(LOG_INFO,
2249 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2250 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2251 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2252 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2253 format_timespan(kernel, sizeof(kernel), kernel_usec),
2254 format_timespan(userspace, sizeof(userspace), userspace_usec),
2255 format_timespan(sum, sizeof(sum), total_usec),
2259 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2260 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2262 if (!log_on_console())
2263 log_struct(LOG_INFO,
2264 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2265 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2266 "MESSAGE=Startup finished in %s.",
2267 format_timespan(sum, sizeof(sum), total_usec),
2271 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2274 "READY=1\nSTATUS=Startup finished in %s.",
2275 format_timespan(sum, sizeof(sum), total_usec));
2278 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2289 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2291 p = strappend("/run/systemd/", name);
2295 r = mkdir_p_label(p, 0755);
2297 log_error("Failed to create generator directory %s: %s",
2303 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2309 log_error("Failed to create generator directory %s: %m",
2319 static void trim_generator_dir(Manager *m, char **generator) {
2326 if (rmdir(*generator) >= 0) {
2334 void manager_run_generators(Manager *m) {
2336 const char *generator_path;
2337 const char *argv[5];
2343 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2344 d = opendir(generator_path);
2346 if (errno == ENOENT)
2349 log_error("Failed to enumerate generator directory %s: %m",
2354 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2358 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2362 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2366 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2367 argv[1] = m->generator_unit_path;
2368 argv[2] = m->generator_unit_path_early;
2369 argv[3] = m->generator_unit_path_late;
2373 execute_directory(generator_path, d, (char**) argv);
2376 trim_generator_dir(m, &m->generator_unit_path);
2377 trim_generator_dir(m, &m->generator_unit_path_early);
2378 trim_generator_dir(m, &m->generator_unit_path_late);
2385 static void remove_generator_dir(Manager *m, char **generator) {
2392 strv_remove(m->lookup_paths.unit_path, *generator);
2393 rm_rf(*generator, false, true, false);
2399 void manager_undo_generators(Manager *m) {
2402 remove_generator_dir(m, &m->generator_unit_path);
2403 remove_generator_dir(m, &m->generator_unit_path_early);
2404 remove_generator_dir(m, &m->generator_unit_path_late);
2407 int manager_set_default_controllers(Manager *m, char **controllers) {
2412 l = strv_copy(controllers);
2416 strv_free(m->default_controllers);
2417 m->default_controllers = l;
2419 cg_shorten_controllers(m->default_controllers);
2424 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2429 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2430 if (!default_rlimit[i])
2433 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2441 void manager_recheck_journal(Manager *m) {
2446 if (m->running_as != SYSTEMD_SYSTEM)
2449 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2450 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2451 log_close_journal();
2455 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2456 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2457 log_close_journal();
2461 /* Hmm, OK, so the socket is fully up and the service is up
2462 * too, then let's make use of the thing. */
2466 void manager_set_show_status(Manager *m, bool b) {
2469 if (m->running_as != SYSTEMD_SYSTEM)
2475 touch("/run/systemd/show-status");
2477 unlink("/run/systemd/show-status");
2480 bool manager_get_show_status(Manager *m) {
2483 if (m->running_as != SYSTEMD_SYSTEM)
2489 /* If Plymouth is running make sure we show the status, so
2490 * that there's something nice to see when people press Esc */
2492 return plymouth_running();
2495 void watch_init(Watch *w) {
2498 w->type = WATCH_INVALID;