1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
29 #include <sys/reboot.h>
30 #include <sys/ioctl.h>
34 #include <sys/types.h>
37 #include <sys/timerfd.h>
43 #include "sd-daemon.h"
45 #include "sd-messages.h"
48 #include "transaction.h"
55 #include "ratelimit.h"
56 #include "locale-setup.h"
57 #include "mount-setup.h"
58 #include "unit-name.h"
60 #include "path-lookup.h"
62 #include "exit-status.h"
65 #include "cgroup-util.h"
66 #include "path-util.h"
68 #include "boot-timestamps.h"
70 #include "bus-errors.h"
71 #include "bus-error.h"
74 #include "dbus-unit.h"
76 #include "dbus-manager.h"
77 #include "bus-kernel.h"
79 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
80 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
82 /* Initial delay and the interval for printing status messages about running jobs */
83 #define JOBS_IN_PROGRESS_WAIT_SEC 5
84 #define JOBS_IN_PROGRESS_PERIOD_SEC 1
85 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
87 /* Where clients shall send notification messages to */
88 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
90 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
92 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
93 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
94 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
95 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
96 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
97 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
99 static int manager_watch_jobs_in_progress(Manager *m) {
102 if (m->jobs_in_progress_event_source)
105 return sd_event_add_monotonic(m->event, JOBS_IN_PROGRESS_WAIT_SEC, 0, manager_dispatch_jobs_in_progress, m, &m->jobs_in_progress_event_source);
108 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
110 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
113 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
114 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
118 p = mempset(p, ' ', pos-2);
119 p = stpcpy(p, ANSI_RED_ON);
123 if (pos > 0 && pos <= width) {
124 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
128 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
131 p = stpcpy(p, ANSI_RED_ON);
134 p = mempset(p, ' ', width-1-pos);
135 strcpy(p, ANSI_HIGHLIGHT_OFF);
139 static void manager_print_jobs_in_progress(Manager *m) {
140 _cleanup_free_ char *job_of_n = NULL;
143 unsigned counter = 0, print_nr;
144 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
149 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
151 HASHMAP_FOREACH(j, m->jobs, i)
152 if (j->state == JOB_RUNNING && counter++ == print_nr)
155 /* m->n_running_jobs must be consistent with the contents of m->jobs,
156 * so the above loop must have succeeded in finding j. */
157 assert(counter == print_nr + 1);
160 cylon_pos = m->jobs_in_progress_iteration % 14;
162 cylon_pos = 14 - cylon_pos;
163 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
165 if (m->n_running_jobs > 1)
166 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
169 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
170 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
172 m->jobs_in_progress_iteration++;
175 static int manager_watch_idle_pipe(Manager *m) {
180 if (m->idle_pipe_event_source)
183 if (m->idle_pipe[2] < 0)
186 r = sd_event_add_io(m->event, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m, &m->idle_pipe_event_source);
188 log_error("Failed to watch idle pipe: %s", strerror(-r));
195 static void manager_close_idle_pipe(Manager *m) {
198 close_pipe(m->idle_pipe);
199 close_pipe(m->idle_pipe + 2);
202 static int manager_setup_time_change(Manager *m) {
205 /* We only care for the cancellation event, hence we set the
206 * timeout to the latest possible value. */
207 struct itimerspec its = {
208 .it_value.tv_sec = TIME_T_MAX,
212 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
214 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
215 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
217 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
218 if (m->time_change_fd < 0) {
219 log_error("Failed to create timerfd: %m");
223 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
224 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
225 close_nointr_nofail(m->time_change_fd);
226 m->time_change_fd = -1;
230 r = sd_event_add_io(m->event, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m, &m->time_change_event_source);
232 log_error("Failed to create time change event source: %s", strerror(-r));
236 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
241 static int enable_special_signals(Manager *m) {
242 _cleanup_close_ int fd = -1;
246 /* Enable that we get SIGINT on control-alt-del. In containers
247 * this will fail with EPERM (older) or EINVAL (newer), so
249 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
250 log_warning("Failed to enable ctrl-alt-del handling: %m");
252 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
254 /* Support systems without virtual console */
256 log_warning("Failed to open /dev/tty0: %m");
258 /* Enable that we get SIGWINCH on kbrequest */
259 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
260 log_warning("Failed to enable kbrequest handling: %m");
266 static int manager_setup_signals(Manager *m) {
267 struct sigaction sa = {
268 .sa_handler = SIG_DFL,
269 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
276 /* We are not interested in SIGSTOP and friends. */
277 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
279 assert_se(sigemptyset(&mask) == 0);
281 sigset_add_many(&mask,
282 SIGCHLD, /* Child died */
283 SIGTERM, /* Reexecute daemon */
284 SIGHUP, /* Reload configuration */
285 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
286 SIGUSR2, /* systemd: dump status */
287 SIGINT, /* Kernel sends us this on control-alt-del */
288 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
289 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
290 SIGRTMIN+0, /* systemd: start default.target */
291 SIGRTMIN+1, /* systemd: isolate rescue.target */
292 SIGRTMIN+2, /* systemd: isolate emergency.target */
293 SIGRTMIN+3, /* systemd: start halt.target */
294 SIGRTMIN+4, /* systemd: start poweroff.target */
295 SIGRTMIN+5, /* systemd: start reboot.target */
296 SIGRTMIN+6, /* systemd: start kexec.target */
297 SIGRTMIN+13, /* systemd: Immediate halt */
298 SIGRTMIN+14, /* systemd: Immediate poweroff */
299 SIGRTMIN+15, /* systemd: Immediate reboot */
300 SIGRTMIN+16, /* systemd: Immediate kexec */
301 SIGRTMIN+20, /* systemd: enable status messages */
302 SIGRTMIN+21, /* systemd: disable status messages */
303 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
304 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
305 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
306 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
307 SIGRTMIN+27, /* systemd: set log target to console */
308 SIGRTMIN+28, /* systemd: set log target to kmsg */
309 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
311 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
313 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
314 if (m->signal_fd < 0)
317 r = sd_event_add_io(m->event, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m, &m->signal_event_source);
321 /* Process signals a bit earlier than the rest of things, but
322 * later that notify_fd processing, so that the notify
323 * processing can still figure out to which process/service a
324 * message belongs, before we reap the process. */
325 r = sd_event_source_set_priority(m->signal_event_source, -5);
329 if (m->running_as == SYSTEMD_SYSTEM)
330 return enable_special_signals(m);
335 static int manager_default_environment(Manager *m) {
338 if (m->running_as == SYSTEMD_SYSTEM) {
339 /* The system manager always starts with a clean
340 * environment for its children. It does not import
341 * the kernel or the parents exported variables.
343 * The initial passed environ is untouched to keep
344 * /proc/self/environ valid; it is used for tagging
345 * the init process inside containers. */
346 m->environment = strv_new("PATH=" DEFAULT_PATH,
349 /* Import locale variables LC_*= from configuration */
350 locale_setup(&m->environment);
352 /* The user manager passes its own environment
353 * along to its children. */
354 m->environment = strv_copy(environ);
359 strv_sort(m->environment);
364 int manager_new(SystemdRunningAs running_as, Manager **_m) {
369 assert(running_as >= 0);
370 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
372 m = new0(Manager, 1);
377 if (detect_container(NULL) <= 0)
378 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
381 m->running_as = running_as;
382 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
384 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
386 m->pin_cgroupfs_fd = m->notify_fd = m->signal_fd = m->time_change_fd = m->dev_autofs_fd = m->private_listen_fd = m->kdbus_fd = -1;
387 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
389 r = manager_default_environment(m);
393 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
397 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
401 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
405 r = hashmap_ensure_allocated(&m->watch_pids, trivial_hash_func, trivial_compare_func);
409 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
413 r = sd_event_default(&m->event);
417 r = sd_event_add_defer(m->event, manager_dispatch_run_queue, m, &m->run_queue_event_source);
421 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
425 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
429 r = manager_setup_signals(m);
433 r = manager_setup_cgroup(m);
437 r = manager_setup_time_change(m);
441 m->udev = udev_new();
447 /* Note that we set up neither kdbus, nor the notify fd
448 * here. We do that after deserialization, since they might
449 * have gotten serialized across the reexec. */
451 m->taint_usr = dir_is_empty("/usr") > 0;
461 static int manager_setup_notify(Manager *m) {
464 struct sockaddr_un un;
466 .sa.sa_family = AF_UNIX,
470 if (m->notify_fd < 0) {
471 _cleanup_close_ int fd = -1;
473 /* First free all secondary fields */
474 free(m->notify_socket);
475 m->notify_socket = NULL;
476 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
478 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
480 log_error("Failed to allocate notification socket: %m");
484 if (getpid() != 1 || detect_container(NULL) > 0)
485 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%" PRIx64, random_u64());
487 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
488 sa.un.sun_path[0] = 0;
490 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
492 log_error("bind() failed: %m");
496 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
498 log_error("SO_PASSCRED failed: %m");
502 sa.un.sun_path[0] = '@';
503 m->notify_socket = strdup(sa.un.sun_path);
504 if (!m->notify_socket)
510 log_debug("Using notification socket %s", m->notify_socket);
513 if (!m->notify_event_source) {
514 r = sd_event_add_io(m->event, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m, &m->notify_event_source);
516 log_error("Failed to allocate notify event source: %s", strerror(-r));
520 /* Process signals a bit earlier than SIGCHLD, so that we can
521 * still identify to which service an exit message belongs */
522 r = sd_event_source_set_priority(m->notify_event_source, -7);
524 log_error("Failed to set priority of notify event source: %s", strerror(-r));
532 static int manager_setup_kdbus(Manager *m) {
533 _cleanup_free_ char *p = NULL;
538 if (m->kdbus_fd >= 0)
541 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
542 if (m->kdbus_fd < 0) {
543 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
547 log_debug("Successfully set up kdbus on %s", p);
549 /* Create the namespace directory here, so that the contents
550 * of that directory is not visible to non-root users. This is
551 * necessary to ensure that users cannot get access to busses
552 * of virtualized users when no UID namespacing is used. */
553 if (m->running_as == SYSTEMD_SYSTEM)
554 mkdir_p_label("/dev/kdbus/ns", 0700);
560 static int manager_connect_bus(Manager *m, bool reexecuting) {
561 bool try_bus_connect;
568 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
570 /* Try to connect to the busses, if possible. */
571 return bus_init(m, try_bus_connect);
574 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
580 while ((u = m->cleanup_queue)) {
581 assert(u->in_cleanup_queue);
591 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
592 GC_OFFSET_UNSURE, /* No clue */
593 GC_OFFSET_GOOD, /* We still need this unit */
594 GC_OFFSET_BAD, /* We don't need this unit anymore */
598 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
605 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
606 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
607 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
610 if (u->in_cleanup_queue)
613 if (unit_check_gc(u))
616 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
620 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
621 unit_gc_sweep(other, gc_marker);
623 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
626 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
633 /* We were unable to find anything out about this entry, so
634 * let's investigate it later */
635 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
636 unit_add_to_gc_queue(u);
640 /* We definitely know that this one is not useful anymore, so
641 * let's mark it for deletion */
642 u->gc_marker = gc_marker + GC_OFFSET_BAD;
643 unit_add_to_cleanup_queue(u);
647 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
650 static unsigned manager_dispatch_gc_queue(Manager *m) {
657 /* log_debug("Running GC..."); */
659 m->gc_marker += _GC_OFFSET_MAX;
660 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
663 gc_marker = m->gc_marker;
665 while ((u = m->gc_queue)) {
666 assert(u->in_gc_queue);
668 unit_gc_sweep(u, gc_marker);
670 LIST_REMOVE(gc_queue, m->gc_queue, u);
671 u->in_gc_queue = false;
675 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
676 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
677 log_debug_unit(u->id, "Collecting %s", u->id);
678 u->gc_marker = gc_marker + GC_OFFSET_BAD;
679 unit_add_to_cleanup_queue(u);
683 m->n_in_gc_queue = 0;
688 static void manager_clear_jobs_and_units(Manager *m) {
693 while ((u = hashmap_first(m->units)))
696 manager_dispatch_cleanup_queue(m);
698 assert(!m->load_queue);
699 assert(!m->run_queue);
700 assert(!m->dbus_unit_queue);
701 assert(!m->dbus_job_queue);
702 assert(!m->cleanup_queue);
703 assert(!m->gc_queue);
705 assert(hashmap_isempty(m->jobs));
706 assert(hashmap_isempty(m->units));
709 m->n_running_jobs = 0;
712 void manager_free(Manager *m) {
718 manager_clear_jobs_and_units(m);
720 for (c = 0; c < _UNIT_TYPE_MAX; c++)
721 if (unit_vtable[c]->shutdown)
722 unit_vtable[c]->shutdown(m);
724 /* If we reexecute ourselves, we keep the root cgroup
726 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
728 manager_undo_generators(m);
732 hashmap_free(m->units);
733 hashmap_free(m->jobs);
734 hashmap_free(m->watch_pids);
735 hashmap_free(m->watch_bus);
737 sd_event_source_unref(m->signal_event_source);
738 sd_event_source_unref(m->notify_event_source);
739 sd_event_source_unref(m->time_change_event_source);
740 sd_event_source_unref(m->jobs_in_progress_event_source);
741 sd_event_source_unref(m->idle_pipe_event_source);
742 sd_event_source_unref(m->run_queue_event_source);
744 if (m->signal_fd >= 0)
745 close_nointr_nofail(m->signal_fd);
746 if (m->notify_fd >= 0)
747 close_nointr_nofail(m->notify_fd);
748 if (m->time_change_fd >= 0)
749 close_nointr_nofail(m->time_change_fd);
750 if (m->kdbus_fd >= 0)
751 close_nointr_nofail(m->kdbus_fd);
753 manager_close_idle_pipe(m);
756 sd_event_unref(m->event);
758 free(m->notify_socket);
760 lookup_paths_free(&m->lookup_paths);
761 strv_free(m->environment);
763 hashmap_free(m->cgroup_unit);
764 set_free_free(m->unit_path_cache);
766 free(m->switch_root);
767 free(m->switch_root_init);
769 for (i = 0; i < RLIMIT_NLIMITS; i++)
772 assert(hashmap_isempty(m->units_requiring_mounts_for));
773 hashmap_free(m->units_requiring_mounts_for);
778 int manager_enumerate(Manager *m) {
784 /* Let's ask every type to load all units from disk/kernel
785 * that it might know */
786 for (c = 0; c < _UNIT_TYPE_MAX; c++)
787 if (unit_vtable[c]->enumerate) {
788 q = unit_vtable[c]->enumerate(m);
793 manager_dispatch_load_queue(m);
797 static int manager_coldplug(Manager *m) {
805 /* Then, let's set up their initial state. */
806 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
812 if ((q = unit_coldplug(u)) < 0)
819 static void manager_build_unit_path_cache(Manager *m) {
821 _cleanup_free_ DIR *d = NULL;
826 set_free_free(m->unit_path_cache);
828 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
829 if (!m->unit_path_cache) {
830 log_error("Failed to allocate unit path cache.");
834 /* This simply builds a list of files we know exist, so that
835 * we don't always have to go to disk */
837 STRV_FOREACH(i, m->lookup_paths.unit_path) {
843 log_error("Failed to open directory %s: %m", *i);
847 while ((de = readdir(d))) {
850 if (ignore_file(de->d_name))
853 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
859 r = set_consume(m->unit_path_cache, p);
871 log_error("Failed to build unit path cache: %s", strerror(-r));
873 set_free_free(m->unit_path_cache);
874 m->unit_path_cache = NULL;
878 static int manager_distribute_fds(Manager *m, FDSet *fds) {
885 HASHMAP_FOREACH(u, m->units, i) {
887 if (fdset_size(fds) <= 0)
890 if (UNIT_VTABLE(u)->distribute_fds) {
891 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
900 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
905 dual_timestamp_get(&m->generators_start_timestamp);
906 manager_run_generators(m);
907 dual_timestamp_get(&m->generators_finish_timestamp);
909 r = lookup_paths_init(
910 &m->lookup_paths, m->running_as, true,
911 m->generator_unit_path,
912 m->generator_unit_path_early,
913 m->generator_unit_path_late);
917 manager_build_unit_path_cache(m);
919 /* If we will deserialize make sure that during enumeration
920 * this is already known, so we increase the counter here
925 /* First, enumerate what we can from all config files */
926 dual_timestamp_get(&m->units_load_start_timestamp);
927 r = manager_enumerate(m);
928 dual_timestamp_get(&m->units_load_finish_timestamp);
930 /* Second, deserialize if there is something to deserialize */
932 q = manager_deserialize(m, serialization, fds);
937 /* Any fds left? Find some unit which wants them. This is
938 * useful to allow container managers to pass some file
939 * descriptors to us pre-initialized. This enables
940 * socket-based activation of entire containers. */
941 if (fdset_size(fds) > 0) {
942 q = manager_distribute_fds(m, fds);
947 /* We might have deserialized the notify fd, but if we didn't
948 * then let's create the bus now */
949 manager_setup_notify(m);
951 /* We might have deserialized the kdbus control fd, but if we
952 * didn't, then let's create the bus now. */
953 manager_setup_kdbus(m);
954 manager_connect_bus(m, !!serialization);
956 /* Third, fire things up! */
957 q = manager_coldplug(m);
962 assert(m->n_reloading > 0);
965 /* Let's wait for the UnitNew/JobNew messages being
966 * sent, before we notify that the reload is
968 m->send_reloading_done = true;
974 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
979 assert(type < _JOB_TYPE_MAX);
981 assert(mode < _JOB_MODE_MAX);
983 if (mode == JOB_ISOLATE && type != JOB_START) {
984 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
988 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
989 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
993 log_debug_unit(unit->id,
994 "Trying to enqueue job %s/%s/%s", unit->id,
995 job_type_to_string(type), job_mode_to_string(mode));
997 job_type_collapse(&type, unit);
999 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1003 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1004 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1005 mode == JOB_IGNORE_DEPENDENCIES, e);
1009 if (mode == JOB_ISOLATE) {
1010 r = transaction_add_isolate_jobs(tr, m);
1015 r = transaction_activate(tr, m, mode, e);
1019 log_debug_unit(unit->id,
1020 "Enqueued job %s/%s as %u", unit->id,
1021 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1024 *_ret = tr->anchor_job;
1026 transaction_free(tr);
1030 transaction_abort(tr);
1031 transaction_free(tr);
1035 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1040 assert(type < _JOB_TYPE_MAX);
1042 assert(mode < _JOB_MODE_MAX);
1044 r = manager_load_unit(m, name, NULL, NULL, &unit);
1048 return manager_add_job(m, type, unit, mode, override, e, _ret);
1051 Job *manager_get_job(Manager *m, uint32_t id) {
1054 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1057 Unit *manager_get_unit(Manager *m, const char *name) {
1061 return hashmap_get(m->units, name);
1064 unsigned manager_dispatch_load_queue(Manager *m) {
1070 /* Make sure we are not run recursively */
1071 if (m->dispatching_load_queue)
1074 m->dispatching_load_queue = true;
1076 /* Dispatches the load queue. Takes a unit from the queue and
1077 * tries to load its data until the queue is empty */
1079 while ((u = m->load_queue)) {
1080 assert(u->in_load_queue);
1086 m->dispatching_load_queue = false;
1090 int manager_load_unit_prepare(
1102 assert(name || path);
1104 /* This will prepare the unit for loading, but not actually
1105 * load anything from disk. */
1107 if (path && !is_path(path))
1108 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1111 name = basename(path);
1113 t = unit_name_to_type(name);
1115 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1116 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1118 ret = manager_get_unit(m, name);
1124 ret = unit_new(m, unit_vtable[t]->object_size);
1129 ret->fragment_path = strdup(path);
1130 if (!ret->fragment_path) {
1136 r = unit_add_name(ret, name);
1142 unit_add_to_load_queue(ret);
1143 unit_add_to_dbus_queue(ret);
1144 unit_add_to_gc_queue(ret);
1152 int manager_load_unit(
1163 /* This will load the service information files, but not actually
1164 * start any services or anything. */
1166 r = manager_load_unit_prepare(m, name, path, e, _ret);
1170 manager_dispatch_load_queue(m);
1173 *_ret = unit_follow_merge(*_ret);
1178 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1185 HASHMAP_FOREACH(j, s->jobs, i)
1186 job_dump(j, f, prefix);
1189 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1197 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1199 unit_dump(u, f, prefix);
1202 void manager_clear_jobs(Manager *m) {
1207 while ((j = hashmap_first(m->jobs)))
1208 /* No need to recurse. We're cancelling all jobs. */
1209 job_finish_and_invalidate(j, JOB_CANCELED, false);
1212 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1213 Manager *m = userdata;
1219 while ((j = m->run_queue)) {
1220 assert(j->installed);
1221 assert(j->in_run_queue);
1223 job_run_and_invalidate(j);
1226 if (m->n_running_jobs > 0)
1227 manager_watch_jobs_in_progress(m);
1229 if (m->n_on_console > 0)
1230 manager_watch_idle_pipe(m);
1235 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1242 if (m->dispatching_dbus_queue)
1245 m->dispatching_dbus_queue = true;
1247 while ((u = m->dbus_unit_queue)) {
1248 assert(u->in_dbus_queue);
1250 bus_unit_send_change_signal(u);
1254 while ((j = m->dbus_job_queue)) {
1255 assert(j->in_dbus_queue);
1257 bus_job_send_change_signal(j);
1261 m->dispatching_dbus_queue = false;
1263 if (m->send_reloading_done) {
1264 m->send_reloading_done = false;
1266 bus_manager_send_reloading(m, false);
1269 if (m->queued_message)
1270 bus_send_queued_message(m);
1275 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1276 Manager *m = userdata;
1280 assert(m->notify_fd == fd);
1282 if (revents != EPOLLIN) {
1283 log_warning("Got unexpected poll event for notify fd.");
1289 struct iovec iovec = {
1291 .iov_len = sizeof(buf)-1,
1295 struct cmsghdr cmsghdr;
1296 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1299 struct msghdr msghdr = {
1302 .msg_control = &control,
1303 .msg_controllen = sizeof(control),
1305 struct ucred *ucred;
1307 _cleanup_strv_free_ char **tags = NULL;
1309 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1314 if (errno == EAGAIN || errno == EINTR)
1320 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1321 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1322 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1323 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1324 log_warning("Received notify message without credentials. Ignoring.");
1328 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1330 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1332 u = manager_get_unit_by_pid(m, ucred->pid);
1334 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1339 assert((size_t) n < sizeof(buf));
1341 tags = strv_split(buf, "\n\r");
1345 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1347 if (UNIT_VTABLE(u)->notify_message)
1348 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1354 static int manager_dispatch_sigchld(Manager *m) {
1361 /* First we call waitd() for a PID and do not reap the
1362 * zombie. That way we can still access /proc/$PID for
1363 * it while it is a zombie. */
1364 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1366 if (errno == ECHILD)
1378 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1379 _cleanup_free_ char *name = NULL;
1381 get_process_comm(si.si_pid, &name);
1382 log_debug("Got SIGCHLD for process "PID_FMT" (%s)", si.si_pid, strna(name));
1385 /* And now figure out the unit this belongs to */
1386 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1388 u = manager_get_unit_by_pid(m, si.si_pid);
1390 /* And now, we actually reap the zombie. */
1391 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1398 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1401 log_debug("Child %lu died (code=%s, status=%i/%s)",
1402 (long unsigned) si.si_pid,
1403 sigchld_code_to_string(si.si_code),
1405 strna(si.si_code == CLD_EXITED
1406 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1407 : signal_to_string(si.si_status)));
1412 log_debug_unit(u->id,
1413 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1415 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1416 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1422 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1423 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1426 log_debug_unit(name, "Activating special unit %s", name);
1428 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1430 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1435 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1436 Manager *m = userdata;
1438 struct signalfd_siginfo sfsi;
1439 bool sigchld = false;
1442 assert(m->signal_fd == fd);
1444 if (revents != EPOLLIN) {
1445 log_warning("Got unexpected events from signal file descriptor.");
1450 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1451 if (n != sizeof(sfsi)) {
1456 if (errno == EINTR || errno == EAGAIN)
1462 if (sfsi.ssi_pid > 0) {
1463 _cleanup_free_ char *p = NULL;
1465 get_process_comm(sfsi.ssi_pid, &p);
1467 log_full(sfsi.ssi_signo == SIGCHLD ||
1468 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1469 ? LOG_DEBUG : LOG_INFO,
1470 "Received SIG%s from PID "PID_FMT" (%s).",
1471 signal_to_string(sfsi.ssi_signo),
1472 sfsi.ssi_pid, strna(p));
1474 log_full(sfsi.ssi_signo == SIGCHLD ||
1475 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1476 ? LOG_DEBUG : LOG_INFO,
1478 signal_to_string(sfsi.ssi_signo));
1480 switch (sfsi.ssi_signo) {
1487 if (m->running_as == SYSTEMD_SYSTEM) {
1488 /* This is for compatibility with the
1489 * original sysvinit */
1490 m->exit_code = MANAGER_REEXECUTE;
1497 if (m->running_as == SYSTEMD_SYSTEM) {
1498 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1502 /* Run the exit target if there is one, if not, just exit. */
1503 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1504 m->exit_code = MANAGER_EXIT;
1511 if (m->running_as == SYSTEMD_SYSTEM)
1512 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1514 /* This is a nop on non-init */
1518 if (m->running_as == SYSTEMD_SYSTEM)
1519 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1521 /* This is a nop on non-init */
1527 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1529 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1530 log_info("Trying to reconnect to bus...");
1534 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1535 log_info("Loading D-Bus service...");
1536 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1543 _cleanup_free_ char *dump = NULL;
1544 _cleanup_fclose_ FILE *f = NULL;
1547 f = open_memstream(&dump, &size);
1549 log_warning("Failed to allocate memory stream.");
1553 manager_dump_units(m, f, "\t");
1554 manager_dump_jobs(m, f, "\t");
1557 log_warning("Failed to write status stream");
1561 log_dump(LOG_INFO, dump);
1566 m->exit_code = MANAGER_RELOAD;
1571 /* Starting SIGRTMIN+0 */
1572 static const char * const target_table[] = {
1573 [0] = SPECIAL_DEFAULT_TARGET,
1574 [1] = SPECIAL_RESCUE_TARGET,
1575 [2] = SPECIAL_EMERGENCY_TARGET,
1576 [3] = SPECIAL_HALT_TARGET,
1577 [4] = SPECIAL_POWEROFF_TARGET,
1578 [5] = SPECIAL_REBOOT_TARGET,
1579 [6] = SPECIAL_KEXEC_TARGET
1582 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1583 static const ManagerExitCode code_table[] = {
1585 [1] = MANAGER_POWEROFF,
1586 [2] = MANAGER_REBOOT,
1590 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1591 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1592 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1593 manager_start_target(m, target_table[idx],
1594 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1598 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1599 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1600 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1604 switch (sfsi.ssi_signo - SIGRTMIN) {
1607 log_debug("Enabling showing of status.");
1608 manager_set_show_status(m, true);
1612 log_debug("Disabling showing of status.");
1613 manager_set_show_status(m, false);
1617 log_set_max_level(LOG_DEBUG);
1618 log_notice("Setting log level to debug.");
1622 log_set_max_level(LOG_INFO);
1623 log_notice("Setting log level to info.");
1627 if (m->running_as == SYSTEMD_USER) {
1628 m->exit_code = MANAGER_EXIT;
1632 /* This is a nop on init */
1636 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1637 log_notice("Setting log target to journal-or-kmsg.");
1641 log_set_target(LOG_TARGET_CONSOLE);
1642 log_notice("Setting log target to console.");
1646 log_set_target(LOG_TARGET_KMSG);
1647 log_notice("Setting log target to kmsg.");
1651 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1652 log_notice("Setting log target to syslog-or-kmsg.");
1656 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1663 manager_dispatch_sigchld(m);
1668 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1669 Manager *m = userdata;
1674 assert(m->time_change_fd == fd);
1676 log_struct(LOG_INFO,
1677 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1678 "MESSAGE=Time has been changed",
1681 /* Restart the watch */
1682 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1684 close_nointr_nofail(m->time_change_fd);
1685 m->time_change_fd = -1;
1687 manager_setup_time_change(m);
1689 HASHMAP_FOREACH(u, m->units, i)
1690 if (UNIT_VTABLE(u)->time_change)
1691 UNIT_VTABLE(u)->time_change(u);
1696 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1697 Manager *m = userdata;
1700 assert(m->idle_pipe[2] == fd);
1702 m->no_console_output = m->n_on_console > 0;
1704 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1705 manager_close_idle_pipe(m);
1710 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1711 Manager *m = userdata;
1715 manager_print_jobs_in_progress(m);
1719 int manager_loop(Manager *m) {
1722 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1725 m->exit_code = MANAGER_RUNNING;
1727 /* Release the path cache */
1728 set_free_free(m->unit_path_cache);
1729 m->unit_path_cache = NULL;
1731 manager_check_finished(m);
1733 /* There might still be some zombies hanging around from
1734 * before we were exec()'ed. Let's reap them. */
1735 r = manager_dispatch_sigchld(m);
1739 while (m->exit_code == MANAGER_RUNNING) {
1742 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1745 if (!ratelimit_test(&rl)) {
1746 /* Yay, something is going seriously wrong, pause a little */
1747 log_warning("Looping too fast. Throttling execution a little.");
1752 if (manager_dispatch_load_queue(m) > 0)
1755 if (manager_dispatch_gc_queue(m) > 0)
1758 if (manager_dispatch_cleanup_queue(m) > 0)
1761 if (manager_dispatch_cgroup_queue(m) > 0)
1764 if (manager_dispatch_dbus_queue(m) > 0)
1767 /* Sleep for half the watchdog time */
1768 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1769 wait_usec = m->runtime_watchdog / 2;
1773 wait_usec = (usec_t) -1;
1775 r = sd_event_run(m->event, wait_usec);
1777 log_error("Failed to run event loop: %s", strerror(-r));
1782 return m->exit_code;
1785 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1786 _cleanup_free_ char *n = NULL;
1794 r = unit_name_from_dbus_path(s, &n);
1798 r = manager_load_unit(m, n, NULL, e, &u);
1807 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1817 p = startswith(s, "/org/freedesktop/systemd1/job/");
1821 r = safe_atou(p, &id);
1825 j = manager_get_job(m, id);
1834 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1840 audit_fd = get_audit_fd();
1844 /* Don't generate audit events if the service was already
1845 * started and we're just deserializing */
1846 if (m->n_reloading > 0)
1849 if (m->running_as != SYSTEMD_SYSTEM)
1852 if (u->type != UNIT_SERVICE)
1855 p = unit_name_to_prefix_and_instance(u->id);
1857 log_error_unit(u->id,
1858 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1862 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1863 if (errno == EPERM) {
1864 /* We aren't allowed to send audit messages?
1865 * Then let's not retry again. */
1868 log_warning("Failed to send audit message: %m");
1876 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1878 union sockaddr_union sa;
1880 char *message = NULL;
1882 /* Don't generate plymouth events if the service was already
1883 * started and we're just deserializing */
1884 if (m->n_reloading > 0)
1887 if (m->running_as != SYSTEMD_SYSTEM)
1890 if (detect_container(NULL) > 0)
1893 if (u->type != UNIT_SERVICE &&
1894 u->type != UNIT_MOUNT &&
1895 u->type != UNIT_SWAP)
1898 /* We set SOCK_NONBLOCK here so that we rather drop the
1899 * message then wait for plymouth */
1900 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1902 log_error("socket() failed: %m");
1907 sa.sa.sa_family = AF_UNIX;
1908 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1909 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1911 if (errno != EPIPE &&
1914 errno != ECONNREFUSED &&
1915 errno != ECONNRESET &&
1916 errno != ECONNABORTED)
1917 log_error("connect() failed: %m");
1922 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1928 if (write(fd, message, n + 1) != n + 1) {
1930 if (errno != EPIPE &&
1933 errno != ECONNREFUSED &&
1934 errno != ECONNRESET &&
1935 errno != ECONNABORTED)
1936 log_error("Failed to write Plymouth message: %m");
1943 close_nointr_nofail(fd);
1948 void manager_dispatch_bus_name_owner_changed(
1951 const char* old_owner,
1952 const char *new_owner) {
1959 u = hashmap_get(m->watch_bus, name);
1963 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1966 int manager_open_serialization(Manager *m, FILE **_f) {
1967 _cleanup_free_ char *path = NULL;
1973 if (m->running_as == SYSTEMD_SYSTEM)
1974 asprintf(&path, "/run/systemd/dump-"PID_FMT"-XXXXXX", getpid());
1976 asprintf(&path, "/tmp/systemd-dump-"PID_FMT"-XXXXXX", getpid());
1981 RUN_WITH_UMASK(0077) {
1982 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1989 log_debug("Serializing state to %s", path);
1991 f = fdopen(fd, "w+");
1993 close_nointr_nofail(fd);
2002 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2015 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2016 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2017 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2018 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2020 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2021 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2022 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2023 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2026 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2027 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2028 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2029 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2030 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2031 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2032 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2033 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2036 if (!switching_root) {
2037 STRV_FOREACH(e, m->environment) {
2038 _cleanup_free_ char *ce;
2044 fprintf(f, "env=%s\n", *e);
2048 if (m->notify_fd >= 0) {
2051 copy = fdset_put_dup(fds, m->notify_fd);
2055 fprintf(f, "notify-fd=%i\n", copy);
2056 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2059 if (m->kdbus_fd >= 0) {
2062 copy = fdset_put_dup(fds, m->kdbus_fd);
2066 fprintf(f, "kdbus-fd=%i\n", copy);
2069 bus_serialize(m, f);
2073 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2077 if (!unit_can_serialize(u))
2084 r = unit_serialize(u, f, fds, !switching_root);
2091 assert(m->n_reloading > 0);
2097 r = bus_fdset_add_all(m, fds);
2104 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2110 log_debug("Deserializing state...");
2115 char line[LINE_MAX], *l;
2117 if (!fgets(line, sizeof(line), f)) {
2132 if (startswith(l, "current-job-id=")) {
2135 if (safe_atou32(l+15, &id) < 0)
2136 log_debug("Failed to parse current job id value %s", l+15);
2138 m->current_job_id = MAX(m->current_job_id, id);
2140 } else if (startswith(l, "n-installed-jobs=")) {
2143 if (safe_atou32(l+17, &n) < 0)
2144 log_debug("Failed to parse installed jobs counter %s", l+17);
2146 m->n_installed_jobs += n;
2148 } else if (startswith(l, "n-failed-jobs=")) {
2151 if (safe_atou32(l+14, &n) < 0)
2152 log_debug("Failed to parse failed jobs counter %s", l+14);
2154 m->n_failed_jobs += n;
2156 } else if (startswith(l, "taint-usr=")) {
2159 b = parse_boolean(l+10);
2161 log_debug("Failed to parse taint /usr flag %s", l+10);
2163 m->taint_usr = m->taint_usr || b;
2165 } else if (startswith(l, "firmware-timestamp="))
2166 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2167 else if (startswith(l, "loader-timestamp="))
2168 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2169 else if (startswith(l, "kernel-timestamp="))
2170 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2171 else if (startswith(l, "initrd-timestamp="))
2172 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2173 else if (startswith(l, "userspace-timestamp="))
2174 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2175 else if (startswith(l, "finish-timestamp="))
2176 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2177 else if (startswith(l, "security-start-timestamp="))
2178 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2179 else if (startswith(l, "security-finish-timestamp="))
2180 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2181 else if (startswith(l, "generators-start-timestamp="))
2182 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2183 else if (startswith(l, "generators-finish-timestamp="))
2184 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2185 else if (startswith(l, "units-load-start-timestamp="))
2186 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2187 else if (startswith(l, "units-load-finish-timestamp="))
2188 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2189 else if (startswith(l, "env=")) {
2190 _cleanup_free_ char *uce = NULL;
2193 uce = cunescape(l+4);
2199 e = strv_env_set(m->environment, uce);
2205 strv_free(m->environment);
2208 } else if (startswith(l, "notify-fd=")) {
2211 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2212 log_debug("Failed to parse notify fd: %s", l + 10);
2214 if (m->notify_fd >= 0) {
2215 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2216 close_nointr_nofail(m->notify_fd);
2219 m->notify_fd = fdset_remove(fds, fd);
2222 } else if (startswith(l, "notify-socket=")) {
2231 free(m->notify_socket);
2232 m->notify_socket = n;
2234 } else if (startswith(l, "kdbus-fd=")) {
2237 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2238 log_debug("Failed to parse kdbus fd: %s", l + 9);
2240 if (m->kdbus_fd >= 0)
2241 close_nointr_nofail(m->kdbus_fd);
2243 m->kdbus_fd = fdset_remove(fds, fd);
2246 } else if (bus_deserialize_item(m, l) == 0)
2247 log_debug("Unknown serialization item '%s'", l);
2252 char name[UNIT_NAME_MAX+2];
2255 if (!fgets(name, sizeof(name), f)) {
2266 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2270 r = unit_deserialize(u, f, fds);
2279 assert(m->n_reloading > 0);
2285 int manager_reload(Manager *m) {
2287 _cleanup_fclose_ FILE *f = NULL;
2288 _cleanup_fdset_free_ FDSet *fds = NULL;
2292 r = manager_open_serialization(m, &f);
2297 bus_manager_send_reloading(m, true);
2305 r = manager_serialize(m, f, fds, false);
2311 if (fseeko(f, 0, SEEK_SET) < 0) {
2316 /* From here on there is no way back. */
2317 manager_clear_jobs_and_units(m);
2318 manager_undo_generators(m);
2319 lookup_paths_free(&m->lookup_paths);
2321 /* Find new unit paths */
2322 manager_run_generators(m);
2324 q = lookup_paths_init(
2325 &m->lookup_paths, m->running_as, true,
2326 m->generator_unit_path,
2327 m->generator_unit_path_early,
2328 m->generator_unit_path_late);
2332 manager_build_unit_path_cache(m);
2334 /* First, enumerate what we can from all config files */
2335 q = manager_enumerate(m);
2339 /* Second, deserialize our stored data */
2340 q = manager_deserialize(m, f, fds);
2347 /* Re-register notify_fd as event source */
2348 q = manager_setup_notify(m);
2352 /* Third, fire things up! */
2353 q = manager_coldplug(m);
2357 assert(m->n_reloading > 0);
2360 m->send_reloading_done = true;
2365 static bool manager_is_booting_or_shutting_down(Manager *m) {
2370 /* Is the initial job still around? */
2371 if (manager_get_job(m, m->default_unit_job_id))
2374 /* Is there a job for the shutdown target? */
2375 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2382 bool manager_is_reloading_or_reexecuting(Manager *m) {
2385 return m->n_reloading != 0;
2388 void manager_reset_failed(Manager *m) {
2394 HASHMAP_FOREACH(u, m->units, i)
2395 unit_reset_failed(u);
2398 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2404 /* Returns true if the unit is inactive or going down */
2405 u = manager_get_unit(m, name);
2409 return unit_inactive_or_pending(u);
2412 void manager_check_finished(Manager *m) {
2413 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2414 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2418 if (m->n_running_jobs == 0)
2419 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2421 if (hashmap_size(m->jobs) > 0) {
2422 if (m->jobs_in_progress_event_source)
2423 sd_event_source_set_time(m->jobs_in_progress_event_source, JOBS_IN_PROGRESS_PERIOD_SEC);
2427 /* Notify Type=idle units that we are done now */
2428 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2429 manager_close_idle_pipe(m);
2431 /* Turn off confirm spawn now */
2432 m->confirm_spawn = false;
2434 if (dual_timestamp_is_set(&m->finish_timestamp))
2437 dual_timestamp_get(&m->finish_timestamp);
2439 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2441 /* Note that m->kernel_usec.monotonic is always at 0,
2442 * and m->firmware_usec.monotonic and
2443 * m->loader_usec.monotonic should be considered
2444 * negative values. */
2446 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2447 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2448 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2449 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2451 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2453 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2454 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2456 if (!log_on_console())
2457 log_struct(LOG_INFO,
2458 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2459 "KERNEL_USEC="USEC_FMT, kernel_usec,
2460 "INITRD_USEC="USEC_FMT, initrd_usec,
2461 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2462 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2463 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2464 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2465 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2466 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2469 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2472 if (!log_on_console())
2473 log_struct(LOG_INFO,
2474 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2475 "KERNEL_USEC="USEC_FMT, kernel_usec,
2476 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2477 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2478 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2479 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2480 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2484 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2485 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2487 if (!log_on_console())
2488 log_struct(LOG_INFO,
2489 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2490 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2491 "MESSAGE=Startup finished in %s.",
2492 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2496 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2499 "READY=1\nSTATUS=Startup finished in %s.",
2500 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2503 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2514 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2515 /* systemd --system, not running --test */
2517 p = strappend("/run/systemd/", name);
2521 r = mkdir_p_label(p, 0755);
2523 log_error("Failed to create generator directory %s: %s",
2528 } else if (m->running_as == SYSTEMD_USER) {
2529 const char *s = NULL;
2531 s = getenv("XDG_RUNTIME_DIR");
2534 p = strjoin(s, "/systemd/", name, NULL);
2538 r = mkdir_p_label(p, 0755);
2540 log_error("Failed to create generator directory %s: %s",
2546 /* systemd --system --test */
2548 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2553 log_error("Failed to create generator directory %s: %m",
2564 static void trim_generator_dir(Manager *m, char **generator) {
2571 if (rmdir(*generator) >= 0) {
2579 void manager_run_generators(Manager *m) {
2580 _cleanup_closedir_ DIR *d = NULL;
2581 const char *generator_path;
2582 const char *argv[5];
2587 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2588 d = opendir(generator_path);
2590 if (errno == ENOENT)
2593 log_error("Failed to enumerate generator directory %s: %m",
2598 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2602 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2606 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2610 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2611 argv[1] = m->generator_unit_path;
2612 argv[2] = m->generator_unit_path_early;
2613 argv[3] = m->generator_unit_path_late;
2616 RUN_WITH_UMASK(0022)
2617 execute_directory(generator_path, d, (char**) argv);
2620 trim_generator_dir(m, &m->generator_unit_path);
2621 trim_generator_dir(m, &m->generator_unit_path_early);
2622 trim_generator_dir(m, &m->generator_unit_path_late);
2625 static void remove_generator_dir(Manager *m, char **generator) {
2632 strv_remove(m->lookup_paths.unit_path, *generator);
2633 rm_rf(*generator, false, true, false);
2639 void manager_undo_generators(Manager *m) {
2642 remove_generator_dir(m, &m->generator_unit_path);
2643 remove_generator_dir(m, &m->generator_unit_path_early);
2644 remove_generator_dir(m, &m->generator_unit_path_late);
2647 int manager_environment_add(Manager *m, char **minus, char **plus) {
2648 char **a = NULL, **b = NULL, **l;
2653 if (!strv_isempty(minus)) {
2654 a = strv_env_delete(l, 1, minus);
2661 if (!strv_isempty(plus)) {
2662 b = strv_env_merge(2, l, plus);
2669 if (m->environment != l)
2670 strv_free(m->environment);
2676 m->environment = strv_sort(l);
2680 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2685 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2686 if (!default_rlimit[i])
2689 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2697 void manager_recheck_journal(Manager *m) {
2702 if (m->running_as != SYSTEMD_SYSTEM)
2705 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2706 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2707 log_close_journal();
2711 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2712 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2713 log_close_journal();
2717 /* Hmm, OK, so the socket is fully up and the service is up
2718 * too, then let's make use of the thing. */
2722 void manager_set_show_status(Manager *m, bool b) {
2725 if (m->running_as != SYSTEMD_SYSTEM)
2731 touch("/run/systemd/show-status");
2733 unlink("/run/systemd/show-status");
2736 static bool manager_get_show_status(Manager *m) {
2739 if (m->running_as != SYSTEMD_SYSTEM)
2742 if (m->no_console_output)
2748 /* If Plymouth is running make sure we show the status, so
2749 * that there's something nice to see when people press Esc */
2751 return plymouth_running();
2754 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2757 if (!manager_get_show_status(m))
2760 /* XXX We should totally drop the check for ephemeral here
2761 * and thus effectively make 'Type=idle' pointless. */
2762 if (ephemeral && m->n_on_console > 0)
2765 if (!manager_is_booting_or_shutting_down(m))
2768 va_start(ap, format);
2769 status_vprintf(status, true, ephemeral, format, ap);
2773 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2774 _cleanup_free_ char *p = NULL;
2782 p = unit_name_from_path(path, suffix);
2786 found = manager_get_unit(m, p);
2796 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2797 char p[strlen(path)+1];
2803 path_kill_slashes(p);
2805 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);