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 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");
134 ev.data.ptr = &m->notify_watch;
136 r = epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev);
138 log_error("Failed to add notification socket fd to epoll: %m");
142 sa.un.sun_path[0] = '@';
143 m->notify_socket = strdup(sa.un.sun_path);
144 if (!m->notify_socket)
147 log_debug("Using notification socket %s", m->notify_socket);
152 static int manager_jobs_in_progress_mod_timer(Manager *m) {
153 struct itimerspec its;
155 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
160 its.it_value.tv_sec = JOBS_IN_PROGRESS_WAIT_SEC;
161 its.it_interval.tv_sec = JOBS_IN_PROGRESS_PERIOD_SEC;
163 if (timerfd_settime(m->jobs_in_progress_watch.fd, 0, &its, NULL) < 0)
169 static int manager_watch_jobs_in_progress(Manager *m) {
170 struct epoll_event ev;
175 if (m->jobs_in_progress_watch.type != WATCH_INVALID)
178 m->jobs_in_progress_watch.type = WATCH_JOBS_IN_PROGRESS;
179 m->jobs_in_progress_watch.fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
180 if (m->jobs_in_progress_watch.fd < 0) {
181 log_error("Failed to create timerfd: %m");
186 r = manager_jobs_in_progress_mod_timer(m);
188 log_error("Failed to set up timer for jobs progress watch: %s", strerror(-r));
194 ev.data.ptr = &m->jobs_in_progress_watch;
196 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->jobs_in_progress_watch.fd, &ev) < 0) {
197 log_error("Failed to add jobs progress timer fd to epoll: %m");
202 log_debug("Set up jobs progress timerfd.");
207 if (m->jobs_in_progress_watch.fd >= 0)
208 close_nointr_nofail(m->jobs_in_progress_watch.fd);
209 watch_init(&m->jobs_in_progress_watch);
213 static void manager_unwatch_jobs_in_progress(Manager *m) {
214 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
217 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->jobs_in_progress_watch.fd, NULL) >= 0);
218 close_nointr_nofail(m->jobs_in_progress_watch.fd);
219 watch_init(&m->jobs_in_progress_watch);
220 m->jobs_in_progress_iteration = 0;
222 log_debug("Closed jobs progress timerfd.");
225 #define CYLON_BUFFER_EXTRA (2*strlen(ANSI_RED_ON) + strlen(ANSI_HIGHLIGHT_RED_ON) + 2*strlen(ANSI_HIGHLIGHT_OFF))
226 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
229 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
230 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
234 p = mempset(p, ' ', pos-2);
235 p = stpcpy(p, ANSI_RED_ON);
239 if (pos > 0 && pos <= width) {
240 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
244 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
247 p = stpcpy(p, ANSI_RED_ON);
250 p = mempset(p, ' ', width-1-pos);
251 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
255 static void manager_print_jobs_in_progress(Manager *m) {
258 char *job_of_n = NULL;
259 unsigned counter = 0, print_nr;
260 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
263 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
265 HASHMAP_FOREACH(j, m->jobs, i)
266 if (j->state == JOB_RUNNING && counter++ == print_nr)
269 /* m->n_running_jobs must be consistent with the contents of m->jobs,
270 * so the above loop must have succeeded in finding j. */
271 assert(counter == print_nr + 1);
273 cylon_pos = m->jobs_in_progress_iteration % 14;
275 cylon_pos = 14 - cylon_pos;
276 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
278 if (m->n_running_jobs > 1)
279 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
282 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
283 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
286 m->jobs_in_progress_iteration++;
289 static int manager_setup_time_change(Manager *m) {
290 struct epoll_event ev;
291 struct itimerspec its;
294 assert(m->time_change_watch.type == WATCH_INVALID);
296 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
297 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
299 m->time_change_watch.type = WATCH_TIME_CHANGE;
300 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
301 if (m->time_change_watch.fd < 0) {
302 log_error("Failed to create timerfd: %m");
308 /* We only care for the cancellation event, hence we set the
309 * timeout to the latest possible value. */
310 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
311 its.it_value.tv_sec = TIME_T_MAX;
313 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
314 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
315 close_nointr_nofail(m->time_change_watch.fd);
316 watch_init(&m->time_change_watch);
322 ev.data.ptr = &m->time_change_watch;
324 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
325 log_error("Failed to add timer change fd to epoll: %m");
329 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
334 static int enable_special_signals(Manager *m) {
339 /* Enable that we get SIGINT on control-alt-del. In containers
340 * this will fail with EPERM (older) or EINVAL (newer), so
342 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
343 log_warning("Failed to enable ctrl-alt-del handling: %m");
345 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
347 /* Support systems without virtual console */
349 log_warning("Failed to open /dev/tty0: %m");
351 /* Enable that we get SIGWINCH on kbrequest */
352 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
353 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
355 close_nointr_nofail(fd);
361 static int manager_setup_signals(Manager *m) {
363 struct epoll_event ev;
368 /* We are not interested in SIGSTOP and friends. */
370 sa.sa_handler = SIG_DFL;
371 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
372 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
374 assert_se(sigemptyset(&mask) == 0);
376 sigset_add_many(&mask,
377 SIGCHLD, /* Child died */
378 SIGTERM, /* Reexecute daemon */
379 SIGHUP, /* Reload configuration */
380 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
381 SIGUSR2, /* systemd: dump status */
382 SIGINT, /* Kernel sends us this on control-alt-del */
383 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
384 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
385 SIGRTMIN+0, /* systemd: start default.target */
386 SIGRTMIN+1, /* systemd: isolate rescue.target */
387 SIGRTMIN+2, /* systemd: isolate emergency.target */
388 SIGRTMIN+3, /* systemd: start halt.target */
389 SIGRTMIN+4, /* systemd: start poweroff.target */
390 SIGRTMIN+5, /* systemd: start reboot.target */
391 SIGRTMIN+6, /* systemd: start kexec.target */
392 SIGRTMIN+13, /* systemd: Immediate halt */
393 SIGRTMIN+14, /* systemd: Immediate poweroff */
394 SIGRTMIN+15, /* systemd: Immediate reboot */
395 SIGRTMIN+16, /* systemd: Immediate kexec */
396 SIGRTMIN+20, /* systemd: enable status messages */
397 SIGRTMIN+21, /* systemd: disable status messages */
398 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
399 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
400 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
401 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
402 SIGRTMIN+27, /* systemd: set log target to console */
403 SIGRTMIN+28, /* systemd: set log target to kmsg */
404 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
406 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
408 m->signal_watch.type = WATCH_SIGNAL;
409 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
410 if (m->signal_watch.fd < 0)
415 ev.data.ptr = &m->signal_watch;
417 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
420 if (m->running_as == SYSTEMD_SYSTEM)
421 return enable_special_signals(m);
426 static void manager_strip_environment(Manager *m) {
429 /* Remove variables from the inherited set that are part of
430 * the container interface:
431 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
432 strv_remove_prefix(m->environment, "container=");
433 strv_remove_prefix(m->environment, "container_");
435 /* Remove variables from the inherited set that are part of
436 * the initrd interface:
437 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
438 strv_remove_prefix(m->environment, "RD_");
440 /* Drop invalid entries */
441 strv_env_clean(m->environment);
444 int manager_new(SystemdRunningAs running_as, Manager **_m) {
449 assert(running_as >= 0);
450 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
452 m = new0(Manager, 1);
456 dual_timestamp_get(&m->userspace_timestamp);
457 dual_timestamp_from_monotonic(&m->kernel_timestamp, 0);
459 efi_get_boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
462 m->running_as = running_as;
463 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
464 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
465 m->pin_cgroupfs_fd = -1;
466 m->idle_pipe[0] = m->idle_pipe[1] = -1;
468 watch_init(&m->signal_watch);
469 watch_init(&m->mount_watch);
470 watch_init(&m->swap_watch);
471 watch_init(&m->udev_watch);
472 watch_init(&m->time_change_watch);
473 watch_init(&m->jobs_in_progress_watch);
475 m->epoll_fd = m->dev_autofs_fd = -1;
476 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
478 m->environment = strv_copy(environ);
482 manager_strip_environment(m);
484 if (running_as == SYSTEMD_SYSTEM) {
485 m->default_controllers = strv_new("cpu", NULL);
486 if (!m->default_controllers)
490 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
493 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
496 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
499 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
502 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
505 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
509 r = manager_setup_signals(m);
513 r = manager_setup_cgroup(m);
517 r = manager_setup_notify(m);
521 r = manager_setup_time_change(m);
525 /* Try to connect to the busses, if possible. */
526 r = bus_init(m, running_as != SYSTEMD_SYSTEM);
530 m->taint_usr = dir_is_empty("/usr") > 0;
540 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
546 while ((u = m->cleanup_queue)) {
547 assert(u->in_cleanup_queue);
557 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
558 GC_OFFSET_UNSURE, /* No clue */
559 GC_OFFSET_GOOD, /* We still need this unit */
560 GC_OFFSET_BAD, /* We don't need this unit anymore */
564 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
571 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
572 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
573 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
576 if (u->in_cleanup_queue)
579 if (unit_check_gc(u))
582 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
586 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
587 unit_gc_sweep(other, gc_marker);
589 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
592 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
599 /* We were unable to find anything out about this entry, so
600 * let's investigate it later */
601 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
602 unit_add_to_gc_queue(u);
606 /* We definitely know that this one is not useful anymore, so
607 * let's mark it for deletion */
608 u->gc_marker = gc_marker + GC_OFFSET_BAD;
609 unit_add_to_cleanup_queue(u);
613 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
616 static unsigned manager_dispatch_gc_queue(Manager *m) {
623 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
624 (m->gc_queue_timestamp <= 0 ||
625 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
628 log_debug("Running GC...");
630 m->gc_marker += _GC_OFFSET_MAX;
631 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
634 gc_marker = m->gc_marker;
636 while ((u = m->gc_queue)) {
637 assert(u->in_gc_queue);
639 unit_gc_sweep(u, gc_marker);
641 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
642 u->in_gc_queue = false;
646 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
647 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
648 log_debug_unit(u->id, "Collecting %s", u->id);
649 u->gc_marker = gc_marker + GC_OFFSET_BAD;
650 unit_add_to_cleanup_queue(u);
654 m->n_in_gc_queue = 0;
655 m->gc_queue_timestamp = 0;
660 static void manager_clear_jobs_and_units(Manager *m) {
665 while ((u = hashmap_first(m->units)))
668 manager_dispatch_cleanup_queue(m);
670 assert(!m->load_queue);
671 assert(!m->run_queue);
672 assert(!m->dbus_unit_queue);
673 assert(!m->dbus_job_queue);
674 assert(!m->cleanup_queue);
675 assert(!m->gc_queue);
677 assert(hashmap_isempty(m->jobs));
678 assert(hashmap_isempty(m->units));
681 m->n_running_jobs = 0;
684 void manager_free(Manager *m) {
690 manager_clear_jobs_and_units(m);
692 for (c = 0; c < _UNIT_TYPE_MAX; c++)
693 if (unit_vtable[c]->shutdown)
694 unit_vtable[c]->shutdown(m);
696 /* If we reexecute ourselves, we keep the root cgroup
698 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
700 manager_undo_generators(m);
704 hashmap_free(m->units);
705 hashmap_free(m->jobs);
706 hashmap_free(m->watch_pids);
707 hashmap_free(m->watch_bus);
709 if (m->epoll_fd >= 0)
710 close_nointr_nofail(m->epoll_fd);
711 if (m->signal_watch.fd >= 0)
712 close_nointr_nofail(m->signal_watch.fd);
713 if (m->notify_watch.fd >= 0)
714 close_nointr_nofail(m->notify_watch.fd);
715 if (m->time_change_watch.fd >= 0)
716 close_nointr_nofail(m->time_change_watch.fd);
717 if (m->jobs_in_progress_watch.fd >= 0)
718 close_nointr_nofail(m->jobs_in_progress_watch.fd);
720 free(m->notify_socket);
722 lookup_paths_free(&m->lookup_paths);
723 strv_free(m->environment);
725 strv_free(m->default_controllers);
727 hashmap_free(m->cgroup_bondings);
728 set_free_free(m->unit_path_cache);
730 close_pipe(m->idle_pipe);
732 free(m->switch_root);
733 free(m->switch_root_init);
735 for (i = 0; i < RLIMIT_NLIMITS; i++)
741 int manager_enumerate(Manager *m) {
747 /* Let's ask every type to load all units from disk/kernel
748 * that it might know */
749 for (c = 0; c < _UNIT_TYPE_MAX; c++)
750 if (unit_vtable[c]->enumerate)
751 if ((q = unit_vtable[c]->enumerate(m)) < 0)
754 manager_dispatch_load_queue(m);
758 int manager_coldplug(Manager *m) {
766 /* Then, let's set up their initial state. */
767 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
773 if ((q = unit_coldplug(u)) < 0)
780 static void manager_build_unit_path_cache(Manager *m) {
782 DIR _cleanup_free_ *d = NULL;
787 set_free_free(m->unit_path_cache);
789 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
790 if (!m->unit_path_cache) {
791 log_error("Failed to allocate unit path cache.");
795 /* This simply builds a list of files we know exist, so that
796 * we don't always have to go to disk */
798 STRV_FOREACH(i, m->lookup_paths.unit_path) {
804 log_error("Failed to open directory %s: %m", *i);
808 while ((de = readdir(d))) {
811 if (ignore_file(de->d_name))
814 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
820 r = set_put(m->unit_path_cache, p);
834 log_error("Failed to build unit path cache: %s", strerror(-r));
836 set_free_free(m->unit_path_cache);
837 m->unit_path_cache = NULL;
840 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
845 manager_run_generators(m);
847 r = lookup_paths_init(
848 &m->lookup_paths, m->running_as, true,
849 m->generator_unit_path,
850 m->generator_unit_path_early,
851 m->generator_unit_path_late);
855 manager_build_unit_path_cache(m);
857 /* If we will deserialize make sure that during enumeration
858 * this is already known, so we increase the counter here
863 /* First, enumerate what we can from all config files */
864 r = manager_enumerate(m);
866 /* Second, deserialize if there is something to deserialize */
868 q = manager_deserialize(m, serialization, fds);
873 /* Any fds left? Find some unit which wants them. This is
874 * useful to allow container managers to pass some file
875 * descriptors to us pre-initialized. This enables
876 * socket-based activation of entire containers. */
877 if (fdset_size(fds) > 0) {
878 q = manager_distribute_fds(m, fds);
883 /* Third, fire things up! */
884 q = manager_coldplug(m);
889 assert(m->n_reloading > 0);
896 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
901 assert(type < _JOB_TYPE_MAX);
903 assert(mode < _JOB_MODE_MAX);
905 if (mode == JOB_ISOLATE && type != JOB_START) {
906 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
910 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
911 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
915 log_debug_unit(unit->id,
916 "Trying to enqueue job %s/%s/%s", unit->id,
917 job_type_to_string(type), job_mode_to_string(mode));
919 job_type_collapse(&type, unit);
921 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
925 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
926 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
927 mode == JOB_IGNORE_DEPENDENCIES, e);
931 if (mode == JOB_ISOLATE) {
932 r = transaction_add_isolate_jobs(tr, m);
937 r = transaction_activate(tr, m, mode, e);
941 log_debug_unit(unit->id,
942 "Enqueued job %s/%s as %u", unit->id,
943 job_type_to_string(type), (unsigned) tr->anchor_job->id);
946 *_ret = tr->anchor_job;
948 transaction_free(tr);
952 transaction_abort(tr);
953 transaction_free(tr);
957 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
962 assert(type < _JOB_TYPE_MAX);
964 assert(mode < _JOB_MODE_MAX);
966 r = manager_load_unit(m, name, NULL, NULL, &unit);
970 return manager_add_job(m, type, unit, mode, override, e, _ret);
973 Job *manager_get_job(Manager *m, uint32_t id) {
976 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
979 Unit *manager_get_unit(Manager *m, const char *name) {
983 return hashmap_get(m->units, name);
986 unsigned manager_dispatch_load_queue(Manager *m) {
992 /* Make sure we are not run recursively */
993 if (m->dispatching_load_queue)
996 m->dispatching_load_queue = true;
998 /* Dispatches the load queue. Takes a unit from the queue and
999 * tries to load its data until the queue is empty */
1001 while ((u = m->load_queue)) {
1002 assert(u->in_load_queue);
1008 m->dispatching_load_queue = false;
1012 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1018 assert(name || path);
1020 /* This will prepare the unit for loading, but not actually
1021 * load anything from disk. */
1023 if (path && !is_path(path)) {
1024 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1029 name = path_get_file_name(path);
1031 t = unit_name_to_type(name);
1033 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
1034 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1038 ret = manager_get_unit(m, name);
1044 ret = unit_new(m, unit_vtable[t]->object_size);
1049 ret->fragment_path = strdup(path);
1050 if (!ret->fragment_path) {
1056 if ((r = unit_add_name(ret, name)) < 0) {
1061 unit_add_to_load_queue(ret);
1062 unit_add_to_dbus_queue(ret);
1063 unit_add_to_gc_queue(ret);
1071 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1076 /* This will load the service information files, but not actually
1077 * start any services or anything. */
1079 r = manager_load_unit_prepare(m, name, path, e, _ret);
1083 manager_dispatch_load_queue(m);
1086 *_ret = unit_follow_merge(*_ret);
1091 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1098 HASHMAP_FOREACH(j, s->jobs, i)
1099 job_dump(j, f, prefix);
1102 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1110 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1112 unit_dump(u, f, prefix);
1115 void manager_clear_jobs(Manager *m) {
1120 while ((j = hashmap_first(m->jobs)))
1121 /* No need to recurse. We're cancelling all jobs. */
1122 job_finish_and_invalidate(j, JOB_CANCELED, false);
1125 unsigned manager_dispatch_run_queue(Manager *m) {
1129 if (m->dispatching_run_queue)
1132 m->dispatching_run_queue = true;
1134 while ((j = m->run_queue)) {
1135 assert(j->installed);
1136 assert(j->in_run_queue);
1138 job_run_and_invalidate(j);
1142 m->dispatching_run_queue = false;
1144 if (m->n_running_jobs > 0)
1145 manager_watch_jobs_in_progress(m);
1150 unsigned manager_dispatch_dbus_queue(Manager *m) {
1157 if (m->dispatching_dbus_queue)
1160 m->dispatching_dbus_queue = true;
1162 while ((u = m->dbus_unit_queue)) {
1163 assert(u->in_dbus_queue);
1165 bus_unit_send_change_signal(u);
1169 while ((j = m->dbus_job_queue)) {
1170 assert(j->in_dbus_queue);
1172 bus_job_send_change_signal(j);
1176 m->dispatching_dbus_queue = false;
1180 static int manager_process_notify_fd(Manager *m) {
1187 struct msghdr msghdr;
1189 struct ucred *ucred;
1191 struct cmsghdr cmsghdr;
1192 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1195 char _cleanup_strv_free_ **tags = NULL;
1198 iovec.iov_base = buf;
1199 iovec.iov_len = sizeof(buf)-1;
1203 msghdr.msg_iov = &iovec;
1204 msghdr.msg_iovlen = 1;
1205 msghdr.msg_control = &control;
1206 msghdr.msg_controllen = sizeof(control);
1208 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1213 if (errno == EAGAIN || errno == EINTR)
1219 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1220 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1221 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1222 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1223 log_warning("Received notify message without credentials. Ignoring.");
1227 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1229 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1231 u = cgroup_unit_by_pid(m, ucred->pid);
1233 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1238 assert((size_t) n < sizeof(buf));
1240 tags = strv_split(buf, "\n\r");
1244 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1246 if (UNIT_VTABLE(u)->notify_message)
1247 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1253 static int manager_dispatch_sigchld(Manager *m) {
1263 /* First we call waitd() for a PID and do not reap the
1264 * zombie. That way we can still access /proc/$PID for
1265 * it while it is a zombie. */
1266 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1268 if (errno == ECHILD)
1280 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1281 char _cleanup_free_ *name = NULL;
1283 get_process_comm(si.si_pid, &name);
1284 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1287 /* Let's flush any message the dying child might still
1288 * have queued for us. This ensures that the process
1289 * still exists in /proc so that we can figure out
1290 * which cgroup and hence unit it belongs to. */
1291 r = manager_process_notify_fd(m);
1295 /* And now figure out the unit this belongs to */
1296 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1298 u = cgroup_unit_by_pid(m, si.si_pid);
1300 /* And now, we actually reap the zombie. */
1301 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1308 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1311 log_debug("Child %lu died (code=%s, status=%i/%s)",
1312 (long unsigned) si.si_pid,
1313 sigchld_code_to_string(si.si_code),
1315 strna(si.si_code == CLD_EXITED
1316 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1317 : signal_to_string(si.si_status)));
1322 log_debug_unit(u->id,
1323 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1325 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1326 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1332 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1336 dbus_error_init(&error);
1338 log_debug_unit(name, "Activating special unit %s", name);
1340 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1342 log_error_unit(name,
1343 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1345 dbus_error_free(&error);
1350 static int manager_process_signal_fd(Manager *m) {
1352 struct signalfd_siginfo sfsi;
1353 bool sigchld = false;
1358 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1359 if (n != sizeof(sfsi)) {
1364 if (errno == EINTR || errno == EAGAIN)
1370 if (sfsi.ssi_pid > 0) {
1373 get_process_comm(sfsi.ssi_pid, &p);
1375 log_debug("Received SIG%s from PID %lu (%s).",
1376 signal_to_string(sfsi.ssi_signo),
1377 (unsigned long) sfsi.ssi_pid, strna(p));
1380 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1382 switch (sfsi.ssi_signo) {
1389 if (m->running_as == SYSTEMD_SYSTEM) {
1390 /* This is for compatibility with the
1391 * original sysvinit */
1392 m->exit_code = MANAGER_REEXECUTE;
1399 if (m->running_as == SYSTEMD_SYSTEM) {
1400 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1404 /* Run the exit target if there is one, if not, just exit. */
1405 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1406 m->exit_code = MANAGER_EXIT;
1413 if (m->running_as == SYSTEMD_SYSTEM)
1414 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1416 /* This is a nop on non-init */
1420 if (m->running_as == SYSTEMD_SYSTEM)
1421 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1423 /* This is a nop on non-init */
1429 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1431 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1432 log_info("Trying to reconnect to bus...");
1436 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1437 log_info("Loading D-Bus service...");
1438 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1449 if (!(f = open_memstream(&dump, &size))) {
1450 log_warning("Failed to allocate memory stream.");
1454 manager_dump_units(m, f, "\t");
1455 manager_dump_jobs(m, f, "\t");
1460 log_warning("Failed to write status stream");
1465 log_dump(LOG_INFO, dump);
1472 m->exit_code = MANAGER_RELOAD;
1477 /* Starting SIGRTMIN+0 */
1478 static const char * const target_table[] = {
1479 [0] = SPECIAL_DEFAULT_TARGET,
1480 [1] = SPECIAL_RESCUE_TARGET,
1481 [2] = SPECIAL_EMERGENCY_TARGET,
1482 [3] = SPECIAL_HALT_TARGET,
1483 [4] = SPECIAL_POWEROFF_TARGET,
1484 [5] = SPECIAL_REBOOT_TARGET,
1485 [6] = SPECIAL_KEXEC_TARGET
1488 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1489 static const ManagerExitCode code_table[] = {
1491 [1] = MANAGER_POWEROFF,
1492 [2] = MANAGER_REBOOT,
1496 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1497 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1498 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1499 manager_start_target(m, target_table[idx],
1500 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1504 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1505 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1506 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1510 switch (sfsi.ssi_signo - SIGRTMIN) {
1513 log_debug("Enabling showing of status.");
1514 manager_set_show_status(m, true);
1518 log_debug("Disabling showing of status.");
1519 manager_set_show_status(m, false);
1523 log_set_max_level(LOG_DEBUG);
1524 log_notice("Setting log level to debug.");
1528 log_set_max_level(LOG_INFO);
1529 log_notice("Setting log level to info.");
1533 if (m->running_as == SYSTEMD_USER) {
1534 m->exit_code = MANAGER_EXIT;
1538 /* This is a nop on init */
1542 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1543 log_notice("Setting log target to journal-or-kmsg.");
1547 log_set_target(LOG_TARGET_CONSOLE);
1548 log_notice("Setting log target to console.");
1552 log_set_target(LOG_TARGET_KMSG);
1553 log_notice("Setting log target to kmsg.");
1557 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1558 log_notice("Setting log target to syslog-or-kmsg.");
1562 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1569 return manager_dispatch_sigchld(m);
1574 static int process_event(Manager *m, struct epoll_event *ev) {
1581 assert_se(w = ev->data.ptr);
1583 if (w->type == WATCH_INVALID)
1590 /* An incoming signal? */
1591 if (ev->events != EPOLLIN)
1594 if ((r = manager_process_signal_fd(m)) < 0)
1601 /* An incoming daemon notification event? */
1602 if (ev->events != EPOLLIN)
1605 if ((r = manager_process_notify_fd(m)) < 0)
1612 /* Some fd event, to be dispatched to the units */
1613 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1616 case WATCH_UNIT_TIMER:
1617 case WATCH_JOB_TIMER: {
1621 /* Some timer event, to be dispatched to the units */
1622 k = read(w->fd, &v, sizeof(v));
1623 if (k != sizeof(v)) {
1625 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1628 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1629 return k < 0 ? -errno : -EIO;
1632 if (w->type == WATCH_UNIT_TIMER)
1633 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1635 job_timer_event(w->data.job, v, w);
1640 /* Some mount table change, intended for the mount subsystem */
1641 mount_fd_event(m, ev->events);
1645 /* Some swap table change, intended for the swap subsystem */
1646 swap_fd_event(m, ev->events);
1650 /* Some notification from udev, intended for the device subsystem */
1651 device_fd_event(m, ev->events);
1654 case WATCH_DBUS_WATCH:
1655 bus_watch_event(m, w, ev->events);
1658 case WATCH_DBUS_TIMEOUT:
1659 bus_timeout_event(m, w, ev->events);
1662 case WATCH_TIME_CHANGE: {
1666 log_struct(LOG_INFO,
1667 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1668 "MESSAGE=Time has been changed",
1671 /* Restart the watch */
1672 epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->time_change_watch.fd,
1674 close_nointr_nofail(m->time_change_watch.fd);
1675 watch_init(&m->time_change_watch);
1676 manager_setup_time_change(m);
1678 HASHMAP_FOREACH(u, m->units, i) {
1679 if (UNIT_VTABLE(u)->time_change)
1680 UNIT_VTABLE(u)->time_change(u);
1686 case WATCH_JOBS_IN_PROGRESS: {
1689 /* not interested in the data */
1690 read(w->fd, &v, sizeof(v));
1692 manager_print_jobs_in_progress(m);
1697 log_error("event type=%i", w->type);
1698 assert_not_reached("Unknown epoll event type.");
1704 int manager_loop(Manager *m) {
1707 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1710 m->exit_code = MANAGER_RUNNING;
1712 /* Release the path cache */
1713 set_free_free(m->unit_path_cache);
1714 m->unit_path_cache = NULL;
1716 manager_check_finished(m);
1718 /* There might still be some zombies hanging around from
1719 * before we were exec()'ed. Leat's reap them */
1720 r = manager_dispatch_sigchld(m);
1724 while (m->exit_code == MANAGER_RUNNING) {
1725 struct epoll_event event;
1729 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1732 if (!ratelimit_test(&rl)) {
1733 /* Yay, something is going seriously wrong, pause a little */
1734 log_warning("Looping too fast. Throttling execution a little.");
1739 if (manager_dispatch_load_queue(m) > 0)
1742 if (manager_dispatch_run_queue(m) > 0)
1745 if (bus_dispatch(m) > 0)
1748 if (manager_dispatch_cleanup_queue(m) > 0)
1751 if (manager_dispatch_gc_queue(m) > 0)
1754 if (manager_dispatch_dbus_queue(m) > 0)
1757 if (swap_dispatch_reload(m) > 0)
1760 /* Sleep for half the watchdog time */
1761 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1762 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1768 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1780 r = process_event(m, &event);
1785 return m->exit_code;
1788 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1797 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1800 n = bus_path_unescape(s+31);
1804 r = manager_load_unit(m, n, NULL, e, &u);
1815 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1824 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1827 r = safe_atou(s + 30, &id);
1831 j = manager_get_job(m, id);
1840 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1846 audit_fd = get_audit_fd();
1850 /* Don't generate audit events if the service was already
1851 * started and we're just deserializing */
1852 if (m->n_reloading > 0)
1855 if (m->running_as != SYSTEMD_SYSTEM)
1858 if (u->type != UNIT_SERVICE)
1861 p = unit_name_to_prefix_and_instance(u->id);
1863 log_error_unit(u->id,
1864 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1868 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1869 if (errno == EPERM) {
1870 /* We aren't allowed to send audit messages?
1871 * Then let's not retry again. */
1874 log_warning("Failed to send audit message: %m");
1882 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1884 union sockaddr_union sa;
1886 char *message = NULL;
1888 /* Don't generate plymouth events if the service was already
1889 * started and we're just deserializing */
1890 if (m->n_reloading > 0)
1893 if (m->running_as != SYSTEMD_SYSTEM)
1896 if (u->type != UNIT_SERVICE &&
1897 u->type != UNIT_MOUNT &&
1898 u->type != UNIT_SWAP)
1901 /* We set SOCK_NONBLOCK here so that we rather drop the
1902 * message then wait for plymouth */
1903 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1905 log_error("socket() failed: %m");
1910 sa.sa.sa_family = AF_UNIX;
1911 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1912 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1914 if (errno != EPIPE &&
1917 errno != ECONNREFUSED &&
1918 errno != ECONNRESET &&
1919 errno != ECONNABORTED)
1920 log_error("connect() failed: %m");
1925 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1931 if (write(fd, message, n + 1) != n + 1) {
1933 if (errno != EPIPE &&
1936 errno != ECONNREFUSED &&
1937 errno != ECONNRESET &&
1938 errno != ECONNABORTED)
1939 log_error("Failed to write Plymouth message: %m");
1946 close_nointr_nofail(fd);
1951 void manager_dispatch_bus_name_owner_changed(
1954 const char* old_owner,
1955 const char *new_owner) {
1962 if (!(u = hashmap_get(m->watch_bus, name)))
1965 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1968 void manager_dispatch_bus_query_pid_done(
1979 if (!(u = hashmap_get(m->watch_bus, name)))
1982 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1985 int manager_open_serialization(Manager *m, FILE **_f) {
1992 if (m->running_as == SYSTEMD_SYSTEM)
1993 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1995 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
2000 RUN_WITH_UMASK(0077) {
2001 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2011 log_debug("Serializing state to %s", path);
2014 f = fdopen(fd, "w+");
2023 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
2036 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2037 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2038 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2039 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2041 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2042 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2043 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2044 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2047 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2048 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2051 STRV_FOREACH(e, m->environment) {
2052 _cleanup_free_ char *ce;
2056 fprintf(f, "env=%s\n", *e);
2061 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2065 if (!unit_can_serialize(u))
2072 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
2078 assert(m->n_reloading > 0);
2084 r = bus_fdset_add_all(m, fds);
2091 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2097 log_debug("Deserializing state...");
2102 char line[LINE_MAX], *l;
2104 if (!fgets(line, sizeof(line), f)) {
2119 if (startswith(l, "current-job-id=")) {
2122 if (safe_atou32(l+15, &id) < 0)
2123 log_debug("Failed to parse current job id value %s", l+15);
2125 m->current_job_id = MAX(m->current_job_id, id);
2126 } else if (startswith(l, "n-installed-jobs=")) {
2129 if (safe_atou32(l+17, &n) < 0)
2130 log_debug("Failed to parse installed jobs counter %s", l+17);
2132 m->n_installed_jobs += n;
2133 } else if (startswith(l, "n-failed-jobs=")) {
2136 if (safe_atou32(l+14, &n) < 0)
2137 log_debug("Failed to parse failed jobs counter %s", l+14);
2139 m->n_failed_jobs += n;
2140 } else if (startswith(l, "taint-usr=")) {
2143 if ((b = parse_boolean(l+10)) < 0)
2144 log_debug("Failed to parse taint /usr flag %s", l+10);
2146 m->taint_usr = m->taint_usr || b;
2147 } else if (startswith(l, "firmware-timestamp="))
2148 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2149 else if (startswith(l, "loader-timestamp="))
2150 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2151 else if (startswith(l, "kernel-timestamp="))
2152 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2153 else if (startswith(l, "initrd-timestamp="))
2154 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2155 else if (startswith(l, "userspace-timestamp="))
2156 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2157 else if (startswith(l, "finish-timestamp="))
2158 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2159 else if (startswith(l, "env=")) {
2160 _cleanup_free_ char *uce = NULL;
2163 uce = cunescape(l+4);
2169 e = strv_env_set(m->environment, uce);
2175 strv_free(m->environment);
2178 log_debug("Unknown serialization item '%s'", l);
2183 char name[UNIT_NAME_MAX+2];
2186 if (!fgets(name, sizeof(name), f)) {
2197 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2201 r = unit_deserialize(u, f, fds);
2212 assert(m->n_reloading > 0);
2218 int manager_distribute_fds(Manager *m, FDSet *fds) {
2225 HASHMAP_FOREACH(u, m->units, i) {
2227 if (fdset_size(fds) <= 0)
2230 if (UNIT_VTABLE(u)->distribute_fds) {
2231 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2240 int manager_reload(Manager *m) {
2247 r = manager_open_serialization(m, &f);
2260 r = manager_serialize(m, f, fds, true);
2266 if (fseeko(f, 0, SEEK_SET) < 0) {
2272 /* From here on there is no way back. */
2273 manager_clear_jobs_and_units(m);
2274 manager_undo_generators(m);
2275 lookup_paths_free(&m->lookup_paths);
2277 /* Find new unit paths */
2278 manager_run_generators(m);
2280 q = lookup_paths_init(
2281 &m->lookup_paths, m->running_as, true,
2282 m->generator_unit_path,
2283 m->generator_unit_path_early,
2284 m->generator_unit_path_late);
2288 manager_build_unit_path_cache(m);
2290 /* First, enumerate what we can from all config files */
2291 q = manager_enumerate(m);
2295 /* Second, deserialize our stored data */
2296 q = manager_deserialize(m, f, fds);
2303 /* Third, fire things up! */
2304 q = manager_coldplug(m);
2308 assert(m->n_reloading > 0);
2321 static bool manager_is_booting_or_shutting_down(Manager *m) {
2326 /* Is the initial job still around? */
2327 if (manager_get_job(m, m->default_unit_job_id))
2330 /* Is there a job for the shutdown target? */
2331 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2338 bool manager_is_reloading_or_reexecuting(Manager *m) {
2341 return m->n_reloading != 0;
2344 void manager_reset_failed(Manager *m) {
2350 HASHMAP_FOREACH(u, m->units, i)
2351 unit_reset_failed(u);
2354 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2360 /* Returns true if the unit is inactive or going down */
2361 u = manager_get_unit(m, name);
2365 return unit_pending_inactive(u);
2368 void manager_check_finished(Manager *m) {
2369 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2370 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2374 if (m->n_running_jobs == 0)
2375 manager_unwatch_jobs_in_progress(m);
2377 if (hashmap_size(m->jobs) > 0) {
2378 manager_jobs_in_progress_mod_timer(m);
2382 /* Notify Type=idle units that we are done now */
2383 close_pipe(m->idle_pipe);
2385 /* Turn off confirm spawn now */
2386 m->confirm_spawn = false;
2388 if (dual_timestamp_is_set(&m->finish_timestamp))
2391 dual_timestamp_get(&m->finish_timestamp);
2393 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2395 /* Note that m->kernel_usec.monotonic is always at 0,
2396 * and m->firmware_usec.monotonic and
2397 * m->loader_usec.monotonic should be considered
2398 * negative values. */
2400 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2401 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2402 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2403 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2405 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2407 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2408 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2410 if (!log_on_console())
2411 log_struct(LOG_INFO,
2412 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2413 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2414 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2415 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2416 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2417 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2418 format_timespan(initrd, sizeof(initrd), initrd_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),
2423 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2426 if (!log_on_console())
2427 log_struct(LOG_INFO,
2428 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2429 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2430 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2431 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2432 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2433 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2434 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2438 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2439 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2441 if (!log_on_console())
2442 log_struct(LOG_INFO,
2443 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2444 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2445 "MESSAGE=Startup finished in %s.",
2446 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2450 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2453 "READY=1\nSTATUS=Startup finished in %s.",
2454 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2457 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2468 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2470 p = strappend("/run/systemd/", name);
2474 r = mkdir_p_label(p, 0755);
2476 log_error("Failed to create generator directory %s: %s",
2482 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2487 log_error("Failed to create generator directory %s: %m",
2498 static void trim_generator_dir(Manager *m, char **generator) {
2505 if (rmdir(*generator) >= 0) {
2513 void manager_run_generators(Manager *m) {
2515 const char *generator_path;
2516 const char *argv[5];
2521 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2522 d = opendir(generator_path);
2524 if (errno == ENOENT)
2527 log_error("Failed to enumerate generator directory %s: %m",
2532 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2536 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2540 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2544 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2545 argv[1] = m->generator_unit_path;
2546 argv[2] = m->generator_unit_path_early;
2547 argv[3] = m->generator_unit_path_late;
2550 RUN_WITH_UMASK(0022) {
2551 execute_directory(generator_path, d, (char**) argv);
2554 trim_generator_dir(m, &m->generator_unit_path);
2555 trim_generator_dir(m, &m->generator_unit_path_early);
2556 trim_generator_dir(m, &m->generator_unit_path_late);
2563 static void remove_generator_dir(Manager *m, char **generator) {
2570 strv_remove(m->lookup_paths.unit_path, *generator);
2571 rm_rf(*generator, false, true, false);
2577 void manager_undo_generators(Manager *m) {
2580 remove_generator_dir(m, &m->generator_unit_path);
2581 remove_generator_dir(m, &m->generator_unit_path_early);
2582 remove_generator_dir(m, &m->generator_unit_path_late);
2585 int manager_set_default_controllers(Manager *m, char **controllers) {
2590 l = strv_copy(controllers);
2594 strv_free(m->default_controllers);
2595 m->default_controllers = l;
2597 cg_shorten_controllers(m->default_controllers);
2602 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2607 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2608 if (!default_rlimit[i])
2611 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2619 void manager_recheck_journal(Manager *m) {
2624 if (m->running_as != SYSTEMD_SYSTEM)
2627 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2628 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2629 log_close_journal();
2633 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2634 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2635 log_close_journal();
2639 /* Hmm, OK, so the socket is fully up and the service is up
2640 * too, then let's make use of the thing. */
2644 void manager_set_show_status(Manager *m, bool b) {
2647 if (m->running_as != SYSTEMD_SYSTEM)
2653 touch("/run/systemd/show-status");
2655 unlink("/run/systemd/show-status");
2658 static bool manager_get_show_status(Manager *m) {
2661 if (m->running_as != SYSTEMD_SYSTEM)
2667 /* If Plymouth is running make sure we show the status, so
2668 * that there's something nice to see when people press Esc */
2670 return plymouth_running();
2673 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2676 if (!manager_get_show_status(m))
2679 /* XXX We should totally drop the check for ephemeral here
2680 * and thus effectively make 'Type=idle' pointless. */
2681 if (ephemeral && m->n_on_console > 0)
2684 if (!manager_is_booting_or_shutting_down(m))
2687 va_start(ap, format);
2688 status_vprintf(status, true, ephemeral, format, ap);
2692 void watch_init(Watch *w) {
2695 w->type = WATCH_INVALID;