1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
29 #include <sys/reboot.h>
30 #include <sys/ioctl.h>
34 #include <sys/types.h>
37 #include <sys/timerfd.h>
43 #include "sd-daemon.h"
45 #include "sd-messages.h"
48 #include "transaction.h"
55 #include "ratelimit.h"
56 #include "locale-setup.h"
57 #include "mount-setup.h"
58 #include "unit-name.h"
60 #include "path-lookup.h"
62 #include "exit-status.h"
65 #include "cgroup-util.h"
66 #include "path-util.h"
68 #include "boot-timestamps.h"
70 #include "bus-errors.h"
71 #include "bus-error.h"
74 #include "dbus-unit.h"
76 #include "dbus-manager.h"
77 #include "bus-kernel.h"
79 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
80 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
82 /* Initial delay and the interval for printing status messages about running jobs */
83 #define JOBS_IN_PROGRESS_WAIT_USEC (5*USEC_PER_SEC)
84 #define JOBS_IN_PROGRESS_PERIOD_USEC (USEC_PER_SEC / 3)
85 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
87 /* Where clients shall send notification messages to */
88 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
90 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
92 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
93 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
94 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
95 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
96 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
97 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
99 static int manager_watch_jobs_in_progress(Manager *m) {
102 if (m->jobs_in_progress_event_source)
105 return sd_event_add_monotonic(m->event, now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC, 0, manager_dispatch_jobs_in_progress, m, &m->jobs_in_progress_event_source);
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 static void manager_print_jobs_in_progress(Manager *m) {
140 _cleanup_free_ char *job_of_n = NULL;
143 unsigned counter = 0, print_nr;
144 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
146 char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
151 if (m->show_status == SHOW_STATUS_AUTO)
152 manager_set_show_status(m, SHOW_STATUS_TEMPORARY);
154 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
156 HASHMAP_FOREACH(j, m->jobs, i)
157 if (j->state == JOB_RUNNING && counter++ == print_nr)
160 /* m->n_running_jobs must be consistent with the contents of m->jobs,
161 * so the above loop must have succeeded in finding j. */
162 assert(counter == print_nr + 1);
165 cylon_pos = m->jobs_in_progress_iteration % 14;
167 cylon_pos = 14 - cylon_pos;
168 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
170 m->jobs_in_progress_iteration++;
172 if (m->n_running_jobs > 1)
173 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
176 format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
177 if (job_get_timeout(j, &x) > 0)
178 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
180 manager_status_printf(m, true, cylon,
181 "%sA %s job is running for %s (%s / %s)",
183 job_type_to_string(j->type),
184 unit_description(j->unit),
189 static int manager_watch_idle_pipe(Manager *m) {
194 if (m->idle_pipe_event_source)
197 if (m->idle_pipe[2] < 0)
200 r = sd_event_add_io(m->event, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m, &m->idle_pipe_event_source);
202 log_error("Failed to watch idle pipe: %s", strerror(-r));
209 static void manager_close_idle_pipe(Manager *m) {
212 close_pipe(m->idle_pipe);
213 close_pipe(m->idle_pipe + 2);
216 static int manager_setup_time_change(Manager *m) {
219 /* We only care for the cancellation event, hence we set the
220 * timeout to the latest possible value. */
221 struct itimerspec its = {
222 .it_value.tv_sec = TIME_T_MAX,
226 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
228 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
229 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
231 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
232 if (m->time_change_fd < 0) {
233 log_error("Failed to create timerfd: %m");
237 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
238 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
239 close_nointr_nofail(m->time_change_fd);
240 m->time_change_fd = -1;
244 r = sd_event_add_io(m->event, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m, &m->time_change_event_source);
246 log_error("Failed to create time change event source: %s", strerror(-r));
250 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
255 static int enable_special_signals(Manager *m) {
256 _cleanup_close_ int fd = -1;
260 /* Enable that we get SIGINT on control-alt-del. In containers
261 * this will fail with EPERM (older) or EINVAL (newer), so
263 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
264 log_warning("Failed to enable ctrl-alt-del handling: %m");
266 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
268 /* Support systems without virtual console */
270 log_warning("Failed to open /dev/tty0: %m");
272 /* Enable that we get SIGWINCH on kbrequest */
273 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
274 log_warning("Failed to enable kbrequest handling: %m");
280 static int manager_setup_signals(Manager *m) {
281 struct sigaction sa = {
282 .sa_handler = SIG_DFL,
283 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
290 /* We are not interested in SIGSTOP and friends. */
291 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
293 assert_se(sigemptyset(&mask) == 0);
295 sigset_add_many(&mask,
296 SIGCHLD, /* Child died */
297 SIGTERM, /* Reexecute daemon */
298 SIGHUP, /* Reload configuration */
299 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
300 SIGUSR2, /* systemd: dump status */
301 SIGINT, /* Kernel sends us this on control-alt-del */
302 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
303 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
304 SIGRTMIN+0, /* systemd: start default.target */
305 SIGRTMIN+1, /* systemd: isolate rescue.target */
306 SIGRTMIN+2, /* systemd: isolate emergency.target */
307 SIGRTMIN+3, /* systemd: start halt.target */
308 SIGRTMIN+4, /* systemd: start poweroff.target */
309 SIGRTMIN+5, /* systemd: start reboot.target */
310 SIGRTMIN+6, /* systemd: start kexec.target */
311 SIGRTMIN+13, /* systemd: Immediate halt */
312 SIGRTMIN+14, /* systemd: Immediate poweroff */
313 SIGRTMIN+15, /* systemd: Immediate reboot */
314 SIGRTMIN+16, /* systemd: Immediate kexec */
315 SIGRTMIN+20, /* systemd: enable status messages */
316 SIGRTMIN+21, /* systemd: disable status messages */
317 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
318 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
319 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
320 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
321 SIGRTMIN+27, /* systemd: set log target to console */
322 SIGRTMIN+28, /* systemd: set log target to kmsg */
323 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
325 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
327 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
328 if (m->signal_fd < 0)
331 r = sd_event_add_io(m->event, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m, &m->signal_event_source);
335 /* Process signals a bit earlier than the rest of things, but
336 * later that notify_fd processing, so that the notify
337 * processing can still figure out to which process/service a
338 * message belongs, before we reap the process. */
339 r = sd_event_source_set_priority(m->signal_event_source, -5);
343 if (m->running_as == SYSTEMD_SYSTEM)
344 return enable_special_signals(m);
349 static void manager_clean_environment(Manager *m) {
352 /* Let's remove some environment variables that we
353 * need ourselves to communicate with our clients */
366 static int manager_default_environment(Manager *m) {
369 if (m->running_as == SYSTEMD_SYSTEM) {
370 /* The system manager always starts with a clean
371 * environment for its children. It does not import
372 * the kernel or the parents exported variables.
374 * The initial passed environ is untouched to keep
375 * /proc/self/environ valid; it is used for tagging
376 * the init process inside containers. */
377 m->environment = strv_new("PATH=" DEFAULT_PATH,
380 /* Import locale variables LC_*= from configuration */
381 locale_setup(&m->environment);
383 /* The user manager passes its own environment
384 * along to its children. */
385 m->environment = strv_copy(environ);
391 manager_clean_environment(m);
392 strv_sort(m->environment);
397 int manager_new(SystemdRunningAs running_as, Manager **_m) {
402 assert(running_as >= 0);
403 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
405 m = new0(Manager, 1);
410 if (detect_container(NULL) <= 0)
411 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
414 m->running_as = running_as;
415 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
417 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
419 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;
420 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
422 r = manager_default_environment(m);
426 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
430 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
434 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
438 r = hashmap_ensure_allocated(&m->watch_pids, trivial_hash_func, trivial_compare_func);
442 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
446 r = sd_event_default(&m->event);
450 r = sd_event_add_defer(m->event, manager_dispatch_run_queue, m, &m->run_queue_event_source);
454 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
458 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
462 r = manager_setup_signals(m);
466 r = manager_setup_cgroup(m);
470 r = manager_setup_time_change(m);
474 m->udev = udev_new();
480 /* Note that we set up neither kdbus, nor the notify fd
481 * here. We do that after deserialization, since they might
482 * have gotten serialized across the reexec. */
484 m->taint_usr = dir_is_empty("/usr") > 0;
494 static int manager_setup_notify(Manager *m) {
497 struct sockaddr_un un;
499 .sa.sa_family = AF_UNIX,
503 if (m->notify_fd < 0) {
504 _cleanup_close_ int fd = -1;
506 /* First free all secondary fields */
507 free(m->notify_socket);
508 m->notify_socket = NULL;
509 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
511 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
513 log_error("Failed to allocate notification socket: %m");
517 if (getpid() != 1 || detect_container(NULL) > 0)
518 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%" PRIx64, random_u64());
520 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
521 sa.un.sun_path[0] = 0;
523 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
525 log_error("bind() failed: %m");
529 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
531 log_error("SO_PASSCRED failed: %m");
535 sa.un.sun_path[0] = '@';
536 m->notify_socket = strdup(sa.un.sun_path);
537 if (!m->notify_socket)
543 log_debug("Using notification socket %s", m->notify_socket);
546 if (!m->notify_event_source) {
547 r = sd_event_add_io(m->event, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m, &m->notify_event_source);
549 log_error("Failed to allocate notify event source: %s", strerror(-r));
553 /* Process signals a bit earlier than SIGCHLD, so that we can
554 * still identify to which service an exit message belongs */
555 r = sd_event_source_set_priority(m->notify_event_source, -7);
557 log_error("Failed to set priority of notify event source: %s", strerror(-r));
565 static int manager_setup_kdbus(Manager *m) {
567 _cleanup_free_ char *p = NULL;
573 if (m->kdbus_fd >= 0)
576 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
577 if (m->kdbus_fd < 0) {
578 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
582 log_debug("Successfully set up kdbus on %s", p);
584 /* Create the namespace directory here, so that the contents
585 * of that directory is not visible to non-root users. This is
586 * necessary to ensure that users cannot get access to busses
587 * of virtualized users when no UID namespacing is used. */
588 if (m->running_as == SYSTEMD_SYSTEM)
589 mkdir_p_label("/dev/kdbus/ns", 0700);
595 static int manager_connect_bus(Manager *m, bool reexecuting) {
596 bool try_bus_connect;
603 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
605 /* Try to connect to the busses, if possible. */
606 return bus_init(m, try_bus_connect);
609 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
615 while ((u = m->cleanup_queue)) {
616 assert(u->in_cleanup_queue);
626 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
627 GC_OFFSET_UNSURE, /* No clue */
628 GC_OFFSET_GOOD, /* We still need this unit */
629 GC_OFFSET_BAD, /* We don't need this unit anymore */
633 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
640 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
641 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
642 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
645 if (u->in_cleanup_queue)
648 if (unit_check_gc(u))
651 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
655 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
656 unit_gc_sweep(other, gc_marker);
658 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
661 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
668 /* We were unable to find anything out about this entry, so
669 * let's investigate it later */
670 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
671 unit_add_to_gc_queue(u);
675 /* We definitely know that this one is not useful anymore, so
676 * let's mark it for deletion */
677 u->gc_marker = gc_marker + GC_OFFSET_BAD;
678 unit_add_to_cleanup_queue(u);
682 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
685 static unsigned manager_dispatch_gc_queue(Manager *m) {
692 /* log_debug("Running GC..."); */
694 m->gc_marker += _GC_OFFSET_MAX;
695 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
698 gc_marker = m->gc_marker;
700 while ((u = m->gc_queue)) {
701 assert(u->in_gc_queue);
703 unit_gc_sweep(u, gc_marker);
705 LIST_REMOVE(gc_queue, m->gc_queue, u);
706 u->in_gc_queue = false;
710 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
711 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
712 log_debug_unit(u->id, "Collecting %s", u->id);
713 u->gc_marker = gc_marker + GC_OFFSET_BAD;
714 unit_add_to_cleanup_queue(u);
718 m->n_in_gc_queue = 0;
723 static void manager_clear_jobs_and_units(Manager *m) {
728 while ((u = hashmap_first(m->units)))
731 manager_dispatch_cleanup_queue(m);
733 assert(!m->load_queue);
734 assert(!m->run_queue);
735 assert(!m->dbus_unit_queue);
736 assert(!m->dbus_job_queue);
737 assert(!m->cleanup_queue);
738 assert(!m->gc_queue);
740 assert(hashmap_isempty(m->jobs));
741 assert(hashmap_isempty(m->units));
744 m->n_running_jobs = 0;
747 void manager_free(Manager *m) {
753 manager_clear_jobs_and_units(m);
755 for (c = 0; c < _UNIT_TYPE_MAX; c++)
756 if (unit_vtable[c]->shutdown)
757 unit_vtable[c]->shutdown(m);
759 /* If we reexecute ourselves, we keep the root cgroup
761 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
763 manager_undo_generators(m);
767 hashmap_free(m->units);
768 hashmap_free(m->jobs);
769 hashmap_free(m->watch_pids);
770 hashmap_free(m->watch_bus);
772 sd_event_source_unref(m->signal_event_source);
773 sd_event_source_unref(m->notify_event_source);
774 sd_event_source_unref(m->time_change_event_source);
775 sd_event_source_unref(m->jobs_in_progress_event_source);
776 sd_event_source_unref(m->idle_pipe_event_source);
777 sd_event_source_unref(m->run_queue_event_source);
779 if (m->signal_fd >= 0)
780 close_nointr_nofail(m->signal_fd);
781 if (m->notify_fd >= 0)
782 close_nointr_nofail(m->notify_fd);
783 if (m->time_change_fd >= 0)
784 close_nointr_nofail(m->time_change_fd);
785 if (m->kdbus_fd >= 0)
786 close_nointr_nofail(m->kdbus_fd);
788 manager_close_idle_pipe(m);
791 sd_event_unref(m->event);
793 free(m->notify_socket);
795 lookup_paths_free(&m->lookup_paths);
796 strv_free(m->environment);
798 hashmap_free(m->cgroup_unit);
799 set_free_free(m->unit_path_cache);
801 free(m->switch_root);
802 free(m->switch_root_init);
804 for (i = 0; i < RLIMIT_NLIMITS; i++)
807 assert(hashmap_isempty(m->units_requiring_mounts_for));
808 hashmap_free(m->units_requiring_mounts_for);
813 int manager_enumerate(Manager *m) {
819 /* Let's ask every type to load all units from disk/kernel
820 * that it might know */
821 for (c = 0; c < _UNIT_TYPE_MAX; c++)
822 if (unit_vtable[c]->enumerate) {
823 q = unit_vtable[c]->enumerate(m);
828 manager_dispatch_load_queue(m);
832 static int manager_coldplug(Manager *m) {
840 /* Then, let's set up their initial state. */
841 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
847 if ((q = unit_coldplug(u)) < 0)
854 static void manager_build_unit_path_cache(Manager *m) {
856 _cleanup_free_ DIR *d = NULL;
861 set_free_free(m->unit_path_cache);
863 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
864 if (!m->unit_path_cache) {
865 log_error("Failed to allocate unit path cache.");
869 /* This simply builds a list of files we know exist, so that
870 * we don't always have to go to disk */
872 STRV_FOREACH(i, m->lookup_paths.unit_path) {
878 log_error("Failed to open directory %s: %m", *i);
882 while ((de = readdir(d))) {
885 if (ignore_file(de->d_name))
888 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
894 r = set_consume(m->unit_path_cache, p);
906 log_error("Failed to build unit path cache: %s", strerror(-r));
908 set_free_free(m->unit_path_cache);
909 m->unit_path_cache = NULL;
913 static int manager_distribute_fds(Manager *m, FDSet *fds) {
920 HASHMAP_FOREACH(u, m->units, i) {
922 if (fdset_size(fds) <= 0)
925 if (UNIT_VTABLE(u)->distribute_fds) {
926 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
935 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
940 dual_timestamp_get(&m->generators_start_timestamp);
941 manager_run_generators(m);
942 dual_timestamp_get(&m->generators_finish_timestamp);
944 r = lookup_paths_init(
945 &m->lookup_paths, m->running_as, true,
946 m->generator_unit_path,
947 m->generator_unit_path_early,
948 m->generator_unit_path_late);
952 manager_build_unit_path_cache(m);
954 /* If we will deserialize make sure that during enumeration
955 * this is already known, so we increase the counter here
960 /* First, enumerate what we can from all config files */
961 dual_timestamp_get(&m->units_load_start_timestamp);
962 r = manager_enumerate(m);
963 dual_timestamp_get(&m->units_load_finish_timestamp);
965 /* Second, deserialize if there is something to deserialize */
967 q = manager_deserialize(m, serialization, fds);
972 /* Any fds left? Find some unit which wants them. This is
973 * useful to allow container managers to pass some file
974 * descriptors to us pre-initialized. This enables
975 * socket-based activation of entire containers. */
976 if (fdset_size(fds) > 0) {
977 q = manager_distribute_fds(m, fds);
982 /* We might have deserialized the notify fd, but if we didn't
983 * then let's create the bus now */
984 manager_setup_notify(m);
986 /* We might have deserialized the kdbus control fd, but if we
987 * didn't, then let's create the bus now. */
988 manager_setup_kdbus(m);
989 manager_connect_bus(m, !!serialization);
991 /* Third, fire things up! */
992 q = manager_coldplug(m);
997 assert(m->n_reloading > 0);
1000 /* Let's wait for the UnitNew/JobNew messages being
1001 * sent, before we notify that the reload is
1003 m->send_reloading_done = true;
1009 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1014 assert(type < _JOB_TYPE_MAX);
1016 assert(mode < _JOB_MODE_MAX);
1018 if (mode == JOB_ISOLATE && type != JOB_START) {
1019 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1023 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1024 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1028 log_debug_unit(unit->id,
1029 "Trying to enqueue job %s/%s/%s", unit->id,
1030 job_type_to_string(type), job_mode_to_string(mode));
1032 job_type_collapse(&type, unit);
1034 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1038 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1039 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1040 mode == JOB_IGNORE_DEPENDENCIES, e);
1044 if (mode == JOB_ISOLATE) {
1045 r = transaction_add_isolate_jobs(tr, m);
1050 r = transaction_activate(tr, m, mode, e);
1054 log_debug_unit(unit->id,
1055 "Enqueued job %s/%s as %u", unit->id,
1056 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1059 *_ret = tr->anchor_job;
1061 transaction_free(tr);
1065 transaction_abort(tr);
1066 transaction_free(tr);
1070 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1075 assert(type < _JOB_TYPE_MAX);
1077 assert(mode < _JOB_MODE_MAX);
1079 r = manager_load_unit(m, name, NULL, NULL, &unit);
1083 return manager_add_job(m, type, unit, mode, override, e, _ret);
1086 Job *manager_get_job(Manager *m, uint32_t id) {
1089 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1092 Unit *manager_get_unit(Manager *m, const char *name) {
1096 return hashmap_get(m->units, name);
1099 unsigned manager_dispatch_load_queue(Manager *m) {
1105 /* Make sure we are not run recursively */
1106 if (m->dispatching_load_queue)
1109 m->dispatching_load_queue = true;
1111 /* Dispatches the load queue. Takes a unit from the queue and
1112 * tries to load its data until the queue is empty */
1114 while ((u = m->load_queue)) {
1115 assert(u->in_load_queue);
1121 m->dispatching_load_queue = false;
1125 int manager_load_unit_prepare(
1137 assert(name || path);
1139 /* This will prepare the unit for loading, but not actually
1140 * load anything from disk. */
1142 if (path && !is_path(path))
1143 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1146 name = basename(path);
1148 t = unit_name_to_type(name);
1150 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1151 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1153 ret = manager_get_unit(m, name);
1159 ret = unit_new(m, unit_vtable[t]->object_size);
1164 ret->fragment_path = strdup(path);
1165 if (!ret->fragment_path) {
1171 r = unit_add_name(ret, name);
1177 unit_add_to_load_queue(ret);
1178 unit_add_to_dbus_queue(ret);
1179 unit_add_to_gc_queue(ret);
1187 int manager_load_unit(
1198 /* This will load the service information files, but not actually
1199 * start any services or anything. */
1201 r = manager_load_unit_prepare(m, name, path, e, _ret);
1205 manager_dispatch_load_queue(m);
1208 *_ret = unit_follow_merge(*_ret);
1213 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1220 HASHMAP_FOREACH(j, s->jobs, i)
1221 job_dump(j, f, prefix);
1224 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1232 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1234 unit_dump(u, f, prefix);
1237 void manager_clear_jobs(Manager *m) {
1242 while ((j = hashmap_first(m->jobs)))
1243 /* No need to recurse. We're cancelling all jobs. */
1244 job_finish_and_invalidate(j, JOB_CANCELED, false);
1247 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1248 Manager *m = userdata;
1254 while ((j = m->run_queue)) {
1255 assert(j->installed);
1256 assert(j->in_run_queue);
1258 job_run_and_invalidate(j);
1261 if (m->n_running_jobs > 0)
1262 manager_watch_jobs_in_progress(m);
1264 if (m->n_on_console > 0)
1265 manager_watch_idle_pipe(m);
1270 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1277 if (m->dispatching_dbus_queue)
1280 m->dispatching_dbus_queue = true;
1282 while ((u = m->dbus_unit_queue)) {
1283 assert(u->in_dbus_queue);
1285 bus_unit_send_change_signal(u);
1289 while ((j = m->dbus_job_queue)) {
1290 assert(j->in_dbus_queue);
1292 bus_job_send_change_signal(j);
1296 m->dispatching_dbus_queue = false;
1298 if (m->send_reloading_done) {
1299 m->send_reloading_done = false;
1301 bus_manager_send_reloading(m, false);
1304 if (m->queued_message)
1305 bus_send_queued_message(m);
1310 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1311 Manager *m = userdata;
1315 assert(m->notify_fd == fd);
1317 if (revents != EPOLLIN) {
1318 log_warning("Got unexpected poll event for notify fd.");
1324 struct iovec iovec = {
1326 .iov_len = sizeof(buf)-1,
1330 struct cmsghdr cmsghdr;
1331 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1334 struct msghdr msghdr = {
1337 .msg_control = &control,
1338 .msg_controllen = sizeof(control),
1340 struct ucred *ucred;
1342 _cleanup_strv_free_ char **tags = NULL;
1344 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1349 if (errno == EAGAIN || errno == EINTR)
1355 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1356 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1357 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1358 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1359 log_warning("Received notify message without credentials. Ignoring.");
1363 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1365 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1367 u = manager_get_unit_by_pid(m, ucred->pid);
1369 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1374 assert((size_t) n < sizeof(buf));
1376 tags = strv_split(buf, "\n\r");
1380 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1382 if (UNIT_VTABLE(u)->notify_message)
1383 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1389 static int manager_dispatch_sigchld(Manager *m) {
1396 /* First we call waitd() for a PID and do not reap the
1397 * zombie. That way we can still access /proc/$PID for
1398 * it while it is a zombie. */
1399 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1401 if (errno == ECHILD)
1413 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1414 _cleanup_free_ char *name = NULL;
1416 get_process_comm(si.si_pid, &name);
1417 log_debug("Got SIGCHLD for process "PID_FMT" (%s)", si.si_pid, strna(name));
1420 /* And now figure out the unit this belongs to */
1421 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1423 u = manager_get_unit_by_pid(m, si.si_pid);
1425 /* And now, we actually reap the zombie. */
1426 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1433 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1436 log_debug("Child %lu died (code=%s, status=%i/%s)",
1437 (long unsigned) si.si_pid,
1438 sigchld_code_to_string(si.si_code),
1440 strna(si.si_code == CLD_EXITED
1441 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1442 : signal_to_string(si.si_status)));
1447 log_debug_unit(u->id,
1448 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1450 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1451 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1457 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1458 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1461 log_debug_unit(name, "Activating special unit %s", name);
1463 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1465 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1470 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1471 Manager *m = userdata;
1473 struct signalfd_siginfo sfsi;
1474 bool sigchld = false;
1477 assert(m->signal_fd == fd);
1479 if (revents != EPOLLIN) {
1480 log_warning("Got unexpected events from signal file descriptor.");
1485 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1486 if (n != sizeof(sfsi)) {
1491 if (errno == EINTR || errno == EAGAIN)
1497 if (sfsi.ssi_pid > 0) {
1498 _cleanup_free_ char *p = NULL;
1500 get_process_comm(sfsi.ssi_pid, &p);
1502 log_full(sfsi.ssi_signo == SIGCHLD ||
1503 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1504 ? LOG_DEBUG : LOG_INFO,
1505 "Received SIG%s from PID "PID_FMT" (%s).",
1506 signal_to_string(sfsi.ssi_signo),
1507 sfsi.ssi_pid, strna(p));
1509 log_full(sfsi.ssi_signo == SIGCHLD ||
1510 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1511 ? LOG_DEBUG : LOG_INFO,
1513 signal_to_string(sfsi.ssi_signo));
1515 switch (sfsi.ssi_signo) {
1522 if (m->running_as == SYSTEMD_SYSTEM) {
1523 /* This is for compatibility with the
1524 * original sysvinit */
1525 m->exit_code = MANAGER_REEXECUTE;
1532 if (m->running_as == SYSTEMD_SYSTEM) {
1533 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1537 /* Run the exit target if there is one, if not, just exit. */
1538 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1539 m->exit_code = MANAGER_EXIT;
1546 if (m->running_as == SYSTEMD_SYSTEM)
1547 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1549 /* This is a nop on non-init */
1553 if (m->running_as == SYSTEMD_SYSTEM)
1554 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1556 /* This is a nop on non-init */
1562 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1564 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1565 log_info("Trying to reconnect to bus...");
1569 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1570 log_info("Loading D-Bus service...");
1571 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1578 _cleanup_free_ char *dump = NULL;
1579 _cleanup_fclose_ FILE *f = NULL;
1582 f = open_memstream(&dump, &size);
1584 log_warning("Failed to allocate memory stream.");
1588 manager_dump_units(m, f, "\t");
1589 manager_dump_jobs(m, f, "\t");
1592 log_warning("Failed to write status stream");
1596 log_dump(LOG_INFO, dump);
1601 m->exit_code = MANAGER_RELOAD;
1606 /* Starting SIGRTMIN+0 */
1607 static const char * const target_table[] = {
1608 [0] = SPECIAL_DEFAULT_TARGET,
1609 [1] = SPECIAL_RESCUE_TARGET,
1610 [2] = SPECIAL_EMERGENCY_TARGET,
1611 [3] = SPECIAL_HALT_TARGET,
1612 [4] = SPECIAL_POWEROFF_TARGET,
1613 [5] = SPECIAL_REBOOT_TARGET,
1614 [6] = SPECIAL_KEXEC_TARGET
1617 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1618 static const ManagerExitCode code_table[] = {
1620 [1] = MANAGER_POWEROFF,
1621 [2] = MANAGER_REBOOT,
1625 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1626 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1627 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1628 manager_start_target(m, target_table[idx],
1629 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1633 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1634 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1635 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1639 switch (sfsi.ssi_signo - SIGRTMIN) {
1642 log_debug("Enabling showing of status.");
1643 manager_set_show_status(m, SHOW_STATUS_YES);
1647 log_debug("Disabling showing of status.");
1648 manager_set_show_status(m, SHOW_STATUS_NO);
1652 log_set_max_level(LOG_DEBUG);
1653 log_notice("Setting log level to debug.");
1657 log_set_max_level(LOG_INFO);
1658 log_notice("Setting log level to info.");
1662 if (m->running_as == SYSTEMD_USER) {
1663 m->exit_code = MANAGER_EXIT;
1667 /* This is a nop on init */
1671 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1672 log_notice("Setting log target to journal-or-kmsg.");
1676 log_set_target(LOG_TARGET_CONSOLE);
1677 log_notice("Setting log target to console.");
1681 log_set_target(LOG_TARGET_KMSG);
1682 log_notice("Setting log target to kmsg.");
1686 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1687 log_notice("Setting log target to syslog-or-kmsg.");
1691 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1698 manager_dispatch_sigchld(m);
1703 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1704 Manager *m = userdata;
1709 assert(m->time_change_fd == fd);
1711 log_struct(LOG_INFO,
1712 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1713 "MESSAGE=Time has been changed",
1716 /* Restart the watch */
1717 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1719 close_nointr_nofail(m->time_change_fd);
1720 m->time_change_fd = -1;
1722 manager_setup_time_change(m);
1724 HASHMAP_FOREACH(u, m->units, i)
1725 if (UNIT_VTABLE(u)->time_change)
1726 UNIT_VTABLE(u)->time_change(u);
1731 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1732 Manager *m = userdata;
1735 assert(m->idle_pipe[2] == fd);
1737 m->no_console_output = m->n_on_console > 0;
1739 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1740 manager_close_idle_pipe(m);
1745 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1746 Manager *m = userdata;
1753 manager_print_jobs_in_progress(m);
1755 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1756 r = sd_event_source_set_time(source, next);
1760 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1763 int manager_loop(Manager *m) {
1766 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1769 m->exit_code = MANAGER_RUNNING;
1771 /* Release the path cache */
1772 set_free_free(m->unit_path_cache);
1773 m->unit_path_cache = NULL;
1775 manager_check_finished(m);
1777 /* There might still be some zombies hanging around from
1778 * before we were exec()'ed. Let's reap them. */
1779 r = manager_dispatch_sigchld(m);
1783 while (m->exit_code == MANAGER_RUNNING) {
1786 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1789 if (!ratelimit_test(&rl)) {
1790 /* Yay, something is going seriously wrong, pause a little */
1791 log_warning("Looping too fast. Throttling execution a little.");
1796 if (manager_dispatch_load_queue(m) > 0)
1799 if (manager_dispatch_gc_queue(m) > 0)
1802 if (manager_dispatch_cleanup_queue(m) > 0)
1805 if (manager_dispatch_cgroup_queue(m) > 0)
1808 if (manager_dispatch_dbus_queue(m) > 0)
1811 /* Sleep for half the watchdog time */
1812 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1813 wait_usec = m->runtime_watchdog / 2;
1817 wait_usec = (usec_t) -1;
1819 r = sd_event_run(m->event, wait_usec);
1821 log_error("Failed to run event loop: %s", strerror(-r));
1826 return m->exit_code;
1829 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1830 _cleanup_free_ char *n = NULL;
1838 r = unit_name_from_dbus_path(s, &n);
1842 r = manager_load_unit(m, n, NULL, e, &u);
1851 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1861 p = startswith(s, "/org/freedesktop/systemd1/job/");
1865 r = safe_atou(p, &id);
1869 j = manager_get_job(m, id);
1878 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1884 audit_fd = get_audit_fd();
1888 /* Don't generate audit events if the service was already
1889 * started and we're just deserializing */
1890 if (m->n_reloading > 0)
1893 if (m->running_as != SYSTEMD_SYSTEM)
1896 if (u->type != UNIT_SERVICE)
1899 p = unit_name_to_prefix_and_instance(u->id);
1901 log_error_unit(u->id,
1902 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1906 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1907 if (errno == EPERM) {
1908 /* We aren't allowed to send audit messages?
1909 * Then let's not retry again. */
1912 log_warning("Failed to send audit message: %m");
1920 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1922 union sockaddr_union sa;
1924 char *message = NULL;
1926 /* Don't generate plymouth 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 (detect_container(NULL) > 0)
1937 if (u->type != UNIT_SERVICE &&
1938 u->type != UNIT_MOUNT &&
1939 u->type != UNIT_SWAP)
1942 /* We set SOCK_NONBLOCK here so that we rather drop the
1943 * message then wait for plymouth */
1944 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1946 log_error("socket() failed: %m");
1951 sa.sa.sa_family = AF_UNIX;
1952 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1953 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1955 if (errno != EPIPE &&
1958 errno != ECONNREFUSED &&
1959 errno != ECONNRESET &&
1960 errno != ECONNABORTED)
1961 log_error("connect() failed: %m");
1966 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1972 if (write(fd, message, n + 1) != n + 1) {
1974 if (errno != EPIPE &&
1977 errno != ECONNREFUSED &&
1978 errno != ECONNRESET &&
1979 errno != ECONNABORTED)
1980 log_error("Failed to write Plymouth message: %m");
1987 close_nointr_nofail(fd);
1992 void manager_dispatch_bus_name_owner_changed(
1995 const char* old_owner,
1996 const char *new_owner) {
2003 u = hashmap_get(m->watch_bus, name);
2007 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2010 int manager_open_serialization(Manager *m, FILE **_f) {
2017 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2018 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2022 log_debug("Serializing state to %s", path);
2024 f = fdopen(fd, "w+");
2026 close_nointr_nofail(fd);
2035 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2048 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2049 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2050 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2051 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2053 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2054 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2055 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2056 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2059 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2060 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2061 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2062 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2063 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2064 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2065 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2066 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2069 if (!switching_root) {
2070 STRV_FOREACH(e, m->environment) {
2071 _cleanup_free_ char *ce;
2077 fprintf(f, "env=%s\n", *e);
2081 if (m->notify_fd >= 0) {
2084 copy = fdset_put_dup(fds, m->notify_fd);
2088 fprintf(f, "notify-fd=%i\n", copy);
2089 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2092 if (m->kdbus_fd >= 0) {
2095 copy = fdset_put_dup(fds, m->kdbus_fd);
2099 fprintf(f, "kdbus-fd=%i\n", copy);
2102 bus_serialize(m, f);
2106 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2110 if (!unit_can_serialize(u))
2117 r = unit_serialize(u, f, fds, !switching_root);
2124 assert(m->n_reloading > 0);
2130 r = bus_fdset_add_all(m, fds);
2137 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2143 log_debug("Deserializing state...");
2148 char line[LINE_MAX], *l;
2150 if (!fgets(line, sizeof(line), f)) {
2165 if (startswith(l, "current-job-id=")) {
2168 if (safe_atou32(l+15, &id) < 0)
2169 log_debug("Failed to parse current job id value %s", l+15);
2171 m->current_job_id = MAX(m->current_job_id, id);
2173 } else if (startswith(l, "n-installed-jobs=")) {
2176 if (safe_atou32(l+17, &n) < 0)
2177 log_debug("Failed to parse installed jobs counter %s", l+17);
2179 m->n_installed_jobs += n;
2181 } else if (startswith(l, "n-failed-jobs=")) {
2184 if (safe_atou32(l+14, &n) < 0)
2185 log_debug("Failed to parse failed jobs counter %s", l+14);
2187 m->n_failed_jobs += n;
2189 } else if (startswith(l, "taint-usr=")) {
2192 b = parse_boolean(l+10);
2194 log_debug("Failed to parse taint /usr flag %s", l+10);
2196 m->taint_usr = m->taint_usr || b;
2198 } else if (startswith(l, "firmware-timestamp="))
2199 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2200 else if (startswith(l, "loader-timestamp="))
2201 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2202 else if (startswith(l, "kernel-timestamp="))
2203 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2204 else if (startswith(l, "initrd-timestamp="))
2205 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2206 else if (startswith(l, "userspace-timestamp="))
2207 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2208 else if (startswith(l, "finish-timestamp="))
2209 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2210 else if (startswith(l, "security-start-timestamp="))
2211 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2212 else if (startswith(l, "security-finish-timestamp="))
2213 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2214 else if (startswith(l, "generators-start-timestamp="))
2215 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2216 else if (startswith(l, "generators-finish-timestamp="))
2217 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2218 else if (startswith(l, "units-load-start-timestamp="))
2219 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2220 else if (startswith(l, "units-load-finish-timestamp="))
2221 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2222 else if (startswith(l, "env=")) {
2223 _cleanup_free_ char *uce = NULL;
2226 uce = cunescape(l+4);
2232 e = strv_env_set(m->environment, uce);
2238 strv_free(m->environment);
2241 } else if (startswith(l, "notify-fd=")) {
2244 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2245 log_debug("Failed to parse notify fd: %s", l + 10);
2247 if (m->notify_fd >= 0) {
2248 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2249 close_nointr_nofail(m->notify_fd);
2252 m->notify_fd = fdset_remove(fds, fd);
2255 } else if (startswith(l, "notify-socket=")) {
2264 free(m->notify_socket);
2265 m->notify_socket = n;
2267 } else if (startswith(l, "kdbus-fd=")) {
2270 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2271 log_debug("Failed to parse kdbus fd: %s", l + 9);
2273 if (m->kdbus_fd >= 0)
2274 close_nointr_nofail(m->kdbus_fd);
2276 m->kdbus_fd = fdset_remove(fds, fd);
2279 } else if (bus_deserialize_item(m, l) == 0)
2280 log_debug("Unknown serialization item '%s'", l);
2285 char name[UNIT_NAME_MAX+2];
2288 if (!fgets(name, sizeof(name), f)) {
2299 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2303 r = unit_deserialize(u, f, fds);
2312 assert(m->n_reloading > 0);
2318 int manager_reload(Manager *m) {
2320 _cleanup_fclose_ FILE *f = NULL;
2321 _cleanup_fdset_free_ FDSet *fds = NULL;
2325 r = manager_open_serialization(m, &f);
2330 bus_manager_send_reloading(m, true);
2338 r = manager_serialize(m, f, fds, false);
2344 if (fseeko(f, 0, SEEK_SET) < 0) {
2349 /* From here on there is no way back. */
2350 manager_clear_jobs_and_units(m);
2351 manager_undo_generators(m);
2352 lookup_paths_free(&m->lookup_paths);
2354 /* Find new unit paths */
2355 manager_run_generators(m);
2357 q = lookup_paths_init(
2358 &m->lookup_paths, m->running_as, true,
2359 m->generator_unit_path,
2360 m->generator_unit_path_early,
2361 m->generator_unit_path_late);
2365 manager_build_unit_path_cache(m);
2367 /* First, enumerate what we can from all config files */
2368 q = manager_enumerate(m);
2372 /* Second, deserialize our stored data */
2373 q = manager_deserialize(m, f, fds);
2380 /* Re-register notify_fd as event source */
2381 q = manager_setup_notify(m);
2385 /* Third, fire things up! */
2386 q = manager_coldplug(m);
2390 assert(m->n_reloading > 0);
2393 m->send_reloading_done = true;
2398 static bool manager_is_booting_or_shutting_down(Manager *m) {
2403 /* Is the initial job still around? */
2404 if (manager_get_job(m, m->default_unit_job_id))
2407 /* Is there a job for the shutdown target? */
2408 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
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) {
2455 if (m->jobs_in_progress_event_source) {
2456 uint64_t next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
2457 sd_event_source_set_time(m->jobs_in_progress_event_source, next);
2462 if (m->show_status == SHOW_STATUS_TEMPORARY)
2463 manager_set_show_status(m, SHOW_STATUS_AUTO);
2465 /* Notify Type=idle units that we are done now */
2466 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2467 manager_close_idle_pipe(m);
2469 /* Turn off confirm spawn now */
2470 m->confirm_spawn = false;
2472 if (dual_timestamp_is_set(&m->finish_timestamp))
2475 dual_timestamp_get(&m->finish_timestamp);
2477 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2479 /* Note that m->kernel_usec.monotonic is always at 0,
2480 * and m->firmware_usec.monotonic and
2481 * m->loader_usec.monotonic should be considered
2482 * negative values. */
2484 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2485 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2486 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2487 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2489 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2491 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2492 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2494 if (!log_on_console())
2495 log_struct(LOG_INFO,
2496 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2497 "KERNEL_USEC="USEC_FMT, kernel_usec,
2498 "INITRD_USEC="USEC_FMT, initrd_usec,
2499 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2500 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2501 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2502 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2503 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2504 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2507 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2510 if (!log_on_console())
2511 log_struct(LOG_INFO,
2512 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2513 "KERNEL_USEC="USEC_FMT, kernel_usec,
2514 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2515 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2516 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2517 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2518 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2522 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2523 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2525 if (!log_on_console())
2526 log_struct(LOG_INFO,
2527 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2528 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2529 "MESSAGE=Startup finished in %s.",
2530 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2534 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2537 "READY=1\nSTATUS=Startup finished in %s.",
2538 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2541 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2552 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2553 /* systemd --system, not running --test */
2555 p = strappend("/run/systemd/", name);
2559 r = mkdir_p_label(p, 0755);
2561 log_error("Failed to create generator directory %s: %s",
2566 } else if (m->running_as == SYSTEMD_USER) {
2567 const char *s = NULL;
2569 s = getenv("XDG_RUNTIME_DIR");
2572 p = strjoin(s, "/systemd/", name, NULL);
2576 r = mkdir_p_label(p, 0755);
2578 log_error("Failed to create generator directory %s: %s",
2584 /* systemd --system --test */
2586 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2591 log_error("Failed to create generator directory %s: %m",
2602 static void trim_generator_dir(Manager *m, char **generator) {
2609 if (rmdir(*generator) >= 0) {
2617 void manager_run_generators(Manager *m) {
2618 _cleanup_closedir_ DIR *d = NULL;
2619 const char *generator_path;
2620 const char *argv[5];
2625 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2626 d = opendir(generator_path);
2628 if (errno == ENOENT)
2631 log_error("Failed to enumerate generator directory %s: %m",
2636 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2640 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2644 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2648 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2649 argv[1] = m->generator_unit_path;
2650 argv[2] = m->generator_unit_path_early;
2651 argv[3] = m->generator_unit_path_late;
2654 RUN_WITH_UMASK(0022)
2655 execute_directory(generator_path, d, (char**) argv);
2658 trim_generator_dir(m, &m->generator_unit_path);
2659 trim_generator_dir(m, &m->generator_unit_path_early);
2660 trim_generator_dir(m, &m->generator_unit_path_late);
2663 static void remove_generator_dir(Manager *m, char **generator) {
2670 strv_remove(m->lookup_paths.unit_path, *generator);
2671 rm_rf(*generator, false, true, false);
2677 void manager_undo_generators(Manager *m) {
2680 remove_generator_dir(m, &m->generator_unit_path);
2681 remove_generator_dir(m, &m->generator_unit_path_early);
2682 remove_generator_dir(m, &m->generator_unit_path_late);
2685 int manager_environment_add(Manager *m, char **minus, char **plus) {
2686 char **a = NULL, **b = NULL, **l;
2691 if (!strv_isempty(minus)) {
2692 a = strv_env_delete(l, 1, minus);
2699 if (!strv_isempty(plus)) {
2700 b = strv_env_merge(2, l, plus);
2707 if (m->environment != l)
2708 strv_free(m->environment);
2715 manager_clean_environment(m);
2716 strv_sort(m->environment);
2721 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2726 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2727 if (!default_rlimit[i])
2730 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2738 void manager_recheck_journal(Manager *m) {
2743 if (m->running_as != SYSTEMD_SYSTEM)
2746 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2747 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2748 log_close_journal();
2752 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2753 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2754 log_close_journal();
2758 /* Hmm, OK, so the socket is fully up and the service is up
2759 * too, then let's make use of the thing. */
2763 void manager_set_show_status(Manager *m, ShowStatus mode) {
2765 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2767 if (m->running_as != SYSTEMD_SYSTEM)
2770 m->show_status = mode;
2773 touch("/run/systemd/show-status");
2775 unlink("/run/systemd/show-status");
2778 static bool manager_get_show_status(Manager *m) {
2781 if (m->running_as != SYSTEMD_SYSTEM)
2784 if (m->no_console_output)
2787 if (m->show_status > 0)
2790 /* If Plymouth is running make sure we show the status, so
2791 * that there's something nice to see when people press Esc */
2793 return plymouth_running();
2796 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2799 if (!manager_get_show_status(m))
2802 /* XXX We should totally drop the check for ephemeral here
2803 * and thus effectively make 'Type=idle' pointless. */
2804 if (ephemeral && m->n_on_console > 0)
2807 if (!manager_is_booting_or_shutting_down(m))
2810 va_start(ap, format);
2811 status_vprintf(status, true, ephemeral, format, ap);
2815 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2816 _cleanup_free_ char *p = NULL;
2824 p = unit_name_from_path(path, suffix);
2828 found = manager_get_unit(m, p);
2838 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2839 char p[strlen(path)+1];
2845 path_kill_slashes(p);
2847 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);