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_setup_notify(Manager *m) {
102 struct sockaddr_un un;
104 .sa.sa_family = AF_UNIX,
108 m->notify_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
109 if (m->notify_fd < 0) {
110 log_error("Failed to allocate notification socket: %m");
114 if (getpid() != 1 || detect_container(NULL) > 0)
115 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
117 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
118 sa.un.sun_path[0] = 0;
120 r = bind(m->notify_fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
122 log_error("bind() failed: %m");
126 r = setsockopt(m->notify_fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
128 log_error("SO_PASSCRED failed: %m");
132 r = sd_event_add_io(m->event, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m, &m->notify_event_source);
134 log_error("Failed to allocate notify event source: %s", strerror(-r));
138 /* Process signals a bit earlier than SIGCHLD, so that we can
139 * still identify to which service an exit message belongs */
140 r = sd_event_source_set_priority(m->notify_event_source, -7);
144 sa.un.sun_path[0] = '@';
145 m->notify_socket = strdup(sa.un.sun_path);
146 if (!m->notify_socket)
149 log_debug("Using notification socket %s", m->notify_socket);
154 static int manager_watch_jobs_in_progress(Manager *m) {
157 if (m->jobs_in_progress_event_source)
160 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);
163 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
165 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
168 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
169 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
173 p = mempset(p, ' ', pos-2);
174 p = stpcpy(p, ANSI_RED_ON);
178 if (pos > 0 && pos <= width) {
179 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
183 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
186 p = stpcpy(p, ANSI_RED_ON);
189 p = mempset(p, ' ', width-1-pos);
190 strcpy(p, ANSI_HIGHLIGHT_OFF);
194 static void manager_print_jobs_in_progress(Manager *m) {
195 _cleanup_free_ char *job_of_n = NULL;
198 unsigned counter = 0, print_nr;
199 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
204 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
206 HASHMAP_FOREACH(j, m->jobs, i)
207 if (j->state == JOB_RUNNING && counter++ == print_nr)
210 /* m->n_running_jobs must be consistent with the contents of m->jobs,
211 * so the above loop must have succeeded in finding j. */
212 assert(counter == print_nr + 1);
215 cylon_pos = m->jobs_in_progress_iteration % 14;
217 cylon_pos = 14 - cylon_pos;
218 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
220 if (m->n_running_jobs > 1)
221 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
224 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
225 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
227 m->jobs_in_progress_iteration++;
230 static int manager_watch_idle_pipe(Manager *m) {
235 if (m->idle_pipe_event_source)
238 if (m->idle_pipe[2] < 0)
241 r = sd_event_add_io(m->event, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m, &m->idle_pipe_event_source);
243 log_error("Failed to watch idle pipe: %s", strerror(-r));
250 static void manager_close_idle_pipe(Manager *m) {
253 close_pipe(m->idle_pipe);
254 close_pipe(m->idle_pipe + 2);
257 static int manager_setup_time_change(Manager *m) {
260 /* We only care for the cancellation event, hence we set the
261 * timeout to the latest possible value. */
262 struct itimerspec its = {
263 .it_value.tv_sec = TIME_T_MAX,
267 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
269 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
270 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
272 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
273 if (m->time_change_fd < 0) {
274 log_error("Failed to create timerfd: %m");
278 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
279 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
280 close_nointr_nofail(m->time_change_fd);
281 m->time_change_fd = -1;
285 r = sd_event_add_io(m->event, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m, &m->time_change_event_source);
287 log_error("Failed to create time change event source: %s", strerror(-r));
291 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
296 static int enable_special_signals(Manager *m) {
297 _cleanup_close_ int fd = -1;
301 /* Enable that we get SIGINT on control-alt-del. In containers
302 * this will fail with EPERM (older) or EINVAL (newer), so
304 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
305 log_warning("Failed to enable ctrl-alt-del handling: %m");
307 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
309 /* Support systems without virtual console */
311 log_warning("Failed to open /dev/tty0: %m");
313 /* Enable that we get SIGWINCH on kbrequest */
314 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
315 log_warning("Failed to enable kbrequest handling: %m");
321 static int manager_setup_signals(Manager *m) {
322 struct sigaction sa = {
323 .sa_handler = SIG_DFL,
324 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
331 /* We are not interested in SIGSTOP and friends. */
332 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
334 assert_se(sigemptyset(&mask) == 0);
336 sigset_add_many(&mask,
337 SIGCHLD, /* Child died */
338 SIGTERM, /* Reexecute daemon */
339 SIGHUP, /* Reload configuration */
340 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
341 SIGUSR2, /* systemd: dump status */
342 SIGINT, /* Kernel sends us this on control-alt-del */
343 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
344 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
345 SIGRTMIN+0, /* systemd: start default.target */
346 SIGRTMIN+1, /* systemd: isolate rescue.target */
347 SIGRTMIN+2, /* systemd: isolate emergency.target */
348 SIGRTMIN+3, /* systemd: start halt.target */
349 SIGRTMIN+4, /* systemd: start poweroff.target */
350 SIGRTMIN+5, /* systemd: start reboot.target */
351 SIGRTMIN+6, /* systemd: start kexec.target */
352 SIGRTMIN+13, /* systemd: Immediate halt */
353 SIGRTMIN+14, /* systemd: Immediate poweroff */
354 SIGRTMIN+15, /* systemd: Immediate reboot */
355 SIGRTMIN+16, /* systemd: Immediate kexec */
356 SIGRTMIN+20, /* systemd: enable status messages */
357 SIGRTMIN+21, /* systemd: disable status messages */
358 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
359 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
360 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
361 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
362 SIGRTMIN+27, /* systemd: set log target to console */
363 SIGRTMIN+28, /* systemd: set log target to kmsg */
364 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
366 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
368 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
369 if (m->signal_fd < 0)
372 r = sd_event_add_io(m->event, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m, &m->signal_event_source);
376 /* Process signals a bit earlier than the rest of things, but
377 * later that notify_fd processing, so that the notify
378 * processing can still figure out to which process/service a
379 * message belongs, before we reap the process. */
380 r = sd_event_source_set_priority(m->signal_event_source, -5);
384 if (m->running_as == SYSTEMD_SYSTEM)
385 return enable_special_signals(m);
390 static int manager_default_environment(Manager *m) {
393 if (m->running_as == SYSTEMD_SYSTEM) {
394 /* The system manager always starts with a clean
395 * environment for its children. It does not import
396 * the kernel or the parents exported variables.
398 * The initial passed environ is untouched to keep
399 * /proc/self/environ valid; it is used for tagging
400 * the init process inside containers. */
401 m->environment = strv_new("PATH=" DEFAULT_PATH,
404 /* Import locale variables LC_*= from configuration */
405 locale_setup(&m->environment);
407 /* The user manager passes its own environment
408 * along to its children. */
409 m->environment = strv_copy(environ);
414 strv_sort(m->environment);
419 static int manager_setup_kdbus(Manager *m) {
420 _cleanup_free_ char *p = NULL;
425 if (m->kdbus_fd >= 0)
428 /* If there's already a bus address set, don't set up kdbus */
429 if (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"))
432 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", &p);
433 if (m->kdbus_fd < 0) {
434 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
438 log_debug("Successfully set up kdbus on %s", p);
440 /* Create the namespace directory here, so that the contents
441 * of that directory is not visible to non-root users. This is
442 * necessary to ensure that users cannot get access to busses
443 * of virtualized users when no UID namespacing is used. */
444 mkdir_p_label("/dev/kdbus/ns", 0700);
450 static int manager_connect_bus(Manager *m, bool reexecuting) {
451 bool try_bus_connect;
458 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
460 /* Try to connect to the busses, if possible. */
461 return bus_init(m, try_bus_connect);
464 int manager_new(SystemdRunningAs running_as, Manager **_m) {
469 assert(running_as >= 0);
470 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
472 m = new0(Manager, 1);
477 if (detect_container(NULL) <= 0)
478 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
481 m->running_as = running_as;
482 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
484 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
486 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;
487 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
489 r = manager_default_environment(m);
493 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
497 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
501 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
505 r = hashmap_ensure_allocated(&m->watch_pids, trivial_hash_func, trivial_compare_func);
509 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
513 r = sd_event_default(&m->event);
517 r = sd_event_add_defer(m->event, manager_dispatch_run_queue, m, &m->run_queue_event_source);
521 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
525 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
529 r = manager_setup_signals(m);
533 r = manager_setup_cgroup(m);
537 r = manager_setup_notify(m);
541 r = manager_setup_time_change(m);
545 m->udev = udev_new();
551 m->taint_usr = dir_is_empty("/usr") > 0;
561 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
567 while ((u = m->cleanup_queue)) {
568 assert(u->in_cleanup_queue);
578 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
579 GC_OFFSET_UNSURE, /* No clue */
580 GC_OFFSET_GOOD, /* We still need this unit */
581 GC_OFFSET_BAD, /* We don't need this unit anymore */
585 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
592 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
593 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
594 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
597 if (u->in_cleanup_queue)
600 if (unit_check_gc(u))
603 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
607 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
608 unit_gc_sweep(other, gc_marker);
610 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
613 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
620 /* We were unable to find anything out about this entry, so
621 * let's investigate it later */
622 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
623 unit_add_to_gc_queue(u);
627 /* We definitely know that this one is not useful anymore, so
628 * let's mark it for deletion */
629 u->gc_marker = gc_marker + GC_OFFSET_BAD;
630 unit_add_to_cleanup_queue(u);
634 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
637 static unsigned manager_dispatch_gc_queue(Manager *m) {
644 /* log_debug("Running GC..."); */
646 m->gc_marker += _GC_OFFSET_MAX;
647 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
650 gc_marker = m->gc_marker;
652 while ((u = m->gc_queue)) {
653 assert(u->in_gc_queue);
655 unit_gc_sweep(u, gc_marker);
657 LIST_REMOVE(gc_queue, m->gc_queue, u);
658 u->in_gc_queue = false;
662 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
663 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
664 log_debug_unit(u->id, "Collecting %s", u->id);
665 u->gc_marker = gc_marker + GC_OFFSET_BAD;
666 unit_add_to_cleanup_queue(u);
670 m->n_in_gc_queue = 0;
675 static void manager_clear_jobs_and_units(Manager *m) {
680 while ((u = hashmap_first(m->units)))
683 manager_dispatch_cleanup_queue(m);
685 assert(!m->load_queue);
686 assert(!m->run_queue);
687 assert(!m->dbus_unit_queue);
688 assert(!m->dbus_job_queue);
689 assert(!m->cleanup_queue);
690 assert(!m->gc_queue);
692 assert(hashmap_isempty(m->jobs));
693 assert(hashmap_isempty(m->units));
696 m->n_running_jobs = 0;
699 void manager_free(Manager *m) {
705 manager_clear_jobs_and_units(m);
707 for (c = 0; c < _UNIT_TYPE_MAX; c++)
708 if (unit_vtable[c]->shutdown)
709 unit_vtable[c]->shutdown(m);
711 /* If we reexecute ourselves, we keep the root cgroup
713 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
715 manager_undo_generators(m);
719 hashmap_free(m->units);
720 hashmap_free(m->jobs);
721 hashmap_free(m->watch_pids);
722 hashmap_free(m->watch_bus);
724 sd_event_source_unref(m->signal_event_source);
725 sd_event_source_unref(m->notify_event_source);
726 sd_event_source_unref(m->time_change_event_source);
727 sd_event_source_unref(m->jobs_in_progress_event_source);
728 sd_event_source_unref(m->idle_pipe_event_source);
729 sd_event_source_unref(m->run_queue_event_source);
731 if (m->signal_fd >= 0)
732 close_nointr_nofail(m->signal_fd);
733 if (m->notify_fd >= 0)
734 close_nointr_nofail(m->notify_fd);
735 if (m->time_change_fd >= 0)
736 close_nointr_nofail(m->time_change_fd);
737 if (m->kdbus_fd >= 0)
738 close_nointr_nofail(m->kdbus_fd);
740 manager_close_idle_pipe(m);
743 sd_event_unref(m->event);
745 free(m->notify_socket);
747 lookup_paths_free(&m->lookup_paths);
748 strv_free(m->environment);
750 hashmap_free(m->cgroup_unit);
751 set_free_free(m->unit_path_cache);
753 free(m->switch_root);
754 free(m->switch_root_init);
756 for (i = 0; i < RLIMIT_NLIMITS; i++)
759 assert(hashmap_isempty(m->units_requiring_mounts_for));
760 hashmap_free(m->units_requiring_mounts_for);
765 int manager_enumerate(Manager *m) {
771 /* Let's ask every type to load all units from disk/kernel
772 * that it might know */
773 for (c = 0; c < _UNIT_TYPE_MAX; c++)
774 if (unit_vtable[c]->enumerate) {
775 q = unit_vtable[c]->enumerate(m);
780 manager_dispatch_load_queue(m);
784 static int manager_coldplug(Manager *m) {
792 /* Then, let's set up their initial state. */
793 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
799 if ((q = unit_coldplug(u)) < 0)
806 static void manager_build_unit_path_cache(Manager *m) {
808 _cleanup_free_ DIR *d = NULL;
813 set_free_free(m->unit_path_cache);
815 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
816 if (!m->unit_path_cache) {
817 log_error("Failed to allocate unit path cache.");
821 /* This simply builds a list of files we know exist, so that
822 * we don't always have to go to disk */
824 STRV_FOREACH(i, m->lookup_paths.unit_path) {
830 log_error("Failed to open directory %s: %m", *i);
834 while ((de = readdir(d))) {
837 if (ignore_file(de->d_name))
840 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
846 r = set_consume(m->unit_path_cache, p);
858 log_error("Failed to build unit path cache: %s", strerror(-r));
860 set_free_free(m->unit_path_cache);
861 m->unit_path_cache = NULL;
865 static int manager_distribute_fds(Manager *m, FDSet *fds) {
872 HASHMAP_FOREACH(u, m->units, i) {
874 if (fdset_size(fds) <= 0)
877 if (UNIT_VTABLE(u)->distribute_fds) {
878 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
887 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
892 dual_timestamp_get(&m->generators_start_timestamp);
893 manager_run_generators(m);
894 dual_timestamp_get(&m->generators_finish_timestamp);
896 r = lookup_paths_init(
897 &m->lookup_paths, m->running_as, true,
898 m->generator_unit_path,
899 m->generator_unit_path_early,
900 m->generator_unit_path_late);
904 manager_build_unit_path_cache(m);
906 /* If we will deserialize make sure that during enumeration
907 * this is already known, so we increase the counter here
912 /* First, enumerate what we can from all config files */
913 dual_timestamp_get(&m->units_load_start_timestamp);
914 r = manager_enumerate(m);
915 dual_timestamp_get(&m->units_load_finish_timestamp);
917 /* Second, deserialize if there is something to deserialize */
919 q = manager_deserialize(m, serialization, fds);
924 /* Any fds left? Find some unit which wants them. This is
925 * useful to allow container managers to pass some file
926 * descriptors to us pre-initialized. This enables
927 * socket-based activation of entire containers. */
928 if (fdset_size(fds) > 0) {
929 q = manager_distribute_fds(m, fds);
934 /* We might have deserialized the kdbus control fd, but if we
935 * didn't, then let's create the bus now. */
936 manager_setup_kdbus(m);
937 manager_connect_bus(m, !!serialization);
939 /* Third, fire things up! */
940 q = manager_coldplug(m);
945 assert(m->n_reloading > 0);
948 /* Let's wait for the UnitNew/JobNew messages being
949 * sent, before we notify that the reload is
951 m->send_reloading_done = true;
957 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
962 assert(type < _JOB_TYPE_MAX);
964 assert(mode < _JOB_MODE_MAX);
966 if (mode == JOB_ISOLATE && type != JOB_START) {
967 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
971 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
972 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
976 log_debug_unit(unit->id,
977 "Trying to enqueue job %s/%s/%s", unit->id,
978 job_type_to_string(type), job_mode_to_string(mode));
980 job_type_collapse(&type, unit);
982 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
986 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
987 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
988 mode == JOB_IGNORE_DEPENDENCIES, e);
992 if (mode == JOB_ISOLATE) {
993 r = transaction_add_isolate_jobs(tr, m);
998 r = transaction_activate(tr, m, mode, e);
1002 log_debug_unit(unit->id,
1003 "Enqueued job %s/%s as %u", unit->id,
1004 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1007 *_ret = tr->anchor_job;
1009 transaction_free(tr);
1013 transaction_abort(tr);
1014 transaction_free(tr);
1018 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1023 assert(type < _JOB_TYPE_MAX);
1025 assert(mode < _JOB_MODE_MAX);
1027 r = manager_load_unit(m, name, NULL, NULL, &unit);
1031 return manager_add_job(m, type, unit, mode, override, e, _ret);
1034 Job *manager_get_job(Manager *m, uint32_t id) {
1037 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1040 Unit *manager_get_unit(Manager *m, const char *name) {
1044 return hashmap_get(m->units, name);
1047 unsigned manager_dispatch_load_queue(Manager *m) {
1053 /* Make sure we are not run recursively */
1054 if (m->dispatching_load_queue)
1057 m->dispatching_load_queue = true;
1059 /* Dispatches the load queue. Takes a unit from the queue and
1060 * tries to load its data until the queue is empty */
1062 while ((u = m->load_queue)) {
1063 assert(u->in_load_queue);
1069 m->dispatching_load_queue = false;
1073 int manager_load_unit_prepare(
1085 assert(name || path);
1087 /* This will prepare the unit for loading, but not actually
1088 * load anything from disk. */
1090 if (path && !is_path(path))
1091 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1094 name = basename(path);
1096 t = unit_name_to_type(name);
1098 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false))
1099 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1101 ret = manager_get_unit(m, name);
1107 ret = unit_new(m, unit_vtable[t]->object_size);
1112 ret->fragment_path = strdup(path);
1113 if (!ret->fragment_path) {
1119 r = unit_add_name(ret, name);
1125 unit_add_to_load_queue(ret);
1126 unit_add_to_dbus_queue(ret);
1127 unit_add_to_gc_queue(ret);
1135 int manager_load_unit(
1146 /* This will load the service information files, but not actually
1147 * start any services or anything. */
1149 r = manager_load_unit_prepare(m, name, path, e, _ret);
1153 manager_dispatch_load_queue(m);
1156 *_ret = unit_follow_merge(*_ret);
1161 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1168 HASHMAP_FOREACH(j, s->jobs, i)
1169 job_dump(j, f, prefix);
1172 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1180 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1182 unit_dump(u, f, prefix);
1185 void manager_clear_jobs(Manager *m) {
1190 while ((j = hashmap_first(m->jobs)))
1191 /* No need to recurse. We're cancelling all jobs. */
1192 job_finish_and_invalidate(j, JOB_CANCELED, false);
1195 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1196 Manager *m = userdata;
1202 while ((j = m->run_queue)) {
1203 assert(j->installed);
1204 assert(j->in_run_queue);
1206 job_run_and_invalidate(j);
1209 if (m->n_running_jobs > 0)
1210 manager_watch_jobs_in_progress(m);
1212 if (m->n_on_console > 0)
1213 manager_watch_idle_pipe(m);
1218 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1225 if (m->dispatching_dbus_queue)
1228 m->dispatching_dbus_queue = true;
1230 while ((u = m->dbus_unit_queue)) {
1231 assert(u->in_dbus_queue);
1233 bus_unit_send_change_signal(u);
1237 while ((j = m->dbus_job_queue)) {
1238 assert(j->in_dbus_queue);
1240 bus_job_send_change_signal(j);
1244 m->dispatching_dbus_queue = false;
1246 if (m->send_reloading_done) {
1247 m->send_reloading_done = false;
1249 bus_manager_send_reloading(m, false);
1252 if (m->queued_message)
1253 bus_send_queued_message(m);
1258 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1259 Manager *m = userdata;
1263 assert(m->notify_fd == fd);
1265 if (revents != EPOLLIN) {
1266 log_warning("Got unexpected poll event for notify fd.");
1272 struct iovec iovec = {
1274 .iov_len = sizeof(buf)-1,
1278 struct cmsghdr cmsghdr;
1279 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1282 struct msghdr msghdr = {
1285 .msg_control = &control,
1286 .msg_controllen = sizeof(control),
1288 struct ucred *ucred;
1290 _cleanup_strv_free_ char **tags = NULL;
1292 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1297 if (errno == EAGAIN || errno == EINTR)
1303 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1304 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1305 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1306 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1307 log_warning("Received notify message without credentials. Ignoring.");
1311 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1313 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1315 u = manager_get_unit_by_pid(m, ucred->pid);
1317 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1322 assert((size_t) n < sizeof(buf));
1324 tags = strv_split(buf, "\n\r");
1328 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1330 if (UNIT_VTABLE(u)->notify_message)
1331 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1337 static int manager_dispatch_sigchld(Manager *m) {
1344 /* First we call waitd() for a PID and do not reap the
1345 * zombie. That way we can still access /proc/$PID for
1346 * it while it is a zombie. */
1347 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1349 if (errno == ECHILD)
1361 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1362 _cleanup_free_ char *name = NULL;
1364 get_process_comm(si.si_pid, &name);
1365 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1368 /* And now figure out the unit this belongs to */
1369 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1371 u = manager_get_unit_by_pid(m, si.si_pid);
1373 /* And now, we actually reap the zombie. */
1374 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1381 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1384 log_debug("Child %lu died (code=%s, status=%i/%s)",
1385 (long unsigned) si.si_pid,
1386 sigchld_code_to_string(si.si_code),
1388 strna(si.si_code == CLD_EXITED
1389 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1390 : signal_to_string(si.si_status)));
1395 log_debug_unit(u->id,
1396 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1398 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1399 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1405 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1406 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1409 log_debug_unit(name, "Activating special unit %s", name);
1411 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1413 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1418 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1419 Manager *m = userdata;
1421 struct signalfd_siginfo sfsi;
1422 bool sigchld = false;
1425 assert(m->signal_fd == fd);
1427 if (revents != EPOLLIN) {
1428 log_warning("Got unexpected events from signal file descriptor.");
1433 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1434 if (n != sizeof(sfsi)) {
1439 if (errno == EINTR || errno == EAGAIN)
1445 if (sfsi.ssi_pid > 0) {
1448 get_process_comm(sfsi.ssi_pid, &p);
1450 log_debug("Received SIG%s from PID %lu (%s).",
1451 signal_to_string(sfsi.ssi_signo),
1452 (unsigned long) sfsi.ssi_pid, strna(p));
1455 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1457 switch (sfsi.ssi_signo) {
1464 if (m->running_as == SYSTEMD_SYSTEM) {
1465 /* This is for compatibility with the
1466 * original sysvinit */
1467 m->exit_code = MANAGER_REEXECUTE;
1474 if (m->running_as == SYSTEMD_SYSTEM) {
1475 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1479 /* Run the exit target if there is one, if not, just exit. */
1480 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1481 m->exit_code = MANAGER_EXIT;
1488 if (m->running_as == SYSTEMD_SYSTEM)
1489 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1491 /* This is a nop on non-init */
1495 if (m->running_as == SYSTEMD_SYSTEM)
1496 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1498 /* This is a nop on non-init */
1504 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1506 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1507 log_info("Trying to reconnect to bus...");
1511 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1512 log_info("Loading D-Bus service...");
1513 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1520 _cleanup_free_ char *dump = NULL;
1521 _cleanup_fclose_ FILE *f = NULL;
1524 f = open_memstream(&dump, &size);
1526 log_warning("Failed to allocate memory stream.");
1530 manager_dump_units(m, f, "\t");
1531 manager_dump_jobs(m, f, "\t");
1534 log_warning("Failed to write status stream");
1538 log_dump(LOG_INFO, dump);
1543 m->exit_code = MANAGER_RELOAD;
1548 /* Starting SIGRTMIN+0 */
1549 static const char * const target_table[] = {
1550 [0] = SPECIAL_DEFAULT_TARGET,
1551 [1] = SPECIAL_RESCUE_TARGET,
1552 [2] = SPECIAL_EMERGENCY_TARGET,
1553 [3] = SPECIAL_HALT_TARGET,
1554 [4] = SPECIAL_POWEROFF_TARGET,
1555 [5] = SPECIAL_REBOOT_TARGET,
1556 [6] = SPECIAL_KEXEC_TARGET
1559 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1560 static const ManagerExitCode code_table[] = {
1562 [1] = MANAGER_POWEROFF,
1563 [2] = MANAGER_REBOOT,
1567 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1568 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1569 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1570 manager_start_target(m, target_table[idx],
1571 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1575 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1576 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1577 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1581 switch (sfsi.ssi_signo - SIGRTMIN) {
1584 log_debug("Enabling showing of status.");
1585 manager_set_show_status(m, true);
1589 log_debug("Disabling showing of status.");
1590 manager_set_show_status(m, false);
1594 log_set_max_level(LOG_DEBUG);
1595 log_notice("Setting log level to debug.");
1599 log_set_max_level(LOG_INFO);
1600 log_notice("Setting log level to info.");
1604 if (m->running_as == SYSTEMD_USER) {
1605 m->exit_code = MANAGER_EXIT;
1609 /* This is a nop on init */
1613 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1614 log_notice("Setting log target to journal-or-kmsg.");
1618 log_set_target(LOG_TARGET_CONSOLE);
1619 log_notice("Setting log target to console.");
1623 log_set_target(LOG_TARGET_KMSG);
1624 log_notice("Setting log target to kmsg.");
1628 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1629 log_notice("Setting log target to syslog-or-kmsg.");
1633 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1640 manager_dispatch_sigchld(m);
1645 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1646 Manager *m = userdata;
1651 assert(m->time_change_fd == fd);
1653 log_struct(LOG_INFO,
1654 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1655 "MESSAGE=Time has been changed",
1658 /* Restart the watch */
1659 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1661 close_nointr_nofail(m->time_change_fd);
1662 m->time_change_fd = -1;
1664 manager_setup_time_change(m);
1666 HASHMAP_FOREACH(u, m->units, i)
1667 if (UNIT_VTABLE(u)->time_change)
1668 UNIT_VTABLE(u)->time_change(u);
1673 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1674 Manager *m = userdata;
1677 assert(m->idle_pipe[2] == fd);
1679 m->no_console_output = m->n_on_console > 0;
1681 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1682 manager_close_idle_pipe(m);
1687 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1688 Manager *m = userdata;
1692 manager_print_jobs_in_progress(m);
1696 int manager_loop(Manager *m) {
1699 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1702 m->exit_code = MANAGER_RUNNING;
1704 /* Release the path cache */
1705 set_free_free(m->unit_path_cache);
1706 m->unit_path_cache = NULL;
1708 manager_check_finished(m);
1710 /* There might still be some zombies hanging around from
1711 * before we were exec()'ed. Let's reap them. */
1712 r = manager_dispatch_sigchld(m);
1716 while (m->exit_code == MANAGER_RUNNING) {
1719 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1722 if (!ratelimit_test(&rl)) {
1723 /* Yay, something is going seriously wrong, pause a little */
1724 log_warning("Looping too fast. Throttling execution a little.");
1729 if (manager_dispatch_load_queue(m) > 0)
1732 if (manager_dispatch_gc_queue(m) > 0)
1735 if (manager_dispatch_cleanup_queue(m) > 0)
1738 if (manager_dispatch_cgroup_queue(m) > 0)
1741 if (manager_dispatch_dbus_queue(m) > 0)
1744 /* Sleep for half the watchdog time */
1745 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1746 wait_usec = m->runtime_watchdog / 2;
1750 wait_usec = (usec_t) -1;
1752 r = sd_event_run(m->event, wait_usec);
1754 log_error("Failed to run event loop: %s", strerror(-r));
1759 return m->exit_code;
1762 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1763 _cleanup_free_ char *n = NULL;
1771 r = unit_name_from_dbus_path(s, &n);
1775 r = manager_load_unit(m, n, NULL, e, &u);
1784 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1794 p = startswith(s, "/org/freedesktop/systemd1/job/");
1798 r = safe_atou(p, &id);
1802 j = manager_get_job(m, id);
1811 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1817 audit_fd = get_audit_fd();
1821 /* Don't generate audit events if the service was already
1822 * started and we're just deserializing */
1823 if (m->n_reloading > 0)
1826 if (m->running_as != SYSTEMD_SYSTEM)
1829 if (u->type != UNIT_SERVICE)
1832 p = unit_name_to_prefix_and_instance(u->id);
1834 log_error_unit(u->id,
1835 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1839 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1840 if (errno == EPERM) {
1841 /* We aren't allowed to send audit messages?
1842 * Then let's not retry again. */
1845 log_warning("Failed to send audit message: %m");
1853 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1855 union sockaddr_union sa;
1857 char *message = NULL;
1859 /* Don't generate plymouth events if the service was already
1860 * started and we're just deserializing */
1861 if (m->n_reloading > 0)
1864 if (m->running_as != SYSTEMD_SYSTEM)
1867 if (detect_container(NULL) > 0)
1870 if (u->type != UNIT_SERVICE &&
1871 u->type != UNIT_MOUNT &&
1872 u->type != UNIT_SWAP)
1875 /* We set SOCK_NONBLOCK here so that we rather drop the
1876 * message then wait for plymouth */
1877 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1879 log_error("socket() failed: %m");
1884 sa.sa.sa_family = AF_UNIX;
1885 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1886 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1888 if (errno != EPIPE &&
1891 errno != ECONNREFUSED &&
1892 errno != ECONNRESET &&
1893 errno != ECONNABORTED)
1894 log_error("connect() failed: %m");
1899 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1905 if (write(fd, message, n + 1) != n + 1) {
1907 if (errno != EPIPE &&
1910 errno != ECONNREFUSED &&
1911 errno != ECONNRESET &&
1912 errno != ECONNABORTED)
1913 log_error("Failed to write Plymouth message: %m");
1920 close_nointr_nofail(fd);
1925 void manager_dispatch_bus_name_owner_changed(
1928 const char* old_owner,
1929 const char *new_owner) {
1936 u = hashmap_get(m->watch_bus, name);
1940 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1943 int manager_open_serialization(Manager *m, FILE **_f) {
1950 if (m->running_as == SYSTEMD_SYSTEM)
1951 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1953 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1958 RUN_WITH_UMASK(0077) {
1959 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1969 log_debug("Serializing state to %s", path);
1972 f = fdopen(fd, "w+");
1981 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
1994 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1995 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1996 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1997 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1999 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2000 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2001 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2002 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2005 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2006 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2007 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2008 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2009 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2010 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2011 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2012 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2015 if (!switching_root) {
2016 STRV_FOREACH(e, m->environment) {
2017 _cleanup_free_ char *ce;
2023 fprintf(f, "env=%s\n", *e);
2027 if (m->kdbus_fd >= 0) {
2030 copy = fdset_put_dup(fds, m->kdbus_fd);
2034 fprintf(f, "kdbus-fd=%i\n", copy);
2037 bus_serialize(m, f);
2041 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2045 if (!unit_can_serialize(u))
2052 r = unit_serialize(u, f, fds, !switching_root);
2059 assert(m->n_reloading > 0);
2065 r = bus_fdset_add_all(m, fds);
2072 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2078 log_debug("Deserializing state...");
2083 char line[LINE_MAX], *l;
2085 if (!fgets(line, sizeof(line), f)) {
2100 if (startswith(l, "current-job-id=")) {
2103 if (safe_atou32(l+15, &id) < 0)
2104 log_debug("Failed to parse current job id value %s", l+15);
2106 m->current_job_id = MAX(m->current_job_id, id);
2108 } else if (startswith(l, "n-installed-jobs=")) {
2111 if (safe_atou32(l+17, &n) < 0)
2112 log_debug("Failed to parse installed jobs counter %s", l+17);
2114 m->n_installed_jobs += n;
2116 } else if (startswith(l, "n-failed-jobs=")) {
2119 if (safe_atou32(l+14, &n) < 0)
2120 log_debug("Failed to parse failed jobs counter %s", l+14);
2122 m->n_failed_jobs += n;
2124 } else if (startswith(l, "taint-usr=")) {
2127 b = parse_boolean(l+10);
2129 log_debug("Failed to parse taint /usr flag %s", l+10);
2131 m->taint_usr = m->taint_usr || b;
2133 } else if (startswith(l, "firmware-timestamp="))
2134 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2135 else if (startswith(l, "loader-timestamp="))
2136 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2137 else if (startswith(l, "kernel-timestamp="))
2138 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2139 else if (startswith(l, "initrd-timestamp="))
2140 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2141 else if (startswith(l, "userspace-timestamp="))
2142 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2143 else if (startswith(l, "finish-timestamp="))
2144 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2145 else if (startswith(l, "security-start-timestamp="))
2146 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2147 else if (startswith(l, "security-finish-timestamp="))
2148 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2149 else if (startswith(l, "generators-start-timestamp="))
2150 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2151 else if (startswith(l, "generators-finish-timestamp="))
2152 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2153 else if (startswith(l, "units-load-start-timestamp="))
2154 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2155 else if (startswith(l, "units-load-finish-timestamp="))
2156 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2157 else if (startswith(l, "env=")) {
2158 _cleanup_free_ char *uce = NULL;
2161 uce = cunescape(l+4);
2167 e = strv_env_set(m->environment, uce);
2173 strv_free(m->environment);
2176 } else if (startswith(l, "kdbus-fd=")) {
2179 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2180 log_debug("Failed to parse kdbus fd: %s", l + 9);
2182 if (m->kdbus_fd >= 0)
2183 close_nointr_nofail(m->kdbus_fd);
2185 m->kdbus_fd = fdset_remove(fds, fd);
2188 } else if (bus_deserialize_item(m, l) == 0)
2189 log_debug("Unknown serialization item '%s'", l);
2194 char name[UNIT_NAME_MAX+2];
2197 if (!fgets(name, sizeof(name), f)) {
2208 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2212 r = unit_deserialize(u, f, fds);
2221 assert(m->n_reloading > 0);
2227 int manager_reload(Manager *m) {
2229 _cleanup_fclose_ FILE *f = NULL;
2230 _cleanup_fdset_free_ FDSet *fds = NULL;
2234 r = manager_open_serialization(m, &f);
2239 bus_manager_send_reloading(m, true);
2247 r = manager_serialize(m, f, fds, false);
2253 if (fseeko(f, 0, SEEK_SET) < 0) {
2258 /* From here on there is no way back. */
2259 manager_clear_jobs_and_units(m);
2260 manager_undo_generators(m);
2261 lookup_paths_free(&m->lookup_paths);
2263 /* Find new unit paths */
2264 manager_run_generators(m);
2266 q = lookup_paths_init(
2267 &m->lookup_paths, m->running_as, true,
2268 m->generator_unit_path,
2269 m->generator_unit_path_early,
2270 m->generator_unit_path_late);
2274 manager_build_unit_path_cache(m);
2276 /* First, enumerate what we can from all config files */
2277 q = manager_enumerate(m);
2281 /* Second, deserialize our stored data */
2282 q = manager_deserialize(m, f, fds);
2289 /* Third, fire things up! */
2290 q = manager_coldplug(m);
2294 assert(m->n_reloading > 0);
2297 m->send_reloading_done = true;
2302 static bool manager_is_booting_or_shutting_down(Manager *m) {
2307 /* Is the initial job still around? */
2308 if (manager_get_job(m, m->default_unit_job_id))
2311 /* Is there a job for the shutdown target? */
2312 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2319 bool manager_is_reloading_or_reexecuting(Manager *m) {
2322 return m->n_reloading != 0;
2325 void manager_reset_failed(Manager *m) {
2331 HASHMAP_FOREACH(u, m->units, i)
2332 unit_reset_failed(u);
2335 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2341 /* Returns true if the unit is inactive or going down */
2342 u = manager_get_unit(m, name);
2346 return unit_inactive_or_pending(u);
2349 void manager_check_finished(Manager *m) {
2350 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2351 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2355 if (m->n_running_jobs == 0)
2356 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2358 if (hashmap_size(m->jobs) > 0) {
2359 if (m->jobs_in_progress_event_source)
2360 sd_event_source_set_time(m->jobs_in_progress_event_source, JOBS_IN_PROGRESS_PERIOD_SEC);
2364 /* Notify Type=idle units that we are done now */
2365 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2366 manager_close_idle_pipe(m);
2368 /* Turn off confirm spawn now */
2369 m->confirm_spawn = false;
2371 if (dual_timestamp_is_set(&m->finish_timestamp))
2374 dual_timestamp_get(&m->finish_timestamp);
2376 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2378 /* Note that m->kernel_usec.monotonic is always at 0,
2379 * and m->firmware_usec.monotonic and
2380 * m->loader_usec.monotonic should be considered
2381 * negative values. */
2383 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2384 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2385 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2386 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2388 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2390 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2391 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2393 if (!log_on_console())
2394 log_struct(LOG_INFO,
2395 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2396 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2397 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2398 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2399 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2400 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2401 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2402 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2403 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2406 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2409 if (!log_on_console())
2410 log_struct(LOG_INFO,
2411 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2412 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2413 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2414 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2415 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2416 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2417 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2421 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2422 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2424 if (!log_on_console())
2425 log_struct(LOG_INFO,
2426 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2427 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2428 "MESSAGE=Startup finished in %s.",
2429 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2433 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2436 "READY=1\nSTATUS=Startup finished in %s.",
2437 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2440 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2451 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2453 p = strappend("/run/systemd/", name);
2457 r = mkdir_p_label(p, 0755);
2459 log_error("Failed to create generator directory %s: %s",
2465 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2470 log_error("Failed to create generator directory %s: %m",
2481 static void trim_generator_dir(Manager *m, char **generator) {
2488 if (rmdir(*generator) >= 0) {
2496 void manager_run_generators(Manager *m) {
2497 _cleanup_closedir_ DIR *d = NULL;
2498 const char *generator_path;
2499 const char *argv[5];
2504 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2505 d = opendir(generator_path);
2507 if (errno == ENOENT)
2510 log_error("Failed to enumerate generator directory %s: %m",
2515 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2519 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2523 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2527 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2528 argv[1] = m->generator_unit_path;
2529 argv[2] = m->generator_unit_path_early;
2530 argv[3] = m->generator_unit_path_late;
2533 RUN_WITH_UMASK(0022)
2534 execute_directory(generator_path, d, (char**) argv);
2537 trim_generator_dir(m, &m->generator_unit_path);
2538 trim_generator_dir(m, &m->generator_unit_path_early);
2539 trim_generator_dir(m, &m->generator_unit_path_late);
2542 static void remove_generator_dir(Manager *m, char **generator) {
2549 strv_remove(m->lookup_paths.unit_path, *generator);
2550 rm_rf(*generator, false, true, false);
2556 void manager_undo_generators(Manager *m) {
2559 remove_generator_dir(m, &m->generator_unit_path);
2560 remove_generator_dir(m, &m->generator_unit_path_early);
2561 remove_generator_dir(m, &m->generator_unit_path_late);
2564 int manager_environment_add(Manager *m, char **minus, char **plus) {
2565 char **a = NULL, **b = NULL, **l;
2570 if (!strv_isempty(minus)) {
2571 a = strv_env_delete(l, 1, minus);
2578 if (!strv_isempty(plus)) {
2579 b = strv_env_merge(2, l, plus);
2586 if (m->environment != l)
2587 strv_free(m->environment);
2593 m->environment = strv_sort(l);
2597 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2602 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2603 if (!default_rlimit[i])
2606 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2614 void manager_recheck_journal(Manager *m) {
2619 if (m->running_as != SYSTEMD_SYSTEM)
2622 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2623 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2624 log_close_journal();
2628 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2629 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2630 log_close_journal();
2634 /* Hmm, OK, so the socket is fully up and the service is up
2635 * too, then let's make use of the thing. */
2639 void manager_set_show_status(Manager *m, bool b) {
2642 if (m->running_as != SYSTEMD_SYSTEM)
2648 touch("/run/systemd/show-status");
2650 unlink("/run/systemd/show-status");
2653 static bool manager_get_show_status(Manager *m) {
2656 if (m->running_as != SYSTEMD_SYSTEM)
2659 if (m->no_console_output)
2665 /* If Plymouth is running make sure we show the status, so
2666 * that there's something nice to see when people press Esc */
2668 return plymouth_running();
2671 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2674 if (!manager_get_show_status(m))
2677 /* XXX We should totally drop the check for ephemeral here
2678 * and thus effectively make 'Type=idle' pointless. */
2679 if (ephemeral && m->n_on_console > 0)
2682 if (!manager_is_booting_or_shutting_down(m))
2685 va_start(ap, format);
2686 status_vprintf(status, true, ephemeral, format, ap);
2690 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2691 _cleanup_free_ char *p = NULL;
2699 p = unit_name_from_path(path, suffix);
2703 found = manager_get_unit(m, p);
2713 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2714 char p[strlen(path)+1];
2720 path_kill_slashes(p);
2722 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);