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_monotonic(m->event, &m->jobs_in_progress_event_source, next, 0, manager_dispatch_jobs_in_progress, m);
108 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
110 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
113 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
114 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
118 p = mempset(p, ' ', pos-2);
119 p = stpcpy(p, ANSI_RED_ON);
123 if (pos > 0 && pos <= width) {
124 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
128 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
131 p = stpcpy(p, ANSI_RED_ON);
134 p = mempset(p, ' ', width-1-pos);
135 strcpy(p, ANSI_HIGHLIGHT_OFF);
139 void manager_flip_auto_status(Manager *m, bool enable) {
143 if (m->show_status == SHOW_STATUS_AUTO)
144 manager_set_show_status(m, SHOW_STATUS_TEMPORARY);
146 if (m->show_status == SHOW_STATUS_TEMPORARY)
147 manager_set_show_status(m, SHOW_STATUS_AUTO);
151 static void manager_print_jobs_in_progress(Manager *m) {
152 _cleanup_free_ char *job_of_n = NULL;
155 unsigned counter = 0, print_nr;
156 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
158 char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
163 manager_flip_auto_status(m, true);
165 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
167 HASHMAP_FOREACH(j, m->jobs, i)
168 if (j->state == JOB_RUNNING && counter++ == print_nr)
171 /* m->n_running_jobs must be consistent with the contents of m->jobs,
172 * so the above loop must have succeeded in finding j. */
173 assert(counter == print_nr + 1);
176 cylon_pos = m->jobs_in_progress_iteration % 14;
178 cylon_pos = 14 - cylon_pos;
179 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
181 m->jobs_in_progress_iteration++;
183 if (m->n_running_jobs > 1)
184 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
187 format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
188 if (job_get_timeout(j, &x) > 0)
189 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
191 manager_status_printf(m, true, cylon,
192 "%sA %s job is running for %s (%s / %s)",
194 job_type_to_string(j->type),
195 unit_description(j->unit),
200 static int manager_watch_idle_pipe(Manager *m) {
205 if (m->idle_pipe_event_source)
208 if (m->idle_pipe[2] < 0)
211 r = sd_event_add_io(m->event, &m->idle_pipe_event_source, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m);
213 log_error("Failed to watch idle pipe: %s", strerror(-r));
220 static void manager_close_idle_pipe(Manager *m) {
223 close_pipe(m->idle_pipe);
224 close_pipe(m->idle_pipe + 2);
227 static int manager_setup_time_change(Manager *m) {
230 /* We only care for the cancellation event, hence we set the
231 * timeout to the latest possible value. */
232 struct itimerspec its = {
233 .it_value.tv_sec = TIME_T_MAX,
237 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
239 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
240 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
242 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
243 if (m->time_change_fd < 0) {
244 log_error("Failed to create timerfd: %m");
248 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
249 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
250 m->time_change_fd = safe_close(m->time_change_fd);
254 r = sd_event_add_io(m->event, &m->time_change_event_source, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m);
256 log_error("Failed to create time change event source: %s", strerror(-r));
260 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
265 static int enable_special_signals(Manager *m) {
266 _cleanup_close_ int fd = -1;
270 /* Enable that we get SIGINT on control-alt-del. In containers
271 * this will fail with EPERM (older) or EINVAL (newer), so
273 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
274 log_warning("Failed to enable ctrl-alt-del handling: %m");
276 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
278 /* Support systems without virtual console */
280 log_warning("Failed to open /dev/tty0: %m");
282 /* Enable that we get SIGWINCH on kbrequest */
283 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
284 log_warning("Failed to enable kbrequest handling: %m");
290 static int manager_setup_signals(Manager *m) {
291 struct sigaction sa = {
292 .sa_handler = SIG_DFL,
293 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
300 /* We are not interested in SIGSTOP and friends. */
301 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
303 assert_se(sigemptyset(&mask) == 0);
305 sigset_add_many(&mask,
306 SIGCHLD, /* Child died */
307 SIGTERM, /* Reexecute daemon */
308 SIGHUP, /* Reload configuration */
309 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
310 SIGUSR2, /* systemd: dump status */
311 SIGINT, /* Kernel sends us this on control-alt-del */
312 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
313 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
314 SIGRTMIN+0, /* systemd: start default.target */
315 SIGRTMIN+1, /* systemd: isolate rescue.target */
316 SIGRTMIN+2, /* systemd: isolate emergency.target */
317 SIGRTMIN+3, /* systemd: start halt.target */
318 SIGRTMIN+4, /* systemd: start poweroff.target */
319 SIGRTMIN+5, /* systemd: start reboot.target */
320 SIGRTMIN+6, /* systemd: start kexec.target */
321 SIGRTMIN+13, /* systemd: Immediate halt */
322 SIGRTMIN+14, /* systemd: Immediate poweroff */
323 SIGRTMIN+15, /* systemd: Immediate reboot */
324 SIGRTMIN+16, /* systemd: Immediate kexec */
325 SIGRTMIN+20, /* systemd: enable status messages */
326 SIGRTMIN+21, /* systemd: disable status messages */
327 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
328 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
329 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
330 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
331 SIGRTMIN+27, /* systemd: set log target to console */
332 SIGRTMIN+28, /* systemd: set log target to kmsg */
333 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
335 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
337 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
338 if (m->signal_fd < 0)
341 r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);
345 /* Process signals a bit earlier than the rest of things, but
346 * later that notify_fd processing, so that the notify
347 * processing can still figure out to which process/service a
348 * message belongs, before we reap the process. */
349 r = sd_event_source_set_priority(m->signal_event_source, -5);
353 if (m->running_as == SYSTEMD_SYSTEM)
354 return enable_special_signals(m);
359 static void manager_clean_environment(Manager *m) {
362 /* Let's remove some environment variables that we
363 * need ourselves to communicate with our clients */
376 static int manager_default_environment(Manager *m) {
379 if (m->running_as == SYSTEMD_SYSTEM) {
380 /* The system manager always starts with a clean
381 * environment for its children. It does not import
382 * the kernel or the parents exported variables.
384 * The initial passed environ is untouched to keep
385 * /proc/self/environ valid; it is used for tagging
386 * the init process inside containers. */
387 m->environment = strv_new("PATH=" DEFAULT_PATH,
390 /* Import locale variables LC_*= from configuration */
391 locale_setup(&m->environment);
393 /* The user manager passes its own environment
394 * along to its children. */
395 m->environment = strv_copy(environ);
401 manager_clean_environment(m);
402 strv_sort(m->environment);
407 int manager_new(SystemdRunningAs running_as, Manager **_m) {
412 assert(running_as >= 0);
413 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
415 m = new0(Manager, 1);
420 if (detect_container(NULL) <= 0)
421 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
424 m->running_as = running_as;
425 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
427 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
429 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;
430 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
432 r = manager_default_environment(m);
436 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
440 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
444 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
448 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
452 r = set_ensure_allocated(&m->failed_units, trivial_hash_func, trivial_compare_func);
456 r = sd_event_default(&m->event);
460 r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
464 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
468 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
472 r = manager_setup_signals(m);
476 r = manager_setup_cgroup(m);
480 r = manager_setup_time_change(m);
484 m->udev = udev_new();
490 /* Note that we set up neither kdbus, nor the notify fd
491 * here. We do that after deserialization, since they might
492 * have gotten serialized across the reexec. */
494 m->taint_usr = dir_is_empty("/usr") > 0;
504 static int manager_setup_notify(Manager *m) {
507 if (m->notify_fd < 0) {
508 _cleanup_close_ int fd = -1;
511 struct sockaddr_un un;
513 .sa.sa_family = AF_UNIX,
517 /* First free all secondary fields */
518 free(m->notify_socket);
519 m->notify_socket = NULL;
520 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
522 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
524 log_error("Failed to allocate notification socket: %m");
528 if (m->running_as == SYSTEMD_SYSTEM)
529 m->notify_socket = strdup("/run/systemd/notify");
533 e = getenv("XDG_RUNTIME_DIR");
535 log_error("XDG_RUNTIME_DIR is not set: %m");
539 m->notify_socket = strappend(e, "/systemd/notify");
541 if (!m->notify_socket)
544 strncpy(sa.un.sun_path, m->notify_socket, sizeof(sa.un.sun_path)-1);
545 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path));
547 log_error("bind() failed: %m");
551 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
553 log_error("SO_PASSCRED failed: %m");
560 log_debug("Using notification socket %s", m->notify_socket);
563 if (!m->notify_event_source) {
564 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
566 log_error("Failed to allocate notify event source: %s", strerror(-r));
570 /* Process signals a bit earlier than SIGCHLD, so that we can
571 * still identify to which service an exit message belongs */
572 r = sd_event_source_set_priority(m->notify_event_source, -7);
574 log_error("Failed to set priority of notify event source: %s", strerror(-r));
582 static int manager_setup_kdbus(Manager *m) {
584 _cleanup_free_ char *p = NULL;
590 if (m->kdbus_fd >= 0)
593 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
594 if (m->kdbus_fd < 0) {
595 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
599 log_debug("Successfully set up kdbus on %s", p);
601 /* Create the namespace directory here, so that the contents
602 * of that directory is not visible to non-root users. This is
603 * necessary to ensure that users cannot get access to busses
604 * of virtualized users when no UID namespacing is used. */
605 if (m->running_as == SYSTEMD_SYSTEM)
606 mkdir_p_label("/dev/kdbus/domain", 0700);
612 static int manager_connect_bus(Manager *m, bool reexecuting) {
613 bool try_bus_connect;
620 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
622 /* Try to connect to the busses, if possible. */
623 return bus_init(m, try_bus_connect);
626 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
632 while ((u = m->cleanup_queue)) {
633 assert(u->in_cleanup_queue);
643 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
644 GC_OFFSET_UNSURE, /* No clue */
645 GC_OFFSET_GOOD, /* We still need this unit */
646 GC_OFFSET_BAD, /* We don't need this unit anymore */
650 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
657 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
658 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
659 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
662 if (u->in_cleanup_queue)
665 if (unit_check_gc(u))
668 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
672 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
673 unit_gc_sweep(other, gc_marker);
675 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
678 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
685 /* We were unable to find anything out about this entry, so
686 * let's investigate it later */
687 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
688 unit_add_to_gc_queue(u);
692 /* We definitely know that this one is not useful anymore, so
693 * let's mark it for deletion */
694 u->gc_marker = gc_marker + GC_OFFSET_BAD;
695 unit_add_to_cleanup_queue(u);
699 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
702 static unsigned manager_dispatch_gc_queue(Manager *m) {
709 /* log_debug("Running GC..."); */
711 m->gc_marker += _GC_OFFSET_MAX;
712 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
715 gc_marker = m->gc_marker;
717 while ((u = m->gc_queue)) {
718 assert(u->in_gc_queue);
720 unit_gc_sweep(u, gc_marker);
722 LIST_REMOVE(gc_queue, m->gc_queue, u);
723 u->in_gc_queue = false;
727 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
728 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
729 log_debug_unit(u->id, "Collecting %s", u->id);
730 u->gc_marker = gc_marker + GC_OFFSET_BAD;
731 unit_add_to_cleanup_queue(u);
735 m->n_in_gc_queue = 0;
740 static void manager_clear_jobs_and_units(Manager *m) {
745 while ((u = hashmap_first(m->units)))
748 manager_dispatch_cleanup_queue(m);
750 assert(!m->load_queue);
751 assert(!m->run_queue);
752 assert(!m->dbus_unit_queue);
753 assert(!m->dbus_job_queue);
754 assert(!m->cleanup_queue);
755 assert(!m->gc_queue);
757 assert(hashmap_isempty(m->jobs));
758 assert(hashmap_isempty(m->units));
761 m->n_running_jobs = 0;
764 void manager_free(Manager *m) {
770 manager_clear_jobs_and_units(m);
772 for (c = 0; c < _UNIT_TYPE_MAX; c++)
773 if (unit_vtable[c]->shutdown)
774 unit_vtable[c]->shutdown(m);
776 /* If we reexecute ourselves, we keep the root cgroup
778 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
780 manager_undo_generators(m);
784 hashmap_free(m->units);
785 hashmap_free(m->jobs);
786 hashmap_free(m->watch_pids1);
787 hashmap_free(m->watch_pids2);
788 hashmap_free(m->watch_bus);
790 set_free(m->failed_units);
792 sd_event_source_unref(m->signal_event_source);
793 sd_event_source_unref(m->notify_event_source);
794 sd_event_source_unref(m->time_change_event_source);
795 sd_event_source_unref(m->jobs_in_progress_event_source);
796 sd_event_source_unref(m->idle_pipe_event_source);
797 sd_event_source_unref(m->run_queue_event_source);
799 safe_close(m->signal_fd);
800 safe_close(m->notify_fd);
801 safe_close(m->time_change_fd);
802 safe_close(m->kdbus_fd);
804 manager_close_idle_pipe(m);
807 sd_event_unref(m->event);
809 free(m->notify_socket);
811 lookup_paths_free(&m->lookup_paths);
812 strv_free(m->environment);
814 hashmap_free(m->cgroup_unit);
815 set_free_free(m->unit_path_cache);
817 free(m->switch_root);
818 free(m->switch_root_init);
820 for (i = 0; i < _RLIMIT_MAX; i++)
823 assert(hashmap_isempty(m->units_requiring_mounts_for));
824 hashmap_free(m->units_requiring_mounts_for);
829 int manager_enumerate(Manager *m) {
835 /* Let's ask every type to load all units from disk/kernel
836 * that it might know */
837 for (c = 0; c < _UNIT_TYPE_MAX; c++)
838 if (unit_vtable[c]->enumerate) {
839 q = unit_vtable[c]->enumerate(m);
844 manager_dispatch_load_queue(m);
848 static int manager_coldplug(Manager *m) {
856 /* Then, let's set up their initial state. */
857 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
864 q = unit_coldplug(u);
872 static void manager_build_unit_path_cache(Manager *m) {
874 _cleanup_free_ DIR *d = NULL;
879 set_free_free(m->unit_path_cache);
881 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
882 if (!m->unit_path_cache) {
883 log_error("Failed to allocate unit path cache.");
887 /* This simply builds a list of files we know exist, so that
888 * we don't always have to go to disk */
890 STRV_FOREACH(i, m->lookup_paths.unit_path) {
896 log_error("Failed to open directory %s: %m", *i);
900 while ((de = readdir(d))) {
903 if (ignore_file(de->d_name))
906 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
912 r = set_consume(m->unit_path_cache, p);
924 log_error("Failed to build unit path cache: %s", strerror(-r));
926 set_free_free(m->unit_path_cache);
927 m->unit_path_cache = NULL;
931 static int manager_distribute_fds(Manager *m, FDSet *fds) {
938 HASHMAP_FOREACH(u, m->units, i) {
940 if (fdset_size(fds) <= 0)
943 if (UNIT_VTABLE(u)->distribute_fds) {
944 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
953 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
958 dual_timestamp_get(&m->generators_start_timestamp);
959 manager_run_generators(m);
960 dual_timestamp_get(&m->generators_finish_timestamp);
962 r = lookup_paths_init(
963 &m->lookup_paths, m->running_as, true,
964 m->generator_unit_path,
965 m->generator_unit_path_early,
966 m->generator_unit_path_late);
970 manager_build_unit_path_cache(m);
972 /* If we will deserialize make sure that during enumeration
973 * this is already known, so we increase the counter here
978 /* First, enumerate what we can from all config files */
979 dual_timestamp_get(&m->units_load_start_timestamp);
980 r = manager_enumerate(m);
981 dual_timestamp_get(&m->units_load_finish_timestamp);
983 /* Second, deserialize if there is something to deserialize */
985 q = manager_deserialize(m, serialization, fds);
990 /* Any fds left? Find some unit which wants them. This is
991 * useful to allow container managers to pass some file
992 * descriptors to us pre-initialized. This enables
993 * socket-based activation of entire containers. */
994 if (fdset_size(fds) > 0) {
995 q = manager_distribute_fds(m, fds);
1000 /* We might have deserialized the notify fd, but if we didn't
1001 * then let's create the bus now */
1002 manager_setup_notify(m);
1004 /* We might have deserialized the kdbus control fd, but if we
1005 * didn't, then let's create the bus now. */
1006 manager_setup_kdbus(m);
1007 manager_connect_bus(m, !!serialization);
1008 bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
1010 /* Third, fire things up! */
1011 q = manager_coldplug(m);
1015 if (serialization) {
1016 assert(m->n_reloading > 0);
1019 /* Let's wait for the UnitNew/JobNew messages being
1020 * sent, before we notify that the reload is
1022 m->send_reloading_done = true;
1028 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1033 assert(type < _JOB_TYPE_MAX);
1035 assert(mode < _JOB_MODE_MAX);
1037 if (mode == JOB_ISOLATE && type != JOB_START) {
1038 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1042 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1043 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1047 log_debug_unit(unit->id,
1048 "Trying to enqueue job %s/%s/%s", unit->id,
1049 job_type_to_string(type), job_mode_to_string(mode));
1051 job_type_collapse(&type, unit);
1053 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1057 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1058 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1059 mode == JOB_IGNORE_DEPENDENCIES, e);
1063 if (mode == JOB_ISOLATE) {
1064 r = transaction_add_isolate_jobs(tr, m);
1069 r = transaction_activate(tr, m, mode, e);
1073 log_debug_unit(unit->id,
1074 "Enqueued job %s/%s as %u", unit->id,
1075 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1078 *_ret = tr->anchor_job;
1080 transaction_free(tr);
1084 transaction_abort(tr);
1085 transaction_free(tr);
1089 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1094 assert(type < _JOB_TYPE_MAX);
1096 assert(mode < _JOB_MODE_MAX);
1098 r = manager_load_unit(m, name, NULL, NULL, &unit);
1102 return manager_add_job(m, type, unit, mode, override, e, _ret);
1105 Job *manager_get_job(Manager *m, uint32_t id) {
1108 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1111 Unit *manager_get_unit(Manager *m, const char *name) {
1115 return hashmap_get(m->units, name);
1118 unsigned manager_dispatch_load_queue(Manager *m) {
1124 /* Make sure we are not run recursively */
1125 if (m->dispatching_load_queue)
1128 m->dispatching_load_queue = true;
1130 /* Dispatches the load queue. Takes a unit from the queue and
1131 * tries to load its data until the queue is empty */
1133 while ((u = m->load_queue)) {
1134 assert(u->in_load_queue);
1140 m->dispatching_load_queue = false;
1144 int manager_load_unit_prepare(
1156 assert(name || path);
1158 /* This will prepare the unit for loading, but not actually
1159 * load anything from disk. */
1161 if (path && !is_path(path))
1162 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1165 name = basename(path);
1167 t = unit_name_to_type(name);
1169 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1170 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1172 ret = manager_get_unit(m, name);
1178 ret = unit_new(m, unit_vtable[t]->object_size);
1183 ret->fragment_path = strdup(path);
1184 if (!ret->fragment_path) {
1190 r = unit_add_name(ret, name);
1196 unit_add_to_load_queue(ret);
1197 unit_add_to_dbus_queue(ret);
1198 unit_add_to_gc_queue(ret);
1206 int manager_load_unit(
1217 /* This will load the service information files, but not actually
1218 * start any services or anything. */
1220 r = manager_load_unit_prepare(m, name, path, e, _ret);
1224 manager_dispatch_load_queue(m);
1227 *_ret = unit_follow_merge(*_ret);
1232 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1239 HASHMAP_FOREACH(j, s->jobs, i)
1240 job_dump(j, f, prefix);
1243 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1251 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1253 unit_dump(u, f, prefix);
1256 void manager_clear_jobs(Manager *m) {
1261 while ((j = hashmap_first(m->jobs)))
1262 /* No need to recurse. We're cancelling all jobs. */
1263 job_finish_and_invalidate(j, JOB_CANCELED, false);
1266 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1267 Manager *m = userdata;
1273 while ((j = m->run_queue)) {
1274 assert(j->installed);
1275 assert(j->in_run_queue);
1277 job_run_and_invalidate(j);
1280 if (m->n_running_jobs > 0)
1281 manager_watch_jobs_in_progress(m);
1283 if (m->n_on_console > 0)
1284 manager_watch_idle_pipe(m);
1289 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1296 if (m->dispatching_dbus_queue)
1299 m->dispatching_dbus_queue = true;
1301 while ((u = m->dbus_unit_queue)) {
1302 assert(u->in_dbus_queue);
1304 bus_unit_send_change_signal(u);
1308 while ((j = m->dbus_job_queue)) {
1309 assert(j->in_dbus_queue);
1311 bus_job_send_change_signal(j);
1315 m->dispatching_dbus_queue = false;
1317 if (m->send_reloading_done) {
1318 m->send_reloading_done = false;
1320 bus_manager_send_reloading(m, false);
1323 if (m->queued_message)
1324 bus_send_queued_message(m);
1329 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n) {
1330 _cleanup_strv_free_ char **tags = NULL;
1337 tags = strv_split(buf, "\n\r");
1343 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1345 if (UNIT_VTABLE(u)->notify_message)
1346 UNIT_VTABLE(u)->notify_message(u, pid, tags);
1349 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1350 Manager *m = userdata;
1354 assert(m->notify_fd == fd);
1356 if (revents != EPOLLIN) {
1357 log_warning("Got unexpected poll event for notify fd.");
1363 struct iovec iovec = {
1365 .iov_len = sizeof(buf)-1,
1370 struct cmsghdr cmsghdr;
1371 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1374 struct msghdr msghdr = {
1377 .msg_control = &control,
1378 .msg_controllen = sizeof(control),
1380 struct ucred *ucred;
1383 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1388 if (errno == EAGAIN || errno == EINTR)
1394 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1395 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1396 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1397 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1398 log_warning("Received notify message without credentials. Ignoring.");
1402 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1404 assert((size_t) n < sizeof(buf));
1407 u = manager_get_unit_by_pid(m, ucred->pid);
1409 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1413 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1415 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1419 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1421 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1426 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1432 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1437 log_debug_unit(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1439 unit_unwatch_pid(u, si->si_pid);
1440 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1443 static int manager_dispatch_sigchld(Manager *m) {
1449 /* First we call waitd() for a PID and do not reap the
1450 * zombie. That way we can still access /proc/$PID for
1451 * it while it is a zombie. */
1452 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1454 if (errno == ECHILD)
1466 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1467 _cleanup_free_ char *name = NULL;
1470 get_process_comm(si.si_pid, &name);
1472 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1473 si.si_pid, strna(name),
1474 sigchld_code_to_string(si.si_code),
1476 strna(si.si_code == CLD_EXITED
1477 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1478 : signal_to_string(si.si_status)));
1480 /* And now figure out the unit this belongs
1481 * to, it might be multiple... */
1482 u = manager_get_unit_by_pid(m, si.si_pid);
1484 invoke_sigchld_event(m, u, &si);
1485 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1487 invoke_sigchld_event(m, u, &si);
1488 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1490 invoke_sigchld_event(m, u, &si);
1493 /* And now, we actually reap the zombie. */
1494 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1505 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1506 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1509 log_debug_unit(name, "Activating special unit %s", name);
1511 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1513 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1518 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1519 Manager *m = userdata;
1521 struct signalfd_siginfo sfsi;
1522 bool sigchld = false;
1525 assert(m->signal_fd == fd);
1527 if (revents != EPOLLIN) {
1528 log_warning("Got unexpected events from signal file descriptor.");
1533 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1534 if (n != sizeof(sfsi)) {
1539 if (errno == EINTR || errno == EAGAIN)
1545 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1546 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1547 ? LOG_DEBUG : LOG_INFO,
1550 switch (sfsi.ssi_signo) {
1557 if (m->running_as == SYSTEMD_SYSTEM) {
1558 /* This is for compatibility with the
1559 * original sysvinit */
1560 m->exit_code = MANAGER_REEXECUTE;
1567 if (m->running_as == SYSTEMD_SYSTEM) {
1568 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1572 /* Run the exit target if there is one, if not, just exit. */
1573 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1574 m->exit_code = MANAGER_EXIT;
1581 if (m->running_as == SYSTEMD_SYSTEM)
1582 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1584 /* This is a nop on non-init */
1588 if (m->running_as == SYSTEMD_SYSTEM)
1589 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1591 /* This is a nop on non-init */
1597 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1599 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1600 log_info("Trying to reconnect to bus...");
1604 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1605 log_info("Loading D-Bus service...");
1606 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1613 _cleanup_free_ char *dump = NULL;
1614 _cleanup_fclose_ FILE *f = NULL;
1617 f = open_memstream(&dump, &size);
1619 log_warning("Failed to allocate memory stream.");
1623 manager_dump_units(m, f, "\t");
1624 manager_dump_jobs(m, f, "\t");
1627 log_warning("Failed to write status stream");
1632 log_warning("Failed to flush status stream");
1636 log_dump(LOG_INFO, dump);
1641 m->exit_code = MANAGER_RELOAD;
1646 /* Starting SIGRTMIN+0 */
1647 static const char * const target_table[] = {
1648 [0] = SPECIAL_DEFAULT_TARGET,
1649 [1] = SPECIAL_RESCUE_TARGET,
1650 [2] = SPECIAL_EMERGENCY_TARGET,
1651 [3] = SPECIAL_HALT_TARGET,
1652 [4] = SPECIAL_POWEROFF_TARGET,
1653 [5] = SPECIAL_REBOOT_TARGET,
1654 [6] = SPECIAL_KEXEC_TARGET
1657 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1658 static const ManagerExitCode code_table[] = {
1660 [1] = MANAGER_POWEROFF,
1661 [2] = MANAGER_REBOOT,
1665 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1666 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1667 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1668 manager_start_target(m, target_table[idx],
1669 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1673 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1674 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1675 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1679 switch (sfsi.ssi_signo - SIGRTMIN) {
1682 log_debug("Enabling showing of status.");
1683 manager_set_show_status(m, SHOW_STATUS_YES);
1687 log_debug("Disabling showing of status.");
1688 manager_set_show_status(m, SHOW_STATUS_NO);
1692 log_set_max_level(LOG_DEBUG);
1693 log_notice("Setting log level to debug.");
1697 log_set_max_level(LOG_INFO);
1698 log_notice("Setting log level to info.");
1702 if (m->running_as == SYSTEMD_USER) {
1703 m->exit_code = MANAGER_EXIT;
1707 /* This is a nop on init */
1711 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1712 log_notice("Setting log target to journal-or-kmsg.");
1716 log_set_target(LOG_TARGET_CONSOLE);
1717 log_notice("Setting log target to console.");
1721 log_set_target(LOG_TARGET_KMSG);
1722 log_notice("Setting log target to kmsg.");
1726 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1727 log_notice("Setting log target to syslog-or-kmsg.");
1731 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1738 manager_dispatch_sigchld(m);
1743 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1744 Manager *m = userdata;
1749 assert(m->time_change_fd == fd);
1751 log_struct(LOG_INFO,
1752 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1753 "MESSAGE=Time has been changed",
1756 /* Restart the watch */
1757 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1758 m->time_change_fd = safe_close(m->time_change_fd);
1760 manager_setup_time_change(m);
1762 HASHMAP_FOREACH(u, m->units, i)
1763 if (UNIT_VTABLE(u)->time_change)
1764 UNIT_VTABLE(u)->time_change(u);
1769 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1770 Manager *m = userdata;
1773 assert(m->idle_pipe[2] == fd);
1775 m->no_console_output = m->n_on_console > 0;
1777 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1778 manager_close_idle_pipe(m);
1783 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1784 Manager *m = userdata;
1791 manager_print_jobs_in_progress(m);
1793 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1794 r = sd_event_source_set_time(source, next);
1798 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1801 int manager_loop(Manager *m) {
1804 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1807 m->exit_code = MANAGER_OK;
1809 /* Release the path cache */
1810 set_free_free(m->unit_path_cache);
1811 m->unit_path_cache = NULL;
1813 manager_check_finished(m);
1815 /* There might still be some zombies hanging around from
1816 * before we were exec()'ed. Let's reap them. */
1817 r = manager_dispatch_sigchld(m);
1821 while (m->exit_code == MANAGER_OK) {
1824 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1827 if (!ratelimit_test(&rl)) {
1828 /* Yay, something is going seriously wrong, pause a little */
1829 log_warning("Looping too fast. Throttling execution a little.");
1834 if (manager_dispatch_load_queue(m) > 0)
1837 if (manager_dispatch_gc_queue(m) > 0)
1840 if (manager_dispatch_cleanup_queue(m) > 0)
1843 if (manager_dispatch_cgroup_queue(m) > 0)
1846 if (manager_dispatch_dbus_queue(m) > 0)
1849 /* Sleep for half the watchdog time */
1850 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1851 wait_usec = m->runtime_watchdog / 2;
1855 wait_usec = (usec_t) -1;
1857 r = sd_event_run(m->event, wait_usec);
1859 log_error("Failed to run event loop: %s", strerror(-r));
1864 return m->exit_code;
1867 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1868 _cleanup_free_ char *n = NULL;
1876 r = unit_name_from_dbus_path(s, &n);
1880 r = manager_load_unit(m, n, NULL, e, &u);
1889 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1899 p = startswith(s, "/org/freedesktop/systemd1/job/");
1903 r = safe_atou(p, &id);
1907 j = manager_get_job(m, id);
1916 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1919 _cleanup_free_ char *p = NULL;
1922 audit_fd = get_audit_fd();
1926 /* Don't generate audit events if the service was already
1927 * started and we're just deserializing */
1928 if (m->n_reloading > 0)
1931 if (m->running_as != SYSTEMD_SYSTEM)
1934 if (u->type != UNIT_SERVICE)
1937 p = unit_name_to_prefix_and_instance(u->id);
1939 log_error_unit(u->id,
1940 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1944 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1945 if (errno == EPERM) {
1946 /* We aren't allowed to send audit messages?
1947 * Then let's not retry again. */
1950 log_warning("Failed to send audit message: %m");
1956 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1957 union sockaddr_union sa = {
1958 .un.sun_family = AF_UNIX,
1959 .un.sun_path = "\0/org/freedesktop/plymouthd",
1963 _cleanup_free_ char *message = NULL;
1964 _cleanup_close_ int fd = -1;
1966 /* Don't generate plymouth events if the service was already
1967 * started and we're just deserializing */
1968 if (m->n_reloading > 0)
1971 if (m->running_as != SYSTEMD_SYSTEM)
1974 if (detect_container(NULL) > 0)
1977 if (u->type != UNIT_SERVICE &&
1978 u->type != UNIT_MOUNT &&
1979 u->type != UNIT_SWAP)
1982 /* We set SOCK_NONBLOCK here so that we rather drop the
1983 * message then wait for plymouth */
1984 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1986 log_error("socket() failed: %m");
1990 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1992 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
1993 log_error("connect() failed: %m");
1997 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2003 if (write(fd, message, n + 1) != n + 1)
2004 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2005 log_error("Failed to write Plymouth message: %m");
2008 void manager_dispatch_bus_name_owner_changed(
2011 const char* old_owner,
2012 const char *new_owner) {
2019 u = hashmap_get(m->watch_bus, name);
2023 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2026 int manager_open_serialization(Manager *m, FILE **_f) {
2033 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2034 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2038 log_debug("Serializing state to %s", path);
2040 f = fdopen(fd, "w+");
2051 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2064 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2065 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2066 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2067 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2069 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2070 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2071 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2072 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2075 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2076 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2077 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2078 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2079 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2080 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2081 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2082 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2085 if (!switching_root) {
2086 STRV_FOREACH(e, m->environment) {
2087 _cleanup_free_ char *ce;
2093 fprintf(f, "env=%s\n", *e);
2097 if (m->notify_fd >= 0) {
2100 copy = fdset_put_dup(fds, m->notify_fd);
2104 fprintf(f, "notify-fd=%i\n", copy);
2105 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2108 if (m->kdbus_fd >= 0) {
2111 copy = fdset_put_dup(fds, m->kdbus_fd);
2115 fprintf(f, "kdbus-fd=%i\n", copy);
2118 bus_track_serialize(m->subscribed, f);
2122 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2126 if (!unit_can_serialize(u))
2133 r = unit_serialize(u, f, fds, !switching_root);
2140 assert(m->n_reloading > 0);
2146 r = bus_fdset_add_all(m, fds);
2153 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2159 log_debug("Deserializing state...");
2164 char line[LINE_MAX], *l;
2166 if (!fgets(line, sizeof(line), f)) {
2181 if (startswith(l, "current-job-id=")) {
2184 if (safe_atou32(l+15, &id) < 0)
2185 log_debug("Failed to parse current job id value %s", l+15);
2187 m->current_job_id = MAX(m->current_job_id, id);
2189 } else if (startswith(l, "n-installed-jobs=")) {
2192 if (safe_atou32(l+17, &n) < 0)
2193 log_debug("Failed to parse installed jobs counter %s", l+17);
2195 m->n_installed_jobs += n;
2197 } else if (startswith(l, "n-failed-jobs=")) {
2200 if (safe_atou32(l+14, &n) < 0)
2201 log_debug("Failed to parse failed jobs counter %s", l+14);
2203 m->n_failed_jobs += n;
2205 } else if (startswith(l, "taint-usr=")) {
2208 b = parse_boolean(l+10);
2210 log_debug("Failed to parse taint /usr flag %s", l+10);
2212 m->taint_usr = m->taint_usr || b;
2214 } else if (startswith(l, "firmware-timestamp="))
2215 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2216 else if (startswith(l, "loader-timestamp="))
2217 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2218 else if (startswith(l, "kernel-timestamp="))
2219 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2220 else if (startswith(l, "initrd-timestamp="))
2221 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2222 else if (startswith(l, "userspace-timestamp="))
2223 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2224 else if (startswith(l, "finish-timestamp="))
2225 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2226 else if (startswith(l, "security-start-timestamp="))
2227 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2228 else if (startswith(l, "security-finish-timestamp="))
2229 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2230 else if (startswith(l, "generators-start-timestamp="))
2231 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2232 else if (startswith(l, "generators-finish-timestamp="))
2233 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2234 else if (startswith(l, "units-load-start-timestamp="))
2235 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2236 else if (startswith(l, "units-load-finish-timestamp="))
2237 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2238 else if (startswith(l, "env=")) {
2239 _cleanup_free_ char *uce = NULL;
2242 uce = cunescape(l+4);
2248 e = strv_env_set(m->environment, uce);
2254 strv_free(m->environment);
2257 } else if (startswith(l, "notify-fd=")) {
2260 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2261 log_debug("Failed to parse notify fd: %s", l + 10);
2263 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2264 safe_close(m->notify_fd);
2265 m->notify_fd = fdset_remove(fds, fd);
2268 } else if (startswith(l, "notify-socket=")) {
2277 free(m->notify_socket);
2278 m->notify_socket = n;
2280 } else if (startswith(l, "kdbus-fd=")) {
2283 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2284 log_debug("Failed to parse kdbus fd: %s", l + 9);
2286 safe_close(m->kdbus_fd);
2287 m->kdbus_fd = fdset_remove(fds, fd);
2290 } else if (bus_track_deserialize_item(&m->deserialized_subscribed, l) == 0)
2291 log_debug("Unknown serialization item '%s'", l);
2296 char name[UNIT_NAME_MAX+2];
2299 if (!fgets(name, sizeof(name), f)) {
2310 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2314 r = unit_deserialize(u, f, fds);
2323 assert(m->n_reloading > 0);
2329 int manager_reload(Manager *m) {
2331 _cleanup_fclose_ FILE *f = NULL;
2332 _cleanup_fdset_free_ FDSet *fds = NULL;
2336 r = manager_open_serialization(m, &f);
2341 bus_manager_send_reloading(m, true);
2349 r = manager_serialize(m, f, fds, false);
2355 if (fseeko(f, 0, SEEK_SET) < 0) {
2360 /* From here on there is no way back. */
2361 manager_clear_jobs_and_units(m);
2362 manager_undo_generators(m);
2363 lookup_paths_free(&m->lookup_paths);
2365 /* Find new unit paths */
2366 manager_run_generators(m);
2368 q = lookup_paths_init(
2369 &m->lookup_paths, m->running_as, true,
2370 m->generator_unit_path,
2371 m->generator_unit_path_early,
2372 m->generator_unit_path_late);
2376 manager_build_unit_path_cache(m);
2378 /* First, enumerate what we can from all config files */
2379 q = manager_enumerate(m);
2383 /* Second, deserialize our stored data */
2384 q = manager_deserialize(m, f, fds);
2391 /* Re-register notify_fd as event source */
2392 q = manager_setup_notify(m);
2396 /* Third, fire things up! */
2397 q = manager_coldplug(m);
2401 assert(m->n_reloading > 0);
2404 m->send_reloading_done = true;
2409 bool manager_is_reloading_or_reexecuting(Manager *m) {
2412 return m->n_reloading != 0;
2415 void manager_reset_failed(Manager *m) {
2421 HASHMAP_FOREACH(u, m->units, i)
2422 unit_reset_failed(u);
2425 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2431 /* Returns true if the unit is inactive or going down */
2432 u = manager_get_unit(m, name);
2436 return unit_inactive_or_pending(u);
2439 void manager_check_finished(Manager *m) {
2440 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2441 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2445 if (m->n_running_jobs == 0)
2446 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2448 if (hashmap_size(m->jobs) > 0) {
2450 if (m->jobs_in_progress_event_source) {
2451 sd_event_source_set_time(m->jobs_in_progress_event_source,
2452 now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2458 manager_flip_auto_status(m, false);
2460 /* Notify Type=idle units that we are done now */
2461 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2462 manager_close_idle_pipe(m);
2464 /* Turn off confirm spawn now */
2465 m->confirm_spawn = false;
2467 if (dual_timestamp_is_set(&m->finish_timestamp))
2470 dual_timestamp_get(&m->finish_timestamp);
2472 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2474 /* Note that m->kernel_usec.monotonic is always at 0,
2475 * and m->firmware_usec.monotonic and
2476 * m->loader_usec.monotonic should be considered
2477 * negative values. */
2479 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2480 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2481 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2482 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2484 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2486 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2487 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2489 if (!log_on_console())
2490 log_struct(LOG_INFO,
2491 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2492 "KERNEL_USEC="USEC_FMT, kernel_usec,
2493 "INITRD_USEC="USEC_FMT, initrd_usec,
2494 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2495 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2496 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2497 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2498 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2499 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2502 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2505 if (!log_on_console())
2506 log_struct(LOG_INFO,
2507 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2508 "KERNEL_USEC="USEC_FMT, kernel_usec,
2509 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2510 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2511 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2512 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2513 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2517 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2518 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2520 if (!log_on_console())
2521 log_struct(LOG_INFO,
2522 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2523 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2524 "MESSAGE=Startup finished in %s.",
2525 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2529 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2532 "READY=1\nSTATUS=Startup finished in %s.",
2533 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2536 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2547 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2548 /* systemd --system, not running --test */
2550 p = strappend("/run/systemd/", name);
2554 r = mkdir_p_label(p, 0755);
2556 log_error("Failed to create generator directory %s: %s",
2561 } else if (m->running_as == SYSTEMD_USER) {
2562 const char *s = NULL;
2564 s = getenv("XDG_RUNTIME_DIR");
2567 p = strjoin(s, "/systemd/", name, NULL);
2571 r = mkdir_p_label(p, 0755);
2573 log_error("Failed to create generator directory %s: %s",
2579 /* systemd --system --test */
2581 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2586 log_error("Failed to create generator directory %s: %m",
2597 static void trim_generator_dir(Manager *m, char **generator) {
2604 if (rmdir(*generator) >= 0) {
2612 void manager_run_generators(Manager *m) {
2613 _cleanup_closedir_ DIR *d = NULL;
2614 const char *generator_path;
2615 const char *argv[5];
2620 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2621 d = opendir(generator_path);
2623 if (errno == ENOENT)
2626 log_error("Failed to enumerate generator directory %s: %m",
2631 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2635 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2639 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2643 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2644 argv[1] = m->generator_unit_path;
2645 argv[2] = m->generator_unit_path_early;
2646 argv[3] = m->generator_unit_path_late;
2649 RUN_WITH_UMASK(0022)
2650 execute_directory(generator_path, d, DEFAULT_TIMEOUT_USEC, (char**) argv);
2653 trim_generator_dir(m, &m->generator_unit_path);
2654 trim_generator_dir(m, &m->generator_unit_path_early);
2655 trim_generator_dir(m, &m->generator_unit_path_late);
2658 static void remove_generator_dir(Manager *m, char **generator) {
2665 strv_remove(m->lookup_paths.unit_path, *generator);
2666 rm_rf(*generator, false, true, false);
2672 void manager_undo_generators(Manager *m) {
2675 remove_generator_dir(m, &m->generator_unit_path);
2676 remove_generator_dir(m, &m->generator_unit_path_early);
2677 remove_generator_dir(m, &m->generator_unit_path_late);
2680 int manager_environment_add(Manager *m, char **minus, char **plus) {
2681 char **a = NULL, **b = NULL, **l;
2686 if (!strv_isempty(minus)) {
2687 a = strv_env_delete(l, 1, minus);
2694 if (!strv_isempty(plus)) {
2695 b = strv_env_merge(2, l, plus);
2702 if (m->environment != l)
2703 strv_free(m->environment);
2710 manager_clean_environment(m);
2711 strv_sort(m->environment);
2716 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2721 for (i = 0; i < _RLIMIT_MAX; i++) {
2722 if (!default_rlimit[i])
2725 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2733 void manager_recheck_journal(Manager *m) {
2738 if (m->running_as != SYSTEMD_SYSTEM)
2741 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2742 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2743 log_close_journal();
2747 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2748 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2749 log_close_journal();
2753 /* Hmm, OK, so the socket is fully up and the service is up
2754 * too, then let's make use of the thing. */
2758 void manager_set_show_status(Manager *m, ShowStatus mode) {
2760 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2762 if (m->running_as != SYSTEMD_SYSTEM)
2765 m->show_status = mode;
2768 touch("/run/systemd/show-status");
2770 unlink("/run/systemd/show-status");
2773 static bool manager_get_show_status(Manager *m) {
2776 if (m->running_as != SYSTEMD_SYSTEM)
2779 if (m->no_console_output)
2782 if (!IN_SET(manager_state(m), MANAGER_STARTING, MANAGER_STOPPING))
2785 if (m->show_status > 0)
2788 /* If Plymouth is running make sure we show the status, so
2789 * that there's something nice to see when people press Esc */
2791 return plymouth_running();
2794 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2797 if (!manager_get_show_status(m))
2800 /* XXX We should totally drop the check for ephemeral here
2801 * and thus effectively make 'Type=idle' pointless. */
2802 if (ephemeral && m->n_on_console > 0)
2805 va_start(ap, format);
2806 status_vprintf(status, true, ephemeral, format, ap);
2810 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2811 _cleanup_free_ char *p = NULL;
2819 p = unit_name_from_path(path, suffix);
2823 found = manager_get_unit(m, p);
2833 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2834 char p[strlen(path)+1];
2840 path_kill_slashes(p);
2842 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
2845 const char *manager_get_runtime_prefix(Manager *m) {
2848 return m->running_as == SYSTEMD_SYSTEM ?
2850 getenv("XDG_RUNTIME_DIR");
2853 ManagerState manager_state(Manager *m) {
2858 /* Did we ever finish booting? If not then we are still starting up */
2859 if (!dual_timestamp_is_set(&m->finish_timestamp))
2860 return MANAGER_STARTING;
2862 /* Is the special shutdown target queued? If so, we are in shutdown state */
2863 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2864 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
2865 return MANAGER_STOPPING;
2867 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
2868 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
2869 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2870 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2871 return MANAGER_MAINTENANCE;
2873 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
2874 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2875 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2876 return MANAGER_MAINTENANCE;
2878 /* Are there any failed units? If so, we are in degraded mode */
2879 if (set_size(m->failed_units) > 0)
2880 return MANAGER_DEGRADED;
2882 return MANAGER_RUNNING;
2885 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
2886 [MANAGER_STARTING] = "starting",
2887 [MANAGER_RUNNING] = "running",
2888 [MANAGER_DEGRADED] = "degraded",
2889 [MANAGER_MAINTENANCE] = "maintenance",
2890 [MANAGER_STOPPING] = "stopping",
2893 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);