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, 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 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
153 HASHMAP_FOREACH(j, m->jobs, i)
154 if (j->state == JOB_RUNNING && counter++ == print_nr)
157 /* m->n_running_jobs must be consistent with the contents of m->jobs,
158 * so the above loop must have succeeded in finding j. */
159 assert(counter == print_nr + 1);
162 cylon_pos = m->jobs_in_progress_iteration % 14;
164 cylon_pos = 14 - cylon_pos;
165 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
167 m->jobs_in_progress_iteration++;
169 if (m->n_running_jobs > 1)
170 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
173 format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
174 if (job_get_timeout(j, &x) > 0)
175 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
177 manager_status_printf(m, true, cylon,
178 "%sA %s job is running for %s (%s / %s)",
180 job_type_to_string(j->type),
181 unit_description(j->unit),
186 static int manager_watch_idle_pipe(Manager *m) {
191 if (m->idle_pipe_event_source)
194 if (m->idle_pipe[2] < 0)
197 r = sd_event_add_io(m->event, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m, &m->idle_pipe_event_source);
199 log_error("Failed to watch idle pipe: %s", strerror(-r));
206 static void manager_close_idle_pipe(Manager *m) {
209 close_pipe(m->idle_pipe);
210 close_pipe(m->idle_pipe + 2);
213 static int manager_setup_time_change(Manager *m) {
216 /* We only care for the cancellation event, hence we set the
217 * timeout to the latest possible value. */
218 struct itimerspec its = {
219 .it_value.tv_sec = TIME_T_MAX,
223 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
225 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
226 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
228 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
229 if (m->time_change_fd < 0) {
230 log_error("Failed to create timerfd: %m");
234 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
235 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
236 close_nointr_nofail(m->time_change_fd);
237 m->time_change_fd = -1;
241 r = sd_event_add_io(m->event, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m, &m->time_change_event_source);
243 log_error("Failed to create time change event source: %s", strerror(-r));
247 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
252 static int enable_special_signals(Manager *m) {
253 _cleanup_close_ int fd = -1;
257 /* Enable that we get SIGINT on control-alt-del. In containers
258 * this will fail with EPERM (older) or EINVAL (newer), so
260 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
261 log_warning("Failed to enable ctrl-alt-del handling: %m");
263 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
265 /* Support systems without virtual console */
267 log_warning("Failed to open /dev/tty0: %m");
269 /* Enable that we get SIGWINCH on kbrequest */
270 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
271 log_warning("Failed to enable kbrequest handling: %m");
277 static int manager_setup_signals(Manager *m) {
278 struct sigaction sa = {
279 .sa_handler = SIG_DFL,
280 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
287 /* We are not interested in SIGSTOP and friends. */
288 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
290 assert_se(sigemptyset(&mask) == 0);
292 sigset_add_many(&mask,
293 SIGCHLD, /* Child died */
294 SIGTERM, /* Reexecute daemon */
295 SIGHUP, /* Reload configuration */
296 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
297 SIGUSR2, /* systemd: dump status */
298 SIGINT, /* Kernel sends us this on control-alt-del */
299 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
300 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
301 SIGRTMIN+0, /* systemd: start default.target */
302 SIGRTMIN+1, /* systemd: isolate rescue.target */
303 SIGRTMIN+2, /* systemd: isolate emergency.target */
304 SIGRTMIN+3, /* systemd: start halt.target */
305 SIGRTMIN+4, /* systemd: start poweroff.target */
306 SIGRTMIN+5, /* systemd: start reboot.target */
307 SIGRTMIN+6, /* systemd: start kexec.target */
308 SIGRTMIN+13, /* systemd: Immediate halt */
309 SIGRTMIN+14, /* systemd: Immediate poweroff */
310 SIGRTMIN+15, /* systemd: Immediate reboot */
311 SIGRTMIN+16, /* systemd: Immediate kexec */
312 SIGRTMIN+20, /* systemd: enable status messages */
313 SIGRTMIN+21, /* systemd: disable status messages */
314 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
315 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
316 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
317 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
318 SIGRTMIN+27, /* systemd: set log target to console */
319 SIGRTMIN+28, /* systemd: set log target to kmsg */
320 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
322 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
324 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
325 if (m->signal_fd < 0)
328 r = sd_event_add_io(m->event, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m, &m->signal_event_source);
332 /* Process signals a bit earlier than the rest of things, but
333 * later that notify_fd processing, so that the notify
334 * processing can still figure out to which process/service a
335 * message belongs, before we reap the process. */
336 r = sd_event_source_set_priority(m->signal_event_source, -5);
340 if (m->running_as == SYSTEMD_SYSTEM)
341 return enable_special_signals(m);
346 static void manager_clean_environment(Manager *m) {
349 /* Let's remove some environment variables that we
350 * need ourselves to communicate with our clients */
363 static int manager_default_environment(Manager *m) {
366 if (m->running_as == SYSTEMD_SYSTEM) {
367 /* The system manager always starts with a clean
368 * environment for its children. It does not import
369 * the kernel or the parents exported variables.
371 * The initial passed environ is untouched to keep
372 * /proc/self/environ valid; it is used for tagging
373 * the init process inside containers. */
374 m->environment = strv_new("PATH=" DEFAULT_PATH,
377 /* Import locale variables LC_*= from configuration */
378 locale_setup(&m->environment);
380 /* The user manager passes its own environment
381 * along to its children. */
382 m->environment = strv_copy(environ);
388 manager_clean_environment(m);
389 strv_sort(m->environment);
394 int manager_new(SystemdRunningAs running_as, Manager **_m) {
399 assert(running_as >= 0);
400 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
402 m = new0(Manager, 1);
407 if (detect_container(NULL) <= 0)
408 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
411 m->running_as = running_as;
412 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
414 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
416 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;
417 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
419 r = manager_default_environment(m);
423 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
427 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
431 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
435 r = hashmap_ensure_allocated(&m->watch_pids, trivial_hash_func, trivial_compare_func);
439 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
443 r = sd_event_default(&m->event);
447 r = sd_event_add_defer(m->event, manager_dispatch_run_queue, m, &m->run_queue_event_source);
451 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
455 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
459 r = manager_setup_signals(m);
463 r = manager_setup_cgroup(m);
467 r = manager_setup_time_change(m);
471 m->udev = udev_new();
477 /* Note that we set up neither kdbus, nor the notify fd
478 * here. We do that after deserialization, since they might
479 * have gotten serialized across the reexec. */
481 m->taint_usr = dir_is_empty("/usr") > 0;
491 static int manager_setup_notify(Manager *m) {
494 struct sockaddr_un un;
496 .sa.sa_family = AF_UNIX,
500 if (m->notify_fd < 0) {
501 _cleanup_close_ int fd = -1;
503 /* First free all secondary fields */
504 free(m->notify_socket);
505 m->notify_socket = NULL;
506 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
508 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
510 log_error("Failed to allocate notification socket: %m");
514 if (getpid() != 1 || detect_container(NULL) > 0)
515 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%" PRIx64, random_u64());
517 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
518 sa.un.sun_path[0] = 0;
520 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
522 log_error("bind() failed: %m");
526 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
528 log_error("SO_PASSCRED failed: %m");
532 sa.un.sun_path[0] = '@';
533 m->notify_socket = strdup(sa.un.sun_path);
534 if (!m->notify_socket)
540 log_debug("Using notification socket %s", m->notify_socket);
543 if (!m->notify_event_source) {
544 r = sd_event_add_io(m->event, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m, &m->notify_event_source);
546 log_error("Failed to allocate notify event source: %s", strerror(-r));
550 /* Process signals a bit earlier than SIGCHLD, so that we can
551 * still identify to which service an exit message belongs */
552 r = sd_event_source_set_priority(m->notify_event_source, -7);
554 log_error("Failed to set priority of notify event source: %s", strerror(-r));
562 static int manager_setup_kdbus(Manager *m) {
564 _cleanup_free_ char *p = NULL;
570 if (m->kdbus_fd >= 0)
573 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
574 if (m->kdbus_fd < 0) {
575 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
579 log_debug("Successfully set up kdbus on %s", p);
581 /* Create the namespace directory here, so that the contents
582 * of that directory is not visible to non-root users. This is
583 * necessary to ensure that users cannot get access to busses
584 * of virtualized users when no UID namespacing is used. */
585 if (m->running_as == SYSTEMD_SYSTEM)
586 mkdir_p_label("/dev/kdbus/ns", 0700);
592 static int manager_connect_bus(Manager *m, bool reexecuting) {
593 bool try_bus_connect;
600 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
602 /* Try to connect to the busses, if possible. */
603 return bus_init(m, try_bus_connect);
606 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
612 while ((u = m->cleanup_queue)) {
613 assert(u->in_cleanup_queue);
623 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
624 GC_OFFSET_UNSURE, /* No clue */
625 GC_OFFSET_GOOD, /* We still need this unit */
626 GC_OFFSET_BAD, /* We don't need this unit anymore */
630 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
637 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
638 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
639 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
642 if (u->in_cleanup_queue)
645 if (unit_check_gc(u))
648 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
652 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
653 unit_gc_sweep(other, gc_marker);
655 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
658 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
665 /* We were unable to find anything out about this entry, so
666 * let's investigate it later */
667 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
668 unit_add_to_gc_queue(u);
672 /* We definitely know that this one is not useful anymore, so
673 * let's mark it for deletion */
674 u->gc_marker = gc_marker + GC_OFFSET_BAD;
675 unit_add_to_cleanup_queue(u);
679 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
682 static unsigned manager_dispatch_gc_queue(Manager *m) {
689 /* log_debug("Running GC..."); */
691 m->gc_marker += _GC_OFFSET_MAX;
692 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
695 gc_marker = m->gc_marker;
697 while ((u = m->gc_queue)) {
698 assert(u->in_gc_queue);
700 unit_gc_sweep(u, gc_marker);
702 LIST_REMOVE(gc_queue, m->gc_queue, u);
703 u->in_gc_queue = false;
707 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
708 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
709 log_debug_unit(u->id, "Collecting %s", u->id);
710 u->gc_marker = gc_marker + GC_OFFSET_BAD;
711 unit_add_to_cleanup_queue(u);
715 m->n_in_gc_queue = 0;
720 static void manager_clear_jobs_and_units(Manager *m) {
725 while ((u = hashmap_first(m->units)))
728 manager_dispatch_cleanup_queue(m);
730 assert(!m->load_queue);
731 assert(!m->run_queue);
732 assert(!m->dbus_unit_queue);
733 assert(!m->dbus_job_queue);
734 assert(!m->cleanup_queue);
735 assert(!m->gc_queue);
737 assert(hashmap_isempty(m->jobs));
738 assert(hashmap_isempty(m->units));
741 m->n_running_jobs = 0;
744 void manager_free(Manager *m) {
750 manager_clear_jobs_and_units(m);
752 for (c = 0; c < _UNIT_TYPE_MAX; c++)
753 if (unit_vtable[c]->shutdown)
754 unit_vtable[c]->shutdown(m);
756 /* If we reexecute ourselves, we keep the root cgroup
758 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
760 manager_undo_generators(m);
764 hashmap_free(m->units);
765 hashmap_free(m->jobs);
766 hashmap_free(m->watch_pids);
767 hashmap_free(m->watch_bus);
769 sd_event_source_unref(m->signal_event_source);
770 sd_event_source_unref(m->notify_event_source);
771 sd_event_source_unref(m->time_change_event_source);
772 sd_event_source_unref(m->jobs_in_progress_event_source);
773 sd_event_source_unref(m->idle_pipe_event_source);
774 sd_event_source_unref(m->run_queue_event_source);
776 if (m->signal_fd >= 0)
777 close_nointr_nofail(m->signal_fd);
778 if (m->notify_fd >= 0)
779 close_nointr_nofail(m->notify_fd);
780 if (m->time_change_fd >= 0)
781 close_nointr_nofail(m->time_change_fd);
782 if (m->kdbus_fd >= 0)
783 close_nointr_nofail(m->kdbus_fd);
785 manager_close_idle_pipe(m);
788 sd_event_unref(m->event);
790 free(m->notify_socket);
792 lookup_paths_free(&m->lookup_paths);
793 strv_free(m->environment);
795 hashmap_free(m->cgroup_unit);
796 set_free_free(m->unit_path_cache);
798 free(m->switch_root);
799 free(m->switch_root_init);
801 for (i = 0; i < RLIMIT_NLIMITS; i++)
804 assert(hashmap_isempty(m->units_requiring_mounts_for));
805 hashmap_free(m->units_requiring_mounts_for);
810 int manager_enumerate(Manager *m) {
816 /* Let's ask every type to load all units from disk/kernel
817 * that it might know */
818 for (c = 0; c < _UNIT_TYPE_MAX; c++)
819 if (unit_vtable[c]->enumerate) {
820 q = unit_vtable[c]->enumerate(m);
825 manager_dispatch_load_queue(m);
829 static int manager_coldplug(Manager *m) {
837 /* Then, let's set up their initial state. */
838 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
844 if ((q = unit_coldplug(u)) < 0)
851 static void manager_build_unit_path_cache(Manager *m) {
853 _cleanup_free_ DIR *d = NULL;
858 set_free_free(m->unit_path_cache);
860 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
861 if (!m->unit_path_cache) {
862 log_error("Failed to allocate unit path cache.");
866 /* This simply builds a list of files we know exist, so that
867 * we don't always have to go to disk */
869 STRV_FOREACH(i, m->lookup_paths.unit_path) {
875 log_error("Failed to open directory %s: %m", *i);
879 while ((de = readdir(d))) {
882 if (ignore_file(de->d_name))
885 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
891 r = set_consume(m->unit_path_cache, p);
903 log_error("Failed to build unit path cache: %s", strerror(-r));
905 set_free_free(m->unit_path_cache);
906 m->unit_path_cache = NULL;
910 static int manager_distribute_fds(Manager *m, FDSet *fds) {
917 HASHMAP_FOREACH(u, m->units, i) {
919 if (fdset_size(fds) <= 0)
922 if (UNIT_VTABLE(u)->distribute_fds) {
923 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
932 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
937 dual_timestamp_get(&m->generators_start_timestamp);
938 manager_run_generators(m);
939 dual_timestamp_get(&m->generators_finish_timestamp);
941 r = lookup_paths_init(
942 &m->lookup_paths, m->running_as, true,
943 m->generator_unit_path,
944 m->generator_unit_path_early,
945 m->generator_unit_path_late);
949 manager_build_unit_path_cache(m);
951 /* If we will deserialize make sure that during enumeration
952 * this is already known, so we increase the counter here
957 /* First, enumerate what we can from all config files */
958 dual_timestamp_get(&m->units_load_start_timestamp);
959 r = manager_enumerate(m);
960 dual_timestamp_get(&m->units_load_finish_timestamp);
962 /* Second, deserialize if there is something to deserialize */
964 q = manager_deserialize(m, serialization, fds);
969 /* Any fds left? Find some unit which wants them. This is
970 * useful to allow container managers to pass some file
971 * descriptors to us pre-initialized. This enables
972 * socket-based activation of entire containers. */
973 if (fdset_size(fds) > 0) {
974 q = manager_distribute_fds(m, fds);
979 /* We might have deserialized the notify fd, but if we didn't
980 * then let's create the bus now */
981 manager_setup_notify(m);
983 /* We might have deserialized the kdbus control fd, but if we
984 * didn't, then let's create the bus now. */
985 manager_setup_kdbus(m);
986 manager_connect_bus(m, !!serialization);
988 /* Third, fire things up! */
989 q = manager_coldplug(m);
994 assert(m->n_reloading > 0);
997 /* Let's wait for the UnitNew/JobNew messages being
998 * sent, before we notify that the reload is
1000 m->send_reloading_done = true;
1006 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1011 assert(type < _JOB_TYPE_MAX);
1013 assert(mode < _JOB_MODE_MAX);
1015 if (mode == JOB_ISOLATE && type != JOB_START) {
1016 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1020 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1021 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1025 log_debug_unit(unit->id,
1026 "Trying to enqueue job %s/%s/%s", unit->id,
1027 job_type_to_string(type), job_mode_to_string(mode));
1029 job_type_collapse(&type, unit);
1031 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1035 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1036 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1037 mode == JOB_IGNORE_DEPENDENCIES, e);
1041 if (mode == JOB_ISOLATE) {
1042 r = transaction_add_isolate_jobs(tr, m);
1047 r = transaction_activate(tr, m, mode, e);
1051 log_debug_unit(unit->id,
1052 "Enqueued job %s/%s as %u", unit->id,
1053 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1056 *_ret = tr->anchor_job;
1058 transaction_free(tr);
1062 transaction_abort(tr);
1063 transaction_free(tr);
1067 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1072 assert(type < _JOB_TYPE_MAX);
1074 assert(mode < _JOB_MODE_MAX);
1076 r = manager_load_unit(m, name, NULL, NULL, &unit);
1080 return manager_add_job(m, type, unit, mode, override, e, _ret);
1083 Job *manager_get_job(Manager *m, uint32_t id) {
1086 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1089 Unit *manager_get_unit(Manager *m, const char *name) {
1093 return hashmap_get(m->units, name);
1096 unsigned manager_dispatch_load_queue(Manager *m) {
1102 /* Make sure we are not run recursively */
1103 if (m->dispatching_load_queue)
1106 m->dispatching_load_queue = true;
1108 /* Dispatches the load queue. Takes a unit from the queue and
1109 * tries to load its data until the queue is empty */
1111 while ((u = m->load_queue)) {
1112 assert(u->in_load_queue);
1118 m->dispatching_load_queue = false;
1122 int manager_load_unit_prepare(
1134 assert(name || path);
1136 /* This will prepare the unit for loading, but not actually
1137 * load anything from disk. */
1139 if (path && !is_path(path))
1140 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1143 name = basename(path);
1145 t = unit_name_to_type(name);
1147 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1148 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1150 ret = manager_get_unit(m, name);
1156 ret = unit_new(m, unit_vtable[t]->object_size);
1161 ret->fragment_path = strdup(path);
1162 if (!ret->fragment_path) {
1168 r = unit_add_name(ret, name);
1174 unit_add_to_load_queue(ret);
1175 unit_add_to_dbus_queue(ret);
1176 unit_add_to_gc_queue(ret);
1184 int manager_load_unit(
1195 /* This will load the service information files, but not actually
1196 * start any services or anything. */
1198 r = manager_load_unit_prepare(m, name, path, e, _ret);
1202 manager_dispatch_load_queue(m);
1205 *_ret = unit_follow_merge(*_ret);
1210 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1217 HASHMAP_FOREACH(j, s->jobs, i)
1218 job_dump(j, f, prefix);
1221 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1229 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1231 unit_dump(u, f, prefix);
1234 void manager_clear_jobs(Manager *m) {
1239 while ((j = hashmap_first(m->jobs)))
1240 /* No need to recurse. We're cancelling all jobs. */
1241 job_finish_and_invalidate(j, JOB_CANCELED, false);
1244 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1245 Manager *m = userdata;
1251 while ((j = m->run_queue)) {
1252 assert(j->installed);
1253 assert(j->in_run_queue);
1255 job_run_and_invalidate(j);
1258 if (m->n_running_jobs > 0)
1259 manager_watch_jobs_in_progress(m);
1261 if (m->n_on_console > 0)
1262 manager_watch_idle_pipe(m);
1267 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1274 if (m->dispatching_dbus_queue)
1277 m->dispatching_dbus_queue = true;
1279 while ((u = m->dbus_unit_queue)) {
1280 assert(u->in_dbus_queue);
1282 bus_unit_send_change_signal(u);
1286 while ((j = m->dbus_job_queue)) {
1287 assert(j->in_dbus_queue);
1289 bus_job_send_change_signal(j);
1293 m->dispatching_dbus_queue = false;
1295 if (m->send_reloading_done) {
1296 m->send_reloading_done = false;
1298 bus_manager_send_reloading(m, false);
1301 if (m->queued_message)
1302 bus_send_queued_message(m);
1307 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1308 Manager *m = userdata;
1312 assert(m->notify_fd == fd);
1314 if (revents != EPOLLIN) {
1315 log_warning("Got unexpected poll event for notify fd.");
1321 struct iovec iovec = {
1323 .iov_len = sizeof(buf)-1,
1327 struct cmsghdr cmsghdr;
1328 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1331 struct msghdr msghdr = {
1334 .msg_control = &control,
1335 .msg_controllen = sizeof(control),
1337 struct ucred *ucred;
1339 _cleanup_strv_free_ char **tags = NULL;
1341 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1346 if (errno == EAGAIN || errno == EINTR)
1352 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1353 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1354 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1355 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1356 log_warning("Received notify message without credentials. Ignoring.");
1360 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1362 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1364 u = manager_get_unit_by_pid(m, ucred->pid);
1366 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1371 assert((size_t) n < sizeof(buf));
1373 tags = strv_split(buf, "\n\r");
1377 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1379 if (UNIT_VTABLE(u)->notify_message)
1380 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1386 static int manager_dispatch_sigchld(Manager *m) {
1393 /* First we call waitd() for a PID and do not reap the
1394 * zombie. That way we can still access /proc/$PID for
1395 * it while it is a zombie. */
1396 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1398 if (errno == ECHILD)
1410 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1411 _cleanup_free_ char *name = NULL;
1413 get_process_comm(si.si_pid, &name);
1414 log_debug("Got SIGCHLD for process "PID_FMT" (%s)", si.si_pid, strna(name));
1417 /* And now figure out the unit this belongs to */
1418 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1420 u = manager_get_unit_by_pid(m, si.si_pid);
1422 /* And now, we actually reap the zombie. */
1423 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1430 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1433 log_debug("Child %lu died (code=%s, status=%i/%s)",
1434 (long unsigned) si.si_pid,
1435 sigchld_code_to_string(si.si_code),
1437 strna(si.si_code == CLD_EXITED
1438 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1439 : signal_to_string(si.si_status)));
1444 log_debug_unit(u->id,
1445 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1447 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1448 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1454 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1455 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1458 log_debug_unit(name, "Activating special unit %s", name);
1460 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1462 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1467 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1468 Manager *m = userdata;
1470 struct signalfd_siginfo sfsi;
1471 bool sigchld = false;
1474 assert(m->signal_fd == fd);
1476 if (revents != EPOLLIN) {
1477 log_warning("Got unexpected events from signal file descriptor.");
1482 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1483 if (n != sizeof(sfsi)) {
1488 if (errno == EINTR || errno == EAGAIN)
1494 if (sfsi.ssi_pid > 0) {
1495 _cleanup_free_ char *p = NULL;
1497 get_process_comm(sfsi.ssi_pid, &p);
1499 log_full(sfsi.ssi_signo == SIGCHLD ||
1500 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1501 ? LOG_DEBUG : LOG_INFO,
1502 "Received SIG%s from PID "PID_FMT" (%s).",
1503 signal_to_string(sfsi.ssi_signo),
1504 sfsi.ssi_pid, strna(p));
1506 log_full(sfsi.ssi_signo == SIGCHLD ||
1507 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1508 ? LOG_DEBUG : LOG_INFO,
1510 signal_to_string(sfsi.ssi_signo));
1512 switch (sfsi.ssi_signo) {
1519 if (m->running_as == SYSTEMD_SYSTEM) {
1520 /* This is for compatibility with the
1521 * original sysvinit */
1522 m->exit_code = MANAGER_REEXECUTE;
1529 if (m->running_as == SYSTEMD_SYSTEM) {
1530 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1534 /* Run the exit target if there is one, if not, just exit. */
1535 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1536 m->exit_code = MANAGER_EXIT;
1543 if (m->running_as == SYSTEMD_SYSTEM)
1544 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1546 /* This is a nop on non-init */
1550 if (m->running_as == SYSTEMD_SYSTEM)
1551 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1553 /* This is a nop on non-init */
1559 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1561 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1562 log_info("Trying to reconnect to bus...");
1566 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1567 log_info("Loading D-Bus service...");
1568 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1575 _cleanup_free_ char *dump = NULL;
1576 _cleanup_fclose_ FILE *f = NULL;
1579 f = open_memstream(&dump, &size);
1581 log_warning("Failed to allocate memory stream.");
1585 manager_dump_units(m, f, "\t");
1586 manager_dump_jobs(m, f, "\t");
1589 log_warning("Failed to write status stream");
1593 log_dump(LOG_INFO, dump);
1598 m->exit_code = MANAGER_RELOAD;
1603 /* Starting SIGRTMIN+0 */
1604 static const char * const target_table[] = {
1605 [0] = SPECIAL_DEFAULT_TARGET,
1606 [1] = SPECIAL_RESCUE_TARGET,
1607 [2] = SPECIAL_EMERGENCY_TARGET,
1608 [3] = SPECIAL_HALT_TARGET,
1609 [4] = SPECIAL_POWEROFF_TARGET,
1610 [5] = SPECIAL_REBOOT_TARGET,
1611 [6] = SPECIAL_KEXEC_TARGET
1614 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1615 static const ManagerExitCode code_table[] = {
1617 [1] = MANAGER_POWEROFF,
1618 [2] = MANAGER_REBOOT,
1622 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1623 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1624 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1625 manager_start_target(m, target_table[idx],
1626 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1630 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1631 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1632 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1636 switch (sfsi.ssi_signo - SIGRTMIN) {
1639 log_debug("Enabling showing of status.");
1640 manager_set_show_status(m, true);
1644 log_debug("Disabling showing of status.");
1645 manager_set_show_status(m, false);
1649 log_set_max_level(LOG_DEBUG);
1650 log_notice("Setting log level to debug.");
1654 log_set_max_level(LOG_INFO);
1655 log_notice("Setting log level to info.");
1659 if (m->running_as == SYSTEMD_USER) {
1660 m->exit_code = MANAGER_EXIT;
1664 /* This is a nop on init */
1668 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1669 log_notice("Setting log target to journal-or-kmsg.");
1673 log_set_target(LOG_TARGET_CONSOLE);
1674 log_notice("Setting log target to console.");
1678 log_set_target(LOG_TARGET_KMSG);
1679 log_notice("Setting log target to kmsg.");
1683 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1684 log_notice("Setting log target to syslog-or-kmsg.");
1688 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1695 manager_dispatch_sigchld(m);
1700 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1701 Manager *m = userdata;
1706 assert(m->time_change_fd == fd);
1708 log_struct(LOG_INFO,
1709 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1710 "MESSAGE=Time has been changed",
1713 /* Restart the watch */
1714 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1716 close_nointr_nofail(m->time_change_fd);
1717 m->time_change_fd = -1;
1719 manager_setup_time_change(m);
1721 HASHMAP_FOREACH(u, m->units, i)
1722 if (UNIT_VTABLE(u)->time_change)
1723 UNIT_VTABLE(u)->time_change(u);
1728 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1729 Manager *m = userdata;
1732 assert(m->idle_pipe[2] == fd);
1734 m->no_console_output = m->n_on_console > 0;
1736 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1737 manager_close_idle_pipe(m);
1742 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1743 Manager *m = userdata;
1750 manager_print_jobs_in_progress(m);
1752 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1753 r = sd_event_source_set_time(source, next);
1757 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1760 int manager_loop(Manager *m) {
1763 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1766 m->exit_code = MANAGER_RUNNING;
1768 /* Release the path cache */
1769 set_free_free(m->unit_path_cache);
1770 m->unit_path_cache = NULL;
1772 manager_check_finished(m);
1774 /* There might still be some zombies hanging around from
1775 * before we were exec()'ed. Let's reap them. */
1776 r = manager_dispatch_sigchld(m);
1780 while (m->exit_code == MANAGER_RUNNING) {
1783 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1786 if (!ratelimit_test(&rl)) {
1787 /* Yay, something is going seriously wrong, pause a little */
1788 log_warning("Looping too fast. Throttling execution a little.");
1793 if (manager_dispatch_load_queue(m) > 0)
1796 if (manager_dispatch_gc_queue(m) > 0)
1799 if (manager_dispatch_cleanup_queue(m) > 0)
1802 if (manager_dispatch_cgroup_queue(m) > 0)
1805 if (manager_dispatch_dbus_queue(m) > 0)
1808 /* Sleep for half the watchdog time */
1809 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1810 wait_usec = m->runtime_watchdog / 2;
1814 wait_usec = (usec_t) -1;
1816 r = sd_event_run(m->event, wait_usec);
1818 log_error("Failed to run event loop: %s", strerror(-r));
1823 return m->exit_code;
1826 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1827 _cleanup_free_ char *n = NULL;
1835 r = unit_name_from_dbus_path(s, &n);
1839 r = manager_load_unit(m, n, NULL, e, &u);
1848 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1858 p = startswith(s, "/org/freedesktop/systemd1/job/");
1862 r = safe_atou(p, &id);
1866 j = manager_get_job(m, id);
1875 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1881 audit_fd = get_audit_fd();
1885 /* Don't generate audit events if the service was already
1886 * started and we're just deserializing */
1887 if (m->n_reloading > 0)
1890 if (m->running_as != SYSTEMD_SYSTEM)
1893 if (u->type != UNIT_SERVICE)
1896 p = unit_name_to_prefix_and_instance(u->id);
1898 log_error_unit(u->id,
1899 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1903 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1904 if (errno == EPERM) {
1905 /* We aren't allowed to send audit messages?
1906 * Then let's not retry again. */
1909 log_warning("Failed to send audit message: %m");
1917 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1919 union sockaddr_union sa;
1921 char *message = NULL;
1923 /* Don't generate plymouth events if the service was already
1924 * started and we're just deserializing */
1925 if (m->n_reloading > 0)
1928 if (m->running_as != SYSTEMD_SYSTEM)
1931 if (detect_container(NULL) > 0)
1934 if (u->type != UNIT_SERVICE &&
1935 u->type != UNIT_MOUNT &&
1936 u->type != UNIT_SWAP)
1939 /* We set SOCK_NONBLOCK here so that we rather drop the
1940 * message then wait for plymouth */
1941 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1943 log_error("socket() failed: %m");
1948 sa.sa.sa_family = AF_UNIX;
1949 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1950 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1952 if (errno != EPIPE &&
1955 errno != ECONNREFUSED &&
1956 errno != ECONNRESET &&
1957 errno != ECONNABORTED)
1958 log_error("connect() failed: %m");
1963 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1969 if (write(fd, message, n + 1) != n + 1) {
1971 if (errno != EPIPE &&
1974 errno != ECONNREFUSED &&
1975 errno != ECONNRESET &&
1976 errno != ECONNABORTED)
1977 log_error("Failed to write Plymouth message: %m");
1984 close_nointr_nofail(fd);
1989 void manager_dispatch_bus_name_owner_changed(
1992 const char* old_owner,
1993 const char *new_owner) {
2000 u = hashmap_get(m->watch_bus, name);
2004 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2007 int manager_open_serialization(Manager *m, FILE **_f) {
2008 _cleanup_free_ char *path = NULL;
2014 if (m->running_as == SYSTEMD_SYSTEM)
2015 asprintf(&path, "/run/systemd/dump-"PID_FMT"-XXXXXX", getpid());
2017 asprintf(&path, "/tmp/systemd-dump-"PID_FMT"-XXXXXX", getpid());
2022 RUN_WITH_UMASK(0077) {
2023 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2030 log_debug("Serializing state to %s", path);
2032 f = fdopen(fd, "w+");
2034 close_nointr_nofail(fd);
2043 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2056 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2057 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2058 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2059 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2061 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2062 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2063 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2064 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2067 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2068 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2069 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2070 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2071 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2072 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2073 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2074 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2077 if (!switching_root) {
2078 STRV_FOREACH(e, m->environment) {
2079 _cleanup_free_ char *ce;
2085 fprintf(f, "env=%s\n", *e);
2089 if (m->notify_fd >= 0) {
2092 copy = fdset_put_dup(fds, m->notify_fd);
2096 fprintf(f, "notify-fd=%i\n", copy);
2097 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2100 if (m->kdbus_fd >= 0) {
2103 copy = fdset_put_dup(fds, m->kdbus_fd);
2107 fprintf(f, "kdbus-fd=%i\n", copy);
2110 bus_serialize(m, f);
2114 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2118 if (!unit_can_serialize(u))
2125 r = unit_serialize(u, f, fds, !switching_root);
2132 assert(m->n_reloading > 0);
2138 r = bus_fdset_add_all(m, fds);
2145 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2151 log_debug("Deserializing state...");
2156 char line[LINE_MAX], *l;
2158 if (!fgets(line, sizeof(line), f)) {
2173 if (startswith(l, "current-job-id=")) {
2176 if (safe_atou32(l+15, &id) < 0)
2177 log_debug("Failed to parse current job id value %s", l+15);
2179 m->current_job_id = MAX(m->current_job_id, id);
2181 } else if (startswith(l, "n-installed-jobs=")) {
2184 if (safe_atou32(l+17, &n) < 0)
2185 log_debug("Failed to parse installed jobs counter %s", l+17);
2187 m->n_installed_jobs += n;
2189 } else if (startswith(l, "n-failed-jobs=")) {
2192 if (safe_atou32(l+14, &n) < 0)
2193 log_debug("Failed to parse failed jobs counter %s", l+14);
2195 m->n_failed_jobs += n;
2197 } else if (startswith(l, "taint-usr=")) {
2200 b = parse_boolean(l+10);
2202 log_debug("Failed to parse taint /usr flag %s", l+10);
2204 m->taint_usr = m->taint_usr || b;
2206 } else if (startswith(l, "firmware-timestamp="))
2207 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2208 else if (startswith(l, "loader-timestamp="))
2209 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2210 else if (startswith(l, "kernel-timestamp="))
2211 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2212 else if (startswith(l, "initrd-timestamp="))
2213 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2214 else if (startswith(l, "userspace-timestamp="))
2215 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2216 else if (startswith(l, "finish-timestamp="))
2217 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2218 else if (startswith(l, "security-start-timestamp="))
2219 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2220 else if (startswith(l, "security-finish-timestamp="))
2221 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2222 else if (startswith(l, "generators-start-timestamp="))
2223 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2224 else if (startswith(l, "generators-finish-timestamp="))
2225 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2226 else if (startswith(l, "units-load-start-timestamp="))
2227 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2228 else if (startswith(l, "units-load-finish-timestamp="))
2229 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2230 else if (startswith(l, "env=")) {
2231 _cleanup_free_ char *uce = NULL;
2234 uce = cunescape(l+4);
2240 e = strv_env_set(m->environment, uce);
2246 strv_free(m->environment);
2249 } else if (startswith(l, "notify-fd=")) {
2252 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2253 log_debug("Failed to parse notify fd: %s", l + 10);
2255 if (m->notify_fd >= 0) {
2256 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2257 close_nointr_nofail(m->notify_fd);
2260 m->notify_fd = fdset_remove(fds, fd);
2263 } else if (startswith(l, "notify-socket=")) {
2272 free(m->notify_socket);
2273 m->notify_socket = n;
2275 } else if (startswith(l, "kdbus-fd=")) {
2278 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2279 log_debug("Failed to parse kdbus fd: %s", l + 9);
2281 if (m->kdbus_fd >= 0)
2282 close_nointr_nofail(m->kdbus_fd);
2284 m->kdbus_fd = fdset_remove(fds, fd);
2287 } else if (bus_deserialize_item(m, l) == 0)
2288 log_debug("Unknown serialization item '%s'", l);
2293 char name[UNIT_NAME_MAX+2];
2296 if (!fgets(name, sizeof(name), f)) {
2307 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2311 r = unit_deserialize(u, f, fds);
2320 assert(m->n_reloading > 0);
2326 int manager_reload(Manager *m) {
2328 _cleanup_fclose_ FILE *f = NULL;
2329 _cleanup_fdset_free_ FDSet *fds = NULL;
2333 r = manager_open_serialization(m, &f);
2338 bus_manager_send_reloading(m, true);
2346 r = manager_serialize(m, f, fds, false);
2352 if (fseeko(f, 0, SEEK_SET) < 0) {
2357 /* From here on there is no way back. */
2358 manager_clear_jobs_and_units(m);
2359 manager_undo_generators(m);
2360 lookup_paths_free(&m->lookup_paths);
2362 /* Find new unit paths */
2363 manager_run_generators(m);
2365 q = lookup_paths_init(
2366 &m->lookup_paths, m->running_as, true,
2367 m->generator_unit_path,
2368 m->generator_unit_path_early,
2369 m->generator_unit_path_late);
2373 manager_build_unit_path_cache(m);
2375 /* First, enumerate what we can from all config files */
2376 q = manager_enumerate(m);
2380 /* Second, deserialize our stored data */
2381 q = manager_deserialize(m, f, fds);
2388 /* Re-register notify_fd as event source */
2389 q = manager_setup_notify(m);
2393 /* Third, fire things up! */
2394 q = manager_coldplug(m);
2398 assert(m->n_reloading > 0);
2401 m->send_reloading_done = true;
2406 static bool manager_is_booting_or_shutting_down(Manager *m) {
2411 /* Is the initial job still around? */
2412 if (manager_get_job(m, m->default_unit_job_id))
2415 /* Is there a job for the shutdown target? */
2416 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2423 bool manager_is_reloading_or_reexecuting(Manager *m) {
2426 return m->n_reloading != 0;
2429 void manager_reset_failed(Manager *m) {
2435 HASHMAP_FOREACH(u, m->units, i)
2436 unit_reset_failed(u);
2439 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2445 /* Returns true if the unit is inactive or going down */
2446 u = manager_get_unit(m, name);
2450 return unit_inactive_or_pending(u);
2453 void manager_check_finished(Manager *m) {
2454 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2455 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2459 if (m->n_running_jobs == 0)
2460 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2462 if (hashmap_size(m->jobs) > 0) {
2463 if (m->jobs_in_progress_event_source) {
2464 uint64_t next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
2465 sd_event_source_set_time(m->jobs_in_progress_event_source, next);
2470 /* Notify Type=idle units that we are done now */
2471 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2472 manager_close_idle_pipe(m);
2474 /* Turn off confirm spawn now */
2475 m->confirm_spawn = false;
2477 if (dual_timestamp_is_set(&m->finish_timestamp))
2480 dual_timestamp_get(&m->finish_timestamp);
2482 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2484 /* Note that m->kernel_usec.monotonic is always at 0,
2485 * and m->firmware_usec.monotonic and
2486 * m->loader_usec.monotonic should be considered
2487 * negative values. */
2489 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2490 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2491 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2492 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2494 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2496 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2497 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2499 if (!log_on_console())
2500 log_struct(LOG_INFO,
2501 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2502 "KERNEL_USEC="USEC_FMT, kernel_usec,
2503 "INITRD_USEC="USEC_FMT, initrd_usec,
2504 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2505 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2506 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2507 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2508 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2509 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2512 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2515 if (!log_on_console())
2516 log_struct(LOG_INFO,
2517 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2518 "KERNEL_USEC="USEC_FMT, kernel_usec,
2519 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2520 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2521 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2522 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2523 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2527 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2528 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2530 if (!log_on_console())
2531 log_struct(LOG_INFO,
2532 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2533 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2534 "MESSAGE=Startup finished in %s.",
2535 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2539 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2542 "READY=1\nSTATUS=Startup finished in %s.",
2543 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2546 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2557 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2558 /* systemd --system, not running --test */
2560 p = strappend("/run/systemd/", name);
2564 r = mkdir_p_label(p, 0755);
2566 log_error("Failed to create generator directory %s: %s",
2571 } else if (m->running_as == SYSTEMD_USER) {
2572 const char *s = NULL;
2574 s = getenv("XDG_RUNTIME_DIR");
2577 p = strjoin(s, "/systemd/", name, NULL);
2581 r = mkdir_p_label(p, 0755);
2583 log_error("Failed to create generator directory %s: %s",
2589 /* systemd --system --test */
2591 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2596 log_error("Failed to create generator directory %s: %m",
2607 static void trim_generator_dir(Manager *m, char **generator) {
2614 if (rmdir(*generator) >= 0) {
2622 void manager_run_generators(Manager *m) {
2623 _cleanup_closedir_ DIR *d = NULL;
2624 const char *generator_path;
2625 const char *argv[5];
2630 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2631 d = opendir(generator_path);
2633 if (errno == ENOENT)
2636 log_error("Failed to enumerate generator directory %s: %m",
2641 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2645 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2649 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2653 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2654 argv[1] = m->generator_unit_path;
2655 argv[2] = m->generator_unit_path_early;
2656 argv[3] = m->generator_unit_path_late;
2659 RUN_WITH_UMASK(0022)
2660 execute_directory(generator_path, d, (char**) argv);
2663 trim_generator_dir(m, &m->generator_unit_path);
2664 trim_generator_dir(m, &m->generator_unit_path_early);
2665 trim_generator_dir(m, &m->generator_unit_path_late);
2668 static void remove_generator_dir(Manager *m, char **generator) {
2675 strv_remove(m->lookup_paths.unit_path, *generator);
2676 rm_rf(*generator, false, true, false);
2682 void manager_undo_generators(Manager *m) {
2685 remove_generator_dir(m, &m->generator_unit_path);
2686 remove_generator_dir(m, &m->generator_unit_path_early);
2687 remove_generator_dir(m, &m->generator_unit_path_late);
2690 int manager_environment_add(Manager *m, char **minus, char **plus) {
2691 char **a = NULL, **b = NULL, **l;
2696 if (!strv_isempty(minus)) {
2697 a = strv_env_delete(l, 1, minus);
2704 if (!strv_isempty(plus)) {
2705 b = strv_env_merge(2, l, plus);
2712 if (m->environment != l)
2713 strv_free(m->environment);
2720 manager_clean_environment(m);
2721 strv_sort(m->environment);
2726 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2731 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2732 if (!default_rlimit[i])
2735 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2743 void manager_recheck_journal(Manager *m) {
2748 if (m->running_as != SYSTEMD_SYSTEM)
2751 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2752 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2753 log_close_journal();
2757 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2758 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2759 log_close_journal();
2763 /* Hmm, OK, so the socket is fully up and the service is up
2764 * too, then let's make use of the thing. */
2768 void manager_set_show_status(Manager *m, bool b) {
2771 if (m->running_as != SYSTEMD_SYSTEM)
2777 touch("/run/systemd/show-status");
2779 unlink("/run/systemd/show-status");
2782 static bool manager_get_show_status(Manager *m) {
2785 if (m->running_as != SYSTEMD_SYSTEM)
2788 if (m->no_console_output)
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 if (!manager_is_booting_or_shutting_down(m))
2814 va_start(ap, format);
2815 status_vprintf(status, true, ephemeral, format, ap);
2819 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2820 _cleanup_free_ char *p = NULL;
2828 p = unit_name_from_path(path, suffix);
2832 found = manager_get_unit(m, p);
2842 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2843 char p[strlen(path)+1];
2849 path_kill_slashes(p);
2851 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);