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 "systemd/sd-daemon.h"
46 #include "systemd/sd-id128.h"
47 #include "systemd/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"
61 #include "dbus-unit.h"
64 #include "path-lookup.h"
66 #include "bus-errors.h"
67 #include "exit-status.h"
70 #include "cgroup-util.h"
71 #include "path-util.h"
73 #include "boot-timestamps.h"
76 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
77 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
79 /* Initial delay and the interval for printing status messages about running jobs */
80 #define JOBS_IN_PROGRESS_WAIT_SEC 5
81 #define JOBS_IN_PROGRESS_PERIOD_SEC 1
82 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
84 /* Where clients shall send notification messages to */
85 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
87 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
89 static int manager_setup_notify(Manager *m) {
92 struct sockaddr_un un;
94 .sa.sa_family = AF_UNIX,
96 struct epoll_event ev = {
98 .data.ptr = &m->notify_watch,
102 m->notify_watch.type = WATCH_NOTIFY;
103 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
104 if (m->notify_watch.fd < 0) {
105 log_error("Failed to allocate notification socket: %m");
109 if (getpid() != 1 || detect_container(NULL) > 0)
110 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
112 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
114 sa.un.sun_path[0] = 0;
116 r = bind(m->notify_watch.fd, &sa.sa,
117 offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
119 log_error("bind() failed: %m");
123 r = setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
125 log_error("SO_PASSCRED failed: %m");
129 r = epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev);
131 log_error("Failed to add notification socket fd to epoll: %m");
135 sa.un.sun_path[0] = '@';
136 m->notify_socket = strdup(sa.un.sun_path);
137 if (!m->notify_socket)
140 log_debug("Using notification socket %s", m->notify_socket);
145 static int manager_jobs_in_progress_mod_timer(Manager *m) {
146 struct itimerspec its = {
147 .it_value.tv_sec = JOBS_IN_PROGRESS_WAIT_SEC,
148 .it_interval.tv_sec = JOBS_IN_PROGRESS_PERIOD_SEC,
151 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
154 if (timerfd_settime(m->jobs_in_progress_watch.fd, 0, &its, NULL) < 0)
160 static int manager_watch_jobs_in_progress(Manager *m) {
161 struct epoll_event ev = {
163 .data.ptr = &m->jobs_in_progress_watch,
167 if (m->jobs_in_progress_watch.type != WATCH_INVALID)
170 m->jobs_in_progress_watch.type = WATCH_JOBS_IN_PROGRESS;
171 m->jobs_in_progress_watch.fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
172 if (m->jobs_in_progress_watch.fd < 0) {
173 log_error("Failed to create timerfd: %m");
178 r = manager_jobs_in_progress_mod_timer(m);
180 log_error("Failed to set up timer for jobs progress watch: %s", strerror(-r));
184 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->jobs_in_progress_watch.fd, &ev) < 0) {
185 log_error("Failed to add jobs progress timer fd to epoll: %m");
190 log_debug("Set up jobs progress timerfd.");
195 if (m->jobs_in_progress_watch.fd >= 0)
196 close_nointr_nofail(m->jobs_in_progress_watch.fd);
197 watch_init(&m->jobs_in_progress_watch);
201 static void manager_unwatch_jobs_in_progress(Manager *m) {
202 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
205 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->jobs_in_progress_watch.fd, NULL) >= 0);
206 close_nointr_nofail(m->jobs_in_progress_watch.fd);
207 watch_init(&m->jobs_in_progress_watch);
208 m->jobs_in_progress_iteration = 0;
210 log_debug("Closed jobs progress timerfd.");
213 #define CYLON_BUFFER_EXTRA (2*strlen(ANSI_RED_ON) + strlen(ANSI_HIGHLIGHT_RED_ON) + 2*strlen(ANSI_HIGHLIGHT_OFF))
214 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
217 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
218 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
222 p = mempset(p, ' ', pos-2);
223 p = stpcpy(p, ANSI_RED_ON);
227 if (pos > 0 && pos <= width) {
228 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
232 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
235 p = stpcpy(p, ANSI_RED_ON);
238 p = mempset(p, ' ', width-1-pos);
239 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
243 static void manager_print_jobs_in_progress(Manager *m) {
246 char *job_of_n = NULL;
247 unsigned counter = 0, print_nr;
248 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
251 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
253 HASHMAP_FOREACH(j, m->jobs, i)
254 if (j->state == JOB_RUNNING && counter++ == print_nr)
257 /* m->n_running_jobs must be consistent with the contents of m->jobs,
258 * so the above loop must have succeeded in finding j. */
259 assert(counter == print_nr + 1);
261 cylon_pos = m->jobs_in_progress_iteration % 14;
263 cylon_pos = 14 - cylon_pos;
264 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
266 if (m->n_running_jobs > 1)
267 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
270 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
271 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
274 m->jobs_in_progress_iteration++;
277 static int manager_watch_idle_pipe(Manager *m) {
278 struct epoll_event ev = {
280 .data.ptr = &m->idle_pipe_watch,
284 if (m->idle_pipe_watch.type != WATCH_INVALID)
287 if (m->idle_pipe[2] < 0)
290 m->idle_pipe_watch.type = WATCH_IDLE_PIPE;
291 m->idle_pipe_watch.fd = m->idle_pipe[2];
292 if (m->idle_pipe_watch.fd < 0) {
293 log_error("Failed to create timerfd: %m");
298 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->idle_pipe_watch.fd, &ev) < 0) {
299 log_error("Failed to add idle_pipe fd to epoll: %m");
304 log_debug("Set up idle_pipe watch.");
309 if (m->idle_pipe_watch.fd >= 0)
310 close_nointr_nofail(m->idle_pipe_watch.fd);
311 watch_init(&m->idle_pipe_watch);
315 static void manager_unwatch_idle_pipe(Manager *m) {
316 if (m->idle_pipe_watch.type != WATCH_IDLE_PIPE)
319 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->idle_pipe_watch.fd, NULL) >= 0);
320 watch_init(&m->idle_pipe_watch);
322 log_debug("Closed idle_pipe watch.");
325 static int manager_setup_time_change(Manager *m) {
326 struct epoll_event ev = {
328 .data.ptr = &m->time_change_watch,
331 /* We only care for the cancellation event, hence we set the
332 * timeout to the latest possible value. */
333 struct itimerspec its = {
334 .it_value.tv_sec = TIME_T_MAX,
336 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
338 assert(m->time_change_watch.type == WATCH_INVALID);
340 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
341 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
343 m->time_change_watch.type = WATCH_TIME_CHANGE;
344 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
345 if (m->time_change_watch.fd < 0) {
346 log_error("Failed to create timerfd: %m");
350 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
351 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
352 close_nointr_nofail(m->time_change_watch.fd);
353 watch_init(&m->time_change_watch);
357 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
358 log_error("Failed to add timer change fd to epoll: %m");
362 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
367 static int enable_special_signals(Manager *m) {
372 /* Enable that we get SIGINT on control-alt-del. In containers
373 * this will fail with EPERM (older) or EINVAL (newer), so
375 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
376 log_warning("Failed to enable ctrl-alt-del handling: %m");
378 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
380 /* Support systems without virtual console */
382 log_warning("Failed to open /dev/tty0: %m");
384 /* Enable that we get SIGWINCH on kbrequest */
385 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
386 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
388 close_nointr_nofail(fd);
394 static int manager_setup_signals(Manager *m) {
396 struct epoll_event ev = {
398 .data.ptr = &m->signal_watch,
400 struct sigaction sa = {
401 .sa_handler = SIG_DFL,
402 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
407 /* We are not interested in SIGSTOP and friends. */
408 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
410 assert_se(sigemptyset(&mask) == 0);
412 sigset_add_many(&mask,
413 SIGCHLD, /* Child died */
414 SIGTERM, /* Reexecute daemon */
415 SIGHUP, /* Reload configuration */
416 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
417 SIGUSR2, /* systemd: dump status */
418 SIGINT, /* Kernel sends us this on control-alt-del */
419 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
420 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
421 SIGRTMIN+0, /* systemd: start default.target */
422 SIGRTMIN+1, /* systemd: isolate rescue.target */
423 SIGRTMIN+2, /* systemd: isolate emergency.target */
424 SIGRTMIN+3, /* systemd: start halt.target */
425 SIGRTMIN+4, /* systemd: start poweroff.target */
426 SIGRTMIN+5, /* systemd: start reboot.target */
427 SIGRTMIN+6, /* systemd: start kexec.target */
428 SIGRTMIN+13, /* systemd: Immediate halt */
429 SIGRTMIN+14, /* systemd: Immediate poweroff */
430 SIGRTMIN+15, /* systemd: Immediate reboot */
431 SIGRTMIN+16, /* systemd: Immediate kexec */
432 SIGRTMIN+20, /* systemd: enable status messages */
433 SIGRTMIN+21, /* systemd: disable status messages */
434 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
435 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
436 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
437 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
438 SIGRTMIN+27, /* systemd: set log target to console */
439 SIGRTMIN+28, /* systemd: set log target to kmsg */
440 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
442 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
444 m->signal_watch.type = WATCH_SIGNAL;
445 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
446 if (m->signal_watch.fd < 0)
449 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
452 if (m->running_as == SYSTEMD_SYSTEM)
453 return enable_special_signals(m);
458 static int manager_default_environment(Manager *m) {
461 if (m->running_as == SYSTEMD_SYSTEM) {
462 /* The system manager always starts with a clean
463 * environment for its children. It does not import
464 * the kernel or the parents exported variables.
466 * The initial passed environ is untouched to keep
467 * /proc/self/environ valid; it is used for tagging
468 * the init process inside containers. */
469 m->environment = strv_new("PATH=" DEFAULT_PATH,
472 /* Import locale variables LC_*= from configuration */
473 locale_setup(&m->environment);
475 /* The user manager passes its own environment
476 * along to its children. */
477 m->environment = strv_copy(environ);
485 int manager_new(SystemdRunningAs running_as, bool reexecuting, Manager **_m) {
490 assert(running_as >= 0);
491 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
493 m = new0(Manager, 1);
498 if (detect_container(NULL) <= 0)
499 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
502 m->running_as = running_as;
503 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
504 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
505 m->pin_cgroupfs_fd = -1;
506 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
508 watch_init(&m->signal_watch);
509 watch_init(&m->mount_watch);
510 watch_init(&m->swap_watch);
511 watch_init(&m->udev_watch);
512 watch_init(&m->time_change_watch);
513 watch_init(&m->jobs_in_progress_watch);
515 m->epoll_fd = m->dev_autofs_fd = -1;
516 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
518 r = manager_default_environment(m);
522 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
525 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
528 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
531 m->cgroup_unit = hashmap_new(string_hash_func, string_compare_func);
535 m->watch_bus = hashmap_new(string_hash_func, string_compare_func);
539 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
543 r = manager_setup_signals(m);
547 r = manager_setup_cgroup(m);
551 r = manager_setup_notify(m);
555 r = manager_setup_time_change(m);
559 /* Try to connect to the busses, if possible. */
560 if ((running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS")) ||
561 running_as == SYSTEMD_SYSTEM) {
562 r = bus_init(m, reexecuting || running_as != SYSTEMD_SYSTEM);
566 log_debug("Skipping DBus session bus connection attempt - no DBUS_SESSION_BUS_ADDRESS set...");
568 m->taint_usr = dir_is_empty("/usr") > 0;
578 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
584 while ((u = m->cleanup_queue)) {
585 assert(u->in_cleanup_queue);
595 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
596 GC_OFFSET_UNSURE, /* No clue */
597 GC_OFFSET_GOOD, /* We still need this unit */
598 GC_OFFSET_BAD, /* We don't need this unit anymore */
602 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
609 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
610 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
611 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
614 if (u->in_cleanup_queue)
617 if (unit_check_gc(u))
620 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
624 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
625 unit_gc_sweep(other, gc_marker);
627 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
630 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
637 /* We were unable to find anything out about this entry, so
638 * let's investigate it later */
639 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
640 unit_add_to_gc_queue(u);
644 /* We definitely know that this one is not useful anymore, so
645 * let's mark it for deletion */
646 u->gc_marker = gc_marker + GC_OFFSET_BAD;
647 unit_add_to_cleanup_queue(u);
651 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
654 static unsigned manager_dispatch_gc_queue(Manager *m) {
661 /* log_debug("Running GC..."); */
663 m->gc_marker += _GC_OFFSET_MAX;
664 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
667 gc_marker = m->gc_marker;
669 while ((u = m->gc_queue)) {
670 assert(u->in_gc_queue);
672 unit_gc_sweep(u, gc_marker);
674 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
675 u->in_gc_queue = false;
679 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
680 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
681 log_debug_unit(u->id, "Collecting %s", u->id);
682 u->gc_marker = gc_marker + GC_OFFSET_BAD;
683 unit_add_to_cleanup_queue(u);
687 m->n_in_gc_queue = 0;
692 static void manager_clear_jobs_and_units(Manager *m) {
697 while ((u = hashmap_first(m->units)))
700 manager_dispatch_cleanup_queue(m);
702 assert(!m->load_queue);
703 assert(!m->run_queue);
704 assert(!m->dbus_unit_queue);
705 assert(!m->dbus_job_queue);
706 assert(!m->cleanup_queue);
707 assert(!m->gc_queue);
709 assert(hashmap_isempty(m->jobs));
710 assert(hashmap_isempty(m->units));
713 m->n_running_jobs = 0;
716 static void close_idle_pipe(Manager *m) {
717 close_pipe(m->idle_pipe);
718 close_pipe(m->idle_pipe + 2);
721 void manager_free(Manager *m) {
727 manager_clear_jobs_and_units(m);
729 for (c = 0; c < _UNIT_TYPE_MAX; c++)
730 if (unit_vtable[c]->shutdown)
731 unit_vtable[c]->shutdown(m);
733 /* If we reexecute ourselves, we keep the root cgroup
735 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
737 manager_undo_generators(m);
741 hashmap_free(m->units);
742 hashmap_free(m->jobs);
743 hashmap_free(m->watch_pids);
744 hashmap_free(m->watch_bus);
746 if (m->epoll_fd >= 0)
747 close_nointr_nofail(m->epoll_fd);
748 if (m->signal_watch.fd >= 0)
749 close_nointr_nofail(m->signal_watch.fd);
750 if (m->notify_watch.fd >= 0)
751 close_nointr_nofail(m->notify_watch.fd);
752 if (m->time_change_watch.fd >= 0)
753 close_nointr_nofail(m->time_change_watch.fd);
754 if (m->jobs_in_progress_watch.fd >= 0)
755 close_nointr_nofail(m->jobs_in_progress_watch.fd);
757 free(m->notify_socket);
759 lookup_paths_free(&m->lookup_paths);
760 strv_free(m->environment);
762 hashmap_free(m->cgroup_unit);
763 set_free_free(m->unit_path_cache);
767 free(m->switch_root);
768 free(m->switch_root_init);
770 for (i = 0; i < RLIMIT_NLIMITS; i++)
773 assert(hashmap_isempty(m->units_requiring_mounts_for));
774 hashmap_free(m->units_requiring_mounts_for);
779 int manager_enumerate(Manager *m) {
785 /* Let's ask every type to load all units from disk/kernel
786 * that it might know */
787 for (c = 0; c < _UNIT_TYPE_MAX; c++)
788 if (unit_vtable[c]->enumerate) {
789 q = unit_vtable[c]->enumerate(m);
794 manager_dispatch_load_queue(m);
798 int manager_coldplug(Manager *m) {
806 /* Then, let's set up their initial state. */
807 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
813 if ((q = unit_coldplug(u)) < 0)
820 static void manager_build_unit_path_cache(Manager *m) {
822 _cleanup_free_ DIR *d = NULL;
827 set_free_free(m->unit_path_cache);
829 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
830 if (!m->unit_path_cache) {
831 log_error("Failed to allocate unit path cache.");
835 /* This simply builds a list of files we know exist, so that
836 * we don't always have to go to disk */
838 STRV_FOREACH(i, m->lookup_paths.unit_path) {
844 log_error("Failed to open directory %s: %m", *i);
848 while ((de = readdir(d))) {
851 if (ignore_file(de->d_name))
854 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
860 r = set_consume(m->unit_path_cache, p);
872 log_error("Failed to build unit path cache: %s", strerror(-r));
874 set_free_free(m->unit_path_cache);
875 m->unit_path_cache = NULL;
878 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
883 dual_timestamp_get(&m->generators_start_timestamp);
884 manager_run_generators(m);
885 dual_timestamp_get(&m->generators_finish_timestamp);
887 r = lookup_paths_init(
888 &m->lookup_paths, m->running_as, true,
889 m->generator_unit_path,
890 m->generator_unit_path_early,
891 m->generator_unit_path_late);
895 manager_build_unit_path_cache(m);
897 /* If we will deserialize make sure that during enumeration
898 * this is already known, so we increase the counter here
903 /* First, enumerate what we can from all config files */
904 dual_timestamp_get(&m->unitsload_start_timestamp);
905 r = manager_enumerate(m);
906 dual_timestamp_get(&m->unitsload_finish_timestamp);
908 /* Second, deserialize if there is something to deserialize */
910 q = manager_deserialize(m, serialization, fds);
915 /* Any fds left? Find some unit which wants them. This is
916 * useful to allow container managers to pass some file
917 * descriptors to us pre-initialized. This enables
918 * socket-based activation of entire containers. */
919 if (fdset_size(fds) > 0) {
920 q = manager_distribute_fds(m, fds);
925 /* Third, fire things up! */
926 q = manager_coldplug(m);
931 assert(m->n_reloading > 0);
934 /* Let's wait for the UnitNew/JobNew messages being
935 * sent, before we notify that the reload is
937 m->send_reloading_done = true;
943 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
948 assert(type < _JOB_TYPE_MAX);
950 assert(mode < _JOB_MODE_MAX);
952 if (mode == JOB_ISOLATE && type != JOB_START) {
953 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
957 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
958 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
962 log_debug_unit(unit->id,
963 "Trying to enqueue job %s/%s/%s", unit->id,
964 job_type_to_string(type), job_mode_to_string(mode));
966 job_type_collapse(&type, unit);
968 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
972 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
973 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
974 mode == JOB_IGNORE_DEPENDENCIES, e);
978 if (mode == JOB_ISOLATE) {
979 r = transaction_add_isolate_jobs(tr, m);
984 r = transaction_activate(tr, m, mode, e);
988 log_debug_unit(unit->id,
989 "Enqueued job %s/%s as %u", unit->id,
990 job_type_to_string(type), (unsigned) tr->anchor_job->id);
993 *_ret = tr->anchor_job;
995 transaction_free(tr);
999 transaction_abort(tr);
1000 transaction_free(tr);
1004 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
1009 assert(type < _JOB_TYPE_MAX);
1011 assert(mode < _JOB_MODE_MAX);
1013 r = manager_load_unit(m, name, NULL, NULL, &unit);
1017 return manager_add_job(m, type, unit, mode, override, e, _ret);
1020 Job *manager_get_job(Manager *m, uint32_t id) {
1023 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1026 Unit *manager_get_unit(Manager *m, const char *name) {
1030 return hashmap_get(m->units, name);
1033 unsigned manager_dispatch_load_queue(Manager *m) {
1039 /* Make sure we are not run recursively */
1040 if (m->dispatching_load_queue)
1043 m->dispatching_load_queue = true;
1045 /* Dispatches the load queue. Takes a unit from the queue and
1046 * tries to load its data until the queue is empty */
1048 while ((u = m->load_queue)) {
1049 assert(u->in_load_queue);
1055 m->dispatching_load_queue = false;
1059 int manager_load_unit_prepare(
1071 assert(name || path);
1073 /* This will prepare the unit for loading, but not actually
1074 * load anything from disk. */
1076 if (path && !is_path(path)) {
1077 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1082 name = path_get_file_name(path);
1084 t = unit_name_to_type(name);
1086 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
1087 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1091 ret = manager_get_unit(m, name);
1097 ret = unit_new(m, unit_vtable[t]->object_size);
1102 ret->fragment_path = strdup(path);
1103 if (!ret->fragment_path) {
1109 r = unit_add_name(ret, name);
1115 unit_add_to_load_queue(ret);
1116 unit_add_to_dbus_queue(ret);
1117 unit_add_to_gc_queue(ret);
1125 int manager_load_unit(
1136 /* This will load the service information files, but not actually
1137 * start any services or anything. */
1139 r = manager_load_unit_prepare(m, name, path, e, _ret);
1143 manager_dispatch_load_queue(m);
1146 *_ret = unit_follow_merge(*_ret);
1151 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1158 HASHMAP_FOREACH(j, s->jobs, i)
1159 job_dump(j, f, prefix);
1162 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1170 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1172 unit_dump(u, f, prefix);
1175 void manager_clear_jobs(Manager *m) {
1180 while ((j = hashmap_first(m->jobs)))
1181 /* No need to recurse. We're cancelling all jobs. */
1182 job_finish_and_invalidate(j, JOB_CANCELED, false);
1185 unsigned manager_dispatch_run_queue(Manager *m) {
1189 if (m->dispatching_run_queue)
1192 m->dispatching_run_queue = true;
1194 while ((j = m->run_queue)) {
1195 assert(j->installed);
1196 assert(j->in_run_queue);
1198 job_run_and_invalidate(j);
1202 m->dispatching_run_queue = false;
1204 if (m->n_running_jobs > 0)
1205 manager_watch_jobs_in_progress(m);
1207 if (m->n_on_console > 0)
1208 manager_watch_idle_pipe(m);
1213 unsigned manager_dispatch_dbus_queue(Manager *m) {
1220 if (m->dispatching_dbus_queue)
1223 m->dispatching_dbus_queue = true;
1225 while ((u = m->dbus_unit_queue)) {
1226 assert(u->in_dbus_queue);
1228 bus_unit_send_change_signal(u);
1232 while ((j = m->dbus_job_queue)) {
1233 assert(j->in_dbus_queue);
1235 bus_job_send_change_signal(j);
1239 m->dispatching_dbus_queue = false;
1241 if (m->send_reloading_done) {
1242 m->send_reloading_done = false;
1244 bus_broadcast_reloading(m, false);
1250 static int manager_process_notify_fd(Manager *m) {
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_watch.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_process_notify_fd(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) {
1403 dbus_error_init(&error);
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,
1410 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1412 dbus_error_free(&error);
1417 static int manager_process_signal_fd(Manager *m) {
1419 struct signalfd_siginfo sfsi;
1420 bool sigchld = false;
1425 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1426 if (n != sizeof(sfsi)) {
1431 if (errno == EINTR || errno == EAGAIN)
1437 if (sfsi.ssi_pid > 0) {
1440 get_process_comm(sfsi.ssi_pid, &p);
1442 log_debug("Received SIG%s from PID %lu (%s).",
1443 signal_to_string(sfsi.ssi_signo),
1444 (unsigned long) sfsi.ssi_pid, strna(p));
1447 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1449 switch (sfsi.ssi_signo) {
1456 if (m->running_as == SYSTEMD_SYSTEM) {
1457 /* This is for compatibility with the
1458 * original sysvinit */
1459 m->exit_code = MANAGER_REEXECUTE;
1466 if (m->running_as == SYSTEMD_SYSTEM) {
1467 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1471 /* Run the exit target if there is one, if not, just exit. */
1472 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1473 m->exit_code = MANAGER_EXIT;
1480 if (m->running_as == SYSTEMD_SYSTEM)
1481 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1483 /* This is a nop on non-init */
1487 if (m->running_as == SYSTEMD_SYSTEM)
1488 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1490 /* This is a nop on non-init */
1496 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1498 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1499 log_info("Trying to reconnect to bus...");
1503 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1504 log_info("Loading D-Bus service...");
1505 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1516 if (!(f = open_memstream(&dump, &size))) {
1517 log_warning("Failed to allocate memory stream.");
1521 manager_dump_units(m, f, "\t");
1522 manager_dump_jobs(m, f, "\t");
1527 log_warning("Failed to write status stream");
1532 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 process_event(Manager *m, struct epoll_event *ev) {
1648 assert_se(w = ev->data.ptr);
1650 if (w->type == WATCH_INVALID)
1657 /* An incoming signal? */
1658 if (ev->events != EPOLLIN)
1661 if ((r = manager_process_signal_fd(m)) < 0)
1668 /* An incoming daemon notification event? */
1669 if (ev->events != EPOLLIN)
1672 if ((r = manager_process_notify_fd(m)) < 0)
1679 /* Some fd event, to be dispatched to the units */
1680 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1683 case WATCH_UNIT_TIMER:
1684 case WATCH_JOB_TIMER: {
1688 /* Some timer event, to be dispatched to the units */
1689 k = read(w->fd, &v, sizeof(v));
1690 if (k != sizeof(v)) {
1692 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1695 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1696 return k < 0 ? -errno : -EIO;
1699 if (w->type == WATCH_UNIT_TIMER)
1700 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1702 job_timer_event(w->data.job, v, w);
1707 /* Some mount table change, intended for the mount subsystem */
1708 mount_fd_event(m, ev->events);
1712 /* Some swap table change, intended for the swap subsystem */
1713 swap_fd_event(m, ev->events);
1717 /* Some notification from udev, intended for the device subsystem */
1718 device_fd_event(m, ev->events);
1721 case WATCH_DBUS_WATCH:
1722 bus_watch_event(m, w, ev->events);
1725 case WATCH_DBUS_TIMEOUT:
1726 bus_timeout_event(m, w, ev->events);
1729 case WATCH_TIME_CHANGE: {
1733 log_struct(LOG_INFO,
1734 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1735 "MESSAGE=Time has been changed",
1738 /* Restart the watch */
1739 epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->time_change_watch.fd,
1741 close_nointr_nofail(m->time_change_watch.fd);
1742 watch_init(&m->time_change_watch);
1743 manager_setup_time_change(m);
1745 HASHMAP_FOREACH(u, m->units, i) {
1746 if (UNIT_VTABLE(u)->time_change)
1747 UNIT_VTABLE(u)->time_change(u);
1753 case WATCH_JOBS_IN_PROGRESS: {
1756 /* not interested in the data */
1757 read(w->fd, &v, sizeof(v));
1759 manager_print_jobs_in_progress(m);
1763 case WATCH_IDLE_PIPE: {
1764 m->no_console_output = true;
1766 manager_unwatch_idle_pipe(m);
1772 log_error("event type=%i", w->type);
1773 assert_not_reached("Unknown epoll event type.");
1779 int manager_loop(Manager *m) {
1782 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1785 m->exit_code = MANAGER_RUNNING;
1787 /* Release the path cache */
1788 set_free_free(m->unit_path_cache);
1789 m->unit_path_cache = NULL;
1791 manager_check_finished(m);
1793 /* There might still be some zombies hanging around from
1794 * before we were exec()'ed. Leat's reap them */
1795 r = manager_dispatch_sigchld(m);
1799 while (m->exit_code == MANAGER_RUNNING) {
1800 struct epoll_event event;
1804 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1807 if (!ratelimit_test(&rl)) {
1808 /* Yay, something is going seriously wrong, pause a little */
1809 log_warning("Looping too fast. Throttling execution a little.");
1814 if (manager_dispatch_load_queue(m) > 0)
1817 if (manager_dispatch_gc_queue(m) > 0)
1820 if (manager_dispatch_cleanup_queue(m) > 0)
1823 if (manager_dispatch_cgroup_queue(m) > 0)
1826 if (manager_dispatch_run_queue(m) > 0)
1829 if (bus_dispatch(m) > 0)
1832 if (manager_dispatch_dbus_queue(m) > 0)
1835 if (swap_dispatch_reload(m) > 0)
1838 /* Sleep for half the watchdog time */
1839 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1840 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1846 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1858 r = process_event(m, &event);
1863 return m->exit_code;
1866 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1867 _cleanup_free_ char *n = NULL;
1875 r = unit_name_from_dbus_path(s, &n);
1879 r = manager_load_unit(m, n, NULL, e, &u);
1888 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1897 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1900 r = safe_atou(s + 30, &id);
1904 j = manager_get_job(m, id);
1913 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1919 audit_fd = get_audit_fd();
1923 /* Don't generate audit events if the service was already
1924 * started and we're just deserializing */
1925 if (m->n_reloading > 0)
1928 if (m->running_as != SYSTEMD_SYSTEM)
1931 if (u->type != UNIT_SERVICE)
1934 p = unit_name_to_prefix_and_instance(u->id);
1936 log_error_unit(u->id,
1937 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1941 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1942 if (errno == EPERM) {
1943 /* We aren't allowed to send audit messages?
1944 * Then let's not retry again. */
1947 log_warning("Failed to send audit message: %m");
1955 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1957 union sockaddr_union sa;
1959 char *message = NULL;
1961 /* Don't generate plymouth events if the service was already
1962 * started and we're just deserializing */
1963 if (m->n_reloading > 0)
1966 if (m->running_as != SYSTEMD_SYSTEM)
1969 if (u->type != UNIT_SERVICE &&
1970 u->type != UNIT_MOUNT &&
1971 u->type != UNIT_SWAP)
1974 /* We set SOCK_NONBLOCK here so that we rather drop the
1975 * message then wait for plymouth */
1976 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1978 log_error("socket() failed: %m");
1983 sa.sa.sa_family = AF_UNIX;
1984 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1985 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1987 if (errno != EPIPE &&
1990 errno != ECONNREFUSED &&
1991 errno != ECONNRESET &&
1992 errno != ECONNABORTED)
1993 log_error("connect() failed: %m");
1998 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2004 if (write(fd, message, n + 1) != n + 1) {
2006 if (errno != EPIPE &&
2009 errno != ECONNREFUSED &&
2010 errno != ECONNRESET &&
2011 errno != ECONNABORTED)
2012 log_error("Failed to write Plymouth message: %m");
2019 close_nointr_nofail(fd);
2024 void manager_dispatch_bus_name_owner_changed(
2027 const char* old_owner,
2028 const char *new_owner) {
2035 if (!(u = hashmap_get(m->watch_bus, name)))
2038 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2041 void manager_dispatch_bus_query_pid_done(
2052 if (!(u = hashmap_get(m->watch_bus, name)))
2055 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
2058 int manager_open_serialization(Manager *m, FILE **_f) {
2065 if (m->running_as == SYSTEMD_SYSTEM)
2066 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
2068 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
2073 RUN_WITH_UMASK(0077) {
2074 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2084 log_debug("Serializing state to %s", path);
2087 f = fdopen(fd, "w+");
2096 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2109 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2110 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2111 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2112 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2114 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2115 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2116 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2117 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2120 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2121 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2124 if (!switching_root) {
2125 STRV_FOREACH(e, m->environment) {
2126 _cleanup_free_ char *ce;
2130 fprintf(f, "env=%s\n", *e);
2134 bus_serialize(m, f);
2138 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2142 if (!unit_can_serialize(u))
2149 r = unit_serialize(u, f, fds, !switching_root);
2156 assert(m->n_reloading > 0);
2162 r = bus_fdset_add_all(m, fds);
2169 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2175 log_debug("Deserializing state...");
2180 char line[LINE_MAX], *l;
2182 if (!fgets(line, sizeof(line), f)) {
2197 if (startswith(l, "current-job-id=")) {
2200 if (safe_atou32(l+15, &id) < 0)
2201 log_debug("Failed to parse current job id value %s", l+15);
2203 m->current_job_id = MAX(m->current_job_id, id);
2204 } else if (startswith(l, "n-installed-jobs=")) {
2207 if (safe_atou32(l+17, &n) < 0)
2208 log_debug("Failed to parse installed jobs counter %s", l+17);
2210 m->n_installed_jobs += n;
2211 } else if (startswith(l, "n-failed-jobs=")) {
2214 if (safe_atou32(l+14, &n) < 0)
2215 log_debug("Failed to parse failed jobs counter %s", l+14);
2217 m->n_failed_jobs += n;
2218 } else if (startswith(l, "taint-usr=")) {
2221 if ((b = parse_boolean(l+10)) < 0)
2222 log_debug("Failed to parse taint /usr flag %s", l+10);
2224 m->taint_usr = m->taint_usr || b;
2225 } else if (startswith(l, "firmware-timestamp="))
2226 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2227 else if (startswith(l, "loader-timestamp="))
2228 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2229 else if (startswith(l, "kernel-timestamp="))
2230 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2231 else if (startswith(l, "initrd-timestamp="))
2232 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2233 else if (startswith(l, "userspace-timestamp="))
2234 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2235 else if (startswith(l, "finish-timestamp="))
2236 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2237 else if (startswith(l, "env=")) {
2238 _cleanup_free_ char *uce = NULL;
2241 uce = cunescape(l+4);
2247 e = strv_env_set(m->environment, uce);
2253 strv_free(m->environment);
2255 } else if (bus_deserialize_item(m, l) == 0)
2256 log_debug("Unknown serialization item '%s'", l);
2261 char name[UNIT_NAME_MAX+2];
2264 if (!fgets(name, sizeof(name), f)) {
2275 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2279 r = unit_deserialize(u, f, fds);
2290 assert(m->n_reloading > 0);
2296 int manager_distribute_fds(Manager *m, FDSet *fds) {
2303 HASHMAP_FOREACH(u, m->units, i) {
2305 if (fdset_size(fds) <= 0)
2308 if (UNIT_VTABLE(u)->distribute_fds) {
2309 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2318 int manager_reload(Manager *m) {
2325 r = manager_open_serialization(m, &f);
2330 bus_broadcast_reloading(m, true);
2339 r = manager_serialize(m, f, fds, false);
2345 if (fseeko(f, 0, SEEK_SET) < 0) {
2351 /* From here on there is no way back. */
2352 manager_clear_jobs_and_units(m);
2353 manager_undo_generators(m);
2354 lookup_paths_free(&m->lookup_paths);
2356 /* Find new unit paths */
2357 manager_run_generators(m);
2359 q = lookup_paths_init(
2360 &m->lookup_paths, m->running_as, true,
2361 m->generator_unit_path,
2362 m->generator_unit_path_early,
2363 m->generator_unit_path_late);
2367 manager_build_unit_path_cache(m);
2369 /* First, enumerate what we can from all config files */
2370 q = manager_enumerate(m);
2374 /* Second, deserialize our stored data */
2375 q = manager_deserialize(m, f, fds);
2382 /* Third, fire things up! */
2383 q = manager_coldplug(m);
2387 assert(m->n_reloading > 0);
2390 m->send_reloading_done = true;
2402 static bool manager_is_booting_or_shutting_down(Manager *m) {
2407 /* Is the initial job still around? */
2408 if (manager_get_job(m, m->default_unit_job_id))
2411 /* Is there a job for the shutdown target? */
2412 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2419 bool manager_is_reloading_or_reexecuting(Manager *m) {
2422 return m->n_reloading != 0;
2425 void manager_reset_failed(Manager *m) {
2431 HASHMAP_FOREACH(u, m->units, i)
2432 unit_reset_failed(u);
2435 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2441 /* Returns true if the unit is inactive or going down */
2442 u = manager_get_unit(m, name);
2446 return unit_inactive_or_pending(u);
2449 void manager_check_finished(Manager *m) {
2450 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2451 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2455 if (m->n_running_jobs == 0)
2456 manager_unwatch_jobs_in_progress(m);
2458 if (hashmap_size(m->jobs) > 0) {
2459 manager_jobs_in_progress_mod_timer(m);
2463 /* Notify Type=idle units that we are done now */
2464 manager_unwatch_idle_pipe(m);
2467 /* Turn off confirm spawn now */
2468 m->confirm_spawn = false;
2470 if (dual_timestamp_is_set(&m->finish_timestamp))
2473 dual_timestamp_get(&m->finish_timestamp);
2475 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2477 /* Note that m->kernel_usec.monotonic is always at 0,
2478 * and m->firmware_usec.monotonic and
2479 * m->loader_usec.monotonic should be considered
2480 * negative values. */
2482 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2483 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2484 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2485 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2487 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2489 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2490 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2492 if (!log_on_console())
2493 log_struct(LOG_INFO,
2494 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2495 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2496 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2497 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2498 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2499 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2500 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2501 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2502 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2505 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2508 if (!log_on_console())
2509 log_struct(LOG_INFO,
2510 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2511 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2512 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2513 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2514 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2515 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2516 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2520 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2521 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2523 if (!log_on_console())
2524 log_struct(LOG_INFO,
2525 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2526 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2527 "MESSAGE=Startup finished in %s.",
2528 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2532 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2535 "READY=1\nSTATUS=Startup finished in %s.",
2536 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2539 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2550 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2552 p = strappend("/run/systemd/", name);
2556 r = mkdir_p_label(p, 0755);
2558 log_error("Failed to create generator directory %s: %s",
2564 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2569 log_error("Failed to create generator directory %s: %m",
2580 static void trim_generator_dir(Manager *m, char **generator) {
2587 if (rmdir(*generator) >= 0) {
2595 void manager_run_generators(Manager *m) {
2597 const char *generator_path;
2598 const char *argv[5];
2603 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2604 d = opendir(generator_path);
2606 if (errno == ENOENT)
2609 log_error("Failed to enumerate generator directory %s: %m",
2614 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2618 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2622 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2626 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2627 argv[1] = m->generator_unit_path;
2628 argv[2] = m->generator_unit_path_early;
2629 argv[3] = m->generator_unit_path_late;
2632 RUN_WITH_UMASK(0022) {
2633 execute_directory(generator_path, d, (char**) argv);
2636 trim_generator_dir(m, &m->generator_unit_path);
2637 trim_generator_dir(m, &m->generator_unit_path_early);
2638 trim_generator_dir(m, &m->generator_unit_path_late);
2645 static void remove_generator_dir(Manager *m, char **generator) {
2652 strv_remove(m->lookup_paths.unit_path, *generator);
2653 rm_rf(*generator, false, true, false);
2659 void manager_undo_generators(Manager *m) {
2662 remove_generator_dir(m, &m->generator_unit_path);
2663 remove_generator_dir(m, &m->generator_unit_path_early);
2664 remove_generator_dir(m, &m->generator_unit_path_late);
2667 int manager_environment_add(Manager *m, char **environment) {
2671 e = strv_env_merge(2, m->environment, environment);
2674 strv_free(m->environment);
2679 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2684 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2685 if (!default_rlimit[i])
2688 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2696 void manager_recheck_journal(Manager *m) {
2701 if (m->running_as != SYSTEMD_SYSTEM)
2704 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2705 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2706 log_close_journal();
2710 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2711 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2712 log_close_journal();
2716 /* Hmm, OK, so the socket is fully up and the service is up
2717 * too, then let's make use of the thing. */
2721 void manager_set_show_status(Manager *m, bool b) {
2724 if (m->running_as != SYSTEMD_SYSTEM)
2730 touch("/run/systemd/show-status");
2732 unlink("/run/systemd/show-status");
2735 static bool manager_get_show_status(Manager *m) {
2738 if (m->running_as != SYSTEMD_SYSTEM)
2741 if (m->no_console_output)
2747 /* If Plymouth is running make sure we show the status, so
2748 * that there's something nice to see when people press Esc */
2750 return plymouth_running();
2753 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2756 if (!manager_get_show_status(m))
2759 /* XXX We should totally drop the check for ephemeral here
2760 * and thus effectively make 'Type=idle' pointless. */
2761 if (ephemeral && m->n_on_console > 0)
2764 if (!manager_is_booting_or_shutting_down(m))
2767 va_start(ap, format);
2768 status_vprintf(status, true, ephemeral, format, ap);
2772 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2773 _cleanup_free_ char *p = NULL;
2781 p = unit_name_from_path(path, suffix);
2785 found = manager_get_unit(m, p);
2795 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2796 char p[strlen(path)+1];
2802 path_kill_slashes(p);
2804 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
2807 void watch_init(Watch *w) {
2810 w->type = WATCH_INVALID;