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/>.
25 #include <sys/epoll.h>
27 #include <sys/signalfd.h>
31 #include <sys/reboot.h>
32 #include <sys/ioctl.h>
36 #include <sys/types.h>
39 #include <sys/timerfd.h>
45 #include "sd-daemon.h"
47 #include "sd-messages.h"
50 #include "transaction.h"
57 #include "ratelimit.h"
58 #include "locale-setup.h"
59 #include "mount-setup.h"
60 #include "unit-name.h"
62 #include "path-lookup.h"
64 #include "exit-status.h"
67 #include "cgroup-util.h"
68 #include "path-util.h"
70 #include "boot-timestamps.h"
72 #include "bus-errors.h"
73 #include "bus-error.h"
76 #include "dbus-unit.h"
78 #include "dbus-manager.h"
79 #include "bus-kernel.h"
81 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
82 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
84 /* Initial delay and the interval for printing status messages about running jobs */
85 #define JOBS_IN_PROGRESS_WAIT_SEC 5
86 #define JOBS_IN_PROGRESS_PERIOD_SEC 1
87 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
89 /* Where clients shall send notification messages to */
90 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
92 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
94 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
95 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
96 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
97 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
98 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
99 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
101 static int manager_setup_notify(Manager *m) {
104 struct sockaddr_un un;
106 .sa.sa_family = AF_UNIX,
110 m->notify_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
111 if (m->notify_fd < 0) {
112 log_error("Failed to allocate notification socket: %m");
116 if (getpid() != 1 || detect_container(NULL) > 0)
117 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
119 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
120 sa.un.sun_path[0] = 0;
122 r = bind(m->notify_fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
124 log_error("bind() failed: %m");
128 r = setsockopt(m->notify_fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
130 log_error("SO_PASSCRED failed: %m");
134 r = sd_event_add_io(m->event, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m, &m->notify_event_source);
136 log_error("Failed to allocate notify event source: %s", strerror(-r));
140 sa.un.sun_path[0] = '@';
141 m->notify_socket = strdup(sa.un.sun_path);
142 if (!m->notify_socket)
145 log_debug("Using notification socket %s", m->notify_socket);
150 static int manager_watch_jobs_in_progress(Manager *m) {
153 if (m->jobs_in_progress_event_source)
156 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);
159 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
161 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
164 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
165 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
169 p = mempset(p, ' ', pos-2);
170 p = stpcpy(p, ANSI_RED_ON);
174 if (pos > 0 && pos <= width) {
175 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
179 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
182 p = stpcpy(p, ANSI_RED_ON);
185 p = mempset(p, ' ', width-1-pos);
186 strcpy(p, ANSI_HIGHLIGHT_OFF);
190 static void manager_print_jobs_in_progress(Manager *m) {
191 _cleanup_free_ char *job_of_n = NULL;
194 unsigned counter = 0, print_nr;
195 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
200 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
202 HASHMAP_FOREACH(j, m->jobs, i)
203 if (j->state == JOB_RUNNING && counter++ == print_nr)
206 /* m->n_running_jobs must be consistent with the contents of m->jobs,
207 * so the above loop must have succeeded in finding j. */
208 assert(counter == print_nr + 1);
211 cylon_pos = m->jobs_in_progress_iteration % 14;
213 cylon_pos = 14 - cylon_pos;
214 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
216 if (m->n_running_jobs > 1)
217 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
220 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
221 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
223 m->jobs_in_progress_iteration++;
226 static int manager_watch_idle_pipe(Manager *m) {
231 if (m->idle_pipe_event_source)
234 if (m->idle_pipe[2] < 0)
237 r = sd_event_add_io(m->event, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m, &m->idle_pipe_event_source);
239 log_error("Failed to watch idle pipe: %s", strerror(-r));
246 static void manager_close_idle_pipe(Manager *m) {
249 close_pipe(m->idle_pipe);
250 close_pipe(m->idle_pipe + 2);
253 static int manager_setup_time_change(Manager *m) {
256 /* We only care for the cancellation event, hence we set the
257 * timeout to the latest possible value. */
258 struct itimerspec its = {
259 .it_value.tv_sec = TIME_T_MAX,
263 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
265 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
266 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
268 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
269 if (m->time_change_fd < 0) {
270 log_error("Failed to create timerfd: %m");
274 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
275 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
276 close_nointr_nofail(m->time_change_fd);
277 m->time_change_fd = -1;
281 r = sd_event_add_io(m->event, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m, &m->time_change_event_source);
283 log_error("Failed to create time change event source: %s", strerror(-r));
287 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
292 static int enable_special_signals(Manager *m) {
293 _cleanup_close_ int fd = -1;
297 /* Enable that we get SIGINT on control-alt-del. In containers
298 * this will fail with EPERM (older) or EINVAL (newer), so
300 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
301 log_warning("Failed to enable ctrl-alt-del handling: %m");
303 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
305 /* Support systems without virtual console */
307 log_warning("Failed to open /dev/tty0: %m");
309 /* Enable that we get SIGWINCH on kbrequest */
310 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
311 log_warning("Failed to enable kbrequest handling: %m");
317 static int manager_setup_signals(Manager *m) {
318 struct sigaction sa = {
319 .sa_handler = SIG_DFL,
320 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
327 /* We are not interested in SIGSTOP and friends. */
328 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
330 assert_se(sigemptyset(&mask) == 0);
332 sigset_add_many(&mask,
333 SIGCHLD, /* Child died */
334 SIGTERM, /* Reexecute daemon */
335 SIGHUP, /* Reload configuration */
336 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
337 SIGUSR2, /* systemd: dump status */
338 SIGINT, /* Kernel sends us this on control-alt-del */
339 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
340 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
341 SIGRTMIN+0, /* systemd: start default.target */
342 SIGRTMIN+1, /* systemd: isolate rescue.target */
343 SIGRTMIN+2, /* systemd: isolate emergency.target */
344 SIGRTMIN+3, /* systemd: start halt.target */
345 SIGRTMIN+4, /* systemd: start poweroff.target */
346 SIGRTMIN+5, /* systemd: start reboot.target */
347 SIGRTMIN+6, /* systemd: start kexec.target */
348 SIGRTMIN+13, /* systemd: Immediate halt */
349 SIGRTMIN+14, /* systemd: Immediate poweroff */
350 SIGRTMIN+15, /* systemd: Immediate reboot */
351 SIGRTMIN+16, /* systemd: Immediate kexec */
352 SIGRTMIN+20, /* systemd: enable status messages */
353 SIGRTMIN+21, /* systemd: disable status messages */
354 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
355 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
356 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
357 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
358 SIGRTMIN+27, /* systemd: set log target to console */
359 SIGRTMIN+28, /* systemd: set log target to kmsg */
360 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
362 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
364 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
365 if (m->signal_fd < 0)
368 r = sd_event_add_io(m->event, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m, &m->signal_event_source);
372 /* Process signals a bit earlier than the rest of things */
373 r = sd_event_source_set_priority(m->signal_event_source, -5);
377 if (m->running_as == SYSTEMD_SYSTEM)
378 return enable_special_signals(m);
383 static int manager_default_environment(Manager *m) {
386 if (m->running_as == SYSTEMD_SYSTEM) {
387 /* The system manager always starts with a clean
388 * environment for its children. It does not import
389 * the kernel or the parents exported variables.
391 * The initial passed environ is untouched to keep
392 * /proc/self/environ valid; it is used for tagging
393 * the init process inside containers. */
394 m->environment = strv_new("PATH=" DEFAULT_PATH,
397 /* Import locale variables LC_*= from configuration */
398 locale_setup(&m->environment);
400 /* The user manager passes its own environment
401 * along to its children. */
402 m->environment = strv_copy(environ);
407 strv_sort(m->environment);
412 static int manager_setup_kdbus(Manager *m) {
413 _cleanup_free_ char *p = NULL;
418 if (m->kdbus_fd >= 0)
421 /* If there's already a bus address set, don't set up kdbus */
422 if (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"))
425 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", &p);
426 if (m->kdbus_fd < 0) {
427 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
431 log_debug("Successfully set up kdbus on %s", p);
437 static int manager_connect_bus(Manager *m, bool reexecuting) {
438 bool try_bus_connect;
445 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
447 /* Try to connect to the busses, if possible. */
448 return bus_init(m, try_bus_connect);
451 int manager_new(SystemdRunningAs running_as, Manager **_m) {
456 assert(running_as >= 0);
457 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
459 m = new0(Manager, 1);
464 if (detect_container(NULL) <= 0)
465 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
468 m->running_as = running_as;
469 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
471 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
473 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;
474 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
476 r = manager_default_environment(m);
480 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
484 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
488 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
492 r = hashmap_ensure_allocated(&m->watch_pids, trivial_hash_func, trivial_compare_func);
496 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
500 r = sd_event_default(&m->event);
504 r = sd_event_add_defer(m->event, manager_dispatch_run_queue, m, &m->run_queue_event_source);
508 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
512 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
516 r = manager_setup_signals(m);
520 r = manager_setup_cgroup(m);
524 r = manager_setup_notify(m);
528 r = manager_setup_time_change(m);
532 m->udev = udev_new();
538 m->taint_usr = dir_is_empty("/usr") > 0;
548 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
554 while ((u = m->cleanup_queue)) {
555 assert(u->in_cleanup_queue);
565 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
566 GC_OFFSET_UNSURE, /* No clue */
567 GC_OFFSET_GOOD, /* We still need this unit */
568 GC_OFFSET_BAD, /* We don't need this unit anymore */
572 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
579 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
580 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
581 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
584 if (u->in_cleanup_queue)
587 if (unit_check_gc(u))
590 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
594 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
595 unit_gc_sweep(other, gc_marker);
597 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
600 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
607 /* We were unable to find anything out about this entry, so
608 * let's investigate it later */
609 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
610 unit_add_to_gc_queue(u);
614 /* We definitely know that this one is not useful anymore, so
615 * let's mark it for deletion */
616 u->gc_marker = gc_marker + GC_OFFSET_BAD;
617 unit_add_to_cleanup_queue(u);
621 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
624 static unsigned manager_dispatch_gc_queue(Manager *m) {
631 /* log_debug("Running GC..."); */
633 m->gc_marker += _GC_OFFSET_MAX;
634 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
637 gc_marker = m->gc_marker;
639 while ((u = m->gc_queue)) {
640 assert(u->in_gc_queue);
642 unit_gc_sweep(u, gc_marker);
644 LIST_REMOVE(gc_queue, m->gc_queue, u);
645 u->in_gc_queue = false;
649 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
650 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
651 log_debug_unit(u->id, "Collecting %s", u->id);
652 u->gc_marker = gc_marker + GC_OFFSET_BAD;
653 unit_add_to_cleanup_queue(u);
657 m->n_in_gc_queue = 0;
662 static void manager_clear_jobs_and_units(Manager *m) {
667 while ((u = hashmap_first(m->units)))
670 manager_dispatch_cleanup_queue(m);
672 assert(!m->load_queue);
673 assert(!m->run_queue);
674 assert(!m->dbus_unit_queue);
675 assert(!m->dbus_job_queue);
676 assert(!m->cleanup_queue);
677 assert(!m->gc_queue);
679 assert(hashmap_isempty(m->jobs));
680 assert(hashmap_isempty(m->units));
683 m->n_running_jobs = 0;
686 void manager_free(Manager *m) {
692 manager_clear_jobs_and_units(m);
694 for (c = 0; c < _UNIT_TYPE_MAX; c++)
695 if (unit_vtable[c]->shutdown)
696 unit_vtable[c]->shutdown(m);
698 /* If we reexecute ourselves, we keep the root cgroup
700 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
702 manager_undo_generators(m);
706 hashmap_free(m->units);
707 hashmap_free(m->jobs);
708 hashmap_free(m->watch_pids);
709 hashmap_free(m->watch_bus);
711 sd_event_source_unref(m->signal_event_source);
712 sd_event_source_unref(m->notify_event_source);
713 sd_event_source_unref(m->time_change_event_source);
714 sd_event_source_unref(m->jobs_in_progress_event_source);
715 sd_event_source_unref(m->idle_pipe_event_source);
716 sd_event_source_unref(m->run_queue_event_source);
718 if (m->signal_fd >= 0)
719 close_nointr_nofail(m->signal_fd);
720 if (m->notify_fd >= 0)
721 close_nointr_nofail(m->notify_fd);
722 if (m->time_change_fd >= 0)
723 close_nointr_nofail(m->time_change_fd);
724 if (m->kdbus_fd >= 0)
725 close_nointr_nofail(m->kdbus_fd);
727 manager_close_idle_pipe(m);
730 sd_event_unref(m->event);
732 free(m->notify_socket);
734 lookup_paths_free(&m->lookup_paths);
735 strv_free(m->environment);
737 hashmap_free(m->cgroup_unit);
738 set_free_free(m->unit_path_cache);
740 free(m->switch_root);
741 free(m->switch_root_init);
743 for (i = 0; i < RLIMIT_NLIMITS; i++)
746 assert(hashmap_isempty(m->units_requiring_mounts_for));
747 hashmap_free(m->units_requiring_mounts_for);
752 int manager_enumerate(Manager *m) {
758 /* Let's ask every type to load all units from disk/kernel
759 * that it might know */
760 for (c = 0; c < _UNIT_TYPE_MAX; c++)
761 if (unit_vtable[c]->enumerate) {
762 q = unit_vtable[c]->enumerate(m);
767 manager_dispatch_load_queue(m);
771 static int manager_coldplug(Manager *m) {
779 /* Then, let's set up their initial state. */
780 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
786 if ((q = unit_coldplug(u)) < 0)
793 static void manager_build_unit_path_cache(Manager *m) {
795 _cleanup_free_ DIR *d = NULL;
800 set_free_free(m->unit_path_cache);
802 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
803 if (!m->unit_path_cache) {
804 log_error("Failed to allocate unit path cache.");
808 /* This simply builds a list of files we know exist, so that
809 * we don't always have to go to disk */
811 STRV_FOREACH(i, m->lookup_paths.unit_path) {
817 log_error("Failed to open directory %s: %m", *i);
821 while ((de = readdir(d))) {
824 if (ignore_file(de->d_name))
827 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
833 r = set_consume(m->unit_path_cache, p);
845 log_error("Failed to build unit path cache: %s", strerror(-r));
847 set_free_free(m->unit_path_cache);
848 m->unit_path_cache = NULL;
852 static int manager_distribute_fds(Manager *m, FDSet *fds) {
859 HASHMAP_FOREACH(u, m->units, i) {
861 if (fdset_size(fds) <= 0)
864 if (UNIT_VTABLE(u)->distribute_fds) {
865 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
874 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
879 dual_timestamp_get(&m->generators_start_timestamp);
880 manager_run_generators(m);
881 dual_timestamp_get(&m->generators_finish_timestamp);
883 r = lookup_paths_init(
884 &m->lookup_paths, m->running_as, true,
885 m->generator_unit_path,
886 m->generator_unit_path_early,
887 m->generator_unit_path_late);
891 manager_build_unit_path_cache(m);
893 /* If we will deserialize make sure that during enumeration
894 * this is already known, so we increase the counter here
899 /* First, enumerate what we can from all config files */
900 dual_timestamp_get(&m->units_load_start_timestamp);
901 r = manager_enumerate(m);
902 dual_timestamp_get(&m->units_load_finish_timestamp);
904 /* Second, deserialize if there is something to deserialize */
906 q = manager_deserialize(m, serialization, fds);
911 /* Any fds left? Find some unit which wants them. This is
912 * useful to allow container managers to pass some file
913 * descriptors to us pre-initialized. This enables
914 * socket-based activation of entire containers. */
915 if (fdset_size(fds) > 0) {
916 q = manager_distribute_fds(m, fds);
921 /* We might have deserialized the kdbus control fd, but if we
922 * didn't, then let's create the bus now. */
923 manager_setup_kdbus(m);
924 manager_connect_bus(m, !!serialization);
926 /* Third, fire things up! */
927 q = manager_coldplug(m);
932 assert(m->n_reloading > 0);
935 /* Let's wait for the UnitNew/JobNew messages being
936 * sent, before we notify that the reload is
938 m->send_reloading_done = true;
944 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
949 assert(type < _JOB_TYPE_MAX);
951 assert(mode < _JOB_MODE_MAX);
953 if (mode == JOB_ISOLATE && type != JOB_START) {
954 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
958 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
959 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
963 log_debug_unit(unit->id,
964 "Trying to enqueue job %s/%s/%s", unit->id,
965 job_type_to_string(type), job_mode_to_string(mode));
967 job_type_collapse(&type, unit);
969 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
973 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
974 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
975 mode == JOB_IGNORE_DEPENDENCIES, e);
979 if (mode == JOB_ISOLATE) {
980 r = transaction_add_isolate_jobs(tr, m);
985 r = transaction_activate(tr, m, mode, e);
989 log_debug_unit(unit->id,
990 "Enqueued job %s/%s as %u", unit->id,
991 job_type_to_string(type), (unsigned) tr->anchor_job->id);
994 *_ret = tr->anchor_job;
996 transaction_free(tr);
1000 transaction_abort(tr);
1001 transaction_free(tr);
1005 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1010 assert(type < _JOB_TYPE_MAX);
1012 assert(mode < _JOB_MODE_MAX);
1014 r = manager_load_unit(m, name, NULL, NULL, &unit);
1018 return manager_add_job(m, type, unit, mode, override, e, _ret);
1021 Job *manager_get_job(Manager *m, uint32_t id) {
1024 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1027 Unit *manager_get_unit(Manager *m, const char *name) {
1031 return hashmap_get(m->units, name);
1034 unsigned manager_dispatch_load_queue(Manager *m) {
1040 /* Make sure we are not run recursively */
1041 if (m->dispatching_load_queue)
1044 m->dispatching_load_queue = true;
1046 /* Dispatches the load queue. Takes a unit from the queue and
1047 * tries to load its data until the queue is empty */
1049 while ((u = m->load_queue)) {
1050 assert(u->in_load_queue);
1056 m->dispatching_load_queue = false;
1060 int manager_load_unit_prepare(
1072 assert(name || path);
1074 /* This will prepare the unit for loading, but not actually
1075 * load anything from disk. */
1077 if (path && !is_path(path))
1078 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1081 name = path_get_file_name(path);
1083 t = unit_name_to_type(name);
1085 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false))
1086 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1088 ret = manager_get_unit(m, name);
1094 ret = unit_new(m, unit_vtable[t]->object_size);
1099 ret->fragment_path = strdup(path);
1100 if (!ret->fragment_path) {
1106 r = unit_add_name(ret, name);
1112 unit_add_to_load_queue(ret);
1113 unit_add_to_dbus_queue(ret);
1114 unit_add_to_gc_queue(ret);
1122 int manager_load_unit(
1133 /* This will load the service information files, but not actually
1134 * start any services or anything. */
1136 r = manager_load_unit_prepare(m, name, path, e, _ret);
1140 manager_dispatch_load_queue(m);
1143 *_ret = unit_follow_merge(*_ret);
1148 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1155 HASHMAP_FOREACH(j, s->jobs, i)
1156 job_dump(j, f, prefix);
1159 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1167 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1169 unit_dump(u, f, prefix);
1172 void manager_clear_jobs(Manager *m) {
1177 while ((j = hashmap_first(m->jobs)))
1178 /* No need to recurse. We're cancelling all jobs. */
1179 job_finish_and_invalidate(j, JOB_CANCELED, false);
1182 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1183 Manager *m = userdata;
1189 while ((j = m->run_queue)) {
1190 assert(j->installed);
1191 assert(j->in_run_queue);
1193 job_run_and_invalidate(j);
1196 if (m->n_running_jobs > 0)
1197 manager_watch_jobs_in_progress(m);
1199 if (m->n_on_console > 0)
1200 manager_watch_idle_pipe(m);
1205 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1212 if (m->dispatching_dbus_queue)
1215 m->dispatching_dbus_queue = true;
1217 while ((u = m->dbus_unit_queue)) {
1218 assert(u->in_dbus_queue);
1220 bus_unit_send_change_signal(u);
1224 while ((j = m->dbus_job_queue)) {
1225 assert(j->in_dbus_queue);
1227 bus_job_send_change_signal(j);
1231 m->dispatching_dbus_queue = false;
1233 if (m->send_reloading_done) {
1234 m->send_reloading_done = false;
1236 bus_manager_send_reloading(m, false);
1239 if (m->queued_message)
1240 bus_send_queued_message(m);
1245 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1246 Manager *m = userdata;
1250 assert(m->notify_fd == fd);
1252 if (revents != EPOLLIN) {
1253 log_warning("Got unexpected poll event for notify fd.");
1259 struct iovec iovec = {
1261 .iov_len = sizeof(buf)-1,
1265 struct cmsghdr cmsghdr;
1266 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1269 struct msghdr msghdr = {
1272 .msg_control = &control,
1273 .msg_controllen = sizeof(control),
1275 struct ucred *ucred;
1277 _cleanup_strv_free_ char **tags = NULL;
1279 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1284 if (errno == EAGAIN || errno == EINTR)
1290 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1291 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1292 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1293 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1294 log_warning("Received notify message without credentials. Ignoring.");
1298 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1300 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1302 u = manager_get_unit_by_pid(m, ucred->pid);
1304 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1309 assert((size_t) n < sizeof(buf));
1311 tags = strv_split(buf, "\n\r");
1315 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1317 if (UNIT_VTABLE(u)->notify_message)
1318 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1324 static int manager_dispatch_sigchld(Manager *m) {
1332 /* First we call waitd() for a PID and do not reap the
1333 * zombie. That way we can still access /proc/$PID for
1334 * it while it is a zombie. */
1335 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1337 if (errno == ECHILD)
1349 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1350 _cleanup_free_ char *name = NULL;
1352 get_process_comm(si.si_pid, &name);
1353 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1356 /* Let's flush any message the dying child might still
1357 * have queued for us. This ensures that the process
1358 * still exists in /proc so that we can figure out
1359 * which cgroup and hence unit it belongs to. */
1360 r = manager_dispatch_notify_fd(m->notify_event_source, m->notify_fd, EPOLLIN, m);
1364 /* And now figure out the unit this belongs to */
1365 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1367 u = manager_get_unit_by_pid(m, si.si_pid);
1369 /* And now, we actually reap the zombie. */
1370 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1377 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1380 log_debug("Child %lu died (code=%s, status=%i/%s)",
1381 (long unsigned) si.si_pid,
1382 sigchld_code_to_string(si.si_code),
1384 strna(si.si_code == CLD_EXITED
1385 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1386 : signal_to_string(si.si_status)));
1391 log_debug_unit(u->id,
1392 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1394 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1395 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1401 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1402 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1405 log_debug_unit(name, "Activating special unit %s", name);
1407 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1409 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1414 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1415 Manager *m = userdata;
1417 struct signalfd_siginfo sfsi;
1418 bool sigchld = false;
1421 assert(m->signal_fd == fd);
1423 if (revents != EPOLLIN) {
1424 log_warning("Got unexpected events from signal file descriptor.");
1429 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1430 if (n != sizeof(sfsi)) {
1435 if (errno == EINTR || errno == EAGAIN)
1441 if (sfsi.ssi_pid > 0) {
1444 get_process_comm(sfsi.ssi_pid, &p);
1446 log_debug("Received SIG%s from PID %lu (%s).",
1447 signal_to_string(sfsi.ssi_signo),
1448 (unsigned long) sfsi.ssi_pid, strna(p));
1451 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1453 switch (sfsi.ssi_signo) {
1460 if (m->running_as == SYSTEMD_SYSTEM) {
1461 /* This is for compatibility with the
1462 * original sysvinit */
1463 m->exit_code = MANAGER_REEXECUTE;
1470 if (m->running_as == SYSTEMD_SYSTEM) {
1471 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1475 /* Run the exit target if there is one, if not, just exit. */
1476 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1477 m->exit_code = MANAGER_EXIT;
1484 if (m->running_as == SYSTEMD_SYSTEM)
1485 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1487 /* This is a nop on non-init */
1491 if (m->running_as == SYSTEMD_SYSTEM)
1492 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1494 /* This is a nop on non-init */
1500 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1502 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1503 log_info("Trying to reconnect to bus...");
1507 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1508 log_info("Loading D-Bus service...");
1509 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1516 _cleanup_free_ char *dump = NULL;
1517 _cleanup_fclose_ FILE *f = NULL;
1520 f = open_memstream(&dump, &size);
1522 log_warning("Failed to allocate memory stream.");
1526 manager_dump_units(m, f, "\t");
1527 manager_dump_jobs(m, f, "\t");
1530 log_warning("Failed to write status stream");
1534 log_dump(LOG_INFO, dump);
1539 m->exit_code = MANAGER_RELOAD;
1544 /* Starting SIGRTMIN+0 */
1545 static const char * const target_table[] = {
1546 [0] = SPECIAL_DEFAULT_TARGET,
1547 [1] = SPECIAL_RESCUE_TARGET,
1548 [2] = SPECIAL_EMERGENCY_TARGET,
1549 [3] = SPECIAL_HALT_TARGET,
1550 [4] = SPECIAL_POWEROFF_TARGET,
1551 [5] = SPECIAL_REBOOT_TARGET,
1552 [6] = SPECIAL_KEXEC_TARGET
1555 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1556 static const ManagerExitCode code_table[] = {
1558 [1] = MANAGER_POWEROFF,
1559 [2] = MANAGER_REBOOT,
1563 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1564 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1565 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1566 manager_start_target(m, target_table[idx],
1567 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1571 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1572 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1573 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1577 switch (sfsi.ssi_signo - SIGRTMIN) {
1580 log_debug("Enabling showing of status.");
1581 manager_set_show_status(m, true);
1585 log_debug("Disabling showing of status.");
1586 manager_set_show_status(m, false);
1590 log_set_max_level(LOG_DEBUG);
1591 log_notice("Setting log level to debug.");
1595 log_set_max_level(LOG_INFO);
1596 log_notice("Setting log level to info.");
1600 if (m->running_as == SYSTEMD_USER) {
1601 m->exit_code = MANAGER_EXIT;
1605 /* This is a nop on init */
1609 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1610 log_notice("Setting log target to journal-or-kmsg.");
1614 log_set_target(LOG_TARGET_CONSOLE);
1615 log_notice("Setting log target to console.");
1619 log_set_target(LOG_TARGET_KMSG);
1620 log_notice("Setting log target to kmsg.");
1624 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1625 log_notice("Setting log target to syslog-or-kmsg.");
1629 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1636 return manager_dispatch_sigchld(m);
1641 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1642 Manager *m = userdata;
1647 assert(m->time_change_fd == fd);
1649 log_struct(LOG_INFO,
1650 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1651 "MESSAGE=Time has been changed",
1654 /* Restart the watch */
1655 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1657 close_nointr_nofail(m->time_change_fd);
1658 m->time_change_fd = -1;
1660 manager_setup_time_change(m);
1662 HASHMAP_FOREACH(u, m->units, i)
1663 if (UNIT_VTABLE(u)->time_change)
1664 UNIT_VTABLE(u)->time_change(u);
1669 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1670 Manager *m = userdata;
1673 assert(m->idle_pipe[2] == fd);
1675 m->no_console_output = m->n_on_console > 0;
1677 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1678 manager_close_idle_pipe(m);
1683 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1684 Manager *m = userdata;
1688 manager_print_jobs_in_progress(m);
1692 int manager_loop(Manager *m) {
1695 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1698 m->exit_code = MANAGER_RUNNING;
1700 /* Release the path cache */
1701 set_free_free(m->unit_path_cache);
1702 m->unit_path_cache = NULL;
1704 manager_check_finished(m);
1706 /* There might still be some zombies hanging around from
1707 * before we were exec()'ed. Let's reap them. */
1708 r = manager_dispatch_sigchld(m);
1712 while (m->exit_code == MANAGER_RUNNING) {
1715 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1718 if (!ratelimit_test(&rl)) {
1719 /* Yay, something is going seriously wrong, pause a little */
1720 log_warning("Looping too fast. Throttling execution a little.");
1725 if (manager_dispatch_load_queue(m) > 0)
1728 if (manager_dispatch_gc_queue(m) > 0)
1731 if (manager_dispatch_cleanup_queue(m) > 0)
1734 if (manager_dispatch_cgroup_queue(m) > 0)
1737 if (manager_dispatch_dbus_queue(m) > 0)
1740 /* Sleep for half the watchdog time */
1741 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1742 wait_usec = m->runtime_watchdog / 2;
1746 wait_usec = (usec_t) -1;
1748 r = sd_event_run(m->event, wait_usec);
1750 log_error("Failed to run event loop: %s", strerror(-r));
1755 return m->exit_code;
1758 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1759 _cleanup_free_ char *n = NULL;
1767 r = unit_name_from_dbus_path(s, &n);
1771 r = manager_load_unit(m, n, NULL, e, &u);
1780 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1790 p = startswith(s, "/org/freedesktop/systemd1/job/");
1794 r = safe_atou(p, &id);
1798 j = manager_get_job(m, id);
1807 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1813 audit_fd = get_audit_fd();
1817 /* Don't generate audit events if the service was already
1818 * started and we're just deserializing */
1819 if (m->n_reloading > 0)
1822 if (m->running_as != SYSTEMD_SYSTEM)
1825 if (u->type != UNIT_SERVICE)
1828 p = unit_name_to_prefix_and_instance(u->id);
1830 log_error_unit(u->id,
1831 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1835 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1836 if (errno == EPERM) {
1837 /* We aren't allowed to send audit messages?
1838 * Then let's not retry again. */
1841 log_warning("Failed to send audit message: %m");
1849 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1851 union sockaddr_union sa;
1853 char *message = NULL;
1855 /* Don't generate plymouth events if the service was already
1856 * started and we're just deserializing */
1857 if (m->n_reloading > 0)
1860 if (m->running_as != SYSTEMD_SYSTEM)
1863 if (detect_container(NULL) > 0)
1866 if (u->type != UNIT_SERVICE &&
1867 u->type != UNIT_MOUNT &&
1868 u->type != UNIT_SWAP)
1871 /* We set SOCK_NONBLOCK here so that we rather drop the
1872 * message then wait for plymouth */
1873 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1875 log_error("socket() failed: %m");
1880 sa.sa.sa_family = AF_UNIX;
1881 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1882 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1884 if (errno != EPIPE &&
1887 errno != ECONNREFUSED &&
1888 errno != ECONNRESET &&
1889 errno != ECONNABORTED)
1890 log_error("connect() failed: %m");
1895 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1901 if (write(fd, message, n + 1) != n + 1) {
1903 if (errno != EPIPE &&
1906 errno != ECONNREFUSED &&
1907 errno != ECONNRESET &&
1908 errno != ECONNABORTED)
1909 log_error("Failed to write Plymouth message: %m");
1916 close_nointr_nofail(fd);
1921 void manager_dispatch_bus_name_owner_changed(
1924 const char* old_owner,
1925 const char *new_owner) {
1932 u = hashmap_get(m->watch_bus, name);
1936 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1939 int manager_open_serialization(Manager *m, FILE **_f) {
1946 if (m->running_as == SYSTEMD_SYSTEM)
1947 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1949 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1954 RUN_WITH_UMASK(0077) {
1955 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1965 log_debug("Serializing state to %s", path);
1968 f = fdopen(fd, "w+");
1977 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
1990 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1991 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1992 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1993 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1995 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1996 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1997 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1998 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2001 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2002 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2003 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2004 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2005 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2006 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2007 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2008 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2011 if (!switching_root) {
2012 STRV_FOREACH(e, m->environment) {
2013 _cleanup_free_ char *ce;
2019 fprintf(f, "env=%s\n", *e);
2023 if (m->kdbus_fd >= 0) {
2026 copy = fdset_put_dup(fds, m->kdbus_fd);
2030 fprintf(f, "kdbus-fd=%i\n", copy);
2033 bus_serialize(m, f);
2037 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2041 if (!unit_can_serialize(u))
2048 r = unit_serialize(u, f, fds, !switching_root);
2055 assert(m->n_reloading > 0);
2061 r = bus_fdset_add_all(m, fds);
2068 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2074 log_debug("Deserializing state...");
2079 char line[LINE_MAX], *l;
2081 if (!fgets(line, sizeof(line), f)) {
2096 if (startswith(l, "current-job-id=")) {
2099 if (safe_atou32(l+15, &id) < 0)
2100 log_debug("Failed to parse current job id value %s", l+15);
2102 m->current_job_id = MAX(m->current_job_id, id);
2104 } else if (startswith(l, "n-installed-jobs=")) {
2107 if (safe_atou32(l+17, &n) < 0)
2108 log_debug("Failed to parse installed jobs counter %s", l+17);
2110 m->n_installed_jobs += n;
2112 } else if (startswith(l, "n-failed-jobs=")) {
2115 if (safe_atou32(l+14, &n) < 0)
2116 log_debug("Failed to parse failed jobs counter %s", l+14);
2118 m->n_failed_jobs += n;
2120 } else if (startswith(l, "taint-usr=")) {
2123 b = parse_boolean(l+10);
2125 log_debug("Failed to parse taint /usr flag %s", l+10);
2127 m->taint_usr = m->taint_usr || b;
2129 } else if (startswith(l, "firmware-timestamp="))
2130 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2131 else if (startswith(l, "loader-timestamp="))
2132 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2133 else if (startswith(l, "kernel-timestamp="))
2134 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2135 else if (startswith(l, "initrd-timestamp="))
2136 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2137 else if (startswith(l, "userspace-timestamp="))
2138 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2139 else if (startswith(l, "finish-timestamp="))
2140 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2141 else if (startswith(l, "security-start-timestamp="))
2142 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2143 else if (startswith(l, "security-finish-timestamp="))
2144 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2145 else if (startswith(l, "generators-start-timestamp="))
2146 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2147 else if (startswith(l, "generators-finish-timestamp="))
2148 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2149 else if (startswith(l, "units-load-start-timestamp="))
2150 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2151 else if (startswith(l, "units-load-finish-timestamp="))
2152 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2153 else if (startswith(l, "env=")) {
2154 _cleanup_free_ char *uce = NULL;
2157 uce = cunescape(l+4);
2163 e = strv_env_set(m->environment, uce);
2169 strv_free(m->environment);
2172 } else if (startswith(l, "kdbus-fd=")) {
2175 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2176 log_debug("Failed to parse kdbus fd: %s", l + 9);
2178 if (m->kdbus_fd >= 0)
2179 close_nointr_nofail(m->kdbus_fd);
2181 m->kdbus_fd = fdset_remove(fds, fd);
2184 } else if (bus_deserialize_item(m, l) == 0)
2185 log_debug("Unknown serialization item '%s'", l);
2190 char name[UNIT_NAME_MAX+2];
2193 if (!fgets(name, sizeof(name), f)) {
2204 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2208 r = unit_deserialize(u, f, fds);
2219 assert(m->n_reloading > 0);
2225 int manager_reload(Manager *m) {
2227 _cleanup_fclose_ FILE *f = NULL;
2228 _cleanup_fdset_free_ FDSet *fds = NULL;
2232 r = manager_open_serialization(m, &f);
2237 bus_manager_send_reloading(m, true);
2245 r = manager_serialize(m, f, fds, false);
2251 if (fseeko(f, 0, SEEK_SET) < 0) {
2256 /* From here on there is no way back. */
2257 manager_clear_jobs_and_units(m);
2258 manager_undo_generators(m);
2259 lookup_paths_free(&m->lookup_paths);
2261 /* Find new unit paths */
2262 manager_run_generators(m);
2264 q = lookup_paths_init(
2265 &m->lookup_paths, m->running_as, true,
2266 m->generator_unit_path,
2267 m->generator_unit_path_early,
2268 m->generator_unit_path_late);
2272 manager_build_unit_path_cache(m);
2274 /* First, enumerate what we can from all config files */
2275 q = manager_enumerate(m);
2279 /* Second, deserialize our stored data */
2280 q = manager_deserialize(m, f, fds);
2287 /* Third, fire things up! */
2288 q = manager_coldplug(m);
2292 assert(m->n_reloading > 0);
2295 m->send_reloading_done = true;
2300 static bool manager_is_booting_or_shutting_down(Manager *m) {
2305 /* Is the initial job still around? */
2306 if (manager_get_job(m, m->default_unit_job_id))
2309 /* Is there a job for the shutdown target? */
2310 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2317 bool manager_is_reloading_or_reexecuting(Manager *m) {
2320 return m->n_reloading != 0;
2323 void manager_reset_failed(Manager *m) {
2329 HASHMAP_FOREACH(u, m->units, i)
2330 unit_reset_failed(u);
2333 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2339 /* Returns true if the unit is inactive or going down */
2340 u = manager_get_unit(m, name);
2344 return unit_inactive_or_pending(u);
2347 void manager_check_finished(Manager *m) {
2348 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2349 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2353 if (m->n_running_jobs == 0)
2354 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2356 if (hashmap_size(m->jobs) > 0) {
2357 if (m->jobs_in_progress_event_source)
2358 sd_event_source_set_time(m->jobs_in_progress_event_source, JOBS_IN_PROGRESS_PERIOD_SEC);
2362 /* Notify Type=idle units that we are done now */
2363 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2364 manager_close_idle_pipe(m);
2366 /* Turn off confirm spawn now */
2367 m->confirm_spawn = false;
2369 if (dual_timestamp_is_set(&m->finish_timestamp))
2372 dual_timestamp_get(&m->finish_timestamp);
2374 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2376 /* Note that m->kernel_usec.monotonic is always at 0,
2377 * and m->firmware_usec.monotonic and
2378 * m->loader_usec.monotonic should be considered
2379 * negative values. */
2381 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2382 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2383 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2384 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2386 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2388 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2389 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2391 if (!log_on_console())
2392 log_struct(LOG_INFO,
2393 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2394 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2395 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2396 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2397 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2398 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2399 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2400 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2401 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2404 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2407 if (!log_on_console())
2408 log_struct(LOG_INFO,
2409 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2410 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2411 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2412 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2413 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2414 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2415 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2419 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2420 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2422 if (!log_on_console())
2423 log_struct(LOG_INFO,
2424 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2425 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2426 "MESSAGE=Startup finished in %s.",
2427 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2431 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2434 "READY=1\nSTATUS=Startup finished in %s.",
2435 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2438 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2449 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2451 p = strappend("/run/systemd/", name);
2455 r = mkdir_p_label(p, 0755);
2457 log_error("Failed to create generator directory %s: %s",
2463 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2468 log_error("Failed to create generator directory %s: %m",
2479 static void trim_generator_dir(Manager *m, char **generator) {
2486 if (rmdir(*generator) >= 0) {
2494 void manager_run_generators(Manager *m) {
2495 _cleanup_closedir_ DIR *d = NULL;
2496 const char *generator_path;
2497 const char *argv[5];
2502 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2503 d = opendir(generator_path);
2505 if (errno == ENOENT)
2508 log_error("Failed to enumerate generator directory %s: %m",
2513 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2517 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2521 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2525 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2526 argv[1] = m->generator_unit_path;
2527 argv[2] = m->generator_unit_path_early;
2528 argv[3] = m->generator_unit_path_late;
2531 RUN_WITH_UMASK(0022)
2532 execute_directory(generator_path, d, (char**) argv);
2535 trim_generator_dir(m, &m->generator_unit_path);
2536 trim_generator_dir(m, &m->generator_unit_path_early);
2537 trim_generator_dir(m, &m->generator_unit_path_late);
2540 static void remove_generator_dir(Manager *m, char **generator) {
2547 strv_remove(m->lookup_paths.unit_path, *generator);
2548 rm_rf(*generator, false, true, false);
2554 void manager_undo_generators(Manager *m) {
2557 remove_generator_dir(m, &m->generator_unit_path);
2558 remove_generator_dir(m, &m->generator_unit_path_early);
2559 remove_generator_dir(m, &m->generator_unit_path_late);
2562 int manager_environment_add(Manager *m, char **minus, char **plus) {
2563 char **a = NULL, **b = NULL, **l;
2568 if (!strv_isempty(minus)) {
2569 a = strv_env_delete(l, 1, minus);
2576 if (!strv_isempty(plus)) {
2577 b = strv_env_merge(2, l, plus);
2584 if (m->environment != l)
2585 strv_free(m->environment);
2591 m->environment = strv_sort(l);
2595 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2600 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2601 if (!default_rlimit[i])
2604 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2612 void manager_recheck_journal(Manager *m) {
2617 if (m->running_as != SYSTEMD_SYSTEM)
2620 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2621 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2622 log_close_journal();
2626 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2627 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2628 log_close_journal();
2632 /* Hmm, OK, so the socket is fully up and the service is up
2633 * too, then let's make use of the thing. */
2637 void manager_set_show_status(Manager *m, bool b) {
2640 if (m->running_as != SYSTEMD_SYSTEM)
2646 touch("/run/systemd/show-status");
2648 unlink("/run/systemd/show-status");
2651 static bool manager_get_show_status(Manager *m) {
2654 if (m->running_as != SYSTEMD_SYSTEM)
2657 if (m->no_console_output)
2663 /* If Plymouth is running make sure we show the status, so
2664 * that there's something nice to see when people press Esc */
2666 return plymouth_running();
2669 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2672 if (!manager_get_show_status(m))
2675 /* XXX We should totally drop the check for ephemeral here
2676 * and thus effectively make 'Type=idle' pointless. */
2677 if (ephemeral && m->n_on_console > 0)
2680 if (!manager_is_booting_or_shutting_down(m))
2683 va_start(ap, format);
2684 status_vprintf(status, true, ephemeral, format, ap);
2688 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2689 _cleanup_free_ char *p = NULL;
2697 p = unit_name_from_path(path, suffix);
2701 found = manager_get_unit(m, p);
2711 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2712 char p[strlen(path)+1];
2718 path_kill_slashes(p);
2720 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);