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 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
89 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
90 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
91 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
92 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
93 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
94 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
96 static int manager_watch_jobs_in_progress(Manager *m) {
101 if (m->jobs_in_progress_event_source)
104 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
105 return sd_event_add_time(
107 &m->jobs_in_progress_event_source,
110 manager_dispatch_jobs_in_progress, m);
113 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
115 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
118 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
119 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
123 p = mempset(p, ' ', pos-2);
124 p = stpcpy(p, ANSI_RED_ON);
128 if (pos > 0 && pos <= width) {
129 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
133 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
136 p = stpcpy(p, ANSI_RED_ON);
139 p = mempset(p, ' ', width-1-pos);
140 strcpy(p, ANSI_HIGHLIGHT_OFF);
144 void manager_flip_auto_status(Manager *m, bool enable) {
148 if (m->show_status == SHOW_STATUS_AUTO)
149 manager_set_show_status(m, SHOW_STATUS_TEMPORARY);
151 if (m->show_status == SHOW_STATUS_TEMPORARY)
152 manager_set_show_status(m, SHOW_STATUS_AUTO);
156 static void manager_print_jobs_in_progress(Manager *m) {
157 _cleanup_free_ char *job_of_n = NULL;
160 unsigned counter = 0, print_nr;
161 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
163 char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
168 manager_flip_auto_status(m, true);
170 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
172 HASHMAP_FOREACH(j, m->jobs, i)
173 if (j->state == JOB_RUNNING && counter++ == print_nr)
176 /* m->n_running_jobs must be consistent with the contents of m->jobs,
177 * so the above loop must have succeeded in finding j. */
178 assert(counter == print_nr + 1);
181 cylon_pos = m->jobs_in_progress_iteration % 14;
183 cylon_pos = 14 - cylon_pos;
184 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
186 m->jobs_in_progress_iteration++;
188 if (m->n_running_jobs > 1)
189 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
192 format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
193 if (job_get_timeout(j, &x) > 0)
194 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
196 manager_status_printf(m, true, cylon,
197 "%sA %s job is running for %s (%s / %s)",
199 job_type_to_string(j->type),
200 unit_description(j->unit),
205 static int manager_watch_idle_pipe(Manager *m) {
210 if (m->idle_pipe_event_source)
213 if (m->idle_pipe[2] < 0)
216 r = sd_event_add_io(m->event, &m->idle_pipe_event_source, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m);
218 log_error("Failed to watch idle pipe: %s", strerror(-r));
225 static void manager_close_idle_pipe(Manager *m) {
228 safe_close_pair(m->idle_pipe);
229 safe_close_pair(m->idle_pipe + 2);
232 static int manager_setup_time_change(Manager *m) {
235 /* We only care for the cancellation event, hence we set the
236 * timeout to the latest possible value. */
237 struct itimerspec its = {
238 .it_value.tv_sec = TIME_T_MAX,
242 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
244 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
245 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
247 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
248 if (m->time_change_fd < 0) {
249 log_error("Failed to create timerfd: %m");
253 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
254 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
255 m->time_change_fd = safe_close(m->time_change_fd);
259 r = sd_event_add_io(m->event, &m->time_change_event_source, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m);
261 log_error("Failed to create time change event source: %s", strerror(-r));
265 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
270 static int enable_special_signals(Manager *m) {
271 _cleanup_close_ int fd = -1;
275 /* Enable that we get SIGINT on control-alt-del. In containers
276 * this will fail with EPERM (older) or EINVAL (newer), so
278 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
279 log_warning("Failed to enable ctrl-alt-del handling: %m");
281 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
283 /* Support systems without virtual console */
285 log_warning("Failed to open /dev/tty0: %m");
287 /* Enable that we get SIGWINCH on kbrequest */
288 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
289 log_warning("Failed to enable kbrequest handling: %m");
295 static int manager_setup_signals(Manager *m) {
296 struct sigaction sa = {
297 .sa_handler = SIG_DFL,
298 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
305 /* We are not interested in SIGSTOP and friends. */
306 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
308 assert_se(sigemptyset(&mask) == 0);
310 sigset_add_many(&mask,
311 SIGCHLD, /* Child died */
312 SIGTERM, /* Reexecute daemon */
313 SIGHUP, /* Reload configuration */
314 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
315 SIGUSR2, /* systemd: dump status */
316 SIGINT, /* Kernel sends us this on control-alt-del */
317 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
318 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
319 SIGRTMIN+0, /* systemd: start default.target */
320 SIGRTMIN+1, /* systemd: isolate rescue.target */
321 SIGRTMIN+2, /* systemd: isolate emergency.target */
322 SIGRTMIN+3, /* systemd: start halt.target */
323 SIGRTMIN+4, /* systemd: start poweroff.target */
324 SIGRTMIN+5, /* systemd: start reboot.target */
325 SIGRTMIN+6, /* systemd: start kexec.target */
326 SIGRTMIN+13, /* systemd: Immediate halt */
327 SIGRTMIN+14, /* systemd: Immediate poweroff */
328 SIGRTMIN+15, /* systemd: Immediate reboot */
329 SIGRTMIN+16, /* systemd: Immediate kexec */
330 SIGRTMIN+20, /* systemd: enable status messages */
331 SIGRTMIN+21, /* systemd: disable status messages */
332 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
333 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
334 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
335 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
336 SIGRTMIN+27, /* systemd: set log target to console */
337 SIGRTMIN+28, /* systemd: set log target to kmsg */
338 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
340 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
342 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
343 if (m->signal_fd < 0)
346 r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);
350 /* Process signals a bit earlier than the rest of things, but
351 * later that notify_fd processing, so that the notify
352 * processing can still figure out to which process/service a
353 * message belongs, before we reap the process. */
354 r = sd_event_source_set_priority(m->signal_event_source, -5);
358 if (m->running_as == SYSTEMD_SYSTEM)
359 return enable_special_signals(m);
364 static void manager_clean_environment(Manager *m) {
367 /* Let's remove some environment variables that we
368 * need ourselves to communicate with our clients */
381 static int manager_default_environment(Manager *m) {
384 if (m->running_as == SYSTEMD_SYSTEM) {
385 /* The system manager always starts with a clean
386 * environment for its children. It does not import
387 * the kernel or the parents exported variables.
389 * The initial passed environ is untouched to keep
390 * /proc/self/environ valid; it is used for tagging
391 * the init process inside containers. */
392 m->environment = strv_new("PATH=" DEFAULT_PATH,
395 /* Import locale variables LC_*= from configuration */
396 locale_setup(&m->environment);
398 /* The user manager passes its own environment
399 * along to its children. */
400 m->environment = strv_copy(environ);
406 manager_clean_environment(m);
407 strv_sort(m->environment);
412 int manager_new(SystemdRunningAs running_as, Manager **_m) {
417 assert(running_as >= 0);
418 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
420 m = new0(Manager, 1);
425 if (running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0)
426 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
429 m->running_as = running_as;
430 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
431 m->default_timer_accuracy_usec = USEC_PER_MINUTE;
432 m->default_cpu_quota_period_usec = 100 * USEC_PER_MSEC;
434 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
436 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;
437 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
439 r = manager_default_environment(m);
443 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
447 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
451 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
455 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
459 r = set_ensure_allocated(&m->failed_units, trivial_hash_func, trivial_compare_func);
463 r = sd_event_default(&m->event);
467 r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
471 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
475 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
479 r = manager_setup_signals(m);
483 r = manager_setup_cgroup(m);
487 r = manager_setup_time_change(m);
491 m->udev = udev_new();
497 /* Note that we set up neither kdbus, nor the notify fd
498 * here. We do that after deserialization, since they might
499 * have gotten serialized across the reexec. */
501 m->taint_usr = dir_is_empty("/usr") > 0;
511 static int manager_setup_notify(Manager *m) {
514 if (m->notify_fd < 0) {
515 _cleanup_close_ int fd = -1;
518 struct sockaddr_un un;
520 .sa.sa_family = AF_UNIX,
524 /* First free all secondary fields */
525 free(m->notify_socket);
526 m->notify_socket = NULL;
527 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
529 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
531 log_error("Failed to allocate notification socket: %m");
535 if (m->running_as == SYSTEMD_SYSTEM)
536 m->notify_socket = strdup("/run/systemd/notify");
540 e = getenv("XDG_RUNTIME_DIR");
542 log_error("XDG_RUNTIME_DIR is not set: %m");
546 m->notify_socket = strappend(e, "/systemd/notify");
548 if (!m->notify_socket)
551 strncpy(sa.un.sun_path, m->notify_socket, sizeof(sa.un.sun_path)-1);
552 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path));
554 log_error("bind() failed: %m");
558 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
560 log_error("SO_PASSCRED failed: %m");
567 log_debug("Using notification socket %s", m->notify_socket);
570 if (!m->notify_event_source) {
571 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
573 log_error("Failed to allocate notify event source: %s", strerror(-r));
577 /* Process signals a bit earlier than SIGCHLD, so that we can
578 * still identify to which service an exit message belongs */
579 r = sd_event_source_set_priority(m->notify_event_source, -7);
581 log_error("Failed to set priority of notify event source: %s", strerror(-r));
589 static int manager_setup_kdbus(Manager *m) {
591 _cleanup_free_ char *p = NULL;
597 if (m->kdbus_fd >= 0)
600 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
601 if (m->kdbus_fd < 0) {
602 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
606 log_debug("Successfully set up kdbus on %s", p);
608 /* Create the namespace directory here, so that the contents
609 * of that directory is not visible to non-root users. This is
610 * necessary to ensure that users cannot get access to busses
611 * of virtualized users when no UID namespacing is used. */
612 if (m->running_as == SYSTEMD_SYSTEM)
613 mkdir_p_label("/dev/kdbus/domain", 0700);
619 static int manager_connect_bus(Manager *m, bool reexecuting) {
620 bool try_bus_connect;
627 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
629 /* Try to connect to the busses, if possible. */
630 return bus_init(m, try_bus_connect);
633 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
639 while ((u = m->cleanup_queue)) {
640 assert(u->in_cleanup_queue);
650 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
651 GC_OFFSET_UNSURE, /* No clue */
652 GC_OFFSET_GOOD, /* We still need this unit */
653 GC_OFFSET_BAD, /* We don't need this unit anymore */
657 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
664 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
665 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
666 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
669 if (u->in_cleanup_queue)
672 if (unit_check_gc(u))
675 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
679 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
680 unit_gc_sweep(other, gc_marker);
682 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
685 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
692 /* We were unable to find anything out about this entry, so
693 * let's investigate it later */
694 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
695 unit_add_to_gc_queue(u);
699 /* We definitely know that this one is not useful anymore, so
700 * let's mark it for deletion */
701 u->gc_marker = gc_marker + GC_OFFSET_BAD;
702 unit_add_to_cleanup_queue(u);
706 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
709 static unsigned manager_dispatch_gc_queue(Manager *m) {
716 /* log_debug("Running GC..."); */
718 m->gc_marker += _GC_OFFSET_MAX;
719 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
722 gc_marker = m->gc_marker;
724 while ((u = m->gc_queue)) {
725 assert(u->in_gc_queue);
727 unit_gc_sweep(u, gc_marker);
729 LIST_REMOVE(gc_queue, m->gc_queue, u);
730 u->in_gc_queue = false;
734 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
735 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
736 log_debug_unit(u->id, "Collecting %s", u->id);
737 u->gc_marker = gc_marker + GC_OFFSET_BAD;
738 unit_add_to_cleanup_queue(u);
742 m->n_in_gc_queue = 0;
747 static void manager_clear_jobs_and_units(Manager *m) {
752 while ((u = hashmap_first(m->units)))
755 manager_dispatch_cleanup_queue(m);
757 assert(!m->load_queue);
758 assert(!m->run_queue);
759 assert(!m->dbus_unit_queue);
760 assert(!m->dbus_job_queue);
761 assert(!m->cleanup_queue);
762 assert(!m->gc_queue);
764 assert(hashmap_isempty(m->jobs));
765 assert(hashmap_isempty(m->units));
768 m->n_running_jobs = 0;
771 void manager_free(Manager *m) {
777 manager_clear_jobs_and_units(m);
779 for (c = 0; c < _UNIT_TYPE_MAX; c++)
780 if (unit_vtable[c]->shutdown)
781 unit_vtable[c]->shutdown(m);
783 /* If we reexecute ourselves, we keep the root cgroup
785 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
787 manager_undo_generators(m);
791 hashmap_free(m->units);
792 hashmap_free(m->jobs);
793 hashmap_free(m->watch_pids1);
794 hashmap_free(m->watch_pids2);
795 hashmap_free(m->watch_bus);
797 set_free(m->failed_units);
799 sd_event_source_unref(m->signal_event_source);
800 sd_event_source_unref(m->notify_event_source);
801 sd_event_source_unref(m->time_change_event_source);
802 sd_event_source_unref(m->jobs_in_progress_event_source);
803 sd_event_source_unref(m->idle_pipe_event_source);
804 sd_event_source_unref(m->run_queue_event_source);
806 safe_close(m->signal_fd);
807 safe_close(m->notify_fd);
808 safe_close(m->time_change_fd);
809 safe_close(m->kdbus_fd);
811 manager_close_idle_pipe(m);
814 sd_event_unref(m->event);
816 free(m->notify_socket);
818 lookup_paths_free(&m->lookup_paths);
819 strv_free(m->environment);
821 hashmap_free(m->cgroup_unit);
822 set_free_free(m->unit_path_cache);
824 free(m->switch_root);
825 free(m->switch_root_init);
827 for (i = 0; i < _RLIMIT_MAX; i++)
830 assert(hashmap_isempty(m->units_requiring_mounts_for));
831 hashmap_free(m->units_requiring_mounts_for);
836 int manager_enumerate(Manager *m) {
842 /* Let's ask every type to load all units from disk/kernel
843 * that it might know */
844 for (c = 0; c < _UNIT_TYPE_MAX; c++)
845 if (unit_vtable[c]->enumerate) {
846 q = unit_vtable[c]->enumerate(m);
851 manager_dispatch_load_queue(m);
855 static int manager_coldplug(Manager *m) {
863 /* Then, let's set up their initial state. */
864 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
871 q = unit_coldplug(u);
879 static void manager_build_unit_path_cache(Manager *m) {
881 _cleanup_free_ DIR *d = NULL;
886 set_free_free(m->unit_path_cache);
888 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
889 if (!m->unit_path_cache) {
890 log_error("Failed to allocate unit path cache.");
894 /* This simply builds a list of files we know exist, so that
895 * we don't always have to go to disk */
897 STRV_FOREACH(i, m->lookup_paths.unit_path) {
903 log_error("Failed to open directory %s: %m", *i);
907 while ((de = readdir(d))) {
910 if (ignore_file(de->d_name))
913 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
919 r = set_consume(m->unit_path_cache, p);
931 log_error("Failed to build unit path cache: %s", strerror(-r));
933 set_free_free(m->unit_path_cache);
934 m->unit_path_cache = NULL;
938 static int manager_distribute_fds(Manager *m, FDSet *fds) {
945 HASHMAP_FOREACH(u, m->units, i) {
947 if (fdset_size(fds) <= 0)
950 if (UNIT_VTABLE(u)->distribute_fds) {
951 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
960 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
965 dual_timestamp_get(&m->generators_start_timestamp);
966 manager_run_generators(m);
967 dual_timestamp_get(&m->generators_finish_timestamp);
969 r = lookup_paths_init(
970 &m->lookup_paths, m->running_as, true,
972 m->generator_unit_path,
973 m->generator_unit_path_early,
974 m->generator_unit_path_late);
978 manager_build_unit_path_cache(m);
980 /* If we will deserialize make sure that during enumeration
981 * this is already known, so we increase the counter here
986 /* First, enumerate what we can from all config files */
987 dual_timestamp_get(&m->units_load_start_timestamp);
988 r = manager_enumerate(m);
989 dual_timestamp_get(&m->units_load_finish_timestamp);
991 /* Second, deserialize if there is something to deserialize */
993 q = manager_deserialize(m, serialization, fds);
998 /* Any fds left? Find some unit which wants them. This is
999 * useful to allow container managers to pass some file
1000 * descriptors to us pre-initialized. This enables
1001 * socket-based activation of entire containers. */
1002 if (fdset_size(fds) > 0) {
1003 q = manager_distribute_fds(m, fds);
1008 /* We might have deserialized the notify fd, but if we didn't
1009 * then let's create the bus now */
1010 manager_setup_notify(m);
1012 /* We might have deserialized the kdbus control fd, but if we
1013 * didn't, then let's create the bus now. */
1014 manager_setup_kdbus(m);
1015 manager_connect_bus(m, !!serialization);
1016 bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
1018 /* Third, fire things up! */
1019 q = manager_coldplug(m);
1023 if (serialization) {
1024 assert(m->n_reloading > 0);
1027 /* Let's wait for the UnitNew/JobNew messages being
1028 * sent, before we notify that the reload is
1030 m->send_reloading_done = true;
1036 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1041 assert(type < _JOB_TYPE_MAX);
1043 assert(mode < _JOB_MODE_MAX);
1045 if (mode == JOB_ISOLATE && type != JOB_START) {
1046 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1050 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1051 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1055 log_debug_unit(unit->id,
1056 "Trying to enqueue job %s/%s/%s", unit->id,
1057 job_type_to_string(type), job_mode_to_string(mode));
1059 job_type_collapse(&type, unit);
1061 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1065 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1066 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1067 mode == JOB_IGNORE_DEPENDENCIES, e);
1071 if (mode == JOB_ISOLATE) {
1072 r = transaction_add_isolate_jobs(tr, m);
1077 r = transaction_activate(tr, m, mode, e);
1081 log_debug_unit(unit->id,
1082 "Enqueued job %s/%s as %u", unit->id,
1083 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1086 *_ret = tr->anchor_job;
1088 transaction_free(tr);
1092 transaction_abort(tr);
1093 transaction_free(tr);
1097 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1102 assert(type < _JOB_TYPE_MAX);
1104 assert(mode < _JOB_MODE_MAX);
1106 r = manager_load_unit(m, name, NULL, NULL, &unit);
1110 return manager_add_job(m, type, unit, mode, override, e, _ret);
1113 Job *manager_get_job(Manager *m, uint32_t id) {
1116 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1119 Unit *manager_get_unit(Manager *m, const char *name) {
1123 return hashmap_get(m->units, name);
1126 unsigned manager_dispatch_load_queue(Manager *m) {
1132 /* Make sure we are not run recursively */
1133 if (m->dispatching_load_queue)
1136 m->dispatching_load_queue = true;
1138 /* Dispatches the load queue. Takes a unit from the queue and
1139 * tries to load its data until the queue is empty */
1141 while ((u = m->load_queue)) {
1142 assert(u->in_load_queue);
1148 m->dispatching_load_queue = false;
1152 int manager_load_unit_prepare(
1164 assert(name || path);
1166 /* This will prepare the unit for loading, but not actually
1167 * load anything from disk. */
1169 if (path && !is_path(path))
1170 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1173 name = basename(path);
1175 t = unit_name_to_type(name);
1177 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1178 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1180 ret = manager_get_unit(m, name);
1186 ret = unit_new(m, unit_vtable[t]->object_size);
1191 ret->fragment_path = strdup(path);
1192 if (!ret->fragment_path) {
1198 r = unit_add_name(ret, name);
1204 unit_add_to_load_queue(ret);
1205 unit_add_to_dbus_queue(ret);
1206 unit_add_to_gc_queue(ret);
1214 int manager_load_unit(
1225 /* This will load the service information files, but not actually
1226 * start any services or anything. */
1228 r = manager_load_unit_prepare(m, name, path, e, _ret);
1232 manager_dispatch_load_queue(m);
1235 *_ret = unit_follow_merge(*_ret);
1240 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1247 HASHMAP_FOREACH(j, s->jobs, i)
1248 job_dump(j, f, prefix);
1251 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1259 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1261 unit_dump(u, f, prefix);
1264 void manager_clear_jobs(Manager *m) {
1269 while ((j = hashmap_first(m->jobs)))
1270 /* No need to recurse. We're cancelling all jobs. */
1271 job_finish_and_invalidate(j, JOB_CANCELED, false);
1274 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1275 Manager *m = userdata;
1281 while ((j = m->run_queue)) {
1282 assert(j->installed);
1283 assert(j->in_run_queue);
1285 job_run_and_invalidate(j);
1288 if (m->n_running_jobs > 0)
1289 manager_watch_jobs_in_progress(m);
1291 if (m->n_on_console > 0)
1292 manager_watch_idle_pipe(m);
1297 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1304 if (m->dispatching_dbus_queue)
1307 m->dispatching_dbus_queue = true;
1309 while ((u = m->dbus_unit_queue)) {
1310 assert(u->in_dbus_queue);
1312 bus_unit_send_change_signal(u);
1316 while ((j = m->dbus_job_queue)) {
1317 assert(j->in_dbus_queue);
1319 bus_job_send_change_signal(j);
1323 m->dispatching_dbus_queue = false;
1325 if (m->send_reloading_done) {
1326 m->send_reloading_done = false;
1328 bus_manager_send_reloading(m, false);
1331 if (m->queued_message)
1332 bus_send_queued_message(m);
1337 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n) {
1338 _cleanup_strv_free_ char **tags = NULL;
1345 tags = strv_split(buf, "\n\r");
1351 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1353 if (UNIT_VTABLE(u)->notify_message)
1354 UNIT_VTABLE(u)->notify_message(u, pid, tags);
1357 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1358 Manager *m = userdata;
1362 assert(m->notify_fd == fd);
1364 if (revents != EPOLLIN) {
1365 log_warning("Got unexpected poll event for notify fd.");
1371 struct iovec iovec = {
1373 .iov_len = sizeof(buf)-1,
1378 struct cmsghdr cmsghdr;
1379 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1382 struct msghdr msghdr = {
1385 .msg_control = &control,
1386 .msg_controllen = sizeof(control),
1388 struct ucred *ucred;
1391 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1396 if (errno == EAGAIN || errno == EINTR)
1402 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1403 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1404 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1405 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1406 log_warning("Received notify message without credentials. Ignoring.");
1410 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1412 assert((size_t) n < sizeof(buf));
1415 u = manager_get_unit_by_pid(m, ucred->pid);
1417 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1421 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1423 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1427 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1429 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1434 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1440 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1445 log_debug_unit(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1447 unit_unwatch_pid(u, si->si_pid);
1448 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1451 static int manager_dispatch_sigchld(Manager *m) {
1457 /* First we call waitd() for a PID and do not reap the
1458 * zombie. That way we can still access /proc/$PID for
1459 * it while it is a zombie. */
1460 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1462 if (errno == ECHILD)
1474 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1475 _cleanup_free_ char *name = NULL;
1478 get_process_comm(si.si_pid, &name);
1480 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1481 si.si_pid, strna(name),
1482 sigchld_code_to_string(si.si_code),
1484 strna(si.si_code == CLD_EXITED
1485 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1486 : signal_to_string(si.si_status)));
1488 /* And now figure out the unit this belongs
1489 * to, it might be multiple... */
1490 u = manager_get_unit_by_pid(m, si.si_pid);
1492 invoke_sigchld_event(m, u, &si);
1493 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1495 invoke_sigchld_event(m, u, &si);
1496 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1498 invoke_sigchld_event(m, u, &si);
1501 /* And now, we actually reap the zombie. */
1502 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1513 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1514 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1517 log_debug_unit(name, "Activating special unit %s", name);
1519 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1521 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1526 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1527 Manager *m = userdata;
1529 struct signalfd_siginfo sfsi;
1530 bool sigchld = false;
1533 assert(m->signal_fd == fd);
1535 if (revents != EPOLLIN) {
1536 log_warning("Got unexpected events from signal file descriptor.");
1541 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1542 if (n != sizeof(sfsi)) {
1547 if (errno == EINTR || errno == EAGAIN)
1553 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1554 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1555 ? LOG_DEBUG : LOG_INFO,
1558 switch (sfsi.ssi_signo) {
1565 if (m->running_as == SYSTEMD_SYSTEM) {
1566 /* This is for compatibility with the
1567 * original sysvinit */
1568 m->exit_code = MANAGER_REEXECUTE;
1575 if (m->running_as == SYSTEMD_SYSTEM) {
1576 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1580 /* Run the exit target if there is one, if not, just exit. */
1581 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1582 m->exit_code = MANAGER_EXIT;
1589 if (m->running_as == SYSTEMD_SYSTEM)
1590 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1592 /* This is a nop on non-init */
1596 if (m->running_as == SYSTEMD_SYSTEM)
1597 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1599 /* This is a nop on non-init */
1605 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1607 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1608 log_info("Trying to reconnect to bus...");
1612 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1613 log_info("Loading D-Bus service...");
1614 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1621 _cleanup_free_ char *dump = NULL;
1622 _cleanup_fclose_ FILE *f = NULL;
1625 f = open_memstream(&dump, &size);
1627 log_warning("Failed to allocate memory stream.");
1631 manager_dump_units(m, f, "\t");
1632 manager_dump_jobs(m, f, "\t");
1635 log_warning("Failed to write status stream");
1640 log_warning("Failed to flush status stream");
1644 log_dump(LOG_INFO, dump);
1649 m->exit_code = MANAGER_RELOAD;
1654 /* Starting SIGRTMIN+0 */
1655 static const char * const target_table[] = {
1656 [0] = SPECIAL_DEFAULT_TARGET,
1657 [1] = SPECIAL_RESCUE_TARGET,
1658 [2] = SPECIAL_EMERGENCY_TARGET,
1659 [3] = SPECIAL_HALT_TARGET,
1660 [4] = SPECIAL_POWEROFF_TARGET,
1661 [5] = SPECIAL_REBOOT_TARGET,
1662 [6] = SPECIAL_KEXEC_TARGET
1665 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1666 static const ManagerExitCode code_table[] = {
1668 [1] = MANAGER_POWEROFF,
1669 [2] = MANAGER_REBOOT,
1673 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1674 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1675 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1676 manager_start_target(m, target_table[idx],
1677 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1681 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1682 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1683 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1687 switch (sfsi.ssi_signo - SIGRTMIN) {
1690 log_debug("Enabling showing of status.");
1691 manager_set_show_status(m, SHOW_STATUS_YES);
1695 log_debug("Disabling showing of status.");
1696 manager_set_show_status(m, SHOW_STATUS_NO);
1700 log_set_max_level(LOG_DEBUG);
1701 log_notice("Setting log level to debug.");
1705 log_set_max_level(LOG_INFO);
1706 log_notice("Setting log level to info.");
1710 if (m->running_as == SYSTEMD_USER) {
1711 m->exit_code = MANAGER_EXIT;
1715 /* This is a nop on init */
1719 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1720 log_notice("Setting log target to journal-or-kmsg.");
1724 log_set_target(LOG_TARGET_CONSOLE);
1725 log_notice("Setting log target to console.");
1729 log_set_target(LOG_TARGET_KMSG);
1730 log_notice("Setting log target to kmsg.");
1734 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1735 log_notice("Setting log target to syslog-or-kmsg.");
1739 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1746 manager_dispatch_sigchld(m);
1751 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1752 Manager *m = userdata;
1757 assert(m->time_change_fd == fd);
1759 log_struct(LOG_INFO,
1760 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1761 "MESSAGE=Time has been changed",
1764 /* Restart the watch */
1765 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1766 m->time_change_fd = safe_close(m->time_change_fd);
1768 manager_setup_time_change(m);
1770 HASHMAP_FOREACH(u, m->units, i)
1771 if (UNIT_VTABLE(u)->time_change)
1772 UNIT_VTABLE(u)->time_change(u);
1777 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1778 Manager *m = userdata;
1781 assert(m->idle_pipe[2] == fd);
1783 m->no_console_output = m->n_on_console > 0;
1785 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1786 manager_close_idle_pipe(m);
1791 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1792 Manager *m = userdata;
1799 manager_print_jobs_in_progress(m);
1801 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1802 r = sd_event_source_set_time(source, next);
1806 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1809 int manager_loop(Manager *m) {
1812 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1815 m->exit_code = MANAGER_OK;
1817 /* Release the path cache */
1818 set_free_free(m->unit_path_cache);
1819 m->unit_path_cache = NULL;
1821 manager_check_finished(m);
1823 /* There might still be some zombies hanging around from
1824 * before we were exec()'ed. Let's reap them. */
1825 r = manager_dispatch_sigchld(m);
1829 while (m->exit_code == MANAGER_OK) {
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_dbus_queue(m) > 0)
1857 /* Sleep for half the watchdog time */
1858 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1859 wait_usec = m->runtime_watchdog / 2;
1863 wait_usec = (usec_t) -1;
1865 r = sd_event_run(m->event, wait_usec);
1867 log_error("Failed to run event loop: %s", strerror(-r));
1872 return m->exit_code;
1875 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1876 _cleanup_free_ char *n = NULL;
1884 r = unit_name_from_dbus_path(s, &n);
1888 r = manager_load_unit(m, n, NULL, e, &u);
1897 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1907 p = startswith(s, "/org/freedesktop/systemd1/job/");
1911 r = safe_atou(p, &id);
1915 j = manager_get_job(m, id);
1924 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1927 _cleanup_free_ char *p = NULL;
1930 audit_fd = get_audit_fd();
1934 /* Don't generate audit events if the service was already
1935 * started and we're just deserializing */
1936 if (m->n_reloading > 0)
1939 if (m->running_as != SYSTEMD_SYSTEM)
1942 if (u->type != UNIT_SERVICE)
1945 p = unit_name_to_prefix_and_instance(u->id);
1947 log_error_unit(u->id,
1948 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1952 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1953 if (errno == EPERM) {
1954 /* We aren't allowed to send audit messages?
1955 * Then let's not retry again. */
1958 log_warning("Failed to send audit message: %m");
1964 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1965 union sockaddr_union sa = {
1966 .un.sun_family = AF_UNIX,
1967 .un.sun_path = "\0/org/freedesktop/plymouthd",
1971 _cleanup_free_ char *message = NULL;
1972 _cleanup_close_ int fd = -1;
1974 /* Don't generate plymouth events if the service was already
1975 * started and we're just deserializing */
1976 if (m->n_reloading > 0)
1979 if (m->running_as != SYSTEMD_SYSTEM)
1982 if (detect_container(NULL) > 0)
1985 if (u->type != UNIT_SERVICE &&
1986 u->type != UNIT_MOUNT &&
1987 u->type != UNIT_SWAP)
1990 /* We set SOCK_NONBLOCK here so that we rather drop the
1991 * message then wait for plymouth */
1992 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1994 log_error("socket() failed: %m");
1998 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2000 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2001 log_error("connect() failed: %m");
2005 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2011 if (write(fd, message, n + 1) != n + 1)
2012 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2013 log_error("Failed to write Plymouth message: %m");
2016 void manager_dispatch_bus_name_owner_changed(
2019 const char* old_owner,
2020 const char *new_owner) {
2027 u = hashmap_get(m->watch_bus, name);
2031 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2034 int manager_open_serialization(Manager *m, FILE **_f) {
2041 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2042 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2046 log_debug("Serializing state to %s", path);
2048 f = fdopen(fd, "w+");
2059 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2072 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2073 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2074 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2075 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2077 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2078 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2079 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2080 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2083 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2084 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2085 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2086 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2087 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2088 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2089 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2090 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2093 if (!switching_root) {
2094 STRV_FOREACH(e, m->environment) {
2095 _cleanup_free_ char *ce;
2101 fprintf(f, "env=%s\n", *e);
2105 if (m->notify_fd >= 0) {
2108 copy = fdset_put_dup(fds, m->notify_fd);
2112 fprintf(f, "notify-fd=%i\n", copy);
2113 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2116 if (m->kdbus_fd >= 0) {
2119 copy = fdset_put_dup(fds, m->kdbus_fd);
2123 fprintf(f, "kdbus-fd=%i\n", copy);
2126 bus_track_serialize(m->subscribed, f);
2130 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2138 r = unit_serialize(u, f, fds, !switching_root);
2145 assert(m->n_reloading > 0);
2151 r = bus_fdset_add_all(m, fds);
2158 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2164 log_debug("Deserializing state...");
2169 char line[LINE_MAX], *l;
2171 if (!fgets(line, sizeof(line), f)) {
2186 if (startswith(l, "current-job-id=")) {
2189 if (safe_atou32(l+15, &id) < 0)
2190 log_debug("Failed to parse current job id value %s", l+15);
2192 m->current_job_id = MAX(m->current_job_id, id);
2194 } else if (startswith(l, "n-installed-jobs=")) {
2197 if (safe_atou32(l+17, &n) < 0)
2198 log_debug("Failed to parse installed jobs counter %s", l+17);
2200 m->n_installed_jobs += n;
2202 } else if (startswith(l, "n-failed-jobs=")) {
2205 if (safe_atou32(l+14, &n) < 0)
2206 log_debug("Failed to parse failed jobs counter %s", l+14);
2208 m->n_failed_jobs += n;
2210 } else if (startswith(l, "taint-usr=")) {
2213 b = parse_boolean(l+10);
2215 log_debug("Failed to parse taint /usr flag %s", l+10);
2217 m->taint_usr = m->taint_usr || b;
2219 } else if (startswith(l, "firmware-timestamp="))
2220 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2221 else if (startswith(l, "loader-timestamp="))
2222 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2223 else if (startswith(l, "kernel-timestamp="))
2224 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2225 else if (startswith(l, "initrd-timestamp="))
2226 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2227 else if (startswith(l, "userspace-timestamp="))
2228 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2229 else if (startswith(l, "finish-timestamp="))
2230 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2231 else if (startswith(l, "security-start-timestamp="))
2232 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2233 else if (startswith(l, "security-finish-timestamp="))
2234 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2235 else if (startswith(l, "generators-start-timestamp="))
2236 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2237 else if (startswith(l, "generators-finish-timestamp="))
2238 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2239 else if (startswith(l, "units-load-start-timestamp="))
2240 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2241 else if (startswith(l, "units-load-finish-timestamp="))
2242 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2243 else if (startswith(l, "env=")) {
2244 _cleanup_free_ char *uce = NULL;
2247 uce = cunescape(l+4);
2253 e = strv_env_set(m->environment, uce);
2259 strv_free(m->environment);
2262 } else if (startswith(l, "notify-fd=")) {
2265 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2266 log_debug("Failed to parse notify fd: %s", l + 10);
2268 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2269 safe_close(m->notify_fd);
2270 m->notify_fd = fdset_remove(fds, fd);
2273 } else if (startswith(l, "notify-socket=")) {
2282 free(m->notify_socket);
2283 m->notify_socket = n;
2285 } else if (startswith(l, "kdbus-fd=")) {
2288 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2289 log_debug("Failed to parse kdbus fd: %s", l + 9);
2291 safe_close(m->kdbus_fd);
2292 m->kdbus_fd = fdset_remove(fds, fd);
2295 } else if (bus_track_deserialize_item(&m->deserialized_subscribed, l) == 0)
2296 log_debug("Unknown serialization item '%s'", l);
2301 char name[UNIT_NAME_MAX+2];
2304 if (!fgets(name, sizeof(name), f)) {
2315 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2319 r = unit_deserialize(u, f, fds);
2328 assert(m->n_reloading > 0);
2334 int manager_reload(Manager *m) {
2336 _cleanup_fclose_ FILE *f = NULL;
2337 _cleanup_fdset_free_ FDSet *fds = NULL;
2341 r = manager_open_serialization(m, &f);
2346 bus_manager_send_reloading(m, true);
2354 r = manager_serialize(m, f, fds, false);
2360 if (fseeko(f, 0, SEEK_SET) < 0) {
2365 /* From here on there is no way back. */
2366 manager_clear_jobs_and_units(m);
2367 manager_undo_generators(m);
2368 lookup_paths_free(&m->lookup_paths);
2370 /* Find new unit paths */
2371 manager_run_generators(m);
2373 q = lookup_paths_init(
2374 &m->lookup_paths, m->running_as, true,
2376 m->generator_unit_path,
2377 m->generator_unit_path_early,
2378 m->generator_unit_path_late);
2382 manager_build_unit_path_cache(m);
2384 /* First, enumerate what we can from all config files */
2385 q = manager_enumerate(m);
2389 /* Second, deserialize our stored data */
2390 q = manager_deserialize(m, f, fds);
2397 /* Re-register notify_fd as event source */
2398 q = manager_setup_notify(m);
2402 /* Third, fire things up! */
2403 q = manager_coldplug(m);
2407 assert(m->n_reloading > 0);
2410 m->send_reloading_done = true;
2415 bool manager_is_reloading_or_reexecuting(Manager *m) {
2418 return m->n_reloading != 0;
2421 void manager_reset_failed(Manager *m) {
2427 HASHMAP_FOREACH(u, m->units, i)
2428 unit_reset_failed(u);
2431 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2437 /* Returns true if the unit is inactive or going down */
2438 u = manager_get_unit(m, name);
2442 return unit_inactive_or_pending(u);
2445 void manager_check_finished(Manager *m) {
2446 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2447 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2451 if (m->n_running_jobs == 0)
2452 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2454 if (hashmap_size(m->jobs) > 0) {
2456 if (m->jobs_in_progress_event_source) {
2457 sd_event_source_set_time(m->jobs_in_progress_event_source,
2458 now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2464 manager_flip_auto_status(m, false);
2466 /* Notify Type=idle units that we are done now */
2467 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2468 manager_close_idle_pipe(m);
2470 /* Turn off confirm spawn now */
2471 m->confirm_spawn = false;
2473 if (dual_timestamp_is_set(&m->finish_timestamp))
2476 dual_timestamp_get(&m->finish_timestamp);
2478 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2480 /* Note that m->kernel_usec.monotonic is always at 0,
2481 * and m->firmware_usec.monotonic and
2482 * m->loader_usec.monotonic should be considered
2483 * negative values. */
2485 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2486 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2487 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2488 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2490 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2492 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2493 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2495 if (!log_on_console())
2496 log_struct(LOG_INFO,
2497 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2498 "KERNEL_USEC="USEC_FMT, kernel_usec,
2499 "INITRD_USEC="USEC_FMT, initrd_usec,
2500 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2501 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2502 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2503 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2504 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2505 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2508 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2511 if (!log_on_console())
2512 log_struct(LOG_INFO,
2513 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2514 "KERNEL_USEC="USEC_FMT, kernel_usec,
2515 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2516 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2517 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2518 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2519 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2523 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2524 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2526 if (!log_on_console())
2527 log_struct(LOG_INFO,
2528 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2529 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2530 "MESSAGE=Startup finished in %s.",
2531 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2535 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2538 "READY=1\nSTATUS=Startup finished in %s.",
2539 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2542 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2553 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2554 /* systemd --system, not running --test */
2556 p = strappend("/run/systemd/", name);
2560 r = mkdir_p_label(p, 0755);
2562 log_error("Failed to create generator directory %s: %s",
2567 } else if (m->running_as == SYSTEMD_USER) {
2568 const char *s = NULL;
2570 s = getenv("XDG_RUNTIME_DIR");
2573 p = strjoin(s, "/systemd/", name, NULL);
2577 r = mkdir_p_label(p, 0755);
2579 log_error("Failed to create generator directory %s: %s",
2585 /* systemd --system --test */
2587 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2592 log_error("Failed to create generator directory %s: %m",
2603 static void trim_generator_dir(Manager *m, char **generator) {
2610 if (rmdir(*generator) >= 0) {
2618 void manager_run_generators(Manager *m) {
2619 _cleanup_closedir_ DIR *d = NULL;
2620 const char *generator_path;
2621 const char *argv[5];
2626 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2627 d = opendir(generator_path);
2629 if (errno == ENOENT)
2632 log_error("Failed to enumerate generator directory %s: %m",
2637 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2641 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2645 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2649 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2650 argv[1] = m->generator_unit_path;
2651 argv[2] = m->generator_unit_path_early;
2652 argv[3] = m->generator_unit_path_late;
2655 RUN_WITH_UMASK(0022)
2656 execute_directory(generator_path, d, DEFAULT_TIMEOUT_USEC, (char**) argv);
2659 trim_generator_dir(m, &m->generator_unit_path);
2660 trim_generator_dir(m, &m->generator_unit_path_early);
2661 trim_generator_dir(m, &m->generator_unit_path_late);
2664 static void remove_generator_dir(Manager *m, char **generator) {
2671 strv_remove(m->lookup_paths.unit_path, *generator);
2672 rm_rf(*generator, false, true, false);
2678 void manager_undo_generators(Manager *m) {
2681 remove_generator_dir(m, &m->generator_unit_path);
2682 remove_generator_dir(m, &m->generator_unit_path_early);
2683 remove_generator_dir(m, &m->generator_unit_path_late);
2686 int manager_environment_add(Manager *m, char **minus, char **plus) {
2687 char **a = NULL, **b = NULL, **l;
2692 if (!strv_isempty(minus)) {
2693 a = strv_env_delete(l, 1, minus);
2700 if (!strv_isempty(plus)) {
2701 b = strv_env_merge(2, l, plus);
2708 if (m->environment != l)
2709 strv_free(m->environment);
2716 manager_clean_environment(m);
2717 strv_sort(m->environment);
2722 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2727 for (i = 0; i < _RLIMIT_MAX; i++) {
2728 if (!default_rlimit[i])
2731 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2739 void manager_recheck_journal(Manager *m) {
2744 if (m->running_as != SYSTEMD_SYSTEM)
2747 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2748 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2749 log_close_journal();
2753 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2754 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2755 log_close_journal();
2759 /* Hmm, OK, so the socket is fully up and the service is up
2760 * too, then let's make use of the thing. */
2764 void manager_set_show_status(Manager *m, ShowStatus mode) {
2766 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2768 if (m->running_as != SYSTEMD_SYSTEM)
2771 m->show_status = mode;
2774 touch("/run/systemd/show-status");
2776 unlink("/run/systemd/show-status");
2779 static bool manager_get_show_status(Manager *m) {
2782 if (m->running_as != SYSTEMD_SYSTEM)
2785 if (m->no_console_output)
2788 if (!IN_SET(manager_state(m), MANAGER_STARTING, MANAGER_STOPPING))
2791 if (m->show_status > 0)
2794 /* If Plymouth is running make sure we show the status, so
2795 * that there's something nice to see when people press Esc */
2797 return plymouth_running();
2800 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2803 if (!manager_get_show_status(m))
2806 /* XXX We should totally drop the check for ephemeral here
2807 * and thus effectively make 'Type=idle' pointless. */
2808 if (ephemeral && m->n_on_console > 0)
2811 va_start(ap, format);
2812 status_vprintf(status, true, ephemeral, format, ap);
2816 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2817 _cleanup_free_ char *p = NULL;
2825 p = unit_name_from_path(path, suffix);
2829 found = manager_get_unit(m, p);
2839 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2840 char p[strlen(path)+1];
2846 path_kill_slashes(p);
2848 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
2851 const char *manager_get_runtime_prefix(Manager *m) {
2854 return m->running_as == SYSTEMD_SYSTEM ?
2856 getenv("XDG_RUNTIME_DIR");
2859 ManagerState manager_state(Manager *m) {
2864 /* Did we ever finish booting? If not then we are still starting up */
2865 if (!dual_timestamp_is_set(&m->finish_timestamp))
2866 return MANAGER_STARTING;
2868 /* Is the special shutdown target queued? If so, we are in shutdown state */
2869 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2870 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
2871 return MANAGER_STOPPING;
2873 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
2874 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
2875 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2876 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2877 return MANAGER_MAINTENANCE;
2879 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
2880 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2881 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2882 return MANAGER_MAINTENANCE;
2884 /* Are there any failed units? If so, we are in degraded mode */
2885 if (set_size(m->failed_units) > 0)
2886 return MANAGER_DEGRADED;
2888 return MANAGER_RUNNING;
2891 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
2892 [MANAGER_STARTING] = "starting",
2893 [MANAGER_RUNNING] = "running",
2894 [MANAGER_DEGRADED] = "degraded",
2895 [MANAGER_MAINTENANCE] = "maintenance",
2896 [MANAGER_STOPPING] = "stopping",
2899 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);