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 .sa.sa_family = AF_UNIX,
99 struct epoll_event ev = {
101 .data.ptr = &m->notify_watch,
105 m->notify_watch.type = WATCH_NOTIFY;
106 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
107 if (m->notify_watch.fd < 0) {
108 log_error("Failed to allocate notification socket: %m");
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 r = bind(m->notify_watch.fd, &sa.sa,
120 offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
122 log_error("bind() failed: %m");
126 r = setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
128 log_error("SO_PASSCRED failed: %m");
132 r = epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev);
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 = {
150 .it_value.tv_sec = JOBS_IN_PROGRESS_WAIT_SEC,
151 .it_interval.tv_sec = JOBS_IN_PROGRESS_PERIOD_SEC,
154 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
157 if (timerfd_settime(m->jobs_in_progress_watch.fd, 0, &its, NULL) < 0)
163 static int manager_watch_jobs_in_progress(Manager *m) {
164 struct epoll_event ev = {
166 .data.ptr = &m->jobs_in_progress_watch,
170 if (m->jobs_in_progress_watch.type != WATCH_INVALID)
173 m->jobs_in_progress_watch.type = WATCH_JOBS_IN_PROGRESS;
174 m->jobs_in_progress_watch.fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
175 if (m->jobs_in_progress_watch.fd < 0) {
176 log_error("Failed to create timerfd: %m");
181 r = manager_jobs_in_progress_mod_timer(m);
183 log_error("Failed to set up timer for jobs progress watch: %s", strerror(-r));
187 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->jobs_in_progress_watch.fd, &ev) < 0) {
188 log_error("Failed to add jobs progress timer fd to epoll: %m");
193 log_debug("Set up jobs progress timerfd.");
198 if (m->jobs_in_progress_watch.fd >= 0)
199 close_nointr_nofail(m->jobs_in_progress_watch.fd);
200 watch_init(&m->jobs_in_progress_watch);
204 static void manager_unwatch_jobs_in_progress(Manager *m) {
205 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
208 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->jobs_in_progress_watch.fd, NULL) >= 0);
209 close_nointr_nofail(m->jobs_in_progress_watch.fd);
210 watch_init(&m->jobs_in_progress_watch);
211 m->jobs_in_progress_iteration = 0;
213 log_debug("Closed jobs progress timerfd.");
216 #define CYLON_BUFFER_EXTRA (2*strlen(ANSI_RED_ON) + strlen(ANSI_HIGHLIGHT_RED_ON) + 2*strlen(ANSI_HIGHLIGHT_OFF))
217 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
220 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
221 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
225 p = mempset(p, ' ', pos-2);
226 p = stpcpy(p, ANSI_RED_ON);
230 if (pos > 0 && pos <= width) {
231 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
235 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
238 p = stpcpy(p, ANSI_RED_ON);
241 p = mempset(p, ' ', width-1-pos);
242 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
246 static void manager_print_jobs_in_progress(Manager *m) {
249 char *job_of_n = NULL;
250 unsigned counter = 0, print_nr;
251 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
254 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
256 HASHMAP_FOREACH(j, m->jobs, i)
257 if (j->state == JOB_RUNNING && counter++ == print_nr)
260 /* m->n_running_jobs must be consistent with the contents of m->jobs,
261 * so the above loop must have succeeded in finding j. */
262 assert(counter == print_nr + 1);
264 cylon_pos = m->jobs_in_progress_iteration % 14;
266 cylon_pos = 14 - cylon_pos;
267 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
269 if (m->n_running_jobs > 1)
270 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
273 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
274 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
277 m->jobs_in_progress_iteration++;
280 static int manager_setup_time_change(Manager *m) {
281 struct epoll_event ev = {
283 .data.ptr = &m->time_change_watch,
286 /* We only care for the cancellation event, hence we set the
287 * timeout to the latest possible value. */
288 struct itimerspec its = {
289 .it_value.tv_sec = TIME_T_MAX,
291 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
293 assert(m->time_change_watch.type == WATCH_INVALID);
295 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
296 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
298 m->time_change_watch.type = WATCH_TIME_CHANGE;
299 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
300 if (m->time_change_watch.fd < 0) {
301 log_error("Failed to create timerfd: %m");
305 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
306 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
307 close_nointr_nofail(m->time_change_watch.fd);
308 watch_init(&m->time_change_watch);
312 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
313 log_error("Failed to add timer change fd to epoll: %m");
317 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
322 static int enable_special_signals(Manager *m) {
327 /* Enable that we get SIGINT on control-alt-del. In containers
328 * this will fail with EPERM (older) or EINVAL (newer), so
330 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
331 log_warning("Failed to enable ctrl-alt-del handling: %m");
333 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
335 /* Support systems without virtual console */
337 log_warning("Failed to open /dev/tty0: %m");
339 /* Enable that we get SIGWINCH on kbrequest */
340 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
341 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
343 close_nointr_nofail(fd);
349 static int manager_setup_signals(Manager *m) {
351 struct epoll_event ev = {
353 .data.ptr = &m->signal_watch,
355 struct sigaction sa = {
356 .sa_handler = SIG_DFL,
357 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
362 /* We are not interested in SIGSTOP and friends. */
363 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
365 assert_se(sigemptyset(&mask) == 0);
367 sigset_add_many(&mask,
368 SIGCHLD, /* Child died */
369 SIGTERM, /* Reexecute daemon */
370 SIGHUP, /* Reload configuration */
371 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
372 SIGUSR2, /* systemd: dump status */
373 SIGINT, /* Kernel sends us this on control-alt-del */
374 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
375 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
376 SIGRTMIN+0, /* systemd: start default.target */
377 SIGRTMIN+1, /* systemd: isolate rescue.target */
378 SIGRTMIN+2, /* systemd: isolate emergency.target */
379 SIGRTMIN+3, /* systemd: start halt.target */
380 SIGRTMIN+4, /* systemd: start poweroff.target */
381 SIGRTMIN+5, /* systemd: start reboot.target */
382 SIGRTMIN+6, /* systemd: start kexec.target */
383 SIGRTMIN+13, /* systemd: Immediate halt */
384 SIGRTMIN+14, /* systemd: Immediate poweroff */
385 SIGRTMIN+15, /* systemd: Immediate reboot */
386 SIGRTMIN+16, /* systemd: Immediate kexec */
387 SIGRTMIN+20, /* systemd: enable status messages */
388 SIGRTMIN+21, /* systemd: disable status messages */
389 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
390 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
391 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
392 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
393 SIGRTMIN+27, /* systemd: set log target to console */
394 SIGRTMIN+28, /* systemd: set log target to kmsg */
395 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
397 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
399 m->signal_watch.type = WATCH_SIGNAL;
400 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
401 if (m->signal_watch.fd < 0)
404 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
407 if (m->running_as == SYSTEMD_SYSTEM)
408 return enable_special_signals(m);
413 static void manager_strip_environment(Manager *m) {
416 /* Remove variables from the inherited set that are part of
417 * the container interface:
418 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
419 strv_remove_prefix(m->environment, "container=");
420 strv_remove_prefix(m->environment, "container_");
422 /* Remove variables from the inherited set that are part of
423 * the initrd interface:
424 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
425 strv_remove_prefix(m->environment, "RD_");
427 /* Drop invalid entries */
428 strv_env_clean(m->environment);
431 int manager_new(SystemdRunningAs running_as, Manager **_m) {
436 assert(running_as >= 0);
437 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
439 m = new0(Manager, 1);
444 if (detect_container(NULL) <= 0)
445 efi_get_boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
448 m->running_as = running_as;
449 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
450 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
451 m->pin_cgroupfs_fd = -1;
452 m->idle_pipe[0] = m->idle_pipe[1] = -1;
454 watch_init(&m->signal_watch);
455 watch_init(&m->mount_watch);
456 watch_init(&m->swap_watch);
457 watch_init(&m->udev_watch);
458 watch_init(&m->time_change_watch);
459 watch_init(&m->jobs_in_progress_watch);
461 m->epoll_fd = m->dev_autofs_fd = -1;
462 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
464 m->environment = strv_copy(environ);
468 manager_strip_environment(m);
470 if (running_as == SYSTEMD_SYSTEM) {
471 m->default_controllers = strv_new("cpu", NULL);
472 if (!m->default_controllers)
476 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
479 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
482 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
485 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
488 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
491 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
495 r = manager_setup_signals(m);
499 r = manager_setup_cgroup(m);
503 r = manager_setup_notify(m);
507 r = manager_setup_time_change(m);
511 /* Try to connect to the busses, if possible. */
512 if ((running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS")) ||
513 running_as == SYSTEMD_SYSTEM) {
514 r = bus_init(m, running_as != SYSTEMD_SYSTEM);
518 log_debug("Skipping DBus session bus connection attempt - no DBUS_SESSION_BUS_ADDRESS set...");
520 m->taint_usr = dir_is_empty("/usr") > 0;
530 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
536 while ((u = m->cleanup_queue)) {
537 assert(u->in_cleanup_queue);
547 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
548 GC_OFFSET_UNSURE, /* No clue */
549 GC_OFFSET_GOOD, /* We still need this unit */
550 GC_OFFSET_BAD, /* We don't need this unit anymore */
554 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
561 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
562 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
563 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
566 if (u->in_cleanup_queue)
569 if (unit_check_gc(u))
572 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
576 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
577 unit_gc_sweep(other, gc_marker);
579 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
582 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
589 /* We were unable to find anything out about this entry, so
590 * let's investigate it later */
591 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
592 unit_add_to_gc_queue(u);
596 /* We definitely know that this one is not useful anymore, so
597 * let's mark it for deletion */
598 u->gc_marker = gc_marker + GC_OFFSET_BAD;
599 unit_add_to_cleanup_queue(u);
603 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
606 static unsigned manager_dispatch_gc_queue(Manager *m) {
613 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
614 (m->gc_queue_timestamp <= 0 ||
615 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
618 log_debug("Running GC...");
620 m->gc_marker += _GC_OFFSET_MAX;
621 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
624 gc_marker = m->gc_marker;
626 while ((u = m->gc_queue)) {
627 assert(u->in_gc_queue);
629 unit_gc_sweep(u, gc_marker);
631 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
632 u->in_gc_queue = false;
636 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
637 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
638 log_debug_unit(u->id, "Collecting %s", u->id);
639 u->gc_marker = gc_marker + GC_OFFSET_BAD;
640 unit_add_to_cleanup_queue(u);
644 m->n_in_gc_queue = 0;
645 m->gc_queue_timestamp = 0;
650 static void manager_clear_jobs_and_units(Manager *m) {
655 while ((u = hashmap_first(m->units)))
658 manager_dispatch_cleanup_queue(m);
660 assert(!m->load_queue);
661 assert(!m->run_queue);
662 assert(!m->dbus_unit_queue);
663 assert(!m->dbus_job_queue);
664 assert(!m->cleanup_queue);
665 assert(!m->gc_queue);
667 assert(hashmap_isempty(m->jobs));
668 assert(hashmap_isempty(m->units));
671 m->n_running_jobs = 0;
674 void manager_free(Manager *m) {
680 manager_clear_jobs_and_units(m);
682 for (c = 0; c < _UNIT_TYPE_MAX; c++)
683 if (unit_vtable[c]->shutdown)
684 unit_vtable[c]->shutdown(m);
686 /* If we reexecute ourselves, we keep the root cgroup
688 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
690 manager_undo_generators(m);
694 hashmap_free(m->units);
695 hashmap_free(m->jobs);
696 hashmap_free(m->watch_pids);
697 hashmap_free(m->watch_bus);
699 if (m->epoll_fd >= 0)
700 close_nointr_nofail(m->epoll_fd);
701 if (m->signal_watch.fd >= 0)
702 close_nointr_nofail(m->signal_watch.fd);
703 if (m->notify_watch.fd >= 0)
704 close_nointr_nofail(m->notify_watch.fd);
705 if (m->time_change_watch.fd >= 0)
706 close_nointr_nofail(m->time_change_watch.fd);
707 if (m->jobs_in_progress_watch.fd >= 0)
708 close_nointr_nofail(m->jobs_in_progress_watch.fd);
710 free(m->notify_socket);
712 lookup_paths_free(&m->lookup_paths);
713 strv_free(m->environment);
715 strv_free(m->default_controllers);
717 hashmap_free(m->cgroup_bondings);
718 set_free_free(m->unit_path_cache);
720 close_pipe(m->idle_pipe);
722 free(m->switch_root);
723 free(m->switch_root_init);
725 for (i = 0; i < RLIMIT_NLIMITS; i++)
731 int manager_enumerate(Manager *m) {
737 /* Let's ask every type to load all units from disk/kernel
738 * that it might know */
739 for (c = 0; c < _UNIT_TYPE_MAX; c++)
740 if (unit_vtable[c]->enumerate)
741 if ((q = unit_vtable[c]->enumerate(m)) < 0)
744 manager_dispatch_load_queue(m);
748 int manager_coldplug(Manager *m) {
756 /* Then, let's set up their initial state. */
757 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
763 if ((q = unit_coldplug(u)) < 0)
770 static void manager_build_unit_path_cache(Manager *m) {
772 _cleanup_free_ DIR *d = NULL;
777 set_free_free(m->unit_path_cache);
779 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
780 if (!m->unit_path_cache) {
781 log_error("Failed to allocate unit path cache.");
785 /* This simply builds a list of files we know exist, so that
786 * we don't always have to go to disk */
788 STRV_FOREACH(i, m->lookup_paths.unit_path) {
794 log_error("Failed to open directory %s: %m", *i);
798 while ((de = readdir(d))) {
801 if (ignore_file(de->d_name))
804 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
810 r = set_consume(m->unit_path_cache, p);
822 log_error("Failed to build unit path cache: %s", strerror(-r));
824 set_free_free(m->unit_path_cache);
825 m->unit_path_cache = NULL;
828 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
833 dual_timestamp_get(&m->generators_start_timestamp);
834 manager_run_generators(m);
835 dual_timestamp_get(&m->generators_finish_timestamp);
837 r = lookup_paths_init(
838 &m->lookup_paths, m->running_as, true,
839 m->generator_unit_path,
840 m->generator_unit_path_early,
841 m->generator_unit_path_late);
845 manager_build_unit_path_cache(m);
847 /* If we will deserialize make sure that during enumeration
848 * this is already known, so we increase the counter here
853 /* First, enumerate what we can from all config files */
854 dual_timestamp_get(&m->unitsload_start_timestamp);
855 r = manager_enumerate(m);
856 dual_timestamp_get(&m->unitsload_finish_timestamp);
858 /* Second, deserialize if there is something to deserialize */
860 q = manager_deserialize(m, serialization, fds);
865 /* Any fds left? Find some unit which wants them. This is
866 * useful to allow container managers to pass some file
867 * descriptors to us pre-initialized. This enables
868 * socket-based activation of entire containers. */
869 if (fdset_size(fds) > 0) {
870 q = manager_distribute_fds(m, fds);
875 /* Third, fire things up! */
876 q = manager_coldplug(m);
881 assert(m->n_reloading > 0);
888 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
893 assert(type < _JOB_TYPE_MAX);
895 assert(mode < _JOB_MODE_MAX);
897 if (mode == JOB_ISOLATE && type != JOB_START) {
898 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
902 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
903 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
907 log_debug_unit(unit->id,
908 "Trying to enqueue job %s/%s/%s", unit->id,
909 job_type_to_string(type), job_mode_to_string(mode));
911 job_type_collapse(&type, unit);
913 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
917 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
918 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
919 mode == JOB_IGNORE_DEPENDENCIES, e);
923 if (mode == JOB_ISOLATE) {
924 r = transaction_add_isolate_jobs(tr, m);
929 r = transaction_activate(tr, m, mode, e);
933 log_debug_unit(unit->id,
934 "Enqueued job %s/%s as %u", unit->id,
935 job_type_to_string(type), (unsigned) tr->anchor_job->id);
938 *_ret = tr->anchor_job;
940 transaction_free(tr);
944 transaction_abort(tr);
945 transaction_free(tr);
949 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
954 assert(type < _JOB_TYPE_MAX);
956 assert(mode < _JOB_MODE_MAX);
958 r = manager_load_unit(m, name, NULL, NULL, &unit);
962 return manager_add_job(m, type, unit, mode, override, e, _ret);
965 Job *manager_get_job(Manager *m, uint32_t id) {
968 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
971 Unit *manager_get_unit(Manager *m, const char *name) {
975 return hashmap_get(m->units, name);
978 unsigned manager_dispatch_load_queue(Manager *m) {
984 /* Make sure we are not run recursively */
985 if (m->dispatching_load_queue)
988 m->dispatching_load_queue = true;
990 /* Dispatches the load queue. Takes a unit from the queue and
991 * tries to load its data until the queue is empty */
993 while ((u = m->load_queue)) {
994 assert(u->in_load_queue);
1000 m->dispatching_load_queue = false;
1004 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1010 assert(name || path);
1012 /* This will prepare the unit for loading, but not actually
1013 * load anything from disk. */
1015 if (path && !is_path(path)) {
1016 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1021 name = path_get_file_name(path);
1023 t = unit_name_to_type(name);
1025 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
1026 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1030 ret = manager_get_unit(m, name);
1036 ret = unit_new(m, unit_vtable[t]->object_size);
1041 ret->fragment_path = strdup(path);
1042 if (!ret->fragment_path) {
1048 r = unit_add_name(ret, name);
1054 unit_add_to_load_queue(ret);
1055 unit_add_to_dbus_queue(ret);
1056 unit_add_to_gc_queue(ret);
1064 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1069 /* This will load the service information files, but not actually
1070 * start any services or anything. */
1072 r = manager_load_unit_prepare(m, name, path, e, _ret);
1076 manager_dispatch_load_queue(m);
1079 *_ret = unit_follow_merge(*_ret);
1084 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1091 HASHMAP_FOREACH(j, s->jobs, i)
1092 job_dump(j, f, prefix);
1095 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1103 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1105 unit_dump(u, f, prefix);
1108 void manager_clear_jobs(Manager *m) {
1113 while ((j = hashmap_first(m->jobs)))
1114 /* No need to recurse. We're cancelling all jobs. */
1115 job_finish_and_invalidate(j, JOB_CANCELED, false);
1118 unsigned manager_dispatch_run_queue(Manager *m) {
1122 if (m->dispatching_run_queue)
1125 m->dispatching_run_queue = true;
1127 while ((j = m->run_queue)) {
1128 assert(j->installed);
1129 assert(j->in_run_queue);
1131 job_run_and_invalidate(j);
1135 m->dispatching_run_queue = false;
1137 if (m->n_running_jobs > 0)
1138 manager_watch_jobs_in_progress(m);
1143 unsigned manager_dispatch_dbus_queue(Manager *m) {
1150 if (m->dispatching_dbus_queue)
1153 m->dispatching_dbus_queue = true;
1155 while ((u = m->dbus_unit_queue)) {
1156 assert(u->in_dbus_queue);
1158 bus_unit_send_change_signal(u);
1162 while ((j = m->dbus_job_queue)) {
1163 assert(j->in_dbus_queue);
1165 bus_job_send_change_signal(j);
1169 m->dispatching_dbus_queue = false;
1173 static int manager_process_notify_fd(Manager *m) {
1180 struct iovec iovec = {
1182 .iov_len = sizeof(buf)-1,
1186 struct cmsghdr cmsghdr;
1187 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1190 struct msghdr msghdr = {
1193 .msg_control = &control,
1194 .msg_controllen = sizeof(control),
1196 struct ucred *ucred;
1198 _cleanup_strv_free_ char **tags = NULL;
1200 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1205 if (errno == EAGAIN || errno == EINTR)
1211 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1212 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1213 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1214 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1215 log_warning("Received notify message without credentials. Ignoring.");
1219 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1221 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1223 u = cgroup_unit_by_pid(m, ucred->pid);
1225 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1230 assert((size_t) n < sizeof(buf));
1232 tags = strv_split(buf, "\n\r");
1236 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1238 if (UNIT_VTABLE(u)->notify_message)
1239 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1245 static int manager_dispatch_sigchld(Manager *m) {
1253 /* First we call waitd() for a PID and do not reap the
1254 * zombie. That way we can still access /proc/$PID for
1255 * it while it is a zombie. */
1256 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1258 if (errno == ECHILD)
1270 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1271 _cleanup_free_ char *name = NULL;
1273 get_process_comm(si.si_pid, &name);
1274 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1277 /* Let's flush any message the dying child might still
1278 * have queued for us. This ensures that the process
1279 * still exists in /proc so that we can figure out
1280 * which cgroup and hence unit it belongs to. */
1281 r = manager_process_notify_fd(m);
1285 /* And now figure out the unit this belongs to */
1286 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1288 u = cgroup_unit_by_pid(m, si.si_pid);
1290 /* And now, we actually reap the zombie. */
1291 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1298 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1301 log_debug("Child %lu died (code=%s, status=%i/%s)",
1302 (long unsigned) si.si_pid,
1303 sigchld_code_to_string(si.si_code),
1305 strna(si.si_code == CLD_EXITED
1306 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1307 : signal_to_string(si.si_status)));
1312 log_debug_unit(u->id,
1313 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1315 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1316 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1322 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1326 dbus_error_init(&error);
1328 log_debug_unit(name, "Activating special unit %s", name);
1330 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1332 log_error_unit(name,
1333 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1335 dbus_error_free(&error);
1340 static int manager_process_signal_fd(Manager *m) {
1342 struct signalfd_siginfo sfsi;
1343 bool sigchld = false;
1348 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1349 if (n != sizeof(sfsi)) {
1354 if (errno == EINTR || errno == EAGAIN)
1360 if (sfsi.ssi_pid > 0) {
1363 get_process_comm(sfsi.ssi_pid, &p);
1365 log_debug("Received SIG%s from PID %lu (%s).",
1366 signal_to_string(sfsi.ssi_signo),
1367 (unsigned long) sfsi.ssi_pid, strna(p));
1370 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1372 switch (sfsi.ssi_signo) {
1379 if (m->running_as == SYSTEMD_SYSTEM) {
1380 /* This is for compatibility with the
1381 * original sysvinit */
1382 m->exit_code = MANAGER_REEXECUTE;
1389 if (m->running_as == SYSTEMD_SYSTEM) {
1390 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1394 /* Run the exit target if there is one, if not, just exit. */
1395 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1396 m->exit_code = MANAGER_EXIT;
1403 if (m->running_as == SYSTEMD_SYSTEM)
1404 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1406 /* This is a nop on non-init */
1410 if (m->running_as == SYSTEMD_SYSTEM)
1411 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1413 /* This is a nop on non-init */
1419 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1421 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1422 log_info("Trying to reconnect to bus...");
1426 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1427 log_info("Loading D-Bus service...");
1428 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1439 if (!(f = open_memstream(&dump, &size))) {
1440 log_warning("Failed to allocate memory stream.");
1444 manager_dump_units(m, f, "\t");
1445 manager_dump_jobs(m, f, "\t");
1450 log_warning("Failed to write status stream");
1455 log_dump(LOG_INFO, dump);
1462 m->exit_code = MANAGER_RELOAD;
1467 /* Starting SIGRTMIN+0 */
1468 static const char * const target_table[] = {
1469 [0] = SPECIAL_DEFAULT_TARGET,
1470 [1] = SPECIAL_RESCUE_TARGET,
1471 [2] = SPECIAL_EMERGENCY_TARGET,
1472 [3] = SPECIAL_HALT_TARGET,
1473 [4] = SPECIAL_POWEROFF_TARGET,
1474 [5] = SPECIAL_REBOOT_TARGET,
1475 [6] = SPECIAL_KEXEC_TARGET
1478 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1479 static const ManagerExitCode code_table[] = {
1481 [1] = MANAGER_POWEROFF,
1482 [2] = MANAGER_REBOOT,
1486 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1487 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1488 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1489 manager_start_target(m, target_table[idx],
1490 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1494 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1495 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1496 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1500 switch (sfsi.ssi_signo - SIGRTMIN) {
1503 log_debug("Enabling showing of status.");
1504 manager_set_show_status(m, true);
1508 log_debug("Disabling showing of status.");
1509 manager_set_show_status(m, false);
1513 log_set_max_level(LOG_DEBUG);
1514 log_notice("Setting log level to debug.");
1518 log_set_max_level(LOG_INFO);
1519 log_notice("Setting log level to info.");
1523 if (m->running_as == SYSTEMD_USER) {
1524 m->exit_code = MANAGER_EXIT;
1528 /* This is a nop on init */
1532 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1533 log_notice("Setting log target to journal-or-kmsg.");
1537 log_set_target(LOG_TARGET_CONSOLE);
1538 log_notice("Setting log target to console.");
1542 log_set_target(LOG_TARGET_KMSG);
1543 log_notice("Setting log target to kmsg.");
1547 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1548 log_notice("Setting log target to syslog-or-kmsg.");
1552 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1559 return manager_dispatch_sigchld(m);
1564 static int process_event(Manager *m, struct epoll_event *ev) {
1571 assert_se(w = ev->data.ptr);
1573 if (w->type == WATCH_INVALID)
1580 /* An incoming signal? */
1581 if (ev->events != EPOLLIN)
1584 if ((r = manager_process_signal_fd(m)) < 0)
1591 /* An incoming daemon notification event? */
1592 if (ev->events != EPOLLIN)
1595 if ((r = manager_process_notify_fd(m)) < 0)
1602 /* Some fd event, to be dispatched to the units */
1603 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1606 case WATCH_UNIT_TIMER:
1607 case WATCH_JOB_TIMER: {
1611 /* Some timer event, to be dispatched to the units */
1612 k = read(w->fd, &v, sizeof(v));
1613 if (k != sizeof(v)) {
1615 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1618 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1619 return k < 0 ? -errno : -EIO;
1622 if (w->type == WATCH_UNIT_TIMER)
1623 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1625 job_timer_event(w->data.job, v, w);
1630 /* Some mount table change, intended for the mount subsystem */
1631 mount_fd_event(m, ev->events);
1635 /* Some swap table change, intended for the swap subsystem */
1636 swap_fd_event(m, ev->events);
1640 /* Some notification from udev, intended for the device subsystem */
1641 device_fd_event(m, ev->events);
1644 case WATCH_DBUS_WATCH:
1645 bus_watch_event(m, w, ev->events);
1648 case WATCH_DBUS_TIMEOUT:
1649 bus_timeout_event(m, w, ev->events);
1652 case WATCH_TIME_CHANGE: {
1656 log_struct(LOG_INFO,
1657 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1658 "MESSAGE=Time has been changed",
1661 /* Restart the watch */
1662 epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->time_change_watch.fd,
1664 close_nointr_nofail(m->time_change_watch.fd);
1665 watch_init(&m->time_change_watch);
1666 manager_setup_time_change(m);
1668 HASHMAP_FOREACH(u, m->units, i) {
1669 if (UNIT_VTABLE(u)->time_change)
1670 UNIT_VTABLE(u)->time_change(u);
1676 case WATCH_JOBS_IN_PROGRESS: {
1679 /* not interested in the data */
1680 read(w->fd, &v, sizeof(v));
1682 manager_print_jobs_in_progress(m);
1687 log_error("event type=%i", w->type);
1688 assert_not_reached("Unknown epoll event type.");
1694 int manager_loop(Manager *m) {
1697 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1700 m->exit_code = MANAGER_RUNNING;
1702 /* Release the path cache */
1703 set_free_free(m->unit_path_cache);
1704 m->unit_path_cache = NULL;
1706 manager_check_finished(m);
1708 /* There might still be some zombies hanging around from
1709 * before we were exec()'ed. Leat's reap them */
1710 r = manager_dispatch_sigchld(m);
1714 while (m->exit_code == MANAGER_RUNNING) {
1715 struct epoll_event event;
1719 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1722 if (!ratelimit_test(&rl)) {
1723 /* Yay, something is going seriously wrong, pause a little */
1724 log_warning("Looping too fast. Throttling execution a little.");
1729 if (manager_dispatch_load_queue(m) > 0)
1732 if (manager_dispatch_run_queue(m) > 0)
1735 if (bus_dispatch(m) > 0)
1738 if (manager_dispatch_cleanup_queue(m) > 0)
1741 if (manager_dispatch_gc_queue(m) > 0)
1744 if (manager_dispatch_dbus_queue(m) > 0)
1747 if (swap_dispatch_reload(m) > 0)
1750 /* Sleep for half the watchdog time */
1751 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1752 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1758 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1770 r = process_event(m, &event);
1775 return m->exit_code;
1778 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1787 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1790 n = bus_path_unescape(s+31);
1794 r = manager_load_unit(m, n, NULL, e, &u);
1805 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1814 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1817 r = safe_atou(s + 30, &id);
1821 j = manager_get_job(m, id);
1830 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1836 audit_fd = get_audit_fd();
1840 /* Don't generate audit events if the service was already
1841 * started and we're just deserializing */
1842 if (m->n_reloading > 0)
1845 if (m->running_as != SYSTEMD_SYSTEM)
1848 if (u->type != UNIT_SERVICE)
1851 p = unit_name_to_prefix_and_instance(u->id);
1853 log_error_unit(u->id,
1854 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1858 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1859 if (errno == EPERM) {
1860 /* We aren't allowed to send audit messages?
1861 * Then let's not retry again. */
1864 log_warning("Failed to send audit message: %m");
1872 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1874 union sockaddr_union sa;
1876 char *message = NULL;
1878 /* Don't generate plymouth events if the service was already
1879 * started and we're just deserializing */
1880 if (m->n_reloading > 0)
1883 if (m->running_as != SYSTEMD_SYSTEM)
1886 if (u->type != UNIT_SERVICE &&
1887 u->type != UNIT_MOUNT &&
1888 u->type != UNIT_SWAP)
1891 /* We set SOCK_NONBLOCK here so that we rather drop the
1892 * message then wait for plymouth */
1893 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1895 log_error("socket() failed: %m");
1900 sa.sa.sa_family = AF_UNIX;
1901 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1902 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1904 if (errno != EPIPE &&
1907 errno != ECONNREFUSED &&
1908 errno != ECONNRESET &&
1909 errno != ECONNABORTED)
1910 log_error("connect() failed: %m");
1915 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1921 if (write(fd, message, n + 1) != n + 1) {
1923 if (errno != EPIPE &&
1926 errno != ECONNREFUSED &&
1927 errno != ECONNRESET &&
1928 errno != ECONNABORTED)
1929 log_error("Failed to write Plymouth message: %m");
1936 close_nointr_nofail(fd);
1941 void manager_dispatch_bus_name_owner_changed(
1944 const char* old_owner,
1945 const char *new_owner) {
1952 if (!(u = hashmap_get(m->watch_bus, name)))
1955 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1958 void manager_dispatch_bus_query_pid_done(
1969 if (!(u = hashmap_get(m->watch_bus, name)))
1972 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1975 int manager_open_serialization(Manager *m, FILE **_f) {
1982 if (m->running_as == SYSTEMD_SYSTEM)
1983 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1985 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1990 RUN_WITH_UMASK(0077) {
1991 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2001 log_debug("Serializing state to %s", path);
2004 f = fdopen(fd, "w+");
2013 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2026 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2027 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2028 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2029 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2031 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2032 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2033 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2034 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2037 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2038 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2041 if (!switching_root) {
2042 STRV_FOREACH(e, m->environment) {
2043 _cleanup_free_ char *ce;
2047 fprintf(f, "env=%s\n", *e);
2053 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2057 if (!unit_can_serialize(u))
2064 if ((r = unit_serialize(u, f, fds, !switching_root)) < 0) {
2070 assert(m->n_reloading > 0);
2076 r = bus_fdset_add_all(m, fds);
2083 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2089 log_debug("Deserializing state...");
2094 char line[LINE_MAX], *l;
2096 if (!fgets(line, sizeof(line), f)) {
2111 if (startswith(l, "current-job-id=")) {
2114 if (safe_atou32(l+15, &id) < 0)
2115 log_debug("Failed to parse current job id value %s", l+15);
2117 m->current_job_id = MAX(m->current_job_id, id);
2118 } else if (startswith(l, "n-installed-jobs=")) {
2121 if (safe_atou32(l+17, &n) < 0)
2122 log_debug("Failed to parse installed jobs counter %s", l+17);
2124 m->n_installed_jobs += n;
2125 } else if (startswith(l, "n-failed-jobs=")) {
2128 if (safe_atou32(l+14, &n) < 0)
2129 log_debug("Failed to parse failed jobs counter %s", l+14);
2131 m->n_failed_jobs += n;
2132 } else if (startswith(l, "taint-usr=")) {
2135 if ((b = parse_boolean(l+10)) < 0)
2136 log_debug("Failed to parse taint /usr flag %s", l+10);
2138 m->taint_usr = m->taint_usr || b;
2139 } else if (startswith(l, "firmware-timestamp="))
2140 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2141 else if (startswith(l, "loader-timestamp="))
2142 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2143 else if (startswith(l, "kernel-timestamp="))
2144 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2145 else if (startswith(l, "initrd-timestamp="))
2146 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2147 else if (startswith(l, "userspace-timestamp="))
2148 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2149 else if (startswith(l, "finish-timestamp="))
2150 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2151 else if (startswith(l, "env=")) {
2152 _cleanup_free_ char *uce = NULL;
2155 uce = cunescape(l+4);
2161 e = strv_env_set(m->environment, uce);
2167 strv_free(m->environment);
2170 log_debug("Unknown serialization item '%s'", l);
2175 char name[UNIT_NAME_MAX+2];
2178 if (!fgets(name, sizeof(name), f)) {
2189 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2193 r = unit_deserialize(u, f, fds);
2204 assert(m->n_reloading > 0);
2210 int manager_distribute_fds(Manager *m, FDSet *fds) {
2217 HASHMAP_FOREACH(u, m->units, i) {
2219 if (fdset_size(fds) <= 0)
2222 if (UNIT_VTABLE(u)->distribute_fds) {
2223 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2232 int manager_reload(Manager *m) {
2239 r = manager_open_serialization(m, &f);
2252 r = manager_serialize(m, f, fds, false);
2258 if (fseeko(f, 0, SEEK_SET) < 0) {
2264 /* From here on there is no way back. */
2265 manager_clear_jobs_and_units(m);
2266 manager_undo_generators(m);
2267 lookup_paths_free(&m->lookup_paths);
2269 /* Find new unit paths */
2270 manager_run_generators(m);
2272 q = lookup_paths_init(
2273 &m->lookup_paths, m->running_as, true,
2274 m->generator_unit_path,
2275 m->generator_unit_path_early,
2276 m->generator_unit_path_late);
2280 manager_build_unit_path_cache(m);
2282 /* First, enumerate what we can from all config files */
2283 q = manager_enumerate(m);
2287 /* Second, deserialize our stored data */
2288 q = manager_deserialize(m, f, fds);
2295 /* Third, fire things up! */
2296 q = manager_coldplug(m);
2300 assert(m->n_reloading > 0);
2313 static bool manager_is_booting_or_shutting_down(Manager *m) {
2318 /* Is the initial job still around? */
2319 if (manager_get_job(m, m->default_unit_job_id))
2322 /* Is there a job for the shutdown target? */
2323 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2330 bool manager_is_reloading_or_reexecuting(Manager *m) {
2333 return m->n_reloading != 0;
2336 void manager_reset_failed(Manager *m) {
2342 HASHMAP_FOREACH(u, m->units, i)
2343 unit_reset_failed(u);
2346 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2352 /* Returns true if the unit is inactive or going down */
2353 u = manager_get_unit(m, name);
2357 return unit_inactive_or_pending(u);
2360 void manager_check_finished(Manager *m) {
2361 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2362 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2366 if (m->n_running_jobs == 0)
2367 manager_unwatch_jobs_in_progress(m);
2369 if (hashmap_size(m->jobs) > 0) {
2370 manager_jobs_in_progress_mod_timer(m);
2374 /* Notify Type=idle units that we are done now */
2375 close_pipe(m->idle_pipe);
2377 /* Turn off confirm spawn now */
2378 m->confirm_spawn = false;
2380 if (dual_timestamp_is_set(&m->finish_timestamp))
2383 dual_timestamp_get(&m->finish_timestamp);
2385 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2387 /* Note that m->kernel_usec.monotonic is always at 0,
2388 * and m->firmware_usec.monotonic and
2389 * m->loader_usec.monotonic should be considered
2390 * negative values. */
2392 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2393 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2394 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2395 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2397 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2399 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2400 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2402 if (!log_on_console())
2403 log_struct(LOG_INFO,
2404 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2405 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2406 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2407 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2408 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2409 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2410 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2411 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2412 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2415 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2418 if (!log_on_console())
2419 log_struct(LOG_INFO,
2420 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2421 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2422 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2423 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2424 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2425 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2426 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2430 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2431 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2433 if (!log_on_console())
2434 log_struct(LOG_INFO,
2435 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2436 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2437 "MESSAGE=Startup finished in %s.",
2438 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2442 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2445 "READY=1\nSTATUS=Startup finished in %s.",
2446 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2449 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2460 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2462 p = strappend("/run/systemd/", name);
2466 r = mkdir_p_label(p, 0755);
2468 log_error("Failed to create generator directory %s: %s",
2474 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2479 log_error("Failed to create generator directory %s: %m",
2490 static void trim_generator_dir(Manager *m, char **generator) {
2497 if (rmdir(*generator) >= 0) {
2505 void manager_run_generators(Manager *m) {
2507 const char *generator_path;
2508 const char *argv[5];
2513 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2514 d = opendir(generator_path);
2516 if (errno == ENOENT)
2519 log_error("Failed to enumerate generator directory %s: %m",
2524 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2528 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2532 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2536 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2537 argv[1] = m->generator_unit_path;
2538 argv[2] = m->generator_unit_path_early;
2539 argv[3] = m->generator_unit_path_late;
2542 RUN_WITH_UMASK(0022) {
2543 execute_directory(generator_path, d, (char**) argv);
2546 trim_generator_dir(m, &m->generator_unit_path);
2547 trim_generator_dir(m, &m->generator_unit_path_early);
2548 trim_generator_dir(m, &m->generator_unit_path_late);
2555 static void remove_generator_dir(Manager *m, char **generator) {
2562 strv_remove(m->lookup_paths.unit_path, *generator);
2563 rm_rf(*generator, false, true, false);
2569 void manager_undo_generators(Manager *m) {
2572 remove_generator_dir(m, &m->generator_unit_path);
2573 remove_generator_dir(m, &m->generator_unit_path_early);
2574 remove_generator_dir(m, &m->generator_unit_path_late);
2577 int manager_set_default_environment(Manager *m, char **environment) {
2581 e = strv_env_merge(2, m->environment, environment);
2584 strv_free(m->environment);
2589 int manager_set_default_controllers(Manager *m, char **controllers) {
2594 l = strv_copy(controllers);
2598 strv_free(m->default_controllers);
2599 m->default_controllers = l;
2601 cg_shorten_controllers(m->default_controllers);
2606 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2611 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2612 if (!default_rlimit[i])
2615 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2623 void manager_recheck_journal(Manager *m) {
2628 if (m->running_as != SYSTEMD_SYSTEM)
2631 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2632 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2633 log_close_journal();
2637 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2638 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2639 log_close_journal();
2643 /* Hmm, OK, so the socket is fully up and the service is up
2644 * too, then let's make use of the thing. */
2648 void manager_set_show_status(Manager *m, bool b) {
2651 if (m->running_as != SYSTEMD_SYSTEM)
2657 touch("/run/systemd/show-status");
2659 unlink("/run/systemd/show-status");
2662 static bool manager_get_show_status(Manager *m) {
2665 if (m->running_as != SYSTEMD_SYSTEM)
2671 /* If Plymouth is running make sure we show the status, so
2672 * that there's something nice to see when people press Esc */
2674 return plymouth_running();
2677 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2680 if (!manager_get_show_status(m))
2683 /* XXX We should totally drop the check for ephemeral here
2684 * and thus effectively make 'Type=idle' pointless. */
2685 if (ephemeral && m->n_on_console > 0)
2688 if (!manager_is_booting_or_shutting_down(m))
2691 va_start(ap, format);
2692 status_vprintf(status, true, ephemeral, format, ap);
2696 void watch_init(Watch *w) {
2699 w->type = WATCH_INVALID;