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 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
89 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
90 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
91 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
92 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
93 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
94 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
96 static int manager_watch_jobs_in_progress(Manager *m) {
101 if (m->jobs_in_progress_event_source)
104 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
105 return sd_event_add_time(
107 &m->jobs_in_progress_event_source,
110 manager_dispatch_jobs_in_progress, m);
113 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
115 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
118 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
119 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
123 p = mempset(p, ' ', pos-2);
124 p = stpcpy(p, ANSI_RED_ON);
128 if (pos > 0 && pos <= width) {
129 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
133 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
136 p = stpcpy(p, ANSI_RED_ON);
139 p = mempset(p, ' ', width-1-pos);
140 strcpy(p, ANSI_HIGHLIGHT_OFF);
144 void manager_flip_auto_status(Manager *m, bool enable) {
148 if (m->show_status == SHOW_STATUS_AUTO)
149 manager_set_show_status(m, SHOW_STATUS_TEMPORARY);
151 if (m->show_status == SHOW_STATUS_TEMPORARY)
152 manager_set_show_status(m, SHOW_STATUS_AUTO);
156 static void manager_print_jobs_in_progress(Manager *m) {
157 _cleanup_free_ char *job_of_n = NULL;
160 unsigned counter = 0, print_nr;
161 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
163 char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
168 manager_flip_auto_status(m, true);
170 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
172 HASHMAP_FOREACH(j, m->jobs, i)
173 if (j->state == JOB_RUNNING && counter++ == print_nr)
176 /* m->n_running_jobs must be consistent with the contents of m->jobs,
177 * so the above loop must have succeeded in finding j. */
178 assert(counter == print_nr + 1);
181 cylon_pos = m->jobs_in_progress_iteration % 14;
183 cylon_pos = 14 - cylon_pos;
184 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
186 m->jobs_in_progress_iteration++;
188 if (m->n_running_jobs > 1)
189 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
192 format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
193 if (job_get_timeout(j, &x) > 0)
194 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
196 manager_status_printf(m, true, cylon,
197 "%sA %s job is running for %s (%s / %s)",
199 job_type_to_string(j->type),
200 unit_description(j->unit),
205 static int manager_watch_idle_pipe(Manager *m) {
210 if (m->idle_pipe_event_source)
213 if (m->idle_pipe[2] < 0)
216 r = sd_event_add_io(m->event, &m->idle_pipe_event_source, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m);
218 log_error("Failed to watch idle pipe: %s", strerror(-r));
225 static void manager_close_idle_pipe(Manager *m) {
228 safe_close_pair(m->idle_pipe);
229 safe_close_pair(m->idle_pipe + 2);
232 static int manager_setup_time_change(Manager *m) {
235 /* We only care for the cancellation event, hence we set the
236 * timeout to the latest possible value. */
237 struct itimerspec its = {
238 .it_value.tv_sec = TIME_T_MAX,
242 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
244 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
245 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
247 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
248 if (m->time_change_fd < 0) {
249 log_error("Failed to create timerfd: %m");
253 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
254 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
255 m->time_change_fd = safe_close(m->time_change_fd);
259 r = sd_event_add_io(m->event, &m->time_change_event_source, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m);
261 log_error("Failed to create time change event source: %s", strerror(-r));
265 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
270 static int enable_special_signals(Manager *m) {
271 _cleanup_close_ int fd = -1;
275 /* Enable that we get SIGINT on control-alt-del. In containers
276 * this will fail with EPERM (older) or EINVAL (newer), so
278 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
279 log_warning("Failed to enable ctrl-alt-del handling: %m");
281 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
283 /* Support systems without virtual console */
285 log_warning("Failed to open /dev/tty0: %m");
287 /* Enable that we get SIGWINCH on kbrequest */
288 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
289 log_warning("Failed to enable kbrequest handling: %m");
295 static int manager_setup_signals(Manager *m) {
296 struct sigaction sa = {
297 .sa_handler = SIG_DFL,
298 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
305 /* We are not interested in SIGSTOP and friends. */
306 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
308 assert_se(sigemptyset(&mask) == 0);
310 sigset_add_many(&mask,
311 SIGCHLD, /* Child died */
312 SIGTERM, /* Reexecute daemon */
313 SIGHUP, /* Reload configuration */
314 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
315 SIGUSR2, /* systemd: dump status */
316 SIGINT, /* Kernel sends us this on control-alt-del */
317 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
318 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
319 SIGRTMIN+0, /* systemd: start default.target */
320 SIGRTMIN+1, /* systemd: isolate rescue.target */
321 SIGRTMIN+2, /* systemd: isolate emergency.target */
322 SIGRTMIN+3, /* systemd: start halt.target */
323 SIGRTMIN+4, /* systemd: start poweroff.target */
324 SIGRTMIN+5, /* systemd: start reboot.target */
325 SIGRTMIN+6, /* systemd: start kexec.target */
326 SIGRTMIN+13, /* systemd: Immediate halt */
327 SIGRTMIN+14, /* systemd: Immediate poweroff */
328 SIGRTMIN+15, /* systemd: Immediate reboot */
329 SIGRTMIN+16, /* systemd: Immediate kexec */
330 SIGRTMIN+20, /* systemd: enable status messages */
331 SIGRTMIN+21, /* systemd: disable status messages */
332 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
333 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
334 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
335 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
336 SIGRTMIN+27, /* systemd: set log target to console */
337 SIGRTMIN+28, /* systemd: set log target to kmsg */
338 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
340 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
342 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
343 if (m->signal_fd < 0)
346 r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);
350 /* Process signals a bit earlier than the rest of things, but
351 * later that notify_fd processing, so that the notify
352 * processing can still figure out to which process/service a
353 * message belongs, before we reap the process. */
354 r = sd_event_source_set_priority(m->signal_event_source, -5);
358 if (m->running_as == SYSTEMD_SYSTEM)
359 return enable_special_signals(m);
364 static void manager_clean_environment(Manager *m) {
367 /* Let's remove some environment variables that we
368 * need ourselves to communicate with our clients */
381 static int manager_default_environment(Manager *m) {
384 if (m->running_as == SYSTEMD_SYSTEM) {
385 /* The system manager always starts with a clean
386 * environment for its children. It does not import
387 * the kernel or the parents exported variables.
389 * The initial passed environ is untouched to keep
390 * /proc/self/environ valid; it is used for tagging
391 * the init process inside containers. */
392 m->environment = strv_new("PATH=" DEFAULT_PATH,
395 /* Import locale variables LC_*= from configuration */
396 locale_setup(&m->environment);
398 /* The user manager passes its own environment
399 * along to its children. */
400 m->environment = strv_copy(environ);
406 manager_clean_environment(m);
407 strv_sort(m->environment);
412 int manager_new(SystemdRunningAs running_as, Manager **_m) {
417 assert(running_as >= 0);
418 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
420 m = new0(Manager, 1);
425 if (running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0)
426 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
429 m->running_as = running_as;
430 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
431 m->default_timer_accuracy_usec = USEC_PER_MINUTE;
433 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
435 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;
436 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
438 r = manager_default_environment(m);
442 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
446 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
450 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
454 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
458 r = set_ensure_allocated(&m->startup_units, trivial_hash_func, trivial_compare_func);
462 r = set_ensure_allocated(&m->failed_units, trivial_hash_func, trivial_compare_func);
466 r = sd_event_default(&m->event);
470 r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
474 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
478 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
482 r = manager_setup_signals(m);
486 r = manager_setup_cgroup(m);
490 r = manager_setup_time_change(m);
494 m->udev = udev_new();
500 /* Note that we set up neither kdbus, nor the notify fd
501 * here. We do that after deserialization, since they might
502 * have gotten serialized across the reexec. */
504 m->taint_usr = dir_is_empty("/usr") > 0;
514 static int manager_setup_notify(Manager *m) {
517 if (m->notify_fd < 0) {
518 _cleanup_close_ int fd = -1;
521 struct sockaddr_un un;
523 .sa.sa_family = AF_UNIX,
527 /* First free all secondary fields */
528 free(m->notify_socket);
529 m->notify_socket = NULL;
530 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
532 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
534 log_error("Failed to allocate notification socket: %m");
538 if (m->running_as == SYSTEMD_SYSTEM)
539 m->notify_socket = strdup("/run/systemd/notify");
543 e = getenv("XDG_RUNTIME_DIR");
545 log_error("XDG_RUNTIME_DIR is not set: %m");
549 m->notify_socket = strappend(e, "/systemd/notify");
551 if (!m->notify_socket)
554 strncpy(sa.un.sun_path, m->notify_socket, sizeof(sa.un.sun_path)-1);
555 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path));
557 log_error("bind() failed: %m");
561 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
563 log_error("SO_PASSCRED failed: %m");
570 log_debug("Using notification socket %s", m->notify_socket);
573 if (!m->notify_event_source) {
574 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
576 log_error("Failed to allocate notify event source: %s", strerror(-r));
580 /* Process signals a bit earlier than SIGCHLD, so that we can
581 * still identify to which service an exit message belongs */
582 r = sd_event_source_set_priority(m->notify_event_source, -7);
584 log_error("Failed to set priority of notify event source: %s", strerror(-r));
592 static int manager_setup_kdbus(Manager *m) {
594 _cleanup_free_ char *p = NULL;
600 if (m->kdbus_fd >= 0)
603 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
604 if (m->kdbus_fd < 0) {
605 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
609 log_debug("Successfully set up kdbus on %s", p);
611 /* Create the namespace directory here, so that the contents
612 * of that directory is not visible to non-root users. This is
613 * necessary to ensure that users cannot get access to busses
614 * of virtualized users when no UID namespacing is used. */
615 if (m->running_as == SYSTEMD_SYSTEM)
616 mkdir_p_label("/dev/kdbus/domain", 0700);
622 static int manager_connect_bus(Manager *m, bool reexecuting) {
623 bool try_bus_connect;
630 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
632 /* Try to connect to the busses, if possible. */
633 return bus_init(m, try_bus_connect);
636 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
642 while ((u = m->cleanup_queue)) {
643 assert(u->in_cleanup_queue);
653 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
654 GC_OFFSET_UNSURE, /* No clue */
655 GC_OFFSET_GOOD, /* We still need this unit */
656 GC_OFFSET_BAD, /* We don't need this unit anymore */
660 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
667 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
668 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
669 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
672 if (u->in_cleanup_queue)
675 if (unit_check_gc(u))
678 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
682 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
683 unit_gc_sweep(other, gc_marker);
685 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
688 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
695 /* We were unable to find anything out about this entry, so
696 * let's investigate it later */
697 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
698 unit_add_to_gc_queue(u);
702 /* We definitely know that this one is not useful anymore, so
703 * let's mark it for deletion */
704 u->gc_marker = gc_marker + GC_OFFSET_BAD;
705 unit_add_to_cleanup_queue(u);
709 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
712 static unsigned manager_dispatch_gc_queue(Manager *m) {
719 /* log_debug("Running GC..."); */
721 m->gc_marker += _GC_OFFSET_MAX;
722 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
725 gc_marker = m->gc_marker;
727 while ((u = m->gc_queue)) {
728 assert(u->in_gc_queue);
730 unit_gc_sweep(u, gc_marker);
732 LIST_REMOVE(gc_queue, m->gc_queue, u);
733 u->in_gc_queue = false;
737 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
738 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
739 log_debug_unit(u->id, "Collecting %s", u->id);
740 u->gc_marker = gc_marker + GC_OFFSET_BAD;
741 unit_add_to_cleanup_queue(u);
745 m->n_in_gc_queue = 0;
750 static void manager_clear_jobs_and_units(Manager *m) {
755 while ((u = hashmap_first(m->units)))
758 manager_dispatch_cleanup_queue(m);
760 assert(!m->load_queue);
761 assert(!m->run_queue);
762 assert(!m->dbus_unit_queue);
763 assert(!m->dbus_job_queue);
764 assert(!m->cleanup_queue);
765 assert(!m->gc_queue);
767 assert(hashmap_isempty(m->jobs));
768 assert(hashmap_isempty(m->units));
771 m->n_running_jobs = 0;
774 void manager_free(Manager *m) {
780 manager_clear_jobs_and_units(m);
782 for (c = 0; c < _UNIT_TYPE_MAX; c++)
783 if (unit_vtable[c]->shutdown)
784 unit_vtable[c]->shutdown(m);
786 /* If we reexecute ourselves, we keep the root cgroup
788 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
790 manager_undo_generators(m);
794 hashmap_free(m->units);
795 hashmap_free(m->jobs);
796 hashmap_free(m->watch_pids1);
797 hashmap_free(m->watch_pids2);
798 hashmap_free(m->watch_bus);
800 set_free(m->startup_units);
801 set_free(m->failed_units);
803 sd_event_source_unref(m->signal_event_source);
804 sd_event_source_unref(m->notify_event_source);
805 sd_event_source_unref(m->time_change_event_source);
806 sd_event_source_unref(m->jobs_in_progress_event_source);
807 sd_event_source_unref(m->idle_pipe_event_source);
808 sd_event_source_unref(m->run_queue_event_source);
810 safe_close(m->signal_fd);
811 safe_close(m->notify_fd);
812 safe_close(m->time_change_fd);
813 safe_close(m->kdbus_fd);
815 manager_close_idle_pipe(m);
818 sd_event_unref(m->event);
820 free(m->notify_socket);
822 lookup_paths_free(&m->lookup_paths);
823 strv_free(m->environment);
825 hashmap_free(m->cgroup_unit);
826 set_free_free(m->unit_path_cache);
828 free(m->switch_root);
829 free(m->switch_root_init);
831 for (i = 0; i < _RLIMIT_MAX; i++)
834 assert(hashmap_isempty(m->units_requiring_mounts_for));
835 hashmap_free(m->units_requiring_mounts_for);
840 int manager_enumerate(Manager *m) {
846 /* Let's ask every type to load all units from disk/kernel
847 * that it might know */
848 for (c = 0; c < _UNIT_TYPE_MAX; c++)
849 if (unit_vtable[c]->enumerate) {
850 q = unit_vtable[c]->enumerate(m);
855 manager_dispatch_load_queue(m);
859 static int manager_coldplug(Manager *m) {
867 /* Then, let's set up their initial state. */
868 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
875 q = unit_coldplug(u);
883 static void manager_build_unit_path_cache(Manager *m) {
885 _cleanup_free_ DIR *d = NULL;
890 set_free_free(m->unit_path_cache);
892 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
893 if (!m->unit_path_cache) {
894 log_error("Failed to allocate unit path cache.");
898 /* This simply builds a list of files we know exist, so that
899 * we don't always have to go to disk */
901 STRV_FOREACH(i, m->lookup_paths.unit_path) {
907 log_error("Failed to open directory %s: %m", *i);
911 while ((de = readdir(d))) {
914 if (ignore_file(de->d_name))
917 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
923 r = set_consume(m->unit_path_cache, p);
935 log_error("Failed to build unit path cache: %s", strerror(-r));
937 set_free_free(m->unit_path_cache);
938 m->unit_path_cache = NULL;
942 static int manager_distribute_fds(Manager *m, FDSet *fds) {
949 HASHMAP_FOREACH(u, m->units, i) {
951 if (fdset_size(fds) <= 0)
954 if (UNIT_VTABLE(u)->distribute_fds) {
955 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
964 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
969 dual_timestamp_get(&m->generators_start_timestamp);
970 manager_run_generators(m);
971 dual_timestamp_get(&m->generators_finish_timestamp);
973 r = lookup_paths_init(
974 &m->lookup_paths, m->running_as, true,
976 m->generator_unit_path,
977 m->generator_unit_path_early,
978 m->generator_unit_path_late);
982 manager_build_unit_path_cache(m);
984 /* If we will deserialize make sure that during enumeration
985 * this is already known, so we increase the counter here
990 /* First, enumerate what we can from all config files */
991 dual_timestamp_get(&m->units_load_start_timestamp);
992 r = manager_enumerate(m);
993 dual_timestamp_get(&m->units_load_finish_timestamp);
995 /* Second, deserialize if there is something to deserialize */
997 q = manager_deserialize(m, serialization, fds);
1002 /* Any fds left? Find some unit which wants them. This is
1003 * useful to allow container managers to pass some file
1004 * descriptors to us pre-initialized. This enables
1005 * socket-based activation of entire containers. */
1006 if (fdset_size(fds) > 0) {
1007 q = manager_distribute_fds(m, fds);
1012 /* We might have deserialized the notify fd, but if we didn't
1013 * then let's create the bus now */
1014 manager_setup_notify(m);
1016 /* We might have deserialized the kdbus control fd, but if we
1017 * didn't, then let's create the bus now. */
1018 manager_setup_kdbus(m);
1019 manager_connect_bus(m, !!serialization);
1020 bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
1022 /* Third, fire things up! */
1023 q = manager_coldplug(m);
1027 if (serialization) {
1028 assert(m->n_reloading > 0);
1031 /* Let's wait for the UnitNew/JobNew messages being
1032 * sent, before we notify that the reload is
1034 m->send_reloading_done = true;
1040 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1045 assert(type < _JOB_TYPE_MAX);
1047 assert(mode < _JOB_MODE_MAX);
1049 if (mode == JOB_ISOLATE && type != JOB_START) {
1050 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1054 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1055 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1059 log_debug_unit(unit->id,
1060 "Trying to enqueue job %s/%s/%s", unit->id,
1061 job_type_to_string(type), job_mode_to_string(mode));
1063 job_type_collapse(&type, unit);
1065 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1069 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1070 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1071 mode == JOB_IGNORE_DEPENDENCIES, e);
1075 if (mode == JOB_ISOLATE) {
1076 r = transaction_add_isolate_jobs(tr, m);
1081 r = transaction_activate(tr, m, mode, e);
1085 log_debug_unit(unit->id,
1086 "Enqueued job %s/%s as %u", unit->id,
1087 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1090 *_ret = tr->anchor_job;
1092 transaction_free(tr);
1096 transaction_abort(tr);
1097 transaction_free(tr);
1101 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1106 assert(type < _JOB_TYPE_MAX);
1108 assert(mode < _JOB_MODE_MAX);
1110 r = manager_load_unit(m, name, NULL, NULL, &unit);
1114 return manager_add_job(m, type, unit, mode, override, e, _ret);
1117 Job *manager_get_job(Manager *m, uint32_t id) {
1120 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1123 Unit *manager_get_unit(Manager *m, const char *name) {
1127 return hashmap_get(m->units, name);
1130 unsigned manager_dispatch_load_queue(Manager *m) {
1136 /* Make sure we are not run recursively */
1137 if (m->dispatching_load_queue)
1140 m->dispatching_load_queue = true;
1142 /* Dispatches the load queue. Takes a unit from the queue and
1143 * tries to load its data until the queue is empty */
1145 while ((u = m->load_queue)) {
1146 assert(u->in_load_queue);
1152 m->dispatching_load_queue = false;
1156 int manager_load_unit_prepare(
1168 assert(name || path);
1170 /* This will prepare the unit for loading, but not actually
1171 * load anything from disk. */
1173 if (path && !is_path(path))
1174 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1177 name = basename(path);
1179 t = unit_name_to_type(name);
1181 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1182 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1184 ret = manager_get_unit(m, name);
1190 ret = unit_new(m, unit_vtable[t]->object_size);
1195 ret->fragment_path = strdup(path);
1196 if (!ret->fragment_path) {
1202 r = unit_add_name(ret, name);
1208 unit_add_to_load_queue(ret);
1209 unit_add_to_dbus_queue(ret);
1210 unit_add_to_gc_queue(ret);
1218 int manager_load_unit(
1229 /* This will load the service information files, but not actually
1230 * start any services or anything. */
1232 r = manager_load_unit_prepare(m, name, path, e, _ret);
1236 manager_dispatch_load_queue(m);
1239 *_ret = unit_follow_merge(*_ret);
1244 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1251 HASHMAP_FOREACH(j, s->jobs, i)
1252 job_dump(j, f, prefix);
1255 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1263 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1265 unit_dump(u, f, prefix);
1268 void manager_clear_jobs(Manager *m) {
1273 while ((j = hashmap_first(m->jobs)))
1274 /* No need to recurse. We're cancelling all jobs. */
1275 job_finish_and_invalidate(j, JOB_CANCELED, false);
1278 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1279 Manager *m = userdata;
1285 while ((j = m->run_queue)) {
1286 assert(j->installed);
1287 assert(j->in_run_queue);
1289 job_run_and_invalidate(j);
1292 if (m->n_running_jobs > 0)
1293 manager_watch_jobs_in_progress(m);
1295 if (m->n_on_console > 0)
1296 manager_watch_idle_pipe(m);
1301 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1308 if (m->dispatching_dbus_queue)
1311 m->dispatching_dbus_queue = true;
1313 while ((u = m->dbus_unit_queue)) {
1314 assert(u->in_dbus_queue);
1316 bus_unit_send_change_signal(u);
1320 while ((j = m->dbus_job_queue)) {
1321 assert(j->in_dbus_queue);
1323 bus_job_send_change_signal(j);
1327 m->dispatching_dbus_queue = false;
1329 if (m->send_reloading_done) {
1330 m->send_reloading_done = false;
1332 bus_manager_send_reloading(m, false);
1335 if (m->queued_message)
1336 bus_send_queued_message(m);
1341 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n) {
1342 _cleanup_strv_free_ char **tags = NULL;
1349 tags = strv_split(buf, "\n\r");
1355 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1357 if (UNIT_VTABLE(u)->notify_message)
1358 UNIT_VTABLE(u)->notify_message(u, pid, tags);
1361 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1362 Manager *m = userdata;
1366 assert(m->notify_fd == fd);
1368 if (revents != EPOLLIN) {
1369 log_warning("Got unexpected poll event for notify fd.");
1375 struct iovec iovec = {
1377 .iov_len = sizeof(buf)-1,
1382 struct cmsghdr cmsghdr;
1383 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1386 struct msghdr msghdr = {
1389 .msg_control = &control,
1390 .msg_controllen = sizeof(control),
1392 struct ucred *ucred;
1395 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1400 if (errno == EAGAIN || errno == EINTR)
1406 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1407 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1408 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1409 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1410 log_warning("Received notify message without credentials. Ignoring.");
1414 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1416 assert((size_t) n < sizeof(buf));
1419 u = manager_get_unit_by_pid(m, ucred->pid);
1421 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1425 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1427 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1431 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1433 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1438 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1444 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1449 log_debug_unit(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1451 unit_unwatch_pid(u, si->si_pid);
1452 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1455 static int manager_dispatch_sigchld(Manager *m) {
1461 /* First we call waitd() for a PID and do not reap the
1462 * zombie. That way we can still access /proc/$PID for
1463 * it while it is a zombie. */
1464 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1466 if (errno == ECHILD)
1478 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1479 _cleanup_free_ char *name = NULL;
1482 get_process_comm(si.si_pid, &name);
1484 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1485 si.si_pid, strna(name),
1486 sigchld_code_to_string(si.si_code),
1488 strna(si.si_code == CLD_EXITED
1489 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1490 : signal_to_string(si.si_status)));
1492 /* And now figure out the unit this belongs
1493 * to, it might be multiple... */
1494 u = manager_get_unit_by_pid(m, si.si_pid);
1496 invoke_sigchld_event(m, u, &si);
1497 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1499 invoke_sigchld_event(m, u, &si);
1500 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1502 invoke_sigchld_event(m, u, &si);
1505 /* And now, we actually reap the zombie. */
1506 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1517 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1518 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1521 log_debug_unit(name, "Activating special unit %s", name);
1523 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1525 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1530 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1531 Manager *m = userdata;
1533 struct signalfd_siginfo sfsi;
1534 bool sigchld = false;
1537 assert(m->signal_fd == fd);
1539 if (revents != EPOLLIN) {
1540 log_warning("Got unexpected events from signal file descriptor.");
1545 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1546 if (n != sizeof(sfsi)) {
1551 if (errno == EINTR || errno == EAGAIN)
1557 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1558 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1559 ? LOG_DEBUG : LOG_INFO,
1562 switch (sfsi.ssi_signo) {
1569 if (m->running_as == SYSTEMD_SYSTEM) {
1570 /* This is for compatibility with the
1571 * original sysvinit */
1572 m->exit_code = MANAGER_REEXECUTE;
1579 if (m->running_as == SYSTEMD_SYSTEM) {
1580 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1584 /* Run the exit target if there is one, if not, just exit. */
1585 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1586 m->exit_code = MANAGER_EXIT;
1593 if (m->running_as == SYSTEMD_SYSTEM)
1594 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1596 /* This is a nop on non-init */
1600 if (m->running_as == SYSTEMD_SYSTEM)
1601 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1603 /* This is a nop on non-init */
1609 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1611 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1612 log_info("Trying to reconnect to bus...");
1616 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1617 log_info("Loading D-Bus service...");
1618 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1625 _cleanup_free_ char *dump = NULL;
1626 _cleanup_fclose_ FILE *f = NULL;
1629 f = open_memstream(&dump, &size);
1631 log_warning("Failed to allocate memory stream.");
1635 manager_dump_units(m, f, "\t");
1636 manager_dump_jobs(m, f, "\t");
1639 log_warning("Failed to write status stream");
1644 log_warning("Failed to flush status stream");
1648 log_dump(LOG_INFO, dump);
1653 m->exit_code = MANAGER_RELOAD;
1658 /* Starting SIGRTMIN+0 */
1659 static const char * const target_table[] = {
1660 [0] = SPECIAL_DEFAULT_TARGET,
1661 [1] = SPECIAL_RESCUE_TARGET,
1662 [2] = SPECIAL_EMERGENCY_TARGET,
1663 [3] = SPECIAL_HALT_TARGET,
1664 [4] = SPECIAL_POWEROFF_TARGET,
1665 [5] = SPECIAL_REBOOT_TARGET,
1666 [6] = SPECIAL_KEXEC_TARGET
1669 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1670 static const ManagerExitCode code_table[] = {
1672 [1] = MANAGER_POWEROFF,
1673 [2] = MANAGER_REBOOT,
1677 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1678 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1679 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1680 manager_start_target(m, target_table[idx],
1681 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1685 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1686 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1687 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1691 switch (sfsi.ssi_signo - SIGRTMIN) {
1694 log_debug("Enabling showing of status.");
1695 manager_set_show_status(m, SHOW_STATUS_YES);
1699 log_debug("Disabling showing of status.");
1700 manager_set_show_status(m, SHOW_STATUS_NO);
1704 log_set_max_level(LOG_DEBUG);
1705 log_notice("Setting log level to debug.");
1709 log_set_max_level(LOG_INFO);
1710 log_notice("Setting log level to info.");
1714 if (m->running_as == SYSTEMD_USER) {
1715 m->exit_code = MANAGER_EXIT;
1719 /* This is a nop on init */
1723 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1724 log_notice("Setting log target to journal-or-kmsg.");
1728 log_set_target(LOG_TARGET_CONSOLE);
1729 log_notice("Setting log target to console.");
1733 log_set_target(LOG_TARGET_KMSG);
1734 log_notice("Setting log target to kmsg.");
1738 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1739 log_notice("Setting log target to syslog-or-kmsg.");
1743 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1750 manager_dispatch_sigchld(m);
1755 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1756 Manager *m = userdata;
1761 assert(m->time_change_fd == fd);
1763 log_struct(LOG_INFO,
1764 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1765 "MESSAGE=Time has been changed",
1768 /* Restart the watch */
1769 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1770 m->time_change_fd = safe_close(m->time_change_fd);
1772 manager_setup_time_change(m);
1774 HASHMAP_FOREACH(u, m->units, i)
1775 if (UNIT_VTABLE(u)->time_change)
1776 UNIT_VTABLE(u)->time_change(u);
1781 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1782 Manager *m = userdata;
1785 assert(m->idle_pipe[2] == fd);
1787 m->no_console_output = m->n_on_console > 0;
1789 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1790 manager_close_idle_pipe(m);
1795 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1796 Manager *m = userdata;
1803 manager_print_jobs_in_progress(m);
1805 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1806 r = sd_event_source_set_time(source, next);
1810 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1813 int manager_loop(Manager *m) {
1816 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1819 m->exit_code = MANAGER_OK;
1821 /* Release the path cache */
1822 set_free_free(m->unit_path_cache);
1823 m->unit_path_cache = NULL;
1825 manager_check_finished(m);
1827 /* There might still be some zombies hanging around from
1828 * before we were exec()'ed. Let's reap them. */
1829 r = manager_dispatch_sigchld(m);
1833 while (m->exit_code == MANAGER_OK) {
1836 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1839 if (!ratelimit_test(&rl)) {
1840 /* Yay, something is going seriously wrong, pause a little */
1841 log_warning("Looping too fast. Throttling execution a little.");
1846 if (manager_dispatch_load_queue(m) > 0)
1849 if (manager_dispatch_gc_queue(m) > 0)
1852 if (manager_dispatch_cleanup_queue(m) > 0)
1855 if (manager_dispatch_cgroup_queue(m) > 0)
1858 if (manager_dispatch_dbus_queue(m) > 0)
1861 /* Sleep for half the watchdog time */
1862 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1863 wait_usec = m->runtime_watchdog / 2;
1867 wait_usec = (usec_t) -1;
1869 r = sd_event_run(m->event, wait_usec);
1871 log_error("Failed to run event loop: %s", strerror(-r));
1876 return m->exit_code;
1879 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1880 _cleanup_free_ char *n = NULL;
1888 r = unit_name_from_dbus_path(s, &n);
1892 r = manager_load_unit(m, n, NULL, e, &u);
1901 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1911 p = startswith(s, "/org/freedesktop/systemd1/job/");
1915 r = safe_atou(p, &id);
1919 j = manager_get_job(m, id);
1928 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1931 _cleanup_free_ char *p = NULL;
1934 audit_fd = get_audit_fd();
1938 /* Don't generate audit events if the service was already
1939 * started and we're just deserializing */
1940 if (m->n_reloading > 0)
1943 if (m->running_as != SYSTEMD_SYSTEM)
1946 if (u->type != UNIT_SERVICE)
1949 p = unit_name_to_prefix_and_instance(u->id);
1951 log_error_unit(u->id,
1952 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1956 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1957 if (errno == EPERM) {
1958 /* We aren't allowed to send audit messages?
1959 * Then let's not retry again. */
1962 log_warning("Failed to send audit message: %m");
1968 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1969 union sockaddr_union sa = {
1970 .un.sun_family = AF_UNIX,
1971 .un.sun_path = "\0/org/freedesktop/plymouthd",
1975 _cleanup_free_ char *message = NULL;
1976 _cleanup_close_ int fd = -1;
1978 /* Don't generate plymouth events if the service was already
1979 * started and we're just deserializing */
1980 if (m->n_reloading > 0)
1983 if (m->running_as != SYSTEMD_SYSTEM)
1986 if (detect_container(NULL) > 0)
1989 if (u->type != UNIT_SERVICE &&
1990 u->type != UNIT_MOUNT &&
1991 u->type != UNIT_SWAP)
1994 /* We set SOCK_NONBLOCK here so that we rather drop the
1995 * message then wait for plymouth */
1996 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1998 log_error("socket() failed: %m");
2002 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2004 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2005 log_error("connect() failed: %m");
2009 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2015 if (write(fd, message, n + 1) != n + 1)
2016 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2017 log_error("Failed to write Plymouth message: %m");
2020 void manager_dispatch_bus_name_owner_changed(
2023 const char* old_owner,
2024 const char *new_owner) {
2031 u = hashmap_get(m->watch_bus, name);
2035 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2038 int manager_open_serialization(Manager *m, FILE **_f) {
2045 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2046 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2050 log_debug("Serializing state to %s", path);
2052 f = fdopen(fd, "w+");
2063 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2076 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2077 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2078 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2079 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2081 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2082 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2083 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2084 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2087 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2088 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2089 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2090 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2091 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2092 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2093 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2094 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2097 if (!switching_root) {
2098 STRV_FOREACH(e, m->environment) {
2099 _cleanup_free_ char *ce;
2105 fprintf(f, "env=%s\n", *e);
2109 if (m->notify_fd >= 0) {
2112 copy = fdset_put_dup(fds, m->notify_fd);
2116 fprintf(f, "notify-fd=%i\n", copy);
2117 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2120 if (m->kdbus_fd >= 0) {
2123 copy = fdset_put_dup(fds, m->kdbus_fd);
2127 fprintf(f, "kdbus-fd=%i\n", copy);
2130 bus_track_serialize(m->subscribed, f);
2134 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2142 r = unit_serialize(u, f, fds, !switching_root);
2149 assert(m->n_reloading > 0);
2155 r = bus_fdset_add_all(m, fds);
2162 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2168 log_debug("Deserializing state...");
2173 char line[LINE_MAX], *l;
2175 if (!fgets(line, sizeof(line), f)) {
2190 if (startswith(l, "current-job-id=")) {
2193 if (safe_atou32(l+15, &id) < 0)
2194 log_debug("Failed to parse current job id value %s", l+15);
2196 m->current_job_id = MAX(m->current_job_id, id);
2198 } else if (startswith(l, "n-installed-jobs=")) {
2201 if (safe_atou32(l+17, &n) < 0)
2202 log_debug("Failed to parse installed jobs counter %s", l+17);
2204 m->n_installed_jobs += n;
2206 } else if (startswith(l, "n-failed-jobs=")) {
2209 if (safe_atou32(l+14, &n) < 0)
2210 log_debug("Failed to parse failed jobs counter %s", l+14);
2212 m->n_failed_jobs += n;
2214 } else if (startswith(l, "taint-usr=")) {
2217 b = parse_boolean(l+10);
2219 log_debug("Failed to parse taint /usr flag %s", l+10);
2221 m->taint_usr = m->taint_usr || b;
2223 } else if (startswith(l, "firmware-timestamp="))
2224 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2225 else if (startswith(l, "loader-timestamp="))
2226 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2227 else if (startswith(l, "kernel-timestamp="))
2228 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2229 else if (startswith(l, "initrd-timestamp="))
2230 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2231 else if (startswith(l, "userspace-timestamp="))
2232 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2233 else if (startswith(l, "finish-timestamp="))
2234 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2235 else if (startswith(l, "security-start-timestamp="))
2236 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2237 else if (startswith(l, "security-finish-timestamp="))
2238 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2239 else if (startswith(l, "generators-start-timestamp="))
2240 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2241 else if (startswith(l, "generators-finish-timestamp="))
2242 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2243 else if (startswith(l, "units-load-start-timestamp="))
2244 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2245 else if (startswith(l, "units-load-finish-timestamp="))
2246 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2247 else if (startswith(l, "env=")) {
2248 _cleanup_free_ char *uce = NULL;
2251 uce = cunescape(l+4);
2257 e = strv_env_set(m->environment, uce);
2263 strv_free(m->environment);
2266 } else if (startswith(l, "notify-fd=")) {
2269 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2270 log_debug("Failed to parse notify fd: %s", l + 10);
2272 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2273 safe_close(m->notify_fd);
2274 m->notify_fd = fdset_remove(fds, fd);
2277 } else if (startswith(l, "notify-socket=")) {
2286 free(m->notify_socket);
2287 m->notify_socket = n;
2289 } else if (startswith(l, "kdbus-fd=")) {
2292 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2293 log_debug("Failed to parse kdbus fd: %s", l + 9);
2295 safe_close(m->kdbus_fd);
2296 m->kdbus_fd = fdset_remove(fds, fd);
2299 } else if (bus_track_deserialize_item(&m->deserialized_subscribed, l) == 0)
2300 log_debug("Unknown serialization item '%s'", l);
2305 char name[UNIT_NAME_MAX+2];
2308 if (!fgets(name, sizeof(name), f)) {
2319 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2323 r = unit_deserialize(u, f, fds);
2332 assert(m->n_reloading > 0);
2338 int manager_reload(Manager *m) {
2340 _cleanup_fclose_ FILE *f = NULL;
2341 _cleanup_fdset_free_ FDSet *fds = NULL;
2345 r = manager_open_serialization(m, &f);
2350 bus_manager_send_reloading(m, true);
2358 r = manager_serialize(m, f, fds, false);
2364 if (fseeko(f, 0, SEEK_SET) < 0) {
2369 /* From here on there is no way back. */
2370 manager_clear_jobs_and_units(m);
2371 manager_undo_generators(m);
2372 lookup_paths_free(&m->lookup_paths);
2374 /* Find new unit paths */
2375 manager_run_generators(m);
2377 q = lookup_paths_init(
2378 &m->lookup_paths, m->running_as, true,
2380 m->generator_unit_path,
2381 m->generator_unit_path_early,
2382 m->generator_unit_path_late);
2386 manager_build_unit_path_cache(m);
2388 /* First, enumerate what we can from all config files */
2389 q = manager_enumerate(m);
2393 /* Second, deserialize our stored data */
2394 q = manager_deserialize(m, f, fds);
2401 /* Re-register notify_fd as event source */
2402 q = manager_setup_notify(m);
2406 /* Third, fire things up! */
2407 q = manager_coldplug(m);
2411 assert(m->n_reloading > 0);
2414 m->send_reloading_done = true;
2419 bool manager_is_reloading_or_reexecuting(Manager *m) {
2422 return m->n_reloading != 0;
2425 void manager_reset_failed(Manager *m) {
2431 HASHMAP_FOREACH(u, m->units, i)
2432 unit_reset_failed(u);
2435 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2441 /* Returns true if the unit is inactive or going down */
2442 u = manager_get_unit(m, name);
2446 return unit_inactive_or_pending(u);
2449 void manager_check_finished(Manager *m) {
2450 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2451 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2457 if (m->n_running_jobs == 0)
2458 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2460 if (hashmap_size(m->jobs) > 0) {
2462 if (m->jobs_in_progress_event_source) {
2463 sd_event_source_set_time(m->jobs_in_progress_event_source,
2464 now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2470 manager_flip_auto_status(m, false);
2472 /* Notify Type=idle units that we are done now */
2473 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2474 manager_close_idle_pipe(m);
2476 /* Turn off confirm spawn now */
2477 m->confirm_spawn = false;
2479 if (dual_timestamp_is_set(&m->finish_timestamp))
2482 dual_timestamp_get(&m->finish_timestamp);
2484 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2486 /* Note that m->kernel_usec.monotonic is always at 0,
2487 * and m->firmware_usec.monotonic and
2488 * m->loader_usec.monotonic should be considered
2489 * negative values. */
2491 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2492 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2493 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2494 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2496 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2498 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2499 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2501 if (!log_on_console())
2502 log_struct(LOG_INFO,
2503 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2504 "KERNEL_USEC="USEC_FMT, kernel_usec,
2505 "INITRD_USEC="USEC_FMT, initrd_usec,
2506 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2507 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2508 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2509 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2510 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2511 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2514 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2517 if (!log_on_console())
2518 log_struct(LOG_INFO,
2519 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2520 "KERNEL_USEC="USEC_FMT, kernel_usec,
2521 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2522 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2523 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2524 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2525 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2529 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2530 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2532 if (!log_on_console())
2533 log_struct(LOG_INFO,
2534 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2535 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2536 "MESSAGE=Startup finished in %s.",
2537 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2541 SET_FOREACH(u, m->startup_units, i)
2542 cgroup_context_apply(unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path, manager_state(m));
2544 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2547 "READY=1\nSTATUS=Startup finished in %s.",
2548 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2551 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2562 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2563 /* systemd --system, not running --test */
2565 p = strappend("/run/systemd/", name);
2569 r = mkdir_p_label(p, 0755);
2571 log_error("Failed to create generator directory %s: %s",
2576 } else if (m->running_as == SYSTEMD_USER) {
2577 const char *s = NULL;
2579 s = getenv("XDG_RUNTIME_DIR");
2582 p = strjoin(s, "/systemd/", name, NULL);
2586 r = mkdir_p_label(p, 0755);
2588 log_error("Failed to create generator directory %s: %s",
2594 /* systemd --system --test */
2596 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2601 log_error("Failed to create generator directory %s: %m",
2612 static void trim_generator_dir(Manager *m, char **generator) {
2619 if (rmdir(*generator) >= 0) {
2627 void manager_run_generators(Manager *m) {
2628 _cleanup_closedir_ DIR *d = NULL;
2629 const char *generator_path;
2630 const char *argv[5];
2635 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2636 d = opendir(generator_path);
2638 if (errno == ENOENT)
2641 log_error("Failed to enumerate generator directory %s: %m",
2646 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2650 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2654 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2658 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2659 argv[1] = m->generator_unit_path;
2660 argv[2] = m->generator_unit_path_early;
2661 argv[3] = m->generator_unit_path_late;
2664 RUN_WITH_UMASK(0022)
2665 execute_directory(generator_path, d, DEFAULT_TIMEOUT_USEC, (char**) argv);
2668 trim_generator_dir(m, &m->generator_unit_path);
2669 trim_generator_dir(m, &m->generator_unit_path_early);
2670 trim_generator_dir(m, &m->generator_unit_path_late);
2673 static void remove_generator_dir(Manager *m, char **generator) {
2680 strv_remove(m->lookup_paths.unit_path, *generator);
2681 rm_rf(*generator, false, true, false);
2687 void manager_undo_generators(Manager *m) {
2690 remove_generator_dir(m, &m->generator_unit_path);
2691 remove_generator_dir(m, &m->generator_unit_path_early);
2692 remove_generator_dir(m, &m->generator_unit_path_late);
2695 int manager_environment_add(Manager *m, char **minus, char **plus) {
2696 char **a = NULL, **b = NULL, **l;
2701 if (!strv_isempty(minus)) {
2702 a = strv_env_delete(l, 1, minus);
2709 if (!strv_isempty(plus)) {
2710 b = strv_env_merge(2, l, plus);
2717 if (m->environment != l)
2718 strv_free(m->environment);
2725 manager_clean_environment(m);
2726 strv_sort(m->environment);
2731 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2736 for (i = 0; i < _RLIMIT_MAX; i++) {
2737 if (!default_rlimit[i])
2740 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2748 void manager_recheck_journal(Manager *m) {
2753 if (m->running_as != SYSTEMD_SYSTEM)
2756 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2757 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2758 log_close_journal();
2762 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2763 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2764 log_close_journal();
2768 /* Hmm, OK, so the socket is fully up and the service is up
2769 * too, then let's make use of the thing. */
2773 void manager_set_show_status(Manager *m, ShowStatus mode) {
2775 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2777 if (m->running_as != SYSTEMD_SYSTEM)
2780 m->show_status = mode;
2783 touch("/run/systemd/show-status");
2785 unlink("/run/systemd/show-status");
2788 static bool manager_get_show_status(Manager *m) {
2791 if (m->running_as != SYSTEMD_SYSTEM)
2794 if (m->no_console_output)
2797 if (!IN_SET(manager_state(m), MANAGER_STARTING, MANAGER_STOPPING))
2800 if (m->show_status > 0)
2803 /* If Plymouth is running make sure we show the status, so
2804 * that there's something nice to see when people press Esc */
2806 return plymouth_running();
2809 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2812 if (!manager_get_show_status(m))
2815 /* XXX We should totally drop the check for ephemeral here
2816 * and thus effectively make 'Type=idle' pointless. */
2817 if (ephemeral && m->n_on_console > 0)
2820 va_start(ap, format);
2821 status_vprintf(status, true, ephemeral, format, ap);
2825 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2826 _cleanup_free_ char *p = NULL;
2834 p = unit_name_from_path(path, suffix);
2838 found = manager_get_unit(m, p);
2848 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2849 char p[strlen(path)+1];
2855 path_kill_slashes(p);
2857 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
2860 const char *manager_get_runtime_prefix(Manager *m) {
2863 return m->running_as == SYSTEMD_SYSTEM ?
2865 getenv("XDG_RUNTIME_DIR");
2868 ManagerState manager_state(Manager *m) {
2873 /* Did we ever finish booting? If not then we are still starting up */
2874 if (!dual_timestamp_is_set(&m->finish_timestamp))
2875 return MANAGER_STARTING;
2877 /* Is the special shutdown target queued? If so, we are in shutdown state */
2878 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2879 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
2880 return MANAGER_STOPPING;
2882 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
2883 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
2884 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2885 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2886 return MANAGER_MAINTENANCE;
2888 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
2889 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2890 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2891 return MANAGER_MAINTENANCE;
2893 /* Are there any failed units? If so, we are in degraded mode */
2894 if (set_size(m->failed_units) > 0)
2895 return MANAGER_DEGRADED;
2897 return MANAGER_RUNNING;
2900 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
2901 [MANAGER_STARTING] = "starting",
2902 [MANAGER_RUNNING] = "running",
2903 [MANAGER_DEGRADED] = "degraded",
2904 [MANAGER_MAINTENANCE] = "maintenance",
2905 [MANAGER_STOPPING] = "stopping",
2908 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);