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 (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;
433 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
435 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;
436 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
438 r = manager_default_environment(m);
442 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
446 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
450 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
454 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
458 r = set_ensure_allocated(&m->failed_units, trivial_hash_func, trivial_compare_func);
462 r = sd_event_default(&m->event);
466 r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
470 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
474 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
478 r = manager_setup_signals(m);
482 r = manager_setup_cgroup(m);
486 r = manager_setup_time_change(m);
490 m->udev = udev_new();
496 /* Note that we set up neither kdbus, nor the notify fd
497 * here. We do that after deserialization, since they might
498 * have gotten serialized across the reexec. */
500 m->taint_usr = dir_is_empty("/usr") > 0;
510 static int manager_setup_notify(Manager *m) {
513 if (m->notify_fd < 0) {
514 _cleanup_close_ int fd = -1;
517 struct sockaddr_un un;
519 .sa.sa_family = AF_UNIX,
523 /* First free all secondary fields */
524 free(m->notify_socket);
525 m->notify_socket = NULL;
526 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
528 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
530 log_error("Failed to allocate notification socket: %m");
534 if (m->running_as == SYSTEMD_SYSTEM)
535 m->notify_socket = strdup("/run/systemd/notify");
539 e = getenv("XDG_RUNTIME_DIR");
541 log_error("XDG_RUNTIME_DIR is not set: %m");
545 m->notify_socket = strappend(e, "/systemd/notify");
547 if (!m->notify_socket)
550 strncpy(sa.un.sun_path, m->notify_socket, sizeof(sa.un.sun_path)-1);
551 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path));
553 log_error("bind() failed: %m");
557 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
559 log_error("SO_PASSCRED failed: %m");
566 log_debug("Using notification socket %s", m->notify_socket);
569 if (!m->notify_event_source) {
570 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
572 log_error("Failed to allocate notify event source: %s", strerror(-r));
576 /* Process signals a bit earlier than SIGCHLD, so that we can
577 * still identify to which service an exit message belongs */
578 r = sd_event_source_set_priority(m->notify_event_source, -7);
580 log_error("Failed to set priority of notify event source: %s", strerror(-r));
588 static int manager_setup_kdbus(Manager *m) {
590 _cleanup_free_ char *p = NULL;
596 if (m->kdbus_fd >= 0)
599 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
600 if (m->kdbus_fd < 0) {
601 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
605 log_debug("Successfully set up kdbus on %s", p);
607 /* Create the namespace directory here, so that the contents
608 * of that directory is not visible to non-root users. This is
609 * necessary to ensure that users cannot get access to busses
610 * of virtualized users when no UID namespacing is used. */
611 if (m->running_as == SYSTEMD_SYSTEM)
612 mkdir_p_label("/dev/kdbus/domain", 0700);
618 static int manager_connect_bus(Manager *m, bool reexecuting) {
619 bool try_bus_connect;
626 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
628 /* Try to connect to the busses, if possible. */
629 return bus_init(m, try_bus_connect);
632 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
638 while ((u = m->cleanup_queue)) {
639 assert(u->in_cleanup_queue);
649 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
650 GC_OFFSET_UNSURE, /* No clue */
651 GC_OFFSET_GOOD, /* We still need this unit */
652 GC_OFFSET_BAD, /* We don't need this unit anymore */
656 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
663 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
664 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
665 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
668 if (u->in_cleanup_queue)
671 if (unit_check_gc(u))
674 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
678 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
679 unit_gc_sweep(other, gc_marker);
681 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
684 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
691 /* We were unable to find anything out about this entry, so
692 * let's investigate it later */
693 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
694 unit_add_to_gc_queue(u);
698 /* We definitely know that this one is not useful anymore, so
699 * let's mark it for deletion */
700 u->gc_marker = gc_marker + GC_OFFSET_BAD;
701 unit_add_to_cleanup_queue(u);
705 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
708 static unsigned manager_dispatch_gc_queue(Manager *m) {
715 /* log_debug("Running GC..."); */
717 m->gc_marker += _GC_OFFSET_MAX;
718 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
721 gc_marker = m->gc_marker;
723 while ((u = m->gc_queue)) {
724 assert(u->in_gc_queue);
726 unit_gc_sweep(u, gc_marker);
728 LIST_REMOVE(gc_queue, m->gc_queue, u);
729 u->in_gc_queue = false;
733 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
734 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
735 log_debug_unit(u->id, "Collecting %s", u->id);
736 u->gc_marker = gc_marker + GC_OFFSET_BAD;
737 unit_add_to_cleanup_queue(u);
741 m->n_in_gc_queue = 0;
746 static void manager_clear_jobs_and_units(Manager *m) {
751 while ((u = hashmap_first(m->units)))
754 manager_dispatch_cleanup_queue(m);
756 assert(!m->load_queue);
757 assert(!m->run_queue);
758 assert(!m->dbus_unit_queue);
759 assert(!m->dbus_job_queue);
760 assert(!m->cleanup_queue);
761 assert(!m->gc_queue);
763 assert(hashmap_isempty(m->jobs));
764 assert(hashmap_isempty(m->units));
767 m->n_running_jobs = 0;
770 void manager_free(Manager *m) {
776 manager_clear_jobs_and_units(m);
778 for (c = 0; c < _UNIT_TYPE_MAX; c++)
779 if (unit_vtable[c]->shutdown)
780 unit_vtable[c]->shutdown(m);
782 /* If we reexecute ourselves, we keep the root cgroup
784 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
786 manager_undo_generators(m);
790 hashmap_free(m->units);
791 hashmap_free(m->jobs);
792 hashmap_free(m->watch_pids1);
793 hashmap_free(m->watch_pids2);
794 hashmap_free(m->watch_bus);
796 set_free(m->failed_units);
798 sd_event_source_unref(m->signal_event_source);
799 sd_event_source_unref(m->notify_event_source);
800 sd_event_source_unref(m->time_change_event_source);
801 sd_event_source_unref(m->jobs_in_progress_event_source);
802 sd_event_source_unref(m->idle_pipe_event_source);
803 sd_event_source_unref(m->run_queue_event_source);
805 safe_close(m->signal_fd);
806 safe_close(m->notify_fd);
807 safe_close(m->time_change_fd);
808 safe_close(m->kdbus_fd);
810 manager_close_idle_pipe(m);
813 sd_event_unref(m->event);
815 free(m->notify_socket);
817 lookup_paths_free(&m->lookup_paths);
818 strv_free(m->environment);
820 hashmap_free(m->cgroup_unit);
821 set_free_free(m->unit_path_cache);
823 free(m->switch_root);
824 free(m->switch_root_init);
826 for (i = 0; i < _RLIMIT_MAX; i++)
829 assert(hashmap_isempty(m->units_requiring_mounts_for));
830 hashmap_free(m->units_requiring_mounts_for);
835 int manager_enumerate(Manager *m) {
841 /* Let's ask every type to load all units from disk/kernel
842 * that it might know */
843 for (c = 0; c < _UNIT_TYPE_MAX; c++)
844 if (unit_vtable[c]->enumerate) {
845 q = unit_vtable[c]->enumerate(m);
850 manager_dispatch_load_queue(m);
854 static int manager_coldplug(Manager *m) {
862 /* Then, let's set up their initial state. */
863 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
870 q = unit_coldplug(u);
878 static void manager_build_unit_path_cache(Manager *m) {
880 _cleanup_free_ DIR *d = NULL;
885 set_free_free(m->unit_path_cache);
887 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
888 if (!m->unit_path_cache) {
889 log_error("Failed to allocate unit path cache.");
893 /* This simply builds a list of files we know exist, so that
894 * we don't always have to go to disk */
896 STRV_FOREACH(i, m->lookup_paths.unit_path) {
902 log_error("Failed to open directory %s: %m", *i);
906 while ((de = readdir(d))) {
909 if (ignore_file(de->d_name))
912 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
918 r = set_consume(m->unit_path_cache, p);
930 log_error("Failed to build unit path cache: %s", strerror(-r));
932 set_free_free(m->unit_path_cache);
933 m->unit_path_cache = NULL;
937 static int manager_distribute_fds(Manager *m, FDSet *fds) {
944 HASHMAP_FOREACH(u, m->units, i) {
946 if (fdset_size(fds) <= 0)
949 if (UNIT_VTABLE(u)->distribute_fds) {
950 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
959 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
964 dual_timestamp_get(&m->generators_start_timestamp);
965 manager_run_generators(m);
966 dual_timestamp_get(&m->generators_finish_timestamp);
968 r = lookup_paths_init(
969 &m->lookup_paths, m->running_as, true,
970 m->generator_unit_path,
971 m->generator_unit_path_early,
972 m->generator_unit_path_late);
976 manager_build_unit_path_cache(m);
978 /* If we will deserialize make sure that during enumeration
979 * this is already known, so we increase the counter here
984 /* First, enumerate what we can from all config files */
985 dual_timestamp_get(&m->units_load_start_timestamp);
986 r = manager_enumerate(m);
987 dual_timestamp_get(&m->units_load_finish_timestamp);
989 /* Second, deserialize if there is something to deserialize */
991 q = manager_deserialize(m, serialization, fds);
996 /* Any fds left? Find some unit which wants them. This is
997 * useful to allow container managers to pass some file
998 * descriptors to us pre-initialized. This enables
999 * socket-based activation of entire containers. */
1000 if (fdset_size(fds) > 0) {
1001 q = manager_distribute_fds(m, fds);
1006 /* We might have deserialized the notify fd, but if we didn't
1007 * then let's create the bus now */
1008 manager_setup_notify(m);
1010 /* We might have deserialized the kdbus control fd, but if we
1011 * didn't, then let's create the bus now. */
1012 manager_setup_kdbus(m);
1013 manager_connect_bus(m, !!serialization);
1014 bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
1016 /* Third, fire things up! */
1017 q = manager_coldplug(m);
1021 if (serialization) {
1022 assert(m->n_reloading > 0);
1025 /* Let's wait for the UnitNew/JobNew messages being
1026 * sent, before we notify that the reload is
1028 m->send_reloading_done = true;
1034 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1039 assert(type < _JOB_TYPE_MAX);
1041 assert(mode < _JOB_MODE_MAX);
1043 if (mode == JOB_ISOLATE && type != JOB_START) {
1044 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1048 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1049 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1053 log_debug_unit(unit->id,
1054 "Trying to enqueue job %s/%s/%s", unit->id,
1055 job_type_to_string(type), job_mode_to_string(mode));
1057 job_type_collapse(&type, unit);
1059 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1063 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1064 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1065 mode == JOB_IGNORE_DEPENDENCIES, e);
1069 if (mode == JOB_ISOLATE) {
1070 r = transaction_add_isolate_jobs(tr, m);
1075 r = transaction_activate(tr, m, mode, e);
1079 log_debug_unit(unit->id,
1080 "Enqueued job %s/%s as %u", unit->id,
1081 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1084 *_ret = tr->anchor_job;
1086 transaction_free(tr);
1090 transaction_abort(tr);
1091 transaction_free(tr);
1095 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1100 assert(type < _JOB_TYPE_MAX);
1102 assert(mode < _JOB_MODE_MAX);
1104 r = manager_load_unit(m, name, NULL, NULL, &unit);
1108 return manager_add_job(m, type, unit, mode, override, e, _ret);
1111 Job *manager_get_job(Manager *m, uint32_t id) {
1114 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1117 Unit *manager_get_unit(Manager *m, const char *name) {
1121 return hashmap_get(m->units, name);
1124 unsigned manager_dispatch_load_queue(Manager *m) {
1130 /* Make sure we are not run recursively */
1131 if (m->dispatching_load_queue)
1134 m->dispatching_load_queue = true;
1136 /* Dispatches the load queue. Takes a unit from the queue and
1137 * tries to load its data until the queue is empty */
1139 while ((u = m->load_queue)) {
1140 assert(u->in_load_queue);
1146 m->dispatching_load_queue = false;
1150 int manager_load_unit_prepare(
1162 assert(name || path);
1164 /* This will prepare the unit for loading, but not actually
1165 * load anything from disk. */
1167 if (path && !is_path(path))
1168 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1171 name = basename(path);
1173 t = unit_name_to_type(name);
1175 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1176 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1178 ret = manager_get_unit(m, name);
1184 ret = unit_new(m, unit_vtable[t]->object_size);
1189 ret->fragment_path = strdup(path);
1190 if (!ret->fragment_path) {
1196 r = unit_add_name(ret, name);
1202 unit_add_to_load_queue(ret);
1203 unit_add_to_dbus_queue(ret);
1204 unit_add_to_gc_queue(ret);
1212 int manager_load_unit(
1223 /* This will load the service information files, but not actually
1224 * start any services or anything. */
1226 r = manager_load_unit_prepare(m, name, path, e, _ret);
1230 manager_dispatch_load_queue(m);
1233 *_ret = unit_follow_merge(*_ret);
1238 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1245 HASHMAP_FOREACH(j, s->jobs, i)
1246 job_dump(j, f, prefix);
1249 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1257 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1259 unit_dump(u, f, prefix);
1262 void manager_clear_jobs(Manager *m) {
1267 while ((j = hashmap_first(m->jobs)))
1268 /* No need to recurse. We're cancelling all jobs. */
1269 job_finish_and_invalidate(j, JOB_CANCELED, false);
1272 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1273 Manager *m = userdata;
1279 while ((j = m->run_queue)) {
1280 assert(j->installed);
1281 assert(j->in_run_queue);
1283 job_run_and_invalidate(j);
1286 if (m->n_running_jobs > 0)
1287 manager_watch_jobs_in_progress(m);
1289 if (m->n_on_console > 0)
1290 manager_watch_idle_pipe(m);
1295 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1302 if (m->dispatching_dbus_queue)
1305 m->dispatching_dbus_queue = true;
1307 while ((u = m->dbus_unit_queue)) {
1308 assert(u->in_dbus_queue);
1310 bus_unit_send_change_signal(u);
1314 while ((j = m->dbus_job_queue)) {
1315 assert(j->in_dbus_queue);
1317 bus_job_send_change_signal(j);
1321 m->dispatching_dbus_queue = false;
1323 if (m->send_reloading_done) {
1324 m->send_reloading_done = false;
1326 bus_manager_send_reloading(m, false);
1329 if (m->queued_message)
1330 bus_send_queued_message(m);
1335 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n) {
1336 _cleanup_strv_free_ char **tags = NULL;
1343 tags = strv_split(buf, "\n\r");
1349 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1351 if (UNIT_VTABLE(u)->notify_message)
1352 UNIT_VTABLE(u)->notify_message(u, pid, tags);
1355 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1356 Manager *m = userdata;
1360 assert(m->notify_fd == fd);
1362 if (revents != EPOLLIN) {
1363 log_warning("Got unexpected poll event for notify fd.");
1369 struct iovec iovec = {
1371 .iov_len = sizeof(buf)-1,
1376 struct cmsghdr cmsghdr;
1377 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1380 struct msghdr msghdr = {
1383 .msg_control = &control,
1384 .msg_controllen = sizeof(control),
1386 struct ucred *ucred;
1389 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1394 if (errno == EAGAIN || errno == EINTR)
1400 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1401 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1402 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1403 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1404 log_warning("Received notify message without credentials. Ignoring.");
1408 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1410 assert((size_t) n < sizeof(buf));
1413 u = manager_get_unit_by_pid(m, ucred->pid);
1415 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1419 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1421 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1425 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1427 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1432 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1438 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1443 log_debug_unit(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1445 unit_unwatch_pid(u, si->si_pid);
1446 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1449 static int manager_dispatch_sigchld(Manager *m) {
1455 /* First we call waitd() for a PID and do not reap the
1456 * zombie. That way we can still access /proc/$PID for
1457 * it while it is a zombie. */
1458 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1460 if (errno == ECHILD)
1472 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1473 _cleanup_free_ char *name = NULL;
1476 get_process_comm(si.si_pid, &name);
1478 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1479 si.si_pid, strna(name),
1480 sigchld_code_to_string(si.si_code),
1482 strna(si.si_code == CLD_EXITED
1483 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1484 : signal_to_string(si.si_status)));
1486 /* And now figure out the unit this belongs
1487 * to, it might be multiple... */
1488 u = manager_get_unit_by_pid(m, si.si_pid);
1490 invoke_sigchld_event(m, u, &si);
1491 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1493 invoke_sigchld_event(m, u, &si);
1494 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1496 invoke_sigchld_event(m, u, &si);
1499 /* And now, we actually reap the zombie. */
1500 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1511 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1512 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1515 log_debug_unit(name, "Activating special unit %s", name);
1517 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1519 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1524 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1525 Manager *m = userdata;
1527 struct signalfd_siginfo sfsi;
1528 bool sigchld = false;
1531 assert(m->signal_fd == fd);
1533 if (revents != EPOLLIN) {
1534 log_warning("Got unexpected events from signal file descriptor.");
1539 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1540 if (n != sizeof(sfsi)) {
1545 if (errno == EINTR || errno == EAGAIN)
1551 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1552 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1553 ? LOG_DEBUG : LOG_INFO,
1556 switch (sfsi.ssi_signo) {
1563 if (m->running_as == SYSTEMD_SYSTEM) {
1564 /* This is for compatibility with the
1565 * original sysvinit */
1566 m->exit_code = MANAGER_REEXECUTE;
1573 if (m->running_as == SYSTEMD_SYSTEM) {
1574 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1578 /* Run the exit target if there is one, if not, just exit. */
1579 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1580 m->exit_code = MANAGER_EXIT;
1587 if (m->running_as == SYSTEMD_SYSTEM)
1588 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1590 /* This is a nop on non-init */
1594 if (m->running_as == SYSTEMD_SYSTEM)
1595 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1597 /* This is a nop on non-init */
1603 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1605 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1606 log_info("Trying to reconnect to bus...");
1610 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1611 log_info("Loading D-Bus service...");
1612 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1619 _cleanup_free_ char *dump = NULL;
1620 _cleanup_fclose_ FILE *f = NULL;
1623 f = open_memstream(&dump, &size);
1625 log_warning("Failed to allocate memory stream.");
1629 manager_dump_units(m, f, "\t");
1630 manager_dump_jobs(m, f, "\t");
1633 log_warning("Failed to write status stream");
1638 log_warning("Failed to flush status stream");
1642 log_dump(LOG_INFO, dump);
1647 m->exit_code = MANAGER_RELOAD;
1652 /* Starting SIGRTMIN+0 */
1653 static const char * const target_table[] = {
1654 [0] = SPECIAL_DEFAULT_TARGET,
1655 [1] = SPECIAL_RESCUE_TARGET,
1656 [2] = SPECIAL_EMERGENCY_TARGET,
1657 [3] = SPECIAL_HALT_TARGET,
1658 [4] = SPECIAL_POWEROFF_TARGET,
1659 [5] = SPECIAL_REBOOT_TARGET,
1660 [6] = SPECIAL_KEXEC_TARGET
1663 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1664 static const ManagerExitCode code_table[] = {
1666 [1] = MANAGER_POWEROFF,
1667 [2] = MANAGER_REBOOT,
1671 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1672 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1673 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1674 manager_start_target(m, target_table[idx],
1675 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1679 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1680 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1681 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1685 switch (sfsi.ssi_signo - SIGRTMIN) {
1688 log_debug("Enabling showing of status.");
1689 manager_set_show_status(m, SHOW_STATUS_YES);
1693 log_debug("Disabling showing of status.");
1694 manager_set_show_status(m, SHOW_STATUS_NO);
1698 log_set_max_level(LOG_DEBUG);
1699 log_notice("Setting log level to debug.");
1703 log_set_max_level(LOG_INFO);
1704 log_notice("Setting log level to info.");
1708 if (m->running_as == SYSTEMD_USER) {
1709 m->exit_code = MANAGER_EXIT;
1713 /* This is a nop on init */
1717 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1718 log_notice("Setting log target to journal-or-kmsg.");
1722 log_set_target(LOG_TARGET_CONSOLE);
1723 log_notice("Setting log target to console.");
1727 log_set_target(LOG_TARGET_KMSG);
1728 log_notice("Setting log target to kmsg.");
1732 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1733 log_notice("Setting log target to syslog-or-kmsg.");
1737 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1744 manager_dispatch_sigchld(m);
1749 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1750 Manager *m = userdata;
1755 assert(m->time_change_fd == fd);
1757 log_struct(LOG_INFO,
1758 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1759 "MESSAGE=Time has been changed",
1762 /* Restart the watch */
1763 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1764 m->time_change_fd = safe_close(m->time_change_fd);
1766 manager_setup_time_change(m);
1768 HASHMAP_FOREACH(u, m->units, i)
1769 if (UNIT_VTABLE(u)->time_change)
1770 UNIT_VTABLE(u)->time_change(u);
1775 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1776 Manager *m = userdata;
1779 assert(m->idle_pipe[2] == fd);
1781 m->no_console_output = m->n_on_console > 0;
1783 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1784 manager_close_idle_pipe(m);
1789 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1790 Manager *m = userdata;
1797 manager_print_jobs_in_progress(m);
1799 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1800 r = sd_event_source_set_time(source, next);
1804 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1807 int manager_loop(Manager *m) {
1810 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1813 m->exit_code = MANAGER_OK;
1815 /* Release the path cache */
1816 set_free_free(m->unit_path_cache);
1817 m->unit_path_cache = NULL;
1819 manager_check_finished(m);
1821 /* There might still be some zombies hanging around from
1822 * before we were exec()'ed. Let's reap them. */
1823 r = manager_dispatch_sigchld(m);
1827 while (m->exit_code == MANAGER_OK) {
1830 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1833 if (!ratelimit_test(&rl)) {
1834 /* Yay, something is going seriously wrong, pause a little */
1835 log_warning("Looping too fast. Throttling execution a little.");
1840 if (manager_dispatch_load_queue(m) > 0)
1843 if (manager_dispatch_gc_queue(m) > 0)
1846 if (manager_dispatch_cleanup_queue(m) > 0)
1849 if (manager_dispatch_cgroup_queue(m) > 0)
1852 if (manager_dispatch_dbus_queue(m) > 0)
1855 /* Sleep for half the watchdog time */
1856 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1857 wait_usec = m->runtime_watchdog / 2;
1861 wait_usec = (usec_t) -1;
1863 r = sd_event_run(m->event, wait_usec);
1865 log_error("Failed to run event loop: %s", strerror(-r));
1870 return m->exit_code;
1873 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1874 _cleanup_free_ char *n = NULL;
1882 r = unit_name_from_dbus_path(s, &n);
1886 r = manager_load_unit(m, n, NULL, e, &u);
1895 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1905 p = startswith(s, "/org/freedesktop/systemd1/job/");
1909 r = safe_atou(p, &id);
1913 j = manager_get_job(m, id);
1922 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1925 _cleanup_free_ char *p = NULL;
1928 audit_fd = get_audit_fd();
1932 /* Don't generate audit events if the service was already
1933 * started and we're just deserializing */
1934 if (m->n_reloading > 0)
1937 if (m->running_as != SYSTEMD_SYSTEM)
1940 if (u->type != UNIT_SERVICE)
1943 p = unit_name_to_prefix_and_instance(u->id);
1945 log_error_unit(u->id,
1946 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1950 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1951 if (errno == EPERM) {
1952 /* We aren't allowed to send audit messages?
1953 * Then let's not retry again. */
1956 log_warning("Failed to send audit message: %m");
1962 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1963 union sockaddr_union sa = {
1964 .un.sun_family = AF_UNIX,
1965 .un.sun_path = "\0/org/freedesktop/plymouthd",
1969 _cleanup_free_ char *message = NULL;
1970 _cleanup_close_ int fd = -1;
1972 /* Don't generate plymouth events if the service was already
1973 * started and we're just deserializing */
1974 if (m->n_reloading > 0)
1977 if (m->running_as != SYSTEMD_SYSTEM)
1980 if (detect_container(NULL) > 0)
1983 if (u->type != UNIT_SERVICE &&
1984 u->type != UNIT_MOUNT &&
1985 u->type != UNIT_SWAP)
1988 /* We set SOCK_NONBLOCK here so that we rather drop the
1989 * message then wait for plymouth */
1990 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1992 log_error("socket() failed: %m");
1996 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1998 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
1999 log_error("connect() failed: %m");
2003 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2009 if (write(fd, message, n + 1) != n + 1)
2010 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2011 log_error("Failed to write Plymouth message: %m");
2014 void manager_dispatch_bus_name_owner_changed(
2017 const char* old_owner,
2018 const char *new_owner) {
2025 u = hashmap_get(m->watch_bus, name);
2029 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2032 int manager_open_serialization(Manager *m, FILE **_f) {
2039 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2040 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2044 log_debug("Serializing state to %s", path);
2046 f = fdopen(fd, "w+");
2057 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2070 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2071 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2072 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2073 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2075 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2076 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2077 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2078 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2081 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2082 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2083 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2084 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2085 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2086 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2087 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2088 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2091 if (!switching_root) {
2092 STRV_FOREACH(e, m->environment) {
2093 _cleanup_free_ char *ce;
2099 fprintf(f, "env=%s\n", *e);
2103 if (m->notify_fd >= 0) {
2106 copy = fdset_put_dup(fds, m->notify_fd);
2110 fprintf(f, "notify-fd=%i\n", copy);
2111 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2114 if (m->kdbus_fd >= 0) {
2117 copy = fdset_put_dup(fds, m->kdbus_fd);
2121 fprintf(f, "kdbus-fd=%i\n", copy);
2124 bus_track_serialize(m->subscribed, f);
2128 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2132 if (!unit_can_serialize(u))
2139 r = unit_serialize(u, f, fds, !switching_root);
2146 assert(m->n_reloading > 0);
2152 r = bus_fdset_add_all(m, fds);
2159 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2165 log_debug("Deserializing state...");
2170 char line[LINE_MAX], *l;
2172 if (!fgets(line, sizeof(line), f)) {
2187 if (startswith(l, "current-job-id=")) {
2190 if (safe_atou32(l+15, &id) < 0)
2191 log_debug("Failed to parse current job id value %s", l+15);
2193 m->current_job_id = MAX(m->current_job_id, id);
2195 } else if (startswith(l, "n-installed-jobs=")) {
2198 if (safe_atou32(l+17, &n) < 0)
2199 log_debug("Failed to parse installed jobs counter %s", l+17);
2201 m->n_installed_jobs += n;
2203 } else if (startswith(l, "n-failed-jobs=")) {
2206 if (safe_atou32(l+14, &n) < 0)
2207 log_debug("Failed to parse failed jobs counter %s", l+14);
2209 m->n_failed_jobs += n;
2211 } else if (startswith(l, "taint-usr=")) {
2214 b = parse_boolean(l+10);
2216 log_debug("Failed to parse taint /usr flag %s", l+10);
2218 m->taint_usr = m->taint_usr || b;
2220 } else if (startswith(l, "firmware-timestamp="))
2221 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2222 else if (startswith(l, "loader-timestamp="))
2223 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2224 else if (startswith(l, "kernel-timestamp="))
2225 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2226 else if (startswith(l, "initrd-timestamp="))
2227 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2228 else if (startswith(l, "userspace-timestamp="))
2229 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2230 else if (startswith(l, "finish-timestamp="))
2231 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2232 else if (startswith(l, "security-start-timestamp="))
2233 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2234 else if (startswith(l, "security-finish-timestamp="))
2235 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2236 else if (startswith(l, "generators-start-timestamp="))
2237 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2238 else if (startswith(l, "generators-finish-timestamp="))
2239 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2240 else if (startswith(l, "units-load-start-timestamp="))
2241 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2242 else if (startswith(l, "units-load-finish-timestamp="))
2243 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2244 else if (startswith(l, "env=")) {
2245 _cleanup_free_ char *uce = NULL;
2248 uce = cunescape(l+4);
2254 e = strv_env_set(m->environment, uce);
2260 strv_free(m->environment);
2263 } else if (startswith(l, "notify-fd=")) {
2266 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2267 log_debug("Failed to parse notify fd: %s", l + 10);
2269 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2270 safe_close(m->notify_fd);
2271 m->notify_fd = fdset_remove(fds, fd);
2274 } else if (startswith(l, "notify-socket=")) {
2283 free(m->notify_socket);
2284 m->notify_socket = n;
2286 } else if (startswith(l, "kdbus-fd=")) {
2289 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2290 log_debug("Failed to parse kdbus fd: %s", l + 9);
2292 safe_close(m->kdbus_fd);
2293 m->kdbus_fd = fdset_remove(fds, fd);
2296 } else if (bus_track_deserialize_item(&m->deserialized_subscribed, l) == 0)
2297 log_debug("Unknown serialization item '%s'", l);
2302 char name[UNIT_NAME_MAX+2];
2305 if (!fgets(name, sizeof(name), f)) {
2316 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2320 r = unit_deserialize(u, f, fds);
2329 assert(m->n_reloading > 0);
2335 int manager_reload(Manager *m) {
2337 _cleanup_fclose_ FILE *f = NULL;
2338 _cleanup_fdset_free_ FDSet *fds = NULL;
2342 r = manager_open_serialization(m, &f);
2347 bus_manager_send_reloading(m, true);
2355 r = manager_serialize(m, f, fds, false);
2361 if (fseeko(f, 0, SEEK_SET) < 0) {
2366 /* From here on there is no way back. */
2367 manager_clear_jobs_and_units(m);
2368 manager_undo_generators(m);
2369 lookup_paths_free(&m->lookup_paths);
2371 /* Find new unit paths */
2372 manager_run_generators(m);
2374 q = lookup_paths_init(
2375 &m->lookup_paths, m->running_as, true,
2376 m->generator_unit_path,
2377 m->generator_unit_path_early,
2378 m->generator_unit_path_late);
2382 manager_build_unit_path_cache(m);
2384 /* First, enumerate what we can from all config files */
2385 q = manager_enumerate(m);
2389 /* Second, deserialize our stored data */
2390 q = manager_deserialize(m, f, fds);
2397 /* Re-register notify_fd as event source */
2398 q = manager_setup_notify(m);
2402 /* Third, fire things up! */
2403 q = manager_coldplug(m);
2407 assert(m->n_reloading > 0);
2410 m->send_reloading_done = true;
2415 bool manager_is_reloading_or_reexecuting(Manager *m) {
2418 return m->n_reloading != 0;
2421 void manager_reset_failed(Manager *m) {
2427 HASHMAP_FOREACH(u, m->units, i)
2428 unit_reset_failed(u);
2431 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2437 /* Returns true if the unit is inactive or going down */
2438 u = manager_get_unit(m, name);
2442 return unit_inactive_or_pending(u);
2445 void manager_check_finished(Manager *m) {
2446 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2447 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2451 if (m->n_running_jobs == 0)
2452 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2454 if (hashmap_size(m->jobs) > 0) {
2456 if (m->jobs_in_progress_event_source) {
2457 sd_event_source_set_time(m->jobs_in_progress_event_source,
2458 now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2464 manager_flip_auto_status(m, false);
2466 /* Notify Type=idle units that we are done now */
2467 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2468 manager_close_idle_pipe(m);
2470 /* Turn off confirm spawn now */
2471 m->confirm_spawn = false;
2473 if (dual_timestamp_is_set(&m->finish_timestamp))
2476 dual_timestamp_get(&m->finish_timestamp);
2478 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2480 /* Note that m->kernel_usec.monotonic is always at 0,
2481 * and m->firmware_usec.monotonic and
2482 * m->loader_usec.monotonic should be considered
2483 * negative values. */
2485 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2486 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2487 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2488 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2490 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2492 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2493 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2495 if (!log_on_console())
2496 log_struct(LOG_INFO,
2497 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2498 "KERNEL_USEC="USEC_FMT, kernel_usec,
2499 "INITRD_USEC="USEC_FMT, initrd_usec,
2500 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2501 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2502 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2503 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2504 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2505 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2508 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2511 if (!log_on_console())
2512 log_struct(LOG_INFO,
2513 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2514 "KERNEL_USEC="USEC_FMT, kernel_usec,
2515 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2516 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2517 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2518 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2519 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2523 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2524 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2526 if (!log_on_console())
2527 log_struct(LOG_INFO,
2528 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2529 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2530 "MESSAGE=Startup finished in %s.",
2531 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2535 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2538 "READY=1\nSTATUS=Startup finished in %s.",
2539 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2542 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2553 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2554 /* systemd --system, not running --test */
2556 p = strappend("/run/systemd/", name);
2560 r = mkdir_p_label(p, 0755);
2562 log_error("Failed to create generator directory %s: %s",
2567 } else if (m->running_as == SYSTEMD_USER) {
2568 const char *s = NULL;
2570 s = getenv("XDG_RUNTIME_DIR");
2573 p = strjoin(s, "/systemd/", name, NULL);
2577 r = mkdir_p_label(p, 0755);
2579 log_error("Failed to create generator directory %s: %s",
2585 /* systemd --system --test */
2587 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2592 log_error("Failed to create generator directory %s: %m",
2603 static void trim_generator_dir(Manager *m, char **generator) {
2610 if (rmdir(*generator) >= 0) {
2618 void manager_run_generators(Manager *m) {
2619 _cleanup_closedir_ DIR *d = NULL;
2620 const char *generator_path;
2621 const char *argv[5];
2626 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2627 d = opendir(generator_path);
2629 if (errno == ENOENT)
2632 log_error("Failed to enumerate generator directory %s: %m",
2637 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2641 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2645 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2649 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2650 argv[1] = m->generator_unit_path;
2651 argv[2] = m->generator_unit_path_early;
2652 argv[3] = m->generator_unit_path_late;
2655 RUN_WITH_UMASK(0022)
2656 execute_directory(generator_path, d, DEFAULT_TIMEOUT_USEC, (char**) argv);
2659 trim_generator_dir(m, &m->generator_unit_path);
2660 trim_generator_dir(m, &m->generator_unit_path_early);
2661 trim_generator_dir(m, &m->generator_unit_path_late);
2664 static void remove_generator_dir(Manager *m, char **generator) {
2671 strv_remove(m->lookup_paths.unit_path, *generator);
2672 rm_rf(*generator, false, true, false);
2678 void manager_undo_generators(Manager *m) {
2681 remove_generator_dir(m, &m->generator_unit_path);
2682 remove_generator_dir(m, &m->generator_unit_path_early);
2683 remove_generator_dir(m, &m->generator_unit_path_late);
2686 int manager_environment_add(Manager *m, char **minus, char **plus) {
2687 char **a = NULL, **b = NULL, **l;
2692 if (!strv_isempty(minus)) {
2693 a = strv_env_delete(l, 1, minus);
2700 if (!strv_isempty(plus)) {
2701 b = strv_env_merge(2, l, plus);
2708 if (m->environment != l)
2709 strv_free(m->environment);
2716 manager_clean_environment(m);
2717 strv_sort(m->environment);
2722 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2727 for (i = 0; i < _RLIMIT_MAX; i++) {
2728 if (!default_rlimit[i])
2731 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2739 void manager_recheck_journal(Manager *m) {
2744 if (m->running_as != SYSTEMD_SYSTEM)
2747 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2748 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2749 log_close_journal();
2753 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2754 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2755 log_close_journal();
2759 /* Hmm, OK, so the socket is fully up and the service is up
2760 * too, then let's make use of the thing. */
2764 void manager_set_show_status(Manager *m, ShowStatus mode) {
2766 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2768 if (m->running_as != SYSTEMD_SYSTEM)
2771 m->show_status = mode;
2774 touch("/run/systemd/show-status");
2776 unlink("/run/systemd/show-status");
2779 static bool manager_get_show_status(Manager *m) {
2782 if (m->running_as != SYSTEMD_SYSTEM)
2785 if (m->no_console_output)
2788 if (!IN_SET(manager_state(m), MANAGER_STARTING, MANAGER_STOPPING))
2791 if (m->show_status > 0)
2794 /* If Plymouth is running make sure we show the status, so
2795 * that there's something nice to see when people press Esc */
2797 return plymouth_running();
2800 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2803 if (!manager_get_show_status(m))
2806 /* XXX We should totally drop the check for ephemeral here
2807 * and thus effectively make 'Type=idle' pointless. */
2808 if (ephemeral && m->n_on_console > 0)
2811 va_start(ap, format);
2812 status_vprintf(status, true, ephemeral, format, ap);
2816 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2817 _cleanup_free_ char *p = NULL;
2825 p = unit_name_from_path(path, suffix);
2829 found = manager_get_unit(m, p);
2839 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2840 char p[strlen(path)+1];
2846 path_kill_slashes(p);
2848 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
2851 const char *manager_get_runtime_prefix(Manager *m) {
2854 return m->running_as == SYSTEMD_SYSTEM ?
2856 getenv("XDG_RUNTIME_DIR");
2859 ManagerState manager_state(Manager *m) {
2864 /* Did we ever finish booting? If not then we are still starting up */
2865 if (!dual_timestamp_is_set(&m->finish_timestamp))
2866 return MANAGER_STARTING;
2868 /* Is the special shutdown target queued? If so, we are in shutdown state */
2869 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2870 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
2871 return MANAGER_STOPPING;
2873 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
2874 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
2875 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2876 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2877 return MANAGER_MAINTENANCE;
2879 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
2880 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2881 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2882 return MANAGER_MAINTENANCE;
2884 /* Are there any failed units? If so, we are in degraded mode */
2885 if (set_size(m->failed_units) > 0)
2886 return MANAGER_DEGRADED;
2888 return MANAGER_RUNNING;
2891 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
2892 [MANAGER_STARTING] = "starting",
2893 [MANAGER_RUNNING] = "running",
2894 [MANAGER_DEGRADED] = "degraded",
2895 [MANAGER_MAINTENANCE] = "maintenance",
2896 [MANAGER_STOPPING] = "stopping",
2899 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);