1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
25 #include <sys/epoll.h>
27 #include <sys/signalfd.h>
31 #include <sys/reboot.h>
32 #include <sys/ioctl.h>
36 #include <sys/types.h>
39 #include <sys/timerfd.h>
45 #include "systemd/sd-daemon.h"
46 #include "systemd/sd-id128.h"
47 #include "systemd/sd-messages.h"
50 #include "transaction.h"
57 #include "ratelimit.h"
59 #include "mount-setup.h"
60 #include "unit-name.h"
61 #include "dbus-unit.h"
64 #include "path-lookup.h"
66 #include "bus-errors.h"
67 #include "exit-status.h"
70 #include "cgroup-util.h"
71 #include "path-util.h"
76 /* As soon as 16 units are in our GC queue, make sure to run a gc sweep */
77 #define GC_QUEUE_ENTRIES_MAX 16
79 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
80 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
82 /* Initial delay and the interval for printing status messages about running jobs */
83 #define JOBS_IN_PROGRESS_WAIT_SEC 5
84 #define JOBS_IN_PROGRESS_PERIOD_SEC 1
85 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
87 /* Where clients shall send notification messages to */
88 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
90 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
92 static int manager_setup_notify(Manager *m) {
95 struct sockaddr_un un;
97 struct epoll_event ev;
102 m->notify_watch.type = WATCH_NOTIFY;
103 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
104 if (m->notify_watch.fd < 0) {
105 log_error("Failed to allocate notification socket: %m");
110 sa.sa.sa_family = AF_UNIX;
112 if (getpid() != 1 || detect_container(NULL) > 0)
113 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
115 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
117 sa.un.sun_path[0] = 0;
119 if (bind(m->notify_watch.fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
120 log_error("bind() failed: %m");
124 if (setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0) {
125 log_error("SO_PASSCRED failed: %m");
131 ev.data.ptr = &m->notify_watch;
133 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev) < 0) {
134 log_error("Failed to add notification socket fd to epoll: %m");
138 sa.un.sun_path[0] = '@';
139 m->notify_socket = strdup(sa.un.sun_path);
140 if (!m->notify_socket)
143 log_debug("Using notification socket %s", m->notify_socket);
148 static int manager_jobs_in_progress_mod_timer(Manager *m) {
149 struct itimerspec its;
153 its.it_value.tv_sec = JOBS_IN_PROGRESS_WAIT_SEC;
154 its.it_interval.tv_sec = JOBS_IN_PROGRESS_PERIOD_SEC;
156 if (timerfd_settime(m->jobs_in_progress_watch.fd, 0, &its, NULL) < 0)
162 static int manager_watch_jobs_in_progress(Manager *m) {
163 struct epoll_event ev;
168 if (m->jobs_in_progress_watch.type != WATCH_INVALID)
171 m->jobs_in_progress_watch.type = WATCH_JOBS_IN_PROGRESS;
172 m->jobs_in_progress_watch.fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
173 if (m->jobs_in_progress_watch.fd < 0) {
174 log_error("Failed to create timerfd: %m");
179 r = manager_jobs_in_progress_mod_timer(m);
181 log_error("Failed to set up timer for jobs progress watch: %s", strerror(-r));
187 ev.data.ptr = &m->jobs_in_progress_watch;
189 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->jobs_in_progress_watch.fd, &ev) < 0) {
190 log_error("Failed to add jobs progress timer fd to epoll: %m");
195 log_debug("Set up jobs progress timerfd.");
200 if (m->jobs_in_progress_watch.fd >= 0)
201 close_nointr_nofail(m->jobs_in_progress_watch.fd);
202 watch_init(&m->jobs_in_progress_watch);
206 static void manager_unwatch_jobs_in_progress(Manager *m) {
207 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
210 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->jobs_in_progress_watch.fd, NULL) >= 0);
211 close_nointr_nofail(m->jobs_in_progress_watch.fd);
212 watch_init(&m->jobs_in_progress_watch);
213 m->jobs_in_progress_iteration = 0;
215 log_debug("Closed jobs progress timerfd.");
218 #define CYLON_BUFFER_EXTRA (2*strlen(ANSI_RED_ON) + strlen(ANSI_HIGHLIGHT_RED_ON) + 2*strlen(ANSI_HIGHLIGHT_OFF))
219 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
222 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
223 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
227 memset(p, ' ', pos-2);
230 memcpy(p, ANSI_RED_ON, strlen(ANSI_RED_ON));
231 p += strlen(ANSI_RED_ON);
235 if (pos > 0 && pos <= width) {
236 memcpy(p, ANSI_HIGHLIGHT_RED_ON, strlen(ANSI_HIGHLIGHT_RED_ON));
237 p += strlen(ANSI_HIGHLIGHT_RED_ON);
241 memcpy(p, ANSI_HIGHLIGHT_OFF, strlen(ANSI_HIGHLIGHT_OFF));
242 p += strlen(ANSI_HIGHLIGHT_OFF);
245 memcpy(p, ANSI_RED_ON, strlen(ANSI_RED_ON));
246 p += strlen(ANSI_RED_ON);
249 memset(p, ' ', width-1-pos);
252 memcpy(p, ANSI_HIGHLIGHT_OFF, strlen(ANSI_HIGHLIGHT_OFF));
253 p += strlen(ANSI_HIGHLIGHT_OFF);
258 static void manager_print_jobs_in_progress(Manager *m) {
261 char *job_of_n = NULL;
262 unsigned counter = 0, print_nr;
263 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
266 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
268 HASHMAP_FOREACH(j, m->jobs, i)
269 if (j->state == JOB_RUNNING && counter++ == print_nr)
275 cylon_pos = m->jobs_in_progress_iteration % 14;
277 cylon_pos = 14 - cylon_pos;
278 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
280 if (m->n_running_jobs > 1)
281 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
284 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
285 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
288 m->jobs_in_progress_iteration++;
291 static int manager_setup_time_change(Manager *m) {
292 struct epoll_event ev;
293 struct itimerspec its;
296 assert(m->time_change_watch.type == WATCH_INVALID);
298 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
299 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
301 m->time_change_watch.type = WATCH_TIME_CHANGE;
302 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
303 if (m->time_change_watch.fd < 0) {
304 log_error("Failed to create timerfd: %m");
310 /* We only care for the cancellation event, hence we set the
311 * timeout to the latest possible value. */
312 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
313 its.it_value.tv_sec = TIME_T_MAX;
315 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
316 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
317 close_nointr_nofail(m->time_change_watch.fd);
318 watch_init(&m->time_change_watch);
324 ev.data.ptr = &m->time_change_watch;
326 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
327 log_error("Failed to add timer change fd to epoll: %m");
331 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
336 static int enable_special_signals(Manager *m) {
341 /* Enable that we get SIGINT on control-alt-del. In containers
342 * this will fail with EPERM (older) or EINVAL (newer), so
344 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
345 log_warning("Failed to enable ctrl-alt-del handling: %m");
347 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
349 /* Support systems without virtual console */
351 log_warning("Failed to open /dev/tty0: %m");
353 /* Enable that we get SIGWINCH on kbrequest */
354 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
355 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
357 close_nointr_nofail(fd);
363 static int manager_setup_signals(Manager *m) {
365 struct epoll_event ev;
370 /* We are not interested in SIGSTOP and friends. */
372 sa.sa_handler = SIG_DFL;
373 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
374 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
376 assert_se(sigemptyset(&mask) == 0);
378 sigset_add_many(&mask,
379 SIGCHLD, /* Child died */
380 SIGTERM, /* Reexecute daemon */
381 SIGHUP, /* Reload configuration */
382 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
383 SIGUSR2, /* systemd: dump status */
384 SIGINT, /* Kernel sends us this on control-alt-del */
385 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
386 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
387 SIGRTMIN+0, /* systemd: start default.target */
388 SIGRTMIN+1, /* systemd: isolate rescue.target */
389 SIGRTMIN+2, /* systemd: isolate emergency.target */
390 SIGRTMIN+3, /* systemd: start halt.target */
391 SIGRTMIN+4, /* systemd: start poweroff.target */
392 SIGRTMIN+5, /* systemd: start reboot.target */
393 SIGRTMIN+6, /* systemd: start kexec.target */
394 SIGRTMIN+13, /* systemd: Immediate halt */
395 SIGRTMIN+14, /* systemd: Immediate poweroff */
396 SIGRTMIN+15, /* systemd: Immediate reboot */
397 SIGRTMIN+16, /* systemd: Immediate kexec */
398 SIGRTMIN+20, /* systemd: enable status messages */
399 SIGRTMIN+21, /* systemd: disable status messages */
400 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
401 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
402 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
403 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
404 SIGRTMIN+27, /* systemd: set log target to console */
405 SIGRTMIN+28, /* systemd: set log target to kmsg */
406 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
408 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
410 m->signal_watch.type = WATCH_SIGNAL;
411 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
412 if (m->signal_watch.fd < 0)
417 ev.data.ptr = &m->signal_watch;
419 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
422 if (m->running_as == SYSTEMD_SYSTEM)
423 return enable_special_signals(m);
428 static void manager_strip_environment(Manager *m) {
431 /* Remove variables from the inherited set that are part of
432 * the container interface:
433 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
434 strv_remove_prefix(m->environment, "container=");
435 strv_remove_prefix(m->environment, "container_");
437 /* Remove variables from the inherited set that are part of
438 * the initrd interface:
439 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
440 strv_remove_prefix(m->environment, "RD_");
442 /* Drop invalid entries */
443 strv_env_clean(m->environment);
446 int manager_new(SystemdRunningAs running_as, Manager **_m) {
451 assert(running_as >= 0);
452 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
454 m = new0(Manager, 1);
458 dual_timestamp_get(&m->userspace_timestamp);
459 dual_timestamp_from_monotonic(&m->kernel_timestamp, 0);
461 efi_get_boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
464 m->running_as = running_as;
465 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
466 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
467 m->pin_cgroupfs_fd = -1;
468 m->idle_pipe[0] = m->idle_pipe[1] = -1;
470 watch_init(&m->signal_watch);
471 watch_init(&m->mount_watch);
472 watch_init(&m->swap_watch);
473 watch_init(&m->udev_watch);
474 watch_init(&m->time_change_watch);
475 watch_init(&m->jobs_in_progress_watch);
477 m->epoll_fd = m->dev_autofs_fd = -1;
478 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
480 m->environment = strv_copy(environ);
484 manager_strip_environment(m);
486 if (running_as == SYSTEMD_SYSTEM) {
487 m->default_controllers = strv_new("cpu", NULL);
488 if (!m->default_controllers)
492 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
495 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
498 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
501 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
504 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
507 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
511 r = manager_setup_signals(m);
515 r = manager_setup_cgroup(m);
519 r = manager_setup_notify(m);
523 r = manager_setup_time_change(m);
527 /* Try to connect to the busses, if possible. */
528 r = bus_init(m, running_as != SYSTEMD_SYSTEM);
532 m->taint_usr = dir_is_empty("/usr") > 0;
542 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
548 while ((u = m->cleanup_queue)) {
549 assert(u->in_cleanup_queue);
559 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
560 GC_OFFSET_UNSURE, /* No clue */
561 GC_OFFSET_GOOD, /* We still need this unit */
562 GC_OFFSET_BAD, /* We don't need this unit anymore */
566 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
573 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
574 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
575 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
578 if (u->in_cleanup_queue)
581 if (unit_check_gc(u))
584 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
588 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
589 unit_gc_sweep(other, gc_marker);
591 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
594 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
601 /* We were unable to find anything out about this entry, so
602 * let's investigate it later */
603 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
604 unit_add_to_gc_queue(u);
608 /* We definitely know that this one is not useful anymore, so
609 * let's mark it for deletion */
610 u->gc_marker = gc_marker + GC_OFFSET_BAD;
611 unit_add_to_cleanup_queue(u);
615 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
618 static unsigned manager_dispatch_gc_queue(Manager *m) {
625 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
626 (m->gc_queue_timestamp <= 0 ||
627 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
630 log_debug("Running GC...");
632 m->gc_marker += _GC_OFFSET_MAX;
633 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
636 gc_marker = m->gc_marker;
638 while ((u = m->gc_queue)) {
639 assert(u->in_gc_queue);
641 unit_gc_sweep(u, gc_marker);
643 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
644 u->in_gc_queue = false;
648 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
649 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
650 log_debug_unit(u->id, "Collecting %s", u->id);
651 u->gc_marker = gc_marker + GC_OFFSET_BAD;
652 unit_add_to_cleanup_queue(u);
656 m->n_in_gc_queue = 0;
657 m->gc_queue_timestamp = 0;
662 static void manager_clear_jobs_and_units(Manager *m) {
667 while ((u = hashmap_first(m->units)))
670 manager_dispatch_cleanup_queue(m);
672 assert(!m->load_queue);
673 assert(!m->run_queue);
674 assert(!m->dbus_unit_queue);
675 assert(!m->dbus_job_queue);
676 assert(!m->cleanup_queue);
677 assert(!m->gc_queue);
679 assert(hashmap_isempty(m->jobs));
680 assert(hashmap_isempty(m->units));
683 m->n_running_jobs = 0;
686 void manager_free(Manager *m) {
692 manager_clear_jobs_and_units(m);
694 for (c = 0; c < _UNIT_TYPE_MAX; c++)
695 if (unit_vtable[c]->shutdown)
696 unit_vtable[c]->shutdown(m);
698 /* If we reexecute ourselves, we keep the root cgroup
700 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
702 manager_undo_generators(m);
706 hashmap_free(m->units);
707 hashmap_free(m->jobs);
708 hashmap_free(m->watch_pids);
709 hashmap_free(m->watch_bus);
711 if (m->epoll_fd >= 0)
712 close_nointr_nofail(m->epoll_fd);
713 if (m->signal_watch.fd >= 0)
714 close_nointr_nofail(m->signal_watch.fd);
715 if (m->notify_watch.fd >= 0)
716 close_nointr_nofail(m->notify_watch.fd);
717 if (m->time_change_watch.fd >= 0)
718 close_nointr_nofail(m->time_change_watch.fd);
719 if (m->jobs_in_progress_watch.fd >= 0)
720 close_nointr_nofail(m->jobs_in_progress_watch.fd);
722 free(m->notify_socket);
724 lookup_paths_free(&m->lookup_paths);
725 strv_free(m->environment);
727 strv_free(m->default_controllers);
729 hashmap_free(m->cgroup_bondings);
730 set_free_free(m->unit_path_cache);
732 close_pipe(m->idle_pipe);
734 free(m->switch_root);
735 free(m->switch_root_init);
737 for (i = 0; i < RLIMIT_NLIMITS; i++)
743 int manager_enumerate(Manager *m) {
749 /* Let's ask every type to load all units from disk/kernel
750 * that it might know */
751 for (c = 0; c < _UNIT_TYPE_MAX; c++)
752 if (unit_vtable[c]->enumerate)
753 if ((q = unit_vtable[c]->enumerate(m)) < 0)
756 manager_dispatch_load_queue(m);
760 int manager_coldplug(Manager *m) {
768 /* Then, let's set up their initial state. */
769 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
775 if ((q = unit_coldplug(u)) < 0)
782 static void manager_build_unit_path_cache(Manager *m) {
784 DIR _cleanup_free_ *d = NULL;
789 set_free_free(m->unit_path_cache);
791 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
792 if (!m->unit_path_cache) {
793 log_error("Failed to allocate unit path cache.");
797 /* This simply builds a list of files we know exist, so that
798 * we don't always have to go to disk */
800 STRV_FOREACH(i, m->lookup_paths.unit_path) {
806 log_error("Failed to open directory %s: %m", *i);
810 while ((de = readdir(d))) {
813 if (ignore_file(de->d_name))
816 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
822 r = set_put(m->unit_path_cache, p);
836 log_error("Failed to build unit path cache: %s", strerror(-r));
838 set_free_free(m->unit_path_cache);
839 m->unit_path_cache = NULL;
842 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
847 manager_run_generators(m);
849 r = lookup_paths_init(
850 &m->lookup_paths, m->running_as, true,
851 m->generator_unit_path,
852 m->generator_unit_path_early,
853 m->generator_unit_path_late);
857 manager_build_unit_path_cache(m);
859 /* If we will deserialize make sure that during enumeration
860 * this is already known, so we increase the counter here
865 /* First, enumerate what we can from all config files */
866 r = manager_enumerate(m);
868 /* Second, deserialize if there is something to deserialize */
870 q = manager_deserialize(m, serialization, fds);
875 /* Any fds left? Find some unit which wants them. This is
876 * useful to allow container managers to pass some file
877 * descriptors to us pre-initialized. This enables
878 * socket-based activation of entire containers. */
879 if (fdset_size(fds) > 0) {
880 q = manager_distribute_fds(m, fds);
885 /* Third, fire things up! */
886 q = manager_coldplug(m);
891 assert(m->n_reloading > 0);
898 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
903 assert(type < _JOB_TYPE_MAX);
905 assert(mode < _JOB_MODE_MAX);
907 if (mode == JOB_ISOLATE && type != JOB_START) {
908 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
912 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
913 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
917 log_debug_unit(unit->id,
918 "Trying to enqueue job %s/%s/%s", unit->id,
919 job_type_to_string(type), job_mode_to_string(mode));
921 job_type_collapse(&type, unit);
923 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
927 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
928 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
929 mode == JOB_IGNORE_DEPENDENCIES, e);
933 if (mode == JOB_ISOLATE) {
934 r = transaction_add_isolate_jobs(tr, m);
939 r = transaction_activate(tr, m, mode, e);
943 log_debug_unit(unit->id,
944 "Enqueued job %s/%s as %u", unit->id,
945 job_type_to_string(type), (unsigned) tr->anchor_job->id);
948 *_ret = tr->anchor_job;
950 transaction_free(tr);
954 transaction_abort(tr);
955 transaction_free(tr);
959 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
964 assert(type < _JOB_TYPE_MAX);
966 assert(mode < _JOB_MODE_MAX);
968 r = manager_load_unit(m, name, NULL, NULL, &unit);
972 return manager_add_job(m, type, unit, mode, override, e, _ret);
975 Job *manager_get_job(Manager *m, uint32_t id) {
978 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
981 Unit *manager_get_unit(Manager *m, const char *name) {
985 return hashmap_get(m->units, name);
988 unsigned manager_dispatch_load_queue(Manager *m) {
994 /* Make sure we are not run recursively */
995 if (m->dispatching_load_queue)
998 m->dispatching_load_queue = true;
1000 /* Dispatches the load queue. Takes a unit from the queue and
1001 * tries to load its data until the queue is empty */
1003 while ((u = m->load_queue)) {
1004 assert(u->in_load_queue);
1010 m->dispatching_load_queue = false;
1014 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1020 assert(name || path);
1022 /* This will prepare the unit for loading, but not actually
1023 * load anything from disk. */
1025 if (path && !is_path(path)) {
1026 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1031 name = path_get_file_name(path);
1033 t = unit_name_to_type(name);
1035 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
1036 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1040 ret = manager_get_unit(m, name);
1046 ret = unit_new(m, unit_vtable[t]->object_size);
1051 ret->fragment_path = strdup(path);
1052 if (!ret->fragment_path) {
1058 if ((r = unit_add_name(ret, name)) < 0) {
1063 unit_add_to_load_queue(ret);
1064 unit_add_to_dbus_queue(ret);
1065 unit_add_to_gc_queue(ret);
1073 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1078 /* This will load the service information files, but not actually
1079 * start any services or anything. */
1081 r = manager_load_unit_prepare(m, name, path, e, _ret);
1085 manager_dispatch_load_queue(m);
1088 *_ret = unit_follow_merge(*_ret);
1093 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1100 HASHMAP_FOREACH(j, s->jobs, i)
1101 job_dump(j, f, prefix);
1104 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1112 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1114 unit_dump(u, f, prefix);
1117 void manager_clear_jobs(Manager *m) {
1122 while ((j = hashmap_first(m->jobs)))
1123 /* No need to recurse. We're cancelling all jobs. */
1124 job_finish_and_invalidate(j, JOB_CANCELED, false);
1127 unsigned manager_dispatch_run_queue(Manager *m) {
1131 if (m->dispatching_run_queue)
1134 m->dispatching_run_queue = true;
1136 while ((j = m->run_queue)) {
1137 assert(j->installed);
1138 assert(j->in_run_queue);
1140 job_run_and_invalidate(j);
1144 m->dispatching_run_queue = false;
1146 if (hashmap_size(m->jobs) > 0)
1147 manager_watch_jobs_in_progress(m);
1152 unsigned manager_dispatch_dbus_queue(Manager *m) {
1159 if (m->dispatching_dbus_queue)
1162 m->dispatching_dbus_queue = true;
1164 while ((u = m->dbus_unit_queue)) {
1165 assert(u->in_dbus_queue);
1167 bus_unit_send_change_signal(u);
1171 while ((j = m->dbus_job_queue)) {
1172 assert(j->in_dbus_queue);
1174 bus_job_send_change_signal(j);
1178 m->dispatching_dbus_queue = false;
1182 static int manager_process_notify_fd(Manager *m) {
1189 struct msghdr msghdr;
1191 struct ucred *ucred;
1193 struct cmsghdr cmsghdr;
1194 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1200 iovec.iov_base = buf;
1201 iovec.iov_len = sizeof(buf)-1;
1205 msghdr.msg_iov = &iovec;
1206 msghdr.msg_iovlen = 1;
1207 msghdr.msg_control = &control;
1208 msghdr.msg_controllen = sizeof(control);
1210 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1215 if (errno == EAGAIN || errno == EINTR)
1221 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1222 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1223 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1224 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1225 log_warning("Received notify message without credentials. Ignoring.");
1229 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1231 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1233 u = cgroup_unit_by_pid(m, ucred->pid);
1235 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1240 assert((size_t) n < sizeof(buf));
1242 tags = strv_split(buf, "\n\r");
1246 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1248 if (UNIT_VTABLE(u)->notify_message)
1249 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1257 static int manager_dispatch_sigchld(Manager *m) {
1267 /* First we call waitd() for a PID and do not reap the
1268 * zombie. That way we can still access /proc/$PID for
1269 * it while it is a zombie. */
1270 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1272 if (errno == ECHILD)
1284 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1285 char _cleanup_free_ *name = NULL;
1287 get_process_comm(si.si_pid, &name);
1288 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1291 /* Let's flush any message the dying child might still
1292 * have queued for us. This ensures that the process
1293 * still exists in /proc so that we can figure out
1294 * which cgroup and hence unit it belongs to. */
1295 r = manager_process_notify_fd(m);
1299 /* And now figure out the unit this belongs to */
1300 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1302 u = cgroup_unit_by_pid(m, si.si_pid);
1304 /* And now, we actually reap the zombie. */
1305 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1312 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1315 log_debug("Child %lu died (code=%s, status=%i/%s)",
1316 (long unsigned) si.si_pid,
1317 sigchld_code_to_string(si.si_code),
1319 strna(si.si_code == CLD_EXITED
1320 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1321 : signal_to_string(si.si_status)));
1326 log_debug_unit(u->id,
1327 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1329 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1330 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1336 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1340 dbus_error_init(&error);
1342 log_debug_unit(name, "Activating special unit %s", name);
1344 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1346 log_error_unit(name,
1347 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1349 dbus_error_free(&error);
1354 static int manager_process_signal_fd(Manager *m) {
1356 struct signalfd_siginfo sfsi;
1357 bool sigchld = false;
1362 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1363 if (n != sizeof(sfsi)) {
1368 if (errno == EINTR || errno == EAGAIN)
1374 if (sfsi.ssi_pid > 0) {
1377 get_process_comm(sfsi.ssi_pid, &p);
1379 log_debug("Received SIG%s from PID %lu (%s).",
1380 signal_to_string(sfsi.ssi_signo),
1381 (unsigned long) sfsi.ssi_pid, strna(p));
1384 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1386 switch (sfsi.ssi_signo) {
1393 if (m->running_as == SYSTEMD_SYSTEM) {
1394 /* This is for compatibility with the
1395 * original sysvinit */
1396 m->exit_code = MANAGER_REEXECUTE;
1403 if (m->running_as == SYSTEMD_SYSTEM) {
1404 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1408 /* Run the exit target if there is one, if not, just exit. */
1409 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1410 m->exit_code = MANAGER_EXIT;
1417 if (m->running_as == SYSTEMD_SYSTEM)
1418 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1420 /* This is a nop on non-init */
1424 if (m->running_as == SYSTEMD_SYSTEM)
1425 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1427 /* This is a nop on non-init */
1433 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1435 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1436 log_info("Trying to reconnect to bus...");
1440 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1441 log_info("Loading D-Bus service...");
1442 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1453 if (!(f = open_memstream(&dump, &size))) {
1454 log_warning("Failed to allocate memory stream.");
1458 manager_dump_units(m, f, "\t");
1459 manager_dump_jobs(m, f, "\t");
1464 log_warning("Failed to write status stream");
1469 log_dump(LOG_INFO, dump);
1476 m->exit_code = MANAGER_RELOAD;
1481 /* Starting SIGRTMIN+0 */
1482 static const char * const target_table[] = {
1483 [0] = SPECIAL_DEFAULT_TARGET,
1484 [1] = SPECIAL_RESCUE_TARGET,
1485 [2] = SPECIAL_EMERGENCY_TARGET,
1486 [3] = SPECIAL_HALT_TARGET,
1487 [4] = SPECIAL_POWEROFF_TARGET,
1488 [5] = SPECIAL_REBOOT_TARGET,
1489 [6] = SPECIAL_KEXEC_TARGET
1492 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1493 static const ManagerExitCode code_table[] = {
1495 [1] = MANAGER_POWEROFF,
1496 [2] = MANAGER_REBOOT,
1500 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1501 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1502 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1503 manager_start_target(m, target_table[idx],
1504 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1508 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1509 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1510 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1514 switch (sfsi.ssi_signo - SIGRTMIN) {
1517 log_debug("Enabling showing of status.");
1518 manager_set_show_status(m, true);
1522 log_debug("Disabling showing of status.");
1523 manager_set_show_status(m, false);
1527 log_set_max_level(LOG_DEBUG);
1528 log_notice("Setting log level to debug.");
1532 log_set_max_level(LOG_INFO);
1533 log_notice("Setting log level to info.");
1537 if (m->running_as == SYSTEMD_USER) {
1538 m->exit_code = MANAGER_EXIT;
1542 /* This is a nop on init */
1546 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1547 log_notice("Setting log target to journal-or-kmsg.");
1551 log_set_target(LOG_TARGET_CONSOLE);
1552 log_notice("Setting log target to console.");
1556 log_set_target(LOG_TARGET_KMSG);
1557 log_notice("Setting log target to kmsg.");
1561 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1562 log_notice("Setting log target to syslog-or-kmsg.");
1566 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1573 return manager_dispatch_sigchld(m);
1578 static int process_event(Manager *m, struct epoll_event *ev) {
1585 assert_se(w = ev->data.ptr);
1587 if (w->type == WATCH_INVALID)
1594 /* An incoming signal? */
1595 if (ev->events != EPOLLIN)
1598 if ((r = manager_process_signal_fd(m)) < 0)
1605 /* An incoming daemon notification event? */
1606 if (ev->events != EPOLLIN)
1609 if ((r = manager_process_notify_fd(m)) < 0)
1616 /* Some fd event, to be dispatched to the units */
1617 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1620 case WATCH_UNIT_TIMER:
1621 case WATCH_JOB_TIMER: {
1625 /* Some timer event, to be dispatched to the units */
1626 k = read(w->fd, &v, sizeof(v));
1627 if (k != sizeof(v)) {
1629 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1632 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1633 return k < 0 ? -errno : -EIO;
1636 if (w->type == WATCH_UNIT_TIMER)
1637 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1639 job_timer_event(w->data.job, v, w);
1644 /* Some mount table change, intended for the mount subsystem */
1645 mount_fd_event(m, ev->events);
1649 /* Some swap table change, intended for the swap subsystem */
1650 swap_fd_event(m, ev->events);
1654 /* Some notification from udev, intended for the device subsystem */
1655 device_fd_event(m, ev->events);
1658 case WATCH_DBUS_WATCH:
1659 bus_watch_event(m, w, ev->events);
1662 case WATCH_DBUS_TIMEOUT:
1663 bus_timeout_event(m, w, ev->events);
1666 case WATCH_TIME_CHANGE: {
1670 log_struct(LOG_INFO,
1671 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1672 "MESSAGE=Time has been changed",
1675 /* Restart the watch */
1676 close_nointr_nofail(m->time_change_watch.fd);
1677 watch_init(&m->time_change_watch);
1678 manager_setup_time_change(m);
1680 HASHMAP_FOREACH(u, m->units, i) {
1681 if (UNIT_VTABLE(u)->time_change)
1682 UNIT_VTABLE(u)->time_change(u);
1688 case WATCH_JOBS_IN_PROGRESS: {
1691 /* not interested in the data */
1692 read(w->fd, &v, sizeof(v));
1694 manager_print_jobs_in_progress(m);
1699 log_error("event type=%i", w->type);
1700 assert_not_reached("Unknown epoll event type.");
1706 int manager_loop(Manager *m) {
1709 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1712 m->exit_code = MANAGER_RUNNING;
1714 /* Release the path cache */
1715 set_free_free(m->unit_path_cache);
1716 m->unit_path_cache = NULL;
1718 manager_check_finished(m);
1720 /* There might still be some zombies hanging around from
1721 * before we were exec()'ed. Leat's reap them */
1722 r = manager_dispatch_sigchld(m);
1726 while (m->exit_code == MANAGER_RUNNING) {
1727 struct epoll_event event;
1731 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1734 if (!ratelimit_test(&rl)) {
1735 /* Yay, something is going seriously wrong, pause a little */
1736 log_warning("Looping too fast. Throttling execution a little.");
1741 if (manager_dispatch_load_queue(m) > 0)
1744 if (manager_dispatch_run_queue(m) > 0)
1747 if (bus_dispatch(m) > 0)
1750 if (manager_dispatch_cleanup_queue(m) > 0)
1753 if (manager_dispatch_gc_queue(m) > 0)
1756 if (manager_dispatch_dbus_queue(m) > 0)
1759 if (swap_dispatch_reload(m) > 0)
1762 /* Sleep for half the watchdog time */
1763 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1764 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1770 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1782 r = process_event(m, &event);
1787 return m->exit_code;
1790 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1799 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1802 n = bus_path_unescape(s+31);
1806 r = manager_load_unit(m, n, NULL, e, &u);
1817 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1826 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1829 r = safe_atou(s + 30, &id);
1833 j = manager_get_job(m, id);
1842 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1848 audit_fd = get_audit_fd();
1852 /* Don't generate audit events if the service was already
1853 * started and we're just deserializing */
1854 if (m->n_reloading > 0)
1857 if (m->running_as != SYSTEMD_SYSTEM)
1860 if (u->type != UNIT_SERVICE)
1863 p = unit_name_to_prefix_and_instance(u->id);
1865 log_error_unit(u->id,
1866 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1870 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1871 if (errno == EPERM) {
1872 /* We aren't allowed to send audit messages?
1873 * Then let's not retry again. */
1876 log_warning("Failed to send audit message: %m");
1884 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1886 union sockaddr_union sa;
1888 char *message = NULL;
1890 /* Don't generate plymouth events if the service was already
1891 * started and we're just deserializing */
1892 if (m->n_reloading > 0)
1895 if (m->running_as != SYSTEMD_SYSTEM)
1898 if (u->type != UNIT_SERVICE &&
1899 u->type != UNIT_MOUNT &&
1900 u->type != UNIT_SWAP)
1903 /* We set SOCK_NONBLOCK here so that we rather drop the
1904 * message then wait for plymouth */
1905 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1906 log_error("socket() failed: %m");
1911 sa.sa.sa_family = AF_UNIX;
1912 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1913 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1915 if (errno != EPIPE &&
1918 errno != ECONNREFUSED &&
1919 errno != ECONNRESET &&
1920 errno != ECONNABORTED)
1921 log_error("connect() failed: %m");
1926 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1932 if (write(fd, message, n + 1) != n + 1) {
1934 if (errno != EPIPE &&
1937 errno != ECONNREFUSED &&
1938 errno != ECONNRESET &&
1939 errno != ECONNABORTED)
1940 log_error("Failed to write Plymouth message: %m");
1947 close_nointr_nofail(fd);
1952 void manager_dispatch_bus_name_owner_changed(
1955 const char* old_owner,
1956 const char *new_owner) {
1963 if (!(u = hashmap_get(m->watch_bus, name)))
1966 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1969 void manager_dispatch_bus_query_pid_done(
1980 if (!(u = hashmap_get(m->watch_bus, name)))
1983 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1986 int manager_open_serialization(Manager *m, FILE **_f) {
1994 if (m->running_as == SYSTEMD_SYSTEM)
1995 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1997 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
2002 saved_umask = umask(0077);
2003 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2013 log_debug("Serializing state to %s", path);
2016 f = fdopen(fd, "w+");
2025 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
2038 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2039 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2040 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2041 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2043 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2044 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2045 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2046 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2049 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2050 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2053 STRV_FOREACH(e, m->environment) {
2054 _cleanup_free_ char *ce;
2058 fprintf(f, "env=%s\n", *e);
2063 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2067 if (!unit_can_serialize(u))
2074 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
2080 assert(m->n_reloading > 0);
2086 r = bus_fdset_add_all(m, fds);
2093 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2099 log_debug("Deserializing state...");
2104 char line[LINE_MAX], *l;
2106 if (!fgets(line, sizeof(line), f)) {
2121 if (startswith(l, "current-job-id=")) {
2124 if (safe_atou32(l+15, &id) < 0)
2125 log_debug("Failed to parse current job id value %s", l+15);
2127 m->current_job_id = MAX(m->current_job_id, id);
2128 } else if (startswith(l, "n-installed-jobs=")) {
2131 if (safe_atou32(l+17, &n) < 0)
2132 log_debug("Failed to parse installed jobs counter %s", l+17);
2134 m->n_installed_jobs += n;
2135 } else if (startswith(l, "n-failed-jobs=")) {
2138 if (safe_atou32(l+14, &n) < 0)
2139 log_debug("Failed to parse failed jobs counter %s", l+14);
2141 m->n_failed_jobs += n;
2142 } else if (startswith(l, "taint-usr=")) {
2145 if ((b = parse_boolean(l+10)) < 0)
2146 log_debug("Failed to parse taint /usr flag %s", l+10);
2148 m->taint_usr = m->taint_usr || b;
2149 } else if (startswith(l, "firmware-timestamp="))
2150 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2151 else if (startswith(l, "loader-timestamp="))
2152 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2153 else if (startswith(l, "kernel-timestamp="))
2154 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2155 else if (startswith(l, "initrd-timestamp="))
2156 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2157 else if (startswith(l, "userspace-timestamp="))
2158 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2159 else if (startswith(l, "finish-timestamp="))
2160 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2161 else if (startswith(l, "env=")) {
2162 _cleanup_free_ char *uce = NULL;
2165 uce = cunescape(l+4);
2171 e = strv_env_set(m->environment, uce);
2177 strv_free(m->environment);
2180 log_debug("Unknown serialization item '%s'", l);
2185 char name[UNIT_NAME_MAX+2];
2188 if (!fgets(name, sizeof(name), f)) {
2199 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2203 r = unit_deserialize(u, f, fds);
2214 assert(m->n_reloading > 0);
2220 int manager_distribute_fds(Manager *m, FDSet *fds) {
2227 HASHMAP_FOREACH(u, m->units, i) {
2229 if (fdset_size(fds) <= 0)
2232 if (UNIT_VTABLE(u)->distribute_fds) {
2233 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2242 int manager_reload(Manager *m) {
2249 r = manager_open_serialization(m, &f);
2262 r = manager_serialize(m, f, fds, true);
2268 if (fseeko(f, 0, SEEK_SET) < 0) {
2274 /* From here on there is no way back. */
2275 manager_clear_jobs_and_units(m);
2276 manager_undo_generators(m);
2277 lookup_paths_free(&m->lookup_paths);
2279 /* Find new unit paths */
2280 manager_run_generators(m);
2282 q = lookup_paths_init(
2283 &m->lookup_paths, m->running_as, true,
2284 m->generator_unit_path,
2285 m->generator_unit_path_early,
2286 m->generator_unit_path_late);
2290 manager_build_unit_path_cache(m);
2292 /* First, enumerate what we can from all config files */
2293 q = manager_enumerate(m);
2297 /* Second, deserialize our stored data */
2298 q = manager_deserialize(m, f, fds);
2305 /* Third, fire things up! */
2306 q = manager_coldplug(m);
2310 assert(m->n_reloading > 0);
2323 static bool manager_is_booting_or_shutting_down(Manager *m) {
2328 /* Is the initial job still around? */
2329 if (manager_get_job(m, m->default_unit_job_id))
2332 /* Is there a job for the shutdown target? */
2333 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2340 void manager_reset_failed(Manager *m) {
2346 HASHMAP_FOREACH(u, m->units, i)
2347 unit_reset_failed(u);
2350 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2356 /* Returns true if the unit is inactive or going down */
2357 u = manager_get_unit(m, name);
2361 return unit_pending_inactive(u);
2364 void manager_check_finished(Manager *m) {
2365 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2366 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2370 if (hashmap_size(m->jobs) > 0) {
2371 manager_jobs_in_progress_mod_timer(m);
2375 /* Notify Type=idle units that we are done now */
2376 close_pipe(m->idle_pipe);
2378 /* Turn off confirm spawn now */
2379 m->confirm_spawn = false;
2381 manager_unwatch_jobs_in_progress(m);
2383 if (dual_timestamp_is_set(&m->finish_timestamp))
2386 dual_timestamp_get(&m->finish_timestamp);
2388 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2390 /* Note that m->kernel_usec.monotonic is always at 0,
2391 * and m->firmware_usec.monotonic and
2392 * m->loader_usec.monotonic should be considered
2393 * negative values. */
2395 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2396 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2397 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2398 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2400 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2402 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2403 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2405 if (!log_on_console())
2406 log_struct(LOG_INFO,
2407 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2408 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2409 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2410 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2411 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2412 format_timespan(kernel, sizeof(kernel), kernel_usec),
2413 format_timespan(initrd, sizeof(initrd), initrd_usec),
2414 format_timespan(userspace, sizeof(userspace), userspace_usec),
2415 format_timespan(sum, sizeof(sum), total_usec),
2418 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2421 if (!log_on_console())
2422 log_struct(LOG_INFO,
2423 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2424 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2425 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2426 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2427 format_timespan(kernel, sizeof(kernel), kernel_usec),
2428 format_timespan(userspace, sizeof(userspace), userspace_usec),
2429 format_timespan(sum, sizeof(sum), total_usec),
2433 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2434 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2436 if (!log_on_console())
2437 log_struct(LOG_INFO,
2438 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2439 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2440 "MESSAGE=Startup finished in %s.",
2441 format_timespan(sum, sizeof(sum), total_usec),
2445 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2448 "READY=1\nSTATUS=Startup finished in %s.",
2449 format_timespan(sum, sizeof(sum), total_usec));
2452 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2463 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2465 p = strappend("/run/systemd/", name);
2469 r = mkdir_p_label(p, 0755);
2471 log_error("Failed to create generator directory %s: %s",
2477 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2482 log_error("Failed to create generator directory %s: %m",
2493 static void trim_generator_dir(Manager *m, char **generator) {
2500 if (rmdir(*generator) >= 0) {
2508 void manager_run_generators(Manager *m) {
2510 const char *generator_path;
2511 const char *argv[5];
2517 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2518 d = opendir(generator_path);
2520 if (errno == ENOENT)
2523 log_error("Failed to enumerate generator directory %s: %m",
2528 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2532 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2536 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2540 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2541 argv[1] = m->generator_unit_path;
2542 argv[2] = m->generator_unit_path_early;
2543 argv[3] = m->generator_unit_path_late;
2547 execute_directory(generator_path, d, (char**) argv);
2550 trim_generator_dir(m, &m->generator_unit_path);
2551 trim_generator_dir(m, &m->generator_unit_path_early);
2552 trim_generator_dir(m, &m->generator_unit_path_late);
2559 static void remove_generator_dir(Manager *m, char **generator) {
2566 strv_remove(m->lookup_paths.unit_path, *generator);
2567 rm_rf(*generator, false, true, false);
2573 void manager_undo_generators(Manager *m) {
2576 remove_generator_dir(m, &m->generator_unit_path);
2577 remove_generator_dir(m, &m->generator_unit_path_early);
2578 remove_generator_dir(m, &m->generator_unit_path_late);
2581 int manager_set_default_controllers(Manager *m, char **controllers) {
2586 l = strv_copy(controllers);
2590 strv_free(m->default_controllers);
2591 m->default_controllers = l;
2593 cg_shorten_controllers(m->default_controllers);
2598 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2603 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2604 if (!default_rlimit[i])
2607 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2615 void manager_recheck_journal(Manager *m) {
2620 if (m->running_as != SYSTEMD_SYSTEM)
2623 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2624 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2625 log_close_journal();
2629 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2630 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2631 log_close_journal();
2635 /* Hmm, OK, so the socket is fully up and the service is up
2636 * too, then let's make use of the thing. */
2640 void manager_set_show_status(Manager *m, bool b) {
2643 if (m->running_as != SYSTEMD_SYSTEM)
2649 touch("/run/systemd/show-status");
2651 unlink("/run/systemd/show-status");
2654 static bool manager_get_show_status(Manager *m) {
2657 if (m->running_as != SYSTEMD_SYSTEM)
2663 /* If Plymouth is running make sure we show the status, so
2664 * that there's something nice to see when people press Esc */
2666 return plymouth_running();
2669 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2672 if (!manager_get_show_status(m))
2675 /* XXX We should totally drop the check for ephemeral here
2676 * and thus effectively make 'Type=idle' pointless. */
2677 if (ephemeral && m->n_on_console > 0)
2680 if (!manager_is_booting_or_shutting_down(m))
2683 va_start(ap, format);
2684 status_vprintf(status, true, ephemeral, format, ap);
2688 void watch_init(Watch *w) {
2691 w->type = WATCH_INVALID;