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_SEC 5
84 #define JOBS_IN_PROGRESS_PERIOD_SEC 1
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_SEC, 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];
149 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
151 HASHMAP_FOREACH(j, m->jobs, i)
152 if (j->state == JOB_RUNNING && counter++ == print_nr)
155 /* m->n_running_jobs must be consistent with the contents of m->jobs,
156 * so the above loop must have succeeded in finding j. */
157 assert(counter == print_nr + 1);
160 cylon_pos = m->jobs_in_progress_iteration % 14;
162 cylon_pos = 14 - cylon_pos;
163 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
165 if (m->n_running_jobs > 1)
166 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
169 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
170 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
172 m->jobs_in_progress_iteration++;
175 static int manager_watch_idle_pipe(Manager *m) {
180 if (m->idle_pipe_event_source)
183 if (m->idle_pipe[2] < 0)
186 r = sd_event_add_io(m->event, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m, &m->idle_pipe_event_source);
188 log_error("Failed to watch idle pipe: %s", strerror(-r));
195 static void manager_close_idle_pipe(Manager *m) {
198 close_pipe(m->idle_pipe);
199 close_pipe(m->idle_pipe + 2);
202 static int manager_setup_time_change(Manager *m) {
205 /* We only care for the cancellation event, hence we set the
206 * timeout to the latest possible value. */
207 struct itimerspec its = {
208 .it_value.tv_sec = TIME_T_MAX,
212 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
214 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
215 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
217 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
218 if (m->time_change_fd < 0) {
219 log_error("Failed to create timerfd: %m");
223 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
224 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
225 close_nointr_nofail(m->time_change_fd);
226 m->time_change_fd = -1;
230 r = sd_event_add_io(m->event, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m, &m->time_change_event_source);
232 log_error("Failed to create time change event source: %s", strerror(-r));
236 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
241 static int enable_special_signals(Manager *m) {
242 _cleanup_close_ int fd = -1;
246 /* Enable that we get SIGINT on control-alt-del. In containers
247 * this will fail with EPERM (older) or EINVAL (newer), so
249 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
250 log_warning("Failed to enable ctrl-alt-del handling: %m");
252 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
254 /* Support systems without virtual console */
256 log_warning("Failed to open /dev/tty0: %m");
258 /* Enable that we get SIGWINCH on kbrequest */
259 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
260 log_warning("Failed to enable kbrequest handling: %m");
266 static int manager_setup_signals(Manager *m) {
267 struct sigaction sa = {
268 .sa_handler = SIG_DFL,
269 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
276 /* We are not interested in SIGSTOP and friends. */
277 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
279 assert_se(sigemptyset(&mask) == 0);
281 sigset_add_many(&mask,
282 SIGCHLD, /* Child died */
283 SIGTERM, /* Reexecute daemon */
284 SIGHUP, /* Reload configuration */
285 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
286 SIGUSR2, /* systemd: dump status */
287 SIGINT, /* Kernel sends us this on control-alt-del */
288 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
289 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
290 SIGRTMIN+0, /* systemd: start default.target */
291 SIGRTMIN+1, /* systemd: isolate rescue.target */
292 SIGRTMIN+2, /* systemd: isolate emergency.target */
293 SIGRTMIN+3, /* systemd: start halt.target */
294 SIGRTMIN+4, /* systemd: start poweroff.target */
295 SIGRTMIN+5, /* systemd: start reboot.target */
296 SIGRTMIN+6, /* systemd: start kexec.target */
297 SIGRTMIN+13, /* systemd: Immediate halt */
298 SIGRTMIN+14, /* systemd: Immediate poweroff */
299 SIGRTMIN+15, /* systemd: Immediate reboot */
300 SIGRTMIN+16, /* systemd: Immediate kexec */
301 SIGRTMIN+20, /* systemd: enable status messages */
302 SIGRTMIN+21, /* systemd: disable status messages */
303 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
304 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
305 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
306 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
307 SIGRTMIN+27, /* systemd: set log target to console */
308 SIGRTMIN+28, /* systemd: set log target to kmsg */
309 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
311 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
313 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
314 if (m->signal_fd < 0)
317 r = sd_event_add_io(m->event, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m, &m->signal_event_source);
321 /* Process signals a bit earlier than the rest of things, but
322 * later that notify_fd processing, so that the notify
323 * processing can still figure out to which process/service a
324 * message belongs, before we reap the process. */
325 r = sd_event_source_set_priority(m->signal_event_source, -5);
329 if (m->running_as == SYSTEMD_SYSTEM)
330 return enable_special_signals(m);
335 static int manager_default_environment(Manager *m) {
338 if (m->running_as == SYSTEMD_SYSTEM) {
339 /* The system manager always starts with a clean
340 * environment for its children. It does not import
341 * the kernel or the parents exported variables.
343 * The initial passed environ is untouched to keep
344 * /proc/self/environ valid; it is used for tagging
345 * the init process inside containers. */
346 m->environment = strv_new("PATH=" DEFAULT_PATH,
349 /* Import locale variables LC_*= from configuration */
350 locale_setup(&m->environment);
352 /* The user manager passes its own environment
353 * along to its children. */
354 m->environment = strv_copy(environ);
359 strv_sort(m->environment);
364 int manager_new(SystemdRunningAs running_as, Manager **_m) {
369 assert(running_as >= 0);
370 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
372 m = new0(Manager, 1);
377 if (detect_container(NULL) <= 0)
378 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
381 m->running_as = running_as;
382 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
384 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
386 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;
387 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
389 r = manager_default_environment(m);
393 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
397 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
401 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
405 r = hashmap_ensure_allocated(&m->watch_pids, trivial_hash_func, trivial_compare_func);
409 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
413 r = sd_event_default(&m->event);
417 r = sd_event_add_defer(m->event, manager_dispatch_run_queue, m, &m->run_queue_event_source);
421 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
425 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
429 r = manager_setup_signals(m);
433 r = manager_setup_cgroup(m);
437 r = manager_setup_time_change(m);
441 m->udev = udev_new();
447 /* Note that we set up neither kdbus, nor the notify fd
448 * here. We do that after deserialization, since they might
449 * have gotten serialized across the reexec. */
451 m->taint_usr = dir_is_empty("/usr") > 0;
461 static int manager_setup_notify(Manager *m) {
464 struct sockaddr_un un;
466 .sa.sa_family = AF_UNIX,
470 if (m->notify_fd < 0) {
471 _cleanup_close_ int fd = -1;
473 /* First free all secondary fields */
474 free(m->notify_socket);
475 m->notify_socket = NULL;
476 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
478 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
480 log_error("Failed to allocate notification socket: %m");
484 if (getpid() != 1 || detect_container(NULL) > 0)
485 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%" PRIx64, random_u64());
487 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
488 sa.un.sun_path[0] = 0;
490 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
492 log_error("bind() failed: %m");
496 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
498 log_error("SO_PASSCRED failed: %m");
502 sa.un.sun_path[0] = '@';
503 m->notify_socket = strdup(sa.un.sun_path);
504 if (!m->notify_socket)
510 log_debug("Using notification socket %s", m->notify_socket);
513 if (!m->notify_event_source) {
514 r = sd_event_add_io(m->event, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m, &m->notify_event_source);
516 log_error("Failed to allocate notify event source: %s", strerror(-r));
520 /* Process signals a bit earlier than SIGCHLD, so that we can
521 * still identify to which service an exit message belongs */
522 r = sd_event_source_set_priority(m->notify_event_source, -7);
524 log_error("Failed to set priority of notify event source: %s", strerror(-r));
532 static int manager_setup_kdbus(Manager *m) {
533 _cleanup_free_ char *p = NULL;
538 if (m->kdbus_fd >= 0)
541 /* If there's already a bus address set, don't set up kdbus */
542 if (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"))
545 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
546 if (m->kdbus_fd < 0) {
547 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
551 log_debug("Successfully set up kdbus on %s", p);
553 /* Create the namespace directory here, so that the contents
554 * of that directory is not visible to non-root users. This is
555 * necessary to ensure that users cannot get access to busses
556 * of virtualized users when no UID namespacing is used. */
557 mkdir_p_label("/dev/kdbus/ns", 0700);
563 static int manager_connect_bus(Manager *m, bool reexecuting) {
564 bool try_bus_connect;
571 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
573 /* Try to connect to the busses, if possible. */
574 return bus_init(m, try_bus_connect);
577 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
583 while ((u = m->cleanup_queue)) {
584 assert(u->in_cleanup_queue);
594 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
595 GC_OFFSET_UNSURE, /* No clue */
596 GC_OFFSET_GOOD, /* We still need this unit */
597 GC_OFFSET_BAD, /* We don't need this unit anymore */
601 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
608 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
609 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
610 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
613 if (u->in_cleanup_queue)
616 if (unit_check_gc(u))
619 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
623 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
624 unit_gc_sweep(other, gc_marker);
626 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
629 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
636 /* We were unable to find anything out about this entry, so
637 * let's investigate it later */
638 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
639 unit_add_to_gc_queue(u);
643 /* We definitely know that this one is not useful anymore, so
644 * let's mark it for deletion */
645 u->gc_marker = gc_marker + GC_OFFSET_BAD;
646 unit_add_to_cleanup_queue(u);
650 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
653 static unsigned manager_dispatch_gc_queue(Manager *m) {
660 /* log_debug("Running GC..."); */
662 m->gc_marker += _GC_OFFSET_MAX;
663 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
666 gc_marker = m->gc_marker;
668 while ((u = m->gc_queue)) {
669 assert(u->in_gc_queue);
671 unit_gc_sweep(u, gc_marker);
673 LIST_REMOVE(gc_queue, m->gc_queue, u);
674 u->in_gc_queue = false;
678 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
679 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
680 log_debug_unit(u->id, "Collecting %s", u->id);
681 u->gc_marker = gc_marker + GC_OFFSET_BAD;
682 unit_add_to_cleanup_queue(u);
686 m->n_in_gc_queue = 0;
691 static void manager_clear_jobs_and_units(Manager *m) {
696 while ((u = hashmap_first(m->units)))
699 manager_dispatch_cleanup_queue(m);
701 assert(!m->load_queue);
702 assert(!m->run_queue);
703 assert(!m->dbus_unit_queue);
704 assert(!m->dbus_job_queue);
705 assert(!m->cleanup_queue);
706 assert(!m->gc_queue);
708 assert(hashmap_isempty(m->jobs));
709 assert(hashmap_isempty(m->units));
712 m->n_running_jobs = 0;
715 void manager_free(Manager *m) {
721 manager_clear_jobs_and_units(m);
723 for (c = 0; c < _UNIT_TYPE_MAX; c++)
724 if (unit_vtable[c]->shutdown)
725 unit_vtable[c]->shutdown(m);
727 /* If we reexecute ourselves, we keep the root cgroup
729 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
731 manager_undo_generators(m);
735 hashmap_free(m->units);
736 hashmap_free(m->jobs);
737 hashmap_free(m->watch_pids);
738 hashmap_free(m->watch_bus);
740 sd_event_source_unref(m->signal_event_source);
741 sd_event_source_unref(m->notify_event_source);
742 sd_event_source_unref(m->time_change_event_source);
743 sd_event_source_unref(m->jobs_in_progress_event_source);
744 sd_event_source_unref(m->idle_pipe_event_source);
745 sd_event_source_unref(m->run_queue_event_source);
747 if (m->signal_fd >= 0)
748 close_nointr_nofail(m->signal_fd);
749 if (m->notify_fd >= 0)
750 close_nointr_nofail(m->notify_fd);
751 if (m->time_change_fd >= 0)
752 close_nointr_nofail(m->time_change_fd);
753 if (m->kdbus_fd >= 0)
754 close_nointr_nofail(m->kdbus_fd);
756 manager_close_idle_pipe(m);
759 sd_event_unref(m->event);
761 free(m->notify_socket);
763 lookup_paths_free(&m->lookup_paths);
764 strv_free(m->environment);
766 hashmap_free(m->cgroup_unit);
767 set_free_free(m->unit_path_cache);
769 free(m->switch_root);
770 free(m->switch_root_init);
772 for (i = 0; i < RLIMIT_NLIMITS; i++)
775 assert(hashmap_isempty(m->units_requiring_mounts_for));
776 hashmap_free(m->units_requiring_mounts_for);
781 int manager_enumerate(Manager *m) {
787 /* Let's ask every type to load all units from disk/kernel
788 * that it might know */
789 for (c = 0; c < _UNIT_TYPE_MAX; c++)
790 if (unit_vtable[c]->enumerate) {
791 q = unit_vtable[c]->enumerate(m);
796 manager_dispatch_load_queue(m);
800 static int manager_coldplug(Manager *m) {
808 /* Then, let's set up their initial state. */
809 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
815 if ((q = unit_coldplug(u)) < 0)
822 static void manager_build_unit_path_cache(Manager *m) {
824 _cleanup_free_ DIR *d = NULL;
829 set_free_free(m->unit_path_cache);
831 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
832 if (!m->unit_path_cache) {
833 log_error("Failed to allocate unit path cache.");
837 /* This simply builds a list of files we know exist, so that
838 * we don't always have to go to disk */
840 STRV_FOREACH(i, m->lookup_paths.unit_path) {
846 log_error("Failed to open directory %s: %m", *i);
850 while ((de = readdir(d))) {
853 if (ignore_file(de->d_name))
856 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
862 r = set_consume(m->unit_path_cache, p);
874 log_error("Failed to build unit path cache: %s", strerror(-r));
876 set_free_free(m->unit_path_cache);
877 m->unit_path_cache = NULL;
881 static int manager_distribute_fds(Manager *m, FDSet *fds) {
888 HASHMAP_FOREACH(u, m->units, i) {
890 if (fdset_size(fds) <= 0)
893 if (UNIT_VTABLE(u)->distribute_fds) {
894 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
903 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
908 dual_timestamp_get(&m->generators_start_timestamp);
909 manager_run_generators(m);
910 dual_timestamp_get(&m->generators_finish_timestamp);
912 r = lookup_paths_init(
913 &m->lookup_paths, m->running_as, true,
914 m->generator_unit_path,
915 m->generator_unit_path_early,
916 m->generator_unit_path_late);
920 manager_build_unit_path_cache(m);
922 /* If we will deserialize make sure that during enumeration
923 * this is already known, so we increase the counter here
928 /* First, enumerate what we can from all config files */
929 dual_timestamp_get(&m->units_load_start_timestamp);
930 r = manager_enumerate(m);
931 dual_timestamp_get(&m->units_load_finish_timestamp);
933 /* Second, deserialize if there is something to deserialize */
935 q = manager_deserialize(m, serialization, fds);
940 /* Any fds left? Find some unit which wants them. This is
941 * useful to allow container managers to pass some file
942 * descriptors to us pre-initialized. This enables
943 * socket-based activation of entire containers. */
944 if (fdset_size(fds) > 0) {
945 q = manager_distribute_fds(m, fds);
950 /* We might have deserialized the notify fd, but if we didn't
951 * then let's create the bus now */
952 manager_setup_notify(m);
954 /* We might have deserialized the kdbus control fd, but if we
955 * didn't, then let's create the bus now. */
956 manager_setup_kdbus(m);
957 manager_connect_bus(m, !!serialization);
959 /* Third, fire things up! */
960 q = manager_coldplug(m);
965 assert(m->n_reloading > 0);
968 /* Let's wait for the UnitNew/JobNew messages being
969 * sent, before we notify that the reload is
971 m->send_reloading_done = true;
977 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
982 assert(type < _JOB_TYPE_MAX);
984 assert(mode < _JOB_MODE_MAX);
986 if (mode == JOB_ISOLATE && type != JOB_START) {
987 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
991 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
992 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
996 log_debug_unit(unit->id,
997 "Trying to enqueue job %s/%s/%s", unit->id,
998 job_type_to_string(type), job_mode_to_string(mode));
1000 job_type_collapse(&type, unit);
1002 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1006 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1007 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1008 mode == JOB_IGNORE_DEPENDENCIES, e);
1012 if (mode == JOB_ISOLATE) {
1013 r = transaction_add_isolate_jobs(tr, m);
1018 r = transaction_activate(tr, m, mode, e);
1022 log_debug_unit(unit->id,
1023 "Enqueued job %s/%s as %u", unit->id,
1024 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1027 *_ret = tr->anchor_job;
1029 transaction_free(tr);
1033 transaction_abort(tr);
1034 transaction_free(tr);
1038 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1043 assert(type < _JOB_TYPE_MAX);
1045 assert(mode < _JOB_MODE_MAX);
1047 r = manager_load_unit(m, name, NULL, NULL, &unit);
1051 return manager_add_job(m, type, unit, mode, override, e, _ret);
1054 Job *manager_get_job(Manager *m, uint32_t id) {
1057 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1060 Unit *manager_get_unit(Manager *m, const char *name) {
1064 return hashmap_get(m->units, name);
1067 unsigned manager_dispatch_load_queue(Manager *m) {
1073 /* Make sure we are not run recursively */
1074 if (m->dispatching_load_queue)
1077 m->dispatching_load_queue = true;
1079 /* Dispatches the load queue. Takes a unit from the queue and
1080 * tries to load its data until the queue is empty */
1082 while ((u = m->load_queue)) {
1083 assert(u->in_load_queue);
1089 m->dispatching_load_queue = false;
1093 int manager_load_unit_prepare(
1105 assert(name || path);
1107 /* This will prepare the unit for loading, but not actually
1108 * load anything from disk. */
1110 if (path && !is_path(path))
1111 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1114 name = basename(path);
1116 t = unit_name_to_type(name);
1118 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1119 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1121 ret = manager_get_unit(m, name);
1127 ret = unit_new(m, unit_vtable[t]->object_size);
1132 ret->fragment_path = strdup(path);
1133 if (!ret->fragment_path) {
1139 r = unit_add_name(ret, name);
1145 unit_add_to_load_queue(ret);
1146 unit_add_to_dbus_queue(ret);
1147 unit_add_to_gc_queue(ret);
1155 int manager_load_unit(
1166 /* This will load the service information files, but not actually
1167 * start any services or anything. */
1169 r = manager_load_unit_prepare(m, name, path, e, _ret);
1173 manager_dispatch_load_queue(m);
1176 *_ret = unit_follow_merge(*_ret);
1181 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1188 HASHMAP_FOREACH(j, s->jobs, i)
1189 job_dump(j, f, prefix);
1192 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1200 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1202 unit_dump(u, f, prefix);
1205 void manager_clear_jobs(Manager *m) {
1210 while ((j = hashmap_first(m->jobs)))
1211 /* No need to recurse. We're cancelling all jobs. */
1212 job_finish_and_invalidate(j, JOB_CANCELED, false);
1215 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1216 Manager *m = userdata;
1222 while ((j = m->run_queue)) {
1223 assert(j->installed);
1224 assert(j->in_run_queue);
1226 job_run_and_invalidate(j);
1229 if (m->n_running_jobs > 0)
1230 manager_watch_jobs_in_progress(m);
1232 if (m->n_on_console > 0)
1233 manager_watch_idle_pipe(m);
1238 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1245 if (m->dispatching_dbus_queue)
1248 m->dispatching_dbus_queue = true;
1250 while ((u = m->dbus_unit_queue)) {
1251 assert(u->in_dbus_queue);
1253 bus_unit_send_change_signal(u);
1257 while ((j = m->dbus_job_queue)) {
1258 assert(j->in_dbus_queue);
1260 bus_job_send_change_signal(j);
1264 m->dispatching_dbus_queue = false;
1266 if (m->send_reloading_done) {
1267 m->send_reloading_done = false;
1269 bus_manager_send_reloading(m, false);
1272 if (m->queued_message)
1273 bus_send_queued_message(m);
1278 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1279 Manager *m = userdata;
1283 assert(m->notify_fd == fd);
1285 if (revents != EPOLLIN) {
1286 log_warning("Got unexpected poll event for notify fd.");
1292 struct iovec iovec = {
1294 .iov_len = sizeof(buf)-1,
1298 struct cmsghdr cmsghdr;
1299 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1302 struct msghdr msghdr = {
1305 .msg_control = &control,
1306 .msg_controllen = sizeof(control),
1308 struct ucred *ucred;
1310 _cleanup_strv_free_ char **tags = NULL;
1312 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1317 if (errno == EAGAIN || errno == EINTR)
1323 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1324 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1325 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1326 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1327 log_warning("Received notify message without credentials. Ignoring.");
1331 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1333 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1335 u = manager_get_unit_by_pid(m, ucred->pid);
1337 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1342 assert((size_t) n < sizeof(buf));
1344 tags = strv_split(buf, "\n\r");
1348 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1350 if (UNIT_VTABLE(u)->notify_message)
1351 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1357 static int manager_dispatch_sigchld(Manager *m) {
1364 /* First we call waitd() for a PID and do not reap the
1365 * zombie. That way we can still access /proc/$PID for
1366 * it while it is a zombie. */
1367 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1369 if (errno == ECHILD)
1381 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1382 _cleanup_free_ char *name = NULL;
1384 get_process_comm(si.si_pid, &name);
1385 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1388 /* And now figure out the unit this belongs to */
1389 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1391 u = manager_get_unit_by_pid(m, si.si_pid);
1393 /* And now, we actually reap the zombie. */
1394 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1401 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1404 log_debug("Child %lu died (code=%s, status=%i/%s)",
1405 (long unsigned) si.si_pid,
1406 sigchld_code_to_string(si.si_code),
1408 strna(si.si_code == CLD_EXITED
1409 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1410 : signal_to_string(si.si_status)));
1415 log_debug_unit(u->id,
1416 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1418 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1419 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1425 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1426 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1429 log_debug_unit(name, "Activating special unit %s", name);
1431 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1433 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1438 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1439 Manager *m = userdata;
1441 struct signalfd_siginfo sfsi;
1442 bool sigchld = false;
1445 assert(m->signal_fd == fd);
1447 if (revents != EPOLLIN) {
1448 log_warning("Got unexpected events from signal file descriptor.");
1453 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1454 if (n != sizeof(sfsi)) {
1459 if (errno == EINTR || errno == EAGAIN)
1465 if (sfsi.ssi_pid > 0) {
1466 _cleanup_free_ char *p = NULL;
1468 get_process_comm(sfsi.ssi_pid, &p);
1470 log_full(sfsi.ssi_signo == SIGCHLD ||
1471 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1472 ? LOG_DEBUG : LOG_INFO,
1473 "Received SIG%s from PID %lu (%s).",
1474 signal_to_string(sfsi.ssi_signo),
1475 (unsigned long) sfsi.ssi_pid, strna(p));
1477 log_full(sfsi.ssi_signo == SIGCHLD ||
1478 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1479 ? LOG_DEBUG : LOG_INFO,
1481 signal_to_string(sfsi.ssi_signo));
1483 switch (sfsi.ssi_signo) {
1490 if (m->running_as == SYSTEMD_SYSTEM) {
1491 /* This is for compatibility with the
1492 * original sysvinit */
1493 m->exit_code = MANAGER_REEXECUTE;
1500 if (m->running_as == SYSTEMD_SYSTEM) {
1501 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1505 /* Run the exit target if there is one, if not, just exit. */
1506 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1507 m->exit_code = MANAGER_EXIT;
1514 if (m->running_as == SYSTEMD_SYSTEM)
1515 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1517 /* This is a nop on non-init */
1521 if (m->running_as == SYSTEMD_SYSTEM)
1522 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1524 /* This is a nop on non-init */
1530 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1532 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1533 log_info("Trying to reconnect to bus...");
1537 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1538 log_info("Loading D-Bus service...");
1539 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1546 _cleanup_free_ char *dump = NULL;
1547 _cleanup_fclose_ FILE *f = NULL;
1550 f = open_memstream(&dump, &size);
1552 log_warning("Failed to allocate memory stream.");
1556 manager_dump_units(m, f, "\t");
1557 manager_dump_jobs(m, f, "\t");
1560 log_warning("Failed to write status stream");
1564 log_dump(LOG_INFO, dump);
1569 m->exit_code = MANAGER_RELOAD;
1574 /* Starting SIGRTMIN+0 */
1575 static const char * const target_table[] = {
1576 [0] = SPECIAL_DEFAULT_TARGET,
1577 [1] = SPECIAL_RESCUE_TARGET,
1578 [2] = SPECIAL_EMERGENCY_TARGET,
1579 [3] = SPECIAL_HALT_TARGET,
1580 [4] = SPECIAL_POWEROFF_TARGET,
1581 [5] = SPECIAL_REBOOT_TARGET,
1582 [6] = SPECIAL_KEXEC_TARGET
1585 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1586 static const ManagerExitCode code_table[] = {
1588 [1] = MANAGER_POWEROFF,
1589 [2] = MANAGER_REBOOT,
1593 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1594 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1595 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1596 manager_start_target(m, target_table[idx],
1597 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1601 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1602 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1603 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1607 switch (sfsi.ssi_signo - SIGRTMIN) {
1610 log_debug("Enabling showing of status.");
1611 manager_set_show_status(m, true);
1615 log_debug("Disabling showing of status.");
1616 manager_set_show_status(m, false);
1620 log_set_max_level(LOG_DEBUG);
1621 log_notice("Setting log level to debug.");
1625 log_set_max_level(LOG_INFO);
1626 log_notice("Setting log level to info.");
1630 if (m->running_as == SYSTEMD_USER) {
1631 m->exit_code = MANAGER_EXIT;
1635 /* This is a nop on init */
1639 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1640 log_notice("Setting log target to journal-or-kmsg.");
1644 log_set_target(LOG_TARGET_CONSOLE);
1645 log_notice("Setting log target to console.");
1649 log_set_target(LOG_TARGET_KMSG);
1650 log_notice("Setting log target to kmsg.");
1654 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1655 log_notice("Setting log target to syslog-or-kmsg.");
1659 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1666 manager_dispatch_sigchld(m);
1671 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1672 Manager *m = userdata;
1677 assert(m->time_change_fd == fd);
1679 log_struct(LOG_INFO,
1680 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1681 "MESSAGE=Time has been changed",
1684 /* Restart the watch */
1685 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1687 close_nointr_nofail(m->time_change_fd);
1688 m->time_change_fd = -1;
1690 manager_setup_time_change(m);
1692 HASHMAP_FOREACH(u, m->units, i)
1693 if (UNIT_VTABLE(u)->time_change)
1694 UNIT_VTABLE(u)->time_change(u);
1699 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1700 Manager *m = userdata;
1703 assert(m->idle_pipe[2] == fd);
1705 m->no_console_output = m->n_on_console > 0;
1707 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1708 manager_close_idle_pipe(m);
1713 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1714 Manager *m = userdata;
1718 manager_print_jobs_in_progress(m);
1722 int manager_loop(Manager *m) {
1725 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1728 m->exit_code = MANAGER_RUNNING;
1730 /* Release the path cache */
1731 set_free_free(m->unit_path_cache);
1732 m->unit_path_cache = NULL;
1734 manager_check_finished(m);
1736 /* There might still be some zombies hanging around from
1737 * before we were exec()'ed. Let's reap them. */
1738 r = manager_dispatch_sigchld(m);
1742 while (m->exit_code == MANAGER_RUNNING) {
1745 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1748 if (!ratelimit_test(&rl)) {
1749 /* Yay, something is going seriously wrong, pause a little */
1750 log_warning("Looping too fast. Throttling execution a little.");
1755 if (manager_dispatch_load_queue(m) > 0)
1758 if (manager_dispatch_gc_queue(m) > 0)
1761 if (manager_dispatch_cleanup_queue(m) > 0)
1764 if (manager_dispatch_cgroup_queue(m) > 0)
1767 if (manager_dispatch_dbus_queue(m) > 0)
1770 /* Sleep for half the watchdog time */
1771 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1772 wait_usec = m->runtime_watchdog / 2;
1776 wait_usec = (usec_t) -1;
1778 r = sd_event_run(m->event, wait_usec);
1780 log_error("Failed to run event loop: %s", strerror(-r));
1785 return m->exit_code;
1788 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1789 _cleanup_free_ char *n = NULL;
1797 r = unit_name_from_dbus_path(s, &n);
1801 r = manager_load_unit(m, n, NULL, e, &u);
1810 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1820 p = startswith(s, "/org/freedesktop/systemd1/job/");
1824 r = safe_atou(p, &id);
1828 j = manager_get_job(m, id);
1837 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1843 audit_fd = get_audit_fd();
1847 /* Don't generate audit events if the service was already
1848 * started and we're just deserializing */
1849 if (m->n_reloading > 0)
1852 if (m->running_as != SYSTEMD_SYSTEM)
1855 if (u->type != UNIT_SERVICE)
1858 p = unit_name_to_prefix_and_instance(u->id);
1860 log_error_unit(u->id,
1861 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1865 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1866 if (errno == EPERM) {
1867 /* We aren't allowed to send audit messages?
1868 * Then let's not retry again. */
1871 log_warning("Failed to send audit message: %m");
1879 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1881 union sockaddr_union sa;
1883 char *message = NULL;
1885 /* Don't generate plymouth 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 (detect_container(NULL) > 0)
1896 if (u->type != UNIT_SERVICE &&
1897 u->type != UNIT_MOUNT &&
1898 u->type != UNIT_SWAP)
1901 /* We set SOCK_NONBLOCK here so that we rather drop the
1902 * message then wait for plymouth */
1903 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1905 log_error("socket() failed: %m");
1910 sa.sa.sa_family = AF_UNIX;
1911 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1912 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1914 if (errno != EPIPE &&
1917 errno != ECONNREFUSED &&
1918 errno != ECONNRESET &&
1919 errno != ECONNABORTED)
1920 log_error("connect() failed: %m");
1925 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1931 if (write(fd, message, n + 1) != n + 1) {
1933 if (errno != EPIPE &&
1936 errno != ECONNREFUSED &&
1937 errno != ECONNRESET &&
1938 errno != ECONNABORTED)
1939 log_error("Failed to write Plymouth message: %m");
1946 close_nointr_nofail(fd);
1951 void manager_dispatch_bus_name_owner_changed(
1954 const char* old_owner,
1955 const char *new_owner) {
1962 u = hashmap_get(m->watch_bus, name);
1966 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1969 int manager_open_serialization(Manager *m, FILE **_f) {
1970 _cleanup_free_ char *path = NULL;
1976 if (m->running_as == SYSTEMD_SYSTEM)
1977 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1979 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1984 RUN_WITH_UMASK(0077) {
1985 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1992 log_debug("Serializing state to %s", path);
1994 f = fdopen(fd, "w+");
1996 close_nointr_nofail(fd);
2005 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2018 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2019 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2020 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2021 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2023 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2024 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2025 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2026 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2029 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2030 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2031 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2032 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2033 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2034 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2035 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2036 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2039 if (!switching_root) {
2040 STRV_FOREACH(e, m->environment) {
2041 _cleanup_free_ char *ce;
2047 fprintf(f, "env=%s\n", *e);
2051 if (m->notify_fd >= 0) {
2054 copy = fdset_put_dup(fds, m->notify_fd);
2058 fprintf(f, "notify-fd=%i\n", copy);
2059 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2062 if (m->kdbus_fd >= 0) {
2065 copy = fdset_put_dup(fds, m->kdbus_fd);
2069 fprintf(f, "kdbus-fd=%i\n", copy);
2072 bus_serialize(m, f);
2076 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2080 if (!unit_can_serialize(u))
2087 r = unit_serialize(u, f, fds, !switching_root);
2094 assert(m->n_reloading > 0);
2100 r = bus_fdset_add_all(m, fds);
2107 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2113 log_debug("Deserializing state...");
2118 char line[LINE_MAX], *l;
2120 if (!fgets(line, sizeof(line), f)) {
2135 if (startswith(l, "current-job-id=")) {
2138 if (safe_atou32(l+15, &id) < 0)
2139 log_debug("Failed to parse current job id value %s", l+15);
2141 m->current_job_id = MAX(m->current_job_id, id);
2143 } else if (startswith(l, "n-installed-jobs=")) {
2146 if (safe_atou32(l+17, &n) < 0)
2147 log_debug("Failed to parse installed jobs counter %s", l+17);
2149 m->n_installed_jobs += n;
2151 } else if (startswith(l, "n-failed-jobs=")) {
2154 if (safe_atou32(l+14, &n) < 0)
2155 log_debug("Failed to parse failed jobs counter %s", l+14);
2157 m->n_failed_jobs += n;
2159 } else if (startswith(l, "taint-usr=")) {
2162 b = parse_boolean(l+10);
2164 log_debug("Failed to parse taint /usr flag %s", l+10);
2166 m->taint_usr = m->taint_usr || b;
2168 } else if (startswith(l, "firmware-timestamp="))
2169 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2170 else if (startswith(l, "loader-timestamp="))
2171 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2172 else if (startswith(l, "kernel-timestamp="))
2173 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2174 else if (startswith(l, "initrd-timestamp="))
2175 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2176 else if (startswith(l, "userspace-timestamp="))
2177 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2178 else if (startswith(l, "finish-timestamp="))
2179 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2180 else if (startswith(l, "security-start-timestamp="))
2181 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2182 else if (startswith(l, "security-finish-timestamp="))
2183 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2184 else if (startswith(l, "generators-start-timestamp="))
2185 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2186 else if (startswith(l, "generators-finish-timestamp="))
2187 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2188 else if (startswith(l, "units-load-start-timestamp="))
2189 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2190 else if (startswith(l, "units-load-finish-timestamp="))
2191 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2192 else if (startswith(l, "env=")) {
2193 _cleanup_free_ char *uce = NULL;
2196 uce = cunescape(l+4);
2202 e = strv_env_set(m->environment, uce);
2208 strv_free(m->environment);
2211 } else if (startswith(l, "notify-fd=")) {
2214 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2215 log_debug("Failed to parse notify fd: %s", l + 10);
2217 if (m->notify_fd >= 0) {
2218 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2219 close_nointr_nofail(m->notify_fd);
2222 m->notify_fd = fdset_remove(fds, fd);
2225 } else if (startswith(l, "notify-socket=")) {
2234 free(m->notify_socket);
2235 m->notify_socket = n;
2237 } else if (startswith(l, "kdbus-fd=")) {
2240 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2241 log_debug("Failed to parse kdbus fd: %s", l + 9);
2243 if (m->kdbus_fd >= 0)
2244 close_nointr_nofail(m->kdbus_fd);
2246 m->kdbus_fd = fdset_remove(fds, fd);
2249 } else if (bus_deserialize_item(m, l) == 0)
2250 log_debug("Unknown serialization item '%s'", l);
2255 char name[UNIT_NAME_MAX+2];
2258 if (!fgets(name, sizeof(name), f)) {
2269 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2273 r = unit_deserialize(u, f, fds);
2282 assert(m->n_reloading > 0);
2288 int manager_reload(Manager *m) {
2290 _cleanup_fclose_ FILE *f = NULL;
2291 _cleanup_fdset_free_ FDSet *fds = NULL;
2295 r = manager_open_serialization(m, &f);
2300 bus_manager_send_reloading(m, true);
2308 r = manager_serialize(m, f, fds, false);
2314 if (fseeko(f, 0, SEEK_SET) < 0) {
2319 /* From here on there is no way back. */
2320 manager_clear_jobs_and_units(m);
2321 manager_undo_generators(m);
2322 lookup_paths_free(&m->lookup_paths);
2324 /* Find new unit paths */
2325 manager_run_generators(m);
2327 q = lookup_paths_init(
2328 &m->lookup_paths, m->running_as, true,
2329 m->generator_unit_path,
2330 m->generator_unit_path_early,
2331 m->generator_unit_path_late);
2335 manager_build_unit_path_cache(m);
2337 /* First, enumerate what we can from all config files */
2338 q = manager_enumerate(m);
2342 /* Second, deserialize our stored data */
2343 q = manager_deserialize(m, f, fds);
2350 /* Third, fire things up! */
2351 q = manager_coldplug(m);
2355 assert(m->n_reloading > 0);
2358 m->send_reloading_done = true;
2363 static bool manager_is_booting_or_shutting_down(Manager *m) {
2368 /* Is the initial job still around? */
2369 if (manager_get_job(m, m->default_unit_job_id))
2372 /* Is there a job for the shutdown target? */
2373 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2380 bool manager_is_reloading_or_reexecuting(Manager *m) {
2383 return m->n_reloading != 0;
2386 void manager_reset_failed(Manager *m) {
2392 HASHMAP_FOREACH(u, m->units, i)
2393 unit_reset_failed(u);
2396 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2402 /* Returns true if the unit is inactive or going down */
2403 u = manager_get_unit(m, name);
2407 return unit_inactive_or_pending(u);
2410 void manager_check_finished(Manager *m) {
2411 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2412 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2416 if (m->n_running_jobs == 0)
2417 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2419 if (hashmap_size(m->jobs) > 0) {
2420 if (m->jobs_in_progress_event_source)
2421 sd_event_source_set_time(m->jobs_in_progress_event_source, JOBS_IN_PROGRESS_PERIOD_SEC);
2425 /* Notify Type=idle units that we are done now */
2426 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2427 manager_close_idle_pipe(m);
2429 /* Turn off confirm spawn now */
2430 m->confirm_spawn = false;
2432 if (dual_timestamp_is_set(&m->finish_timestamp))
2435 dual_timestamp_get(&m->finish_timestamp);
2437 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2439 /* Note that m->kernel_usec.monotonic is always at 0,
2440 * and m->firmware_usec.monotonic and
2441 * m->loader_usec.monotonic should be considered
2442 * negative values. */
2444 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2445 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2446 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2447 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2449 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2451 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2452 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2454 if (!log_on_console())
2455 log_struct(LOG_INFO,
2456 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2457 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2458 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2459 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2460 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2461 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2462 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2463 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2464 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2467 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2470 if (!log_on_console())
2471 log_struct(LOG_INFO,
2472 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2473 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2474 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2475 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2476 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2477 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2478 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2482 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2483 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2485 if (!log_on_console())
2486 log_struct(LOG_INFO,
2487 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2488 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2489 "MESSAGE=Startup finished in %s.",
2490 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2494 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2497 "READY=1\nSTATUS=Startup finished in %s.",
2498 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2501 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2512 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2514 p = strappend("/run/systemd/", name);
2518 r = mkdir_p_label(p, 0755);
2520 log_error("Failed to create generator directory %s: %s",
2526 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2531 log_error("Failed to create generator directory %s: %m",
2542 static void trim_generator_dir(Manager *m, char **generator) {
2549 if (rmdir(*generator) >= 0) {
2557 void manager_run_generators(Manager *m) {
2558 _cleanup_closedir_ DIR *d = NULL;
2559 const char *generator_path;
2560 const char *argv[5];
2565 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2566 d = opendir(generator_path);
2568 if (errno == ENOENT)
2571 log_error("Failed to enumerate generator directory %s: %m",
2576 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2580 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2584 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2588 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2589 argv[1] = m->generator_unit_path;
2590 argv[2] = m->generator_unit_path_early;
2591 argv[3] = m->generator_unit_path_late;
2594 RUN_WITH_UMASK(0022)
2595 execute_directory(generator_path, d, (char**) argv);
2598 trim_generator_dir(m, &m->generator_unit_path);
2599 trim_generator_dir(m, &m->generator_unit_path_early);
2600 trim_generator_dir(m, &m->generator_unit_path_late);
2603 static void remove_generator_dir(Manager *m, char **generator) {
2610 strv_remove(m->lookup_paths.unit_path, *generator);
2611 rm_rf(*generator, false, true, false);
2617 void manager_undo_generators(Manager *m) {
2620 remove_generator_dir(m, &m->generator_unit_path);
2621 remove_generator_dir(m, &m->generator_unit_path_early);
2622 remove_generator_dir(m, &m->generator_unit_path_late);
2625 int manager_environment_add(Manager *m, char **minus, char **plus) {
2626 char **a = NULL, **b = NULL, **l;
2631 if (!strv_isempty(minus)) {
2632 a = strv_env_delete(l, 1, minus);
2639 if (!strv_isempty(plus)) {
2640 b = strv_env_merge(2, l, plus);
2647 if (m->environment != l)
2648 strv_free(m->environment);
2654 m->environment = strv_sort(l);
2658 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2663 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2664 if (!default_rlimit[i])
2667 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2675 void manager_recheck_journal(Manager *m) {
2680 if (m->running_as != SYSTEMD_SYSTEM)
2683 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2684 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2685 log_close_journal();
2689 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2690 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2691 log_close_journal();
2695 /* Hmm, OK, so the socket is fully up and the service is up
2696 * too, then let's make use of the thing. */
2700 void manager_set_show_status(Manager *m, bool b) {
2703 if (m->running_as != SYSTEMD_SYSTEM)
2709 touch("/run/systemd/show-status");
2711 unlink("/run/systemd/show-status");
2714 static bool manager_get_show_status(Manager *m) {
2717 if (m->running_as != SYSTEMD_SYSTEM)
2720 if (m->no_console_output)
2726 /* If Plymouth is running make sure we show the status, so
2727 * that there's something nice to see when people press Esc */
2729 return plymouth_running();
2732 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2735 if (!manager_get_show_status(m))
2738 /* XXX We should totally drop the check for ephemeral here
2739 * and thus effectively make 'Type=idle' pointless. */
2740 if (ephemeral && m->n_on_console > 0)
2743 if (!manager_is_booting_or_shutting_down(m))
2746 va_start(ap, format);
2747 status_vprintf(status, true, ephemeral, format, ap);
2751 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2752 _cleanup_free_ char *p = NULL;
2760 p = unit_name_from_path(path, suffix);
2764 found = manager_get_unit(m, p);
2774 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2775 char p[strlen(path)+1];
2781 path_kill_slashes(p);
2783 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);