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/>.
29 #include <sys/reboot.h>
30 #include <sys/ioctl.h>
34 #include <sys/types.h>
37 #include <sys/timerfd.h>
43 #include "sd-daemon.h"
45 #include "sd-messages.h"
48 #include "transaction.h"
55 #include "ratelimit.h"
56 #include "locale-setup.h"
57 #include "mount-setup.h"
58 #include "unit-name.h"
60 #include "path-lookup.h"
62 #include "exit-status.h"
65 #include "cgroup-util.h"
66 #include "path-util.h"
68 #include "boot-timestamps.h"
70 #include "bus-errors.h"
71 #include "bus-error.h"
74 #include "dbus-unit.h"
76 #include "dbus-manager.h"
77 #include "bus-kernel.h"
79 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
80 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
82 /* Initial delay and the interval for printing status messages about running jobs */
83 #define JOBS_IN_PROGRESS_WAIT_USEC (5*USEC_PER_SEC)
84 #define JOBS_IN_PROGRESS_PERIOD_USEC (USEC_PER_SEC / 3)
85 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
87 /* Where clients shall send notification messages to */
88 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
90 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
92 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
93 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
94 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
95 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
96 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
97 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
99 static int manager_watch_jobs_in_progress(Manager *m) {
104 if (m->jobs_in_progress_event_source)
107 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
108 return sd_event_add_monotonic(m->event, &m->jobs_in_progress_event_source, next, 0, manager_dispatch_jobs_in_progress, m);
111 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
113 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
116 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
117 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
121 p = mempset(p, ' ', pos-2);
122 p = stpcpy(p, ANSI_RED_ON);
126 if (pos > 0 && pos <= width) {
127 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
131 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
134 p = stpcpy(p, ANSI_RED_ON);
137 p = mempset(p, ' ', width-1-pos);
138 strcpy(p, ANSI_HIGHLIGHT_OFF);
142 void manager_flip_auto_status(Manager *m, bool enable) {
146 if (m->show_status == SHOW_STATUS_AUTO)
147 manager_set_show_status(m, SHOW_STATUS_TEMPORARY);
149 if (m->show_status == SHOW_STATUS_TEMPORARY)
150 manager_set_show_status(m, SHOW_STATUS_AUTO);
154 static void manager_print_jobs_in_progress(Manager *m) {
155 _cleanup_free_ char *job_of_n = NULL;
158 unsigned counter = 0, print_nr;
159 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
161 char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
166 manager_flip_auto_status(m, true);
168 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
170 HASHMAP_FOREACH(j, m->jobs, i)
171 if (j->state == JOB_RUNNING && counter++ == print_nr)
174 /* m->n_running_jobs must be consistent with the contents of m->jobs,
175 * so the above loop must have succeeded in finding j. */
176 assert(counter == print_nr + 1);
179 cylon_pos = m->jobs_in_progress_iteration % 14;
181 cylon_pos = 14 - cylon_pos;
182 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
184 m->jobs_in_progress_iteration++;
186 if (m->n_running_jobs > 1)
187 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
190 format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
191 if (job_get_timeout(j, &x) > 0)
192 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
194 manager_status_printf(m, true, cylon,
195 "%sA %s job is running for %s (%s / %s)",
197 job_type_to_string(j->type),
198 unit_description(j->unit),
203 static int manager_watch_idle_pipe(Manager *m) {
208 if (m->idle_pipe_event_source)
211 if (m->idle_pipe[2] < 0)
214 r = sd_event_add_io(m->event, &m->idle_pipe_event_source, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m);
216 log_error("Failed to watch idle pipe: %s", strerror(-r));
223 static void manager_close_idle_pipe(Manager *m) {
226 close_pipe(m->idle_pipe);
227 close_pipe(m->idle_pipe + 2);
230 static int manager_setup_time_change(Manager *m) {
233 /* We only care for the cancellation event, hence we set the
234 * timeout to the latest possible value. */
235 struct itimerspec its = {
236 .it_value.tv_sec = TIME_T_MAX,
240 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
242 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
243 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
245 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
246 if (m->time_change_fd < 0) {
247 log_error("Failed to create timerfd: %m");
251 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
252 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
253 close_nointr_nofail(m->time_change_fd);
254 m->time_change_fd = -1;
258 r = sd_event_add_io(m->event, &m->time_change_event_source, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m);
260 log_error("Failed to create time change event source: %s", strerror(-r));
264 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
269 static int enable_special_signals(Manager *m) {
270 _cleanup_close_ int fd = -1;
274 /* Enable that we get SIGINT on control-alt-del. In containers
275 * this will fail with EPERM (older) or EINVAL (newer), so
277 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
278 log_warning("Failed to enable ctrl-alt-del handling: %m");
280 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
282 /* Support systems without virtual console */
284 log_warning("Failed to open /dev/tty0: %m");
286 /* Enable that we get SIGWINCH on kbrequest */
287 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
288 log_warning("Failed to enable kbrequest handling: %m");
294 static int manager_setup_signals(Manager *m) {
295 struct sigaction sa = {
296 .sa_handler = SIG_DFL,
297 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
304 /* We are not interested in SIGSTOP and friends. */
305 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
307 assert_se(sigemptyset(&mask) == 0);
309 sigset_add_many(&mask,
310 SIGCHLD, /* Child died */
311 SIGTERM, /* Reexecute daemon */
312 SIGHUP, /* Reload configuration */
313 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
314 SIGUSR2, /* systemd: dump status */
315 SIGINT, /* Kernel sends us this on control-alt-del */
316 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
317 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
318 SIGRTMIN+0, /* systemd: start default.target */
319 SIGRTMIN+1, /* systemd: isolate rescue.target */
320 SIGRTMIN+2, /* systemd: isolate emergency.target */
321 SIGRTMIN+3, /* systemd: start halt.target */
322 SIGRTMIN+4, /* systemd: start poweroff.target */
323 SIGRTMIN+5, /* systemd: start reboot.target */
324 SIGRTMIN+6, /* systemd: start kexec.target */
325 SIGRTMIN+13, /* systemd: Immediate halt */
326 SIGRTMIN+14, /* systemd: Immediate poweroff */
327 SIGRTMIN+15, /* systemd: Immediate reboot */
328 SIGRTMIN+16, /* systemd: Immediate kexec */
329 SIGRTMIN+20, /* systemd: enable status messages */
330 SIGRTMIN+21, /* systemd: disable status messages */
331 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
332 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
333 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
334 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
335 SIGRTMIN+27, /* systemd: set log target to console */
336 SIGRTMIN+28, /* systemd: set log target to kmsg */
337 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
339 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
341 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
342 if (m->signal_fd < 0)
345 r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);
349 /* Process signals a bit earlier than the rest of things, but
350 * later that notify_fd processing, so that the notify
351 * processing can still figure out to which process/service a
352 * message belongs, before we reap the process. */
353 r = sd_event_source_set_priority(m->signal_event_source, -5);
357 if (m->running_as == SYSTEMD_SYSTEM)
358 return enable_special_signals(m);
363 static void manager_clean_environment(Manager *m) {
366 /* Let's remove some environment variables that we
367 * need ourselves to communicate with our clients */
380 static int manager_default_environment(Manager *m) {
383 if (m->running_as == SYSTEMD_SYSTEM) {
384 /* The system manager always starts with a clean
385 * environment for its children. It does not import
386 * the kernel or the parents exported variables.
388 * The initial passed environ is untouched to keep
389 * /proc/self/environ valid; it is used for tagging
390 * the init process inside containers. */
391 m->environment = strv_new("PATH=" DEFAULT_PATH,
394 /* Import locale variables LC_*= from configuration */
395 locale_setup(&m->environment);
397 /* The user manager passes its own environment
398 * along to its children. */
399 m->environment = strv_copy(environ);
405 manager_clean_environment(m);
406 strv_sort(m->environment);
411 int manager_new(SystemdRunningAs running_as, Manager **_m) {
416 assert(running_as >= 0);
417 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
419 m = new0(Manager, 1);
424 if (detect_container(NULL) <= 0)
425 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
428 m->running_as = running_as;
429 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
431 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
433 m->pin_cgroupfs_fd = m->notify_fd = m->signal_fd = m->time_change_fd = m->dev_autofs_fd = m->private_listen_fd = m->kdbus_fd = -1;
434 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
436 r = manager_default_environment(m);
440 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
444 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
448 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
452 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
456 r = set_ensure_allocated(&m->failed_units, trivial_hash_func, trivial_compare_func);
460 r = sd_event_default(&m->event);
464 r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
468 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
472 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
476 r = manager_setup_signals(m);
480 r = manager_setup_cgroup(m);
484 r = manager_setup_time_change(m);
488 m->udev = udev_new();
494 /* Note that we set up neither kdbus, nor the notify fd
495 * here. We do that after deserialization, since they might
496 * have gotten serialized across the reexec. */
498 m->taint_usr = dir_is_empty("/usr") > 0;
508 static int manager_setup_notify(Manager *m) {
511 struct sockaddr_un un;
513 .sa.sa_family = AF_UNIX,
517 if (m->notify_fd < 0) {
518 _cleanup_close_ int fd = -1;
520 /* First free all secondary fields */
521 free(m->notify_socket);
522 m->notify_socket = NULL;
523 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
525 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
527 log_error("Failed to allocate notification socket: %m");
531 if (getpid() != 1 || detect_container(NULL) > 0)
532 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%" PRIx64, random_u64());
534 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
535 sa.un.sun_path[0] = 0;
537 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
539 log_error("bind() failed: %m");
543 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
545 log_error("SO_PASSCRED failed: %m");
549 sa.un.sun_path[0] = '@';
550 m->notify_socket = strdup(sa.un.sun_path);
551 if (!m->notify_socket)
557 log_debug("Using notification socket %s", m->notify_socket);
560 if (!m->notify_event_source) {
561 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
563 log_error("Failed to allocate notify event source: %s", strerror(-r));
567 /* Process signals a bit earlier than SIGCHLD, so that we can
568 * still identify to which service an exit message belongs */
569 r = sd_event_source_set_priority(m->notify_event_source, -7);
571 log_error("Failed to set priority of notify event source: %s", strerror(-r));
579 static int manager_setup_kdbus(Manager *m) {
581 _cleanup_free_ char *p = NULL;
587 if (m->kdbus_fd >= 0)
590 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
591 if (m->kdbus_fd < 0) {
592 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
596 log_debug("Successfully set up kdbus on %s", p);
598 /* Create the namespace directory here, so that the contents
599 * of that directory is not visible to non-root users. This is
600 * necessary to ensure that users cannot get access to busses
601 * of virtualized users when no UID namespacing is used. */
602 if (m->running_as == SYSTEMD_SYSTEM)
603 mkdir_p_label("/dev/kdbus/domain", 0700);
609 static int manager_connect_bus(Manager *m, bool reexecuting) {
610 bool try_bus_connect;
617 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
619 /* Try to connect to the busses, if possible. */
620 return bus_init(m, try_bus_connect);
623 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
629 while ((u = m->cleanup_queue)) {
630 assert(u->in_cleanup_queue);
640 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
641 GC_OFFSET_UNSURE, /* No clue */
642 GC_OFFSET_GOOD, /* We still need this unit */
643 GC_OFFSET_BAD, /* We don't need this unit anymore */
647 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
654 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
655 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
656 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
659 if (u->in_cleanup_queue)
662 if (unit_check_gc(u))
665 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
669 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
670 unit_gc_sweep(other, gc_marker);
672 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
675 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
682 /* We were unable to find anything out about this entry, so
683 * let's investigate it later */
684 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
685 unit_add_to_gc_queue(u);
689 /* We definitely know that this one is not useful anymore, so
690 * let's mark it for deletion */
691 u->gc_marker = gc_marker + GC_OFFSET_BAD;
692 unit_add_to_cleanup_queue(u);
696 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
699 static unsigned manager_dispatch_gc_queue(Manager *m) {
706 /* log_debug("Running GC..."); */
708 m->gc_marker += _GC_OFFSET_MAX;
709 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
712 gc_marker = m->gc_marker;
714 while ((u = m->gc_queue)) {
715 assert(u->in_gc_queue);
717 unit_gc_sweep(u, gc_marker);
719 LIST_REMOVE(gc_queue, m->gc_queue, u);
720 u->in_gc_queue = false;
724 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
725 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
726 log_debug_unit(u->id, "Collecting %s", u->id);
727 u->gc_marker = gc_marker + GC_OFFSET_BAD;
728 unit_add_to_cleanup_queue(u);
732 m->n_in_gc_queue = 0;
737 static void manager_clear_jobs_and_units(Manager *m) {
742 while ((u = hashmap_first(m->units)))
745 manager_dispatch_cleanup_queue(m);
747 assert(!m->load_queue);
748 assert(!m->run_queue);
749 assert(!m->dbus_unit_queue);
750 assert(!m->dbus_job_queue);
751 assert(!m->cleanup_queue);
752 assert(!m->gc_queue);
754 assert(hashmap_isempty(m->jobs));
755 assert(hashmap_isempty(m->units));
758 m->n_running_jobs = 0;
761 void manager_free(Manager *m) {
767 manager_clear_jobs_and_units(m);
769 for (c = 0; c < _UNIT_TYPE_MAX; c++)
770 if (unit_vtable[c]->shutdown)
771 unit_vtable[c]->shutdown(m);
773 /* If we reexecute ourselves, we keep the root cgroup
775 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
777 manager_undo_generators(m);
781 hashmap_free(m->units);
782 hashmap_free(m->jobs);
783 hashmap_free(m->watch_pids1);
784 hashmap_free(m->watch_pids2);
785 hashmap_free(m->watch_bus);
787 set_free(m->failed_units);
789 sd_event_source_unref(m->signal_event_source);
790 sd_event_source_unref(m->notify_event_source);
791 sd_event_source_unref(m->time_change_event_source);
792 sd_event_source_unref(m->jobs_in_progress_event_source);
793 sd_event_source_unref(m->idle_pipe_event_source);
794 sd_event_source_unref(m->run_queue_event_source);
796 if (m->signal_fd >= 0)
797 close_nointr_nofail(m->signal_fd);
798 if (m->notify_fd >= 0)
799 close_nointr_nofail(m->notify_fd);
800 if (m->time_change_fd >= 0)
801 close_nointr_nofail(m->time_change_fd);
802 if (m->kdbus_fd >= 0)
803 close_nointr_nofail(m->kdbus_fd);
805 manager_close_idle_pipe(m);
808 sd_event_unref(m->event);
810 free(m->notify_socket);
812 lookup_paths_free(&m->lookup_paths);
813 strv_free(m->environment);
815 hashmap_free(m->cgroup_unit);
816 set_free_free(m->unit_path_cache);
818 free(m->switch_root);
819 free(m->switch_root_init);
821 for (i = 0; i < _RLIMIT_MAX; i++)
824 assert(hashmap_isempty(m->units_requiring_mounts_for));
825 hashmap_free(m->units_requiring_mounts_for);
830 int manager_enumerate(Manager *m) {
836 /* Let's ask every type to load all units from disk/kernel
837 * that it might know */
838 for (c = 0; c < _UNIT_TYPE_MAX; c++)
839 if (unit_vtable[c]->enumerate) {
840 q = unit_vtable[c]->enumerate(m);
845 manager_dispatch_load_queue(m);
849 static int manager_coldplug(Manager *m) {
857 /* Then, let's set up their initial state. */
858 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
865 q = unit_coldplug(u);
873 static void manager_build_unit_path_cache(Manager *m) {
875 _cleanup_free_ DIR *d = NULL;
880 set_free_free(m->unit_path_cache);
882 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
883 if (!m->unit_path_cache) {
884 log_error("Failed to allocate unit path cache.");
888 /* This simply builds a list of files we know exist, so that
889 * we don't always have to go to disk */
891 STRV_FOREACH(i, m->lookup_paths.unit_path) {
897 log_error("Failed to open directory %s: %m", *i);
901 while ((de = readdir(d))) {
904 if (ignore_file(de->d_name))
907 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
913 r = set_consume(m->unit_path_cache, p);
925 log_error("Failed to build unit path cache: %s", strerror(-r));
927 set_free_free(m->unit_path_cache);
928 m->unit_path_cache = NULL;
932 static int manager_distribute_fds(Manager *m, FDSet *fds) {
939 HASHMAP_FOREACH(u, m->units, i) {
941 if (fdset_size(fds) <= 0)
944 if (UNIT_VTABLE(u)->distribute_fds) {
945 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
954 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
959 dual_timestamp_get(&m->generators_start_timestamp);
960 manager_run_generators(m);
961 dual_timestamp_get(&m->generators_finish_timestamp);
963 r = lookup_paths_init(
964 &m->lookup_paths, m->running_as, true,
965 m->generator_unit_path,
966 m->generator_unit_path_early,
967 m->generator_unit_path_late);
971 manager_build_unit_path_cache(m);
973 /* If we will deserialize make sure that during enumeration
974 * this is already known, so we increase the counter here
979 /* First, enumerate what we can from all config files */
980 dual_timestamp_get(&m->units_load_start_timestamp);
981 r = manager_enumerate(m);
982 dual_timestamp_get(&m->units_load_finish_timestamp);
984 /* Second, deserialize if there is something to deserialize */
986 q = manager_deserialize(m, serialization, fds);
991 /* Any fds left? Find some unit which wants them. This is
992 * useful to allow container managers to pass some file
993 * descriptors to us pre-initialized. This enables
994 * socket-based activation of entire containers. */
995 if (fdset_size(fds) > 0) {
996 q = manager_distribute_fds(m, fds);
1001 /* We might have deserialized the notify fd, but if we didn't
1002 * then let's create the bus now */
1003 manager_setup_notify(m);
1005 /* We might have deserialized the kdbus control fd, but if we
1006 * didn't, then let's create the bus now. */
1007 manager_setup_kdbus(m);
1008 manager_connect_bus(m, !!serialization);
1009 bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
1011 /* Third, fire things up! */
1012 q = manager_coldplug(m);
1016 if (serialization) {
1017 assert(m->n_reloading > 0);
1020 /* Let's wait for the UnitNew/JobNew messages being
1021 * sent, before we notify that the reload is
1023 m->send_reloading_done = true;
1029 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1034 assert(type < _JOB_TYPE_MAX);
1036 assert(mode < _JOB_MODE_MAX);
1038 if (mode == JOB_ISOLATE && type != JOB_START) {
1039 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1043 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1044 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1048 log_debug_unit(unit->id,
1049 "Trying to enqueue job %s/%s/%s", unit->id,
1050 job_type_to_string(type), job_mode_to_string(mode));
1052 job_type_collapse(&type, unit);
1054 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1058 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1059 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1060 mode == JOB_IGNORE_DEPENDENCIES, e);
1064 if (mode == JOB_ISOLATE) {
1065 r = transaction_add_isolate_jobs(tr, m);
1070 r = transaction_activate(tr, m, mode, e);
1074 log_debug_unit(unit->id,
1075 "Enqueued job %s/%s as %u", unit->id,
1076 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1079 *_ret = tr->anchor_job;
1081 transaction_free(tr);
1085 transaction_abort(tr);
1086 transaction_free(tr);
1090 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1095 assert(type < _JOB_TYPE_MAX);
1097 assert(mode < _JOB_MODE_MAX);
1099 r = manager_load_unit(m, name, NULL, NULL, &unit);
1103 return manager_add_job(m, type, unit, mode, override, e, _ret);
1106 Job *manager_get_job(Manager *m, uint32_t id) {
1109 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1112 Unit *manager_get_unit(Manager *m, const char *name) {
1116 return hashmap_get(m->units, name);
1119 unsigned manager_dispatch_load_queue(Manager *m) {
1125 /* Make sure we are not run recursively */
1126 if (m->dispatching_load_queue)
1129 m->dispatching_load_queue = true;
1131 /* Dispatches the load queue. Takes a unit from the queue and
1132 * tries to load its data until the queue is empty */
1134 while ((u = m->load_queue)) {
1135 assert(u->in_load_queue);
1141 m->dispatching_load_queue = false;
1145 int manager_load_unit_prepare(
1157 assert(name || path);
1159 /* This will prepare the unit for loading, but not actually
1160 * load anything from disk. */
1162 if (path && !is_path(path))
1163 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1166 name = basename(path);
1168 t = unit_name_to_type(name);
1170 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1171 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1173 ret = manager_get_unit(m, name);
1179 ret = unit_new(m, unit_vtable[t]->object_size);
1184 ret->fragment_path = strdup(path);
1185 if (!ret->fragment_path) {
1191 r = unit_add_name(ret, name);
1197 unit_add_to_load_queue(ret);
1198 unit_add_to_dbus_queue(ret);
1199 unit_add_to_gc_queue(ret);
1207 int manager_load_unit(
1218 /* This will load the service information files, but not actually
1219 * start any services or anything. */
1221 r = manager_load_unit_prepare(m, name, path, e, _ret);
1225 manager_dispatch_load_queue(m);
1228 *_ret = unit_follow_merge(*_ret);
1233 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1240 HASHMAP_FOREACH(j, s->jobs, i)
1241 job_dump(j, f, prefix);
1244 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1252 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1254 unit_dump(u, f, prefix);
1257 void manager_clear_jobs(Manager *m) {
1262 while ((j = hashmap_first(m->jobs)))
1263 /* No need to recurse. We're cancelling all jobs. */
1264 job_finish_and_invalidate(j, JOB_CANCELED, false);
1267 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1268 Manager *m = userdata;
1274 while ((j = m->run_queue)) {
1275 assert(j->installed);
1276 assert(j->in_run_queue);
1278 job_run_and_invalidate(j);
1281 if (m->n_running_jobs > 0)
1282 manager_watch_jobs_in_progress(m);
1284 if (m->n_on_console > 0)
1285 manager_watch_idle_pipe(m);
1290 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1297 if (m->dispatching_dbus_queue)
1300 m->dispatching_dbus_queue = true;
1302 while ((u = m->dbus_unit_queue)) {
1303 assert(u->in_dbus_queue);
1305 bus_unit_send_change_signal(u);
1309 while ((j = m->dbus_job_queue)) {
1310 assert(j->in_dbus_queue);
1312 bus_job_send_change_signal(j);
1316 m->dispatching_dbus_queue = false;
1318 if (m->send_reloading_done) {
1319 m->send_reloading_done = false;
1321 bus_manager_send_reloading(m, false);
1324 if (m->queued_message)
1325 bus_send_queued_message(m);
1330 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n) {
1331 _cleanup_strv_free_ char **tags = NULL;
1338 tags = strv_split(buf, "\n\r");
1344 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1346 if (UNIT_VTABLE(u)->notify_message)
1347 UNIT_VTABLE(u)->notify_message(u, pid, tags);
1350 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1351 Manager *m = userdata;
1355 assert(m->notify_fd == fd);
1357 if (revents != EPOLLIN) {
1358 log_warning("Got unexpected poll event for notify fd.");
1364 struct iovec iovec = {
1366 .iov_len = sizeof(buf)-1,
1371 struct cmsghdr cmsghdr;
1372 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1375 struct msghdr msghdr = {
1378 .msg_control = &control,
1379 .msg_controllen = sizeof(control),
1381 struct ucred *ucred;
1384 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1389 if (errno == EAGAIN || errno == EINTR)
1395 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1396 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1397 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1398 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1399 log_warning("Received notify message without credentials. Ignoring.");
1403 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1405 assert((size_t) n < sizeof(buf));
1408 u = manager_get_unit_by_pid(m, ucred->pid);
1410 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1414 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1416 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1420 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1422 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1427 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1433 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1438 log_debug_unit(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1440 unit_unwatch_pid(u, si->si_pid);
1441 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1444 static int manager_dispatch_sigchld(Manager *m) {
1450 /* First we call waitd() for a PID and do not reap the
1451 * zombie. That way we can still access /proc/$PID for
1452 * it while it is a zombie. */
1453 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1455 if (errno == ECHILD)
1467 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1468 _cleanup_free_ char *name = NULL;
1471 get_process_comm(si.si_pid, &name);
1473 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1474 si.si_pid, strna(name),
1475 sigchld_code_to_string(si.si_code),
1477 strna(si.si_code == CLD_EXITED
1478 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1479 : signal_to_string(si.si_status)));
1481 /* And now figure out the unit this belongs
1482 * to, it might be multiple... */
1483 u = manager_get_unit_by_pid(m, si.si_pid);
1485 invoke_sigchld_event(m, u, &si);
1486 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1488 invoke_sigchld_event(m, u, &si);
1489 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1491 invoke_sigchld_event(m, u, &si);
1494 /* And now, we actually reap the zombie. */
1495 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1506 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1507 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1510 log_debug_unit(name, "Activating special unit %s", name);
1512 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1514 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1519 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1520 Manager *m = userdata;
1522 struct signalfd_siginfo sfsi;
1523 bool sigchld = false;
1526 assert(m->signal_fd == fd);
1528 if (revents != EPOLLIN) {
1529 log_warning("Got unexpected events from signal file descriptor.");
1534 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1535 if (n != sizeof(sfsi)) {
1540 if (errno == EINTR || errno == EAGAIN)
1546 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1547 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1548 ? LOG_DEBUG : LOG_INFO,
1551 switch (sfsi.ssi_signo) {
1558 if (m->running_as == SYSTEMD_SYSTEM) {
1559 /* This is for compatibility with the
1560 * original sysvinit */
1561 m->exit_code = MANAGER_REEXECUTE;
1568 if (m->running_as == SYSTEMD_SYSTEM) {
1569 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1573 /* Run the exit target if there is one, if not, just exit. */
1574 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1575 m->exit_code = MANAGER_EXIT;
1582 if (m->running_as == SYSTEMD_SYSTEM)
1583 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1585 /* This is a nop on non-init */
1589 if (m->running_as == SYSTEMD_SYSTEM)
1590 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1592 /* This is a nop on non-init */
1598 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1600 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1601 log_info("Trying to reconnect to bus...");
1605 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1606 log_info("Loading D-Bus service...");
1607 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1614 _cleanup_free_ char *dump = NULL;
1615 _cleanup_fclose_ FILE *f = NULL;
1618 f = open_memstream(&dump, &size);
1620 log_warning("Failed to allocate memory stream.");
1624 manager_dump_units(m, f, "\t");
1625 manager_dump_jobs(m, f, "\t");
1628 log_warning("Failed to write status stream");
1633 log_warning("Failed to flush status stream");
1637 log_dump(LOG_INFO, dump);
1642 m->exit_code = MANAGER_RELOAD;
1647 /* Starting SIGRTMIN+0 */
1648 static const char * const target_table[] = {
1649 [0] = SPECIAL_DEFAULT_TARGET,
1650 [1] = SPECIAL_RESCUE_TARGET,
1651 [2] = SPECIAL_EMERGENCY_TARGET,
1652 [3] = SPECIAL_HALT_TARGET,
1653 [4] = SPECIAL_POWEROFF_TARGET,
1654 [5] = SPECIAL_REBOOT_TARGET,
1655 [6] = SPECIAL_KEXEC_TARGET
1658 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1659 static const ManagerExitCode code_table[] = {
1661 [1] = MANAGER_POWEROFF,
1662 [2] = MANAGER_REBOOT,
1666 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1667 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1668 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1669 manager_start_target(m, target_table[idx],
1670 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1674 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1675 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1676 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1680 switch (sfsi.ssi_signo - SIGRTMIN) {
1683 log_debug("Enabling showing of status.");
1684 manager_set_show_status(m, SHOW_STATUS_YES);
1688 log_debug("Disabling showing of status.");
1689 manager_set_show_status(m, SHOW_STATUS_NO);
1693 log_set_max_level(LOG_DEBUG);
1694 log_notice("Setting log level to debug.");
1698 log_set_max_level(LOG_INFO);
1699 log_notice("Setting log level to info.");
1703 if (m->running_as == SYSTEMD_USER) {
1704 m->exit_code = MANAGER_EXIT;
1708 /* This is a nop on init */
1712 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1713 log_notice("Setting log target to journal-or-kmsg.");
1717 log_set_target(LOG_TARGET_CONSOLE);
1718 log_notice("Setting log target to console.");
1722 log_set_target(LOG_TARGET_KMSG);
1723 log_notice("Setting log target to kmsg.");
1727 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1728 log_notice("Setting log target to syslog-or-kmsg.");
1732 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1739 manager_dispatch_sigchld(m);
1744 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1745 Manager *m = userdata;
1750 assert(m->time_change_fd == fd);
1752 log_struct(LOG_INFO,
1753 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1754 "MESSAGE=Time has been changed",
1757 /* Restart the watch */
1758 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1760 close_nointr_nofail(m->time_change_fd);
1761 m->time_change_fd = -1;
1763 manager_setup_time_change(m);
1765 HASHMAP_FOREACH(u, m->units, i)
1766 if (UNIT_VTABLE(u)->time_change)
1767 UNIT_VTABLE(u)->time_change(u);
1772 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1773 Manager *m = userdata;
1776 assert(m->idle_pipe[2] == fd);
1778 m->no_console_output = m->n_on_console > 0;
1780 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1781 manager_close_idle_pipe(m);
1786 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1787 Manager *m = userdata;
1794 manager_print_jobs_in_progress(m);
1796 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1797 r = sd_event_source_set_time(source, next);
1801 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1804 int manager_loop(Manager *m) {
1807 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1810 m->exit_code = MANAGER_OK;
1812 /* Release the path cache */
1813 set_free_free(m->unit_path_cache);
1814 m->unit_path_cache = NULL;
1816 manager_check_finished(m);
1818 /* There might still be some zombies hanging around from
1819 * before we were exec()'ed. Let's reap them. */
1820 r = manager_dispatch_sigchld(m);
1824 while (m->exit_code == MANAGER_OK) {
1827 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1830 if (!ratelimit_test(&rl)) {
1831 /* Yay, something is going seriously wrong, pause a little */
1832 log_warning("Looping too fast. Throttling execution a little.");
1837 if (manager_dispatch_load_queue(m) > 0)
1840 if (manager_dispatch_gc_queue(m) > 0)
1843 if (manager_dispatch_cleanup_queue(m) > 0)
1846 if (manager_dispatch_cgroup_queue(m) > 0)
1849 if (manager_dispatch_dbus_queue(m) > 0)
1852 /* Sleep for half the watchdog time */
1853 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1854 wait_usec = m->runtime_watchdog / 2;
1858 wait_usec = (usec_t) -1;
1860 r = sd_event_run(m->event, wait_usec);
1862 log_error("Failed to run event loop: %s", strerror(-r));
1867 return m->exit_code;
1870 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1871 _cleanup_free_ char *n = NULL;
1879 r = unit_name_from_dbus_path(s, &n);
1883 r = manager_load_unit(m, n, NULL, e, &u);
1892 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1902 p = startswith(s, "/org/freedesktop/systemd1/job/");
1906 r = safe_atou(p, &id);
1910 j = manager_get_job(m, id);
1919 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1922 _cleanup_free_ char *p = NULL;
1925 audit_fd = get_audit_fd();
1929 /* Don't generate audit events if the service was already
1930 * started and we're just deserializing */
1931 if (m->n_reloading > 0)
1934 if (m->running_as != SYSTEMD_SYSTEM)
1937 if (u->type != UNIT_SERVICE)
1940 p = unit_name_to_prefix_and_instance(u->id);
1942 log_error_unit(u->id,
1943 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1947 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1948 if (errno == EPERM) {
1949 /* We aren't allowed to send audit messages?
1950 * Then let's not retry again. */
1953 log_warning("Failed to send audit message: %m");
1959 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1960 union sockaddr_union sa = {
1961 .un.sun_family = AF_UNIX,
1962 .un.sun_path = "\0/org/freedesktop/plymouthd",
1966 _cleanup_free_ char *message = NULL;
1967 _cleanup_close_ int fd = -1;
1969 /* Don't generate plymouth events if the service was already
1970 * started and we're just deserializing */
1971 if (m->n_reloading > 0)
1974 if (m->running_as != SYSTEMD_SYSTEM)
1977 if (detect_container(NULL) > 0)
1980 if (u->type != UNIT_SERVICE &&
1981 u->type != UNIT_MOUNT &&
1982 u->type != UNIT_SWAP)
1985 /* We set SOCK_NONBLOCK here so that we rather drop the
1986 * message then wait for plymouth */
1987 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1989 log_error("socket() failed: %m");
1993 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1995 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
1996 log_error("connect() failed: %m");
2000 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2006 if (write(fd, message, n + 1) != n + 1)
2007 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2008 log_error("Failed to write Plymouth message: %m");
2011 void manager_dispatch_bus_name_owner_changed(
2014 const char* old_owner,
2015 const char *new_owner) {
2022 u = hashmap_get(m->watch_bus, name);
2026 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2029 int manager_open_serialization(Manager *m, FILE **_f) {
2036 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2037 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2041 log_debug("Serializing state to %s", path);
2043 f = fdopen(fd, "w+");
2045 close_nointr_nofail(fd);
2054 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2067 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2068 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2069 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2070 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2072 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2073 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2074 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2075 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2078 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2079 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2080 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2081 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2082 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2083 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2084 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2085 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2088 if (!switching_root) {
2089 STRV_FOREACH(e, m->environment) {
2090 _cleanup_free_ char *ce;
2096 fprintf(f, "env=%s\n", *e);
2100 if (m->notify_fd >= 0) {
2103 copy = fdset_put_dup(fds, m->notify_fd);
2107 fprintf(f, "notify-fd=%i\n", copy);
2108 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2111 if (m->kdbus_fd >= 0) {
2114 copy = fdset_put_dup(fds, m->kdbus_fd);
2118 fprintf(f, "kdbus-fd=%i\n", copy);
2121 bus_track_serialize(m->subscribed, f);
2125 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2129 if (!unit_can_serialize(u))
2136 r = unit_serialize(u, f, fds, !switching_root);
2143 assert(m->n_reloading > 0);
2149 r = bus_fdset_add_all(m, fds);
2156 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2162 log_debug("Deserializing state...");
2167 char line[LINE_MAX], *l;
2169 if (!fgets(line, sizeof(line), f)) {
2184 if (startswith(l, "current-job-id=")) {
2187 if (safe_atou32(l+15, &id) < 0)
2188 log_debug("Failed to parse current job id value %s", l+15);
2190 m->current_job_id = MAX(m->current_job_id, id);
2192 } else if (startswith(l, "n-installed-jobs=")) {
2195 if (safe_atou32(l+17, &n) < 0)
2196 log_debug("Failed to parse installed jobs counter %s", l+17);
2198 m->n_installed_jobs += n;
2200 } else if (startswith(l, "n-failed-jobs=")) {
2203 if (safe_atou32(l+14, &n) < 0)
2204 log_debug("Failed to parse failed jobs counter %s", l+14);
2206 m->n_failed_jobs += n;
2208 } else if (startswith(l, "taint-usr=")) {
2211 b = parse_boolean(l+10);
2213 log_debug("Failed to parse taint /usr flag %s", l+10);
2215 m->taint_usr = m->taint_usr || b;
2217 } else if (startswith(l, "firmware-timestamp="))
2218 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2219 else if (startswith(l, "loader-timestamp="))
2220 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2221 else if (startswith(l, "kernel-timestamp="))
2222 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2223 else if (startswith(l, "initrd-timestamp="))
2224 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2225 else if (startswith(l, "userspace-timestamp="))
2226 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2227 else if (startswith(l, "finish-timestamp="))
2228 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2229 else if (startswith(l, "security-start-timestamp="))
2230 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2231 else if (startswith(l, "security-finish-timestamp="))
2232 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2233 else if (startswith(l, "generators-start-timestamp="))
2234 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2235 else if (startswith(l, "generators-finish-timestamp="))
2236 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2237 else if (startswith(l, "units-load-start-timestamp="))
2238 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2239 else if (startswith(l, "units-load-finish-timestamp="))
2240 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2241 else if (startswith(l, "env=")) {
2242 _cleanup_free_ char *uce = NULL;
2245 uce = cunescape(l+4);
2251 e = strv_env_set(m->environment, uce);
2257 strv_free(m->environment);
2260 } else if (startswith(l, "notify-fd=")) {
2263 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2264 log_debug("Failed to parse notify fd: %s", l + 10);
2266 if (m->notify_fd >= 0) {
2267 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2268 close_nointr_nofail(m->notify_fd);
2271 m->notify_fd = fdset_remove(fds, fd);
2274 } else if (startswith(l, "notify-socket=")) {
2283 free(m->notify_socket);
2284 m->notify_socket = n;
2286 } else if (startswith(l, "kdbus-fd=")) {
2289 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2290 log_debug("Failed to parse kdbus fd: %s", l + 9);
2292 if (m->kdbus_fd >= 0)
2293 close_nointr_nofail(m->kdbus_fd);
2295 m->kdbus_fd = fdset_remove(fds, fd);
2298 } else if (bus_track_deserialize_item(&m->deserialized_subscribed, l) == 0)
2299 log_debug("Unknown serialization item '%s'", l);
2304 char name[UNIT_NAME_MAX+2];
2307 if (!fgets(name, sizeof(name), f)) {
2318 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2322 r = unit_deserialize(u, f, fds);
2331 assert(m->n_reloading > 0);
2337 int manager_reload(Manager *m) {
2339 _cleanup_fclose_ FILE *f = NULL;
2340 _cleanup_fdset_free_ FDSet *fds = NULL;
2344 r = manager_open_serialization(m, &f);
2349 bus_manager_send_reloading(m, true);
2357 r = manager_serialize(m, f, fds, false);
2363 if (fseeko(f, 0, SEEK_SET) < 0) {
2368 /* From here on there is no way back. */
2369 manager_clear_jobs_and_units(m);
2370 manager_undo_generators(m);
2371 lookup_paths_free(&m->lookup_paths);
2373 /* Find new unit paths */
2374 manager_run_generators(m);
2376 q = lookup_paths_init(
2377 &m->lookup_paths, m->running_as, true,
2378 m->generator_unit_path,
2379 m->generator_unit_path_early,
2380 m->generator_unit_path_late);
2384 manager_build_unit_path_cache(m);
2386 /* First, enumerate what we can from all config files */
2387 q = manager_enumerate(m);
2391 /* Second, deserialize our stored data */
2392 q = manager_deserialize(m, f, fds);
2399 /* Re-register notify_fd as event source */
2400 q = manager_setup_notify(m);
2404 /* Third, fire things up! */
2405 q = manager_coldplug(m);
2409 assert(m->n_reloading > 0);
2412 m->send_reloading_done = true;
2417 bool manager_is_reloading_or_reexecuting(Manager *m) {
2420 return m->n_reloading != 0;
2423 void manager_reset_failed(Manager *m) {
2429 HASHMAP_FOREACH(u, m->units, i)
2430 unit_reset_failed(u);
2433 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2439 /* Returns true if the unit is inactive or going down */
2440 u = manager_get_unit(m, name);
2444 return unit_inactive_or_pending(u);
2447 void manager_check_finished(Manager *m) {
2448 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2449 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2453 if (m->n_running_jobs == 0)
2454 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2456 if (hashmap_size(m->jobs) > 0) {
2458 if (m->jobs_in_progress_event_source) {
2459 sd_event_source_set_time(m->jobs_in_progress_event_source,
2460 now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2466 manager_flip_auto_status(m, false);
2468 /* Notify Type=idle units that we are done now */
2469 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2470 manager_close_idle_pipe(m);
2472 /* Turn off confirm spawn now */
2473 m->confirm_spawn = false;
2475 if (dual_timestamp_is_set(&m->finish_timestamp))
2478 dual_timestamp_get(&m->finish_timestamp);
2480 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2482 /* Note that m->kernel_usec.monotonic is always at 0,
2483 * and m->firmware_usec.monotonic and
2484 * m->loader_usec.monotonic should be considered
2485 * negative values. */
2487 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2488 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2489 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2490 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2492 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2494 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2495 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2497 if (!log_on_console())
2498 log_struct(LOG_INFO,
2499 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2500 "KERNEL_USEC="USEC_FMT, kernel_usec,
2501 "INITRD_USEC="USEC_FMT, initrd_usec,
2502 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2503 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2504 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2505 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2506 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2507 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2510 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2513 if (!log_on_console())
2514 log_struct(LOG_INFO,
2515 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2516 "KERNEL_USEC="USEC_FMT, kernel_usec,
2517 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2518 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2519 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2520 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2521 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2525 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2526 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2528 if (!log_on_console())
2529 log_struct(LOG_INFO,
2530 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2531 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2532 "MESSAGE=Startup finished in %s.",
2533 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2537 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2540 "READY=1\nSTATUS=Startup finished in %s.",
2541 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2544 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2555 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2556 /* systemd --system, not running --test */
2558 p = strappend("/run/systemd/", name);
2562 r = mkdir_p_label(p, 0755);
2564 log_error("Failed to create generator directory %s: %s",
2569 } else if (m->running_as == SYSTEMD_USER) {
2570 const char *s = NULL;
2572 s = getenv("XDG_RUNTIME_DIR");
2575 p = strjoin(s, "/systemd/", name, NULL);
2579 r = mkdir_p_label(p, 0755);
2581 log_error("Failed to create generator directory %s: %s",
2587 /* systemd --system --test */
2589 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2594 log_error("Failed to create generator directory %s: %m",
2605 static void trim_generator_dir(Manager *m, char **generator) {
2612 if (rmdir(*generator) >= 0) {
2620 void manager_run_generators(Manager *m) {
2621 _cleanup_closedir_ DIR *d = NULL;
2622 const char *generator_path;
2623 const char *argv[5];
2628 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2629 d = opendir(generator_path);
2631 if (errno == ENOENT)
2634 log_error("Failed to enumerate generator directory %s: %m",
2639 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2643 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2647 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2651 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2652 argv[1] = m->generator_unit_path;
2653 argv[2] = m->generator_unit_path_early;
2654 argv[3] = m->generator_unit_path_late;
2657 RUN_WITH_UMASK(0022)
2658 execute_directory(generator_path, d, DEFAULT_TIMEOUT_USEC, (char**) argv);
2661 trim_generator_dir(m, &m->generator_unit_path);
2662 trim_generator_dir(m, &m->generator_unit_path_early);
2663 trim_generator_dir(m, &m->generator_unit_path_late);
2666 static void remove_generator_dir(Manager *m, char **generator) {
2673 strv_remove(m->lookup_paths.unit_path, *generator);
2674 rm_rf(*generator, false, true, false);
2680 void manager_undo_generators(Manager *m) {
2683 remove_generator_dir(m, &m->generator_unit_path);
2684 remove_generator_dir(m, &m->generator_unit_path_early);
2685 remove_generator_dir(m, &m->generator_unit_path_late);
2688 int manager_environment_add(Manager *m, char **minus, char **plus) {
2689 char **a = NULL, **b = NULL, **l;
2694 if (!strv_isempty(minus)) {
2695 a = strv_env_delete(l, 1, minus);
2702 if (!strv_isempty(plus)) {
2703 b = strv_env_merge(2, l, plus);
2710 if (m->environment != l)
2711 strv_free(m->environment);
2718 manager_clean_environment(m);
2719 strv_sort(m->environment);
2724 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2729 for (i = 0; i < _RLIMIT_MAX; i++) {
2730 if (!default_rlimit[i])
2733 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2741 void manager_recheck_journal(Manager *m) {
2746 if (m->running_as != SYSTEMD_SYSTEM)
2749 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2750 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2751 log_close_journal();
2755 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2756 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2757 log_close_journal();
2761 /* Hmm, OK, so the socket is fully up and the service is up
2762 * too, then let's make use of the thing. */
2766 void manager_set_show_status(Manager *m, ShowStatus mode) {
2768 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2770 if (m->running_as != SYSTEMD_SYSTEM)
2773 m->show_status = mode;
2776 touch("/run/systemd/show-status");
2778 unlink("/run/systemd/show-status");
2781 static bool manager_get_show_status(Manager *m) {
2784 if (m->running_as != SYSTEMD_SYSTEM)
2787 if (m->no_console_output)
2790 if (!IN_SET(manager_state(m), MANAGER_STARTING, MANAGER_STOPPING))
2793 if (m->show_status > 0)
2796 /* If Plymouth is running make sure we show the status, so
2797 * that there's something nice to see when people press Esc */
2799 return plymouth_running();
2802 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2805 if (!manager_get_show_status(m))
2808 /* XXX We should totally drop the check for ephemeral here
2809 * and thus effectively make 'Type=idle' pointless. */
2810 if (ephemeral && m->n_on_console > 0)
2813 va_start(ap, format);
2814 status_vprintf(status, true, ephemeral, format, ap);
2818 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2819 _cleanup_free_ char *p = NULL;
2827 p = unit_name_from_path(path, suffix);
2831 found = manager_get_unit(m, p);
2841 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2842 char p[strlen(path)+1];
2848 path_kill_slashes(p);
2850 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
2853 const char *manager_get_runtime_prefix(Manager *m) {
2856 return m->running_as == SYSTEMD_SYSTEM ?
2858 getenv("XDG_RUNTIME_DIR");
2861 ManagerState manager_state(Manager *m) {
2866 /* Did we ever finish booting? If not then we are still starting up */
2867 if (!dual_timestamp_is_set(&m->finish_timestamp))
2868 return MANAGER_STARTING;
2870 /* Is the special shutdown target queued? If so, we are in shutdown state */
2871 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2872 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
2873 return MANAGER_STOPPING;
2875 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
2876 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
2877 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2878 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2879 return MANAGER_MAINTENANCE;
2881 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
2882 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2883 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2884 return MANAGER_MAINTENANCE;
2886 /* Are there any failed units? If so, we are in degraded mode */
2887 if (set_size(m->failed_units) > 0)
2888 return MANAGER_DEGRADED;
2890 return MANAGER_RUNNING;
2893 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
2894 [MANAGER_STARTING] = "starting",
2895 [MANAGER_RUNNING] = "running",
2896 [MANAGER_DEGRADED] = "degraded",
2897 [MANAGER_MAINTENANCE] = "maintenance",
2898 [MANAGER_STOPPING] = "stopping",
2901 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);