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) {
534 _cleanup_free_ char *p = NULL;
540 if (m->kdbus_fd >= 0)
543 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
544 if (m->kdbus_fd < 0) {
545 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
549 log_debug("Successfully set up kdbus on %s", p);
551 /* Create the namespace directory here, so that the contents
552 * of that directory is not visible to non-root users. This is
553 * necessary to ensure that users cannot get access to busses
554 * of virtualized users when no UID namespacing is used. */
555 if (m->running_as == SYSTEMD_SYSTEM)
556 mkdir_p_label("/dev/kdbus/ns", 0700);
562 static int manager_connect_bus(Manager *m, bool reexecuting) {
563 bool try_bus_connect;
570 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
572 /* Try to connect to the busses, if possible. */
573 return bus_init(m, try_bus_connect);
576 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
582 while ((u = m->cleanup_queue)) {
583 assert(u->in_cleanup_queue);
593 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
594 GC_OFFSET_UNSURE, /* No clue */
595 GC_OFFSET_GOOD, /* We still need this unit */
596 GC_OFFSET_BAD, /* We don't need this unit anymore */
600 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
607 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
608 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
609 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
612 if (u->in_cleanup_queue)
615 if (unit_check_gc(u))
618 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
622 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
623 unit_gc_sweep(other, gc_marker);
625 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
628 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
635 /* We were unable to find anything out about this entry, so
636 * let's investigate it later */
637 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
638 unit_add_to_gc_queue(u);
642 /* We definitely know that this one is not useful anymore, so
643 * let's mark it for deletion */
644 u->gc_marker = gc_marker + GC_OFFSET_BAD;
645 unit_add_to_cleanup_queue(u);
649 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
652 static unsigned manager_dispatch_gc_queue(Manager *m) {
659 /* log_debug("Running GC..."); */
661 m->gc_marker += _GC_OFFSET_MAX;
662 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
665 gc_marker = m->gc_marker;
667 while ((u = m->gc_queue)) {
668 assert(u->in_gc_queue);
670 unit_gc_sweep(u, gc_marker);
672 LIST_REMOVE(gc_queue, m->gc_queue, u);
673 u->in_gc_queue = false;
677 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
678 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
679 log_debug_unit(u->id, "Collecting %s", u->id);
680 u->gc_marker = gc_marker + GC_OFFSET_BAD;
681 unit_add_to_cleanup_queue(u);
685 m->n_in_gc_queue = 0;
690 static void manager_clear_jobs_and_units(Manager *m) {
695 while ((u = hashmap_first(m->units)))
698 manager_dispatch_cleanup_queue(m);
700 assert(!m->load_queue);
701 assert(!m->run_queue);
702 assert(!m->dbus_unit_queue);
703 assert(!m->dbus_job_queue);
704 assert(!m->cleanup_queue);
705 assert(!m->gc_queue);
707 assert(hashmap_isempty(m->jobs));
708 assert(hashmap_isempty(m->units));
711 m->n_running_jobs = 0;
714 void manager_free(Manager *m) {
720 manager_clear_jobs_and_units(m);
722 for (c = 0; c < _UNIT_TYPE_MAX; c++)
723 if (unit_vtable[c]->shutdown)
724 unit_vtable[c]->shutdown(m);
726 /* If we reexecute ourselves, we keep the root cgroup
728 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
730 manager_undo_generators(m);
734 hashmap_free(m->units);
735 hashmap_free(m->jobs);
736 hashmap_free(m->watch_pids);
737 hashmap_free(m->watch_bus);
739 sd_event_source_unref(m->signal_event_source);
740 sd_event_source_unref(m->notify_event_source);
741 sd_event_source_unref(m->time_change_event_source);
742 sd_event_source_unref(m->jobs_in_progress_event_source);
743 sd_event_source_unref(m->idle_pipe_event_source);
744 sd_event_source_unref(m->run_queue_event_source);
746 if (m->signal_fd >= 0)
747 close_nointr_nofail(m->signal_fd);
748 if (m->notify_fd >= 0)
749 close_nointr_nofail(m->notify_fd);
750 if (m->time_change_fd >= 0)
751 close_nointr_nofail(m->time_change_fd);
752 if (m->kdbus_fd >= 0)
753 close_nointr_nofail(m->kdbus_fd);
755 manager_close_idle_pipe(m);
758 sd_event_unref(m->event);
760 free(m->notify_socket);
762 lookup_paths_free(&m->lookup_paths);
763 strv_free(m->environment);
765 hashmap_free(m->cgroup_unit);
766 set_free_free(m->unit_path_cache);
768 free(m->switch_root);
769 free(m->switch_root_init);
771 for (i = 0; i < RLIMIT_NLIMITS; i++)
774 assert(hashmap_isempty(m->units_requiring_mounts_for));
775 hashmap_free(m->units_requiring_mounts_for);
780 int manager_enumerate(Manager *m) {
786 /* Let's ask every type to load all units from disk/kernel
787 * that it might know */
788 for (c = 0; c < _UNIT_TYPE_MAX; c++)
789 if (unit_vtable[c]->enumerate) {
790 q = unit_vtable[c]->enumerate(m);
795 manager_dispatch_load_queue(m);
799 static int manager_coldplug(Manager *m) {
807 /* Then, let's set up their initial state. */
808 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
814 if ((q = unit_coldplug(u)) < 0)
821 static void manager_build_unit_path_cache(Manager *m) {
823 _cleanup_free_ DIR *d = NULL;
828 set_free_free(m->unit_path_cache);
830 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
831 if (!m->unit_path_cache) {
832 log_error("Failed to allocate unit path cache.");
836 /* This simply builds a list of files we know exist, so that
837 * we don't always have to go to disk */
839 STRV_FOREACH(i, m->lookup_paths.unit_path) {
845 log_error("Failed to open directory %s: %m", *i);
849 while ((de = readdir(d))) {
852 if (ignore_file(de->d_name))
855 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
861 r = set_consume(m->unit_path_cache, p);
873 log_error("Failed to build unit path cache: %s", strerror(-r));
875 set_free_free(m->unit_path_cache);
876 m->unit_path_cache = NULL;
880 static int manager_distribute_fds(Manager *m, FDSet *fds) {
887 HASHMAP_FOREACH(u, m->units, i) {
889 if (fdset_size(fds) <= 0)
892 if (UNIT_VTABLE(u)->distribute_fds) {
893 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
902 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
907 dual_timestamp_get(&m->generators_start_timestamp);
908 manager_run_generators(m);
909 dual_timestamp_get(&m->generators_finish_timestamp);
911 r = lookup_paths_init(
912 &m->lookup_paths, m->running_as, true,
913 m->generator_unit_path,
914 m->generator_unit_path_early,
915 m->generator_unit_path_late);
919 manager_build_unit_path_cache(m);
921 /* If we will deserialize make sure that during enumeration
922 * this is already known, so we increase the counter here
927 /* First, enumerate what we can from all config files */
928 dual_timestamp_get(&m->units_load_start_timestamp);
929 r = manager_enumerate(m);
930 dual_timestamp_get(&m->units_load_finish_timestamp);
932 /* Second, deserialize if there is something to deserialize */
934 q = manager_deserialize(m, serialization, fds);
939 /* Any fds left? Find some unit which wants them. This is
940 * useful to allow container managers to pass some file
941 * descriptors to us pre-initialized. This enables
942 * socket-based activation of entire containers. */
943 if (fdset_size(fds) > 0) {
944 q = manager_distribute_fds(m, fds);
949 /* We might have deserialized the notify fd, but if we didn't
950 * then let's create the bus now */
951 manager_setup_notify(m);
953 /* We might have deserialized the kdbus control fd, but if we
954 * didn't, then let's create the bus now. */
955 manager_setup_kdbus(m);
956 manager_connect_bus(m, !!serialization);
958 /* Third, fire things up! */
959 q = manager_coldplug(m);
964 assert(m->n_reloading > 0);
967 /* Let's wait for the UnitNew/JobNew messages being
968 * sent, before we notify that the reload is
970 m->send_reloading_done = true;
976 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
981 assert(type < _JOB_TYPE_MAX);
983 assert(mode < _JOB_MODE_MAX);
985 if (mode == JOB_ISOLATE && type != JOB_START) {
986 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
990 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
991 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
995 log_debug_unit(unit->id,
996 "Trying to enqueue job %s/%s/%s", unit->id,
997 job_type_to_string(type), job_mode_to_string(mode));
999 job_type_collapse(&type, unit);
1001 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1005 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1006 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1007 mode == JOB_IGNORE_DEPENDENCIES, e);
1011 if (mode == JOB_ISOLATE) {
1012 r = transaction_add_isolate_jobs(tr, m);
1017 r = transaction_activate(tr, m, mode, e);
1021 log_debug_unit(unit->id,
1022 "Enqueued job %s/%s as %u", unit->id,
1023 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1026 *_ret = tr->anchor_job;
1028 transaction_free(tr);
1032 transaction_abort(tr);
1033 transaction_free(tr);
1037 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1042 assert(type < _JOB_TYPE_MAX);
1044 assert(mode < _JOB_MODE_MAX);
1046 r = manager_load_unit(m, name, NULL, NULL, &unit);
1050 return manager_add_job(m, type, unit, mode, override, e, _ret);
1053 Job *manager_get_job(Manager *m, uint32_t id) {
1056 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1059 Unit *manager_get_unit(Manager *m, const char *name) {
1063 return hashmap_get(m->units, name);
1066 unsigned manager_dispatch_load_queue(Manager *m) {
1072 /* Make sure we are not run recursively */
1073 if (m->dispatching_load_queue)
1076 m->dispatching_load_queue = true;
1078 /* Dispatches the load queue. Takes a unit from the queue and
1079 * tries to load its data until the queue is empty */
1081 while ((u = m->load_queue)) {
1082 assert(u->in_load_queue);
1088 m->dispatching_load_queue = false;
1092 int manager_load_unit_prepare(
1104 assert(name || path);
1106 /* This will prepare the unit for loading, but not actually
1107 * load anything from disk. */
1109 if (path && !is_path(path))
1110 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1113 name = basename(path);
1115 t = unit_name_to_type(name);
1117 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1118 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1120 ret = manager_get_unit(m, name);
1126 ret = unit_new(m, unit_vtable[t]->object_size);
1131 ret->fragment_path = strdup(path);
1132 if (!ret->fragment_path) {
1138 r = unit_add_name(ret, name);
1144 unit_add_to_load_queue(ret);
1145 unit_add_to_dbus_queue(ret);
1146 unit_add_to_gc_queue(ret);
1154 int manager_load_unit(
1165 /* This will load the service information files, but not actually
1166 * start any services or anything. */
1168 r = manager_load_unit_prepare(m, name, path, e, _ret);
1172 manager_dispatch_load_queue(m);
1175 *_ret = unit_follow_merge(*_ret);
1180 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1187 HASHMAP_FOREACH(j, s->jobs, i)
1188 job_dump(j, f, prefix);
1191 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1199 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1201 unit_dump(u, f, prefix);
1204 void manager_clear_jobs(Manager *m) {
1209 while ((j = hashmap_first(m->jobs)))
1210 /* No need to recurse. We're cancelling all jobs. */
1211 job_finish_and_invalidate(j, JOB_CANCELED, false);
1214 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1215 Manager *m = userdata;
1221 while ((j = m->run_queue)) {
1222 assert(j->installed);
1223 assert(j->in_run_queue);
1225 job_run_and_invalidate(j);
1228 if (m->n_running_jobs > 0)
1229 manager_watch_jobs_in_progress(m);
1231 if (m->n_on_console > 0)
1232 manager_watch_idle_pipe(m);
1237 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1244 if (m->dispatching_dbus_queue)
1247 m->dispatching_dbus_queue = true;
1249 while ((u = m->dbus_unit_queue)) {
1250 assert(u->in_dbus_queue);
1252 bus_unit_send_change_signal(u);
1256 while ((j = m->dbus_job_queue)) {
1257 assert(j->in_dbus_queue);
1259 bus_job_send_change_signal(j);
1263 m->dispatching_dbus_queue = false;
1265 if (m->send_reloading_done) {
1266 m->send_reloading_done = false;
1268 bus_manager_send_reloading(m, false);
1271 if (m->queued_message)
1272 bus_send_queued_message(m);
1277 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1278 Manager *m = userdata;
1282 assert(m->notify_fd == fd);
1284 if (revents != EPOLLIN) {
1285 log_warning("Got unexpected poll event for notify fd.");
1291 struct iovec iovec = {
1293 .iov_len = sizeof(buf)-1,
1297 struct cmsghdr cmsghdr;
1298 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1301 struct msghdr msghdr = {
1304 .msg_control = &control,
1305 .msg_controllen = sizeof(control),
1307 struct ucred *ucred;
1309 _cleanup_strv_free_ char **tags = NULL;
1311 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1316 if (errno == EAGAIN || errno == EINTR)
1322 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1323 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1324 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1325 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1326 log_warning("Received notify message without credentials. Ignoring.");
1330 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1332 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1334 u = manager_get_unit_by_pid(m, ucred->pid);
1336 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1341 assert((size_t) n < sizeof(buf));
1343 tags = strv_split(buf, "\n\r");
1347 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1349 if (UNIT_VTABLE(u)->notify_message)
1350 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1356 static int manager_dispatch_sigchld(Manager *m) {
1363 /* First we call waitd() for a PID and do not reap the
1364 * zombie. That way we can still access /proc/$PID for
1365 * it while it is a zombie. */
1366 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1368 if (errno == ECHILD)
1380 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1381 _cleanup_free_ char *name = NULL;
1383 get_process_comm(si.si_pid, &name);
1384 log_debug("Got SIGCHLD for process "PID_FMT" (%s)", si.si_pid, strna(name));
1387 /* And now figure out the unit this belongs to */
1388 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1390 u = manager_get_unit_by_pid(m, si.si_pid);
1392 /* And now, we actually reap the zombie. */
1393 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1400 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1403 log_debug("Child %lu died (code=%s, status=%i/%s)",
1404 (long unsigned) si.si_pid,
1405 sigchld_code_to_string(si.si_code),
1407 strna(si.si_code == CLD_EXITED
1408 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1409 : signal_to_string(si.si_status)));
1414 log_debug_unit(u->id,
1415 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1417 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1418 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1424 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1425 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1428 log_debug_unit(name, "Activating special unit %s", name);
1430 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1432 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1437 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1438 Manager *m = userdata;
1440 struct signalfd_siginfo sfsi;
1441 bool sigchld = false;
1444 assert(m->signal_fd == fd);
1446 if (revents != EPOLLIN) {
1447 log_warning("Got unexpected events from signal file descriptor.");
1452 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1453 if (n != sizeof(sfsi)) {
1458 if (errno == EINTR || errno == EAGAIN)
1464 if (sfsi.ssi_pid > 0) {
1465 _cleanup_free_ char *p = NULL;
1467 get_process_comm(sfsi.ssi_pid, &p);
1469 log_full(sfsi.ssi_signo == SIGCHLD ||
1470 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1471 ? LOG_DEBUG : LOG_INFO,
1472 "Received SIG%s from PID "PID_FMT" (%s).",
1473 signal_to_string(sfsi.ssi_signo),
1474 sfsi.ssi_pid, strna(p));
1476 log_full(sfsi.ssi_signo == SIGCHLD ||
1477 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1478 ? LOG_DEBUG : LOG_INFO,
1480 signal_to_string(sfsi.ssi_signo));
1482 switch (sfsi.ssi_signo) {
1489 if (m->running_as == SYSTEMD_SYSTEM) {
1490 /* This is for compatibility with the
1491 * original sysvinit */
1492 m->exit_code = MANAGER_REEXECUTE;
1499 if (m->running_as == SYSTEMD_SYSTEM) {
1500 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1504 /* Run the exit target if there is one, if not, just exit. */
1505 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1506 m->exit_code = MANAGER_EXIT;
1513 if (m->running_as == SYSTEMD_SYSTEM)
1514 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1516 /* This is a nop on non-init */
1520 if (m->running_as == SYSTEMD_SYSTEM)
1521 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1523 /* This is a nop on non-init */
1529 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1531 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1532 log_info("Trying to reconnect to bus...");
1536 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1537 log_info("Loading D-Bus service...");
1538 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1545 _cleanup_free_ char *dump = NULL;
1546 _cleanup_fclose_ FILE *f = NULL;
1549 f = open_memstream(&dump, &size);
1551 log_warning("Failed to allocate memory stream.");
1555 manager_dump_units(m, f, "\t");
1556 manager_dump_jobs(m, f, "\t");
1559 log_warning("Failed to write status stream");
1563 log_dump(LOG_INFO, dump);
1568 m->exit_code = MANAGER_RELOAD;
1573 /* Starting SIGRTMIN+0 */
1574 static const char * const target_table[] = {
1575 [0] = SPECIAL_DEFAULT_TARGET,
1576 [1] = SPECIAL_RESCUE_TARGET,
1577 [2] = SPECIAL_EMERGENCY_TARGET,
1578 [3] = SPECIAL_HALT_TARGET,
1579 [4] = SPECIAL_POWEROFF_TARGET,
1580 [5] = SPECIAL_REBOOT_TARGET,
1581 [6] = SPECIAL_KEXEC_TARGET
1584 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1585 static const ManagerExitCode code_table[] = {
1587 [1] = MANAGER_POWEROFF,
1588 [2] = MANAGER_REBOOT,
1592 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1593 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1594 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1595 manager_start_target(m, target_table[idx],
1596 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1600 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1601 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1602 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1606 switch (sfsi.ssi_signo - SIGRTMIN) {
1609 log_debug("Enabling showing of status.");
1610 manager_set_show_status(m, true);
1614 log_debug("Disabling showing of status.");
1615 manager_set_show_status(m, false);
1619 log_set_max_level(LOG_DEBUG);
1620 log_notice("Setting log level to debug.");
1624 log_set_max_level(LOG_INFO);
1625 log_notice("Setting log level to info.");
1629 if (m->running_as == SYSTEMD_USER) {
1630 m->exit_code = MANAGER_EXIT;
1634 /* This is a nop on init */
1638 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1639 log_notice("Setting log target to journal-or-kmsg.");
1643 log_set_target(LOG_TARGET_CONSOLE);
1644 log_notice("Setting log target to console.");
1648 log_set_target(LOG_TARGET_KMSG);
1649 log_notice("Setting log target to kmsg.");
1653 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1654 log_notice("Setting log target to syslog-or-kmsg.");
1658 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1665 manager_dispatch_sigchld(m);
1670 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1671 Manager *m = userdata;
1676 assert(m->time_change_fd == fd);
1678 log_struct(LOG_INFO,
1679 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1680 "MESSAGE=Time has been changed",
1683 /* Restart the watch */
1684 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1686 close_nointr_nofail(m->time_change_fd);
1687 m->time_change_fd = -1;
1689 manager_setup_time_change(m);
1691 HASHMAP_FOREACH(u, m->units, i)
1692 if (UNIT_VTABLE(u)->time_change)
1693 UNIT_VTABLE(u)->time_change(u);
1698 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1699 Manager *m = userdata;
1702 assert(m->idle_pipe[2] == fd);
1704 m->no_console_output = m->n_on_console > 0;
1706 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1707 manager_close_idle_pipe(m);
1712 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1713 Manager *m = userdata;
1717 manager_print_jobs_in_progress(m);
1721 int manager_loop(Manager *m) {
1724 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1727 m->exit_code = MANAGER_RUNNING;
1729 /* Release the path cache */
1730 set_free_free(m->unit_path_cache);
1731 m->unit_path_cache = NULL;
1733 manager_check_finished(m);
1735 /* There might still be some zombies hanging around from
1736 * before we were exec()'ed. Let's reap them. */
1737 r = manager_dispatch_sigchld(m);
1741 while (m->exit_code == MANAGER_RUNNING) {
1744 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1747 if (!ratelimit_test(&rl)) {
1748 /* Yay, something is going seriously wrong, pause a little */
1749 log_warning("Looping too fast. Throttling execution a little.");
1754 if (manager_dispatch_load_queue(m) > 0)
1757 if (manager_dispatch_gc_queue(m) > 0)
1760 if (manager_dispatch_cleanup_queue(m) > 0)
1763 if (manager_dispatch_cgroup_queue(m) > 0)
1766 if (manager_dispatch_dbus_queue(m) > 0)
1769 /* Sleep for half the watchdog time */
1770 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1771 wait_usec = m->runtime_watchdog / 2;
1775 wait_usec = (usec_t) -1;
1777 r = sd_event_run(m->event, wait_usec);
1779 log_error("Failed to run event loop: %s", strerror(-r));
1784 return m->exit_code;
1787 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1788 _cleanup_free_ char *n = NULL;
1796 r = unit_name_from_dbus_path(s, &n);
1800 r = manager_load_unit(m, n, NULL, e, &u);
1809 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1819 p = startswith(s, "/org/freedesktop/systemd1/job/");
1823 r = safe_atou(p, &id);
1827 j = manager_get_job(m, id);
1836 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1842 audit_fd = get_audit_fd();
1846 /* Don't generate audit events if the service was already
1847 * started and we're just deserializing */
1848 if (m->n_reloading > 0)
1851 if (m->running_as != SYSTEMD_SYSTEM)
1854 if (u->type != UNIT_SERVICE)
1857 p = unit_name_to_prefix_and_instance(u->id);
1859 log_error_unit(u->id,
1860 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1864 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1865 if (errno == EPERM) {
1866 /* We aren't allowed to send audit messages?
1867 * Then let's not retry again. */
1870 log_warning("Failed to send audit message: %m");
1878 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1880 union sockaddr_union sa;
1882 char *message = NULL;
1884 /* Don't generate plymouth events if the service was already
1885 * started and we're just deserializing */
1886 if (m->n_reloading > 0)
1889 if (m->running_as != SYSTEMD_SYSTEM)
1892 if (detect_container(NULL) > 0)
1895 if (u->type != UNIT_SERVICE &&
1896 u->type != UNIT_MOUNT &&
1897 u->type != UNIT_SWAP)
1900 /* We set SOCK_NONBLOCK here so that we rather drop the
1901 * message then wait for plymouth */
1902 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1904 log_error("socket() failed: %m");
1909 sa.sa.sa_family = AF_UNIX;
1910 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1911 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1913 if (errno != EPIPE &&
1916 errno != ECONNREFUSED &&
1917 errno != ECONNRESET &&
1918 errno != ECONNABORTED)
1919 log_error("connect() failed: %m");
1924 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1930 if (write(fd, message, n + 1) != n + 1) {
1932 if (errno != EPIPE &&
1935 errno != ECONNREFUSED &&
1936 errno != ECONNRESET &&
1937 errno != ECONNABORTED)
1938 log_error("Failed to write Plymouth message: %m");
1945 close_nointr_nofail(fd);
1950 void manager_dispatch_bus_name_owner_changed(
1953 const char* old_owner,
1954 const char *new_owner) {
1961 u = hashmap_get(m->watch_bus, name);
1965 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1968 int manager_open_serialization(Manager *m, FILE **_f) {
1969 _cleanup_free_ char *path = NULL;
1975 if (m->running_as == SYSTEMD_SYSTEM)
1976 asprintf(&path, "/run/systemd/dump-"PID_FMT"-XXXXXX", getpid());
1978 asprintf(&path, "/tmp/systemd-dump-"PID_FMT"-XXXXXX", getpid());
1983 RUN_WITH_UMASK(0077) {
1984 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1991 log_debug("Serializing state to %s", path);
1993 f = fdopen(fd, "w+");
1995 close_nointr_nofail(fd);
2004 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2017 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2018 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2019 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2020 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2022 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2023 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2024 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2025 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2028 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2029 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2030 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2031 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2032 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2033 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2034 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2035 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2038 if (!switching_root) {
2039 STRV_FOREACH(e, m->environment) {
2040 _cleanup_free_ char *ce;
2046 fprintf(f, "env=%s\n", *e);
2050 if (m->notify_fd >= 0) {
2053 copy = fdset_put_dup(fds, m->notify_fd);
2057 fprintf(f, "notify-fd=%i\n", copy);
2058 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2061 if (m->kdbus_fd >= 0) {
2064 copy = fdset_put_dup(fds, m->kdbus_fd);
2068 fprintf(f, "kdbus-fd=%i\n", copy);
2071 bus_serialize(m, f);
2075 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2079 if (!unit_can_serialize(u))
2086 r = unit_serialize(u, f, fds, !switching_root);
2093 assert(m->n_reloading > 0);
2099 r = bus_fdset_add_all(m, fds);
2106 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2112 log_debug("Deserializing state...");
2117 char line[LINE_MAX], *l;
2119 if (!fgets(line, sizeof(line), f)) {
2134 if (startswith(l, "current-job-id=")) {
2137 if (safe_atou32(l+15, &id) < 0)
2138 log_debug("Failed to parse current job id value %s", l+15);
2140 m->current_job_id = MAX(m->current_job_id, id);
2142 } else if (startswith(l, "n-installed-jobs=")) {
2145 if (safe_atou32(l+17, &n) < 0)
2146 log_debug("Failed to parse installed jobs counter %s", l+17);
2148 m->n_installed_jobs += n;
2150 } else if (startswith(l, "n-failed-jobs=")) {
2153 if (safe_atou32(l+14, &n) < 0)
2154 log_debug("Failed to parse failed jobs counter %s", l+14);
2156 m->n_failed_jobs += n;
2158 } else if (startswith(l, "taint-usr=")) {
2161 b = parse_boolean(l+10);
2163 log_debug("Failed to parse taint /usr flag %s", l+10);
2165 m->taint_usr = m->taint_usr || b;
2167 } else if (startswith(l, "firmware-timestamp="))
2168 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2169 else if (startswith(l, "loader-timestamp="))
2170 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2171 else if (startswith(l, "kernel-timestamp="))
2172 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2173 else if (startswith(l, "initrd-timestamp="))
2174 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2175 else if (startswith(l, "userspace-timestamp="))
2176 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2177 else if (startswith(l, "finish-timestamp="))
2178 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2179 else if (startswith(l, "security-start-timestamp="))
2180 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2181 else if (startswith(l, "security-finish-timestamp="))
2182 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2183 else if (startswith(l, "generators-start-timestamp="))
2184 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2185 else if (startswith(l, "generators-finish-timestamp="))
2186 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2187 else if (startswith(l, "units-load-start-timestamp="))
2188 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2189 else if (startswith(l, "units-load-finish-timestamp="))
2190 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2191 else if (startswith(l, "env=")) {
2192 _cleanup_free_ char *uce = NULL;
2195 uce = cunescape(l+4);
2201 e = strv_env_set(m->environment, uce);
2207 strv_free(m->environment);
2210 } else if (startswith(l, "notify-fd=")) {
2213 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2214 log_debug("Failed to parse notify fd: %s", l + 10);
2216 if (m->notify_fd >= 0) {
2217 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2218 close_nointr_nofail(m->notify_fd);
2221 m->notify_fd = fdset_remove(fds, fd);
2224 } else if (startswith(l, "notify-socket=")) {
2233 free(m->notify_socket);
2234 m->notify_socket = n;
2236 } else if (startswith(l, "kdbus-fd=")) {
2239 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2240 log_debug("Failed to parse kdbus fd: %s", l + 9);
2242 if (m->kdbus_fd >= 0)
2243 close_nointr_nofail(m->kdbus_fd);
2245 m->kdbus_fd = fdset_remove(fds, fd);
2248 } else if (bus_deserialize_item(m, l) == 0)
2249 log_debug("Unknown serialization item '%s'", l);
2254 char name[UNIT_NAME_MAX+2];
2257 if (!fgets(name, sizeof(name), f)) {
2268 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2272 r = unit_deserialize(u, f, fds);
2281 assert(m->n_reloading > 0);
2287 int manager_reload(Manager *m) {
2289 _cleanup_fclose_ FILE *f = NULL;
2290 _cleanup_fdset_free_ FDSet *fds = NULL;
2294 r = manager_open_serialization(m, &f);
2299 bus_manager_send_reloading(m, true);
2307 r = manager_serialize(m, f, fds, false);
2313 if (fseeko(f, 0, SEEK_SET) < 0) {
2318 /* From here on there is no way back. */
2319 manager_clear_jobs_and_units(m);
2320 manager_undo_generators(m);
2321 lookup_paths_free(&m->lookup_paths);
2323 /* Find new unit paths */
2324 manager_run_generators(m);
2326 q = lookup_paths_init(
2327 &m->lookup_paths, m->running_as, true,
2328 m->generator_unit_path,
2329 m->generator_unit_path_early,
2330 m->generator_unit_path_late);
2334 manager_build_unit_path_cache(m);
2336 /* First, enumerate what we can from all config files */
2337 q = manager_enumerate(m);
2341 /* Second, deserialize our stored data */
2342 q = manager_deserialize(m, f, fds);
2349 /* Re-register notify_fd as event source */
2350 q = manager_setup_notify(m);
2354 /* Third, fire things up! */
2355 q = manager_coldplug(m);
2359 assert(m->n_reloading > 0);
2362 m->send_reloading_done = true;
2367 static bool manager_is_booting_or_shutting_down(Manager *m) {
2372 /* Is the initial job still around? */
2373 if (manager_get_job(m, m->default_unit_job_id))
2376 /* Is there a job for the shutdown target? */
2377 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2384 bool manager_is_reloading_or_reexecuting(Manager *m) {
2387 return m->n_reloading != 0;
2390 void manager_reset_failed(Manager *m) {
2396 HASHMAP_FOREACH(u, m->units, i)
2397 unit_reset_failed(u);
2400 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2406 /* Returns true if the unit is inactive or going down */
2407 u = manager_get_unit(m, name);
2411 return unit_inactive_or_pending(u);
2414 void manager_check_finished(Manager *m) {
2415 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2416 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2420 if (m->n_running_jobs == 0)
2421 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2423 if (hashmap_size(m->jobs) > 0) {
2424 if (m->jobs_in_progress_event_source)
2425 sd_event_source_set_time(m->jobs_in_progress_event_source, JOBS_IN_PROGRESS_PERIOD_SEC);
2429 /* Notify Type=idle units that we are done now */
2430 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2431 manager_close_idle_pipe(m);
2433 /* Turn off confirm spawn now */
2434 m->confirm_spawn = false;
2436 if (dual_timestamp_is_set(&m->finish_timestamp))
2439 dual_timestamp_get(&m->finish_timestamp);
2441 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2443 /* Note that m->kernel_usec.monotonic is always at 0,
2444 * and m->firmware_usec.monotonic and
2445 * m->loader_usec.monotonic should be considered
2446 * negative values. */
2448 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2449 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2450 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2451 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2453 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2455 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2456 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2458 if (!log_on_console())
2459 log_struct(LOG_INFO,
2460 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2461 "KERNEL_USEC="USEC_FMT, kernel_usec,
2462 "INITRD_USEC="USEC_FMT, initrd_usec,
2463 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2464 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2465 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2466 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2467 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2468 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2471 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2474 if (!log_on_console())
2475 log_struct(LOG_INFO,
2476 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2477 "KERNEL_USEC="USEC_FMT, kernel_usec,
2478 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2479 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2480 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2481 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2482 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2486 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2487 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2489 if (!log_on_console())
2490 log_struct(LOG_INFO,
2491 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2492 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2493 "MESSAGE=Startup finished in %s.",
2494 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2498 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2501 "READY=1\nSTATUS=Startup finished in %s.",
2502 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2505 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2516 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2517 /* systemd --system, not running --test */
2519 p = strappend("/run/systemd/", name);
2523 r = mkdir_p_label(p, 0755);
2525 log_error("Failed to create generator directory %s: %s",
2530 } else if (m->running_as == SYSTEMD_USER) {
2531 const char *s = NULL;
2533 s = getenv("XDG_RUNTIME_DIR");
2536 p = strjoin(s, "/systemd/", name, NULL);
2540 r = mkdir_p_label(p, 0755);
2542 log_error("Failed to create generator directory %s: %s",
2548 /* systemd --system --test */
2550 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2555 log_error("Failed to create generator directory %s: %m",
2566 static void trim_generator_dir(Manager *m, char **generator) {
2573 if (rmdir(*generator) >= 0) {
2581 void manager_run_generators(Manager *m) {
2582 _cleanup_closedir_ DIR *d = NULL;
2583 const char *generator_path;
2584 const char *argv[5];
2589 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2590 d = opendir(generator_path);
2592 if (errno == ENOENT)
2595 log_error("Failed to enumerate generator directory %s: %m",
2600 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2604 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2608 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2612 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2613 argv[1] = m->generator_unit_path;
2614 argv[2] = m->generator_unit_path_early;
2615 argv[3] = m->generator_unit_path_late;
2618 RUN_WITH_UMASK(0022)
2619 execute_directory(generator_path, d, (char**) argv);
2622 trim_generator_dir(m, &m->generator_unit_path);
2623 trim_generator_dir(m, &m->generator_unit_path_early);
2624 trim_generator_dir(m, &m->generator_unit_path_late);
2627 static void remove_generator_dir(Manager *m, char **generator) {
2634 strv_remove(m->lookup_paths.unit_path, *generator);
2635 rm_rf(*generator, false, true, false);
2641 void manager_undo_generators(Manager *m) {
2644 remove_generator_dir(m, &m->generator_unit_path);
2645 remove_generator_dir(m, &m->generator_unit_path_early);
2646 remove_generator_dir(m, &m->generator_unit_path_late);
2649 int manager_environment_add(Manager *m, char **minus, char **plus) {
2650 char **a = NULL, **b = NULL, **l;
2655 if (!strv_isempty(minus)) {
2656 a = strv_env_delete(l, 1, minus);
2663 if (!strv_isempty(plus)) {
2664 b = strv_env_merge(2, l, plus);
2671 if (m->environment != l)
2672 strv_free(m->environment);
2678 m->environment = strv_sort(l);
2682 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2687 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2688 if (!default_rlimit[i])
2691 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2699 void manager_recheck_journal(Manager *m) {
2704 if (m->running_as != SYSTEMD_SYSTEM)
2707 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2708 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2709 log_close_journal();
2713 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2714 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2715 log_close_journal();
2719 /* Hmm, OK, so the socket is fully up and the service is up
2720 * too, then let's make use of the thing. */
2724 void manager_set_show_status(Manager *m, bool b) {
2727 if (m->running_as != SYSTEMD_SYSTEM)
2733 touch("/run/systemd/show-status");
2735 unlink("/run/systemd/show-status");
2738 static bool manager_get_show_status(Manager *m) {
2741 if (m->running_as != SYSTEMD_SYSTEM)
2744 if (m->no_console_output)
2750 /* If Plymouth is running make sure we show the status, so
2751 * that there's something nice to see when people press Esc */
2753 return plymouth_running();
2756 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2759 if (!manager_get_show_status(m))
2762 /* XXX We should totally drop the check for ephemeral here
2763 * and thus effectively make 'Type=idle' pointless. */
2764 if (ephemeral && m->n_on_console > 0)
2767 if (!manager_is_booting_or_shutting_down(m))
2770 va_start(ap, format);
2771 status_vprintf(status, true, ephemeral, format, ap);
2775 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2776 _cleanup_free_ char *p = NULL;
2784 p = unit_name_from_path(path, suffix);
2788 found = manager_get_unit(m, p);
2798 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2799 char p[strlen(path)+1];
2805 path_kill_slashes(p);
2807 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);