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/>.
29 #include <sys/reboot.h>
30 #include <sys/ioctl.h>
34 #include <sys/types.h>
37 #include <sys/timerfd.h>
43 #include "sd-daemon.h"
45 #include "sd-messages.h"
48 #include "transaction.h"
55 #include "ratelimit.h"
56 #include "locale-setup.h"
57 #include "mount-setup.h"
58 #include "unit-name.h"
60 #include "path-lookup.h"
62 #include "exit-status.h"
65 #include "cgroup-util.h"
66 #include "path-util.h"
68 #include "boot-timestamps.h"
70 #include "bus-errors.h"
71 #include "bus-error.h"
74 #include "dbus-unit.h"
76 #include "dbus-manager.h"
77 #include "bus-kernel.h"
79 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
80 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
82 /* Initial delay and the interval for printing status messages about running jobs */
83 #define JOBS_IN_PROGRESS_WAIT_USEC (5*USEC_PER_SEC)
84 #define JOBS_IN_PROGRESS_PERIOD_USEC (USEC_PER_SEC / 3)
85 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
87 /* Where clients shall send notification messages to */
88 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
90 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
92 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
93 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
94 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
95 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
96 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
97 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
99 static int manager_watch_jobs_in_progress(Manager *m) {
104 if (m->jobs_in_progress_event_source)
107 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
108 log_debug("queuing for "USEC_FMT, next);
109 return sd_event_add_monotonic(m->event, next, 0, manager_dispatch_jobs_in_progress, m, &m->jobs_in_progress_event_source);
112 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
114 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
117 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
118 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
122 p = mempset(p, ' ', pos-2);
123 p = stpcpy(p, ANSI_RED_ON);
127 if (pos > 0 && pos <= width) {
128 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
132 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
135 p = stpcpy(p, ANSI_RED_ON);
138 p = mempset(p, ' ', width-1-pos);
139 strcpy(p, ANSI_HIGHLIGHT_OFF);
143 void manager_flip_auto_status(Manager *m, bool enable) {
145 if (m->show_status == SHOW_STATUS_AUTO)
146 manager_set_show_status(m, SHOW_STATUS_TEMPORARY);
148 if (m->show_status == SHOW_STATUS_TEMPORARY)
149 manager_set_show_status(m, SHOW_STATUS_AUTO);
153 static void manager_print_jobs_in_progress(Manager *m) {
154 _cleanup_free_ char *job_of_n = NULL;
157 unsigned counter = 0, print_nr;
158 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
160 char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
165 manager_flip_auto_status(m, true);
167 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
169 HASHMAP_FOREACH(j, m->jobs, i)
170 if (j->state == JOB_RUNNING && counter++ == print_nr)
173 /* m->n_running_jobs must be consistent with the contents of m->jobs,
174 * so the above loop must have succeeded in finding j. */
175 assert(counter == print_nr + 1);
178 cylon_pos = m->jobs_in_progress_iteration % 14;
180 cylon_pos = 14 - cylon_pos;
181 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
183 m->jobs_in_progress_iteration++;
185 if (m->n_running_jobs > 1)
186 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
189 format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
190 if (job_get_timeout(j, &x) > 0)
191 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
193 manager_status_printf(m, true, cylon,
194 "%sA %s job is running for %s (%s / %s)",
196 job_type_to_string(j->type),
197 unit_description(j->unit),
202 static int manager_watch_idle_pipe(Manager *m) {
207 if (m->idle_pipe_event_source)
210 if (m->idle_pipe[2] < 0)
213 r = sd_event_add_io(m->event, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m, &m->idle_pipe_event_source);
215 log_error("Failed to watch idle pipe: %s", strerror(-r));
222 static void manager_close_idle_pipe(Manager *m) {
225 close_pipe(m->idle_pipe);
226 close_pipe(m->idle_pipe + 2);
229 static int manager_setup_time_change(Manager *m) {
232 /* We only care for the cancellation event, hence we set the
233 * timeout to the latest possible value. */
234 struct itimerspec its = {
235 .it_value.tv_sec = TIME_T_MAX,
239 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
241 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
242 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
244 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
245 if (m->time_change_fd < 0) {
246 log_error("Failed to create timerfd: %m");
250 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
251 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
252 close_nointr_nofail(m->time_change_fd);
253 m->time_change_fd = -1;
257 r = sd_event_add_io(m->event, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m, &m->time_change_event_source);
259 log_error("Failed to create time change event source: %s", strerror(-r));
263 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
268 static int enable_special_signals(Manager *m) {
269 _cleanup_close_ int fd = -1;
273 /* Enable that we get SIGINT on control-alt-del. In containers
274 * this will fail with EPERM (older) or EINVAL (newer), so
276 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
277 log_warning("Failed to enable ctrl-alt-del handling: %m");
279 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
281 /* Support systems without virtual console */
283 log_warning("Failed to open /dev/tty0: %m");
285 /* Enable that we get SIGWINCH on kbrequest */
286 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
287 log_warning("Failed to enable kbrequest handling: %m");
293 static int manager_setup_signals(Manager *m) {
294 struct sigaction sa = {
295 .sa_handler = SIG_DFL,
296 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
303 /* We are not interested in SIGSTOP and friends. */
304 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
306 assert_se(sigemptyset(&mask) == 0);
308 sigset_add_many(&mask,
309 SIGCHLD, /* Child died */
310 SIGTERM, /* Reexecute daemon */
311 SIGHUP, /* Reload configuration */
312 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
313 SIGUSR2, /* systemd: dump status */
314 SIGINT, /* Kernel sends us this on control-alt-del */
315 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
316 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
317 SIGRTMIN+0, /* systemd: start default.target */
318 SIGRTMIN+1, /* systemd: isolate rescue.target */
319 SIGRTMIN+2, /* systemd: isolate emergency.target */
320 SIGRTMIN+3, /* systemd: start halt.target */
321 SIGRTMIN+4, /* systemd: start poweroff.target */
322 SIGRTMIN+5, /* systemd: start reboot.target */
323 SIGRTMIN+6, /* systemd: start kexec.target */
324 SIGRTMIN+13, /* systemd: Immediate halt */
325 SIGRTMIN+14, /* systemd: Immediate poweroff */
326 SIGRTMIN+15, /* systemd: Immediate reboot */
327 SIGRTMIN+16, /* systemd: Immediate kexec */
328 SIGRTMIN+20, /* systemd: enable status messages */
329 SIGRTMIN+21, /* systemd: disable status messages */
330 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
331 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
332 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
333 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
334 SIGRTMIN+27, /* systemd: set log target to console */
335 SIGRTMIN+28, /* systemd: set log target to kmsg */
336 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
338 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
340 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
341 if (m->signal_fd < 0)
344 r = sd_event_add_io(m->event, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m, &m->signal_event_source);
348 /* Process signals a bit earlier than the rest of things, but
349 * later that notify_fd processing, so that the notify
350 * processing can still figure out to which process/service a
351 * message belongs, before we reap the process. */
352 r = sd_event_source_set_priority(m->signal_event_source, -5);
356 if (m->running_as == SYSTEMD_SYSTEM)
357 return enable_special_signals(m);
362 static void manager_clean_environment(Manager *m) {
365 /* Let's remove some environment variables that we
366 * need ourselves to communicate with our clients */
379 static int manager_default_environment(Manager *m) {
382 if (m->running_as == SYSTEMD_SYSTEM) {
383 /* The system manager always starts with a clean
384 * environment for its children. It does not import
385 * the kernel or the parents exported variables.
387 * The initial passed environ is untouched to keep
388 * /proc/self/environ valid; it is used for tagging
389 * the init process inside containers. */
390 m->environment = strv_new("PATH=" DEFAULT_PATH,
393 /* Import locale variables LC_*= from configuration */
394 locale_setup(&m->environment);
396 /* The user manager passes its own environment
397 * along to its children. */
398 m->environment = strv_copy(environ);
404 manager_clean_environment(m);
405 strv_sort(m->environment);
410 int manager_new(SystemdRunningAs running_as, Manager **_m) {
415 assert(running_as >= 0);
416 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
418 m = new0(Manager, 1);
423 if (detect_container(NULL) <= 0)
424 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
427 m->running_as = running_as;
428 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
430 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
432 m->pin_cgroupfs_fd = m->notify_fd = m->signal_fd = m->time_change_fd = m->dev_autofs_fd = m->private_listen_fd = m->kdbus_fd = -1;
433 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
435 r = manager_default_environment(m);
439 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
443 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
447 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
451 r = hashmap_ensure_allocated(&m->watch_pids, trivial_hash_func, trivial_compare_func);
455 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
459 r = sd_event_default(&m->event);
463 r = sd_event_add_defer(m->event, manager_dispatch_run_queue, m, &m->run_queue_event_source);
467 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
471 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
475 r = manager_setup_signals(m);
479 r = manager_setup_cgroup(m);
483 r = manager_setup_time_change(m);
487 m->udev = udev_new();
493 /* Note that we set up neither kdbus, nor the notify fd
494 * here. We do that after deserialization, since they might
495 * have gotten serialized across the reexec. */
497 m->taint_usr = dir_is_empty("/usr") > 0;
507 static int manager_setup_notify(Manager *m) {
510 struct sockaddr_un un;
512 .sa.sa_family = AF_UNIX,
516 if (m->notify_fd < 0) {
517 _cleanup_close_ int fd = -1;
519 /* First free all secondary fields */
520 free(m->notify_socket);
521 m->notify_socket = NULL;
522 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
524 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
526 log_error("Failed to allocate notification socket: %m");
530 if (getpid() != 1 || detect_container(NULL) > 0)
531 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%" PRIx64, random_u64());
533 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
534 sa.un.sun_path[0] = 0;
536 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
538 log_error("bind() failed: %m");
542 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
544 log_error("SO_PASSCRED failed: %m");
548 sa.un.sun_path[0] = '@';
549 m->notify_socket = strdup(sa.un.sun_path);
550 if (!m->notify_socket)
556 log_debug("Using notification socket %s", m->notify_socket);
559 if (!m->notify_event_source) {
560 r = sd_event_add_io(m->event, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m, &m->notify_event_source);
562 log_error("Failed to allocate notify event source: %s", strerror(-r));
566 /* Process signals a bit earlier than SIGCHLD, so that we can
567 * still identify to which service an exit message belongs */
568 r = sd_event_source_set_priority(m->notify_event_source, -7);
570 log_error("Failed to set priority of notify event source: %s", strerror(-r));
578 static int manager_setup_kdbus(Manager *m) {
580 _cleanup_free_ char *p = NULL;
586 if (m->kdbus_fd >= 0)
589 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
590 if (m->kdbus_fd < 0) {
591 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
595 log_debug("Successfully set up kdbus on %s", p);
597 /* Create the namespace directory here, so that the contents
598 * of that directory is not visible to non-root users. This is
599 * necessary to ensure that users cannot get access to busses
600 * of virtualized users when no UID namespacing is used. */
601 if (m->running_as == SYSTEMD_SYSTEM)
602 mkdir_p_label("/dev/kdbus/ns", 0700);
608 static int manager_connect_bus(Manager *m, bool reexecuting) {
609 bool try_bus_connect;
616 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
618 /* Try to connect to the busses, if possible. */
619 return bus_init(m, try_bus_connect);
622 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
628 while ((u = m->cleanup_queue)) {
629 assert(u->in_cleanup_queue);
639 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
640 GC_OFFSET_UNSURE, /* No clue */
641 GC_OFFSET_GOOD, /* We still need this unit */
642 GC_OFFSET_BAD, /* We don't need this unit anymore */
646 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
653 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
654 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
655 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
658 if (u->in_cleanup_queue)
661 if (unit_check_gc(u))
664 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
668 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
669 unit_gc_sweep(other, gc_marker);
671 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
674 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
681 /* We were unable to find anything out about this entry, so
682 * let's investigate it later */
683 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
684 unit_add_to_gc_queue(u);
688 /* We definitely know that this one is not useful anymore, so
689 * let's mark it for deletion */
690 u->gc_marker = gc_marker + GC_OFFSET_BAD;
691 unit_add_to_cleanup_queue(u);
695 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
698 static unsigned manager_dispatch_gc_queue(Manager *m) {
705 /* log_debug("Running GC..."); */
707 m->gc_marker += _GC_OFFSET_MAX;
708 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
711 gc_marker = m->gc_marker;
713 while ((u = m->gc_queue)) {
714 assert(u->in_gc_queue);
716 unit_gc_sweep(u, gc_marker);
718 LIST_REMOVE(gc_queue, m->gc_queue, u);
719 u->in_gc_queue = false;
723 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
724 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
725 log_debug_unit(u->id, "Collecting %s", u->id);
726 u->gc_marker = gc_marker + GC_OFFSET_BAD;
727 unit_add_to_cleanup_queue(u);
731 m->n_in_gc_queue = 0;
736 static void manager_clear_jobs_and_units(Manager *m) {
741 while ((u = hashmap_first(m->units)))
744 manager_dispatch_cleanup_queue(m);
746 assert(!m->load_queue);
747 assert(!m->run_queue);
748 assert(!m->dbus_unit_queue);
749 assert(!m->dbus_job_queue);
750 assert(!m->cleanup_queue);
751 assert(!m->gc_queue);
753 assert(hashmap_isempty(m->jobs));
754 assert(hashmap_isempty(m->units));
757 m->n_running_jobs = 0;
760 void manager_free(Manager *m) {
766 manager_clear_jobs_and_units(m);
768 for (c = 0; c < _UNIT_TYPE_MAX; c++)
769 if (unit_vtable[c]->shutdown)
770 unit_vtable[c]->shutdown(m);
772 /* If we reexecute ourselves, we keep the root cgroup
774 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
776 manager_undo_generators(m);
780 hashmap_free(m->units);
781 hashmap_free(m->jobs);
782 hashmap_free(m->watch_pids);
783 hashmap_free(m->watch_bus);
785 sd_event_source_unref(m->signal_event_source);
786 sd_event_source_unref(m->notify_event_source);
787 sd_event_source_unref(m->time_change_event_source);
788 sd_event_source_unref(m->jobs_in_progress_event_source);
789 sd_event_source_unref(m->idle_pipe_event_source);
790 sd_event_source_unref(m->run_queue_event_source);
792 if (m->signal_fd >= 0)
793 close_nointr_nofail(m->signal_fd);
794 if (m->notify_fd >= 0)
795 close_nointr_nofail(m->notify_fd);
796 if (m->time_change_fd >= 0)
797 close_nointr_nofail(m->time_change_fd);
798 if (m->kdbus_fd >= 0)
799 close_nointr_nofail(m->kdbus_fd);
801 manager_close_idle_pipe(m);
804 sd_event_unref(m->event);
806 free(m->notify_socket);
808 lookup_paths_free(&m->lookup_paths);
809 strv_free(m->environment);
811 hashmap_free(m->cgroup_unit);
812 set_free_free(m->unit_path_cache);
814 free(m->switch_root);
815 free(m->switch_root_init);
817 for (i = 0; i < RLIMIT_NLIMITS; i++)
820 assert(hashmap_isempty(m->units_requiring_mounts_for));
821 hashmap_free(m->units_requiring_mounts_for);
826 int manager_enumerate(Manager *m) {
832 /* Let's ask every type to load all units from disk/kernel
833 * that it might know */
834 for (c = 0; c < _UNIT_TYPE_MAX; c++)
835 if (unit_vtable[c]->enumerate) {
836 q = unit_vtable[c]->enumerate(m);
841 manager_dispatch_load_queue(m);
845 static int manager_coldplug(Manager *m) {
853 /* Then, let's set up their initial state. */
854 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
860 if ((q = unit_coldplug(u)) < 0)
867 static void manager_build_unit_path_cache(Manager *m) {
869 _cleanup_free_ DIR *d = NULL;
874 set_free_free(m->unit_path_cache);
876 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
877 if (!m->unit_path_cache) {
878 log_error("Failed to allocate unit path cache.");
882 /* This simply builds a list of files we know exist, so that
883 * we don't always have to go to disk */
885 STRV_FOREACH(i, m->lookup_paths.unit_path) {
891 log_error("Failed to open directory %s: %m", *i);
895 while ((de = readdir(d))) {
898 if (ignore_file(de->d_name))
901 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
907 r = set_consume(m->unit_path_cache, p);
919 log_error("Failed to build unit path cache: %s", strerror(-r));
921 set_free_free(m->unit_path_cache);
922 m->unit_path_cache = NULL;
926 static int manager_distribute_fds(Manager *m, FDSet *fds) {
933 HASHMAP_FOREACH(u, m->units, i) {
935 if (fdset_size(fds) <= 0)
938 if (UNIT_VTABLE(u)->distribute_fds) {
939 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
948 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
953 dual_timestamp_get(&m->generators_start_timestamp);
954 manager_run_generators(m);
955 dual_timestamp_get(&m->generators_finish_timestamp);
957 r = lookup_paths_init(
958 &m->lookup_paths, m->running_as, true,
959 m->generator_unit_path,
960 m->generator_unit_path_early,
961 m->generator_unit_path_late);
965 manager_build_unit_path_cache(m);
967 /* If we will deserialize make sure that during enumeration
968 * this is already known, so we increase the counter here
973 /* First, enumerate what we can from all config files */
974 dual_timestamp_get(&m->units_load_start_timestamp);
975 r = manager_enumerate(m);
976 dual_timestamp_get(&m->units_load_finish_timestamp);
978 /* Second, deserialize if there is something to deserialize */
980 q = manager_deserialize(m, serialization, fds);
985 /* Any fds left? Find some unit which wants them. This is
986 * useful to allow container managers to pass some file
987 * descriptors to us pre-initialized. This enables
988 * socket-based activation of entire containers. */
989 if (fdset_size(fds) > 0) {
990 q = manager_distribute_fds(m, fds);
995 /* We might have deserialized the notify fd, but if we didn't
996 * then let's create the bus now */
997 manager_setup_notify(m);
999 /* We might have deserialized the kdbus control fd, but if we
1000 * didn't, then let's create the bus now. */
1001 manager_setup_kdbus(m);
1002 manager_connect_bus(m, !!serialization);
1004 /* Third, fire things up! */
1005 q = manager_coldplug(m);
1009 if (serialization) {
1010 assert(m->n_reloading > 0);
1013 /* Let's wait for the UnitNew/JobNew messages being
1014 * sent, before we notify that the reload is
1016 m->send_reloading_done = true;
1022 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1027 assert(type < _JOB_TYPE_MAX);
1029 assert(mode < _JOB_MODE_MAX);
1031 if (mode == JOB_ISOLATE && type != JOB_START) {
1032 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1036 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1037 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1041 log_debug_unit(unit->id,
1042 "Trying to enqueue job %s/%s/%s", unit->id,
1043 job_type_to_string(type), job_mode_to_string(mode));
1045 job_type_collapse(&type, unit);
1047 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1051 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1052 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1053 mode == JOB_IGNORE_DEPENDENCIES, e);
1057 if (mode == JOB_ISOLATE) {
1058 r = transaction_add_isolate_jobs(tr, m);
1063 r = transaction_activate(tr, m, mode, e);
1067 log_debug_unit(unit->id,
1068 "Enqueued job %s/%s as %u", unit->id,
1069 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1072 *_ret = tr->anchor_job;
1074 transaction_free(tr);
1078 transaction_abort(tr);
1079 transaction_free(tr);
1083 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1088 assert(type < _JOB_TYPE_MAX);
1090 assert(mode < _JOB_MODE_MAX);
1092 r = manager_load_unit(m, name, NULL, NULL, &unit);
1096 return manager_add_job(m, type, unit, mode, override, e, _ret);
1099 Job *manager_get_job(Manager *m, uint32_t id) {
1102 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1105 Unit *manager_get_unit(Manager *m, const char *name) {
1109 return hashmap_get(m->units, name);
1112 unsigned manager_dispatch_load_queue(Manager *m) {
1118 /* Make sure we are not run recursively */
1119 if (m->dispatching_load_queue)
1122 m->dispatching_load_queue = true;
1124 /* Dispatches the load queue. Takes a unit from the queue and
1125 * tries to load its data until the queue is empty */
1127 while ((u = m->load_queue)) {
1128 assert(u->in_load_queue);
1134 m->dispatching_load_queue = false;
1138 int manager_load_unit_prepare(
1150 assert(name || path);
1152 /* This will prepare the unit for loading, but not actually
1153 * load anything from disk. */
1155 if (path && !is_path(path))
1156 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1159 name = basename(path);
1161 t = unit_name_to_type(name);
1163 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1164 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1166 ret = manager_get_unit(m, name);
1172 ret = unit_new(m, unit_vtable[t]->object_size);
1177 ret->fragment_path = strdup(path);
1178 if (!ret->fragment_path) {
1184 r = unit_add_name(ret, name);
1190 unit_add_to_load_queue(ret);
1191 unit_add_to_dbus_queue(ret);
1192 unit_add_to_gc_queue(ret);
1200 int manager_load_unit(
1211 /* This will load the service information files, but not actually
1212 * start any services or anything. */
1214 r = manager_load_unit_prepare(m, name, path, e, _ret);
1218 manager_dispatch_load_queue(m);
1221 *_ret = unit_follow_merge(*_ret);
1226 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1233 HASHMAP_FOREACH(j, s->jobs, i)
1234 job_dump(j, f, prefix);
1237 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1245 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1247 unit_dump(u, f, prefix);
1250 void manager_clear_jobs(Manager *m) {
1255 while ((j = hashmap_first(m->jobs)))
1256 /* No need to recurse. We're cancelling all jobs. */
1257 job_finish_and_invalidate(j, JOB_CANCELED, false);
1260 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1261 Manager *m = userdata;
1267 while ((j = m->run_queue)) {
1268 assert(j->installed);
1269 assert(j->in_run_queue);
1271 job_run_and_invalidate(j);
1274 if (m->n_running_jobs > 0)
1275 manager_watch_jobs_in_progress(m);
1277 if (m->n_on_console > 0)
1278 manager_watch_idle_pipe(m);
1283 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1290 if (m->dispatching_dbus_queue)
1293 m->dispatching_dbus_queue = true;
1295 while ((u = m->dbus_unit_queue)) {
1296 assert(u->in_dbus_queue);
1298 bus_unit_send_change_signal(u);
1302 while ((j = m->dbus_job_queue)) {
1303 assert(j->in_dbus_queue);
1305 bus_job_send_change_signal(j);
1309 m->dispatching_dbus_queue = false;
1311 if (m->send_reloading_done) {
1312 m->send_reloading_done = false;
1314 bus_manager_send_reloading(m, false);
1317 if (m->queued_message)
1318 bus_send_queued_message(m);
1323 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1324 Manager *m = userdata;
1328 assert(m->notify_fd == fd);
1330 if (revents != EPOLLIN) {
1331 log_warning("Got unexpected poll event for notify fd.");
1337 struct iovec iovec = {
1339 .iov_len = sizeof(buf)-1,
1343 struct cmsghdr cmsghdr;
1344 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1347 struct msghdr msghdr = {
1350 .msg_control = &control,
1351 .msg_controllen = sizeof(control),
1353 struct ucred *ucred;
1355 _cleanup_strv_free_ char **tags = NULL;
1357 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1362 if (errno == EAGAIN || errno == EINTR)
1368 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1369 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1370 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1371 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1372 log_warning("Received notify message without credentials. Ignoring.");
1376 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1378 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1380 u = manager_get_unit_by_pid(m, ucred->pid);
1382 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1387 assert((size_t) n < sizeof(buf));
1389 tags = strv_split(buf, "\n\r");
1393 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1395 if (UNIT_VTABLE(u)->notify_message)
1396 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1402 static int manager_dispatch_sigchld(Manager *m) {
1409 /* First we call waitd() for a PID and do not reap the
1410 * zombie. That way we can still access /proc/$PID for
1411 * it while it is a zombie. */
1412 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1414 if (errno == ECHILD)
1426 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1427 _cleanup_free_ char *name = NULL;
1429 get_process_comm(si.si_pid, &name);
1430 log_debug("Got SIGCHLD for process "PID_FMT" (%s)", si.si_pid, strna(name));
1433 /* And now figure out the unit this belongs to */
1434 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1436 u = manager_get_unit_by_pid(m, si.si_pid);
1438 /* And now, we actually reap the zombie. */
1439 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1446 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1449 log_debug("Child %lu died (code=%s, status=%i/%s)",
1450 (long unsigned) si.si_pid,
1451 sigchld_code_to_string(si.si_code),
1453 strna(si.si_code == CLD_EXITED
1454 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1455 : signal_to_string(si.si_status)));
1460 log_debug_unit(u->id,
1461 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1463 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1464 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1470 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1471 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1474 log_debug_unit(name, "Activating special unit %s", name);
1476 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1478 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1483 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1484 Manager *m = userdata;
1486 struct signalfd_siginfo sfsi;
1487 bool sigchld = false;
1490 assert(m->signal_fd == fd);
1492 if (revents != EPOLLIN) {
1493 log_warning("Got unexpected events from signal file descriptor.");
1498 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1499 if (n != sizeof(sfsi)) {
1504 if (errno == EINTR || errno == EAGAIN)
1510 if (sfsi.ssi_pid > 0) {
1511 _cleanup_free_ char *p = NULL;
1513 get_process_comm(sfsi.ssi_pid, &p);
1515 log_full(sfsi.ssi_signo == SIGCHLD ||
1516 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1517 ? LOG_DEBUG : LOG_INFO,
1518 "Received SIG%s from PID "PID_FMT" (%s).",
1519 signal_to_string(sfsi.ssi_signo),
1520 sfsi.ssi_pid, strna(p));
1522 log_full(sfsi.ssi_signo == SIGCHLD ||
1523 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1524 ? LOG_DEBUG : LOG_INFO,
1526 signal_to_string(sfsi.ssi_signo));
1528 switch (sfsi.ssi_signo) {
1535 if (m->running_as == SYSTEMD_SYSTEM) {
1536 /* This is for compatibility with the
1537 * original sysvinit */
1538 m->exit_code = MANAGER_REEXECUTE;
1545 if (m->running_as == SYSTEMD_SYSTEM) {
1546 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1550 /* Run the exit target if there is one, if not, just exit. */
1551 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1552 m->exit_code = MANAGER_EXIT;
1559 if (m->running_as == SYSTEMD_SYSTEM)
1560 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1562 /* This is a nop on non-init */
1566 if (m->running_as == SYSTEMD_SYSTEM)
1567 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1569 /* This is a nop on non-init */
1575 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1577 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1578 log_info("Trying to reconnect to bus...");
1582 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1583 log_info("Loading D-Bus service...");
1584 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1591 _cleanup_free_ char *dump = NULL;
1592 _cleanup_fclose_ FILE *f = NULL;
1595 f = open_memstream(&dump, &size);
1597 log_warning("Failed to allocate memory stream.");
1601 manager_dump_units(m, f, "\t");
1602 manager_dump_jobs(m, f, "\t");
1605 log_warning("Failed to write status stream");
1609 log_dump(LOG_INFO, dump);
1614 m->exit_code = MANAGER_RELOAD;
1619 /* Starting SIGRTMIN+0 */
1620 static const char * const target_table[] = {
1621 [0] = SPECIAL_DEFAULT_TARGET,
1622 [1] = SPECIAL_RESCUE_TARGET,
1623 [2] = SPECIAL_EMERGENCY_TARGET,
1624 [3] = SPECIAL_HALT_TARGET,
1625 [4] = SPECIAL_POWEROFF_TARGET,
1626 [5] = SPECIAL_REBOOT_TARGET,
1627 [6] = SPECIAL_KEXEC_TARGET
1630 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1631 static const ManagerExitCode code_table[] = {
1633 [1] = MANAGER_POWEROFF,
1634 [2] = MANAGER_REBOOT,
1638 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1639 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1640 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1641 manager_start_target(m, target_table[idx],
1642 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1646 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1647 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1648 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1652 switch (sfsi.ssi_signo - SIGRTMIN) {
1655 log_debug("Enabling showing of status.");
1656 manager_set_show_status(m, SHOW_STATUS_YES);
1660 log_debug("Disabling showing of status.");
1661 manager_set_show_status(m, SHOW_STATUS_NO);
1665 log_set_max_level(LOG_DEBUG);
1666 log_notice("Setting log level to debug.");
1670 log_set_max_level(LOG_INFO);
1671 log_notice("Setting log level to info.");
1675 if (m->running_as == SYSTEMD_USER) {
1676 m->exit_code = MANAGER_EXIT;
1680 /* This is a nop on init */
1684 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1685 log_notice("Setting log target to journal-or-kmsg.");
1689 log_set_target(LOG_TARGET_CONSOLE);
1690 log_notice("Setting log target to console.");
1694 log_set_target(LOG_TARGET_KMSG);
1695 log_notice("Setting log target to kmsg.");
1699 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1700 log_notice("Setting log target to syslog-or-kmsg.");
1704 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1711 manager_dispatch_sigchld(m);
1716 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1717 Manager *m = userdata;
1722 assert(m->time_change_fd == fd);
1724 log_struct(LOG_INFO,
1725 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1726 "MESSAGE=Time has been changed",
1729 /* Restart the watch */
1730 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1732 close_nointr_nofail(m->time_change_fd);
1733 m->time_change_fd = -1;
1735 manager_setup_time_change(m);
1737 HASHMAP_FOREACH(u, m->units, i)
1738 if (UNIT_VTABLE(u)->time_change)
1739 UNIT_VTABLE(u)->time_change(u);
1744 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1745 Manager *m = userdata;
1748 assert(m->idle_pipe[2] == fd);
1750 m->no_console_output = m->n_on_console > 0;
1752 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1753 manager_close_idle_pipe(m);
1758 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1759 Manager *m = userdata;
1766 manager_print_jobs_in_progress(m);
1768 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1769 log_debug("requeuing for "USEC_FMT, next);
1770 r = sd_event_source_set_time(source, next);
1774 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1777 int manager_loop(Manager *m) {
1780 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1783 m->exit_code = MANAGER_RUNNING;
1785 /* Release the path cache */
1786 set_free_free(m->unit_path_cache);
1787 m->unit_path_cache = NULL;
1789 manager_check_finished(m);
1791 /* There might still be some zombies hanging around from
1792 * before we were exec()'ed. Let's reap them. */
1793 r = manager_dispatch_sigchld(m);
1797 while (m->exit_code == MANAGER_RUNNING) {
1800 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1803 if (!ratelimit_test(&rl)) {
1804 /* Yay, something is going seriously wrong, pause a little */
1805 log_warning("Looping too fast. Throttling execution a little.");
1810 if (manager_dispatch_load_queue(m) > 0)
1813 if (manager_dispatch_gc_queue(m) > 0)
1816 if (manager_dispatch_cleanup_queue(m) > 0)
1819 if (manager_dispatch_cgroup_queue(m) > 0)
1822 if (manager_dispatch_dbus_queue(m) > 0)
1825 /* Sleep for half the watchdog time */
1826 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1827 wait_usec = m->runtime_watchdog / 2;
1831 wait_usec = (usec_t) -1;
1833 r = sd_event_run(m->event, wait_usec);
1835 log_error("Failed to run event loop: %s", strerror(-r));
1840 return m->exit_code;
1843 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1844 _cleanup_free_ char *n = NULL;
1852 r = unit_name_from_dbus_path(s, &n);
1856 r = manager_load_unit(m, n, NULL, e, &u);
1865 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1875 p = startswith(s, "/org/freedesktop/systemd1/job/");
1879 r = safe_atou(p, &id);
1883 j = manager_get_job(m, id);
1892 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1898 audit_fd = get_audit_fd();
1902 /* Don't generate audit events if the service was already
1903 * started and we're just deserializing */
1904 if (m->n_reloading > 0)
1907 if (m->running_as != SYSTEMD_SYSTEM)
1910 if (u->type != UNIT_SERVICE)
1913 p = unit_name_to_prefix_and_instance(u->id);
1915 log_error_unit(u->id,
1916 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1920 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1921 if (errno == EPERM) {
1922 /* We aren't allowed to send audit messages?
1923 * Then let's not retry again. */
1926 log_warning("Failed to send audit message: %m");
1934 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1936 union sockaddr_union sa;
1938 char *message = NULL;
1940 /* Don't generate plymouth events if the service was already
1941 * started and we're just deserializing */
1942 if (m->n_reloading > 0)
1945 if (m->running_as != SYSTEMD_SYSTEM)
1948 if (detect_container(NULL) > 0)
1951 if (u->type != UNIT_SERVICE &&
1952 u->type != UNIT_MOUNT &&
1953 u->type != UNIT_SWAP)
1956 /* We set SOCK_NONBLOCK here so that we rather drop the
1957 * message then wait for plymouth */
1958 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1960 log_error("socket() failed: %m");
1965 sa.sa.sa_family = AF_UNIX;
1966 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1967 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1969 if (errno != EPIPE &&
1972 errno != ECONNREFUSED &&
1973 errno != ECONNRESET &&
1974 errno != ECONNABORTED)
1975 log_error("connect() failed: %m");
1980 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1986 if (write(fd, message, n + 1) != n + 1) {
1988 if (errno != EPIPE &&
1991 errno != ECONNREFUSED &&
1992 errno != ECONNRESET &&
1993 errno != ECONNABORTED)
1994 log_error("Failed to write Plymouth message: %m");
2001 close_nointr_nofail(fd);
2006 void manager_dispatch_bus_name_owner_changed(
2009 const char* old_owner,
2010 const char *new_owner) {
2017 u = hashmap_get(m->watch_bus, name);
2021 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2024 int manager_open_serialization(Manager *m, FILE **_f) {
2031 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2032 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2036 log_debug("Serializing state to %s", path);
2038 f = fdopen(fd, "w+");
2040 close_nointr_nofail(fd);
2049 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2062 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2063 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2064 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2065 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2067 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2068 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2069 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2070 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2073 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2074 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2075 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2076 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2077 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2078 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2079 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2080 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2083 if (!switching_root) {
2084 STRV_FOREACH(e, m->environment) {
2085 _cleanup_free_ char *ce;
2091 fprintf(f, "env=%s\n", *e);
2095 if (m->notify_fd >= 0) {
2098 copy = fdset_put_dup(fds, m->notify_fd);
2102 fprintf(f, "notify-fd=%i\n", copy);
2103 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2106 if (m->kdbus_fd >= 0) {
2109 copy = fdset_put_dup(fds, m->kdbus_fd);
2113 fprintf(f, "kdbus-fd=%i\n", copy);
2116 bus_serialize(m, f);
2120 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2124 if (!unit_can_serialize(u))
2131 r = unit_serialize(u, f, fds, !switching_root);
2138 assert(m->n_reloading > 0);
2144 r = bus_fdset_add_all(m, fds);
2151 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2157 log_debug("Deserializing state...");
2162 char line[LINE_MAX], *l;
2164 if (!fgets(line, sizeof(line), f)) {
2179 if (startswith(l, "current-job-id=")) {
2182 if (safe_atou32(l+15, &id) < 0)
2183 log_debug("Failed to parse current job id value %s", l+15);
2185 m->current_job_id = MAX(m->current_job_id, id);
2187 } else if (startswith(l, "n-installed-jobs=")) {
2190 if (safe_atou32(l+17, &n) < 0)
2191 log_debug("Failed to parse installed jobs counter %s", l+17);
2193 m->n_installed_jobs += n;
2195 } else if (startswith(l, "n-failed-jobs=")) {
2198 if (safe_atou32(l+14, &n) < 0)
2199 log_debug("Failed to parse failed jobs counter %s", l+14);
2201 m->n_failed_jobs += n;
2203 } else if (startswith(l, "taint-usr=")) {
2206 b = parse_boolean(l+10);
2208 log_debug("Failed to parse taint /usr flag %s", l+10);
2210 m->taint_usr = m->taint_usr || b;
2212 } else if (startswith(l, "firmware-timestamp="))
2213 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2214 else if (startswith(l, "loader-timestamp="))
2215 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2216 else if (startswith(l, "kernel-timestamp="))
2217 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2218 else if (startswith(l, "initrd-timestamp="))
2219 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2220 else if (startswith(l, "userspace-timestamp="))
2221 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2222 else if (startswith(l, "finish-timestamp="))
2223 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2224 else if (startswith(l, "security-start-timestamp="))
2225 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2226 else if (startswith(l, "security-finish-timestamp="))
2227 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2228 else if (startswith(l, "generators-start-timestamp="))
2229 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2230 else if (startswith(l, "generators-finish-timestamp="))
2231 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2232 else if (startswith(l, "units-load-start-timestamp="))
2233 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2234 else if (startswith(l, "units-load-finish-timestamp="))
2235 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2236 else if (startswith(l, "env=")) {
2237 _cleanup_free_ char *uce = NULL;
2240 uce = cunescape(l+4);
2246 e = strv_env_set(m->environment, uce);
2252 strv_free(m->environment);
2255 } else if (startswith(l, "notify-fd=")) {
2258 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2259 log_debug("Failed to parse notify fd: %s", l + 10);
2261 if (m->notify_fd >= 0) {
2262 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2263 close_nointr_nofail(m->notify_fd);
2266 m->notify_fd = fdset_remove(fds, fd);
2269 } else if (startswith(l, "notify-socket=")) {
2278 free(m->notify_socket);
2279 m->notify_socket = n;
2281 } else if (startswith(l, "kdbus-fd=")) {
2284 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2285 log_debug("Failed to parse kdbus fd: %s", l + 9);
2287 if (m->kdbus_fd >= 0)
2288 close_nointr_nofail(m->kdbus_fd);
2290 m->kdbus_fd = fdset_remove(fds, fd);
2293 } else if (bus_deserialize_item(m, l) == 0)
2294 log_debug("Unknown serialization item '%s'", l);
2299 char name[UNIT_NAME_MAX+2];
2302 if (!fgets(name, sizeof(name), f)) {
2313 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2317 r = unit_deserialize(u, f, fds);
2326 assert(m->n_reloading > 0);
2332 int manager_reload(Manager *m) {
2334 _cleanup_fclose_ FILE *f = NULL;
2335 _cleanup_fdset_free_ FDSet *fds = NULL;
2339 r = manager_open_serialization(m, &f);
2344 bus_manager_send_reloading(m, true);
2352 r = manager_serialize(m, f, fds, false);
2358 if (fseeko(f, 0, SEEK_SET) < 0) {
2363 /* From here on there is no way back. */
2364 manager_clear_jobs_and_units(m);
2365 manager_undo_generators(m);
2366 lookup_paths_free(&m->lookup_paths);
2368 /* Find new unit paths */
2369 manager_run_generators(m);
2371 q = lookup_paths_init(
2372 &m->lookup_paths, m->running_as, true,
2373 m->generator_unit_path,
2374 m->generator_unit_path_early,
2375 m->generator_unit_path_late);
2379 manager_build_unit_path_cache(m);
2381 /* First, enumerate what we can from all config files */
2382 q = manager_enumerate(m);
2386 /* Second, deserialize our stored data */
2387 q = manager_deserialize(m, f, fds);
2394 /* Re-register notify_fd as event source */
2395 q = manager_setup_notify(m);
2399 /* Third, fire things up! */
2400 q = manager_coldplug(m);
2404 assert(m->n_reloading > 0);
2407 m->send_reloading_done = true;
2412 static bool manager_is_booting_or_shutting_down(Manager *m) {
2417 /* Is the initial job still around? */
2418 if (manager_get_job(m, m->default_unit_job_id))
2421 /* Is there a job for the shutdown target? */
2422 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2429 bool manager_is_reloading_or_reexecuting(Manager *m) {
2432 return m->n_reloading != 0;
2435 void manager_reset_failed(Manager *m) {
2441 HASHMAP_FOREACH(u, m->units, i)
2442 unit_reset_failed(u);
2445 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2451 /* Returns true if the unit is inactive or going down */
2452 u = manager_get_unit(m, name);
2456 return unit_inactive_or_pending(u);
2459 void manager_check_finished(Manager *m) {
2460 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2461 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2465 if (m->n_running_jobs == 0)
2466 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2468 if (hashmap_size(m->jobs) > 0) {
2469 if (m->jobs_in_progress_event_source) {
2470 uint64_t next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
2471 log_debug("requeuing for "USEC_FMT, next);
2472 sd_event_source_set_time(m->jobs_in_progress_event_source, next);
2477 manager_flip_auto_status(m, false);
2479 /* Notify Type=idle units that we are done now */
2480 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2481 manager_close_idle_pipe(m);
2483 /* Turn off confirm spawn now */
2484 m->confirm_spawn = false;
2486 if (dual_timestamp_is_set(&m->finish_timestamp))
2489 dual_timestamp_get(&m->finish_timestamp);
2491 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2493 /* Note that m->kernel_usec.monotonic is always at 0,
2494 * and m->firmware_usec.monotonic and
2495 * m->loader_usec.monotonic should be considered
2496 * negative values. */
2498 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2499 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2500 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2501 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2503 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2505 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2506 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2508 if (!log_on_console())
2509 log_struct(LOG_INFO,
2510 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2511 "KERNEL_USEC="USEC_FMT, kernel_usec,
2512 "INITRD_USEC="USEC_FMT, initrd_usec,
2513 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2514 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2515 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2516 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2517 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2518 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2521 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2524 if (!log_on_console())
2525 log_struct(LOG_INFO,
2526 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2527 "KERNEL_USEC="USEC_FMT, kernel_usec,
2528 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2529 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2530 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2531 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2532 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2536 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2537 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2539 if (!log_on_console())
2540 log_struct(LOG_INFO,
2541 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2542 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2543 "MESSAGE=Startup finished in %s.",
2544 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2548 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2551 "READY=1\nSTATUS=Startup finished in %s.",
2552 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2555 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2566 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2567 /* systemd --system, not running --test */
2569 p = strappend("/run/systemd/", name);
2573 r = mkdir_p_label(p, 0755);
2575 log_error("Failed to create generator directory %s: %s",
2580 } else if (m->running_as == SYSTEMD_USER) {
2581 const char *s = NULL;
2583 s = getenv("XDG_RUNTIME_DIR");
2586 p = strjoin(s, "/systemd/", name, NULL);
2590 r = mkdir_p_label(p, 0755);
2592 log_error("Failed to create generator directory %s: %s",
2598 /* systemd --system --test */
2600 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2605 log_error("Failed to create generator directory %s: %m",
2616 static void trim_generator_dir(Manager *m, char **generator) {
2623 if (rmdir(*generator) >= 0) {
2631 void manager_run_generators(Manager *m) {
2632 _cleanup_closedir_ DIR *d = NULL;
2633 const char *generator_path;
2634 const char *argv[5];
2639 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2640 d = opendir(generator_path);
2642 if (errno == ENOENT)
2645 log_error("Failed to enumerate generator directory %s: %m",
2650 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2654 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2658 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2662 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2663 argv[1] = m->generator_unit_path;
2664 argv[2] = m->generator_unit_path_early;
2665 argv[3] = m->generator_unit_path_late;
2668 RUN_WITH_UMASK(0022)
2669 execute_directory(generator_path, d, (char**) argv);
2672 trim_generator_dir(m, &m->generator_unit_path);
2673 trim_generator_dir(m, &m->generator_unit_path_early);
2674 trim_generator_dir(m, &m->generator_unit_path_late);
2677 static void remove_generator_dir(Manager *m, char **generator) {
2684 strv_remove(m->lookup_paths.unit_path, *generator);
2685 rm_rf(*generator, false, true, false);
2691 void manager_undo_generators(Manager *m) {
2694 remove_generator_dir(m, &m->generator_unit_path);
2695 remove_generator_dir(m, &m->generator_unit_path_early);
2696 remove_generator_dir(m, &m->generator_unit_path_late);
2699 int manager_environment_add(Manager *m, char **minus, char **plus) {
2700 char **a = NULL, **b = NULL, **l;
2705 if (!strv_isempty(minus)) {
2706 a = strv_env_delete(l, 1, minus);
2713 if (!strv_isempty(plus)) {
2714 b = strv_env_merge(2, l, plus);
2721 if (m->environment != l)
2722 strv_free(m->environment);
2729 manager_clean_environment(m);
2730 strv_sort(m->environment);
2735 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2740 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2741 if (!default_rlimit[i])
2744 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2752 void manager_recheck_journal(Manager *m) {
2757 if (m->running_as != SYSTEMD_SYSTEM)
2760 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2761 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2762 log_close_journal();
2766 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2767 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2768 log_close_journal();
2772 /* Hmm, OK, so the socket is fully up and the service is up
2773 * too, then let's make use of the thing. */
2777 void manager_set_show_status(Manager *m, ShowStatus mode) {
2779 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2781 if (m->running_as != SYSTEMD_SYSTEM)
2784 m->show_status = mode;
2787 touch("/run/systemd/show-status");
2789 unlink("/run/systemd/show-status");
2792 static bool manager_get_show_status(Manager *m) {
2795 if (m->running_as != SYSTEMD_SYSTEM)
2798 if (m->no_console_output)
2801 if (m->show_status > 0)
2804 /* If Plymouth is running make sure we show the status, so
2805 * that there's something nice to see when people press Esc */
2807 return plymouth_running();
2810 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2813 if (!manager_get_show_status(m))
2816 /* XXX We should totally drop the check for ephemeral here
2817 * and thus effectively make 'Type=idle' pointless. */
2818 if (ephemeral && m->n_on_console > 0)
2821 if (!manager_is_booting_or_shutting_down(m))
2824 va_start(ap, format);
2825 status_vprintf(status, true, ephemeral, format, ap);
2829 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2830 _cleanup_free_ char *p = NULL;
2838 p = unit_name_from_path(path, suffix);
2842 found = manager_get_unit(m, p);
2852 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2853 char p[strlen(path)+1];
2859 path_kill_slashes(p);
2861 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);