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);
403 int manager_new(SystemdRunningAs running_as, bool reexecuting, Manager **_m) {
406 bool try_bus_connect = false;
409 assert(running_as >= 0);
410 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
412 m = new0(Manager, 1);
417 if (detect_container(NULL) <= 0)
418 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
421 m->running_as = running_as;
422 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
424 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
426 m->pin_cgroupfs_fd = m->notify_fd = m->signal_fd = m->time_change_fd = m->dev_autofs_fd = m->private_listen_fd = -1;
427 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
429 r = manager_default_environment(m);
433 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
437 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
441 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
445 r = hashmap_ensure_allocated(&m->watch_pids, trivial_hash_func, trivial_compare_func);
449 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
453 r = sd_event_default(&m->event);
457 r = manager_setup_signals(m);
461 r = manager_setup_cgroup(m);
465 r = manager_setup_notify(m);
469 r = manager_setup_time_change(m);
473 if (running_as == SYSTEMD_SYSTEM)
474 try_bus_connect = reexecuting;
475 else if (getenv("DBUS_SESSION_BUS_ADDRESS"))
476 try_bus_connect = true;
478 log_debug("Skipping DBus session bus connection attempt - no DBUS_SESSION_BUS_ADDRESS set...");
480 /* Try to connect to the busses, if possible. */
481 r = bus_init(m, try_bus_connect);
485 m->taint_usr = dir_is_empty("/usr") > 0;
495 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
501 while ((u = m->cleanup_queue)) {
502 assert(u->in_cleanup_queue);
512 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
513 GC_OFFSET_UNSURE, /* No clue */
514 GC_OFFSET_GOOD, /* We still need this unit */
515 GC_OFFSET_BAD, /* We don't need this unit anymore */
519 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
526 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
527 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
528 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
531 if (u->in_cleanup_queue)
534 if (unit_check_gc(u))
537 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
541 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
542 unit_gc_sweep(other, gc_marker);
544 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
547 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
554 /* We were unable to find anything out about this entry, so
555 * let's investigate it later */
556 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
557 unit_add_to_gc_queue(u);
561 /* We definitely know that this one is not useful anymore, so
562 * let's mark it for deletion */
563 u->gc_marker = gc_marker + GC_OFFSET_BAD;
564 unit_add_to_cleanup_queue(u);
568 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
571 static unsigned manager_dispatch_gc_queue(Manager *m) {
578 /* log_debug("Running GC..."); */
580 m->gc_marker += _GC_OFFSET_MAX;
581 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
584 gc_marker = m->gc_marker;
586 while ((u = m->gc_queue)) {
587 assert(u->in_gc_queue);
589 unit_gc_sweep(u, gc_marker);
591 LIST_REMOVE(gc_queue, m->gc_queue, u);
592 u->in_gc_queue = false;
596 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
597 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
598 log_debug_unit(u->id, "Collecting %s", u->id);
599 u->gc_marker = gc_marker + GC_OFFSET_BAD;
600 unit_add_to_cleanup_queue(u);
604 m->n_in_gc_queue = 0;
609 static void manager_clear_jobs_and_units(Manager *m) {
614 while ((u = hashmap_first(m->units)))
617 manager_dispatch_cleanup_queue(m);
619 assert(!m->load_queue);
620 assert(!m->run_queue);
621 assert(!m->dbus_unit_queue);
622 assert(!m->dbus_job_queue);
623 assert(!m->cleanup_queue);
624 assert(!m->gc_queue);
626 assert(hashmap_isempty(m->jobs));
627 assert(hashmap_isempty(m->units));
630 m->n_running_jobs = 0;
633 void manager_free(Manager *m) {
639 manager_clear_jobs_and_units(m);
641 for (c = 0; c < _UNIT_TYPE_MAX; c++)
642 if (unit_vtable[c]->shutdown)
643 unit_vtable[c]->shutdown(m);
645 /* If we reexecute ourselves, we keep the root cgroup
647 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
649 manager_undo_generators(m);
653 hashmap_free(m->units);
654 hashmap_free(m->jobs);
655 hashmap_free(m->watch_pids);
656 hashmap_free(m->watch_bus);
658 sd_event_source_unref(m->signal_event_source);
659 sd_event_source_unref(m->notify_event_source);
660 sd_event_source_unref(m->time_change_event_source);
661 sd_event_source_unref(m->jobs_in_progress_event_source);
662 sd_event_source_unref(m->idle_pipe_event_source);
664 if (m->signal_fd >= 0)
665 close_nointr_nofail(m->signal_fd);
666 if (m->notify_fd >= 0)
667 close_nointr_nofail(m->notify_fd);
668 if (m->time_change_fd >= 0)
669 close_nointr_nofail(m->time_change_fd);
671 manager_close_idle_pipe(m);
673 sd_event_unref(m->event);
675 free(m->notify_socket);
677 lookup_paths_free(&m->lookup_paths);
678 strv_free(m->environment);
680 hashmap_free(m->cgroup_unit);
681 set_free_free(m->unit_path_cache);
683 free(m->switch_root);
684 free(m->switch_root_init);
686 for (i = 0; i < RLIMIT_NLIMITS; i++)
689 assert(hashmap_isempty(m->units_requiring_mounts_for));
690 hashmap_free(m->units_requiring_mounts_for);
695 int manager_enumerate(Manager *m) {
701 /* Let's ask every type to load all units from disk/kernel
702 * that it might know */
703 for (c = 0; c < _UNIT_TYPE_MAX; c++)
704 if (unit_vtable[c]->enumerate) {
705 q = unit_vtable[c]->enumerate(m);
710 manager_dispatch_load_queue(m);
714 static int manager_coldplug(Manager *m) {
722 /* Then, let's set up their initial state. */
723 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
729 if ((q = unit_coldplug(u)) < 0)
736 static void manager_build_unit_path_cache(Manager *m) {
738 _cleanup_free_ DIR *d = NULL;
743 set_free_free(m->unit_path_cache);
745 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
746 if (!m->unit_path_cache) {
747 log_error("Failed to allocate unit path cache.");
751 /* This simply builds a list of files we know exist, so that
752 * we don't always have to go to disk */
754 STRV_FOREACH(i, m->lookup_paths.unit_path) {
760 log_error("Failed to open directory %s: %m", *i);
764 while ((de = readdir(d))) {
767 if (ignore_file(de->d_name))
770 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
776 r = set_consume(m->unit_path_cache, p);
788 log_error("Failed to build unit path cache: %s", strerror(-r));
790 set_free_free(m->unit_path_cache);
791 m->unit_path_cache = NULL;
795 static int manager_distribute_fds(Manager *m, FDSet *fds) {
802 HASHMAP_FOREACH(u, m->units, i) {
804 if (fdset_size(fds) <= 0)
807 if (UNIT_VTABLE(u)->distribute_fds) {
808 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
817 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
822 dual_timestamp_get(&m->generators_start_timestamp);
823 manager_run_generators(m);
824 dual_timestamp_get(&m->generators_finish_timestamp);
826 r = lookup_paths_init(
827 &m->lookup_paths, m->running_as, true,
828 m->generator_unit_path,
829 m->generator_unit_path_early,
830 m->generator_unit_path_late);
834 manager_build_unit_path_cache(m);
836 /* If we will deserialize make sure that during enumeration
837 * this is already known, so we increase the counter here
842 /* First, enumerate what we can from all config files */
843 dual_timestamp_get(&m->units_load_start_timestamp);
844 r = manager_enumerate(m);
845 dual_timestamp_get(&m->units_load_finish_timestamp);
847 /* Second, deserialize if there is something to deserialize */
849 q = manager_deserialize(m, serialization, fds);
854 /* Any fds left? Find some unit which wants them. This is
855 * useful to allow container managers to pass some file
856 * descriptors to us pre-initialized. This enables
857 * socket-based activation of entire containers. */
858 if (fdset_size(fds) > 0) {
859 q = manager_distribute_fds(m, fds);
864 /* Third, fire things up! */
865 q = manager_coldplug(m);
870 assert(m->n_reloading > 0);
873 /* Let's wait for the UnitNew/JobNew messages being
874 * sent, before we notify that the reload is
876 m->send_reloading_done = true;
882 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
887 assert(type < _JOB_TYPE_MAX);
889 assert(mode < _JOB_MODE_MAX);
891 if (mode == JOB_ISOLATE && type != JOB_START) {
892 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
896 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
897 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
901 log_debug_unit(unit->id,
902 "Trying to enqueue job %s/%s/%s", unit->id,
903 job_type_to_string(type), job_mode_to_string(mode));
905 job_type_collapse(&type, unit);
907 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
911 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
912 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
913 mode == JOB_IGNORE_DEPENDENCIES, e);
917 if (mode == JOB_ISOLATE) {
918 r = transaction_add_isolate_jobs(tr, m);
923 r = transaction_activate(tr, m, mode, e);
927 log_debug_unit(unit->id,
928 "Enqueued job %s/%s as %u", unit->id,
929 job_type_to_string(type), (unsigned) tr->anchor_job->id);
932 *_ret = tr->anchor_job;
934 transaction_free(tr);
938 transaction_abort(tr);
939 transaction_free(tr);
943 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
948 assert(type < _JOB_TYPE_MAX);
950 assert(mode < _JOB_MODE_MAX);
952 r = manager_load_unit(m, name, NULL, NULL, &unit);
956 return manager_add_job(m, type, unit, mode, override, e, _ret);
959 Job *manager_get_job(Manager *m, uint32_t id) {
962 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
965 Unit *manager_get_unit(Manager *m, const char *name) {
969 return hashmap_get(m->units, name);
972 unsigned manager_dispatch_load_queue(Manager *m) {
978 /* Make sure we are not run recursively */
979 if (m->dispatching_load_queue)
982 m->dispatching_load_queue = true;
984 /* Dispatches the load queue. Takes a unit from the queue and
985 * tries to load its data until the queue is empty */
987 while ((u = m->load_queue)) {
988 assert(u->in_load_queue);
994 m->dispatching_load_queue = false;
998 int manager_load_unit_prepare(
1010 assert(name || path);
1012 /* This will prepare the unit for loading, but not actually
1013 * load anything from disk. */
1015 if (path && !is_path(path))
1016 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1019 name = path_get_file_name(path);
1021 t = unit_name_to_type(name);
1023 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false))
1024 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1026 ret = manager_get_unit(m, name);
1032 ret = unit_new(m, unit_vtable[t]->object_size);
1037 ret->fragment_path = strdup(path);
1038 if (!ret->fragment_path) {
1044 r = unit_add_name(ret, name);
1050 unit_add_to_load_queue(ret);
1051 unit_add_to_dbus_queue(ret);
1052 unit_add_to_gc_queue(ret);
1060 int manager_load_unit(
1071 /* This will load the service information files, but not actually
1072 * start any services or anything. */
1074 r = manager_load_unit_prepare(m, name, path, e, _ret);
1078 manager_dispatch_load_queue(m);
1081 *_ret = unit_follow_merge(*_ret);
1086 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1093 HASHMAP_FOREACH(j, s->jobs, i)
1094 job_dump(j, f, prefix);
1097 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1105 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1107 unit_dump(u, f, prefix);
1110 void manager_clear_jobs(Manager *m) {
1115 while ((j = hashmap_first(m->jobs)))
1116 /* No need to recurse. We're cancelling all jobs. */
1117 job_finish_and_invalidate(j, JOB_CANCELED, false);
1120 static unsigned manager_dispatch_run_queue(Manager *m) {
1124 if (m->dispatching_run_queue)
1127 m->dispatching_run_queue = true;
1129 while ((j = m->run_queue)) {
1130 assert(j->installed);
1131 assert(j->in_run_queue);
1133 job_run_and_invalidate(j);
1137 m->dispatching_run_queue = false;
1139 if (m->n_running_jobs > 0)
1140 manager_watch_jobs_in_progress(m);
1142 if (m->n_on_console > 0)
1143 manager_watch_idle_pipe(m);
1148 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1155 if (m->dispatching_dbus_queue)
1158 m->dispatching_dbus_queue = true;
1160 while ((u = m->dbus_unit_queue)) {
1161 assert(u->in_dbus_queue);
1163 bus_unit_send_change_signal(u);
1167 while ((j = m->dbus_job_queue)) {
1168 assert(j->in_dbus_queue);
1170 bus_job_send_change_signal(j);
1174 m->dispatching_dbus_queue = false;
1176 if (m->send_reloading_done) {
1177 m->send_reloading_done = false;
1179 bus_manager_send_reloading(m, false);
1182 if (m->queued_message)
1183 bus_send_queued_message(m);
1188 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1189 Manager *m = userdata;
1193 assert(m->notify_fd == fd);
1195 if (revents != EPOLLIN) {
1196 log_warning("Got unexpected poll event for notify fd.");
1202 struct iovec iovec = {
1204 .iov_len = sizeof(buf)-1,
1208 struct cmsghdr cmsghdr;
1209 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1212 struct msghdr msghdr = {
1215 .msg_control = &control,
1216 .msg_controllen = sizeof(control),
1218 struct ucred *ucred;
1220 _cleanup_strv_free_ char **tags = NULL;
1222 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1227 if (errno == EAGAIN || errno == EINTR)
1233 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1234 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1235 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1236 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1237 log_warning("Received notify message without credentials. Ignoring.");
1241 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1243 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1245 u = manager_get_unit_by_pid(m, ucred->pid);
1247 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1252 assert((size_t) n < sizeof(buf));
1254 tags = strv_split(buf, "\n\r");
1258 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1260 if (UNIT_VTABLE(u)->notify_message)
1261 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1267 static int manager_dispatch_sigchld(Manager *m) {
1275 /* First we call waitd() for a PID and do not reap the
1276 * zombie. That way we can still access /proc/$PID for
1277 * it while it is a zombie. */
1278 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1280 if (errno == ECHILD)
1292 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1293 _cleanup_free_ char *name = NULL;
1295 get_process_comm(si.si_pid, &name);
1296 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1299 /* Let's flush any message the dying child might still
1300 * have queued for us. This ensures that the process
1301 * still exists in /proc so that we can figure out
1302 * which cgroup and hence unit it belongs to. */
1303 r = manager_dispatch_notify_fd(m->notify_event_source, m->notify_fd, EPOLLIN, m);
1307 /* And now figure out the unit this belongs to */
1308 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1310 u = manager_get_unit_by_pid(m, si.si_pid);
1312 /* And now, we actually reap the zombie. */
1313 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1320 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1323 log_debug("Child %lu died (code=%s, status=%i/%s)",
1324 (long unsigned) si.si_pid,
1325 sigchld_code_to_string(si.si_code),
1327 strna(si.si_code == CLD_EXITED
1328 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1329 : signal_to_string(si.si_status)));
1334 log_debug_unit(u->id,
1335 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1337 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1338 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1344 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1345 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1348 log_debug_unit(name, "Activating special unit %s", name);
1350 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1352 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1357 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1358 Manager *m = userdata;
1360 struct signalfd_siginfo sfsi;
1361 bool sigchld = false;
1364 assert(m->signal_fd == fd);
1366 if (revents != EPOLLIN) {
1367 log_warning("Got unexpected events from signal file descriptor.");
1372 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1373 if (n != sizeof(sfsi)) {
1378 if (errno == EINTR || errno == EAGAIN)
1384 if (sfsi.ssi_pid > 0) {
1387 get_process_comm(sfsi.ssi_pid, &p);
1389 log_debug("Received SIG%s from PID %lu (%s).",
1390 signal_to_string(sfsi.ssi_signo),
1391 (unsigned long) sfsi.ssi_pid, strna(p));
1394 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1396 switch (sfsi.ssi_signo) {
1403 if (m->running_as == SYSTEMD_SYSTEM) {
1404 /* This is for compatibility with the
1405 * original sysvinit */
1406 m->exit_code = MANAGER_REEXECUTE;
1413 if (m->running_as == SYSTEMD_SYSTEM) {
1414 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1418 /* Run the exit target if there is one, if not, just exit. */
1419 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1420 m->exit_code = MANAGER_EXIT;
1427 if (m->running_as == SYSTEMD_SYSTEM)
1428 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1430 /* This is a nop on non-init */
1434 if (m->running_as == SYSTEMD_SYSTEM)
1435 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1437 /* This is a nop on non-init */
1443 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1445 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1446 log_info("Trying to reconnect to bus...");
1450 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1451 log_info("Loading D-Bus service...");
1452 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1459 _cleanup_free_ char *dump = NULL;
1460 _cleanup_fclose_ FILE *f = NULL;
1463 f = open_memstream(&dump, &size);
1465 log_warning("Failed to allocate memory stream.");
1469 manager_dump_units(m, f, "\t");
1470 manager_dump_jobs(m, f, "\t");
1473 log_warning("Failed to write status stream");
1477 log_dump(LOG_INFO, dump);
1482 m->exit_code = MANAGER_RELOAD;
1487 /* Starting SIGRTMIN+0 */
1488 static const char * const target_table[] = {
1489 [0] = SPECIAL_DEFAULT_TARGET,
1490 [1] = SPECIAL_RESCUE_TARGET,
1491 [2] = SPECIAL_EMERGENCY_TARGET,
1492 [3] = SPECIAL_HALT_TARGET,
1493 [4] = SPECIAL_POWEROFF_TARGET,
1494 [5] = SPECIAL_REBOOT_TARGET,
1495 [6] = SPECIAL_KEXEC_TARGET
1498 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1499 static const ManagerExitCode code_table[] = {
1501 [1] = MANAGER_POWEROFF,
1502 [2] = MANAGER_REBOOT,
1506 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1507 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1508 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1509 manager_start_target(m, target_table[idx],
1510 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1514 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1515 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1516 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1520 switch (sfsi.ssi_signo - SIGRTMIN) {
1523 log_debug("Enabling showing of status.");
1524 manager_set_show_status(m, true);
1528 log_debug("Disabling showing of status.");
1529 manager_set_show_status(m, false);
1533 log_set_max_level(LOG_DEBUG);
1534 log_notice("Setting log level to debug.");
1538 log_set_max_level(LOG_INFO);
1539 log_notice("Setting log level to info.");
1543 if (m->running_as == SYSTEMD_USER) {
1544 m->exit_code = MANAGER_EXIT;
1548 /* This is a nop on init */
1552 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1553 log_notice("Setting log target to journal-or-kmsg.");
1557 log_set_target(LOG_TARGET_CONSOLE);
1558 log_notice("Setting log target to console.");
1562 log_set_target(LOG_TARGET_KMSG);
1563 log_notice("Setting log target to kmsg.");
1567 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1568 log_notice("Setting log target to syslog-or-kmsg.");
1572 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1579 return manager_dispatch_sigchld(m);
1584 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1585 Manager *m = userdata;
1590 assert(m->time_change_fd == fd);
1592 log_struct(LOG_INFO,
1593 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1594 "MESSAGE=Time has been changed",
1597 /* Restart the watch */
1598 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1600 close_nointr_nofail(m->time_change_fd);
1601 m->time_change_fd = -1;
1603 manager_setup_time_change(m);
1605 HASHMAP_FOREACH(u, m->units, i)
1606 if (UNIT_VTABLE(u)->time_change)
1607 UNIT_VTABLE(u)->time_change(u);
1612 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1613 Manager *m = userdata;
1616 assert(m->idle_pipe[2] == fd);
1618 m->no_console_output = m->n_on_console > 0;
1620 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1621 manager_close_idle_pipe(m);
1626 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1627 Manager *m = userdata;
1631 manager_print_jobs_in_progress(m);
1635 int manager_loop(Manager *m) {
1638 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1641 m->exit_code = MANAGER_RUNNING;
1643 /* Release the path cache */
1644 set_free_free(m->unit_path_cache);
1645 m->unit_path_cache = NULL;
1647 manager_check_finished(m);
1649 /* There might still be some zombies hanging around from
1650 * before we were exec()'ed. Let's reap them. */
1651 r = manager_dispatch_sigchld(m);
1655 while (m->exit_code == MANAGER_RUNNING) {
1658 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1661 if (!ratelimit_test(&rl)) {
1662 /* Yay, something is going seriously wrong, pause a little */
1663 log_warning("Looping too fast. Throttling execution a little.");
1668 if (manager_dispatch_load_queue(m) > 0)
1671 if (manager_dispatch_gc_queue(m) > 0)
1674 if (manager_dispatch_cleanup_queue(m) > 0)
1677 if (manager_dispatch_cgroup_queue(m) > 0)
1680 if (manager_dispatch_run_queue(m) > 0)
1683 if (manager_dispatch_dbus_queue(m) > 0)
1686 /* Sleep for half the watchdog time */
1687 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1688 wait_usec = m->runtime_watchdog / 2;
1692 wait_usec = (usec_t) -1;
1694 r = sd_event_run(m->event, wait_usec);
1696 log_error("Failed to run event loop: %s", strerror(-r));
1701 return m->exit_code;
1704 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1705 _cleanup_free_ char *n = NULL;
1713 r = unit_name_from_dbus_path(s, &n);
1717 r = manager_load_unit(m, n, NULL, e, &u);
1726 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1736 p = startswith(s, "/org/freedesktop/systemd1/job/");
1740 r = safe_atou(p, &id);
1744 j = manager_get_job(m, id);
1753 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1759 audit_fd = get_audit_fd();
1763 /* Don't generate audit events if the service was already
1764 * started and we're just deserializing */
1765 if (m->n_reloading > 0)
1768 if (m->running_as != SYSTEMD_SYSTEM)
1771 if (u->type != UNIT_SERVICE)
1774 p = unit_name_to_prefix_and_instance(u->id);
1776 log_error_unit(u->id,
1777 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1781 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1782 if (errno == EPERM) {
1783 /* We aren't allowed to send audit messages?
1784 * Then let's not retry again. */
1787 log_warning("Failed to send audit message: %m");
1795 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1797 union sockaddr_union sa;
1799 char *message = NULL;
1801 /* Don't generate plymouth events if the service was already
1802 * started and we're just deserializing */
1803 if (m->n_reloading > 0)
1806 if (m->running_as != SYSTEMD_SYSTEM)
1809 if (detect_container(NULL) > 0)
1812 if (u->type != UNIT_SERVICE &&
1813 u->type != UNIT_MOUNT &&
1814 u->type != UNIT_SWAP)
1817 /* We set SOCK_NONBLOCK here so that we rather drop the
1818 * message then wait for plymouth */
1819 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1821 log_error("socket() failed: %m");
1826 sa.sa.sa_family = AF_UNIX;
1827 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1828 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1830 if (errno != EPIPE &&
1833 errno != ECONNREFUSED &&
1834 errno != ECONNRESET &&
1835 errno != ECONNABORTED)
1836 log_error("connect() failed: %m");
1841 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1847 if (write(fd, message, n + 1) != n + 1) {
1849 if (errno != EPIPE &&
1852 errno != ECONNREFUSED &&
1853 errno != ECONNRESET &&
1854 errno != ECONNABORTED)
1855 log_error("Failed to write Plymouth message: %m");
1862 close_nointr_nofail(fd);
1867 void manager_dispatch_bus_name_owner_changed(
1870 const char* old_owner,
1871 const char *new_owner) {
1878 u = hashmap_get(m->watch_bus, name);
1882 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1885 int manager_open_serialization(Manager *m, FILE **_f) {
1892 if (m->running_as == SYSTEMD_SYSTEM)
1893 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1895 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1900 RUN_WITH_UMASK(0077) {
1901 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1911 log_debug("Serializing state to %s", path);
1914 f = fdopen(fd, "w+");
1923 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
1936 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1937 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1938 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1939 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1941 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1942 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1943 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1944 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1947 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1948 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1949 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
1950 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
1951 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
1952 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
1953 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
1954 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
1957 if (!switching_root) {
1958 STRV_FOREACH(e, m->environment) {
1959 _cleanup_free_ char *ce;
1963 fprintf(f, "env=%s\n", *e);
1967 bus_serialize(m, f);
1971 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1975 if (!unit_can_serialize(u))
1982 r = unit_serialize(u, f, fds, !switching_root);
1989 assert(m->n_reloading > 0);
1995 r = bus_fdset_add_all(m, fds);
2002 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2008 log_debug("Deserializing state...");
2013 char line[LINE_MAX], *l;
2015 if (!fgets(line, sizeof(line), f)) {
2030 if (startswith(l, "current-job-id=")) {
2033 if (safe_atou32(l+15, &id) < 0)
2034 log_debug("Failed to parse current job id value %s", l+15);
2036 m->current_job_id = MAX(m->current_job_id, id);
2038 } else if (startswith(l, "n-installed-jobs=")) {
2041 if (safe_atou32(l+17, &n) < 0)
2042 log_debug("Failed to parse installed jobs counter %s", l+17);
2044 m->n_installed_jobs += n;
2046 } else if (startswith(l, "n-failed-jobs=")) {
2049 if (safe_atou32(l+14, &n) < 0)
2050 log_debug("Failed to parse failed jobs counter %s", l+14);
2052 m->n_failed_jobs += n;
2054 } else if (startswith(l, "taint-usr=")) {
2057 if ((b = parse_boolean(l+10)) < 0)
2058 log_debug("Failed to parse taint /usr flag %s", l+10);
2060 m->taint_usr = m->taint_usr || b;
2062 } else if (startswith(l, "firmware-timestamp="))
2063 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2064 else if (startswith(l, "loader-timestamp="))
2065 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2066 else if (startswith(l, "kernel-timestamp="))
2067 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2068 else if (startswith(l, "initrd-timestamp="))
2069 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2070 else if (startswith(l, "userspace-timestamp="))
2071 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2072 else if (startswith(l, "finish-timestamp="))
2073 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2074 else if (startswith(l, "security-start-timestamp="))
2075 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2076 else if (startswith(l, "security-finish-timestamp="))
2077 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2078 else if (startswith(l, "generators-start-timestamp="))
2079 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2080 else if (startswith(l, "generators-finish-timestamp="))
2081 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2082 else if (startswith(l, "units-load-start-timestamp="))
2083 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2084 else if (startswith(l, "units-load-finish-timestamp="))
2085 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2086 else if (startswith(l, "env=")) {
2087 _cleanup_free_ char *uce = NULL;
2090 uce = cunescape(l+4);
2096 e = strv_env_set(m->environment, uce);
2102 strv_free(m->environment);
2104 } else if (bus_deserialize_item(m, l) == 0)
2105 log_debug("Unknown serialization item '%s'", l);
2110 char name[UNIT_NAME_MAX+2];
2113 if (!fgets(name, sizeof(name), f)) {
2124 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2128 r = unit_deserialize(u, f, fds);
2139 assert(m->n_reloading > 0);
2145 int manager_reload(Manager *m) {
2147 _cleanup_fclose_ FILE *f = NULL;
2148 _cleanup_fdset_free_ FDSet *fds = NULL;
2152 r = manager_open_serialization(m, &f);
2157 bus_manager_send_reloading(m, true);
2165 r = manager_serialize(m, f, fds, false);
2171 if (fseeko(f, 0, SEEK_SET) < 0) {
2176 /* From here on there is no way back. */
2177 manager_clear_jobs_and_units(m);
2178 manager_undo_generators(m);
2179 lookup_paths_free(&m->lookup_paths);
2181 /* Find new unit paths */
2182 manager_run_generators(m);
2184 q = lookup_paths_init(
2185 &m->lookup_paths, m->running_as, true,
2186 m->generator_unit_path,
2187 m->generator_unit_path_early,
2188 m->generator_unit_path_late);
2192 manager_build_unit_path_cache(m);
2194 /* First, enumerate what we can from all config files */
2195 q = manager_enumerate(m);
2199 /* Second, deserialize our stored data */
2200 q = manager_deserialize(m, f, fds);
2207 /* Third, fire things up! */
2208 q = manager_coldplug(m);
2212 assert(m->n_reloading > 0);
2215 m->send_reloading_done = true;
2220 static bool manager_is_booting_or_shutting_down(Manager *m) {
2225 /* Is the initial job still around? */
2226 if (manager_get_job(m, m->default_unit_job_id))
2229 /* Is there a job for the shutdown target? */
2230 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2237 bool manager_is_reloading_or_reexecuting(Manager *m) {
2240 return m->n_reloading != 0;
2243 void manager_reset_failed(Manager *m) {
2249 HASHMAP_FOREACH(u, m->units, i)
2250 unit_reset_failed(u);
2253 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2259 /* Returns true if the unit is inactive or going down */
2260 u = manager_get_unit(m, name);
2264 return unit_inactive_or_pending(u);
2267 void manager_check_finished(Manager *m) {
2268 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2269 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2273 if (m->n_running_jobs == 0)
2274 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2276 if (hashmap_size(m->jobs) > 0 && m->jobs_in_progress_event_source) {
2277 sd_event_source_set_time(m->jobs_in_progress_event_source, JOBS_IN_PROGRESS_PERIOD_SEC);
2281 /* Notify Type=idle units that we are done now */
2282 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2283 manager_close_idle_pipe(m);
2285 /* Turn off confirm spawn now */
2286 m->confirm_spawn = false;
2288 if (dual_timestamp_is_set(&m->finish_timestamp))
2291 dual_timestamp_get(&m->finish_timestamp);
2293 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2295 /* Note that m->kernel_usec.monotonic is always at 0,
2296 * and m->firmware_usec.monotonic and
2297 * m->loader_usec.monotonic should be considered
2298 * negative values. */
2300 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2301 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2302 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2303 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2305 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2307 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2308 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2310 if (!log_on_console())
2311 log_struct(LOG_INFO,
2312 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2313 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2314 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2315 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2316 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2317 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2318 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2319 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2320 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2323 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2326 if (!log_on_console())
2327 log_struct(LOG_INFO,
2328 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2329 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2330 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2331 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2332 format_timespan(kernel, sizeof(kernel), kernel_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),
2338 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2339 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2341 if (!log_on_console())
2342 log_struct(LOG_INFO,
2343 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2344 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2345 "MESSAGE=Startup finished in %s.",
2346 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2350 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2353 "READY=1\nSTATUS=Startup finished in %s.",
2354 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2357 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2368 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2370 p = strappend("/run/systemd/", name);
2374 r = mkdir_p_label(p, 0755);
2376 log_error("Failed to create generator directory %s: %s",
2382 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2387 log_error("Failed to create generator directory %s: %m",
2398 static void trim_generator_dir(Manager *m, char **generator) {
2405 if (rmdir(*generator) >= 0) {
2413 void manager_run_generators(Manager *m) {
2414 _cleanup_closedir_ DIR *d = NULL;
2415 const char *generator_path;
2416 const char *argv[5];
2421 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2422 d = opendir(generator_path);
2424 if (errno == ENOENT)
2427 log_error("Failed to enumerate generator directory %s: %m",
2432 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2436 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2440 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2444 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2445 argv[1] = m->generator_unit_path;
2446 argv[2] = m->generator_unit_path_early;
2447 argv[3] = m->generator_unit_path_late;
2450 RUN_WITH_UMASK(0022)
2451 execute_directory(generator_path, d, (char**) argv);
2454 trim_generator_dir(m, &m->generator_unit_path);
2455 trim_generator_dir(m, &m->generator_unit_path_early);
2456 trim_generator_dir(m, &m->generator_unit_path_late);
2459 static void remove_generator_dir(Manager *m, char **generator) {
2466 strv_remove(m->lookup_paths.unit_path, *generator);
2467 rm_rf(*generator, false, true, false);
2473 void manager_undo_generators(Manager *m) {
2476 remove_generator_dir(m, &m->generator_unit_path);
2477 remove_generator_dir(m, &m->generator_unit_path_early);
2478 remove_generator_dir(m, &m->generator_unit_path_late);
2481 int manager_environment_add(Manager *m, char **minus, char **plus) {
2482 char **a = NULL, **b = NULL, **l;
2487 if (!strv_isempty(minus)) {
2488 a = strv_env_delete(l, 1, minus);
2495 if (!strv_isempty(plus)) {
2496 b = strv_env_merge(2, l, plus);
2503 if (m->environment != l)
2504 strv_free(m->environment);
2514 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2519 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2520 if (!default_rlimit[i])
2523 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2531 void manager_recheck_journal(Manager *m) {
2536 if (m->running_as != SYSTEMD_SYSTEM)
2539 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2540 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2541 log_close_journal();
2545 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2546 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2547 log_close_journal();
2551 /* Hmm, OK, so the socket is fully up and the service is up
2552 * too, then let's make use of the thing. */
2556 void manager_set_show_status(Manager *m, bool b) {
2559 if (m->running_as != SYSTEMD_SYSTEM)
2565 touch("/run/systemd/show-status");
2567 unlink("/run/systemd/show-status");
2570 static bool manager_get_show_status(Manager *m) {
2573 if (m->running_as != SYSTEMD_SYSTEM)
2576 if (m->no_console_output)
2582 /* If Plymouth is running make sure we show the status, so
2583 * that there's something nice to see when people press Esc */
2585 return plymouth_running();
2588 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2591 if (!manager_get_show_status(m))
2594 /* XXX We should totally drop the check for ephemeral here
2595 * and thus effectively make 'Type=idle' pointless. */
2596 if (ephemeral && m->n_on_console > 0)
2599 if (!manager_is_booting_or_shutting_down(m))
2602 va_start(ap, format);
2603 status_vprintf(status, true, ephemeral, format, ap);
2607 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2608 _cleanup_free_ char *p = NULL;
2616 p = unit_name_from_path(path, suffix);
2620 found = manager_get_unit(m, p);
2630 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2631 char p[strlen(path)+1];
2637 path_kill_slashes(p);
2639 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);