1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
29 #include <sys/reboot.h>
30 #include <sys/ioctl.h>
34 #include <sys/types.h>
37 #include <sys/timerfd.h>
43 #include "sd-daemon.h"
45 #include "sd-messages.h"
48 #include "transaction.h"
55 #include "ratelimit.h"
56 #include "locale-setup.h"
57 #include "mount-setup.h"
58 #include "unit-name.h"
60 #include "path-lookup.h"
62 #include "exit-status.h"
65 #include "cgroup-util.h"
66 #include "path-util.h"
68 #include "boot-timestamps.h"
70 #include "bus-errors.h"
71 #include "bus-error.h"
74 #include "dbus-unit.h"
76 #include "dbus-manager.h"
77 #include "bus-kernel.h"
79 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
80 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
82 /* Initial delay and the interval for printing status messages about running jobs */
83 #define JOBS_IN_PROGRESS_WAIT_USEC (5*USEC_PER_SEC)
84 #define JOBS_IN_PROGRESS_PERIOD_USEC (USEC_PER_SEC / 3)
85 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
87 /* Where clients shall send notification messages to */
88 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
90 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
92 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
93 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
94 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
95 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
96 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
97 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
99 static int manager_watch_jobs_in_progress(Manager *m) {
104 if (m->jobs_in_progress_event_source)
107 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
108 return sd_event_add_monotonic(m->event, &m->jobs_in_progress_event_source, next, 0, manager_dispatch_jobs_in_progress, m);
111 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
113 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
116 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
117 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
121 p = mempset(p, ' ', pos-2);
122 p = stpcpy(p, ANSI_RED_ON);
126 if (pos > 0 && pos <= width) {
127 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
131 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
134 p = stpcpy(p, ANSI_RED_ON);
137 p = mempset(p, ' ', width-1-pos);
138 strcpy(p, ANSI_HIGHLIGHT_OFF);
142 void manager_flip_auto_status(Manager *m, bool enable) {
144 if (m->show_status == SHOW_STATUS_AUTO)
145 manager_set_show_status(m, SHOW_STATUS_TEMPORARY);
147 if (m->show_status == SHOW_STATUS_TEMPORARY)
148 manager_set_show_status(m, SHOW_STATUS_AUTO);
152 static void manager_print_jobs_in_progress(Manager *m) {
153 _cleanup_free_ char *job_of_n = NULL;
156 unsigned counter = 0, print_nr;
157 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
159 char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
164 manager_flip_auto_status(m, true);
166 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
168 HASHMAP_FOREACH(j, m->jobs, i)
169 if (j->state == JOB_RUNNING && counter++ == print_nr)
172 /* m->n_running_jobs must be consistent with the contents of m->jobs,
173 * so the above loop must have succeeded in finding j. */
174 assert(counter == print_nr + 1);
177 cylon_pos = m->jobs_in_progress_iteration % 14;
179 cylon_pos = 14 - cylon_pos;
180 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
182 m->jobs_in_progress_iteration++;
184 if (m->n_running_jobs > 1)
185 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
188 format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
189 if (job_get_timeout(j, &x) > 0)
190 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
192 manager_status_printf(m, true, cylon,
193 "%sA %s job is running for %s (%s / %s)",
195 job_type_to_string(j->type),
196 unit_description(j->unit),
201 static int manager_watch_idle_pipe(Manager *m) {
206 if (m->idle_pipe_event_source)
209 if (m->idle_pipe[2] < 0)
212 r = sd_event_add_io(m->event, &m->idle_pipe_event_source, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m);
214 log_error("Failed to watch idle pipe: %s", strerror(-r));
221 static void manager_close_idle_pipe(Manager *m) {
224 close_pipe(m->idle_pipe);
225 close_pipe(m->idle_pipe + 2);
228 static int manager_setup_time_change(Manager *m) {
231 /* We only care for the cancellation event, hence we set the
232 * timeout to the latest possible value. */
233 struct itimerspec its = {
234 .it_value.tv_sec = TIME_T_MAX,
238 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
240 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
241 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
243 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
244 if (m->time_change_fd < 0) {
245 log_error("Failed to create timerfd: %m");
249 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
250 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
251 close_nointr_nofail(m->time_change_fd);
252 m->time_change_fd = -1;
256 r = sd_event_add_io(m->event, &m->time_change_event_source, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m);
258 log_error("Failed to create time change event source: %s", strerror(-r));
262 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
267 static int enable_special_signals(Manager *m) {
268 _cleanup_close_ int fd = -1;
272 /* Enable that we get SIGINT on control-alt-del. In containers
273 * this will fail with EPERM (older) or EINVAL (newer), so
275 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
276 log_warning("Failed to enable ctrl-alt-del handling: %m");
278 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
280 /* Support systems without virtual console */
282 log_warning("Failed to open /dev/tty0: %m");
284 /* Enable that we get SIGWINCH on kbrequest */
285 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
286 log_warning("Failed to enable kbrequest handling: %m");
292 static int manager_setup_signals(Manager *m) {
293 struct sigaction sa = {
294 .sa_handler = SIG_DFL,
295 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
302 /* We are not interested in SIGSTOP and friends. */
303 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
305 assert_se(sigemptyset(&mask) == 0);
307 sigset_add_many(&mask,
308 SIGCHLD, /* Child died */
309 SIGTERM, /* Reexecute daemon */
310 SIGHUP, /* Reload configuration */
311 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
312 SIGUSR2, /* systemd: dump status */
313 SIGINT, /* Kernel sends us this on control-alt-del */
314 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
315 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
316 SIGRTMIN+0, /* systemd: start default.target */
317 SIGRTMIN+1, /* systemd: isolate rescue.target */
318 SIGRTMIN+2, /* systemd: isolate emergency.target */
319 SIGRTMIN+3, /* systemd: start halt.target */
320 SIGRTMIN+4, /* systemd: start poweroff.target */
321 SIGRTMIN+5, /* systemd: start reboot.target */
322 SIGRTMIN+6, /* systemd: start kexec.target */
323 SIGRTMIN+13, /* systemd: Immediate halt */
324 SIGRTMIN+14, /* systemd: Immediate poweroff */
325 SIGRTMIN+15, /* systemd: Immediate reboot */
326 SIGRTMIN+16, /* systemd: Immediate kexec */
327 SIGRTMIN+20, /* systemd: enable status messages */
328 SIGRTMIN+21, /* systemd: disable status messages */
329 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
330 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
331 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
332 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
333 SIGRTMIN+27, /* systemd: set log target to console */
334 SIGRTMIN+28, /* systemd: set log target to kmsg */
335 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
337 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
339 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
340 if (m->signal_fd < 0)
343 r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);
347 /* Process signals a bit earlier than the rest of things, but
348 * later that notify_fd processing, so that the notify
349 * processing can still figure out to which process/service a
350 * message belongs, before we reap the process. */
351 r = sd_event_source_set_priority(m->signal_event_source, -5);
355 if (m->running_as == SYSTEMD_SYSTEM)
356 return enable_special_signals(m);
361 static void manager_clean_environment(Manager *m) {
364 /* Let's remove some environment variables that we
365 * need ourselves to communicate with our clients */
378 static int manager_default_environment(Manager *m) {
381 if (m->running_as == SYSTEMD_SYSTEM) {
382 /* The system manager always starts with a clean
383 * environment for its children. It does not import
384 * the kernel or the parents exported variables.
386 * The initial passed environ is untouched to keep
387 * /proc/self/environ valid; it is used for tagging
388 * the init process inside containers. */
389 m->environment = strv_new("PATH=" DEFAULT_PATH,
392 /* Import locale variables LC_*= from configuration */
393 locale_setup(&m->environment);
395 /* The user manager passes its own environment
396 * along to its children. */
397 m->environment = strv_copy(environ);
403 manager_clean_environment(m);
404 strv_sort(m->environment);
409 int manager_new(SystemdRunningAs running_as, Manager **_m) {
414 assert(running_as >= 0);
415 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
417 m = new0(Manager, 1);
422 if (detect_container(NULL) <= 0)
423 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
426 m->running_as = running_as;
427 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
429 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
431 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;
432 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
434 r = manager_default_environment(m);
438 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
442 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
446 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
450 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
454 r = sd_event_default(&m->event);
458 r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
462 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
466 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
470 r = manager_setup_signals(m);
474 r = manager_setup_cgroup(m);
478 r = manager_setup_time_change(m);
482 m->udev = udev_new();
488 /* Note that we set up neither kdbus, nor the notify fd
489 * here. We do that after deserialization, since they might
490 * have gotten serialized across the reexec. */
492 m->taint_usr = dir_is_empty("/usr") > 0;
502 static int manager_setup_notify(Manager *m) {
505 struct sockaddr_un un;
507 .sa.sa_family = AF_UNIX,
511 if (m->notify_fd < 0) {
512 _cleanup_close_ int fd = -1;
514 /* First free all secondary fields */
515 free(m->notify_socket);
516 m->notify_socket = NULL;
517 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
519 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
521 log_error("Failed to allocate notification socket: %m");
525 if (getpid() != 1 || detect_container(NULL) > 0)
526 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%" PRIx64, random_u64());
528 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
529 sa.un.sun_path[0] = 0;
531 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
533 log_error("bind() failed: %m");
537 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
539 log_error("SO_PASSCRED failed: %m");
543 sa.un.sun_path[0] = '@';
544 m->notify_socket = strdup(sa.un.sun_path);
545 if (!m->notify_socket)
551 log_debug("Using notification socket %s", m->notify_socket);
554 if (!m->notify_event_source) {
555 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
557 log_error("Failed to allocate notify event source: %s", strerror(-r));
561 /* Process signals a bit earlier than SIGCHLD, so that we can
562 * still identify to which service an exit message belongs */
563 r = sd_event_source_set_priority(m->notify_event_source, -7);
565 log_error("Failed to set priority of notify event source: %s", strerror(-r));
573 static int manager_setup_kdbus(Manager *m) {
575 _cleanup_free_ char *p = NULL;
581 if (m->kdbus_fd >= 0)
584 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
585 if (m->kdbus_fd < 0) {
586 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
590 log_debug("Successfully set up kdbus on %s", p);
592 /* Create the namespace directory here, so that the contents
593 * of that directory is not visible to non-root users. This is
594 * necessary to ensure that users cannot get access to busses
595 * of virtualized users when no UID namespacing is used. */
596 if (m->running_as == SYSTEMD_SYSTEM)
597 mkdir_p_label("/dev/kdbus/domain", 0700);
603 static int manager_connect_bus(Manager *m, bool reexecuting) {
604 bool try_bus_connect;
611 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
613 /* Try to connect to the busses, if possible. */
614 return bus_init(m, try_bus_connect);
617 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
623 while ((u = m->cleanup_queue)) {
624 assert(u->in_cleanup_queue);
634 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
635 GC_OFFSET_UNSURE, /* No clue */
636 GC_OFFSET_GOOD, /* We still need this unit */
637 GC_OFFSET_BAD, /* We don't need this unit anymore */
641 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
648 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
649 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
650 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
653 if (u->in_cleanup_queue)
656 if (unit_check_gc(u))
659 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
663 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
664 unit_gc_sweep(other, gc_marker);
666 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
669 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
676 /* We were unable to find anything out about this entry, so
677 * let's investigate it later */
678 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
679 unit_add_to_gc_queue(u);
683 /* We definitely know that this one is not useful anymore, so
684 * let's mark it for deletion */
685 u->gc_marker = gc_marker + GC_OFFSET_BAD;
686 unit_add_to_cleanup_queue(u);
690 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
693 static unsigned manager_dispatch_gc_queue(Manager *m) {
700 /* log_debug("Running GC..."); */
702 m->gc_marker += _GC_OFFSET_MAX;
703 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
706 gc_marker = m->gc_marker;
708 while ((u = m->gc_queue)) {
709 assert(u->in_gc_queue);
711 unit_gc_sweep(u, gc_marker);
713 LIST_REMOVE(gc_queue, m->gc_queue, u);
714 u->in_gc_queue = false;
718 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
719 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
720 log_debug_unit(u->id, "Collecting %s", u->id);
721 u->gc_marker = gc_marker + GC_OFFSET_BAD;
722 unit_add_to_cleanup_queue(u);
726 m->n_in_gc_queue = 0;
731 static void manager_clear_jobs_and_units(Manager *m) {
736 while ((u = hashmap_first(m->units)))
739 manager_dispatch_cleanup_queue(m);
741 assert(!m->load_queue);
742 assert(!m->run_queue);
743 assert(!m->dbus_unit_queue);
744 assert(!m->dbus_job_queue);
745 assert(!m->cleanup_queue);
746 assert(!m->gc_queue);
748 assert(hashmap_isempty(m->jobs));
749 assert(hashmap_isempty(m->units));
752 m->n_running_jobs = 0;
755 void manager_free(Manager *m) {
761 manager_clear_jobs_and_units(m);
763 for (c = 0; c < _UNIT_TYPE_MAX; c++)
764 if (unit_vtable[c]->shutdown)
765 unit_vtable[c]->shutdown(m);
767 /* If we reexecute ourselves, we keep the root cgroup
769 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
771 manager_undo_generators(m);
775 hashmap_free(m->units);
776 hashmap_free(m->jobs);
777 hashmap_free(m->watch_pids1);
778 hashmap_free(m->watch_pids2);
779 hashmap_free(m->watch_bus);
781 sd_event_source_unref(m->signal_event_source);
782 sd_event_source_unref(m->notify_event_source);
783 sd_event_source_unref(m->time_change_event_source);
784 sd_event_source_unref(m->jobs_in_progress_event_source);
785 sd_event_source_unref(m->idle_pipe_event_source);
786 sd_event_source_unref(m->run_queue_event_source);
788 if (m->signal_fd >= 0)
789 close_nointr_nofail(m->signal_fd);
790 if (m->notify_fd >= 0)
791 close_nointr_nofail(m->notify_fd);
792 if (m->time_change_fd >= 0)
793 close_nointr_nofail(m->time_change_fd);
794 if (m->kdbus_fd >= 0)
795 close_nointr_nofail(m->kdbus_fd);
797 manager_close_idle_pipe(m);
800 sd_event_unref(m->event);
802 free(m->notify_socket);
804 lookup_paths_free(&m->lookup_paths);
805 strv_free(m->environment);
807 hashmap_free(m->cgroup_unit);
808 set_free_free(m->unit_path_cache);
810 free(m->switch_root);
811 free(m->switch_root_init);
813 for (i = 0; i < _RLIMIT_MAX; i++)
816 assert(hashmap_isempty(m->units_requiring_mounts_for));
817 hashmap_free(m->units_requiring_mounts_for);
822 int manager_enumerate(Manager *m) {
828 /* Let's ask every type to load all units from disk/kernel
829 * that it might know */
830 for (c = 0; c < _UNIT_TYPE_MAX; c++)
831 if (unit_vtable[c]->enumerate) {
832 q = unit_vtable[c]->enumerate(m);
837 manager_dispatch_load_queue(m);
841 static int manager_coldplug(Manager *m) {
849 /* Then, let's set up their initial state. */
850 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
857 q = unit_coldplug(u);
865 static void manager_build_unit_path_cache(Manager *m) {
867 _cleanup_free_ DIR *d = NULL;
872 set_free_free(m->unit_path_cache);
874 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
875 if (!m->unit_path_cache) {
876 log_error("Failed to allocate unit path cache.");
880 /* This simply builds a list of files we know exist, so that
881 * we don't always have to go to disk */
883 STRV_FOREACH(i, m->lookup_paths.unit_path) {
889 log_error("Failed to open directory %s: %m", *i);
893 while ((de = readdir(d))) {
896 if (ignore_file(de->d_name))
899 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
905 r = set_consume(m->unit_path_cache, p);
917 log_error("Failed to build unit path cache: %s", strerror(-r));
919 set_free_free(m->unit_path_cache);
920 m->unit_path_cache = NULL;
924 static int manager_distribute_fds(Manager *m, FDSet *fds) {
931 HASHMAP_FOREACH(u, m->units, i) {
933 if (fdset_size(fds) <= 0)
936 if (UNIT_VTABLE(u)->distribute_fds) {
937 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
946 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
951 dual_timestamp_get(&m->generators_start_timestamp);
952 manager_run_generators(m);
953 dual_timestamp_get(&m->generators_finish_timestamp);
955 r = lookup_paths_init(
956 &m->lookup_paths, m->running_as, true,
957 m->generator_unit_path,
958 m->generator_unit_path_early,
959 m->generator_unit_path_late);
963 manager_build_unit_path_cache(m);
965 /* If we will deserialize make sure that during enumeration
966 * this is already known, so we increase the counter here
971 /* First, enumerate what we can from all config files */
972 dual_timestamp_get(&m->units_load_start_timestamp);
973 r = manager_enumerate(m);
974 dual_timestamp_get(&m->units_load_finish_timestamp);
976 /* Second, deserialize if there is something to deserialize */
978 q = manager_deserialize(m, serialization, fds);
983 /* Any fds left? Find some unit which wants them. This is
984 * useful to allow container managers to pass some file
985 * descriptors to us pre-initialized. This enables
986 * socket-based activation of entire containers. */
987 if (fdset_size(fds) > 0) {
988 q = manager_distribute_fds(m, fds);
993 /* We might have deserialized the notify fd, but if we didn't
994 * then let's create the bus now */
995 manager_setup_notify(m);
997 /* We might have deserialized the kdbus control fd, but if we
998 * didn't, then let's create the bus now. */
999 manager_setup_kdbus(m);
1000 manager_connect_bus(m, !!serialization);
1001 bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
1003 /* Third, fire things up! */
1004 q = manager_coldplug(m);
1008 if (serialization) {
1009 assert(m->n_reloading > 0);
1012 /* Let's wait for the UnitNew/JobNew messages being
1013 * sent, before we notify that the reload is
1015 m->send_reloading_done = true;
1021 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1026 assert(type < _JOB_TYPE_MAX);
1028 assert(mode < _JOB_MODE_MAX);
1030 if (mode == JOB_ISOLATE && type != JOB_START) {
1031 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1035 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1036 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1040 log_debug_unit(unit->id,
1041 "Trying to enqueue job %s/%s/%s", unit->id,
1042 job_type_to_string(type), job_mode_to_string(mode));
1044 job_type_collapse(&type, unit);
1046 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1050 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1051 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1052 mode == JOB_IGNORE_DEPENDENCIES, e);
1056 if (mode == JOB_ISOLATE) {
1057 r = transaction_add_isolate_jobs(tr, m);
1062 r = transaction_activate(tr, m, mode, e);
1066 log_debug_unit(unit->id,
1067 "Enqueued job %s/%s as %u", unit->id,
1068 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1071 *_ret = tr->anchor_job;
1073 transaction_free(tr);
1077 transaction_abort(tr);
1078 transaction_free(tr);
1082 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1087 assert(type < _JOB_TYPE_MAX);
1089 assert(mode < _JOB_MODE_MAX);
1091 r = manager_load_unit(m, name, NULL, NULL, &unit);
1095 return manager_add_job(m, type, unit, mode, override, e, _ret);
1098 Job *manager_get_job(Manager *m, uint32_t id) {
1101 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1104 Unit *manager_get_unit(Manager *m, const char *name) {
1108 return hashmap_get(m->units, name);
1111 unsigned manager_dispatch_load_queue(Manager *m) {
1117 /* Make sure we are not run recursively */
1118 if (m->dispatching_load_queue)
1121 m->dispatching_load_queue = true;
1123 /* Dispatches the load queue. Takes a unit from the queue and
1124 * tries to load its data until the queue is empty */
1126 while ((u = m->load_queue)) {
1127 assert(u->in_load_queue);
1133 m->dispatching_load_queue = false;
1137 int manager_load_unit_prepare(
1149 assert(name || path);
1151 /* This will prepare the unit for loading, but not actually
1152 * load anything from disk. */
1154 if (path && !is_path(path))
1155 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1158 name = basename(path);
1160 t = unit_name_to_type(name);
1162 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1163 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1165 ret = manager_get_unit(m, name);
1171 ret = unit_new(m, unit_vtable[t]->object_size);
1176 ret->fragment_path = strdup(path);
1177 if (!ret->fragment_path) {
1183 r = unit_add_name(ret, name);
1189 unit_add_to_load_queue(ret);
1190 unit_add_to_dbus_queue(ret);
1191 unit_add_to_gc_queue(ret);
1199 int manager_load_unit(
1210 /* This will load the service information files, but not actually
1211 * start any services or anything. */
1213 r = manager_load_unit_prepare(m, name, path, e, _ret);
1217 manager_dispatch_load_queue(m);
1220 *_ret = unit_follow_merge(*_ret);
1225 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1232 HASHMAP_FOREACH(j, s->jobs, i)
1233 job_dump(j, f, prefix);
1236 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1244 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1246 unit_dump(u, f, prefix);
1249 void manager_clear_jobs(Manager *m) {
1254 while ((j = hashmap_first(m->jobs)))
1255 /* No need to recurse. We're cancelling all jobs. */
1256 job_finish_and_invalidate(j, JOB_CANCELED, false);
1259 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1260 Manager *m = userdata;
1266 while ((j = m->run_queue)) {
1267 assert(j->installed);
1268 assert(j->in_run_queue);
1270 job_run_and_invalidate(j);
1273 if (m->n_running_jobs > 0)
1274 manager_watch_jobs_in_progress(m);
1276 if (m->n_on_console > 0)
1277 manager_watch_idle_pipe(m);
1282 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1289 if (m->dispatching_dbus_queue)
1292 m->dispatching_dbus_queue = true;
1294 while ((u = m->dbus_unit_queue)) {
1295 assert(u->in_dbus_queue);
1297 bus_unit_send_change_signal(u);
1301 while ((j = m->dbus_job_queue)) {
1302 assert(j->in_dbus_queue);
1304 bus_job_send_change_signal(j);
1308 m->dispatching_dbus_queue = false;
1310 if (m->send_reloading_done) {
1311 m->send_reloading_done = false;
1313 bus_manager_send_reloading(m, false);
1316 if (m->queued_message)
1317 bus_send_queued_message(m);
1322 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n) {
1323 _cleanup_strv_free_ char **tags = NULL;
1330 tags = strv_split(buf, "\n\r");
1336 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1338 if (UNIT_VTABLE(u)->notify_message)
1339 UNIT_VTABLE(u)->notify_message(u, pid, tags);
1342 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1343 Manager *m = userdata;
1347 assert(m->notify_fd == fd);
1349 if (revents != EPOLLIN) {
1350 log_warning("Got unexpected poll event for notify fd.");
1356 struct iovec iovec = {
1358 .iov_len = sizeof(buf)-1,
1363 struct cmsghdr cmsghdr;
1364 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1367 struct msghdr msghdr = {
1370 .msg_control = &control,
1371 .msg_controllen = sizeof(control),
1373 struct ucred *ucred;
1376 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1381 if (errno == EAGAIN || errno == EINTR)
1387 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1388 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1389 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1390 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1391 log_warning("Received notify message without credentials. Ignoring.");
1395 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1397 assert((size_t) n < sizeof(buf));
1400 u = manager_get_unit_by_pid(m, ucred->pid);
1402 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1406 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1408 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1412 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1414 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1419 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1425 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1430 log_debug_unit(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1432 unit_unwatch_pid(u, si->si_pid);
1433 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1436 static int manager_dispatch_sigchld(Manager *m) {
1442 /* First we call waitd() for a PID and do not reap the
1443 * zombie. That way we can still access /proc/$PID for
1444 * it while it is a zombie. */
1445 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1447 if (errno == ECHILD)
1459 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1460 _cleanup_free_ char *name = NULL;
1463 get_process_comm(si.si_pid, &name);
1465 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1466 si.si_pid, strna(name),
1467 sigchld_code_to_string(si.si_code),
1469 strna(si.si_code == CLD_EXITED
1470 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1471 : signal_to_string(si.si_status)));
1473 /* And now figure out the unit this belongs
1474 * to, it might be multiple... */
1475 u = manager_get_unit_by_pid(m, si.si_pid);
1477 invoke_sigchld_event(m, u, &si);
1478 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1480 invoke_sigchld_event(m, u, &si);
1481 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1483 invoke_sigchld_event(m, u, &si);
1486 /* And now, we actually reap the zombie. */
1487 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1498 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1499 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1502 log_debug_unit(name, "Activating special unit %s", name);
1504 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1506 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1511 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1512 Manager *m = userdata;
1514 struct signalfd_siginfo sfsi;
1515 bool sigchld = false;
1518 assert(m->signal_fd == fd);
1520 if (revents != EPOLLIN) {
1521 log_warning("Got unexpected events from signal file descriptor.");
1526 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1527 if (n != sizeof(sfsi)) {
1532 if (errno == EINTR || errno == EAGAIN)
1538 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1539 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1540 ? LOG_DEBUG : LOG_INFO,
1543 switch (sfsi.ssi_signo) {
1550 if (m->running_as == SYSTEMD_SYSTEM) {
1551 /* This is for compatibility with the
1552 * original sysvinit */
1553 m->exit_code = MANAGER_REEXECUTE;
1560 if (m->running_as == SYSTEMD_SYSTEM) {
1561 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1565 /* Run the exit target if there is one, if not, just exit. */
1566 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1567 m->exit_code = MANAGER_EXIT;
1574 if (m->running_as == SYSTEMD_SYSTEM)
1575 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1577 /* This is a nop on non-init */
1581 if (m->running_as == SYSTEMD_SYSTEM)
1582 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1584 /* This is a nop on non-init */
1590 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1592 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1593 log_info("Trying to reconnect to bus...");
1597 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1598 log_info("Loading D-Bus service...");
1599 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1606 _cleanup_free_ char *dump = NULL;
1607 _cleanup_fclose_ FILE *f = NULL;
1610 f = open_memstream(&dump, &size);
1612 log_warning("Failed to allocate memory stream.");
1616 manager_dump_units(m, f, "\t");
1617 manager_dump_jobs(m, f, "\t");
1620 log_warning("Failed to write status stream");
1624 log_dump(LOG_INFO, dump);
1629 m->exit_code = MANAGER_RELOAD;
1634 /* Starting SIGRTMIN+0 */
1635 static const char * const target_table[] = {
1636 [0] = SPECIAL_DEFAULT_TARGET,
1637 [1] = SPECIAL_RESCUE_TARGET,
1638 [2] = SPECIAL_EMERGENCY_TARGET,
1639 [3] = SPECIAL_HALT_TARGET,
1640 [4] = SPECIAL_POWEROFF_TARGET,
1641 [5] = SPECIAL_REBOOT_TARGET,
1642 [6] = SPECIAL_KEXEC_TARGET
1645 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1646 static const ManagerExitCode code_table[] = {
1648 [1] = MANAGER_POWEROFF,
1649 [2] = MANAGER_REBOOT,
1653 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1654 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1655 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1656 manager_start_target(m, target_table[idx],
1657 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1661 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1662 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1663 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1667 switch (sfsi.ssi_signo - SIGRTMIN) {
1670 log_debug("Enabling showing of status.");
1671 manager_set_show_status(m, SHOW_STATUS_YES);
1675 log_debug("Disabling showing of status.");
1676 manager_set_show_status(m, SHOW_STATUS_NO);
1680 log_set_max_level(LOG_DEBUG);
1681 log_notice("Setting log level to debug.");
1685 log_set_max_level(LOG_INFO);
1686 log_notice("Setting log level to info.");
1690 if (m->running_as == SYSTEMD_USER) {
1691 m->exit_code = MANAGER_EXIT;
1695 /* This is a nop on init */
1699 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1700 log_notice("Setting log target to journal-or-kmsg.");
1704 log_set_target(LOG_TARGET_CONSOLE);
1705 log_notice("Setting log target to console.");
1709 log_set_target(LOG_TARGET_KMSG);
1710 log_notice("Setting log target to kmsg.");
1714 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1715 log_notice("Setting log target to syslog-or-kmsg.");
1719 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1726 manager_dispatch_sigchld(m);
1731 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1732 Manager *m = userdata;
1737 assert(m->time_change_fd == fd);
1739 log_struct(LOG_INFO,
1740 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1741 "MESSAGE=Time has been changed",
1744 /* Restart the watch */
1745 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1747 close_nointr_nofail(m->time_change_fd);
1748 m->time_change_fd = -1;
1750 manager_setup_time_change(m);
1752 HASHMAP_FOREACH(u, m->units, i)
1753 if (UNIT_VTABLE(u)->time_change)
1754 UNIT_VTABLE(u)->time_change(u);
1759 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1760 Manager *m = userdata;
1763 assert(m->idle_pipe[2] == fd);
1765 m->no_console_output = m->n_on_console > 0;
1767 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1768 manager_close_idle_pipe(m);
1773 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1774 Manager *m = userdata;
1781 manager_print_jobs_in_progress(m);
1783 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1784 r = sd_event_source_set_time(source, next);
1788 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1791 int manager_loop(Manager *m) {
1794 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1797 m->exit_code = MANAGER_RUNNING;
1799 /* Release the path cache */
1800 set_free_free(m->unit_path_cache);
1801 m->unit_path_cache = NULL;
1803 manager_check_finished(m);
1805 /* There might still be some zombies hanging around from
1806 * before we were exec()'ed. Let's reap them. */
1807 r = manager_dispatch_sigchld(m);
1811 while (m->exit_code == MANAGER_RUNNING) {
1814 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1817 if (!ratelimit_test(&rl)) {
1818 /* Yay, something is going seriously wrong, pause a little */
1819 log_warning("Looping too fast. Throttling execution a little.");
1824 if (manager_dispatch_load_queue(m) > 0)
1827 if (manager_dispatch_gc_queue(m) > 0)
1830 if (manager_dispatch_cleanup_queue(m) > 0)
1833 if (manager_dispatch_cgroup_queue(m) > 0)
1836 if (manager_dispatch_dbus_queue(m) > 0)
1839 /* Sleep for half the watchdog time */
1840 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1841 wait_usec = m->runtime_watchdog / 2;
1845 wait_usec = (usec_t) -1;
1847 r = sd_event_run(m->event, wait_usec);
1849 log_error("Failed to run event loop: %s", strerror(-r));
1854 return m->exit_code;
1857 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1858 _cleanup_free_ char *n = NULL;
1866 r = unit_name_from_dbus_path(s, &n);
1870 r = manager_load_unit(m, n, NULL, e, &u);
1879 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1889 p = startswith(s, "/org/freedesktop/systemd1/job/");
1893 r = safe_atou(p, &id);
1897 j = manager_get_job(m, id);
1906 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1909 _cleanup_free_ char *p = NULL;
1912 audit_fd = get_audit_fd();
1916 /* Don't generate audit events if the service was already
1917 * started and we're just deserializing */
1918 if (m->n_reloading > 0)
1921 if (m->running_as != SYSTEMD_SYSTEM)
1924 if (u->type != UNIT_SERVICE)
1927 p = unit_name_to_prefix_and_instance(u->id);
1929 log_error_unit(u->id,
1930 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1934 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1935 if (errno == EPERM) {
1936 /* We aren't allowed to send audit messages?
1937 * Then let's not retry again. */
1940 log_warning("Failed to send audit message: %m");
1946 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1947 union sockaddr_union sa = {
1948 .un.sun_family = AF_UNIX,
1949 .un.sun_path = "\0/org/freedesktop/plymouthd",
1953 _cleanup_free_ char *message = NULL;
1954 _cleanup_close_ int fd = -1;
1956 /* Don't generate plymouth events if the service was already
1957 * started and we're just deserializing */
1958 if (m->n_reloading > 0)
1961 if (m->running_as != SYSTEMD_SYSTEM)
1964 if (detect_container(NULL) > 0)
1967 if (u->type != UNIT_SERVICE &&
1968 u->type != UNIT_MOUNT &&
1969 u->type != UNIT_SWAP)
1972 /* We set SOCK_NONBLOCK here so that we rather drop the
1973 * message then wait for plymouth */
1974 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1976 log_error("socket() failed: %m");
1980 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1982 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
1983 log_error("connect() failed: %m");
1987 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1993 if (write(fd, message, n + 1) != n + 1)
1994 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
1995 log_error("Failed to write Plymouth message: %m");
1998 void manager_dispatch_bus_name_owner_changed(
2001 const char* old_owner,
2002 const char *new_owner) {
2009 u = hashmap_get(m->watch_bus, name);
2013 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2016 int manager_open_serialization(Manager *m, FILE **_f) {
2023 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2024 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2028 log_debug("Serializing state to %s", path);
2030 f = fdopen(fd, "w+");
2032 close_nointr_nofail(fd);
2041 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2054 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2055 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2056 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2057 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2059 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2060 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2061 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2062 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2065 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2066 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2067 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2068 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2069 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2070 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2071 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2072 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2075 if (!switching_root) {
2076 STRV_FOREACH(e, m->environment) {
2077 _cleanup_free_ char *ce;
2083 fprintf(f, "env=%s\n", *e);
2087 if (m->notify_fd >= 0) {
2090 copy = fdset_put_dup(fds, m->notify_fd);
2094 fprintf(f, "notify-fd=%i\n", copy);
2095 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2098 if (m->kdbus_fd >= 0) {
2101 copy = fdset_put_dup(fds, m->kdbus_fd);
2105 fprintf(f, "kdbus-fd=%i\n", copy);
2108 bus_track_serialize(m->subscribed, f);
2112 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2116 if (!unit_can_serialize(u))
2123 r = unit_serialize(u, f, fds, !switching_root);
2130 assert(m->n_reloading > 0);
2136 r = bus_fdset_add_all(m, fds);
2143 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2149 log_debug("Deserializing state...");
2154 char line[LINE_MAX], *l;
2156 if (!fgets(line, sizeof(line), f)) {
2171 if (startswith(l, "current-job-id=")) {
2174 if (safe_atou32(l+15, &id) < 0)
2175 log_debug("Failed to parse current job id value %s", l+15);
2177 m->current_job_id = MAX(m->current_job_id, id);
2179 } else if (startswith(l, "n-installed-jobs=")) {
2182 if (safe_atou32(l+17, &n) < 0)
2183 log_debug("Failed to parse installed jobs counter %s", l+17);
2185 m->n_installed_jobs += n;
2187 } else if (startswith(l, "n-failed-jobs=")) {
2190 if (safe_atou32(l+14, &n) < 0)
2191 log_debug("Failed to parse failed jobs counter %s", l+14);
2193 m->n_failed_jobs += n;
2195 } else if (startswith(l, "taint-usr=")) {
2198 b = parse_boolean(l+10);
2200 log_debug("Failed to parse taint /usr flag %s", l+10);
2202 m->taint_usr = m->taint_usr || b;
2204 } else if (startswith(l, "firmware-timestamp="))
2205 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2206 else if (startswith(l, "loader-timestamp="))
2207 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2208 else if (startswith(l, "kernel-timestamp="))
2209 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2210 else if (startswith(l, "initrd-timestamp="))
2211 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2212 else if (startswith(l, "userspace-timestamp="))
2213 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2214 else if (startswith(l, "finish-timestamp="))
2215 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2216 else if (startswith(l, "security-start-timestamp="))
2217 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2218 else if (startswith(l, "security-finish-timestamp="))
2219 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2220 else if (startswith(l, "generators-start-timestamp="))
2221 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2222 else if (startswith(l, "generators-finish-timestamp="))
2223 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2224 else if (startswith(l, "units-load-start-timestamp="))
2225 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2226 else if (startswith(l, "units-load-finish-timestamp="))
2227 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2228 else if (startswith(l, "env=")) {
2229 _cleanup_free_ char *uce = NULL;
2232 uce = cunescape(l+4);
2238 e = strv_env_set(m->environment, uce);
2244 strv_free(m->environment);
2247 } else if (startswith(l, "notify-fd=")) {
2250 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2251 log_debug("Failed to parse notify fd: %s", l + 10);
2253 if (m->notify_fd >= 0) {
2254 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2255 close_nointr_nofail(m->notify_fd);
2258 m->notify_fd = fdset_remove(fds, fd);
2261 } else if (startswith(l, "notify-socket=")) {
2270 free(m->notify_socket);
2271 m->notify_socket = n;
2273 } else if (startswith(l, "kdbus-fd=")) {
2276 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2277 log_debug("Failed to parse kdbus fd: %s", l + 9);
2279 if (m->kdbus_fd >= 0)
2280 close_nointr_nofail(m->kdbus_fd);
2282 m->kdbus_fd = fdset_remove(fds, fd);
2285 } else if (bus_track_deserialize_item(&m->deserialized_subscribed, l) == 0)
2286 log_debug("Unknown serialization item '%s'", l);
2291 char name[UNIT_NAME_MAX+2];
2294 if (!fgets(name, sizeof(name), f)) {
2305 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2309 r = unit_deserialize(u, f, fds);
2318 assert(m->n_reloading > 0);
2324 int manager_reload(Manager *m) {
2326 _cleanup_fclose_ FILE *f = NULL;
2327 _cleanup_fdset_free_ FDSet *fds = NULL;
2331 r = manager_open_serialization(m, &f);
2336 bus_manager_send_reloading(m, true);
2344 r = manager_serialize(m, f, fds, false);
2350 if (fseeko(f, 0, SEEK_SET) < 0) {
2355 /* From here on there is no way back. */
2356 manager_clear_jobs_and_units(m);
2357 manager_undo_generators(m);
2358 lookup_paths_free(&m->lookup_paths);
2360 /* Find new unit paths */
2361 manager_run_generators(m);
2363 q = lookup_paths_init(
2364 &m->lookup_paths, m->running_as, true,
2365 m->generator_unit_path,
2366 m->generator_unit_path_early,
2367 m->generator_unit_path_late);
2371 manager_build_unit_path_cache(m);
2373 /* First, enumerate what we can from all config files */
2374 q = manager_enumerate(m);
2378 /* Second, deserialize our stored data */
2379 q = manager_deserialize(m, f, fds);
2386 /* Re-register notify_fd as event source */
2387 q = manager_setup_notify(m);
2391 /* Third, fire things up! */
2392 q = manager_coldplug(m);
2396 assert(m->n_reloading > 0);
2399 m->send_reloading_done = true;
2404 static bool manager_is_booting_or_shutting_down(Manager *m) {
2409 /* Is the initial job still around? */
2410 if (manager_get_job(m, m->default_unit_job_id))
2413 /* Is there a job for the shutdown target? */
2414 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2421 bool manager_is_reloading_or_reexecuting(Manager *m) {
2424 return m->n_reloading != 0;
2427 void manager_reset_failed(Manager *m) {
2433 HASHMAP_FOREACH(u, m->units, i)
2434 unit_reset_failed(u);
2437 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2443 /* Returns true if the unit is inactive or going down */
2444 u = manager_get_unit(m, name);
2448 return unit_inactive_or_pending(u);
2451 void manager_check_finished(Manager *m) {
2452 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2453 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2457 if (m->n_running_jobs == 0)
2458 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2460 if (hashmap_size(m->jobs) > 0) {
2461 if (m->jobs_in_progress_event_source) {
2462 uint64_t next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
2463 sd_event_source_set_time(m->jobs_in_progress_event_source, next);
2468 manager_flip_auto_status(m, false);
2470 /* Notify Type=idle units that we are done now */
2471 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2472 manager_close_idle_pipe(m);
2474 /* Turn off confirm spawn now */
2475 m->confirm_spawn = false;
2477 if (dual_timestamp_is_set(&m->finish_timestamp))
2480 dual_timestamp_get(&m->finish_timestamp);
2482 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2484 /* Note that m->kernel_usec.monotonic is always at 0,
2485 * and m->firmware_usec.monotonic and
2486 * m->loader_usec.monotonic should be considered
2487 * negative values. */
2489 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2490 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2491 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2492 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2494 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2496 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2497 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2499 if (!log_on_console())
2500 log_struct(LOG_INFO,
2501 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2502 "KERNEL_USEC="USEC_FMT, kernel_usec,
2503 "INITRD_USEC="USEC_FMT, initrd_usec,
2504 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2505 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2506 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2507 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2508 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2509 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2512 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2515 if (!log_on_console())
2516 log_struct(LOG_INFO,
2517 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2518 "KERNEL_USEC="USEC_FMT, kernel_usec,
2519 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2520 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2521 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2522 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2523 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2527 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2528 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2530 if (!log_on_console())
2531 log_struct(LOG_INFO,
2532 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2533 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2534 "MESSAGE=Startup finished in %s.",
2535 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2539 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2542 "READY=1\nSTATUS=Startup finished in %s.",
2543 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2546 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2557 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2558 /* systemd --system, not running --test */
2560 p = strappend("/run/systemd/", name);
2564 r = mkdir_p_label(p, 0755);
2566 log_error("Failed to create generator directory %s: %s",
2571 } else if (m->running_as == SYSTEMD_USER) {
2572 const char *s = NULL;
2574 s = getenv("XDG_RUNTIME_DIR");
2577 p = strjoin(s, "/systemd/", name, NULL);
2581 r = mkdir_p_label(p, 0755);
2583 log_error("Failed to create generator directory %s: %s",
2589 /* systemd --system --test */
2591 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2596 log_error("Failed to create generator directory %s: %m",
2607 static void trim_generator_dir(Manager *m, char **generator) {
2614 if (rmdir(*generator) >= 0) {
2622 void manager_run_generators(Manager *m) {
2623 _cleanup_closedir_ DIR *d = NULL;
2624 const char *generator_path;
2625 const char *argv[5];
2630 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2631 d = opendir(generator_path);
2633 if (errno == ENOENT)
2636 log_error("Failed to enumerate generator directory %s: %m",
2641 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2645 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2649 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2653 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2654 argv[1] = m->generator_unit_path;
2655 argv[2] = m->generator_unit_path_early;
2656 argv[3] = m->generator_unit_path_late;
2659 RUN_WITH_UMASK(0022)
2660 execute_directory(generator_path, d, DEFAULT_TIMEOUT_USEC, (char**) argv);
2663 trim_generator_dir(m, &m->generator_unit_path);
2664 trim_generator_dir(m, &m->generator_unit_path_early);
2665 trim_generator_dir(m, &m->generator_unit_path_late);
2668 static void remove_generator_dir(Manager *m, char **generator) {
2675 strv_remove(m->lookup_paths.unit_path, *generator);
2676 rm_rf(*generator, false, true, false);
2682 void manager_undo_generators(Manager *m) {
2685 remove_generator_dir(m, &m->generator_unit_path);
2686 remove_generator_dir(m, &m->generator_unit_path_early);
2687 remove_generator_dir(m, &m->generator_unit_path_late);
2690 int manager_environment_add(Manager *m, char **minus, char **plus) {
2691 char **a = NULL, **b = NULL, **l;
2696 if (!strv_isempty(minus)) {
2697 a = strv_env_delete(l, 1, minus);
2704 if (!strv_isempty(plus)) {
2705 b = strv_env_merge(2, l, plus);
2712 if (m->environment != l)
2713 strv_free(m->environment);
2720 manager_clean_environment(m);
2721 strv_sort(m->environment);
2726 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2731 for (i = 0; i < _RLIMIT_MAX; i++) {
2732 if (!default_rlimit[i])
2735 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2743 void manager_recheck_journal(Manager *m) {
2748 if (m->running_as != SYSTEMD_SYSTEM)
2751 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2752 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2753 log_close_journal();
2757 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2758 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2759 log_close_journal();
2763 /* Hmm, OK, so the socket is fully up and the service is up
2764 * too, then let's make use of the thing. */
2768 void manager_set_show_status(Manager *m, ShowStatus mode) {
2770 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2772 if (m->running_as != SYSTEMD_SYSTEM)
2775 m->show_status = mode;
2778 touch("/run/systemd/show-status");
2780 unlink("/run/systemd/show-status");
2783 static bool manager_get_show_status(Manager *m) {
2786 if (m->running_as != SYSTEMD_SYSTEM)
2789 if (m->no_console_output)
2792 if (m->show_status > 0)
2795 /* If Plymouth is running make sure we show the status, so
2796 * that there's something nice to see when people press Esc */
2798 return plymouth_running();
2801 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2804 if (!manager_get_show_status(m))
2807 /* XXX We should totally drop the check for ephemeral here
2808 * and thus effectively make 'Type=idle' pointless. */
2809 if (ephemeral && m->n_on_console > 0)
2812 if (!manager_is_booting_or_shutting_down(m))
2815 va_start(ap, format);
2816 status_vprintf(status, true, ephemeral, format, ap);
2820 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2821 _cleanup_free_ char *p = NULL;
2829 p = unit_name_from_path(path, suffix);
2833 found = manager_get_unit(m, p);
2843 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2844 char p[strlen(path)+1];
2850 path_kill_slashes(p);
2852 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
2855 const char *manager_get_runtime_prefix(Manager *m) {
2857 return m->running_as == SYSTEMD_SYSTEM ?
2859 getenv("XDG_RUNTIME_DIR");