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"
73 #include "boot-timestamps.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 strcpy(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);
262 cylon_pos = m->jobs_in_progress_iteration % 14;
264 cylon_pos = 14 - cylon_pos;
265 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
267 if (m->n_running_jobs > 1)
268 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
271 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
272 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
275 m->jobs_in_progress_iteration++;
278 static int manager_watch_idle_pipe(Manager *m) {
279 struct epoll_event ev = {
281 .data.ptr = &m->idle_pipe_watch,
285 if (m->idle_pipe_watch.type != WATCH_INVALID)
288 if (m->idle_pipe[2] < 0)
291 m->idle_pipe_watch.type = WATCH_IDLE_PIPE;
292 m->idle_pipe_watch.fd = m->idle_pipe[2];
293 if (m->idle_pipe_watch.fd < 0) {
294 log_error("Failed to create timerfd: %m");
299 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->idle_pipe_watch.fd, &ev) < 0) {
300 log_error("Failed to add idle_pipe fd to epoll: %m");
305 log_debug("Set up idle_pipe watch.");
310 if (m->idle_pipe_watch.fd >= 0)
311 close_nointr_nofail(m->idle_pipe_watch.fd);
312 watch_init(&m->idle_pipe_watch);
316 static void manager_unwatch_idle_pipe(Manager *m) {
317 if (m->idle_pipe_watch.type != WATCH_IDLE_PIPE)
320 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->idle_pipe_watch.fd, NULL) >= 0);
321 watch_init(&m->idle_pipe_watch);
323 log_debug("Closed idle_pipe watch.");
326 static int manager_setup_time_change(Manager *m) {
327 struct epoll_event ev = {
329 .data.ptr = &m->time_change_watch,
332 /* We only care for the cancellation event, hence we set the
333 * timeout to the latest possible value. */
334 struct itimerspec its = {
335 .it_value.tv_sec = TIME_T_MAX,
337 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
339 assert(m->time_change_watch.type == WATCH_INVALID);
341 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
342 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
344 m->time_change_watch.type = WATCH_TIME_CHANGE;
345 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
346 if (m->time_change_watch.fd < 0) {
347 log_error("Failed to create timerfd: %m");
351 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
352 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
353 close_nointr_nofail(m->time_change_watch.fd);
354 watch_init(&m->time_change_watch);
358 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
359 log_error("Failed to add timer change fd to epoll: %m");
363 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
368 static int enable_special_signals(Manager *m) {
373 /* Enable that we get SIGINT on control-alt-del. In containers
374 * this will fail with EPERM (older) or EINVAL (newer), so
376 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
377 log_warning("Failed to enable ctrl-alt-del handling: %m");
379 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
381 /* Support systems without virtual console */
383 log_warning("Failed to open /dev/tty0: %m");
385 /* Enable that we get SIGWINCH on kbrequest */
386 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
387 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
389 close_nointr_nofail(fd);
395 static int manager_setup_signals(Manager *m) {
397 struct epoll_event ev = {
399 .data.ptr = &m->signal_watch,
401 struct sigaction sa = {
402 .sa_handler = SIG_DFL,
403 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
408 /* We are not interested in SIGSTOP and friends. */
409 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
411 assert_se(sigemptyset(&mask) == 0);
413 sigset_add_many(&mask,
414 SIGCHLD, /* Child died */
415 SIGTERM, /* Reexecute daemon */
416 SIGHUP, /* Reload configuration */
417 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
418 SIGUSR2, /* systemd: dump status */
419 SIGINT, /* Kernel sends us this on control-alt-del */
420 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
421 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
422 SIGRTMIN+0, /* systemd: start default.target */
423 SIGRTMIN+1, /* systemd: isolate rescue.target */
424 SIGRTMIN+2, /* systemd: isolate emergency.target */
425 SIGRTMIN+3, /* systemd: start halt.target */
426 SIGRTMIN+4, /* systemd: start poweroff.target */
427 SIGRTMIN+5, /* systemd: start reboot.target */
428 SIGRTMIN+6, /* systemd: start kexec.target */
429 SIGRTMIN+13, /* systemd: Immediate halt */
430 SIGRTMIN+14, /* systemd: Immediate poweroff */
431 SIGRTMIN+15, /* systemd: Immediate reboot */
432 SIGRTMIN+16, /* systemd: Immediate kexec */
433 SIGRTMIN+20, /* systemd: enable status messages */
434 SIGRTMIN+21, /* systemd: disable status messages */
435 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
436 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
437 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
438 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
439 SIGRTMIN+27, /* systemd: set log target to console */
440 SIGRTMIN+28, /* systemd: set log target to kmsg */
441 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
443 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
445 m->signal_watch.type = WATCH_SIGNAL;
446 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
447 if (m->signal_watch.fd < 0)
450 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
453 if (m->running_as == SYSTEMD_SYSTEM)
454 return enable_special_signals(m);
459 static int manager_default_environment(Manager *m) {
462 if (m->running_as == SYSTEMD_SYSTEM) {
463 /* The system manager always starts with a clean
464 * environment for its children. It does not import
465 * the kernel or the parents exported variables.
467 * The initial passed environ is untouched to keep
468 * /proc/self/environ valid; it is used for tagging
469 * the init process inside containers. */
470 m->environment = strv_new("PATH=" DEFAULT_PATH,
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) {
489 bool try_bus_connect = false;
492 assert(running_as >= 0);
493 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
495 m = new0(Manager, 1);
500 if (detect_container(NULL) <= 0)
501 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
504 m->running_as = running_as;
505 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
506 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
507 m->pin_cgroupfs_fd = -1;
508 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
510 watch_init(&m->signal_watch);
511 watch_init(&m->mount_watch);
512 watch_init(&m->swap_watch);
513 watch_init(&m->udev_watch);
514 watch_init(&m->time_change_watch);
515 watch_init(&m->jobs_in_progress_watch);
517 m->epoll_fd = m->dev_autofs_fd = -1;
518 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
520 r = manager_default_environment(m);
524 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
527 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
530 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
533 m->cgroup_unit = hashmap_new(string_hash_func, string_compare_func);
537 m->watch_bus = hashmap_new(string_hash_func, string_compare_func);
541 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
545 r = manager_setup_signals(m);
549 r = manager_setup_cgroup(m);
553 r = manager_setup_notify(m);
557 r = manager_setup_time_change(m);
561 if (running_as == SYSTEMD_SYSTEM)
562 try_bus_connect = reexecuting;
563 else if (getenv("DBUS_SESSION_BUS_ADDRESS"))
564 try_bus_connect = true;
566 log_debug("Skipping DBus session bus connection attempt - no DBUS_SESSION_BUS_ADDRESS set...");
568 /* Try to connect to the busses, if possible. */
569 r = bus_init(m, try_bus_connect);
573 m->taint_usr = dir_is_empty("/usr") > 0;
583 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
589 while ((u = m->cleanup_queue)) {
590 assert(u->in_cleanup_queue);
600 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
601 GC_OFFSET_UNSURE, /* No clue */
602 GC_OFFSET_GOOD, /* We still need this unit */
603 GC_OFFSET_BAD, /* We don't need this unit anymore */
607 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
614 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
615 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
616 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
619 if (u->in_cleanup_queue)
622 if (unit_check_gc(u))
625 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
629 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
630 unit_gc_sweep(other, gc_marker);
632 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
635 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
642 /* We were unable to find anything out about this entry, so
643 * let's investigate it later */
644 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
645 unit_add_to_gc_queue(u);
649 /* We definitely know that this one is not useful anymore, so
650 * let's mark it for deletion */
651 u->gc_marker = gc_marker + GC_OFFSET_BAD;
652 unit_add_to_cleanup_queue(u);
656 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
659 static unsigned manager_dispatch_gc_queue(Manager *m) {
666 /* log_debug("Running GC..."); */
668 m->gc_marker += _GC_OFFSET_MAX;
669 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
672 gc_marker = m->gc_marker;
674 while ((u = m->gc_queue)) {
675 assert(u->in_gc_queue);
677 unit_gc_sweep(u, gc_marker);
679 LIST_REMOVE(gc_queue, m->gc_queue, u);
680 u->in_gc_queue = false;
684 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
685 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
686 log_debug_unit(u->id, "Collecting %s", u->id);
687 u->gc_marker = gc_marker + GC_OFFSET_BAD;
688 unit_add_to_cleanup_queue(u);
692 m->n_in_gc_queue = 0;
697 static void manager_clear_jobs_and_units(Manager *m) {
702 while ((u = hashmap_first(m->units)))
705 manager_dispatch_cleanup_queue(m);
707 assert(!m->load_queue);
708 assert(!m->run_queue);
709 assert(!m->dbus_unit_queue);
710 assert(!m->dbus_job_queue);
711 assert(!m->cleanup_queue);
712 assert(!m->gc_queue);
714 assert(hashmap_isempty(m->jobs));
715 assert(hashmap_isempty(m->units));
718 m->n_running_jobs = 0;
721 static void close_idle_pipe(Manager *m) {
722 close_pipe(m->idle_pipe);
723 close_pipe(m->idle_pipe + 2);
726 void manager_free(Manager *m) {
732 manager_clear_jobs_and_units(m);
734 for (c = 0; c < _UNIT_TYPE_MAX; c++)
735 if (unit_vtable[c]->shutdown)
736 unit_vtable[c]->shutdown(m);
738 /* If we reexecute ourselves, we keep the root cgroup
740 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
742 manager_undo_generators(m);
746 hashmap_free(m->units);
747 hashmap_free(m->jobs);
748 hashmap_free(m->watch_pids);
749 hashmap_free(m->watch_bus);
751 if (m->epoll_fd >= 0)
752 close_nointr_nofail(m->epoll_fd);
753 if (m->signal_watch.fd >= 0)
754 close_nointr_nofail(m->signal_watch.fd);
755 if (m->notify_watch.fd >= 0)
756 close_nointr_nofail(m->notify_watch.fd);
757 if (m->time_change_watch.fd >= 0)
758 close_nointr_nofail(m->time_change_watch.fd);
759 if (m->jobs_in_progress_watch.fd >= 0)
760 close_nointr_nofail(m->jobs_in_progress_watch.fd);
762 free(m->notify_socket);
764 lookup_paths_free(&m->lookup_paths);
765 strv_free(m->environment);
767 hashmap_free(m->cgroup_unit);
768 set_free_free(m->unit_path_cache);
772 free(m->switch_root);
773 free(m->switch_root_init);
775 for (i = 0; i < RLIMIT_NLIMITS; i++)
778 assert(hashmap_isempty(m->units_requiring_mounts_for));
779 hashmap_free(m->units_requiring_mounts_for);
784 int manager_enumerate(Manager *m) {
790 /* Let's ask every type to load all units from disk/kernel
791 * that it might know */
792 for (c = 0; c < _UNIT_TYPE_MAX; c++)
793 if (unit_vtable[c]->enumerate) {
794 q = unit_vtable[c]->enumerate(m);
799 manager_dispatch_load_queue(m);
803 static int manager_coldplug(Manager *m) {
811 /* Then, let's set up their initial state. */
812 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
818 if ((q = unit_coldplug(u)) < 0)
825 static void manager_build_unit_path_cache(Manager *m) {
827 _cleanup_free_ DIR *d = NULL;
832 set_free_free(m->unit_path_cache);
834 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
835 if (!m->unit_path_cache) {
836 log_error("Failed to allocate unit path cache.");
840 /* This simply builds a list of files we know exist, so that
841 * we don't always have to go to disk */
843 STRV_FOREACH(i, m->lookup_paths.unit_path) {
849 log_error("Failed to open directory %s: %m", *i);
853 while ((de = readdir(d))) {
856 if (ignore_file(de->d_name))
859 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
865 r = set_consume(m->unit_path_cache, p);
877 log_error("Failed to build unit path cache: %s", strerror(-r));
879 set_free_free(m->unit_path_cache);
880 m->unit_path_cache = NULL;
884 static int manager_distribute_fds(Manager *m, FDSet *fds) {
891 HASHMAP_FOREACH(u, m->units, i) {
893 if (fdset_size(fds) <= 0)
896 if (UNIT_VTABLE(u)->distribute_fds) {
897 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
906 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
911 dual_timestamp_get(&m->generators_start_timestamp);
912 manager_run_generators(m);
913 dual_timestamp_get(&m->generators_finish_timestamp);
915 r = lookup_paths_init(
916 &m->lookup_paths, m->running_as, true,
917 m->generator_unit_path,
918 m->generator_unit_path_early,
919 m->generator_unit_path_late);
923 manager_build_unit_path_cache(m);
925 /* If we will deserialize make sure that during enumeration
926 * this is already known, so we increase the counter here
931 /* First, enumerate what we can from all config files */
932 dual_timestamp_get(&m->unitsload_start_timestamp);
933 r = manager_enumerate(m);
934 dual_timestamp_get(&m->unitsload_finish_timestamp);
936 /* Second, deserialize if there is something to deserialize */
938 q = manager_deserialize(m, serialization, fds);
943 /* Any fds left? Find some unit which wants them. This is
944 * useful to allow container managers to pass some file
945 * descriptors to us pre-initialized. This enables
946 * socket-based activation of entire containers. */
947 if (fdset_size(fds) > 0) {
948 q = manager_distribute_fds(m, fds);
953 /* Third, fire things up! */
954 q = manager_coldplug(m);
959 assert(m->n_reloading > 0);
962 /* Let's wait for the UnitNew/JobNew messages being
963 * sent, before we notify that the reload is
965 m->send_reloading_done = true;
971 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
976 assert(type < _JOB_TYPE_MAX);
978 assert(mode < _JOB_MODE_MAX);
980 if (mode == JOB_ISOLATE && type != JOB_START) {
981 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
985 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
986 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
990 log_debug_unit(unit->id,
991 "Trying to enqueue job %s/%s/%s", unit->id,
992 job_type_to_string(type), job_mode_to_string(mode));
994 job_type_collapse(&type, unit);
996 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1000 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1001 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1002 mode == JOB_IGNORE_DEPENDENCIES, e);
1006 if (mode == JOB_ISOLATE) {
1007 r = transaction_add_isolate_jobs(tr, m);
1012 r = transaction_activate(tr, m, mode, e);
1016 log_debug_unit(unit->id,
1017 "Enqueued job %s/%s as %u", unit->id,
1018 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1021 *_ret = tr->anchor_job;
1023 transaction_free(tr);
1027 transaction_abort(tr);
1028 transaction_free(tr);
1032 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
1037 assert(type < _JOB_TYPE_MAX);
1039 assert(mode < _JOB_MODE_MAX);
1041 r = manager_load_unit(m, name, NULL, NULL, &unit);
1045 return manager_add_job(m, type, unit, mode, override, e, _ret);
1048 Job *manager_get_job(Manager *m, uint32_t id) {
1051 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1054 Unit *manager_get_unit(Manager *m, const char *name) {
1058 return hashmap_get(m->units, name);
1061 unsigned manager_dispatch_load_queue(Manager *m) {
1067 /* Make sure we are not run recursively */
1068 if (m->dispatching_load_queue)
1071 m->dispatching_load_queue = true;
1073 /* Dispatches the load queue. Takes a unit from the queue and
1074 * tries to load its data until the queue is empty */
1076 while ((u = m->load_queue)) {
1077 assert(u->in_load_queue);
1083 m->dispatching_load_queue = false;
1087 int manager_load_unit_prepare(
1099 assert(name || path);
1101 /* This will prepare the unit for loading, but not actually
1102 * load anything from disk. */
1104 if (path && !is_path(path)) {
1105 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1110 name = path_get_file_name(path);
1112 t = unit_name_to_type(name);
1114 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
1115 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1119 ret = manager_get_unit(m, name);
1125 ret = unit_new(m, unit_vtable[t]->object_size);
1130 ret->fragment_path = strdup(path);
1131 if (!ret->fragment_path) {
1137 r = unit_add_name(ret, name);
1143 unit_add_to_load_queue(ret);
1144 unit_add_to_dbus_queue(ret);
1145 unit_add_to_gc_queue(ret);
1153 int manager_load_unit(
1164 /* This will load the service information files, but not actually
1165 * start any services or anything. */
1167 r = manager_load_unit_prepare(m, name, path, e, _ret);
1171 manager_dispatch_load_queue(m);
1174 *_ret = unit_follow_merge(*_ret);
1179 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1186 HASHMAP_FOREACH(j, s->jobs, i)
1187 job_dump(j, f, prefix);
1190 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1198 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1200 unit_dump(u, f, prefix);
1203 void manager_clear_jobs(Manager *m) {
1208 while ((j = hashmap_first(m->jobs)))
1209 /* No need to recurse. We're cancelling all jobs. */
1210 job_finish_and_invalidate(j, JOB_CANCELED, false);
1213 static unsigned manager_dispatch_run_queue(Manager *m) {
1217 if (m->dispatching_run_queue)
1220 m->dispatching_run_queue = true;
1222 while ((j = m->run_queue)) {
1223 assert(j->installed);
1224 assert(j->in_run_queue);
1226 job_run_and_invalidate(j);
1230 m->dispatching_run_queue = false;
1232 if (m->n_running_jobs > 0)
1233 manager_watch_jobs_in_progress(m);
1235 if (m->n_on_console > 0)
1236 manager_watch_idle_pipe(m);
1241 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1248 if (m->dispatching_dbus_queue)
1251 m->dispatching_dbus_queue = true;
1253 while ((u = m->dbus_unit_queue)) {
1254 assert(u->in_dbus_queue);
1256 bus_unit_send_change_signal(u);
1260 while ((j = m->dbus_job_queue)) {
1261 assert(j->in_dbus_queue);
1263 bus_job_send_change_signal(j);
1267 m->dispatching_dbus_queue = false;
1269 if (m->send_reloading_done) {
1270 m->send_reloading_done = false;
1272 bus_broadcast_reloading(m, false);
1278 static int manager_process_notify_fd(Manager *m) {
1285 struct iovec iovec = {
1287 .iov_len = sizeof(buf)-1,
1291 struct cmsghdr cmsghdr;
1292 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1295 struct msghdr msghdr = {
1298 .msg_control = &control,
1299 .msg_controllen = sizeof(control),
1301 struct ucred *ucred;
1303 _cleanup_strv_free_ char **tags = NULL;
1305 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1310 if (errno == EAGAIN || errno == EINTR)
1316 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1317 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1318 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1319 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1320 log_warning("Received notify message without credentials. Ignoring.");
1324 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1326 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1328 u = manager_get_unit_by_pid(m, ucred->pid);
1330 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1335 assert((size_t) n < sizeof(buf));
1337 tags = strv_split(buf, "\n\r");
1341 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1343 if (UNIT_VTABLE(u)->notify_message)
1344 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1350 static int manager_dispatch_sigchld(Manager *m) {
1358 /* First we call waitd() for a PID and do not reap the
1359 * zombie. That way we can still access /proc/$PID for
1360 * it while it is a zombie. */
1361 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1363 if (errno == ECHILD)
1375 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1376 _cleanup_free_ char *name = NULL;
1378 get_process_comm(si.si_pid, &name);
1379 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1382 /* Let's flush any message the dying child might still
1383 * have queued for us. This ensures that the process
1384 * still exists in /proc so that we can figure out
1385 * which cgroup and hence unit it belongs to. */
1386 r = manager_process_notify_fd(m);
1390 /* And now figure out the unit this belongs to */
1391 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1393 u = manager_get_unit_by_pid(m, si.si_pid);
1395 /* And now, we actually reap the zombie. */
1396 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1403 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1406 log_debug("Child %lu died (code=%s, status=%i/%s)",
1407 (long unsigned) si.si_pid,
1408 sigchld_code_to_string(si.si_code),
1410 strna(si.si_code == CLD_EXITED
1411 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1412 : signal_to_string(si.si_status)));
1417 log_debug_unit(u->id,
1418 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1420 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1421 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1427 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1431 dbus_error_init(&error);
1433 log_debug_unit(name, "Activating special unit %s", name);
1435 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1437 log_error_unit(name,
1438 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1440 dbus_error_free(&error);
1445 static int manager_process_signal_fd(Manager *m) {
1447 struct signalfd_siginfo sfsi;
1448 bool sigchld = false;
1453 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1454 if (n != sizeof(sfsi)) {
1459 if (errno == EINTR || errno == EAGAIN)
1465 if (sfsi.ssi_pid > 0) {
1468 get_process_comm(sfsi.ssi_pid, &p);
1470 log_debug("Received SIG%s from PID %lu (%s).",
1471 signal_to_string(sfsi.ssi_signo),
1472 (unsigned long) sfsi.ssi_pid, strna(p));
1475 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1477 switch (sfsi.ssi_signo) {
1484 if (m->running_as == SYSTEMD_SYSTEM) {
1485 /* This is for compatibility with the
1486 * original sysvinit */
1487 m->exit_code = MANAGER_REEXECUTE;
1494 if (m->running_as == SYSTEMD_SYSTEM) {
1495 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1499 /* Run the exit target if there is one, if not, just exit. */
1500 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1501 m->exit_code = MANAGER_EXIT;
1508 if (m->running_as == SYSTEMD_SYSTEM)
1509 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1511 /* This is a nop on non-init */
1515 if (m->running_as == SYSTEMD_SYSTEM)
1516 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1518 /* This is a nop on non-init */
1524 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1526 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1527 log_info("Trying to reconnect to bus...");
1531 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1532 log_info("Loading D-Bus service...");
1533 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1544 if (!(f = open_memstream(&dump, &size))) {
1545 log_warning("Failed to allocate memory stream.");
1549 manager_dump_units(m, f, "\t");
1550 manager_dump_jobs(m, f, "\t");
1555 log_warning("Failed to write status stream");
1560 log_dump(LOG_INFO, dump);
1567 m->exit_code = MANAGER_RELOAD;
1572 /* Starting SIGRTMIN+0 */
1573 static const char * const target_table[] = {
1574 [0] = SPECIAL_DEFAULT_TARGET,
1575 [1] = SPECIAL_RESCUE_TARGET,
1576 [2] = SPECIAL_EMERGENCY_TARGET,
1577 [3] = SPECIAL_HALT_TARGET,
1578 [4] = SPECIAL_POWEROFF_TARGET,
1579 [5] = SPECIAL_REBOOT_TARGET,
1580 [6] = SPECIAL_KEXEC_TARGET
1583 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1584 static const ManagerExitCode code_table[] = {
1586 [1] = MANAGER_POWEROFF,
1587 [2] = MANAGER_REBOOT,
1591 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1592 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1593 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1594 manager_start_target(m, target_table[idx],
1595 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1599 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1600 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1601 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1605 switch (sfsi.ssi_signo - SIGRTMIN) {
1608 log_debug("Enabling showing of status.");
1609 manager_set_show_status(m, true);
1613 log_debug("Disabling showing of status.");
1614 manager_set_show_status(m, false);
1618 log_set_max_level(LOG_DEBUG);
1619 log_notice("Setting log level to debug.");
1623 log_set_max_level(LOG_INFO);
1624 log_notice("Setting log level to info.");
1628 if (m->running_as == SYSTEMD_USER) {
1629 m->exit_code = MANAGER_EXIT;
1633 /* This is a nop on init */
1637 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1638 log_notice("Setting log target to journal-or-kmsg.");
1642 log_set_target(LOG_TARGET_CONSOLE);
1643 log_notice("Setting log target to console.");
1647 log_set_target(LOG_TARGET_KMSG);
1648 log_notice("Setting log target to kmsg.");
1652 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1653 log_notice("Setting log target to syslog-or-kmsg.");
1657 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1664 return manager_dispatch_sigchld(m);
1669 static int process_event(Manager *m, struct epoll_event *ev) {
1676 assert_se(w = ev->data.ptr);
1678 if (w->type == WATCH_INVALID)
1685 /* An incoming signal? */
1686 if (ev->events != EPOLLIN)
1689 if ((r = manager_process_signal_fd(m)) < 0)
1696 /* An incoming daemon notification event? */
1697 if (ev->events != EPOLLIN)
1700 if ((r = manager_process_notify_fd(m)) < 0)
1707 /* Some fd event, to be dispatched to the units */
1708 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1711 case WATCH_UNIT_TIMER:
1712 case WATCH_JOB_TIMER: {
1716 /* Some timer event, to be dispatched to the units */
1717 k = read(w->fd, &v, sizeof(v));
1718 if (k != sizeof(v)) {
1720 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1723 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1724 return k < 0 ? -errno : -EIO;
1727 if (w->type == WATCH_UNIT_TIMER)
1728 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1730 job_timer_event(w->data.job, v, w);
1735 /* Some mount table change, intended for the mount subsystem */
1736 mount_fd_event(m, ev->events);
1740 /* Some swap table change, intended for the swap subsystem */
1741 swap_fd_event(m, ev->events);
1745 /* Some notification from udev, intended for the device subsystem */
1746 device_fd_event(m, ev->events);
1749 case WATCH_DBUS_WATCH:
1750 bus_watch_event(m, w, ev->events);
1753 case WATCH_DBUS_TIMEOUT:
1754 bus_timeout_event(m, w, ev->events);
1757 case WATCH_TIME_CHANGE: {
1761 log_struct(LOG_INFO,
1762 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1763 "MESSAGE=Time has been changed",
1766 /* Restart the watch */
1767 epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->time_change_watch.fd,
1769 close_nointr_nofail(m->time_change_watch.fd);
1770 watch_init(&m->time_change_watch);
1771 manager_setup_time_change(m);
1773 HASHMAP_FOREACH(u, m->units, i) {
1774 if (UNIT_VTABLE(u)->time_change)
1775 UNIT_VTABLE(u)->time_change(u);
1781 case WATCH_JOBS_IN_PROGRESS: {
1784 /* not interested in the data */
1785 read(w->fd, &v, sizeof(v));
1787 manager_print_jobs_in_progress(m);
1791 case WATCH_IDLE_PIPE: {
1792 m->no_console_output = true;
1794 manager_unwatch_idle_pipe(m);
1800 log_error("event type=%i", w->type);
1801 assert_not_reached("Unknown epoll event type.");
1807 int manager_loop(Manager *m) {
1810 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1813 m->exit_code = MANAGER_RUNNING;
1815 /* Release the path cache */
1816 set_free_free(m->unit_path_cache);
1817 m->unit_path_cache = NULL;
1819 manager_check_finished(m);
1821 /* There might still be some zombies hanging around from
1822 * before we were exec()'ed. Let's reap them. */
1823 r = manager_dispatch_sigchld(m);
1827 while (m->exit_code == MANAGER_RUNNING) {
1828 struct epoll_event event;
1832 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1835 if (!ratelimit_test(&rl)) {
1836 /* Yay, something is going seriously wrong, pause a little */
1837 log_warning("Looping too fast. Throttling execution a little.");
1842 if (manager_dispatch_load_queue(m) > 0)
1845 if (manager_dispatch_gc_queue(m) > 0)
1848 if (manager_dispatch_cleanup_queue(m) > 0)
1851 if (manager_dispatch_cgroup_queue(m) > 0)
1854 if (manager_dispatch_run_queue(m) > 0)
1857 if (bus_dispatch(m) > 0)
1860 if (manager_dispatch_dbus_queue(m) > 0)
1863 if (swap_dispatch_reload(m) > 0)
1866 /* Sleep for half the watchdog time */
1867 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1868 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1874 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1886 r = process_event(m, &event);
1891 return m->exit_code;
1894 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1895 _cleanup_free_ char *n = NULL;
1903 r = unit_name_from_dbus_path(s, &n);
1907 r = manager_load_unit(m, n, NULL, e, &u);
1916 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1925 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1928 r = safe_atou(s + 30, &id);
1932 j = manager_get_job(m, id);
1941 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1947 audit_fd = get_audit_fd();
1951 /* Don't generate audit events if the service was already
1952 * started and we're just deserializing */
1953 if (m->n_reloading > 0)
1956 if (m->running_as != SYSTEMD_SYSTEM)
1959 if (u->type != UNIT_SERVICE)
1962 p = unit_name_to_prefix_and_instance(u->id);
1964 log_error_unit(u->id,
1965 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1969 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1970 if (errno == EPERM) {
1971 /* We aren't allowed to send audit messages?
1972 * Then let's not retry again. */
1975 log_warning("Failed to send audit message: %m");
1983 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1985 union sockaddr_union sa;
1987 char *message = NULL;
1989 /* Don't generate plymouth events if the service was already
1990 * started and we're just deserializing */
1991 if (m->n_reloading > 0)
1994 if (m->running_as != SYSTEMD_SYSTEM)
1997 if (u->type != UNIT_SERVICE &&
1998 u->type != UNIT_MOUNT &&
1999 u->type != UNIT_SWAP)
2002 /* We set SOCK_NONBLOCK here so that we rather drop the
2003 * message then wait for plymouth */
2004 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2006 log_error("socket() failed: %m");
2011 sa.sa.sa_family = AF_UNIX;
2012 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
2013 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2015 if (errno != EPIPE &&
2018 errno != ECONNREFUSED &&
2019 errno != ECONNRESET &&
2020 errno != ECONNABORTED)
2021 log_error("connect() failed: %m");
2026 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2032 if (write(fd, message, n + 1) != n + 1) {
2034 if (errno != EPIPE &&
2037 errno != ECONNREFUSED &&
2038 errno != ECONNRESET &&
2039 errno != ECONNABORTED)
2040 log_error("Failed to write Plymouth message: %m");
2047 close_nointr_nofail(fd);
2052 void manager_dispatch_bus_name_owner_changed(
2055 const char* old_owner,
2056 const char *new_owner) {
2063 if (!(u = hashmap_get(m->watch_bus, name)))
2066 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2069 void manager_dispatch_bus_query_pid_done(
2080 if (!(u = hashmap_get(m->watch_bus, name)))
2083 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
2086 int manager_open_serialization(Manager *m, FILE **_f) {
2093 if (m->running_as == SYSTEMD_SYSTEM)
2094 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
2096 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
2101 RUN_WITH_UMASK(0077) {
2102 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2112 log_debug("Serializing state to %s", path);
2115 f = fdopen(fd, "w+");
2124 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2137 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2138 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2139 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2140 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2142 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2143 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2144 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2145 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2148 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2149 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2152 if (!switching_root) {
2153 STRV_FOREACH(e, m->environment) {
2154 _cleanup_free_ char *ce;
2158 fprintf(f, "env=%s\n", *e);
2162 bus_serialize(m, f);
2166 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2170 if (!unit_can_serialize(u))
2177 r = unit_serialize(u, f, fds, !switching_root);
2184 assert(m->n_reloading > 0);
2190 r = bus_fdset_add_all(m, fds);
2197 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2203 log_debug("Deserializing state...");
2208 char line[LINE_MAX], *l;
2210 if (!fgets(line, sizeof(line), f)) {
2225 if (startswith(l, "current-job-id=")) {
2228 if (safe_atou32(l+15, &id) < 0)
2229 log_debug("Failed to parse current job id value %s", l+15);
2231 m->current_job_id = MAX(m->current_job_id, id);
2232 } else if (startswith(l, "n-installed-jobs=")) {
2235 if (safe_atou32(l+17, &n) < 0)
2236 log_debug("Failed to parse installed jobs counter %s", l+17);
2238 m->n_installed_jobs += n;
2239 } else if (startswith(l, "n-failed-jobs=")) {
2242 if (safe_atou32(l+14, &n) < 0)
2243 log_debug("Failed to parse failed jobs counter %s", l+14);
2245 m->n_failed_jobs += n;
2246 } else if (startswith(l, "taint-usr=")) {
2249 if ((b = parse_boolean(l+10)) < 0)
2250 log_debug("Failed to parse taint /usr flag %s", l+10);
2252 m->taint_usr = m->taint_usr || b;
2253 } else if (startswith(l, "firmware-timestamp="))
2254 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2255 else if (startswith(l, "loader-timestamp="))
2256 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2257 else if (startswith(l, "kernel-timestamp="))
2258 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2259 else if (startswith(l, "initrd-timestamp="))
2260 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2261 else if (startswith(l, "userspace-timestamp="))
2262 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2263 else if (startswith(l, "finish-timestamp="))
2264 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2265 else if (startswith(l, "env=")) {
2266 _cleanup_free_ char *uce = NULL;
2269 uce = cunescape(l+4);
2275 e = strv_env_set(m->environment, uce);
2281 strv_free(m->environment);
2283 } else if (bus_deserialize_item(m, l) == 0)
2284 log_debug("Unknown serialization item '%s'", l);
2289 char name[UNIT_NAME_MAX+2];
2292 if (!fgets(name, sizeof(name), f)) {
2303 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2307 r = unit_deserialize(u, f, fds);
2318 assert(m->n_reloading > 0);
2324 int manager_reload(Manager *m) {
2326 _cleanup_fclose_ FILE *f = NULL;
2327 _cleanup_fdset_free_ FDSet *fds = NULL;
2331 r = manager_open_serialization(m, &f);
2336 bus_broadcast_reloading(m, true);
2344 r = manager_serialize(m, f, fds, false);
2350 if (fseeko(f, 0, SEEK_SET) < 0) {
2355 /* From here on there is no way back. */
2356 manager_clear_jobs_and_units(m);
2357 manager_undo_generators(m);
2358 lookup_paths_free(&m->lookup_paths);
2360 /* Find new unit paths */
2361 manager_run_generators(m);
2363 q = lookup_paths_init(
2364 &m->lookup_paths, m->running_as, true,
2365 m->generator_unit_path,
2366 m->generator_unit_path_early,
2367 m->generator_unit_path_late);
2371 manager_build_unit_path_cache(m);
2373 /* First, enumerate what we can from all config files */
2374 q = manager_enumerate(m);
2378 /* Second, deserialize our stored data */
2379 q = manager_deserialize(m, f, fds);
2386 /* Third, fire things up! */
2387 q = manager_coldplug(m);
2391 assert(m->n_reloading > 0);
2394 m->send_reloading_done = true;
2399 static bool manager_is_booting_or_shutting_down(Manager *m) {
2404 /* Is the initial job still around? */
2405 if (manager_get_job(m, m->default_unit_job_id))
2408 /* Is there a job for the shutdown target? */
2409 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2416 bool manager_is_reloading_or_reexecuting(Manager *m) {
2419 return m->n_reloading != 0;
2422 void manager_reset_failed(Manager *m) {
2428 HASHMAP_FOREACH(u, m->units, i)
2429 unit_reset_failed(u);
2432 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2438 /* Returns true if the unit is inactive or going down */
2439 u = manager_get_unit(m, name);
2443 return unit_inactive_or_pending(u);
2446 void manager_check_finished(Manager *m) {
2447 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2448 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2452 if (m->n_running_jobs == 0)
2453 manager_unwatch_jobs_in_progress(m);
2455 if (hashmap_size(m->jobs) > 0) {
2456 manager_jobs_in_progress_mod_timer(m);
2460 /* Notify Type=idle units that we are done now */
2461 manager_unwatch_idle_pipe(m);
2464 /* Turn off confirm spawn now */
2465 m->confirm_spawn = false;
2467 if (dual_timestamp_is_set(&m->finish_timestamp))
2470 dual_timestamp_get(&m->finish_timestamp);
2472 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2474 /* Note that m->kernel_usec.monotonic is always at 0,
2475 * and m->firmware_usec.monotonic and
2476 * m->loader_usec.monotonic should be considered
2477 * negative values. */
2479 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2480 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2481 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2482 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2484 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2486 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2487 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2489 if (!log_on_console())
2490 log_struct(LOG_INFO,
2491 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2492 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2493 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2494 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2495 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2496 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2497 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2498 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2499 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2502 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2505 if (!log_on_console())
2506 log_struct(LOG_INFO,
2507 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2508 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2509 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2510 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2511 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2512 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2513 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2517 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2518 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2520 if (!log_on_console())
2521 log_struct(LOG_INFO,
2522 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2523 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2524 "MESSAGE=Startup finished in %s.",
2525 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2529 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2532 "READY=1\nSTATUS=Startup finished in %s.",
2533 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2536 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2547 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2549 p = strappend("/run/systemd/", name);
2553 r = mkdir_p_label(p, 0755);
2555 log_error("Failed to create generator directory %s: %s",
2561 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2566 log_error("Failed to create generator directory %s: %m",
2577 static void trim_generator_dir(Manager *m, char **generator) {
2584 if (rmdir(*generator) >= 0) {
2592 void manager_run_generators(Manager *m) {
2594 const char *generator_path;
2595 const char *argv[5];
2600 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2601 d = opendir(generator_path);
2603 if (errno == ENOENT)
2606 log_error("Failed to enumerate generator directory %s: %m",
2611 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2615 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2619 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2623 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2624 argv[1] = m->generator_unit_path;
2625 argv[2] = m->generator_unit_path_early;
2626 argv[3] = m->generator_unit_path_late;
2629 RUN_WITH_UMASK(0022) {
2630 execute_directory(generator_path, d, (char**) argv);
2633 trim_generator_dir(m, &m->generator_unit_path);
2634 trim_generator_dir(m, &m->generator_unit_path_early);
2635 trim_generator_dir(m, &m->generator_unit_path_late);
2642 static void remove_generator_dir(Manager *m, char **generator) {
2649 strv_remove(m->lookup_paths.unit_path, *generator);
2650 rm_rf(*generator, false, true, false);
2656 void manager_undo_generators(Manager *m) {
2659 remove_generator_dir(m, &m->generator_unit_path);
2660 remove_generator_dir(m, &m->generator_unit_path_early);
2661 remove_generator_dir(m, &m->generator_unit_path_late);
2664 int manager_environment_add(Manager *m, char **environment) {
2668 e = strv_env_merge(2, m->environment, environment);
2672 strv_free(m->environment);
2678 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2683 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2684 if (!default_rlimit[i])
2687 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2695 void manager_recheck_journal(Manager *m) {
2700 if (m->running_as != SYSTEMD_SYSTEM)
2703 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2704 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2705 log_close_journal();
2709 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2710 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2711 log_close_journal();
2715 /* Hmm, OK, so the socket is fully up and the service is up
2716 * too, then let's make use of the thing. */
2720 void manager_set_show_status(Manager *m, bool b) {
2723 if (m->running_as != SYSTEMD_SYSTEM)
2729 touch("/run/systemd/show-status");
2731 unlink("/run/systemd/show-status");
2734 static bool manager_get_show_status(Manager *m) {
2737 if (m->running_as != SYSTEMD_SYSTEM)
2740 if (m->no_console_output)
2746 /* If Plymouth is running make sure we show the status, so
2747 * that there's something nice to see when people press Esc */
2749 return plymouth_running();
2752 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2755 if (!manager_get_show_status(m))
2758 /* XXX We should totally drop the check for ephemeral here
2759 * and thus effectively make 'Type=idle' pointless. */
2760 if (ephemeral && m->n_on_console > 0)
2763 if (!manager_is_booting_or_shutting_down(m))
2766 va_start(ap, format);
2767 status_vprintf(status, true, ephemeral, format, ap);
2771 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2772 _cleanup_free_ char *p = NULL;
2780 p = unit_name_from_path(path, suffix);
2784 found = manager_get_unit(m, p);
2794 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2795 char p[strlen(path)+1];
2801 path_kill_slashes(p);
2803 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
2806 void watch_init(Watch *w) {
2809 w->type = WATCH_INVALID;