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,
971 m->generator_unit_path,
972 m->generator_unit_path_early,
973 m->generator_unit_path_late);
977 manager_build_unit_path_cache(m);
979 /* If we will deserialize make sure that during enumeration
980 * this is already known, so we increase the counter here
985 /* First, enumerate what we can from all config files */
986 dual_timestamp_get(&m->units_load_start_timestamp);
987 r = manager_enumerate(m);
988 dual_timestamp_get(&m->units_load_finish_timestamp);
990 /* Second, deserialize if there is something to deserialize */
992 q = manager_deserialize(m, serialization, fds);
997 /* Any fds left? Find some unit which wants them. This is
998 * useful to allow container managers to pass some file
999 * descriptors to us pre-initialized. This enables
1000 * socket-based activation of entire containers. */
1001 if (fdset_size(fds) > 0) {
1002 q = manager_distribute_fds(m, fds);
1007 /* We might have deserialized the notify fd, but if we didn't
1008 * then let's create the bus now */
1009 manager_setup_notify(m);
1011 /* We might have deserialized the kdbus control fd, but if we
1012 * didn't, then let's create the bus now. */
1013 manager_setup_kdbus(m);
1014 manager_connect_bus(m, !!serialization);
1015 bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
1017 /* Third, fire things up! */
1018 q = manager_coldplug(m);
1022 if (serialization) {
1023 assert(m->n_reloading > 0);
1026 /* Let's wait for the UnitNew/JobNew messages being
1027 * sent, before we notify that the reload is
1029 m->send_reloading_done = true;
1035 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1040 assert(type < _JOB_TYPE_MAX);
1042 assert(mode < _JOB_MODE_MAX);
1044 if (mode == JOB_ISOLATE && type != JOB_START) {
1045 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1049 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1050 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1054 log_debug_unit(unit->id,
1055 "Trying to enqueue job %s/%s/%s", unit->id,
1056 job_type_to_string(type), job_mode_to_string(mode));
1058 job_type_collapse(&type, unit);
1060 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1064 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1065 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1066 mode == JOB_IGNORE_DEPENDENCIES, e);
1070 if (mode == JOB_ISOLATE) {
1071 r = transaction_add_isolate_jobs(tr, m);
1076 r = transaction_activate(tr, m, mode, e);
1080 log_debug_unit(unit->id,
1081 "Enqueued job %s/%s as %u", unit->id,
1082 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1085 *_ret = tr->anchor_job;
1087 transaction_free(tr);
1091 transaction_abort(tr);
1092 transaction_free(tr);
1096 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1101 assert(type < _JOB_TYPE_MAX);
1103 assert(mode < _JOB_MODE_MAX);
1105 r = manager_load_unit(m, name, NULL, NULL, &unit);
1109 return manager_add_job(m, type, unit, mode, override, e, _ret);
1112 Job *manager_get_job(Manager *m, uint32_t id) {
1115 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1118 Unit *manager_get_unit(Manager *m, const char *name) {
1122 return hashmap_get(m->units, name);
1125 unsigned manager_dispatch_load_queue(Manager *m) {
1131 /* Make sure we are not run recursively */
1132 if (m->dispatching_load_queue)
1135 m->dispatching_load_queue = true;
1137 /* Dispatches the load queue. Takes a unit from the queue and
1138 * tries to load its data until the queue is empty */
1140 while ((u = m->load_queue)) {
1141 assert(u->in_load_queue);
1147 m->dispatching_load_queue = false;
1151 int manager_load_unit_prepare(
1163 assert(name || path);
1165 /* This will prepare the unit for loading, but not actually
1166 * load anything from disk. */
1168 if (path && !is_path(path))
1169 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1172 name = basename(path);
1174 t = unit_name_to_type(name);
1176 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1177 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1179 ret = manager_get_unit(m, name);
1185 ret = unit_new(m, unit_vtable[t]->object_size);
1190 ret->fragment_path = strdup(path);
1191 if (!ret->fragment_path) {
1197 r = unit_add_name(ret, name);
1203 unit_add_to_load_queue(ret);
1204 unit_add_to_dbus_queue(ret);
1205 unit_add_to_gc_queue(ret);
1213 int manager_load_unit(
1224 /* This will load the service information files, but not actually
1225 * start any services or anything. */
1227 r = manager_load_unit_prepare(m, name, path, e, _ret);
1231 manager_dispatch_load_queue(m);
1234 *_ret = unit_follow_merge(*_ret);
1239 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1246 HASHMAP_FOREACH(j, s->jobs, i)
1247 job_dump(j, f, prefix);
1250 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1258 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1260 unit_dump(u, f, prefix);
1263 void manager_clear_jobs(Manager *m) {
1268 while ((j = hashmap_first(m->jobs)))
1269 /* No need to recurse. We're cancelling all jobs. */
1270 job_finish_and_invalidate(j, JOB_CANCELED, false);
1273 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1274 Manager *m = userdata;
1280 while ((j = m->run_queue)) {
1281 assert(j->installed);
1282 assert(j->in_run_queue);
1284 job_run_and_invalidate(j);
1287 if (m->n_running_jobs > 0)
1288 manager_watch_jobs_in_progress(m);
1290 if (m->n_on_console > 0)
1291 manager_watch_idle_pipe(m);
1296 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1303 if (m->dispatching_dbus_queue)
1306 m->dispatching_dbus_queue = true;
1308 while ((u = m->dbus_unit_queue)) {
1309 assert(u->in_dbus_queue);
1311 bus_unit_send_change_signal(u);
1315 while ((j = m->dbus_job_queue)) {
1316 assert(j->in_dbus_queue);
1318 bus_job_send_change_signal(j);
1322 m->dispatching_dbus_queue = false;
1324 if (m->send_reloading_done) {
1325 m->send_reloading_done = false;
1327 bus_manager_send_reloading(m, false);
1330 if (m->queued_message)
1331 bus_send_queued_message(m);
1336 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n) {
1337 _cleanup_strv_free_ char **tags = NULL;
1344 tags = strv_split(buf, "\n\r");
1350 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1352 if (UNIT_VTABLE(u)->notify_message)
1353 UNIT_VTABLE(u)->notify_message(u, pid, tags);
1356 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1357 Manager *m = userdata;
1361 assert(m->notify_fd == fd);
1363 if (revents != EPOLLIN) {
1364 log_warning("Got unexpected poll event for notify fd.");
1370 struct iovec iovec = {
1372 .iov_len = sizeof(buf)-1,
1377 struct cmsghdr cmsghdr;
1378 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1381 struct msghdr msghdr = {
1384 .msg_control = &control,
1385 .msg_controllen = sizeof(control),
1387 struct ucred *ucred;
1390 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1395 if (errno == EAGAIN || errno == EINTR)
1401 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1402 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1403 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1404 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1405 log_warning("Received notify message without credentials. Ignoring.");
1409 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1411 assert((size_t) n < sizeof(buf));
1414 u = manager_get_unit_by_pid(m, ucred->pid);
1416 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1420 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1422 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1426 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1428 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1433 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1439 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1444 log_debug_unit(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1446 unit_unwatch_pid(u, si->si_pid);
1447 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1450 static int manager_dispatch_sigchld(Manager *m) {
1456 /* First we call waitd() for a PID and do not reap the
1457 * zombie. That way we can still access /proc/$PID for
1458 * it while it is a zombie. */
1459 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1461 if (errno == ECHILD)
1473 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1474 _cleanup_free_ char *name = NULL;
1477 get_process_comm(si.si_pid, &name);
1479 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1480 si.si_pid, strna(name),
1481 sigchld_code_to_string(si.si_code),
1483 strna(si.si_code == CLD_EXITED
1484 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1485 : signal_to_string(si.si_status)));
1487 /* And now figure out the unit this belongs
1488 * to, it might be multiple... */
1489 u = manager_get_unit_by_pid(m, si.si_pid);
1491 invoke_sigchld_event(m, u, &si);
1492 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1494 invoke_sigchld_event(m, u, &si);
1495 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1497 invoke_sigchld_event(m, u, &si);
1500 /* And now, we actually reap the zombie. */
1501 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1512 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1513 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1516 log_debug_unit(name, "Activating special unit %s", name);
1518 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1520 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1525 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1526 Manager *m = userdata;
1528 struct signalfd_siginfo sfsi;
1529 bool sigchld = false;
1532 assert(m->signal_fd == fd);
1534 if (revents != EPOLLIN) {
1535 log_warning("Got unexpected events from signal file descriptor.");
1540 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1541 if (n != sizeof(sfsi)) {
1546 if (errno == EINTR || errno == EAGAIN)
1552 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1553 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1554 ? LOG_DEBUG : LOG_INFO,
1557 switch (sfsi.ssi_signo) {
1564 if (m->running_as == SYSTEMD_SYSTEM) {
1565 /* This is for compatibility with the
1566 * original sysvinit */
1567 m->exit_code = MANAGER_REEXECUTE;
1574 if (m->running_as == SYSTEMD_SYSTEM) {
1575 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1579 /* Run the exit target if there is one, if not, just exit. */
1580 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1581 m->exit_code = MANAGER_EXIT;
1588 if (m->running_as == SYSTEMD_SYSTEM)
1589 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1591 /* This is a nop on non-init */
1595 if (m->running_as == SYSTEMD_SYSTEM)
1596 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1598 /* This is a nop on non-init */
1604 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1606 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1607 log_info("Trying to reconnect to bus...");
1611 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1612 log_info("Loading D-Bus service...");
1613 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1620 _cleanup_free_ char *dump = NULL;
1621 _cleanup_fclose_ FILE *f = NULL;
1624 f = open_memstream(&dump, &size);
1626 log_warning("Failed to allocate memory stream.");
1630 manager_dump_units(m, f, "\t");
1631 manager_dump_jobs(m, f, "\t");
1634 log_warning("Failed to write status stream");
1639 log_warning("Failed to flush status stream");
1643 log_dump(LOG_INFO, dump);
1648 m->exit_code = MANAGER_RELOAD;
1653 /* Starting SIGRTMIN+0 */
1654 static const char * const target_table[] = {
1655 [0] = SPECIAL_DEFAULT_TARGET,
1656 [1] = SPECIAL_RESCUE_TARGET,
1657 [2] = SPECIAL_EMERGENCY_TARGET,
1658 [3] = SPECIAL_HALT_TARGET,
1659 [4] = SPECIAL_POWEROFF_TARGET,
1660 [5] = SPECIAL_REBOOT_TARGET,
1661 [6] = SPECIAL_KEXEC_TARGET
1664 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1665 static const ManagerExitCode code_table[] = {
1667 [1] = MANAGER_POWEROFF,
1668 [2] = MANAGER_REBOOT,
1672 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1673 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1674 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1675 manager_start_target(m, target_table[idx],
1676 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1680 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1681 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1682 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1686 switch (sfsi.ssi_signo - SIGRTMIN) {
1689 log_debug("Enabling showing of status.");
1690 manager_set_show_status(m, SHOW_STATUS_YES);
1694 log_debug("Disabling showing of status.");
1695 manager_set_show_status(m, SHOW_STATUS_NO);
1699 log_set_max_level(LOG_DEBUG);
1700 log_notice("Setting log level to debug.");
1704 log_set_max_level(LOG_INFO);
1705 log_notice("Setting log level to info.");
1709 if (m->running_as == SYSTEMD_USER) {
1710 m->exit_code = MANAGER_EXIT;
1714 /* This is a nop on init */
1718 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1719 log_notice("Setting log target to journal-or-kmsg.");
1723 log_set_target(LOG_TARGET_CONSOLE);
1724 log_notice("Setting log target to console.");
1728 log_set_target(LOG_TARGET_KMSG);
1729 log_notice("Setting log target to kmsg.");
1733 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1734 log_notice("Setting log target to syslog-or-kmsg.");
1738 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1745 manager_dispatch_sigchld(m);
1750 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1751 Manager *m = userdata;
1756 assert(m->time_change_fd == fd);
1758 log_struct(LOG_INFO,
1759 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1760 "MESSAGE=Time has been changed",
1763 /* Restart the watch */
1764 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1765 m->time_change_fd = safe_close(m->time_change_fd);
1767 manager_setup_time_change(m);
1769 HASHMAP_FOREACH(u, m->units, i)
1770 if (UNIT_VTABLE(u)->time_change)
1771 UNIT_VTABLE(u)->time_change(u);
1776 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1777 Manager *m = userdata;
1780 assert(m->idle_pipe[2] == fd);
1782 m->no_console_output = m->n_on_console > 0;
1784 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1785 manager_close_idle_pipe(m);
1790 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1791 Manager *m = userdata;
1798 manager_print_jobs_in_progress(m);
1800 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1801 r = sd_event_source_set_time(source, next);
1805 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1808 int manager_loop(Manager *m) {
1811 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1814 m->exit_code = MANAGER_OK;
1816 /* Release the path cache */
1817 set_free_free(m->unit_path_cache);
1818 m->unit_path_cache = NULL;
1820 manager_check_finished(m);
1822 /* There might still be some zombies hanging around from
1823 * before we were exec()'ed. Let's reap them. */
1824 r = manager_dispatch_sigchld(m);
1828 while (m->exit_code == MANAGER_OK) {
1831 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1834 if (!ratelimit_test(&rl)) {
1835 /* Yay, something is going seriously wrong, pause a little */
1836 log_warning("Looping too fast. Throttling execution a little.");
1841 if (manager_dispatch_load_queue(m) > 0)
1844 if (manager_dispatch_gc_queue(m) > 0)
1847 if (manager_dispatch_cleanup_queue(m) > 0)
1850 if (manager_dispatch_cgroup_queue(m) > 0)
1853 if (manager_dispatch_dbus_queue(m) > 0)
1856 /* Sleep for half the watchdog time */
1857 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1858 wait_usec = m->runtime_watchdog / 2;
1862 wait_usec = (usec_t) -1;
1864 r = sd_event_run(m->event, wait_usec);
1866 log_error("Failed to run event loop: %s", strerror(-r));
1871 return m->exit_code;
1874 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1875 _cleanup_free_ char *n = NULL;
1883 r = unit_name_from_dbus_path(s, &n);
1887 r = manager_load_unit(m, n, NULL, e, &u);
1896 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1906 p = startswith(s, "/org/freedesktop/systemd1/job/");
1910 r = safe_atou(p, &id);
1914 j = manager_get_job(m, id);
1923 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1926 _cleanup_free_ char *p = NULL;
1929 audit_fd = get_audit_fd();
1933 /* Don't generate audit events if the service was already
1934 * started and we're just deserializing */
1935 if (m->n_reloading > 0)
1938 if (m->running_as != SYSTEMD_SYSTEM)
1941 if (u->type != UNIT_SERVICE)
1944 p = unit_name_to_prefix_and_instance(u->id);
1946 log_error_unit(u->id,
1947 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1951 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1952 if (errno == EPERM) {
1953 /* We aren't allowed to send audit messages?
1954 * Then let's not retry again. */
1957 log_warning("Failed to send audit message: %m");
1963 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1964 union sockaddr_union sa = {
1965 .un.sun_family = AF_UNIX,
1966 .un.sun_path = "\0/org/freedesktop/plymouthd",
1970 _cleanup_free_ char *message = NULL;
1971 _cleanup_close_ int fd = -1;
1973 /* Don't generate plymouth events if the service was already
1974 * started and we're just deserializing */
1975 if (m->n_reloading > 0)
1978 if (m->running_as != SYSTEMD_SYSTEM)
1981 if (detect_container(NULL) > 0)
1984 if (u->type != UNIT_SERVICE &&
1985 u->type != UNIT_MOUNT &&
1986 u->type != UNIT_SWAP)
1989 /* We set SOCK_NONBLOCK here so that we rather drop the
1990 * message then wait for plymouth */
1991 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1993 log_error("socket() failed: %m");
1997 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1999 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2000 log_error("connect() failed: %m");
2004 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2010 if (write(fd, message, n + 1) != n + 1)
2011 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2012 log_error("Failed to write Plymouth message: %m");
2015 void manager_dispatch_bus_name_owner_changed(
2018 const char* old_owner,
2019 const char *new_owner) {
2026 u = hashmap_get(m->watch_bus, name);
2030 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2033 int manager_open_serialization(Manager *m, FILE **_f) {
2040 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2041 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2045 log_debug("Serializing state to %s", path);
2047 f = fdopen(fd, "w+");
2058 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2071 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2072 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2073 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2074 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2076 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2077 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2078 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2079 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2082 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2083 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2084 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2085 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2086 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2087 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2088 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2089 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2092 if (!switching_root) {
2093 STRV_FOREACH(e, m->environment) {
2094 _cleanup_free_ char *ce;
2100 fprintf(f, "env=%s\n", *e);
2104 if (m->notify_fd >= 0) {
2107 copy = fdset_put_dup(fds, m->notify_fd);
2111 fprintf(f, "notify-fd=%i\n", copy);
2112 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2115 if (m->kdbus_fd >= 0) {
2118 copy = fdset_put_dup(fds, m->kdbus_fd);
2122 fprintf(f, "kdbus-fd=%i\n", copy);
2125 bus_track_serialize(m->subscribed, f);
2129 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2133 if (!unit_can_serialize(u))
2140 r = unit_serialize(u, f, fds, !switching_root);
2147 assert(m->n_reloading > 0);
2153 r = bus_fdset_add_all(m, fds);
2160 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2166 log_debug("Deserializing state...");
2171 char line[LINE_MAX], *l;
2173 if (!fgets(line, sizeof(line), f)) {
2188 if (startswith(l, "current-job-id=")) {
2191 if (safe_atou32(l+15, &id) < 0)
2192 log_debug("Failed to parse current job id value %s", l+15);
2194 m->current_job_id = MAX(m->current_job_id, id);
2196 } else if (startswith(l, "n-installed-jobs=")) {
2199 if (safe_atou32(l+17, &n) < 0)
2200 log_debug("Failed to parse installed jobs counter %s", l+17);
2202 m->n_installed_jobs += n;
2204 } else if (startswith(l, "n-failed-jobs=")) {
2207 if (safe_atou32(l+14, &n) < 0)
2208 log_debug("Failed to parse failed jobs counter %s", l+14);
2210 m->n_failed_jobs += n;
2212 } else if (startswith(l, "taint-usr=")) {
2215 b = parse_boolean(l+10);
2217 log_debug("Failed to parse taint /usr flag %s", l+10);
2219 m->taint_usr = m->taint_usr || b;
2221 } else if (startswith(l, "firmware-timestamp="))
2222 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2223 else if (startswith(l, "loader-timestamp="))
2224 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2225 else if (startswith(l, "kernel-timestamp="))
2226 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2227 else if (startswith(l, "initrd-timestamp="))
2228 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2229 else if (startswith(l, "userspace-timestamp="))
2230 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2231 else if (startswith(l, "finish-timestamp="))
2232 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2233 else if (startswith(l, "security-start-timestamp="))
2234 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2235 else if (startswith(l, "security-finish-timestamp="))
2236 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2237 else if (startswith(l, "generators-start-timestamp="))
2238 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2239 else if (startswith(l, "generators-finish-timestamp="))
2240 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2241 else if (startswith(l, "units-load-start-timestamp="))
2242 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2243 else if (startswith(l, "units-load-finish-timestamp="))
2244 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2245 else if (startswith(l, "env=")) {
2246 _cleanup_free_ char *uce = NULL;
2249 uce = cunescape(l+4);
2255 e = strv_env_set(m->environment, uce);
2261 strv_free(m->environment);
2264 } else if (startswith(l, "notify-fd=")) {
2267 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2268 log_debug("Failed to parse notify fd: %s", l + 10);
2270 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2271 safe_close(m->notify_fd);
2272 m->notify_fd = fdset_remove(fds, fd);
2275 } else if (startswith(l, "notify-socket=")) {
2284 free(m->notify_socket);
2285 m->notify_socket = n;
2287 } else if (startswith(l, "kdbus-fd=")) {
2290 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2291 log_debug("Failed to parse kdbus fd: %s", l + 9);
2293 safe_close(m->kdbus_fd);
2294 m->kdbus_fd = fdset_remove(fds, fd);
2297 } else if (bus_track_deserialize_item(&m->deserialized_subscribed, l) == 0)
2298 log_debug("Unknown serialization item '%s'", l);
2303 char name[UNIT_NAME_MAX+2];
2306 if (!fgets(name, sizeof(name), f)) {
2317 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2321 r = unit_deserialize(u, f, fds);
2330 assert(m->n_reloading > 0);
2336 int manager_reload(Manager *m) {
2338 _cleanup_fclose_ FILE *f = NULL;
2339 _cleanup_fdset_free_ FDSet *fds = NULL;
2343 r = manager_open_serialization(m, &f);
2348 bus_manager_send_reloading(m, true);
2356 r = manager_serialize(m, f, fds, false);
2362 if (fseeko(f, 0, SEEK_SET) < 0) {
2367 /* From here on there is no way back. */
2368 manager_clear_jobs_and_units(m);
2369 manager_undo_generators(m);
2370 lookup_paths_free(&m->lookup_paths);
2372 /* Find new unit paths */
2373 manager_run_generators(m);
2375 q = lookup_paths_init(
2376 &m->lookup_paths, m->running_as, true,
2377 m->generator_unit_path,
2378 m->generator_unit_path_early,
2379 m->generator_unit_path_late);
2383 manager_build_unit_path_cache(m);
2385 /* First, enumerate what we can from all config files */
2386 q = manager_enumerate(m);
2390 /* Second, deserialize our stored data */
2391 q = manager_deserialize(m, f, fds);
2398 /* Re-register notify_fd as event source */
2399 q = manager_setup_notify(m);
2403 /* Third, fire things up! */
2404 q = manager_coldplug(m);
2408 assert(m->n_reloading > 0);
2411 m->send_reloading_done = true;
2416 bool manager_is_reloading_or_reexecuting(Manager *m) {
2419 return m->n_reloading != 0;
2422 void manager_reset_failed(Manager *m) {
2428 HASHMAP_FOREACH(u, m->units, i)
2429 unit_reset_failed(u);
2432 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2438 /* Returns true if the unit is inactive or going down */
2439 u = manager_get_unit(m, name);
2443 return unit_inactive_or_pending(u);
2446 void manager_check_finished(Manager *m) {
2447 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2448 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2452 if (m->n_running_jobs == 0)
2453 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2455 if (hashmap_size(m->jobs) > 0) {
2457 if (m->jobs_in_progress_event_source) {
2458 sd_event_source_set_time(m->jobs_in_progress_event_source,
2459 now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2465 manager_flip_auto_status(m, false);
2467 /* Notify Type=idle units that we are done now */
2468 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2469 manager_close_idle_pipe(m);
2471 /* Turn off confirm spawn now */
2472 m->confirm_spawn = false;
2474 if (dual_timestamp_is_set(&m->finish_timestamp))
2477 dual_timestamp_get(&m->finish_timestamp);
2479 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2481 /* Note that m->kernel_usec.monotonic is always at 0,
2482 * and m->firmware_usec.monotonic and
2483 * m->loader_usec.monotonic should be considered
2484 * negative values. */
2486 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2487 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2488 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2489 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2491 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2493 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2494 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2496 if (!log_on_console())
2497 log_struct(LOG_INFO,
2498 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2499 "KERNEL_USEC="USEC_FMT, kernel_usec,
2500 "INITRD_USEC="USEC_FMT, initrd_usec,
2501 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2502 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2503 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2504 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2505 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2506 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2509 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2512 if (!log_on_console())
2513 log_struct(LOG_INFO,
2514 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2515 "KERNEL_USEC="USEC_FMT, kernel_usec,
2516 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2517 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2518 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2519 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2520 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2524 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2525 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2527 if (!log_on_console())
2528 log_struct(LOG_INFO,
2529 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2530 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2531 "MESSAGE=Startup finished in %s.",
2532 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2536 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2539 "READY=1\nSTATUS=Startup finished in %s.",
2540 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2543 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2554 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2555 /* systemd --system, not running --test */
2557 p = strappend("/run/systemd/", name);
2561 r = mkdir_p_label(p, 0755);
2563 log_error("Failed to create generator directory %s: %s",
2568 } else if (m->running_as == SYSTEMD_USER) {
2569 const char *s = NULL;
2571 s = getenv("XDG_RUNTIME_DIR");
2574 p = strjoin(s, "/systemd/", name, NULL);
2578 r = mkdir_p_label(p, 0755);
2580 log_error("Failed to create generator directory %s: %s",
2586 /* systemd --system --test */
2588 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2593 log_error("Failed to create generator directory %s: %m",
2604 static void trim_generator_dir(Manager *m, char **generator) {
2611 if (rmdir(*generator) >= 0) {
2619 void manager_run_generators(Manager *m) {
2620 _cleanup_closedir_ DIR *d = NULL;
2621 const char *generator_path;
2622 const char *argv[5];
2627 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2628 d = opendir(generator_path);
2630 if (errno == ENOENT)
2633 log_error("Failed to enumerate generator directory %s: %m",
2638 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2642 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2646 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2650 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2651 argv[1] = m->generator_unit_path;
2652 argv[2] = m->generator_unit_path_early;
2653 argv[3] = m->generator_unit_path_late;
2656 RUN_WITH_UMASK(0022)
2657 execute_directory(generator_path, d, DEFAULT_TIMEOUT_USEC, (char**) argv);
2660 trim_generator_dir(m, &m->generator_unit_path);
2661 trim_generator_dir(m, &m->generator_unit_path_early);
2662 trim_generator_dir(m, &m->generator_unit_path_late);
2665 static void remove_generator_dir(Manager *m, char **generator) {
2672 strv_remove(m->lookup_paths.unit_path, *generator);
2673 rm_rf(*generator, false, true, false);
2679 void manager_undo_generators(Manager *m) {
2682 remove_generator_dir(m, &m->generator_unit_path);
2683 remove_generator_dir(m, &m->generator_unit_path_early);
2684 remove_generator_dir(m, &m->generator_unit_path_late);
2687 int manager_environment_add(Manager *m, char **minus, char **plus) {
2688 char **a = NULL, **b = NULL, **l;
2693 if (!strv_isempty(minus)) {
2694 a = strv_env_delete(l, 1, minus);
2701 if (!strv_isempty(plus)) {
2702 b = strv_env_merge(2, l, plus);
2709 if (m->environment != l)
2710 strv_free(m->environment);
2717 manager_clean_environment(m);
2718 strv_sort(m->environment);
2723 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2728 for (i = 0; i < _RLIMIT_MAX; i++) {
2729 if (!default_rlimit[i])
2732 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2740 void manager_recheck_journal(Manager *m) {
2745 if (m->running_as != SYSTEMD_SYSTEM)
2748 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2749 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2750 log_close_journal();
2754 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2755 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2756 log_close_journal();
2760 /* Hmm, OK, so the socket is fully up and the service is up
2761 * too, then let's make use of the thing. */
2765 void manager_set_show_status(Manager *m, ShowStatus mode) {
2767 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2769 if (m->running_as != SYSTEMD_SYSTEM)
2772 m->show_status = mode;
2775 touch("/run/systemd/show-status");
2777 unlink("/run/systemd/show-status");
2780 static bool manager_get_show_status(Manager *m) {
2783 if (m->running_as != SYSTEMD_SYSTEM)
2786 if (m->no_console_output)
2789 if (!IN_SET(manager_state(m), MANAGER_STARTING, MANAGER_STOPPING))
2792 if (m->show_status > 0)
2795 /* If Plymouth is running make sure we show the status, so
2796 * that there's something nice to see when people press Esc */
2798 return plymouth_running();
2801 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2804 if (!manager_get_show_status(m))
2807 /* XXX We should totally drop the check for ephemeral here
2808 * and thus effectively make 'Type=idle' pointless. */
2809 if (ephemeral && m->n_on_console > 0)
2812 va_start(ap, format);
2813 status_vprintf(status, true, ephemeral, format, ap);
2817 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2818 _cleanup_free_ char *p = NULL;
2826 p = unit_name_from_path(path, suffix);
2830 found = manager_get_unit(m, p);
2840 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2841 char p[strlen(path)+1];
2847 path_kill_slashes(p);
2849 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
2852 const char *manager_get_runtime_prefix(Manager *m) {
2855 return m->running_as == SYSTEMD_SYSTEM ?
2857 getenv("XDG_RUNTIME_DIR");
2860 ManagerState manager_state(Manager *m) {
2865 /* Did we ever finish booting? If not then we are still starting up */
2866 if (!dual_timestamp_is_set(&m->finish_timestamp))
2867 return MANAGER_STARTING;
2869 /* Is the special shutdown target queued? If so, we are in shutdown state */
2870 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2871 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
2872 return MANAGER_STOPPING;
2874 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
2875 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
2876 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2877 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2878 return MANAGER_MAINTENANCE;
2880 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
2881 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2882 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2883 return MANAGER_MAINTENANCE;
2885 /* Are there any failed units? If so, we are in degraded mode */
2886 if (set_size(m->failed_units) > 0)
2887 return MANAGER_DEGRADED;
2889 return MANAGER_RUNNING;
2892 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
2893 [MANAGER_STARTING] = "starting",
2894 [MANAGER_RUNNING] = "running",
2895 [MANAGER_DEGRADED] = "degraded",
2896 [MANAGER_MAINTENANCE] = "maintenance",
2897 [MANAGER_STOPPING] = "stopping",
2900 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);