1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
25 #include <sys/epoll.h>
27 #include <sys/signalfd.h>
31 #include <sys/reboot.h>
32 #include <sys/ioctl.h>
36 #include <sys/types.h>
39 #include <sys/timerfd.h>
45 #include "systemd/sd-daemon.h"
46 #include "systemd/sd-id128.h"
47 #include "systemd/sd-messages.h"
50 #include "transaction.h"
57 #include "ratelimit.h"
58 #include "locale-setup.h"
59 #include "mount-setup.h"
60 #include "unit-name.h"
61 #include "dbus-unit.h"
64 #include "path-lookup.h"
66 #include "bus-errors.h"
67 #include "exit-status.h"
70 #include "cgroup-util.h"
71 #include "path-util.h"
73 #include "boot-timestamps.h"
76 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
77 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
79 /* Initial delay and the interval for printing status messages about running jobs */
80 #define JOBS_IN_PROGRESS_WAIT_SEC 5
81 #define JOBS_IN_PROGRESS_PERIOD_SEC 1
82 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
84 /* Where clients shall send notification messages to */
85 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
87 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
89 static int manager_setup_notify(Manager *m) {
92 struct sockaddr_un un;
94 .sa.sa_family = AF_UNIX,
96 struct epoll_event ev = {
98 .data.ptr = &m->notify_watch,
102 m->notify_watch.type = WATCH_NOTIFY;
103 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
104 if (m->notify_watch.fd < 0) {
105 log_error("Failed to allocate notification socket: %m");
109 if (getpid() != 1 || detect_container(NULL) > 0)
110 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
112 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
114 sa.un.sun_path[0] = 0;
116 r = bind(m->notify_watch.fd, &sa.sa,
117 offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
119 log_error("bind() failed: %m");
123 r = setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
125 log_error("SO_PASSCRED failed: %m");
129 r = epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev);
131 log_error("Failed to add notification socket fd to epoll: %m");
135 sa.un.sun_path[0] = '@';
136 m->notify_socket = strdup(sa.un.sun_path);
137 if (!m->notify_socket)
140 log_debug("Using notification socket %s", m->notify_socket);
145 static int manager_jobs_in_progress_mod_timer(Manager *m) {
146 struct itimerspec its = {
147 .it_value.tv_sec = JOBS_IN_PROGRESS_WAIT_SEC,
148 .it_interval.tv_sec = JOBS_IN_PROGRESS_PERIOD_SEC,
151 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
154 if (timerfd_settime(m->jobs_in_progress_watch.fd, 0, &its, NULL) < 0)
160 static int manager_watch_jobs_in_progress(Manager *m) {
161 struct epoll_event ev = {
163 .data.ptr = &m->jobs_in_progress_watch,
167 if (m->jobs_in_progress_watch.type != WATCH_INVALID)
170 m->jobs_in_progress_watch.type = WATCH_JOBS_IN_PROGRESS;
171 m->jobs_in_progress_watch.fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
172 if (m->jobs_in_progress_watch.fd < 0) {
173 log_error("Failed to create timerfd: %m");
178 r = manager_jobs_in_progress_mod_timer(m);
180 log_error("Failed to set up timer for jobs progress watch: %s", strerror(-r));
184 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->jobs_in_progress_watch.fd, &ev) < 0) {
185 log_error("Failed to add jobs progress timer fd to epoll: %m");
190 log_debug("Set up jobs progress timerfd.");
195 if (m->jobs_in_progress_watch.fd >= 0)
196 close_nointr_nofail(m->jobs_in_progress_watch.fd);
197 watch_init(&m->jobs_in_progress_watch);
201 static void manager_unwatch_jobs_in_progress(Manager *m) {
202 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
205 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->jobs_in_progress_watch.fd, NULL) >= 0);
206 close_nointr_nofail(m->jobs_in_progress_watch.fd);
207 watch_init(&m->jobs_in_progress_watch);
208 m->jobs_in_progress_iteration = 0;
210 log_debug("Closed jobs progress timerfd.");
213 #define CYLON_BUFFER_EXTRA (2*strlen(ANSI_RED_ON) + strlen(ANSI_HIGHLIGHT_RED_ON) + 2*strlen(ANSI_HIGHLIGHT_OFF))
214 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
217 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
218 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
222 p = mempset(p, ' ', pos-2);
223 p = stpcpy(p, ANSI_RED_ON);
227 if (pos > 0 && pos <= width) {
228 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
232 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
235 p = stpcpy(p, ANSI_RED_ON);
238 p = mempset(p, ' ', width-1-pos);
239 strcpy(p, ANSI_HIGHLIGHT_OFF);
243 static void manager_print_jobs_in_progress(Manager *m) {
246 char *job_of_n = NULL;
247 unsigned counter = 0, print_nr;
248 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
251 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
253 HASHMAP_FOREACH(j, m->jobs, i)
254 if (j->state == JOB_RUNNING && counter++ == print_nr)
257 /* m->n_running_jobs must be consistent with the contents of m->jobs,
258 * so the above loop must have succeeded in finding j. */
259 assert(counter == print_nr + 1);
262 cylon_pos = m->jobs_in_progress_iteration % 14;
264 cylon_pos = 14 - cylon_pos;
265 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
267 if (m->n_running_jobs > 1)
268 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
271 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
272 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
275 m->jobs_in_progress_iteration++;
278 static int manager_watch_idle_pipe(Manager *m) {
279 struct epoll_event ev = {
281 .data.ptr = &m->idle_pipe_watch,
285 if (m->idle_pipe_watch.type != WATCH_INVALID)
288 if (m->idle_pipe[2] < 0)
291 m->idle_pipe_watch.type = WATCH_IDLE_PIPE;
292 m->idle_pipe_watch.fd = m->idle_pipe[2];
293 if (m->idle_pipe_watch.fd < 0) {
294 log_error("Failed to create timerfd: %m");
299 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->idle_pipe_watch.fd, &ev) < 0) {
300 log_error("Failed to add idle_pipe fd to epoll: %m");
305 log_debug("Set up idle_pipe watch.");
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 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->idle_pipe_watch.fd, NULL) >= 0);
321 watch_init(&m->idle_pipe_watch);
323 log_debug("Closed idle_pipe watch.");
326 static int manager_setup_time_change(Manager *m) {
327 struct epoll_event ev = {
329 .data.ptr = &m->time_change_watch,
332 /* We only care for the cancellation event, hence we set the
333 * timeout to the latest possible value. */
334 struct itimerspec its = {
335 .it_value.tv_sec = TIME_T_MAX,
337 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
339 assert(m->time_change_watch.type == WATCH_INVALID);
341 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
342 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
344 m->time_change_watch.type = WATCH_TIME_CHANGE;
345 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
346 if (m->time_change_watch.fd < 0) {
347 log_error("Failed to create timerfd: %m");
351 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
352 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
353 close_nointr_nofail(m->time_change_watch.fd);
354 watch_init(&m->time_change_watch);
358 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
359 log_error("Failed to add timer change fd to epoll: %m");
363 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
368 static int enable_special_signals(Manager *m) {
373 /* Enable that we get SIGINT on control-alt-del. In containers
374 * this will fail with EPERM (older) or EINVAL (newer), so
376 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
377 log_warning("Failed to enable ctrl-alt-del handling: %m");
379 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
381 /* Support systems without virtual console */
383 log_warning("Failed to open /dev/tty0: %m");
385 /* Enable that we get SIGWINCH on kbrequest */
386 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
387 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
389 close_nointr_nofail(fd);
395 static int manager_setup_signals(Manager *m) {
397 struct epoll_event ev = {
399 .data.ptr = &m->signal_watch,
401 struct sigaction sa = {
402 .sa_handler = SIG_DFL,
403 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
408 /* We are not interested in SIGSTOP and friends. */
409 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
411 assert_se(sigemptyset(&mask) == 0);
413 sigset_add_many(&mask,
414 SIGCHLD, /* Child died */
415 SIGTERM, /* Reexecute daemon */
416 SIGHUP, /* Reload configuration */
417 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
418 SIGUSR2, /* systemd: dump status */
419 SIGINT, /* Kernel sends us this on control-alt-del */
420 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
421 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
422 SIGRTMIN+0, /* systemd: start default.target */
423 SIGRTMIN+1, /* systemd: isolate rescue.target */
424 SIGRTMIN+2, /* systemd: isolate emergency.target */
425 SIGRTMIN+3, /* systemd: start halt.target */
426 SIGRTMIN+4, /* systemd: start poweroff.target */
427 SIGRTMIN+5, /* systemd: start reboot.target */
428 SIGRTMIN+6, /* systemd: start kexec.target */
429 SIGRTMIN+13, /* systemd: Immediate halt */
430 SIGRTMIN+14, /* systemd: Immediate poweroff */
431 SIGRTMIN+15, /* systemd: Immediate reboot */
432 SIGRTMIN+16, /* systemd: Immediate kexec */
433 SIGRTMIN+20, /* systemd: enable status messages */
434 SIGRTMIN+21, /* systemd: disable status messages */
435 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
436 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
437 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
438 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
439 SIGRTMIN+27, /* systemd: set log target to console */
440 SIGRTMIN+28, /* systemd: set log target to kmsg */
441 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
443 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
445 m->signal_watch.type = WATCH_SIGNAL;
446 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
447 if (m->signal_watch.fd < 0)
450 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
453 if (m->running_as == SYSTEMD_SYSTEM)
454 return enable_special_signals(m);
459 static int manager_default_environment(Manager *m) {
462 if (m->running_as == SYSTEMD_SYSTEM) {
463 /* The system manager always starts with a clean
464 * environment for its children. It does not import
465 * the kernel or the parents exported variables.
467 * The initial passed environ is untouched to keep
468 * /proc/self/environ valid; it is used for tagging
469 * the init process inside containers. */
470 m->environment = strv_new("PATH=" DEFAULT_PATH,
473 /* Import locale variables LC_*= from configuration */
474 locale_setup(&m->environment);
476 /* The user manager passes its own environment
477 * along to its children. */
478 m->environment = strv_copy(environ);
486 int manager_new(SystemdRunningAs running_as, bool reexecuting, Manager **_m) {
491 assert(running_as >= 0);
492 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
494 m = new0(Manager, 1);
499 if (detect_container(NULL) <= 0)
500 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
503 m->running_as = running_as;
504 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
505 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
506 m->pin_cgroupfs_fd = -1;
507 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
509 watch_init(&m->signal_watch);
510 watch_init(&m->mount_watch);
511 watch_init(&m->swap_watch);
512 watch_init(&m->udev_watch);
513 watch_init(&m->time_change_watch);
514 watch_init(&m->jobs_in_progress_watch);
516 m->epoll_fd = m->dev_autofs_fd = -1;
517 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
519 r = manager_default_environment(m);
523 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
526 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
529 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
532 m->cgroup_unit = hashmap_new(string_hash_func, string_compare_func);
536 m->watch_bus = hashmap_new(string_hash_func, string_compare_func);
540 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
544 r = manager_setup_signals(m);
548 r = manager_setup_cgroup(m);
552 r = manager_setup_notify(m);
556 r = manager_setup_time_change(m);
560 /* Try to connect to the busses, if possible. */
561 if ((running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS")) ||
562 running_as == SYSTEMD_SYSTEM) {
563 r = bus_init(m, reexecuting || running_as != SYSTEMD_SYSTEM);
567 log_debug("Skipping DBus session bus connection attempt - no DBUS_SESSION_BUS_ADDRESS set...");
569 m->taint_usr = dir_is_empty("/usr") > 0;
579 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
585 while ((u = m->cleanup_queue)) {
586 assert(u->in_cleanup_queue);
596 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
597 GC_OFFSET_UNSURE, /* No clue */
598 GC_OFFSET_GOOD, /* We still need this unit */
599 GC_OFFSET_BAD, /* We don't need this unit anymore */
603 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
610 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
611 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
612 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
615 if (u->in_cleanup_queue)
618 if (unit_check_gc(u))
621 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
625 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
626 unit_gc_sweep(other, gc_marker);
628 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
631 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
638 /* We were unable to find anything out about this entry, so
639 * let's investigate it later */
640 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
641 unit_add_to_gc_queue(u);
645 /* We definitely know that this one is not useful anymore, so
646 * let's mark it for deletion */
647 u->gc_marker = gc_marker + GC_OFFSET_BAD;
648 unit_add_to_cleanup_queue(u);
652 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
655 static unsigned manager_dispatch_gc_queue(Manager *m) {
662 /* log_debug("Running GC..."); */
664 m->gc_marker += _GC_OFFSET_MAX;
665 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
668 gc_marker = m->gc_marker;
670 while ((u = m->gc_queue)) {
671 assert(u->in_gc_queue);
673 unit_gc_sweep(u, gc_marker);
675 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
676 u->in_gc_queue = false;
680 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
681 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
682 log_debug_unit(u->id, "Collecting %s", u->id);
683 u->gc_marker = gc_marker + GC_OFFSET_BAD;
684 unit_add_to_cleanup_queue(u);
688 m->n_in_gc_queue = 0;
693 static void manager_clear_jobs_and_units(Manager *m) {
698 while ((u = hashmap_first(m->units)))
701 manager_dispatch_cleanup_queue(m);
703 assert(!m->load_queue);
704 assert(!m->run_queue);
705 assert(!m->dbus_unit_queue);
706 assert(!m->dbus_job_queue);
707 assert(!m->cleanup_queue);
708 assert(!m->gc_queue);
710 assert(hashmap_isempty(m->jobs));
711 assert(hashmap_isempty(m->units));
714 m->n_running_jobs = 0;
717 static void close_idle_pipe(Manager *m) {
718 close_pipe(m->idle_pipe);
719 close_pipe(m->idle_pipe + 2);
722 void manager_free(Manager *m) {
728 manager_clear_jobs_and_units(m);
730 for (c = 0; c < _UNIT_TYPE_MAX; c++)
731 if (unit_vtable[c]->shutdown)
732 unit_vtable[c]->shutdown(m);
734 /* If we reexecute ourselves, we keep the root cgroup
736 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
738 manager_undo_generators(m);
742 hashmap_free(m->units);
743 hashmap_free(m->jobs);
744 hashmap_free(m->watch_pids);
745 hashmap_free(m->watch_bus);
747 if (m->epoll_fd >= 0)
748 close_nointr_nofail(m->epoll_fd);
749 if (m->signal_watch.fd >= 0)
750 close_nointr_nofail(m->signal_watch.fd);
751 if (m->notify_watch.fd >= 0)
752 close_nointr_nofail(m->notify_watch.fd);
753 if (m->time_change_watch.fd >= 0)
754 close_nointr_nofail(m->time_change_watch.fd);
755 if (m->jobs_in_progress_watch.fd >= 0)
756 close_nointr_nofail(m->jobs_in_progress_watch.fd);
758 free(m->notify_socket);
760 lookup_paths_free(&m->lookup_paths);
761 strv_free(m->environment);
763 hashmap_free(m->cgroup_unit);
764 set_free_free(m->unit_path_cache);
768 free(m->switch_root);
769 free(m->switch_root_init);
771 for (i = 0; i < RLIMIT_NLIMITS; i++)
774 assert(hashmap_isempty(m->units_requiring_mounts_for));
775 hashmap_free(m->units_requiring_mounts_for);
780 int manager_enumerate(Manager *m) {
786 /* Let's ask every type to load all units from disk/kernel
787 * that it might know */
788 for (c = 0; c < _UNIT_TYPE_MAX; c++)
789 if (unit_vtable[c]->enumerate) {
790 q = unit_vtable[c]->enumerate(m);
795 manager_dispatch_load_queue(m);
799 int manager_coldplug(Manager *m) {
807 /* Then, let's set up their initial state. */
808 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
814 if ((q = unit_coldplug(u)) < 0)
821 static void manager_build_unit_path_cache(Manager *m) {
823 _cleanup_free_ DIR *d = NULL;
828 set_free_free(m->unit_path_cache);
830 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
831 if (!m->unit_path_cache) {
832 log_error("Failed to allocate unit path cache.");
836 /* This simply builds a list of files we know exist, so that
837 * we don't always have to go to disk */
839 STRV_FOREACH(i, m->lookup_paths.unit_path) {
845 log_error("Failed to open directory %s: %m", *i);
849 while ((de = readdir(d))) {
852 if (ignore_file(de->d_name))
855 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
861 r = set_consume(m->unit_path_cache, p);
873 log_error("Failed to build unit path cache: %s", strerror(-r));
875 set_free_free(m->unit_path_cache);
876 m->unit_path_cache = NULL;
879 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
884 dual_timestamp_get(&m->generators_start_timestamp);
885 manager_run_generators(m);
886 dual_timestamp_get(&m->generators_finish_timestamp);
888 r = lookup_paths_init(
889 &m->lookup_paths, m->running_as, true,
890 m->generator_unit_path,
891 m->generator_unit_path_early,
892 m->generator_unit_path_late);
896 manager_build_unit_path_cache(m);
898 /* If we will deserialize make sure that during enumeration
899 * this is already known, so we increase the counter here
904 /* First, enumerate what we can from all config files */
905 dual_timestamp_get(&m->unitsload_start_timestamp);
906 r = manager_enumerate(m);
907 dual_timestamp_get(&m->unitsload_finish_timestamp);
909 /* Second, deserialize if there is something to deserialize */
911 q = manager_deserialize(m, serialization, fds);
916 /* Any fds left? Find some unit which wants them. This is
917 * useful to allow container managers to pass some file
918 * descriptors to us pre-initialized. This enables
919 * socket-based activation of entire containers. */
920 if (fdset_size(fds) > 0) {
921 q = manager_distribute_fds(m, fds);
926 /* Third, fire things up! */
927 q = manager_coldplug(m);
932 assert(m->n_reloading > 0);
935 /* Let's wait for the UnitNew/JobNew messages being
936 * sent, before we notify that the reload is
938 m->send_reloading_done = true;
944 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
949 assert(type < _JOB_TYPE_MAX);
951 assert(mode < _JOB_MODE_MAX);
953 if (mode == JOB_ISOLATE && type != JOB_START) {
954 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
958 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
959 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
963 log_debug_unit(unit->id,
964 "Trying to enqueue job %s/%s/%s", unit->id,
965 job_type_to_string(type), job_mode_to_string(mode));
967 job_type_collapse(&type, unit);
969 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
973 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
974 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
975 mode == JOB_IGNORE_DEPENDENCIES, e);
979 if (mode == JOB_ISOLATE) {
980 r = transaction_add_isolate_jobs(tr, m);
985 r = transaction_activate(tr, m, mode, e);
989 log_debug_unit(unit->id,
990 "Enqueued job %s/%s as %u", unit->id,
991 job_type_to_string(type), (unsigned) tr->anchor_job->id);
994 *_ret = tr->anchor_job;
996 transaction_free(tr);
1000 transaction_abort(tr);
1001 transaction_free(tr);
1005 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
1010 assert(type < _JOB_TYPE_MAX);
1012 assert(mode < _JOB_MODE_MAX);
1014 r = manager_load_unit(m, name, NULL, NULL, &unit);
1018 return manager_add_job(m, type, unit, mode, override, e, _ret);
1021 Job *manager_get_job(Manager *m, uint32_t id) {
1024 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1027 Unit *manager_get_unit(Manager *m, const char *name) {
1031 return hashmap_get(m->units, name);
1034 unsigned manager_dispatch_load_queue(Manager *m) {
1040 /* Make sure we are not run recursively */
1041 if (m->dispatching_load_queue)
1044 m->dispatching_load_queue = true;
1046 /* Dispatches the load queue. Takes a unit from the queue and
1047 * tries to load its data until the queue is empty */
1049 while ((u = m->load_queue)) {
1050 assert(u->in_load_queue);
1056 m->dispatching_load_queue = false;
1060 int manager_load_unit_prepare(
1072 assert(name || path);
1074 /* This will prepare the unit for loading, but not actually
1075 * load anything from disk. */
1077 if (path && !is_path(path)) {
1078 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1083 name = path_get_file_name(path);
1085 t = unit_name_to_type(name);
1087 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
1088 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1092 ret = manager_get_unit(m, name);
1098 ret = unit_new(m, unit_vtable[t]->object_size);
1103 ret->fragment_path = strdup(path);
1104 if (!ret->fragment_path) {
1110 r = unit_add_name(ret, name);
1116 unit_add_to_load_queue(ret);
1117 unit_add_to_dbus_queue(ret);
1118 unit_add_to_gc_queue(ret);
1126 int manager_load_unit(
1137 /* This will load the service information files, but not actually
1138 * start any services or anything. */
1140 r = manager_load_unit_prepare(m, name, path, e, _ret);
1144 manager_dispatch_load_queue(m);
1147 *_ret = unit_follow_merge(*_ret);
1152 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1159 HASHMAP_FOREACH(j, s->jobs, i)
1160 job_dump(j, f, prefix);
1163 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1171 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1173 unit_dump(u, f, prefix);
1176 void manager_clear_jobs(Manager *m) {
1181 while ((j = hashmap_first(m->jobs)))
1182 /* No need to recurse. We're cancelling all jobs. */
1183 job_finish_and_invalidate(j, JOB_CANCELED, false);
1186 unsigned manager_dispatch_run_queue(Manager *m) {
1190 if (m->dispatching_run_queue)
1193 m->dispatching_run_queue = true;
1195 while ((j = m->run_queue)) {
1196 assert(j->installed);
1197 assert(j->in_run_queue);
1199 job_run_and_invalidate(j);
1203 m->dispatching_run_queue = false;
1205 if (m->n_running_jobs > 0)
1206 manager_watch_jobs_in_progress(m);
1208 if (m->n_on_console > 0)
1209 manager_watch_idle_pipe(m);
1214 unsigned manager_dispatch_dbus_queue(Manager *m) {
1221 if (m->dispatching_dbus_queue)
1224 m->dispatching_dbus_queue = true;
1226 while ((u = m->dbus_unit_queue)) {
1227 assert(u->in_dbus_queue);
1229 bus_unit_send_change_signal(u);
1233 while ((j = m->dbus_job_queue)) {
1234 assert(j->in_dbus_queue);
1236 bus_job_send_change_signal(j);
1240 m->dispatching_dbus_queue = false;
1242 if (m->send_reloading_done) {
1243 m->send_reloading_done = false;
1245 bus_broadcast_reloading(m, false);
1251 static int manager_process_notify_fd(Manager *m) {
1258 struct iovec iovec = {
1260 .iov_len = sizeof(buf)-1,
1264 struct cmsghdr cmsghdr;
1265 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1268 struct msghdr msghdr = {
1271 .msg_control = &control,
1272 .msg_controllen = sizeof(control),
1274 struct ucred *ucred;
1276 _cleanup_strv_free_ char **tags = NULL;
1278 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1283 if (errno == EAGAIN || errno == EINTR)
1289 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1290 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1291 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1292 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1293 log_warning("Received notify message without credentials. Ignoring.");
1297 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1299 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1301 u = manager_get_unit_by_pid(m, ucred->pid);
1303 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1308 assert((size_t) n < sizeof(buf));
1310 tags = strv_split(buf, "\n\r");
1314 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1316 if (UNIT_VTABLE(u)->notify_message)
1317 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1323 static int manager_dispatch_sigchld(Manager *m) {
1331 /* First we call waitd() for a PID and do not reap the
1332 * zombie. That way we can still access /proc/$PID for
1333 * it while it is a zombie. */
1334 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1336 if (errno == ECHILD)
1348 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1349 _cleanup_free_ char *name = NULL;
1351 get_process_comm(si.si_pid, &name);
1352 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1355 /* Let's flush any message the dying child might still
1356 * have queued for us. This ensures that the process
1357 * still exists in /proc so that we can figure out
1358 * which cgroup and hence unit it belongs to. */
1359 r = manager_process_notify_fd(m);
1363 /* And now figure out the unit this belongs to */
1364 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1366 u = manager_get_unit_by_pid(m, si.si_pid);
1368 /* And now, we actually reap the zombie. */
1369 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1376 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1379 log_debug("Child %lu died (code=%s, status=%i/%s)",
1380 (long unsigned) si.si_pid,
1381 sigchld_code_to_string(si.si_code),
1383 strna(si.si_code == CLD_EXITED
1384 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1385 : signal_to_string(si.si_status)));
1390 log_debug_unit(u->id,
1391 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1393 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1394 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1400 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1404 dbus_error_init(&error);
1406 log_debug_unit(name, "Activating special unit %s", name);
1408 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1410 log_error_unit(name,
1411 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1413 dbus_error_free(&error);
1418 static int manager_process_signal_fd(Manager *m) {
1420 struct signalfd_siginfo sfsi;
1421 bool sigchld = false;
1426 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1427 if (n != sizeof(sfsi)) {
1432 if (errno == EINTR || errno == EAGAIN)
1438 if (sfsi.ssi_pid > 0) {
1441 get_process_comm(sfsi.ssi_pid, &p);
1443 log_debug("Received SIG%s from PID %lu (%s).",
1444 signal_to_string(sfsi.ssi_signo),
1445 (unsigned long) sfsi.ssi_pid, strna(p));
1448 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1450 switch (sfsi.ssi_signo) {
1457 if (m->running_as == SYSTEMD_SYSTEM) {
1458 /* This is for compatibility with the
1459 * original sysvinit */
1460 m->exit_code = MANAGER_REEXECUTE;
1467 if (m->running_as == SYSTEMD_SYSTEM) {
1468 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1472 /* Run the exit target if there is one, if not, just exit. */
1473 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1474 m->exit_code = MANAGER_EXIT;
1481 if (m->running_as == SYSTEMD_SYSTEM)
1482 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1484 /* This is a nop on non-init */
1488 if (m->running_as == SYSTEMD_SYSTEM)
1489 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1491 /* This is a nop on non-init */
1497 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1499 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1500 log_info("Trying to reconnect to bus...");
1504 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1505 log_info("Loading D-Bus service...");
1506 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1517 if (!(f = open_memstream(&dump, &size))) {
1518 log_warning("Failed to allocate memory stream.");
1522 manager_dump_units(m, f, "\t");
1523 manager_dump_jobs(m, f, "\t");
1528 log_warning("Failed to write status stream");
1533 log_dump(LOG_INFO, dump);
1540 m->exit_code = MANAGER_RELOAD;
1545 /* Starting SIGRTMIN+0 */
1546 static const char * const target_table[] = {
1547 [0] = SPECIAL_DEFAULT_TARGET,
1548 [1] = SPECIAL_RESCUE_TARGET,
1549 [2] = SPECIAL_EMERGENCY_TARGET,
1550 [3] = SPECIAL_HALT_TARGET,
1551 [4] = SPECIAL_POWEROFF_TARGET,
1552 [5] = SPECIAL_REBOOT_TARGET,
1553 [6] = SPECIAL_KEXEC_TARGET
1556 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1557 static const ManagerExitCode code_table[] = {
1559 [1] = MANAGER_POWEROFF,
1560 [2] = MANAGER_REBOOT,
1564 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1565 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1566 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1567 manager_start_target(m, target_table[idx],
1568 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1572 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1573 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1574 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1578 switch (sfsi.ssi_signo - SIGRTMIN) {
1581 log_debug("Enabling showing of status.");
1582 manager_set_show_status(m, true);
1586 log_debug("Disabling showing of status.");
1587 manager_set_show_status(m, false);
1591 log_set_max_level(LOG_DEBUG);
1592 log_notice("Setting log level to debug.");
1596 log_set_max_level(LOG_INFO);
1597 log_notice("Setting log level to info.");
1601 if (m->running_as == SYSTEMD_USER) {
1602 m->exit_code = MANAGER_EXIT;
1606 /* This is a nop on init */
1610 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1611 log_notice("Setting log target to journal-or-kmsg.");
1615 log_set_target(LOG_TARGET_CONSOLE);
1616 log_notice("Setting log target to console.");
1620 log_set_target(LOG_TARGET_KMSG);
1621 log_notice("Setting log target to kmsg.");
1625 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1626 log_notice("Setting log target to syslog-or-kmsg.");
1630 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1637 return manager_dispatch_sigchld(m);
1642 static int process_event(Manager *m, struct epoll_event *ev) {
1649 assert_se(w = ev->data.ptr);
1651 if (w->type == WATCH_INVALID)
1658 /* An incoming signal? */
1659 if (ev->events != EPOLLIN)
1662 if ((r = manager_process_signal_fd(m)) < 0)
1669 /* An incoming daemon notification event? */
1670 if (ev->events != EPOLLIN)
1673 if ((r = manager_process_notify_fd(m)) < 0)
1680 /* Some fd event, to be dispatched to the units */
1681 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1684 case WATCH_UNIT_TIMER:
1685 case WATCH_JOB_TIMER: {
1689 /* Some timer event, to be dispatched to the units */
1690 k = read(w->fd, &v, sizeof(v));
1691 if (k != sizeof(v)) {
1693 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1696 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1697 return k < 0 ? -errno : -EIO;
1700 if (w->type == WATCH_UNIT_TIMER)
1701 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1703 job_timer_event(w->data.job, v, w);
1708 /* Some mount table change, intended for the mount subsystem */
1709 mount_fd_event(m, ev->events);
1713 /* Some swap table change, intended for the swap subsystem */
1714 swap_fd_event(m, ev->events);
1718 /* Some notification from udev, intended for the device subsystem */
1719 device_fd_event(m, ev->events);
1722 case WATCH_DBUS_WATCH:
1723 bus_watch_event(m, w, ev->events);
1726 case WATCH_DBUS_TIMEOUT:
1727 bus_timeout_event(m, w, ev->events);
1730 case WATCH_TIME_CHANGE: {
1734 log_struct(LOG_INFO,
1735 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1736 "MESSAGE=Time has been changed",
1739 /* Restart the watch */
1740 epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->time_change_watch.fd,
1742 close_nointr_nofail(m->time_change_watch.fd);
1743 watch_init(&m->time_change_watch);
1744 manager_setup_time_change(m);
1746 HASHMAP_FOREACH(u, m->units, i) {
1747 if (UNIT_VTABLE(u)->time_change)
1748 UNIT_VTABLE(u)->time_change(u);
1754 case WATCH_JOBS_IN_PROGRESS: {
1757 /* not interested in the data */
1758 read(w->fd, &v, sizeof(v));
1760 manager_print_jobs_in_progress(m);
1764 case WATCH_IDLE_PIPE: {
1765 m->no_console_output = true;
1767 manager_unwatch_idle_pipe(m);
1773 log_error("event type=%i", w->type);
1774 assert_not_reached("Unknown epoll event type.");
1780 int manager_loop(Manager *m) {
1783 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1786 m->exit_code = MANAGER_RUNNING;
1788 /* Release the path cache */
1789 set_free_free(m->unit_path_cache);
1790 m->unit_path_cache = NULL;
1792 manager_check_finished(m);
1794 /* There might still be some zombies hanging around from
1795 * before we were exec()'ed. Leat's reap them */
1796 r = manager_dispatch_sigchld(m);
1800 while (m->exit_code == MANAGER_RUNNING) {
1801 struct epoll_event event;
1805 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1808 if (!ratelimit_test(&rl)) {
1809 /* Yay, something is going seriously wrong, pause a little */
1810 log_warning("Looping too fast. Throttling execution a little.");
1815 if (manager_dispatch_load_queue(m) > 0)
1818 if (manager_dispatch_gc_queue(m) > 0)
1821 if (manager_dispatch_cleanup_queue(m) > 0)
1824 if (manager_dispatch_cgroup_queue(m) > 0)
1827 if (manager_dispatch_run_queue(m) > 0)
1830 if (bus_dispatch(m) > 0)
1833 if (manager_dispatch_dbus_queue(m) > 0)
1836 if (swap_dispatch_reload(m) > 0)
1839 /* Sleep for half the watchdog time */
1840 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1841 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1847 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1859 r = process_event(m, &event);
1864 return m->exit_code;
1867 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1868 _cleanup_free_ char *n = NULL;
1876 r = unit_name_from_dbus_path(s, &n);
1880 r = manager_load_unit(m, n, NULL, e, &u);
1889 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1898 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1901 r = safe_atou(s + 30, &id);
1905 j = manager_get_job(m, id);
1914 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1920 audit_fd = get_audit_fd();
1924 /* Don't generate audit events if the service was already
1925 * started and we're just deserializing */
1926 if (m->n_reloading > 0)
1929 if (m->running_as != SYSTEMD_SYSTEM)
1932 if (u->type != UNIT_SERVICE)
1935 p = unit_name_to_prefix_and_instance(u->id);
1937 log_error_unit(u->id,
1938 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1942 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1943 if (errno == EPERM) {
1944 /* We aren't allowed to send audit messages?
1945 * Then let's not retry again. */
1948 log_warning("Failed to send audit message: %m");
1956 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1958 union sockaddr_union sa;
1960 char *message = NULL;
1962 /* Don't generate plymouth events if the service was already
1963 * started and we're just deserializing */
1964 if (m->n_reloading > 0)
1967 if (m->running_as != SYSTEMD_SYSTEM)
1970 if (u->type != UNIT_SERVICE &&
1971 u->type != UNIT_MOUNT &&
1972 u->type != UNIT_SWAP)
1975 /* We set SOCK_NONBLOCK here so that we rather drop the
1976 * message then wait for plymouth */
1977 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1979 log_error("socket() failed: %m");
1984 sa.sa.sa_family = AF_UNIX;
1985 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1986 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1988 if (errno != EPIPE &&
1991 errno != ECONNREFUSED &&
1992 errno != ECONNRESET &&
1993 errno != ECONNABORTED)
1994 log_error("connect() failed: %m");
1999 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2005 if (write(fd, message, n + 1) != n + 1) {
2007 if (errno != EPIPE &&
2010 errno != ECONNREFUSED &&
2011 errno != ECONNRESET &&
2012 errno != ECONNABORTED)
2013 log_error("Failed to write Plymouth message: %m");
2020 close_nointr_nofail(fd);
2025 void manager_dispatch_bus_name_owner_changed(
2028 const char* old_owner,
2029 const char *new_owner) {
2036 if (!(u = hashmap_get(m->watch_bus, name)))
2039 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2042 void manager_dispatch_bus_query_pid_done(
2053 if (!(u = hashmap_get(m->watch_bus, name)))
2056 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
2059 int manager_open_serialization(Manager *m, FILE **_f) {
2066 if (m->running_as == SYSTEMD_SYSTEM)
2067 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
2069 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
2074 RUN_WITH_UMASK(0077) {
2075 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2085 log_debug("Serializing state to %s", path);
2088 f = fdopen(fd, "w+");
2097 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2110 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2111 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2112 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2113 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2115 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2116 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2117 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2118 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2121 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2122 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2125 if (!switching_root) {
2126 STRV_FOREACH(e, m->environment) {
2127 _cleanup_free_ char *ce;
2131 fprintf(f, "env=%s\n", *e);
2135 bus_serialize(m, f);
2139 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2143 if (!unit_can_serialize(u))
2150 r = unit_serialize(u, f, fds, !switching_root);
2157 assert(m->n_reloading > 0);
2163 r = bus_fdset_add_all(m, fds);
2170 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2176 log_debug("Deserializing state...");
2181 char line[LINE_MAX], *l;
2183 if (!fgets(line, sizeof(line), f)) {
2198 if (startswith(l, "current-job-id=")) {
2201 if (safe_atou32(l+15, &id) < 0)
2202 log_debug("Failed to parse current job id value %s", l+15);
2204 m->current_job_id = MAX(m->current_job_id, id);
2205 } else if (startswith(l, "n-installed-jobs=")) {
2208 if (safe_atou32(l+17, &n) < 0)
2209 log_debug("Failed to parse installed jobs counter %s", l+17);
2211 m->n_installed_jobs += n;
2212 } else if (startswith(l, "n-failed-jobs=")) {
2215 if (safe_atou32(l+14, &n) < 0)
2216 log_debug("Failed to parse failed jobs counter %s", l+14);
2218 m->n_failed_jobs += n;
2219 } else if (startswith(l, "taint-usr=")) {
2222 if ((b = parse_boolean(l+10)) < 0)
2223 log_debug("Failed to parse taint /usr flag %s", l+10);
2225 m->taint_usr = m->taint_usr || b;
2226 } else if (startswith(l, "firmware-timestamp="))
2227 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2228 else if (startswith(l, "loader-timestamp="))
2229 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2230 else if (startswith(l, "kernel-timestamp="))
2231 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2232 else if (startswith(l, "initrd-timestamp="))
2233 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2234 else if (startswith(l, "userspace-timestamp="))
2235 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2236 else if (startswith(l, "finish-timestamp="))
2237 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2238 else if (startswith(l, "env=")) {
2239 _cleanup_free_ char *uce = NULL;
2242 uce = cunescape(l+4);
2248 e = strv_env_set(m->environment, uce);
2254 strv_free(m->environment);
2256 } else if (bus_deserialize_item(m, l) == 0)
2257 log_debug("Unknown serialization item '%s'", l);
2262 char name[UNIT_NAME_MAX+2];
2265 if (!fgets(name, sizeof(name), f)) {
2276 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2280 r = unit_deserialize(u, f, fds);
2291 assert(m->n_reloading > 0);
2297 int manager_distribute_fds(Manager *m, FDSet *fds) {
2304 HASHMAP_FOREACH(u, m->units, i) {
2306 if (fdset_size(fds) <= 0)
2309 if (UNIT_VTABLE(u)->distribute_fds) {
2310 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2319 int manager_reload(Manager *m) {
2321 _cleanup_fclose_ FILE *f = NULL;
2322 _cleanup_fdset_free_ FDSet *fds = NULL;
2326 r = manager_open_serialization(m, &f);
2331 bus_broadcast_reloading(m, true);
2339 r = manager_serialize(m, f, fds, false);
2345 if (fseeko(f, 0, SEEK_SET) < 0) {
2350 /* From here on there is no way back. */
2351 manager_clear_jobs_and_units(m);
2352 manager_undo_generators(m);
2353 lookup_paths_free(&m->lookup_paths);
2355 /* Find new unit paths */
2356 manager_run_generators(m);
2358 q = lookup_paths_init(
2359 &m->lookup_paths, m->running_as, true,
2360 m->generator_unit_path,
2361 m->generator_unit_path_early,
2362 m->generator_unit_path_late);
2366 manager_build_unit_path_cache(m);
2368 /* First, enumerate what we can from all config files */
2369 q = manager_enumerate(m);
2373 /* Second, deserialize our stored data */
2374 q = manager_deserialize(m, f, fds);
2381 /* Third, fire things up! */
2382 q = manager_coldplug(m);
2386 assert(m->n_reloading > 0);
2389 m->send_reloading_done = true;
2394 static bool manager_is_booting_or_shutting_down(Manager *m) {
2399 /* Is the initial job still around? */
2400 if (manager_get_job(m, m->default_unit_job_id))
2403 /* Is there a job for the shutdown target? */
2404 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2411 bool manager_is_reloading_or_reexecuting(Manager *m) {
2414 return m->n_reloading != 0;
2417 void manager_reset_failed(Manager *m) {
2423 HASHMAP_FOREACH(u, m->units, i)
2424 unit_reset_failed(u);
2427 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2433 /* Returns true if the unit is inactive or going down */
2434 u = manager_get_unit(m, name);
2438 return unit_inactive_or_pending(u);
2441 void manager_check_finished(Manager *m) {
2442 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2443 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2447 if (m->n_running_jobs == 0)
2448 manager_unwatch_jobs_in_progress(m);
2450 if (hashmap_size(m->jobs) > 0) {
2451 manager_jobs_in_progress_mod_timer(m);
2455 /* Notify Type=idle units that we are done now */
2456 manager_unwatch_idle_pipe(m);
2459 /* Turn off confirm spawn now */
2460 m->confirm_spawn = false;
2462 if (dual_timestamp_is_set(&m->finish_timestamp))
2465 dual_timestamp_get(&m->finish_timestamp);
2467 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2469 /* Note that m->kernel_usec.monotonic is always at 0,
2470 * and m->firmware_usec.monotonic and
2471 * m->loader_usec.monotonic should be considered
2472 * negative values. */
2474 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2475 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2476 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2477 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2479 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2481 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2482 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2484 if (!log_on_console())
2485 log_struct(LOG_INFO,
2486 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2487 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2488 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2489 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2490 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2491 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2492 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2493 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2494 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2497 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2500 if (!log_on_console())
2501 log_struct(LOG_INFO,
2502 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2503 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2504 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2505 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2506 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2507 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2508 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2512 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2513 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2515 if (!log_on_console())
2516 log_struct(LOG_INFO,
2517 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2518 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2519 "MESSAGE=Startup finished in %s.",
2520 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2524 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2527 "READY=1\nSTATUS=Startup finished in %s.",
2528 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2531 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2542 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2544 p = strappend("/run/systemd/", name);
2548 r = mkdir_p_label(p, 0755);
2550 log_error("Failed to create generator directory %s: %s",
2556 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2561 log_error("Failed to create generator directory %s: %m",
2572 static void trim_generator_dir(Manager *m, char **generator) {
2579 if (rmdir(*generator) >= 0) {
2587 void manager_run_generators(Manager *m) {
2589 const char *generator_path;
2590 const char *argv[5];
2595 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2596 d = opendir(generator_path);
2598 if (errno == ENOENT)
2601 log_error("Failed to enumerate generator directory %s: %m",
2606 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2610 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2614 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2618 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2619 argv[1] = m->generator_unit_path;
2620 argv[2] = m->generator_unit_path_early;
2621 argv[3] = m->generator_unit_path_late;
2624 RUN_WITH_UMASK(0022) {
2625 execute_directory(generator_path, d, (char**) argv);
2628 trim_generator_dir(m, &m->generator_unit_path);
2629 trim_generator_dir(m, &m->generator_unit_path_early);
2630 trim_generator_dir(m, &m->generator_unit_path_late);
2637 static void remove_generator_dir(Manager *m, char **generator) {
2644 strv_remove(m->lookup_paths.unit_path, *generator);
2645 rm_rf(*generator, false, true, false);
2651 void manager_undo_generators(Manager *m) {
2654 remove_generator_dir(m, &m->generator_unit_path);
2655 remove_generator_dir(m, &m->generator_unit_path_early);
2656 remove_generator_dir(m, &m->generator_unit_path_late);
2659 int manager_environment_add(Manager *m, char **environment) {
2663 e = strv_env_merge(2, m->environment, environment);
2667 strv_free(m->environment);
2673 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2678 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2679 if (!default_rlimit[i])
2682 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2690 void manager_recheck_journal(Manager *m) {
2695 if (m->running_as != SYSTEMD_SYSTEM)
2698 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2699 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2700 log_close_journal();
2704 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2705 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2706 log_close_journal();
2710 /* Hmm, OK, so the socket is fully up and the service is up
2711 * too, then let's make use of the thing. */
2715 void manager_set_show_status(Manager *m, bool b) {
2718 if (m->running_as != SYSTEMD_SYSTEM)
2724 touch("/run/systemd/show-status");
2726 unlink("/run/systemd/show-status");
2729 static bool manager_get_show_status(Manager *m) {
2732 if (m->running_as != SYSTEMD_SYSTEM)
2735 if (m->no_console_output)
2741 /* If Plymouth is running make sure we show the status, so
2742 * that there's something nice to see when people press Esc */
2744 return plymouth_running();
2747 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2750 if (!manager_get_show_status(m))
2753 /* XXX We should totally drop the check for ephemeral here
2754 * and thus effectively make 'Type=idle' pointless. */
2755 if (ephemeral && m->n_on_console > 0)
2758 if (!manager_is_booting_or_shutting_down(m))
2761 va_start(ap, format);
2762 status_vprintf(status, true, ephemeral, format, ap);
2766 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2767 _cleanup_free_ char *p = NULL;
2775 p = unit_name_from_path(path, suffix);
2779 found = manager_get_unit(m, p);
2789 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2790 char p[strlen(path)+1];
2796 path_kill_slashes(p);
2798 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
2801 void watch_init(Watch *w) {
2804 w->type = WATCH_INVALID;