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 "mount-setup.h"
59 #include "unit-name.h"
60 #include "dbus-unit.h"
63 #include "path-lookup.h"
65 #include "bus-errors.h"
66 #include "exit-status.h"
69 #include "cgroup-util.h"
70 #include "path-util.h"
75 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
76 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
78 /* Initial delay and the interval for printing status messages about running jobs */
79 #define JOBS_IN_PROGRESS_WAIT_SEC 5
80 #define JOBS_IN_PROGRESS_PERIOD_SEC 1
81 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
83 /* Where clients shall send notification messages to */
84 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
86 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
88 static int manager_setup_notify(Manager *m) {
91 struct sockaddr_un un;
93 .sa.sa_family = AF_UNIX,
95 struct epoll_event ev = {
97 .data.ptr = &m->notify_watch,
101 m->notify_watch.type = WATCH_NOTIFY;
102 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
103 if (m->notify_watch.fd < 0) {
104 log_error("Failed to allocate notification socket: %m");
108 if (getpid() != 1 || detect_container(NULL) > 0)
109 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
111 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
113 sa.un.sun_path[0] = 0;
115 r = bind(m->notify_watch.fd, &sa.sa,
116 offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
118 log_error("bind() failed: %m");
122 r = setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
124 log_error("SO_PASSCRED failed: %m");
128 r = epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev);
130 log_error("Failed to add notification socket fd to epoll: %m");
134 sa.un.sun_path[0] = '@';
135 m->notify_socket = strdup(sa.un.sun_path);
136 if (!m->notify_socket)
139 log_debug("Using notification socket %s", m->notify_socket);
144 static int manager_jobs_in_progress_mod_timer(Manager *m) {
145 struct itimerspec its = {
146 .it_value.tv_sec = JOBS_IN_PROGRESS_WAIT_SEC,
147 .it_interval.tv_sec = JOBS_IN_PROGRESS_PERIOD_SEC,
150 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
153 if (timerfd_settime(m->jobs_in_progress_watch.fd, 0, &its, NULL) < 0)
159 static int manager_watch_jobs_in_progress(Manager *m) {
160 struct epoll_event ev = {
162 .data.ptr = &m->jobs_in_progress_watch,
166 if (m->jobs_in_progress_watch.type != WATCH_INVALID)
169 m->jobs_in_progress_watch.type = WATCH_JOBS_IN_PROGRESS;
170 m->jobs_in_progress_watch.fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
171 if (m->jobs_in_progress_watch.fd < 0) {
172 log_error("Failed to create timerfd: %m");
177 r = manager_jobs_in_progress_mod_timer(m);
179 log_error("Failed to set up timer for jobs progress watch: %s", strerror(-r));
183 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->jobs_in_progress_watch.fd, &ev) < 0) {
184 log_error("Failed to add jobs progress timer fd to epoll: %m");
189 log_debug("Set up jobs progress timerfd.");
194 if (m->jobs_in_progress_watch.fd >= 0)
195 close_nointr_nofail(m->jobs_in_progress_watch.fd);
196 watch_init(&m->jobs_in_progress_watch);
200 static void manager_unwatch_jobs_in_progress(Manager *m) {
201 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
204 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->jobs_in_progress_watch.fd, NULL) >= 0);
205 close_nointr_nofail(m->jobs_in_progress_watch.fd);
206 watch_init(&m->jobs_in_progress_watch);
207 m->jobs_in_progress_iteration = 0;
209 log_debug("Closed jobs progress timerfd.");
212 #define CYLON_BUFFER_EXTRA (2*strlen(ANSI_RED_ON) + strlen(ANSI_HIGHLIGHT_RED_ON) + 2*strlen(ANSI_HIGHLIGHT_OFF))
213 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
216 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
217 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
221 p = mempset(p, ' ', pos-2);
222 p = stpcpy(p, ANSI_RED_ON);
226 if (pos > 0 && pos <= width) {
227 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
231 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
234 p = stpcpy(p, ANSI_RED_ON);
237 p = mempset(p, ' ', width-1-pos);
238 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
242 static void manager_print_jobs_in_progress(Manager *m) {
245 char *job_of_n = NULL;
246 unsigned counter = 0, print_nr;
247 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
250 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
252 HASHMAP_FOREACH(j, m->jobs, i)
253 if (j->state == JOB_RUNNING && counter++ == print_nr)
256 /* m->n_running_jobs must be consistent with the contents of m->jobs,
257 * so the above loop must have succeeded in finding j. */
258 assert(counter == print_nr + 1);
260 cylon_pos = m->jobs_in_progress_iteration % 14;
262 cylon_pos = 14 - cylon_pos;
263 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
265 if (m->n_running_jobs > 1)
266 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
269 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
270 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
273 m->jobs_in_progress_iteration++;
276 static int manager_watch_idle_pipe(Manager *m) {
277 struct epoll_event ev = {
279 .data.ptr = &m->idle_pipe_watch,
283 if (m->idle_pipe_watch.type != WATCH_INVALID)
286 if (m->idle_pipe[2] < 0)
289 m->idle_pipe_watch.type = WATCH_IDLE_PIPE;
290 m->idle_pipe_watch.fd = m->idle_pipe[2];
291 if (m->idle_pipe_watch.fd < 0) {
292 log_error("Failed to create timerfd: %m");
297 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->idle_pipe_watch.fd, &ev) < 0) {
298 log_error("Failed to add idle_pipe fd to epoll: %m");
303 log_debug("Set up idle_pipe watch.");
308 if (m->idle_pipe_watch.fd >= 0)
309 close_nointr_nofail(m->idle_pipe_watch.fd);
310 watch_init(&m->idle_pipe_watch);
314 static void manager_unwatch_idle_pipe(Manager *m) {
315 if (m->idle_pipe_watch.type != WATCH_IDLE_PIPE)
318 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->idle_pipe_watch.fd, NULL) >= 0);
319 watch_init(&m->idle_pipe_watch);
321 log_debug("Closed idle_pipe watch.");
324 static int manager_setup_time_change(Manager *m) {
325 struct epoll_event ev = {
327 .data.ptr = &m->time_change_watch,
330 /* We only care for the cancellation event, hence we set the
331 * timeout to the latest possible value. */
332 struct itimerspec its = {
333 .it_value.tv_sec = TIME_T_MAX,
335 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
337 assert(m->time_change_watch.type == WATCH_INVALID);
339 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
340 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
342 m->time_change_watch.type = WATCH_TIME_CHANGE;
343 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
344 if (m->time_change_watch.fd < 0) {
345 log_error("Failed to create timerfd: %m");
349 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
350 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
351 close_nointr_nofail(m->time_change_watch.fd);
352 watch_init(&m->time_change_watch);
356 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
357 log_error("Failed to add timer change fd to epoll: %m");
361 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
366 static int enable_special_signals(Manager *m) {
371 /* Enable that we get SIGINT on control-alt-del. In containers
372 * this will fail with EPERM (older) or EINVAL (newer), so
374 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
375 log_warning("Failed to enable ctrl-alt-del handling: %m");
377 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
379 /* Support systems without virtual console */
381 log_warning("Failed to open /dev/tty0: %m");
383 /* Enable that we get SIGWINCH on kbrequest */
384 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
385 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
387 close_nointr_nofail(fd);
393 static int manager_setup_signals(Manager *m) {
395 struct epoll_event ev = {
397 .data.ptr = &m->signal_watch,
399 struct sigaction sa = {
400 .sa_handler = SIG_DFL,
401 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
406 /* We are not interested in SIGSTOP and friends. */
407 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
409 assert_se(sigemptyset(&mask) == 0);
411 sigset_add_many(&mask,
412 SIGCHLD, /* Child died */
413 SIGTERM, /* Reexecute daemon */
414 SIGHUP, /* Reload configuration */
415 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
416 SIGUSR2, /* systemd: dump status */
417 SIGINT, /* Kernel sends us this on control-alt-del */
418 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
419 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
420 SIGRTMIN+0, /* systemd: start default.target */
421 SIGRTMIN+1, /* systemd: isolate rescue.target */
422 SIGRTMIN+2, /* systemd: isolate emergency.target */
423 SIGRTMIN+3, /* systemd: start halt.target */
424 SIGRTMIN+4, /* systemd: start poweroff.target */
425 SIGRTMIN+5, /* systemd: start reboot.target */
426 SIGRTMIN+6, /* systemd: start kexec.target */
427 SIGRTMIN+13, /* systemd: Immediate halt */
428 SIGRTMIN+14, /* systemd: Immediate poweroff */
429 SIGRTMIN+15, /* systemd: Immediate reboot */
430 SIGRTMIN+16, /* systemd: Immediate kexec */
431 SIGRTMIN+20, /* systemd: enable status messages */
432 SIGRTMIN+21, /* systemd: disable status messages */
433 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
434 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
435 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
436 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
437 SIGRTMIN+27, /* systemd: set log target to console */
438 SIGRTMIN+28, /* systemd: set log target to kmsg */
439 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
441 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
443 m->signal_watch.type = WATCH_SIGNAL;
444 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
445 if (m->signal_watch.fd < 0)
448 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
451 if (m->running_as == SYSTEMD_SYSTEM)
452 return enable_special_signals(m);
457 static void manager_strip_environment(Manager *m) {
460 /* Remove variables from the inherited set that are part of
461 * the container interface:
462 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
463 strv_remove_prefix(m->environment, "container=");
464 strv_remove_prefix(m->environment, "container_");
466 /* Remove variables from the inherited set that are part of
467 * the initrd interface:
468 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
469 strv_remove_prefix(m->environment, "RD_");
471 /* Drop invalid entries */
472 strv_env_clean(m->environment);
475 int manager_new(SystemdRunningAs running_as, bool reexecuting, Manager **_m) {
480 assert(running_as >= 0);
481 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
483 m = new0(Manager, 1);
488 if (detect_container(NULL) <= 0)
489 efi_get_boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
492 m->running_as = running_as;
493 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
494 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
495 m->pin_cgroupfs_fd = -1;
496 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
498 watch_init(&m->signal_watch);
499 watch_init(&m->mount_watch);
500 watch_init(&m->swap_watch);
501 watch_init(&m->udev_watch);
502 watch_init(&m->time_change_watch);
503 watch_init(&m->jobs_in_progress_watch);
505 m->epoll_fd = m->dev_autofs_fd = -1;
506 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
508 m->environment = strv_copy(environ);
512 manager_strip_environment(m);
514 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
517 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
520 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
523 m->cgroup_unit = hashmap_new(string_hash_func, string_compare_func);
527 m->watch_bus = hashmap_new(string_hash_func, string_compare_func);
531 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
535 r = manager_setup_signals(m);
539 r = manager_setup_cgroup(m);
543 r = manager_setup_notify(m);
547 r = manager_setup_time_change(m);
551 /* Try to connect to the busses, if possible. */
552 if ((running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS")) ||
553 running_as == SYSTEMD_SYSTEM) {
554 r = bus_init(m, reexecuting || running_as != SYSTEMD_SYSTEM);
558 log_debug("Skipping DBus session bus connection attempt - no DBUS_SESSION_BUS_ADDRESS set...");
560 m->taint_usr = dir_is_empty("/usr") > 0;
570 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
576 while ((u = m->cleanup_queue)) {
577 assert(u->in_cleanup_queue);
587 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
588 GC_OFFSET_UNSURE, /* No clue */
589 GC_OFFSET_GOOD, /* We still need this unit */
590 GC_OFFSET_BAD, /* We don't need this unit anymore */
594 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
601 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
602 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
603 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
606 if (u->in_cleanup_queue)
609 if (unit_check_gc(u))
612 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
616 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
617 unit_gc_sweep(other, gc_marker);
619 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
622 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
629 /* We were unable to find anything out about this entry, so
630 * let's investigate it later */
631 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
632 unit_add_to_gc_queue(u);
636 /* We definitely know that this one is not useful anymore, so
637 * let's mark it for deletion */
638 u->gc_marker = gc_marker + GC_OFFSET_BAD;
639 unit_add_to_cleanup_queue(u);
643 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
646 static unsigned manager_dispatch_gc_queue(Manager *m) {
653 /* log_debug("Running GC..."); */
655 m->gc_marker += _GC_OFFSET_MAX;
656 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
659 gc_marker = m->gc_marker;
661 while ((u = m->gc_queue)) {
662 assert(u->in_gc_queue);
664 unit_gc_sweep(u, gc_marker);
666 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
667 u->in_gc_queue = false;
671 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
672 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
673 log_debug_unit(u->id, "Collecting %s", u->id);
674 u->gc_marker = gc_marker + GC_OFFSET_BAD;
675 unit_add_to_cleanup_queue(u);
679 m->n_in_gc_queue = 0;
684 static void manager_clear_jobs_and_units(Manager *m) {
689 while ((u = hashmap_first(m->units)))
692 manager_dispatch_cleanup_queue(m);
694 assert(!m->load_queue);
695 assert(!m->run_queue);
696 assert(!m->dbus_unit_queue);
697 assert(!m->dbus_job_queue);
698 assert(!m->cleanup_queue);
699 assert(!m->gc_queue);
701 assert(hashmap_isempty(m->jobs));
702 assert(hashmap_isempty(m->units));
705 m->n_running_jobs = 0;
708 static void close_idle_pipe(Manager *m) {
709 close_pipe(m->idle_pipe);
710 close_pipe(m->idle_pipe + 2);
713 void manager_free(Manager *m) {
719 manager_clear_jobs_and_units(m);
721 for (c = 0; c < _UNIT_TYPE_MAX; c++)
722 if (unit_vtable[c]->shutdown)
723 unit_vtable[c]->shutdown(m);
725 /* If we reexecute ourselves, we keep the root cgroup
727 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
729 manager_undo_generators(m);
733 hashmap_free(m->units);
734 hashmap_free(m->jobs);
735 hashmap_free(m->watch_pids);
736 hashmap_free(m->watch_bus);
738 if (m->epoll_fd >= 0)
739 close_nointr_nofail(m->epoll_fd);
740 if (m->signal_watch.fd >= 0)
741 close_nointr_nofail(m->signal_watch.fd);
742 if (m->notify_watch.fd >= 0)
743 close_nointr_nofail(m->notify_watch.fd);
744 if (m->time_change_watch.fd >= 0)
745 close_nointr_nofail(m->time_change_watch.fd);
746 if (m->jobs_in_progress_watch.fd >= 0)
747 close_nointr_nofail(m->jobs_in_progress_watch.fd);
749 free(m->notify_socket);
751 lookup_paths_free(&m->lookup_paths);
752 strv_free(m->environment);
754 hashmap_free(m->cgroup_unit);
755 set_free_free(m->unit_path_cache);
759 free(m->switch_root);
760 free(m->switch_root_init);
762 for (i = 0; i < RLIMIT_NLIMITS; i++)
768 int manager_enumerate(Manager *m) {
774 /* Let's ask every type to load all units from disk/kernel
775 * that it might know */
776 for (c = 0; c < _UNIT_TYPE_MAX; c++)
777 if (unit_vtable[c]->enumerate)
778 if ((q = unit_vtable[c]->enumerate(m)) < 0)
781 manager_dispatch_load_queue(m);
785 int manager_coldplug(Manager *m) {
793 /* Then, let's set up their initial state. */
794 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
800 if ((q = unit_coldplug(u)) < 0)
807 static void manager_build_unit_path_cache(Manager *m) {
809 _cleanup_free_ DIR *d = NULL;
814 set_free_free(m->unit_path_cache);
816 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
817 if (!m->unit_path_cache) {
818 log_error("Failed to allocate unit path cache.");
822 /* This simply builds a list of files we know exist, so that
823 * we don't always have to go to disk */
825 STRV_FOREACH(i, m->lookup_paths.unit_path) {
831 log_error("Failed to open directory %s: %m", *i);
835 while ((de = readdir(d))) {
838 if (ignore_file(de->d_name))
841 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
847 r = set_consume(m->unit_path_cache, p);
859 log_error("Failed to build unit path cache: %s", strerror(-r));
861 set_free_free(m->unit_path_cache);
862 m->unit_path_cache = NULL;
865 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
870 dual_timestamp_get(&m->generators_start_timestamp);
871 manager_run_generators(m);
872 dual_timestamp_get(&m->generators_finish_timestamp);
874 r = lookup_paths_init(
875 &m->lookup_paths, m->running_as, true,
876 m->generator_unit_path,
877 m->generator_unit_path_early,
878 m->generator_unit_path_late);
882 manager_build_unit_path_cache(m);
884 /* If we will deserialize make sure that during enumeration
885 * this is already known, so we increase the counter here
890 /* First, enumerate what we can from all config files */
891 dual_timestamp_get(&m->unitsload_start_timestamp);
892 r = manager_enumerate(m);
893 dual_timestamp_get(&m->unitsload_finish_timestamp);
895 /* Second, deserialize if there is something to deserialize */
897 q = manager_deserialize(m, serialization, fds);
902 /* Any fds left? Find some unit which wants them. This is
903 * useful to allow container managers to pass some file
904 * descriptors to us pre-initialized. This enables
905 * socket-based activation of entire containers. */
906 if (fdset_size(fds) > 0) {
907 q = manager_distribute_fds(m, fds);
912 /* Third, fire things up! */
913 q = manager_coldplug(m);
918 assert(m->n_reloading > 0);
921 /* Let's wait for the UnitNew/JobNew messages being
922 * sent, before we notify that the reload is
924 m->send_reloading_done = true;
930 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
935 assert(type < _JOB_TYPE_MAX);
937 assert(mode < _JOB_MODE_MAX);
939 if (mode == JOB_ISOLATE && type != JOB_START) {
940 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
944 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
945 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
949 log_debug_unit(unit->id,
950 "Trying to enqueue job %s/%s/%s", unit->id,
951 job_type_to_string(type), job_mode_to_string(mode));
953 job_type_collapse(&type, unit);
955 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
959 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
960 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
961 mode == JOB_IGNORE_DEPENDENCIES, e);
965 if (mode == JOB_ISOLATE) {
966 r = transaction_add_isolate_jobs(tr, m);
971 r = transaction_activate(tr, m, mode, e);
975 log_debug_unit(unit->id,
976 "Enqueued job %s/%s as %u", unit->id,
977 job_type_to_string(type), (unsigned) tr->anchor_job->id);
980 *_ret = tr->anchor_job;
982 transaction_free(tr);
986 transaction_abort(tr);
987 transaction_free(tr);
991 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
996 assert(type < _JOB_TYPE_MAX);
998 assert(mode < _JOB_MODE_MAX);
1000 r = manager_load_unit(m, name, NULL, NULL, &unit);
1004 return manager_add_job(m, type, unit, mode, override, e, _ret);
1007 Job *manager_get_job(Manager *m, uint32_t id) {
1010 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1013 Unit *manager_get_unit(Manager *m, const char *name) {
1017 return hashmap_get(m->units, name);
1020 unsigned manager_dispatch_load_queue(Manager *m) {
1026 /* Make sure we are not run recursively */
1027 if (m->dispatching_load_queue)
1030 m->dispatching_load_queue = true;
1032 /* Dispatches the load queue. Takes a unit from the queue and
1033 * tries to load its data until the queue is empty */
1035 while ((u = m->load_queue)) {
1036 assert(u->in_load_queue);
1042 m->dispatching_load_queue = false;
1046 int manager_load_unit_prepare(
1058 assert(name || path);
1060 /* This will prepare the unit for loading, but not actually
1061 * load anything from disk. */
1063 if (path && !is_path(path)) {
1064 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1069 name = path_get_file_name(path);
1071 t = unit_name_to_type(name);
1073 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
1074 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1078 ret = manager_get_unit(m, name);
1084 ret = unit_new(m, unit_vtable[t]->object_size);
1089 ret->fragment_path = strdup(path);
1090 if (!ret->fragment_path) {
1096 r = unit_add_name(ret, name);
1102 unit_add_to_load_queue(ret);
1103 unit_add_to_dbus_queue(ret);
1104 unit_add_to_gc_queue(ret);
1112 int manager_load_unit(
1123 /* This will load the service information files, but not actually
1124 * start any services or anything. */
1126 r = manager_load_unit_prepare(m, name, path, e, _ret);
1130 manager_dispatch_load_queue(m);
1133 *_ret = unit_follow_merge(*_ret);
1138 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1145 HASHMAP_FOREACH(j, s->jobs, i)
1146 job_dump(j, f, prefix);
1149 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1157 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1159 unit_dump(u, f, prefix);
1162 void manager_clear_jobs(Manager *m) {
1167 while ((j = hashmap_first(m->jobs)))
1168 /* No need to recurse. We're cancelling all jobs. */
1169 job_finish_and_invalidate(j, JOB_CANCELED, false);
1172 unsigned manager_dispatch_run_queue(Manager *m) {
1176 if (m->dispatching_run_queue)
1179 m->dispatching_run_queue = true;
1181 while ((j = m->run_queue)) {
1182 assert(j->installed);
1183 assert(j->in_run_queue);
1185 job_run_and_invalidate(j);
1189 m->dispatching_run_queue = false;
1191 if (m->n_running_jobs > 0)
1192 manager_watch_jobs_in_progress(m);
1194 if (m->n_on_console > 0)
1195 manager_watch_idle_pipe(m);
1200 unsigned manager_dispatch_dbus_queue(Manager *m) {
1207 if (m->dispatching_dbus_queue)
1210 m->dispatching_dbus_queue = true;
1212 while ((u = m->dbus_unit_queue)) {
1213 assert(u->in_dbus_queue);
1215 bus_unit_send_change_signal(u);
1219 while ((j = m->dbus_job_queue)) {
1220 assert(j->in_dbus_queue);
1222 bus_job_send_change_signal(j);
1226 m->dispatching_dbus_queue = false;
1228 if (m->send_reloading_done) {
1229 m->send_reloading_done = false;
1231 bus_broadcast_reloading(m, false);
1237 static int manager_process_notify_fd(Manager *m) {
1244 struct iovec iovec = {
1246 .iov_len = sizeof(buf)-1,
1250 struct cmsghdr cmsghdr;
1251 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1254 struct msghdr msghdr = {
1257 .msg_control = &control,
1258 .msg_controllen = sizeof(control),
1260 struct ucred *ucred;
1262 _cleanup_strv_free_ char **tags = NULL;
1264 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1269 if (errno == EAGAIN || errno == EINTR)
1275 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1276 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1277 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1278 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1279 log_warning("Received notify message without credentials. Ignoring.");
1283 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1285 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1287 u = manager_get_unit_by_pid(m, ucred->pid);
1289 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1294 assert((size_t) n < sizeof(buf));
1296 tags = strv_split(buf, "\n\r");
1300 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1302 if (UNIT_VTABLE(u)->notify_message)
1303 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1309 static int manager_dispatch_sigchld(Manager *m) {
1317 /* First we call waitd() for a PID and do not reap the
1318 * zombie. That way we can still access /proc/$PID for
1319 * it while it is a zombie. */
1320 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1322 if (errno == ECHILD)
1334 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1335 _cleanup_free_ char *name = NULL;
1337 get_process_comm(si.si_pid, &name);
1338 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1341 /* Let's flush any message the dying child might still
1342 * have queued for us. This ensures that the process
1343 * still exists in /proc so that we can figure out
1344 * which cgroup and hence unit it belongs to. */
1345 r = manager_process_notify_fd(m);
1349 /* And now figure out the unit this belongs to */
1350 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1352 u = manager_get_unit_by_pid(m, si.si_pid);
1354 /* And now, we actually reap the zombie. */
1355 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1362 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1365 log_debug("Child %lu died (code=%s, status=%i/%s)",
1366 (long unsigned) si.si_pid,
1367 sigchld_code_to_string(si.si_code),
1369 strna(si.si_code == CLD_EXITED
1370 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1371 : signal_to_string(si.si_status)));
1376 log_debug_unit(u->id,
1377 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1379 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1380 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1386 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1390 dbus_error_init(&error);
1392 log_debug_unit(name, "Activating special unit %s", name);
1394 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1396 log_error_unit(name,
1397 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1399 dbus_error_free(&error);
1404 static int manager_process_signal_fd(Manager *m) {
1406 struct signalfd_siginfo sfsi;
1407 bool sigchld = false;
1412 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1413 if (n != sizeof(sfsi)) {
1418 if (errno == EINTR || errno == EAGAIN)
1424 if (sfsi.ssi_pid > 0) {
1427 get_process_comm(sfsi.ssi_pid, &p);
1429 log_debug("Received SIG%s from PID %lu (%s).",
1430 signal_to_string(sfsi.ssi_signo),
1431 (unsigned long) sfsi.ssi_pid, strna(p));
1434 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1436 switch (sfsi.ssi_signo) {
1443 if (m->running_as == SYSTEMD_SYSTEM) {
1444 /* This is for compatibility with the
1445 * original sysvinit */
1446 m->exit_code = MANAGER_REEXECUTE;
1453 if (m->running_as == SYSTEMD_SYSTEM) {
1454 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1458 /* Run the exit target if there is one, if not, just exit. */
1459 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1460 m->exit_code = MANAGER_EXIT;
1467 if (m->running_as == SYSTEMD_SYSTEM)
1468 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1470 /* This is a nop on non-init */
1474 if (m->running_as == SYSTEMD_SYSTEM)
1475 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1477 /* This is a nop on non-init */
1483 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1485 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1486 log_info("Trying to reconnect to bus...");
1490 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1491 log_info("Loading D-Bus service...");
1492 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1503 if (!(f = open_memstream(&dump, &size))) {
1504 log_warning("Failed to allocate memory stream.");
1508 manager_dump_units(m, f, "\t");
1509 manager_dump_jobs(m, f, "\t");
1514 log_warning("Failed to write status stream");
1519 log_dump(LOG_INFO, dump);
1526 m->exit_code = MANAGER_RELOAD;
1531 /* Starting SIGRTMIN+0 */
1532 static const char * const target_table[] = {
1533 [0] = SPECIAL_DEFAULT_TARGET,
1534 [1] = SPECIAL_RESCUE_TARGET,
1535 [2] = SPECIAL_EMERGENCY_TARGET,
1536 [3] = SPECIAL_HALT_TARGET,
1537 [4] = SPECIAL_POWEROFF_TARGET,
1538 [5] = SPECIAL_REBOOT_TARGET,
1539 [6] = SPECIAL_KEXEC_TARGET
1542 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1543 static const ManagerExitCode code_table[] = {
1545 [1] = MANAGER_POWEROFF,
1546 [2] = MANAGER_REBOOT,
1550 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1551 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1552 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1553 manager_start_target(m, target_table[idx],
1554 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1558 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1559 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1560 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1564 switch (sfsi.ssi_signo - SIGRTMIN) {
1567 log_debug("Enabling showing of status.");
1568 manager_set_show_status(m, true);
1572 log_debug("Disabling showing of status.");
1573 manager_set_show_status(m, false);
1577 log_set_max_level(LOG_DEBUG);
1578 log_notice("Setting log level to debug.");
1582 log_set_max_level(LOG_INFO);
1583 log_notice("Setting log level to info.");
1587 if (m->running_as == SYSTEMD_USER) {
1588 m->exit_code = MANAGER_EXIT;
1592 /* This is a nop on init */
1596 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1597 log_notice("Setting log target to journal-or-kmsg.");
1601 log_set_target(LOG_TARGET_CONSOLE);
1602 log_notice("Setting log target to console.");
1606 log_set_target(LOG_TARGET_KMSG);
1607 log_notice("Setting log target to kmsg.");
1611 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1612 log_notice("Setting log target to syslog-or-kmsg.");
1616 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1623 return manager_dispatch_sigchld(m);
1628 static int process_event(Manager *m, struct epoll_event *ev) {
1635 assert_se(w = ev->data.ptr);
1637 if (w->type == WATCH_INVALID)
1644 /* An incoming signal? */
1645 if (ev->events != EPOLLIN)
1648 if ((r = manager_process_signal_fd(m)) < 0)
1655 /* An incoming daemon notification event? */
1656 if (ev->events != EPOLLIN)
1659 if ((r = manager_process_notify_fd(m)) < 0)
1666 /* Some fd event, to be dispatched to the units */
1667 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1670 case WATCH_UNIT_TIMER:
1671 case WATCH_JOB_TIMER: {
1675 /* Some timer event, to be dispatched to the units */
1676 k = read(w->fd, &v, sizeof(v));
1677 if (k != sizeof(v)) {
1679 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1682 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1683 return k < 0 ? -errno : -EIO;
1686 if (w->type == WATCH_UNIT_TIMER)
1687 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1689 job_timer_event(w->data.job, v, w);
1694 /* Some mount table change, intended for the mount subsystem */
1695 mount_fd_event(m, ev->events);
1699 /* Some swap table change, intended for the swap subsystem */
1700 swap_fd_event(m, ev->events);
1704 /* Some notification from udev, intended for the device subsystem */
1705 device_fd_event(m, ev->events);
1708 case WATCH_DBUS_WATCH:
1709 bus_watch_event(m, w, ev->events);
1712 case WATCH_DBUS_TIMEOUT:
1713 bus_timeout_event(m, w, ev->events);
1716 case WATCH_TIME_CHANGE: {
1720 log_struct(LOG_INFO,
1721 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1722 "MESSAGE=Time has been changed",
1725 /* Restart the watch */
1726 epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->time_change_watch.fd,
1728 close_nointr_nofail(m->time_change_watch.fd);
1729 watch_init(&m->time_change_watch);
1730 manager_setup_time_change(m);
1732 HASHMAP_FOREACH(u, m->units, i) {
1733 if (UNIT_VTABLE(u)->time_change)
1734 UNIT_VTABLE(u)->time_change(u);
1740 case WATCH_JOBS_IN_PROGRESS: {
1743 /* not interested in the data */
1744 read(w->fd, &v, sizeof(v));
1746 manager_print_jobs_in_progress(m);
1750 case WATCH_IDLE_PIPE: {
1751 m->no_console_output = true;
1753 manager_unwatch_idle_pipe(m);
1759 log_error("event type=%i", w->type);
1760 assert_not_reached("Unknown epoll event type.");
1766 int manager_loop(Manager *m) {
1769 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1772 m->exit_code = MANAGER_RUNNING;
1774 /* Release the path cache */
1775 set_free_free(m->unit_path_cache);
1776 m->unit_path_cache = NULL;
1778 manager_check_finished(m);
1780 /* There might still be some zombies hanging around from
1781 * before we were exec()'ed. Leat's reap them */
1782 r = manager_dispatch_sigchld(m);
1786 while (m->exit_code == MANAGER_RUNNING) {
1787 struct epoll_event event;
1791 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1794 if (!ratelimit_test(&rl)) {
1795 /* Yay, something is going seriously wrong, pause a little */
1796 log_warning("Looping too fast. Throttling execution a little.");
1801 if (manager_dispatch_load_queue(m) > 0)
1804 if (manager_dispatch_gc_queue(m) > 0)
1807 if (manager_dispatch_cleanup_queue(m) > 0)
1810 if (manager_dispatch_cgroup_queue(m) > 0)
1813 if (manager_dispatch_run_queue(m) > 0)
1816 if (bus_dispatch(m) > 0)
1819 if (manager_dispatch_dbus_queue(m) > 0)
1822 if (swap_dispatch_reload(m) > 0)
1825 /* Sleep for half the watchdog time */
1826 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1827 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1833 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1845 r = process_event(m, &event);
1850 return m->exit_code;
1853 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1854 _cleanup_free_ char *n = NULL;
1862 r = unit_name_from_dbus_path(s, &n);
1866 r = manager_load_unit(m, n, NULL, e, &u);
1875 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1884 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1887 r = safe_atou(s + 30, &id);
1891 j = manager_get_job(m, id);
1900 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1906 audit_fd = get_audit_fd();
1910 /* Don't generate audit events if the service was already
1911 * started and we're just deserializing */
1912 if (m->n_reloading > 0)
1915 if (m->running_as != SYSTEMD_SYSTEM)
1918 if (u->type != UNIT_SERVICE)
1921 p = unit_name_to_prefix_and_instance(u->id);
1923 log_error_unit(u->id,
1924 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1928 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1929 if (errno == EPERM) {
1930 /* We aren't allowed to send audit messages?
1931 * Then let's not retry again. */
1934 log_warning("Failed to send audit message: %m");
1942 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1944 union sockaddr_union sa;
1946 char *message = NULL;
1948 /* Don't generate plymouth events if the service was already
1949 * started and we're just deserializing */
1950 if (m->n_reloading > 0)
1953 if (m->running_as != SYSTEMD_SYSTEM)
1956 if (u->type != UNIT_SERVICE &&
1957 u->type != UNIT_MOUNT &&
1958 u->type != UNIT_SWAP)
1961 /* We set SOCK_NONBLOCK here so that we rather drop the
1962 * message then wait for plymouth */
1963 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1965 log_error("socket() failed: %m");
1970 sa.sa.sa_family = AF_UNIX;
1971 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1972 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1974 if (errno != EPIPE &&
1977 errno != ECONNREFUSED &&
1978 errno != ECONNRESET &&
1979 errno != ECONNABORTED)
1980 log_error("connect() failed: %m");
1985 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1991 if (write(fd, message, n + 1) != n + 1) {
1993 if (errno != EPIPE &&
1996 errno != ECONNREFUSED &&
1997 errno != ECONNRESET &&
1998 errno != ECONNABORTED)
1999 log_error("Failed to write Plymouth message: %m");
2006 close_nointr_nofail(fd);
2011 void manager_dispatch_bus_name_owner_changed(
2014 const char* old_owner,
2015 const char *new_owner) {
2022 if (!(u = hashmap_get(m->watch_bus, name)))
2025 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2028 void manager_dispatch_bus_query_pid_done(
2039 if (!(u = hashmap_get(m->watch_bus, name)))
2042 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
2045 int manager_open_serialization(Manager *m, FILE **_f) {
2052 if (m->running_as == SYSTEMD_SYSTEM)
2053 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
2055 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
2060 RUN_WITH_UMASK(0077) {
2061 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2071 log_debug("Serializing state to %s", path);
2074 f = fdopen(fd, "w+");
2083 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2096 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2097 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2098 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2099 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2101 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2102 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2103 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2104 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2107 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2108 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2111 if (!switching_root) {
2112 STRV_FOREACH(e, m->environment) {
2113 _cleanup_free_ char *ce;
2117 fprintf(f, "env=%s\n", *e);
2121 bus_serialize(m, f);
2125 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2129 if (!unit_can_serialize(u))
2136 r = unit_serialize(u, f, fds, !switching_root);
2143 assert(m->n_reloading > 0);
2149 r = bus_fdset_add_all(m, fds);
2156 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2162 log_debug("Deserializing state...");
2167 char line[LINE_MAX], *l;
2169 if (!fgets(line, sizeof(line), f)) {
2184 if (startswith(l, "current-job-id=")) {
2187 if (safe_atou32(l+15, &id) < 0)
2188 log_debug("Failed to parse current job id value %s", l+15);
2190 m->current_job_id = MAX(m->current_job_id, id);
2191 } else if (startswith(l, "n-installed-jobs=")) {
2194 if (safe_atou32(l+17, &n) < 0)
2195 log_debug("Failed to parse installed jobs counter %s", l+17);
2197 m->n_installed_jobs += n;
2198 } else if (startswith(l, "n-failed-jobs=")) {
2201 if (safe_atou32(l+14, &n) < 0)
2202 log_debug("Failed to parse failed jobs counter %s", l+14);
2204 m->n_failed_jobs += n;
2205 } else if (startswith(l, "taint-usr=")) {
2208 if ((b = parse_boolean(l+10)) < 0)
2209 log_debug("Failed to parse taint /usr flag %s", l+10);
2211 m->taint_usr = m->taint_usr || b;
2212 } else if (startswith(l, "firmware-timestamp="))
2213 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2214 else if (startswith(l, "loader-timestamp="))
2215 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2216 else if (startswith(l, "kernel-timestamp="))
2217 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2218 else if (startswith(l, "initrd-timestamp="))
2219 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2220 else if (startswith(l, "userspace-timestamp="))
2221 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2222 else if (startswith(l, "finish-timestamp="))
2223 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2224 else if (startswith(l, "env=")) {
2225 _cleanup_free_ char *uce = NULL;
2228 uce = cunescape(l+4);
2234 e = strv_env_set(m->environment, uce);
2240 strv_free(m->environment);
2242 } else if (bus_deserialize_item(m, l) == 0)
2243 log_debug("Unknown serialization item '%s'", l);
2248 char name[UNIT_NAME_MAX+2];
2251 if (!fgets(name, sizeof(name), f)) {
2262 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2266 r = unit_deserialize(u, f, fds);
2277 assert(m->n_reloading > 0);
2283 int manager_distribute_fds(Manager *m, FDSet *fds) {
2290 HASHMAP_FOREACH(u, m->units, i) {
2292 if (fdset_size(fds) <= 0)
2295 if (UNIT_VTABLE(u)->distribute_fds) {
2296 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2305 int manager_reload(Manager *m) {
2312 r = manager_open_serialization(m, &f);
2317 bus_broadcast_reloading(m, true);
2326 r = manager_serialize(m, f, fds, false);
2332 if (fseeko(f, 0, SEEK_SET) < 0) {
2338 /* From here on there is no way back. */
2339 manager_clear_jobs_and_units(m);
2340 manager_undo_generators(m);
2341 lookup_paths_free(&m->lookup_paths);
2343 /* Find new unit paths */
2344 manager_run_generators(m);
2346 q = lookup_paths_init(
2347 &m->lookup_paths, m->running_as, true,
2348 m->generator_unit_path,
2349 m->generator_unit_path_early,
2350 m->generator_unit_path_late);
2354 manager_build_unit_path_cache(m);
2356 /* First, enumerate what we can from all config files */
2357 q = manager_enumerate(m);
2361 /* Second, deserialize our stored data */
2362 q = manager_deserialize(m, f, fds);
2369 /* Third, fire things up! */
2370 q = manager_coldplug(m);
2374 assert(m->n_reloading > 0);
2377 m->send_reloading_done = true;
2389 static bool manager_is_booting_or_shutting_down(Manager *m) {
2394 /* Is the initial job still around? */
2395 if (manager_get_job(m, m->default_unit_job_id))
2398 /* Is there a job for the shutdown target? */
2399 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2406 bool manager_is_reloading_or_reexecuting(Manager *m) {
2409 return m->n_reloading != 0;
2412 void manager_reset_failed(Manager *m) {
2418 HASHMAP_FOREACH(u, m->units, i)
2419 unit_reset_failed(u);
2422 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2428 /* Returns true if the unit is inactive or going down */
2429 u = manager_get_unit(m, name);
2433 return unit_inactive_or_pending(u);
2436 void manager_check_finished(Manager *m) {
2437 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2438 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2442 if (m->n_running_jobs == 0)
2443 manager_unwatch_jobs_in_progress(m);
2445 if (hashmap_size(m->jobs) > 0) {
2446 manager_jobs_in_progress_mod_timer(m);
2450 /* Notify Type=idle units that we are done now */
2451 manager_unwatch_idle_pipe(m);
2454 /* Turn off confirm spawn now */
2455 m->confirm_spawn = false;
2457 if (dual_timestamp_is_set(&m->finish_timestamp))
2460 dual_timestamp_get(&m->finish_timestamp);
2462 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2464 /* Note that m->kernel_usec.monotonic is always at 0,
2465 * and m->firmware_usec.monotonic and
2466 * m->loader_usec.monotonic should be considered
2467 * negative values. */
2469 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2470 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2471 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2472 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2474 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2476 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2477 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2479 if (!log_on_console())
2480 log_struct(LOG_INFO,
2481 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2482 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2483 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2484 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2485 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2486 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2487 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2488 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2489 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2492 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2495 if (!log_on_console())
2496 log_struct(LOG_INFO,
2497 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2498 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2499 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2500 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2501 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2502 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2503 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2507 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2508 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2510 if (!log_on_console())
2511 log_struct(LOG_INFO,
2512 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2513 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2514 "MESSAGE=Startup finished in %s.",
2515 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2519 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2522 "READY=1\nSTATUS=Startup finished in %s.",
2523 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2526 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2537 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2539 p = strappend("/run/systemd/", name);
2543 r = mkdir_p_label(p, 0755);
2545 log_error("Failed to create generator directory %s: %s",
2551 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2556 log_error("Failed to create generator directory %s: %m",
2567 static void trim_generator_dir(Manager *m, char **generator) {
2574 if (rmdir(*generator) >= 0) {
2582 void manager_run_generators(Manager *m) {
2584 const char *generator_path;
2585 const char *argv[5];
2590 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2591 d = opendir(generator_path);
2593 if (errno == ENOENT)
2596 log_error("Failed to enumerate generator directory %s: %m",
2601 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2605 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2609 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2613 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2614 argv[1] = m->generator_unit_path;
2615 argv[2] = m->generator_unit_path_early;
2616 argv[3] = m->generator_unit_path_late;
2619 RUN_WITH_UMASK(0022) {
2620 execute_directory(generator_path, d, (char**) argv);
2623 trim_generator_dir(m, &m->generator_unit_path);
2624 trim_generator_dir(m, &m->generator_unit_path_early);
2625 trim_generator_dir(m, &m->generator_unit_path_late);
2632 static void remove_generator_dir(Manager *m, char **generator) {
2639 strv_remove(m->lookup_paths.unit_path, *generator);
2640 rm_rf(*generator, false, true, false);
2646 void manager_undo_generators(Manager *m) {
2649 remove_generator_dir(m, &m->generator_unit_path);
2650 remove_generator_dir(m, &m->generator_unit_path_early);
2651 remove_generator_dir(m, &m->generator_unit_path_late);
2654 int manager_set_default_environment(Manager *m, char **environment) {
2658 e = strv_env_merge(2, m->environment, environment);
2661 strv_free(m->environment);
2666 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2671 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2672 if (!default_rlimit[i])
2675 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2683 void manager_recheck_journal(Manager *m) {
2688 if (m->running_as != SYSTEMD_SYSTEM)
2691 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2692 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2693 log_close_journal();
2697 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2698 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2699 log_close_journal();
2703 /* Hmm, OK, so the socket is fully up and the service is up
2704 * too, then let's make use of the thing. */
2708 void manager_set_show_status(Manager *m, bool b) {
2711 if (m->running_as != SYSTEMD_SYSTEM)
2717 touch("/run/systemd/show-status");
2719 unlink("/run/systemd/show-status");
2722 static bool manager_get_show_status(Manager *m) {
2725 if (m->running_as != SYSTEMD_SYSTEM)
2728 if (m->no_console_output)
2734 /* If Plymouth is running make sure we show the status, so
2735 * that there's something nice to see when people press Esc */
2737 return plymouth_running();
2740 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2743 if (!manager_get_show_status(m))
2746 /* XXX We should totally drop the check for ephemeral here
2747 * and thus effectively make 'Type=idle' pointless. */
2748 if (ephemeral && m->n_on_console > 0)
2751 if (!manager_is_booting_or_shutting_down(m))
2754 va_start(ap, format);
2755 status_vprintf(status, true, ephemeral, format, ap);
2759 void watch_init(Watch *w) {
2762 w->type = WATCH_INVALID;