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;
432 m->default_cpu_quota_period_usec = 100 * USEC_PER_MSEC;
434 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
436 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;
437 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
439 r = manager_default_environment(m);
443 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
447 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
451 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
455 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
459 r = set_ensure_allocated(&m->startup_units, trivial_hash_func, trivial_compare_func);
463 r = set_ensure_allocated(&m->failed_units, trivial_hash_func, trivial_compare_func);
467 r = sd_event_default(&m->event);
471 r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
475 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
479 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
483 r = manager_setup_signals(m);
487 r = manager_setup_cgroup(m);
491 r = manager_setup_time_change(m);
495 m->udev = udev_new();
501 /* Note that we set up neither kdbus, nor the notify fd
502 * here. We do that after deserialization, since they might
503 * have gotten serialized across the reexec. */
505 m->taint_usr = dir_is_empty("/usr") > 0;
515 static int manager_setup_notify(Manager *m) {
518 if (m->notify_fd < 0) {
519 _cleanup_close_ int fd = -1;
522 struct sockaddr_un un;
524 .sa.sa_family = AF_UNIX,
528 /* First free all secondary fields */
529 free(m->notify_socket);
530 m->notify_socket = NULL;
531 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
533 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
535 log_error("Failed to allocate notification socket: %m");
539 if (m->running_as == SYSTEMD_SYSTEM)
540 m->notify_socket = strdup("/run/systemd/notify");
544 e = getenv("XDG_RUNTIME_DIR");
546 log_error("XDG_RUNTIME_DIR is not set: %m");
550 m->notify_socket = strappend(e, "/systemd/notify");
552 if (!m->notify_socket)
555 strncpy(sa.un.sun_path, m->notify_socket, sizeof(sa.un.sun_path)-1);
556 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path));
558 log_error("bind() failed: %m");
562 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
564 log_error("SO_PASSCRED failed: %m");
571 log_debug("Using notification socket %s", m->notify_socket);
574 if (!m->notify_event_source) {
575 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
577 log_error("Failed to allocate notify event source: %s", strerror(-r));
581 /* Process signals a bit earlier than SIGCHLD, so that we can
582 * still identify to which service an exit message belongs */
583 r = sd_event_source_set_priority(m->notify_event_source, -7);
585 log_error("Failed to set priority of notify event source: %s", strerror(-r));
593 static int manager_setup_kdbus(Manager *m) {
595 _cleanup_free_ char *p = NULL;
601 if (m->kdbus_fd >= 0)
604 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
605 if (m->kdbus_fd < 0) {
606 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
610 log_debug("Successfully set up kdbus on %s", p);
612 /* Create the namespace directory here, so that the contents
613 * of that directory is not visible to non-root users. This is
614 * necessary to ensure that users cannot get access to busses
615 * of virtualized users when no UID namespacing is used. */
616 if (m->running_as == SYSTEMD_SYSTEM)
617 mkdir_p_label("/dev/kdbus/domain", 0700);
623 static int manager_connect_bus(Manager *m, bool reexecuting) {
624 bool try_bus_connect;
631 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
633 /* Try to connect to the busses, if possible. */
634 return bus_init(m, try_bus_connect);
637 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
643 while ((u = m->cleanup_queue)) {
644 assert(u->in_cleanup_queue);
654 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
655 GC_OFFSET_UNSURE, /* No clue */
656 GC_OFFSET_GOOD, /* We still need this unit */
657 GC_OFFSET_BAD, /* We don't need this unit anymore */
661 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
668 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
669 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
670 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
673 if (u->in_cleanup_queue)
676 if (unit_check_gc(u))
679 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
683 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
684 unit_gc_sweep(other, gc_marker);
686 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
689 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
696 /* We were unable to find anything out about this entry, so
697 * let's investigate it later */
698 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
699 unit_add_to_gc_queue(u);
703 /* We definitely know that this one is not useful anymore, so
704 * let's mark it for deletion */
705 u->gc_marker = gc_marker + GC_OFFSET_BAD;
706 unit_add_to_cleanup_queue(u);
710 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
713 static unsigned manager_dispatch_gc_queue(Manager *m) {
720 /* log_debug("Running GC..."); */
722 m->gc_marker += _GC_OFFSET_MAX;
723 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
726 gc_marker = m->gc_marker;
728 while ((u = m->gc_queue)) {
729 assert(u->in_gc_queue);
731 unit_gc_sweep(u, gc_marker);
733 LIST_REMOVE(gc_queue, m->gc_queue, u);
734 u->in_gc_queue = false;
738 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
739 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
740 log_debug_unit(u->id, "Collecting %s", u->id);
741 u->gc_marker = gc_marker + GC_OFFSET_BAD;
742 unit_add_to_cleanup_queue(u);
746 m->n_in_gc_queue = 0;
751 static void manager_clear_jobs_and_units(Manager *m) {
756 while ((u = hashmap_first(m->units)))
759 manager_dispatch_cleanup_queue(m);
761 assert(!m->load_queue);
762 assert(!m->run_queue);
763 assert(!m->dbus_unit_queue);
764 assert(!m->dbus_job_queue);
765 assert(!m->cleanup_queue);
766 assert(!m->gc_queue);
768 assert(hashmap_isempty(m->jobs));
769 assert(hashmap_isempty(m->units));
772 m->n_running_jobs = 0;
775 void manager_free(Manager *m) {
781 manager_clear_jobs_and_units(m);
783 for (c = 0; c < _UNIT_TYPE_MAX; c++)
784 if (unit_vtable[c]->shutdown)
785 unit_vtable[c]->shutdown(m);
787 /* If we reexecute ourselves, we keep the root cgroup
789 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
791 manager_undo_generators(m);
795 hashmap_free(m->units);
796 hashmap_free(m->jobs);
797 hashmap_free(m->watch_pids1);
798 hashmap_free(m->watch_pids2);
799 hashmap_free(m->watch_bus);
801 set_free(m->startup_units);
802 set_free(m->failed_units);
804 sd_event_source_unref(m->signal_event_source);
805 sd_event_source_unref(m->notify_event_source);
806 sd_event_source_unref(m->time_change_event_source);
807 sd_event_source_unref(m->jobs_in_progress_event_source);
808 sd_event_source_unref(m->idle_pipe_event_source);
809 sd_event_source_unref(m->run_queue_event_source);
811 safe_close(m->signal_fd);
812 safe_close(m->notify_fd);
813 safe_close(m->time_change_fd);
814 safe_close(m->kdbus_fd);
816 manager_close_idle_pipe(m);
819 sd_event_unref(m->event);
821 free(m->notify_socket);
823 lookup_paths_free(&m->lookup_paths);
824 strv_free(m->environment);
826 hashmap_free(m->cgroup_unit);
827 set_free_free(m->unit_path_cache);
829 free(m->switch_root);
830 free(m->switch_root_init);
832 for (i = 0; i < _RLIMIT_MAX; i++)
835 assert(hashmap_isempty(m->units_requiring_mounts_for));
836 hashmap_free(m->units_requiring_mounts_for);
841 int manager_enumerate(Manager *m) {
847 /* Let's ask every type to load all units from disk/kernel
848 * that it might know */
849 for (c = 0; c < _UNIT_TYPE_MAX; c++)
850 if (unit_vtable[c]->enumerate) {
851 q = unit_vtable[c]->enumerate(m);
856 manager_dispatch_load_queue(m);
860 static int manager_coldplug(Manager *m) {
868 /* Then, let's set up their initial state. */
869 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
876 q = unit_coldplug(u);
884 static void manager_build_unit_path_cache(Manager *m) {
886 _cleanup_free_ DIR *d = NULL;
891 set_free_free(m->unit_path_cache);
893 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
894 if (!m->unit_path_cache) {
895 log_error("Failed to allocate unit path cache.");
899 /* This simply builds a list of files we know exist, so that
900 * we don't always have to go to disk */
902 STRV_FOREACH(i, m->lookup_paths.unit_path) {
908 log_error("Failed to open directory %s: %m", *i);
912 while ((de = readdir(d))) {
915 if (ignore_file(de->d_name))
918 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
924 r = set_consume(m->unit_path_cache, p);
936 log_error("Failed to build unit path cache: %s", strerror(-r));
938 set_free_free(m->unit_path_cache);
939 m->unit_path_cache = NULL;
943 static int manager_distribute_fds(Manager *m, FDSet *fds) {
950 HASHMAP_FOREACH(u, m->units, i) {
952 if (fdset_size(fds) <= 0)
955 if (UNIT_VTABLE(u)->distribute_fds) {
956 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
965 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
970 dual_timestamp_get(&m->generators_start_timestamp);
971 manager_run_generators(m);
972 dual_timestamp_get(&m->generators_finish_timestamp);
974 r = lookup_paths_init(
975 &m->lookup_paths, m->running_as, true,
977 m->generator_unit_path,
978 m->generator_unit_path_early,
979 m->generator_unit_path_late);
983 manager_build_unit_path_cache(m);
985 /* If we will deserialize make sure that during enumeration
986 * this is already known, so we increase the counter here
991 /* First, enumerate what we can from all config files */
992 dual_timestamp_get(&m->units_load_start_timestamp);
993 r = manager_enumerate(m);
994 dual_timestamp_get(&m->units_load_finish_timestamp);
996 /* Second, deserialize if there is something to deserialize */
998 q = manager_deserialize(m, serialization, fds);
1003 /* Any fds left? Find some unit which wants them. This is
1004 * useful to allow container managers to pass some file
1005 * descriptors to us pre-initialized. This enables
1006 * socket-based activation of entire containers. */
1007 if (fdset_size(fds) > 0) {
1008 q = manager_distribute_fds(m, fds);
1013 /* We might have deserialized the notify fd, but if we didn't
1014 * then let's create the bus now */
1015 manager_setup_notify(m);
1017 /* We might have deserialized the kdbus control fd, but if we
1018 * didn't, then let's create the bus now. */
1019 manager_setup_kdbus(m);
1020 manager_connect_bus(m, !!serialization);
1021 bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
1023 /* Third, fire things up! */
1024 q = manager_coldplug(m);
1028 if (serialization) {
1029 assert(m->n_reloading > 0);
1032 /* Let's wait for the UnitNew/JobNew messages being
1033 * sent, before we notify that the reload is
1035 m->send_reloading_done = true;
1041 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1046 assert(type < _JOB_TYPE_MAX);
1048 assert(mode < _JOB_MODE_MAX);
1050 if (mode == JOB_ISOLATE && type != JOB_START) {
1051 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1055 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1056 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1060 log_debug_unit(unit->id,
1061 "Trying to enqueue job %s/%s/%s", unit->id,
1062 job_type_to_string(type), job_mode_to_string(mode));
1064 job_type_collapse(&type, unit);
1066 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1070 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1071 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1072 mode == JOB_IGNORE_DEPENDENCIES, e);
1076 if (mode == JOB_ISOLATE) {
1077 r = transaction_add_isolate_jobs(tr, m);
1082 r = transaction_activate(tr, m, mode, e);
1086 log_debug_unit(unit->id,
1087 "Enqueued job %s/%s as %u", unit->id,
1088 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1091 *_ret = tr->anchor_job;
1093 transaction_free(tr);
1097 transaction_abort(tr);
1098 transaction_free(tr);
1102 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1107 assert(type < _JOB_TYPE_MAX);
1109 assert(mode < _JOB_MODE_MAX);
1111 r = manager_load_unit(m, name, NULL, NULL, &unit);
1115 return manager_add_job(m, type, unit, mode, override, e, _ret);
1118 Job *manager_get_job(Manager *m, uint32_t id) {
1121 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1124 Unit *manager_get_unit(Manager *m, const char *name) {
1128 return hashmap_get(m->units, name);
1131 unsigned manager_dispatch_load_queue(Manager *m) {
1137 /* Make sure we are not run recursively */
1138 if (m->dispatching_load_queue)
1141 m->dispatching_load_queue = true;
1143 /* Dispatches the load queue. Takes a unit from the queue and
1144 * tries to load its data until the queue is empty */
1146 while ((u = m->load_queue)) {
1147 assert(u->in_load_queue);
1153 m->dispatching_load_queue = false;
1157 int manager_load_unit_prepare(
1169 assert(name || path);
1171 /* This will prepare the unit for loading, but not actually
1172 * load anything from disk. */
1174 if (path && !is_path(path))
1175 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1178 name = basename(path);
1180 t = unit_name_to_type(name);
1182 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1183 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1185 ret = manager_get_unit(m, name);
1191 ret = unit_new(m, unit_vtable[t]->object_size);
1196 ret->fragment_path = strdup(path);
1197 if (!ret->fragment_path) {
1203 r = unit_add_name(ret, name);
1209 unit_add_to_load_queue(ret);
1210 unit_add_to_dbus_queue(ret);
1211 unit_add_to_gc_queue(ret);
1219 int manager_load_unit(
1230 /* This will load the service information files, but not actually
1231 * start any services or anything. */
1233 r = manager_load_unit_prepare(m, name, path, e, _ret);
1237 manager_dispatch_load_queue(m);
1240 *_ret = unit_follow_merge(*_ret);
1245 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1252 HASHMAP_FOREACH(j, s->jobs, i)
1253 job_dump(j, f, prefix);
1256 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1264 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1266 unit_dump(u, f, prefix);
1269 void manager_clear_jobs(Manager *m) {
1274 while ((j = hashmap_first(m->jobs)))
1275 /* No need to recurse. We're cancelling all jobs. */
1276 job_finish_and_invalidate(j, JOB_CANCELED, false);
1279 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1280 Manager *m = userdata;
1286 while ((j = m->run_queue)) {
1287 assert(j->installed);
1288 assert(j->in_run_queue);
1290 job_run_and_invalidate(j);
1293 if (m->n_running_jobs > 0)
1294 manager_watch_jobs_in_progress(m);
1296 if (m->n_on_console > 0)
1297 manager_watch_idle_pipe(m);
1302 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1309 if (m->dispatching_dbus_queue)
1312 m->dispatching_dbus_queue = true;
1314 while ((u = m->dbus_unit_queue)) {
1315 assert(u->in_dbus_queue);
1317 bus_unit_send_change_signal(u);
1321 while ((j = m->dbus_job_queue)) {
1322 assert(j->in_dbus_queue);
1324 bus_job_send_change_signal(j);
1328 m->dispatching_dbus_queue = false;
1330 if (m->send_reloading_done) {
1331 m->send_reloading_done = false;
1333 bus_manager_send_reloading(m, false);
1336 if (m->queued_message)
1337 bus_send_queued_message(m);
1342 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n) {
1343 _cleanup_strv_free_ char **tags = NULL;
1350 tags = strv_split(buf, "\n\r");
1356 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1358 if (UNIT_VTABLE(u)->notify_message)
1359 UNIT_VTABLE(u)->notify_message(u, pid, tags);
1362 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1363 Manager *m = userdata;
1367 assert(m->notify_fd == fd);
1369 if (revents != EPOLLIN) {
1370 log_warning("Got unexpected poll event for notify fd.");
1376 struct iovec iovec = {
1378 .iov_len = sizeof(buf)-1,
1383 struct cmsghdr cmsghdr;
1384 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1387 struct msghdr msghdr = {
1390 .msg_control = &control,
1391 .msg_controllen = sizeof(control),
1393 struct ucred *ucred;
1396 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1401 if (errno == EAGAIN || errno == EINTR)
1407 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1408 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1409 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1410 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1411 log_warning("Received notify message without credentials. Ignoring.");
1415 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1417 assert((size_t) n < sizeof(buf));
1420 u = manager_get_unit_by_pid(m, ucred->pid);
1422 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1426 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1428 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1432 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1434 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1439 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1445 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1450 log_debug_unit(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1452 unit_unwatch_pid(u, si->si_pid);
1453 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1456 static int manager_dispatch_sigchld(Manager *m) {
1462 /* First we call waitd() for a PID and do not reap the
1463 * zombie. That way we can still access /proc/$PID for
1464 * it while it is a zombie. */
1465 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1467 if (errno == ECHILD)
1479 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1480 _cleanup_free_ char *name = NULL;
1483 get_process_comm(si.si_pid, &name);
1485 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1486 si.si_pid, strna(name),
1487 sigchld_code_to_string(si.si_code),
1489 strna(si.si_code == CLD_EXITED
1490 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1491 : signal_to_string(si.si_status)));
1493 /* And now figure out the unit this belongs
1494 * to, it might be multiple... */
1495 u = manager_get_unit_by_pid(m, si.si_pid);
1497 invoke_sigchld_event(m, u, &si);
1498 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1500 invoke_sigchld_event(m, u, &si);
1501 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1503 invoke_sigchld_event(m, u, &si);
1506 /* And now, we actually reap the zombie. */
1507 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1518 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1519 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1522 log_debug_unit(name, "Activating special unit %s", name);
1524 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1526 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1531 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1532 Manager *m = userdata;
1534 struct signalfd_siginfo sfsi;
1535 bool sigchld = false;
1538 assert(m->signal_fd == fd);
1540 if (revents != EPOLLIN) {
1541 log_warning("Got unexpected events from signal file descriptor.");
1546 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1547 if (n != sizeof(sfsi)) {
1552 if (errno == EINTR || errno == EAGAIN)
1558 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1559 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1560 ? LOG_DEBUG : LOG_INFO,
1563 switch (sfsi.ssi_signo) {
1570 if (m->running_as == SYSTEMD_SYSTEM) {
1571 /* This is for compatibility with the
1572 * original sysvinit */
1573 m->exit_code = MANAGER_REEXECUTE;
1580 if (m->running_as == SYSTEMD_SYSTEM) {
1581 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1585 /* Run the exit target if there is one, if not, just exit. */
1586 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1587 m->exit_code = MANAGER_EXIT;
1594 if (m->running_as == SYSTEMD_SYSTEM)
1595 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1597 /* This is a nop on non-init */
1601 if (m->running_as == SYSTEMD_SYSTEM)
1602 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1604 /* This is a nop on non-init */
1610 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1612 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1613 log_info("Trying to reconnect to bus...");
1617 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1618 log_info("Loading D-Bus service...");
1619 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1626 _cleanup_free_ char *dump = NULL;
1627 _cleanup_fclose_ FILE *f = NULL;
1630 f = open_memstream(&dump, &size);
1632 log_warning("Failed to allocate memory stream.");
1636 manager_dump_units(m, f, "\t");
1637 manager_dump_jobs(m, f, "\t");
1640 log_warning("Failed to write status stream");
1645 log_warning("Failed to flush status stream");
1649 log_dump(LOG_INFO, dump);
1654 m->exit_code = MANAGER_RELOAD;
1659 /* Starting SIGRTMIN+0 */
1660 static const char * const target_table[] = {
1661 [0] = SPECIAL_DEFAULT_TARGET,
1662 [1] = SPECIAL_RESCUE_TARGET,
1663 [2] = SPECIAL_EMERGENCY_TARGET,
1664 [3] = SPECIAL_HALT_TARGET,
1665 [4] = SPECIAL_POWEROFF_TARGET,
1666 [5] = SPECIAL_REBOOT_TARGET,
1667 [6] = SPECIAL_KEXEC_TARGET
1670 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1671 static const ManagerExitCode code_table[] = {
1673 [1] = MANAGER_POWEROFF,
1674 [2] = MANAGER_REBOOT,
1678 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1679 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1680 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1681 manager_start_target(m, target_table[idx],
1682 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1686 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1687 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1688 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1692 switch (sfsi.ssi_signo - SIGRTMIN) {
1695 log_debug("Enabling showing of status.");
1696 manager_set_show_status(m, SHOW_STATUS_YES);
1700 log_debug("Disabling showing of status.");
1701 manager_set_show_status(m, SHOW_STATUS_NO);
1705 log_set_max_level(LOG_DEBUG);
1706 log_notice("Setting log level to debug.");
1710 log_set_max_level(LOG_INFO);
1711 log_notice("Setting log level to info.");
1715 if (m->running_as == SYSTEMD_USER) {
1716 m->exit_code = MANAGER_EXIT;
1720 /* This is a nop on init */
1724 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1725 log_notice("Setting log target to journal-or-kmsg.");
1729 log_set_target(LOG_TARGET_CONSOLE);
1730 log_notice("Setting log target to console.");
1734 log_set_target(LOG_TARGET_KMSG);
1735 log_notice("Setting log target to kmsg.");
1739 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1740 log_notice("Setting log target to syslog-or-kmsg.");
1744 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1751 manager_dispatch_sigchld(m);
1756 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1757 Manager *m = userdata;
1762 assert(m->time_change_fd == fd);
1764 log_struct(LOG_INFO,
1765 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1766 "MESSAGE=Time has been changed",
1769 /* Restart the watch */
1770 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1771 m->time_change_fd = safe_close(m->time_change_fd);
1773 manager_setup_time_change(m);
1775 HASHMAP_FOREACH(u, m->units, i)
1776 if (UNIT_VTABLE(u)->time_change)
1777 UNIT_VTABLE(u)->time_change(u);
1782 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1783 Manager *m = userdata;
1786 assert(m->idle_pipe[2] == fd);
1788 m->no_console_output = m->n_on_console > 0;
1790 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1791 manager_close_idle_pipe(m);
1796 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1797 Manager *m = userdata;
1804 manager_print_jobs_in_progress(m);
1806 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1807 r = sd_event_source_set_time(source, next);
1811 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1814 int manager_loop(Manager *m) {
1817 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1820 m->exit_code = MANAGER_OK;
1822 /* Release the path cache */
1823 set_free_free(m->unit_path_cache);
1824 m->unit_path_cache = NULL;
1826 manager_check_finished(m);
1828 /* There might still be some zombies hanging around from
1829 * before we were exec()'ed. Let's reap them. */
1830 r = manager_dispatch_sigchld(m);
1834 while (m->exit_code == MANAGER_OK) {
1837 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1840 if (!ratelimit_test(&rl)) {
1841 /* Yay, something is going seriously wrong, pause a little */
1842 log_warning("Looping too fast. Throttling execution a little.");
1847 if (manager_dispatch_load_queue(m) > 0)
1850 if (manager_dispatch_gc_queue(m) > 0)
1853 if (manager_dispatch_cleanup_queue(m) > 0)
1856 if (manager_dispatch_cgroup_queue(m) > 0)
1859 if (manager_dispatch_dbus_queue(m) > 0)
1862 /* Sleep for half the watchdog time */
1863 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1864 wait_usec = m->runtime_watchdog / 2;
1868 wait_usec = (usec_t) -1;
1870 r = sd_event_run(m->event, wait_usec);
1872 log_error("Failed to run event loop: %s", strerror(-r));
1877 return m->exit_code;
1880 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1881 _cleanup_free_ char *n = NULL;
1889 r = unit_name_from_dbus_path(s, &n);
1893 r = manager_load_unit(m, n, NULL, e, &u);
1902 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1912 p = startswith(s, "/org/freedesktop/systemd1/job/");
1916 r = safe_atou(p, &id);
1920 j = manager_get_job(m, id);
1929 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1932 _cleanup_free_ char *p = NULL;
1935 audit_fd = get_audit_fd();
1939 /* Don't generate audit events if the service was already
1940 * started and we're just deserializing */
1941 if (m->n_reloading > 0)
1944 if (m->running_as != SYSTEMD_SYSTEM)
1947 if (u->type != UNIT_SERVICE)
1950 p = unit_name_to_prefix_and_instance(u->id);
1952 log_error_unit(u->id,
1953 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1957 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1958 if (errno == EPERM) {
1959 /* We aren't allowed to send audit messages?
1960 * Then let's not retry again. */
1963 log_warning("Failed to send audit message: %m");
1969 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1970 union sockaddr_union sa = {
1971 .un.sun_family = AF_UNIX,
1972 .un.sun_path = "\0/org/freedesktop/plymouthd",
1976 _cleanup_free_ char *message = NULL;
1977 _cleanup_close_ int fd = -1;
1979 /* Don't generate plymouth events if the service was already
1980 * started and we're just deserializing */
1981 if (m->n_reloading > 0)
1984 if (m->running_as != SYSTEMD_SYSTEM)
1987 if (detect_container(NULL) > 0)
1990 if (u->type != UNIT_SERVICE &&
1991 u->type != UNIT_MOUNT &&
1992 u->type != UNIT_SWAP)
1995 /* We set SOCK_NONBLOCK here so that we rather drop the
1996 * message then wait for plymouth */
1997 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1999 log_error("socket() failed: %m");
2003 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2005 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2006 log_error("connect() failed: %m");
2010 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2016 if (write(fd, message, n + 1) != n + 1)
2017 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2018 log_error("Failed to write Plymouth message: %m");
2021 void manager_dispatch_bus_name_owner_changed(
2024 const char* old_owner,
2025 const char *new_owner) {
2032 u = hashmap_get(m->watch_bus, name);
2036 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2039 int manager_open_serialization(Manager *m, FILE **_f) {
2046 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2047 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2051 log_debug("Serializing state to %s", path);
2053 f = fdopen(fd, "w+");
2064 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2077 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2078 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2079 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2080 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2082 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2083 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2084 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2085 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2088 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2089 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2090 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2091 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2092 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2093 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2094 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2095 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2098 if (!switching_root) {
2099 STRV_FOREACH(e, m->environment) {
2100 _cleanup_free_ char *ce;
2106 fprintf(f, "env=%s\n", *e);
2110 if (m->notify_fd >= 0) {
2113 copy = fdset_put_dup(fds, m->notify_fd);
2117 fprintf(f, "notify-fd=%i\n", copy);
2118 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2121 if (m->kdbus_fd >= 0) {
2124 copy = fdset_put_dup(fds, m->kdbus_fd);
2128 fprintf(f, "kdbus-fd=%i\n", copy);
2131 bus_track_serialize(m->subscribed, f);
2135 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2143 r = unit_serialize(u, f, fds, !switching_root);
2150 assert(m->n_reloading > 0);
2156 r = bus_fdset_add_all(m, fds);
2163 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2169 log_debug("Deserializing state...");
2174 char line[LINE_MAX], *l;
2176 if (!fgets(line, sizeof(line), f)) {
2191 if (startswith(l, "current-job-id=")) {
2194 if (safe_atou32(l+15, &id) < 0)
2195 log_debug("Failed to parse current job id value %s", l+15);
2197 m->current_job_id = MAX(m->current_job_id, id);
2199 } else if (startswith(l, "n-installed-jobs=")) {
2202 if (safe_atou32(l+17, &n) < 0)
2203 log_debug("Failed to parse installed jobs counter %s", l+17);
2205 m->n_installed_jobs += n;
2207 } else if (startswith(l, "n-failed-jobs=")) {
2210 if (safe_atou32(l+14, &n) < 0)
2211 log_debug("Failed to parse failed jobs counter %s", l+14);
2213 m->n_failed_jobs += n;
2215 } else if (startswith(l, "taint-usr=")) {
2218 b = parse_boolean(l+10);
2220 log_debug("Failed to parse taint /usr flag %s", l+10);
2222 m->taint_usr = m->taint_usr || b;
2224 } else if (startswith(l, "firmware-timestamp="))
2225 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2226 else if (startswith(l, "loader-timestamp="))
2227 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2228 else if (startswith(l, "kernel-timestamp="))
2229 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2230 else if (startswith(l, "initrd-timestamp="))
2231 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2232 else if (startswith(l, "userspace-timestamp="))
2233 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2234 else if (startswith(l, "finish-timestamp="))
2235 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2236 else if (startswith(l, "security-start-timestamp="))
2237 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2238 else if (startswith(l, "security-finish-timestamp="))
2239 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2240 else if (startswith(l, "generators-start-timestamp="))
2241 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2242 else if (startswith(l, "generators-finish-timestamp="))
2243 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2244 else if (startswith(l, "units-load-start-timestamp="))
2245 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2246 else if (startswith(l, "units-load-finish-timestamp="))
2247 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2248 else if (startswith(l, "env=")) {
2249 _cleanup_free_ char *uce = NULL;
2252 uce = cunescape(l+4);
2258 e = strv_env_set(m->environment, uce);
2264 strv_free(m->environment);
2267 } else if (startswith(l, "notify-fd=")) {
2270 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2271 log_debug("Failed to parse notify fd: %s", l + 10);
2273 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2274 safe_close(m->notify_fd);
2275 m->notify_fd = fdset_remove(fds, fd);
2278 } else if (startswith(l, "notify-socket=")) {
2287 free(m->notify_socket);
2288 m->notify_socket = n;
2290 } else if (startswith(l, "kdbus-fd=")) {
2293 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2294 log_debug("Failed to parse kdbus fd: %s", l + 9);
2296 safe_close(m->kdbus_fd);
2297 m->kdbus_fd = fdset_remove(fds, fd);
2300 } else if (bus_track_deserialize_item(&m->deserialized_subscribed, l) == 0)
2301 log_debug("Unknown serialization item '%s'", l);
2306 char name[UNIT_NAME_MAX+2];
2309 if (!fgets(name, sizeof(name), f)) {
2320 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2324 r = unit_deserialize(u, f, fds);
2333 assert(m->n_reloading > 0);
2339 int manager_reload(Manager *m) {
2341 _cleanup_fclose_ FILE *f = NULL;
2342 _cleanup_fdset_free_ FDSet *fds = NULL;
2346 r = manager_open_serialization(m, &f);
2351 bus_manager_send_reloading(m, true);
2359 r = manager_serialize(m, f, fds, false);
2365 if (fseeko(f, 0, SEEK_SET) < 0) {
2370 /* From here on there is no way back. */
2371 manager_clear_jobs_and_units(m);
2372 manager_undo_generators(m);
2373 lookup_paths_free(&m->lookup_paths);
2375 /* Find new unit paths */
2376 manager_run_generators(m);
2378 q = lookup_paths_init(
2379 &m->lookup_paths, m->running_as, true,
2381 m->generator_unit_path,
2382 m->generator_unit_path_early,
2383 m->generator_unit_path_late);
2387 manager_build_unit_path_cache(m);
2389 /* First, enumerate what we can from all config files */
2390 q = manager_enumerate(m);
2394 /* Second, deserialize our stored data */
2395 q = manager_deserialize(m, f, fds);
2402 /* Re-register notify_fd as event source */
2403 q = manager_setup_notify(m);
2407 /* Third, fire things up! */
2408 q = manager_coldplug(m);
2412 assert(m->n_reloading > 0);
2415 m->send_reloading_done = true;
2420 bool manager_is_reloading_or_reexecuting(Manager *m) {
2423 return m->n_reloading != 0;
2426 void manager_reset_failed(Manager *m) {
2432 HASHMAP_FOREACH(u, m->units, i)
2433 unit_reset_failed(u);
2436 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2442 /* Returns true if the unit is inactive or going down */
2443 u = manager_get_unit(m, name);
2447 return unit_inactive_or_pending(u);
2450 void manager_check_finished(Manager *m) {
2451 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2452 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2455 UnitActiveState state;
2459 if (m->n_running_jobs == 0)
2460 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2462 if (hashmap_size(m->jobs) > 0) {
2464 if (m->jobs_in_progress_event_source) {
2465 sd_event_source_set_time(m->jobs_in_progress_event_source,
2466 now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2472 manager_flip_auto_status(m, false);
2474 /* Notify Type=idle units that we are done now */
2475 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2476 manager_close_idle_pipe(m);
2478 /* Turn off confirm spawn now */
2479 m->confirm_spawn = false;
2481 if (dual_timestamp_is_set(&m->finish_timestamp))
2484 dual_timestamp_get(&m->finish_timestamp);
2486 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2488 /* Note that m->kernel_usec.monotonic is always at 0,
2489 * and m->firmware_usec.monotonic and
2490 * m->loader_usec.monotonic should be considered
2491 * negative values. */
2493 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2494 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2495 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2496 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2498 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2500 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2501 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2503 if (!log_on_console())
2504 log_struct(LOG_INFO,
2505 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2506 "KERNEL_USEC="USEC_FMT, kernel_usec,
2507 "INITRD_USEC="USEC_FMT, initrd_usec,
2508 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2509 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2510 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2511 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2512 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2513 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2516 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2519 if (!log_on_console())
2520 log_struct(LOG_INFO,
2521 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2522 "KERNEL_USEC="USEC_FMT, kernel_usec,
2523 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2524 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2525 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2526 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2527 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2531 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2532 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2534 if (!log_on_console())
2535 log_struct(LOG_INFO,
2536 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2537 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2538 "MESSAGE=Startup finished in %s.",
2539 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2543 SET_FOREACH(u, m->startup_units, i) {
2544 u = set_steal_first(m->startup_units);
2545 state = unit_active_state(u);
2546 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(state))
2548 cgroup_context_apply(m, unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path);
2551 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2554 "READY=1\nSTATUS=Startup finished in %s.",
2555 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2558 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2569 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2570 /* systemd --system, not running --test */
2572 p = strappend("/run/systemd/", name);
2576 r = mkdir_p_label(p, 0755);
2578 log_error("Failed to create generator directory %s: %s",
2583 } else if (m->running_as == SYSTEMD_USER) {
2584 const char *s = NULL;
2586 s = getenv("XDG_RUNTIME_DIR");
2589 p = strjoin(s, "/systemd/", name, NULL);
2593 r = mkdir_p_label(p, 0755);
2595 log_error("Failed to create generator directory %s: %s",
2601 /* systemd --system --test */
2603 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2608 log_error("Failed to create generator directory %s: %m",
2619 static void trim_generator_dir(Manager *m, char **generator) {
2626 if (rmdir(*generator) >= 0) {
2634 void manager_run_generators(Manager *m) {
2635 _cleanup_closedir_ DIR *d = NULL;
2636 const char *generator_path;
2637 const char *argv[5];
2642 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2643 d = opendir(generator_path);
2645 if (errno == ENOENT)
2648 log_error("Failed to enumerate generator directory %s: %m",
2653 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2657 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2661 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2665 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2666 argv[1] = m->generator_unit_path;
2667 argv[2] = m->generator_unit_path_early;
2668 argv[3] = m->generator_unit_path_late;
2671 RUN_WITH_UMASK(0022)
2672 execute_directory(generator_path, d, DEFAULT_TIMEOUT_USEC, (char**) argv);
2675 trim_generator_dir(m, &m->generator_unit_path);
2676 trim_generator_dir(m, &m->generator_unit_path_early);
2677 trim_generator_dir(m, &m->generator_unit_path_late);
2680 static void remove_generator_dir(Manager *m, char **generator) {
2687 strv_remove(m->lookup_paths.unit_path, *generator);
2688 rm_rf(*generator, false, true, false);
2694 void manager_undo_generators(Manager *m) {
2697 remove_generator_dir(m, &m->generator_unit_path);
2698 remove_generator_dir(m, &m->generator_unit_path_early);
2699 remove_generator_dir(m, &m->generator_unit_path_late);
2702 int manager_environment_add(Manager *m, char **minus, char **plus) {
2703 char **a = NULL, **b = NULL, **l;
2708 if (!strv_isempty(minus)) {
2709 a = strv_env_delete(l, 1, minus);
2716 if (!strv_isempty(plus)) {
2717 b = strv_env_merge(2, l, plus);
2724 if (m->environment != l)
2725 strv_free(m->environment);
2732 manager_clean_environment(m);
2733 strv_sort(m->environment);
2738 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2743 for (i = 0; i < _RLIMIT_MAX; i++) {
2744 if (!default_rlimit[i])
2747 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2755 void manager_recheck_journal(Manager *m) {
2760 if (m->running_as != SYSTEMD_SYSTEM)
2763 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2764 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2765 log_close_journal();
2769 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2770 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2771 log_close_journal();
2775 /* Hmm, OK, so the socket is fully up and the service is up
2776 * too, then let's make use of the thing. */
2780 void manager_set_show_status(Manager *m, ShowStatus mode) {
2782 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2784 if (m->running_as != SYSTEMD_SYSTEM)
2787 m->show_status = mode;
2790 touch("/run/systemd/show-status");
2792 unlink("/run/systemd/show-status");
2795 static bool manager_get_show_status(Manager *m) {
2798 if (m->running_as != SYSTEMD_SYSTEM)
2801 if (m->no_console_output)
2804 if (!IN_SET(manager_state(m), MANAGER_STARTING, MANAGER_STOPPING))
2807 if (m->show_status > 0)
2810 /* If Plymouth is running make sure we show the status, so
2811 * that there's something nice to see when people press Esc */
2813 return plymouth_running();
2816 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2819 if (!manager_get_show_status(m))
2822 /* XXX We should totally drop the check for ephemeral here
2823 * and thus effectively make 'Type=idle' pointless. */
2824 if (ephemeral && m->n_on_console > 0)
2827 va_start(ap, format);
2828 status_vprintf(status, true, ephemeral, format, ap);
2832 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2833 _cleanup_free_ char *p = NULL;
2841 p = unit_name_from_path(path, suffix);
2845 found = manager_get_unit(m, p);
2855 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2856 char p[strlen(path)+1];
2862 path_kill_slashes(p);
2864 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
2867 const char *manager_get_runtime_prefix(Manager *m) {
2870 return m->running_as == SYSTEMD_SYSTEM ?
2872 getenv("XDG_RUNTIME_DIR");
2875 ManagerState manager_state(Manager *m) {
2880 /* Did we ever finish booting? If not then we are still starting up */
2881 if (!dual_timestamp_is_set(&m->finish_timestamp))
2882 return MANAGER_STARTING;
2884 /* Is the special shutdown target queued? If so, we are in shutdown state */
2885 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2886 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
2887 return MANAGER_STOPPING;
2889 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
2890 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
2891 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2892 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2893 return MANAGER_MAINTENANCE;
2895 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
2896 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2897 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2898 return MANAGER_MAINTENANCE;
2900 /* Are there any failed units? If so, we are in degraded mode */
2901 if (set_size(m->failed_units) > 0)
2902 return MANAGER_DEGRADED;
2904 return MANAGER_RUNNING;
2907 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
2908 [MANAGER_STARTING] = "starting",
2909 [MANAGER_RUNNING] = "running",
2910 [MANAGER_DEGRADED] = "degraded",
2911 [MANAGER_MAINTENANCE] = "maintenance",
2912 [MANAGER_STOPPING] = "stopping",
2915 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);