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 .sa.sa_family = AF_UNIX,
99 struct epoll_event ev = {
101 .data.ptr = &m->notify_watch,
105 m->notify_watch.type = WATCH_NOTIFY;
106 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
107 if (m->notify_watch.fd < 0) {
108 log_error("Failed to allocate notification socket: %m");
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 r = bind(m->notify_watch.fd, &sa.sa,
120 offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
122 log_error("bind() failed: %m");
126 r = setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
128 log_error("SO_PASSCRED failed: %m");
132 r = epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev);
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 = {
150 .it_value.tv_sec = JOBS_IN_PROGRESS_WAIT_SEC,
151 .it_interval.tv_sec = JOBS_IN_PROGRESS_PERIOD_SEC,
154 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
157 if (timerfd_settime(m->jobs_in_progress_watch.fd, 0, &its, NULL) < 0)
163 static int manager_watch_jobs_in_progress(Manager *m) {
164 struct epoll_event ev = {
166 .data.ptr = &m->jobs_in_progress_watch,
170 if (m->jobs_in_progress_watch.type != WATCH_INVALID)
173 m->jobs_in_progress_watch.type = WATCH_JOBS_IN_PROGRESS;
174 m->jobs_in_progress_watch.fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
175 if (m->jobs_in_progress_watch.fd < 0) {
176 log_error("Failed to create timerfd: %m");
181 r = manager_jobs_in_progress_mod_timer(m);
183 log_error("Failed to set up timer for jobs progress watch: %s", strerror(-r));
187 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->jobs_in_progress_watch.fd, &ev) < 0) {
188 log_error("Failed to add jobs progress timer fd to epoll: %m");
193 log_debug("Set up jobs progress timerfd.");
198 if (m->jobs_in_progress_watch.fd >= 0)
199 close_nointr_nofail(m->jobs_in_progress_watch.fd);
200 watch_init(&m->jobs_in_progress_watch);
204 static void manager_unwatch_jobs_in_progress(Manager *m) {
205 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
208 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->jobs_in_progress_watch.fd, NULL) >= 0);
209 close_nointr_nofail(m->jobs_in_progress_watch.fd);
210 watch_init(&m->jobs_in_progress_watch);
211 m->jobs_in_progress_iteration = 0;
213 log_debug("Closed jobs progress timerfd.");
216 #define CYLON_BUFFER_EXTRA (2*strlen(ANSI_RED_ON) + strlen(ANSI_HIGHLIGHT_RED_ON) + 2*strlen(ANSI_HIGHLIGHT_OFF))
217 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
220 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
221 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
225 p = mempset(p, ' ', pos-2);
226 p = stpcpy(p, ANSI_RED_ON);
230 if (pos > 0 && pos <= width) {
231 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
235 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
238 p = stpcpy(p, ANSI_RED_ON);
241 p = mempset(p, ' ', width-1-pos);
242 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
246 static void manager_print_jobs_in_progress(Manager *m) {
249 char *job_of_n = NULL;
250 unsigned counter = 0, print_nr;
251 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
254 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
256 HASHMAP_FOREACH(j, m->jobs, i)
257 if (j->state == JOB_RUNNING && counter++ == print_nr)
260 /* m->n_running_jobs must be consistent with the contents of m->jobs,
261 * so the above loop must have succeeded in finding j. */
262 assert(counter == print_nr + 1);
264 cylon_pos = m->jobs_in_progress_iteration % 14;
266 cylon_pos = 14 - cylon_pos;
267 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
269 if (m->n_running_jobs > 1)
270 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
273 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
274 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
277 m->jobs_in_progress_iteration++;
280 static int manager_setup_time_change(Manager *m) {
281 struct epoll_event ev = {
283 .data.ptr = &m->time_change_watch,
286 /* We only care for the cancellation event, hence we set the
287 * timeout to the latest possible value. */
288 struct itimerspec its = {
289 .it_value.tv_sec = TIME_T_MAX,
291 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
293 assert(m->time_change_watch.type == WATCH_INVALID);
295 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
296 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
298 m->time_change_watch.type = WATCH_TIME_CHANGE;
299 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
300 if (m->time_change_watch.fd < 0) {
301 log_error("Failed to create timerfd: %m");
305 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
306 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
307 close_nointr_nofail(m->time_change_watch.fd);
308 watch_init(&m->time_change_watch);
312 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
313 log_error("Failed to add timer change fd to epoll: %m");
317 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
322 static int enable_special_signals(Manager *m) {
327 /* Enable that we get SIGINT on control-alt-del. In containers
328 * this will fail with EPERM (older) or EINVAL (newer), so
330 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
331 log_warning("Failed to enable ctrl-alt-del handling: %m");
333 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
335 /* Support systems without virtual console */
337 log_warning("Failed to open /dev/tty0: %m");
339 /* Enable that we get SIGWINCH on kbrequest */
340 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
341 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
343 close_nointr_nofail(fd);
349 static int manager_setup_signals(Manager *m) {
351 struct epoll_event ev = {
353 .data.ptr = &m->signal_watch,
355 struct sigaction sa = {
356 .sa_handler = SIG_DFL,
357 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
362 /* We are not interested in SIGSTOP and friends. */
363 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
365 assert_se(sigemptyset(&mask) == 0);
367 sigset_add_many(&mask,
368 SIGCHLD, /* Child died */
369 SIGTERM, /* Reexecute daemon */
370 SIGHUP, /* Reload configuration */
371 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
372 SIGUSR2, /* systemd: dump status */
373 SIGINT, /* Kernel sends us this on control-alt-del */
374 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
375 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
376 SIGRTMIN+0, /* systemd: start default.target */
377 SIGRTMIN+1, /* systemd: isolate rescue.target */
378 SIGRTMIN+2, /* systemd: isolate emergency.target */
379 SIGRTMIN+3, /* systemd: start halt.target */
380 SIGRTMIN+4, /* systemd: start poweroff.target */
381 SIGRTMIN+5, /* systemd: start reboot.target */
382 SIGRTMIN+6, /* systemd: start kexec.target */
383 SIGRTMIN+13, /* systemd: Immediate halt */
384 SIGRTMIN+14, /* systemd: Immediate poweroff */
385 SIGRTMIN+15, /* systemd: Immediate reboot */
386 SIGRTMIN+16, /* systemd: Immediate kexec */
387 SIGRTMIN+20, /* systemd: enable status messages */
388 SIGRTMIN+21, /* systemd: disable status messages */
389 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
390 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
391 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
392 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
393 SIGRTMIN+27, /* systemd: set log target to console */
394 SIGRTMIN+28, /* systemd: set log target to kmsg */
395 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
397 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
399 m->signal_watch.type = WATCH_SIGNAL;
400 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
401 if (m->signal_watch.fd < 0)
404 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
407 if (m->running_as == SYSTEMD_SYSTEM)
408 return enable_special_signals(m);
413 static void manager_strip_environment(Manager *m) {
416 /* Remove variables from the inherited set that are part of
417 * the container interface:
418 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
419 strv_remove_prefix(m->environment, "container=");
420 strv_remove_prefix(m->environment, "container_");
422 /* Remove variables from the inherited set that are part of
423 * the initrd interface:
424 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
425 strv_remove_prefix(m->environment, "RD_");
427 /* Drop invalid entries */
428 strv_env_clean(m->environment);
431 int manager_new(SystemdRunningAs running_as, Manager **_m) {
436 assert(running_as >= 0);
437 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
439 m = new0(Manager, 1);
443 dual_timestamp_get(&m->userspace_timestamp);
444 dual_timestamp_from_monotonic(&m->kernel_timestamp, 0);
446 efi_get_boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
449 m->running_as = running_as;
450 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
451 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
452 m->pin_cgroupfs_fd = -1;
453 m->idle_pipe[0] = m->idle_pipe[1] = -1;
455 watch_init(&m->signal_watch);
456 watch_init(&m->mount_watch);
457 watch_init(&m->swap_watch);
458 watch_init(&m->udev_watch);
459 watch_init(&m->time_change_watch);
460 watch_init(&m->jobs_in_progress_watch);
462 m->epoll_fd = m->dev_autofs_fd = -1;
463 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
465 m->environment = strv_copy(environ);
469 manager_strip_environment(m);
471 if (running_as == SYSTEMD_SYSTEM) {
472 m->default_controllers = strv_new("cpu", NULL);
473 if (!m->default_controllers)
477 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
480 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
483 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
486 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
489 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
492 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
496 r = manager_setup_signals(m);
500 r = manager_setup_cgroup(m);
504 r = manager_setup_notify(m);
508 r = manager_setup_time_change(m);
512 /* Try to connect to the busses, if possible. */
513 r = bus_init(m, running_as != SYSTEMD_SYSTEM);
517 m->taint_usr = dir_is_empty("/usr") > 0;
527 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
533 while ((u = m->cleanup_queue)) {
534 assert(u->in_cleanup_queue);
544 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
545 GC_OFFSET_UNSURE, /* No clue */
546 GC_OFFSET_GOOD, /* We still need this unit */
547 GC_OFFSET_BAD, /* We don't need this unit anymore */
551 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
558 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
559 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
560 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
563 if (u->in_cleanup_queue)
566 if (unit_check_gc(u))
569 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
573 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
574 unit_gc_sweep(other, gc_marker);
576 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
579 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
586 /* We were unable to find anything out about this entry, so
587 * let's investigate it later */
588 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
589 unit_add_to_gc_queue(u);
593 /* We definitely know that this one is not useful anymore, so
594 * let's mark it for deletion */
595 u->gc_marker = gc_marker + GC_OFFSET_BAD;
596 unit_add_to_cleanup_queue(u);
600 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
603 static unsigned manager_dispatch_gc_queue(Manager *m) {
610 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
611 (m->gc_queue_timestamp <= 0 ||
612 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
615 log_debug("Running GC...");
617 m->gc_marker += _GC_OFFSET_MAX;
618 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
621 gc_marker = m->gc_marker;
623 while ((u = m->gc_queue)) {
624 assert(u->in_gc_queue);
626 unit_gc_sweep(u, gc_marker);
628 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
629 u->in_gc_queue = false;
633 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
634 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
635 log_debug_unit(u->id, "Collecting %s", u->id);
636 u->gc_marker = gc_marker + GC_OFFSET_BAD;
637 unit_add_to_cleanup_queue(u);
641 m->n_in_gc_queue = 0;
642 m->gc_queue_timestamp = 0;
647 static void manager_clear_jobs_and_units(Manager *m) {
652 while ((u = hashmap_first(m->units)))
655 manager_dispatch_cleanup_queue(m);
657 assert(!m->load_queue);
658 assert(!m->run_queue);
659 assert(!m->dbus_unit_queue);
660 assert(!m->dbus_job_queue);
661 assert(!m->cleanup_queue);
662 assert(!m->gc_queue);
664 assert(hashmap_isempty(m->jobs));
665 assert(hashmap_isempty(m->units));
668 m->n_running_jobs = 0;
671 void manager_free(Manager *m) {
677 manager_clear_jobs_and_units(m);
679 for (c = 0; c < _UNIT_TYPE_MAX; c++)
680 if (unit_vtable[c]->shutdown)
681 unit_vtable[c]->shutdown(m);
683 /* If we reexecute ourselves, we keep the root cgroup
685 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
687 manager_undo_generators(m);
691 hashmap_free(m->units);
692 hashmap_free(m->jobs);
693 hashmap_free(m->watch_pids);
694 hashmap_free(m->watch_bus);
696 if (m->epoll_fd >= 0)
697 close_nointr_nofail(m->epoll_fd);
698 if (m->signal_watch.fd >= 0)
699 close_nointr_nofail(m->signal_watch.fd);
700 if (m->notify_watch.fd >= 0)
701 close_nointr_nofail(m->notify_watch.fd);
702 if (m->time_change_watch.fd >= 0)
703 close_nointr_nofail(m->time_change_watch.fd);
704 if (m->jobs_in_progress_watch.fd >= 0)
705 close_nointr_nofail(m->jobs_in_progress_watch.fd);
707 free(m->notify_socket);
709 lookup_paths_free(&m->lookup_paths);
710 strv_free(m->environment);
712 strv_free(m->default_controllers);
714 hashmap_free(m->cgroup_bondings);
715 set_free_free(m->unit_path_cache);
717 close_pipe(m->idle_pipe);
719 free(m->switch_root);
720 free(m->switch_root_init);
722 for (i = 0; i < RLIMIT_NLIMITS; i++)
728 int manager_enumerate(Manager *m) {
734 /* Let's ask every type to load all units from disk/kernel
735 * that it might know */
736 for (c = 0; c < _UNIT_TYPE_MAX; c++)
737 if (unit_vtable[c]->enumerate)
738 if ((q = unit_vtable[c]->enumerate(m)) < 0)
741 manager_dispatch_load_queue(m);
745 int manager_coldplug(Manager *m) {
753 /* Then, let's set up their initial state. */
754 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
760 if ((q = unit_coldplug(u)) < 0)
767 static void manager_build_unit_path_cache(Manager *m) {
769 DIR _cleanup_free_ *d = NULL;
774 set_free_free(m->unit_path_cache);
776 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
777 if (!m->unit_path_cache) {
778 log_error("Failed to allocate unit path cache.");
782 /* This simply builds a list of files we know exist, so that
783 * we don't always have to go to disk */
785 STRV_FOREACH(i, m->lookup_paths.unit_path) {
791 log_error("Failed to open directory %s: %m", *i);
795 while ((de = readdir(d))) {
798 if (ignore_file(de->d_name))
801 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
807 r = set_put(m->unit_path_cache, p);
821 log_error("Failed to build unit path cache: %s", strerror(-r));
823 set_free_free(m->unit_path_cache);
824 m->unit_path_cache = NULL;
827 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
832 manager_run_generators(m);
834 r = lookup_paths_init(
835 &m->lookup_paths, m->running_as, true,
836 m->generator_unit_path,
837 m->generator_unit_path_early,
838 m->generator_unit_path_late);
842 manager_build_unit_path_cache(m);
844 /* If we will deserialize make sure that during enumeration
845 * this is already known, so we increase the counter here
850 /* First, enumerate what we can from all config files */
851 r = manager_enumerate(m);
853 /* Second, deserialize if there is something to deserialize */
855 q = manager_deserialize(m, serialization, fds);
860 /* Any fds left? Find some unit which wants them. This is
861 * useful to allow container managers to pass some file
862 * descriptors to us pre-initialized. This enables
863 * socket-based activation of entire containers. */
864 if (fdset_size(fds) > 0) {
865 q = manager_distribute_fds(m, fds);
870 /* Third, fire things up! */
871 q = manager_coldplug(m);
876 assert(m->n_reloading > 0);
883 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
888 assert(type < _JOB_TYPE_MAX);
890 assert(mode < _JOB_MODE_MAX);
892 if (mode == JOB_ISOLATE && type != JOB_START) {
893 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
897 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
898 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
902 log_debug_unit(unit->id,
903 "Trying to enqueue job %s/%s/%s", unit->id,
904 job_type_to_string(type), job_mode_to_string(mode));
906 job_type_collapse(&type, unit);
908 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
912 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
913 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
914 mode == JOB_IGNORE_DEPENDENCIES, e);
918 if (mode == JOB_ISOLATE) {
919 r = transaction_add_isolate_jobs(tr, m);
924 r = transaction_activate(tr, m, mode, e);
928 log_debug_unit(unit->id,
929 "Enqueued job %s/%s as %u", unit->id,
930 job_type_to_string(type), (unsigned) tr->anchor_job->id);
933 *_ret = tr->anchor_job;
935 transaction_free(tr);
939 transaction_abort(tr);
940 transaction_free(tr);
944 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
949 assert(type < _JOB_TYPE_MAX);
951 assert(mode < _JOB_MODE_MAX);
953 r = manager_load_unit(m, name, NULL, NULL, &unit);
957 return manager_add_job(m, type, unit, mode, override, e, _ret);
960 Job *manager_get_job(Manager *m, uint32_t id) {
963 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
966 Unit *manager_get_unit(Manager *m, const char *name) {
970 return hashmap_get(m->units, name);
973 unsigned manager_dispatch_load_queue(Manager *m) {
979 /* Make sure we are not run recursively */
980 if (m->dispatching_load_queue)
983 m->dispatching_load_queue = true;
985 /* Dispatches the load queue. Takes a unit from the queue and
986 * tries to load its data until the queue is empty */
988 while ((u = m->load_queue)) {
989 assert(u->in_load_queue);
995 m->dispatching_load_queue = false;
999 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1005 assert(name || path);
1007 /* This will prepare the unit for loading, but not actually
1008 * load anything from disk. */
1010 if (path && !is_path(path)) {
1011 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1016 name = path_get_file_name(path);
1018 t = unit_name_to_type(name);
1020 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
1021 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1025 ret = manager_get_unit(m, name);
1031 ret = unit_new(m, unit_vtable[t]->object_size);
1036 ret->fragment_path = strdup(path);
1037 if (!ret->fragment_path) {
1043 if ((r = unit_add_name(ret, name)) < 0) {
1048 unit_add_to_load_queue(ret);
1049 unit_add_to_dbus_queue(ret);
1050 unit_add_to_gc_queue(ret);
1058 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1063 /* This will load the service information files, but not actually
1064 * start any services or anything. */
1066 r = manager_load_unit_prepare(m, name, path, e, _ret);
1070 manager_dispatch_load_queue(m);
1073 *_ret = unit_follow_merge(*_ret);
1078 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1085 HASHMAP_FOREACH(j, s->jobs, i)
1086 job_dump(j, f, prefix);
1089 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1097 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1099 unit_dump(u, f, prefix);
1102 void manager_clear_jobs(Manager *m) {
1107 while ((j = hashmap_first(m->jobs)))
1108 /* No need to recurse. We're cancelling all jobs. */
1109 job_finish_and_invalidate(j, JOB_CANCELED, false);
1112 unsigned manager_dispatch_run_queue(Manager *m) {
1116 if (m->dispatching_run_queue)
1119 m->dispatching_run_queue = true;
1121 while ((j = m->run_queue)) {
1122 assert(j->installed);
1123 assert(j->in_run_queue);
1125 job_run_and_invalidate(j);
1129 m->dispatching_run_queue = false;
1131 if (m->n_running_jobs > 0)
1132 manager_watch_jobs_in_progress(m);
1137 unsigned manager_dispatch_dbus_queue(Manager *m) {
1144 if (m->dispatching_dbus_queue)
1147 m->dispatching_dbus_queue = true;
1149 while ((u = m->dbus_unit_queue)) {
1150 assert(u->in_dbus_queue);
1152 bus_unit_send_change_signal(u);
1156 while ((j = m->dbus_job_queue)) {
1157 assert(j->in_dbus_queue);
1159 bus_job_send_change_signal(j);
1163 m->dispatching_dbus_queue = false;
1167 static int manager_process_notify_fd(Manager *m) {
1174 struct iovec iovec = {
1176 .iov_len = sizeof(buf)-1,
1180 struct cmsghdr cmsghdr;
1181 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1184 struct msghdr msghdr = {
1187 .msg_control = &control,
1188 .msg_controllen = sizeof(control),
1190 struct ucred *ucred;
1192 char _cleanup_strv_free_ **tags = NULL;
1194 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1199 if (errno == EAGAIN || errno == EINTR)
1205 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1206 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1207 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1208 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1209 log_warning("Received notify message without credentials. Ignoring.");
1213 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1215 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1217 u = cgroup_unit_by_pid(m, ucred->pid);
1219 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1224 assert((size_t) n < sizeof(buf));
1226 tags = strv_split(buf, "\n\r");
1230 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1232 if (UNIT_VTABLE(u)->notify_message)
1233 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1239 static int manager_dispatch_sigchld(Manager *m) {
1247 /* First we call waitd() for a PID and do not reap the
1248 * zombie. That way we can still access /proc/$PID for
1249 * it while it is a zombie. */
1250 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1252 if (errno == ECHILD)
1264 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1265 char _cleanup_free_ *name = NULL;
1267 get_process_comm(si.si_pid, &name);
1268 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1271 /* Let's flush any message the dying child might still
1272 * have queued for us. This ensures that the process
1273 * still exists in /proc so that we can figure out
1274 * which cgroup and hence unit it belongs to. */
1275 r = manager_process_notify_fd(m);
1279 /* And now figure out the unit this belongs to */
1280 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1282 u = cgroup_unit_by_pid(m, si.si_pid);
1284 /* And now, we actually reap the zombie. */
1285 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1292 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1295 log_debug("Child %lu died (code=%s, status=%i/%s)",
1296 (long unsigned) si.si_pid,
1297 sigchld_code_to_string(si.si_code),
1299 strna(si.si_code == CLD_EXITED
1300 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1301 : signal_to_string(si.si_status)));
1306 log_debug_unit(u->id,
1307 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1309 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1310 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1316 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1320 dbus_error_init(&error);
1322 log_debug_unit(name, "Activating special unit %s", name);
1324 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1326 log_error_unit(name,
1327 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1329 dbus_error_free(&error);
1334 static int manager_process_signal_fd(Manager *m) {
1336 struct signalfd_siginfo sfsi;
1337 bool sigchld = false;
1342 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1343 if (n != sizeof(sfsi)) {
1348 if (errno == EINTR || errno == EAGAIN)
1354 if (sfsi.ssi_pid > 0) {
1357 get_process_comm(sfsi.ssi_pid, &p);
1359 log_debug("Received SIG%s from PID %lu (%s).",
1360 signal_to_string(sfsi.ssi_signo),
1361 (unsigned long) sfsi.ssi_pid, strna(p));
1364 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1366 switch (sfsi.ssi_signo) {
1373 if (m->running_as == SYSTEMD_SYSTEM) {
1374 /* This is for compatibility with the
1375 * original sysvinit */
1376 m->exit_code = MANAGER_REEXECUTE;
1383 if (m->running_as == SYSTEMD_SYSTEM) {
1384 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1388 /* Run the exit target if there is one, if not, just exit. */
1389 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1390 m->exit_code = MANAGER_EXIT;
1397 if (m->running_as == SYSTEMD_SYSTEM)
1398 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1400 /* This is a nop on non-init */
1404 if (m->running_as == SYSTEMD_SYSTEM)
1405 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1407 /* This is a nop on non-init */
1413 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1415 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1416 log_info("Trying to reconnect to bus...");
1420 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1421 log_info("Loading D-Bus service...");
1422 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1433 if (!(f = open_memstream(&dump, &size))) {
1434 log_warning("Failed to allocate memory stream.");
1438 manager_dump_units(m, f, "\t");
1439 manager_dump_jobs(m, f, "\t");
1444 log_warning("Failed to write status stream");
1449 log_dump(LOG_INFO, dump);
1456 m->exit_code = MANAGER_RELOAD;
1461 /* Starting SIGRTMIN+0 */
1462 static const char * const target_table[] = {
1463 [0] = SPECIAL_DEFAULT_TARGET,
1464 [1] = SPECIAL_RESCUE_TARGET,
1465 [2] = SPECIAL_EMERGENCY_TARGET,
1466 [3] = SPECIAL_HALT_TARGET,
1467 [4] = SPECIAL_POWEROFF_TARGET,
1468 [5] = SPECIAL_REBOOT_TARGET,
1469 [6] = SPECIAL_KEXEC_TARGET
1472 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1473 static const ManagerExitCode code_table[] = {
1475 [1] = MANAGER_POWEROFF,
1476 [2] = MANAGER_REBOOT,
1480 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1481 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1482 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1483 manager_start_target(m, target_table[idx],
1484 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1488 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1489 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1490 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1494 switch (sfsi.ssi_signo - SIGRTMIN) {
1497 log_debug("Enabling showing of status.");
1498 manager_set_show_status(m, true);
1502 log_debug("Disabling showing of status.");
1503 manager_set_show_status(m, false);
1507 log_set_max_level(LOG_DEBUG);
1508 log_notice("Setting log level to debug.");
1512 log_set_max_level(LOG_INFO);
1513 log_notice("Setting log level to info.");
1517 if (m->running_as == SYSTEMD_USER) {
1518 m->exit_code = MANAGER_EXIT;
1522 /* This is a nop on init */
1526 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1527 log_notice("Setting log target to journal-or-kmsg.");
1531 log_set_target(LOG_TARGET_CONSOLE);
1532 log_notice("Setting log target to console.");
1536 log_set_target(LOG_TARGET_KMSG);
1537 log_notice("Setting log target to kmsg.");
1541 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1542 log_notice("Setting log target to syslog-or-kmsg.");
1546 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1553 return manager_dispatch_sigchld(m);
1558 static int process_event(Manager *m, struct epoll_event *ev) {
1565 assert_se(w = ev->data.ptr);
1567 if (w->type == WATCH_INVALID)
1574 /* An incoming signal? */
1575 if (ev->events != EPOLLIN)
1578 if ((r = manager_process_signal_fd(m)) < 0)
1585 /* An incoming daemon notification event? */
1586 if (ev->events != EPOLLIN)
1589 if ((r = manager_process_notify_fd(m)) < 0)
1596 /* Some fd event, to be dispatched to the units */
1597 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1600 case WATCH_UNIT_TIMER:
1601 case WATCH_JOB_TIMER: {
1605 /* Some timer event, to be dispatched to the units */
1606 k = read(w->fd, &v, sizeof(v));
1607 if (k != sizeof(v)) {
1609 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1612 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1613 return k < 0 ? -errno : -EIO;
1616 if (w->type == WATCH_UNIT_TIMER)
1617 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1619 job_timer_event(w->data.job, v, w);
1624 /* Some mount table change, intended for the mount subsystem */
1625 mount_fd_event(m, ev->events);
1629 /* Some swap table change, intended for the swap subsystem */
1630 swap_fd_event(m, ev->events);
1634 /* Some notification from udev, intended for the device subsystem */
1635 device_fd_event(m, ev->events);
1638 case WATCH_DBUS_WATCH:
1639 bus_watch_event(m, w, ev->events);
1642 case WATCH_DBUS_TIMEOUT:
1643 bus_timeout_event(m, w, ev->events);
1646 case WATCH_TIME_CHANGE: {
1650 log_struct(LOG_INFO,
1651 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1652 "MESSAGE=Time has been changed",
1655 /* Restart the watch */
1656 epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->time_change_watch.fd,
1658 close_nointr_nofail(m->time_change_watch.fd);
1659 watch_init(&m->time_change_watch);
1660 manager_setup_time_change(m);
1662 HASHMAP_FOREACH(u, m->units, i) {
1663 if (UNIT_VTABLE(u)->time_change)
1664 UNIT_VTABLE(u)->time_change(u);
1670 case WATCH_JOBS_IN_PROGRESS: {
1673 /* not interested in the data */
1674 read(w->fd, &v, sizeof(v));
1676 manager_print_jobs_in_progress(m);
1681 log_error("event type=%i", w->type);
1682 assert_not_reached("Unknown epoll event type.");
1688 int manager_loop(Manager *m) {
1691 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1694 m->exit_code = MANAGER_RUNNING;
1696 /* Release the path cache */
1697 set_free_free(m->unit_path_cache);
1698 m->unit_path_cache = NULL;
1700 manager_check_finished(m);
1702 /* There might still be some zombies hanging around from
1703 * before we were exec()'ed. Leat's reap them */
1704 r = manager_dispatch_sigchld(m);
1708 while (m->exit_code == MANAGER_RUNNING) {
1709 struct epoll_event event;
1713 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1716 if (!ratelimit_test(&rl)) {
1717 /* Yay, something is going seriously wrong, pause a little */
1718 log_warning("Looping too fast. Throttling execution a little.");
1723 if (manager_dispatch_load_queue(m) > 0)
1726 if (manager_dispatch_run_queue(m) > 0)
1729 if (bus_dispatch(m) > 0)
1732 if (manager_dispatch_cleanup_queue(m) > 0)
1735 if (manager_dispatch_gc_queue(m) > 0)
1738 if (manager_dispatch_dbus_queue(m) > 0)
1741 if (swap_dispatch_reload(m) > 0)
1744 /* Sleep for half the watchdog time */
1745 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1746 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1752 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1764 r = process_event(m, &event);
1769 return m->exit_code;
1772 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1781 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1784 n = bus_path_unescape(s+31);
1788 r = manager_load_unit(m, n, NULL, e, &u);
1799 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1808 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1811 r = safe_atou(s + 30, &id);
1815 j = manager_get_job(m, id);
1824 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1830 audit_fd = get_audit_fd();
1834 /* Don't generate audit events if the service was already
1835 * started and we're just deserializing */
1836 if (m->n_reloading > 0)
1839 if (m->running_as != SYSTEMD_SYSTEM)
1842 if (u->type != UNIT_SERVICE)
1845 p = unit_name_to_prefix_and_instance(u->id);
1847 log_error_unit(u->id,
1848 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1852 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1853 if (errno == EPERM) {
1854 /* We aren't allowed to send audit messages?
1855 * Then let's not retry again. */
1858 log_warning("Failed to send audit message: %m");
1866 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1868 union sockaddr_union sa;
1870 char *message = NULL;
1872 /* Don't generate plymouth events if the service was already
1873 * started and we're just deserializing */
1874 if (m->n_reloading > 0)
1877 if (m->running_as != SYSTEMD_SYSTEM)
1880 if (u->type != UNIT_SERVICE &&
1881 u->type != UNIT_MOUNT &&
1882 u->type != UNIT_SWAP)
1885 /* We set SOCK_NONBLOCK here so that we rather drop the
1886 * message then wait for plymouth */
1887 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1889 log_error("socket() failed: %m");
1894 sa.sa.sa_family = AF_UNIX;
1895 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1896 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1898 if (errno != EPIPE &&
1901 errno != ECONNREFUSED &&
1902 errno != ECONNRESET &&
1903 errno != ECONNABORTED)
1904 log_error("connect() failed: %m");
1909 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1915 if (write(fd, message, n + 1) != n + 1) {
1917 if (errno != EPIPE &&
1920 errno != ECONNREFUSED &&
1921 errno != ECONNRESET &&
1922 errno != ECONNABORTED)
1923 log_error("Failed to write Plymouth message: %m");
1930 close_nointr_nofail(fd);
1935 void manager_dispatch_bus_name_owner_changed(
1938 const char* old_owner,
1939 const char *new_owner) {
1946 if (!(u = hashmap_get(m->watch_bus, name)))
1949 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1952 void manager_dispatch_bus_query_pid_done(
1963 if (!(u = hashmap_get(m->watch_bus, name)))
1966 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1969 int manager_open_serialization(Manager *m, FILE **_f) {
1976 if (m->running_as == SYSTEMD_SYSTEM)
1977 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1979 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1984 RUN_WITH_UMASK(0077) {
1985 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1995 log_debug("Serializing state to %s", path);
1998 f = fdopen(fd, "w+");
2007 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2020 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2021 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2022 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2023 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2025 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2026 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2027 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2028 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2031 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2032 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2035 if (!switching_root) {
2036 STRV_FOREACH(e, m->environment) {
2037 _cleanup_free_ char *ce;
2041 fprintf(f, "env=%s\n", *e);
2047 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2051 if (!unit_can_serialize(u))
2058 if ((r = unit_serialize(u, f, fds, !switching_root)) < 0) {
2064 assert(m->n_reloading > 0);
2070 r = bus_fdset_add_all(m, fds);
2077 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2083 log_debug("Deserializing state...");
2088 char line[LINE_MAX], *l;
2090 if (!fgets(line, sizeof(line), f)) {
2105 if (startswith(l, "current-job-id=")) {
2108 if (safe_atou32(l+15, &id) < 0)
2109 log_debug("Failed to parse current job id value %s", l+15);
2111 m->current_job_id = MAX(m->current_job_id, id);
2112 } else if (startswith(l, "n-installed-jobs=")) {
2115 if (safe_atou32(l+17, &n) < 0)
2116 log_debug("Failed to parse installed jobs counter %s", l+17);
2118 m->n_installed_jobs += n;
2119 } else if (startswith(l, "n-failed-jobs=")) {
2122 if (safe_atou32(l+14, &n) < 0)
2123 log_debug("Failed to parse failed jobs counter %s", l+14);
2125 m->n_failed_jobs += n;
2126 } else if (startswith(l, "taint-usr=")) {
2129 if ((b = parse_boolean(l+10)) < 0)
2130 log_debug("Failed to parse taint /usr flag %s", l+10);
2132 m->taint_usr = m->taint_usr || b;
2133 } else if (startswith(l, "firmware-timestamp="))
2134 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2135 else if (startswith(l, "loader-timestamp="))
2136 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2137 else if (startswith(l, "kernel-timestamp="))
2138 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2139 else if (startswith(l, "initrd-timestamp="))
2140 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2141 else if (startswith(l, "userspace-timestamp="))
2142 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2143 else if (startswith(l, "finish-timestamp="))
2144 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2145 else if (startswith(l, "env=")) {
2146 _cleanup_free_ char *uce = NULL;
2149 uce = cunescape(l+4);
2155 e = strv_env_set(m->environment, uce);
2161 strv_free(m->environment);
2164 log_debug("Unknown serialization item '%s'", l);
2169 char name[UNIT_NAME_MAX+2];
2172 if (!fgets(name, sizeof(name), f)) {
2183 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2187 r = unit_deserialize(u, f, fds);
2198 assert(m->n_reloading > 0);
2204 int manager_distribute_fds(Manager *m, FDSet *fds) {
2211 HASHMAP_FOREACH(u, m->units, i) {
2213 if (fdset_size(fds) <= 0)
2216 if (UNIT_VTABLE(u)->distribute_fds) {
2217 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2226 int manager_reload(Manager *m) {
2233 r = manager_open_serialization(m, &f);
2246 r = manager_serialize(m, f, fds, false);
2252 if (fseeko(f, 0, SEEK_SET) < 0) {
2258 /* From here on there is no way back. */
2259 manager_clear_jobs_and_units(m);
2260 manager_undo_generators(m);
2261 lookup_paths_free(&m->lookup_paths);
2263 /* Find new unit paths */
2264 manager_run_generators(m);
2266 q = lookup_paths_init(
2267 &m->lookup_paths, m->running_as, true,
2268 m->generator_unit_path,
2269 m->generator_unit_path_early,
2270 m->generator_unit_path_late);
2274 manager_build_unit_path_cache(m);
2276 /* First, enumerate what we can from all config files */
2277 q = manager_enumerate(m);
2281 /* Second, deserialize our stored data */
2282 q = manager_deserialize(m, f, fds);
2289 /* Third, fire things up! */
2290 q = manager_coldplug(m);
2294 assert(m->n_reloading > 0);
2307 static bool manager_is_booting_or_shutting_down(Manager *m) {
2312 /* Is the initial job still around? */
2313 if (manager_get_job(m, m->default_unit_job_id))
2316 /* Is there a job for the shutdown target? */
2317 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2324 bool manager_is_reloading_or_reexecuting(Manager *m) {
2327 return m->n_reloading != 0;
2330 void manager_reset_failed(Manager *m) {
2336 HASHMAP_FOREACH(u, m->units, i)
2337 unit_reset_failed(u);
2340 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2346 /* Returns true if the unit is inactive or going down */
2347 u = manager_get_unit(m, name);
2351 return unit_pending_inactive(u);
2354 void manager_check_finished(Manager *m) {
2355 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2356 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2360 if (m->n_running_jobs == 0)
2361 manager_unwatch_jobs_in_progress(m);
2363 if (hashmap_size(m->jobs) > 0) {
2364 manager_jobs_in_progress_mod_timer(m);
2368 /* Notify Type=idle units that we are done now */
2369 close_pipe(m->idle_pipe);
2371 /* Turn off confirm spawn now */
2372 m->confirm_spawn = false;
2374 if (dual_timestamp_is_set(&m->finish_timestamp))
2377 dual_timestamp_get(&m->finish_timestamp);
2379 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2381 /* Note that m->kernel_usec.monotonic is always at 0,
2382 * and m->firmware_usec.monotonic and
2383 * m->loader_usec.monotonic should be considered
2384 * negative values. */
2386 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2387 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2388 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2389 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2391 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2393 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2394 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2396 if (!log_on_console())
2397 log_struct(LOG_INFO,
2398 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2399 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2400 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2401 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2402 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2403 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2404 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2405 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2406 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2409 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2412 if (!log_on_console())
2413 log_struct(LOG_INFO,
2414 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2415 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2416 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2417 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2418 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2419 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2420 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2424 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2425 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2427 if (!log_on_console())
2428 log_struct(LOG_INFO,
2429 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2430 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2431 "MESSAGE=Startup finished in %s.",
2432 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2436 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2439 "READY=1\nSTATUS=Startup finished in %s.",
2440 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2443 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2454 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2456 p = strappend("/run/systemd/", name);
2460 r = mkdir_p_label(p, 0755);
2462 log_error("Failed to create generator directory %s: %s",
2468 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2473 log_error("Failed to create generator directory %s: %m",
2484 static void trim_generator_dir(Manager *m, char **generator) {
2491 if (rmdir(*generator) >= 0) {
2499 void manager_run_generators(Manager *m) {
2501 const char *generator_path;
2502 const char *argv[5];
2507 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2508 d = opendir(generator_path);
2510 if (errno == ENOENT)
2513 log_error("Failed to enumerate generator directory %s: %m",
2518 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2522 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2526 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2530 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2531 argv[1] = m->generator_unit_path;
2532 argv[2] = m->generator_unit_path_early;
2533 argv[3] = m->generator_unit_path_late;
2536 RUN_WITH_UMASK(0022) {
2537 execute_directory(generator_path, d, (char**) argv);
2540 trim_generator_dir(m, &m->generator_unit_path);
2541 trim_generator_dir(m, &m->generator_unit_path_early);
2542 trim_generator_dir(m, &m->generator_unit_path_late);
2549 static void remove_generator_dir(Manager *m, char **generator) {
2556 strv_remove(m->lookup_paths.unit_path, *generator);
2557 rm_rf(*generator, false, true, false);
2563 void manager_undo_generators(Manager *m) {
2566 remove_generator_dir(m, &m->generator_unit_path);
2567 remove_generator_dir(m, &m->generator_unit_path_early);
2568 remove_generator_dir(m, &m->generator_unit_path_late);
2571 int manager_set_default_controllers(Manager *m, char **controllers) {
2576 l = strv_copy(controllers);
2580 strv_free(m->default_controllers);
2581 m->default_controllers = l;
2583 cg_shorten_controllers(m->default_controllers);
2588 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2593 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2594 if (!default_rlimit[i])
2597 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2605 void manager_recheck_journal(Manager *m) {
2610 if (m->running_as != SYSTEMD_SYSTEM)
2613 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2614 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2615 log_close_journal();
2619 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2620 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2621 log_close_journal();
2625 /* Hmm, OK, so the socket is fully up and the service is up
2626 * too, then let's make use of the thing. */
2630 void manager_set_show_status(Manager *m, bool b) {
2633 if (m->running_as != SYSTEMD_SYSTEM)
2639 touch("/run/systemd/show-status");
2641 unlink("/run/systemd/show-status");
2644 static bool manager_get_show_status(Manager *m) {
2647 if (m->running_as != SYSTEMD_SYSTEM)
2653 /* If Plymouth is running make sure we show the status, so
2654 * that there's something nice to see when people press Esc */
2656 return plymouth_running();
2659 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2662 if (!manager_get_show_status(m))
2665 /* XXX We should totally drop the check for ephemeral here
2666 * and thus effectively make 'Type=idle' pointless. */
2667 if (ephemeral && m->n_on_console > 0)
2670 if (!manager_is_booting_or_shutting_down(m))
2673 va_start(ap, format);
2674 status_vprintf(status, true, ephemeral, format, ap);
2678 void watch_init(Watch *w) {
2681 w->type = WATCH_INVALID;