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;
153 its.it_value.tv_sec = JOBS_IN_PROGRESS_WAIT_SEC;
154 its.it_interval.tv_sec = JOBS_IN_PROGRESS_PERIOD_SEC;
156 if (timerfd_settime(m->jobs_in_progress_watch.fd, 0, &its, NULL) < 0)
162 static int manager_watch_jobs_in_progress(Manager *m) {
163 struct epoll_event ev;
168 if (m->jobs_in_progress_watch.type != WATCH_INVALID)
171 m->jobs_in_progress_watch.type = WATCH_JOBS_IN_PROGRESS;
172 m->jobs_in_progress_watch.fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
173 if (m->jobs_in_progress_watch.fd < 0) {
174 log_error("Failed to create timerfd: %m");
179 r = manager_jobs_in_progress_mod_timer(m);
181 log_error("Failed to set up timer for jobs progress watch: %s", strerror(-r));
187 ev.data.ptr = &m->jobs_in_progress_watch;
189 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->jobs_in_progress_watch.fd, &ev) < 0) {
190 log_error("Failed to add jobs progress timer fd to epoll: %m");
195 log_debug("Set up jobs progress timerfd.");
200 if (m->jobs_in_progress_watch.fd >= 0)
201 close_nointr_nofail(m->jobs_in_progress_watch.fd);
202 watch_init(&m->jobs_in_progress_watch);
206 static void manager_unwatch_jobs_in_progress(Manager *m) {
207 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
210 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->jobs_in_progress_watch.fd, NULL) >= 0);
211 close_nointr_nofail(m->jobs_in_progress_watch.fd);
212 watch_init(&m->jobs_in_progress_watch);
213 m->jobs_in_progress_iteration = 0;
215 log_debug("Closed jobs progress timerfd.");
218 #define CYLON_BUFFER_EXTRA (2*strlen(ANSI_RED_ON) + strlen(ANSI_HIGHLIGHT_RED_ON) + 2*strlen(ANSI_HIGHLIGHT_OFF))
219 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
222 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
223 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
227 memset(p, ' ', pos-2);
230 memcpy(p, ANSI_RED_ON, strlen(ANSI_RED_ON));
231 p += strlen(ANSI_RED_ON);
235 if (pos > 0 && pos <= width) {
236 memcpy(p, ANSI_HIGHLIGHT_RED_ON, strlen(ANSI_HIGHLIGHT_RED_ON));
237 p += strlen(ANSI_HIGHLIGHT_RED_ON);
241 memcpy(p, ANSI_HIGHLIGHT_OFF, strlen(ANSI_HIGHLIGHT_OFF));
242 p += strlen(ANSI_HIGHLIGHT_OFF);
245 memcpy(p, ANSI_RED_ON, strlen(ANSI_RED_ON));
246 p += strlen(ANSI_RED_ON);
249 memset(p, ' ', width-1-pos);
252 memcpy(p, ANSI_HIGHLIGHT_OFF, strlen(ANSI_HIGHLIGHT_OFF));
253 p += strlen(ANSI_HIGHLIGHT_OFF);
258 static void manager_print_jobs_in_progress(Manager *m) {
261 char *job_of_n = NULL;
262 unsigned counter = 0, print_nr;
263 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
266 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
268 HASHMAP_FOREACH(j, m->jobs, i)
269 if (j->state == JOB_RUNNING && counter++ == print_nr)
275 cylon_pos = m->jobs_in_progress_iteration % 14;
277 cylon_pos = 14 - cylon_pos;
278 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
280 if (m->n_running_jobs > 1)
281 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
284 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
285 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
288 m->jobs_in_progress_iteration++;
291 static int manager_setup_time_change(Manager *m) {
292 struct epoll_event ev;
293 struct itimerspec its;
296 assert(m->time_change_watch.type == WATCH_INVALID);
298 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
299 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
301 m->time_change_watch.type = WATCH_TIME_CHANGE;
302 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
303 if (m->time_change_watch.fd < 0) {
304 log_error("Failed to create timerfd: %m");
310 /* We only care for the cancellation event, hence we set the
311 * timeout to the latest possible value. */
312 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
313 its.it_value.tv_sec = TIME_T_MAX;
315 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
316 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
317 close_nointr_nofail(m->time_change_watch.fd);
318 watch_init(&m->time_change_watch);
324 ev.data.ptr = &m->time_change_watch;
326 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
327 log_error("Failed to add timer change fd to epoll: %m");
331 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
336 static int enable_special_signals(Manager *m) {
341 /* Enable that we get SIGINT on control-alt-del. In containers
342 * this will fail with EPERM (older) or EINVAL (newer), so
344 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
345 log_warning("Failed to enable ctrl-alt-del handling: %m");
347 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
349 /* Support systems without virtual console */
351 log_warning("Failed to open /dev/tty0: %m");
353 /* Enable that we get SIGWINCH on kbrequest */
354 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
355 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
357 close_nointr_nofail(fd);
363 static int manager_setup_signals(Manager *m) {
365 struct epoll_event ev;
370 /* We are not interested in SIGSTOP and friends. */
372 sa.sa_handler = SIG_DFL;
373 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
374 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
376 assert_se(sigemptyset(&mask) == 0);
378 sigset_add_many(&mask,
379 SIGCHLD, /* Child died */
380 SIGTERM, /* Reexecute daemon */
381 SIGHUP, /* Reload configuration */
382 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
383 SIGUSR2, /* systemd: dump status */
384 SIGINT, /* Kernel sends us this on control-alt-del */
385 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
386 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
387 SIGRTMIN+0, /* systemd: start default.target */
388 SIGRTMIN+1, /* systemd: isolate rescue.target */
389 SIGRTMIN+2, /* systemd: isolate emergency.target */
390 SIGRTMIN+3, /* systemd: start halt.target */
391 SIGRTMIN+4, /* systemd: start poweroff.target */
392 SIGRTMIN+5, /* systemd: start reboot.target */
393 SIGRTMIN+6, /* systemd: start kexec.target */
394 SIGRTMIN+13, /* systemd: Immediate halt */
395 SIGRTMIN+14, /* systemd: Immediate poweroff */
396 SIGRTMIN+15, /* systemd: Immediate reboot */
397 SIGRTMIN+16, /* systemd: Immediate kexec */
398 SIGRTMIN+20, /* systemd: enable status messages */
399 SIGRTMIN+21, /* systemd: disable status messages */
400 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
401 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
402 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
403 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
404 SIGRTMIN+27, /* systemd: set log target to console */
405 SIGRTMIN+28, /* systemd: set log target to kmsg */
406 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
408 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
410 m->signal_watch.type = WATCH_SIGNAL;
411 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
412 if (m->signal_watch.fd < 0)
417 ev.data.ptr = &m->signal_watch;
419 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
422 if (m->running_as == SYSTEMD_SYSTEM)
423 return enable_special_signals(m);
428 static void manager_strip_environment(Manager *m) {
431 /* Remove variables from the inherited set that are part of
432 * the container interface:
433 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
434 strv_remove_prefix(m->environment, "container=");
435 strv_remove_prefix(m->environment, "container_");
437 /* Remove variables from the inherited set that are part of
438 * the initrd interface:
439 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
440 strv_remove_prefix(m->environment, "RD_");
442 /* Drop invalid entries */
443 strv_env_clean(m->environment);
446 int manager_new(SystemdRunningAs running_as, Manager **_m) {
451 assert(running_as >= 0);
452 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
454 m = new0(Manager, 1);
458 dual_timestamp_get(&m->userspace_timestamp);
459 dual_timestamp_from_monotonic(&m->kernel_timestamp, 0);
461 efi_get_boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
464 m->running_as = running_as;
465 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
466 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
467 m->pin_cgroupfs_fd = -1;
468 m->idle_pipe[0] = m->idle_pipe[1] = -1;
470 watch_init(&m->signal_watch);
471 watch_init(&m->mount_watch);
472 watch_init(&m->swap_watch);
473 watch_init(&m->udev_watch);
474 watch_init(&m->time_change_watch);
475 watch_init(&m->jobs_in_progress_watch);
477 m->epoll_fd = m->dev_autofs_fd = -1;
478 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
480 m->environment = strv_copy(environ);
484 manager_strip_environment(m);
486 if (running_as == SYSTEMD_SYSTEM) {
487 m->default_controllers = strv_new("cpu", NULL);
488 if (!m->default_controllers)
492 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
495 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
498 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
501 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
504 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
507 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
511 r = manager_setup_signals(m);
515 r = manager_setup_cgroup(m);
519 r = manager_setup_notify(m);
523 r = manager_setup_time_change(m);
527 /* Try to connect to the busses, if possible. */
528 r = bus_init(m, running_as != SYSTEMD_SYSTEM);
532 m->taint_usr = dir_is_empty("/usr") > 0;
542 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
548 while ((u = m->cleanup_queue)) {
549 assert(u->in_cleanup_queue);
559 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
560 GC_OFFSET_UNSURE, /* No clue */
561 GC_OFFSET_GOOD, /* We still need this unit */
562 GC_OFFSET_BAD, /* We don't need this unit anymore */
566 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
573 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
574 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
575 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
578 if (u->in_cleanup_queue)
581 if (unit_check_gc(u))
584 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
588 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
589 unit_gc_sweep(other, gc_marker);
591 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
594 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
601 /* We were unable to find anything out about this entry, so
602 * let's investigate it later */
603 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
604 unit_add_to_gc_queue(u);
608 /* We definitely know that this one is not useful anymore, so
609 * let's mark it for deletion */
610 u->gc_marker = gc_marker + GC_OFFSET_BAD;
611 unit_add_to_cleanup_queue(u);
615 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
618 static unsigned manager_dispatch_gc_queue(Manager *m) {
625 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
626 (m->gc_queue_timestamp <= 0 ||
627 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
630 log_debug("Running GC...");
632 m->gc_marker += _GC_OFFSET_MAX;
633 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
636 gc_marker = m->gc_marker;
638 while ((u = m->gc_queue)) {
639 assert(u->in_gc_queue);
641 unit_gc_sweep(u, gc_marker);
643 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
644 u->in_gc_queue = false;
648 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
649 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
650 log_debug_unit(u->id, "Collecting %s", u->id);
651 u->gc_marker = gc_marker + GC_OFFSET_BAD;
652 unit_add_to_cleanup_queue(u);
656 m->n_in_gc_queue = 0;
657 m->gc_queue_timestamp = 0;
662 static void manager_clear_jobs_and_units(Manager *m) {
667 while ((u = hashmap_first(m->units)))
670 manager_dispatch_cleanup_queue(m);
672 assert(!m->load_queue);
673 assert(!m->run_queue);
674 assert(!m->dbus_unit_queue);
675 assert(!m->dbus_job_queue);
676 assert(!m->cleanup_queue);
677 assert(!m->gc_queue);
679 assert(hashmap_isempty(m->jobs));
680 assert(hashmap_isempty(m->units));
683 void manager_free(Manager *m) {
689 manager_clear_jobs_and_units(m);
691 for (c = 0; c < _UNIT_TYPE_MAX; c++)
692 if (unit_vtable[c]->shutdown)
693 unit_vtable[c]->shutdown(m);
695 /* If we reexecute ourselves, we keep the root cgroup
697 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
699 manager_undo_generators(m);
703 hashmap_free(m->units);
704 hashmap_free(m->jobs);
705 hashmap_free(m->watch_pids);
706 hashmap_free(m->watch_bus);
708 if (m->epoll_fd >= 0)
709 close_nointr_nofail(m->epoll_fd);
710 if (m->signal_watch.fd >= 0)
711 close_nointr_nofail(m->signal_watch.fd);
712 if (m->notify_watch.fd >= 0)
713 close_nointr_nofail(m->notify_watch.fd);
714 if (m->time_change_watch.fd >= 0)
715 close_nointr_nofail(m->time_change_watch.fd);
716 if (m->jobs_in_progress_watch.fd >= 0)
717 close_nointr_nofail(m->jobs_in_progress_watch.fd);
719 free(m->notify_socket);
721 lookup_paths_free(&m->lookup_paths);
722 strv_free(m->environment);
724 strv_free(m->default_controllers);
726 hashmap_free(m->cgroup_bondings);
727 set_free_free(m->unit_path_cache);
729 close_pipe(m->idle_pipe);
731 free(m->switch_root);
732 free(m->switch_root_init);
734 for (i = 0; i < RLIMIT_NLIMITS; i++)
740 int manager_enumerate(Manager *m) {
746 /* Let's ask every type to load all units from disk/kernel
747 * that it might know */
748 for (c = 0; c < _UNIT_TYPE_MAX; c++)
749 if (unit_vtable[c]->enumerate)
750 if ((q = unit_vtable[c]->enumerate(m)) < 0)
753 manager_dispatch_load_queue(m);
757 int manager_coldplug(Manager *m) {
765 /* Then, let's set up their initial state. */
766 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
772 if ((q = unit_coldplug(u)) < 0)
779 static void manager_build_unit_path_cache(Manager *m) {
781 DIR _cleanup_free_ *d = NULL;
786 set_free_free(m->unit_path_cache);
788 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
789 if (!m->unit_path_cache) {
790 log_error("Failed to allocate unit path cache.");
794 /* This simply builds a list of files we know exist, so that
795 * we don't always have to go to disk */
797 STRV_FOREACH(i, m->lookup_paths.unit_path) {
803 log_error("Failed to open directory %s: %m", *i);
807 while ((de = readdir(d))) {
810 if (ignore_file(de->d_name))
813 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
819 r = set_put(m->unit_path_cache, p);
833 log_error("Failed to build unit path cache: %s", strerror(-r));
835 set_free_free(m->unit_path_cache);
836 m->unit_path_cache = NULL;
839 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
844 manager_run_generators(m);
846 r = lookup_paths_init(
847 &m->lookup_paths, m->running_as, true,
848 m->generator_unit_path,
849 m->generator_unit_path_early,
850 m->generator_unit_path_late);
854 manager_build_unit_path_cache(m);
856 /* If we will deserialize make sure that during enumeration
857 * this is already known, so we increase the counter here
862 /* First, enumerate what we can from all config files */
863 r = manager_enumerate(m);
865 /* Second, deserialize if there is something to deserialize */
867 q = manager_deserialize(m, serialization, fds);
872 /* Any fds left? Find some unit which wants them. This is
873 * useful to allow container managers to pass some file
874 * descriptors to us pre-initialized. This enables
875 * socket-based activation of entire containers. */
876 if (fdset_size(fds) > 0) {
877 q = manager_distribute_fds(m, fds);
882 /* Third, fire things up! */
883 q = manager_coldplug(m);
888 assert(m->n_reloading > 0);
895 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
900 assert(type < _JOB_TYPE_MAX);
902 assert(mode < _JOB_MODE_MAX);
904 if (mode == JOB_ISOLATE && type != JOB_START) {
905 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
909 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
910 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
914 log_debug_unit(unit->id,
915 "Trying to enqueue job %s/%s/%s", unit->id,
916 job_type_to_string(type), job_mode_to_string(mode));
918 job_type_collapse(&type, unit);
920 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
924 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
925 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
926 mode == JOB_IGNORE_DEPENDENCIES, e);
930 if (mode == JOB_ISOLATE) {
931 r = transaction_add_isolate_jobs(tr, m);
936 r = transaction_activate(tr, m, mode, e);
940 log_debug_unit(unit->id,
941 "Enqueued job %s/%s as %u", unit->id,
942 job_type_to_string(type), (unsigned) tr->anchor_job->id);
945 *_ret = tr->anchor_job;
947 transaction_free(tr);
951 transaction_abort(tr);
952 transaction_free(tr);
956 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
961 assert(type < _JOB_TYPE_MAX);
963 assert(mode < _JOB_MODE_MAX);
965 r = manager_load_unit(m, name, NULL, NULL, &unit);
969 return manager_add_job(m, type, unit, mode, override, e, _ret);
972 Job *manager_get_job(Manager *m, uint32_t id) {
975 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
978 Unit *manager_get_unit(Manager *m, const char *name) {
982 return hashmap_get(m->units, name);
985 unsigned manager_dispatch_load_queue(Manager *m) {
991 /* Make sure we are not run recursively */
992 if (m->dispatching_load_queue)
995 m->dispatching_load_queue = true;
997 /* Dispatches the load queue. Takes a unit from the queue and
998 * tries to load its data until the queue is empty */
1000 while ((u = m->load_queue)) {
1001 assert(u->in_load_queue);
1007 m->dispatching_load_queue = false;
1011 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1017 assert(name || path);
1019 /* This will prepare the unit for loading, but not actually
1020 * load anything from disk. */
1022 if (path && !is_path(path)) {
1023 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1028 name = path_get_file_name(path);
1030 t = unit_name_to_type(name);
1032 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
1033 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1037 ret = manager_get_unit(m, name);
1043 ret = unit_new(m, unit_vtable[t]->object_size);
1048 ret->fragment_path = strdup(path);
1049 if (!ret->fragment_path) {
1055 if ((r = unit_add_name(ret, name)) < 0) {
1060 unit_add_to_load_queue(ret);
1061 unit_add_to_dbus_queue(ret);
1062 unit_add_to_gc_queue(ret);
1070 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1075 /* This will load the service information files, but not actually
1076 * start any services or anything. */
1078 r = manager_load_unit_prepare(m, name, path, e, _ret);
1082 manager_dispatch_load_queue(m);
1085 *_ret = unit_follow_merge(*_ret);
1090 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1097 HASHMAP_FOREACH(j, s->jobs, i)
1098 job_dump(j, f, prefix);
1101 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1109 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1111 unit_dump(u, f, prefix);
1114 void manager_clear_jobs(Manager *m) {
1119 while ((j = hashmap_first(m->jobs)))
1120 /* No need to recurse. We're cancelling all jobs. */
1121 job_finish_and_invalidate(j, JOB_CANCELED, false);
1124 unsigned manager_dispatch_run_queue(Manager *m) {
1128 if (m->dispatching_run_queue)
1131 m->dispatching_run_queue = true;
1133 while ((j = m->run_queue)) {
1134 assert(j->installed);
1135 assert(j->in_run_queue);
1137 job_run_and_invalidate(j);
1141 m->dispatching_run_queue = false;
1143 if (hashmap_size(m->jobs) > 0)
1144 manager_watch_jobs_in_progress(m);
1149 unsigned manager_dispatch_dbus_queue(Manager *m) {
1156 if (m->dispatching_dbus_queue)
1159 m->dispatching_dbus_queue = true;
1161 while ((u = m->dbus_unit_queue)) {
1162 assert(u->in_dbus_queue);
1164 bus_unit_send_change_signal(u);
1168 while ((j = m->dbus_job_queue)) {
1169 assert(j->in_dbus_queue);
1171 bus_job_send_change_signal(j);
1175 m->dispatching_dbus_queue = false;
1179 static int manager_process_notify_fd(Manager *m) {
1186 struct msghdr msghdr;
1188 struct ucred *ucred;
1190 struct cmsghdr cmsghdr;
1191 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1197 iovec.iov_base = buf;
1198 iovec.iov_len = sizeof(buf)-1;
1202 msghdr.msg_iov = &iovec;
1203 msghdr.msg_iovlen = 1;
1204 msghdr.msg_control = &control;
1205 msghdr.msg_controllen = sizeof(control);
1207 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1212 if (errno == EAGAIN || errno == EINTR)
1218 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1219 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1220 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1221 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1222 log_warning("Received notify message without credentials. Ignoring.");
1226 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1228 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1230 u = cgroup_unit_by_pid(m, ucred->pid);
1232 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1237 assert((size_t) n < sizeof(buf));
1239 tags = strv_split(buf, "\n\r");
1243 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1245 if (UNIT_VTABLE(u)->notify_message)
1246 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1254 static int manager_dispatch_sigchld(Manager *m) {
1264 /* First we call waitd() for a PID and do not reap the
1265 * zombie. That way we can still access /proc/$PID for
1266 * it while it is a zombie. */
1267 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1269 if (errno == ECHILD)
1281 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1282 char _cleanup_free_ *name = NULL;
1284 get_process_comm(si.si_pid, &name);
1285 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1288 /* Let's flush any message the dying child might still
1289 * have queued for us. This ensures that the process
1290 * still exists in /proc so that we can figure out
1291 * which cgroup and hence unit it belongs to. */
1292 r = manager_process_notify_fd(m);
1296 /* And now figure out the unit this belongs to */
1297 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1299 u = cgroup_unit_by_pid(m, si.si_pid);
1301 /* And now, we actually reap the zombie. */
1302 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1309 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1312 log_debug("Child %lu died (code=%s, status=%i/%s)",
1313 (long unsigned) si.si_pid,
1314 sigchld_code_to_string(si.si_code),
1316 strna(si.si_code == CLD_EXITED
1317 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1318 : signal_to_string(si.si_status)));
1323 log_debug_unit(u->id,
1324 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1326 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1327 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1333 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1337 dbus_error_init(&error);
1339 log_debug_unit(name, "Activating special unit %s", name);
1341 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1343 log_error_unit(name,
1344 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1346 dbus_error_free(&error);
1351 static int manager_process_signal_fd(Manager *m) {
1353 struct signalfd_siginfo sfsi;
1354 bool sigchld = false;
1359 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1360 if (n != sizeof(sfsi)) {
1365 if (errno == EINTR || errno == EAGAIN)
1371 if (sfsi.ssi_pid > 0) {
1374 get_process_comm(sfsi.ssi_pid, &p);
1376 log_debug("Received SIG%s from PID %lu (%s).",
1377 signal_to_string(sfsi.ssi_signo),
1378 (unsigned long) sfsi.ssi_pid, strna(p));
1381 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1383 switch (sfsi.ssi_signo) {
1390 if (m->running_as == SYSTEMD_SYSTEM) {
1391 /* This is for compatibility with the
1392 * original sysvinit */
1393 m->exit_code = MANAGER_REEXECUTE;
1400 if (m->running_as == SYSTEMD_SYSTEM) {
1401 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1405 /* Run the exit target if there is one, if not, just exit. */
1406 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1407 m->exit_code = MANAGER_EXIT;
1414 if (m->running_as == SYSTEMD_SYSTEM)
1415 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1417 /* This is a nop on non-init */
1421 if (m->running_as == SYSTEMD_SYSTEM)
1422 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1424 /* This is a nop on non-init */
1430 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1432 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1433 log_info("Trying to reconnect to bus...");
1437 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1438 log_info("Loading D-Bus service...");
1439 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1450 if (!(f = open_memstream(&dump, &size))) {
1451 log_warning("Failed to allocate memory stream.");
1455 manager_dump_units(m, f, "\t");
1456 manager_dump_jobs(m, f, "\t");
1461 log_warning("Failed to write status stream");
1466 log_dump(LOG_INFO, dump);
1473 m->exit_code = MANAGER_RELOAD;
1478 /* Starting SIGRTMIN+0 */
1479 static const char * const target_table[] = {
1480 [0] = SPECIAL_DEFAULT_TARGET,
1481 [1] = SPECIAL_RESCUE_TARGET,
1482 [2] = SPECIAL_EMERGENCY_TARGET,
1483 [3] = SPECIAL_HALT_TARGET,
1484 [4] = SPECIAL_POWEROFF_TARGET,
1485 [5] = SPECIAL_REBOOT_TARGET,
1486 [6] = SPECIAL_KEXEC_TARGET
1489 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1490 static const ManagerExitCode code_table[] = {
1492 [1] = MANAGER_POWEROFF,
1493 [2] = MANAGER_REBOOT,
1497 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1498 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1499 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1500 manager_start_target(m, target_table[idx],
1501 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1505 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1506 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1507 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1511 switch (sfsi.ssi_signo - SIGRTMIN) {
1514 log_debug("Enabling showing of status.");
1515 manager_set_show_status(m, true);
1519 log_debug("Disabling showing of status.");
1520 manager_set_show_status(m, false);
1524 log_set_max_level(LOG_DEBUG);
1525 log_notice("Setting log level to debug.");
1529 log_set_max_level(LOG_INFO);
1530 log_notice("Setting log level to info.");
1534 if (m->running_as == SYSTEMD_USER) {
1535 m->exit_code = MANAGER_EXIT;
1539 /* This is a nop on init */
1543 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1544 log_notice("Setting log target to journal-or-kmsg.");
1548 log_set_target(LOG_TARGET_CONSOLE);
1549 log_notice("Setting log target to console.");
1553 log_set_target(LOG_TARGET_KMSG);
1554 log_notice("Setting log target to kmsg.");
1558 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1559 log_notice("Setting log target to syslog-or-kmsg.");
1563 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1570 return manager_dispatch_sigchld(m);
1575 static int process_event(Manager *m, struct epoll_event *ev) {
1582 assert_se(w = ev->data.ptr);
1584 if (w->type == WATCH_INVALID)
1591 /* An incoming signal? */
1592 if (ev->events != EPOLLIN)
1595 if ((r = manager_process_signal_fd(m)) < 0)
1602 /* An incoming daemon notification event? */
1603 if (ev->events != EPOLLIN)
1606 if ((r = manager_process_notify_fd(m)) < 0)
1613 /* Some fd event, to be dispatched to the units */
1614 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1617 case WATCH_UNIT_TIMER:
1618 case WATCH_JOB_TIMER: {
1622 /* Some timer event, to be dispatched to the units */
1623 k = read(w->fd, &v, sizeof(v));
1624 if (k != sizeof(v)) {
1626 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1629 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1630 return k < 0 ? -errno : -EIO;
1633 if (w->type == WATCH_UNIT_TIMER)
1634 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1636 job_timer_event(w->data.job, v, w);
1641 /* Some mount table change, intended for the mount subsystem */
1642 mount_fd_event(m, ev->events);
1646 /* Some swap table change, intended for the swap subsystem */
1647 swap_fd_event(m, ev->events);
1651 /* Some notification from udev, intended for the device subsystem */
1652 device_fd_event(m, ev->events);
1655 case WATCH_DBUS_WATCH:
1656 bus_watch_event(m, w, ev->events);
1659 case WATCH_DBUS_TIMEOUT:
1660 bus_timeout_event(m, w, ev->events);
1663 case WATCH_TIME_CHANGE: {
1667 log_struct(LOG_INFO,
1668 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1669 "MESSAGE=Time has been changed",
1672 /* Restart the watch */
1673 close_nointr_nofail(m->time_change_watch.fd);
1674 watch_init(&m->time_change_watch);
1675 manager_setup_time_change(m);
1677 HASHMAP_FOREACH(u, m->units, i) {
1678 if (UNIT_VTABLE(u)->time_change)
1679 UNIT_VTABLE(u)->time_change(u);
1685 case WATCH_JOBS_IN_PROGRESS: {
1688 /* not interested in the data */
1689 read(w->fd, &v, sizeof(v));
1691 manager_print_jobs_in_progress(m);
1696 log_error("event type=%i", w->type);
1697 assert_not_reached("Unknown epoll event type.");
1703 int manager_loop(Manager *m) {
1706 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1709 m->exit_code = MANAGER_RUNNING;
1711 /* Release the path cache */
1712 set_free_free(m->unit_path_cache);
1713 m->unit_path_cache = NULL;
1715 manager_check_finished(m);
1717 /* There might still be some zombies hanging around from
1718 * before we were exec()'ed. Leat's reap them */
1719 r = manager_dispatch_sigchld(m);
1723 while (m->exit_code == MANAGER_RUNNING) {
1724 struct epoll_event event;
1728 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1731 if (!ratelimit_test(&rl)) {
1732 /* Yay, something is going seriously wrong, pause a little */
1733 log_warning("Looping too fast. Throttling execution a little.");
1738 if (manager_dispatch_load_queue(m) > 0)
1741 if (manager_dispatch_run_queue(m) > 0)
1744 if (bus_dispatch(m) > 0)
1747 if (manager_dispatch_cleanup_queue(m) > 0)
1750 if (manager_dispatch_gc_queue(m) > 0)
1753 if (manager_dispatch_dbus_queue(m) > 0)
1756 if (swap_dispatch_reload(m) > 0)
1759 /* Sleep for half the watchdog time */
1760 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1761 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1767 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1779 r = process_event(m, &event);
1784 return m->exit_code;
1787 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1796 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1799 n = bus_path_unescape(s+31);
1803 r = manager_load_unit(m, n, NULL, e, &u);
1814 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1823 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1826 r = safe_atou(s + 30, &id);
1830 j = manager_get_job(m, id);
1839 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1845 audit_fd = get_audit_fd();
1849 /* Don't generate audit events if the service was already
1850 * started and we're just deserializing */
1851 if (m->n_reloading > 0)
1854 if (m->running_as != SYSTEMD_SYSTEM)
1857 if (u->type != UNIT_SERVICE)
1860 p = unit_name_to_prefix_and_instance(u->id);
1862 log_error_unit(u->id,
1863 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1867 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1868 if (errno == EPERM) {
1869 /* We aren't allowed to send audit messages?
1870 * Then let's not retry again. */
1873 log_warning("Failed to send audit message: %m");
1881 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1883 union sockaddr_union sa;
1885 char *message = NULL;
1887 /* Don't generate plymouth events if the service was already
1888 * started and we're just deserializing */
1889 if (m->n_reloading > 0)
1892 if (m->running_as != SYSTEMD_SYSTEM)
1895 if (u->type != UNIT_SERVICE &&
1896 u->type != UNIT_MOUNT &&
1897 u->type != UNIT_SWAP)
1900 /* We set SOCK_NONBLOCK here so that we rather drop the
1901 * message then wait for plymouth */
1902 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1903 log_error("socket() failed: %m");
1908 sa.sa.sa_family = AF_UNIX;
1909 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1910 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1912 if (errno != EPIPE &&
1915 errno != ECONNREFUSED &&
1916 errno != ECONNRESET &&
1917 errno != ECONNABORTED)
1918 log_error("connect() failed: %m");
1923 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1929 if (write(fd, message, n + 1) != n + 1) {
1931 if (errno != EPIPE &&
1934 errno != ECONNREFUSED &&
1935 errno != ECONNRESET &&
1936 errno != ECONNABORTED)
1937 log_error("Failed to write Plymouth message: %m");
1944 close_nointr_nofail(fd);
1949 void manager_dispatch_bus_name_owner_changed(
1952 const char* old_owner,
1953 const char *new_owner) {
1960 if (!(u = hashmap_get(m->watch_bus, name)))
1963 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1966 void manager_dispatch_bus_query_pid_done(
1977 if (!(u = hashmap_get(m->watch_bus, name)))
1980 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1983 int manager_open_serialization(Manager *m, FILE **_f) {
1991 if (m->running_as == SYSTEMD_SYSTEM)
1992 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1994 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1999 saved_umask = umask(0077);
2000 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2010 log_debug("Serializing state to %s", path);
2013 f = fdopen(fd, "w+");
2022 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
2035 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2036 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2037 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2038 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2040 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2041 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2042 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2043 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2046 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2047 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2050 STRV_FOREACH(e, m->environment) {
2051 _cleanup_free_ char *ce;
2055 fprintf(f, "env=%s\n", *e);
2060 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2064 if (!unit_can_serialize(u))
2071 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
2077 assert(m->n_reloading > 0);
2083 r = bus_fdset_add_all(m, fds);
2090 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2096 log_debug("Deserializing state...");
2101 char line[LINE_MAX], *l;
2103 if (!fgets(line, sizeof(line), f)) {
2118 if (startswith(l, "current-job-id=")) {
2121 if (safe_atou32(l+15, &id) < 0)
2122 log_debug("Failed to parse current job id value %s", l+15);
2124 m->current_job_id = MAX(m->current_job_id, id);
2125 } else if (startswith(l, "n-installed-jobs=")) {
2128 if (safe_atou32(l+17, &n) < 0)
2129 log_debug("Failed to parse installed jobs counter %s", l+17);
2131 m->n_installed_jobs += n;
2132 } else if (startswith(l, "n-failed-jobs=")) {
2135 if (safe_atou32(l+14, &n) < 0)
2136 log_debug("Failed to parse failed jobs counter %s", l+14);
2138 m->n_failed_jobs += n;
2139 } else if (startswith(l, "taint-usr=")) {
2142 if ((b = parse_boolean(l+10)) < 0)
2143 log_debug("Failed to parse taint /usr flag %s", l+10);
2145 m->taint_usr = m->taint_usr || b;
2146 } else if (startswith(l, "firmware-timestamp="))
2147 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2148 else if (startswith(l, "loader-timestamp="))
2149 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2150 else if (startswith(l, "kernel-timestamp="))
2151 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2152 else if (startswith(l, "initrd-timestamp="))
2153 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2154 else if (startswith(l, "userspace-timestamp="))
2155 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2156 else if (startswith(l, "finish-timestamp="))
2157 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2158 else if (startswith(l, "env=")) {
2159 _cleanup_free_ char *uce = NULL;
2162 uce = cunescape(l+4);
2168 e = strv_env_set(m->environment, uce);
2174 strv_free(m->environment);
2177 log_debug("Unknown serialization item '%s'", l);
2182 char name[UNIT_NAME_MAX+2];
2185 if (!fgets(name, sizeof(name), f)) {
2196 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2200 r = unit_deserialize(u, f, fds);
2211 assert(m->n_reloading > 0);
2217 int manager_distribute_fds(Manager *m, FDSet *fds) {
2224 HASHMAP_FOREACH(u, m->units, i) {
2226 if (fdset_size(fds) <= 0)
2229 if (UNIT_VTABLE(u)->distribute_fds) {
2230 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2239 int manager_reload(Manager *m) {
2246 r = manager_open_serialization(m, &f);
2259 r = manager_serialize(m, f, fds, true);
2265 if (fseeko(f, 0, SEEK_SET) < 0) {
2271 /* From here on there is no way back. */
2272 manager_clear_jobs_and_units(m);
2273 manager_undo_generators(m);
2274 lookup_paths_free(&m->lookup_paths);
2276 /* Find new unit paths */
2277 manager_run_generators(m);
2279 q = lookup_paths_init(
2280 &m->lookup_paths, m->running_as, true,
2281 m->generator_unit_path,
2282 m->generator_unit_path_early,
2283 m->generator_unit_path_late);
2287 manager_build_unit_path_cache(m);
2289 /* First, enumerate what we can from all config files */
2290 q = manager_enumerate(m);
2294 /* Second, deserialize our stored data */
2295 q = manager_deserialize(m, f, fds);
2302 /* Third, fire things up! */
2303 q = manager_coldplug(m);
2307 assert(m->n_reloading > 0);
2320 static bool manager_is_booting_or_shutting_down(Manager *m) {
2325 /* Is the initial job still around? */
2326 if (manager_get_job(m, m->default_unit_job_id))
2329 /* Is there a job for the shutdown target? */
2330 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2337 void manager_reset_failed(Manager *m) {
2343 HASHMAP_FOREACH(u, m->units, i)
2344 unit_reset_failed(u);
2347 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2353 /* Returns true if the unit is inactive or going down */
2354 u = manager_get_unit(m, name);
2358 return unit_pending_inactive(u);
2361 void manager_check_finished(Manager *m) {
2362 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2363 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2367 if (hashmap_size(m->jobs) > 0) {
2368 manager_jobs_in_progress_mod_timer(m);
2372 /* Notify Type=idle units that we are done now */
2373 close_pipe(m->idle_pipe);
2375 /* Turn off confirm spawn now */
2376 m->confirm_spawn = false;
2378 manager_unwatch_jobs_in_progress(m);
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),
2410 format_timespan(initrd, sizeof(initrd), initrd_usec),
2411 format_timespan(userspace, sizeof(userspace), userspace_usec),
2412 format_timespan(sum, sizeof(sum), total_usec),
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),
2425 format_timespan(userspace, sizeof(userspace), userspace_usec),
2426 format_timespan(sum, sizeof(sum), total_usec),
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),
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));
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);
2480 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];
2514 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2515 d = opendir(generator_path);
2517 if (errno == ENOENT)
2520 log_error("Failed to enumerate generator directory %s: %m",
2525 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2529 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2533 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2537 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2538 argv[1] = m->generator_unit_path;
2539 argv[2] = m->generator_unit_path_early;
2540 argv[3] = m->generator_unit_path_late;
2544 execute_directory(generator_path, d, (char**) argv);
2547 trim_generator_dir(m, &m->generator_unit_path);
2548 trim_generator_dir(m, &m->generator_unit_path_early);
2549 trim_generator_dir(m, &m->generator_unit_path_late);
2556 static void remove_generator_dir(Manager *m, char **generator) {
2563 strv_remove(m->lookup_paths.unit_path, *generator);
2564 rm_rf(*generator, false, true, false);
2570 void manager_undo_generators(Manager *m) {
2573 remove_generator_dir(m, &m->generator_unit_path);
2574 remove_generator_dir(m, &m->generator_unit_path_early);
2575 remove_generator_dir(m, &m->generator_unit_path_late);
2578 int manager_set_default_controllers(Manager *m, char **controllers) {
2583 l = strv_copy(controllers);
2587 strv_free(m->default_controllers);
2588 m->default_controllers = l;
2590 cg_shorten_controllers(m->default_controllers);
2595 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2600 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2601 if (!default_rlimit[i])
2604 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2612 void manager_recheck_journal(Manager *m) {
2617 if (m->running_as != SYSTEMD_SYSTEM)
2620 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2621 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2622 log_close_journal();
2626 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2627 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2628 log_close_journal();
2632 /* Hmm, OK, so the socket is fully up and the service is up
2633 * too, then let's make use of the thing. */
2637 void manager_set_show_status(Manager *m, bool b) {
2640 if (m->running_as != SYSTEMD_SYSTEM)
2646 touch("/run/systemd/show-status");
2648 unlink("/run/systemd/show-status");
2651 static bool manager_get_show_status(Manager *m) {
2654 if (m->running_as != SYSTEMD_SYSTEM)
2660 /* If Plymouth is running make sure we show the status, so
2661 * that there's something nice to see when people press Esc */
2663 return plymouth_running();
2666 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2669 if (!manager_get_show_status(m))
2672 /* XXX We should totally drop the check for ephemeral here
2673 * and thus effectively make 'Type=idle' pointless. */
2674 if (ephemeral && m->n_on_console > 0)
2677 if (!manager_is_booting_or_shutting_down(m))
2680 va_start(ap, format);
2681 status_vprintf(status, true, ephemeral, format, ap);
2685 void watch_init(Watch *w) {
2688 w->type = WATCH_INVALID;