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"
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"
76 /* As soon as 16 units are in our GC queue, make sure to run a gc sweep */
77 #define GC_QUEUE_ENTRIES_MAX 16
79 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
80 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
82 /* Initial delay and the interval for printing status messages about running jobs */
83 #define JOBS_IN_PROGRESS_WAIT_SEC 5
84 #define JOBS_IN_PROGRESS_PERIOD_SEC 1
85 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
87 /* Where clients shall send notification messages to */
88 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
90 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
92 static int manager_setup_notify(Manager *m) {
95 struct sockaddr_un un;
97 struct epoll_event ev;
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");
110 sa.sa.sa_family = AF_UNIX;
112 if (getpid() != 1 || detect_container(NULL) > 0)
113 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
115 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
117 sa.un.sun_path[0] = 0;
119 if (bind(m->notify_watch.fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
120 log_error("bind() failed: %m");
124 if (setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0) {
125 log_error("SO_PASSCRED failed: %m");
131 ev.data.ptr = &m->notify_watch;
133 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev) < 0) {
134 log_error("Failed to add notification socket fd to epoll: %m");
138 sa.un.sun_path[0] = '@';
139 m->notify_socket = strdup(sa.un.sun_path);
140 if (!m->notify_socket)
143 log_debug("Using notification socket %s", m->notify_socket);
148 static int manager_jobs_in_progress_mod_timer(Manager *m) {
149 struct itimerspec its;
151 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
156 its.it_value.tv_sec = JOBS_IN_PROGRESS_WAIT_SEC;
157 its.it_interval.tv_sec = JOBS_IN_PROGRESS_PERIOD_SEC;
159 if (timerfd_settime(m->jobs_in_progress_watch.fd, 0, &its, NULL) < 0)
165 static int manager_watch_jobs_in_progress(Manager *m) {
166 struct epoll_event ev;
171 if (m->jobs_in_progress_watch.type != WATCH_INVALID)
174 m->jobs_in_progress_watch.type = WATCH_JOBS_IN_PROGRESS;
175 m->jobs_in_progress_watch.fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
176 if (m->jobs_in_progress_watch.fd < 0) {
177 log_error("Failed to create timerfd: %m");
182 r = manager_jobs_in_progress_mod_timer(m);
184 log_error("Failed to set up timer for jobs progress watch: %s", strerror(-r));
190 ev.data.ptr = &m->jobs_in_progress_watch;
192 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->jobs_in_progress_watch.fd, &ev) < 0) {
193 log_error("Failed to add jobs progress timer fd to epoll: %m");
198 log_debug("Set up jobs progress timerfd.");
203 if (m->jobs_in_progress_watch.fd >= 0)
204 close_nointr_nofail(m->jobs_in_progress_watch.fd);
205 watch_init(&m->jobs_in_progress_watch);
209 static void manager_unwatch_jobs_in_progress(Manager *m) {
210 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
213 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->jobs_in_progress_watch.fd, NULL) >= 0);
214 close_nointr_nofail(m->jobs_in_progress_watch.fd);
215 watch_init(&m->jobs_in_progress_watch);
216 m->jobs_in_progress_iteration = 0;
218 log_debug("Closed jobs progress timerfd.");
221 #define CYLON_BUFFER_EXTRA (2*strlen(ANSI_RED_ON) + strlen(ANSI_HIGHLIGHT_RED_ON) + 2*strlen(ANSI_HIGHLIGHT_OFF))
222 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
225 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
226 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
230 memset(p, ' ', pos-2);
233 memcpy(p, ANSI_RED_ON, strlen(ANSI_RED_ON));
234 p += strlen(ANSI_RED_ON);
238 if (pos > 0 && pos <= width) {
239 memcpy(p, ANSI_HIGHLIGHT_RED_ON, strlen(ANSI_HIGHLIGHT_RED_ON));
240 p += strlen(ANSI_HIGHLIGHT_RED_ON);
244 memcpy(p, ANSI_HIGHLIGHT_OFF, strlen(ANSI_HIGHLIGHT_OFF));
245 p += strlen(ANSI_HIGHLIGHT_OFF);
248 memcpy(p, ANSI_RED_ON, strlen(ANSI_RED_ON));
249 p += strlen(ANSI_RED_ON);
252 memset(p, ' ', width-1-pos);
255 memcpy(p, ANSI_HIGHLIGHT_OFF, strlen(ANSI_HIGHLIGHT_OFF));
256 p += strlen(ANSI_HIGHLIGHT_OFF);
261 static void manager_print_jobs_in_progress(Manager *m) {
264 char *job_of_n = NULL;
265 unsigned counter = 0, print_nr;
266 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
269 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
271 HASHMAP_FOREACH(j, m->jobs, i)
272 if (j->state == JOB_RUNNING && counter++ == print_nr)
275 /* m->n_running_jobs must be consistent with the contents of m->jobs,
276 * so the above loop must have succeeded in finding j. */
277 assert(counter == print_nr + 1);
279 cylon_pos = m->jobs_in_progress_iteration % 14;
281 cylon_pos = 14 - cylon_pos;
282 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
284 if (m->n_running_jobs > 1)
285 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
288 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
289 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
292 m->jobs_in_progress_iteration++;
295 static int manager_setup_time_change(Manager *m) {
296 struct epoll_event ev;
297 struct itimerspec its;
300 assert(m->time_change_watch.type == WATCH_INVALID);
302 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
303 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
305 m->time_change_watch.type = WATCH_TIME_CHANGE;
306 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
307 if (m->time_change_watch.fd < 0) {
308 log_error("Failed to create timerfd: %m");
314 /* We only care for the cancellation event, hence we set the
315 * timeout to the latest possible value. */
316 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
317 its.it_value.tv_sec = TIME_T_MAX;
319 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
320 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
321 close_nointr_nofail(m->time_change_watch.fd);
322 watch_init(&m->time_change_watch);
328 ev.data.ptr = &m->time_change_watch;
330 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
331 log_error("Failed to add timer change fd to epoll: %m");
335 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
340 static int enable_special_signals(Manager *m) {
345 /* Enable that we get SIGINT on control-alt-del. In containers
346 * this will fail with EPERM (older) or EINVAL (newer), so
348 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
349 log_warning("Failed to enable ctrl-alt-del handling: %m");
351 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
353 /* Support systems without virtual console */
355 log_warning("Failed to open /dev/tty0: %m");
357 /* Enable that we get SIGWINCH on kbrequest */
358 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
359 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
361 close_nointr_nofail(fd);
367 static int manager_setup_signals(Manager *m) {
369 struct epoll_event ev;
374 /* We are not interested in SIGSTOP and friends. */
376 sa.sa_handler = SIG_DFL;
377 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
378 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
380 assert_se(sigemptyset(&mask) == 0);
382 sigset_add_many(&mask,
383 SIGCHLD, /* Child died */
384 SIGTERM, /* Reexecute daemon */
385 SIGHUP, /* Reload configuration */
386 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
387 SIGUSR2, /* systemd: dump status */
388 SIGINT, /* Kernel sends us this on control-alt-del */
389 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
390 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
391 SIGRTMIN+0, /* systemd: start default.target */
392 SIGRTMIN+1, /* systemd: isolate rescue.target */
393 SIGRTMIN+2, /* systemd: isolate emergency.target */
394 SIGRTMIN+3, /* systemd: start halt.target */
395 SIGRTMIN+4, /* systemd: start poweroff.target */
396 SIGRTMIN+5, /* systemd: start reboot.target */
397 SIGRTMIN+6, /* systemd: start kexec.target */
398 SIGRTMIN+13, /* systemd: Immediate halt */
399 SIGRTMIN+14, /* systemd: Immediate poweroff */
400 SIGRTMIN+15, /* systemd: Immediate reboot */
401 SIGRTMIN+16, /* systemd: Immediate kexec */
402 SIGRTMIN+20, /* systemd: enable status messages */
403 SIGRTMIN+21, /* systemd: disable status messages */
404 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
405 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
406 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
407 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
408 SIGRTMIN+27, /* systemd: set log target to console */
409 SIGRTMIN+28, /* systemd: set log target to kmsg */
410 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
412 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
414 m->signal_watch.type = WATCH_SIGNAL;
415 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
416 if (m->signal_watch.fd < 0)
421 ev.data.ptr = &m->signal_watch;
423 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
426 if (m->running_as == SYSTEMD_SYSTEM)
427 return enable_special_signals(m);
432 static void manager_strip_environment(Manager *m) {
435 /* Remove variables from the inherited set that are part of
436 * the container interface:
437 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
438 strv_remove_prefix(m->environment, "container=");
439 strv_remove_prefix(m->environment, "container_");
441 /* Remove variables from the inherited set that are part of
442 * the initrd interface:
443 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
444 strv_remove_prefix(m->environment, "RD_");
446 /* Drop invalid entries */
447 strv_env_clean(m->environment);
450 int manager_new(SystemdRunningAs running_as, Manager **_m) {
455 assert(running_as >= 0);
456 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
458 m = new0(Manager, 1);
462 dual_timestamp_get(&m->userspace_timestamp);
463 dual_timestamp_from_monotonic(&m->kernel_timestamp, 0);
465 efi_get_boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
468 m->running_as = running_as;
469 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
470 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
471 m->pin_cgroupfs_fd = -1;
472 m->idle_pipe[0] = m->idle_pipe[1] = -1;
474 watch_init(&m->signal_watch);
475 watch_init(&m->mount_watch);
476 watch_init(&m->swap_watch);
477 watch_init(&m->udev_watch);
478 watch_init(&m->time_change_watch);
479 watch_init(&m->jobs_in_progress_watch);
481 m->epoll_fd = m->dev_autofs_fd = -1;
482 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
484 m->environment = strv_copy(environ);
488 manager_strip_environment(m);
490 if (running_as == SYSTEMD_SYSTEM) {
491 m->default_controllers = strv_new("cpu", NULL);
492 if (!m->default_controllers)
496 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
499 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
502 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
505 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
508 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
511 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
515 r = manager_setup_signals(m);
519 r = manager_setup_cgroup(m);
523 r = manager_setup_notify(m);
527 r = manager_setup_time_change(m);
531 /* Try to connect to the busses, if possible. */
532 r = bus_init(m, running_as != SYSTEMD_SYSTEM);
536 m->taint_usr = dir_is_empty("/usr") > 0;
546 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
552 while ((u = m->cleanup_queue)) {
553 assert(u->in_cleanup_queue);
563 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
564 GC_OFFSET_UNSURE, /* No clue */
565 GC_OFFSET_GOOD, /* We still need this unit */
566 GC_OFFSET_BAD, /* We don't need this unit anymore */
570 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
577 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
578 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
579 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
582 if (u->in_cleanup_queue)
585 if (unit_check_gc(u))
588 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
592 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
593 unit_gc_sweep(other, gc_marker);
595 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
598 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
605 /* We were unable to find anything out about this entry, so
606 * let's investigate it later */
607 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
608 unit_add_to_gc_queue(u);
612 /* We definitely know that this one is not useful anymore, so
613 * let's mark it for deletion */
614 u->gc_marker = gc_marker + GC_OFFSET_BAD;
615 unit_add_to_cleanup_queue(u);
619 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
622 static unsigned manager_dispatch_gc_queue(Manager *m) {
629 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
630 (m->gc_queue_timestamp <= 0 ||
631 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
634 log_debug("Running GC...");
636 m->gc_marker += _GC_OFFSET_MAX;
637 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
640 gc_marker = m->gc_marker;
642 while ((u = m->gc_queue)) {
643 assert(u->in_gc_queue);
645 unit_gc_sweep(u, gc_marker);
647 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
648 u->in_gc_queue = false;
652 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
653 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
654 log_debug_unit(u->id, "Collecting %s", u->id);
655 u->gc_marker = gc_marker + GC_OFFSET_BAD;
656 unit_add_to_cleanup_queue(u);
660 m->n_in_gc_queue = 0;
661 m->gc_queue_timestamp = 0;
666 static void manager_clear_jobs_and_units(Manager *m) {
671 while ((u = hashmap_first(m->units)))
674 manager_dispatch_cleanup_queue(m);
676 assert(!m->load_queue);
677 assert(!m->run_queue);
678 assert(!m->dbus_unit_queue);
679 assert(!m->dbus_job_queue);
680 assert(!m->cleanup_queue);
681 assert(!m->gc_queue);
683 assert(hashmap_isempty(m->jobs));
684 assert(hashmap_isempty(m->units));
687 m->n_running_jobs = 0;
690 void manager_free(Manager *m) {
696 manager_clear_jobs_and_units(m);
698 for (c = 0; c < _UNIT_TYPE_MAX; c++)
699 if (unit_vtable[c]->shutdown)
700 unit_vtable[c]->shutdown(m);
702 /* If we reexecute ourselves, we keep the root cgroup
704 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
706 manager_undo_generators(m);
710 hashmap_free(m->units);
711 hashmap_free(m->jobs);
712 hashmap_free(m->watch_pids);
713 hashmap_free(m->watch_bus);
715 if (m->epoll_fd >= 0)
716 close_nointr_nofail(m->epoll_fd);
717 if (m->signal_watch.fd >= 0)
718 close_nointr_nofail(m->signal_watch.fd);
719 if (m->notify_watch.fd >= 0)
720 close_nointr_nofail(m->notify_watch.fd);
721 if (m->time_change_watch.fd >= 0)
722 close_nointr_nofail(m->time_change_watch.fd);
723 if (m->jobs_in_progress_watch.fd >= 0)
724 close_nointr_nofail(m->jobs_in_progress_watch.fd);
726 free(m->notify_socket);
728 lookup_paths_free(&m->lookup_paths);
729 strv_free(m->environment);
731 strv_free(m->default_controllers);
733 hashmap_free(m->cgroup_bondings);
734 set_free_free(m->unit_path_cache);
736 close_pipe(m->idle_pipe);
738 free(m->switch_root);
739 free(m->switch_root_init);
741 for (i = 0; i < RLIMIT_NLIMITS; i++)
747 int manager_enumerate(Manager *m) {
753 /* Let's ask every type to load all units from disk/kernel
754 * that it might know */
755 for (c = 0; c < _UNIT_TYPE_MAX; c++)
756 if (unit_vtable[c]->enumerate)
757 if ((q = unit_vtable[c]->enumerate(m)) < 0)
760 manager_dispatch_load_queue(m);
764 int manager_coldplug(Manager *m) {
772 /* Then, let's set up their initial state. */
773 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
779 if ((q = unit_coldplug(u)) < 0)
786 static void manager_build_unit_path_cache(Manager *m) {
788 DIR _cleanup_free_ *d = NULL;
793 set_free_free(m->unit_path_cache);
795 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
796 if (!m->unit_path_cache) {
797 log_error("Failed to allocate unit path cache.");
801 /* This simply builds a list of files we know exist, so that
802 * we don't always have to go to disk */
804 STRV_FOREACH(i, m->lookup_paths.unit_path) {
810 log_error("Failed to open directory %s: %m", *i);
814 while ((de = readdir(d))) {
817 if (ignore_file(de->d_name))
820 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
826 r = set_put(m->unit_path_cache, p);
840 log_error("Failed to build unit path cache: %s", strerror(-r));
842 set_free_free(m->unit_path_cache);
843 m->unit_path_cache = NULL;
846 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
851 manager_run_generators(m);
853 r = lookup_paths_init(
854 &m->lookup_paths, m->running_as, true,
855 m->generator_unit_path,
856 m->generator_unit_path_early,
857 m->generator_unit_path_late);
861 manager_build_unit_path_cache(m);
863 /* If we will deserialize make sure that during enumeration
864 * this is already known, so we increase the counter here
869 /* First, enumerate what we can from all config files */
870 r = manager_enumerate(m);
872 /* Second, deserialize if there is something to deserialize */
874 q = manager_deserialize(m, serialization, fds);
879 /* Any fds left? Find some unit which wants them. This is
880 * useful to allow container managers to pass some file
881 * descriptors to us pre-initialized. This enables
882 * socket-based activation of entire containers. */
883 if (fdset_size(fds) > 0) {
884 q = manager_distribute_fds(m, fds);
889 /* Third, fire things up! */
890 q = manager_coldplug(m);
895 assert(m->n_reloading > 0);
902 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
907 assert(type < _JOB_TYPE_MAX);
909 assert(mode < _JOB_MODE_MAX);
911 if (mode == JOB_ISOLATE && type != JOB_START) {
912 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
916 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
917 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
921 log_debug_unit(unit->id,
922 "Trying to enqueue job %s/%s/%s", unit->id,
923 job_type_to_string(type), job_mode_to_string(mode));
925 job_type_collapse(&type, unit);
927 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
931 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
932 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
933 mode == JOB_IGNORE_DEPENDENCIES, e);
937 if (mode == JOB_ISOLATE) {
938 r = transaction_add_isolate_jobs(tr, m);
943 r = transaction_activate(tr, m, mode, e);
947 log_debug_unit(unit->id,
948 "Enqueued job %s/%s as %u", unit->id,
949 job_type_to_string(type), (unsigned) tr->anchor_job->id);
952 *_ret = tr->anchor_job;
954 transaction_free(tr);
958 transaction_abort(tr);
959 transaction_free(tr);
963 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
968 assert(type < _JOB_TYPE_MAX);
970 assert(mode < _JOB_MODE_MAX);
972 r = manager_load_unit(m, name, NULL, NULL, &unit);
976 return manager_add_job(m, type, unit, mode, override, e, _ret);
979 Job *manager_get_job(Manager *m, uint32_t id) {
982 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
985 Unit *manager_get_unit(Manager *m, const char *name) {
989 return hashmap_get(m->units, name);
992 unsigned manager_dispatch_load_queue(Manager *m) {
998 /* Make sure we are not run recursively */
999 if (m->dispatching_load_queue)
1002 m->dispatching_load_queue = true;
1004 /* Dispatches the load queue. Takes a unit from the queue and
1005 * tries to load its data until the queue is empty */
1007 while ((u = m->load_queue)) {
1008 assert(u->in_load_queue);
1014 m->dispatching_load_queue = false;
1018 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1024 assert(name || path);
1026 /* This will prepare the unit for loading, but not actually
1027 * load anything from disk. */
1029 if (path && !is_path(path)) {
1030 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1035 name = path_get_file_name(path);
1037 t = unit_name_to_type(name);
1039 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
1040 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1044 ret = manager_get_unit(m, name);
1050 ret = unit_new(m, unit_vtable[t]->object_size);
1055 ret->fragment_path = strdup(path);
1056 if (!ret->fragment_path) {
1062 if ((r = unit_add_name(ret, name)) < 0) {
1067 unit_add_to_load_queue(ret);
1068 unit_add_to_dbus_queue(ret);
1069 unit_add_to_gc_queue(ret);
1077 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1082 /* This will load the service information files, but not actually
1083 * start any services or anything. */
1085 r = manager_load_unit_prepare(m, name, path, e, _ret);
1089 manager_dispatch_load_queue(m);
1092 *_ret = unit_follow_merge(*_ret);
1097 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1104 HASHMAP_FOREACH(j, s->jobs, i)
1105 job_dump(j, f, prefix);
1108 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1116 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1118 unit_dump(u, f, prefix);
1121 void manager_clear_jobs(Manager *m) {
1126 while ((j = hashmap_first(m->jobs)))
1127 /* No need to recurse. We're cancelling all jobs. */
1128 job_finish_and_invalidate(j, JOB_CANCELED, false);
1131 unsigned manager_dispatch_run_queue(Manager *m) {
1135 if (m->dispatching_run_queue)
1138 m->dispatching_run_queue = true;
1140 while ((j = m->run_queue)) {
1141 assert(j->installed);
1142 assert(j->in_run_queue);
1144 job_run_and_invalidate(j);
1148 m->dispatching_run_queue = false;
1150 if (m->n_running_jobs > 0)
1151 manager_watch_jobs_in_progress(m);
1156 unsigned manager_dispatch_dbus_queue(Manager *m) {
1163 if (m->dispatching_dbus_queue)
1166 m->dispatching_dbus_queue = true;
1168 while ((u = m->dbus_unit_queue)) {
1169 assert(u->in_dbus_queue);
1171 bus_unit_send_change_signal(u);
1175 while ((j = m->dbus_job_queue)) {
1176 assert(j->in_dbus_queue);
1178 bus_job_send_change_signal(j);
1182 m->dispatching_dbus_queue = false;
1186 static int manager_process_notify_fd(Manager *m) {
1193 struct msghdr msghdr;
1195 struct ucred *ucred;
1197 struct cmsghdr cmsghdr;
1198 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1204 iovec.iov_base = buf;
1205 iovec.iov_len = sizeof(buf)-1;
1209 msghdr.msg_iov = &iovec;
1210 msghdr.msg_iovlen = 1;
1211 msghdr.msg_control = &control;
1212 msghdr.msg_controllen = sizeof(control);
1214 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1219 if (errno == EAGAIN || errno == EINTR)
1225 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1226 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1227 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1228 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1229 log_warning("Received notify message without credentials. Ignoring.");
1233 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1235 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1237 u = cgroup_unit_by_pid(m, ucred->pid);
1239 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1244 assert((size_t) n < sizeof(buf));
1246 tags = strv_split(buf, "\n\r");
1250 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1252 if (UNIT_VTABLE(u)->notify_message)
1253 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1261 static int manager_dispatch_sigchld(Manager *m) {
1271 /* First we call waitd() for a PID and do not reap the
1272 * zombie. That way we can still access /proc/$PID for
1273 * it while it is a zombie. */
1274 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1276 if (errno == ECHILD)
1288 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1289 char _cleanup_free_ *name = NULL;
1291 get_process_comm(si.si_pid, &name);
1292 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1295 /* Let's flush any message the dying child might still
1296 * have queued for us. This ensures that the process
1297 * still exists in /proc so that we can figure out
1298 * which cgroup and hence unit it belongs to. */
1299 r = manager_process_notify_fd(m);
1303 /* And now figure out the unit this belongs to */
1304 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1306 u = cgroup_unit_by_pid(m, si.si_pid);
1308 /* And now, we actually reap the zombie. */
1309 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1316 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1319 log_debug("Child %lu died (code=%s, status=%i/%s)",
1320 (long unsigned) si.si_pid,
1321 sigchld_code_to_string(si.si_code),
1323 strna(si.si_code == CLD_EXITED
1324 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1325 : signal_to_string(si.si_status)));
1330 log_debug_unit(u->id,
1331 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1333 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1334 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1340 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1344 dbus_error_init(&error);
1346 log_debug_unit(name, "Activating special unit %s", name);
1348 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1350 log_error_unit(name,
1351 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1353 dbus_error_free(&error);
1358 static int manager_process_signal_fd(Manager *m) {
1360 struct signalfd_siginfo sfsi;
1361 bool sigchld = false;
1366 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1367 if (n != sizeof(sfsi)) {
1372 if (errno == EINTR || errno == EAGAIN)
1378 if (sfsi.ssi_pid > 0) {
1381 get_process_comm(sfsi.ssi_pid, &p);
1383 log_debug("Received SIG%s from PID %lu (%s).",
1384 signal_to_string(sfsi.ssi_signo),
1385 (unsigned long) sfsi.ssi_pid, strna(p));
1388 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1390 switch (sfsi.ssi_signo) {
1397 if (m->running_as == SYSTEMD_SYSTEM) {
1398 /* This is for compatibility with the
1399 * original sysvinit */
1400 m->exit_code = MANAGER_REEXECUTE;
1407 if (m->running_as == SYSTEMD_SYSTEM) {
1408 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1412 /* Run the exit target if there is one, if not, just exit. */
1413 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1414 m->exit_code = MANAGER_EXIT;
1421 if (m->running_as == SYSTEMD_SYSTEM)
1422 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1424 /* This is a nop on non-init */
1428 if (m->running_as == SYSTEMD_SYSTEM)
1429 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1431 /* This is a nop on non-init */
1437 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1439 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1440 log_info("Trying to reconnect to bus...");
1444 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1445 log_info("Loading D-Bus service...");
1446 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1457 if (!(f = open_memstream(&dump, &size))) {
1458 log_warning("Failed to allocate memory stream.");
1462 manager_dump_units(m, f, "\t");
1463 manager_dump_jobs(m, f, "\t");
1468 log_warning("Failed to write status stream");
1473 log_dump(LOG_INFO, dump);
1480 m->exit_code = MANAGER_RELOAD;
1485 /* Starting SIGRTMIN+0 */
1486 static const char * const target_table[] = {
1487 [0] = SPECIAL_DEFAULT_TARGET,
1488 [1] = SPECIAL_RESCUE_TARGET,
1489 [2] = SPECIAL_EMERGENCY_TARGET,
1490 [3] = SPECIAL_HALT_TARGET,
1491 [4] = SPECIAL_POWEROFF_TARGET,
1492 [5] = SPECIAL_REBOOT_TARGET,
1493 [6] = SPECIAL_KEXEC_TARGET
1496 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1497 static const ManagerExitCode code_table[] = {
1499 [1] = MANAGER_POWEROFF,
1500 [2] = MANAGER_REBOOT,
1504 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1505 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1506 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1507 manager_start_target(m, target_table[idx],
1508 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1512 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1513 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1514 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1518 switch (sfsi.ssi_signo - SIGRTMIN) {
1521 log_debug("Enabling showing of status.");
1522 manager_set_show_status(m, true);
1526 log_debug("Disabling showing of status.");
1527 manager_set_show_status(m, false);
1531 log_set_max_level(LOG_DEBUG);
1532 log_notice("Setting log level to debug.");
1536 log_set_max_level(LOG_INFO);
1537 log_notice("Setting log level to info.");
1541 if (m->running_as == SYSTEMD_USER) {
1542 m->exit_code = MANAGER_EXIT;
1546 /* This is a nop on init */
1550 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1551 log_notice("Setting log target to journal-or-kmsg.");
1555 log_set_target(LOG_TARGET_CONSOLE);
1556 log_notice("Setting log target to console.");
1560 log_set_target(LOG_TARGET_KMSG);
1561 log_notice("Setting log target to kmsg.");
1565 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1566 log_notice("Setting log target to syslog-or-kmsg.");
1570 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1577 return manager_dispatch_sigchld(m);
1582 static int process_event(Manager *m, struct epoll_event *ev) {
1589 assert_se(w = ev->data.ptr);
1591 if (w->type == WATCH_INVALID)
1598 /* An incoming signal? */
1599 if (ev->events != EPOLLIN)
1602 if ((r = manager_process_signal_fd(m)) < 0)
1609 /* An incoming daemon notification event? */
1610 if (ev->events != EPOLLIN)
1613 if ((r = manager_process_notify_fd(m)) < 0)
1620 /* Some fd event, to be dispatched to the units */
1621 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1624 case WATCH_UNIT_TIMER:
1625 case WATCH_JOB_TIMER: {
1629 /* Some timer event, to be dispatched to the units */
1630 k = read(w->fd, &v, sizeof(v));
1631 if (k != sizeof(v)) {
1633 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1636 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1637 return k < 0 ? -errno : -EIO;
1640 if (w->type == WATCH_UNIT_TIMER)
1641 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1643 job_timer_event(w->data.job, v, w);
1648 /* Some mount table change, intended for the mount subsystem */
1649 mount_fd_event(m, ev->events);
1653 /* Some swap table change, intended for the swap subsystem */
1654 swap_fd_event(m, ev->events);
1658 /* Some notification from udev, intended for the device subsystem */
1659 device_fd_event(m, ev->events);
1662 case WATCH_DBUS_WATCH:
1663 bus_watch_event(m, w, ev->events);
1666 case WATCH_DBUS_TIMEOUT:
1667 bus_timeout_event(m, w, ev->events);
1670 case WATCH_TIME_CHANGE: {
1674 log_struct(LOG_INFO,
1675 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1676 "MESSAGE=Time has been changed",
1679 /* Restart the watch */
1680 epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->time_change_watch.fd,
1682 close_nointr_nofail(m->time_change_watch.fd);
1683 watch_init(&m->time_change_watch);
1684 manager_setup_time_change(m);
1686 HASHMAP_FOREACH(u, m->units, i) {
1687 if (UNIT_VTABLE(u)->time_change)
1688 UNIT_VTABLE(u)->time_change(u);
1694 case WATCH_JOBS_IN_PROGRESS: {
1697 /* not interested in the data */
1698 read(w->fd, &v, sizeof(v));
1700 manager_print_jobs_in_progress(m);
1705 log_error("event type=%i", w->type);
1706 assert_not_reached("Unknown epoll event type.");
1712 int manager_loop(Manager *m) {
1715 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1718 m->exit_code = MANAGER_RUNNING;
1720 /* Release the path cache */
1721 set_free_free(m->unit_path_cache);
1722 m->unit_path_cache = NULL;
1724 manager_check_finished(m);
1726 /* There might still be some zombies hanging around from
1727 * before we were exec()'ed. Leat's reap them */
1728 r = manager_dispatch_sigchld(m);
1732 while (m->exit_code == MANAGER_RUNNING) {
1733 struct epoll_event event;
1737 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1740 if (!ratelimit_test(&rl)) {
1741 /* Yay, something is going seriously wrong, pause a little */
1742 log_warning("Looping too fast. Throttling execution a little.");
1747 if (manager_dispatch_load_queue(m) > 0)
1750 if (manager_dispatch_run_queue(m) > 0)
1753 if (bus_dispatch(m) > 0)
1756 if (manager_dispatch_cleanup_queue(m) > 0)
1759 if (manager_dispatch_gc_queue(m) > 0)
1762 if (manager_dispatch_dbus_queue(m) > 0)
1765 if (swap_dispatch_reload(m) > 0)
1768 /* Sleep for half the watchdog time */
1769 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1770 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1776 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1788 r = process_event(m, &event);
1793 return m->exit_code;
1796 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1805 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1808 n = bus_path_unescape(s+31);
1812 r = manager_load_unit(m, n, NULL, e, &u);
1823 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1832 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1835 r = safe_atou(s + 30, &id);
1839 j = manager_get_job(m, id);
1848 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1854 audit_fd = get_audit_fd();
1858 /* Don't generate audit events if the service was already
1859 * started and we're just deserializing */
1860 if (m->n_reloading > 0)
1863 if (m->running_as != SYSTEMD_SYSTEM)
1866 if (u->type != UNIT_SERVICE)
1869 p = unit_name_to_prefix_and_instance(u->id);
1871 log_error_unit(u->id,
1872 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1876 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1877 if (errno == EPERM) {
1878 /* We aren't allowed to send audit messages?
1879 * Then let's not retry again. */
1882 log_warning("Failed to send audit message: %m");
1890 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1892 union sockaddr_union sa;
1894 char *message = NULL;
1896 /* Don't generate plymouth events if the service was already
1897 * started and we're just deserializing */
1898 if (m->n_reloading > 0)
1901 if (m->running_as != SYSTEMD_SYSTEM)
1904 if (u->type != UNIT_SERVICE &&
1905 u->type != UNIT_MOUNT &&
1906 u->type != UNIT_SWAP)
1909 /* We set SOCK_NONBLOCK here so that we rather drop the
1910 * message then wait for plymouth */
1911 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1912 log_error("socket() failed: %m");
1917 sa.sa.sa_family = AF_UNIX;
1918 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1919 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1921 if (errno != EPIPE &&
1924 errno != ECONNREFUSED &&
1925 errno != ECONNRESET &&
1926 errno != ECONNABORTED)
1927 log_error("connect() failed: %m");
1932 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1938 if (write(fd, message, n + 1) != n + 1) {
1940 if (errno != EPIPE &&
1943 errno != ECONNREFUSED &&
1944 errno != ECONNRESET &&
1945 errno != ECONNABORTED)
1946 log_error("Failed to write Plymouth message: %m");
1953 close_nointr_nofail(fd);
1958 void manager_dispatch_bus_name_owner_changed(
1961 const char* old_owner,
1962 const char *new_owner) {
1969 if (!(u = hashmap_get(m->watch_bus, name)))
1972 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1975 void manager_dispatch_bus_query_pid_done(
1986 if (!(u = hashmap_get(m->watch_bus, name)))
1989 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1992 int manager_open_serialization(Manager *m, FILE **_f) {
2000 if (m->running_as == SYSTEMD_SYSTEM)
2001 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
2003 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
2008 saved_umask = umask(0077);
2009 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2019 log_debug("Serializing state to %s", path);
2022 f = fdopen(fd, "w+");
2031 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
2044 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2045 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2046 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2047 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2049 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2050 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2051 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2052 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2055 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2056 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2059 STRV_FOREACH(e, m->environment) {
2060 _cleanup_free_ char *ce;
2064 fprintf(f, "env=%s\n", *e);
2069 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2073 if (!unit_can_serialize(u))
2080 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
2086 assert(m->n_reloading > 0);
2092 r = bus_fdset_add_all(m, fds);
2099 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2105 log_debug("Deserializing state...");
2110 char line[LINE_MAX], *l;
2112 if (!fgets(line, sizeof(line), f)) {
2127 if (startswith(l, "current-job-id=")) {
2130 if (safe_atou32(l+15, &id) < 0)
2131 log_debug("Failed to parse current job id value %s", l+15);
2133 m->current_job_id = MAX(m->current_job_id, id);
2134 } else if (startswith(l, "n-installed-jobs=")) {
2137 if (safe_atou32(l+17, &n) < 0)
2138 log_debug("Failed to parse installed jobs counter %s", l+17);
2140 m->n_installed_jobs += n;
2141 } else if (startswith(l, "n-failed-jobs=")) {
2144 if (safe_atou32(l+14, &n) < 0)
2145 log_debug("Failed to parse failed jobs counter %s", l+14);
2147 m->n_failed_jobs += n;
2148 } else if (startswith(l, "taint-usr=")) {
2151 if ((b = parse_boolean(l+10)) < 0)
2152 log_debug("Failed to parse taint /usr flag %s", l+10);
2154 m->taint_usr = m->taint_usr || b;
2155 } else if (startswith(l, "firmware-timestamp="))
2156 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2157 else if (startswith(l, "loader-timestamp="))
2158 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2159 else if (startswith(l, "kernel-timestamp="))
2160 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2161 else if (startswith(l, "initrd-timestamp="))
2162 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2163 else if (startswith(l, "userspace-timestamp="))
2164 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2165 else if (startswith(l, "finish-timestamp="))
2166 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2167 else if (startswith(l, "env=")) {
2168 _cleanup_free_ char *uce = NULL;
2171 uce = cunescape(l+4);
2177 e = strv_env_set(m->environment, uce);
2183 strv_free(m->environment);
2186 log_debug("Unknown serialization item '%s'", l);
2191 char name[UNIT_NAME_MAX+2];
2194 if (!fgets(name, sizeof(name), f)) {
2205 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2209 r = unit_deserialize(u, f, fds);
2220 assert(m->n_reloading > 0);
2226 int manager_distribute_fds(Manager *m, FDSet *fds) {
2233 HASHMAP_FOREACH(u, m->units, i) {
2235 if (fdset_size(fds) <= 0)
2238 if (UNIT_VTABLE(u)->distribute_fds) {
2239 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2248 int manager_reload(Manager *m) {
2255 r = manager_open_serialization(m, &f);
2268 r = manager_serialize(m, f, fds, true);
2274 if (fseeko(f, 0, SEEK_SET) < 0) {
2280 /* From here on there is no way back. */
2281 manager_clear_jobs_and_units(m);
2282 manager_undo_generators(m);
2283 lookup_paths_free(&m->lookup_paths);
2285 /* Find new unit paths */
2286 manager_run_generators(m);
2288 q = lookup_paths_init(
2289 &m->lookup_paths, m->running_as, true,
2290 m->generator_unit_path,
2291 m->generator_unit_path_early,
2292 m->generator_unit_path_late);
2296 manager_build_unit_path_cache(m);
2298 /* First, enumerate what we can from all config files */
2299 q = manager_enumerate(m);
2303 /* Second, deserialize our stored data */
2304 q = manager_deserialize(m, f, fds);
2311 /* Third, fire things up! */
2312 q = manager_coldplug(m);
2316 assert(m->n_reloading > 0);
2329 static bool manager_is_booting_or_shutting_down(Manager *m) {
2334 /* Is the initial job still around? */
2335 if (manager_get_job(m, m->default_unit_job_id))
2338 /* Is there a job for the shutdown target? */
2339 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2346 void manager_reset_failed(Manager *m) {
2352 HASHMAP_FOREACH(u, m->units, i)
2353 unit_reset_failed(u);
2356 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2362 /* Returns true if the unit is inactive or going down */
2363 u = manager_get_unit(m, name);
2367 return unit_pending_inactive(u);
2370 void manager_check_finished(Manager *m) {
2371 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2372 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2376 if (m->n_running_jobs == 0)
2377 manager_unwatch_jobs_in_progress(m);
2379 if (hashmap_size(m->jobs) > 0) {
2380 manager_jobs_in_progress_mod_timer(m);
2384 /* Notify Type=idle units that we are done now */
2385 close_pipe(m->idle_pipe);
2387 /* Turn off confirm spawn now */
2388 m->confirm_spawn = false;
2390 if (dual_timestamp_is_set(&m->finish_timestamp))
2393 dual_timestamp_get(&m->finish_timestamp);
2395 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2397 /* Note that m->kernel_usec.monotonic is always at 0,
2398 * and m->firmware_usec.monotonic and
2399 * m->loader_usec.monotonic should be considered
2400 * negative values. */
2402 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2403 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2404 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2405 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2407 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2409 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2410 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2412 if (!log_on_console())
2413 log_struct(LOG_INFO,
2414 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2415 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2416 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2417 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2418 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2419 format_timespan(kernel, sizeof(kernel), kernel_usec),
2420 format_timespan(initrd, sizeof(initrd), initrd_usec),
2421 format_timespan(userspace, sizeof(userspace), userspace_usec),
2422 format_timespan(sum, sizeof(sum), total_usec),
2425 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2428 if (!log_on_console())
2429 log_struct(LOG_INFO,
2430 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2431 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2432 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2433 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2434 format_timespan(kernel, sizeof(kernel), kernel_usec),
2435 format_timespan(userspace, sizeof(userspace), userspace_usec),
2436 format_timespan(sum, sizeof(sum), total_usec),
2440 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2441 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2443 if (!log_on_console())
2444 log_struct(LOG_INFO,
2445 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2446 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2447 "MESSAGE=Startup finished in %s.",
2448 format_timespan(sum, sizeof(sum), total_usec),
2452 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2455 "READY=1\nSTATUS=Startup finished in %s.",
2456 format_timespan(sum, sizeof(sum), total_usec));
2459 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2470 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2472 p = strappend("/run/systemd/", name);
2476 r = mkdir_p_label(p, 0755);
2478 log_error("Failed to create generator directory %s: %s",
2484 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2489 log_error("Failed to create generator directory %s: %m",
2500 static void trim_generator_dir(Manager *m, char **generator) {
2507 if (rmdir(*generator) >= 0) {
2515 void manager_run_generators(Manager *m) {
2517 const char *generator_path;
2518 const char *argv[5];
2524 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2525 d = opendir(generator_path);
2527 if (errno == ENOENT)
2530 log_error("Failed to enumerate generator directory %s: %m",
2535 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2539 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2543 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2547 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2548 argv[1] = m->generator_unit_path;
2549 argv[2] = m->generator_unit_path_early;
2550 argv[3] = m->generator_unit_path_late;
2554 execute_directory(generator_path, d, (char**) argv);
2557 trim_generator_dir(m, &m->generator_unit_path);
2558 trim_generator_dir(m, &m->generator_unit_path_early);
2559 trim_generator_dir(m, &m->generator_unit_path_late);
2566 static void remove_generator_dir(Manager *m, char **generator) {
2573 strv_remove(m->lookup_paths.unit_path, *generator);
2574 rm_rf(*generator, false, true, false);
2580 void manager_undo_generators(Manager *m) {
2583 remove_generator_dir(m, &m->generator_unit_path);
2584 remove_generator_dir(m, &m->generator_unit_path_early);
2585 remove_generator_dir(m, &m->generator_unit_path_late);
2588 int manager_set_default_controllers(Manager *m, char **controllers) {
2593 l = strv_copy(controllers);
2597 strv_free(m->default_controllers);
2598 m->default_controllers = l;
2600 cg_shorten_controllers(m->default_controllers);
2605 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2610 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2611 if (!default_rlimit[i])
2614 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2622 void manager_recheck_journal(Manager *m) {
2627 if (m->running_as != SYSTEMD_SYSTEM)
2630 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2631 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2632 log_close_journal();
2636 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2637 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2638 log_close_journal();
2642 /* Hmm, OK, so the socket is fully up and the service is up
2643 * too, then let's make use of the thing. */
2647 void manager_set_show_status(Manager *m, bool b) {
2650 if (m->running_as != SYSTEMD_SYSTEM)
2656 touch("/run/systemd/show-status");
2658 unlink("/run/systemd/show-status");
2661 static bool manager_get_show_status(Manager *m) {
2664 if (m->running_as != SYSTEMD_SYSTEM)
2670 /* If Plymouth is running make sure we show the status, so
2671 * that there's something nice to see when people press Esc */
2673 return plymouth_running();
2676 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2679 if (!manager_get_show_status(m))
2682 /* XXX We should totally drop the check for ephemeral here
2683 * and thus effectively make 'Type=idle' pointless. */
2684 if (ephemeral && m->n_on_console > 0)
2687 if (!manager_is_booting_or_shutting_down(m))
2690 va_start(ap, format);
2691 status_vprintf(status, true, ephemeral, format, ap);
2695 void watch_init(Watch *w) {
2698 w->type = WATCH_INVALID;