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 sa.un.sun_path[0] = '@';
139 m->notify_socket = strdup(sa.un.sun_path);
140 if (!m->notify_socket)
143 log_debug("Using notification socket %s", m->notify_socket);
148 static int manager_watch_jobs_in_progress(Manager *m) {
151 if (m->jobs_in_progress_event_source)
154 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);
157 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
159 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
162 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
163 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
167 p = mempset(p, ' ', pos-2);
168 p = stpcpy(p, ANSI_RED_ON);
172 if (pos > 0 && pos <= width) {
173 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
177 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
180 p = stpcpy(p, ANSI_RED_ON);
183 p = mempset(p, ' ', width-1-pos);
184 strcpy(p, ANSI_HIGHLIGHT_OFF);
188 static void manager_print_jobs_in_progress(Manager *m) {
189 _cleanup_free_ char *job_of_n = NULL;
192 unsigned counter = 0, print_nr;
193 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
198 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
200 HASHMAP_FOREACH(j, m->jobs, i)
201 if (j->state == JOB_RUNNING && counter++ == print_nr)
204 /* m->n_running_jobs must be consistent with the contents of m->jobs,
205 * so the above loop must have succeeded in finding j. */
206 assert(counter == print_nr + 1);
209 cylon_pos = m->jobs_in_progress_iteration % 14;
211 cylon_pos = 14 - cylon_pos;
212 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
214 if (m->n_running_jobs > 1)
215 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
218 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
219 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
221 m->jobs_in_progress_iteration++;
224 static int manager_watch_idle_pipe(Manager *m) {
229 if (m->idle_pipe_event_source)
232 if (m->idle_pipe[2] < 0)
235 r = sd_event_add_io(m->event, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m, &m->idle_pipe_event_source);
237 log_error("Failed to watch idle pipe: %s", strerror(-r));
244 static void manager_close_idle_pipe(Manager *m) {
247 close_pipe(m->idle_pipe);
248 close_pipe(m->idle_pipe + 2);
251 static int manager_setup_time_change(Manager *m) {
254 /* We only care for the cancellation event, hence we set the
255 * timeout to the latest possible value. */
256 struct itimerspec its = {
257 .it_value.tv_sec = TIME_T_MAX,
261 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
263 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
264 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
266 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
267 if (m->time_change_fd < 0) {
268 log_error("Failed to create timerfd: %m");
272 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
273 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
274 close_nointr_nofail(m->time_change_fd);
275 m->time_change_fd = -1;
279 r = sd_event_add_io(m->event, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m, &m->time_change_event_source);
281 log_error("Failed to create time change event source: %s", strerror(-r));
285 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
290 static int enable_special_signals(Manager *m) {
291 _cleanup_close_ int fd = -1;
295 /* Enable that we get SIGINT on control-alt-del. In containers
296 * this will fail with EPERM (older) or EINVAL (newer), so
298 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
299 log_warning("Failed to enable ctrl-alt-del handling: %m");
301 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
303 /* Support systems without virtual console */
305 log_warning("Failed to open /dev/tty0: %m");
307 /* Enable that we get SIGWINCH on kbrequest */
308 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
309 log_warning("Failed to enable kbrequest handling: %m");
315 static int manager_setup_signals(Manager *m) {
316 struct sigaction sa = {
317 .sa_handler = SIG_DFL,
318 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
325 /* We are not interested in SIGSTOP and friends. */
326 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
328 assert_se(sigemptyset(&mask) == 0);
330 sigset_add_many(&mask,
331 SIGCHLD, /* Child died */
332 SIGTERM, /* Reexecute daemon */
333 SIGHUP, /* Reload configuration */
334 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
335 SIGUSR2, /* systemd: dump status */
336 SIGINT, /* Kernel sends us this on control-alt-del */
337 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
338 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
339 SIGRTMIN+0, /* systemd: start default.target */
340 SIGRTMIN+1, /* systemd: isolate rescue.target */
341 SIGRTMIN+2, /* systemd: isolate emergency.target */
342 SIGRTMIN+3, /* systemd: start halt.target */
343 SIGRTMIN+4, /* systemd: start poweroff.target */
344 SIGRTMIN+5, /* systemd: start reboot.target */
345 SIGRTMIN+6, /* systemd: start kexec.target */
346 SIGRTMIN+13, /* systemd: Immediate halt */
347 SIGRTMIN+14, /* systemd: Immediate poweroff */
348 SIGRTMIN+15, /* systemd: Immediate reboot */
349 SIGRTMIN+16, /* systemd: Immediate kexec */
350 SIGRTMIN+20, /* systemd: enable status messages */
351 SIGRTMIN+21, /* systemd: disable status messages */
352 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
353 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
354 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
355 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
356 SIGRTMIN+27, /* systemd: set log target to console */
357 SIGRTMIN+28, /* systemd: set log target to kmsg */
358 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
360 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
362 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
363 if (m->signal_fd < 0)
366 r = sd_event_add_io(m->event, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m, &m->signal_event_source);
370 /* Process signals a bit earlier than the rest of things */
371 r = sd_event_source_set_priority(m->signal_event_source, -5);
375 if (m->running_as == SYSTEMD_SYSTEM)
376 return enable_special_signals(m);
381 static int manager_default_environment(Manager *m) {
384 if (m->running_as == SYSTEMD_SYSTEM) {
385 /* The system manager always starts with a clean
386 * environment for its children. It does not import
387 * the kernel or the parents exported variables.
389 * The initial passed environ is untouched to keep
390 * /proc/self/environ valid; it is used for tagging
391 * the init process inside containers. */
392 m->environment = strv_new("PATH=" DEFAULT_PATH,
395 /* Import locale variables LC_*= from configuration */
396 locale_setup(&m->environment);
398 /* The user manager passes its own environment
399 * along to its children. */
400 m->environment = strv_copy(environ);
405 strv_sort(m->environment);
410 static int manager_setup_kdbus(Manager *m) {
411 _cleanup_free_ char *p = NULL;
416 if (m->kdbus_fd >= 0)
419 /* If there's already a bus address set, don't set up kdbus */
420 if (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"))
423 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", &p);
424 if (m->kdbus_fd < 0) {
425 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
429 log_debug("Successfully set up kdbus on %s", p);
435 static int manager_connect_bus(Manager *m, bool reexecuting) {
436 bool try_bus_connect;
443 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
445 /* Try to connect to the busses, if possible. */
446 return bus_init(m, try_bus_connect);
449 int manager_new(SystemdRunningAs running_as, Manager **_m) {
454 assert(running_as >= 0);
455 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
457 m = new0(Manager, 1);
462 if (detect_container(NULL) <= 0)
463 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
466 m->running_as = running_as;
467 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
469 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
471 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;
472 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
474 r = manager_default_environment(m);
478 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
482 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
486 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
490 r = hashmap_ensure_allocated(&m->watch_pids, trivial_hash_func, trivial_compare_func);
494 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
498 r = sd_event_default(&m->event);
502 r = sd_event_add_defer(m->event, manager_dispatch_run_queue, m, &m->run_queue_event_source);
506 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
510 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
514 r = manager_setup_signals(m);
518 r = manager_setup_cgroup(m);
522 r = manager_setup_notify(m);
526 r = manager_setup_time_change(m);
530 m->udev = udev_new();
536 m->taint_usr = dir_is_empty("/usr") > 0;
546 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
552 while ((u = m->cleanup_queue)) {
553 assert(u->in_cleanup_queue);
563 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
564 GC_OFFSET_UNSURE, /* No clue */
565 GC_OFFSET_GOOD, /* We still need this unit */
566 GC_OFFSET_BAD, /* We don't need this unit anymore */
570 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
577 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
578 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
579 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
582 if (u->in_cleanup_queue)
585 if (unit_check_gc(u))
588 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
592 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
593 unit_gc_sweep(other, gc_marker);
595 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
598 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
605 /* We were unable to find anything out about this entry, so
606 * let's investigate it later */
607 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
608 unit_add_to_gc_queue(u);
612 /* We definitely know that this one is not useful anymore, so
613 * let's mark it for deletion */
614 u->gc_marker = gc_marker + GC_OFFSET_BAD;
615 unit_add_to_cleanup_queue(u);
619 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
622 static unsigned manager_dispatch_gc_queue(Manager *m) {
629 /* log_debug("Running GC..."); */
631 m->gc_marker += _GC_OFFSET_MAX;
632 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
635 gc_marker = m->gc_marker;
637 while ((u = m->gc_queue)) {
638 assert(u->in_gc_queue);
640 unit_gc_sweep(u, gc_marker);
642 LIST_REMOVE(gc_queue, m->gc_queue, u);
643 u->in_gc_queue = false;
647 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
648 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
649 log_debug_unit(u->id, "Collecting %s", u->id);
650 u->gc_marker = gc_marker + GC_OFFSET_BAD;
651 unit_add_to_cleanup_queue(u);
655 m->n_in_gc_queue = 0;
660 static void manager_clear_jobs_and_units(Manager *m) {
665 while ((u = hashmap_first(m->units)))
668 manager_dispatch_cleanup_queue(m);
670 assert(!m->load_queue);
671 assert(!m->run_queue);
672 assert(!m->dbus_unit_queue);
673 assert(!m->dbus_job_queue);
674 assert(!m->cleanup_queue);
675 assert(!m->gc_queue);
677 assert(hashmap_isempty(m->jobs));
678 assert(hashmap_isempty(m->units));
681 m->n_running_jobs = 0;
684 void manager_free(Manager *m) {
690 manager_clear_jobs_and_units(m);
692 for (c = 0; c < _UNIT_TYPE_MAX; c++)
693 if (unit_vtable[c]->shutdown)
694 unit_vtable[c]->shutdown(m);
696 /* If we reexecute ourselves, we keep the root cgroup
698 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
700 manager_undo_generators(m);
704 hashmap_free(m->units);
705 hashmap_free(m->jobs);
706 hashmap_free(m->watch_pids);
707 hashmap_free(m->watch_bus);
709 sd_event_source_unref(m->signal_event_source);
710 sd_event_source_unref(m->notify_event_source);
711 sd_event_source_unref(m->time_change_event_source);
712 sd_event_source_unref(m->jobs_in_progress_event_source);
713 sd_event_source_unref(m->idle_pipe_event_source);
714 sd_event_source_unref(m->run_queue_event_source);
716 if (m->signal_fd >= 0)
717 close_nointr_nofail(m->signal_fd);
718 if (m->notify_fd >= 0)
719 close_nointr_nofail(m->notify_fd);
720 if (m->time_change_fd >= 0)
721 close_nointr_nofail(m->time_change_fd);
722 if (m->kdbus_fd >= 0)
723 close_nointr_nofail(m->kdbus_fd);
725 manager_close_idle_pipe(m);
728 sd_event_unref(m->event);
730 free(m->notify_socket);
732 lookup_paths_free(&m->lookup_paths);
733 strv_free(m->environment);
735 hashmap_free(m->cgroup_unit);
736 set_free_free(m->unit_path_cache);
738 free(m->switch_root);
739 free(m->switch_root_init);
741 for (i = 0; i < RLIMIT_NLIMITS; i++)
744 assert(hashmap_isempty(m->units_requiring_mounts_for));
745 hashmap_free(m->units_requiring_mounts_for);
750 int manager_enumerate(Manager *m) {
756 /* Let's ask every type to load all units from disk/kernel
757 * that it might know */
758 for (c = 0; c < _UNIT_TYPE_MAX; c++)
759 if (unit_vtable[c]->enumerate) {
760 q = unit_vtable[c]->enumerate(m);
765 manager_dispatch_load_queue(m);
769 static int manager_coldplug(Manager *m) {
777 /* Then, let's set up their initial state. */
778 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
784 if ((q = unit_coldplug(u)) < 0)
791 static void manager_build_unit_path_cache(Manager *m) {
793 _cleanup_free_ DIR *d = NULL;
798 set_free_free(m->unit_path_cache);
800 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
801 if (!m->unit_path_cache) {
802 log_error("Failed to allocate unit path cache.");
806 /* This simply builds a list of files we know exist, so that
807 * we don't always have to go to disk */
809 STRV_FOREACH(i, m->lookup_paths.unit_path) {
815 log_error("Failed to open directory %s: %m", *i);
819 while ((de = readdir(d))) {
822 if (ignore_file(de->d_name))
825 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
831 r = set_consume(m->unit_path_cache, p);
843 log_error("Failed to build unit path cache: %s", strerror(-r));
845 set_free_free(m->unit_path_cache);
846 m->unit_path_cache = NULL;
850 static int manager_distribute_fds(Manager *m, FDSet *fds) {
857 HASHMAP_FOREACH(u, m->units, i) {
859 if (fdset_size(fds) <= 0)
862 if (UNIT_VTABLE(u)->distribute_fds) {
863 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
872 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
877 dual_timestamp_get(&m->generators_start_timestamp);
878 manager_run_generators(m);
879 dual_timestamp_get(&m->generators_finish_timestamp);
881 r = lookup_paths_init(
882 &m->lookup_paths, m->running_as, true,
883 m->generator_unit_path,
884 m->generator_unit_path_early,
885 m->generator_unit_path_late);
889 manager_build_unit_path_cache(m);
891 /* If we will deserialize make sure that during enumeration
892 * this is already known, so we increase the counter here
897 /* First, enumerate what we can from all config files */
898 dual_timestamp_get(&m->units_load_start_timestamp);
899 r = manager_enumerate(m);
900 dual_timestamp_get(&m->units_load_finish_timestamp);
902 /* Second, deserialize if there is something to deserialize */
904 q = manager_deserialize(m, serialization, fds);
909 /* Any fds left? Find some unit which wants them. This is
910 * useful to allow container managers to pass some file
911 * descriptors to us pre-initialized. This enables
912 * socket-based activation of entire containers. */
913 if (fdset_size(fds) > 0) {
914 q = manager_distribute_fds(m, fds);
919 /* We might have deserialized the kdbus control fd, but if we
920 * didn't, then let's create the bus now. */
921 manager_setup_kdbus(m);
922 manager_connect_bus(m, !!serialization);
924 /* Third, fire things up! */
925 q = manager_coldplug(m);
930 assert(m->n_reloading > 0);
933 /* Let's wait for the UnitNew/JobNew messages being
934 * sent, before we notify that the reload is
936 m->send_reloading_done = true;
942 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
947 assert(type < _JOB_TYPE_MAX);
949 assert(mode < _JOB_MODE_MAX);
951 if (mode == JOB_ISOLATE && type != JOB_START) {
952 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
956 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
957 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
961 log_debug_unit(unit->id,
962 "Trying to enqueue job %s/%s/%s", unit->id,
963 job_type_to_string(type), job_mode_to_string(mode));
965 job_type_collapse(&type, unit);
967 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
971 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
972 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
973 mode == JOB_IGNORE_DEPENDENCIES, e);
977 if (mode == JOB_ISOLATE) {
978 r = transaction_add_isolate_jobs(tr, m);
983 r = transaction_activate(tr, m, mode, e);
987 log_debug_unit(unit->id,
988 "Enqueued job %s/%s as %u", unit->id,
989 job_type_to_string(type), (unsigned) tr->anchor_job->id);
992 *_ret = tr->anchor_job;
994 transaction_free(tr);
998 transaction_abort(tr);
999 transaction_free(tr);
1003 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1008 assert(type < _JOB_TYPE_MAX);
1010 assert(mode < _JOB_MODE_MAX);
1012 r = manager_load_unit(m, name, NULL, NULL, &unit);
1016 return manager_add_job(m, type, unit, mode, override, e, _ret);
1019 Job *manager_get_job(Manager *m, uint32_t id) {
1022 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1025 Unit *manager_get_unit(Manager *m, const char *name) {
1029 return hashmap_get(m->units, name);
1032 unsigned manager_dispatch_load_queue(Manager *m) {
1038 /* Make sure we are not run recursively */
1039 if (m->dispatching_load_queue)
1042 m->dispatching_load_queue = true;
1044 /* Dispatches the load queue. Takes a unit from the queue and
1045 * tries to load its data until the queue is empty */
1047 while ((u = m->load_queue)) {
1048 assert(u->in_load_queue);
1054 m->dispatching_load_queue = false;
1058 int manager_load_unit_prepare(
1070 assert(name || path);
1072 /* This will prepare the unit for loading, but not actually
1073 * load anything from disk. */
1075 if (path && !is_path(path))
1076 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1079 name = basename(path);
1081 t = unit_name_to_type(name);
1083 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false))
1084 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1086 ret = manager_get_unit(m, name);
1092 ret = unit_new(m, unit_vtable[t]->object_size);
1097 ret->fragment_path = strdup(path);
1098 if (!ret->fragment_path) {
1104 r = unit_add_name(ret, name);
1110 unit_add_to_load_queue(ret);
1111 unit_add_to_dbus_queue(ret);
1112 unit_add_to_gc_queue(ret);
1120 int manager_load_unit(
1131 /* This will load the service information files, but not actually
1132 * start any services or anything. */
1134 r = manager_load_unit_prepare(m, name, path, e, _ret);
1138 manager_dispatch_load_queue(m);
1141 *_ret = unit_follow_merge(*_ret);
1146 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1153 HASHMAP_FOREACH(j, s->jobs, i)
1154 job_dump(j, f, prefix);
1157 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1165 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1167 unit_dump(u, f, prefix);
1170 void manager_clear_jobs(Manager *m) {
1175 while ((j = hashmap_first(m->jobs)))
1176 /* No need to recurse. We're cancelling all jobs. */
1177 job_finish_and_invalidate(j, JOB_CANCELED, false);
1180 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1181 Manager *m = userdata;
1187 while ((j = m->run_queue)) {
1188 assert(j->installed);
1189 assert(j->in_run_queue);
1191 job_run_and_invalidate(j);
1194 if (m->n_running_jobs > 0)
1195 manager_watch_jobs_in_progress(m);
1197 if (m->n_on_console > 0)
1198 manager_watch_idle_pipe(m);
1203 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1210 if (m->dispatching_dbus_queue)
1213 m->dispatching_dbus_queue = true;
1215 while ((u = m->dbus_unit_queue)) {
1216 assert(u->in_dbus_queue);
1218 bus_unit_send_change_signal(u);
1222 while ((j = m->dbus_job_queue)) {
1223 assert(j->in_dbus_queue);
1225 bus_job_send_change_signal(j);
1229 m->dispatching_dbus_queue = false;
1231 if (m->send_reloading_done) {
1232 m->send_reloading_done = false;
1234 bus_manager_send_reloading(m, false);
1237 if (m->queued_message)
1238 bus_send_queued_message(m);
1243 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1244 Manager *m = userdata;
1248 assert(m->notify_fd == fd);
1250 if (revents != EPOLLIN) {
1251 log_warning("Got unexpected poll event for notify fd.");
1257 struct iovec iovec = {
1259 .iov_len = sizeof(buf)-1,
1263 struct cmsghdr cmsghdr;
1264 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1267 struct msghdr msghdr = {
1270 .msg_control = &control,
1271 .msg_controllen = sizeof(control),
1273 struct ucred *ucred;
1275 _cleanup_strv_free_ char **tags = NULL;
1277 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1282 if (errno == EAGAIN || errno == EINTR)
1288 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1289 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1290 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1291 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1292 log_warning("Received notify message without credentials. Ignoring.");
1296 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1298 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1300 u = manager_get_unit_by_pid(m, ucred->pid);
1302 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1307 assert((size_t) n < sizeof(buf));
1309 tags = strv_split(buf, "\n\r");
1313 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1315 if (UNIT_VTABLE(u)->notify_message)
1316 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1322 static int manager_dispatch_sigchld(Manager *m) {
1330 /* First we call waitd() for a PID and do not reap the
1331 * zombie. That way we can still access /proc/$PID for
1332 * it while it is a zombie. */
1333 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1335 if (errno == ECHILD)
1347 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1348 _cleanup_free_ char *name = NULL;
1350 get_process_comm(si.si_pid, &name);
1351 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1354 /* Let's flush any message the dying child might still
1355 * have queued for us. This ensures that the process
1356 * still exists in /proc so that we can figure out
1357 * which cgroup and hence unit it belongs to. */
1358 r = manager_dispatch_notify_fd(m->notify_event_source, m->notify_fd, EPOLLIN, m);
1362 /* And now figure out the unit this belongs to */
1363 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1365 u = manager_get_unit_by_pid(m, si.si_pid);
1367 /* And now, we actually reap the zombie. */
1368 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1375 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1378 log_debug("Child %lu died (code=%s, status=%i/%s)",
1379 (long unsigned) si.si_pid,
1380 sigchld_code_to_string(si.si_code),
1382 strna(si.si_code == CLD_EXITED
1383 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1384 : signal_to_string(si.si_status)));
1389 log_debug_unit(u->id,
1390 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1392 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1393 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1399 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1400 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1403 log_debug_unit(name, "Activating special unit %s", name);
1405 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1407 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1412 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1413 Manager *m = userdata;
1415 struct signalfd_siginfo sfsi;
1416 bool sigchld = false;
1419 assert(m->signal_fd == fd);
1421 if (revents != EPOLLIN) {
1422 log_warning("Got unexpected events from signal file descriptor.");
1427 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1428 if (n != sizeof(sfsi)) {
1433 if (errno == EINTR || errno == EAGAIN)
1439 if (sfsi.ssi_pid > 0) {
1442 get_process_comm(sfsi.ssi_pid, &p);
1444 log_debug("Received SIG%s from PID %lu (%s).",
1445 signal_to_string(sfsi.ssi_signo),
1446 (unsigned long) sfsi.ssi_pid, strna(p));
1449 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1451 switch (sfsi.ssi_signo) {
1458 if (m->running_as == SYSTEMD_SYSTEM) {
1459 /* This is for compatibility with the
1460 * original sysvinit */
1461 m->exit_code = MANAGER_REEXECUTE;
1468 if (m->running_as == SYSTEMD_SYSTEM) {
1469 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1473 /* Run the exit target if there is one, if not, just exit. */
1474 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1475 m->exit_code = MANAGER_EXIT;
1482 if (m->running_as == SYSTEMD_SYSTEM)
1483 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1485 /* This is a nop on non-init */
1489 if (m->running_as == SYSTEMD_SYSTEM)
1490 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1492 /* This is a nop on non-init */
1498 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1500 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1501 log_info("Trying to reconnect to bus...");
1505 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1506 log_info("Loading D-Bus service...");
1507 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1514 _cleanup_free_ char *dump = NULL;
1515 _cleanup_fclose_ FILE *f = NULL;
1518 f = open_memstream(&dump, &size);
1520 log_warning("Failed to allocate memory stream.");
1524 manager_dump_units(m, f, "\t");
1525 manager_dump_jobs(m, f, "\t");
1528 log_warning("Failed to write status stream");
1532 log_dump(LOG_INFO, dump);
1537 m->exit_code = MANAGER_RELOAD;
1542 /* Starting SIGRTMIN+0 */
1543 static const char * const target_table[] = {
1544 [0] = SPECIAL_DEFAULT_TARGET,
1545 [1] = SPECIAL_RESCUE_TARGET,
1546 [2] = SPECIAL_EMERGENCY_TARGET,
1547 [3] = SPECIAL_HALT_TARGET,
1548 [4] = SPECIAL_POWEROFF_TARGET,
1549 [5] = SPECIAL_REBOOT_TARGET,
1550 [6] = SPECIAL_KEXEC_TARGET
1553 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1554 static const ManagerExitCode code_table[] = {
1556 [1] = MANAGER_POWEROFF,
1557 [2] = MANAGER_REBOOT,
1561 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1562 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1563 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1564 manager_start_target(m, target_table[idx],
1565 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1569 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1570 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1571 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1575 switch (sfsi.ssi_signo - SIGRTMIN) {
1578 log_debug("Enabling showing of status.");
1579 manager_set_show_status(m, true);
1583 log_debug("Disabling showing of status.");
1584 manager_set_show_status(m, false);
1588 log_set_max_level(LOG_DEBUG);
1589 log_notice("Setting log level to debug.");
1593 log_set_max_level(LOG_INFO);
1594 log_notice("Setting log level to info.");
1598 if (m->running_as == SYSTEMD_USER) {
1599 m->exit_code = MANAGER_EXIT;
1603 /* This is a nop on init */
1607 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1608 log_notice("Setting log target to journal-or-kmsg.");
1612 log_set_target(LOG_TARGET_CONSOLE);
1613 log_notice("Setting log target to console.");
1617 log_set_target(LOG_TARGET_KMSG);
1618 log_notice("Setting log target to kmsg.");
1622 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1623 log_notice("Setting log target to syslog-or-kmsg.");
1627 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1634 manager_dispatch_sigchld(m);
1639 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1640 Manager *m = userdata;
1645 assert(m->time_change_fd == fd);
1647 log_struct(LOG_INFO,
1648 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1649 "MESSAGE=Time has been changed",
1652 /* Restart the watch */
1653 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1655 close_nointr_nofail(m->time_change_fd);
1656 m->time_change_fd = -1;
1658 manager_setup_time_change(m);
1660 HASHMAP_FOREACH(u, m->units, i)
1661 if (UNIT_VTABLE(u)->time_change)
1662 UNIT_VTABLE(u)->time_change(u);
1667 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1668 Manager *m = userdata;
1671 assert(m->idle_pipe[2] == fd);
1673 m->no_console_output = m->n_on_console > 0;
1675 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1676 manager_close_idle_pipe(m);
1681 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1682 Manager *m = userdata;
1686 manager_print_jobs_in_progress(m);
1690 int manager_loop(Manager *m) {
1693 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1696 m->exit_code = MANAGER_RUNNING;
1698 /* Release the path cache */
1699 set_free_free(m->unit_path_cache);
1700 m->unit_path_cache = NULL;
1702 manager_check_finished(m);
1704 /* There might still be some zombies hanging around from
1705 * before we were exec()'ed. Let's reap them. */
1706 r = manager_dispatch_sigchld(m);
1710 while (m->exit_code == MANAGER_RUNNING) {
1713 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1716 if (!ratelimit_test(&rl)) {
1717 /* Yay, something is going seriously wrong, pause a little */
1718 log_warning("Looping too fast. Throttling execution a little.");
1723 if (manager_dispatch_load_queue(m) > 0)
1726 if (manager_dispatch_gc_queue(m) > 0)
1729 if (manager_dispatch_cleanup_queue(m) > 0)
1732 if (manager_dispatch_cgroup_queue(m) > 0)
1735 if (manager_dispatch_dbus_queue(m) > 0)
1738 /* Sleep for half the watchdog time */
1739 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1740 wait_usec = m->runtime_watchdog / 2;
1744 wait_usec = (usec_t) -1;
1746 r = sd_event_run(m->event, wait_usec);
1748 log_error("Failed to run event loop: %s", strerror(-r));
1753 return m->exit_code;
1756 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1757 _cleanup_free_ char *n = NULL;
1765 r = unit_name_from_dbus_path(s, &n);
1769 r = manager_load_unit(m, n, NULL, e, &u);
1778 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1788 p = startswith(s, "/org/freedesktop/systemd1/job/");
1792 r = safe_atou(p, &id);
1796 j = manager_get_job(m, id);
1805 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1811 audit_fd = get_audit_fd();
1815 /* Don't generate audit events if the service was already
1816 * started and we're just deserializing */
1817 if (m->n_reloading > 0)
1820 if (m->running_as != SYSTEMD_SYSTEM)
1823 if (u->type != UNIT_SERVICE)
1826 p = unit_name_to_prefix_and_instance(u->id);
1828 log_error_unit(u->id,
1829 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1833 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1834 if (errno == EPERM) {
1835 /* We aren't allowed to send audit messages?
1836 * Then let's not retry again. */
1839 log_warning("Failed to send audit message: %m");
1847 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1849 union sockaddr_union sa;
1851 char *message = NULL;
1853 /* Don't generate plymouth events if the service was already
1854 * started and we're just deserializing */
1855 if (m->n_reloading > 0)
1858 if (m->running_as != SYSTEMD_SYSTEM)
1861 if (detect_container(NULL) > 0)
1864 if (u->type != UNIT_SERVICE &&
1865 u->type != UNIT_MOUNT &&
1866 u->type != UNIT_SWAP)
1869 /* We set SOCK_NONBLOCK here so that we rather drop the
1870 * message then wait for plymouth */
1871 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1873 log_error("socket() failed: %m");
1878 sa.sa.sa_family = AF_UNIX;
1879 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1880 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1882 if (errno != EPIPE &&
1885 errno != ECONNREFUSED &&
1886 errno != ECONNRESET &&
1887 errno != ECONNABORTED)
1888 log_error("connect() failed: %m");
1893 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1899 if (write(fd, message, n + 1) != n + 1) {
1901 if (errno != EPIPE &&
1904 errno != ECONNREFUSED &&
1905 errno != ECONNRESET &&
1906 errno != ECONNABORTED)
1907 log_error("Failed to write Plymouth message: %m");
1914 close_nointr_nofail(fd);
1919 void manager_dispatch_bus_name_owner_changed(
1922 const char* old_owner,
1923 const char *new_owner) {
1930 u = hashmap_get(m->watch_bus, name);
1934 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1937 int manager_open_serialization(Manager *m, FILE **_f) {
1944 if (m->running_as == SYSTEMD_SYSTEM)
1945 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1947 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1952 RUN_WITH_UMASK(0077) {
1953 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1963 log_debug("Serializing state to %s", path);
1966 f = fdopen(fd, "w+");
1975 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
1988 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1989 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1990 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1991 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1993 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1994 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1995 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1996 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1999 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2000 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2001 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2002 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2003 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2004 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2005 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2006 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2009 if (!switching_root) {
2010 STRV_FOREACH(e, m->environment) {
2011 _cleanup_free_ char *ce;
2017 fprintf(f, "env=%s\n", *e);
2021 if (m->kdbus_fd >= 0) {
2024 copy = fdset_put_dup(fds, m->kdbus_fd);
2028 fprintf(f, "kdbus-fd=%i\n", copy);
2031 bus_serialize(m, f);
2035 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2039 if (!unit_can_serialize(u))
2046 r = unit_serialize(u, f, fds, !switching_root);
2053 assert(m->n_reloading > 0);
2059 r = bus_fdset_add_all(m, fds);
2066 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2072 log_debug("Deserializing state...");
2077 char line[LINE_MAX], *l;
2079 if (!fgets(line, sizeof(line), f)) {
2094 if (startswith(l, "current-job-id=")) {
2097 if (safe_atou32(l+15, &id) < 0)
2098 log_debug("Failed to parse current job id value %s", l+15);
2100 m->current_job_id = MAX(m->current_job_id, id);
2102 } else if (startswith(l, "n-installed-jobs=")) {
2105 if (safe_atou32(l+17, &n) < 0)
2106 log_debug("Failed to parse installed jobs counter %s", l+17);
2108 m->n_installed_jobs += n;
2110 } else if (startswith(l, "n-failed-jobs=")) {
2113 if (safe_atou32(l+14, &n) < 0)
2114 log_debug("Failed to parse failed jobs counter %s", l+14);
2116 m->n_failed_jobs += n;
2118 } else if (startswith(l, "taint-usr=")) {
2121 b = parse_boolean(l+10);
2123 log_debug("Failed to parse taint /usr flag %s", l+10);
2125 m->taint_usr = m->taint_usr || b;
2127 } else if (startswith(l, "firmware-timestamp="))
2128 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2129 else if (startswith(l, "loader-timestamp="))
2130 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2131 else if (startswith(l, "kernel-timestamp="))
2132 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2133 else if (startswith(l, "initrd-timestamp="))
2134 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2135 else if (startswith(l, "userspace-timestamp="))
2136 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2137 else if (startswith(l, "finish-timestamp="))
2138 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2139 else if (startswith(l, "security-start-timestamp="))
2140 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2141 else if (startswith(l, "security-finish-timestamp="))
2142 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2143 else if (startswith(l, "generators-start-timestamp="))
2144 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2145 else if (startswith(l, "generators-finish-timestamp="))
2146 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2147 else if (startswith(l, "units-load-start-timestamp="))
2148 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2149 else if (startswith(l, "units-load-finish-timestamp="))
2150 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2151 else if (startswith(l, "env=")) {
2152 _cleanup_free_ char *uce = NULL;
2155 uce = cunescape(l+4);
2161 e = strv_env_set(m->environment, uce);
2167 strv_free(m->environment);
2170 } else if (startswith(l, "kdbus-fd=")) {
2173 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2174 log_debug("Failed to parse kdbus fd: %s", l + 9);
2176 if (m->kdbus_fd >= 0)
2177 close_nointr_nofail(m->kdbus_fd);
2179 m->kdbus_fd = fdset_remove(fds, fd);
2182 } else if (bus_deserialize_item(m, l) == 0)
2183 log_debug("Unknown serialization item '%s'", l);
2188 char name[UNIT_NAME_MAX+2];
2191 if (!fgets(name, sizeof(name), f)) {
2202 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2206 r = unit_deserialize(u, f, fds);
2215 assert(m->n_reloading > 0);
2221 int manager_reload(Manager *m) {
2223 _cleanup_fclose_ FILE *f = NULL;
2224 _cleanup_fdset_free_ FDSet *fds = NULL;
2228 r = manager_open_serialization(m, &f);
2233 bus_manager_send_reloading(m, true);
2241 r = manager_serialize(m, f, fds, false);
2247 if (fseeko(f, 0, SEEK_SET) < 0) {
2252 /* From here on there is no way back. */
2253 manager_clear_jobs_and_units(m);
2254 manager_undo_generators(m);
2255 lookup_paths_free(&m->lookup_paths);
2257 /* Find new unit paths */
2258 manager_run_generators(m);
2260 q = lookup_paths_init(
2261 &m->lookup_paths, m->running_as, true,
2262 m->generator_unit_path,
2263 m->generator_unit_path_early,
2264 m->generator_unit_path_late);
2268 manager_build_unit_path_cache(m);
2270 /* First, enumerate what we can from all config files */
2271 q = manager_enumerate(m);
2275 /* Second, deserialize our stored data */
2276 q = manager_deserialize(m, f, fds);
2283 /* Third, fire things up! */
2284 q = manager_coldplug(m);
2288 assert(m->n_reloading > 0);
2291 m->send_reloading_done = true;
2296 static bool manager_is_booting_or_shutting_down(Manager *m) {
2301 /* Is the initial job still around? */
2302 if (manager_get_job(m, m->default_unit_job_id))
2305 /* Is there a job for the shutdown target? */
2306 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2313 bool manager_is_reloading_or_reexecuting(Manager *m) {
2316 return m->n_reloading != 0;
2319 void manager_reset_failed(Manager *m) {
2325 HASHMAP_FOREACH(u, m->units, i)
2326 unit_reset_failed(u);
2329 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2335 /* Returns true if the unit is inactive or going down */
2336 u = manager_get_unit(m, name);
2340 return unit_inactive_or_pending(u);
2343 void manager_check_finished(Manager *m) {
2344 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2345 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2349 if (m->n_running_jobs == 0)
2350 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2352 if (hashmap_size(m->jobs) > 0) {
2353 if (m->jobs_in_progress_event_source)
2354 sd_event_source_set_time(m->jobs_in_progress_event_source, JOBS_IN_PROGRESS_PERIOD_SEC);
2358 /* Notify Type=idle units that we are done now */
2359 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2360 manager_close_idle_pipe(m);
2362 /* Turn off confirm spawn now */
2363 m->confirm_spawn = false;
2365 if (dual_timestamp_is_set(&m->finish_timestamp))
2368 dual_timestamp_get(&m->finish_timestamp);
2370 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2372 /* Note that m->kernel_usec.monotonic is always at 0,
2373 * and m->firmware_usec.monotonic and
2374 * m->loader_usec.monotonic should be considered
2375 * negative values. */
2377 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2378 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2379 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2380 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2382 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2384 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2385 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2387 if (!log_on_console())
2388 log_struct(LOG_INFO,
2389 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2390 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2391 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2392 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2393 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2394 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2395 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2396 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2397 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2400 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2403 if (!log_on_console())
2404 log_struct(LOG_INFO,
2405 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2406 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2407 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2408 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2409 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2410 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2411 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2415 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2416 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2418 if (!log_on_console())
2419 log_struct(LOG_INFO,
2420 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2421 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2422 "MESSAGE=Startup finished in %s.",
2423 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2427 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2430 "READY=1\nSTATUS=Startup finished in %s.",
2431 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2434 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2445 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2447 p = strappend("/run/systemd/", name);
2451 r = mkdir_p_label(p, 0755);
2453 log_error("Failed to create generator directory %s: %s",
2459 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2464 log_error("Failed to create generator directory %s: %m",
2475 static void trim_generator_dir(Manager *m, char **generator) {
2482 if (rmdir(*generator) >= 0) {
2490 void manager_run_generators(Manager *m) {
2491 _cleanup_closedir_ DIR *d = NULL;
2492 const char *generator_path;
2493 const char *argv[5];
2498 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2499 d = opendir(generator_path);
2501 if (errno == ENOENT)
2504 log_error("Failed to enumerate generator directory %s: %m",
2509 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2513 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2517 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2521 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2522 argv[1] = m->generator_unit_path;
2523 argv[2] = m->generator_unit_path_early;
2524 argv[3] = m->generator_unit_path_late;
2527 RUN_WITH_UMASK(0022)
2528 execute_directory(generator_path, d, (char**) argv);
2531 trim_generator_dir(m, &m->generator_unit_path);
2532 trim_generator_dir(m, &m->generator_unit_path_early);
2533 trim_generator_dir(m, &m->generator_unit_path_late);
2536 static void remove_generator_dir(Manager *m, char **generator) {
2543 strv_remove(m->lookup_paths.unit_path, *generator);
2544 rm_rf(*generator, false, true, false);
2550 void manager_undo_generators(Manager *m) {
2553 remove_generator_dir(m, &m->generator_unit_path);
2554 remove_generator_dir(m, &m->generator_unit_path_early);
2555 remove_generator_dir(m, &m->generator_unit_path_late);
2558 int manager_environment_add(Manager *m, char **minus, char **plus) {
2559 char **a = NULL, **b = NULL, **l;
2564 if (!strv_isempty(minus)) {
2565 a = strv_env_delete(l, 1, minus);
2572 if (!strv_isempty(plus)) {
2573 b = strv_env_merge(2, l, plus);
2580 if (m->environment != l)
2581 strv_free(m->environment);
2587 m->environment = strv_sort(l);
2591 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2596 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2597 if (!default_rlimit[i])
2600 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2608 void manager_recheck_journal(Manager *m) {
2613 if (m->running_as != SYSTEMD_SYSTEM)
2616 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2617 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2618 log_close_journal();
2622 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2623 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2624 log_close_journal();
2628 /* Hmm, OK, so the socket is fully up and the service is up
2629 * too, then let's make use of the thing. */
2633 void manager_set_show_status(Manager *m, bool b) {
2636 if (m->running_as != SYSTEMD_SYSTEM)
2642 touch("/run/systemd/show-status");
2644 unlink("/run/systemd/show-status");
2647 static bool manager_get_show_status(Manager *m) {
2650 if (m->running_as != SYSTEMD_SYSTEM)
2653 if (m->no_console_output)
2659 /* If Plymouth is running make sure we show the status, so
2660 * that there's something nice to see when people press Esc */
2662 return plymouth_running();
2665 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2668 if (!manager_get_show_status(m))
2671 /* XXX We should totally drop the check for ephemeral here
2672 * and thus effectively make 'Type=idle' pointless. */
2673 if (ephemeral && m->n_on_console > 0)
2676 if (!manager_is_booting_or_shutting_down(m))
2679 va_start(ap, format);
2680 status_vprintf(status, true, ephemeral, format, ap);
2684 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2685 _cleanup_free_ char *p = NULL;
2693 p = unit_name_from_path(path, suffix);
2697 found = manager_get_unit(m, p);
2707 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2708 char p[strlen(path)+1];
2714 path_kill_slashes(p);
2716 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);