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));
247 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
248 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
250 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
251 if (m->time_change_fd < 0) {
252 log_error("Failed to create timerfd: %m");
256 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
257 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
258 m->time_change_fd = safe_close(m->time_change_fd);
262 r = sd_event_add_io(m->event, &m->time_change_event_source, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m);
264 log_error("Failed to create time change event source: %s", strerror(-r));
268 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
273 static int enable_special_signals(Manager *m) {
274 _cleanup_close_ int fd = -1;
278 /* Enable that we get SIGINT on control-alt-del. In containers
279 * this will fail with EPERM (older) or EINVAL (newer), so
281 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
282 log_warning("Failed to enable ctrl-alt-del handling: %m");
284 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
286 /* Support systems without virtual console */
288 log_warning("Failed to open /dev/tty0: %m");
290 /* Enable that we get SIGWINCH on kbrequest */
291 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
292 log_warning("Failed to enable kbrequest handling: %m");
298 static int manager_setup_signals(Manager *m) {
299 struct sigaction sa = {
300 .sa_handler = SIG_DFL,
301 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
311 /* We are not interested in SIGSTOP and friends. */
312 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
314 assert_se(sigemptyset(&mask) == 0);
316 sigset_add_many(&mask,
317 SIGCHLD, /* Child died */
318 SIGTERM, /* Reexecute daemon */
319 SIGHUP, /* Reload configuration */
320 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
321 SIGUSR2, /* systemd: dump status */
322 SIGINT, /* Kernel sends us this on control-alt-del */
323 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
324 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
325 SIGRTMIN+0, /* systemd: start default.target */
326 SIGRTMIN+1, /* systemd: isolate rescue.target */
327 SIGRTMIN+2, /* systemd: isolate emergency.target */
328 SIGRTMIN+3, /* systemd: start halt.target */
329 SIGRTMIN+4, /* systemd: start poweroff.target */
330 SIGRTMIN+5, /* systemd: start reboot.target */
331 SIGRTMIN+6, /* systemd: start kexec.target */
332 SIGRTMIN+13, /* systemd: Immediate halt */
333 SIGRTMIN+14, /* systemd: Immediate poweroff */
334 SIGRTMIN+15, /* systemd: Immediate reboot */
335 SIGRTMIN+16, /* systemd: Immediate kexec */
336 SIGRTMIN+20, /* systemd: enable status messages */
337 SIGRTMIN+21, /* systemd: disable status messages */
338 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
339 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
340 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
341 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
342 SIGRTMIN+27, /* systemd: set log target to console */
343 SIGRTMIN+28, /* systemd: set log target to kmsg */
344 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
346 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
348 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
349 if (m->signal_fd < 0)
352 r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);
356 /* Process signals a bit earlier than the rest of things, but
357 * later that notify_fd processing, so that the notify
358 * processing can still figure out to which process/service a
359 * message belongs, before we reap the process. */
360 r = sd_event_source_set_priority(m->signal_event_source, -5);
364 if (m->running_as == SYSTEMD_SYSTEM)
365 return enable_special_signals(m);
370 static void manager_clean_environment(Manager *m) {
373 /* Let's remove some environment variables that we
374 * need ourselves to communicate with our clients */
387 static int manager_default_environment(Manager *m) {
390 if (m->running_as == SYSTEMD_SYSTEM) {
391 /* The system manager always starts with a clean
392 * environment for its children. It does not import
393 * the kernel or the parents exported variables.
395 * The initial passed environ is untouched to keep
396 * /proc/self/environ valid; it is used for tagging
397 * the init process inside containers. */
398 m->environment = strv_new("PATH=" DEFAULT_PATH,
401 /* Import locale variables LC_*= from configuration */
402 locale_setup(&m->environment);
404 /* The user manager passes its own environment
405 * along to its children. */
406 m->environment = strv_copy(environ);
412 manager_clean_environment(m);
413 strv_sort(m->environment);
418 int manager_new(SystemdRunningAs running_as, bool test_run, Manager **_m) {
423 assert(running_as >= 0);
424 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
426 m = new0(Manager, 1);
431 if (running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0)
432 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
435 m->running_as = running_as;
436 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
437 m->default_timer_accuracy_usec = USEC_PER_MINUTE;
439 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
441 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;
442 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
444 m->test_run = test_run;
446 r = manager_default_environment(m);
450 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
454 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
458 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
462 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
466 r = set_ensure_allocated(&m->startup_units, trivial_hash_func, trivial_compare_func);
470 r = set_ensure_allocated(&m->failed_units, trivial_hash_func, trivial_compare_func);
474 r = sd_event_default(&m->event);
478 r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
482 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
486 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
490 r = manager_setup_signals(m);
494 r = manager_setup_cgroup(m);
498 r = manager_setup_time_change(m);
502 m->udev = udev_new();
508 /* Note that we set up neither kdbus, nor the notify fd
509 * here. We do that after deserialization, since they might
510 * have gotten serialized across the reexec. */
512 m->taint_usr = dir_is_empty("/usr") > 0;
522 static int manager_setup_notify(Manager *m) {
528 if (m->notify_fd < 0) {
529 _cleanup_close_ int fd = -1;
532 struct sockaddr_un un;
534 .sa.sa_family = AF_UNIX,
538 /* First free all secondary fields */
539 free(m->notify_socket);
540 m->notify_socket = NULL;
541 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
543 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
545 log_error("Failed to allocate notification socket: %m");
549 if (m->running_as == SYSTEMD_SYSTEM)
550 m->notify_socket = strdup("/run/systemd/notify");
554 e = getenv("XDG_RUNTIME_DIR");
556 log_error("XDG_RUNTIME_DIR is not set: %m");
560 m->notify_socket = strappend(e, "/systemd/notify");
562 if (!m->notify_socket)
565 strncpy(sa.un.sun_path, m->notify_socket, sizeof(sa.un.sun_path)-1);
566 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path));
568 log_error("bind(@%s) failed: %m", sa.un.sun_path+1);
572 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
574 log_error("SO_PASSCRED failed: %m");
581 log_debug("Using notification socket %s", m->notify_socket);
584 if (!m->notify_event_source) {
585 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
587 log_error("Failed to allocate notify event source: %s", strerror(-r));
591 /* Process signals a bit earlier than SIGCHLD, so that we can
592 * still identify to which service an exit message belongs */
593 r = sd_event_source_set_priority(m->notify_event_source, -7);
595 log_error("Failed to set priority of notify event source: %s", strerror(-r));
603 static int manager_setup_kdbus(Manager *m) {
605 _cleanup_free_ char *p = NULL;
609 if (m->test_run || m->kdbus_fd >= 0)
612 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
613 if (m->kdbus_fd < 0) {
614 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
618 log_debug("Successfully set up kdbus on %s", p);
620 /* Create the namespace directory here, so that the contents
621 * of that directory is not visible to non-root users. This is
622 * necessary to ensure that users cannot get access to busses
623 * of virtualized users when no UID namespacing is used. */
624 if (m->running_as == SYSTEMD_SYSTEM)
625 mkdir_p_label("/dev/kdbus/domain", 0700);
631 static int manager_connect_bus(Manager *m, bool reexecuting) {
632 bool try_bus_connect;
642 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
644 /* Try to connect to the busses, if possible. */
645 return bus_init(m, try_bus_connect);
648 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
654 while ((u = m->cleanup_queue)) {
655 assert(u->in_cleanup_queue);
665 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
666 GC_OFFSET_UNSURE, /* No clue */
667 GC_OFFSET_GOOD, /* We still need this unit */
668 GC_OFFSET_BAD, /* We don't need this unit anymore */
672 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
679 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
680 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
681 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
684 if (u->in_cleanup_queue)
687 if (unit_check_gc(u))
690 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
694 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
695 unit_gc_sweep(other, gc_marker);
697 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
700 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
707 /* We were unable to find anything out about this entry, so
708 * let's investigate it later */
709 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
710 unit_add_to_gc_queue(u);
714 /* We definitely know that this one is not useful anymore, so
715 * let's mark it for deletion */
716 u->gc_marker = gc_marker + GC_OFFSET_BAD;
717 unit_add_to_cleanup_queue(u);
721 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
724 static unsigned manager_dispatch_gc_queue(Manager *m) {
731 /* log_debug("Running GC..."); */
733 m->gc_marker += _GC_OFFSET_MAX;
734 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
737 gc_marker = m->gc_marker;
739 while ((u = m->gc_queue)) {
740 assert(u->in_gc_queue);
742 unit_gc_sweep(u, gc_marker);
744 LIST_REMOVE(gc_queue, m->gc_queue, u);
745 u->in_gc_queue = false;
749 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
750 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
751 log_debug_unit(u->id, "Collecting %s", u->id);
752 u->gc_marker = gc_marker + GC_OFFSET_BAD;
753 unit_add_to_cleanup_queue(u);
757 m->n_in_gc_queue = 0;
762 static void manager_clear_jobs_and_units(Manager *m) {
767 while ((u = hashmap_first(m->units)))
770 manager_dispatch_cleanup_queue(m);
772 assert(!m->load_queue);
773 assert(!m->run_queue);
774 assert(!m->dbus_unit_queue);
775 assert(!m->dbus_job_queue);
776 assert(!m->cleanup_queue);
777 assert(!m->gc_queue);
779 assert(hashmap_isempty(m->jobs));
780 assert(hashmap_isempty(m->units));
783 m->n_running_jobs = 0;
786 void manager_free(Manager *m) {
792 manager_clear_jobs_and_units(m);
794 for (c = 0; c < _UNIT_TYPE_MAX; c++)
795 if (unit_vtable[c]->shutdown)
796 unit_vtable[c]->shutdown(m);
798 /* If we reexecute ourselves, we keep the root cgroup
800 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
802 manager_undo_generators(m);
806 hashmap_free(m->units);
807 hashmap_free(m->jobs);
808 hashmap_free(m->watch_pids1);
809 hashmap_free(m->watch_pids2);
810 hashmap_free(m->watch_bus);
812 set_free(m->startup_units);
813 set_free(m->failed_units);
815 sd_event_source_unref(m->signal_event_source);
816 sd_event_source_unref(m->notify_event_source);
817 sd_event_source_unref(m->time_change_event_source);
818 sd_event_source_unref(m->jobs_in_progress_event_source);
819 sd_event_source_unref(m->idle_pipe_event_source);
820 sd_event_source_unref(m->run_queue_event_source);
822 safe_close(m->signal_fd);
823 safe_close(m->notify_fd);
824 safe_close(m->time_change_fd);
825 safe_close(m->kdbus_fd);
827 manager_close_idle_pipe(m);
830 sd_event_unref(m->event);
832 free(m->notify_socket);
834 lookup_paths_free(&m->lookup_paths);
835 strv_free(m->environment);
837 hashmap_free(m->cgroup_unit);
838 set_free_free(m->unit_path_cache);
840 free(m->switch_root);
841 free(m->switch_root_init);
843 for (i = 0; i < _RLIMIT_MAX; i++)
846 assert(hashmap_isempty(m->units_requiring_mounts_for));
847 hashmap_free(m->units_requiring_mounts_for);
852 int manager_enumerate(Manager *m) {
858 /* Let's ask every type to load all units from disk/kernel
859 * that it might know */
860 for (c = 0; c < _UNIT_TYPE_MAX; c++)
861 if (unit_vtable[c]->enumerate) {
862 q = unit_vtable[c]->enumerate(m);
867 manager_dispatch_load_queue(m);
871 static int manager_coldplug(Manager *m) {
879 /* Then, let's set up their initial state. */
880 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
887 q = unit_coldplug(u);
895 static void manager_build_unit_path_cache(Manager *m) {
897 _cleanup_free_ DIR *d = NULL;
902 set_free_free(m->unit_path_cache);
904 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
905 if (!m->unit_path_cache) {
906 log_error("Failed to allocate unit path cache.");
910 /* This simply builds a list of files we know exist, so that
911 * we don't always have to go to disk */
913 STRV_FOREACH(i, m->lookup_paths.unit_path) {
919 log_error("Failed to open directory %s: %m", *i);
923 while ((de = readdir(d))) {
926 if (ignore_file(de->d_name))
929 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
935 r = set_consume(m->unit_path_cache, p);
947 log_error("Failed to build unit path cache: %s", strerror(-r));
949 set_free_free(m->unit_path_cache);
950 m->unit_path_cache = NULL;
954 static int manager_distribute_fds(Manager *m, FDSet *fds) {
961 HASHMAP_FOREACH(u, m->units, i) {
963 if (fdset_size(fds) <= 0)
966 if (UNIT_VTABLE(u)->distribute_fds) {
967 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
976 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
981 dual_timestamp_get(&m->generators_start_timestamp);
982 manager_run_generators(m);
983 dual_timestamp_get(&m->generators_finish_timestamp);
985 r = lookup_paths_init(
986 &m->lookup_paths, m->running_as, true,
988 m->generator_unit_path,
989 m->generator_unit_path_early,
990 m->generator_unit_path_late);
994 manager_build_unit_path_cache(m);
996 /* If we will deserialize make sure that during enumeration
997 * this is already known, so we increase the counter here
1002 /* First, enumerate what we can from all config files */
1003 dual_timestamp_get(&m->units_load_start_timestamp);
1004 r = manager_enumerate(m);
1005 dual_timestamp_get(&m->units_load_finish_timestamp);
1007 /* Second, deserialize if there is something to deserialize */
1009 r = manager_deserialize(m, serialization, fds);
1011 /* Any fds left? Find some unit which wants them. This is
1012 * useful to allow container managers to pass some file
1013 * descriptors to us pre-initialized. This enables
1014 * socket-based activation of entire containers. */
1015 if (fdset_size(fds) > 0) {
1016 q = manager_distribute_fds(m, fds);
1017 if (q < 0 && r == 0)
1021 /* We might have deserialized the notify fd, but if we didn't
1022 * then let's create the bus now */
1023 q = manager_setup_notify(m);
1024 if (q < 0 && r == 0)
1027 /* We might have deserialized the kdbus control fd, but if we
1028 * didn't, then let's create the bus now. */
1029 manager_setup_kdbus(m);
1030 manager_connect_bus(m, !!serialization);
1031 bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
1033 /* Third, fire things up! */
1034 q = manager_coldplug(m);
1035 if (q < 0 && r == 0)
1038 if (serialization) {
1039 assert(m->n_reloading > 0);
1042 /* Let's wait for the UnitNew/JobNew messages being
1043 * sent, before we notify that the reload is
1045 m->send_reloading_done = true;
1051 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1056 assert(type < _JOB_TYPE_MAX);
1058 assert(mode < _JOB_MODE_MAX);
1060 if (mode == JOB_ISOLATE && type != JOB_START) {
1061 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1065 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1066 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1070 log_debug_unit(unit->id,
1071 "Trying to enqueue job %s/%s/%s", unit->id,
1072 job_type_to_string(type), job_mode_to_string(mode));
1074 job_type_collapse(&type, unit);
1076 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1080 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1081 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1082 mode == JOB_IGNORE_DEPENDENCIES, e);
1086 if (mode == JOB_ISOLATE) {
1087 r = transaction_add_isolate_jobs(tr, m);
1092 r = transaction_activate(tr, m, mode, e);
1096 log_debug_unit(unit->id,
1097 "Enqueued job %s/%s as %u", unit->id,
1098 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1101 *_ret = tr->anchor_job;
1103 transaction_free(tr);
1107 transaction_abort(tr);
1108 transaction_free(tr);
1112 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1117 assert(type < _JOB_TYPE_MAX);
1119 assert(mode < _JOB_MODE_MAX);
1121 r = manager_load_unit(m, name, NULL, NULL, &unit);
1125 return manager_add_job(m, type, unit, mode, override, e, _ret);
1128 Job *manager_get_job(Manager *m, uint32_t id) {
1131 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1134 Unit *manager_get_unit(Manager *m, const char *name) {
1138 return hashmap_get(m->units, name);
1141 unsigned manager_dispatch_load_queue(Manager *m) {
1147 /* Make sure we are not run recursively */
1148 if (m->dispatching_load_queue)
1151 m->dispatching_load_queue = true;
1153 /* Dispatches the load queue. Takes a unit from the queue and
1154 * tries to load its data until the queue is empty */
1156 while ((u = m->load_queue)) {
1157 assert(u->in_load_queue);
1163 m->dispatching_load_queue = false;
1167 int manager_load_unit_prepare(
1179 assert(name || path);
1181 /* This will prepare the unit for loading, but not actually
1182 * load anything from disk. */
1184 if (path && !is_path(path))
1185 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1188 name = basename(path);
1190 t = unit_name_to_type(name);
1192 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1193 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1195 ret = manager_get_unit(m, name);
1201 ret = unit_new(m, unit_vtable[t]->object_size);
1206 ret->fragment_path = strdup(path);
1207 if (!ret->fragment_path) {
1213 r = unit_add_name(ret, name);
1219 unit_add_to_load_queue(ret);
1220 unit_add_to_dbus_queue(ret);
1221 unit_add_to_gc_queue(ret);
1229 int manager_load_unit(
1240 /* This will load the service information files, but not actually
1241 * start any services or anything. */
1243 r = manager_load_unit_prepare(m, name, path, e, _ret);
1247 manager_dispatch_load_queue(m);
1250 *_ret = unit_follow_merge(*_ret);
1255 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1262 HASHMAP_FOREACH(j, s->jobs, i)
1263 job_dump(j, f, prefix);
1266 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1274 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1276 unit_dump(u, f, prefix);
1279 void manager_clear_jobs(Manager *m) {
1284 while ((j = hashmap_first(m->jobs)))
1285 /* No need to recurse. We're cancelling all jobs. */
1286 job_finish_and_invalidate(j, JOB_CANCELED, false);
1289 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1290 Manager *m = userdata;
1296 while ((j = m->run_queue)) {
1297 assert(j->installed);
1298 assert(j->in_run_queue);
1300 job_run_and_invalidate(j);
1303 if (m->n_running_jobs > 0)
1304 manager_watch_jobs_in_progress(m);
1306 if (m->n_on_console > 0)
1307 manager_watch_idle_pipe(m);
1312 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1319 if (m->dispatching_dbus_queue)
1322 m->dispatching_dbus_queue = true;
1324 while ((u = m->dbus_unit_queue)) {
1325 assert(u->in_dbus_queue);
1327 bus_unit_send_change_signal(u);
1331 while ((j = m->dbus_job_queue)) {
1332 assert(j->in_dbus_queue);
1334 bus_job_send_change_signal(j);
1338 m->dispatching_dbus_queue = false;
1340 if (m->send_reloading_done) {
1341 m->send_reloading_done = false;
1343 bus_manager_send_reloading(m, false);
1346 if (m->queued_message)
1347 bus_send_queued_message(m);
1352 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n) {
1353 _cleanup_strv_free_ char **tags = NULL;
1360 tags = strv_split(buf, "\n\r");
1366 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1368 if (UNIT_VTABLE(u)->notify_message)
1369 UNIT_VTABLE(u)->notify_message(u, pid, tags);
1372 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1373 Manager *m = userdata;
1377 assert(m->notify_fd == fd);
1379 if (revents != EPOLLIN) {
1380 log_warning("Got unexpected poll event for notify fd.");
1386 struct iovec iovec = {
1388 .iov_len = sizeof(buf)-1,
1393 struct cmsghdr cmsghdr;
1394 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1397 struct msghdr msghdr = {
1400 .msg_control = &control,
1401 .msg_controllen = sizeof(control),
1403 struct ucred *ucred;
1406 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1411 if (errno == EAGAIN || errno == EINTR)
1417 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1418 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1419 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1420 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1421 log_warning("Received notify message without credentials. Ignoring.");
1425 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1427 assert((size_t) n < sizeof(buf));
1430 u = manager_get_unit_by_pid(m, ucred->pid);
1432 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1436 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1438 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1442 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1444 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1449 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1455 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1460 log_debug_unit(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1462 unit_unwatch_pid(u, si->si_pid);
1463 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1466 static int manager_dispatch_sigchld(Manager *m) {
1472 /* First we call waitd() for a PID and do not reap the
1473 * zombie. That way we can still access /proc/$PID for
1474 * it while it is a zombie. */
1475 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1477 if (errno == ECHILD)
1489 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1490 _cleanup_free_ char *name = NULL;
1493 get_process_comm(si.si_pid, &name);
1495 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1496 si.si_pid, strna(name),
1497 sigchld_code_to_string(si.si_code),
1499 strna(si.si_code == CLD_EXITED
1500 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1501 : signal_to_string(si.si_status)));
1503 /* And now figure out the unit this belongs
1504 * to, it might be multiple... */
1505 u = manager_get_unit_by_pid(m, si.si_pid);
1507 invoke_sigchld_event(m, u, &si);
1508 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1510 invoke_sigchld_event(m, u, &si);
1511 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1513 invoke_sigchld_event(m, u, &si);
1516 /* And now, we actually reap the zombie. */
1517 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1528 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1529 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1532 log_debug_unit(name, "Activating special unit %s", name);
1534 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1536 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1541 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1542 Manager *m = userdata;
1544 struct signalfd_siginfo sfsi;
1545 bool sigchld = false;
1548 assert(m->signal_fd == fd);
1550 if (revents != EPOLLIN) {
1551 log_warning("Got unexpected events from signal file descriptor.");
1556 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1557 if (n != sizeof(sfsi)) {
1562 if (errno == EINTR || errno == EAGAIN)
1568 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1569 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1570 ? LOG_DEBUG : LOG_INFO,
1573 switch (sfsi.ssi_signo) {
1580 if (m->running_as == SYSTEMD_SYSTEM) {
1581 /* This is for compatibility with the
1582 * original sysvinit */
1583 m->exit_code = MANAGER_REEXECUTE;
1590 if (m->running_as == SYSTEMD_SYSTEM) {
1591 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1595 /* Run the exit target if there is one, if not, just exit. */
1596 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1597 m->exit_code = MANAGER_EXIT;
1604 if (m->running_as == SYSTEMD_SYSTEM)
1605 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1607 /* This is a nop on non-init */
1611 if (m->running_as == SYSTEMD_SYSTEM)
1612 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1614 /* This is a nop on non-init */
1620 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1622 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1623 log_info("Trying to reconnect to bus...");
1627 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1628 log_info("Loading D-Bus service...");
1629 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1636 _cleanup_free_ char *dump = NULL;
1637 _cleanup_fclose_ FILE *f = NULL;
1640 f = open_memstream(&dump, &size);
1642 log_warning("Failed to allocate memory stream.");
1646 manager_dump_units(m, f, "\t");
1647 manager_dump_jobs(m, f, "\t");
1650 log_warning("Failed to write status stream");
1655 log_warning("Failed to flush status stream");
1659 log_dump(LOG_INFO, dump);
1664 m->exit_code = MANAGER_RELOAD;
1669 /* Starting SIGRTMIN+0 */
1670 static const char * const target_table[] = {
1671 [0] = SPECIAL_DEFAULT_TARGET,
1672 [1] = SPECIAL_RESCUE_TARGET,
1673 [2] = SPECIAL_EMERGENCY_TARGET,
1674 [3] = SPECIAL_HALT_TARGET,
1675 [4] = SPECIAL_POWEROFF_TARGET,
1676 [5] = SPECIAL_REBOOT_TARGET,
1677 [6] = SPECIAL_KEXEC_TARGET
1680 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1681 static const ManagerExitCode code_table[] = {
1683 [1] = MANAGER_POWEROFF,
1684 [2] = MANAGER_REBOOT,
1688 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1689 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1690 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1691 manager_start_target(m, target_table[idx],
1692 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1696 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1697 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1698 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1702 switch (sfsi.ssi_signo - SIGRTMIN) {
1705 log_debug("Enabling showing of status.");
1706 manager_set_show_status(m, SHOW_STATUS_YES);
1710 log_debug("Disabling showing of status.");
1711 manager_set_show_status(m, SHOW_STATUS_NO);
1715 log_set_max_level(LOG_DEBUG);
1716 log_notice("Setting log level to debug.");
1720 log_set_max_level(LOG_INFO);
1721 log_notice("Setting log level to info.");
1725 if (m->running_as == SYSTEMD_USER) {
1726 m->exit_code = MANAGER_EXIT;
1730 /* This is a nop on init */
1734 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1735 log_notice("Setting log target to journal-or-kmsg.");
1739 log_set_target(LOG_TARGET_CONSOLE);
1740 log_notice("Setting log target to console.");
1744 log_set_target(LOG_TARGET_KMSG);
1745 log_notice("Setting log target to kmsg.");
1749 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1750 log_notice("Setting log target to syslog-or-kmsg.");
1754 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1761 manager_dispatch_sigchld(m);
1766 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1767 Manager *m = userdata;
1772 assert(m->time_change_fd == fd);
1774 log_struct(LOG_INFO,
1775 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1776 "MESSAGE=Time has been changed",
1779 /* Restart the watch */
1780 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1781 m->time_change_fd = safe_close(m->time_change_fd);
1783 manager_setup_time_change(m);
1785 HASHMAP_FOREACH(u, m->units, i)
1786 if (UNIT_VTABLE(u)->time_change)
1787 UNIT_VTABLE(u)->time_change(u);
1792 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1793 Manager *m = userdata;
1796 assert(m->idle_pipe[2] == fd);
1798 m->no_console_output = m->n_on_console > 0;
1800 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1801 manager_close_idle_pipe(m);
1806 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1807 Manager *m = userdata;
1814 manager_print_jobs_in_progress(m);
1816 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1817 r = sd_event_source_set_time(source, next);
1821 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1824 int manager_loop(Manager *m) {
1827 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1830 m->exit_code = MANAGER_OK;
1832 /* Release the path cache */
1833 set_free_free(m->unit_path_cache);
1834 m->unit_path_cache = NULL;
1836 manager_check_finished(m);
1838 /* There might still be some zombies hanging around from
1839 * before we were exec()'ed. Let's reap them. */
1840 r = manager_dispatch_sigchld(m);
1844 while (m->exit_code == MANAGER_OK) {
1847 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1850 if (!ratelimit_test(&rl)) {
1851 /* Yay, something is going seriously wrong, pause a little */
1852 log_warning("Looping too fast. Throttling execution a little.");
1857 if (manager_dispatch_load_queue(m) > 0)
1860 if (manager_dispatch_gc_queue(m) > 0)
1863 if (manager_dispatch_cleanup_queue(m) > 0)
1866 if (manager_dispatch_cgroup_queue(m) > 0)
1869 if (manager_dispatch_dbus_queue(m) > 0)
1872 /* Sleep for half the watchdog time */
1873 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1874 wait_usec = m->runtime_watchdog / 2;
1878 wait_usec = USEC_INFINITY;
1880 r = sd_event_run(m->event, wait_usec);
1882 log_error("Failed to run event loop: %s", strerror(-r));
1887 return m->exit_code;
1890 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1891 _cleanup_free_ char *n = NULL;
1899 r = unit_name_from_dbus_path(s, &n);
1903 r = manager_load_unit(m, n, NULL, e, &u);
1912 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1922 p = startswith(s, "/org/freedesktop/systemd1/job/");
1926 r = safe_atou(p, &id);
1930 j = manager_get_job(m, id);
1939 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1942 _cleanup_free_ char *p = NULL;
1945 audit_fd = get_audit_fd();
1949 /* Don't generate audit events if the service was already
1950 * started and we're just deserializing */
1951 if (m->n_reloading > 0)
1954 if (m->running_as != SYSTEMD_SYSTEM)
1957 if (u->type != UNIT_SERVICE)
1960 p = unit_name_to_prefix_and_instance(u->id);
1962 log_error_unit(u->id,
1963 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1967 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1968 if (errno == EPERM) {
1969 /* We aren't allowed to send audit messages?
1970 * Then let's not retry again. */
1973 log_warning("Failed to send audit message: %m");
1979 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1980 union sockaddr_union sa = PLYMOUTH_SOCKET;
1983 _cleanup_free_ char *message = NULL;
1984 _cleanup_close_ int fd = -1;
1986 /* Don't generate plymouth events if the service was already
1987 * started and we're just deserializing */
1988 if (m->n_reloading > 0)
1991 if (m->running_as != SYSTEMD_SYSTEM)
1994 if (detect_container(NULL) > 0)
1997 if (u->type != UNIT_SERVICE &&
1998 u->type != UNIT_MOUNT &&
1999 u->type != UNIT_SWAP)
2002 /* We set SOCK_NONBLOCK here so that we rather drop the
2003 * message then wait for plymouth */
2004 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2006 log_error("socket() failed: %m");
2010 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2012 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2013 log_error("connect() failed: %m");
2017 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2023 if (write(fd, message, n + 1) != n + 1)
2024 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2025 log_error("Failed to write Plymouth message: %m");
2028 void manager_dispatch_bus_name_owner_changed(
2031 const char* old_owner,
2032 const char *new_owner) {
2039 u = hashmap_get(m->watch_bus, name);
2043 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2046 int manager_open_serialization(Manager *m, FILE **_f) {
2053 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2054 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2058 log_debug("Serializing state to %s", path);
2060 f = fdopen(fd, "w+");
2071 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2084 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2085 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2086 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2087 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2089 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2090 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2091 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2092 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2095 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2096 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2097 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2098 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2099 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2100 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2101 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2102 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2105 if (!switching_root) {
2106 STRV_FOREACH(e, m->environment) {
2107 _cleanup_free_ char *ce;
2113 fprintf(f, "env=%s\n", *e);
2117 if (m->notify_fd >= 0) {
2120 copy = fdset_put_dup(fds, m->notify_fd);
2124 fprintf(f, "notify-fd=%i\n", copy);
2125 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2128 if (m->kdbus_fd >= 0) {
2131 copy = fdset_put_dup(fds, m->kdbus_fd);
2135 fprintf(f, "kdbus-fd=%i\n", copy);
2138 bus_track_serialize(m->subscribed, f);
2142 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2150 r = unit_serialize(u, f, fds, !switching_root);
2157 assert(m->n_reloading > 0);
2163 r = bus_fdset_add_all(m, fds);
2170 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2176 log_debug("Deserializing state...");
2181 char line[LINE_MAX], *l;
2183 if (!fgets(line, sizeof(line), f)) {
2198 if (startswith(l, "current-job-id=")) {
2201 if (safe_atou32(l+15, &id) < 0)
2202 log_debug("Failed to parse current job id value %s", l+15);
2204 m->current_job_id = MAX(m->current_job_id, id);
2206 } else if (startswith(l, "n-installed-jobs=")) {
2209 if (safe_atou32(l+17, &n) < 0)
2210 log_debug("Failed to parse installed jobs counter %s", l+17);
2212 m->n_installed_jobs += n;
2214 } else if (startswith(l, "n-failed-jobs=")) {
2217 if (safe_atou32(l+14, &n) < 0)
2218 log_debug("Failed to parse failed jobs counter %s", l+14);
2220 m->n_failed_jobs += n;
2222 } else if (startswith(l, "taint-usr=")) {
2225 b = parse_boolean(l+10);
2227 log_debug("Failed to parse taint /usr flag %s", l+10);
2229 m->taint_usr = m->taint_usr || b;
2231 } else if (startswith(l, "firmware-timestamp="))
2232 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2233 else if (startswith(l, "loader-timestamp="))
2234 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2235 else if (startswith(l, "kernel-timestamp="))
2236 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2237 else if (startswith(l, "initrd-timestamp="))
2238 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2239 else if (startswith(l, "userspace-timestamp="))
2240 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2241 else if (startswith(l, "finish-timestamp="))
2242 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2243 else if (startswith(l, "security-start-timestamp="))
2244 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2245 else if (startswith(l, "security-finish-timestamp="))
2246 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2247 else if (startswith(l, "generators-start-timestamp="))
2248 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2249 else if (startswith(l, "generators-finish-timestamp="))
2250 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2251 else if (startswith(l, "units-load-start-timestamp="))
2252 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2253 else if (startswith(l, "units-load-finish-timestamp="))
2254 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2255 else if (startswith(l, "env=")) {
2256 _cleanup_free_ char *uce = NULL;
2259 uce = cunescape(l+4);
2265 e = strv_env_set(m->environment, uce);
2271 strv_free(m->environment);
2274 } else if (startswith(l, "notify-fd=")) {
2277 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2278 log_debug("Failed to parse notify fd: %s", l + 10);
2280 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2281 safe_close(m->notify_fd);
2282 m->notify_fd = fdset_remove(fds, fd);
2285 } else if (startswith(l, "notify-socket=")) {
2294 free(m->notify_socket);
2295 m->notify_socket = n;
2297 } else if (startswith(l, "kdbus-fd=")) {
2300 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2301 log_debug("Failed to parse kdbus fd: %s", l + 9);
2303 safe_close(m->kdbus_fd);
2304 m->kdbus_fd = fdset_remove(fds, fd);
2307 } else if (bus_track_deserialize_item(&m->deserialized_subscribed, l) == 0)
2308 log_debug("Unknown serialization item '%s'", l);
2313 char name[UNIT_NAME_MAX+2];
2316 if (!fgets(name, sizeof(name), f)) {
2327 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2331 r = unit_deserialize(u, f, fds);
2340 assert(m->n_reloading > 0);
2346 int manager_reload(Manager *m) {
2348 _cleanup_fclose_ FILE *f = NULL;
2349 _cleanup_fdset_free_ FDSet *fds = NULL;
2353 r = manager_open_serialization(m, &f);
2358 bus_manager_send_reloading(m, true);
2366 r = manager_serialize(m, f, fds, false);
2372 if (fseeko(f, 0, SEEK_SET) < 0) {
2377 /* From here on there is no way back. */
2378 manager_clear_jobs_and_units(m);
2379 manager_undo_generators(m);
2380 lookup_paths_free(&m->lookup_paths);
2382 /* Find new unit paths */
2383 manager_run_generators(m);
2385 q = lookup_paths_init(
2386 &m->lookup_paths, m->running_as, true,
2388 m->generator_unit_path,
2389 m->generator_unit_path_early,
2390 m->generator_unit_path_late);
2394 manager_build_unit_path_cache(m);
2396 /* First, enumerate what we can from all config files */
2397 q = manager_enumerate(m);
2401 /* Second, deserialize our stored data */
2402 q = manager_deserialize(m, f, fds);
2409 /* Re-register notify_fd as event source */
2410 q = manager_setup_notify(m);
2414 /* Third, fire things up! */
2415 q = manager_coldplug(m);
2419 assert(m->n_reloading > 0);
2422 m->send_reloading_done = true;
2427 bool manager_is_reloading_or_reexecuting(Manager *m) {
2430 return m->n_reloading != 0;
2433 void manager_reset_failed(Manager *m) {
2439 HASHMAP_FOREACH(u, m->units, i)
2440 unit_reset_failed(u);
2443 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2449 /* Returns true if the unit is inactive or going down */
2450 u = manager_get_unit(m, name);
2454 return unit_inactive_or_pending(u);
2457 void manager_check_finished(Manager *m) {
2458 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2459 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2465 if (m->n_running_jobs == 0)
2466 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2468 if (hashmap_size(m->jobs) > 0) {
2470 if (m->jobs_in_progress_event_source) {
2471 sd_event_source_set_time(m->jobs_in_progress_event_source,
2472 now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2478 manager_flip_auto_status(m, false);
2480 /* Notify Type=idle units that we are done now */
2481 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2482 manager_close_idle_pipe(m);
2484 /* Turn off confirm spawn now */
2485 m->confirm_spawn = false;
2487 /* This is no longer the first boot */
2488 manager_set_first_boot(m, false);
2490 if (dual_timestamp_is_set(&m->finish_timestamp))
2493 dual_timestamp_get(&m->finish_timestamp);
2495 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2497 /* Note that m->kernel_usec.monotonic is always at 0,
2498 * and m->firmware_usec.monotonic and
2499 * m->loader_usec.monotonic should be considered
2500 * negative values. */
2502 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2503 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2504 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2505 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2507 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2509 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2510 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2512 if (!log_on_console())
2513 log_struct(LOG_INFO,
2514 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2515 "KERNEL_USEC="USEC_FMT, kernel_usec,
2516 "INITRD_USEC="USEC_FMT, initrd_usec,
2517 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2518 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2519 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2520 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2521 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2522 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2525 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2528 if (!log_on_console())
2529 log_struct(LOG_INFO,
2530 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2531 "KERNEL_USEC="USEC_FMT, kernel_usec,
2532 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2533 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2534 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2535 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2536 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2540 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2541 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2543 if (!log_on_console())
2544 log_struct(LOG_INFO,
2545 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2546 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2547 "MESSAGE=Startup finished in %s.",
2548 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2552 SET_FOREACH(u, m->startup_units, i)
2554 cgroup_context_apply(unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path, manager_state(m));
2556 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2559 "READY=1\nSTATUS=Startup finished in %s.",
2560 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2563 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2574 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2575 /* systemd --system, not running --test */
2577 p = strappend("/run/systemd/", name);
2581 r = mkdir_p_label(p, 0755);
2583 log_error("Failed to create generator directory %s: %s",
2588 } else if (m->running_as == SYSTEMD_USER) {
2589 const char *s = NULL;
2591 s = getenv("XDG_RUNTIME_DIR");
2594 p = strjoin(s, "/systemd/", name, NULL);
2598 r = mkdir_p_label(p, 0755);
2600 log_error("Failed to create generator directory %s: %s",
2606 /* systemd --system --test */
2608 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2613 log_error("Failed to create generator directory %s: %m",
2624 static void trim_generator_dir(Manager *m, char **generator) {
2631 if (rmdir(*generator) >= 0) {
2639 void manager_run_generators(Manager *m) {
2640 _cleanup_closedir_ DIR *d = NULL;
2641 const char *generator_path;
2642 const char *argv[5];
2650 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2651 d = opendir(generator_path);
2653 if (errno == ENOENT)
2656 log_error("Failed to enumerate generator directory %s: %m",
2661 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2665 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2669 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2673 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2674 argv[1] = m->generator_unit_path;
2675 argv[2] = m->generator_unit_path_early;
2676 argv[3] = m->generator_unit_path_late;
2679 RUN_WITH_UMASK(0022)
2680 execute_directory(generator_path, d, DEFAULT_TIMEOUT_USEC, (char**) argv);
2683 trim_generator_dir(m, &m->generator_unit_path);
2684 trim_generator_dir(m, &m->generator_unit_path_early);
2685 trim_generator_dir(m, &m->generator_unit_path_late);
2688 static void remove_generator_dir(Manager *m, char **generator) {
2695 strv_remove(m->lookup_paths.unit_path, *generator);
2696 rm_rf(*generator, false, true, false);
2702 void manager_undo_generators(Manager *m) {
2705 remove_generator_dir(m, &m->generator_unit_path);
2706 remove_generator_dir(m, &m->generator_unit_path_early);
2707 remove_generator_dir(m, &m->generator_unit_path_late);
2710 int manager_environment_add(Manager *m, char **minus, char **plus) {
2711 char **a = NULL, **b = NULL, **l;
2716 if (!strv_isempty(minus)) {
2717 a = strv_env_delete(l, 1, minus);
2724 if (!strv_isempty(plus)) {
2725 b = strv_env_merge(2, l, plus);
2732 if (m->environment != l)
2733 strv_free(m->environment);
2740 manager_clean_environment(m);
2741 strv_sort(m->environment);
2746 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2751 for (i = 0; i < _RLIMIT_MAX; i++) {
2752 if (!default_rlimit[i])
2755 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2763 void manager_recheck_journal(Manager *m) {
2768 if (m->running_as != SYSTEMD_SYSTEM)
2771 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2772 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2773 log_close_journal();
2777 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2778 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2779 log_close_journal();
2783 /* Hmm, OK, so the socket is fully up and the service is up
2784 * too, then let's make use of the thing. */
2788 void manager_set_show_status(Manager *m, ShowStatus mode) {
2790 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2792 if (m->running_as != SYSTEMD_SYSTEM)
2795 m->show_status = mode;
2798 touch("/run/systemd/show-status");
2800 unlink("/run/systemd/show-status");
2803 static bool manager_get_show_status(Manager *m) {
2806 if (m->running_as != SYSTEMD_SYSTEM)
2809 if (m->no_console_output)
2812 if (!IN_SET(manager_state(m), MANAGER_STARTING, MANAGER_STOPPING))
2815 if (m->show_status > 0)
2818 /* If Plymouth is running make sure we show the status, so
2819 * that there's something nice to see when people press Esc */
2821 return plymouth_running();
2824 void manager_set_first_boot(Manager *m, bool b) {
2827 if (m->running_as != SYSTEMD_SYSTEM)
2833 touch("/run/systemd/first-boot");
2835 unlink("/run/systemd/first-boot");
2838 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2841 if (!manager_get_show_status(m))
2844 /* XXX We should totally drop the check for ephemeral here
2845 * and thus effectively make 'Type=idle' pointless. */
2846 if (ephemeral && m->n_on_console > 0)
2849 va_start(ap, format);
2850 status_vprintf(status, true, ephemeral, format, ap);
2854 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2855 _cleanup_free_ char *p = NULL;
2863 p = unit_name_from_path(path, suffix);
2867 found = manager_get_unit(m, p);
2877 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2878 char p[strlen(path)+1];
2884 path_kill_slashes(p);
2886 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
2889 const char *manager_get_runtime_prefix(Manager *m) {
2892 return m->running_as == SYSTEMD_SYSTEM ?
2894 getenv("XDG_RUNTIME_DIR");
2897 ManagerState manager_state(Manager *m) {
2902 /* Did we ever finish booting? If not then we are still starting up */
2903 if (!dual_timestamp_is_set(&m->finish_timestamp))
2904 return MANAGER_STARTING;
2906 /* Is the special shutdown target queued? If so, we are in shutdown state */
2907 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2908 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
2909 return MANAGER_STOPPING;
2911 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
2912 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
2913 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2914 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2915 return MANAGER_MAINTENANCE;
2917 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
2918 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2919 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2920 return MANAGER_MAINTENANCE;
2922 /* Are there any failed units? If so, we are in degraded mode */
2923 if (set_size(m->failed_units) > 0)
2924 return MANAGER_DEGRADED;
2926 return MANAGER_RUNNING;
2929 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
2930 [MANAGER_STARTING] = "starting",
2931 [MANAGER_RUNNING] = "running",
2932 [MANAGER_DEGRADED] = "degraded",
2933 [MANAGER_MAINTENANCE] = "maintenance",
2934 [MANAGER_STOPPING] = "stopping",
2937 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);