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 (obsolete)*/
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;
530 union sockaddr_union sa = {
531 .sa.sa_family = AF_UNIX,
533 static const int one = 1;
535 /* First free all secondary fields */
536 free(m->notify_socket);
537 m->notify_socket = NULL;
538 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
540 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
542 log_error("Failed to allocate notification socket: %m");
546 if (m->running_as == SYSTEMD_SYSTEM)
547 m->notify_socket = strdup("/run/systemd/notify");
551 e = getenv("XDG_RUNTIME_DIR");
553 log_error("XDG_RUNTIME_DIR is not set: %m");
557 m->notify_socket = strappend(e, "/systemd/notify");
559 if (!m->notify_socket)
562 strncpy(sa.un.sun_path, m->notify_socket, sizeof(sa.un.sun_path)-1);
563 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path));
565 log_error("bind(%s) failed: %m", sa.un.sun_path);
569 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
571 log_error("SO_PASSCRED failed: %m");
578 log_debug("Using notification socket %s", m->notify_socket);
581 if (!m->notify_event_source) {
582 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
584 log_error("Failed to allocate notify event source: %s", strerror(-r));
588 /* Process signals a bit earlier than SIGCHLD, so that we can
589 * still identify to which service an exit message belongs */
590 r = sd_event_source_set_priority(m->notify_event_source, -7);
592 log_error("Failed to set priority of notify event source: %s", strerror(-r));
600 static int manager_setup_kdbus(Manager *m) {
602 _cleanup_free_ char *p = NULL;
606 if (m->test_run || m->kdbus_fd >= 0)
609 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
610 if (m->kdbus_fd < 0) {
611 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
615 log_debug("Successfully set up kdbus on %s", p);
617 /* Create the namespace directory here, so that the contents
618 * of that directory is not visible to non-root users. This is
619 * necessary to ensure that users cannot get access to busses
620 * of virtualized users when no UID namespacing is used. */
621 if (m->running_as == SYSTEMD_SYSTEM)
622 mkdir_p_label("/dev/kdbus/domain", 0700);
628 static int manager_connect_bus(Manager *m, bool reexecuting) {
629 bool try_bus_connect;
639 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
641 /* Try to connect to the busses, if possible. */
642 return bus_init(m, try_bus_connect);
645 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
651 while ((u = m->cleanup_queue)) {
652 assert(u->in_cleanup_queue);
662 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
663 GC_OFFSET_UNSURE, /* No clue */
664 GC_OFFSET_GOOD, /* We still need this unit */
665 GC_OFFSET_BAD, /* We don't need this unit anymore */
669 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
676 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
677 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
678 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
681 if (u->in_cleanup_queue)
684 if (unit_check_gc(u))
687 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
691 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
692 unit_gc_sweep(other, gc_marker);
694 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
697 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
704 /* We were unable to find anything out about this entry, so
705 * let's investigate it later */
706 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
707 unit_add_to_gc_queue(u);
711 /* We definitely know that this one is not useful anymore, so
712 * let's mark it for deletion */
713 u->gc_marker = gc_marker + GC_OFFSET_BAD;
714 unit_add_to_cleanup_queue(u);
718 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
721 static unsigned manager_dispatch_gc_queue(Manager *m) {
728 /* log_debug("Running GC..."); */
730 m->gc_marker += _GC_OFFSET_MAX;
731 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
734 gc_marker = m->gc_marker;
736 while ((u = m->gc_queue)) {
737 assert(u->in_gc_queue);
739 unit_gc_sweep(u, gc_marker);
741 LIST_REMOVE(gc_queue, m->gc_queue, u);
742 u->in_gc_queue = false;
746 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
747 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
748 log_debug_unit(u->id, "Collecting %s", u->id);
749 u->gc_marker = gc_marker + GC_OFFSET_BAD;
750 unit_add_to_cleanup_queue(u);
754 m->n_in_gc_queue = 0;
759 static void manager_clear_jobs_and_units(Manager *m) {
764 while ((u = hashmap_first(m->units)))
767 manager_dispatch_cleanup_queue(m);
769 assert(!m->load_queue);
770 assert(!m->run_queue);
771 assert(!m->dbus_unit_queue);
772 assert(!m->dbus_job_queue);
773 assert(!m->cleanup_queue);
774 assert(!m->gc_queue);
776 assert(hashmap_isempty(m->jobs));
777 assert(hashmap_isempty(m->units));
780 m->n_running_jobs = 0;
783 void manager_free(Manager *m) {
789 manager_clear_jobs_and_units(m);
791 for (c = 0; c < _UNIT_TYPE_MAX; c++)
792 if (unit_vtable[c]->shutdown)
793 unit_vtable[c]->shutdown(m);
795 /* If we reexecute ourselves, we keep the root cgroup
797 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
799 manager_undo_generators(m);
803 hashmap_free(m->units);
804 hashmap_free(m->jobs);
805 hashmap_free(m->watch_pids1);
806 hashmap_free(m->watch_pids2);
807 hashmap_free(m->watch_bus);
809 set_free(m->startup_units);
810 set_free(m->failed_units);
812 sd_event_source_unref(m->signal_event_source);
813 sd_event_source_unref(m->notify_event_source);
814 sd_event_source_unref(m->time_change_event_source);
815 sd_event_source_unref(m->jobs_in_progress_event_source);
816 sd_event_source_unref(m->idle_pipe_event_source);
817 sd_event_source_unref(m->run_queue_event_source);
819 safe_close(m->signal_fd);
820 safe_close(m->notify_fd);
821 safe_close(m->time_change_fd);
822 safe_close(m->kdbus_fd);
824 manager_close_idle_pipe(m);
827 sd_event_unref(m->event);
829 free(m->notify_socket);
831 lookup_paths_free(&m->lookup_paths);
832 strv_free(m->environment);
834 hashmap_free(m->cgroup_unit);
835 set_free_free(m->unit_path_cache);
837 free(m->switch_root);
838 free(m->switch_root_init);
840 for (i = 0; i < _RLIMIT_MAX; i++)
843 assert(hashmap_isempty(m->units_requiring_mounts_for));
844 hashmap_free(m->units_requiring_mounts_for);
849 int manager_enumerate(Manager *m) {
855 /* Let's ask every type to load all units from disk/kernel
856 * that it might know */
857 for (c = 0; c < _UNIT_TYPE_MAX; c++)
858 if (unit_vtable[c]->enumerate) {
859 q = unit_vtable[c]->enumerate(m);
864 manager_dispatch_load_queue(m);
868 static int manager_coldplug(Manager *m) {
876 /* Then, let's set up their initial state. */
877 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
884 q = unit_coldplug(u);
892 static void manager_build_unit_path_cache(Manager *m) {
894 _cleanup_free_ DIR *d = NULL;
899 set_free_free(m->unit_path_cache);
901 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
902 if (!m->unit_path_cache) {
903 log_error("Failed to allocate unit path cache.");
907 /* This simply builds a list of files we know exist, so that
908 * we don't always have to go to disk */
910 STRV_FOREACH(i, m->lookup_paths.unit_path) {
916 log_error("Failed to open directory %s: %m", *i);
920 while ((de = readdir(d))) {
923 if (ignore_file(de->d_name))
926 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
932 r = set_consume(m->unit_path_cache, p);
944 log_error("Failed to build unit path cache: %s", strerror(-r));
946 set_free_free(m->unit_path_cache);
947 m->unit_path_cache = NULL;
951 static int manager_distribute_fds(Manager *m, FDSet *fds) {
958 HASHMAP_FOREACH(u, m->units, i) {
960 if (fdset_size(fds) <= 0)
963 if (UNIT_VTABLE(u)->distribute_fds) {
964 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
973 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
978 dual_timestamp_get(&m->generators_start_timestamp);
979 manager_run_generators(m);
980 dual_timestamp_get(&m->generators_finish_timestamp);
982 r = lookup_paths_init(
983 &m->lookup_paths, m->running_as, true,
985 m->generator_unit_path,
986 m->generator_unit_path_early,
987 m->generator_unit_path_late);
991 manager_build_unit_path_cache(m);
993 /* If we will deserialize make sure that during enumeration
994 * this is already known, so we increase the counter here
999 /* First, enumerate what we can from all config files */
1000 dual_timestamp_get(&m->units_load_start_timestamp);
1001 r = manager_enumerate(m);
1002 dual_timestamp_get(&m->units_load_finish_timestamp);
1004 /* Second, deserialize if there is something to deserialize */
1006 r = manager_deserialize(m, serialization, fds);
1008 /* Any fds left? Find some unit which wants them. This is
1009 * useful to allow container managers to pass some file
1010 * descriptors to us pre-initialized. This enables
1011 * socket-based activation of entire containers. */
1012 if (fdset_size(fds) > 0) {
1013 q = manager_distribute_fds(m, fds);
1014 if (q < 0 && r == 0)
1018 /* We might have deserialized the notify fd, but if we didn't
1019 * then let's create the bus now */
1020 q = manager_setup_notify(m);
1021 if (q < 0 && r == 0)
1024 /* We might have deserialized the kdbus control fd, but if we
1025 * didn't, then let's create the bus now. */
1026 manager_setup_kdbus(m);
1027 manager_connect_bus(m, !!serialization);
1028 bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
1030 /* Third, fire things up! */
1031 q = manager_coldplug(m);
1032 if (q < 0 && r == 0)
1035 if (serialization) {
1036 assert(m->n_reloading > 0);
1039 /* Let's wait for the UnitNew/JobNew messages being
1040 * sent, before we notify that the reload is
1042 m->send_reloading_done = true;
1048 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1053 assert(type < _JOB_TYPE_MAX);
1055 assert(mode < _JOB_MODE_MAX);
1057 if (mode == JOB_ISOLATE && type != JOB_START) {
1058 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1062 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1063 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1067 log_debug_unit(unit->id,
1068 "Trying to enqueue job %s/%s/%s", unit->id,
1069 job_type_to_string(type), job_mode_to_string(mode));
1071 job_type_collapse(&type, unit);
1073 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1077 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1078 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1079 mode == JOB_IGNORE_DEPENDENCIES, e);
1083 if (mode == JOB_ISOLATE) {
1084 r = transaction_add_isolate_jobs(tr, m);
1089 r = transaction_activate(tr, m, mode, e);
1093 log_debug_unit(unit->id,
1094 "Enqueued job %s/%s as %u", unit->id,
1095 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1098 *_ret = tr->anchor_job;
1100 transaction_free(tr);
1104 transaction_abort(tr);
1105 transaction_free(tr);
1109 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1114 assert(type < _JOB_TYPE_MAX);
1116 assert(mode < _JOB_MODE_MAX);
1118 r = manager_load_unit(m, name, NULL, NULL, &unit);
1122 return manager_add_job(m, type, unit, mode, override, e, _ret);
1125 Job *manager_get_job(Manager *m, uint32_t id) {
1128 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1131 Unit *manager_get_unit(Manager *m, const char *name) {
1135 return hashmap_get(m->units, name);
1138 unsigned manager_dispatch_load_queue(Manager *m) {
1144 /* Make sure we are not run recursively */
1145 if (m->dispatching_load_queue)
1148 m->dispatching_load_queue = true;
1150 /* Dispatches the load queue. Takes a unit from the queue and
1151 * tries to load its data until the queue is empty */
1153 while ((u = m->load_queue)) {
1154 assert(u->in_load_queue);
1160 m->dispatching_load_queue = false;
1164 int manager_load_unit_prepare(
1176 assert(name || path);
1178 /* This will prepare the unit for loading, but not actually
1179 * load anything from disk. */
1181 if (path && !is_path(path))
1182 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1185 name = basename(path);
1187 t = unit_name_to_type(name);
1189 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1190 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1192 ret = manager_get_unit(m, name);
1198 ret = unit_new(m, unit_vtable[t]->object_size);
1203 ret->fragment_path = strdup(path);
1204 if (!ret->fragment_path) {
1210 r = unit_add_name(ret, name);
1216 unit_add_to_load_queue(ret);
1217 unit_add_to_dbus_queue(ret);
1218 unit_add_to_gc_queue(ret);
1226 int manager_load_unit(
1237 /* This will load the service information files, but not actually
1238 * start any services or anything. */
1240 r = manager_load_unit_prepare(m, name, path, e, _ret);
1244 manager_dispatch_load_queue(m);
1247 *_ret = unit_follow_merge(*_ret);
1252 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1259 HASHMAP_FOREACH(j, s->jobs, i)
1260 job_dump(j, f, prefix);
1263 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1271 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1273 unit_dump(u, f, prefix);
1276 void manager_clear_jobs(Manager *m) {
1281 while ((j = hashmap_first(m->jobs)))
1282 /* No need to recurse. We're cancelling all jobs. */
1283 job_finish_and_invalidate(j, JOB_CANCELED, false);
1286 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1287 Manager *m = userdata;
1293 while ((j = m->run_queue)) {
1294 assert(j->installed);
1295 assert(j->in_run_queue);
1297 job_run_and_invalidate(j);
1300 if (m->n_running_jobs > 0)
1301 manager_watch_jobs_in_progress(m);
1303 if (m->n_on_console > 0)
1304 manager_watch_idle_pipe(m);
1309 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1316 if (m->dispatching_dbus_queue)
1319 m->dispatching_dbus_queue = true;
1321 while ((u = m->dbus_unit_queue)) {
1322 assert(u->in_dbus_queue);
1324 bus_unit_send_change_signal(u);
1328 while ((j = m->dbus_job_queue)) {
1329 assert(j->in_dbus_queue);
1331 bus_job_send_change_signal(j);
1335 m->dispatching_dbus_queue = false;
1337 if (m->send_reloading_done) {
1338 m->send_reloading_done = false;
1340 bus_manager_send_reloading(m, false);
1343 if (m->queued_message)
1344 bus_send_queued_message(m);
1349 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n) {
1350 _cleanup_strv_free_ char **tags = NULL;
1357 tags = strv_split(buf, "\n\r");
1363 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1365 if (UNIT_VTABLE(u)->notify_message)
1366 UNIT_VTABLE(u)->notify_message(u, pid, tags);
1369 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1370 Manager *m = userdata;
1374 assert(m->notify_fd == fd);
1376 if (revents != EPOLLIN) {
1377 log_warning("Got unexpected poll event for notify fd.");
1383 struct iovec iovec = {
1385 .iov_len = sizeof(buf)-1,
1390 struct cmsghdr cmsghdr;
1391 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1394 struct msghdr msghdr = {
1397 .msg_control = &control,
1398 .msg_controllen = sizeof(control),
1400 struct ucred *ucred;
1403 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1408 if (errno == EAGAIN || errno == EINTR)
1414 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1415 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1416 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1417 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1418 log_warning("Received notify message without credentials. Ignoring.");
1422 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1424 assert((size_t) n < sizeof(buf));
1427 /* Notify every unit that might be interested, but try
1428 * to avoid notifying the same one multiple times. */
1429 u1 = manager_get_unit_by_pid(m, ucred->pid);
1431 manager_invoke_notify_message(m, u1, ucred->pid, buf, n);
1435 u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1436 if (u2 && u2 != u1) {
1437 manager_invoke_notify_message(m, u2, ucred->pid, buf, n);
1441 u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1442 if (u3 && u3 != u2 && u3 != u1) {
1443 manager_invoke_notify_message(m, u3, ucred->pid, buf, n);
1448 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1454 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1459 log_debug_unit(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1461 unit_unwatch_pid(u, si->si_pid);
1462 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1465 static int manager_dispatch_sigchld(Manager *m) {
1471 /* First we call waitd() for a PID and do not reap the
1472 * zombie. That way we can still access /proc/$PID for
1473 * it while it is a zombie. */
1474 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1476 if (errno == ECHILD)
1488 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1489 _cleanup_free_ char *name = NULL;
1492 get_process_comm(si.si_pid, &name);
1494 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1495 si.si_pid, strna(name),
1496 sigchld_code_to_string(si.si_code),
1498 strna(si.si_code == CLD_EXITED
1499 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1500 : signal_to_string(si.si_status)));
1502 /* And now figure out the unit this belongs
1503 * to, it might be multiple... */
1504 u1 = manager_get_unit_by_pid(m, si.si_pid);
1506 invoke_sigchld_event(m, u1, &si);
1507 u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1509 invoke_sigchld_event(m, u2, &si);
1510 u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1511 if (u3 && u3 != u2 && u3 != u1)
1512 invoke_sigchld_event(m, u3, &si);
1515 /* And now, we actually reap the zombie. */
1516 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1527 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1528 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1531 log_debug_unit(name, "Activating special unit %s", name);
1533 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1535 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1540 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1541 Manager *m = userdata;
1543 struct signalfd_siginfo sfsi;
1544 bool sigchld = false;
1547 assert(m->signal_fd == fd);
1549 if (revents != EPOLLIN) {
1550 log_warning("Got unexpected events from signal file descriptor.");
1555 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1556 if (n != sizeof(sfsi)) {
1561 if (errno == EINTR || errno == EAGAIN)
1567 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1568 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1569 ? LOG_DEBUG : LOG_INFO,
1572 switch (sfsi.ssi_signo) {
1579 if (m->running_as == SYSTEMD_SYSTEM) {
1580 /* This is for compatibility with the
1581 * original sysvinit */
1582 m->exit_code = MANAGER_REEXECUTE;
1589 if (m->running_as == SYSTEMD_SYSTEM) {
1590 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1594 /* Run the exit target if there is one, if not, just exit. */
1595 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1596 m->exit_code = MANAGER_EXIT;
1603 if (m->running_as == SYSTEMD_SYSTEM)
1604 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1606 /* This is a nop on non-init */
1610 if (m->running_as == SYSTEMD_SYSTEM)
1611 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1613 /* This is a nop on non-init */
1619 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1621 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1622 log_info("Trying to reconnect to bus...");
1626 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1627 log_info("Loading D-Bus service...");
1628 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1635 _cleanup_free_ char *dump = NULL;
1636 _cleanup_fclose_ FILE *f = NULL;
1639 f = open_memstream(&dump, &size);
1641 log_warning("Failed to allocate memory stream.");
1645 manager_dump_units(m, f, "\t");
1646 manager_dump_jobs(m, f, "\t");
1649 log_warning("Failed to write status stream");
1654 log_warning("Failed to flush status stream");
1658 log_dump(LOG_INFO, dump);
1663 m->exit_code = MANAGER_RELOAD;
1668 /* Starting SIGRTMIN+0 */
1669 static const char * const target_table[] = {
1670 [0] = SPECIAL_DEFAULT_TARGET,
1671 [1] = SPECIAL_RESCUE_TARGET,
1672 [2] = SPECIAL_EMERGENCY_TARGET,
1673 [3] = SPECIAL_HALT_TARGET,
1674 [4] = SPECIAL_POWEROFF_TARGET,
1675 [5] = SPECIAL_REBOOT_TARGET,
1676 [6] = SPECIAL_KEXEC_TARGET
1679 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1680 static const ManagerExitCode code_table[] = {
1682 [1] = MANAGER_POWEROFF,
1683 [2] = MANAGER_REBOOT,
1687 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1688 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1689 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1690 manager_start_target(m, target_table[idx],
1691 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1695 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1696 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1697 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1701 switch (sfsi.ssi_signo - SIGRTMIN) {
1704 log_debug("Enabling showing of status.");
1705 manager_set_show_status(m, SHOW_STATUS_YES);
1709 log_debug("Disabling showing of status.");
1710 manager_set_show_status(m, SHOW_STATUS_NO);
1714 log_set_max_level(LOG_DEBUG);
1715 log_notice("Setting log level to debug.");
1719 log_set_max_level(LOG_INFO);
1720 log_notice("Setting log level to info.");
1724 if (m->running_as == SYSTEMD_USER) {
1725 m->exit_code = MANAGER_EXIT;
1729 /* This is a nop on init */
1733 case 29: /* compatibility: used to be mapped to LOG_TARGET_SYSLOG_OR_KMSG */
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_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1756 manager_dispatch_sigchld(m);
1761 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1762 Manager *m = userdata;
1767 assert(m->time_change_fd == fd);
1769 log_struct(LOG_INFO,
1770 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1771 "MESSAGE=Time has been changed",
1774 /* Restart the watch */
1775 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1776 m->time_change_fd = safe_close(m->time_change_fd);
1778 manager_setup_time_change(m);
1780 HASHMAP_FOREACH(u, m->units, i)
1781 if (UNIT_VTABLE(u)->time_change)
1782 UNIT_VTABLE(u)->time_change(u);
1787 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1788 Manager *m = userdata;
1791 assert(m->idle_pipe[2] == fd);
1793 m->no_console_output = m->n_on_console > 0;
1795 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1796 manager_close_idle_pipe(m);
1801 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1802 Manager *m = userdata;
1809 manager_print_jobs_in_progress(m);
1811 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1812 r = sd_event_source_set_time(source, next);
1816 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1819 int manager_loop(Manager *m) {
1822 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1825 m->exit_code = MANAGER_OK;
1827 /* Release the path cache */
1828 set_free_free(m->unit_path_cache);
1829 m->unit_path_cache = NULL;
1831 manager_check_finished(m);
1833 /* There might still be some zombies hanging around from
1834 * before we were exec()'ed. Let's reap them. */
1835 r = manager_dispatch_sigchld(m);
1839 while (m->exit_code == MANAGER_OK) {
1842 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1845 if (!ratelimit_test(&rl)) {
1846 /* Yay, something is going seriously wrong, pause a little */
1847 log_warning("Looping too fast. Throttling execution a little.");
1852 if (manager_dispatch_load_queue(m) > 0)
1855 if (manager_dispatch_gc_queue(m) > 0)
1858 if (manager_dispatch_cleanup_queue(m) > 0)
1861 if (manager_dispatch_cgroup_queue(m) > 0)
1864 if (manager_dispatch_dbus_queue(m) > 0)
1867 /* Sleep for half the watchdog time */
1868 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1869 wait_usec = m->runtime_watchdog / 2;
1873 wait_usec = USEC_INFINITY;
1875 r = sd_event_run(m->event, wait_usec);
1877 log_error("Failed to run event loop: %s", strerror(-r));
1882 return m->exit_code;
1885 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1886 _cleanup_free_ char *n = NULL;
1894 r = unit_name_from_dbus_path(s, &n);
1898 r = manager_load_unit(m, n, NULL, e, &u);
1907 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1917 p = startswith(s, "/org/freedesktop/systemd1/job/");
1921 r = safe_atou(p, &id);
1925 j = manager_get_job(m, id);
1934 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1937 _cleanup_free_ char *p = NULL;
1940 audit_fd = get_audit_fd();
1944 /* Don't generate audit events if the service was already
1945 * started and we're just deserializing */
1946 if (m->n_reloading > 0)
1949 if (m->running_as != SYSTEMD_SYSTEM)
1952 if (u->type != UNIT_SERVICE)
1955 p = unit_name_to_prefix_and_instance(u->id);
1957 log_error_unit(u->id,
1958 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1962 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1963 if (errno == EPERM) {
1964 /* We aren't allowed to send audit messages?
1965 * Then let's not retry again. */
1968 log_warning("Failed to send audit message: %m");
1974 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1975 union sockaddr_union sa = PLYMOUTH_SOCKET;
1978 _cleanup_free_ char *message = NULL;
1979 _cleanup_close_ int fd = -1;
1981 /* Don't generate plymouth events if the service was already
1982 * started and we're just deserializing */
1983 if (m->n_reloading > 0)
1986 if (m->running_as != SYSTEMD_SYSTEM)
1989 if (detect_container(NULL) > 0)
1992 if (u->type != UNIT_SERVICE &&
1993 u->type != UNIT_MOUNT &&
1994 u->type != UNIT_SWAP)
1997 /* We set SOCK_NONBLOCK here so that we rather drop the
1998 * message then wait for plymouth */
1999 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2001 log_error("socket() failed: %m");
2005 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2007 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2008 log_error("connect() failed: %m");
2012 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2018 if (write(fd, message, n + 1) != n + 1)
2019 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2020 log_error("Failed to write Plymouth message: %m");
2023 void manager_dispatch_bus_name_owner_changed(
2026 const char* old_owner,
2027 const char *new_owner) {
2034 u = hashmap_get(m->watch_bus, name);
2038 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2041 int manager_open_serialization(Manager *m, FILE **_f) {
2048 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2049 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2053 log_debug("Serializing state to %s", path);
2055 f = fdopen(fd, "w+");
2066 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2079 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2080 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2081 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2082 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2084 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2085 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2086 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2087 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2090 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2091 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2092 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2093 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2094 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2095 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2096 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2097 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2100 if (!switching_root) {
2101 STRV_FOREACH(e, m->environment) {
2102 _cleanup_free_ char *ce;
2108 fprintf(f, "env=%s\n", *e);
2112 if (m->notify_fd >= 0) {
2115 copy = fdset_put_dup(fds, m->notify_fd);
2119 fprintf(f, "notify-fd=%i\n", copy);
2120 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2123 if (m->kdbus_fd >= 0) {
2126 copy = fdset_put_dup(fds, m->kdbus_fd);
2130 fprintf(f, "kdbus-fd=%i\n", copy);
2133 bus_track_serialize(m->subscribed, f);
2137 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2145 r = unit_serialize(u, f, fds, !switching_root);
2152 assert(m->n_reloading > 0);
2158 r = bus_fdset_add_all(m, fds);
2165 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2171 log_debug("Deserializing state...");
2176 char line[LINE_MAX], *l;
2178 if (!fgets(line, sizeof(line), f)) {
2193 if (startswith(l, "current-job-id=")) {
2196 if (safe_atou32(l+15, &id) < 0)
2197 log_debug("Failed to parse current job id value %s", l+15);
2199 m->current_job_id = MAX(m->current_job_id, id);
2201 } else if (startswith(l, "n-installed-jobs=")) {
2204 if (safe_atou32(l+17, &n) < 0)
2205 log_debug("Failed to parse installed jobs counter %s", l+17);
2207 m->n_installed_jobs += n;
2209 } else if (startswith(l, "n-failed-jobs=")) {
2212 if (safe_atou32(l+14, &n) < 0)
2213 log_debug("Failed to parse failed jobs counter %s", l+14);
2215 m->n_failed_jobs += n;
2217 } else if (startswith(l, "taint-usr=")) {
2220 b = parse_boolean(l+10);
2222 log_debug("Failed to parse taint /usr flag %s", l+10);
2224 m->taint_usr = m->taint_usr || b;
2226 } else if (startswith(l, "firmware-timestamp="))
2227 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2228 else if (startswith(l, "loader-timestamp="))
2229 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2230 else if (startswith(l, "kernel-timestamp="))
2231 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2232 else if (startswith(l, "initrd-timestamp="))
2233 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2234 else if (startswith(l, "userspace-timestamp="))
2235 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2236 else if (startswith(l, "finish-timestamp="))
2237 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2238 else if (startswith(l, "security-start-timestamp="))
2239 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2240 else if (startswith(l, "security-finish-timestamp="))
2241 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2242 else if (startswith(l, "generators-start-timestamp="))
2243 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2244 else if (startswith(l, "generators-finish-timestamp="))
2245 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2246 else if (startswith(l, "units-load-start-timestamp="))
2247 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2248 else if (startswith(l, "units-load-finish-timestamp="))
2249 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2250 else if (startswith(l, "env=")) {
2251 _cleanup_free_ char *uce = NULL;
2254 uce = cunescape(l+4);
2260 e = strv_env_set(m->environment, uce);
2266 strv_free(m->environment);
2269 } else if (startswith(l, "notify-fd=")) {
2272 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2273 log_debug("Failed to parse notify fd: %s", l + 10);
2275 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2276 safe_close(m->notify_fd);
2277 m->notify_fd = fdset_remove(fds, fd);
2280 } else if (startswith(l, "notify-socket=")) {
2289 free(m->notify_socket);
2290 m->notify_socket = n;
2292 } else if (startswith(l, "kdbus-fd=")) {
2295 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2296 log_debug("Failed to parse kdbus fd: %s", l + 9);
2298 safe_close(m->kdbus_fd);
2299 m->kdbus_fd = fdset_remove(fds, fd);
2302 } else if (bus_track_deserialize_item(&m->deserialized_subscribed, l) == 0)
2303 log_debug("Unknown serialization item '%s'", l);
2308 char name[UNIT_NAME_MAX+2];
2311 if (!fgets(name, sizeof(name), f)) {
2322 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2326 r = unit_deserialize(u, f, fds);
2335 assert(m->n_reloading > 0);
2341 int manager_reload(Manager *m) {
2343 _cleanup_fclose_ FILE *f = NULL;
2344 _cleanup_fdset_free_ FDSet *fds = NULL;
2348 r = manager_open_serialization(m, &f);
2353 bus_manager_send_reloading(m, true);
2361 r = manager_serialize(m, f, fds, false);
2367 if (fseeko(f, 0, SEEK_SET) < 0) {
2372 /* From here on there is no way back. */
2373 manager_clear_jobs_and_units(m);
2374 manager_undo_generators(m);
2375 lookup_paths_free(&m->lookup_paths);
2377 /* Find new unit paths */
2378 manager_run_generators(m);
2380 q = lookup_paths_init(
2381 &m->lookup_paths, m->running_as, true,
2383 m->generator_unit_path,
2384 m->generator_unit_path_early,
2385 m->generator_unit_path_late);
2389 manager_build_unit_path_cache(m);
2391 /* First, enumerate what we can from all config files */
2392 q = manager_enumerate(m);
2396 /* Second, deserialize our stored data */
2397 q = manager_deserialize(m, f, fds);
2404 /* Re-register notify_fd as event source */
2405 q = manager_setup_notify(m);
2409 /* Third, fire things up! */
2410 q = manager_coldplug(m);
2414 assert(m->n_reloading > 0);
2417 m->send_reloading_done = true;
2422 bool manager_is_reloading_or_reexecuting(Manager *m) {
2425 return m->n_reloading != 0;
2428 void manager_reset_failed(Manager *m) {
2434 HASHMAP_FOREACH(u, m->units, i)
2435 unit_reset_failed(u);
2438 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2444 /* Returns true if the unit is inactive or going down */
2445 u = manager_get_unit(m, name);
2449 return unit_inactive_or_pending(u);
2452 void manager_check_finished(Manager *m) {
2453 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2454 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2460 if (m->n_running_jobs == 0)
2461 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2463 if (hashmap_size(m->jobs) > 0) {
2465 if (m->jobs_in_progress_event_source) {
2466 sd_event_source_set_time(m->jobs_in_progress_event_source,
2467 now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2473 manager_flip_auto_status(m, false);
2475 /* Notify Type=idle units that we are done now */
2476 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2477 manager_close_idle_pipe(m);
2479 /* Turn off confirm spawn now */
2480 m->confirm_spawn = false;
2482 /* This is no longer the first boot */
2483 manager_set_first_boot(m, false);
2485 if (dual_timestamp_is_set(&m->finish_timestamp))
2488 dual_timestamp_get(&m->finish_timestamp);
2490 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2492 /* Note that m->kernel_usec.monotonic is always at 0,
2493 * and m->firmware_usec.monotonic and
2494 * m->loader_usec.monotonic should be considered
2495 * negative values. */
2497 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2498 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2499 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2500 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2502 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2504 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2505 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2507 if (!log_on_console())
2508 log_struct(LOG_INFO,
2509 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2510 "KERNEL_USEC="USEC_FMT, kernel_usec,
2511 "INITRD_USEC="USEC_FMT, initrd_usec,
2512 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2513 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2514 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2515 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2516 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2517 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2520 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2523 if (!log_on_console())
2524 log_struct(LOG_INFO,
2525 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2526 "KERNEL_USEC="USEC_FMT, kernel_usec,
2527 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2528 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2529 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2530 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2531 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2535 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2536 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2538 if (!log_on_console())
2539 log_struct(LOG_INFO,
2540 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2541 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2542 "MESSAGE=Startup finished in %s.",
2543 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2547 SET_FOREACH(u, m->startup_units, i)
2549 cgroup_context_apply(unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path, manager_state(m));
2551 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2555 "STATUS=Startup finished in %s.",
2556 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2559 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2570 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2571 /* systemd --system, not running --test */
2573 p = strappend("/run/systemd/", name);
2577 r = mkdir_p_label(p, 0755);
2579 log_error("Failed to create generator directory %s: %s",
2584 } else if (m->running_as == SYSTEMD_USER) {
2585 const char *s = NULL;
2587 s = getenv("XDG_RUNTIME_DIR");
2590 p = strjoin(s, "/systemd/", name, NULL);
2594 r = mkdir_p_label(p, 0755);
2596 log_error("Failed to create generator directory %s: %s",
2602 /* systemd --system --test */
2604 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2609 log_error("Failed to create generator directory %s: %m",
2620 static void trim_generator_dir(Manager *m, char **generator) {
2627 if (rmdir(*generator) >= 0) {
2635 void manager_run_generators(Manager *m) {
2636 _cleanup_closedir_ DIR *d = NULL;
2637 const char *generator_path;
2638 const char *argv[5];
2646 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2647 d = opendir(generator_path);
2649 if (errno == ENOENT)
2652 log_error("Failed to enumerate generator directory %s: %m",
2657 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2661 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2665 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2669 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2670 argv[1] = m->generator_unit_path;
2671 argv[2] = m->generator_unit_path_early;
2672 argv[3] = m->generator_unit_path_late;
2675 RUN_WITH_UMASK(0022)
2676 execute_directory(generator_path, d, DEFAULT_TIMEOUT_USEC, (char**) argv);
2679 trim_generator_dir(m, &m->generator_unit_path);
2680 trim_generator_dir(m, &m->generator_unit_path_early);
2681 trim_generator_dir(m, &m->generator_unit_path_late);
2684 static void remove_generator_dir(Manager *m, char **generator) {
2691 strv_remove(m->lookup_paths.unit_path, *generator);
2692 rm_rf(*generator, false, true, false);
2698 void manager_undo_generators(Manager *m) {
2701 remove_generator_dir(m, &m->generator_unit_path);
2702 remove_generator_dir(m, &m->generator_unit_path_early);
2703 remove_generator_dir(m, &m->generator_unit_path_late);
2706 int manager_environment_add(Manager *m, char **minus, char **plus) {
2707 char **a = NULL, **b = NULL, **l;
2712 if (!strv_isempty(minus)) {
2713 a = strv_env_delete(l, 1, minus);
2720 if (!strv_isempty(plus)) {
2721 b = strv_env_merge(2, l, plus);
2728 if (m->environment != l)
2729 strv_free(m->environment);
2736 manager_clean_environment(m);
2737 strv_sort(m->environment);
2742 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2747 for (i = 0; i < _RLIMIT_MAX; i++) {
2748 if (!default_rlimit[i])
2751 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2759 void manager_recheck_journal(Manager *m) {
2764 if (m->running_as != SYSTEMD_SYSTEM)
2767 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2768 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2769 log_close_journal();
2773 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2774 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2775 log_close_journal();
2779 /* Hmm, OK, so the socket is fully up and the service is up
2780 * too, then let's make use of the thing. */
2784 void manager_set_show_status(Manager *m, ShowStatus mode) {
2786 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2788 if (m->running_as != SYSTEMD_SYSTEM)
2791 m->show_status = mode;
2794 touch("/run/systemd/show-status");
2796 unlink("/run/systemd/show-status");
2799 static bool manager_get_show_status(Manager *m) {
2802 if (m->running_as != SYSTEMD_SYSTEM)
2805 if (m->no_console_output)
2808 if (!IN_SET(manager_state(m), MANAGER_STARTING, MANAGER_STOPPING))
2811 if (m->show_status > 0)
2814 /* If Plymouth is running make sure we show the status, so
2815 * that there's something nice to see when people press Esc */
2817 return plymouth_running();
2820 void manager_set_first_boot(Manager *m, bool b) {
2823 if (m->running_as != SYSTEMD_SYSTEM)
2829 touch("/run/systemd/first-boot");
2831 unlink("/run/systemd/first-boot");
2834 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2837 if (!manager_get_show_status(m))
2840 /* XXX We should totally drop the check for ephemeral here
2841 * and thus effectively make 'Type=idle' pointless. */
2842 if (ephemeral && m->n_on_console > 0)
2845 va_start(ap, format);
2846 status_vprintf(status, true, ephemeral, format, ap);
2850 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2851 _cleanup_free_ char *p = NULL;
2859 p = unit_name_from_path(path, suffix);
2863 found = manager_get_unit(m, p);
2873 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2874 char p[strlen(path)+1];
2880 path_kill_slashes(p);
2882 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
2885 const char *manager_get_runtime_prefix(Manager *m) {
2888 return m->running_as == SYSTEMD_SYSTEM ?
2890 getenv("XDG_RUNTIME_DIR");
2893 ManagerState manager_state(Manager *m) {
2898 /* Did we ever finish booting? If not then we are still starting up */
2899 if (!dual_timestamp_is_set(&m->finish_timestamp))
2900 return MANAGER_STARTING;
2902 /* Is the special shutdown target queued? If so, we are in shutdown state */
2903 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2904 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
2905 return MANAGER_STOPPING;
2907 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
2908 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
2909 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2910 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2911 return MANAGER_MAINTENANCE;
2913 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
2914 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2915 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2916 return MANAGER_MAINTENANCE;
2918 /* Are there any failed units? If so, we are in degraded mode */
2919 if (set_size(m->failed_units) > 0)
2920 return MANAGER_DEGRADED;
2922 return MANAGER_RUNNING;
2925 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
2926 [MANAGER_STARTING] = "starting",
2927 [MANAGER_RUNNING] = "running",
2928 [MANAGER_DEGRADED] = "degraded",
2929 [MANAGER_MAINTENANCE] = "maintenance",
2930 [MANAGER_STOPPING] = "stopping",
2933 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);