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 "sd-daemon.h"
47 #include "sd-messages.h"
50 #include "transaction.h"
57 #include "ratelimit.h"
58 #include "locale-setup.h"
59 #include "mount-setup.h"
60 #include "unit-name.h"
62 #include "path-lookup.h"
64 #include "exit-status.h"
67 #include "cgroup-util.h"
68 #include "path-util.h"
70 #include "boot-timestamps.h"
72 #include "bus-errors.h"
73 #include "bus-error.h"
76 #include "dbus-unit.h"
78 #include "dbus-manager.h"
80 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
81 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
83 /* Initial delay and the interval for printing status messages about running jobs */
84 #define JOBS_IN_PROGRESS_WAIT_SEC 5
85 #define JOBS_IN_PROGRESS_PERIOD_SEC 1
86 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
88 /* Where clients shall send notification messages to */
89 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
91 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
93 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
94 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
95 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
96 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
97 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
99 static int manager_setup_notify(Manager *m) {
102 struct sockaddr_un un;
104 .sa.sa_family = AF_UNIX,
108 m->notify_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
109 if (m->notify_fd < 0) {
110 log_error("Failed to allocate notification socket: %m");
114 if (getpid() != 1 || detect_container(NULL) > 0)
115 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
117 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
118 sa.un.sun_path[0] = 0;
120 r = bind(m->notify_fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
122 log_error("bind() failed: %m");
126 r = setsockopt(m->notify_fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
128 log_error("SO_PASSCRED failed: %m");
132 r = sd_event_add_io(m->event, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m, &m->notify_event_source);
134 log_error("Failed to allocate notify event source: %s", strerror(-r));
138 sa.un.sun_path[0] = '@';
139 m->notify_socket = strdup(sa.un.sun_path);
140 if (!m->notify_socket)
143 log_debug("Using notification socket %s", m->notify_socket);
148 static int manager_watch_jobs_in_progress(Manager *m) {
151 if (m->jobs_in_progress_event_source)
154 return sd_event_add_monotonic(m->event, JOBS_IN_PROGRESS_WAIT_SEC, 0, manager_dispatch_jobs_in_progress, m, &m->jobs_in_progress_event_source);
157 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
159 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
162 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
163 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
167 p = mempset(p, ' ', pos-2);
168 p = stpcpy(p, ANSI_RED_ON);
172 if (pos > 0 && pos <= width) {
173 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
177 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
180 p = stpcpy(p, ANSI_RED_ON);
183 p = mempset(p, ' ', width-1-pos);
184 strcpy(p, ANSI_HIGHLIGHT_OFF);
188 static void manager_print_jobs_in_progress(Manager *m) {
189 _cleanup_free_ char *job_of_n = NULL;
192 unsigned counter = 0, print_nr;
193 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
198 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
200 HASHMAP_FOREACH(j, m->jobs, i)
201 if (j->state == JOB_RUNNING && counter++ == print_nr)
204 /* m->n_running_jobs must be consistent with the contents of m->jobs,
205 * so the above loop must have succeeded in finding j. */
206 assert(counter == print_nr + 1);
209 cylon_pos = m->jobs_in_progress_iteration % 14;
211 cylon_pos = 14 - cylon_pos;
212 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
214 if (m->n_running_jobs > 1)
215 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
218 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
219 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
221 m->jobs_in_progress_iteration++;
224 static int manager_watch_idle_pipe(Manager *m) {
229 if (m->idle_pipe_event_source)
232 if (m->idle_pipe[2] < 0)
235 r = sd_event_add_io(m->event, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m, &m->idle_pipe_event_source);
237 log_error("Failed to watch idle pipe: %s", strerror(-r));
244 static void manager_close_idle_pipe(Manager *m) {
247 close_pipe(m->idle_pipe);
248 close_pipe(m->idle_pipe + 2);
251 static int manager_setup_time_change(Manager *m) {
254 /* We only care for the cancellation event, hence we set the
255 * timeout to the latest possible value. */
256 struct itimerspec its = {
257 .it_value.tv_sec = TIME_T_MAX,
261 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
263 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
264 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
266 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
267 if (m->time_change_fd < 0) {
268 log_error("Failed to create timerfd: %m");
272 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
273 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
274 close_nointr_nofail(m->time_change_fd);
275 m->time_change_fd = -1;
279 r = sd_event_add_io(m->event, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m, &m->time_change_event_source);
281 log_error("Failed to create time change event source: %s", strerror(-r));
285 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
290 static int enable_special_signals(Manager *m) {
291 _cleanup_close_ int fd = -1;
295 /* Enable that we get SIGINT on control-alt-del. In containers
296 * this will fail with EPERM (older) or EINVAL (newer), so
298 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
299 log_warning("Failed to enable ctrl-alt-del handling: %m");
301 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
303 /* Support systems without virtual console */
305 log_warning("Failed to open /dev/tty0: %m");
307 /* Enable that we get SIGWINCH on kbrequest */
308 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
309 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
315 static int manager_setup_signals(Manager *m) {
316 struct sigaction sa = {
317 .sa_handler = SIG_DFL,
318 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
325 /* We are not interested in SIGSTOP and friends. */
326 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
328 assert_se(sigemptyset(&mask) == 0);
330 sigset_add_many(&mask,
331 SIGCHLD, /* Child died */
332 SIGTERM, /* Reexecute daemon */
333 SIGHUP, /* Reload configuration */
334 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
335 SIGUSR2, /* systemd: dump status */
336 SIGINT, /* Kernel sends us this on control-alt-del */
337 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
338 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
339 SIGRTMIN+0, /* systemd: start default.target */
340 SIGRTMIN+1, /* systemd: isolate rescue.target */
341 SIGRTMIN+2, /* systemd: isolate emergency.target */
342 SIGRTMIN+3, /* systemd: start halt.target */
343 SIGRTMIN+4, /* systemd: start poweroff.target */
344 SIGRTMIN+5, /* systemd: start reboot.target */
345 SIGRTMIN+6, /* systemd: start kexec.target */
346 SIGRTMIN+13, /* systemd: Immediate halt */
347 SIGRTMIN+14, /* systemd: Immediate poweroff */
348 SIGRTMIN+15, /* systemd: Immediate reboot */
349 SIGRTMIN+16, /* systemd: Immediate kexec */
350 SIGRTMIN+20, /* systemd: enable status messages */
351 SIGRTMIN+21, /* systemd: disable status messages */
352 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
353 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
354 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
355 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
356 SIGRTMIN+27, /* systemd: set log target to console */
357 SIGRTMIN+28, /* systemd: set log target to kmsg */
358 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
360 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
362 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
363 if (m->signal_fd < 0)
366 r = sd_event_add_io(m->event, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m, &m->signal_event_source);
370 if (m->running_as == SYSTEMD_SYSTEM)
371 return enable_special_signals(m);
376 static int manager_default_environment(Manager *m) {
379 if (m->running_as == SYSTEMD_SYSTEM) {
380 /* The system manager always starts with a clean
381 * environment for its children. It does not import
382 * the kernel or the parents exported variables.
384 * The initial passed environ is untouched to keep
385 * /proc/self/environ valid; it is used for tagging
386 * the init process inside containers. */
387 m->environment = strv_new("PATH=" DEFAULT_PATH,
390 /* Import locale variables LC_*= from configuration */
391 locale_setup(&m->environment);
393 /* The user manager passes its own environment
394 * along to its children. */
395 m->environment = strv_copy(environ);
400 strv_sort(m->environment);
405 int manager_new(SystemdRunningAs running_as, bool reexecuting, Manager **_m) {
408 bool try_bus_connect = false;
411 assert(running_as >= 0);
412 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
414 m = new0(Manager, 1);
419 if (detect_container(NULL) <= 0)
420 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
423 m->running_as = running_as;
424 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
426 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
428 m->pin_cgroupfs_fd = m->notify_fd = m->signal_fd = m->time_change_fd = m->dev_autofs_fd = m->private_listen_fd = -1;
429 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
431 r = manager_default_environment(m);
435 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
439 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
443 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
447 r = hashmap_ensure_allocated(&m->watch_pids, trivial_hash_func, trivial_compare_func);
451 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
455 r = sd_event_default(&m->event);
459 r = manager_setup_signals(m);
463 r = manager_setup_cgroup(m);
467 r = manager_setup_notify(m);
471 r = manager_setup_time_change(m);
475 if (running_as == SYSTEMD_SYSTEM)
476 try_bus_connect = reexecuting;
477 else if (getenv("DBUS_SESSION_BUS_ADDRESS"))
478 try_bus_connect = true;
480 log_debug("Skipping DBus session bus connection attempt - no DBUS_SESSION_BUS_ADDRESS set...");
482 /* Try to connect to the busses, if possible. */
483 r = bus_init(m, try_bus_connect);
487 m->taint_usr = dir_is_empty("/usr") > 0;
497 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
503 while ((u = m->cleanup_queue)) {
504 assert(u->in_cleanup_queue);
514 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
515 GC_OFFSET_UNSURE, /* No clue */
516 GC_OFFSET_GOOD, /* We still need this unit */
517 GC_OFFSET_BAD, /* We don't need this unit anymore */
521 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
528 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
529 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
530 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
533 if (u->in_cleanup_queue)
536 if (unit_check_gc(u))
539 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
543 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
544 unit_gc_sweep(other, gc_marker);
546 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
549 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
556 /* We were unable to find anything out about this entry, so
557 * let's investigate it later */
558 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
559 unit_add_to_gc_queue(u);
563 /* We definitely know that this one is not useful anymore, so
564 * let's mark it for deletion */
565 u->gc_marker = gc_marker + GC_OFFSET_BAD;
566 unit_add_to_cleanup_queue(u);
570 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
573 static unsigned manager_dispatch_gc_queue(Manager *m) {
580 /* log_debug("Running GC..."); */
582 m->gc_marker += _GC_OFFSET_MAX;
583 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
586 gc_marker = m->gc_marker;
588 while ((u = m->gc_queue)) {
589 assert(u->in_gc_queue);
591 unit_gc_sweep(u, gc_marker);
593 LIST_REMOVE(gc_queue, m->gc_queue, u);
594 u->in_gc_queue = false;
598 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
599 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
600 log_debug_unit(u->id, "Collecting %s", u->id);
601 u->gc_marker = gc_marker + GC_OFFSET_BAD;
602 unit_add_to_cleanup_queue(u);
606 m->n_in_gc_queue = 0;
611 static void manager_clear_jobs_and_units(Manager *m) {
616 while ((u = hashmap_first(m->units)))
619 manager_dispatch_cleanup_queue(m);
621 assert(!m->load_queue);
622 assert(!m->run_queue);
623 assert(!m->dbus_unit_queue);
624 assert(!m->dbus_job_queue);
625 assert(!m->cleanup_queue);
626 assert(!m->gc_queue);
628 assert(hashmap_isempty(m->jobs));
629 assert(hashmap_isempty(m->units));
632 m->n_running_jobs = 0;
635 void manager_free(Manager *m) {
641 manager_clear_jobs_and_units(m);
643 for (c = 0; c < _UNIT_TYPE_MAX; c++)
644 if (unit_vtable[c]->shutdown)
645 unit_vtable[c]->shutdown(m);
647 /* If we reexecute ourselves, we keep the root cgroup
649 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
651 manager_undo_generators(m);
655 hashmap_free(m->units);
656 hashmap_free(m->jobs);
657 hashmap_free(m->watch_pids);
658 hashmap_free(m->watch_bus);
660 sd_event_source_unref(m->signal_event_source);
661 sd_event_source_unref(m->notify_event_source);
662 sd_event_source_unref(m->time_change_event_source);
663 sd_event_source_unref(m->jobs_in_progress_event_source);
664 sd_event_source_unref(m->idle_pipe_event_source);
666 if (m->signal_fd >= 0)
667 close_nointr_nofail(m->signal_fd);
668 if (m->notify_fd >= 0)
669 close_nointr_nofail(m->notify_fd);
670 if (m->time_change_fd >= 0)
671 close_nointr_nofail(m->time_change_fd);
673 manager_close_idle_pipe(m);
675 sd_event_unref(m->event);
677 free(m->notify_socket);
679 lookup_paths_free(&m->lookup_paths);
680 strv_free(m->environment);
682 hashmap_free(m->cgroup_unit);
683 set_free_free(m->unit_path_cache);
685 free(m->switch_root);
686 free(m->switch_root_init);
688 for (i = 0; i < RLIMIT_NLIMITS; i++)
691 assert(hashmap_isempty(m->units_requiring_mounts_for));
692 hashmap_free(m->units_requiring_mounts_for);
697 int manager_enumerate(Manager *m) {
703 /* Let's ask every type to load all units from disk/kernel
704 * that it might know */
705 for (c = 0; c < _UNIT_TYPE_MAX; c++)
706 if (unit_vtable[c]->enumerate) {
707 q = unit_vtable[c]->enumerate(m);
712 manager_dispatch_load_queue(m);
716 static int manager_coldplug(Manager *m) {
724 /* Then, let's set up their initial state. */
725 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
731 if ((q = unit_coldplug(u)) < 0)
738 static void manager_build_unit_path_cache(Manager *m) {
740 _cleanup_free_ DIR *d = NULL;
745 set_free_free(m->unit_path_cache);
747 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
748 if (!m->unit_path_cache) {
749 log_error("Failed to allocate unit path cache.");
753 /* This simply builds a list of files we know exist, so that
754 * we don't always have to go to disk */
756 STRV_FOREACH(i, m->lookup_paths.unit_path) {
762 log_error("Failed to open directory %s: %m", *i);
766 while ((de = readdir(d))) {
769 if (ignore_file(de->d_name))
772 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
778 r = set_consume(m->unit_path_cache, p);
790 log_error("Failed to build unit path cache: %s", strerror(-r));
792 set_free_free(m->unit_path_cache);
793 m->unit_path_cache = NULL;
797 static int manager_distribute_fds(Manager *m, FDSet *fds) {
804 HASHMAP_FOREACH(u, m->units, i) {
806 if (fdset_size(fds) <= 0)
809 if (UNIT_VTABLE(u)->distribute_fds) {
810 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
819 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
824 dual_timestamp_get(&m->generators_start_timestamp);
825 manager_run_generators(m);
826 dual_timestamp_get(&m->generators_finish_timestamp);
828 r = lookup_paths_init(
829 &m->lookup_paths, m->running_as, true,
830 m->generator_unit_path,
831 m->generator_unit_path_early,
832 m->generator_unit_path_late);
836 manager_build_unit_path_cache(m);
838 /* If we will deserialize make sure that during enumeration
839 * this is already known, so we increase the counter here
844 /* First, enumerate what we can from all config files */
845 dual_timestamp_get(&m->units_load_start_timestamp);
846 r = manager_enumerate(m);
847 dual_timestamp_get(&m->units_load_finish_timestamp);
849 /* Second, deserialize if there is something to deserialize */
851 q = manager_deserialize(m, serialization, fds);
856 /* Any fds left? Find some unit which wants them. This is
857 * useful to allow container managers to pass some file
858 * descriptors to us pre-initialized. This enables
859 * socket-based activation of entire containers. */
860 if (fdset_size(fds) > 0) {
861 q = manager_distribute_fds(m, fds);
866 /* Third, fire things up! */
867 q = manager_coldplug(m);
872 assert(m->n_reloading > 0);
875 /* Let's wait for the UnitNew/JobNew messages being
876 * sent, before we notify that the reload is
878 m->send_reloading_done = true;
884 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
889 assert(type < _JOB_TYPE_MAX);
891 assert(mode < _JOB_MODE_MAX);
893 if (mode == JOB_ISOLATE && type != JOB_START) {
894 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
898 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
899 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
903 log_debug_unit(unit->id,
904 "Trying to enqueue job %s/%s/%s", unit->id,
905 job_type_to_string(type), job_mode_to_string(mode));
907 job_type_collapse(&type, unit);
909 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
913 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
914 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
915 mode == JOB_IGNORE_DEPENDENCIES, e);
919 if (mode == JOB_ISOLATE) {
920 r = transaction_add_isolate_jobs(tr, m);
925 r = transaction_activate(tr, m, mode, e);
929 log_debug_unit(unit->id,
930 "Enqueued job %s/%s as %u", unit->id,
931 job_type_to_string(type), (unsigned) tr->anchor_job->id);
934 *_ret = tr->anchor_job;
936 transaction_free(tr);
940 transaction_abort(tr);
941 transaction_free(tr);
945 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
950 assert(type < _JOB_TYPE_MAX);
952 assert(mode < _JOB_MODE_MAX);
954 r = manager_load_unit(m, name, NULL, NULL, &unit);
958 return manager_add_job(m, type, unit, mode, override, e, _ret);
961 Job *manager_get_job(Manager *m, uint32_t id) {
964 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
967 Unit *manager_get_unit(Manager *m, const char *name) {
971 return hashmap_get(m->units, name);
974 unsigned manager_dispatch_load_queue(Manager *m) {
980 /* Make sure we are not run recursively */
981 if (m->dispatching_load_queue)
984 m->dispatching_load_queue = true;
986 /* Dispatches the load queue. Takes a unit from the queue and
987 * tries to load its data until the queue is empty */
989 while ((u = m->load_queue)) {
990 assert(u->in_load_queue);
996 m->dispatching_load_queue = false;
1000 int manager_load_unit_prepare(
1012 assert(name || path);
1014 /* This will prepare the unit for loading, but not actually
1015 * load anything from disk. */
1017 if (path && !is_path(path))
1018 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1021 name = path_get_file_name(path);
1023 t = unit_name_to_type(name);
1025 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false))
1026 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1028 ret = manager_get_unit(m, name);
1034 ret = unit_new(m, unit_vtable[t]->object_size);
1039 ret->fragment_path = strdup(path);
1040 if (!ret->fragment_path) {
1046 r = unit_add_name(ret, name);
1052 unit_add_to_load_queue(ret);
1053 unit_add_to_dbus_queue(ret);
1054 unit_add_to_gc_queue(ret);
1062 int manager_load_unit(
1073 /* This will load the service information files, but not actually
1074 * start any services or anything. */
1076 r = manager_load_unit_prepare(m, name, path, e, _ret);
1080 manager_dispatch_load_queue(m);
1083 *_ret = unit_follow_merge(*_ret);
1088 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1095 HASHMAP_FOREACH(j, s->jobs, i)
1096 job_dump(j, f, prefix);
1099 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1107 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1109 unit_dump(u, f, prefix);
1112 void manager_clear_jobs(Manager *m) {
1117 while ((j = hashmap_first(m->jobs)))
1118 /* No need to recurse. We're cancelling all jobs. */
1119 job_finish_and_invalidate(j, JOB_CANCELED, false);
1122 static unsigned manager_dispatch_run_queue(Manager *m) {
1126 if (m->dispatching_run_queue)
1129 m->dispatching_run_queue = true;
1131 while ((j = m->run_queue)) {
1132 assert(j->installed);
1133 assert(j->in_run_queue);
1135 job_run_and_invalidate(j);
1139 m->dispatching_run_queue = false;
1141 if (m->n_running_jobs > 0)
1142 manager_watch_jobs_in_progress(m);
1144 if (m->n_on_console > 0)
1145 manager_watch_idle_pipe(m);
1150 static 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;
1178 if (m->send_reloading_done) {
1179 m->send_reloading_done = false;
1181 bus_manager_send_reloading(m, false);
1184 if (m->queued_message)
1185 bus_send_queued_message(m);
1190 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1191 Manager *m = userdata;
1195 assert(m->notify_fd == fd);
1197 if (revents != EPOLLIN) {
1198 log_warning("Got unexpected poll event for notify fd.");
1204 struct iovec iovec = {
1206 .iov_len = sizeof(buf)-1,
1210 struct cmsghdr cmsghdr;
1211 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1214 struct msghdr msghdr = {
1217 .msg_control = &control,
1218 .msg_controllen = sizeof(control),
1220 struct ucred *ucred;
1222 _cleanup_strv_free_ char **tags = NULL;
1224 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1229 if (errno == EAGAIN || errno == EINTR)
1235 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1236 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1237 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1238 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1239 log_warning("Received notify message without credentials. Ignoring.");
1243 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1245 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1247 u = manager_get_unit_by_pid(m, ucred->pid);
1249 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1254 assert((size_t) n < sizeof(buf));
1256 tags = strv_split(buf, "\n\r");
1260 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1262 if (UNIT_VTABLE(u)->notify_message)
1263 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1269 static int manager_dispatch_sigchld(Manager *m) {
1277 /* First we call waitd() for a PID and do not reap the
1278 * zombie. That way we can still access /proc/$PID for
1279 * it while it is a zombie. */
1280 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1282 if (errno == ECHILD)
1294 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1295 _cleanup_free_ char *name = NULL;
1297 get_process_comm(si.si_pid, &name);
1298 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1301 /* Let's flush any message the dying child might still
1302 * have queued for us. This ensures that the process
1303 * still exists in /proc so that we can figure out
1304 * which cgroup and hence unit it belongs to. */
1305 r = manager_dispatch_notify_fd(m->notify_event_source, m->notify_fd, EPOLLIN, m);
1309 /* And now figure out the unit this belongs to */
1310 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1312 u = manager_get_unit_by_pid(m, si.si_pid);
1314 /* And now, we actually reap the zombie. */
1315 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1322 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1325 log_debug("Child %lu died (code=%s, status=%i/%s)",
1326 (long unsigned) si.si_pid,
1327 sigchld_code_to_string(si.si_code),
1329 strna(si.si_code == CLD_EXITED
1330 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1331 : signal_to_string(si.si_status)));
1336 log_debug_unit(u->id,
1337 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1339 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1340 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1346 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1347 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1350 log_debug_unit(name, "Activating special unit %s", name);
1352 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1354 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1359 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1360 Manager *m = userdata;
1362 struct signalfd_siginfo sfsi;
1363 bool sigchld = false;
1366 assert(m->signal_fd == fd);
1368 if (revents != EPOLLIN) {
1369 log_warning("Got unexpected events from signal file descriptor.");
1374 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1375 if (n != sizeof(sfsi)) {
1380 if (errno == EINTR || errno == EAGAIN)
1386 if (sfsi.ssi_pid > 0) {
1389 get_process_comm(sfsi.ssi_pid, &p);
1391 log_debug("Received SIG%s from PID %lu (%s).",
1392 signal_to_string(sfsi.ssi_signo),
1393 (unsigned long) sfsi.ssi_pid, strna(p));
1396 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1398 switch (sfsi.ssi_signo) {
1405 if (m->running_as == SYSTEMD_SYSTEM) {
1406 /* This is for compatibility with the
1407 * original sysvinit */
1408 m->exit_code = MANAGER_REEXECUTE;
1415 if (m->running_as == SYSTEMD_SYSTEM) {
1416 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1420 /* Run the exit target if there is one, if not, just exit. */
1421 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1422 m->exit_code = MANAGER_EXIT;
1429 if (m->running_as == SYSTEMD_SYSTEM)
1430 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1432 /* This is a nop on non-init */
1436 if (m->running_as == SYSTEMD_SYSTEM)
1437 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1439 /* This is a nop on non-init */
1445 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1447 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1448 log_info("Trying to reconnect to bus...");
1452 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1453 log_info("Loading D-Bus service...");
1454 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1461 _cleanup_free_ char *dump = NULL;
1462 _cleanup_fclose_ FILE *f = NULL;
1465 f = open_memstream(&dump, &size);
1467 log_warning("Failed to allocate memory stream.");
1471 manager_dump_units(m, f, "\t");
1472 manager_dump_jobs(m, f, "\t");
1475 log_warning("Failed to write status stream");
1479 log_dump(LOG_INFO, dump);
1484 m->exit_code = MANAGER_RELOAD;
1489 /* Starting SIGRTMIN+0 */
1490 static const char * const target_table[] = {
1491 [0] = SPECIAL_DEFAULT_TARGET,
1492 [1] = SPECIAL_RESCUE_TARGET,
1493 [2] = SPECIAL_EMERGENCY_TARGET,
1494 [3] = SPECIAL_HALT_TARGET,
1495 [4] = SPECIAL_POWEROFF_TARGET,
1496 [5] = SPECIAL_REBOOT_TARGET,
1497 [6] = SPECIAL_KEXEC_TARGET
1500 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1501 static const ManagerExitCode code_table[] = {
1503 [1] = MANAGER_POWEROFF,
1504 [2] = MANAGER_REBOOT,
1508 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1509 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1510 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1511 manager_start_target(m, target_table[idx],
1512 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1516 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1517 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1518 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1522 switch (sfsi.ssi_signo - SIGRTMIN) {
1525 log_debug("Enabling showing of status.");
1526 manager_set_show_status(m, true);
1530 log_debug("Disabling showing of status.");
1531 manager_set_show_status(m, false);
1535 log_set_max_level(LOG_DEBUG);
1536 log_notice("Setting log level to debug.");
1540 log_set_max_level(LOG_INFO);
1541 log_notice("Setting log level to info.");
1545 if (m->running_as == SYSTEMD_USER) {
1546 m->exit_code = MANAGER_EXIT;
1550 /* This is a nop on init */
1554 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1555 log_notice("Setting log target to journal-or-kmsg.");
1559 log_set_target(LOG_TARGET_CONSOLE);
1560 log_notice("Setting log target to console.");
1564 log_set_target(LOG_TARGET_KMSG);
1565 log_notice("Setting log target to kmsg.");
1569 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1570 log_notice("Setting log target to syslog-or-kmsg.");
1574 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1581 return manager_dispatch_sigchld(m);
1586 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1587 Manager *m = userdata;
1592 assert(m->time_change_fd == fd);
1594 log_struct(LOG_INFO,
1595 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1596 "MESSAGE=Time has been changed",
1599 /* Restart the watch */
1600 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1602 close_nointr_nofail(m->time_change_fd);
1603 m->time_change_fd = -1;
1605 manager_setup_time_change(m);
1607 HASHMAP_FOREACH(u, m->units, i)
1608 if (UNIT_VTABLE(u)->time_change)
1609 UNIT_VTABLE(u)->time_change(u);
1614 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1615 Manager *m = userdata;
1618 assert(m->idle_pipe[2] == fd);
1620 m->no_console_output = m->n_on_console > 0;
1622 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1623 manager_close_idle_pipe(m);
1628 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1629 Manager *m = userdata;
1633 manager_print_jobs_in_progress(m);
1637 int manager_loop(Manager *m) {
1640 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1643 m->exit_code = MANAGER_RUNNING;
1645 /* Release the path cache */
1646 set_free_free(m->unit_path_cache);
1647 m->unit_path_cache = NULL;
1649 manager_check_finished(m);
1651 /* There might still be some zombies hanging around from
1652 * before we were exec()'ed. Let's reap them. */
1653 r = manager_dispatch_sigchld(m);
1657 while (m->exit_code == MANAGER_RUNNING) {
1660 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1663 if (!ratelimit_test(&rl)) {
1664 /* Yay, something is going seriously wrong, pause a little */
1665 log_warning("Looping too fast. Throttling execution a little.");
1670 if (manager_dispatch_load_queue(m) > 0)
1673 if (manager_dispatch_gc_queue(m) > 0)
1676 if (manager_dispatch_cleanup_queue(m) > 0)
1679 if (manager_dispatch_cgroup_queue(m) > 0)
1682 if (manager_dispatch_run_queue(m) > 0)
1685 if (manager_dispatch_dbus_queue(m) > 0)
1688 /* Sleep for half the watchdog time */
1689 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1690 wait_usec = m->runtime_watchdog / 2;
1694 wait_usec = (usec_t) -1;
1696 r = sd_event_run(m->event, wait_usec);
1698 log_error("Failed to run event loop: %s", strerror(-r));
1703 return m->exit_code;
1706 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1707 _cleanup_free_ char *n = NULL;
1715 r = unit_name_from_dbus_path(s, &n);
1719 r = manager_load_unit(m, n, NULL, e, &u);
1728 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1738 p = startswith(s, "/org/freedesktop/systemd1/job/");
1742 r = safe_atou(p, &id);
1746 j = manager_get_job(m, id);
1755 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1761 audit_fd = get_audit_fd();
1765 /* Don't generate audit events if the service was already
1766 * started and we're just deserializing */
1767 if (m->n_reloading > 0)
1770 if (m->running_as != SYSTEMD_SYSTEM)
1773 if (u->type != UNIT_SERVICE)
1776 p = unit_name_to_prefix_and_instance(u->id);
1778 log_error_unit(u->id,
1779 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1783 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1784 if (errno == EPERM) {
1785 /* We aren't allowed to send audit messages?
1786 * Then let's not retry again. */
1789 log_warning("Failed to send audit message: %m");
1797 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1799 union sockaddr_union sa;
1801 char *message = NULL;
1803 /* Don't generate plymouth events if the service was already
1804 * started and we're just deserializing */
1805 if (m->n_reloading > 0)
1808 if (m->running_as != SYSTEMD_SYSTEM)
1811 if (detect_container(NULL) > 0)
1814 if (u->type != UNIT_SERVICE &&
1815 u->type != UNIT_MOUNT &&
1816 u->type != UNIT_SWAP)
1819 /* We set SOCK_NONBLOCK here so that we rather drop the
1820 * message then wait for plymouth */
1821 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1823 log_error("socket() failed: %m");
1828 sa.sa.sa_family = AF_UNIX;
1829 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1830 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1832 if (errno != EPIPE &&
1835 errno != ECONNREFUSED &&
1836 errno != ECONNRESET &&
1837 errno != ECONNABORTED)
1838 log_error("connect() failed: %m");
1843 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1849 if (write(fd, message, n + 1) != n + 1) {
1851 if (errno != EPIPE &&
1854 errno != ECONNREFUSED &&
1855 errno != ECONNRESET &&
1856 errno != ECONNABORTED)
1857 log_error("Failed to write Plymouth message: %m");
1864 close_nointr_nofail(fd);
1869 void manager_dispatch_bus_name_owner_changed(
1872 const char* old_owner,
1873 const char *new_owner) {
1880 u = hashmap_get(m->watch_bus, name);
1884 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1887 int manager_open_serialization(Manager *m, FILE **_f) {
1894 if (m->running_as == SYSTEMD_SYSTEM)
1895 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1897 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1902 RUN_WITH_UMASK(0077) {
1903 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1913 log_debug("Serializing state to %s", path);
1916 f = fdopen(fd, "w+");
1925 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
1938 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1939 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1940 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1941 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1943 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1944 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1945 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1946 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1949 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1950 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1951 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
1952 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
1953 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
1954 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
1955 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
1956 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
1959 if (!switching_root) {
1960 STRV_FOREACH(e, m->environment) {
1961 _cleanup_free_ char *ce;
1965 fprintf(f, "env=%s\n", *e);
1969 bus_serialize(m, f);
1973 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1977 if (!unit_can_serialize(u))
1984 r = unit_serialize(u, f, fds, !switching_root);
1991 assert(m->n_reloading > 0);
1997 r = bus_fdset_add_all(m, fds);
2004 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2010 log_debug("Deserializing state...");
2015 char line[LINE_MAX], *l;
2017 if (!fgets(line, sizeof(line), f)) {
2032 if (startswith(l, "current-job-id=")) {
2035 if (safe_atou32(l+15, &id) < 0)
2036 log_debug("Failed to parse current job id value %s", l+15);
2038 m->current_job_id = MAX(m->current_job_id, id);
2040 } else if (startswith(l, "n-installed-jobs=")) {
2043 if (safe_atou32(l+17, &n) < 0)
2044 log_debug("Failed to parse installed jobs counter %s", l+17);
2046 m->n_installed_jobs += n;
2048 } else if (startswith(l, "n-failed-jobs=")) {
2051 if (safe_atou32(l+14, &n) < 0)
2052 log_debug("Failed to parse failed jobs counter %s", l+14);
2054 m->n_failed_jobs += n;
2056 } else if (startswith(l, "taint-usr=")) {
2059 if ((b = parse_boolean(l+10)) < 0)
2060 log_debug("Failed to parse taint /usr flag %s", l+10);
2062 m->taint_usr = m->taint_usr || b;
2064 } else if (startswith(l, "firmware-timestamp="))
2065 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2066 else if (startswith(l, "loader-timestamp="))
2067 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2068 else if (startswith(l, "kernel-timestamp="))
2069 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2070 else if (startswith(l, "initrd-timestamp="))
2071 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2072 else if (startswith(l, "userspace-timestamp="))
2073 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2074 else if (startswith(l, "finish-timestamp="))
2075 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2076 else if (startswith(l, "security-start-timestamp="))
2077 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2078 else if (startswith(l, "security-finish-timestamp="))
2079 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2080 else if (startswith(l, "generators-start-timestamp="))
2081 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2082 else if (startswith(l, "generators-finish-timestamp="))
2083 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2084 else if (startswith(l, "units-load-start-timestamp="))
2085 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2086 else if (startswith(l, "units-load-finish-timestamp="))
2087 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2088 else if (startswith(l, "env=")) {
2089 _cleanup_free_ char *uce = NULL;
2092 uce = cunescape(l+4);
2098 e = strv_env_set(m->environment, uce);
2104 strv_free(m->environment);
2106 } else if (bus_deserialize_item(m, l) == 0)
2107 log_debug("Unknown serialization item '%s'", l);
2112 char name[UNIT_NAME_MAX+2];
2115 if (!fgets(name, sizeof(name), f)) {
2126 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2130 r = unit_deserialize(u, f, fds);
2141 assert(m->n_reloading > 0);
2147 int manager_reload(Manager *m) {
2149 _cleanup_fclose_ FILE *f = NULL;
2150 _cleanup_fdset_free_ FDSet *fds = NULL;
2154 r = manager_open_serialization(m, &f);
2159 bus_manager_send_reloading(m, true);
2167 r = manager_serialize(m, f, fds, false);
2173 if (fseeko(f, 0, SEEK_SET) < 0) {
2178 /* From here on there is no way back. */
2179 manager_clear_jobs_and_units(m);
2180 manager_undo_generators(m);
2181 lookup_paths_free(&m->lookup_paths);
2183 /* Find new unit paths */
2184 manager_run_generators(m);
2186 q = lookup_paths_init(
2187 &m->lookup_paths, m->running_as, true,
2188 m->generator_unit_path,
2189 m->generator_unit_path_early,
2190 m->generator_unit_path_late);
2194 manager_build_unit_path_cache(m);
2196 /* First, enumerate what we can from all config files */
2197 q = manager_enumerate(m);
2201 /* Second, deserialize our stored data */
2202 q = manager_deserialize(m, f, fds);
2209 /* Third, fire things up! */
2210 q = manager_coldplug(m);
2214 assert(m->n_reloading > 0);
2217 m->send_reloading_done = true;
2222 static bool manager_is_booting_or_shutting_down(Manager *m) {
2227 /* Is the initial job still around? */
2228 if (manager_get_job(m, m->default_unit_job_id))
2231 /* Is there a job for the shutdown target? */
2232 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2239 bool manager_is_reloading_or_reexecuting(Manager *m) {
2242 return m->n_reloading != 0;
2245 void manager_reset_failed(Manager *m) {
2251 HASHMAP_FOREACH(u, m->units, i)
2252 unit_reset_failed(u);
2255 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2261 /* Returns true if the unit is inactive or going down */
2262 u = manager_get_unit(m, name);
2266 return unit_inactive_or_pending(u);
2269 void manager_check_finished(Manager *m) {
2270 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2271 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2275 if (m->n_running_jobs == 0)
2276 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2278 if (hashmap_size(m->jobs) > 0 && m->jobs_in_progress_event_source) {
2279 sd_event_source_set_time(m->jobs_in_progress_event_source, JOBS_IN_PROGRESS_PERIOD_SEC);
2283 /* Notify Type=idle units that we are done now */
2284 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2285 manager_close_idle_pipe(m);
2287 /* Turn off confirm spawn now */
2288 m->confirm_spawn = false;
2290 if (dual_timestamp_is_set(&m->finish_timestamp))
2293 dual_timestamp_get(&m->finish_timestamp);
2295 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2297 /* Note that m->kernel_usec.monotonic is always at 0,
2298 * and m->firmware_usec.monotonic and
2299 * m->loader_usec.monotonic should be considered
2300 * negative values. */
2302 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2303 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2304 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2305 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2307 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2309 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2310 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2312 if (!log_on_console())
2313 log_struct(LOG_INFO,
2314 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2315 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2316 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2317 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2318 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2319 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2320 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2321 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2322 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2325 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2328 if (!log_on_console())
2329 log_struct(LOG_INFO,
2330 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2331 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2332 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2333 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2334 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2335 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2336 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2340 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2341 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2343 if (!log_on_console())
2344 log_struct(LOG_INFO,
2345 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2346 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2347 "MESSAGE=Startup finished in %s.",
2348 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2352 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2355 "READY=1\nSTATUS=Startup finished in %s.",
2356 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2359 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2370 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2372 p = strappend("/run/systemd/", name);
2376 r = mkdir_p_label(p, 0755);
2378 log_error("Failed to create generator directory %s: %s",
2384 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2389 log_error("Failed to create generator directory %s: %m",
2400 static void trim_generator_dir(Manager *m, char **generator) {
2407 if (rmdir(*generator) >= 0) {
2415 void manager_run_generators(Manager *m) {
2416 _cleanup_closedir_ DIR *d = NULL;
2417 const char *generator_path;
2418 const char *argv[5];
2423 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2424 d = opendir(generator_path);
2426 if (errno == ENOENT)
2429 log_error("Failed to enumerate generator directory %s: %m",
2434 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2438 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2442 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2446 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2447 argv[1] = m->generator_unit_path;
2448 argv[2] = m->generator_unit_path_early;
2449 argv[3] = m->generator_unit_path_late;
2452 RUN_WITH_UMASK(0022)
2453 execute_directory(generator_path, d, (char**) argv);
2456 trim_generator_dir(m, &m->generator_unit_path);
2457 trim_generator_dir(m, &m->generator_unit_path_early);
2458 trim_generator_dir(m, &m->generator_unit_path_late);
2461 static void remove_generator_dir(Manager *m, char **generator) {
2468 strv_remove(m->lookup_paths.unit_path, *generator);
2469 rm_rf(*generator, false, true, false);
2475 void manager_undo_generators(Manager *m) {
2478 remove_generator_dir(m, &m->generator_unit_path);
2479 remove_generator_dir(m, &m->generator_unit_path_early);
2480 remove_generator_dir(m, &m->generator_unit_path_late);
2483 int manager_environment_add(Manager *m, char **minus, char **plus) {
2484 char **a = NULL, **b = NULL, **l;
2489 if (!strv_isempty(minus)) {
2490 a = strv_env_delete(l, 1, minus);
2497 if (!strv_isempty(plus)) {
2498 b = strv_env_merge(2, l, plus);
2505 if (m->environment != l)
2506 strv_free(m->environment);
2512 m->environment = strv_sort(l);
2516 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2521 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2522 if (!default_rlimit[i])
2525 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2533 void manager_recheck_journal(Manager *m) {
2538 if (m->running_as != SYSTEMD_SYSTEM)
2541 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2542 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2543 log_close_journal();
2547 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2548 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2549 log_close_journal();
2553 /* Hmm, OK, so the socket is fully up and the service is up
2554 * too, then let's make use of the thing. */
2558 void manager_set_show_status(Manager *m, bool b) {
2561 if (m->running_as != SYSTEMD_SYSTEM)
2567 touch("/run/systemd/show-status");
2569 unlink("/run/systemd/show-status");
2572 static bool manager_get_show_status(Manager *m) {
2575 if (m->running_as != SYSTEMD_SYSTEM)
2578 if (m->no_console_output)
2584 /* If Plymouth is running make sure we show the status, so
2585 * that there's something nice to see when people press Esc */
2587 return plymouth_running();
2590 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2593 if (!manager_get_show_status(m))
2596 /* XXX We should totally drop the check for ephemeral here
2597 * and thus effectively make 'Type=idle' pointless. */
2598 if (ephemeral && m->n_on_console > 0)
2601 if (!manager_is_booting_or_shutting_down(m))
2604 va_start(ap, format);
2605 status_vprintf(status, true, ephemeral, format, ap);
2609 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2610 _cleanup_free_ char *p = NULL;
2618 p = unit_name_from_path(path, suffix);
2622 found = manager_get_unit(m, p);
2632 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2633 char p[strlen(path)+1];
2639 path_kill_slashes(p);
2641 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);