1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
25 #include <sys/epoll.h>
27 #include <sys/signalfd.h>
31 #include <sys/reboot.h>
32 #include <sys/ioctl.h>
36 #include <sys/types.h>
39 #include <sys/timerfd.h>
45 #include "systemd/sd-daemon.h"
46 #include "systemd/sd-id128.h"
47 #include "systemd/sd-messages.h"
50 #include "transaction.h"
57 #include "ratelimit.h"
58 #include "mount-setup.h"
59 #include "unit-name.h"
60 #include "dbus-unit.h"
63 #include "path-lookup.h"
65 #include "bus-errors.h"
66 #include "exit-status.h"
69 #include "cgroup-util.h"
70 #include "path-util.h"
75 /* As soon as 16 units are in our GC queue, make sure to run a gc sweep */
76 #define GC_QUEUE_ENTRIES_MAX 16
78 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
79 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
81 /* Initial delay and the interval for printing status messages about running jobs */
82 #define JOBS_IN_PROGRESS_WAIT_SEC 5
83 #define JOBS_IN_PROGRESS_PERIOD_SEC 1
84 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
86 /* Where clients shall send notification messages to */
87 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
89 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
91 static int manager_setup_notify(Manager *m) {
94 struct sockaddr_un un;
96 .sa.sa_family = AF_UNIX,
98 struct epoll_event ev = {
100 .data.ptr = &m->notify_watch,
104 m->notify_watch.type = WATCH_NOTIFY;
105 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
106 if (m->notify_watch.fd < 0) {
107 log_error("Failed to allocate notification socket: %m");
111 if (getpid() != 1 || detect_container(NULL) > 0)
112 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
114 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
116 sa.un.sun_path[0] = 0;
118 r = bind(m->notify_watch.fd, &sa.sa,
119 offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
121 log_error("bind() failed: %m");
125 r = setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
127 log_error("SO_PASSCRED failed: %m");
131 r = epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev);
133 log_error("Failed to add notification socket fd to epoll: %m");
137 sa.un.sun_path[0] = '@';
138 m->notify_socket = strdup(sa.un.sun_path);
139 if (!m->notify_socket)
142 log_debug("Using notification socket %s", m->notify_socket);
147 static int manager_jobs_in_progress_mod_timer(Manager *m) {
148 struct itimerspec its = {
149 .it_value.tv_sec = JOBS_IN_PROGRESS_WAIT_SEC,
150 .it_interval.tv_sec = JOBS_IN_PROGRESS_PERIOD_SEC,
153 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
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 = {
165 .data.ptr = &m->jobs_in_progress_watch,
169 if (m->jobs_in_progress_watch.type != WATCH_INVALID)
172 m->jobs_in_progress_watch.type = WATCH_JOBS_IN_PROGRESS;
173 m->jobs_in_progress_watch.fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
174 if (m->jobs_in_progress_watch.fd < 0) {
175 log_error("Failed to create timerfd: %m");
180 r = manager_jobs_in_progress_mod_timer(m);
182 log_error("Failed to set up timer for jobs progress watch: %s", strerror(-r));
186 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->jobs_in_progress_watch.fd, &ev) < 0) {
187 log_error("Failed to add jobs progress timer fd to epoll: %m");
192 log_debug("Set up jobs progress timerfd.");
197 if (m->jobs_in_progress_watch.fd >= 0)
198 close_nointr_nofail(m->jobs_in_progress_watch.fd);
199 watch_init(&m->jobs_in_progress_watch);
203 static void manager_unwatch_jobs_in_progress(Manager *m) {
204 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
207 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->jobs_in_progress_watch.fd, NULL) >= 0);
208 close_nointr_nofail(m->jobs_in_progress_watch.fd);
209 watch_init(&m->jobs_in_progress_watch);
210 m->jobs_in_progress_iteration = 0;
212 log_debug("Closed jobs progress timerfd.");
215 #define CYLON_BUFFER_EXTRA (2*strlen(ANSI_RED_ON) + strlen(ANSI_HIGHLIGHT_RED_ON) + 2*strlen(ANSI_HIGHLIGHT_OFF))
216 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
219 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
220 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
224 p = mempset(p, ' ', pos-2);
225 p = stpcpy(p, ANSI_RED_ON);
229 if (pos > 0 && pos <= width) {
230 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
234 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
237 p = stpcpy(p, ANSI_RED_ON);
240 p = mempset(p, ' ', width-1-pos);
241 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
245 static void manager_print_jobs_in_progress(Manager *m) {
248 char *job_of_n = NULL;
249 unsigned counter = 0, print_nr;
250 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
253 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
255 HASHMAP_FOREACH(j, m->jobs, i)
256 if (j->state == JOB_RUNNING && counter++ == print_nr)
259 /* m->n_running_jobs must be consistent with the contents of m->jobs,
260 * so the above loop must have succeeded in finding j. */
261 assert(counter == print_nr + 1);
263 cylon_pos = m->jobs_in_progress_iteration % 14;
265 cylon_pos = 14 - cylon_pos;
266 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
268 if (m->n_running_jobs > 1)
269 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
272 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
273 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
276 m->jobs_in_progress_iteration++;
279 static int manager_setup_time_change(Manager *m) {
280 struct epoll_event ev = {
282 .data.ptr = &m->time_change_watch,
285 /* We only care for the cancellation event, hence we set the
286 * timeout to the latest possible value. */
287 struct itimerspec its = {
288 .it_value.tv_sec = TIME_T_MAX,
290 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
292 assert(m->time_change_watch.type == WATCH_INVALID);
294 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
295 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
297 m->time_change_watch.type = WATCH_TIME_CHANGE;
298 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
299 if (m->time_change_watch.fd < 0) {
300 log_error("Failed to create timerfd: %m");
304 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
305 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
306 close_nointr_nofail(m->time_change_watch.fd);
307 watch_init(&m->time_change_watch);
311 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
312 log_error("Failed to add timer change fd to epoll: %m");
316 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
321 static int enable_special_signals(Manager *m) {
326 /* Enable that we get SIGINT on control-alt-del. In containers
327 * this will fail with EPERM (older) or EINVAL (newer), so
329 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
330 log_warning("Failed to enable ctrl-alt-del handling: %m");
332 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
334 /* Support systems without virtual console */
336 log_warning("Failed to open /dev/tty0: %m");
338 /* Enable that we get SIGWINCH on kbrequest */
339 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
340 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
342 close_nointr_nofail(fd);
348 static int manager_setup_signals(Manager *m) {
350 struct epoll_event ev = {
352 .data.ptr = &m->signal_watch,
354 struct sigaction sa = {
355 .sa_handler = SIG_DFL,
356 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
361 /* We are not interested in SIGSTOP and friends. */
362 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
364 assert_se(sigemptyset(&mask) == 0);
366 sigset_add_many(&mask,
367 SIGCHLD, /* Child died */
368 SIGTERM, /* Reexecute daemon */
369 SIGHUP, /* Reload configuration */
370 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
371 SIGUSR2, /* systemd: dump status */
372 SIGINT, /* Kernel sends us this on control-alt-del */
373 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
374 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
375 SIGRTMIN+0, /* systemd: start default.target */
376 SIGRTMIN+1, /* systemd: isolate rescue.target */
377 SIGRTMIN+2, /* systemd: isolate emergency.target */
378 SIGRTMIN+3, /* systemd: start halt.target */
379 SIGRTMIN+4, /* systemd: start poweroff.target */
380 SIGRTMIN+5, /* systemd: start reboot.target */
381 SIGRTMIN+6, /* systemd: start kexec.target */
382 SIGRTMIN+13, /* systemd: Immediate halt */
383 SIGRTMIN+14, /* systemd: Immediate poweroff */
384 SIGRTMIN+15, /* systemd: Immediate reboot */
385 SIGRTMIN+16, /* systemd: Immediate kexec */
386 SIGRTMIN+20, /* systemd: enable status messages */
387 SIGRTMIN+21, /* systemd: disable status messages */
388 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
389 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
390 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
391 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
392 SIGRTMIN+27, /* systemd: set log target to console */
393 SIGRTMIN+28, /* systemd: set log target to kmsg */
394 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
396 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
398 m->signal_watch.type = WATCH_SIGNAL;
399 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
400 if (m->signal_watch.fd < 0)
403 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
406 if (m->running_as == SYSTEMD_SYSTEM)
407 return enable_special_signals(m);
412 static void manager_strip_environment(Manager *m) {
415 /* Remove variables from the inherited set that are part of
416 * the container interface:
417 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
418 strv_remove_prefix(m->environment, "container=");
419 strv_remove_prefix(m->environment, "container_");
421 /* Remove variables from the inherited set that are part of
422 * the initrd interface:
423 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
424 strv_remove_prefix(m->environment, "RD_");
426 /* Drop invalid entries */
427 strv_env_clean(m->environment);
430 int manager_new(SystemdRunningAs running_as, Manager **_m) {
435 assert(running_as >= 0);
436 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
438 m = new0(Manager, 1);
443 if (detect_container(NULL) <= 0)
444 efi_get_boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
447 m->running_as = running_as;
448 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
449 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
450 m->pin_cgroupfs_fd = -1;
451 m->idle_pipe[0] = m->idle_pipe[1] = -1;
453 watch_init(&m->signal_watch);
454 watch_init(&m->mount_watch);
455 watch_init(&m->swap_watch);
456 watch_init(&m->udev_watch);
457 watch_init(&m->time_change_watch);
458 watch_init(&m->jobs_in_progress_watch);
460 m->epoll_fd = m->dev_autofs_fd = -1;
461 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
463 m->environment = strv_copy(environ);
467 manager_strip_environment(m);
469 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
472 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
475 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
478 m->cgroup_unit = hashmap_new(string_hash_func, string_compare_func);
482 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
485 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
489 r = manager_setup_signals(m);
493 r = manager_setup_cgroup(m);
497 r = manager_setup_notify(m);
501 r = manager_setup_time_change(m);
505 /* Try to connect to the busses, if possible. */
506 if ((running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS")) ||
507 running_as == SYSTEMD_SYSTEM) {
508 r = bus_init(m, running_as != SYSTEMD_SYSTEM);
512 log_debug("Skipping DBus session bus connection attempt - no DBUS_SESSION_BUS_ADDRESS set...");
514 m->taint_usr = dir_is_empty("/usr") > 0;
524 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
530 while ((u = m->cleanup_queue)) {
531 assert(u->in_cleanup_queue);
541 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
542 GC_OFFSET_UNSURE, /* No clue */
543 GC_OFFSET_GOOD, /* We still need this unit */
544 GC_OFFSET_BAD, /* We don't need this unit anymore */
548 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
555 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
556 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
557 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
560 if (u->in_cleanup_queue)
563 if (unit_check_gc(u))
566 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
570 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
571 unit_gc_sweep(other, gc_marker);
573 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
576 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
583 /* We were unable to find anything out about this entry, so
584 * let's investigate it later */
585 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
586 unit_add_to_gc_queue(u);
590 /* We definitely know that this one is not useful anymore, so
591 * let's mark it for deletion */
592 u->gc_marker = gc_marker + GC_OFFSET_BAD;
593 unit_add_to_cleanup_queue(u);
597 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
600 static unsigned manager_dispatch_gc_queue(Manager *m) {
607 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
608 (m->gc_queue_timestamp <= 0 ||
609 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
612 log_debug("Running GC...");
614 m->gc_marker += _GC_OFFSET_MAX;
615 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
618 gc_marker = m->gc_marker;
620 while ((u = m->gc_queue)) {
621 assert(u->in_gc_queue);
623 unit_gc_sweep(u, gc_marker);
625 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
626 u->in_gc_queue = false;
630 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
631 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
632 log_debug_unit(u->id, "Collecting %s", u->id);
633 u->gc_marker = gc_marker + GC_OFFSET_BAD;
634 unit_add_to_cleanup_queue(u);
638 m->n_in_gc_queue = 0;
639 m->gc_queue_timestamp = 0;
644 static void manager_clear_jobs_and_units(Manager *m) {
649 while ((u = hashmap_first(m->units)))
652 manager_dispatch_cleanup_queue(m);
654 assert(!m->load_queue);
655 assert(!m->run_queue);
656 assert(!m->dbus_unit_queue);
657 assert(!m->dbus_job_queue);
658 assert(!m->cleanup_queue);
659 assert(!m->gc_queue);
661 assert(hashmap_isempty(m->jobs));
662 assert(hashmap_isempty(m->units));
665 m->n_running_jobs = 0;
668 void manager_free(Manager *m) {
674 manager_clear_jobs_and_units(m);
676 for (c = 0; c < _UNIT_TYPE_MAX; c++)
677 if (unit_vtable[c]->shutdown)
678 unit_vtable[c]->shutdown(m);
680 /* If we reexecute ourselves, we keep the root cgroup
682 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
684 manager_undo_generators(m);
688 hashmap_free(m->units);
689 hashmap_free(m->jobs);
690 hashmap_free(m->watch_pids);
691 hashmap_free(m->watch_bus);
693 if (m->epoll_fd >= 0)
694 close_nointr_nofail(m->epoll_fd);
695 if (m->signal_watch.fd >= 0)
696 close_nointr_nofail(m->signal_watch.fd);
697 if (m->notify_watch.fd >= 0)
698 close_nointr_nofail(m->notify_watch.fd);
699 if (m->time_change_watch.fd >= 0)
700 close_nointr_nofail(m->time_change_watch.fd);
701 if (m->jobs_in_progress_watch.fd >= 0)
702 close_nointr_nofail(m->jobs_in_progress_watch.fd);
704 free(m->notify_socket);
706 lookup_paths_free(&m->lookup_paths);
707 strv_free(m->environment);
709 hashmap_free(m->cgroup_unit);
710 set_free_free(m->unit_path_cache);
712 close_pipe(m->idle_pipe);
714 free(m->switch_root);
715 free(m->switch_root_init);
717 for (i = 0; i < RLIMIT_NLIMITS; i++)
723 int manager_enumerate(Manager *m) {
729 /* Let's ask every type to load all units from disk/kernel
730 * that it might know */
731 for (c = 0; c < _UNIT_TYPE_MAX; c++)
732 if (unit_vtable[c]->enumerate)
733 if ((q = unit_vtable[c]->enumerate(m)) < 0)
736 manager_dispatch_load_queue(m);
740 int manager_coldplug(Manager *m) {
748 /* Then, let's set up their initial state. */
749 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
755 if ((q = unit_coldplug(u)) < 0)
762 static void manager_build_unit_path_cache(Manager *m) {
764 _cleanup_free_ DIR *d = NULL;
769 set_free_free(m->unit_path_cache);
771 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
772 if (!m->unit_path_cache) {
773 log_error("Failed to allocate unit path cache.");
777 /* This simply builds a list of files we know exist, so that
778 * we don't always have to go to disk */
780 STRV_FOREACH(i, m->lookup_paths.unit_path) {
786 log_error("Failed to open directory %s: %m", *i);
790 while ((de = readdir(d))) {
793 if (ignore_file(de->d_name))
796 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
802 r = set_consume(m->unit_path_cache, p);
814 log_error("Failed to build unit path cache: %s", strerror(-r));
816 set_free_free(m->unit_path_cache);
817 m->unit_path_cache = NULL;
820 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
825 dual_timestamp_get(&m->generators_start_timestamp);
826 manager_run_generators(m);
827 dual_timestamp_get(&m->generators_finish_timestamp);
829 r = lookup_paths_init(
830 &m->lookup_paths, m->running_as, true,
831 m->generator_unit_path,
832 m->generator_unit_path_early,
833 m->generator_unit_path_late);
837 manager_build_unit_path_cache(m);
839 /* If we will deserialize make sure that during enumeration
840 * this is already known, so we increase the counter here
845 /* First, enumerate what we can from all config files */
846 dual_timestamp_get(&m->unitsload_start_timestamp);
847 r = manager_enumerate(m);
848 dual_timestamp_get(&m->unitsload_finish_timestamp);
850 /* Second, deserialize if there is something to deserialize */
852 q = manager_deserialize(m, serialization, fds);
857 /* Any fds left? Find some unit which wants them. This is
858 * useful to allow container managers to pass some file
859 * descriptors to us pre-initialized. This enables
860 * socket-based activation of entire containers. */
861 if (fdset_size(fds) > 0) {
862 q = manager_distribute_fds(m, fds);
867 /* Third, fire things up! */
868 q = manager_coldplug(m);
873 assert(m->n_reloading > 0);
880 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
885 assert(type < _JOB_TYPE_MAX);
887 assert(mode < _JOB_MODE_MAX);
889 if (mode == JOB_ISOLATE && type != JOB_START) {
890 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
894 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
895 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
899 log_debug_unit(unit->id,
900 "Trying to enqueue job %s/%s/%s", unit->id,
901 job_type_to_string(type), job_mode_to_string(mode));
903 job_type_collapse(&type, unit);
905 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
909 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
910 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
911 mode == JOB_IGNORE_DEPENDENCIES, e);
915 if (mode == JOB_ISOLATE) {
916 r = transaction_add_isolate_jobs(tr, m);
921 r = transaction_activate(tr, m, mode, e);
925 log_debug_unit(unit->id,
926 "Enqueued job %s/%s as %u", unit->id,
927 job_type_to_string(type), (unsigned) tr->anchor_job->id);
930 *_ret = tr->anchor_job;
932 transaction_free(tr);
936 transaction_abort(tr);
937 transaction_free(tr);
941 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
946 assert(type < _JOB_TYPE_MAX);
948 assert(mode < _JOB_MODE_MAX);
950 r = manager_load_unit(m, name, NULL, NULL, &unit);
954 return manager_add_job(m, type, unit, mode, override, e, _ret);
957 Job *manager_get_job(Manager *m, uint32_t id) {
960 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
963 Unit *manager_get_unit(Manager *m, const char *name) {
967 return hashmap_get(m->units, name);
970 unsigned manager_dispatch_load_queue(Manager *m) {
976 /* Make sure we are not run recursively */
977 if (m->dispatching_load_queue)
980 m->dispatching_load_queue = true;
982 /* Dispatches the load queue. Takes a unit from the queue and
983 * tries to load its data until the queue is empty */
985 while ((u = m->load_queue)) {
986 assert(u->in_load_queue);
992 m->dispatching_load_queue = false;
996 int manager_load_unit_prepare(
1008 assert(name || path);
1010 /* This will prepare the unit for loading, but not actually
1011 * load anything from disk. */
1013 if (path && !is_path(path)) {
1014 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1019 name = path_get_file_name(path);
1021 t = unit_name_to_type(name);
1023 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
1024 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1028 ret = manager_get_unit(m, name);
1034 ret = unit_new(m, unit_vtable[t]->object_size);
1039 ret->fragment_path = strdup(path);
1040 if (!ret->fragment_path) {
1046 r = unit_add_name(ret, name);
1052 unit_add_to_load_queue(ret);
1053 unit_add_to_dbus_queue(ret);
1054 unit_add_to_gc_queue(ret);
1062 int manager_load_unit(
1073 /* This will load the service information files, but not actually
1074 * start any services or anything. */
1076 r = manager_load_unit_prepare(m, name, path, e, _ret);
1080 manager_dispatch_load_queue(m);
1083 *_ret = unit_follow_merge(*_ret);
1088 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1095 HASHMAP_FOREACH(j, s->jobs, i)
1096 job_dump(j, f, prefix);
1099 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1107 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1109 unit_dump(u, f, prefix);
1112 void manager_clear_jobs(Manager *m) {
1117 while ((j = hashmap_first(m->jobs)))
1118 /* No need to recurse. We're cancelling all jobs. */
1119 job_finish_and_invalidate(j, JOB_CANCELED, false);
1122 unsigned manager_dispatch_run_queue(Manager *m) {
1126 if (m->dispatching_run_queue)
1129 m->dispatching_run_queue = true;
1131 while ((j = m->run_queue)) {
1132 assert(j->installed);
1133 assert(j->in_run_queue);
1135 job_run_and_invalidate(j);
1139 m->dispatching_run_queue = false;
1141 if (m->n_running_jobs > 0)
1142 manager_watch_jobs_in_progress(m);
1147 unsigned manager_dispatch_dbus_queue(Manager *m) {
1154 if (m->dispatching_dbus_queue)
1157 m->dispatching_dbus_queue = true;
1159 while ((u = m->dbus_unit_queue)) {
1160 assert(u->in_dbus_queue);
1162 bus_unit_send_change_signal(u);
1166 while ((j = m->dbus_job_queue)) {
1167 assert(j->in_dbus_queue);
1169 bus_job_send_change_signal(j);
1173 m->dispatching_dbus_queue = false;
1177 static int manager_process_notify_fd(Manager *m) {
1184 struct iovec iovec = {
1186 .iov_len = sizeof(buf)-1,
1190 struct cmsghdr cmsghdr;
1191 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1194 struct msghdr msghdr = {
1197 .msg_control = &control,
1198 .msg_controllen = sizeof(control),
1200 struct ucred *ucred;
1202 _cleanup_strv_free_ char **tags = NULL;
1204 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1209 if (errno == EAGAIN || errno == EINTR)
1215 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1216 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1217 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1218 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1219 log_warning("Received notify message without credentials. Ignoring.");
1223 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1225 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1227 u = manager_get_unit_by_pid(m, ucred->pid);
1229 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1234 assert((size_t) n < sizeof(buf));
1236 tags = strv_split(buf, "\n\r");
1240 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1242 if (UNIT_VTABLE(u)->notify_message)
1243 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1249 static int manager_dispatch_sigchld(Manager *m) {
1257 /* First we call waitd() for a PID and do not reap the
1258 * zombie. That way we can still access /proc/$PID for
1259 * it while it is a zombie. */
1260 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1262 if (errno == ECHILD)
1274 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1275 _cleanup_free_ char *name = NULL;
1277 get_process_comm(si.si_pid, &name);
1278 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1281 /* Let's flush any message the dying child might still
1282 * have queued for us. This ensures that the process
1283 * still exists in /proc so that we can figure out
1284 * which cgroup and hence unit it belongs to. */
1285 r = manager_process_notify_fd(m);
1289 /* And now figure out the unit this belongs to */
1290 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1292 u = manager_get_unit_by_pid(m, si.si_pid);
1294 /* And now, we actually reap the zombie. */
1295 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1302 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1305 log_debug("Child %lu died (code=%s, status=%i/%s)",
1306 (long unsigned) si.si_pid,
1307 sigchld_code_to_string(si.si_code),
1309 strna(si.si_code == CLD_EXITED
1310 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1311 : signal_to_string(si.si_status)));
1316 log_debug_unit(u->id,
1317 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1319 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1320 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1326 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1330 dbus_error_init(&error);
1332 log_debug_unit(name, "Activating special unit %s", name);
1334 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1336 log_error_unit(name,
1337 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1339 dbus_error_free(&error);
1344 static int manager_process_signal_fd(Manager *m) {
1346 struct signalfd_siginfo sfsi;
1347 bool sigchld = false;
1352 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1353 if (n != sizeof(sfsi)) {
1358 if (errno == EINTR || errno == EAGAIN)
1364 if (sfsi.ssi_pid > 0) {
1367 get_process_comm(sfsi.ssi_pid, &p);
1369 log_debug("Received SIG%s from PID %lu (%s).",
1370 signal_to_string(sfsi.ssi_signo),
1371 (unsigned long) sfsi.ssi_pid, strna(p));
1374 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1376 switch (sfsi.ssi_signo) {
1383 if (m->running_as == SYSTEMD_SYSTEM) {
1384 /* This is for compatibility with the
1385 * original sysvinit */
1386 m->exit_code = MANAGER_REEXECUTE;
1393 if (m->running_as == SYSTEMD_SYSTEM) {
1394 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1398 /* Run the exit target if there is one, if not, just exit. */
1399 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1400 m->exit_code = MANAGER_EXIT;
1407 if (m->running_as == SYSTEMD_SYSTEM)
1408 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1410 /* This is a nop on non-init */
1414 if (m->running_as == SYSTEMD_SYSTEM)
1415 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1417 /* This is a nop on non-init */
1423 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1425 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1426 log_info("Trying to reconnect to bus...");
1430 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1431 log_info("Loading D-Bus service...");
1432 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1443 if (!(f = open_memstream(&dump, &size))) {
1444 log_warning("Failed to allocate memory stream.");
1448 manager_dump_units(m, f, "\t");
1449 manager_dump_jobs(m, f, "\t");
1454 log_warning("Failed to write status stream");
1459 log_dump(LOG_INFO, dump);
1466 m->exit_code = MANAGER_RELOAD;
1471 /* Starting SIGRTMIN+0 */
1472 static const char * const target_table[] = {
1473 [0] = SPECIAL_DEFAULT_TARGET,
1474 [1] = SPECIAL_RESCUE_TARGET,
1475 [2] = SPECIAL_EMERGENCY_TARGET,
1476 [3] = SPECIAL_HALT_TARGET,
1477 [4] = SPECIAL_POWEROFF_TARGET,
1478 [5] = SPECIAL_REBOOT_TARGET,
1479 [6] = SPECIAL_KEXEC_TARGET
1482 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1483 static const ManagerExitCode code_table[] = {
1485 [1] = MANAGER_POWEROFF,
1486 [2] = MANAGER_REBOOT,
1490 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1491 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1492 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1493 manager_start_target(m, target_table[idx],
1494 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1498 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1499 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1500 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1504 switch (sfsi.ssi_signo - SIGRTMIN) {
1507 log_debug("Enabling showing of status.");
1508 manager_set_show_status(m, true);
1512 log_debug("Disabling showing of status.");
1513 manager_set_show_status(m, false);
1517 log_set_max_level(LOG_DEBUG);
1518 log_notice("Setting log level to debug.");
1522 log_set_max_level(LOG_INFO);
1523 log_notice("Setting log level to info.");
1527 if (m->running_as == SYSTEMD_USER) {
1528 m->exit_code = MANAGER_EXIT;
1532 /* This is a nop on init */
1536 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1537 log_notice("Setting log target to journal-or-kmsg.");
1541 log_set_target(LOG_TARGET_CONSOLE);
1542 log_notice("Setting log target to console.");
1546 log_set_target(LOG_TARGET_KMSG);
1547 log_notice("Setting log target to kmsg.");
1551 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1552 log_notice("Setting log target to syslog-or-kmsg.");
1556 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1563 return manager_dispatch_sigchld(m);
1568 static int process_event(Manager *m, struct epoll_event *ev) {
1575 assert_se(w = ev->data.ptr);
1577 if (w->type == WATCH_INVALID)
1584 /* An incoming signal? */
1585 if (ev->events != EPOLLIN)
1588 if ((r = manager_process_signal_fd(m)) < 0)
1595 /* An incoming daemon notification event? */
1596 if (ev->events != EPOLLIN)
1599 if ((r = manager_process_notify_fd(m)) < 0)
1606 /* Some fd event, to be dispatched to the units */
1607 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1610 case WATCH_UNIT_TIMER:
1611 case WATCH_JOB_TIMER: {
1615 /* Some timer event, to be dispatched to the units */
1616 k = read(w->fd, &v, sizeof(v));
1617 if (k != sizeof(v)) {
1619 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1622 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1623 return k < 0 ? -errno : -EIO;
1626 if (w->type == WATCH_UNIT_TIMER)
1627 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1629 job_timer_event(w->data.job, v, w);
1634 /* Some mount table change, intended for the mount subsystem */
1635 mount_fd_event(m, ev->events);
1639 /* Some swap table change, intended for the swap subsystem */
1640 swap_fd_event(m, ev->events);
1644 /* Some notification from udev, intended for the device subsystem */
1645 device_fd_event(m, ev->events);
1648 case WATCH_DBUS_WATCH:
1649 bus_watch_event(m, w, ev->events);
1652 case WATCH_DBUS_TIMEOUT:
1653 bus_timeout_event(m, w, ev->events);
1656 case WATCH_TIME_CHANGE: {
1660 log_struct(LOG_INFO,
1661 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1662 "MESSAGE=Time has been changed",
1665 /* Restart the watch */
1666 epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->time_change_watch.fd,
1668 close_nointr_nofail(m->time_change_watch.fd);
1669 watch_init(&m->time_change_watch);
1670 manager_setup_time_change(m);
1672 HASHMAP_FOREACH(u, m->units, i) {
1673 if (UNIT_VTABLE(u)->time_change)
1674 UNIT_VTABLE(u)->time_change(u);
1680 case WATCH_JOBS_IN_PROGRESS: {
1683 /* not interested in the data */
1684 read(w->fd, &v, sizeof(v));
1686 manager_print_jobs_in_progress(m);
1691 log_error("event type=%i", w->type);
1692 assert_not_reached("Unknown epoll event type.");
1698 int manager_loop(Manager *m) {
1701 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1704 m->exit_code = MANAGER_RUNNING;
1706 /* Release the path cache */
1707 set_free_free(m->unit_path_cache);
1708 m->unit_path_cache = NULL;
1710 manager_check_finished(m);
1712 /* There might still be some zombies hanging around from
1713 * before we were exec()'ed. Leat's reap them */
1714 r = manager_dispatch_sigchld(m);
1718 while (m->exit_code == MANAGER_RUNNING) {
1719 struct epoll_event event;
1723 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1726 if (!ratelimit_test(&rl)) {
1727 /* Yay, something is going seriously wrong, pause a little */
1728 log_warning("Looping too fast. Throttling execution a little.");
1733 if (manager_dispatch_load_queue(m) > 0)
1736 if (manager_dispatch_run_queue(m) > 0)
1739 if (bus_dispatch(m) > 0)
1742 if (manager_dispatch_cleanup_queue(m) > 0)
1745 if (manager_dispatch_gc_queue(m) > 0)
1748 if (manager_dispatch_cgroup_queue(m) > 0)
1751 if (manager_dispatch_dbus_queue(m) > 0)
1754 if (swap_dispatch_reload(m) > 0)
1757 /* Sleep for half the watchdog time */
1758 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1759 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1765 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1777 r = process_event(m, &event);
1782 return m->exit_code;
1785 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1794 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1797 n = bus_path_unescape(s+31);
1801 r = manager_load_unit(m, n, NULL, e, &u);
1812 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1821 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1824 r = safe_atou(s + 30, &id);
1828 j = manager_get_job(m, id);
1837 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1843 audit_fd = get_audit_fd();
1847 /* Don't generate audit events if the service was already
1848 * started and we're just deserializing */
1849 if (m->n_reloading > 0)
1852 if (m->running_as != SYSTEMD_SYSTEM)
1855 if (u->type != UNIT_SERVICE)
1858 p = unit_name_to_prefix_and_instance(u->id);
1860 log_error_unit(u->id,
1861 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1865 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1866 if (errno == EPERM) {
1867 /* We aren't allowed to send audit messages?
1868 * Then let's not retry again. */
1871 log_warning("Failed to send audit message: %m");
1879 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1881 union sockaddr_union sa;
1883 char *message = NULL;
1885 /* Don't generate plymouth events if the service was already
1886 * started and we're just deserializing */
1887 if (m->n_reloading > 0)
1890 if (m->running_as != SYSTEMD_SYSTEM)
1893 if (u->type != UNIT_SERVICE &&
1894 u->type != UNIT_MOUNT &&
1895 u->type != UNIT_SWAP)
1898 /* We set SOCK_NONBLOCK here so that we rather drop the
1899 * message then wait for plymouth */
1900 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1902 log_error("socket() failed: %m");
1907 sa.sa.sa_family = AF_UNIX;
1908 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1909 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1911 if (errno != EPIPE &&
1914 errno != ECONNREFUSED &&
1915 errno != ECONNRESET &&
1916 errno != ECONNABORTED)
1917 log_error("connect() failed: %m");
1922 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1928 if (write(fd, message, n + 1) != n + 1) {
1930 if (errno != EPIPE &&
1933 errno != ECONNREFUSED &&
1934 errno != ECONNRESET &&
1935 errno != ECONNABORTED)
1936 log_error("Failed to write Plymouth message: %m");
1943 close_nointr_nofail(fd);
1948 void manager_dispatch_bus_name_owner_changed(
1951 const char* old_owner,
1952 const char *new_owner) {
1959 if (!(u = hashmap_get(m->watch_bus, name)))
1962 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1965 void manager_dispatch_bus_query_pid_done(
1976 if (!(u = hashmap_get(m->watch_bus, name)))
1979 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1982 int manager_open_serialization(Manager *m, FILE **_f) {
1989 if (m->running_as == SYSTEMD_SYSTEM)
1990 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1992 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1997 RUN_WITH_UMASK(0077) {
1998 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2008 log_debug("Serializing state to %s", path);
2011 f = fdopen(fd, "w+");
2020 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2033 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2034 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2035 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2036 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2038 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2039 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2040 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2041 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2044 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2045 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2048 if (!switching_root) {
2049 STRV_FOREACH(e, m->environment) {
2050 _cleanup_free_ char *ce;
2054 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, !switching_root)) < 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, false);
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 bool manager_is_reloading_or_reexecuting(Manager *m) {
2340 return m->n_reloading != 0;
2343 void manager_reset_failed(Manager *m) {
2349 HASHMAP_FOREACH(u, m->units, i)
2350 unit_reset_failed(u);
2353 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2359 /* Returns true if the unit is inactive or going down */
2360 u = manager_get_unit(m, name);
2364 return unit_inactive_or_pending(u);
2367 void manager_check_finished(Manager *m) {
2368 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2369 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2373 if (m->n_running_jobs == 0)
2374 manager_unwatch_jobs_in_progress(m);
2376 if (hashmap_size(m->jobs) > 0) {
2377 manager_jobs_in_progress_mod_timer(m);
2381 /* Notify Type=idle units that we are done now */
2382 close_pipe(m->idle_pipe);
2384 /* Turn off confirm spawn now */
2385 m->confirm_spawn = false;
2387 if (dual_timestamp_is_set(&m->finish_timestamp))
2390 dual_timestamp_get(&m->finish_timestamp);
2392 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2394 /* Note that m->kernel_usec.monotonic is always at 0,
2395 * and m->firmware_usec.monotonic and
2396 * m->loader_usec.monotonic should be considered
2397 * negative values. */
2399 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2400 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2401 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2402 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2404 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2406 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2407 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2409 if (!log_on_console())
2410 log_struct(LOG_INFO,
2411 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2412 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2413 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2414 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2415 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2416 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2417 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2418 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2419 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2422 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2425 if (!log_on_console())
2426 log_struct(LOG_INFO,
2427 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2428 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2429 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2430 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2431 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2432 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2433 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2437 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2438 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2440 if (!log_on_console())
2441 log_struct(LOG_INFO,
2442 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2443 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2444 "MESSAGE=Startup finished in %s.",
2445 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2449 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2452 "READY=1\nSTATUS=Startup finished in %s.",
2453 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2456 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2467 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2469 p = strappend("/run/systemd/", name);
2473 r = mkdir_p_label(p, 0755);
2475 log_error("Failed to create generator directory %s: %s",
2481 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2486 log_error("Failed to create generator directory %s: %m",
2497 static void trim_generator_dir(Manager *m, char **generator) {
2504 if (rmdir(*generator) >= 0) {
2512 void manager_run_generators(Manager *m) {
2514 const char *generator_path;
2515 const char *argv[5];
2520 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2521 d = opendir(generator_path);
2523 if (errno == ENOENT)
2526 log_error("Failed to enumerate generator directory %s: %m",
2531 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2535 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2539 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2543 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2544 argv[1] = m->generator_unit_path;
2545 argv[2] = m->generator_unit_path_early;
2546 argv[3] = m->generator_unit_path_late;
2549 RUN_WITH_UMASK(0022) {
2550 execute_directory(generator_path, d, (char**) argv);
2553 trim_generator_dir(m, &m->generator_unit_path);
2554 trim_generator_dir(m, &m->generator_unit_path_early);
2555 trim_generator_dir(m, &m->generator_unit_path_late);
2562 static void remove_generator_dir(Manager *m, char **generator) {
2569 strv_remove(m->lookup_paths.unit_path, *generator);
2570 rm_rf(*generator, false, true, false);
2576 void manager_undo_generators(Manager *m) {
2579 remove_generator_dir(m, &m->generator_unit_path);
2580 remove_generator_dir(m, &m->generator_unit_path_early);
2581 remove_generator_dir(m, &m->generator_unit_path_late);
2584 int manager_set_default_environment(Manager *m, char **environment) {
2588 e = strv_env_merge(2, m->environment, environment);
2591 strv_free(m->environment);
2596 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2601 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2602 if (!default_rlimit[i])
2605 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2613 void manager_recheck_journal(Manager *m) {
2618 if (m->running_as != SYSTEMD_SYSTEM)
2621 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2622 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2623 log_close_journal();
2627 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2628 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2629 log_close_journal();
2633 /* Hmm, OK, so the socket is fully up and the service is up
2634 * too, then let's make use of the thing. */
2638 void manager_set_show_status(Manager *m, bool b) {
2641 if (m->running_as != SYSTEMD_SYSTEM)
2647 touch("/run/systemd/show-status");
2649 unlink("/run/systemd/show-status");
2652 static bool manager_get_show_status(Manager *m) {
2655 if (m->running_as != SYSTEMD_SYSTEM)
2661 /* If Plymouth is running make sure we show the status, so
2662 * that there's something nice to see when people press Esc */
2664 return plymouth_running();
2667 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2670 if (!manager_get_show_status(m))
2673 /* XXX We should totally drop the check for ephemeral here
2674 * and thus effectively make 'Type=idle' pointless. */
2675 if (ephemeral && m->n_on_console > 0)
2678 if (!manager_is_booting_or_shutting_down(m))
2681 va_start(ap, format);
2682 status_vprintf(status, true, ephemeral, format, ap);
2686 void watch_init(Watch *w) {
2689 w->type = WATCH_INVALID;