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"
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);
442 m->running_as = running_as;
443 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
444 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
445 m->pin_cgroupfs_fd = -1;
446 m->idle_pipe[0] = m->idle_pipe[1] = -1;
448 watch_init(&m->signal_watch);
449 watch_init(&m->mount_watch);
450 watch_init(&m->swap_watch);
451 watch_init(&m->udev_watch);
452 watch_init(&m->time_change_watch);
453 watch_init(&m->jobs_in_progress_watch);
455 m->epoll_fd = m->dev_autofs_fd = -1;
456 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
458 m->environment = strv_copy(environ);
462 manager_strip_environment(m);
464 if (running_as == SYSTEMD_SYSTEM) {
465 m->default_controllers = strv_new("cpu", NULL);
466 if (!m->default_controllers)
470 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
473 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
476 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
479 if (!(m->cgroup_bondings = 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 r = bus_init(m, running_as != SYSTEMD_SYSTEM);
510 m->taint_usr = dir_is_empty("/usr") > 0;
520 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
526 while ((u = m->cleanup_queue)) {
527 assert(u->in_cleanup_queue);
537 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
538 GC_OFFSET_UNSURE, /* No clue */
539 GC_OFFSET_GOOD, /* We still need this unit */
540 GC_OFFSET_BAD, /* We don't need this unit anymore */
544 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
551 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
552 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
553 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
556 if (u->in_cleanup_queue)
559 if (unit_check_gc(u))
562 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
566 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
567 unit_gc_sweep(other, gc_marker);
569 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
572 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
579 /* We were unable to find anything out about this entry, so
580 * let's investigate it later */
581 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
582 unit_add_to_gc_queue(u);
586 /* We definitely know that this one is not useful anymore, so
587 * let's mark it for deletion */
588 u->gc_marker = gc_marker + GC_OFFSET_BAD;
589 unit_add_to_cleanup_queue(u);
593 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
596 static unsigned manager_dispatch_gc_queue(Manager *m) {
603 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
604 (m->gc_queue_timestamp <= 0 ||
605 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
608 log_debug("Running GC...");
610 m->gc_marker += _GC_OFFSET_MAX;
611 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
614 gc_marker = m->gc_marker;
616 while ((u = m->gc_queue)) {
617 assert(u->in_gc_queue);
619 unit_gc_sweep(u, gc_marker);
621 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
622 u->in_gc_queue = false;
626 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
627 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
628 log_debug_unit(u->id, "Collecting %s", u->id);
629 u->gc_marker = gc_marker + GC_OFFSET_BAD;
630 unit_add_to_cleanup_queue(u);
634 m->n_in_gc_queue = 0;
635 m->gc_queue_timestamp = 0;
640 static void manager_clear_jobs_and_units(Manager *m) {
645 while ((u = hashmap_first(m->units)))
648 manager_dispatch_cleanup_queue(m);
650 assert(!m->load_queue);
651 assert(!m->run_queue);
652 assert(!m->dbus_unit_queue);
653 assert(!m->dbus_job_queue);
654 assert(!m->cleanup_queue);
655 assert(!m->gc_queue);
657 assert(hashmap_isempty(m->jobs));
658 assert(hashmap_isempty(m->units));
661 m->n_running_jobs = 0;
664 void manager_free(Manager *m) {
670 manager_clear_jobs_and_units(m);
672 for (c = 0; c < _UNIT_TYPE_MAX; c++)
673 if (unit_vtable[c]->shutdown)
674 unit_vtable[c]->shutdown(m);
676 /* If we reexecute ourselves, we keep the root cgroup
678 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
680 manager_undo_generators(m);
684 hashmap_free(m->units);
685 hashmap_free(m->jobs);
686 hashmap_free(m->watch_pids);
687 hashmap_free(m->watch_bus);
689 if (m->epoll_fd >= 0)
690 close_nointr_nofail(m->epoll_fd);
691 if (m->signal_watch.fd >= 0)
692 close_nointr_nofail(m->signal_watch.fd);
693 if (m->notify_watch.fd >= 0)
694 close_nointr_nofail(m->notify_watch.fd);
695 if (m->time_change_watch.fd >= 0)
696 close_nointr_nofail(m->time_change_watch.fd);
697 if (m->jobs_in_progress_watch.fd >= 0)
698 close_nointr_nofail(m->jobs_in_progress_watch.fd);
700 free(m->notify_socket);
702 lookup_paths_free(&m->lookup_paths);
703 strv_free(m->environment);
705 strv_free(m->default_controllers);
707 hashmap_free(m->cgroup_bondings);
708 set_free_free(m->unit_path_cache);
710 close_pipe(m->idle_pipe);
712 free(m->switch_root);
713 free(m->switch_root_init);
715 for (i = 0; i < RLIMIT_NLIMITS; i++)
721 int manager_enumerate(Manager *m) {
727 /* Let's ask every type to load all units from disk/kernel
728 * that it might know */
729 for (c = 0; c < _UNIT_TYPE_MAX; c++)
730 if (unit_vtable[c]->enumerate)
731 if ((q = unit_vtable[c]->enumerate(m)) < 0)
734 manager_dispatch_load_queue(m);
738 int manager_coldplug(Manager *m) {
746 /* Then, let's set up their initial state. */
747 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
753 if ((q = unit_coldplug(u)) < 0)
760 static void manager_build_unit_path_cache(Manager *m) {
762 _cleanup_free_ DIR *d = NULL;
767 set_free_free(m->unit_path_cache);
769 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
770 if (!m->unit_path_cache) {
771 log_error("Failed to allocate unit path cache.");
775 /* This simply builds a list of files we know exist, so that
776 * we don't always have to go to disk */
778 STRV_FOREACH(i, m->lookup_paths.unit_path) {
784 log_error("Failed to open directory %s: %m", *i);
788 while ((de = readdir(d))) {
791 if (ignore_file(de->d_name))
794 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
800 r = set_consume(m->unit_path_cache, p);
812 log_error("Failed to build unit path cache: %s", strerror(-r));
814 set_free_free(m->unit_path_cache);
815 m->unit_path_cache = NULL;
818 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
823 manager_run_generators(m);
825 r = lookup_paths_init(
826 &m->lookup_paths, m->running_as, true,
827 m->generator_unit_path,
828 m->generator_unit_path_early,
829 m->generator_unit_path_late);
833 manager_build_unit_path_cache(m);
835 /* If we will deserialize make sure that during enumeration
836 * this is already known, so we increase the counter here
841 /* First, enumerate what we can from all config files */
842 r = manager_enumerate(m);
844 /* Second, deserialize if there is something to deserialize */
846 q = manager_deserialize(m, serialization, fds);
851 /* Any fds left? Find some unit which wants them. This is
852 * useful to allow container managers to pass some file
853 * descriptors to us pre-initialized. This enables
854 * socket-based activation of entire containers. */
855 if (fdset_size(fds) > 0) {
856 q = manager_distribute_fds(m, fds);
861 /* Third, fire things up! */
862 q = manager_coldplug(m);
867 assert(m->n_reloading > 0);
874 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
879 assert(type < _JOB_TYPE_MAX);
881 assert(mode < _JOB_MODE_MAX);
883 if (mode == JOB_ISOLATE && type != JOB_START) {
884 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
888 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
889 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
893 log_debug_unit(unit->id,
894 "Trying to enqueue job %s/%s/%s", unit->id,
895 job_type_to_string(type), job_mode_to_string(mode));
897 job_type_collapse(&type, unit);
899 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
903 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
904 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
905 mode == JOB_IGNORE_DEPENDENCIES, e);
909 if (mode == JOB_ISOLATE) {
910 r = transaction_add_isolate_jobs(tr, m);
915 r = transaction_activate(tr, m, mode, e);
919 log_debug_unit(unit->id,
920 "Enqueued job %s/%s as %u", unit->id,
921 job_type_to_string(type), (unsigned) tr->anchor_job->id);
924 *_ret = tr->anchor_job;
926 transaction_free(tr);
930 transaction_abort(tr);
931 transaction_free(tr);
935 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
940 assert(type < _JOB_TYPE_MAX);
942 assert(mode < _JOB_MODE_MAX);
944 r = manager_load_unit(m, name, NULL, NULL, &unit);
948 return manager_add_job(m, type, unit, mode, override, e, _ret);
951 Job *manager_get_job(Manager *m, uint32_t id) {
954 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
957 Unit *manager_get_unit(Manager *m, const char *name) {
961 return hashmap_get(m->units, name);
964 unsigned manager_dispatch_load_queue(Manager *m) {
970 /* Make sure we are not run recursively */
971 if (m->dispatching_load_queue)
974 m->dispatching_load_queue = true;
976 /* Dispatches the load queue. Takes a unit from the queue and
977 * tries to load its data until the queue is empty */
979 while ((u = m->load_queue)) {
980 assert(u->in_load_queue);
986 m->dispatching_load_queue = false;
990 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
996 assert(name || path);
998 /* This will prepare the unit for loading, but not actually
999 * load anything from disk. */
1001 if (path && !is_path(path)) {
1002 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1007 name = path_get_file_name(path);
1009 t = unit_name_to_type(name);
1011 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
1012 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1016 ret = manager_get_unit(m, name);
1022 ret = unit_new(m, unit_vtable[t]->object_size);
1027 ret->fragment_path = strdup(path);
1028 if (!ret->fragment_path) {
1034 if ((r = unit_add_name(ret, name)) < 0) {
1039 unit_add_to_load_queue(ret);
1040 unit_add_to_dbus_queue(ret);
1041 unit_add_to_gc_queue(ret);
1049 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1054 /* This will load the service information files, but not actually
1055 * start any services or anything. */
1057 r = manager_load_unit_prepare(m, name, path, e, _ret);
1061 manager_dispatch_load_queue(m);
1064 *_ret = unit_follow_merge(*_ret);
1069 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1076 HASHMAP_FOREACH(j, s->jobs, i)
1077 job_dump(j, f, prefix);
1080 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1088 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1090 unit_dump(u, f, prefix);
1093 void manager_clear_jobs(Manager *m) {
1098 while ((j = hashmap_first(m->jobs)))
1099 /* No need to recurse. We're cancelling all jobs. */
1100 job_finish_and_invalidate(j, JOB_CANCELED, false);
1103 unsigned manager_dispatch_run_queue(Manager *m) {
1107 if (m->dispatching_run_queue)
1110 m->dispatching_run_queue = true;
1112 while ((j = m->run_queue)) {
1113 assert(j->installed);
1114 assert(j->in_run_queue);
1116 job_run_and_invalidate(j);
1120 m->dispatching_run_queue = false;
1122 if (m->n_running_jobs > 0)
1123 manager_watch_jobs_in_progress(m);
1128 unsigned manager_dispatch_dbus_queue(Manager *m) {
1135 if (m->dispatching_dbus_queue)
1138 m->dispatching_dbus_queue = true;
1140 while ((u = m->dbus_unit_queue)) {
1141 assert(u->in_dbus_queue);
1143 bus_unit_send_change_signal(u);
1147 while ((j = m->dbus_job_queue)) {
1148 assert(j->in_dbus_queue);
1150 bus_job_send_change_signal(j);
1154 m->dispatching_dbus_queue = false;
1158 static int manager_process_notify_fd(Manager *m) {
1165 struct iovec iovec = {
1167 .iov_len = sizeof(buf)-1,
1171 struct cmsghdr cmsghdr;
1172 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1175 struct msghdr msghdr = {
1178 .msg_control = &control,
1179 .msg_controllen = sizeof(control),
1181 struct ucred *ucred;
1183 _cleanup_strv_free_ char **tags = NULL;
1185 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1190 if (errno == EAGAIN || errno == EINTR)
1196 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1197 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1198 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1199 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1200 log_warning("Received notify message without credentials. Ignoring.");
1204 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1206 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1208 u = cgroup_unit_by_pid(m, ucred->pid);
1210 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1215 assert((size_t) n < sizeof(buf));
1217 tags = strv_split(buf, "\n\r");
1221 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1223 if (UNIT_VTABLE(u)->notify_message)
1224 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1230 static int manager_dispatch_sigchld(Manager *m) {
1238 /* First we call waitd() for a PID and do not reap the
1239 * zombie. That way we can still access /proc/$PID for
1240 * it while it is a zombie. */
1241 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1243 if (errno == ECHILD)
1255 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1256 _cleanup_free_ char *name = NULL;
1258 get_process_comm(si.si_pid, &name);
1259 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1262 /* Let's flush any message the dying child might still
1263 * have queued for us. This ensures that the process
1264 * still exists in /proc so that we can figure out
1265 * which cgroup and hence unit it belongs to. */
1266 r = manager_process_notify_fd(m);
1270 /* And now figure out the unit this belongs to */
1271 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1273 u = cgroup_unit_by_pid(m, si.si_pid);
1275 /* And now, we actually reap the zombie. */
1276 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1283 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1286 log_debug("Child %lu died (code=%s, status=%i/%s)",
1287 (long unsigned) si.si_pid,
1288 sigchld_code_to_string(si.si_code),
1290 strna(si.si_code == CLD_EXITED
1291 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1292 : signal_to_string(si.si_status)));
1297 log_debug_unit(u->id,
1298 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1300 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1301 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1307 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1311 dbus_error_init(&error);
1313 log_debug_unit(name, "Activating special unit %s", name);
1315 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1317 log_error_unit(name,
1318 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1320 dbus_error_free(&error);
1325 static int manager_process_signal_fd(Manager *m) {
1327 struct signalfd_siginfo sfsi;
1328 bool sigchld = false;
1333 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1334 if (n != sizeof(sfsi)) {
1339 if (errno == EINTR || errno == EAGAIN)
1345 if (sfsi.ssi_pid > 0) {
1348 get_process_comm(sfsi.ssi_pid, &p);
1350 log_debug("Received SIG%s from PID %lu (%s).",
1351 signal_to_string(sfsi.ssi_signo),
1352 (unsigned long) sfsi.ssi_pid, strna(p));
1355 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1357 switch (sfsi.ssi_signo) {
1364 if (m->running_as == SYSTEMD_SYSTEM) {
1365 /* This is for compatibility with the
1366 * original sysvinit */
1367 m->exit_code = MANAGER_REEXECUTE;
1374 if (m->running_as == SYSTEMD_SYSTEM) {
1375 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1379 /* Run the exit target if there is one, if not, just exit. */
1380 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1381 m->exit_code = MANAGER_EXIT;
1388 if (m->running_as == SYSTEMD_SYSTEM)
1389 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1391 /* This is a nop on non-init */
1395 if (m->running_as == SYSTEMD_SYSTEM)
1396 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1398 /* This is a nop on non-init */
1404 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1406 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1407 log_info("Trying to reconnect to bus...");
1411 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1412 log_info("Loading D-Bus service...");
1413 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1424 if (!(f = open_memstream(&dump, &size))) {
1425 log_warning("Failed to allocate memory stream.");
1429 manager_dump_units(m, f, "\t");
1430 manager_dump_jobs(m, f, "\t");
1435 log_warning("Failed to write status stream");
1440 log_dump(LOG_INFO, dump);
1447 m->exit_code = MANAGER_RELOAD;
1452 /* Starting SIGRTMIN+0 */
1453 static const char * const target_table[] = {
1454 [0] = SPECIAL_DEFAULT_TARGET,
1455 [1] = SPECIAL_RESCUE_TARGET,
1456 [2] = SPECIAL_EMERGENCY_TARGET,
1457 [3] = SPECIAL_HALT_TARGET,
1458 [4] = SPECIAL_POWEROFF_TARGET,
1459 [5] = SPECIAL_REBOOT_TARGET,
1460 [6] = SPECIAL_KEXEC_TARGET
1463 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1464 static const ManagerExitCode code_table[] = {
1466 [1] = MANAGER_POWEROFF,
1467 [2] = MANAGER_REBOOT,
1471 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1472 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1473 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1474 manager_start_target(m, target_table[idx],
1475 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1479 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1480 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1481 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1485 switch (sfsi.ssi_signo - SIGRTMIN) {
1488 log_debug("Enabling showing of status.");
1489 manager_set_show_status(m, true);
1493 log_debug("Disabling showing of status.");
1494 manager_set_show_status(m, false);
1498 log_set_max_level(LOG_DEBUG);
1499 log_notice("Setting log level to debug.");
1503 log_set_max_level(LOG_INFO);
1504 log_notice("Setting log level to info.");
1508 if (m->running_as == SYSTEMD_USER) {
1509 m->exit_code = MANAGER_EXIT;
1513 /* This is a nop on init */
1517 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1518 log_notice("Setting log target to journal-or-kmsg.");
1522 log_set_target(LOG_TARGET_CONSOLE);
1523 log_notice("Setting log target to console.");
1527 log_set_target(LOG_TARGET_KMSG);
1528 log_notice("Setting log target to kmsg.");
1532 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1533 log_notice("Setting log target to syslog-or-kmsg.");
1537 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1544 return manager_dispatch_sigchld(m);
1549 static int process_event(Manager *m, struct epoll_event *ev) {
1556 assert_se(w = ev->data.ptr);
1558 if (w->type == WATCH_INVALID)
1565 /* An incoming signal? */
1566 if (ev->events != EPOLLIN)
1569 if ((r = manager_process_signal_fd(m)) < 0)
1576 /* An incoming daemon notification event? */
1577 if (ev->events != EPOLLIN)
1580 if ((r = manager_process_notify_fd(m)) < 0)
1587 /* Some fd event, to be dispatched to the units */
1588 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1591 case WATCH_UNIT_TIMER:
1592 case WATCH_JOB_TIMER: {
1596 /* Some timer event, to be dispatched to the units */
1597 k = read(w->fd, &v, sizeof(v));
1598 if (k != sizeof(v)) {
1600 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1603 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1604 return k < 0 ? -errno : -EIO;
1607 if (w->type == WATCH_UNIT_TIMER)
1608 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1610 job_timer_event(w->data.job, v, w);
1615 /* Some mount table change, intended for the mount subsystem */
1616 mount_fd_event(m, ev->events);
1620 /* Some swap table change, intended for the swap subsystem */
1621 swap_fd_event(m, ev->events);
1625 /* Some notification from udev, intended for the device subsystem */
1626 device_fd_event(m, ev->events);
1629 case WATCH_DBUS_WATCH:
1630 bus_watch_event(m, w, ev->events);
1633 case WATCH_DBUS_TIMEOUT:
1634 bus_timeout_event(m, w, ev->events);
1637 case WATCH_TIME_CHANGE: {
1641 log_struct(LOG_INFO,
1642 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1643 "MESSAGE=Time has been changed",
1646 /* Restart the watch */
1647 epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->time_change_watch.fd,
1649 close_nointr_nofail(m->time_change_watch.fd);
1650 watch_init(&m->time_change_watch);
1651 manager_setup_time_change(m);
1653 HASHMAP_FOREACH(u, m->units, i) {
1654 if (UNIT_VTABLE(u)->time_change)
1655 UNIT_VTABLE(u)->time_change(u);
1661 case WATCH_JOBS_IN_PROGRESS: {
1664 /* not interested in the data */
1665 read(w->fd, &v, sizeof(v));
1667 manager_print_jobs_in_progress(m);
1672 log_error("event type=%i", w->type);
1673 assert_not_reached("Unknown epoll event type.");
1679 int manager_loop(Manager *m) {
1682 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1685 m->exit_code = MANAGER_RUNNING;
1687 /* Release the path cache */
1688 set_free_free(m->unit_path_cache);
1689 m->unit_path_cache = NULL;
1691 manager_check_finished(m);
1693 /* There might still be some zombies hanging around from
1694 * before we were exec()'ed. Leat's reap them */
1695 r = manager_dispatch_sigchld(m);
1699 while (m->exit_code == MANAGER_RUNNING) {
1700 struct epoll_event event;
1704 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1707 if (!ratelimit_test(&rl)) {
1708 /* Yay, something is going seriously wrong, pause a little */
1709 log_warning("Looping too fast. Throttling execution a little.");
1714 if (manager_dispatch_load_queue(m) > 0)
1717 if (manager_dispatch_run_queue(m) > 0)
1720 if (bus_dispatch(m) > 0)
1723 if (manager_dispatch_cleanup_queue(m) > 0)
1726 if (manager_dispatch_gc_queue(m) > 0)
1729 if (manager_dispatch_dbus_queue(m) > 0)
1732 if (swap_dispatch_reload(m) > 0)
1735 /* Sleep for half the watchdog time */
1736 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1737 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1743 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1755 r = process_event(m, &event);
1760 return m->exit_code;
1763 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1772 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1775 n = bus_path_unescape(s+31);
1779 r = manager_load_unit(m, n, NULL, e, &u);
1790 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1799 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1802 r = safe_atou(s + 30, &id);
1806 j = manager_get_job(m, id);
1815 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1821 audit_fd = get_audit_fd();
1825 /* Don't generate audit events if the service was already
1826 * started and we're just deserializing */
1827 if (m->n_reloading > 0)
1830 if (m->running_as != SYSTEMD_SYSTEM)
1833 if (u->type != UNIT_SERVICE)
1836 p = unit_name_to_prefix_and_instance(u->id);
1838 log_error_unit(u->id,
1839 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1843 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1844 if (errno == EPERM) {
1845 /* We aren't allowed to send audit messages?
1846 * Then let's not retry again. */
1849 log_warning("Failed to send audit message: %m");
1857 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1859 union sockaddr_union sa;
1861 char *message = NULL;
1863 /* Don't generate plymouth events if the service was already
1864 * started and we're just deserializing */
1865 if (m->n_reloading > 0)
1868 if (m->running_as != SYSTEMD_SYSTEM)
1871 if (u->type != UNIT_SERVICE &&
1872 u->type != UNIT_MOUNT &&
1873 u->type != UNIT_SWAP)
1876 /* We set SOCK_NONBLOCK here so that we rather drop the
1877 * message then wait for plymouth */
1878 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1880 log_error("socket() failed: %m");
1885 sa.sa.sa_family = AF_UNIX;
1886 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1887 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1889 if (errno != EPIPE &&
1892 errno != ECONNREFUSED &&
1893 errno != ECONNRESET &&
1894 errno != ECONNABORTED)
1895 log_error("connect() failed: %m");
1900 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1906 if (write(fd, message, n + 1) != n + 1) {
1908 if (errno != EPIPE &&
1911 errno != ECONNREFUSED &&
1912 errno != ECONNRESET &&
1913 errno != ECONNABORTED)
1914 log_error("Failed to write Plymouth message: %m");
1921 close_nointr_nofail(fd);
1926 void manager_dispatch_bus_name_owner_changed(
1929 const char* old_owner,
1930 const char *new_owner) {
1937 if (!(u = hashmap_get(m->watch_bus, name)))
1940 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1943 void manager_dispatch_bus_query_pid_done(
1954 if (!(u = hashmap_get(m->watch_bus, name)))
1957 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1960 int manager_open_serialization(Manager *m, FILE **_f) {
1967 if (m->running_as == SYSTEMD_SYSTEM)
1968 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1970 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1975 RUN_WITH_UMASK(0077) {
1976 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1986 log_debug("Serializing state to %s", path);
1989 f = fdopen(fd, "w+");
1998 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2011 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2012 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2013 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2014 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2016 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2017 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2018 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2019 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2022 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2023 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2026 if (!switching_root) {
2027 STRV_FOREACH(e, m->environment) {
2028 _cleanup_free_ char *ce;
2032 fprintf(f, "env=%s\n", *e);
2038 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2042 if (!unit_can_serialize(u))
2049 if ((r = unit_serialize(u, f, fds, !switching_root)) < 0) {
2055 assert(m->n_reloading > 0);
2061 r = bus_fdset_add_all(m, fds);
2068 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2074 log_debug("Deserializing state...");
2079 char line[LINE_MAX], *l;
2081 if (!fgets(line, sizeof(line), f)) {
2096 if (startswith(l, "current-job-id=")) {
2099 if (safe_atou32(l+15, &id) < 0)
2100 log_debug("Failed to parse current job id value %s", l+15);
2102 m->current_job_id = MAX(m->current_job_id, id);
2103 } else if (startswith(l, "n-installed-jobs=")) {
2106 if (safe_atou32(l+17, &n) < 0)
2107 log_debug("Failed to parse installed jobs counter %s", l+17);
2109 m->n_installed_jobs += n;
2110 } else if (startswith(l, "n-failed-jobs=")) {
2113 if (safe_atou32(l+14, &n) < 0)
2114 log_debug("Failed to parse failed jobs counter %s", l+14);
2116 m->n_failed_jobs += n;
2117 } else if (startswith(l, "taint-usr=")) {
2120 if ((b = parse_boolean(l+10)) < 0)
2121 log_debug("Failed to parse taint /usr flag %s", l+10);
2123 m->taint_usr = m->taint_usr || b;
2124 } else if (startswith(l, "firmware-timestamp="))
2125 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2126 else if (startswith(l, "loader-timestamp="))
2127 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2128 else if (startswith(l, "kernel-timestamp="))
2129 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2130 else if (startswith(l, "initrd-timestamp="))
2131 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2132 else if (startswith(l, "userspace-timestamp="))
2133 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2134 else if (startswith(l, "finish-timestamp="))
2135 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2136 else if (startswith(l, "env=")) {
2137 _cleanup_free_ char *uce = NULL;
2140 uce = cunescape(l+4);
2146 e = strv_env_set(m->environment, uce);
2152 strv_free(m->environment);
2155 log_debug("Unknown serialization item '%s'", l);
2160 char name[UNIT_NAME_MAX+2];
2163 if (!fgets(name, sizeof(name), f)) {
2174 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2178 r = unit_deserialize(u, f, fds);
2189 assert(m->n_reloading > 0);
2195 int manager_distribute_fds(Manager *m, FDSet *fds) {
2202 HASHMAP_FOREACH(u, m->units, i) {
2204 if (fdset_size(fds) <= 0)
2207 if (UNIT_VTABLE(u)->distribute_fds) {
2208 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2217 int manager_reload(Manager *m) {
2224 r = manager_open_serialization(m, &f);
2237 r = manager_serialize(m, f, fds, false);
2243 if (fseeko(f, 0, SEEK_SET) < 0) {
2249 /* From here on there is no way back. */
2250 manager_clear_jobs_and_units(m);
2251 manager_undo_generators(m);
2252 lookup_paths_free(&m->lookup_paths);
2254 /* Find new unit paths */
2255 manager_run_generators(m);
2257 q = lookup_paths_init(
2258 &m->lookup_paths, m->running_as, true,
2259 m->generator_unit_path,
2260 m->generator_unit_path_early,
2261 m->generator_unit_path_late);
2265 manager_build_unit_path_cache(m);
2267 /* First, enumerate what we can from all config files */
2268 q = manager_enumerate(m);
2272 /* Second, deserialize our stored data */
2273 q = manager_deserialize(m, f, fds);
2280 /* Third, fire things up! */
2281 q = manager_coldplug(m);
2285 assert(m->n_reloading > 0);
2298 static bool manager_is_booting_or_shutting_down(Manager *m) {
2303 /* Is the initial job still around? */
2304 if (manager_get_job(m, m->default_unit_job_id))
2307 /* Is there a job for the shutdown target? */
2308 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2315 bool manager_is_reloading_or_reexecuting(Manager *m) {
2318 return m->n_reloading != 0;
2321 void manager_reset_failed(Manager *m) {
2327 HASHMAP_FOREACH(u, m->units, i)
2328 unit_reset_failed(u);
2331 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2337 /* Returns true if the unit is inactive or going down */
2338 u = manager_get_unit(m, name);
2342 return unit_inactive_or_pending(u);
2345 void manager_check_finished(Manager *m) {
2346 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2347 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2351 if (m->n_running_jobs == 0)
2352 manager_unwatch_jobs_in_progress(m);
2354 if (hashmap_size(m->jobs) > 0) {
2355 manager_jobs_in_progress_mod_timer(m);
2359 /* Notify Type=idle units that we are done now */
2360 close_pipe(m->idle_pipe);
2362 /* Turn off confirm spawn now */
2363 m->confirm_spawn = false;
2365 if (dual_timestamp_is_set(&m->finish_timestamp))
2368 dual_timestamp_get(&m->finish_timestamp);
2370 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2372 /* Note that m->kernel_usec.monotonic is always at 0,
2373 * and m->firmware_usec.monotonic and
2374 * m->loader_usec.monotonic should be considered
2375 * negative values. */
2377 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2378 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2379 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2380 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2382 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2384 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2385 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2387 if (!log_on_console())
2388 log_struct(LOG_INFO,
2389 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2390 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2391 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2392 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2393 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2394 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2395 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2396 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2397 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2400 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2403 if (!log_on_console())
2404 log_struct(LOG_INFO,
2405 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2406 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2407 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2408 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2409 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2410 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2411 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2415 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2416 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2418 if (!log_on_console())
2419 log_struct(LOG_INFO,
2420 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2421 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2422 "MESSAGE=Startup finished in %s.",
2423 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2427 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2430 "READY=1\nSTATUS=Startup finished in %s.",
2431 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2434 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2445 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2447 p = strappend("/run/systemd/", name);
2451 r = mkdir_p_label(p, 0755);
2453 log_error("Failed to create generator directory %s: %s",
2459 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2464 log_error("Failed to create generator directory %s: %m",
2475 static void trim_generator_dir(Manager *m, char **generator) {
2482 if (rmdir(*generator) >= 0) {
2490 void manager_run_generators(Manager *m) {
2492 const char *generator_path;
2493 const char *argv[5];
2498 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2499 d = opendir(generator_path);
2501 if (errno == ENOENT)
2504 log_error("Failed to enumerate generator directory %s: %m",
2509 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2513 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2517 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2521 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2522 argv[1] = m->generator_unit_path;
2523 argv[2] = m->generator_unit_path_early;
2524 argv[3] = m->generator_unit_path_late;
2527 RUN_WITH_UMASK(0022) {
2528 execute_directory(generator_path, d, (char**) argv);
2531 trim_generator_dir(m, &m->generator_unit_path);
2532 trim_generator_dir(m, &m->generator_unit_path_early);
2533 trim_generator_dir(m, &m->generator_unit_path_late);
2540 static void remove_generator_dir(Manager *m, char **generator) {
2547 strv_remove(m->lookup_paths.unit_path, *generator);
2548 rm_rf(*generator, false, true, false);
2554 void manager_undo_generators(Manager *m) {
2557 remove_generator_dir(m, &m->generator_unit_path);
2558 remove_generator_dir(m, &m->generator_unit_path_early);
2559 remove_generator_dir(m, &m->generator_unit_path_late);
2562 int manager_set_default_controllers(Manager *m, char **controllers) {
2567 l = strv_copy(controllers);
2571 strv_free(m->default_controllers);
2572 m->default_controllers = l;
2574 cg_shorten_controllers(m->default_controllers);
2579 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2584 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2585 if (!default_rlimit[i])
2588 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2596 void manager_recheck_journal(Manager *m) {
2601 if (m->running_as != SYSTEMD_SYSTEM)
2604 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2605 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2606 log_close_journal();
2610 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2611 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2612 log_close_journal();
2616 /* Hmm, OK, so the socket is fully up and the service is up
2617 * too, then let's make use of the thing. */
2621 void manager_set_show_status(Manager *m, bool b) {
2624 if (m->running_as != SYSTEMD_SYSTEM)
2630 touch("/run/systemd/show-status");
2632 unlink("/run/systemd/show-status");
2635 static bool manager_get_show_status(Manager *m) {
2638 if (m->running_as != SYSTEMD_SYSTEM)
2644 /* If Plymouth is running make sure we show the status, so
2645 * that there's something nice to see when people press Esc */
2647 return plymouth_running();
2650 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2653 if (!manager_get_show_status(m))
2656 /* XXX We should totally drop the check for ephemeral here
2657 * and thus effectively make 'Type=idle' pointless. */
2658 if (ephemeral && m->n_on_console > 0)
2661 if (!manager_is_booting_or_shutting_down(m))
2664 va_start(ap, format);
2665 status_vprintf(status, true, ephemeral, format, ap);
2669 void watch_init(Watch *w) {
2672 w->type = WATCH_INVALID;