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"
58 #include "locale-setup.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 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
77 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
79 /* Initial delay and the interval for printing status messages about running jobs */
80 #define JOBS_IN_PROGRESS_WAIT_SEC 5
81 #define JOBS_IN_PROGRESS_PERIOD_SEC 1
82 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
84 /* Where clients shall send notification messages to */
85 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
87 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
89 static int manager_setup_notify(Manager *m) {
92 struct sockaddr_un un;
94 .sa.sa_family = AF_UNIX,
96 struct epoll_event ev = {
98 .data.ptr = &m->notify_watch,
102 m->notify_watch.type = WATCH_NOTIFY;
103 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
104 if (m->notify_watch.fd < 0) {
105 log_error("Failed to allocate notification socket: %m");
109 if (getpid() != 1 || detect_container(NULL) > 0)
110 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
112 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
114 sa.un.sun_path[0] = 0;
116 r = bind(m->notify_watch.fd, &sa.sa,
117 offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
119 log_error("bind() failed: %m");
123 r = setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
125 log_error("SO_PASSCRED failed: %m");
129 r = epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev);
131 log_error("Failed to add notification socket fd to epoll: %m");
135 sa.un.sun_path[0] = '@';
136 m->notify_socket = strdup(sa.un.sun_path);
137 if (!m->notify_socket)
140 log_debug("Using notification socket %s", m->notify_socket);
145 static int manager_jobs_in_progress_mod_timer(Manager *m) {
146 struct itimerspec its = {
147 .it_value.tv_sec = JOBS_IN_PROGRESS_WAIT_SEC,
148 .it_interval.tv_sec = JOBS_IN_PROGRESS_PERIOD_SEC,
151 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
154 if (timerfd_settime(m->jobs_in_progress_watch.fd, 0, &its, NULL) < 0)
160 static int manager_watch_jobs_in_progress(Manager *m) {
161 struct epoll_event ev = {
163 .data.ptr = &m->jobs_in_progress_watch,
167 if (m->jobs_in_progress_watch.type != WATCH_INVALID)
170 m->jobs_in_progress_watch.type = WATCH_JOBS_IN_PROGRESS;
171 m->jobs_in_progress_watch.fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
172 if (m->jobs_in_progress_watch.fd < 0) {
173 log_error("Failed to create timerfd: %m");
178 r = manager_jobs_in_progress_mod_timer(m);
180 log_error("Failed to set up timer for jobs progress watch: %s", strerror(-r));
184 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->jobs_in_progress_watch.fd, &ev) < 0) {
185 log_error("Failed to add jobs progress timer fd to epoll: %m");
190 log_debug("Set up jobs progress timerfd.");
195 if (m->jobs_in_progress_watch.fd >= 0)
196 close_nointr_nofail(m->jobs_in_progress_watch.fd);
197 watch_init(&m->jobs_in_progress_watch);
201 static void manager_unwatch_jobs_in_progress(Manager *m) {
202 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
205 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->jobs_in_progress_watch.fd, NULL) >= 0);
206 close_nointr_nofail(m->jobs_in_progress_watch.fd);
207 watch_init(&m->jobs_in_progress_watch);
208 m->jobs_in_progress_iteration = 0;
210 log_debug("Closed jobs progress timerfd.");
213 #define CYLON_BUFFER_EXTRA (2*strlen(ANSI_RED_ON) + strlen(ANSI_HIGHLIGHT_RED_ON) + 2*strlen(ANSI_HIGHLIGHT_OFF))
214 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
217 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
218 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
222 p = mempset(p, ' ', pos-2);
223 p = stpcpy(p, ANSI_RED_ON);
227 if (pos > 0 && pos <= width) {
228 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
232 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
235 p = stpcpy(p, ANSI_RED_ON);
238 p = mempset(p, ' ', width-1-pos);
239 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
243 static void manager_print_jobs_in_progress(Manager *m) {
246 char *job_of_n = NULL;
247 unsigned counter = 0, print_nr;
248 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
251 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
253 HASHMAP_FOREACH(j, m->jobs, i)
254 if (j->state == JOB_RUNNING && counter++ == print_nr)
257 /* m->n_running_jobs must be consistent with the contents of m->jobs,
258 * so the above loop must have succeeded in finding j. */
259 assert(counter == print_nr + 1);
261 cylon_pos = m->jobs_in_progress_iteration % 14;
263 cylon_pos = 14 - cylon_pos;
264 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
266 if (m->n_running_jobs > 1)
267 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
270 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
271 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
274 m->jobs_in_progress_iteration++;
277 static int manager_watch_idle_pipe(Manager *m) {
278 struct epoll_event ev = {
280 .data.ptr = &m->idle_pipe_watch,
284 if (m->idle_pipe_watch.type != WATCH_INVALID)
287 if (m->idle_pipe[2] < 0)
290 m->idle_pipe_watch.type = WATCH_IDLE_PIPE;
291 m->idle_pipe_watch.fd = m->idle_pipe[2];
292 if (m->idle_pipe_watch.fd < 0) {
293 log_error("Failed to create timerfd: %m");
298 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->idle_pipe_watch.fd, &ev) < 0) {
299 log_error("Failed to add idle_pipe fd to epoll: %m");
304 log_debug("Set up idle_pipe watch.");
309 if (m->idle_pipe_watch.fd >= 0)
310 close_nointr_nofail(m->idle_pipe_watch.fd);
311 watch_init(&m->idle_pipe_watch);
315 static void manager_unwatch_idle_pipe(Manager *m) {
316 if (m->idle_pipe_watch.type != WATCH_IDLE_PIPE)
319 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->idle_pipe_watch.fd, NULL) >= 0);
320 watch_init(&m->idle_pipe_watch);
322 log_debug("Closed idle_pipe watch.");
325 static int manager_setup_time_change(Manager *m) {
326 struct epoll_event ev = {
328 .data.ptr = &m->time_change_watch,
331 /* We only care for the cancellation event, hence we set the
332 * timeout to the latest possible value. */
333 struct itimerspec its = {
334 .it_value.tv_sec = TIME_T_MAX,
336 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
338 assert(m->time_change_watch.type == WATCH_INVALID);
340 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
341 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
343 m->time_change_watch.type = WATCH_TIME_CHANGE;
344 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
345 if (m->time_change_watch.fd < 0) {
346 log_error("Failed to create timerfd: %m");
350 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
351 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
352 close_nointr_nofail(m->time_change_watch.fd);
353 watch_init(&m->time_change_watch);
357 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
358 log_error("Failed to add timer change fd to epoll: %m");
362 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
367 static int enable_special_signals(Manager *m) {
372 /* Enable that we get SIGINT on control-alt-del. In containers
373 * this will fail with EPERM (older) or EINVAL (newer), so
375 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
376 log_warning("Failed to enable ctrl-alt-del handling: %m");
378 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
380 /* Support systems without virtual console */
382 log_warning("Failed to open /dev/tty0: %m");
384 /* Enable that we get SIGWINCH on kbrequest */
385 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
386 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
388 close_nointr_nofail(fd);
394 static int manager_setup_signals(Manager *m) {
396 struct epoll_event ev = {
398 .data.ptr = &m->signal_watch,
400 struct sigaction sa = {
401 .sa_handler = SIG_DFL,
402 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
407 /* We are not interested in SIGSTOP and friends. */
408 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
410 assert_se(sigemptyset(&mask) == 0);
412 sigset_add_many(&mask,
413 SIGCHLD, /* Child died */
414 SIGTERM, /* Reexecute daemon */
415 SIGHUP, /* Reload configuration */
416 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
417 SIGUSR2, /* systemd: dump status */
418 SIGINT, /* Kernel sends us this on control-alt-del */
419 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
420 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
421 SIGRTMIN+0, /* systemd: start default.target */
422 SIGRTMIN+1, /* systemd: isolate rescue.target */
423 SIGRTMIN+2, /* systemd: isolate emergency.target */
424 SIGRTMIN+3, /* systemd: start halt.target */
425 SIGRTMIN+4, /* systemd: start poweroff.target */
426 SIGRTMIN+5, /* systemd: start reboot.target */
427 SIGRTMIN+6, /* systemd: start kexec.target */
428 SIGRTMIN+13, /* systemd: Immediate halt */
429 SIGRTMIN+14, /* systemd: Immediate poweroff */
430 SIGRTMIN+15, /* systemd: Immediate reboot */
431 SIGRTMIN+16, /* systemd: Immediate kexec */
432 SIGRTMIN+20, /* systemd: enable status messages */
433 SIGRTMIN+21, /* systemd: disable status messages */
434 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
435 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
436 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
437 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
438 SIGRTMIN+27, /* systemd: set log target to console */
439 SIGRTMIN+28, /* systemd: set log target to kmsg */
440 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
442 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
444 m->signal_watch.type = WATCH_SIGNAL;
445 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
446 if (m->signal_watch.fd < 0)
449 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
452 if (m->running_as == SYSTEMD_SYSTEM)
453 return enable_special_signals(m);
458 static int manager_default_environment(Manager *m) {
459 const char *path = "PATH=" DEFAULT_PATH;
463 if (m->running_as == SYSTEMD_SYSTEM) {
464 /* The system manager always starts with a clean
465 * environment for its children. It does not import
466 * the kernel or the parents exported variables.
468 * The initial passed environ is untouched to keep
469 * /proc/self/environ valid; it is used for tagging
470 * the init process inside containers. */
471 m->environment = strv_new(path, NULL);
473 /* Import locale variables LC_*= from configuration */
474 locale_setup(&m->environment);
476 /* The user manager passes its own environment
477 * along to its children. */
478 m->environment = strv_copy(environ);
486 int manager_new(SystemdRunningAs running_as, bool reexecuting, Manager **_m) {
491 assert(running_as >= 0);
492 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
494 m = new0(Manager, 1);
499 if (detect_container(NULL) <= 0)
500 efi_get_boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
503 m->running_as = running_as;
504 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
505 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
506 m->pin_cgroupfs_fd = -1;
507 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
509 watch_init(&m->signal_watch);
510 watch_init(&m->mount_watch);
511 watch_init(&m->swap_watch);
512 watch_init(&m->udev_watch);
513 watch_init(&m->time_change_watch);
514 watch_init(&m->jobs_in_progress_watch);
516 m->epoll_fd = m->dev_autofs_fd = -1;
517 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
519 r = manager_default_environment(m);
523 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
526 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
529 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
532 m->cgroup_unit = hashmap_new(string_hash_func, string_compare_func);
536 m->watch_bus = hashmap_new(string_hash_func, string_compare_func);
540 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
544 r = manager_setup_signals(m);
548 r = manager_setup_cgroup(m);
552 r = manager_setup_notify(m);
556 r = manager_setup_time_change(m);
560 /* Try to connect to the busses, if possible. */
561 if ((running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS")) ||
562 running_as == SYSTEMD_SYSTEM) {
563 r = bus_init(m, reexecuting || running_as != SYSTEMD_SYSTEM);
567 log_debug("Skipping DBus session bus connection attempt - no DBUS_SESSION_BUS_ADDRESS set...");
569 m->taint_usr = dir_is_empty("/usr") > 0;
579 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
585 while ((u = m->cleanup_queue)) {
586 assert(u->in_cleanup_queue);
596 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
597 GC_OFFSET_UNSURE, /* No clue */
598 GC_OFFSET_GOOD, /* We still need this unit */
599 GC_OFFSET_BAD, /* We don't need this unit anymore */
603 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
610 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
611 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
612 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
615 if (u->in_cleanup_queue)
618 if (unit_check_gc(u))
621 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
625 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
626 unit_gc_sweep(other, gc_marker);
628 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
631 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
638 /* We were unable to find anything out about this entry, so
639 * let's investigate it later */
640 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
641 unit_add_to_gc_queue(u);
645 /* We definitely know that this one is not useful anymore, so
646 * let's mark it for deletion */
647 u->gc_marker = gc_marker + GC_OFFSET_BAD;
648 unit_add_to_cleanup_queue(u);
652 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
655 static unsigned manager_dispatch_gc_queue(Manager *m) {
662 /* log_debug("Running GC..."); */
664 m->gc_marker += _GC_OFFSET_MAX;
665 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
668 gc_marker = m->gc_marker;
670 while ((u = m->gc_queue)) {
671 assert(u->in_gc_queue);
673 unit_gc_sweep(u, gc_marker);
675 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
676 u->in_gc_queue = false;
680 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
681 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
682 log_debug_unit(u->id, "Collecting %s", u->id);
683 u->gc_marker = gc_marker + GC_OFFSET_BAD;
684 unit_add_to_cleanup_queue(u);
688 m->n_in_gc_queue = 0;
693 static void manager_clear_jobs_and_units(Manager *m) {
698 while ((u = hashmap_first(m->units)))
701 manager_dispatch_cleanup_queue(m);
703 assert(!m->load_queue);
704 assert(!m->run_queue);
705 assert(!m->dbus_unit_queue);
706 assert(!m->dbus_job_queue);
707 assert(!m->cleanup_queue);
708 assert(!m->gc_queue);
710 assert(hashmap_isempty(m->jobs));
711 assert(hashmap_isempty(m->units));
714 m->n_running_jobs = 0;
717 static void close_idle_pipe(Manager *m) {
718 close_pipe(m->idle_pipe);
719 close_pipe(m->idle_pipe + 2);
722 void manager_free(Manager *m) {
728 manager_clear_jobs_and_units(m);
730 for (c = 0; c < _UNIT_TYPE_MAX; c++)
731 if (unit_vtable[c]->shutdown)
732 unit_vtable[c]->shutdown(m);
734 /* If we reexecute ourselves, we keep the root cgroup
736 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
738 manager_undo_generators(m);
742 hashmap_free(m->units);
743 hashmap_free(m->jobs);
744 hashmap_free(m->watch_pids);
745 hashmap_free(m->watch_bus);
747 if (m->epoll_fd >= 0)
748 close_nointr_nofail(m->epoll_fd);
749 if (m->signal_watch.fd >= 0)
750 close_nointr_nofail(m->signal_watch.fd);
751 if (m->notify_watch.fd >= 0)
752 close_nointr_nofail(m->notify_watch.fd);
753 if (m->time_change_watch.fd >= 0)
754 close_nointr_nofail(m->time_change_watch.fd);
755 if (m->jobs_in_progress_watch.fd >= 0)
756 close_nointr_nofail(m->jobs_in_progress_watch.fd);
758 free(m->notify_socket);
760 lookup_paths_free(&m->lookup_paths);
761 strv_free(m->environment);
763 hashmap_free(m->cgroup_unit);
764 set_free_free(m->unit_path_cache);
768 free(m->switch_root);
769 free(m->switch_root_init);
771 for (i = 0; i < RLIMIT_NLIMITS; i++)
777 int manager_enumerate(Manager *m) {
783 /* Let's ask every type to load all units from disk/kernel
784 * that it might know */
785 for (c = 0; c < _UNIT_TYPE_MAX; c++)
786 if (unit_vtable[c]->enumerate)
787 if ((q = unit_vtable[c]->enumerate(m)) < 0)
790 manager_dispatch_load_queue(m);
794 int manager_coldplug(Manager *m) {
802 /* Then, let's set up their initial state. */
803 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
809 if ((q = unit_coldplug(u)) < 0)
816 static void manager_build_unit_path_cache(Manager *m) {
818 _cleanup_free_ DIR *d = NULL;
823 set_free_free(m->unit_path_cache);
825 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
826 if (!m->unit_path_cache) {
827 log_error("Failed to allocate unit path cache.");
831 /* This simply builds a list of files we know exist, so that
832 * we don't always have to go to disk */
834 STRV_FOREACH(i, m->lookup_paths.unit_path) {
840 log_error("Failed to open directory %s: %m", *i);
844 while ((de = readdir(d))) {
847 if (ignore_file(de->d_name))
850 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
856 r = set_consume(m->unit_path_cache, p);
868 log_error("Failed to build unit path cache: %s", strerror(-r));
870 set_free_free(m->unit_path_cache);
871 m->unit_path_cache = NULL;
874 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
879 dual_timestamp_get(&m->generators_start_timestamp);
880 manager_run_generators(m);
881 dual_timestamp_get(&m->generators_finish_timestamp);
883 r = lookup_paths_init(
884 &m->lookup_paths, m->running_as, true,
885 m->generator_unit_path,
886 m->generator_unit_path_early,
887 m->generator_unit_path_late);
891 manager_build_unit_path_cache(m);
893 /* If we will deserialize make sure that during enumeration
894 * this is already known, so we increase the counter here
899 /* First, enumerate what we can from all config files */
900 dual_timestamp_get(&m->unitsload_start_timestamp);
901 r = manager_enumerate(m);
902 dual_timestamp_get(&m->unitsload_finish_timestamp);
904 /* Second, deserialize if there is something to deserialize */
906 q = manager_deserialize(m, serialization, fds);
911 /* Any fds left? Find some unit which wants them. This is
912 * useful to allow container managers to pass some file
913 * descriptors to us pre-initialized. This enables
914 * socket-based activation of entire containers. */
915 if (fdset_size(fds) > 0) {
916 q = manager_distribute_fds(m, fds);
921 /* Third, fire things up! */
922 q = manager_coldplug(m);
927 assert(m->n_reloading > 0);
930 /* Let's wait for the UnitNew/JobNew messages being
931 * sent, before we notify that the reload is
933 m->send_reloading_done = true;
939 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
944 assert(type < _JOB_TYPE_MAX);
946 assert(mode < _JOB_MODE_MAX);
948 if (mode == JOB_ISOLATE && type != JOB_START) {
949 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
953 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
954 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
958 log_debug_unit(unit->id,
959 "Trying to enqueue job %s/%s/%s", unit->id,
960 job_type_to_string(type), job_mode_to_string(mode));
962 job_type_collapse(&type, unit);
964 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
968 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
969 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
970 mode == JOB_IGNORE_DEPENDENCIES, e);
974 if (mode == JOB_ISOLATE) {
975 r = transaction_add_isolate_jobs(tr, m);
980 r = transaction_activate(tr, m, mode, e);
984 log_debug_unit(unit->id,
985 "Enqueued job %s/%s as %u", unit->id,
986 job_type_to_string(type), (unsigned) tr->anchor_job->id);
989 *_ret = tr->anchor_job;
991 transaction_free(tr);
995 transaction_abort(tr);
996 transaction_free(tr);
1000 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
1005 assert(type < _JOB_TYPE_MAX);
1007 assert(mode < _JOB_MODE_MAX);
1009 r = manager_load_unit(m, name, NULL, NULL, &unit);
1013 return manager_add_job(m, type, unit, mode, override, e, _ret);
1016 Job *manager_get_job(Manager *m, uint32_t id) {
1019 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1022 Unit *manager_get_unit(Manager *m, const char *name) {
1026 return hashmap_get(m->units, name);
1029 unsigned manager_dispatch_load_queue(Manager *m) {
1035 /* Make sure we are not run recursively */
1036 if (m->dispatching_load_queue)
1039 m->dispatching_load_queue = true;
1041 /* Dispatches the load queue. Takes a unit from the queue and
1042 * tries to load its data until the queue is empty */
1044 while ((u = m->load_queue)) {
1045 assert(u->in_load_queue);
1051 m->dispatching_load_queue = false;
1055 int manager_load_unit_prepare(
1067 assert(name || path);
1069 /* This will prepare the unit for loading, but not actually
1070 * load anything from disk. */
1072 if (path && !is_path(path)) {
1073 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1078 name = path_get_file_name(path);
1080 t = unit_name_to_type(name);
1082 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
1083 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1087 ret = manager_get_unit(m, name);
1093 ret = unit_new(m, unit_vtable[t]->object_size);
1098 ret->fragment_path = strdup(path);
1099 if (!ret->fragment_path) {
1105 r = unit_add_name(ret, name);
1111 unit_add_to_load_queue(ret);
1112 unit_add_to_dbus_queue(ret);
1113 unit_add_to_gc_queue(ret);
1121 int manager_load_unit(
1132 /* This will load the service information files, but not actually
1133 * start any services or anything. */
1135 r = manager_load_unit_prepare(m, name, path, e, _ret);
1139 manager_dispatch_load_queue(m);
1142 *_ret = unit_follow_merge(*_ret);
1147 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1154 HASHMAP_FOREACH(j, s->jobs, i)
1155 job_dump(j, f, prefix);
1158 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1166 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1168 unit_dump(u, f, prefix);
1171 void manager_clear_jobs(Manager *m) {
1176 while ((j = hashmap_first(m->jobs)))
1177 /* No need to recurse. We're cancelling all jobs. */
1178 job_finish_and_invalidate(j, JOB_CANCELED, false);
1181 unsigned manager_dispatch_run_queue(Manager *m) {
1185 if (m->dispatching_run_queue)
1188 m->dispatching_run_queue = true;
1190 while ((j = m->run_queue)) {
1191 assert(j->installed);
1192 assert(j->in_run_queue);
1194 job_run_and_invalidate(j);
1198 m->dispatching_run_queue = false;
1200 if (m->n_running_jobs > 0)
1201 manager_watch_jobs_in_progress(m);
1203 if (m->n_on_console > 0)
1204 manager_watch_idle_pipe(m);
1209 unsigned manager_dispatch_dbus_queue(Manager *m) {
1216 if (m->dispatching_dbus_queue)
1219 m->dispatching_dbus_queue = true;
1221 while ((u = m->dbus_unit_queue)) {
1222 assert(u->in_dbus_queue);
1224 bus_unit_send_change_signal(u);
1228 while ((j = m->dbus_job_queue)) {
1229 assert(j->in_dbus_queue);
1231 bus_job_send_change_signal(j);
1235 m->dispatching_dbus_queue = false;
1237 if (m->send_reloading_done) {
1238 m->send_reloading_done = false;
1240 bus_broadcast_reloading(m, false);
1246 static int manager_process_notify_fd(Manager *m) {
1253 struct iovec iovec = {
1255 .iov_len = sizeof(buf)-1,
1259 struct cmsghdr cmsghdr;
1260 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1263 struct msghdr msghdr = {
1266 .msg_control = &control,
1267 .msg_controllen = sizeof(control),
1269 struct ucred *ucred;
1271 _cleanup_strv_free_ char **tags = NULL;
1273 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1278 if (errno == EAGAIN || errno == EINTR)
1284 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1285 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1286 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1287 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1288 log_warning("Received notify message without credentials. Ignoring.");
1292 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1294 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1296 u = manager_get_unit_by_pid(m, ucred->pid);
1298 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1303 assert((size_t) n < sizeof(buf));
1305 tags = strv_split(buf, "\n\r");
1309 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1311 if (UNIT_VTABLE(u)->notify_message)
1312 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1318 static int manager_dispatch_sigchld(Manager *m) {
1326 /* First we call waitd() for a PID and do not reap the
1327 * zombie. That way we can still access /proc/$PID for
1328 * it while it is a zombie. */
1329 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1331 if (errno == ECHILD)
1343 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1344 _cleanup_free_ char *name = NULL;
1346 get_process_comm(si.si_pid, &name);
1347 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1350 /* Let's flush any message the dying child might still
1351 * have queued for us. This ensures that the process
1352 * still exists in /proc so that we can figure out
1353 * which cgroup and hence unit it belongs to. */
1354 r = manager_process_notify_fd(m);
1358 /* And now figure out the unit this belongs to */
1359 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1361 u = manager_get_unit_by_pid(m, si.si_pid);
1363 /* And now, we actually reap the zombie. */
1364 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1371 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1374 log_debug("Child %lu died (code=%s, status=%i/%s)",
1375 (long unsigned) si.si_pid,
1376 sigchld_code_to_string(si.si_code),
1378 strna(si.si_code == CLD_EXITED
1379 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1380 : signal_to_string(si.si_status)));
1385 log_debug_unit(u->id,
1386 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1388 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1389 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1395 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1399 dbus_error_init(&error);
1401 log_debug_unit(name, "Activating special unit %s", name);
1403 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1405 log_error_unit(name,
1406 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1408 dbus_error_free(&error);
1413 static int manager_process_signal_fd(Manager *m) {
1415 struct signalfd_siginfo sfsi;
1416 bool sigchld = false;
1421 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1422 if (n != sizeof(sfsi)) {
1427 if (errno == EINTR || errno == EAGAIN)
1433 if (sfsi.ssi_pid > 0) {
1436 get_process_comm(sfsi.ssi_pid, &p);
1438 log_debug("Received SIG%s from PID %lu (%s).",
1439 signal_to_string(sfsi.ssi_signo),
1440 (unsigned long) sfsi.ssi_pid, strna(p));
1443 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1445 switch (sfsi.ssi_signo) {
1452 if (m->running_as == SYSTEMD_SYSTEM) {
1453 /* This is for compatibility with the
1454 * original sysvinit */
1455 m->exit_code = MANAGER_REEXECUTE;
1462 if (m->running_as == SYSTEMD_SYSTEM) {
1463 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1467 /* Run the exit target if there is one, if not, just exit. */
1468 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1469 m->exit_code = MANAGER_EXIT;
1476 if (m->running_as == SYSTEMD_SYSTEM)
1477 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1479 /* This is a nop on non-init */
1483 if (m->running_as == SYSTEMD_SYSTEM)
1484 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1486 /* This is a nop on non-init */
1492 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1494 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1495 log_info("Trying to reconnect to bus...");
1499 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1500 log_info("Loading D-Bus service...");
1501 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1512 if (!(f = open_memstream(&dump, &size))) {
1513 log_warning("Failed to allocate memory stream.");
1517 manager_dump_units(m, f, "\t");
1518 manager_dump_jobs(m, f, "\t");
1523 log_warning("Failed to write status stream");
1528 log_dump(LOG_INFO, dump);
1535 m->exit_code = MANAGER_RELOAD;
1540 /* Starting SIGRTMIN+0 */
1541 static const char * const target_table[] = {
1542 [0] = SPECIAL_DEFAULT_TARGET,
1543 [1] = SPECIAL_RESCUE_TARGET,
1544 [2] = SPECIAL_EMERGENCY_TARGET,
1545 [3] = SPECIAL_HALT_TARGET,
1546 [4] = SPECIAL_POWEROFF_TARGET,
1547 [5] = SPECIAL_REBOOT_TARGET,
1548 [6] = SPECIAL_KEXEC_TARGET
1551 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1552 static const ManagerExitCode code_table[] = {
1554 [1] = MANAGER_POWEROFF,
1555 [2] = MANAGER_REBOOT,
1559 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1560 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1561 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1562 manager_start_target(m, target_table[idx],
1563 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1567 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1568 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1569 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1573 switch (sfsi.ssi_signo - SIGRTMIN) {
1576 log_debug("Enabling showing of status.");
1577 manager_set_show_status(m, true);
1581 log_debug("Disabling showing of status.");
1582 manager_set_show_status(m, false);
1586 log_set_max_level(LOG_DEBUG);
1587 log_notice("Setting log level to debug.");
1591 log_set_max_level(LOG_INFO);
1592 log_notice("Setting log level to info.");
1596 if (m->running_as == SYSTEMD_USER) {
1597 m->exit_code = MANAGER_EXIT;
1601 /* This is a nop on init */
1605 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1606 log_notice("Setting log target to journal-or-kmsg.");
1610 log_set_target(LOG_TARGET_CONSOLE);
1611 log_notice("Setting log target to console.");
1615 log_set_target(LOG_TARGET_KMSG);
1616 log_notice("Setting log target to kmsg.");
1620 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1621 log_notice("Setting log target to syslog-or-kmsg.");
1625 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1632 return manager_dispatch_sigchld(m);
1637 static int process_event(Manager *m, struct epoll_event *ev) {
1644 assert_se(w = ev->data.ptr);
1646 if (w->type == WATCH_INVALID)
1653 /* An incoming signal? */
1654 if (ev->events != EPOLLIN)
1657 if ((r = manager_process_signal_fd(m)) < 0)
1664 /* An incoming daemon notification event? */
1665 if (ev->events != EPOLLIN)
1668 if ((r = manager_process_notify_fd(m)) < 0)
1675 /* Some fd event, to be dispatched to the units */
1676 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1679 case WATCH_UNIT_TIMER:
1680 case WATCH_JOB_TIMER: {
1684 /* Some timer event, to be dispatched to the units */
1685 k = read(w->fd, &v, sizeof(v));
1686 if (k != sizeof(v)) {
1688 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1691 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1692 return k < 0 ? -errno : -EIO;
1695 if (w->type == WATCH_UNIT_TIMER)
1696 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1698 job_timer_event(w->data.job, v, w);
1703 /* Some mount table change, intended for the mount subsystem */
1704 mount_fd_event(m, ev->events);
1708 /* Some swap table change, intended for the swap subsystem */
1709 swap_fd_event(m, ev->events);
1713 /* Some notification from udev, intended for the device subsystem */
1714 device_fd_event(m, ev->events);
1717 case WATCH_DBUS_WATCH:
1718 bus_watch_event(m, w, ev->events);
1721 case WATCH_DBUS_TIMEOUT:
1722 bus_timeout_event(m, w, ev->events);
1725 case WATCH_TIME_CHANGE: {
1729 log_struct(LOG_INFO,
1730 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1731 "MESSAGE=Time has been changed",
1734 /* Restart the watch */
1735 epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->time_change_watch.fd,
1737 close_nointr_nofail(m->time_change_watch.fd);
1738 watch_init(&m->time_change_watch);
1739 manager_setup_time_change(m);
1741 HASHMAP_FOREACH(u, m->units, i) {
1742 if (UNIT_VTABLE(u)->time_change)
1743 UNIT_VTABLE(u)->time_change(u);
1749 case WATCH_JOBS_IN_PROGRESS: {
1752 /* not interested in the data */
1753 read(w->fd, &v, sizeof(v));
1755 manager_print_jobs_in_progress(m);
1759 case WATCH_IDLE_PIPE: {
1760 m->no_console_output = true;
1762 manager_unwatch_idle_pipe(m);
1768 log_error("event type=%i", w->type);
1769 assert_not_reached("Unknown epoll event type.");
1775 int manager_loop(Manager *m) {
1778 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1781 m->exit_code = MANAGER_RUNNING;
1783 /* Release the path cache */
1784 set_free_free(m->unit_path_cache);
1785 m->unit_path_cache = NULL;
1787 manager_check_finished(m);
1789 /* There might still be some zombies hanging around from
1790 * before we were exec()'ed. Leat's reap them */
1791 r = manager_dispatch_sigchld(m);
1795 while (m->exit_code == MANAGER_RUNNING) {
1796 struct epoll_event event;
1800 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1803 if (!ratelimit_test(&rl)) {
1804 /* Yay, something is going seriously wrong, pause a little */
1805 log_warning("Looping too fast. Throttling execution a little.");
1810 if (manager_dispatch_load_queue(m) > 0)
1813 if (manager_dispatch_gc_queue(m) > 0)
1816 if (manager_dispatch_cleanup_queue(m) > 0)
1819 if (manager_dispatch_cgroup_queue(m) > 0)
1822 if (manager_dispatch_run_queue(m) > 0)
1825 if (bus_dispatch(m) > 0)
1828 if (manager_dispatch_dbus_queue(m) > 0)
1831 if (swap_dispatch_reload(m) > 0)
1834 /* Sleep for half the watchdog time */
1835 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1836 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1842 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1854 r = process_event(m, &event);
1859 return m->exit_code;
1862 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1863 _cleanup_free_ char *n = NULL;
1871 r = unit_name_from_dbus_path(s, &n);
1875 r = manager_load_unit(m, n, NULL, e, &u);
1884 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1893 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1896 r = safe_atou(s + 30, &id);
1900 j = manager_get_job(m, id);
1909 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1915 audit_fd = get_audit_fd();
1919 /* Don't generate audit events if the service was already
1920 * started and we're just deserializing */
1921 if (m->n_reloading > 0)
1924 if (m->running_as != SYSTEMD_SYSTEM)
1927 if (u->type != UNIT_SERVICE)
1930 p = unit_name_to_prefix_and_instance(u->id);
1932 log_error_unit(u->id,
1933 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1937 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1938 if (errno == EPERM) {
1939 /* We aren't allowed to send audit messages?
1940 * Then let's not retry again. */
1943 log_warning("Failed to send audit message: %m");
1951 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1953 union sockaddr_union sa;
1955 char *message = NULL;
1957 /* Don't generate plymouth events if the service was already
1958 * started and we're just deserializing */
1959 if (m->n_reloading > 0)
1962 if (m->running_as != SYSTEMD_SYSTEM)
1965 if (u->type != UNIT_SERVICE &&
1966 u->type != UNIT_MOUNT &&
1967 u->type != UNIT_SWAP)
1970 /* We set SOCK_NONBLOCK here so that we rather drop the
1971 * message then wait for plymouth */
1972 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1974 log_error("socket() failed: %m");
1979 sa.sa.sa_family = AF_UNIX;
1980 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1981 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1983 if (errno != EPIPE &&
1986 errno != ECONNREFUSED &&
1987 errno != ECONNRESET &&
1988 errno != ECONNABORTED)
1989 log_error("connect() failed: %m");
1994 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2000 if (write(fd, message, n + 1) != n + 1) {
2002 if (errno != EPIPE &&
2005 errno != ECONNREFUSED &&
2006 errno != ECONNRESET &&
2007 errno != ECONNABORTED)
2008 log_error("Failed to write Plymouth message: %m");
2015 close_nointr_nofail(fd);
2020 void manager_dispatch_bus_name_owner_changed(
2023 const char* old_owner,
2024 const char *new_owner) {
2031 if (!(u = hashmap_get(m->watch_bus, name)))
2034 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2037 void manager_dispatch_bus_query_pid_done(
2048 if (!(u = hashmap_get(m->watch_bus, name)))
2051 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
2054 int manager_open_serialization(Manager *m, FILE **_f) {
2061 if (m->running_as == SYSTEMD_SYSTEM)
2062 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
2064 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
2069 RUN_WITH_UMASK(0077) {
2070 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2080 log_debug("Serializing state to %s", path);
2083 f = fdopen(fd, "w+");
2092 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2105 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2106 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2107 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2108 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2110 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2111 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2112 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2113 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2116 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2117 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2120 if (!switching_root) {
2121 STRV_FOREACH(e, m->environment) {
2122 _cleanup_free_ char *ce;
2126 fprintf(f, "env=%s\n", *e);
2130 bus_serialize(m, f);
2134 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2138 if (!unit_can_serialize(u))
2145 r = unit_serialize(u, f, fds, !switching_root);
2152 assert(m->n_reloading > 0);
2158 r = bus_fdset_add_all(m, fds);
2165 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2171 log_debug("Deserializing state...");
2176 char line[LINE_MAX], *l;
2178 if (!fgets(line, sizeof(line), f)) {
2193 if (startswith(l, "current-job-id=")) {
2196 if (safe_atou32(l+15, &id) < 0)
2197 log_debug("Failed to parse current job id value %s", l+15);
2199 m->current_job_id = MAX(m->current_job_id, id);
2200 } else if (startswith(l, "n-installed-jobs=")) {
2203 if (safe_atou32(l+17, &n) < 0)
2204 log_debug("Failed to parse installed jobs counter %s", l+17);
2206 m->n_installed_jobs += n;
2207 } else if (startswith(l, "n-failed-jobs=")) {
2210 if (safe_atou32(l+14, &n) < 0)
2211 log_debug("Failed to parse failed jobs counter %s", l+14);
2213 m->n_failed_jobs += n;
2214 } else if (startswith(l, "taint-usr=")) {
2217 if ((b = parse_boolean(l+10)) < 0)
2218 log_debug("Failed to parse taint /usr flag %s", l+10);
2220 m->taint_usr = m->taint_usr || b;
2221 } else if (startswith(l, "firmware-timestamp="))
2222 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2223 else if (startswith(l, "loader-timestamp="))
2224 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2225 else if (startswith(l, "kernel-timestamp="))
2226 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2227 else if (startswith(l, "initrd-timestamp="))
2228 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2229 else if (startswith(l, "userspace-timestamp="))
2230 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2231 else if (startswith(l, "finish-timestamp="))
2232 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2233 else if (startswith(l, "env=")) {
2234 _cleanup_free_ char *uce = NULL;
2237 uce = cunescape(l+4);
2243 e = strv_env_set(m->environment, uce);
2249 strv_free(m->environment);
2251 } else if (bus_deserialize_item(m, l) == 0)
2252 log_debug("Unknown serialization item '%s'", l);
2257 char name[UNIT_NAME_MAX+2];
2260 if (!fgets(name, sizeof(name), f)) {
2271 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2275 r = unit_deserialize(u, f, fds);
2286 assert(m->n_reloading > 0);
2292 int manager_distribute_fds(Manager *m, FDSet *fds) {
2299 HASHMAP_FOREACH(u, m->units, i) {
2301 if (fdset_size(fds) <= 0)
2304 if (UNIT_VTABLE(u)->distribute_fds) {
2305 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2314 int manager_reload(Manager *m) {
2321 r = manager_open_serialization(m, &f);
2326 bus_broadcast_reloading(m, true);
2335 r = manager_serialize(m, f, fds, false);
2341 if (fseeko(f, 0, SEEK_SET) < 0) {
2347 /* From here on there is no way back. */
2348 manager_clear_jobs_and_units(m);
2349 manager_undo_generators(m);
2350 lookup_paths_free(&m->lookup_paths);
2352 /* Find new unit paths */
2353 manager_run_generators(m);
2355 q = lookup_paths_init(
2356 &m->lookup_paths, m->running_as, true,
2357 m->generator_unit_path,
2358 m->generator_unit_path_early,
2359 m->generator_unit_path_late);
2363 manager_build_unit_path_cache(m);
2365 /* First, enumerate what we can from all config files */
2366 q = manager_enumerate(m);
2370 /* Second, deserialize our stored data */
2371 q = manager_deserialize(m, f, fds);
2378 /* Third, fire things up! */
2379 q = manager_coldplug(m);
2383 assert(m->n_reloading > 0);
2386 m->send_reloading_done = true;
2398 static bool manager_is_booting_or_shutting_down(Manager *m) {
2403 /* Is the initial job still around? */
2404 if (manager_get_job(m, m->default_unit_job_id))
2407 /* Is there a job for the shutdown target? */
2408 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2415 bool manager_is_reloading_or_reexecuting(Manager *m) {
2418 return m->n_reloading != 0;
2421 void manager_reset_failed(Manager *m) {
2427 HASHMAP_FOREACH(u, m->units, i)
2428 unit_reset_failed(u);
2431 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2437 /* Returns true if the unit is inactive or going down */
2438 u = manager_get_unit(m, name);
2442 return unit_inactive_or_pending(u);
2445 void manager_check_finished(Manager *m) {
2446 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2447 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2451 if (m->n_running_jobs == 0)
2452 manager_unwatch_jobs_in_progress(m);
2454 if (hashmap_size(m->jobs) > 0) {
2455 manager_jobs_in_progress_mod_timer(m);
2459 /* Notify Type=idle units that we are done now */
2460 manager_unwatch_idle_pipe(m);
2463 /* Turn off confirm spawn now */
2464 m->confirm_spawn = false;
2466 if (dual_timestamp_is_set(&m->finish_timestamp))
2469 dual_timestamp_get(&m->finish_timestamp);
2471 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2473 /* Note that m->kernel_usec.monotonic is always at 0,
2474 * and m->firmware_usec.monotonic and
2475 * m->loader_usec.monotonic should be considered
2476 * negative values. */
2478 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2479 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2480 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2481 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2483 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2485 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2486 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2488 if (!log_on_console())
2489 log_struct(LOG_INFO,
2490 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2491 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2492 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2493 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2494 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2495 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2496 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2497 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2498 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2501 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2504 if (!log_on_console())
2505 log_struct(LOG_INFO,
2506 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2507 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2508 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2509 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2510 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2511 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2512 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2516 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2517 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2519 if (!log_on_console())
2520 log_struct(LOG_INFO,
2521 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2522 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2523 "MESSAGE=Startup finished in %s.",
2524 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2528 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2531 "READY=1\nSTATUS=Startup finished in %s.",
2532 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2535 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2546 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2548 p = strappend("/run/systemd/", name);
2552 r = mkdir_p_label(p, 0755);
2554 log_error("Failed to create generator directory %s: %s",
2560 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2565 log_error("Failed to create generator directory %s: %m",
2576 static void trim_generator_dir(Manager *m, char **generator) {
2583 if (rmdir(*generator) >= 0) {
2591 void manager_run_generators(Manager *m) {
2593 const char *generator_path;
2594 const char *argv[5];
2599 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2600 d = opendir(generator_path);
2602 if (errno == ENOENT)
2605 log_error("Failed to enumerate generator directory %s: %m",
2610 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2614 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2618 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2622 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2623 argv[1] = m->generator_unit_path;
2624 argv[2] = m->generator_unit_path_early;
2625 argv[3] = m->generator_unit_path_late;
2628 RUN_WITH_UMASK(0022) {
2629 execute_directory(generator_path, d, (char**) argv);
2632 trim_generator_dir(m, &m->generator_unit_path);
2633 trim_generator_dir(m, &m->generator_unit_path_early);
2634 trim_generator_dir(m, &m->generator_unit_path_late);
2641 static void remove_generator_dir(Manager *m, char **generator) {
2648 strv_remove(m->lookup_paths.unit_path, *generator);
2649 rm_rf(*generator, false, true, false);
2655 void manager_undo_generators(Manager *m) {
2658 remove_generator_dir(m, &m->generator_unit_path);
2659 remove_generator_dir(m, &m->generator_unit_path_early);
2660 remove_generator_dir(m, &m->generator_unit_path_late);
2663 int manager_environment_add(Manager *m, char **environment) {
2667 e = strv_env_merge(2, m->environment, environment);
2670 strv_free(m->environment);
2675 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2680 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2681 if (!default_rlimit[i])
2684 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2692 void manager_recheck_journal(Manager *m) {
2697 if (m->running_as != SYSTEMD_SYSTEM)
2700 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2701 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2702 log_close_journal();
2706 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2707 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2708 log_close_journal();
2712 /* Hmm, OK, so the socket is fully up and the service is up
2713 * too, then let's make use of the thing. */
2717 void manager_set_show_status(Manager *m, bool b) {
2720 if (m->running_as != SYSTEMD_SYSTEM)
2726 touch("/run/systemd/show-status");
2728 unlink("/run/systemd/show-status");
2731 static bool manager_get_show_status(Manager *m) {
2734 if (m->running_as != SYSTEMD_SYSTEM)
2737 if (m->no_console_output)
2743 /* If Plymouth is running make sure we show the status, so
2744 * that there's something nice to see when people press Esc */
2746 return plymouth_running();
2749 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2752 if (!manager_get_show_status(m))
2755 /* XXX We should totally drop the check for ephemeral here
2756 * and thus effectively make 'Type=idle' pointless. */
2757 if (ephemeral && m->n_on_console > 0)
2760 if (!manager_is_booting_or_shutting_down(m))
2763 va_start(ap, format);
2764 status_vprintf(status, true, ephemeral, format, ap);
2768 void watch_init(Watch *w) {
2771 w->type = WATCH_INVALID;