1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
25 #include <sys/epoll.h>
27 #include <sys/signalfd.h>
31 #include <sys/reboot.h>
32 #include <sys/ioctl.h>
36 #include <sys/types.h>
39 #include <sys/timerfd.h>
45 #include "systemd/sd-daemon.h"
46 #include "systemd/sd-id128.h"
47 #include "systemd/sd-messages.h"
50 #include "transaction.h"
57 #include "ratelimit.h"
59 #include "mount-setup.h"
60 #include "unit-name.h"
61 #include "dbus-unit.h"
64 #include "path-lookup.h"
66 #include "bus-errors.h"
67 #include "exit-status.h"
70 #include "cgroup-util.h"
71 #include "path-util.h"
76 /* As soon as 16 units are in our GC queue, make sure to run a gc sweep */
77 #define GC_QUEUE_ENTRIES_MAX 16
79 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
80 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
82 /* Initial delay and the interval for printing status messages about running jobs */
83 #define JOBS_IN_PROGRESS_WAIT_SEC 5
84 #define JOBS_IN_PROGRESS_PERIOD_SEC 1
85 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
87 /* Where clients shall send notification messages to */
88 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
90 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
92 static int manager_setup_notify(Manager *m) {
95 struct sockaddr_un un;
97 struct epoll_event ev;
102 m->notify_watch.type = WATCH_NOTIFY;
103 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
104 if (m->notify_watch.fd < 0) {
105 log_error("Failed to allocate notification socket: %m");
110 sa.sa.sa_family = AF_UNIX;
112 if (getpid() != 1 || detect_container(NULL) > 0)
113 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
115 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
117 sa.un.sun_path[0] = 0;
119 if (bind(m->notify_watch.fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
120 log_error("bind() failed: %m");
124 if (setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0) {
125 log_error("SO_PASSCRED failed: %m");
131 ev.data.ptr = &m->notify_watch;
133 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev) < 0) {
134 log_error("Failed to add notification socket fd to epoll: %m");
138 sa.un.sun_path[0] = '@';
139 m->notify_socket = strdup(sa.un.sun_path);
140 if (!m->notify_socket)
143 log_debug("Using notification socket %s", m->notify_socket);
148 static int manager_jobs_in_progress_mod_timer(Manager *m) {
149 struct itimerspec its;
153 its.it_value.tv_sec = JOBS_IN_PROGRESS_WAIT_SEC;
154 its.it_interval.tv_sec = JOBS_IN_PROGRESS_PERIOD_SEC;
156 if (timerfd_settime(m->jobs_in_progress_watch.fd, 0, &its, NULL) < 0)
162 static int manager_watch_jobs_in_progress(Manager *m) {
163 struct epoll_event ev;
168 if (m->jobs_in_progress_watch.type != WATCH_INVALID)
171 m->jobs_in_progress_watch.type = WATCH_JOBS_IN_PROGRESS;
172 m->jobs_in_progress_watch.fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
173 if (m->jobs_in_progress_watch.fd < 0) {
174 log_error("Failed to create timerfd: %m");
179 r = manager_jobs_in_progress_mod_timer(m);
181 log_error("Failed to set up timer for jobs progress watch: %s", strerror(-r));
187 ev.data.ptr = &m->jobs_in_progress_watch;
189 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->jobs_in_progress_watch.fd, &ev) < 0) {
190 log_error("Failed to add jobs progress timer fd to epoll: %m");
195 log_debug("Set up jobs progress timerfd.");
200 if (m->jobs_in_progress_watch.fd >= 0)
201 close_nointr_nofail(m->jobs_in_progress_watch.fd);
202 watch_init(&m->jobs_in_progress_watch);
206 static void manager_unwatch_jobs_in_progress(Manager *m) {
207 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
210 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->jobs_in_progress_watch.fd, NULL) >= 0);
211 close_nointr_nofail(m->jobs_in_progress_watch.fd);
212 watch_init(&m->jobs_in_progress_watch);
213 m->jobs_in_progress_iteration = 0;
215 log_debug("Closed jobs progress timerfd.");
218 #define CYLON_BUFFER_EXTRA (2*strlen(ANSI_RED_ON) + strlen(ANSI_HIGHLIGHT_RED_ON) + 2*strlen(ANSI_HIGHLIGHT_OFF))
219 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
222 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
223 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
227 memset(p, ' ', pos-2);
230 memcpy(p, ANSI_RED_ON, strlen(ANSI_RED_ON));
231 p += strlen(ANSI_RED_ON);
235 if (pos > 0 && pos <= width) {
236 memcpy(p, ANSI_HIGHLIGHT_RED_ON, strlen(ANSI_HIGHLIGHT_RED_ON));
237 p += strlen(ANSI_HIGHLIGHT_RED_ON);
241 memcpy(p, ANSI_HIGHLIGHT_OFF, strlen(ANSI_HIGHLIGHT_OFF));
242 p += strlen(ANSI_HIGHLIGHT_OFF);
245 memcpy(p, ANSI_RED_ON, strlen(ANSI_RED_ON));
246 p += strlen(ANSI_RED_ON);
249 memset(p, ' ', width-1-pos);
252 memcpy(p, ANSI_HIGHLIGHT_OFF, strlen(ANSI_HIGHLIGHT_OFF));
253 p += strlen(ANSI_HIGHLIGHT_OFF);
258 static void manager_print_jobs_in_progress(Manager *m) {
261 char *job_of_n = NULL;
262 unsigned counter = 0, print_nr;
263 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
266 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
268 HASHMAP_FOREACH(j, m->jobs, i)
269 if (j->state == JOB_RUNNING && counter++ == print_nr)
272 /* m->n_running_jobs must be consistent with the contents of m->jobs,
273 * so the above loop must have succeeded in finding j. */
274 assert(counter == print_nr + 1);
276 cylon_pos = m->jobs_in_progress_iteration % 14;
278 cylon_pos = 14 - cylon_pos;
279 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
281 if (m->n_running_jobs > 1)
282 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
285 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
286 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
289 m->jobs_in_progress_iteration++;
292 static int manager_setup_time_change(Manager *m) {
293 struct epoll_event ev;
294 struct itimerspec its;
297 assert(m->time_change_watch.type == WATCH_INVALID);
299 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
300 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
302 m->time_change_watch.type = WATCH_TIME_CHANGE;
303 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
304 if (m->time_change_watch.fd < 0) {
305 log_error("Failed to create timerfd: %m");
311 /* We only care for the cancellation event, hence we set the
312 * timeout to the latest possible value. */
313 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
314 its.it_value.tv_sec = TIME_T_MAX;
316 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
317 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
318 close_nointr_nofail(m->time_change_watch.fd);
319 watch_init(&m->time_change_watch);
325 ev.data.ptr = &m->time_change_watch;
327 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
328 log_error("Failed to add timer change fd to epoll: %m");
332 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
337 static int enable_special_signals(Manager *m) {
342 /* Enable that we get SIGINT on control-alt-del. In containers
343 * this will fail with EPERM (older) or EINVAL (newer), so
345 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
346 log_warning("Failed to enable ctrl-alt-del handling: %m");
348 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
350 /* Support systems without virtual console */
352 log_warning("Failed to open /dev/tty0: %m");
354 /* Enable that we get SIGWINCH on kbrequest */
355 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
356 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
358 close_nointr_nofail(fd);
364 static int manager_setup_signals(Manager *m) {
366 struct epoll_event ev;
371 /* We are not interested in SIGSTOP and friends. */
373 sa.sa_handler = SIG_DFL;
374 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
375 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
377 assert_se(sigemptyset(&mask) == 0);
379 sigset_add_many(&mask,
380 SIGCHLD, /* Child died */
381 SIGTERM, /* Reexecute daemon */
382 SIGHUP, /* Reload configuration */
383 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
384 SIGUSR2, /* systemd: dump status */
385 SIGINT, /* Kernel sends us this on control-alt-del */
386 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
387 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
388 SIGRTMIN+0, /* systemd: start default.target */
389 SIGRTMIN+1, /* systemd: isolate rescue.target */
390 SIGRTMIN+2, /* systemd: isolate emergency.target */
391 SIGRTMIN+3, /* systemd: start halt.target */
392 SIGRTMIN+4, /* systemd: start poweroff.target */
393 SIGRTMIN+5, /* systemd: start reboot.target */
394 SIGRTMIN+6, /* systemd: start kexec.target */
395 SIGRTMIN+13, /* systemd: Immediate halt */
396 SIGRTMIN+14, /* systemd: Immediate poweroff */
397 SIGRTMIN+15, /* systemd: Immediate reboot */
398 SIGRTMIN+16, /* systemd: Immediate kexec */
399 SIGRTMIN+20, /* systemd: enable status messages */
400 SIGRTMIN+21, /* systemd: disable status messages */
401 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
402 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
403 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
404 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
405 SIGRTMIN+27, /* systemd: set log target to console */
406 SIGRTMIN+28, /* systemd: set log target to kmsg */
407 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
409 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
411 m->signal_watch.type = WATCH_SIGNAL;
412 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
413 if (m->signal_watch.fd < 0)
418 ev.data.ptr = &m->signal_watch;
420 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
423 if (m->running_as == SYSTEMD_SYSTEM)
424 return enable_special_signals(m);
429 static void manager_strip_environment(Manager *m) {
432 /* Remove variables from the inherited set that are part of
433 * the container interface:
434 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
435 strv_remove_prefix(m->environment, "container=");
436 strv_remove_prefix(m->environment, "container_");
438 /* Remove variables from the inherited set that are part of
439 * the initrd interface:
440 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
441 strv_remove_prefix(m->environment, "RD_");
443 /* Drop invalid entries */
444 strv_env_clean(m->environment);
447 int manager_new(SystemdRunningAs running_as, Manager **_m) {
452 assert(running_as >= 0);
453 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
455 m = new0(Manager, 1);
459 dual_timestamp_get(&m->userspace_timestamp);
460 dual_timestamp_from_monotonic(&m->kernel_timestamp, 0);
462 efi_get_boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
465 m->running_as = running_as;
466 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
467 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
468 m->pin_cgroupfs_fd = -1;
469 m->idle_pipe[0] = m->idle_pipe[1] = -1;
471 watch_init(&m->signal_watch);
472 watch_init(&m->mount_watch);
473 watch_init(&m->swap_watch);
474 watch_init(&m->udev_watch);
475 watch_init(&m->time_change_watch);
476 watch_init(&m->jobs_in_progress_watch);
478 m->epoll_fd = m->dev_autofs_fd = -1;
479 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
481 m->environment = strv_copy(environ);
485 manager_strip_environment(m);
487 if (running_as == SYSTEMD_SYSTEM) {
488 m->default_controllers = strv_new("cpu", NULL);
489 if (!m->default_controllers)
493 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
496 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
499 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
502 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
505 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
508 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
512 r = manager_setup_signals(m);
516 r = manager_setup_cgroup(m);
520 r = manager_setup_notify(m);
524 r = manager_setup_time_change(m);
528 /* Try to connect to the busses, if possible. */
529 r = bus_init(m, running_as != SYSTEMD_SYSTEM);
533 m->taint_usr = dir_is_empty("/usr") > 0;
543 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
549 while ((u = m->cleanup_queue)) {
550 assert(u->in_cleanup_queue);
560 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
561 GC_OFFSET_UNSURE, /* No clue */
562 GC_OFFSET_GOOD, /* We still need this unit */
563 GC_OFFSET_BAD, /* We don't need this unit anymore */
567 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
574 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
575 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
576 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
579 if (u->in_cleanup_queue)
582 if (unit_check_gc(u))
585 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
589 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
590 unit_gc_sweep(other, gc_marker);
592 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
595 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
602 /* We were unable to find anything out about this entry, so
603 * let's investigate it later */
604 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
605 unit_add_to_gc_queue(u);
609 /* We definitely know that this one is not useful anymore, so
610 * let's mark it for deletion */
611 u->gc_marker = gc_marker + GC_OFFSET_BAD;
612 unit_add_to_cleanup_queue(u);
616 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
619 static unsigned manager_dispatch_gc_queue(Manager *m) {
626 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
627 (m->gc_queue_timestamp <= 0 ||
628 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
631 log_debug("Running GC...");
633 m->gc_marker += _GC_OFFSET_MAX;
634 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
637 gc_marker = m->gc_marker;
639 while ((u = m->gc_queue)) {
640 assert(u->in_gc_queue);
642 unit_gc_sweep(u, gc_marker);
644 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
645 u->in_gc_queue = false;
649 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
650 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
651 log_debug_unit(u->id, "Collecting %s", u->id);
652 u->gc_marker = gc_marker + GC_OFFSET_BAD;
653 unit_add_to_cleanup_queue(u);
657 m->n_in_gc_queue = 0;
658 m->gc_queue_timestamp = 0;
663 static void manager_clear_jobs_and_units(Manager *m) {
668 while ((u = hashmap_first(m->units)))
671 manager_dispatch_cleanup_queue(m);
673 assert(!m->load_queue);
674 assert(!m->run_queue);
675 assert(!m->dbus_unit_queue);
676 assert(!m->dbus_job_queue);
677 assert(!m->cleanup_queue);
678 assert(!m->gc_queue);
680 assert(hashmap_isempty(m->jobs));
681 assert(hashmap_isempty(m->units));
684 m->n_running_jobs = 0;
687 void manager_free(Manager *m) {
693 manager_clear_jobs_and_units(m);
695 for (c = 0; c < _UNIT_TYPE_MAX; c++)
696 if (unit_vtable[c]->shutdown)
697 unit_vtable[c]->shutdown(m);
699 /* If we reexecute ourselves, we keep the root cgroup
701 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
703 manager_undo_generators(m);
707 hashmap_free(m->units);
708 hashmap_free(m->jobs);
709 hashmap_free(m->watch_pids);
710 hashmap_free(m->watch_bus);
712 if (m->epoll_fd >= 0)
713 close_nointr_nofail(m->epoll_fd);
714 if (m->signal_watch.fd >= 0)
715 close_nointr_nofail(m->signal_watch.fd);
716 if (m->notify_watch.fd >= 0)
717 close_nointr_nofail(m->notify_watch.fd);
718 if (m->time_change_watch.fd >= 0)
719 close_nointr_nofail(m->time_change_watch.fd);
720 if (m->jobs_in_progress_watch.fd >= 0)
721 close_nointr_nofail(m->jobs_in_progress_watch.fd);
723 free(m->notify_socket);
725 lookup_paths_free(&m->lookup_paths);
726 strv_free(m->environment);
728 strv_free(m->default_controllers);
730 hashmap_free(m->cgroup_bondings);
731 set_free_free(m->unit_path_cache);
733 close_pipe(m->idle_pipe);
735 free(m->switch_root);
736 free(m->switch_root_init);
738 for (i = 0; i < RLIMIT_NLIMITS; i++)
744 int manager_enumerate(Manager *m) {
750 /* Let's ask every type to load all units from disk/kernel
751 * that it might know */
752 for (c = 0; c < _UNIT_TYPE_MAX; c++)
753 if (unit_vtable[c]->enumerate)
754 if ((q = unit_vtable[c]->enumerate(m)) < 0)
757 manager_dispatch_load_queue(m);
761 int manager_coldplug(Manager *m) {
769 /* Then, let's set up their initial state. */
770 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
776 if ((q = unit_coldplug(u)) < 0)
783 static void manager_build_unit_path_cache(Manager *m) {
785 DIR _cleanup_free_ *d = NULL;
790 set_free_free(m->unit_path_cache);
792 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
793 if (!m->unit_path_cache) {
794 log_error("Failed to allocate unit path cache.");
798 /* This simply builds a list of files we know exist, so that
799 * we don't always have to go to disk */
801 STRV_FOREACH(i, m->lookup_paths.unit_path) {
807 log_error("Failed to open directory %s: %m", *i);
811 while ((de = readdir(d))) {
814 if (ignore_file(de->d_name))
817 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
823 r = set_put(m->unit_path_cache, p);
837 log_error("Failed to build unit path cache: %s", strerror(-r));
839 set_free_free(m->unit_path_cache);
840 m->unit_path_cache = NULL;
843 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
848 manager_run_generators(m);
850 r = lookup_paths_init(
851 &m->lookup_paths, m->running_as, true,
852 m->generator_unit_path,
853 m->generator_unit_path_early,
854 m->generator_unit_path_late);
858 manager_build_unit_path_cache(m);
860 /* If we will deserialize make sure that during enumeration
861 * this is already known, so we increase the counter here
866 /* First, enumerate what we can from all config files */
867 r = manager_enumerate(m);
869 /* Second, deserialize if there is something to deserialize */
871 q = manager_deserialize(m, serialization, fds);
876 /* Any fds left? Find some unit which wants them. This is
877 * useful to allow container managers to pass some file
878 * descriptors to us pre-initialized. This enables
879 * socket-based activation of entire containers. */
880 if (fdset_size(fds) > 0) {
881 q = manager_distribute_fds(m, fds);
886 /* Third, fire things up! */
887 q = manager_coldplug(m);
892 assert(m->n_reloading > 0);
899 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
904 assert(type < _JOB_TYPE_MAX);
906 assert(mode < _JOB_MODE_MAX);
908 if (mode == JOB_ISOLATE && type != JOB_START) {
909 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
913 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
914 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
918 log_debug_unit(unit->id,
919 "Trying to enqueue job %s/%s/%s", unit->id,
920 job_type_to_string(type), job_mode_to_string(mode));
922 job_type_collapse(&type, unit);
924 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
928 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
929 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
930 mode == JOB_IGNORE_DEPENDENCIES, e);
934 if (mode == JOB_ISOLATE) {
935 r = transaction_add_isolate_jobs(tr, m);
940 r = transaction_activate(tr, m, mode, e);
944 log_debug_unit(unit->id,
945 "Enqueued job %s/%s as %u", unit->id,
946 job_type_to_string(type), (unsigned) tr->anchor_job->id);
949 *_ret = tr->anchor_job;
951 transaction_free(tr);
955 transaction_abort(tr);
956 transaction_free(tr);
960 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
965 assert(type < _JOB_TYPE_MAX);
967 assert(mode < _JOB_MODE_MAX);
969 r = manager_load_unit(m, name, NULL, NULL, &unit);
973 return manager_add_job(m, type, unit, mode, override, e, _ret);
976 Job *manager_get_job(Manager *m, uint32_t id) {
979 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
982 Unit *manager_get_unit(Manager *m, const char *name) {
986 return hashmap_get(m->units, name);
989 unsigned manager_dispatch_load_queue(Manager *m) {
995 /* Make sure we are not run recursively */
996 if (m->dispatching_load_queue)
999 m->dispatching_load_queue = true;
1001 /* Dispatches the load queue. Takes a unit from the queue and
1002 * tries to load its data until the queue is empty */
1004 while ((u = m->load_queue)) {
1005 assert(u->in_load_queue);
1011 m->dispatching_load_queue = false;
1015 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1021 assert(name || path);
1023 /* This will prepare the unit for loading, but not actually
1024 * load anything from disk. */
1026 if (path && !is_path(path)) {
1027 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1032 name = path_get_file_name(path);
1034 t = unit_name_to_type(name);
1036 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
1037 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1041 ret = manager_get_unit(m, name);
1047 ret = unit_new(m, unit_vtable[t]->object_size);
1052 ret->fragment_path = strdup(path);
1053 if (!ret->fragment_path) {
1059 if ((r = unit_add_name(ret, name)) < 0) {
1064 unit_add_to_load_queue(ret);
1065 unit_add_to_dbus_queue(ret);
1066 unit_add_to_gc_queue(ret);
1074 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1079 /* This will load the service information files, but not actually
1080 * start any services or anything. */
1082 r = manager_load_unit_prepare(m, name, path, e, _ret);
1086 manager_dispatch_load_queue(m);
1089 *_ret = unit_follow_merge(*_ret);
1094 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1101 HASHMAP_FOREACH(j, s->jobs, i)
1102 job_dump(j, f, prefix);
1105 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1113 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1115 unit_dump(u, f, prefix);
1118 void manager_clear_jobs(Manager *m) {
1123 while ((j = hashmap_first(m->jobs)))
1124 /* No need to recurse. We're cancelling all jobs. */
1125 job_finish_and_invalidate(j, JOB_CANCELED, false);
1128 unsigned manager_dispatch_run_queue(Manager *m) {
1132 if (m->dispatching_run_queue)
1135 m->dispatching_run_queue = true;
1137 while ((j = m->run_queue)) {
1138 assert(j->installed);
1139 assert(j->in_run_queue);
1141 job_run_and_invalidate(j);
1145 m->dispatching_run_queue = false;
1147 if (m->n_running_jobs > 0)
1148 manager_watch_jobs_in_progress(m);
1153 unsigned manager_dispatch_dbus_queue(Manager *m) {
1160 if (m->dispatching_dbus_queue)
1163 m->dispatching_dbus_queue = true;
1165 while ((u = m->dbus_unit_queue)) {
1166 assert(u->in_dbus_queue);
1168 bus_unit_send_change_signal(u);
1172 while ((j = m->dbus_job_queue)) {
1173 assert(j->in_dbus_queue);
1175 bus_job_send_change_signal(j);
1179 m->dispatching_dbus_queue = false;
1183 static int manager_process_notify_fd(Manager *m) {
1190 struct msghdr msghdr;
1192 struct ucred *ucred;
1194 struct cmsghdr cmsghdr;
1195 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1201 iovec.iov_base = buf;
1202 iovec.iov_len = sizeof(buf)-1;
1206 msghdr.msg_iov = &iovec;
1207 msghdr.msg_iovlen = 1;
1208 msghdr.msg_control = &control;
1209 msghdr.msg_controllen = sizeof(control);
1211 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1216 if (errno == EAGAIN || errno == EINTR)
1222 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1223 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1224 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1225 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1226 log_warning("Received notify message without credentials. Ignoring.");
1230 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1232 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1234 u = cgroup_unit_by_pid(m, ucred->pid);
1236 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1241 assert((size_t) n < sizeof(buf));
1243 tags = strv_split(buf, "\n\r");
1247 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1249 if (UNIT_VTABLE(u)->notify_message)
1250 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1258 static int manager_dispatch_sigchld(Manager *m) {
1268 /* First we call waitd() for a PID and do not reap the
1269 * zombie. That way we can still access /proc/$PID for
1270 * it while it is a zombie. */
1271 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1273 if (errno == ECHILD)
1285 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1286 char _cleanup_free_ *name = NULL;
1288 get_process_comm(si.si_pid, &name);
1289 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1292 /* Let's flush any message the dying child might still
1293 * have queued for us. This ensures that the process
1294 * still exists in /proc so that we can figure out
1295 * which cgroup and hence unit it belongs to. */
1296 r = manager_process_notify_fd(m);
1300 /* And now figure out the unit this belongs to */
1301 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1303 u = cgroup_unit_by_pid(m, si.si_pid);
1305 /* And now, we actually reap the zombie. */
1306 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1313 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1316 log_debug("Child %lu died (code=%s, status=%i/%s)",
1317 (long unsigned) si.si_pid,
1318 sigchld_code_to_string(si.si_code),
1320 strna(si.si_code == CLD_EXITED
1321 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1322 : signal_to_string(si.si_status)));
1327 log_debug_unit(u->id,
1328 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1330 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1331 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1337 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1341 dbus_error_init(&error);
1343 log_debug_unit(name, "Activating special unit %s", name);
1345 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1347 log_error_unit(name,
1348 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1350 dbus_error_free(&error);
1355 static int manager_process_signal_fd(Manager *m) {
1357 struct signalfd_siginfo sfsi;
1358 bool sigchld = false;
1363 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1364 if (n != sizeof(sfsi)) {
1369 if (errno == EINTR || errno == EAGAIN)
1375 if (sfsi.ssi_pid > 0) {
1378 get_process_comm(sfsi.ssi_pid, &p);
1380 log_debug("Received SIG%s from PID %lu (%s).",
1381 signal_to_string(sfsi.ssi_signo),
1382 (unsigned long) sfsi.ssi_pid, strna(p));
1385 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1387 switch (sfsi.ssi_signo) {
1394 if (m->running_as == SYSTEMD_SYSTEM) {
1395 /* This is for compatibility with the
1396 * original sysvinit */
1397 m->exit_code = MANAGER_REEXECUTE;
1404 if (m->running_as == SYSTEMD_SYSTEM) {
1405 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1409 /* Run the exit target if there is one, if not, just exit. */
1410 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1411 m->exit_code = MANAGER_EXIT;
1418 if (m->running_as == SYSTEMD_SYSTEM)
1419 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1421 /* This is a nop on non-init */
1425 if (m->running_as == SYSTEMD_SYSTEM)
1426 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1428 /* This is a nop on non-init */
1434 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1436 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1437 log_info("Trying to reconnect to bus...");
1441 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1442 log_info("Loading D-Bus service...");
1443 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1454 if (!(f = open_memstream(&dump, &size))) {
1455 log_warning("Failed to allocate memory stream.");
1459 manager_dump_units(m, f, "\t");
1460 manager_dump_jobs(m, f, "\t");
1465 log_warning("Failed to write status stream");
1470 log_dump(LOG_INFO, dump);
1477 m->exit_code = MANAGER_RELOAD;
1482 /* Starting SIGRTMIN+0 */
1483 static const char * const target_table[] = {
1484 [0] = SPECIAL_DEFAULT_TARGET,
1485 [1] = SPECIAL_RESCUE_TARGET,
1486 [2] = SPECIAL_EMERGENCY_TARGET,
1487 [3] = SPECIAL_HALT_TARGET,
1488 [4] = SPECIAL_POWEROFF_TARGET,
1489 [5] = SPECIAL_REBOOT_TARGET,
1490 [6] = SPECIAL_KEXEC_TARGET
1493 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1494 static const ManagerExitCode code_table[] = {
1496 [1] = MANAGER_POWEROFF,
1497 [2] = MANAGER_REBOOT,
1501 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1502 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1503 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1504 manager_start_target(m, target_table[idx],
1505 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1509 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1510 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1511 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1515 switch (sfsi.ssi_signo - SIGRTMIN) {
1518 log_debug("Enabling showing of status.");
1519 manager_set_show_status(m, true);
1523 log_debug("Disabling showing of status.");
1524 manager_set_show_status(m, false);
1528 log_set_max_level(LOG_DEBUG);
1529 log_notice("Setting log level to debug.");
1533 log_set_max_level(LOG_INFO);
1534 log_notice("Setting log level to info.");
1538 if (m->running_as == SYSTEMD_USER) {
1539 m->exit_code = MANAGER_EXIT;
1543 /* This is a nop on init */
1547 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1548 log_notice("Setting log target to journal-or-kmsg.");
1552 log_set_target(LOG_TARGET_CONSOLE);
1553 log_notice("Setting log target to console.");
1557 log_set_target(LOG_TARGET_KMSG);
1558 log_notice("Setting log target to kmsg.");
1562 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1563 log_notice("Setting log target to syslog-or-kmsg.");
1567 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1574 return manager_dispatch_sigchld(m);
1579 static int process_event(Manager *m, struct epoll_event *ev) {
1586 assert_se(w = ev->data.ptr);
1588 if (w->type == WATCH_INVALID)
1595 /* An incoming signal? */
1596 if (ev->events != EPOLLIN)
1599 if ((r = manager_process_signal_fd(m)) < 0)
1606 /* An incoming daemon notification event? */
1607 if (ev->events != EPOLLIN)
1610 if ((r = manager_process_notify_fd(m)) < 0)
1617 /* Some fd event, to be dispatched to the units */
1618 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1621 case WATCH_UNIT_TIMER:
1622 case WATCH_JOB_TIMER: {
1626 /* Some timer event, to be dispatched to the units */
1627 k = read(w->fd, &v, sizeof(v));
1628 if (k != sizeof(v)) {
1630 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1633 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1634 return k < 0 ? -errno : -EIO;
1637 if (w->type == WATCH_UNIT_TIMER)
1638 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1640 job_timer_event(w->data.job, v, w);
1645 /* Some mount table change, intended for the mount subsystem */
1646 mount_fd_event(m, ev->events);
1650 /* Some swap table change, intended for the swap subsystem */
1651 swap_fd_event(m, ev->events);
1655 /* Some notification from udev, intended for the device subsystem */
1656 device_fd_event(m, ev->events);
1659 case WATCH_DBUS_WATCH:
1660 bus_watch_event(m, w, ev->events);
1663 case WATCH_DBUS_TIMEOUT:
1664 bus_timeout_event(m, w, ev->events);
1667 case WATCH_TIME_CHANGE: {
1671 log_struct(LOG_INFO,
1672 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1673 "MESSAGE=Time has been changed",
1676 /* Restart the watch */
1677 epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->time_change_watch.fd,
1679 close_nointr_nofail(m->time_change_watch.fd);
1680 watch_init(&m->time_change_watch);
1681 manager_setup_time_change(m);
1683 HASHMAP_FOREACH(u, m->units, i) {
1684 if (UNIT_VTABLE(u)->time_change)
1685 UNIT_VTABLE(u)->time_change(u);
1691 case WATCH_JOBS_IN_PROGRESS: {
1694 /* not interested in the data */
1695 read(w->fd, &v, sizeof(v));
1697 manager_print_jobs_in_progress(m);
1702 log_error("event type=%i", w->type);
1703 assert_not_reached("Unknown epoll event type.");
1709 int manager_loop(Manager *m) {
1712 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1715 m->exit_code = MANAGER_RUNNING;
1717 /* Release the path cache */
1718 set_free_free(m->unit_path_cache);
1719 m->unit_path_cache = NULL;
1721 manager_check_finished(m);
1723 /* There might still be some zombies hanging around from
1724 * before we were exec()'ed. Leat's reap them */
1725 r = manager_dispatch_sigchld(m);
1729 while (m->exit_code == MANAGER_RUNNING) {
1730 struct epoll_event event;
1734 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1737 if (!ratelimit_test(&rl)) {
1738 /* Yay, something is going seriously wrong, pause a little */
1739 log_warning("Looping too fast. Throttling execution a little.");
1744 if (manager_dispatch_load_queue(m) > 0)
1747 if (manager_dispatch_run_queue(m) > 0)
1750 if (bus_dispatch(m) > 0)
1753 if (manager_dispatch_cleanup_queue(m) > 0)
1756 if (manager_dispatch_gc_queue(m) > 0)
1759 if (manager_dispatch_dbus_queue(m) > 0)
1762 if (swap_dispatch_reload(m) > 0)
1765 /* Sleep for half the watchdog time */
1766 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1767 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1773 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1785 r = process_event(m, &event);
1790 return m->exit_code;
1793 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1802 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1805 n = bus_path_unescape(s+31);
1809 r = manager_load_unit(m, n, NULL, e, &u);
1820 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1829 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1832 r = safe_atou(s + 30, &id);
1836 j = manager_get_job(m, id);
1845 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1851 audit_fd = get_audit_fd();
1855 /* Don't generate audit events if the service was already
1856 * started and we're just deserializing */
1857 if (m->n_reloading > 0)
1860 if (m->running_as != SYSTEMD_SYSTEM)
1863 if (u->type != UNIT_SERVICE)
1866 p = unit_name_to_prefix_and_instance(u->id);
1868 log_error_unit(u->id,
1869 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1873 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1874 if (errno == EPERM) {
1875 /* We aren't allowed to send audit messages?
1876 * Then let's not retry again. */
1879 log_warning("Failed to send audit message: %m");
1887 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1889 union sockaddr_union sa;
1891 char *message = NULL;
1893 /* Don't generate plymouth events if the service was already
1894 * started and we're just deserializing */
1895 if (m->n_reloading > 0)
1898 if (m->running_as != SYSTEMD_SYSTEM)
1901 if (u->type != UNIT_SERVICE &&
1902 u->type != UNIT_MOUNT &&
1903 u->type != UNIT_SWAP)
1906 /* We set SOCK_NONBLOCK here so that we rather drop the
1907 * message then wait for plymouth */
1908 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1909 log_error("socket() failed: %m");
1914 sa.sa.sa_family = AF_UNIX;
1915 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1916 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1918 if (errno != EPIPE &&
1921 errno != ECONNREFUSED &&
1922 errno != ECONNRESET &&
1923 errno != ECONNABORTED)
1924 log_error("connect() failed: %m");
1929 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1935 if (write(fd, message, n + 1) != n + 1) {
1937 if (errno != EPIPE &&
1940 errno != ECONNREFUSED &&
1941 errno != ECONNRESET &&
1942 errno != ECONNABORTED)
1943 log_error("Failed to write Plymouth message: %m");
1950 close_nointr_nofail(fd);
1955 void manager_dispatch_bus_name_owner_changed(
1958 const char* old_owner,
1959 const char *new_owner) {
1966 if (!(u = hashmap_get(m->watch_bus, name)))
1969 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1972 void manager_dispatch_bus_query_pid_done(
1983 if (!(u = hashmap_get(m->watch_bus, name)))
1986 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1989 int manager_open_serialization(Manager *m, FILE **_f) {
1997 if (m->running_as == SYSTEMD_SYSTEM)
1998 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
2000 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
2005 saved_umask = umask(0077);
2006 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2016 log_debug("Serializing state to %s", path);
2019 f = fdopen(fd, "w+");
2028 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
2041 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2042 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2043 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2044 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2046 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2047 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2048 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2049 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2052 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2053 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2056 STRV_FOREACH(e, m->environment) {
2057 _cleanup_free_ char *ce;
2061 fprintf(f, "env=%s\n", *e);
2066 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2070 if (!unit_can_serialize(u))
2077 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
2083 assert(m->n_reloading > 0);
2089 r = bus_fdset_add_all(m, fds);
2096 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2102 log_debug("Deserializing state...");
2107 char line[LINE_MAX], *l;
2109 if (!fgets(line, sizeof(line), f)) {
2124 if (startswith(l, "current-job-id=")) {
2127 if (safe_atou32(l+15, &id) < 0)
2128 log_debug("Failed to parse current job id value %s", l+15);
2130 m->current_job_id = MAX(m->current_job_id, id);
2131 } else if (startswith(l, "n-installed-jobs=")) {
2134 if (safe_atou32(l+17, &n) < 0)
2135 log_debug("Failed to parse installed jobs counter %s", l+17);
2137 m->n_installed_jobs += n;
2138 } else if (startswith(l, "n-failed-jobs=")) {
2141 if (safe_atou32(l+14, &n) < 0)
2142 log_debug("Failed to parse failed jobs counter %s", l+14);
2144 m->n_failed_jobs += n;
2145 } else if (startswith(l, "taint-usr=")) {
2148 if ((b = parse_boolean(l+10)) < 0)
2149 log_debug("Failed to parse taint /usr flag %s", l+10);
2151 m->taint_usr = m->taint_usr || b;
2152 } else if (startswith(l, "firmware-timestamp="))
2153 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2154 else if (startswith(l, "loader-timestamp="))
2155 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2156 else if (startswith(l, "kernel-timestamp="))
2157 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2158 else if (startswith(l, "initrd-timestamp="))
2159 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2160 else if (startswith(l, "userspace-timestamp="))
2161 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2162 else if (startswith(l, "finish-timestamp="))
2163 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2164 else if (startswith(l, "env=")) {
2165 _cleanup_free_ char *uce = NULL;
2168 uce = cunescape(l+4);
2174 e = strv_env_set(m->environment, uce);
2180 strv_free(m->environment);
2183 log_debug("Unknown serialization item '%s'", l);
2188 char name[UNIT_NAME_MAX+2];
2191 if (!fgets(name, sizeof(name), f)) {
2202 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2206 r = unit_deserialize(u, f, fds);
2217 assert(m->n_reloading > 0);
2223 int manager_distribute_fds(Manager *m, FDSet *fds) {
2230 HASHMAP_FOREACH(u, m->units, i) {
2232 if (fdset_size(fds) <= 0)
2235 if (UNIT_VTABLE(u)->distribute_fds) {
2236 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2245 int manager_reload(Manager *m) {
2252 r = manager_open_serialization(m, &f);
2265 r = manager_serialize(m, f, fds, true);
2271 if (fseeko(f, 0, SEEK_SET) < 0) {
2277 /* From here on there is no way back. */
2278 manager_clear_jobs_and_units(m);
2279 manager_undo_generators(m);
2280 lookup_paths_free(&m->lookup_paths);
2282 /* Find new unit paths */
2283 manager_run_generators(m);
2285 q = lookup_paths_init(
2286 &m->lookup_paths, m->running_as, true,
2287 m->generator_unit_path,
2288 m->generator_unit_path_early,
2289 m->generator_unit_path_late);
2293 manager_build_unit_path_cache(m);
2295 /* First, enumerate what we can from all config files */
2296 q = manager_enumerate(m);
2300 /* Second, deserialize our stored data */
2301 q = manager_deserialize(m, f, fds);
2308 /* Third, fire things up! */
2309 q = manager_coldplug(m);
2313 assert(m->n_reloading > 0);
2326 static bool manager_is_booting_or_shutting_down(Manager *m) {
2331 /* Is the initial job still around? */
2332 if (manager_get_job(m, m->default_unit_job_id))
2335 /* Is there a job for the shutdown target? */
2336 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2343 void manager_reset_failed(Manager *m) {
2349 HASHMAP_FOREACH(u, m->units, i)
2350 unit_reset_failed(u);
2353 bool manager_unit_pending_inactive(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_pending_inactive(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)
2379 /* Notify Type=idle units that we are done now */
2380 close_pipe(m->idle_pipe);
2382 /* Turn off confirm spawn now */
2383 m->confirm_spawn = false;
2385 if (dual_timestamp_is_set(&m->finish_timestamp))
2388 dual_timestamp_get(&m->finish_timestamp);
2390 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2392 /* Note that m->kernel_usec.monotonic is always at 0,
2393 * and m->firmware_usec.monotonic and
2394 * m->loader_usec.monotonic should be considered
2395 * negative values. */
2397 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2398 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2399 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2400 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2402 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2404 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2405 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2407 if (!log_on_console())
2408 log_struct(LOG_INFO,
2409 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2410 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2411 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2412 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2413 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2414 format_timespan(kernel, sizeof(kernel), kernel_usec),
2415 format_timespan(initrd, sizeof(initrd), initrd_usec),
2416 format_timespan(userspace, sizeof(userspace), userspace_usec),
2417 format_timespan(sum, sizeof(sum), total_usec),
2420 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2423 if (!log_on_console())
2424 log_struct(LOG_INFO,
2425 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2426 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2427 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2428 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2429 format_timespan(kernel, sizeof(kernel), kernel_usec),
2430 format_timespan(userspace, sizeof(userspace), userspace_usec),
2431 format_timespan(sum, sizeof(sum), total_usec),
2435 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2436 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2438 if (!log_on_console())
2439 log_struct(LOG_INFO,
2440 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2441 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2442 "MESSAGE=Startup finished in %s.",
2443 format_timespan(sum, sizeof(sum), total_usec),
2447 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2450 "READY=1\nSTATUS=Startup finished in %s.",
2451 format_timespan(sum, sizeof(sum), total_usec));
2454 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2465 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2467 p = strappend("/run/systemd/", name);
2471 r = mkdir_p_label(p, 0755);
2473 log_error("Failed to create generator directory %s: %s",
2479 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2484 log_error("Failed to create generator directory %s: %m",
2495 static void trim_generator_dir(Manager *m, char **generator) {
2502 if (rmdir(*generator) >= 0) {
2510 void manager_run_generators(Manager *m) {
2512 const char *generator_path;
2513 const char *argv[5];
2519 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2520 d = opendir(generator_path);
2522 if (errno == ENOENT)
2525 log_error("Failed to enumerate generator directory %s: %m",
2530 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2534 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2538 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2542 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2543 argv[1] = m->generator_unit_path;
2544 argv[2] = m->generator_unit_path_early;
2545 argv[3] = m->generator_unit_path_late;
2549 execute_directory(generator_path, d, (char**) argv);
2552 trim_generator_dir(m, &m->generator_unit_path);
2553 trim_generator_dir(m, &m->generator_unit_path_early);
2554 trim_generator_dir(m, &m->generator_unit_path_late);
2561 static void remove_generator_dir(Manager *m, char **generator) {
2568 strv_remove(m->lookup_paths.unit_path, *generator);
2569 rm_rf(*generator, false, true, false);
2575 void manager_undo_generators(Manager *m) {
2578 remove_generator_dir(m, &m->generator_unit_path);
2579 remove_generator_dir(m, &m->generator_unit_path_early);
2580 remove_generator_dir(m, &m->generator_unit_path_late);
2583 int manager_set_default_controllers(Manager *m, char **controllers) {
2588 l = strv_copy(controllers);
2592 strv_free(m->default_controllers);
2593 m->default_controllers = l;
2595 cg_shorten_controllers(m->default_controllers);
2600 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2605 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2606 if (!default_rlimit[i])
2609 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2617 void manager_recheck_journal(Manager *m) {
2622 if (m->running_as != SYSTEMD_SYSTEM)
2625 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2626 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2627 log_close_journal();
2631 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2632 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2633 log_close_journal();
2637 /* Hmm, OK, so the socket is fully up and the service is up
2638 * too, then let's make use of the thing. */
2642 void manager_set_show_status(Manager *m, bool b) {
2645 if (m->running_as != SYSTEMD_SYSTEM)
2651 touch("/run/systemd/show-status");
2653 unlink("/run/systemd/show-status");
2656 static bool manager_get_show_status(Manager *m) {
2659 if (m->running_as != SYSTEMD_SYSTEM)
2665 /* If Plymouth is running make sure we show the status, so
2666 * that there's something nice to see when people press Esc */
2668 return plymouth_running();
2671 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2674 if (!manager_get_show_status(m))
2677 /* XXX We should totally drop the check for ephemeral here
2678 * and thus effectively make 'Type=idle' pointless. */
2679 if (ephemeral && m->n_on_console > 0)
2682 if (!manager_is_booting_or_shutting_down(m))
2685 va_start(ap, format);
2686 status_vprintf(status, true, ephemeral, format, ap);
2690 void watch_init(Watch *w) {
2693 w->type = WATCH_INVALID;