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"
58 #include "mount-setup.h"
59 #include "unit-name.h"
60 #include "dbus-unit.h"
63 #include "path-lookup.h"
65 #include "bus-errors.h"
66 #include "exit-status.h"
69 #include "cgroup-util.h"
70 #include "path-util.h"
75 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
76 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
78 /* Initial delay and the interval for printing status messages about running jobs */
79 #define JOBS_IN_PROGRESS_WAIT_SEC 5
80 #define JOBS_IN_PROGRESS_PERIOD_SEC 1
81 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
83 /* Where clients shall send notification messages to */
84 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
86 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
88 static int manager_setup_notify(Manager *m) {
91 struct sockaddr_un un;
93 .sa.sa_family = AF_UNIX,
95 struct epoll_event ev = {
97 .data.ptr = &m->notify_watch,
101 m->notify_watch.type = WATCH_NOTIFY;
102 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
103 if (m->notify_watch.fd < 0) {
104 log_error("Failed to allocate notification socket: %m");
108 if (getpid() != 1 || detect_container(NULL) > 0)
109 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
111 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
113 sa.un.sun_path[0] = 0;
115 r = bind(m->notify_watch.fd, &sa.sa,
116 offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
118 log_error("bind() failed: %m");
122 r = setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
124 log_error("SO_PASSCRED failed: %m");
128 r = epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev);
130 log_error("Failed to add notification socket fd to epoll: %m");
134 sa.un.sun_path[0] = '@';
135 m->notify_socket = strdup(sa.un.sun_path);
136 if (!m->notify_socket)
139 log_debug("Using notification socket %s", m->notify_socket);
144 static int manager_jobs_in_progress_mod_timer(Manager *m) {
145 struct itimerspec its = {
146 .it_value.tv_sec = JOBS_IN_PROGRESS_WAIT_SEC,
147 .it_interval.tv_sec = JOBS_IN_PROGRESS_PERIOD_SEC,
150 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
153 if (timerfd_settime(m->jobs_in_progress_watch.fd, 0, &its, NULL) < 0)
159 static int manager_watch_jobs_in_progress(Manager *m) {
160 struct epoll_event ev = {
162 .data.ptr = &m->jobs_in_progress_watch,
166 if (m->jobs_in_progress_watch.type != WATCH_INVALID)
169 m->jobs_in_progress_watch.type = WATCH_JOBS_IN_PROGRESS;
170 m->jobs_in_progress_watch.fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
171 if (m->jobs_in_progress_watch.fd < 0) {
172 log_error("Failed to create timerfd: %m");
177 r = manager_jobs_in_progress_mod_timer(m);
179 log_error("Failed to set up timer for jobs progress watch: %s", strerror(-r));
183 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->jobs_in_progress_watch.fd, &ev) < 0) {
184 log_error("Failed to add jobs progress timer fd to epoll: %m");
189 log_debug("Set up jobs progress timerfd.");
194 if (m->jobs_in_progress_watch.fd >= 0)
195 close_nointr_nofail(m->jobs_in_progress_watch.fd);
196 watch_init(&m->jobs_in_progress_watch);
200 static void manager_unwatch_jobs_in_progress(Manager *m) {
201 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
204 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->jobs_in_progress_watch.fd, NULL) >= 0);
205 close_nointr_nofail(m->jobs_in_progress_watch.fd);
206 watch_init(&m->jobs_in_progress_watch);
207 m->jobs_in_progress_iteration = 0;
209 log_debug("Closed jobs progress timerfd.");
212 #define CYLON_BUFFER_EXTRA (2*strlen(ANSI_RED_ON) + strlen(ANSI_HIGHLIGHT_RED_ON) + 2*strlen(ANSI_HIGHLIGHT_OFF))
213 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
216 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
217 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
221 p = mempset(p, ' ', pos-2);
222 p = stpcpy(p, ANSI_RED_ON);
226 if (pos > 0 && pos <= width) {
227 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
231 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
234 p = stpcpy(p, ANSI_RED_ON);
237 p = mempset(p, ' ', width-1-pos);
238 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
242 static void manager_print_jobs_in_progress(Manager *m) {
245 char *job_of_n = NULL;
246 unsigned counter = 0, print_nr;
247 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
250 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
252 HASHMAP_FOREACH(j, m->jobs, i)
253 if (j->state == JOB_RUNNING && counter++ == print_nr)
256 /* m->n_running_jobs must be consistent with the contents of m->jobs,
257 * so the above loop must have succeeded in finding j. */
258 assert(counter == print_nr + 1);
260 cylon_pos = m->jobs_in_progress_iteration % 14;
262 cylon_pos = 14 - cylon_pos;
263 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
265 if (m->n_running_jobs > 1)
266 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
269 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
270 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
273 m->jobs_in_progress_iteration++;
276 static int manager_setup_time_change(Manager *m) {
277 struct epoll_event ev = {
279 .data.ptr = &m->time_change_watch,
282 /* We only care for the cancellation event, hence we set the
283 * timeout to the latest possible value. */
284 struct itimerspec its = {
285 .it_value.tv_sec = TIME_T_MAX,
287 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
289 assert(m->time_change_watch.type == WATCH_INVALID);
291 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
292 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
294 m->time_change_watch.type = WATCH_TIME_CHANGE;
295 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
296 if (m->time_change_watch.fd < 0) {
297 log_error("Failed to create timerfd: %m");
301 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
302 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
303 close_nointr_nofail(m->time_change_watch.fd);
304 watch_init(&m->time_change_watch);
308 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
309 log_error("Failed to add timer change fd to epoll: %m");
313 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
318 static int enable_special_signals(Manager *m) {
323 /* Enable that we get SIGINT on control-alt-del. In containers
324 * this will fail with EPERM (older) or EINVAL (newer), so
326 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
327 log_warning("Failed to enable ctrl-alt-del handling: %m");
329 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
331 /* Support systems without virtual console */
333 log_warning("Failed to open /dev/tty0: %m");
335 /* Enable that we get SIGWINCH on kbrequest */
336 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
337 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
339 close_nointr_nofail(fd);
345 static int manager_setup_signals(Manager *m) {
347 struct epoll_event ev = {
349 .data.ptr = &m->signal_watch,
351 struct sigaction sa = {
352 .sa_handler = SIG_DFL,
353 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
358 /* We are not interested in SIGSTOP and friends. */
359 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
361 assert_se(sigemptyset(&mask) == 0);
363 sigset_add_many(&mask,
364 SIGCHLD, /* Child died */
365 SIGTERM, /* Reexecute daemon */
366 SIGHUP, /* Reload configuration */
367 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
368 SIGUSR2, /* systemd: dump status */
369 SIGINT, /* Kernel sends us this on control-alt-del */
370 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
371 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
372 SIGRTMIN+0, /* systemd: start default.target */
373 SIGRTMIN+1, /* systemd: isolate rescue.target */
374 SIGRTMIN+2, /* systemd: isolate emergency.target */
375 SIGRTMIN+3, /* systemd: start halt.target */
376 SIGRTMIN+4, /* systemd: start poweroff.target */
377 SIGRTMIN+5, /* systemd: start reboot.target */
378 SIGRTMIN+6, /* systemd: start kexec.target */
379 SIGRTMIN+13, /* systemd: Immediate halt */
380 SIGRTMIN+14, /* systemd: Immediate poweroff */
381 SIGRTMIN+15, /* systemd: Immediate reboot */
382 SIGRTMIN+16, /* systemd: Immediate kexec */
383 SIGRTMIN+20, /* systemd: enable status messages */
384 SIGRTMIN+21, /* systemd: disable status messages */
385 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
386 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
387 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
388 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
389 SIGRTMIN+27, /* systemd: set log target to console */
390 SIGRTMIN+28, /* systemd: set log target to kmsg */
391 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
393 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
395 m->signal_watch.type = WATCH_SIGNAL;
396 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
397 if (m->signal_watch.fd < 0)
400 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
403 if (m->running_as == SYSTEMD_SYSTEM)
404 return enable_special_signals(m);
409 static void manager_strip_environment(Manager *m) {
412 /* Remove variables from the inherited set that are part of
413 * the container interface:
414 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
415 strv_remove_prefix(m->environment, "container=");
416 strv_remove_prefix(m->environment, "container_");
418 /* Remove variables from the inherited set that are part of
419 * the initrd interface:
420 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
421 strv_remove_prefix(m->environment, "RD_");
423 /* Drop invalid entries */
424 strv_env_clean(m->environment);
427 int manager_new(SystemdRunningAs running_as, bool reexecuting, Manager **_m) {
432 assert(running_as >= 0);
433 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
435 m = new0(Manager, 1);
440 if (detect_container(NULL) <= 0)
441 efi_get_boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
444 m->running_as = running_as;
445 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
446 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
447 m->pin_cgroupfs_fd = -1;
448 m->idle_pipe[0] = m->idle_pipe[1] = -1;
450 watch_init(&m->signal_watch);
451 watch_init(&m->mount_watch);
452 watch_init(&m->swap_watch);
453 watch_init(&m->udev_watch);
454 watch_init(&m->time_change_watch);
455 watch_init(&m->jobs_in_progress_watch);
457 m->epoll_fd = m->dev_autofs_fd = -1;
458 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
460 m->environment = strv_copy(environ);
464 manager_strip_environment(m);
466 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
469 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
472 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
475 m->cgroup_unit = hashmap_new(string_hash_func, string_compare_func);
479 m->watch_bus = hashmap_new(string_hash_func, string_compare_func);
483 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
487 r = manager_setup_signals(m);
491 r = manager_setup_cgroup(m);
495 r = manager_setup_notify(m);
499 r = manager_setup_time_change(m);
503 /* Try to connect to the busses, if possible. */
504 if ((running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS")) ||
505 running_as == SYSTEMD_SYSTEM) {
506 r = bus_init(m, reexecuting || running_as != SYSTEMD_SYSTEM);
510 log_debug("Skipping DBus session bus connection attempt - no DBUS_SESSION_BUS_ADDRESS set...");
512 m->taint_usr = dir_is_empty("/usr") > 0;
522 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
528 while ((u = m->cleanup_queue)) {
529 assert(u->in_cleanup_queue);
539 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
540 GC_OFFSET_UNSURE, /* No clue */
541 GC_OFFSET_GOOD, /* We still need this unit */
542 GC_OFFSET_BAD, /* We don't need this unit anymore */
546 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
553 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
554 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
555 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
558 if (u->in_cleanup_queue)
561 if (unit_check_gc(u))
564 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
568 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
569 unit_gc_sweep(other, gc_marker);
571 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
574 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
581 /* We were unable to find anything out about this entry, so
582 * let's investigate it later */
583 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
584 unit_add_to_gc_queue(u);
588 /* We definitely know that this one is not useful anymore, so
589 * let's mark it for deletion */
590 u->gc_marker = gc_marker + GC_OFFSET_BAD;
591 unit_add_to_cleanup_queue(u);
595 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
598 static unsigned manager_dispatch_gc_queue(Manager *m) {
605 /* log_debug("Running GC..."); */
607 m->gc_marker += _GC_OFFSET_MAX;
608 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
611 gc_marker = m->gc_marker;
613 while ((u = m->gc_queue)) {
614 assert(u->in_gc_queue);
616 unit_gc_sweep(u, gc_marker);
618 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
619 u->in_gc_queue = false;
623 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
624 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
625 log_debug_unit(u->id, "Collecting %s", u->id);
626 u->gc_marker = gc_marker + GC_OFFSET_BAD;
627 unit_add_to_cleanup_queue(u);
631 m->n_in_gc_queue = 0;
636 static void manager_clear_jobs_and_units(Manager *m) {
641 while ((u = hashmap_first(m->units)))
644 manager_dispatch_cleanup_queue(m);
646 assert(!m->load_queue);
647 assert(!m->run_queue);
648 assert(!m->dbus_unit_queue);
649 assert(!m->dbus_job_queue);
650 assert(!m->cleanup_queue);
651 assert(!m->gc_queue);
653 assert(hashmap_isempty(m->jobs));
654 assert(hashmap_isempty(m->units));
657 m->n_running_jobs = 0;
660 void manager_free(Manager *m) {
666 manager_clear_jobs_and_units(m);
668 for (c = 0; c < _UNIT_TYPE_MAX; c++)
669 if (unit_vtable[c]->shutdown)
670 unit_vtable[c]->shutdown(m);
672 /* If we reexecute ourselves, we keep the root cgroup
674 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
676 manager_undo_generators(m);
680 hashmap_free(m->units);
681 hashmap_free(m->jobs);
682 hashmap_free(m->watch_pids);
683 hashmap_free(m->watch_bus);
685 if (m->epoll_fd >= 0)
686 close_nointr_nofail(m->epoll_fd);
687 if (m->signal_watch.fd >= 0)
688 close_nointr_nofail(m->signal_watch.fd);
689 if (m->notify_watch.fd >= 0)
690 close_nointr_nofail(m->notify_watch.fd);
691 if (m->time_change_watch.fd >= 0)
692 close_nointr_nofail(m->time_change_watch.fd);
693 if (m->jobs_in_progress_watch.fd >= 0)
694 close_nointr_nofail(m->jobs_in_progress_watch.fd);
696 free(m->notify_socket);
698 lookup_paths_free(&m->lookup_paths);
699 strv_free(m->environment);
701 hashmap_free(m->cgroup_unit);
702 set_free_free(m->unit_path_cache);
704 close_pipe(m->idle_pipe);
706 free(m->switch_root);
707 free(m->switch_root_init);
709 for (i = 0; i < RLIMIT_NLIMITS; i++)
715 int manager_enumerate(Manager *m) {
721 /* Let's ask every type to load all units from disk/kernel
722 * that it might know */
723 for (c = 0; c < _UNIT_TYPE_MAX; c++)
724 if (unit_vtable[c]->enumerate)
725 if ((q = unit_vtable[c]->enumerate(m)) < 0)
728 manager_dispatch_load_queue(m);
732 int manager_coldplug(Manager *m) {
740 /* Then, let's set up their initial state. */
741 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
747 if ((q = unit_coldplug(u)) < 0)
754 static void manager_build_unit_path_cache(Manager *m) {
756 _cleanup_free_ DIR *d = NULL;
761 set_free_free(m->unit_path_cache);
763 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
764 if (!m->unit_path_cache) {
765 log_error("Failed to allocate unit path cache.");
769 /* This simply builds a list of files we know exist, so that
770 * we don't always have to go to disk */
772 STRV_FOREACH(i, m->lookup_paths.unit_path) {
778 log_error("Failed to open directory %s: %m", *i);
782 while ((de = readdir(d))) {
785 if (ignore_file(de->d_name))
788 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
794 r = set_consume(m->unit_path_cache, p);
806 log_error("Failed to build unit path cache: %s", strerror(-r));
808 set_free_free(m->unit_path_cache);
809 m->unit_path_cache = NULL;
812 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
817 dual_timestamp_get(&m->generators_start_timestamp);
818 manager_run_generators(m);
819 dual_timestamp_get(&m->generators_finish_timestamp);
821 r = lookup_paths_init(
822 &m->lookup_paths, m->running_as, true,
823 m->generator_unit_path,
824 m->generator_unit_path_early,
825 m->generator_unit_path_late);
829 manager_build_unit_path_cache(m);
831 /* If we will deserialize make sure that during enumeration
832 * this is already known, so we increase the counter here
837 /* First, enumerate what we can from all config files */
838 dual_timestamp_get(&m->unitsload_start_timestamp);
839 r = manager_enumerate(m);
840 dual_timestamp_get(&m->unitsload_finish_timestamp);
842 /* Second, deserialize if there is something to deserialize */
844 q = manager_deserialize(m, serialization, fds);
849 /* Any fds left? Find some unit which wants them. This is
850 * useful to allow container managers to pass some file
851 * descriptors to us pre-initialized. This enables
852 * socket-based activation of entire containers. */
853 if (fdset_size(fds) > 0) {
854 q = manager_distribute_fds(m, fds);
859 /* Third, fire things up! */
860 q = manager_coldplug(m);
865 assert(m->n_reloading > 0);
868 /* Let's wait for the UnitNew/JobNew messages being
869 * sent, before we notify that the reload is
871 m->send_reloading_done = true;
877 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
882 assert(type < _JOB_TYPE_MAX);
884 assert(mode < _JOB_MODE_MAX);
886 if (mode == JOB_ISOLATE && type != JOB_START) {
887 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
891 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
892 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
896 log_debug_unit(unit->id,
897 "Trying to enqueue job %s/%s/%s", unit->id,
898 job_type_to_string(type), job_mode_to_string(mode));
900 job_type_collapse(&type, unit);
902 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
906 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
907 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
908 mode == JOB_IGNORE_DEPENDENCIES, e);
912 if (mode == JOB_ISOLATE) {
913 r = transaction_add_isolate_jobs(tr, m);
918 r = transaction_activate(tr, m, mode, e);
922 log_debug_unit(unit->id,
923 "Enqueued job %s/%s as %u", unit->id,
924 job_type_to_string(type), (unsigned) tr->anchor_job->id);
927 *_ret = tr->anchor_job;
929 transaction_free(tr);
933 transaction_abort(tr);
934 transaction_free(tr);
938 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
943 assert(type < _JOB_TYPE_MAX);
945 assert(mode < _JOB_MODE_MAX);
947 r = manager_load_unit(m, name, NULL, NULL, &unit);
951 return manager_add_job(m, type, unit, mode, override, e, _ret);
954 Job *manager_get_job(Manager *m, uint32_t id) {
957 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
960 Unit *manager_get_unit(Manager *m, const char *name) {
964 return hashmap_get(m->units, name);
967 unsigned manager_dispatch_load_queue(Manager *m) {
973 /* Make sure we are not run recursively */
974 if (m->dispatching_load_queue)
977 m->dispatching_load_queue = true;
979 /* Dispatches the load queue. Takes a unit from the queue and
980 * tries to load its data until the queue is empty */
982 while ((u = m->load_queue)) {
983 assert(u->in_load_queue);
989 m->dispatching_load_queue = false;
993 int manager_load_unit_prepare(
1005 assert(name || path);
1007 /* This will prepare the unit for loading, but not actually
1008 * load anything from disk. */
1010 if (path && !is_path(path)) {
1011 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1016 name = path_get_file_name(path);
1018 t = unit_name_to_type(name);
1020 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
1021 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1025 ret = manager_get_unit(m, name);
1031 ret = unit_new(m, unit_vtable[t]->object_size);
1036 ret->fragment_path = strdup(path);
1037 if (!ret->fragment_path) {
1043 r = unit_add_name(ret, name);
1049 unit_add_to_load_queue(ret);
1050 unit_add_to_dbus_queue(ret);
1051 unit_add_to_gc_queue(ret);
1059 int manager_load_unit(
1070 /* This will load the service information files, but not actually
1071 * start any services or anything. */
1073 r = manager_load_unit_prepare(m, name, path, e, _ret);
1077 manager_dispatch_load_queue(m);
1080 *_ret = unit_follow_merge(*_ret);
1085 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1092 HASHMAP_FOREACH(j, s->jobs, i)
1093 job_dump(j, f, prefix);
1096 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1104 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1106 unit_dump(u, f, prefix);
1109 void manager_clear_jobs(Manager *m) {
1114 while ((j = hashmap_first(m->jobs)))
1115 /* No need to recurse. We're cancelling all jobs. */
1116 job_finish_and_invalidate(j, JOB_CANCELED, false);
1119 unsigned manager_dispatch_run_queue(Manager *m) {
1123 if (m->dispatching_run_queue)
1126 m->dispatching_run_queue = true;
1128 while ((j = m->run_queue)) {
1129 assert(j->installed);
1130 assert(j->in_run_queue);
1132 job_run_and_invalidate(j);
1136 m->dispatching_run_queue = false;
1138 if (m->n_running_jobs > 0)
1139 manager_watch_jobs_in_progress(m);
1144 unsigned manager_dispatch_dbus_queue(Manager *m) {
1151 if (m->dispatching_dbus_queue)
1154 m->dispatching_dbus_queue = true;
1156 while ((u = m->dbus_unit_queue)) {
1157 assert(u->in_dbus_queue);
1159 bus_unit_send_change_signal(u);
1163 while ((j = m->dbus_job_queue)) {
1164 assert(j->in_dbus_queue);
1166 bus_job_send_change_signal(j);
1170 m->dispatching_dbus_queue = false;
1172 if (m->send_reloading_done) {
1173 m->send_reloading_done = false;
1175 bus_broadcast_reloading(m, false);
1181 static int manager_process_notify_fd(Manager *m) {
1188 struct iovec iovec = {
1190 .iov_len = sizeof(buf)-1,
1194 struct cmsghdr cmsghdr;
1195 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1198 struct msghdr msghdr = {
1201 .msg_control = &control,
1202 .msg_controllen = sizeof(control),
1204 struct ucred *ucred;
1206 _cleanup_strv_free_ char **tags = NULL;
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 = manager_get_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) {
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 _cleanup_free_ char *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 = manager_get_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_IRREVERSIBLY);
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_gc_queue(m) > 0)
1743 if (manager_dispatch_cleanup_queue(m) > 0)
1746 if (manager_dispatch_cgroup_queue(m) > 0)
1749 if (manager_dispatch_run_queue(m) > 0)
1752 if (bus_dispatch(m) > 0)
1755 if (manager_dispatch_dbus_queue(m) > 0)
1758 if (swap_dispatch_reload(m) > 0)
1761 /* Sleep for half the watchdog time */
1762 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1763 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1769 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1781 r = process_event(m, &event);
1786 return m->exit_code;
1789 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1790 _cleanup_free_ char *n = NULL;
1798 r = unit_name_from_dbus_path(s, &n);
1802 r = manager_load_unit(m, n, NULL, e, &u);
1811 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1820 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1823 r = safe_atou(s + 30, &id);
1827 j = manager_get_job(m, id);
1836 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1842 audit_fd = get_audit_fd();
1846 /* Don't generate audit events if the service was already
1847 * started and we're just deserializing */
1848 if (m->n_reloading > 0)
1851 if (m->running_as != SYSTEMD_SYSTEM)
1854 if (u->type != UNIT_SERVICE)
1857 p = unit_name_to_prefix_and_instance(u->id);
1859 log_error_unit(u->id,
1860 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1864 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1865 if (errno == EPERM) {
1866 /* We aren't allowed to send audit messages?
1867 * Then let's not retry again. */
1870 log_warning("Failed to send audit message: %m");
1878 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1880 union sockaddr_union sa;
1882 char *message = NULL;
1884 /* Don't generate plymouth events if the service was already
1885 * started and we're just deserializing */
1886 if (m->n_reloading > 0)
1889 if (m->running_as != SYSTEMD_SYSTEM)
1892 if (u->type != UNIT_SERVICE &&
1893 u->type != UNIT_MOUNT &&
1894 u->type != UNIT_SWAP)
1897 /* We set SOCK_NONBLOCK here so that we rather drop the
1898 * message then wait for plymouth */
1899 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1901 log_error("socket() failed: %m");
1906 sa.sa.sa_family = AF_UNIX;
1907 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1908 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1910 if (errno != EPIPE &&
1913 errno != ECONNREFUSED &&
1914 errno != ECONNRESET &&
1915 errno != ECONNABORTED)
1916 log_error("connect() failed: %m");
1921 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1927 if (write(fd, message, n + 1) != n + 1) {
1929 if (errno != EPIPE &&
1932 errno != ECONNREFUSED &&
1933 errno != ECONNRESET &&
1934 errno != ECONNABORTED)
1935 log_error("Failed to write Plymouth message: %m");
1942 close_nointr_nofail(fd);
1947 void manager_dispatch_bus_name_owner_changed(
1950 const char* old_owner,
1951 const char *new_owner) {
1958 if (!(u = hashmap_get(m->watch_bus, name)))
1961 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1964 void manager_dispatch_bus_query_pid_done(
1975 if (!(u = hashmap_get(m->watch_bus, name)))
1978 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1981 int manager_open_serialization(Manager *m, FILE **_f) {
1988 if (m->running_as == SYSTEMD_SYSTEM)
1989 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1991 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1996 RUN_WITH_UMASK(0077) {
1997 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2007 log_debug("Serializing state to %s", path);
2010 f = fdopen(fd, "w+");
2019 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2032 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2033 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2034 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2035 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2037 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2038 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2039 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2040 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2043 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2044 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2047 if (!switching_root) {
2048 STRV_FOREACH(e, m->environment) {
2049 _cleanup_free_ char *ce;
2053 fprintf(f, "env=%s\n", *e);
2057 bus_serialize(m, f);
2061 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2065 if (!unit_can_serialize(u))
2072 r = unit_serialize(u, f, fds, !switching_root);
2079 assert(m->n_reloading > 0);
2085 r = bus_fdset_add_all(m, fds);
2092 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2098 log_debug("Deserializing state...");
2103 char line[LINE_MAX], *l;
2105 if (!fgets(line, sizeof(line), f)) {
2120 if (startswith(l, "current-job-id=")) {
2123 if (safe_atou32(l+15, &id) < 0)
2124 log_debug("Failed to parse current job id value %s", l+15);
2126 m->current_job_id = MAX(m->current_job_id, id);
2127 } else if (startswith(l, "n-installed-jobs=")) {
2130 if (safe_atou32(l+17, &n) < 0)
2131 log_debug("Failed to parse installed jobs counter %s", l+17);
2133 m->n_installed_jobs += n;
2134 } else if (startswith(l, "n-failed-jobs=")) {
2137 if (safe_atou32(l+14, &n) < 0)
2138 log_debug("Failed to parse failed jobs counter %s", l+14);
2140 m->n_failed_jobs += n;
2141 } else if (startswith(l, "taint-usr=")) {
2144 if ((b = parse_boolean(l+10)) < 0)
2145 log_debug("Failed to parse taint /usr flag %s", l+10);
2147 m->taint_usr = m->taint_usr || b;
2148 } else if (startswith(l, "firmware-timestamp="))
2149 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2150 else if (startswith(l, "loader-timestamp="))
2151 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2152 else if (startswith(l, "kernel-timestamp="))
2153 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2154 else if (startswith(l, "initrd-timestamp="))
2155 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2156 else if (startswith(l, "userspace-timestamp="))
2157 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2158 else if (startswith(l, "finish-timestamp="))
2159 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2160 else if (startswith(l, "env=")) {
2161 _cleanup_free_ char *uce = NULL;
2164 uce = cunescape(l+4);
2170 e = strv_env_set(m->environment, uce);
2176 strv_free(m->environment);
2178 } else if (bus_deserialize_item(m, l) == 0)
2179 log_debug("Unknown serialization item '%s'", l);
2184 char name[UNIT_NAME_MAX+2];
2187 if (!fgets(name, sizeof(name), f)) {
2198 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2202 r = unit_deserialize(u, f, fds);
2213 assert(m->n_reloading > 0);
2219 int manager_distribute_fds(Manager *m, FDSet *fds) {
2226 HASHMAP_FOREACH(u, m->units, i) {
2228 if (fdset_size(fds) <= 0)
2231 if (UNIT_VTABLE(u)->distribute_fds) {
2232 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2241 int manager_reload(Manager *m) {
2248 r = manager_open_serialization(m, &f);
2253 bus_broadcast_reloading(m, true);
2262 r = manager_serialize(m, f, fds, false);
2268 if (fseeko(f, 0, SEEK_SET) < 0) {
2274 /* From here on there is no way back. */
2275 manager_clear_jobs_and_units(m);
2276 manager_undo_generators(m);
2277 lookup_paths_free(&m->lookup_paths);
2279 /* Find new unit paths */
2280 manager_run_generators(m);
2282 q = lookup_paths_init(
2283 &m->lookup_paths, m->running_as, true,
2284 m->generator_unit_path,
2285 m->generator_unit_path_early,
2286 m->generator_unit_path_late);
2290 manager_build_unit_path_cache(m);
2292 /* First, enumerate what we can from all config files */
2293 q = manager_enumerate(m);
2297 /* Second, deserialize our stored data */
2298 q = manager_deserialize(m, f, fds);
2305 /* Third, fire things up! */
2306 q = manager_coldplug(m);
2310 assert(m->n_reloading > 0);
2313 m->send_reloading_done = true;
2325 static bool manager_is_booting_or_shutting_down(Manager *m) {
2330 /* Is the initial job still around? */
2331 if (manager_get_job(m, m->default_unit_job_id))
2334 /* Is there a job for the shutdown target? */
2335 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2342 bool manager_is_reloading_or_reexecuting(Manager *m) {
2345 return m->n_reloading != 0;
2348 void manager_reset_failed(Manager *m) {
2354 HASHMAP_FOREACH(u, m->units, i)
2355 unit_reset_failed(u);
2358 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2364 /* Returns true if the unit is inactive or going down */
2365 u = manager_get_unit(m, name);
2369 return unit_inactive_or_pending(u);
2372 void manager_check_finished(Manager *m) {
2373 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2374 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2378 if (m->n_running_jobs == 0)
2379 manager_unwatch_jobs_in_progress(m);
2381 if (hashmap_size(m->jobs) > 0) {
2382 manager_jobs_in_progress_mod_timer(m);
2386 /* Notify Type=idle units that we are done now */
2387 close_pipe(m->idle_pipe);
2389 /* Turn off confirm spawn now */
2390 m->confirm_spawn = false;
2392 if (dual_timestamp_is_set(&m->finish_timestamp))
2395 dual_timestamp_get(&m->finish_timestamp);
2397 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2399 /* Note that m->kernel_usec.monotonic is always at 0,
2400 * and m->firmware_usec.monotonic and
2401 * m->loader_usec.monotonic should be considered
2402 * negative values. */
2404 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2405 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2406 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2407 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2409 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2411 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2412 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2414 if (!log_on_console())
2415 log_struct(LOG_INFO,
2416 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2417 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2418 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2419 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2420 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2421 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2422 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2423 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2424 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2427 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2430 if (!log_on_console())
2431 log_struct(LOG_INFO,
2432 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2433 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2434 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2435 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2436 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2437 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2438 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2442 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2443 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2445 if (!log_on_console())
2446 log_struct(LOG_INFO,
2447 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2448 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2449 "MESSAGE=Startup finished in %s.",
2450 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2454 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2457 "READY=1\nSTATUS=Startup finished in %s.",
2458 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2461 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2472 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2474 p = strappend("/run/systemd/", name);
2478 r = mkdir_p_label(p, 0755);
2480 log_error("Failed to create generator directory %s: %s",
2486 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2491 log_error("Failed to create generator directory %s: %m",
2502 static void trim_generator_dir(Manager *m, char **generator) {
2509 if (rmdir(*generator) >= 0) {
2517 void manager_run_generators(Manager *m) {
2519 const char *generator_path;
2520 const char *argv[5];
2525 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2526 d = opendir(generator_path);
2528 if (errno == ENOENT)
2531 log_error("Failed to enumerate generator directory %s: %m",
2536 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2540 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2544 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2548 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2549 argv[1] = m->generator_unit_path;
2550 argv[2] = m->generator_unit_path_early;
2551 argv[3] = m->generator_unit_path_late;
2554 RUN_WITH_UMASK(0022) {
2555 execute_directory(generator_path, d, (char**) argv);
2558 trim_generator_dir(m, &m->generator_unit_path);
2559 trim_generator_dir(m, &m->generator_unit_path_early);
2560 trim_generator_dir(m, &m->generator_unit_path_late);
2567 static void remove_generator_dir(Manager *m, char **generator) {
2574 strv_remove(m->lookup_paths.unit_path, *generator);
2575 rm_rf(*generator, false, true, false);
2581 void manager_undo_generators(Manager *m) {
2584 remove_generator_dir(m, &m->generator_unit_path);
2585 remove_generator_dir(m, &m->generator_unit_path_early);
2586 remove_generator_dir(m, &m->generator_unit_path_late);
2589 int manager_set_default_environment(Manager *m, char **environment) {
2593 e = strv_env_merge(2, m->environment, environment);
2596 strv_free(m->environment);
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;