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.");
304 log_debug("m->epoll_fd=%d m->idle_pipe_watch.fd=%d",
305 m->epoll_fd, m->idle_pipe_watch.fd);
310 if (m->idle_pipe_watch.fd >= 0)
311 close_nointr_nofail(m->idle_pipe_watch.fd);
312 watch_init(&m->idle_pipe_watch);
316 static void manager_unwatch_idle_pipe(Manager *m) {
317 if (m->idle_pipe_watch.type != WATCH_IDLE_PIPE)
320 log_debug("m->epoll_fd=%d m->idle_pipe_watch.fd=%d",
321 m->epoll_fd, m->idle_pipe_watch.fd);
322 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->idle_pipe_watch.fd, NULL) >= 0);
323 watch_init(&m->idle_pipe_watch);
325 log_debug("Closed idle_pipe watch.");
328 static int manager_setup_time_change(Manager *m) {
329 struct epoll_event ev = {
331 .data.ptr = &m->time_change_watch,
334 /* We only care for the cancellation event, hence we set the
335 * timeout to the latest possible value. */
336 struct itimerspec its = {
337 .it_value.tv_sec = TIME_T_MAX,
339 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
341 assert(m->time_change_watch.type == WATCH_INVALID);
343 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
344 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
346 m->time_change_watch.type = WATCH_TIME_CHANGE;
347 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
348 if (m->time_change_watch.fd < 0) {
349 log_error("Failed to create timerfd: %m");
353 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
354 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
355 close_nointr_nofail(m->time_change_watch.fd);
356 watch_init(&m->time_change_watch);
360 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
361 log_error("Failed to add timer change fd to epoll: %m");
365 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
370 static int enable_special_signals(Manager *m) {
375 /* Enable that we get SIGINT on control-alt-del. In containers
376 * this will fail with EPERM (older) or EINVAL (newer), so
378 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
379 log_warning("Failed to enable ctrl-alt-del handling: %m");
381 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
383 /* Support systems without virtual console */
385 log_warning("Failed to open /dev/tty0: %m");
387 /* Enable that we get SIGWINCH on kbrequest */
388 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
389 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
391 close_nointr_nofail(fd);
397 static int manager_setup_signals(Manager *m) {
399 struct epoll_event ev = {
401 .data.ptr = &m->signal_watch,
403 struct sigaction sa = {
404 .sa_handler = SIG_DFL,
405 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
410 /* We are not interested in SIGSTOP and friends. */
411 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
413 assert_se(sigemptyset(&mask) == 0);
415 sigset_add_many(&mask,
416 SIGCHLD, /* Child died */
417 SIGTERM, /* Reexecute daemon */
418 SIGHUP, /* Reload configuration */
419 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
420 SIGUSR2, /* systemd: dump status */
421 SIGINT, /* Kernel sends us this on control-alt-del */
422 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
423 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
424 SIGRTMIN+0, /* systemd: start default.target */
425 SIGRTMIN+1, /* systemd: isolate rescue.target */
426 SIGRTMIN+2, /* systemd: isolate emergency.target */
427 SIGRTMIN+3, /* systemd: start halt.target */
428 SIGRTMIN+4, /* systemd: start poweroff.target */
429 SIGRTMIN+5, /* systemd: start reboot.target */
430 SIGRTMIN+6, /* systemd: start kexec.target */
431 SIGRTMIN+13, /* systemd: Immediate halt */
432 SIGRTMIN+14, /* systemd: Immediate poweroff */
433 SIGRTMIN+15, /* systemd: Immediate reboot */
434 SIGRTMIN+16, /* systemd: Immediate kexec */
435 SIGRTMIN+20, /* systemd: enable status messages */
436 SIGRTMIN+21, /* systemd: disable status messages */
437 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
438 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
439 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
440 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
441 SIGRTMIN+27, /* systemd: set log target to console */
442 SIGRTMIN+28, /* systemd: set log target to kmsg */
443 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
445 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
447 m->signal_watch.type = WATCH_SIGNAL;
448 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
449 if (m->signal_watch.fd < 0)
452 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
455 if (m->running_as == SYSTEMD_SYSTEM)
456 return enable_special_signals(m);
461 static void manager_strip_environment(Manager *m) {
464 /* Remove variables from the inherited set that are part of
465 * the container interface:
466 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
467 strv_remove_prefix(m->environment, "container=");
468 strv_remove_prefix(m->environment, "container_");
470 /* Remove variables from the inherited set that are part of
471 * the initrd interface:
472 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
473 strv_remove_prefix(m->environment, "RD_");
475 /* Drop invalid entries */
476 strv_env_clean(m->environment);
479 int manager_new(SystemdRunningAs running_as, bool reexecuting, Manager **_m) {
484 assert(running_as >= 0);
485 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
487 m = new0(Manager, 1);
492 if (detect_container(NULL) <= 0)
493 efi_get_boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
496 m->running_as = running_as;
497 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
498 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
499 m->pin_cgroupfs_fd = -1;
500 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
502 watch_init(&m->signal_watch);
503 watch_init(&m->mount_watch);
504 watch_init(&m->swap_watch);
505 watch_init(&m->udev_watch);
506 watch_init(&m->time_change_watch);
507 watch_init(&m->jobs_in_progress_watch);
509 m->epoll_fd = m->dev_autofs_fd = -1;
510 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
512 m->environment = strv_copy(environ);
516 manager_strip_environment(m);
518 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
521 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
524 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
527 m->cgroup_unit = hashmap_new(string_hash_func, string_compare_func);
531 m->watch_bus = hashmap_new(string_hash_func, string_compare_func);
535 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
539 r = manager_setup_signals(m);
543 r = manager_setup_cgroup(m);
547 r = manager_setup_notify(m);
551 r = manager_setup_time_change(m);
555 /* Try to connect to the busses, if possible. */
556 if ((running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS")) ||
557 running_as == SYSTEMD_SYSTEM) {
558 r = bus_init(m, reexecuting || running_as != SYSTEMD_SYSTEM);
562 log_debug("Skipping DBus session bus connection attempt - no DBUS_SESSION_BUS_ADDRESS set...");
564 m->taint_usr = dir_is_empty("/usr") > 0;
574 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
580 while ((u = m->cleanup_queue)) {
581 assert(u->in_cleanup_queue);
591 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
592 GC_OFFSET_UNSURE, /* No clue */
593 GC_OFFSET_GOOD, /* We still need this unit */
594 GC_OFFSET_BAD, /* We don't need this unit anymore */
598 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
605 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
606 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
607 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
610 if (u->in_cleanup_queue)
613 if (unit_check_gc(u))
616 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
620 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
621 unit_gc_sweep(other, gc_marker);
623 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
626 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
633 /* We were unable to find anything out about this entry, so
634 * let's investigate it later */
635 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
636 unit_add_to_gc_queue(u);
640 /* We definitely know that this one is not useful anymore, so
641 * let's mark it for deletion */
642 u->gc_marker = gc_marker + GC_OFFSET_BAD;
643 unit_add_to_cleanup_queue(u);
647 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
650 static unsigned manager_dispatch_gc_queue(Manager *m) {
657 /* log_debug("Running GC..."); */
659 m->gc_marker += _GC_OFFSET_MAX;
660 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
663 gc_marker = m->gc_marker;
665 while ((u = m->gc_queue)) {
666 assert(u->in_gc_queue);
668 unit_gc_sweep(u, gc_marker);
670 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
671 u->in_gc_queue = false;
675 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
676 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
677 log_debug_unit(u->id, "Collecting %s", u->id);
678 u->gc_marker = gc_marker + GC_OFFSET_BAD;
679 unit_add_to_cleanup_queue(u);
683 m->n_in_gc_queue = 0;
688 static void manager_clear_jobs_and_units(Manager *m) {
693 while ((u = hashmap_first(m->units)))
696 manager_dispatch_cleanup_queue(m);
698 assert(!m->load_queue);
699 assert(!m->run_queue);
700 assert(!m->dbus_unit_queue);
701 assert(!m->dbus_job_queue);
702 assert(!m->cleanup_queue);
703 assert(!m->gc_queue);
705 assert(hashmap_isempty(m->jobs));
706 assert(hashmap_isempty(m->units));
709 m->n_running_jobs = 0;
712 static void close_idle_pipe(Manager *m) {
713 close_pipe(m->idle_pipe);
714 close_pipe(m->idle_pipe + 2);
717 void manager_free(Manager *m) {
723 manager_clear_jobs_and_units(m);
725 for (c = 0; c < _UNIT_TYPE_MAX; c++)
726 if (unit_vtable[c]->shutdown)
727 unit_vtable[c]->shutdown(m);
729 /* If we reexecute ourselves, we keep the root cgroup
731 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
733 manager_undo_generators(m);
737 hashmap_free(m->units);
738 hashmap_free(m->jobs);
739 hashmap_free(m->watch_pids);
740 hashmap_free(m->watch_bus);
742 if (m->epoll_fd >= 0)
743 close_nointr_nofail(m->epoll_fd);
744 if (m->signal_watch.fd >= 0)
745 close_nointr_nofail(m->signal_watch.fd);
746 if (m->notify_watch.fd >= 0)
747 close_nointr_nofail(m->notify_watch.fd);
748 if (m->time_change_watch.fd >= 0)
749 close_nointr_nofail(m->time_change_watch.fd);
750 if (m->jobs_in_progress_watch.fd >= 0)
751 close_nointr_nofail(m->jobs_in_progress_watch.fd);
753 free(m->notify_socket);
755 lookup_paths_free(&m->lookup_paths);
756 strv_free(m->environment);
758 hashmap_free(m->cgroup_unit);
759 set_free_free(m->unit_path_cache);
763 free(m->switch_root);
764 free(m->switch_root_init);
766 for (i = 0; i < RLIMIT_NLIMITS; i++)
772 int manager_enumerate(Manager *m) {
778 /* Let's ask every type to load all units from disk/kernel
779 * that it might know */
780 for (c = 0; c < _UNIT_TYPE_MAX; c++)
781 if (unit_vtable[c]->enumerate)
782 if ((q = unit_vtable[c]->enumerate(m)) < 0)
785 manager_dispatch_load_queue(m);
789 int manager_coldplug(Manager *m) {
797 /* Then, let's set up their initial state. */
798 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
804 if ((q = unit_coldplug(u)) < 0)
811 static void manager_build_unit_path_cache(Manager *m) {
813 _cleanup_free_ DIR *d = NULL;
818 set_free_free(m->unit_path_cache);
820 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
821 if (!m->unit_path_cache) {
822 log_error("Failed to allocate unit path cache.");
826 /* This simply builds a list of files we know exist, so that
827 * we don't always have to go to disk */
829 STRV_FOREACH(i, m->lookup_paths.unit_path) {
835 log_error("Failed to open directory %s: %m", *i);
839 while ((de = readdir(d))) {
842 if (ignore_file(de->d_name))
845 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
851 r = set_consume(m->unit_path_cache, p);
863 log_error("Failed to build unit path cache: %s", strerror(-r));
865 set_free_free(m->unit_path_cache);
866 m->unit_path_cache = NULL;
869 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
874 dual_timestamp_get(&m->generators_start_timestamp);
875 manager_run_generators(m);
876 dual_timestamp_get(&m->generators_finish_timestamp);
878 r = lookup_paths_init(
879 &m->lookup_paths, m->running_as, true,
880 m->generator_unit_path,
881 m->generator_unit_path_early,
882 m->generator_unit_path_late);
886 manager_build_unit_path_cache(m);
888 /* If we will deserialize make sure that during enumeration
889 * this is already known, so we increase the counter here
894 /* First, enumerate what we can from all config files */
895 dual_timestamp_get(&m->unitsload_start_timestamp);
896 r = manager_enumerate(m);
897 dual_timestamp_get(&m->unitsload_finish_timestamp);
899 /* Second, deserialize if there is something to deserialize */
901 q = manager_deserialize(m, serialization, fds);
906 /* Any fds left? Find some unit which wants them. This is
907 * useful to allow container managers to pass some file
908 * descriptors to us pre-initialized. This enables
909 * socket-based activation of entire containers. */
910 if (fdset_size(fds) > 0) {
911 q = manager_distribute_fds(m, fds);
916 /* Third, fire things up! */
917 q = manager_coldplug(m);
922 assert(m->n_reloading > 0);
925 /* Let's wait for the UnitNew/JobNew messages being
926 * sent, before we notify that the reload is
928 m->send_reloading_done = true;
934 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
939 assert(type < _JOB_TYPE_MAX);
941 assert(mode < _JOB_MODE_MAX);
943 if (mode == JOB_ISOLATE && type != JOB_START) {
944 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
948 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
949 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
953 log_debug_unit(unit->id,
954 "Trying to enqueue job %s/%s/%s", unit->id,
955 job_type_to_string(type), job_mode_to_string(mode));
957 job_type_collapse(&type, unit);
959 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
963 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
964 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
965 mode == JOB_IGNORE_DEPENDENCIES, e);
969 if (mode == JOB_ISOLATE) {
970 r = transaction_add_isolate_jobs(tr, m);
975 r = transaction_activate(tr, m, mode, e);
979 log_debug_unit(unit->id,
980 "Enqueued job %s/%s as %u", unit->id,
981 job_type_to_string(type), (unsigned) tr->anchor_job->id);
984 *_ret = tr->anchor_job;
986 transaction_free(tr);
990 transaction_abort(tr);
991 transaction_free(tr);
995 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
1000 assert(type < _JOB_TYPE_MAX);
1002 assert(mode < _JOB_MODE_MAX);
1004 r = manager_load_unit(m, name, NULL, NULL, &unit);
1008 return manager_add_job(m, type, unit, mode, override, e, _ret);
1011 Job *manager_get_job(Manager *m, uint32_t id) {
1014 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1017 Unit *manager_get_unit(Manager *m, const char *name) {
1021 return hashmap_get(m->units, name);
1024 unsigned manager_dispatch_load_queue(Manager *m) {
1030 /* Make sure we are not run recursively */
1031 if (m->dispatching_load_queue)
1034 m->dispatching_load_queue = true;
1036 /* Dispatches the load queue. Takes a unit from the queue and
1037 * tries to load its data until the queue is empty */
1039 while ((u = m->load_queue)) {
1040 assert(u->in_load_queue);
1046 m->dispatching_load_queue = false;
1050 int manager_load_unit_prepare(
1062 assert(name || path);
1064 /* This will prepare the unit for loading, but not actually
1065 * load anything from disk. */
1067 if (path && !is_path(path)) {
1068 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1073 name = path_get_file_name(path);
1075 t = unit_name_to_type(name);
1077 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
1078 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1082 ret = manager_get_unit(m, name);
1088 ret = unit_new(m, unit_vtable[t]->object_size);
1093 ret->fragment_path = strdup(path);
1094 if (!ret->fragment_path) {
1100 r = unit_add_name(ret, name);
1106 unit_add_to_load_queue(ret);
1107 unit_add_to_dbus_queue(ret);
1108 unit_add_to_gc_queue(ret);
1116 int manager_load_unit(
1127 /* This will load the service information files, but not actually
1128 * start any services or anything. */
1130 r = manager_load_unit_prepare(m, name, path, e, _ret);
1134 manager_dispatch_load_queue(m);
1137 *_ret = unit_follow_merge(*_ret);
1142 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1149 HASHMAP_FOREACH(j, s->jobs, i)
1150 job_dump(j, f, prefix);
1153 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1161 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1163 unit_dump(u, f, prefix);
1166 void manager_clear_jobs(Manager *m) {
1171 while ((j = hashmap_first(m->jobs)))
1172 /* No need to recurse. We're cancelling all jobs. */
1173 job_finish_and_invalidate(j, JOB_CANCELED, false);
1176 unsigned manager_dispatch_run_queue(Manager *m) {
1180 if (m->dispatching_run_queue)
1183 m->dispatching_run_queue = true;
1185 while ((j = m->run_queue)) {
1186 assert(j->installed);
1187 assert(j->in_run_queue);
1189 job_run_and_invalidate(j);
1193 m->dispatching_run_queue = false;
1195 if (m->n_running_jobs > 0)
1196 manager_watch_jobs_in_progress(m);
1198 if (m->n_on_console > 0)
1199 manager_watch_idle_pipe(m);
1204 unsigned manager_dispatch_dbus_queue(Manager *m) {
1211 if (m->dispatching_dbus_queue)
1214 m->dispatching_dbus_queue = true;
1216 while ((u = m->dbus_unit_queue)) {
1217 assert(u->in_dbus_queue);
1219 bus_unit_send_change_signal(u);
1223 while ((j = m->dbus_job_queue)) {
1224 assert(j->in_dbus_queue);
1226 bus_job_send_change_signal(j);
1230 m->dispatching_dbus_queue = false;
1232 if (m->send_reloading_done) {
1233 m->send_reloading_done = false;
1235 bus_broadcast_reloading(m, false);
1241 static int manager_process_notify_fd(Manager *m) {
1248 struct iovec iovec = {
1250 .iov_len = sizeof(buf)-1,
1254 struct cmsghdr cmsghdr;
1255 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1258 struct msghdr msghdr = {
1261 .msg_control = &control,
1262 .msg_controllen = sizeof(control),
1264 struct ucred *ucred;
1266 _cleanup_strv_free_ char **tags = NULL;
1268 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1273 if (errno == EAGAIN || errno == EINTR)
1279 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1280 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1281 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1282 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1283 log_warning("Received notify message without credentials. Ignoring.");
1287 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1289 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1291 u = manager_get_unit_by_pid(m, ucred->pid);
1293 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1298 assert((size_t) n < sizeof(buf));
1300 tags = strv_split(buf, "\n\r");
1304 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1306 if (UNIT_VTABLE(u)->notify_message)
1307 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1313 static int manager_dispatch_sigchld(Manager *m) {
1321 /* First we call waitd() for a PID and do not reap the
1322 * zombie. That way we can still access /proc/$PID for
1323 * it while it is a zombie. */
1324 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1326 if (errno == ECHILD)
1338 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1339 _cleanup_free_ char *name = NULL;
1341 get_process_comm(si.si_pid, &name);
1342 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1345 /* Let's flush any message the dying child might still
1346 * have queued for us. This ensures that the process
1347 * still exists in /proc so that we can figure out
1348 * which cgroup and hence unit it belongs to. */
1349 r = manager_process_notify_fd(m);
1353 /* And now figure out the unit this belongs to */
1354 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1356 u = manager_get_unit_by_pid(m, si.si_pid);
1358 /* And now, we actually reap the zombie. */
1359 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1366 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1369 log_debug("Child %lu died (code=%s, status=%i/%s)",
1370 (long unsigned) si.si_pid,
1371 sigchld_code_to_string(si.si_code),
1373 strna(si.si_code == CLD_EXITED
1374 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1375 : signal_to_string(si.si_status)));
1380 log_debug_unit(u->id,
1381 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1383 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1384 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1390 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1394 dbus_error_init(&error);
1396 log_debug_unit(name, "Activating special unit %s", name);
1398 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1400 log_error_unit(name,
1401 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1403 dbus_error_free(&error);
1408 static int manager_process_signal_fd(Manager *m) {
1410 struct signalfd_siginfo sfsi;
1411 bool sigchld = false;
1416 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1417 if (n != sizeof(sfsi)) {
1422 if (errno == EINTR || errno == EAGAIN)
1428 if (sfsi.ssi_pid > 0) {
1431 get_process_comm(sfsi.ssi_pid, &p);
1433 log_debug("Received SIG%s from PID %lu (%s).",
1434 signal_to_string(sfsi.ssi_signo),
1435 (unsigned long) sfsi.ssi_pid, strna(p));
1438 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1440 switch (sfsi.ssi_signo) {
1447 if (m->running_as == SYSTEMD_SYSTEM) {
1448 /* This is for compatibility with the
1449 * original sysvinit */
1450 m->exit_code = MANAGER_REEXECUTE;
1457 if (m->running_as == SYSTEMD_SYSTEM) {
1458 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1462 /* Run the exit target if there is one, if not, just exit. */
1463 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1464 m->exit_code = MANAGER_EXIT;
1471 if (m->running_as == SYSTEMD_SYSTEM)
1472 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1474 /* This is a nop on non-init */
1478 if (m->running_as == SYSTEMD_SYSTEM)
1479 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1481 /* This is a nop on non-init */
1487 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1489 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1490 log_info("Trying to reconnect to bus...");
1494 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1495 log_info("Loading D-Bus service...");
1496 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1507 if (!(f = open_memstream(&dump, &size))) {
1508 log_warning("Failed to allocate memory stream.");
1512 manager_dump_units(m, f, "\t");
1513 manager_dump_jobs(m, f, "\t");
1518 log_warning("Failed to write status stream");
1523 log_dump(LOG_INFO, dump);
1530 m->exit_code = MANAGER_RELOAD;
1535 /* Starting SIGRTMIN+0 */
1536 static const char * const target_table[] = {
1537 [0] = SPECIAL_DEFAULT_TARGET,
1538 [1] = SPECIAL_RESCUE_TARGET,
1539 [2] = SPECIAL_EMERGENCY_TARGET,
1540 [3] = SPECIAL_HALT_TARGET,
1541 [4] = SPECIAL_POWEROFF_TARGET,
1542 [5] = SPECIAL_REBOOT_TARGET,
1543 [6] = SPECIAL_KEXEC_TARGET
1546 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1547 static const ManagerExitCode code_table[] = {
1549 [1] = MANAGER_POWEROFF,
1550 [2] = MANAGER_REBOOT,
1554 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1555 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1556 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1557 manager_start_target(m, target_table[idx],
1558 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1562 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1563 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1564 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1568 switch (sfsi.ssi_signo - SIGRTMIN) {
1571 log_debug("Enabling showing of status.");
1572 manager_set_show_status(m, true);
1576 log_debug("Disabling showing of status.");
1577 manager_set_show_status(m, false);
1581 log_set_max_level(LOG_DEBUG);
1582 log_notice("Setting log level to debug.");
1586 log_set_max_level(LOG_INFO);
1587 log_notice("Setting log level to info.");
1591 if (m->running_as == SYSTEMD_USER) {
1592 m->exit_code = MANAGER_EXIT;
1596 /* This is a nop on init */
1600 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1601 log_notice("Setting log target to journal-or-kmsg.");
1605 log_set_target(LOG_TARGET_CONSOLE);
1606 log_notice("Setting log target to console.");
1610 log_set_target(LOG_TARGET_KMSG);
1611 log_notice("Setting log target to kmsg.");
1615 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1616 log_notice("Setting log target to syslog-or-kmsg.");
1620 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1627 return manager_dispatch_sigchld(m);
1632 static int process_event(Manager *m, struct epoll_event *ev) {
1639 assert_se(w = ev->data.ptr);
1641 if (w->type == WATCH_INVALID)
1648 /* An incoming signal? */
1649 if (ev->events != EPOLLIN)
1652 if ((r = manager_process_signal_fd(m)) < 0)
1659 /* An incoming daemon notification event? */
1660 if (ev->events != EPOLLIN)
1663 if ((r = manager_process_notify_fd(m)) < 0)
1670 /* Some fd event, to be dispatched to the units */
1671 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1674 case WATCH_UNIT_TIMER:
1675 case WATCH_JOB_TIMER: {
1679 /* Some timer event, to be dispatched to the units */
1680 k = read(w->fd, &v, sizeof(v));
1681 if (k != sizeof(v)) {
1683 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1686 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1687 return k < 0 ? -errno : -EIO;
1690 if (w->type == WATCH_UNIT_TIMER)
1691 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1693 job_timer_event(w->data.job, v, w);
1698 /* Some mount table change, intended for the mount subsystem */
1699 mount_fd_event(m, ev->events);
1703 /* Some swap table change, intended for the swap subsystem */
1704 swap_fd_event(m, ev->events);
1708 /* Some notification from udev, intended for the device subsystem */
1709 device_fd_event(m, ev->events);
1712 case WATCH_DBUS_WATCH:
1713 bus_watch_event(m, w, ev->events);
1716 case WATCH_DBUS_TIMEOUT:
1717 bus_timeout_event(m, w, ev->events);
1720 case WATCH_TIME_CHANGE: {
1724 log_struct(LOG_INFO,
1725 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1726 "MESSAGE=Time has been changed",
1729 /* Restart the watch */
1730 epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->time_change_watch.fd,
1732 close_nointr_nofail(m->time_change_watch.fd);
1733 watch_init(&m->time_change_watch);
1734 manager_setup_time_change(m);
1736 HASHMAP_FOREACH(u, m->units, i) {
1737 if (UNIT_VTABLE(u)->time_change)
1738 UNIT_VTABLE(u)->time_change(u);
1744 case WATCH_JOBS_IN_PROGRESS: {
1747 /* not interested in the data */
1748 read(w->fd, &v, sizeof(v));
1750 manager_print_jobs_in_progress(m);
1754 case WATCH_IDLE_PIPE: {
1755 m->no_console_output = true;
1757 manager_unwatch_idle_pipe(m);
1763 log_error("event type=%i", w->type);
1764 assert_not_reached("Unknown epoll event type.");
1770 int manager_loop(Manager *m) {
1773 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1776 m->exit_code = MANAGER_RUNNING;
1778 /* Release the path cache */
1779 set_free_free(m->unit_path_cache);
1780 m->unit_path_cache = NULL;
1782 manager_check_finished(m);
1784 /* There might still be some zombies hanging around from
1785 * before we were exec()'ed. Leat's reap them */
1786 r = manager_dispatch_sigchld(m);
1790 while (m->exit_code == MANAGER_RUNNING) {
1791 struct epoll_event event;
1795 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1798 if (!ratelimit_test(&rl)) {
1799 /* Yay, something is going seriously wrong, pause a little */
1800 log_warning("Looping too fast. Throttling execution a little.");
1805 if (manager_dispatch_load_queue(m) > 0)
1808 if (manager_dispatch_gc_queue(m) > 0)
1811 if (manager_dispatch_cleanup_queue(m) > 0)
1814 if (manager_dispatch_cgroup_queue(m) > 0)
1817 if (manager_dispatch_run_queue(m) > 0)
1820 if (bus_dispatch(m) > 0)
1823 if (manager_dispatch_dbus_queue(m) > 0)
1826 if (swap_dispatch_reload(m) > 0)
1829 /* Sleep for half the watchdog time */
1830 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1831 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1837 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1849 r = process_event(m, &event);
1854 return m->exit_code;
1857 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1858 _cleanup_free_ char *n = NULL;
1866 r = unit_name_from_dbus_path(s, &n);
1870 r = manager_load_unit(m, n, NULL, e, &u);
1879 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1888 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1891 r = safe_atou(s + 30, &id);
1895 j = manager_get_job(m, id);
1904 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1910 audit_fd = get_audit_fd();
1914 /* Don't generate audit events if the service was already
1915 * started and we're just deserializing */
1916 if (m->n_reloading > 0)
1919 if (m->running_as != SYSTEMD_SYSTEM)
1922 if (u->type != UNIT_SERVICE)
1925 p = unit_name_to_prefix_and_instance(u->id);
1927 log_error_unit(u->id,
1928 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1932 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1933 if (errno == EPERM) {
1934 /* We aren't allowed to send audit messages?
1935 * Then let's not retry again. */
1938 log_warning("Failed to send audit message: %m");
1946 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1948 union sockaddr_union sa;
1950 char *message = NULL;
1952 /* Don't generate plymouth events if the service was already
1953 * started and we're just deserializing */
1954 if (m->n_reloading > 0)
1957 if (m->running_as != SYSTEMD_SYSTEM)
1960 if (u->type != UNIT_SERVICE &&
1961 u->type != UNIT_MOUNT &&
1962 u->type != UNIT_SWAP)
1965 /* We set SOCK_NONBLOCK here so that we rather drop the
1966 * message then wait for plymouth */
1967 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1969 log_error("socket() failed: %m");
1974 sa.sa.sa_family = AF_UNIX;
1975 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1976 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1978 if (errno != EPIPE &&
1981 errno != ECONNREFUSED &&
1982 errno != ECONNRESET &&
1983 errno != ECONNABORTED)
1984 log_error("connect() failed: %m");
1989 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1995 if (write(fd, message, n + 1) != n + 1) {
1997 if (errno != EPIPE &&
2000 errno != ECONNREFUSED &&
2001 errno != ECONNRESET &&
2002 errno != ECONNABORTED)
2003 log_error("Failed to write Plymouth message: %m");
2010 close_nointr_nofail(fd);
2015 void manager_dispatch_bus_name_owner_changed(
2018 const char* old_owner,
2019 const char *new_owner) {
2026 if (!(u = hashmap_get(m->watch_bus, name)))
2029 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2032 void manager_dispatch_bus_query_pid_done(
2043 if (!(u = hashmap_get(m->watch_bus, name)))
2046 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
2049 int manager_open_serialization(Manager *m, FILE **_f) {
2056 if (m->running_as == SYSTEMD_SYSTEM)
2057 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
2059 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
2064 RUN_WITH_UMASK(0077) {
2065 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2075 log_debug("Serializing state to %s", path);
2078 f = fdopen(fd, "w+");
2087 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2100 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2101 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2102 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2103 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2105 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2106 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2107 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2108 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2111 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2112 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2115 if (!switching_root) {
2116 STRV_FOREACH(e, m->environment) {
2117 _cleanup_free_ char *ce;
2121 fprintf(f, "env=%s\n", *e);
2125 bus_serialize(m, f);
2129 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2133 if (!unit_can_serialize(u))
2140 r = unit_serialize(u, f, fds, !switching_root);
2147 assert(m->n_reloading > 0);
2153 r = bus_fdset_add_all(m, fds);
2160 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2166 log_debug("Deserializing state...");
2171 char line[LINE_MAX], *l;
2173 if (!fgets(line, sizeof(line), f)) {
2188 if (startswith(l, "current-job-id=")) {
2191 if (safe_atou32(l+15, &id) < 0)
2192 log_debug("Failed to parse current job id value %s", l+15);
2194 m->current_job_id = MAX(m->current_job_id, id);
2195 } else if (startswith(l, "n-installed-jobs=")) {
2198 if (safe_atou32(l+17, &n) < 0)
2199 log_debug("Failed to parse installed jobs counter %s", l+17);
2201 m->n_installed_jobs += n;
2202 } else if (startswith(l, "n-failed-jobs=")) {
2205 if (safe_atou32(l+14, &n) < 0)
2206 log_debug("Failed to parse failed jobs counter %s", l+14);
2208 m->n_failed_jobs += n;
2209 } else if (startswith(l, "taint-usr=")) {
2212 if ((b = parse_boolean(l+10)) < 0)
2213 log_debug("Failed to parse taint /usr flag %s", l+10);
2215 m->taint_usr = m->taint_usr || b;
2216 } else if (startswith(l, "firmware-timestamp="))
2217 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2218 else if (startswith(l, "loader-timestamp="))
2219 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2220 else if (startswith(l, "kernel-timestamp="))
2221 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2222 else if (startswith(l, "initrd-timestamp="))
2223 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2224 else if (startswith(l, "userspace-timestamp="))
2225 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2226 else if (startswith(l, "finish-timestamp="))
2227 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2228 else if (startswith(l, "env=")) {
2229 _cleanup_free_ char *uce = NULL;
2232 uce = cunescape(l+4);
2238 e = strv_env_set(m->environment, uce);
2244 strv_free(m->environment);
2246 } else if (bus_deserialize_item(m, l) == 0)
2247 log_debug("Unknown serialization item '%s'", l);
2252 char name[UNIT_NAME_MAX+2];
2255 if (!fgets(name, sizeof(name), f)) {
2266 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2270 r = unit_deserialize(u, f, fds);
2281 assert(m->n_reloading > 0);
2287 int manager_distribute_fds(Manager *m, FDSet *fds) {
2294 HASHMAP_FOREACH(u, m->units, i) {
2296 if (fdset_size(fds) <= 0)
2299 if (UNIT_VTABLE(u)->distribute_fds) {
2300 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2309 int manager_reload(Manager *m) {
2316 r = manager_open_serialization(m, &f);
2321 bus_broadcast_reloading(m, true);
2330 r = manager_serialize(m, f, fds, false);
2336 if (fseeko(f, 0, SEEK_SET) < 0) {
2342 /* From here on there is no way back. */
2343 manager_clear_jobs_and_units(m);
2344 manager_undo_generators(m);
2345 lookup_paths_free(&m->lookup_paths);
2347 /* Find new unit paths */
2348 manager_run_generators(m);
2350 q = lookup_paths_init(
2351 &m->lookup_paths, m->running_as, true,
2352 m->generator_unit_path,
2353 m->generator_unit_path_early,
2354 m->generator_unit_path_late);
2358 manager_build_unit_path_cache(m);
2360 /* First, enumerate what we can from all config files */
2361 q = manager_enumerate(m);
2365 /* Second, deserialize our stored data */
2366 q = manager_deserialize(m, f, fds);
2373 /* Third, fire things up! */
2374 q = manager_coldplug(m);
2378 assert(m->n_reloading > 0);
2381 m->send_reloading_done = true;
2393 static bool manager_is_booting_or_shutting_down(Manager *m) {
2398 /* Is the initial job still around? */
2399 if (manager_get_job(m, m->default_unit_job_id))
2402 /* Is there a job for the shutdown target? */
2403 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2410 bool manager_is_reloading_or_reexecuting(Manager *m) {
2413 return m->n_reloading != 0;
2416 void manager_reset_failed(Manager *m) {
2422 HASHMAP_FOREACH(u, m->units, i)
2423 unit_reset_failed(u);
2426 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2432 /* Returns true if the unit is inactive or going down */
2433 u = manager_get_unit(m, name);
2437 return unit_inactive_or_pending(u);
2440 void manager_check_finished(Manager *m) {
2441 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2442 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2446 if (m->n_running_jobs == 0)
2447 manager_unwatch_jobs_in_progress(m);
2449 if (hashmap_size(m->jobs) > 0) {
2450 manager_jobs_in_progress_mod_timer(m);
2454 /* Notify Type=idle units that we are done now */
2455 manager_unwatch_idle_pipe(m);
2458 /* Turn off confirm spawn now */
2459 m->confirm_spawn = false;
2461 if (dual_timestamp_is_set(&m->finish_timestamp))
2464 dual_timestamp_get(&m->finish_timestamp);
2466 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2468 /* Note that m->kernel_usec.monotonic is always at 0,
2469 * and m->firmware_usec.monotonic and
2470 * m->loader_usec.monotonic should be considered
2471 * negative values. */
2473 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2474 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2475 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2476 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2478 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2480 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2481 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2483 if (!log_on_console())
2484 log_struct(LOG_INFO,
2485 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2486 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2487 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2488 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2489 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2490 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2491 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2492 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2493 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2496 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2499 if (!log_on_console())
2500 log_struct(LOG_INFO,
2501 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2502 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2503 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2504 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2505 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2506 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2507 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2511 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2512 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2514 if (!log_on_console())
2515 log_struct(LOG_INFO,
2516 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2517 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2518 "MESSAGE=Startup finished in %s.",
2519 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2523 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2526 "READY=1\nSTATUS=Startup finished in %s.",
2527 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2530 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2541 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2543 p = strappend("/run/systemd/", name);
2547 r = mkdir_p_label(p, 0755);
2549 log_error("Failed to create generator directory %s: %s",
2555 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2560 log_error("Failed to create generator directory %s: %m",
2571 static void trim_generator_dir(Manager *m, char **generator) {
2578 if (rmdir(*generator) >= 0) {
2586 void manager_run_generators(Manager *m) {
2588 const char *generator_path;
2589 const char *argv[5];
2594 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2595 d = opendir(generator_path);
2597 if (errno == ENOENT)
2600 log_error("Failed to enumerate generator directory %s: %m",
2605 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2609 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2613 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2617 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2618 argv[1] = m->generator_unit_path;
2619 argv[2] = m->generator_unit_path_early;
2620 argv[3] = m->generator_unit_path_late;
2623 RUN_WITH_UMASK(0022) {
2624 execute_directory(generator_path, d, (char**) argv);
2627 trim_generator_dir(m, &m->generator_unit_path);
2628 trim_generator_dir(m, &m->generator_unit_path_early);
2629 trim_generator_dir(m, &m->generator_unit_path_late);
2636 static void remove_generator_dir(Manager *m, char **generator) {
2643 strv_remove(m->lookup_paths.unit_path, *generator);
2644 rm_rf(*generator, false, true, false);
2650 void manager_undo_generators(Manager *m) {
2653 remove_generator_dir(m, &m->generator_unit_path);
2654 remove_generator_dir(m, &m->generator_unit_path_early);
2655 remove_generator_dir(m, &m->generator_unit_path_late);
2658 int manager_set_default_environment(Manager *m, char **environment) {
2662 e = strv_env_merge(2, m->environment, environment);
2665 strv_free(m->environment);
2670 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2675 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2676 if (!default_rlimit[i])
2679 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2687 void manager_recheck_journal(Manager *m) {
2692 if (m->running_as != SYSTEMD_SYSTEM)
2695 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2696 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2697 log_close_journal();
2701 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2702 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2703 log_close_journal();
2707 /* Hmm, OK, so the socket is fully up and the service is up
2708 * too, then let's make use of the thing. */
2712 void manager_set_show_status(Manager *m, bool b) {
2715 if (m->running_as != SYSTEMD_SYSTEM)
2721 touch("/run/systemd/show-status");
2723 unlink("/run/systemd/show-status");
2726 static bool manager_get_show_status(Manager *m) {
2729 if (m->running_as != SYSTEMD_SYSTEM)
2732 if (m->no_console_output)
2738 /* If Plymouth is running make sure we show the status, so
2739 * that there's something nice to see when people press Esc */
2741 return plymouth_running();
2744 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2747 if (!manager_get_show_status(m))
2750 /* XXX We should totally drop the check for ephemeral here
2751 * and thus effectively make 'Type=idle' pointless. */
2752 if (ephemeral && m->n_on_console > 0)
2755 if (!manager_is_booting_or_shutting_down(m))
2758 va_start(ap, format);
2759 status_vprintf(status, true, ephemeral, format, ap);
2763 void watch_init(Watch *w) {
2766 w->type = WATCH_INVALID;