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);
98 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
100 static int manager_setup_notify(Manager *m) {
103 struct sockaddr_un un;
105 .sa.sa_family = AF_UNIX,
109 m->notify_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
110 if (m->notify_fd < 0) {
111 log_error("Failed to allocate notification socket: %m");
115 if (getpid() != 1 || detect_container(NULL) > 0)
116 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
118 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
119 sa.un.sun_path[0] = 0;
121 r = bind(m->notify_fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
123 log_error("bind() failed: %m");
127 r = setsockopt(m->notify_fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
129 log_error("SO_PASSCRED failed: %m");
133 r = sd_event_add_io(m->event, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m, &m->notify_event_source);
135 log_error("Failed to allocate notify event source: %s", strerror(-r));
139 sa.un.sun_path[0] = '@';
140 m->notify_socket = strdup(sa.un.sun_path);
141 if (!m->notify_socket)
144 log_debug("Using notification socket %s", m->notify_socket);
149 static int manager_watch_jobs_in_progress(Manager *m) {
152 if (m->jobs_in_progress_event_source)
155 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);
158 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
160 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
163 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
164 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
168 p = mempset(p, ' ', pos-2);
169 p = stpcpy(p, ANSI_RED_ON);
173 if (pos > 0 && pos <= width) {
174 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
178 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
181 p = stpcpy(p, ANSI_RED_ON);
184 p = mempset(p, ' ', width-1-pos);
185 strcpy(p, ANSI_HIGHLIGHT_OFF);
189 static void manager_print_jobs_in_progress(Manager *m) {
190 _cleanup_free_ char *job_of_n = NULL;
193 unsigned counter = 0, print_nr;
194 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
199 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
201 HASHMAP_FOREACH(j, m->jobs, i)
202 if (j->state == JOB_RUNNING && counter++ == print_nr)
205 /* m->n_running_jobs must be consistent with the contents of m->jobs,
206 * so the above loop must have succeeded in finding j. */
207 assert(counter == print_nr + 1);
210 cylon_pos = m->jobs_in_progress_iteration % 14;
212 cylon_pos = 14 - cylon_pos;
213 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
215 if (m->n_running_jobs > 1)
216 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
219 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
220 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
222 m->jobs_in_progress_iteration++;
225 static int manager_watch_idle_pipe(Manager *m) {
230 if (m->idle_pipe_event_source)
233 if (m->idle_pipe[2] < 0)
236 r = sd_event_add_io(m->event, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m, &m->idle_pipe_event_source);
238 log_error("Failed to watch idle pipe: %s", strerror(-r));
245 static void manager_close_idle_pipe(Manager *m) {
248 close_pipe(m->idle_pipe);
249 close_pipe(m->idle_pipe + 2);
252 static int manager_setup_time_change(Manager *m) {
255 /* We only care for the cancellation event, hence we set the
256 * timeout to the latest possible value. */
257 struct itimerspec its = {
258 .it_value.tv_sec = TIME_T_MAX,
262 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
264 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
265 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
267 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
268 if (m->time_change_fd < 0) {
269 log_error("Failed to create timerfd: %m");
273 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
274 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
275 close_nointr_nofail(m->time_change_fd);
276 m->time_change_fd = -1;
280 r = sd_event_add_io(m->event, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m, &m->time_change_event_source);
282 log_error("Failed to create time change event source: %s", strerror(-r));
286 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
291 static int enable_special_signals(Manager *m) {
292 _cleanup_close_ int fd = -1;
296 /* Enable that we get SIGINT on control-alt-del. In containers
297 * this will fail with EPERM (older) or EINVAL (newer), so
299 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
300 log_warning("Failed to enable ctrl-alt-del handling: %m");
302 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
304 /* Support systems without virtual console */
306 log_warning("Failed to open /dev/tty0: %m");
308 /* Enable that we get SIGWINCH on kbrequest */
309 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
310 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
316 static int manager_setup_signals(Manager *m) {
317 struct sigaction sa = {
318 .sa_handler = SIG_DFL,
319 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
326 /* We are not interested in SIGSTOP and friends. */
327 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
329 assert_se(sigemptyset(&mask) == 0);
331 sigset_add_many(&mask,
332 SIGCHLD, /* Child died */
333 SIGTERM, /* Reexecute daemon */
334 SIGHUP, /* Reload configuration */
335 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
336 SIGUSR2, /* systemd: dump status */
337 SIGINT, /* Kernel sends us this on control-alt-del */
338 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
339 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
340 SIGRTMIN+0, /* systemd: start default.target */
341 SIGRTMIN+1, /* systemd: isolate rescue.target */
342 SIGRTMIN+2, /* systemd: isolate emergency.target */
343 SIGRTMIN+3, /* systemd: start halt.target */
344 SIGRTMIN+4, /* systemd: start poweroff.target */
345 SIGRTMIN+5, /* systemd: start reboot.target */
346 SIGRTMIN+6, /* systemd: start kexec.target */
347 SIGRTMIN+13, /* systemd: Immediate halt */
348 SIGRTMIN+14, /* systemd: Immediate poweroff */
349 SIGRTMIN+15, /* systemd: Immediate reboot */
350 SIGRTMIN+16, /* systemd: Immediate kexec */
351 SIGRTMIN+20, /* systemd: enable status messages */
352 SIGRTMIN+21, /* systemd: disable status messages */
353 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
354 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
355 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
356 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
357 SIGRTMIN+27, /* systemd: set log target to console */
358 SIGRTMIN+28, /* systemd: set log target to kmsg */
359 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
361 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
363 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
364 if (m->signal_fd < 0)
367 r = sd_event_add_io(m->event, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m, &m->signal_event_source);
371 /* Process signals a bit earlier than the rest of things */
372 r = sd_event_source_set_priority(m->signal_event_source, -5);
376 if (m->running_as == SYSTEMD_SYSTEM)
377 return enable_special_signals(m);
382 static int manager_default_environment(Manager *m) {
385 if (m->running_as == SYSTEMD_SYSTEM) {
386 /* The system manager always starts with a clean
387 * environment for its children. It does not import
388 * the kernel or the parents exported variables.
390 * The initial passed environ is untouched to keep
391 * /proc/self/environ valid; it is used for tagging
392 * the init process inside containers. */
393 m->environment = strv_new("PATH=" DEFAULT_PATH,
396 /* Import locale variables LC_*= from configuration */
397 locale_setup(&m->environment);
399 /* The user manager passes its own environment
400 * along to its children. */
401 m->environment = strv_copy(environ);
406 strv_sort(m->environment);
411 int manager_new(SystemdRunningAs running_as, bool reexecuting, Manager **_m) {
414 bool try_bus_connect = false;
417 assert(running_as >= 0);
418 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
420 m = new0(Manager, 1);
425 if (detect_container(NULL) <= 0)
426 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
429 m->running_as = running_as;
430 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
432 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
434 m->pin_cgroupfs_fd = m->notify_fd = m->signal_fd = m->time_change_fd = m->dev_autofs_fd = m->private_listen_fd = -1;
435 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
437 r = manager_default_environment(m);
441 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
445 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
449 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
453 r = hashmap_ensure_allocated(&m->watch_pids, trivial_hash_func, trivial_compare_func);
457 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
461 r = sd_event_default(&m->event);
465 r = sd_event_add_defer(m->event, manager_dispatch_run_queue, m, &m->run_queue_event_source);
469 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
473 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
477 r = manager_setup_signals(m);
481 r = manager_setup_cgroup(m);
485 r = manager_setup_notify(m);
489 r = manager_setup_time_change(m);
493 if (running_as == SYSTEMD_SYSTEM)
494 try_bus_connect = reexecuting;
495 else if (getenv("DBUS_SESSION_BUS_ADDRESS"))
496 try_bus_connect = true;
498 log_debug("Skipping DBus session bus connection attempt - no DBUS_SESSION_BUS_ADDRESS set...");
500 /* Try to connect to the busses, if possible. */
501 r = bus_init(m, try_bus_connect);
505 m->taint_usr = dir_is_empty("/usr") > 0;
515 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
521 while ((u = m->cleanup_queue)) {
522 assert(u->in_cleanup_queue);
532 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
533 GC_OFFSET_UNSURE, /* No clue */
534 GC_OFFSET_GOOD, /* We still need this unit */
535 GC_OFFSET_BAD, /* We don't need this unit anymore */
539 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
546 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
547 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
548 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
551 if (u->in_cleanup_queue)
554 if (unit_check_gc(u))
557 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
561 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
562 unit_gc_sweep(other, gc_marker);
564 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
567 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
574 /* We were unable to find anything out about this entry, so
575 * let's investigate it later */
576 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
577 unit_add_to_gc_queue(u);
581 /* We definitely know that this one is not useful anymore, so
582 * let's mark it for deletion */
583 u->gc_marker = gc_marker + GC_OFFSET_BAD;
584 unit_add_to_cleanup_queue(u);
588 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
591 static unsigned manager_dispatch_gc_queue(Manager *m) {
598 /* log_debug("Running GC..."); */
600 m->gc_marker += _GC_OFFSET_MAX;
601 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
604 gc_marker = m->gc_marker;
606 while ((u = m->gc_queue)) {
607 assert(u->in_gc_queue);
609 unit_gc_sweep(u, gc_marker);
611 LIST_REMOVE(gc_queue, m->gc_queue, u);
612 u->in_gc_queue = false;
616 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
617 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
618 log_debug_unit(u->id, "Collecting %s", u->id);
619 u->gc_marker = gc_marker + GC_OFFSET_BAD;
620 unit_add_to_cleanup_queue(u);
624 m->n_in_gc_queue = 0;
629 static void manager_clear_jobs_and_units(Manager *m) {
634 while ((u = hashmap_first(m->units)))
637 manager_dispatch_cleanup_queue(m);
639 assert(!m->load_queue);
640 assert(!m->run_queue);
641 assert(!m->dbus_unit_queue);
642 assert(!m->dbus_job_queue);
643 assert(!m->cleanup_queue);
644 assert(!m->gc_queue);
646 assert(hashmap_isempty(m->jobs));
647 assert(hashmap_isempty(m->units));
650 m->n_running_jobs = 0;
653 void manager_free(Manager *m) {
659 manager_clear_jobs_and_units(m);
661 for (c = 0; c < _UNIT_TYPE_MAX; c++)
662 if (unit_vtable[c]->shutdown)
663 unit_vtable[c]->shutdown(m);
665 /* If we reexecute ourselves, we keep the root cgroup
667 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
669 manager_undo_generators(m);
673 hashmap_free(m->units);
674 hashmap_free(m->jobs);
675 hashmap_free(m->watch_pids);
676 hashmap_free(m->watch_bus);
678 sd_event_source_unref(m->signal_event_source);
679 sd_event_source_unref(m->notify_event_source);
680 sd_event_source_unref(m->time_change_event_source);
681 sd_event_source_unref(m->jobs_in_progress_event_source);
682 sd_event_source_unref(m->idle_pipe_event_source);
683 sd_event_source_unref(m->run_queue_event_source);
685 if (m->signal_fd >= 0)
686 close_nointr_nofail(m->signal_fd);
687 if (m->notify_fd >= 0)
688 close_nointr_nofail(m->notify_fd);
689 if (m->time_change_fd >= 0)
690 close_nointr_nofail(m->time_change_fd);
692 manager_close_idle_pipe(m);
694 sd_event_unref(m->event);
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 free(m->switch_root);
705 free(m->switch_root_init);
707 for (i = 0; i < RLIMIT_NLIMITS; i++)
710 assert(hashmap_isempty(m->units_requiring_mounts_for));
711 hashmap_free(m->units_requiring_mounts_for);
716 int manager_enumerate(Manager *m) {
722 /* Let's ask every type to load all units from disk/kernel
723 * that it might know */
724 for (c = 0; c < _UNIT_TYPE_MAX; c++)
725 if (unit_vtable[c]->enumerate) {
726 q = unit_vtable[c]->enumerate(m);
731 manager_dispatch_load_queue(m);
735 static int manager_coldplug(Manager *m) {
743 /* Then, let's set up their initial state. */
744 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
750 if ((q = unit_coldplug(u)) < 0)
757 static void manager_build_unit_path_cache(Manager *m) {
759 _cleanup_free_ DIR *d = NULL;
764 set_free_free(m->unit_path_cache);
766 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
767 if (!m->unit_path_cache) {
768 log_error("Failed to allocate unit path cache.");
772 /* This simply builds a list of files we know exist, so that
773 * we don't always have to go to disk */
775 STRV_FOREACH(i, m->lookup_paths.unit_path) {
781 log_error("Failed to open directory %s: %m", *i);
785 while ((de = readdir(d))) {
788 if (ignore_file(de->d_name))
791 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
797 r = set_consume(m->unit_path_cache, p);
809 log_error("Failed to build unit path cache: %s", strerror(-r));
811 set_free_free(m->unit_path_cache);
812 m->unit_path_cache = NULL;
816 static int manager_distribute_fds(Manager *m, FDSet *fds) {
823 HASHMAP_FOREACH(u, m->units, i) {
825 if (fdset_size(fds) <= 0)
828 if (UNIT_VTABLE(u)->distribute_fds) {
829 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
838 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
843 dual_timestamp_get(&m->generators_start_timestamp);
844 manager_run_generators(m);
845 dual_timestamp_get(&m->generators_finish_timestamp);
847 r = lookup_paths_init(
848 &m->lookup_paths, m->running_as, true,
849 m->generator_unit_path,
850 m->generator_unit_path_early,
851 m->generator_unit_path_late);
855 manager_build_unit_path_cache(m);
857 /* If we will deserialize make sure that during enumeration
858 * this is already known, so we increase the counter here
863 /* First, enumerate what we can from all config files */
864 dual_timestamp_get(&m->units_load_start_timestamp);
865 r = manager_enumerate(m);
866 dual_timestamp_get(&m->units_load_finish_timestamp);
868 /* Second, deserialize if there is something to deserialize */
870 q = manager_deserialize(m, serialization, fds);
875 /* Any fds left? Find some unit which wants them. This is
876 * useful to allow container managers to pass some file
877 * descriptors to us pre-initialized. This enables
878 * socket-based activation of entire containers. */
879 if (fdset_size(fds) > 0) {
880 q = manager_distribute_fds(m, fds);
885 /* Third, fire things up! */
886 q = manager_coldplug(m);
891 assert(m->n_reloading > 0);
894 /* Let's wait for the UnitNew/JobNew messages being
895 * sent, before we notify that the reload is
897 m->send_reloading_done = true;
903 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
908 assert(type < _JOB_TYPE_MAX);
910 assert(mode < _JOB_MODE_MAX);
912 if (mode == JOB_ISOLATE && type != JOB_START) {
913 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
917 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
918 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
922 log_debug_unit(unit->id,
923 "Trying to enqueue job %s/%s/%s", unit->id,
924 job_type_to_string(type), job_mode_to_string(mode));
926 job_type_collapse(&type, unit);
928 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
932 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
933 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
934 mode == JOB_IGNORE_DEPENDENCIES, e);
938 if (mode == JOB_ISOLATE) {
939 r = transaction_add_isolate_jobs(tr, m);
944 r = transaction_activate(tr, m, mode, e);
948 log_debug_unit(unit->id,
949 "Enqueued job %s/%s as %u", unit->id,
950 job_type_to_string(type), (unsigned) tr->anchor_job->id);
953 *_ret = tr->anchor_job;
955 transaction_free(tr);
959 transaction_abort(tr);
960 transaction_free(tr);
964 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
969 assert(type < _JOB_TYPE_MAX);
971 assert(mode < _JOB_MODE_MAX);
973 r = manager_load_unit(m, name, NULL, NULL, &unit);
977 return manager_add_job(m, type, unit, mode, override, e, _ret);
980 Job *manager_get_job(Manager *m, uint32_t id) {
983 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
986 Unit *manager_get_unit(Manager *m, const char *name) {
990 return hashmap_get(m->units, name);
993 unsigned manager_dispatch_load_queue(Manager *m) {
999 /* Make sure we are not run recursively */
1000 if (m->dispatching_load_queue)
1003 m->dispatching_load_queue = true;
1005 /* Dispatches the load queue. Takes a unit from the queue and
1006 * tries to load its data until the queue is empty */
1008 while ((u = m->load_queue)) {
1009 assert(u->in_load_queue);
1015 m->dispatching_load_queue = false;
1019 int manager_load_unit_prepare(
1031 assert(name || path);
1033 /* This will prepare the unit for loading, but not actually
1034 * load anything from disk. */
1036 if (path && !is_path(path))
1037 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1040 name = path_get_file_name(path);
1042 t = unit_name_to_type(name);
1044 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false))
1045 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1047 ret = manager_get_unit(m, name);
1053 ret = unit_new(m, unit_vtable[t]->object_size);
1058 ret->fragment_path = strdup(path);
1059 if (!ret->fragment_path) {
1065 r = unit_add_name(ret, name);
1071 unit_add_to_load_queue(ret);
1072 unit_add_to_dbus_queue(ret);
1073 unit_add_to_gc_queue(ret);
1081 int manager_load_unit(
1092 /* This will load the service information files, but not actually
1093 * start any services or anything. */
1095 r = manager_load_unit_prepare(m, name, path, e, _ret);
1099 manager_dispatch_load_queue(m);
1102 *_ret = unit_follow_merge(*_ret);
1107 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1114 HASHMAP_FOREACH(j, s->jobs, i)
1115 job_dump(j, f, prefix);
1118 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1126 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1128 unit_dump(u, f, prefix);
1131 void manager_clear_jobs(Manager *m) {
1136 while ((j = hashmap_first(m->jobs)))
1137 /* No need to recurse. We're cancelling all jobs. */
1138 job_finish_and_invalidate(j, JOB_CANCELED, false);
1141 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1142 Manager *m = userdata;
1148 while ((j = m->run_queue)) {
1149 assert(j->installed);
1150 assert(j->in_run_queue);
1152 job_run_and_invalidate(j);
1155 if (m->n_running_jobs > 0)
1156 manager_watch_jobs_in_progress(m);
1158 if (m->n_on_console > 0)
1159 manager_watch_idle_pipe(m);
1164 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1171 if (m->dispatching_dbus_queue)
1174 m->dispatching_dbus_queue = true;
1176 while ((u = m->dbus_unit_queue)) {
1177 assert(u->in_dbus_queue);
1179 bus_unit_send_change_signal(u);
1183 while ((j = m->dbus_job_queue)) {
1184 assert(j->in_dbus_queue);
1186 bus_job_send_change_signal(j);
1190 m->dispatching_dbus_queue = false;
1192 if (m->send_reloading_done) {
1193 m->send_reloading_done = false;
1195 bus_manager_send_reloading(m, false);
1198 if (m->queued_message)
1199 bus_send_queued_message(m);
1204 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1205 Manager *m = userdata;
1209 assert(m->notify_fd == fd);
1211 if (revents != EPOLLIN) {
1212 log_warning("Got unexpected poll event for notify fd.");
1218 struct iovec iovec = {
1220 .iov_len = sizeof(buf)-1,
1224 struct cmsghdr cmsghdr;
1225 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1228 struct msghdr msghdr = {
1231 .msg_control = &control,
1232 .msg_controllen = sizeof(control),
1234 struct ucred *ucred;
1236 _cleanup_strv_free_ char **tags = NULL;
1238 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1243 if (errno == EAGAIN || errno == EINTR)
1249 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1250 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1251 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1252 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1253 log_warning("Received notify message without credentials. Ignoring.");
1257 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1259 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1261 u = manager_get_unit_by_pid(m, ucred->pid);
1263 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1268 assert((size_t) n < sizeof(buf));
1270 tags = strv_split(buf, "\n\r");
1274 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1276 if (UNIT_VTABLE(u)->notify_message)
1277 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1283 static int manager_dispatch_sigchld(Manager *m) {
1291 /* First we call waitd() for a PID and do not reap the
1292 * zombie. That way we can still access /proc/$PID for
1293 * it while it is a zombie. */
1294 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1296 if (errno == ECHILD)
1308 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1309 _cleanup_free_ char *name = NULL;
1311 get_process_comm(si.si_pid, &name);
1312 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1315 /* Let's flush any message the dying child might still
1316 * have queued for us. This ensures that the process
1317 * still exists in /proc so that we can figure out
1318 * which cgroup and hence unit it belongs to. */
1319 r = manager_dispatch_notify_fd(m->notify_event_source, m->notify_fd, EPOLLIN, m);
1323 /* And now figure out the unit this belongs to */
1324 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1326 u = manager_get_unit_by_pid(m, si.si_pid);
1328 /* And now, we actually reap the zombie. */
1329 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1336 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1339 log_debug("Child %lu died (code=%s, status=%i/%s)",
1340 (long unsigned) si.si_pid,
1341 sigchld_code_to_string(si.si_code),
1343 strna(si.si_code == CLD_EXITED
1344 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1345 : signal_to_string(si.si_status)));
1350 log_debug_unit(u->id,
1351 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1353 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1354 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1360 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1361 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1364 log_debug_unit(name, "Activating special unit %s", name);
1366 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1368 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1373 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1374 Manager *m = userdata;
1376 struct signalfd_siginfo sfsi;
1377 bool sigchld = false;
1380 assert(m->signal_fd == fd);
1382 if (revents != EPOLLIN) {
1383 log_warning("Got unexpected events from signal file descriptor.");
1388 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1389 if (n != sizeof(sfsi)) {
1394 if (errno == EINTR || errno == EAGAIN)
1400 if (sfsi.ssi_pid > 0) {
1403 get_process_comm(sfsi.ssi_pid, &p);
1405 log_debug("Received SIG%s from PID %lu (%s).",
1406 signal_to_string(sfsi.ssi_signo),
1407 (unsigned long) sfsi.ssi_pid, strna(p));
1410 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1412 switch (sfsi.ssi_signo) {
1419 if (m->running_as == SYSTEMD_SYSTEM) {
1420 /* This is for compatibility with the
1421 * original sysvinit */
1422 m->exit_code = MANAGER_REEXECUTE;
1429 if (m->running_as == SYSTEMD_SYSTEM) {
1430 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1434 /* Run the exit target if there is one, if not, just exit. */
1435 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1436 m->exit_code = MANAGER_EXIT;
1443 if (m->running_as == SYSTEMD_SYSTEM)
1444 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1446 /* This is a nop on non-init */
1450 if (m->running_as == SYSTEMD_SYSTEM)
1451 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1453 /* This is a nop on non-init */
1459 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1461 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1462 log_info("Trying to reconnect to bus...");
1466 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1467 log_info("Loading D-Bus service...");
1468 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1475 _cleanup_free_ char *dump = NULL;
1476 _cleanup_fclose_ FILE *f = NULL;
1479 f = open_memstream(&dump, &size);
1481 log_warning("Failed to allocate memory stream.");
1485 manager_dump_units(m, f, "\t");
1486 manager_dump_jobs(m, f, "\t");
1489 log_warning("Failed to write status stream");
1493 log_dump(LOG_INFO, dump);
1498 m->exit_code = MANAGER_RELOAD;
1503 /* Starting SIGRTMIN+0 */
1504 static const char * const target_table[] = {
1505 [0] = SPECIAL_DEFAULT_TARGET,
1506 [1] = SPECIAL_RESCUE_TARGET,
1507 [2] = SPECIAL_EMERGENCY_TARGET,
1508 [3] = SPECIAL_HALT_TARGET,
1509 [4] = SPECIAL_POWEROFF_TARGET,
1510 [5] = SPECIAL_REBOOT_TARGET,
1511 [6] = SPECIAL_KEXEC_TARGET
1514 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1515 static const ManagerExitCode code_table[] = {
1517 [1] = MANAGER_POWEROFF,
1518 [2] = MANAGER_REBOOT,
1522 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1523 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1524 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1525 manager_start_target(m, target_table[idx],
1526 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1530 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1531 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1532 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1536 switch (sfsi.ssi_signo - SIGRTMIN) {
1539 log_debug("Enabling showing of status.");
1540 manager_set_show_status(m, true);
1544 log_debug("Disabling showing of status.");
1545 manager_set_show_status(m, false);
1549 log_set_max_level(LOG_DEBUG);
1550 log_notice("Setting log level to debug.");
1554 log_set_max_level(LOG_INFO);
1555 log_notice("Setting log level to info.");
1559 if (m->running_as == SYSTEMD_USER) {
1560 m->exit_code = MANAGER_EXIT;
1564 /* This is a nop on init */
1568 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1569 log_notice("Setting log target to journal-or-kmsg.");
1573 log_set_target(LOG_TARGET_CONSOLE);
1574 log_notice("Setting log target to console.");
1578 log_set_target(LOG_TARGET_KMSG);
1579 log_notice("Setting log target to kmsg.");
1583 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1584 log_notice("Setting log target to syslog-or-kmsg.");
1588 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1595 return manager_dispatch_sigchld(m);
1600 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1601 Manager *m = userdata;
1606 assert(m->time_change_fd == fd);
1608 log_struct(LOG_INFO,
1609 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1610 "MESSAGE=Time has been changed",
1613 /* Restart the watch */
1614 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1616 close_nointr_nofail(m->time_change_fd);
1617 m->time_change_fd = -1;
1619 manager_setup_time_change(m);
1621 HASHMAP_FOREACH(u, m->units, i)
1622 if (UNIT_VTABLE(u)->time_change)
1623 UNIT_VTABLE(u)->time_change(u);
1628 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1629 Manager *m = userdata;
1632 assert(m->idle_pipe[2] == fd);
1634 m->no_console_output = m->n_on_console > 0;
1636 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1637 manager_close_idle_pipe(m);
1642 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1643 Manager *m = userdata;
1647 manager_print_jobs_in_progress(m);
1651 int manager_loop(Manager *m) {
1654 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1657 m->exit_code = MANAGER_RUNNING;
1659 /* Release the path cache */
1660 set_free_free(m->unit_path_cache);
1661 m->unit_path_cache = NULL;
1663 manager_check_finished(m);
1665 /* There might still be some zombies hanging around from
1666 * before we were exec()'ed. Let's reap them. */
1667 r = manager_dispatch_sigchld(m);
1671 while (m->exit_code == MANAGER_RUNNING) {
1674 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1677 if (!ratelimit_test(&rl)) {
1678 /* Yay, something is going seriously wrong, pause a little */
1679 log_warning("Looping too fast. Throttling execution a little.");
1684 if (manager_dispatch_load_queue(m) > 0)
1687 if (manager_dispatch_gc_queue(m) > 0)
1690 if (manager_dispatch_cleanup_queue(m) > 0)
1693 if (manager_dispatch_cgroup_queue(m) > 0)
1696 if (manager_dispatch_dbus_queue(m) > 0)
1699 /* Sleep for half the watchdog time */
1700 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1701 wait_usec = m->runtime_watchdog / 2;
1705 wait_usec = (usec_t) -1;
1707 r = sd_event_run(m->event, wait_usec);
1709 log_error("Failed to run event loop: %s", strerror(-r));
1714 return m->exit_code;
1717 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1718 _cleanup_free_ char *n = NULL;
1726 r = unit_name_from_dbus_path(s, &n);
1730 r = manager_load_unit(m, n, NULL, e, &u);
1739 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1749 p = startswith(s, "/org/freedesktop/systemd1/job/");
1753 r = safe_atou(p, &id);
1757 j = manager_get_job(m, id);
1766 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1772 audit_fd = get_audit_fd();
1776 /* Don't generate audit events if the service was already
1777 * started and we're just deserializing */
1778 if (m->n_reloading > 0)
1781 if (m->running_as != SYSTEMD_SYSTEM)
1784 if (u->type != UNIT_SERVICE)
1787 p = unit_name_to_prefix_and_instance(u->id);
1789 log_error_unit(u->id,
1790 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1794 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1795 if (errno == EPERM) {
1796 /* We aren't allowed to send audit messages?
1797 * Then let's not retry again. */
1800 log_warning("Failed to send audit message: %m");
1808 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1810 union sockaddr_union sa;
1812 char *message = NULL;
1814 /* Don't generate plymouth events if the service was already
1815 * started and we're just deserializing */
1816 if (m->n_reloading > 0)
1819 if (m->running_as != SYSTEMD_SYSTEM)
1822 if (detect_container(NULL) > 0)
1825 if (u->type != UNIT_SERVICE &&
1826 u->type != UNIT_MOUNT &&
1827 u->type != UNIT_SWAP)
1830 /* We set SOCK_NONBLOCK here so that we rather drop the
1831 * message then wait for plymouth */
1832 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1834 log_error("socket() failed: %m");
1839 sa.sa.sa_family = AF_UNIX;
1840 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1841 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1843 if (errno != EPIPE &&
1846 errno != ECONNREFUSED &&
1847 errno != ECONNRESET &&
1848 errno != ECONNABORTED)
1849 log_error("connect() failed: %m");
1854 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1860 if (write(fd, message, n + 1) != n + 1) {
1862 if (errno != EPIPE &&
1865 errno != ECONNREFUSED &&
1866 errno != ECONNRESET &&
1867 errno != ECONNABORTED)
1868 log_error("Failed to write Plymouth message: %m");
1875 close_nointr_nofail(fd);
1880 void manager_dispatch_bus_name_owner_changed(
1883 const char* old_owner,
1884 const char *new_owner) {
1891 u = hashmap_get(m->watch_bus, name);
1895 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1898 int manager_open_serialization(Manager *m, FILE **_f) {
1905 if (m->running_as == SYSTEMD_SYSTEM)
1906 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1908 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1913 RUN_WITH_UMASK(0077) {
1914 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1924 log_debug("Serializing state to %s", path);
1927 f = fdopen(fd, "w+");
1936 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
1949 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1950 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1951 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1952 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1954 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1955 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1956 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1957 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1960 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1961 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1962 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
1963 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
1964 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
1965 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
1966 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
1967 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
1970 if (!switching_root) {
1971 STRV_FOREACH(e, m->environment) {
1972 _cleanup_free_ char *ce;
1976 fprintf(f, "env=%s\n", *e);
1980 bus_serialize(m, f);
1984 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1988 if (!unit_can_serialize(u))
1995 r = unit_serialize(u, f, fds, !switching_root);
2002 assert(m->n_reloading > 0);
2008 r = bus_fdset_add_all(m, fds);
2015 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2021 log_debug("Deserializing state...");
2026 char line[LINE_MAX], *l;
2028 if (!fgets(line, sizeof(line), f)) {
2043 if (startswith(l, "current-job-id=")) {
2046 if (safe_atou32(l+15, &id) < 0)
2047 log_debug("Failed to parse current job id value %s", l+15);
2049 m->current_job_id = MAX(m->current_job_id, id);
2051 } else if (startswith(l, "n-installed-jobs=")) {
2054 if (safe_atou32(l+17, &n) < 0)
2055 log_debug("Failed to parse installed jobs counter %s", l+17);
2057 m->n_installed_jobs += n;
2059 } else if (startswith(l, "n-failed-jobs=")) {
2062 if (safe_atou32(l+14, &n) < 0)
2063 log_debug("Failed to parse failed jobs counter %s", l+14);
2065 m->n_failed_jobs += n;
2067 } else if (startswith(l, "taint-usr=")) {
2070 if ((b = parse_boolean(l+10)) < 0)
2071 log_debug("Failed to parse taint /usr flag %s", l+10);
2073 m->taint_usr = m->taint_usr || b;
2075 } else if (startswith(l, "firmware-timestamp="))
2076 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2077 else if (startswith(l, "loader-timestamp="))
2078 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2079 else if (startswith(l, "kernel-timestamp="))
2080 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2081 else if (startswith(l, "initrd-timestamp="))
2082 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2083 else if (startswith(l, "userspace-timestamp="))
2084 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2085 else if (startswith(l, "finish-timestamp="))
2086 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2087 else if (startswith(l, "security-start-timestamp="))
2088 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2089 else if (startswith(l, "security-finish-timestamp="))
2090 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2091 else if (startswith(l, "generators-start-timestamp="))
2092 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2093 else if (startswith(l, "generators-finish-timestamp="))
2094 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2095 else if (startswith(l, "units-load-start-timestamp="))
2096 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2097 else if (startswith(l, "units-load-finish-timestamp="))
2098 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2099 else if (startswith(l, "env=")) {
2100 _cleanup_free_ char *uce = NULL;
2103 uce = cunescape(l+4);
2109 e = strv_env_set(m->environment, uce);
2115 strv_free(m->environment);
2117 } else if (bus_deserialize_item(m, l) == 0)
2118 log_debug("Unknown serialization item '%s'", l);
2123 char name[UNIT_NAME_MAX+2];
2126 if (!fgets(name, sizeof(name), f)) {
2137 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2141 r = unit_deserialize(u, f, fds);
2152 assert(m->n_reloading > 0);
2158 int manager_reload(Manager *m) {
2160 _cleanup_fclose_ FILE *f = NULL;
2161 _cleanup_fdset_free_ FDSet *fds = NULL;
2165 r = manager_open_serialization(m, &f);
2170 bus_manager_send_reloading(m, true);
2178 r = manager_serialize(m, f, fds, false);
2184 if (fseeko(f, 0, SEEK_SET) < 0) {
2189 /* From here on there is no way back. */
2190 manager_clear_jobs_and_units(m);
2191 manager_undo_generators(m);
2192 lookup_paths_free(&m->lookup_paths);
2194 /* Find new unit paths */
2195 manager_run_generators(m);
2197 q = lookup_paths_init(
2198 &m->lookup_paths, m->running_as, true,
2199 m->generator_unit_path,
2200 m->generator_unit_path_early,
2201 m->generator_unit_path_late);
2205 manager_build_unit_path_cache(m);
2207 /* First, enumerate what we can from all config files */
2208 q = manager_enumerate(m);
2212 /* Second, deserialize our stored data */
2213 q = manager_deserialize(m, f, fds);
2220 /* Third, fire things up! */
2221 q = manager_coldplug(m);
2225 assert(m->n_reloading > 0);
2228 m->send_reloading_done = true;
2233 static bool manager_is_booting_or_shutting_down(Manager *m) {
2238 /* Is the initial job still around? */
2239 if (manager_get_job(m, m->default_unit_job_id))
2242 /* Is there a job for the shutdown target? */
2243 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2250 bool manager_is_reloading_or_reexecuting(Manager *m) {
2253 return m->n_reloading != 0;
2256 void manager_reset_failed(Manager *m) {
2262 HASHMAP_FOREACH(u, m->units, i)
2263 unit_reset_failed(u);
2266 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2272 /* Returns true if the unit is inactive or going down */
2273 u = manager_get_unit(m, name);
2277 return unit_inactive_or_pending(u);
2280 void manager_check_finished(Manager *m) {
2281 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2282 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2286 if (m->n_running_jobs == 0)
2287 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2289 if (hashmap_size(m->jobs) > 0) {
2290 if (m->jobs_in_progress_event_source)
2291 sd_event_source_set_time(m->jobs_in_progress_event_source, JOBS_IN_PROGRESS_PERIOD_SEC);
2295 /* Notify Type=idle units that we are done now */
2296 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2297 manager_close_idle_pipe(m);
2299 /* Turn off confirm spawn now */
2300 m->confirm_spawn = false;
2302 if (dual_timestamp_is_set(&m->finish_timestamp))
2305 dual_timestamp_get(&m->finish_timestamp);
2307 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2309 /* Note that m->kernel_usec.monotonic is always at 0,
2310 * and m->firmware_usec.monotonic and
2311 * m->loader_usec.monotonic should be considered
2312 * negative values. */
2314 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2315 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2316 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2317 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2319 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2321 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2322 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2324 if (!log_on_console())
2325 log_struct(LOG_INFO,
2326 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2327 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2328 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2329 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2330 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2331 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2332 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2333 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2334 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2337 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2340 if (!log_on_console())
2341 log_struct(LOG_INFO,
2342 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2343 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2344 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2345 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2346 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2347 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2348 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2352 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2353 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2355 if (!log_on_console())
2356 log_struct(LOG_INFO,
2357 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2358 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2359 "MESSAGE=Startup finished in %s.",
2360 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2364 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2367 "READY=1\nSTATUS=Startup finished in %s.",
2368 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2371 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2382 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2384 p = strappend("/run/systemd/", name);
2388 r = mkdir_p_label(p, 0755);
2390 log_error("Failed to create generator directory %s: %s",
2396 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2401 log_error("Failed to create generator directory %s: %m",
2412 static void trim_generator_dir(Manager *m, char **generator) {
2419 if (rmdir(*generator) >= 0) {
2427 void manager_run_generators(Manager *m) {
2428 _cleanup_closedir_ DIR *d = NULL;
2429 const char *generator_path;
2430 const char *argv[5];
2435 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2436 d = opendir(generator_path);
2438 if (errno == ENOENT)
2441 log_error("Failed to enumerate generator directory %s: %m",
2446 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2450 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2454 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2458 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2459 argv[1] = m->generator_unit_path;
2460 argv[2] = m->generator_unit_path_early;
2461 argv[3] = m->generator_unit_path_late;
2464 RUN_WITH_UMASK(0022)
2465 execute_directory(generator_path, d, (char**) argv);
2468 trim_generator_dir(m, &m->generator_unit_path);
2469 trim_generator_dir(m, &m->generator_unit_path_early);
2470 trim_generator_dir(m, &m->generator_unit_path_late);
2473 static void remove_generator_dir(Manager *m, char **generator) {
2480 strv_remove(m->lookup_paths.unit_path, *generator);
2481 rm_rf(*generator, false, true, false);
2487 void manager_undo_generators(Manager *m) {
2490 remove_generator_dir(m, &m->generator_unit_path);
2491 remove_generator_dir(m, &m->generator_unit_path_early);
2492 remove_generator_dir(m, &m->generator_unit_path_late);
2495 int manager_environment_add(Manager *m, char **minus, char **plus) {
2496 char **a = NULL, **b = NULL, **l;
2501 if (!strv_isempty(minus)) {
2502 a = strv_env_delete(l, 1, minus);
2509 if (!strv_isempty(plus)) {
2510 b = strv_env_merge(2, l, plus);
2517 if (m->environment != l)
2518 strv_free(m->environment);
2524 m->environment = strv_sort(l);
2528 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2533 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2534 if (!default_rlimit[i])
2537 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2545 void manager_recheck_journal(Manager *m) {
2550 if (m->running_as != SYSTEMD_SYSTEM)
2553 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2554 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2555 log_close_journal();
2559 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2560 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2561 log_close_journal();
2565 /* Hmm, OK, so the socket is fully up and the service is up
2566 * too, then let's make use of the thing. */
2570 void manager_set_show_status(Manager *m, bool b) {
2573 if (m->running_as != SYSTEMD_SYSTEM)
2579 touch("/run/systemd/show-status");
2581 unlink("/run/systemd/show-status");
2584 static bool manager_get_show_status(Manager *m) {
2587 if (m->running_as != SYSTEMD_SYSTEM)
2590 if (m->no_console_output)
2596 /* If Plymouth is running make sure we show the status, so
2597 * that there's something nice to see when people press Esc */
2599 return plymouth_running();
2602 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2605 if (!manager_get_show_status(m))
2608 /* XXX We should totally drop the check for ephemeral here
2609 * and thus effectively make 'Type=idle' pointless. */
2610 if (ephemeral && m->n_on_console > 0)
2613 if (!manager_is_booting_or_shutting_down(m))
2616 va_start(ap, format);
2617 status_vprintf(status, true, ephemeral, format, ap);
2621 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2622 _cleanup_free_ char *p = NULL;
2630 p = unit_name_from_path(path, suffix);
2634 found = manager_get_unit(m, p);
2644 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2645 char p[strlen(path)+1];
2651 path_kill_slashes(p);
2653 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);