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) {
102 if (m->jobs_in_progress_event_source)
105 return sd_event_add_monotonic(m->event, now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC, 0, manager_dispatch_jobs_in_progress, m, &m->jobs_in_progress_event_source);
108 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
110 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
113 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
114 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
118 p = mempset(p, ' ', pos-2);
119 p = stpcpy(p, ANSI_RED_ON);
123 if (pos > 0 && pos <= width) {
124 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
128 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
131 p = stpcpy(p, ANSI_RED_ON);
134 p = mempset(p, ' ', width-1-pos);
135 strcpy(p, ANSI_HIGHLIGHT_OFF);
139 void manager_flip_auto_status(Manager *m, bool enable) {
141 if (m->show_status == SHOW_STATUS_AUTO)
142 manager_set_show_status(m, SHOW_STATUS_TEMPORARY);
144 if (m->show_status == SHOW_STATUS_TEMPORARY)
145 manager_set_show_status(m, SHOW_STATUS_AUTO);
149 static void manager_print_jobs_in_progress(Manager *m) {
150 _cleanup_free_ char *job_of_n = NULL;
153 unsigned counter = 0, print_nr;
154 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
156 char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
161 manager_flip_auto_status(m, true);
163 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
165 HASHMAP_FOREACH(j, m->jobs, i)
166 if (j->state == JOB_RUNNING && counter++ == print_nr)
169 /* m->n_running_jobs must be consistent with the contents of m->jobs,
170 * so the above loop must have succeeded in finding j. */
171 assert(counter == print_nr + 1);
174 cylon_pos = m->jobs_in_progress_iteration % 14;
176 cylon_pos = 14 - cylon_pos;
177 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
179 m->jobs_in_progress_iteration++;
181 if (m->n_running_jobs > 1)
182 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
185 format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
186 if (job_get_timeout(j, &x) > 0)
187 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
189 manager_status_printf(m, true, cylon,
190 "%sA %s job is running for %s (%s / %s)",
192 job_type_to_string(j->type),
193 unit_description(j->unit),
198 static int manager_watch_idle_pipe(Manager *m) {
203 if (m->idle_pipe_event_source)
206 if (m->idle_pipe[2] < 0)
209 r = sd_event_add_io(m->event, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m, &m->idle_pipe_event_source);
211 log_error("Failed to watch idle pipe: %s", strerror(-r));
218 static void manager_close_idle_pipe(Manager *m) {
221 close_pipe(m->idle_pipe);
222 close_pipe(m->idle_pipe + 2);
225 static int manager_setup_time_change(Manager *m) {
228 /* We only care for the cancellation event, hence we set the
229 * timeout to the latest possible value. */
230 struct itimerspec its = {
231 .it_value.tv_sec = TIME_T_MAX,
235 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
237 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
238 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
240 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
241 if (m->time_change_fd < 0) {
242 log_error("Failed to create timerfd: %m");
246 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
247 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
248 close_nointr_nofail(m->time_change_fd);
249 m->time_change_fd = -1;
253 r = sd_event_add_io(m->event, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m, &m->time_change_event_source);
255 log_error("Failed to create time change event source: %s", strerror(-r));
259 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
264 static int enable_special_signals(Manager *m) {
265 _cleanup_close_ int fd = -1;
269 /* Enable that we get SIGINT on control-alt-del. In containers
270 * this will fail with EPERM (older) or EINVAL (newer), so
272 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
273 log_warning("Failed to enable ctrl-alt-del handling: %m");
275 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
277 /* Support systems without virtual console */
279 log_warning("Failed to open /dev/tty0: %m");
281 /* Enable that we get SIGWINCH on kbrequest */
282 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
283 log_warning("Failed to enable kbrequest handling: %m");
289 static int manager_setup_signals(Manager *m) {
290 struct sigaction sa = {
291 .sa_handler = SIG_DFL,
292 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
299 /* We are not interested in SIGSTOP and friends. */
300 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
302 assert_se(sigemptyset(&mask) == 0);
304 sigset_add_many(&mask,
305 SIGCHLD, /* Child died */
306 SIGTERM, /* Reexecute daemon */
307 SIGHUP, /* Reload configuration */
308 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
309 SIGUSR2, /* systemd: dump status */
310 SIGINT, /* Kernel sends us this on control-alt-del */
311 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
312 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
313 SIGRTMIN+0, /* systemd: start default.target */
314 SIGRTMIN+1, /* systemd: isolate rescue.target */
315 SIGRTMIN+2, /* systemd: isolate emergency.target */
316 SIGRTMIN+3, /* systemd: start halt.target */
317 SIGRTMIN+4, /* systemd: start poweroff.target */
318 SIGRTMIN+5, /* systemd: start reboot.target */
319 SIGRTMIN+6, /* systemd: start kexec.target */
320 SIGRTMIN+13, /* systemd: Immediate halt */
321 SIGRTMIN+14, /* systemd: Immediate poweroff */
322 SIGRTMIN+15, /* systemd: Immediate reboot */
323 SIGRTMIN+16, /* systemd: Immediate kexec */
324 SIGRTMIN+20, /* systemd: enable status messages */
325 SIGRTMIN+21, /* systemd: disable status messages */
326 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
327 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
328 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
329 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
330 SIGRTMIN+27, /* systemd: set log target to console */
331 SIGRTMIN+28, /* systemd: set log target to kmsg */
332 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
334 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
336 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
337 if (m->signal_fd < 0)
340 r = sd_event_add_io(m->event, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m, &m->signal_event_source);
344 /* Process signals a bit earlier than the rest of things, but
345 * later that notify_fd processing, so that the notify
346 * processing can still figure out to which process/service a
347 * message belongs, before we reap the process. */
348 r = sd_event_source_set_priority(m->signal_event_source, -5);
352 if (m->running_as == SYSTEMD_SYSTEM)
353 return enable_special_signals(m);
358 static void manager_clean_environment(Manager *m) {
361 /* Let's remove some environment variables that we
362 * need ourselves to communicate with our clients */
375 static int manager_default_environment(Manager *m) {
378 if (m->running_as == SYSTEMD_SYSTEM) {
379 /* The system manager always starts with a clean
380 * environment for its children. It does not import
381 * the kernel or the parents exported variables.
383 * The initial passed environ is untouched to keep
384 * /proc/self/environ valid; it is used for tagging
385 * the init process inside containers. */
386 m->environment = strv_new("PATH=" DEFAULT_PATH,
389 /* Import locale variables LC_*= from configuration */
390 locale_setup(&m->environment);
392 /* The user manager passes its own environment
393 * along to its children. */
394 m->environment = strv_copy(environ);
400 manager_clean_environment(m);
401 strv_sort(m->environment);
406 int manager_new(SystemdRunningAs running_as, Manager **_m) {
411 assert(running_as >= 0);
412 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
414 m = new0(Manager, 1);
419 if (detect_container(NULL) <= 0)
420 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
423 m->running_as = running_as;
424 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
426 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
428 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;
429 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
431 r = manager_default_environment(m);
435 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
439 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
443 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
447 r = hashmap_ensure_allocated(&m->watch_pids, trivial_hash_func, trivial_compare_func);
451 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
455 r = sd_event_default(&m->event);
459 r = sd_event_add_defer(m->event, manager_dispatch_run_queue, m, &m->run_queue_event_source);
463 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
467 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
471 r = manager_setup_signals(m);
475 r = manager_setup_cgroup(m);
479 r = manager_setup_time_change(m);
483 m->udev = udev_new();
489 /* Note that we set up neither kdbus, nor the notify fd
490 * here. We do that after deserialization, since they might
491 * have gotten serialized across the reexec. */
493 m->taint_usr = dir_is_empty("/usr") > 0;
503 static int manager_setup_notify(Manager *m) {
506 struct sockaddr_un un;
508 .sa.sa_family = AF_UNIX,
512 if (m->notify_fd < 0) {
513 _cleanup_close_ int fd = -1;
515 /* First free all secondary fields */
516 free(m->notify_socket);
517 m->notify_socket = NULL;
518 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
520 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
522 log_error("Failed to allocate notification socket: %m");
526 if (getpid() != 1 || detect_container(NULL) > 0)
527 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%" PRIx64, random_u64());
529 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
530 sa.un.sun_path[0] = 0;
532 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
534 log_error("bind() failed: %m");
538 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
540 log_error("SO_PASSCRED failed: %m");
544 sa.un.sun_path[0] = '@';
545 m->notify_socket = strdup(sa.un.sun_path);
546 if (!m->notify_socket)
552 log_debug("Using notification socket %s", m->notify_socket);
555 if (!m->notify_event_source) {
556 r = sd_event_add_io(m->event, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m, &m->notify_event_source);
558 log_error("Failed to allocate notify event source: %s", strerror(-r));
562 /* Process signals a bit earlier than SIGCHLD, so that we can
563 * still identify to which service an exit message belongs */
564 r = sd_event_source_set_priority(m->notify_event_source, -7);
566 log_error("Failed to set priority of notify event source: %s", strerror(-r));
574 static int manager_setup_kdbus(Manager *m) {
576 _cleanup_free_ char *p = NULL;
582 if (m->kdbus_fd >= 0)
585 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
586 if (m->kdbus_fd < 0) {
587 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
591 log_debug("Successfully set up kdbus on %s", p);
593 /* Create the namespace directory here, so that the contents
594 * of that directory is not visible to non-root users. This is
595 * necessary to ensure that users cannot get access to busses
596 * of virtualized users when no UID namespacing is used. */
597 if (m->running_as == SYSTEMD_SYSTEM)
598 mkdir_p_label("/dev/kdbus/ns", 0700);
604 static int manager_connect_bus(Manager *m, bool reexecuting) {
605 bool try_bus_connect;
612 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
614 /* Try to connect to the busses, if possible. */
615 return bus_init(m, try_bus_connect);
618 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
624 while ((u = m->cleanup_queue)) {
625 assert(u->in_cleanup_queue);
635 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
636 GC_OFFSET_UNSURE, /* No clue */
637 GC_OFFSET_GOOD, /* We still need this unit */
638 GC_OFFSET_BAD, /* We don't need this unit anymore */
642 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
649 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
650 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
651 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
654 if (u->in_cleanup_queue)
657 if (unit_check_gc(u))
660 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
664 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
665 unit_gc_sweep(other, gc_marker);
667 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
670 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
677 /* We were unable to find anything out about this entry, so
678 * let's investigate it later */
679 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
680 unit_add_to_gc_queue(u);
684 /* We definitely know that this one is not useful anymore, so
685 * let's mark it for deletion */
686 u->gc_marker = gc_marker + GC_OFFSET_BAD;
687 unit_add_to_cleanup_queue(u);
691 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
694 static unsigned manager_dispatch_gc_queue(Manager *m) {
701 /* log_debug("Running GC..."); */
703 m->gc_marker += _GC_OFFSET_MAX;
704 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
707 gc_marker = m->gc_marker;
709 while ((u = m->gc_queue)) {
710 assert(u->in_gc_queue);
712 unit_gc_sweep(u, gc_marker);
714 LIST_REMOVE(gc_queue, m->gc_queue, u);
715 u->in_gc_queue = false;
719 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
720 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
721 log_debug_unit(u->id, "Collecting %s", u->id);
722 u->gc_marker = gc_marker + GC_OFFSET_BAD;
723 unit_add_to_cleanup_queue(u);
727 m->n_in_gc_queue = 0;
732 static void manager_clear_jobs_and_units(Manager *m) {
737 while ((u = hashmap_first(m->units)))
740 manager_dispatch_cleanup_queue(m);
742 assert(!m->load_queue);
743 assert(!m->run_queue);
744 assert(!m->dbus_unit_queue);
745 assert(!m->dbus_job_queue);
746 assert(!m->cleanup_queue);
747 assert(!m->gc_queue);
749 assert(hashmap_isempty(m->jobs));
750 assert(hashmap_isempty(m->units));
753 m->n_running_jobs = 0;
756 void manager_free(Manager *m) {
762 manager_clear_jobs_and_units(m);
764 for (c = 0; c < _UNIT_TYPE_MAX; c++)
765 if (unit_vtable[c]->shutdown)
766 unit_vtable[c]->shutdown(m);
768 /* If we reexecute ourselves, we keep the root cgroup
770 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
772 manager_undo_generators(m);
776 hashmap_free(m->units);
777 hashmap_free(m->jobs);
778 hashmap_free(m->watch_pids);
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_NLIMITS; 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) {
856 if ((q = unit_coldplug(u)) < 0)
863 static void manager_build_unit_path_cache(Manager *m) {
865 _cleanup_free_ DIR *d = NULL;
870 set_free_free(m->unit_path_cache);
872 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
873 if (!m->unit_path_cache) {
874 log_error("Failed to allocate unit path cache.");
878 /* This simply builds a list of files we know exist, so that
879 * we don't always have to go to disk */
881 STRV_FOREACH(i, m->lookup_paths.unit_path) {
887 log_error("Failed to open directory %s: %m", *i);
891 while ((de = readdir(d))) {
894 if (ignore_file(de->d_name))
897 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
903 r = set_consume(m->unit_path_cache, p);
915 log_error("Failed to build unit path cache: %s", strerror(-r));
917 set_free_free(m->unit_path_cache);
918 m->unit_path_cache = NULL;
922 static int manager_distribute_fds(Manager *m, FDSet *fds) {
929 HASHMAP_FOREACH(u, m->units, i) {
931 if (fdset_size(fds) <= 0)
934 if (UNIT_VTABLE(u)->distribute_fds) {
935 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
944 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
949 dual_timestamp_get(&m->generators_start_timestamp);
950 manager_run_generators(m);
951 dual_timestamp_get(&m->generators_finish_timestamp);
953 r = lookup_paths_init(
954 &m->lookup_paths, m->running_as, true,
955 m->generator_unit_path,
956 m->generator_unit_path_early,
957 m->generator_unit_path_late);
961 manager_build_unit_path_cache(m);
963 /* If we will deserialize make sure that during enumeration
964 * this is already known, so we increase the counter here
969 /* First, enumerate what we can from all config files */
970 dual_timestamp_get(&m->units_load_start_timestamp);
971 r = manager_enumerate(m);
972 dual_timestamp_get(&m->units_load_finish_timestamp);
974 /* Second, deserialize if there is something to deserialize */
976 q = manager_deserialize(m, serialization, fds);
981 /* Any fds left? Find some unit which wants them. This is
982 * useful to allow container managers to pass some file
983 * descriptors to us pre-initialized. This enables
984 * socket-based activation of entire containers. */
985 if (fdset_size(fds) > 0) {
986 q = manager_distribute_fds(m, fds);
991 /* We might have deserialized the notify fd, but if we didn't
992 * then let's create the bus now */
993 manager_setup_notify(m);
995 /* We might have deserialized the kdbus control fd, but if we
996 * didn't, then let's create the bus now. */
997 manager_setup_kdbus(m);
998 manager_connect_bus(m, !!serialization);
1000 /* Third, fire things up! */
1001 q = manager_coldplug(m);
1005 if (serialization) {
1006 assert(m->n_reloading > 0);
1009 /* Let's wait for the UnitNew/JobNew messages being
1010 * sent, before we notify that the reload is
1012 m->send_reloading_done = true;
1018 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1023 assert(type < _JOB_TYPE_MAX);
1025 assert(mode < _JOB_MODE_MAX);
1027 if (mode == JOB_ISOLATE && type != JOB_START) {
1028 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1032 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1033 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1037 log_debug_unit(unit->id,
1038 "Trying to enqueue job %s/%s/%s", unit->id,
1039 job_type_to_string(type), job_mode_to_string(mode));
1041 job_type_collapse(&type, unit);
1043 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1047 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1048 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1049 mode == JOB_IGNORE_DEPENDENCIES, e);
1053 if (mode == JOB_ISOLATE) {
1054 r = transaction_add_isolate_jobs(tr, m);
1059 r = transaction_activate(tr, m, mode, e);
1063 log_debug_unit(unit->id,
1064 "Enqueued job %s/%s as %u", unit->id,
1065 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1068 *_ret = tr->anchor_job;
1070 transaction_free(tr);
1074 transaction_abort(tr);
1075 transaction_free(tr);
1079 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1084 assert(type < _JOB_TYPE_MAX);
1086 assert(mode < _JOB_MODE_MAX);
1088 r = manager_load_unit(m, name, NULL, NULL, &unit);
1092 return manager_add_job(m, type, unit, mode, override, e, _ret);
1095 Job *manager_get_job(Manager *m, uint32_t id) {
1098 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1101 Unit *manager_get_unit(Manager *m, const char *name) {
1105 return hashmap_get(m->units, name);
1108 unsigned manager_dispatch_load_queue(Manager *m) {
1114 /* Make sure we are not run recursively */
1115 if (m->dispatching_load_queue)
1118 m->dispatching_load_queue = true;
1120 /* Dispatches the load queue. Takes a unit from the queue and
1121 * tries to load its data until the queue is empty */
1123 while ((u = m->load_queue)) {
1124 assert(u->in_load_queue);
1130 m->dispatching_load_queue = false;
1134 int manager_load_unit_prepare(
1146 assert(name || path);
1148 /* This will prepare the unit for loading, but not actually
1149 * load anything from disk. */
1151 if (path && !is_path(path))
1152 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1155 name = basename(path);
1157 t = unit_name_to_type(name);
1159 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1160 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1162 ret = manager_get_unit(m, name);
1168 ret = unit_new(m, unit_vtable[t]->object_size);
1173 ret->fragment_path = strdup(path);
1174 if (!ret->fragment_path) {
1180 r = unit_add_name(ret, name);
1186 unit_add_to_load_queue(ret);
1187 unit_add_to_dbus_queue(ret);
1188 unit_add_to_gc_queue(ret);
1196 int manager_load_unit(
1207 /* This will load the service information files, but not actually
1208 * start any services or anything. */
1210 r = manager_load_unit_prepare(m, name, path, e, _ret);
1214 manager_dispatch_load_queue(m);
1217 *_ret = unit_follow_merge(*_ret);
1222 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1229 HASHMAP_FOREACH(j, s->jobs, i)
1230 job_dump(j, f, prefix);
1233 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1241 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1243 unit_dump(u, f, prefix);
1246 void manager_clear_jobs(Manager *m) {
1251 while ((j = hashmap_first(m->jobs)))
1252 /* No need to recurse. We're cancelling all jobs. */
1253 job_finish_and_invalidate(j, JOB_CANCELED, false);
1256 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1257 Manager *m = userdata;
1263 while ((j = m->run_queue)) {
1264 assert(j->installed);
1265 assert(j->in_run_queue);
1267 job_run_and_invalidate(j);
1270 if (m->n_running_jobs > 0)
1271 manager_watch_jobs_in_progress(m);
1273 if (m->n_on_console > 0)
1274 manager_watch_idle_pipe(m);
1279 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1286 if (m->dispatching_dbus_queue)
1289 m->dispatching_dbus_queue = true;
1291 while ((u = m->dbus_unit_queue)) {
1292 assert(u->in_dbus_queue);
1294 bus_unit_send_change_signal(u);
1298 while ((j = m->dbus_job_queue)) {
1299 assert(j->in_dbus_queue);
1301 bus_job_send_change_signal(j);
1305 m->dispatching_dbus_queue = false;
1307 if (m->send_reloading_done) {
1308 m->send_reloading_done = false;
1310 bus_manager_send_reloading(m, false);
1313 if (m->queued_message)
1314 bus_send_queued_message(m);
1319 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1320 Manager *m = userdata;
1324 assert(m->notify_fd == fd);
1326 if (revents != EPOLLIN) {
1327 log_warning("Got unexpected poll event for notify fd.");
1333 struct iovec iovec = {
1335 .iov_len = sizeof(buf)-1,
1339 struct cmsghdr cmsghdr;
1340 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1343 struct msghdr msghdr = {
1346 .msg_control = &control,
1347 .msg_controllen = sizeof(control),
1349 struct ucred *ucred;
1351 _cleanup_strv_free_ char **tags = NULL;
1353 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1358 if (errno == EAGAIN || errno == EINTR)
1364 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1365 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1366 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1367 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1368 log_warning("Received notify message without credentials. Ignoring.");
1372 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1374 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1376 u = manager_get_unit_by_pid(m, ucred->pid);
1378 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1383 assert((size_t) n < sizeof(buf));
1385 tags = strv_split(buf, "\n\r");
1389 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1391 if (UNIT_VTABLE(u)->notify_message)
1392 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1398 static int manager_dispatch_sigchld(Manager *m) {
1405 /* First we call waitd() for a PID and do not reap the
1406 * zombie. That way we can still access /proc/$PID for
1407 * it while it is a zombie. */
1408 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1410 if (errno == ECHILD)
1422 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1423 _cleanup_free_ char *name = NULL;
1425 get_process_comm(si.si_pid, &name);
1426 log_debug("Got SIGCHLD for process "PID_FMT" (%s)", si.si_pid, strna(name));
1429 /* And now figure out the unit this belongs to */
1430 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1432 u = manager_get_unit_by_pid(m, si.si_pid);
1434 /* And now, we actually reap the zombie. */
1435 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1442 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1445 log_debug("Child %lu died (code=%s, status=%i/%s)",
1446 (long unsigned) si.si_pid,
1447 sigchld_code_to_string(si.si_code),
1449 strna(si.si_code == CLD_EXITED
1450 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1451 : signal_to_string(si.si_status)));
1456 log_debug_unit(u->id,
1457 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1459 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1460 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1466 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1467 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1470 log_debug_unit(name, "Activating special unit %s", name);
1472 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1474 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1479 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1480 Manager *m = userdata;
1482 struct signalfd_siginfo sfsi;
1483 bool sigchld = false;
1486 assert(m->signal_fd == fd);
1488 if (revents != EPOLLIN) {
1489 log_warning("Got unexpected events from signal file descriptor.");
1494 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1495 if (n != sizeof(sfsi)) {
1500 if (errno == EINTR || errno == EAGAIN)
1506 if (sfsi.ssi_pid > 0) {
1507 _cleanup_free_ char *p = NULL;
1509 get_process_comm(sfsi.ssi_pid, &p);
1511 log_full(sfsi.ssi_signo == SIGCHLD ||
1512 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1513 ? LOG_DEBUG : LOG_INFO,
1514 "Received SIG%s from PID "PID_FMT" (%s).",
1515 signal_to_string(sfsi.ssi_signo),
1516 sfsi.ssi_pid, strna(p));
1518 log_full(sfsi.ssi_signo == SIGCHLD ||
1519 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1520 ? LOG_DEBUG : LOG_INFO,
1522 signal_to_string(sfsi.ssi_signo));
1524 switch (sfsi.ssi_signo) {
1531 if (m->running_as == SYSTEMD_SYSTEM) {
1532 /* This is for compatibility with the
1533 * original sysvinit */
1534 m->exit_code = MANAGER_REEXECUTE;
1541 if (m->running_as == SYSTEMD_SYSTEM) {
1542 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1546 /* Run the exit target if there is one, if not, just exit. */
1547 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1548 m->exit_code = MANAGER_EXIT;
1555 if (m->running_as == SYSTEMD_SYSTEM)
1556 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1558 /* This is a nop on non-init */
1562 if (m->running_as == SYSTEMD_SYSTEM)
1563 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1565 /* This is a nop on non-init */
1571 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1573 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1574 log_info("Trying to reconnect to bus...");
1578 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1579 log_info("Loading D-Bus service...");
1580 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1587 _cleanup_free_ char *dump = NULL;
1588 _cleanup_fclose_ FILE *f = NULL;
1591 f = open_memstream(&dump, &size);
1593 log_warning("Failed to allocate memory stream.");
1597 manager_dump_units(m, f, "\t");
1598 manager_dump_jobs(m, f, "\t");
1601 log_warning("Failed to write status stream");
1605 log_dump(LOG_INFO, dump);
1610 m->exit_code = MANAGER_RELOAD;
1615 /* Starting SIGRTMIN+0 */
1616 static const char * const target_table[] = {
1617 [0] = SPECIAL_DEFAULT_TARGET,
1618 [1] = SPECIAL_RESCUE_TARGET,
1619 [2] = SPECIAL_EMERGENCY_TARGET,
1620 [3] = SPECIAL_HALT_TARGET,
1621 [4] = SPECIAL_POWEROFF_TARGET,
1622 [5] = SPECIAL_REBOOT_TARGET,
1623 [6] = SPECIAL_KEXEC_TARGET
1626 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1627 static const ManagerExitCode code_table[] = {
1629 [1] = MANAGER_POWEROFF,
1630 [2] = MANAGER_REBOOT,
1634 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1635 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1636 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1637 manager_start_target(m, target_table[idx],
1638 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1642 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1643 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1644 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1648 switch (sfsi.ssi_signo - SIGRTMIN) {
1651 log_debug("Enabling showing of status.");
1652 manager_set_show_status(m, SHOW_STATUS_YES);
1656 log_debug("Disabling showing of status.");
1657 manager_set_show_status(m, SHOW_STATUS_NO);
1661 log_set_max_level(LOG_DEBUG);
1662 log_notice("Setting log level to debug.");
1666 log_set_max_level(LOG_INFO);
1667 log_notice("Setting log level to info.");
1671 if (m->running_as == SYSTEMD_USER) {
1672 m->exit_code = MANAGER_EXIT;
1676 /* This is a nop on init */
1680 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1681 log_notice("Setting log target to journal-or-kmsg.");
1685 log_set_target(LOG_TARGET_CONSOLE);
1686 log_notice("Setting log target to console.");
1690 log_set_target(LOG_TARGET_KMSG);
1691 log_notice("Setting log target to kmsg.");
1695 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1696 log_notice("Setting log target to syslog-or-kmsg.");
1700 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1707 manager_dispatch_sigchld(m);
1712 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1713 Manager *m = userdata;
1718 assert(m->time_change_fd == fd);
1720 log_struct(LOG_INFO,
1721 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1722 "MESSAGE=Time has been changed",
1725 /* Restart the watch */
1726 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1728 close_nointr_nofail(m->time_change_fd);
1729 m->time_change_fd = -1;
1731 manager_setup_time_change(m);
1733 HASHMAP_FOREACH(u, m->units, i)
1734 if (UNIT_VTABLE(u)->time_change)
1735 UNIT_VTABLE(u)->time_change(u);
1740 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1741 Manager *m = userdata;
1744 assert(m->idle_pipe[2] == fd);
1746 m->no_console_output = m->n_on_console > 0;
1748 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1749 manager_close_idle_pipe(m);
1754 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1755 Manager *m = userdata;
1762 manager_print_jobs_in_progress(m);
1764 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1765 r = sd_event_source_set_time(source, next);
1769 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1772 int manager_loop(Manager *m) {
1775 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1778 m->exit_code = MANAGER_RUNNING;
1780 /* Release the path cache */
1781 set_free_free(m->unit_path_cache);
1782 m->unit_path_cache = NULL;
1784 manager_check_finished(m);
1786 /* There might still be some zombies hanging around from
1787 * before we were exec()'ed. Let's reap them. */
1788 r = manager_dispatch_sigchld(m);
1792 while (m->exit_code == MANAGER_RUNNING) {
1795 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1798 if (!ratelimit_test(&rl)) {
1799 /* Yay, something is going seriously wrong, pause a little */
1800 log_warning("Looping too fast. Throttling execution a little.");
1805 if (manager_dispatch_load_queue(m) > 0)
1808 if (manager_dispatch_gc_queue(m) > 0)
1811 if (manager_dispatch_cleanup_queue(m) > 0)
1814 if (manager_dispatch_cgroup_queue(m) > 0)
1817 if (manager_dispatch_dbus_queue(m) > 0)
1820 /* Sleep for half the watchdog time */
1821 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1822 wait_usec = m->runtime_watchdog / 2;
1826 wait_usec = (usec_t) -1;
1828 r = sd_event_run(m->event, wait_usec);
1830 log_error("Failed to run event loop: %s", strerror(-r));
1835 return m->exit_code;
1838 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1839 _cleanup_free_ char *n = NULL;
1847 r = unit_name_from_dbus_path(s, &n);
1851 r = manager_load_unit(m, n, NULL, e, &u);
1860 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1870 p = startswith(s, "/org/freedesktop/systemd1/job/");
1874 r = safe_atou(p, &id);
1878 j = manager_get_job(m, id);
1887 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1893 audit_fd = get_audit_fd();
1897 /* Don't generate audit events if the service was already
1898 * started and we're just deserializing */
1899 if (m->n_reloading > 0)
1902 if (m->running_as != SYSTEMD_SYSTEM)
1905 if (u->type != UNIT_SERVICE)
1908 p = unit_name_to_prefix_and_instance(u->id);
1910 log_error_unit(u->id,
1911 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1915 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1916 if (errno == EPERM) {
1917 /* We aren't allowed to send audit messages?
1918 * Then let's not retry again. */
1921 log_warning("Failed to send audit message: %m");
1929 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1931 union sockaddr_union sa;
1933 char *message = NULL;
1935 /* Don't generate plymouth events if the service was already
1936 * started and we're just deserializing */
1937 if (m->n_reloading > 0)
1940 if (m->running_as != SYSTEMD_SYSTEM)
1943 if (detect_container(NULL) > 0)
1946 if (u->type != UNIT_SERVICE &&
1947 u->type != UNIT_MOUNT &&
1948 u->type != UNIT_SWAP)
1951 /* We set SOCK_NONBLOCK here so that we rather drop the
1952 * message then wait for plymouth */
1953 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1955 log_error("socket() failed: %m");
1960 sa.sa.sa_family = AF_UNIX;
1961 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1962 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1964 if (errno != EPIPE &&
1967 errno != ECONNREFUSED &&
1968 errno != ECONNRESET &&
1969 errno != ECONNABORTED)
1970 log_error("connect() failed: %m");
1975 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1981 if (write(fd, message, n + 1) != n + 1) {
1983 if (errno != EPIPE &&
1986 errno != ECONNREFUSED &&
1987 errno != ECONNRESET &&
1988 errno != ECONNABORTED)
1989 log_error("Failed to write Plymouth message: %m");
1996 close_nointr_nofail(fd);
2001 void manager_dispatch_bus_name_owner_changed(
2004 const char* old_owner,
2005 const char *new_owner) {
2012 u = hashmap_get(m->watch_bus, name);
2016 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2019 int manager_open_serialization(Manager *m, FILE **_f) {
2026 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2027 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2031 log_debug("Serializing state to %s", path);
2033 f = fdopen(fd, "w+");
2035 close_nointr_nofail(fd);
2044 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2057 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2058 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2059 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2060 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2062 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2063 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2064 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2065 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2068 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2069 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2070 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2071 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2072 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2073 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2074 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2075 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2078 if (!switching_root) {
2079 STRV_FOREACH(e, m->environment) {
2080 _cleanup_free_ char *ce;
2086 fprintf(f, "env=%s\n", *e);
2090 if (m->notify_fd >= 0) {
2093 copy = fdset_put_dup(fds, m->notify_fd);
2097 fprintf(f, "notify-fd=%i\n", copy);
2098 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2101 if (m->kdbus_fd >= 0) {
2104 copy = fdset_put_dup(fds, m->kdbus_fd);
2108 fprintf(f, "kdbus-fd=%i\n", copy);
2111 bus_serialize(m, f);
2115 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2119 if (!unit_can_serialize(u))
2126 r = unit_serialize(u, f, fds, !switching_root);
2133 assert(m->n_reloading > 0);
2139 r = bus_fdset_add_all(m, fds);
2146 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2152 log_debug("Deserializing state...");
2157 char line[LINE_MAX], *l;
2159 if (!fgets(line, sizeof(line), f)) {
2174 if (startswith(l, "current-job-id=")) {
2177 if (safe_atou32(l+15, &id) < 0)
2178 log_debug("Failed to parse current job id value %s", l+15);
2180 m->current_job_id = MAX(m->current_job_id, id);
2182 } else if (startswith(l, "n-installed-jobs=")) {
2185 if (safe_atou32(l+17, &n) < 0)
2186 log_debug("Failed to parse installed jobs counter %s", l+17);
2188 m->n_installed_jobs += n;
2190 } else if (startswith(l, "n-failed-jobs=")) {
2193 if (safe_atou32(l+14, &n) < 0)
2194 log_debug("Failed to parse failed jobs counter %s", l+14);
2196 m->n_failed_jobs += n;
2198 } else if (startswith(l, "taint-usr=")) {
2201 b = parse_boolean(l+10);
2203 log_debug("Failed to parse taint /usr flag %s", l+10);
2205 m->taint_usr = m->taint_usr || b;
2207 } else if (startswith(l, "firmware-timestamp="))
2208 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2209 else if (startswith(l, "loader-timestamp="))
2210 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2211 else if (startswith(l, "kernel-timestamp="))
2212 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2213 else if (startswith(l, "initrd-timestamp="))
2214 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2215 else if (startswith(l, "userspace-timestamp="))
2216 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2217 else if (startswith(l, "finish-timestamp="))
2218 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2219 else if (startswith(l, "security-start-timestamp="))
2220 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2221 else if (startswith(l, "security-finish-timestamp="))
2222 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2223 else if (startswith(l, "generators-start-timestamp="))
2224 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2225 else if (startswith(l, "generators-finish-timestamp="))
2226 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2227 else if (startswith(l, "units-load-start-timestamp="))
2228 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2229 else if (startswith(l, "units-load-finish-timestamp="))
2230 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2231 else if (startswith(l, "env=")) {
2232 _cleanup_free_ char *uce = NULL;
2235 uce = cunescape(l+4);
2241 e = strv_env_set(m->environment, uce);
2247 strv_free(m->environment);
2250 } else if (startswith(l, "notify-fd=")) {
2253 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2254 log_debug("Failed to parse notify fd: %s", l + 10);
2256 if (m->notify_fd >= 0) {
2257 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2258 close_nointr_nofail(m->notify_fd);
2261 m->notify_fd = fdset_remove(fds, fd);
2264 } else if (startswith(l, "notify-socket=")) {
2273 free(m->notify_socket);
2274 m->notify_socket = n;
2276 } else if (startswith(l, "kdbus-fd=")) {
2279 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2280 log_debug("Failed to parse kdbus fd: %s", l + 9);
2282 if (m->kdbus_fd >= 0)
2283 close_nointr_nofail(m->kdbus_fd);
2285 m->kdbus_fd = fdset_remove(fds, fd);
2288 } else if (bus_deserialize_item(m, l) == 0)
2289 log_debug("Unknown serialization item '%s'", l);
2294 char name[UNIT_NAME_MAX+2];
2297 if (!fgets(name, sizeof(name), f)) {
2308 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2312 r = unit_deserialize(u, f, fds);
2321 assert(m->n_reloading > 0);
2327 int manager_reload(Manager *m) {
2329 _cleanup_fclose_ FILE *f = NULL;
2330 _cleanup_fdset_free_ FDSet *fds = NULL;
2334 r = manager_open_serialization(m, &f);
2339 bus_manager_send_reloading(m, true);
2347 r = manager_serialize(m, f, fds, false);
2353 if (fseeko(f, 0, SEEK_SET) < 0) {
2358 /* From here on there is no way back. */
2359 manager_clear_jobs_and_units(m);
2360 manager_undo_generators(m);
2361 lookup_paths_free(&m->lookup_paths);
2363 /* Find new unit paths */
2364 manager_run_generators(m);
2366 q = lookup_paths_init(
2367 &m->lookup_paths, m->running_as, true,
2368 m->generator_unit_path,
2369 m->generator_unit_path_early,
2370 m->generator_unit_path_late);
2374 manager_build_unit_path_cache(m);
2376 /* First, enumerate what we can from all config files */
2377 q = manager_enumerate(m);
2381 /* Second, deserialize our stored data */
2382 q = manager_deserialize(m, f, fds);
2389 /* Re-register notify_fd as event source */
2390 q = manager_setup_notify(m);
2394 /* Third, fire things up! */
2395 q = manager_coldplug(m);
2399 assert(m->n_reloading > 0);
2402 m->send_reloading_done = true;
2407 static bool manager_is_booting_or_shutting_down(Manager *m) {
2412 /* Is the initial job still around? */
2413 if (manager_get_job(m, m->default_unit_job_id))
2416 /* Is there a job for the shutdown target? */
2417 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2424 bool manager_is_reloading_or_reexecuting(Manager *m) {
2427 return m->n_reloading != 0;
2430 void manager_reset_failed(Manager *m) {
2436 HASHMAP_FOREACH(u, m->units, i)
2437 unit_reset_failed(u);
2440 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2446 /* Returns true if the unit is inactive or going down */
2447 u = manager_get_unit(m, name);
2451 return unit_inactive_or_pending(u);
2454 void manager_check_finished(Manager *m) {
2455 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2456 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) {
2464 if (m->jobs_in_progress_event_source) {
2465 uint64_t next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
2466 sd_event_source_set_time(m->jobs_in_progress_event_source, next);
2471 manager_flip_auto_status(m, false);
2473 /* Notify Type=idle units that we are done now */
2474 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2475 manager_close_idle_pipe(m);
2477 /* Turn off confirm spawn now */
2478 m->confirm_spawn = false;
2480 if (dual_timestamp_is_set(&m->finish_timestamp))
2483 dual_timestamp_get(&m->finish_timestamp);
2485 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2487 /* Note that m->kernel_usec.monotonic is always at 0,
2488 * and m->firmware_usec.monotonic and
2489 * m->loader_usec.monotonic should be considered
2490 * negative values. */
2492 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2493 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2494 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2495 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2497 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2499 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2500 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2502 if (!log_on_console())
2503 log_struct(LOG_INFO,
2504 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2505 "KERNEL_USEC="USEC_FMT, kernel_usec,
2506 "INITRD_USEC="USEC_FMT, initrd_usec,
2507 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2508 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2509 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2510 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2511 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2512 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2515 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2518 if (!log_on_console())
2519 log_struct(LOG_INFO,
2520 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2521 "KERNEL_USEC="USEC_FMT, kernel_usec,
2522 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2523 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2524 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2525 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2526 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2530 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2531 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2533 if (!log_on_console())
2534 log_struct(LOG_INFO,
2535 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2536 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2537 "MESSAGE=Startup finished in %s.",
2538 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2542 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2545 "READY=1\nSTATUS=Startup finished in %s.",
2546 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2549 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2560 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2561 /* systemd --system, not running --test */
2563 p = strappend("/run/systemd/", name);
2567 r = mkdir_p_label(p, 0755);
2569 log_error("Failed to create generator directory %s: %s",
2574 } else if (m->running_as == SYSTEMD_USER) {
2575 const char *s = NULL;
2577 s = getenv("XDG_RUNTIME_DIR");
2580 p = strjoin(s, "/systemd/", name, NULL);
2584 r = mkdir_p_label(p, 0755);
2586 log_error("Failed to create generator directory %s: %s",
2592 /* systemd --system --test */
2594 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2599 log_error("Failed to create generator directory %s: %m",
2610 static void trim_generator_dir(Manager *m, char **generator) {
2617 if (rmdir(*generator) >= 0) {
2625 void manager_run_generators(Manager *m) {
2626 _cleanup_closedir_ DIR *d = NULL;
2627 const char *generator_path;
2628 const char *argv[5];
2633 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2634 d = opendir(generator_path);
2636 if (errno == ENOENT)
2639 log_error("Failed to enumerate generator directory %s: %m",
2644 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2648 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2652 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2656 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2657 argv[1] = m->generator_unit_path;
2658 argv[2] = m->generator_unit_path_early;
2659 argv[3] = m->generator_unit_path_late;
2662 RUN_WITH_UMASK(0022)
2663 execute_directory(generator_path, d, (char**) argv);
2666 trim_generator_dir(m, &m->generator_unit_path);
2667 trim_generator_dir(m, &m->generator_unit_path_early);
2668 trim_generator_dir(m, &m->generator_unit_path_late);
2671 static void remove_generator_dir(Manager *m, char **generator) {
2678 strv_remove(m->lookup_paths.unit_path, *generator);
2679 rm_rf(*generator, false, true, false);
2685 void manager_undo_generators(Manager *m) {
2688 remove_generator_dir(m, &m->generator_unit_path);
2689 remove_generator_dir(m, &m->generator_unit_path_early);
2690 remove_generator_dir(m, &m->generator_unit_path_late);
2693 int manager_environment_add(Manager *m, char **minus, char **plus) {
2694 char **a = NULL, **b = NULL, **l;
2699 if (!strv_isempty(minus)) {
2700 a = strv_env_delete(l, 1, minus);
2707 if (!strv_isempty(plus)) {
2708 b = strv_env_merge(2, l, plus);
2715 if (m->environment != l)
2716 strv_free(m->environment);
2723 manager_clean_environment(m);
2724 strv_sort(m->environment);
2729 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2734 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2735 if (!default_rlimit[i])
2738 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2746 void manager_recheck_journal(Manager *m) {
2751 if (m->running_as != SYSTEMD_SYSTEM)
2754 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2755 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2756 log_close_journal();
2760 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2761 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2762 log_close_journal();
2766 /* Hmm, OK, so the socket is fully up and the service is up
2767 * too, then let's make use of the thing. */
2771 void manager_set_show_status(Manager *m, ShowStatus mode) {
2773 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2775 if (m->running_as != SYSTEMD_SYSTEM)
2778 m->show_status = mode;
2781 touch("/run/systemd/show-status");
2783 unlink("/run/systemd/show-status");
2786 static bool manager_get_show_status(Manager *m) {
2789 if (m->running_as != SYSTEMD_SYSTEM)
2792 if (m->no_console_output)
2795 if (m->show_status > 0)
2798 /* If Plymouth is running make sure we show the status, so
2799 * that there's something nice to see when people press Esc */
2801 return plymouth_running();
2804 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2807 if (!manager_get_show_status(m))
2810 /* XXX We should totally drop the check for ephemeral here
2811 * and thus effectively make 'Type=idle' pointless. */
2812 if (ephemeral && m->n_on_console > 0)
2815 if (!manager_is_booting_or_shutting_down(m))
2818 va_start(ap, format);
2819 status_vprintf(status, true, ephemeral, format, ap);
2823 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2824 _cleanup_free_ char *p = NULL;
2832 p = unit_name_from_path(path, suffix);
2836 found = manager_get_unit(m, p);
2846 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2847 char p[strlen(path)+1];
2853 path_kill_slashes(p);
2855 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);