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 void manager_clean_environment(Manager *m) {
338 /* Let's remove some environment variables that we
339 * need ourselves to communicate with our clients */
352 static int manager_default_environment(Manager *m) {
355 if (m->running_as == SYSTEMD_SYSTEM) {
356 /* The system manager always starts with a clean
357 * environment for its children. It does not import
358 * the kernel or the parents exported variables.
360 * The initial passed environ is untouched to keep
361 * /proc/self/environ valid; it is used for tagging
362 * the init process inside containers. */
363 m->environment = strv_new("PATH=" DEFAULT_PATH,
366 /* Import locale variables LC_*= from configuration */
367 locale_setup(&m->environment);
369 /* The user manager passes its own environment
370 * along to its children. */
371 m->environment = strv_copy(environ);
377 manager_clean_environment(m);
378 strv_sort(m->environment);
383 int manager_new(SystemdRunningAs running_as, Manager **_m) {
388 assert(running_as >= 0);
389 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
391 m = new0(Manager, 1);
396 if (detect_container(NULL) <= 0)
397 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
400 m->running_as = running_as;
401 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
403 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
405 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;
406 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
408 r = manager_default_environment(m);
412 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
416 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
420 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
424 r = hashmap_ensure_allocated(&m->watch_pids, trivial_hash_func, trivial_compare_func);
428 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
432 r = sd_event_default(&m->event);
436 r = sd_event_add_defer(m->event, manager_dispatch_run_queue, m, &m->run_queue_event_source);
440 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
444 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
448 r = manager_setup_signals(m);
452 r = manager_setup_cgroup(m);
456 r = manager_setup_time_change(m);
460 m->udev = udev_new();
466 /* Note that we set up neither kdbus, nor the notify fd
467 * here. We do that after deserialization, since they might
468 * have gotten serialized across the reexec. */
470 m->taint_usr = dir_is_empty("/usr") > 0;
480 static int manager_setup_notify(Manager *m) {
483 struct sockaddr_un un;
485 .sa.sa_family = AF_UNIX,
489 if (m->notify_fd < 0) {
490 _cleanup_close_ int fd = -1;
492 /* First free all secondary fields */
493 free(m->notify_socket);
494 m->notify_socket = NULL;
495 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
497 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
499 log_error("Failed to allocate notification socket: %m");
503 if (getpid() != 1 || detect_container(NULL) > 0)
504 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%" PRIx64, random_u64());
506 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
507 sa.un.sun_path[0] = 0;
509 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
511 log_error("bind() failed: %m");
515 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
517 log_error("SO_PASSCRED failed: %m");
521 sa.un.sun_path[0] = '@';
522 m->notify_socket = strdup(sa.un.sun_path);
523 if (!m->notify_socket)
529 log_debug("Using notification socket %s", m->notify_socket);
532 if (!m->notify_event_source) {
533 r = sd_event_add_io(m->event, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m, &m->notify_event_source);
535 log_error("Failed to allocate notify event source: %s", strerror(-r));
539 /* Process signals a bit earlier than SIGCHLD, so that we can
540 * still identify to which service an exit message belongs */
541 r = sd_event_source_set_priority(m->notify_event_source, -7);
543 log_error("Failed to set priority of notify event source: %s", strerror(-r));
551 static int manager_setup_kdbus(Manager *m) {
553 _cleanup_free_ char *p = NULL;
559 if (m->kdbus_fd >= 0)
562 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
563 if (m->kdbus_fd < 0) {
564 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
568 log_debug("Successfully set up kdbus on %s", p);
570 /* Create the namespace directory here, so that the contents
571 * of that directory is not visible to non-root users. This is
572 * necessary to ensure that users cannot get access to busses
573 * of virtualized users when no UID namespacing is used. */
574 if (m->running_as == SYSTEMD_SYSTEM)
575 mkdir_p_label("/dev/kdbus/ns", 0700);
581 static int manager_connect_bus(Manager *m, bool reexecuting) {
582 bool try_bus_connect;
589 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
591 /* Try to connect to the busses, if possible. */
592 return bus_init(m, try_bus_connect);
595 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
601 while ((u = m->cleanup_queue)) {
602 assert(u->in_cleanup_queue);
612 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
613 GC_OFFSET_UNSURE, /* No clue */
614 GC_OFFSET_GOOD, /* We still need this unit */
615 GC_OFFSET_BAD, /* We don't need this unit anymore */
619 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
626 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
627 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
628 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
631 if (u->in_cleanup_queue)
634 if (unit_check_gc(u))
637 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
641 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
642 unit_gc_sweep(other, gc_marker);
644 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
647 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
654 /* We were unable to find anything out about this entry, so
655 * let's investigate it later */
656 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
657 unit_add_to_gc_queue(u);
661 /* We definitely know that this one is not useful anymore, so
662 * let's mark it for deletion */
663 u->gc_marker = gc_marker + GC_OFFSET_BAD;
664 unit_add_to_cleanup_queue(u);
668 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
671 static unsigned manager_dispatch_gc_queue(Manager *m) {
678 /* log_debug("Running GC..."); */
680 m->gc_marker += _GC_OFFSET_MAX;
681 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
684 gc_marker = m->gc_marker;
686 while ((u = m->gc_queue)) {
687 assert(u->in_gc_queue);
689 unit_gc_sweep(u, gc_marker);
691 LIST_REMOVE(gc_queue, m->gc_queue, u);
692 u->in_gc_queue = false;
696 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
697 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
698 log_debug_unit(u->id, "Collecting %s", u->id);
699 u->gc_marker = gc_marker + GC_OFFSET_BAD;
700 unit_add_to_cleanup_queue(u);
704 m->n_in_gc_queue = 0;
709 static void manager_clear_jobs_and_units(Manager *m) {
714 while ((u = hashmap_first(m->units)))
717 manager_dispatch_cleanup_queue(m);
719 assert(!m->load_queue);
720 assert(!m->run_queue);
721 assert(!m->dbus_unit_queue);
722 assert(!m->dbus_job_queue);
723 assert(!m->cleanup_queue);
724 assert(!m->gc_queue);
726 assert(hashmap_isempty(m->jobs));
727 assert(hashmap_isempty(m->units));
730 m->n_running_jobs = 0;
733 void manager_free(Manager *m) {
739 manager_clear_jobs_and_units(m);
741 for (c = 0; c < _UNIT_TYPE_MAX; c++)
742 if (unit_vtable[c]->shutdown)
743 unit_vtable[c]->shutdown(m);
745 /* If we reexecute ourselves, we keep the root cgroup
747 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
749 manager_undo_generators(m);
753 hashmap_free(m->units);
754 hashmap_free(m->jobs);
755 hashmap_free(m->watch_pids);
756 hashmap_free(m->watch_bus);
758 sd_event_source_unref(m->signal_event_source);
759 sd_event_source_unref(m->notify_event_source);
760 sd_event_source_unref(m->time_change_event_source);
761 sd_event_source_unref(m->jobs_in_progress_event_source);
762 sd_event_source_unref(m->idle_pipe_event_source);
763 sd_event_source_unref(m->run_queue_event_source);
765 if (m->signal_fd >= 0)
766 close_nointr_nofail(m->signal_fd);
767 if (m->notify_fd >= 0)
768 close_nointr_nofail(m->notify_fd);
769 if (m->time_change_fd >= 0)
770 close_nointr_nofail(m->time_change_fd);
771 if (m->kdbus_fd >= 0)
772 close_nointr_nofail(m->kdbus_fd);
774 manager_close_idle_pipe(m);
777 sd_event_unref(m->event);
779 free(m->notify_socket);
781 lookup_paths_free(&m->lookup_paths);
782 strv_free(m->environment);
784 hashmap_free(m->cgroup_unit);
785 set_free_free(m->unit_path_cache);
787 free(m->switch_root);
788 free(m->switch_root_init);
790 for (i = 0; i < RLIMIT_NLIMITS; i++)
793 assert(hashmap_isempty(m->units_requiring_mounts_for));
794 hashmap_free(m->units_requiring_mounts_for);
799 int manager_enumerate(Manager *m) {
805 /* Let's ask every type to load all units from disk/kernel
806 * that it might know */
807 for (c = 0; c < _UNIT_TYPE_MAX; c++)
808 if (unit_vtable[c]->enumerate) {
809 q = unit_vtable[c]->enumerate(m);
814 manager_dispatch_load_queue(m);
818 static int manager_coldplug(Manager *m) {
826 /* Then, let's set up their initial state. */
827 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
833 if ((q = unit_coldplug(u)) < 0)
840 static void manager_build_unit_path_cache(Manager *m) {
842 _cleanup_free_ DIR *d = NULL;
847 set_free_free(m->unit_path_cache);
849 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
850 if (!m->unit_path_cache) {
851 log_error("Failed to allocate unit path cache.");
855 /* This simply builds a list of files we know exist, so that
856 * we don't always have to go to disk */
858 STRV_FOREACH(i, m->lookup_paths.unit_path) {
864 log_error("Failed to open directory %s: %m", *i);
868 while ((de = readdir(d))) {
871 if (ignore_file(de->d_name))
874 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
880 r = set_consume(m->unit_path_cache, p);
892 log_error("Failed to build unit path cache: %s", strerror(-r));
894 set_free_free(m->unit_path_cache);
895 m->unit_path_cache = NULL;
899 static int manager_distribute_fds(Manager *m, FDSet *fds) {
906 HASHMAP_FOREACH(u, m->units, i) {
908 if (fdset_size(fds) <= 0)
911 if (UNIT_VTABLE(u)->distribute_fds) {
912 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
921 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
926 dual_timestamp_get(&m->generators_start_timestamp);
927 manager_run_generators(m);
928 dual_timestamp_get(&m->generators_finish_timestamp);
930 r = lookup_paths_init(
931 &m->lookup_paths, m->running_as, true,
932 m->generator_unit_path,
933 m->generator_unit_path_early,
934 m->generator_unit_path_late);
938 manager_build_unit_path_cache(m);
940 /* If we will deserialize make sure that during enumeration
941 * this is already known, so we increase the counter here
946 /* First, enumerate what we can from all config files */
947 dual_timestamp_get(&m->units_load_start_timestamp);
948 r = manager_enumerate(m);
949 dual_timestamp_get(&m->units_load_finish_timestamp);
951 /* Second, deserialize if there is something to deserialize */
953 q = manager_deserialize(m, serialization, fds);
958 /* Any fds left? Find some unit which wants them. This is
959 * useful to allow container managers to pass some file
960 * descriptors to us pre-initialized. This enables
961 * socket-based activation of entire containers. */
962 if (fdset_size(fds) > 0) {
963 q = manager_distribute_fds(m, fds);
968 /* We might have deserialized the notify fd, but if we didn't
969 * then let's create the bus now */
970 manager_setup_notify(m);
972 /* We might have deserialized the kdbus control fd, but if we
973 * didn't, then let's create the bus now. */
974 manager_setup_kdbus(m);
975 manager_connect_bus(m, !!serialization);
977 /* Third, fire things up! */
978 q = manager_coldplug(m);
983 assert(m->n_reloading > 0);
986 /* Let's wait for the UnitNew/JobNew messages being
987 * sent, before we notify that the reload is
989 m->send_reloading_done = true;
995 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1000 assert(type < _JOB_TYPE_MAX);
1002 assert(mode < _JOB_MODE_MAX);
1004 if (mode == JOB_ISOLATE && type != JOB_START) {
1005 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1009 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1010 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1014 log_debug_unit(unit->id,
1015 "Trying to enqueue job %s/%s/%s", unit->id,
1016 job_type_to_string(type), job_mode_to_string(mode));
1018 job_type_collapse(&type, unit);
1020 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1024 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1025 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1026 mode == JOB_IGNORE_DEPENDENCIES, e);
1030 if (mode == JOB_ISOLATE) {
1031 r = transaction_add_isolate_jobs(tr, m);
1036 r = transaction_activate(tr, m, mode, e);
1040 log_debug_unit(unit->id,
1041 "Enqueued job %s/%s as %u", unit->id,
1042 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1045 *_ret = tr->anchor_job;
1047 transaction_free(tr);
1051 transaction_abort(tr);
1052 transaction_free(tr);
1056 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1061 assert(type < _JOB_TYPE_MAX);
1063 assert(mode < _JOB_MODE_MAX);
1065 r = manager_load_unit(m, name, NULL, NULL, &unit);
1069 return manager_add_job(m, type, unit, mode, override, e, _ret);
1072 Job *manager_get_job(Manager *m, uint32_t id) {
1075 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1078 Unit *manager_get_unit(Manager *m, const char *name) {
1082 return hashmap_get(m->units, name);
1085 unsigned manager_dispatch_load_queue(Manager *m) {
1091 /* Make sure we are not run recursively */
1092 if (m->dispatching_load_queue)
1095 m->dispatching_load_queue = true;
1097 /* Dispatches the load queue. Takes a unit from the queue and
1098 * tries to load its data until the queue is empty */
1100 while ((u = m->load_queue)) {
1101 assert(u->in_load_queue);
1107 m->dispatching_load_queue = false;
1111 int manager_load_unit_prepare(
1123 assert(name || path);
1125 /* This will prepare the unit for loading, but not actually
1126 * load anything from disk. */
1128 if (path && !is_path(path))
1129 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1132 name = basename(path);
1134 t = unit_name_to_type(name);
1136 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1137 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1139 ret = manager_get_unit(m, name);
1145 ret = unit_new(m, unit_vtable[t]->object_size);
1150 ret->fragment_path = strdup(path);
1151 if (!ret->fragment_path) {
1157 r = unit_add_name(ret, name);
1163 unit_add_to_load_queue(ret);
1164 unit_add_to_dbus_queue(ret);
1165 unit_add_to_gc_queue(ret);
1173 int manager_load_unit(
1184 /* This will load the service information files, but not actually
1185 * start any services or anything. */
1187 r = manager_load_unit_prepare(m, name, path, e, _ret);
1191 manager_dispatch_load_queue(m);
1194 *_ret = unit_follow_merge(*_ret);
1199 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1206 HASHMAP_FOREACH(j, s->jobs, i)
1207 job_dump(j, f, prefix);
1210 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1218 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1220 unit_dump(u, f, prefix);
1223 void manager_clear_jobs(Manager *m) {
1228 while ((j = hashmap_first(m->jobs)))
1229 /* No need to recurse. We're cancelling all jobs. */
1230 job_finish_and_invalidate(j, JOB_CANCELED, false);
1233 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1234 Manager *m = userdata;
1240 while ((j = m->run_queue)) {
1241 assert(j->installed);
1242 assert(j->in_run_queue);
1244 job_run_and_invalidate(j);
1247 if (m->n_running_jobs > 0)
1248 manager_watch_jobs_in_progress(m);
1250 if (m->n_on_console > 0)
1251 manager_watch_idle_pipe(m);
1256 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1263 if (m->dispatching_dbus_queue)
1266 m->dispatching_dbus_queue = true;
1268 while ((u = m->dbus_unit_queue)) {
1269 assert(u->in_dbus_queue);
1271 bus_unit_send_change_signal(u);
1275 while ((j = m->dbus_job_queue)) {
1276 assert(j->in_dbus_queue);
1278 bus_job_send_change_signal(j);
1282 m->dispatching_dbus_queue = false;
1284 if (m->send_reloading_done) {
1285 m->send_reloading_done = false;
1287 bus_manager_send_reloading(m, false);
1290 if (m->queued_message)
1291 bus_send_queued_message(m);
1296 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1297 Manager *m = userdata;
1301 assert(m->notify_fd == fd);
1303 if (revents != EPOLLIN) {
1304 log_warning("Got unexpected poll event for notify fd.");
1310 struct iovec iovec = {
1312 .iov_len = sizeof(buf)-1,
1316 struct cmsghdr cmsghdr;
1317 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1320 struct msghdr msghdr = {
1323 .msg_control = &control,
1324 .msg_controllen = sizeof(control),
1326 struct ucred *ucred;
1328 _cleanup_strv_free_ char **tags = NULL;
1330 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1335 if (errno == EAGAIN || errno == EINTR)
1341 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1342 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1343 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1344 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1345 log_warning("Received notify message without credentials. Ignoring.");
1349 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1351 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1353 u = manager_get_unit_by_pid(m, ucred->pid);
1355 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1360 assert((size_t) n < sizeof(buf));
1362 tags = strv_split(buf, "\n\r");
1366 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1368 if (UNIT_VTABLE(u)->notify_message)
1369 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1375 static int manager_dispatch_sigchld(Manager *m) {
1382 /* First we call waitd() for a PID and do not reap the
1383 * zombie. That way we can still access /proc/$PID for
1384 * it while it is a zombie. */
1385 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1387 if (errno == ECHILD)
1399 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1400 _cleanup_free_ char *name = NULL;
1402 get_process_comm(si.si_pid, &name);
1403 log_debug("Got SIGCHLD for process "PID_FMT" (%s)", si.si_pid, strna(name));
1406 /* And now figure out the unit this belongs to */
1407 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1409 u = manager_get_unit_by_pid(m, si.si_pid);
1411 /* And now, we actually reap the zombie. */
1412 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1419 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1422 log_debug("Child %lu died (code=%s, status=%i/%s)",
1423 (long unsigned) si.si_pid,
1424 sigchld_code_to_string(si.si_code),
1426 strna(si.si_code == CLD_EXITED
1427 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1428 : signal_to_string(si.si_status)));
1433 log_debug_unit(u->id,
1434 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1436 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1437 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1443 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1444 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1447 log_debug_unit(name, "Activating special unit %s", name);
1449 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1451 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1456 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1457 Manager *m = userdata;
1459 struct signalfd_siginfo sfsi;
1460 bool sigchld = false;
1463 assert(m->signal_fd == fd);
1465 if (revents != EPOLLIN) {
1466 log_warning("Got unexpected events from signal file descriptor.");
1471 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1472 if (n != sizeof(sfsi)) {
1477 if (errno == EINTR || errno == EAGAIN)
1483 if (sfsi.ssi_pid > 0) {
1484 _cleanup_free_ char *p = NULL;
1486 get_process_comm(sfsi.ssi_pid, &p);
1488 log_full(sfsi.ssi_signo == SIGCHLD ||
1489 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1490 ? LOG_DEBUG : LOG_INFO,
1491 "Received SIG%s from PID "PID_FMT" (%s).",
1492 signal_to_string(sfsi.ssi_signo),
1493 sfsi.ssi_pid, strna(p));
1495 log_full(sfsi.ssi_signo == SIGCHLD ||
1496 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1497 ? LOG_DEBUG : LOG_INFO,
1499 signal_to_string(sfsi.ssi_signo));
1501 switch (sfsi.ssi_signo) {
1508 if (m->running_as == SYSTEMD_SYSTEM) {
1509 /* This is for compatibility with the
1510 * original sysvinit */
1511 m->exit_code = MANAGER_REEXECUTE;
1518 if (m->running_as == SYSTEMD_SYSTEM) {
1519 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1523 /* Run the exit target if there is one, if not, just exit. */
1524 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1525 m->exit_code = MANAGER_EXIT;
1532 if (m->running_as == SYSTEMD_SYSTEM)
1533 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1535 /* This is a nop on non-init */
1539 if (m->running_as == SYSTEMD_SYSTEM)
1540 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1542 /* This is a nop on non-init */
1548 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1550 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1551 log_info("Trying to reconnect to bus...");
1555 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1556 log_info("Loading D-Bus service...");
1557 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1564 _cleanup_free_ char *dump = NULL;
1565 _cleanup_fclose_ FILE *f = NULL;
1568 f = open_memstream(&dump, &size);
1570 log_warning("Failed to allocate memory stream.");
1574 manager_dump_units(m, f, "\t");
1575 manager_dump_jobs(m, f, "\t");
1578 log_warning("Failed to write status stream");
1582 log_dump(LOG_INFO, dump);
1587 m->exit_code = MANAGER_RELOAD;
1592 /* Starting SIGRTMIN+0 */
1593 static const char * const target_table[] = {
1594 [0] = SPECIAL_DEFAULT_TARGET,
1595 [1] = SPECIAL_RESCUE_TARGET,
1596 [2] = SPECIAL_EMERGENCY_TARGET,
1597 [3] = SPECIAL_HALT_TARGET,
1598 [4] = SPECIAL_POWEROFF_TARGET,
1599 [5] = SPECIAL_REBOOT_TARGET,
1600 [6] = SPECIAL_KEXEC_TARGET
1603 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1604 static const ManagerExitCode code_table[] = {
1606 [1] = MANAGER_POWEROFF,
1607 [2] = MANAGER_REBOOT,
1611 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1612 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1613 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1614 manager_start_target(m, target_table[idx],
1615 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1619 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1620 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1621 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1625 switch (sfsi.ssi_signo - SIGRTMIN) {
1628 log_debug("Enabling showing of status.");
1629 manager_set_show_status(m, true);
1633 log_debug("Disabling showing of status.");
1634 manager_set_show_status(m, false);
1638 log_set_max_level(LOG_DEBUG);
1639 log_notice("Setting log level to debug.");
1643 log_set_max_level(LOG_INFO);
1644 log_notice("Setting log level to info.");
1648 if (m->running_as == SYSTEMD_USER) {
1649 m->exit_code = MANAGER_EXIT;
1653 /* This is a nop on init */
1657 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1658 log_notice("Setting log target to journal-or-kmsg.");
1662 log_set_target(LOG_TARGET_CONSOLE);
1663 log_notice("Setting log target to console.");
1667 log_set_target(LOG_TARGET_KMSG);
1668 log_notice("Setting log target to kmsg.");
1672 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1673 log_notice("Setting log target to syslog-or-kmsg.");
1677 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1684 manager_dispatch_sigchld(m);
1689 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1690 Manager *m = userdata;
1695 assert(m->time_change_fd == fd);
1697 log_struct(LOG_INFO,
1698 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1699 "MESSAGE=Time has been changed",
1702 /* Restart the watch */
1703 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1705 close_nointr_nofail(m->time_change_fd);
1706 m->time_change_fd = -1;
1708 manager_setup_time_change(m);
1710 HASHMAP_FOREACH(u, m->units, i)
1711 if (UNIT_VTABLE(u)->time_change)
1712 UNIT_VTABLE(u)->time_change(u);
1717 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1718 Manager *m = userdata;
1721 assert(m->idle_pipe[2] == fd);
1723 m->no_console_output = m->n_on_console > 0;
1725 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1726 manager_close_idle_pipe(m);
1731 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1732 Manager *m = userdata;
1736 manager_print_jobs_in_progress(m);
1740 int manager_loop(Manager *m) {
1743 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1746 m->exit_code = MANAGER_RUNNING;
1748 /* Release the path cache */
1749 set_free_free(m->unit_path_cache);
1750 m->unit_path_cache = NULL;
1752 manager_check_finished(m);
1754 /* There might still be some zombies hanging around from
1755 * before we were exec()'ed. Let's reap them. */
1756 r = manager_dispatch_sigchld(m);
1760 while (m->exit_code == MANAGER_RUNNING) {
1763 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1766 if (!ratelimit_test(&rl)) {
1767 /* Yay, something is going seriously wrong, pause a little */
1768 log_warning("Looping too fast. Throttling execution a little.");
1773 if (manager_dispatch_load_queue(m) > 0)
1776 if (manager_dispatch_gc_queue(m) > 0)
1779 if (manager_dispatch_cleanup_queue(m) > 0)
1782 if (manager_dispatch_cgroup_queue(m) > 0)
1785 if (manager_dispatch_dbus_queue(m) > 0)
1788 /* Sleep for half the watchdog time */
1789 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1790 wait_usec = m->runtime_watchdog / 2;
1794 wait_usec = (usec_t) -1;
1796 r = sd_event_run(m->event, wait_usec);
1798 log_error("Failed to run event loop: %s", strerror(-r));
1803 return m->exit_code;
1806 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1807 _cleanup_free_ char *n = NULL;
1815 r = unit_name_from_dbus_path(s, &n);
1819 r = manager_load_unit(m, n, NULL, e, &u);
1828 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1838 p = startswith(s, "/org/freedesktop/systemd1/job/");
1842 r = safe_atou(p, &id);
1846 j = manager_get_job(m, id);
1855 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1861 audit_fd = get_audit_fd();
1865 /* Don't generate audit events if the service was already
1866 * started and we're just deserializing */
1867 if (m->n_reloading > 0)
1870 if (m->running_as != SYSTEMD_SYSTEM)
1873 if (u->type != UNIT_SERVICE)
1876 p = unit_name_to_prefix_and_instance(u->id);
1878 log_error_unit(u->id,
1879 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1883 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1884 if (errno == EPERM) {
1885 /* We aren't allowed to send audit messages?
1886 * Then let's not retry again. */
1889 log_warning("Failed to send audit message: %m");
1897 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1899 union sockaddr_union sa;
1901 char *message = NULL;
1903 /* Don't generate plymouth events if the service was already
1904 * started and we're just deserializing */
1905 if (m->n_reloading > 0)
1908 if (m->running_as != SYSTEMD_SYSTEM)
1911 if (detect_container(NULL) > 0)
1914 if (u->type != UNIT_SERVICE &&
1915 u->type != UNIT_MOUNT &&
1916 u->type != UNIT_SWAP)
1919 /* We set SOCK_NONBLOCK here so that we rather drop the
1920 * message then wait for plymouth */
1921 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1923 log_error("socket() failed: %m");
1928 sa.sa.sa_family = AF_UNIX;
1929 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1930 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1932 if (errno != EPIPE &&
1935 errno != ECONNREFUSED &&
1936 errno != ECONNRESET &&
1937 errno != ECONNABORTED)
1938 log_error("connect() failed: %m");
1943 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1949 if (write(fd, message, n + 1) != n + 1) {
1951 if (errno != EPIPE &&
1954 errno != ECONNREFUSED &&
1955 errno != ECONNRESET &&
1956 errno != ECONNABORTED)
1957 log_error("Failed to write Plymouth message: %m");
1964 close_nointr_nofail(fd);
1969 void manager_dispatch_bus_name_owner_changed(
1972 const char* old_owner,
1973 const char *new_owner) {
1980 u = hashmap_get(m->watch_bus, name);
1984 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1987 int manager_open_serialization(Manager *m, FILE **_f) {
1988 _cleanup_free_ char *path = NULL;
1994 if (m->running_as == SYSTEMD_SYSTEM)
1995 asprintf(&path, "/run/systemd/dump-"PID_FMT"-XXXXXX", getpid());
1997 asprintf(&path, "/tmp/systemd-dump-"PID_FMT"-XXXXXX", getpid());
2002 RUN_WITH_UMASK(0077) {
2003 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2010 log_debug("Serializing state to %s", path);
2012 f = fdopen(fd, "w+");
2014 close_nointr_nofail(fd);
2023 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2036 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2037 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2038 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2039 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2041 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2042 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2043 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2044 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2047 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2048 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2049 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2050 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2051 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2052 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2053 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2054 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2057 if (!switching_root) {
2058 STRV_FOREACH(e, m->environment) {
2059 _cleanup_free_ char *ce;
2065 fprintf(f, "env=%s\n", *e);
2069 if (m->notify_fd >= 0) {
2072 copy = fdset_put_dup(fds, m->notify_fd);
2076 fprintf(f, "notify-fd=%i\n", copy);
2077 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2080 if (m->kdbus_fd >= 0) {
2083 copy = fdset_put_dup(fds, m->kdbus_fd);
2087 fprintf(f, "kdbus-fd=%i\n", copy);
2090 bus_serialize(m, f);
2094 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2098 if (!unit_can_serialize(u))
2105 r = unit_serialize(u, f, fds, !switching_root);
2112 assert(m->n_reloading > 0);
2118 r = bus_fdset_add_all(m, fds);
2125 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2131 log_debug("Deserializing state...");
2136 char line[LINE_MAX], *l;
2138 if (!fgets(line, sizeof(line), f)) {
2153 if (startswith(l, "current-job-id=")) {
2156 if (safe_atou32(l+15, &id) < 0)
2157 log_debug("Failed to parse current job id value %s", l+15);
2159 m->current_job_id = MAX(m->current_job_id, id);
2161 } else if (startswith(l, "n-installed-jobs=")) {
2164 if (safe_atou32(l+17, &n) < 0)
2165 log_debug("Failed to parse installed jobs counter %s", l+17);
2167 m->n_installed_jobs += n;
2169 } else if (startswith(l, "n-failed-jobs=")) {
2172 if (safe_atou32(l+14, &n) < 0)
2173 log_debug("Failed to parse failed jobs counter %s", l+14);
2175 m->n_failed_jobs += n;
2177 } else if (startswith(l, "taint-usr=")) {
2180 b = parse_boolean(l+10);
2182 log_debug("Failed to parse taint /usr flag %s", l+10);
2184 m->taint_usr = m->taint_usr || b;
2186 } else if (startswith(l, "firmware-timestamp="))
2187 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2188 else if (startswith(l, "loader-timestamp="))
2189 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2190 else if (startswith(l, "kernel-timestamp="))
2191 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2192 else if (startswith(l, "initrd-timestamp="))
2193 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2194 else if (startswith(l, "userspace-timestamp="))
2195 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2196 else if (startswith(l, "finish-timestamp="))
2197 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2198 else if (startswith(l, "security-start-timestamp="))
2199 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2200 else if (startswith(l, "security-finish-timestamp="))
2201 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2202 else if (startswith(l, "generators-start-timestamp="))
2203 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2204 else if (startswith(l, "generators-finish-timestamp="))
2205 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2206 else if (startswith(l, "units-load-start-timestamp="))
2207 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2208 else if (startswith(l, "units-load-finish-timestamp="))
2209 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2210 else if (startswith(l, "env=")) {
2211 _cleanup_free_ char *uce = NULL;
2214 uce = cunescape(l+4);
2220 e = strv_env_set(m->environment, uce);
2226 strv_free(m->environment);
2229 } else if (startswith(l, "notify-fd=")) {
2232 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2233 log_debug("Failed to parse notify fd: %s", l + 10);
2235 if (m->notify_fd >= 0) {
2236 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2237 close_nointr_nofail(m->notify_fd);
2240 m->notify_fd = fdset_remove(fds, fd);
2243 } else if (startswith(l, "notify-socket=")) {
2252 free(m->notify_socket);
2253 m->notify_socket = n;
2255 } else if (startswith(l, "kdbus-fd=")) {
2258 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2259 log_debug("Failed to parse kdbus fd: %s", l + 9);
2261 if (m->kdbus_fd >= 0)
2262 close_nointr_nofail(m->kdbus_fd);
2264 m->kdbus_fd = fdset_remove(fds, fd);
2267 } else if (bus_deserialize_item(m, l) == 0)
2268 log_debug("Unknown serialization item '%s'", l);
2273 char name[UNIT_NAME_MAX+2];
2276 if (!fgets(name, sizeof(name), f)) {
2287 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2291 r = unit_deserialize(u, f, fds);
2300 assert(m->n_reloading > 0);
2306 int manager_reload(Manager *m) {
2308 _cleanup_fclose_ FILE *f = NULL;
2309 _cleanup_fdset_free_ FDSet *fds = NULL;
2313 r = manager_open_serialization(m, &f);
2318 bus_manager_send_reloading(m, true);
2326 r = manager_serialize(m, f, fds, false);
2332 if (fseeko(f, 0, SEEK_SET) < 0) {
2337 /* From here on there is no way back. */
2338 manager_clear_jobs_and_units(m);
2339 manager_undo_generators(m);
2340 lookup_paths_free(&m->lookup_paths);
2342 /* Find new unit paths */
2343 manager_run_generators(m);
2345 q = lookup_paths_init(
2346 &m->lookup_paths, m->running_as, true,
2347 m->generator_unit_path,
2348 m->generator_unit_path_early,
2349 m->generator_unit_path_late);
2353 manager_build_unit_path_cache(m);
2355 /* First, enumerate what we can from all config files */
2356 q = manager_enumerate(m);
2360 /* Second, deserialize our stored data */
2361 q = manager_deserialize(m, f, fds);
2368 /* Re-register notify_fd as event source */
2369 q = manager_setup_notify(m);
2373 /* Third, fire things up! */
2374 q = manager_coldplug(m);
2378 assert(m->n_reloading > 0);
2381 m->send_reloading_done = true;
2386 static bool manager_is_booting_or_shutting_down(Manager *m) {
2391 /* Is the initial job still around? */
2392 if (manager_get_job(m, m->default_unit_job_id))
2395 /* Is there a job for the shutdown target? */
2396 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2403 bool manager_is_reloading_or_reexecuting(Manager *m) {
2406 return m->n_reloading != 0;
2409 void manager_reset_failed(Manager *m) {
2415 HASHMAP_FOREACH(u, m->units, i)
2416 unit_reset_failed(u);
2419 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2425 /* Returns true if the unit is inactive or going down */
2426 u = manager_get_unit(m, name);
2430 return unit_inactive_or_pending(u);
2433 void manager_check_finished(Manager *m) {
2434 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2435 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2439 if (m->n_running_jobs == 0)
2440 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2442 if (hashmap_size(m->jobs) > 0) {
2443 if (m->jobs_in_progress_event_source)
2444 sd_event_source_set_time(m->jobs_in_progress_event_source, JOBS_IN_PROGRESS_PERIOD_SEC);
2448 /* Notify Type=idle units that we are done now */
2449 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2450 manager_close_idle_pipe(m);
2452 /* Turn off confirm spawn now */
2453 m->confirm_spawn = false;
2455 if (dual_timestamp_is_set(&m->finish_timestamp))
2458 dual_timestamp_get(&m->finish_timestamp);
2460 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2462 /* Note that m->kernel_usec.monotonic is always at 0,
2463 * and m->firmware_usec.monotonic and
2464 * m->loader_usec.monotonic should be considered
2465 * negative values. */
2467 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2468 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2469 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2470 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2472 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2474 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2475 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2477 if (!log_on_console())
2478 log_struct(LOG_INFO,
2479 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2480 "KERNEL_USEC="USEC_FMT, kernel_usec,
2481 "INITRD_USEC="USEC_FMT, initrd_usec,
2482 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2483 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2484 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2485 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2486 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2487 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2490 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2493 if (!log_on_console())
2494 log_struct(LOG_INFO,
2495 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2496 "KERNEL_USEC="USEC_FMT, kernel_usec,
2497 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2498 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2499 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2500 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2501 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2505 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2506 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2508 if (!log_on_console())
2509 log_struct(LOG_INFO,
2510 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2511 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2512 "MESSAGE=Startup finished in %s.",
2513 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2517 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2520 "READY=1\nSTATUS=Startup finished in %s.",
2521 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2524 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2535 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2536 /* systemd --system, not running --test */
2538 p = strappend("/run/systemd/", name);
2542 r = mkdir_p_label(p, 0755);
2544 log_error("Failed to create generator directory %s: %s",
2549 } else if (m->running_as == SYSTEMD_USER) {
2550 const char *s = NULL;
2552 s = getenv("XDG_RUNTIME_DIR");
2555 p = strjoin(s, "/systemd/", name, NULL);
2559 r = mkdir_p_label(p, 0755);
2561 log_error("Failed to create generator directory %s: %s",
2567 /* systemd --system --test */
2569 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2574 log_error("Failed to create generator directory %s: %m",
2585 static void trim_generator_dir(Manager *m, char **generator) {
2592 if (rmdir(*generator) >= 0) {
2600 void manager_run_generators(Manager *m) {
2601 _cleanup_closedir_ DIR *d = NULL;
2602 const char *generator_path;
2603 const char *argv[5];
2608 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2609 d = opendir(generator_path);
2611 if (errno == ENOENT)
2614 log_error("Failed to enumerate generator directory %s: %m",
2619 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2623 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2627 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2631 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2632 argv[1] = m->generator_unit_path;
2633 argv[2] = m->generator_unit_path_early;
2634 argv[3] = m->generator_unit_path_late;
2637 RUN_WITH_UMASK(0022)
2638 execute_directory(generator_path, d, (char**) argv);
2641 trim_generator_dir(m, &m->generator_unit_path);
2642 trim_generator_dir(m, &m->generator_unit_path_early);
2643 trim_generator_dir(m, &m->generator_unit_path_late);
2646 static void remove_generator_dir(Manager *m, char **generator) {
2653 strv_remove(m->lookup_paths.unit_path, *generator);
2654 rm_rf(*generator, false, true, false);
2660 void manager_undo_generators(Manager *m) {
2663 remove_generator_dir(m, &m->generator_unit_path);
2664 remove_generator_dir(m, &m->generator_unit_path_early);
2665 remove_generator_dir(m, &m->generator_unit_path_late);
2668 int manager_environment_add(Manager *m, char **minus, char **plus) {
2669 char **a = NULL, **b = NULL, **l;
2674 if (!strv_isempty(minus)) {
2675 a = strv_env_delete(l, 1, minus);
2682 if (!strv_isempty(plus)) {
2683 b = strv_env_merge(2, l, plus);
2690 if (m->environment != l)
2691 strv_free(m->environment);
2698 manager_clean_environment(m);
2699 strv_sort(m->environment);
2704 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2709 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2710 if (!default_rlimit[i])
2713 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2721 void manager_recheck_journal(Manager *m) {
2726 if (m->running_as != SYSTEMD_SYSTEM)
2729 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2730 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2731 log_close_journal();
2735 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2736 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2737 log_close_journal();
2741 /* Hmm, OK, so the socket is fully up and the service is up
2742 * too, then let's make use of the thing. */
2746 void manager_set_show_status(Manager *m, bool b) {
2749 if (m->running_as != SYSTEMD_SYSTEM)
2755 touch("/run/systemd/show-status");
2757 unlink("/run/systemd/show-status");
2760 static bool manager_get_show_status(Manager *m) {
2763 if (m->running_as != SYSTEMD_SYSTEM)
2766 if (m->no_console_output)
2772 /* If Plymouth is running make sure we show the status, so
2773 * that there's something nice to see when people press Esc */
2775 return plymouth_running();
2778 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2781 if (!manager_get_show_status(m))
2784 /* XXX We should totally drop the check for ephemeral here
2785 * and thus effectively make 'Type=idle' pointless. */
2786 if (ephemeral && m->n_on_console > 0)
2789 if (!manager_is_booting_or_shutting_down(m))
2792 va_start(ap, format);
2793 status_vprintf(status, true, ephemeral, format, ap);
2797 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2798 _cleanup_free_ char *p = NULL;
2806 p = unit_name_from_path(path, suffix);
2810 found = manager_get_unit(m, p);
2820 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2821 char p[strlen(path)+1];
2827 path_kill_slashes(p);
2829 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);