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;
151 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
156 its.it_value.tv_sec = JOBS_IN_PROGRESS_WAIT_SEC;
157 its.it_interval.tv_sec = JOBS_IN_PROGRESS_PERIOD_SEC;
159 if (timerfd_settime(m->jobs_in_progress_watch.fd, 0, &its, NULL) < 0)
165 static int manager_watch_jobs_in_progress(Manager *m) {
166 struct epoll_event ev;
171 if (m->jobs_in_progress_watch.type != WATCH_INVALID)
174 m->jobs_in_progress_watch.type = WATCH_JOBS_IN_PROGRESS;
175 m->jobs_in_progress_watch.fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
176 if (m->jobs_in_progress_watch.fd < 0) {
177 log_error("Failed to create timerfd: %m");
182 r = manager_jobs_in_progress_mod_timer(m);
184 log_error("Failed to set up timer for jobs progress watch: %s", strerror(-r));
190 ev.data.ptr = &m->jobs_in_progress_watch;
192 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->jobs_in_progress_watch.fd, &ev) < 0) {
193 log_error("Failed to add jobs progress timer fd to epoll: %m");
198 log_debug("Set up jobs progress timerfd.");
203 if (m->jobs_in_progress_watch.fd >= 0)
204 close_nointr_nofail(m->jobs_in_progress_watch.fd);
205 watch_init(&m->jobs_in_progress_watch);
209 static void manager_unwatch_jobs_in_progress(Manager *m) {
210 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
213 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->jobs_in_progress_watch.fd, NULL) >= 0);
214 close_nointr_nofail(m->jobs_in_progress_watch.fd);
215 watch_init(&m->jobs_in_progress_watch);
216 m->jobs_in_progress_iteration = 0;
218 log_debug("Closed jobs progress timerfd.");
221 #define CYLON_BUFFER_EXTRA (2*strlen(ANSI_RED_ON) + strlen(ANSI_HIGHLIGHT_RED_ON) + 2*strlen(ANSI_HIGHLIGHT_OFF))
222 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
225 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
226 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
230 p = mempset(p, ' ', pos-2);
231 p = stpcpy(p, ANSI_RED_ON);
235 if (pos > 0 && pos <= width) {
236 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
240 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
243 p = stpcpy(p, ANSI_RED_ON);
246 p = mempset(p, ' ', width-1-pos);
247 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
251 static void manager_print_jobs_in_progress(Manager *m) {
254 char *job_of_n = NULL;
255 unsigned counter = 0, print_nr;
256 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
259 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
261 HASHMAP_FOREACH(j, m->jobs, i)
262 if (j->state == JOB_RUNNING && counter++ == print_nr)
265 /* m->n_running_jobs must be consistent with the contents of m->jobs,
266 * so the above loop must have succeeded in finding j. */
267 assert(counter == print_nr + 1);
269 cylon_pos = m->jobs_in_progress_iteration % 14;
271 cylon_pos = 14 - cylon_pos;
272 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
274 if (m->n_running_jobs > 1)
275 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
278 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
279 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
282 m->jobs_in_progress_iteration++;
285 static int manager_setup_time_change(Manager *m) {
286 struct epoll_event ev;
287 struct itimerspec its;
290 assert(m->time_change_watch.type == WATCH_INVALID);
292 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
293 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
295 m->time_change_watch.type = WATCH_TIME_CHANGE;
296 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
297 if (m->time_change_watch.fd < 0) {
298 log_error("Failed to create timerfd: %m");
304 /* We only care for the cancellation event, hence we set the
305 * timeout to the latest possible value. */
306 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
307 its.it_value.tv_sec = TIME_T_MAX;
309 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
310 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
311 close_nointr_nofail(m->time_change_watch.fd);
312 watch_init(&m->time_change_watch);
318 ev.data.ptr = &m->time_change_watch;
320 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
321 log_error("Failed to add timer change fd to epoll: %m");
325 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
330 static int enable_special_signals(Manager *m) {
335 /* Enable that we get SIGINT on control-alt-del. In containers
336 * this will fail with EPERM (older) or EINVAL (newer), so
338 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
339 log_warning("Failed to enable ctrl-alt-del handling: %m");
341 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
343 /* Support systems without virtual console */
345 log_warning("Failed to open /dev/tty0: %m");
347 /* Enable that we get SIGWINCH on kbrequest */
348 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
349 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
351 close_nointr_nofail(fd);
357 static int manager_setup_signals(Manager *m) {
359 struct epoll_event ev;
364 /* We are not interested in SIGSTOP and friends. */
366 sa.sa_handler = SIG_DFL;
367 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
368 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
370 assert_se(sigemptyset(&mask) == 0);
372 sigset_add_many(&mask,
373 SIGCHLD, /* Child died */
374 SIGTERM, /* Reexecute daemon */
375 SIGHUP, /* Reload configuration */
376 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
377 SIGUSR2, /* systemd: dump status */
378 SIGINT, /* Kernel sends us this on control-alt-del */
379 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
380 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
381 SIGRTMIN+0, /* systemd: start default.target */
382 SIGRTMIN+1, /* systemd: isolate rescue.target */
383 SIGRTMIN+2, /* systemd: isolate emergency.target */
384 SIGRTMIN+3, /* systemd: start halt.target */
385 SIGRTMIN+4, /* systemd: start poweroff.target */
386 SIGRTMIN+5, /* systemd: start reboot.target */
387 SIGRTMIN+6, /* systemd: start kexec.target */
388 SIGRTMIN+13, /* systemd: Immediate halt */
389 SIGRTMIN+14, /* systemd: Immediate poweroff */
390 SIGRTMIN+15, /* systemd: Immediate reboot */
391 SIGRTMIN+16, /* systemd: Immediate kexec */
392 SIGRTMIN+20, /* systemd: enable status messages */
393 SIGRTMIN+21, /* systemd: disable status messages */
394 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
395 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
396 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
397 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
398 SIGRTMIN+27, /* systemd: set log target to console */
399 SIGRTMIN+28, /* systemd: set log target to kmsg */
400 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
402 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
404 m->signal_watch.type = WATCH_SIGNAL;
405 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
406 if (m->signal_watch.fd < 0)
411 ev.data.ptr = &m->signal_watch;
413 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
416 if (m->running_as == SYSTEMD_SYSTEM)
417 return enable_special_signals(m);
422 static void manager_strip_environment(Manager *m) {
425 /* Remove variables from the inherited set that are part of
426 * the container interface:
427 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
428 strv_remove_prefix(m->environment, "container=");
429 strv_remove_prefix(m->environment, "container_");
431 /* Remove variables from the inherited set that are part of
432 * the initrd interface:
433 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
434 strv_remove_prefix(m->environment, "RD_");
436 /* Drop invalid entries */
437 strv_env_clean(m->environment);
440 int manager_new(SystemdRunningAs running_as, Manager **_m) {
445 assert(running_as >= 0);
446 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
448 m = new0(Manager, 1);
452 dual_timestamp_get(&m->userspace_timestamp);
453 dual_timestamp_from_monotonic(&m->kernel_timestamp, 0);
455 efi_get_boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
458 m->running_as = running_as;
459 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
460 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
461 m->pin_cgroupfs_fd = -1;
462 m->idle_pipe[0] = m->idle_pipe[1] = -1;
464 watch_init(&m->signal_watch);
465 watch_init(&m->mount_watch);
466 watch_init(&m->swap_watch);
467 watch_init(&m->udev_watch);
468 watch_init(&m->time_change_watch);
469 watch_init(&m->jobs_in_progress_watch);
471 m->epoll_fd = m->dev_autofs_fd = -1;
472 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
474 m->environment = strv_copy(environ);
478 manager_strip_environment(m);
480 if (running_as == SYSTEMD_SYSTEM) {
481 m->default_controllers = strv_new("cpu", NULL);
482 if (!m->default_controllers)
486 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
489 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
492 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
495 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
498 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
501 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
505 r = manager_setup_signals(m);
509 r = manager_setup_cgroup(m);
513 r = manager_setup_notify(m);
517 r = manager_setup_time_change(m);
521 /* Try to connect to the busses, if possible. */
522 r = bus_init(m, running_as != SYSTEMD_SYSTEM);
526 m->taint_usr = dir_is_empty("/usr") > 0;
536 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
542 while ((u = m->cleanup_queue)) {
543 assert(u->in_cleanup_queue);
553 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
554 GC_OFFSET_UNSURE, /* No clue */
555 GC_OFFSET_GOOD, /* We still need this unit */
556 GC_OFFSET_BAD, /* We don't need this unit anymore */
560 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
567 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
568 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
569 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
572 if (u->in_cleanup_queue)
575 if (unit_check_gc(u))
578 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
582 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
583 unit_gc_sweep(other, gc_marker);
585 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
588 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
595 /* We were unable to find anything out about this entry, so
596 * let's investigate it later */
597 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
598 unit_add_to_gc_queue(u);
602 /* We definitely know that this one is not useful anymore, so
603 * let's mark it for deletion */
604 u->gc_marker = gc_marker + GC_OFFSET_BAD;
605 unit_add_to_cleanup_queue(u);
609 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
612 static unsigned manager_dispatch_gc_queue(Manager *m) {
619 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
620 (m->gc_queue_timestamp <= 0 ||
621 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
624 log_debug("Running GC...");
626 m->gc_marker += _GC_OFFSET_MAX;
627 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
630 gc_marker = m->gc_marker;
632 while ((u = m->gc_queue)) {
633 assert(u->in_gc_queue);
635 unit_gc_sweep(u, gc_marker);
637 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
638 u->in_gc_queue = false;
642 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
643 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
644 log_debug_unit(u->id, "Collecting %s", u->id);
645 u->gc_marker = gc_marker + GC_OFFSET_BAD;
646 unit_add_to_cleanup_queue(u);
650 m->n_in_gc_queue = 0;
651 m->gc_queue_timestamp = 0;
656 static void manager_clear_jobs_and_units(Manager *m) {
661 while ((u = hashmap_first(m->units)))
664 manager_dispatch_cleanup_queue(m);
666 assert(!m->load_queue);
667 assert(!m->run_queue);
668 assert(!m->dbus_unit_queue);
669 assert(!m->dbus_job_queue);
670 assert(!m->cleanup_queue);
671 assert(!m->gc_queue);
673 assert(hashmap_isempty(m->jobs));
674 assert(hashmap_isempty(m->units));
677 m->n_running_jobs = 0;
680 void manager_free(Manager *m) {
686 manager_clear_jobs_and_units(m);
688 for (c = 0; c < _UNIT_TYPE_MAX; c++)
689 if (unit_vtable[c]->shutdown)
690 unit_vtable[c]->shutdown(m);
692 /* If we reexecute ourselves, we keep the root cgroup
694 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
696 manager_undo_generators(m);
700 hashmap_free(m->units);
701 hashmap_free(m->jobs);
702 hashmap_free(m->watch_pids);
703 hashmap_free(m->watch_bus);
705 if (m->epoll_fd >= 0)
706 close_nointr_nofail(m->epoll_fd);
707 if (m->signal_watch.fd >= 0)
708 close_nointr_nofail(m->signal_watch.fd);
709 if (m->notify_watch.fd >= 0)
710 close_nointr_nofail(m->notify_watch.fd);
711 if (m->time_change_watch.fd >= 0)
712 close_nointr_nofail(m->time_change_watch.fd);
713 if (m->jobs_in_progress_watch.fd >= 0)
714 close_nointr_nofail(m->jobs_in_progress_watch.fd);
716 free(m->notify_socket);
718 lookup_paths_free(&m->lookup_paths);
719 strv_free(m->environment);
721 strv_free(m->default_controllers);
723 hashmap_free(m->cgroup_bondings);
724 set_free_free(m->unit_path_cache);
726 close_pipe(m->idle_pipe);
728 free(m->switch_root);
729 free(m->switch_root_init);
731 for (i = 0; i < RLIMIT_NLIMITS; i++)
737 int manager_enumerate(Manager *m) {
743 /* Let's ask every type to load all units from disk/kernel
744 * that it might know */
745 for (c = 0; c < _UNIT_TYPE_MAX; c++)
746 if (unit_vtable[c]->enumerate)
747 if ((q = unit_vtable[c]->enumerate(m)) < 0)
750 manager_dispatch_load_queue(m);
754 int manager_coldplug(Manager *m) {
762 /* Then, let's set up their initial state. */
763 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
769 if ((q = unit_coldplug(u)) < 0)
776 static void manager_build_unit_path_cache(Manager *m) {
778 DIR _cleanup_free_ *d = NULL;
783 set_free_free(m->unit_path_cache);
785 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
786 if (!m->unit_path_cache) {
787 log_error("Failed to allocate unit path cache.");
791 /* This simply builds a list of files we know exist, so that
792 * we don't always have to go to disk */
794 STRV_FOREACH(i, m->lookup_paths.unit_path) {
800 log_error("Failed to open directory %s: %m", *i);
804 while ((de = readdir(d))) {
807 if (ignore_file(de->d_name))
810 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
816 r = set_put(m->unit_path_cache, p);
830 log_error("Failed to build unit path cache: %s", strerror(-r));
832 set_free_free(m->unit_path_cache);
833 m->unit_path_cache = NULL;
836 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
841 manager_run_generators(m);
843 r = lookup_paths_init(
844 &m->lookup_paths, m->running_as, true,
845 m->generator_unit_path,
846 m->generator_unit_path_early,
847 m->generator_unit_path_late);
851 manager_build_unit_path_cache(m);
853 /* If we will deserialize make sure that during enumeration
854 * this is already known, so we increase the counter here
859 /* First, enumerate what we can from all config files */
860 r = manager_enumerate(m);
862 /* Second, deserialize if there is something to deserialize */
864 q = manager_deserialize(m, serialization, fds);
869 /* Any fds left? Find some unit which wants them. This is
870 * useful to allow container managers to pass some file
871 * descriptors to us pre-initialized. This enables
872 * socket-based activation of entire containers. */
873 if (fdset_size(fds) > 0) {
874 q = manager_distribute_fds(m, fds);
879 /* Third, fire things up! */
880 q = manager_coldplug(m);
885 assert(m->n_reloading > 0);
892 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
897 assert(type < _JOB_TYPE_MAX);
899 assert(mode < _JOB_MODE_MAX);
901 if (mode == JOB_ISOLATE && type != JOB_START) {
902 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
906 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
907 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
911 log_debug_unit(unit->id,
912 "Trying to enqueue job %s/%s/%s", unit->id,
913 job_type_to_string(type), job_mode_to_string(mode));
915 job_type_collapse(&type, unit);
917 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
921 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
922 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
923 mode == JOB_IGNORE_DEPENDENCIES, e);
927 if (mode == JOB_ISOLATE) {
928 r = transaction_add_isolate_jobs(tr, m);
933 r = transaction_activate(tr, m, mode, e);
937 log_debug_unit(unit->id,
938 "Enqueued job %s/%s as %u", unit->id,
939 job_type_to_string(type), (unsigned) tr->anchor_job->id);
942 *_ret = tr->anchor_job;
944 transaction_free(tr);
948 transaction_abort(tr);
949 transaction_free(tr);
953 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
958 assert(type < _JOB_TYPE_MAX);
960 assert(mode < _JOB_MODE_MAX);
962 r = manager_load_unit(m, name, NULL, NULL, &unit);
966 return manager_add_job(m, type, unit, mode, override, e, _ret);
969 Job *manager_get_job(Manager *m, uint32_t id) {
972 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
975 Unit *manager_get_unit(Manager *m, const char *name) {
979 return hashmap_get(m->units, name);
982 unsigned manager_dispatch_load_queue(Manager *m) {
988 /* Make sure we are not run recursively */
989 if (m->dispatching_load_queue)
992 m->dispatching_load_queue = true;
994 /* Dispatches the load queue. Takes a unit from the queue and
995 * tries to load its data until the queue is empty */
997 while ((u = m->load_queue)) {
998 assert(u->in_load_queue);
1004 m->dispatching_load_queue = false;
1008 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1014 assert(name || path);
1016 /* This will prepare the unit for loading, but not actually
1017 * load anything from disk. */
1019 if (path && !is_path(path)) {
1020 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1025 name = path_get_file_name(path);
1027 t = unit_name_to_type(name);
1029 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
1030 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1034 ret = manager_get_unit(m, name);
1040 ret = unit_new(m, unit_vtable[t]->object_size);
1045 ret->fragment_path = strdup(path);
1046 if (!ret->fragment_path) {
1052 if ((r = unit_add_name(ret, name)) < 0) {
1057 unit_add_to_load_queue(ret);
1058 unit_add_to_dbus_queue(ret);
1059 unit_add_to_gc_queue(ret);
1067 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1072 /* This will load the service information files, but not actually
1073 * start any services or anything. */
1075 r = manager_load_unit_prepare(m, name, path, e, _ret);
1079 manager_dispatch_load_queue(m);
1082 *_ret = unit_follow_merge(*_ret);
1087 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1094 HASHMAP_FOREACH(j, s->jobs, i)
1095 job_dump(j, f, prefix);
1098 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1106 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1108 unit_dump(u, f, prefix);
1111 void manager_clear_jobs(Manager *m) {
1116 while ((j = hashmap_first(m->jobs)))
1117 /* No need to recurse. We're cancelling all jobs. */
1118 job_finish_and_invalidate(j, JOB_CANCELED, false);
1121 unsigned manager_dispatch_run_queue(Manager *m) {
1125 if (m->dispatching_run_queue)
1128 m->dispatching_run_queue = true;
1130 while ((j = m->run_queue)) {
1131 assert(j->installed);
1132 assert(j->in_run_queue);
1134 job_run_and_invalidate(j);
1138 m->dispatching_run_queue = false;
1140 if (m->n_running_jobs > 0)
1141 manager_watch_jobs_in_progress(m);
1146 unsigned manager_dispatch_dbus_queue(Manager *m) {
1153 if (m->dispatching_dbus_queue)
1156 m->dispatching_dbus_queue = true;
1158 while ((u = m->dbus_unit_queue)) {
1159 assert(u->in_dbus_queue);
1161 bus_unit_send_change_signal(u);
1165 while ((j = m->dbus_job_queue)) {
1166 assert(j->in_dbus_queue);
1168 bus_job_send_change_signal(j);
1172 m->dispatching_dbus_queue = false;
1176 static int manager_process_notify_fd(Manager *m) {
1183 struct msghdr msghdr;
1185 struct ucred *ucred;
1187 struct cmsghdr cmsghdr;
1188 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1194 iovec.iov_base = buf;
1195 iovec.iov_len = sizeof(buf)-1;
1199 msghdr.msg_iov = &iovec;
1200 msghdr.msg_iovlen = 1;
1201 msghdr.msg_control = &control;
1202 msghdr.msg_controllen = sizeof(control);
1204 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1209 if (errno == EAGAIN || errno == EINTR)
1215 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1216 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1217 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1218 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1219 log_warning("Received notify message without credentials. Ignoring.");
1223 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1225 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1227 u = cgroup_unit_by_pid(m, ucred->pid);
1229 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1234 assert((size_t) n < sizeof(buf));
1236 tags = strv_split(buf, "\n\r");
1240 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1242 if (UNIT_VTABLE(u)->notify_message)
1243 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1251 static int manager_dispatch_sigchld(Manager *m) {
1261 /* First we call waitd() for a PID and do not reap the
1262 * zombie. That way we can still access /proc/$PID for
1263 * it while it is a zombie. */
1264 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1266 if (errno == ECHILD)
1278 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1279 char _cleanup_free_ *name = NULL;
1281 get_process_comm(si.si_pid, &name);
1282 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1285 /* Let's flush any message the dying child might still
1286 * have queued for us. This ensures that the process
1287 * still exists in /proc so that we can figure out
1288 * which cgroup and hence unit it belongs to. */
1289 r = manager_process_notify_fd(m);
1293 /* And now figure out the unit this belongs to */
1294 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1296 u = cgroup_unit_by_pid(m, si.si_pid);
1298 /* And now, we actually reap the zombie. */
1299 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1306 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1309 log_debug("Child %lu died (code=%s, status=%i/%s)",
1310 (long unsigned) si.si_pid,
1311 sigchld_code_to_string(si.si_code),
1313 strna(si.si_code == CLD_EXITED
1314 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1315 : signal_to_string(si.si_status)));
1320 log_debug_unit(u->id,
1321 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1323 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1324 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1330 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1334 dbus_error_init(&error);
1336 log_debug_unit(name, "Activating special unit %s", name);
1338 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1340 log_error_unit(name,
1341 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1343 dbus_error_free(&error);
1348 static int manager_process_signal_fd(Manager *m) {
1350 struct signalfd_siginfo sfsi;
1351 bool sigchld = false;
1356 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1357 if (n != sizeof(sfsi)) {
1362 if (errno == EINTR || errno == EAGAIN)
1368 if (sfsi.ssi_pid > 0) {
1371 get_process_comm(sfsi.ssi_pid, &p);
1373 log_debug("Received SIG%s from PID %lu (%s).",
1374 signal_to_string(sfsi.ssi_signo),
1375 (unsigned long) sfsi.ssi_pid, strna(p));
1378 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1380 switch (sfsi.ssi_signo) {
1387 if (m->running_as == SYSTEMD_SYSTEM) {
1388 /* This is for compatibility with the
1389 * original sysvinit */
1390 m->exit_code = MANAGER_REEXECUTE;
1397 if (m->running_as == SYSTEMD_SYSTEM) {
1398 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1402 /* Run the exit target if there is one, if not, just exit. */
1403 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1404 m->exit_code = MANAGER_EXIT;
1411 if (m->running_as == SYSTEMD_SYSTEM)
1412 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1414 /* This is a nop on non-init */
1418 if (m->running_as == SYSTEMD_SYSTEM)
1419 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1421 /* This is a nop on non-init */
1427 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1429 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1430 log_info("Trying to reconnect to bus...");
1434 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1435 log_info("Loading D-Bus service...");
1436 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1447 if (!(f = open_memstream(&dump, &size))) {
1448 log_warning("Failed to allocate memory stream.");
1452 manager_dump_units(m, f, "\t");
1453 manager_dump_jobs(m, f, "\t");
1458 log_warning("Failed to write status stream");
1463 log_dump(LOG_INFO, dump);
1470 m->exit_code = MANAGER_RELOAD;
1475 /* Starting SIGRTMIN+0 */
1476 static const char * const target_table[] = {
1477 [0] = SPECIAL_DEFAULT_TARGET,
1478 [1] = SPECIAL_RESCUE_TARGET,
1479 [2] = SPECIAL_EMERGENCY_TARGET,
1480 [3] = SPECIAL_HALT_TARGET,
1481 [4] = SPECIAL_POWEROFF_TARGET,
1482 [5] = SPECIAL_REBOOT_TARGET,
1483 [6] = SPECIAL_KEXEC_TARGET
1486 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1487 static const ManagerExitCode code_table[] = {
1489 [1] = MANAGER_POWEROFF,
1490 [2] = MANAGER_REBOOT,
1494 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1495 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1496 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1497 manager_start_target(m, target_table[idx],
1498 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1502 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1503 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1504 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1508 switch (sfsi.ssi_signo - SIGRTMIN) {
1511 log_debug("Enabling showing of status.");
1512 manager_set_show_status(m, true);
1516 log_debug("Disabling showing of status.");
1517 manager_set_show_status(m, false);
1521 log_set_max_level(LOG_DEBUG);
1522 log_notice("Setting log level to debug.");
1526 log_set_max_level(LOG_INFO);
1527 log_notice("Setting log level to info.");
1531 if (m->running_as == SYSTEMD_USER) {
1532 m->exit_code = MANAGER_EXIT;
1536 /* This is a nop on init */
1540 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1541 log_notice("Setting log target to journal-or-kmsg.");
1545 log_set_target(LOG_TARGET_CONSOLE);
1546 log_notice("Setting log target to console.");
1550 log_set_target(LOG_TARGET_KMSG);
1551 log_notice("Setting log target to kmsg.");
1555 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1556 log_notice("Setting log target to syslog-or-kmsg.");
1560 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1567 return manager_dispatch_sigchld(m);
1572 static int process_event(Manager *m, struct epoll_event *ev) {
1579 assert_se(w = ev->data.ptr);
1581 if (w->type == WATCH_INVALID)
1588 /* An incoming signal? */
1589 if (ev->events != EPOLLIN)
1592 if ((r = manager_process_signal_fd(m)) < 0)
1599 /* An incoming daemon notification event? */
1600 if (ev->events != EPOLLIN)
1603 if ((r = manager_process_notify_fd(m)) < 0)
1610 /* Some fd event, to be dispatched to the units */
1611 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1614 case WATCH_UNIT_TIMER:
1615 case WATCH_JOB_TIMER: {
1619 /* Some timer event, to be dispatched to the units */
1620 k = read(w->fd, &v, sizeof(v));
1621 if (k != sizeof(v)) {
1623 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1626 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1627 return k < 0 ? -errno : -EIO;
1630 if (w->type == WATCH_UNIT_TIMER)
1631 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1633 job_timer_event(w->data.job, v, w);
1638 /* Some mount table change, intended for the mount subsystem */
1639 mount_fd_event(m, ev->events);
1643 /* Some swap table change, intended for the swap subsystem */
1644 swap_fd_event(m, ev->events);
1648 /* Some notification from udev, intended for the device subsystem */
1649 device_fd_event(m, ev->events);
1652 case WATCH_DBUS_WATCH:
1653 bus_watch_event(m, w, ev->events);
1656 case WATCH_DBUS_TIMEOUT:
1657 bus_timeout_event(m, w, ev->events);
1660 case WATCH_TIME_CHANGE: {
1664 log_struct(LOG_INFO,
1665 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1666 "MESSAGE=Time has been changed",
1669 /* Restart the watch */
1670 epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->time_change_watch.fd,
1672 close_nointr_nofail(m->time_change_watch.fd);
1673 watch_init(&m->time_change_watch);
1674 manager_setup_time_change(m);
1676 HASHMAP_FOREACH(u, m->units, i) {
1677 if (UNIT_VTABLE(u)->time_change)
1678 UNIT_VTABLE(u)->time_change(u);
1684 case WATCH_JOBS_IN_PROGRESS: {
1687 /* not interested in the data */
1688 read(w->fd, &v, sizeof(v));
1690 manager_print_jobs_in_progress(m);
1695 log_error("event type=%i", w->type);
1696 assert_not_reached("Unknown epoll event type.");
1702 int manager_loop(Manager *m) {
1705 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1708 m->exit_code = MANAGER_RUNNING;
1710 /* Release the path cache */
1711 set_free_free(m->unit_path_cache);
1712 m->unit_path_cache = NULL;
1714 manager_check_finished(m);
1716 /* There might still be some zombies hanging around from
1717 * before we were exec()'ed. Leat's reap them */
1718 r = manager_dispatch_sigchld(m);
1722 while (m->exit_code == MANAGER_RUNNING) {
1723 struct epoll_event event;
1727 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1730 if (!ratelimit_test(&rl)) {
1731 /* Yay, something is going seriously wrong, pause a little */
1732 log_warning("Looping too fast. Throttling execution a little.");
1737 if (manager_dispatch_load_queue(m) > 0)
1740 if (manager_dispatch_run_queue(m) > 0)
1743 if (bus_dispatch(m) > 0)
1746 if (manager_dispatch_cleanup_queue(m) > 0)
1749 if (manager_dispatch_gc_queue(m) > 0)
1752 if (manager_dispatch_dbus_queue(m) > 0)
1755 if (swap_dispatch_reload(m) > 0)
1758 /* Sleep for half the watchdog time */
1759 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1760 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1766 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1778 r = process_event(m, &event);
1783 return m->exit_code;
1786 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1795 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1798 n = bus_path_unescape(s+31);
1802 r = manager_load_unit(m, n, NULL, e, &u);
1813 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1822 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1825 r = safe_atou(s + 30, &id);
1829 j = manager_get_job(m, id);
1838 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1844 audit_fd = get_audit_fd();
1848 /* Don't generate audit events if the service was already
1849 * started and we're just deserializing */
1850 if (m->n_reloading > 0)
1853 if (m->running_as != SYSTEMD_SYSTEM)
1856 if (u->type != UNIT_SERVICE)
1859 p = unit_name_to_prefix_and_instance(u->id);
1861 log_error_unit(u->id,
1862 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1866 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1867 if (errno == EPERM) {
1868 /* We aren't allowed to send audit messages?
1869 * Then let's not retry again. */
1872 log_warning("Failed to send audit message: %m");
1880 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1882 union sockaddr_union sa;
1884 char *message = NULL;
1886 /* Don't generate plymouth events if the service was already
1887 * started and we're just deserializing */
1888 if (m->n_reloading > 0)
1891 if (m->running_as != SYSTEMD_SYSTEM)
1894 if (u->type != UNIT_SERVICE &&
1895 u->type != UNIT_MOUNT &&
1896 u->type != UNIT_SWAP)
1899 /* We set SOCK_NONBLOCK here so that we rather drop the
1900 * message then wait for plymouth */
1901 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1902 log_error("socket() failed: %m");
1907 sa.sa.sa_family = AF_UNIX;
1908 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1909 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1911 if (errno != EPIPE &&
1914 errno != ECONNREFUSED &&
1915 errno != ECONNRESET &&
1916 errno != ECONNABORTED)
1917 log_error("connect() failed: %m");
1922 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1928 if (write(fd, message, n + 1) != n + 1) {
1930 if (errno != EPIPE &&
1933 errno != ECONNREFUSED &&
1934 errno != ECONNRESET &&
1935 errno != ECONNABORTED)
1936 log_error("Failed to write Plymouth message: %m");
1943 close_nointr_nofail(fd);
1948 void manager_dispatch_bus_name_owner_changed(
1951 const char* old_owner,
1952 const char *new_owner) {
1959 if (!(u = hashmap_get(m->watch_bus, name)))
1962 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1965 void manager_dispatch_bus_query_pid_done(
1976 if (!(u = hashmap_get(m->watch_bus, name)))
1979 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1982 int manager_open_serialization(Manager *m, FILE **_f) {
1990 if (m->running_as == SYSTEMD_SYSTEM)
1991 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1993 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1998 saved_umask = umask(0077);
1999 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2009 log_debug("Serializing state to %s", path);
2012 f = fdopen(fd, "w+");
2021 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
2034 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2035 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2036 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2037 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2039 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2040 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2041 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2042 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2045 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2046 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2049 STRV_FOREACH(e, m->environment) {
2050 _cleanup_free_ char *ce;
2054 fprintf(f, "env=%s\n", *e);
2059 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2063 if (!unit_can_serialize(u))
2070 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
2076 assert(m->n_reloading > 0);
2082 r = bus_fdset_add_all(m, fds);
2089 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2095 log_debug("Deserializing state...");
2100 char line[LINE_MAX], *l;
2102 if (!fgets(line, sizeof(line), f)) {
2117 if (startswith(l, "current-job-id=")) {
2120 if (safe_atou32(l+15, &id) < 0)
2121 log_debug("Failed to parse current job id value %s", l+15);
2123 m->current_job_id = MAX(m->current_job_id, id);
2124 } else if (startswith(l, "n-installed-jobs=")) {
2127 if (safe_atou32(l+17, &n) < 0)
2128 log_debug("Failed to parse installed jobs counter %s", l+17);
2130 m->n_installed_jobs += n;
2131 } else if (startswith(l, "n-failed-jobs=")) {
2134 if (safe_atou32(l+14, &n) < 0)
2135 log_debug("Failed to parse failed jobs counter %s", l+14);
2137 m->n_failed_jobs += n;
2138 } else if (startswith(l, "taint-usr=")) {
2141 if ((b = parse_boolean(l+10)) < 0)
2142 log_debug("Failed to parse taint /usr flag %s", l+10);
2144 m->taint_usr = m->taint_usr || b;
2145 } else if (startswith(l, "firmware-timestamp="))
2146 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2147 else if (startswith(l, "loader-timestamp="))
2148 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2149 else if (startswith(l, "kernel-timestamp="))
2150 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2151 else if (startswith(l, "initrd-timestamp="))
2152 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2153 else if (startswith(l, "userspace-timestamp="))
2154 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2155 else if (startswith(l, "finish-timestamp="))
2156 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2157 else if (startswith(l, "env=")) {
2158 _cleanup_free_ char *uce = NULL;
2161 uce = cunescape(l+4);
2167 e = strv_env_set(m->environment, uce);
2173 strv_free(m->environment);
2176 log_debug("Unknown serialization item '%s'", l);
2181 char name[UNIT_NAME_MAX+2];
2184 if (!fgets(name, sizeof(name), f)) {
2195 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2199 r = unit_deserialize(u, f, fds);
2210 assert(m->n_reloading > 0);
2216 int manager_distribute_fds(Manager *m, FDSet *fds) {
2223 HASHMAP_FOREACH(u, m->units, i) {
2225 if (fdset_size(fds) <= 0)
2228 if (UNIT_VTABLE(u)->distribute_fds) {
2229 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2238 int manager_reload(Manager *m) {
2245 r = manager_open_serialization(m, &f);
2258 r = manager_serialize(m, f, fds, true);
2264 if (fseeko(f, 0, SEEK_SET) < 0) {
2270 /* From here on there is no way back. */
2271 manager_clear_jobs_and_units(m);
2272 manager_undo_generators(m);
2273 lookup_paths_free(&m->lookup_paths);
2275 /* Find new unit paths */
2276 manager_run_generators(m);
2278 q = lookup_paths_init(
2279 &m->lookup_paths, m->running_as, true,
2280 m->generator_unit_path,
2281 m->generator_unit_path_early,
2282 m->generator_unit_path_late);
2286 manager_build_unit_path_cache(m);
2288 /* First, enumerate what we can from all config files */
2289 q = manager_enumerate(m);
2293 /* Second, deserialize our stored data */
2294 q = manager_deserialize(m, f, fds);
2301 /* Third, fire things up! */
2302 q = manager_coldplug(m);
2306 assert(m->n_reloading > 0);
2319 static bool manager_is_booting_or_shutting_down(Manager *m) {
2324 /* Is the initial job still around? */
2325 if (manager_get_job(m, m->default_unit_job_id))
2328 /* Is there a job for the shutdown target? */
2329 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2336 bool manager_is_reloading_or_reexecuting(Manager *m) {
2339 return m->n_reloading != 0;
2342 void manager_reset_failed(Manager *m) {
2348 HASHMAP_FOREACH(u, m->units, i)
2349 unit_reset_failed(u);
2352 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2358 /* Returns true if the unit is inactive or going down */
2359 u = manager_get_unit(m, name);
2363 return unit_pending_inactive(u);
2366 void manager_check_finished(Manager *m) {
2367 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2368 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2372 if (m->n_running_jobs == 0)
2373 manager_unwatch_jobs_in_progress(m);
2375 if (hashmap_size(m->jobs) > 0) {
2376 manager_jobs_in_progress_mod_timer(m);
2380 /* Notify Type=idle units that we are done now */
2381 close_pipe(m->idle_pipe);
2383 /* Turn off confirm spawn now */
2384 m->confirm_spawn = false;
2386 if (dual_timestamp_is_set(&m->finish_timestamp))
2389 dual_timestamp_get(&m->finish_timestamp);
2391 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2393 /* Note that m->kernel_usec.monotonic is always at 0,
2394 * and m->firmware_usec.monotonic and
2395 * m->loader_usec.monotonic should be considered
2396 * negative values. */
2398 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2399 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2400 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2401 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2403 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2405 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2406 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2408 if (!log_on_console())
2409 log_struct(LOG_INFO,
2410 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2411 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2412 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2413 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2414 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2415 format_timespan(kernel, sizeof(kernel), kernel_usec),
2416 format_timespan(initrd, sizeof(initrd), initrd_usec),
2417 format_timespan(userspace, sizeof(userspace), userspace_usec),
2418 format_timespan(sum, sizeof(sum), total_usec),
2421 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2424 if (!log_on_console())
2425 log_struct(LOG_INFO,
2426 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2427 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2428 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2429 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2430 format_timespan(kernel, sizeof(kernel), kernel_usec),
2431 format_timespan(userspace, sizeof(userspace), userspace_usec),
2432 format_timespan(sum, sizeof(sum), total_usec),
2436 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2437 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2439 if (!log_on_console())
2440 log_struct(LOG_INFO,
2441 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2442 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2443 "MESSAGE=Startup finished in %s.",
2444 format_timespan(sum, sizeof(sum), total_usec),
2448 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2451 "READY=1\nSTATUS=Startup finished in %s.",
2452 format_timespan(sum, sizeof(sum), total_usec));
2455 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2466 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2468 p = strappend("/run/systemd/", name);
2472 r = mkdir_p_label(p, 0755);
2474 log_error("Failed to create generator directory %s: %s",
2480 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2485 log_error("Failed to create generator directory %s: %m",
2496 static void trim_generator_dir(Manager *m, char **generator) {
2503 if (rmdir(*generator) >= 0) {
2511 void manager_run_generators(Manager *m) {
2513 const char *generator_path;
2514 const char *argv[5];
2520 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2521 d = opendir(generator_path);
2523 if (errno == ENOENT)
2526 log_error("Failed to enumerate generator directory %s: %m",
2531 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2535 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2539 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2543 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2544 argv[1] = m->generator_unit_path;
2545 argv[2] = m->generator_unit_path_early;
2546 argv[3] = m->generator_unit_path_late;
2550 execute_directory(generator_path, d, (char**) argv);
2553 trim_generator_dir(m, &m->generator_unit_path);
2554 trim_generator_dir(m, &m->generator_unit_path_early);
2555 trim_generator_dir(m, &m->generator_unit_path_late);
2562 static void remove_generator_dir(Manager *m, char **generator) {
2569 strv_remove(m->lookup_paths.unit_path, *generator);
2570 rm_rf(*generator, false, true, false);
2576 void manager_undo_generators(Manager *m) {
2579 remove_generator_dir(m, &m->generator_unit_path);
2580 remove_generator_dir(m, &m->generator_unit_path_early);
2581 remove_generator_dir(m, &m->generator_unit_path_late);
2584 int manager_set_default_controllers(Manager *m, char **controllers) {
2589 l = strv_copy(controllers);
2593 strv_free(m->default_controllers);
2594 m->default_controllers = l;
2596 cg_shorten_controllers(m->default_controllers);
2601 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2606 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2607 if (!default_rlimit[i])
2610 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2618 void manager_recheck_journal(Manager *m) {
2623 if (m->running_as != SYSTEMD_SYSTEM)
2626 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2627 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2628 log_close_journal();
2632 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2633 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2634 log_close_journal();
2638 /* Hmm, OK, so the socket is fully up and the service is up
2639 * too, then let's make use of the thing. */
2643 void manager_set_show_status(Manager *m, bool b) {
2646 if (m->running_as != SYSTEMD_SYSTEM)
2652 touch("/run/systemd/show-status");
2654 unlink("/run/systemd/show-status");
2657 static bool manager_get_show_status(Manager *m) {
2660 if (m->running_as != SYSTEMD_SYSTEM)
2666 /* If Plymouth is running make sure we show the status, so
2667 * that there's something nice to see when people press Esc */
2669 return plymouth_running();
2672 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2675 if (!manager_get_show_status(m))
2678 /* XXX We should totally drop the check for ephemeral here
2679 * and thus effectively make 'Type=idle' pointless. */
2680 if (ephemeral && m->n_on_console > 0)
2683 if (!manager_is_booting_or_shutting_down(m))
2686 va_start(ap, format);
2687 status_vprintf(status, true, ephemeral, format, ap);
2691 void watch_init(Watch *w) {
2694 w->type = WATCH_INVALID;