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, next, 0, manager_dispatch_jobs_in_progress, m, &m->jobs_in_progress_event_source);
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[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m, &m->idle_pipe_event_source);
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_fd, EPOLLIN, manager_dispatch_time_change_fd, m, &m->time_change_event_source);
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_fd, EPOLLIN, manager_dispatch_signal_fd, m, &m->signal_event_source);
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_pids, trivial_hash_func, trivial_compare_func);
454 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
458 r = sd_event_default(&m->event);
462 r = sd_event_add_defer(m->event, manager_dispatch_run_queue, m, &m->run_queue_event_source);
466 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
470 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
474 r = manager_setup_signals(m);
478 r = manager_setup_cgroup(m);
482 r = manager_setup_time_change(m);
486 m->udev = udev_new();
492 /* Note that we set up neither kdbus, nor the notify fd
493 * here. We do that after deserialization, since they might
494 * have gotten serialized across the reexec. */
496 m->taint_usr = dir_is_empty("/usr") > 0;
506 static int manager_setup_notify(Manager *m) {
509 struct sockaddr_un un;
511 .sa.sa_family = AF_UNIX,
515 if (m->notify_fd < 0) {
516 _cleanup_close_ int fd = -1;
518 /* First free all secondary fields */
519 free(m->notify_socket);
520 m->notify_socket = NULL;
521 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
523 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
525 log_error("Failed to allocate notification socket: %m");
529 if (getpid() != 1 || detect_container(NULL) > 0)
530 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%" PRIx64, random_u64());
532 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
533 sa.un.sun_path[0] = 0;
535 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
537 log_error("bind() failed: %m");
541 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
543 log_error("SO_PASSCRED failed: %m");
547 sa.un.sun_path[0] = '@';
548 m->notify_socket = strdup(sa.un.sun_path);
549 if (!m->notify_socket)
555 log_debug("Using notification socket %s", m->notify_socket);
558 if (!m->notify_event_source) {
559 r = sd_event_add_io(m->event, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m, &m->notify_event_source);
561 log_error("Failed to allocate notify event source: %s", strerror(-r));
565 /* Process signals a bit earlier than SIGCHLD, so that we can
566 * still identify to which service an exit message belongs */
567 r = sd_event_source_set_priority(m->notify_event_source, -7);
569 log_error("Failed to set priority of notify event source: %s", strerror(-r));
577 static int manager_setup_kdbus(Manager *m) {
579 _cleanup_free_ char *p = NULL;
585 if (m->kdbus_fd >= 0)
588 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
589 if (m->kdbus_fd < 0) {
590 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
594 log_debug("Successfully set up kdbus on %s", p);
596 /* Create the namespace directory here, so that the contents
597 * of that directory is not visible to non-root users. This is
598 * necessary to ensure that users cannot get access to busses
599 * of virtualized users when no UID namespacing is used. */
600 if (m->running_as == SYSTEMD_SYSTEM)
601 mkdir_p_label("/dev/kdbus/domain", 0700);
607 static int manager_connect_bus(Manager *m, bool reexecuting) {
608 bool try_bus_connect;
615 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
617 /* Try to connect to the busses, if possible. */
618 return bus_init(m, try_bus_connect);
621 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
627 while ((u = m->cleanup_queue)) {
628 assert(u->in_cleanup_queue);
638 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
639 GC_OFFSET_UNSURE, /* No clue */
640 GC_OFFSET_GOOD, /* We still need this unit */
641 GC_OFFSET_BAD, /* We don't need this unit anymore */
645 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
652 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
653 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
654 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
657 if (u->in_cleanup_queue)
660 if (unit_check_gc(u))
663 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
667 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
668 unit_gc_sweep(other, gc_marker);
670 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
673 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
680 /* We were unable to find anything out about this entry, so
681 * let's investigate it later */
682 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
683 unit_add_to_gc_queue(u);
687 /* We definitely know that this one is not useful anymore, so
688 * let's mark it for deletion */
689 u->gc_marker = gc_marker + GC_OFFSET_BAD;
690 unit_add_to_cleanup_queue(u);
694 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
697 static unsigned manager_dispatch_gc_queue(Manager *m) {
704 /* log_debug("Running GC..."); */
706 m->gc_marker += _GC_OFFSET_MAX;
707 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
710 gc_marker = m->gc_marker;
712 while ((u = m->gc_queue)) {
713 assert(u->in_gc_queue);
715 unit_gc_sweep(u, gc_marker);
717 LIST_REMOVE(gc_queue, m->gc_queue, u);
718 u->in_gc_queue = false;
722 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
723 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
724 log_debug_unit(u->id, "Collecting %s", u->id);
725 u->gc_marker = gc_marker + GC_OFFSET_BAD;
726 unit_add_to_cleanup_queue(u);
730 m->n_in_gc_queue = 0;
735 static void manager_clear_jobs_and_units(Manager *m) {
740 while ((u = hashmap_first(m->units)))
743 manager_dispatch_cleanup_queue(m);
745 assert(!m->load_queue);
746 assert(!m->run_queue);
747 assert(!m->dbus_unit_queue);
748 assert(!m->dbus_job_queue);
749 assert(!m->cleanup_queue);
750 assert(!m->gc_queue);
752 assert(hashmap_isempty(m->jobs));
753 assert(hashmap_isempty(m->units));
756 m->n_running_jobs = 0;
759 void manager_free(Manager *m) {
765 manager_clear_jobs_and_units(m);
767 for (c = 0; c < _UNIT_TYPE_MAX; c++)
768 if (unit_vtable[c]->shutdown)
769 unit_vtable[c]->shutdown(m);
771 /* If we reexecute ourselves, we keep the root cgroup
773 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
775 manager_undo_generators(m);
779 hashmap_free(m->units);
780 hashmap_free(m->jobs);
781 hashmap_free(m->watch_pids);
782 hashmap_free(m->watch_bus);
784 sd_event_source_unref(m->signal_event_source);
785 sd_event_source_unref(m->notify_event_source);
786 sd_event_source_unref(m->time_change_event_source);
787 sd_event_source_unref(m->jobs_in_progress_event_source);
788 sd_event_source_unref(m->idle_pipe_event_source);
789 sd_event_source_unref(m->run_queue_event_source);
791 if (m->signal_fd >= 0)
792 close_nointr_nofail(m->signal_fd);
793 if (m->notify_fd >= 0)
794 close_nointr_nofail(m->notify_fd);
795 if (m->time_change_fd >= 0)
796 close_nointr_nofail(m->time_change_fd);
797 if (m->kdbus_fd >= 0)
798 close_nointr_nofail(m->kdbus_fd);
800 manager_close_idle_pipe(m);
803 sd_event_unref(m->event);
805 free(m->notify_socket);
807 lookup_paths_free(&m->lookup_paths);
808 strv_free(m->environment);
810 hashmap_free(m->cgroup_unit);
811 set_free_free(m->unit_path_cache);
813 free(m->switch_root);
814 free(m->switch_root_init);
816 for (i = 0; i < RLIMIT_NLIMITS; i++)
819 assert(hashmap_isempty(m->units_requiring_mounts_for));
820 hashmap_free(m->units_requiring_mounts_for);
825 int manager_enumerate(Manager *m) {
831 /* Let's ask every type to load all units from disk/kernel
832 * that it might know */
833 for (c = 0; c < _UNIT_TYPE_MAX; c++)
834 if (unit_vtable[c]->enumerate) {
835 q = unit_vtable[c]->enumerate(m);
840 manager_dispatch_load_queue(m);
844 static int manager_coldplug(Manager *m) {
852 /* Then, let's set up their initial state. */
853 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
859 if ((q = unit_coldplug(u)) < 0)
866 static void manager_build_unit_path_cache(Manager *m) {
868 _cleanup_free_ DIR *d = NULL;
873 set_free_free(m->unit_path_cache);
875 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
876 if (!m->unit_path_cache) {
877 log_error("Failed to allocate unit path cache.");
881 /* This simply builds a list of files we know exist, so that
882 * we don't always have to go to disk */
884 STRV_FOREACH(i, m->lookup_paths.unit_path) {
890 log_error("Failed to open directory %s: %m", *i);
894 while ((de = readdir(d))) {
897 if (ignore_file(de->d_name))
900 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
906 r = set_consume(m->unit_path_cache, p);
918 log_error("Failed to build unit path cache: %s", strerror(-r));
920 set_free_free(m->unit_path_cache);
921 m->unit_path_cache = NULL;
925 static int manager_distribute_fds(Manager *m, FDSet *fds) {
932 HASHMAP_FOREACH(u, m->units, i) {
934 if (fdset_size(fds) <= 0)
937 if (UNIT_VTABLE(u)->distribute_fds) {
938 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
947 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
952 dual_timestamp_get(&m->generators_start_timestamp);
953 manager_run_generators(m);
954 dual_timestamp_get(&m->generators_finish_timestamp);
956 r = lookup_paths_init(
957 &m->lookup_paths, m->running_as, true,
958 m->generator_unit_path,
959 m->generator_unit_path_early,
960 m->generator_unit_path_late);
964 manager_build_unit_path_cache(m);
966 /* If we will deserialize make sure that during enumeration
967 * this is already known, so we increase the counter here
972 /* First, enumerate what we can from all config files */
973 dual_timestamp_get(&m->units_load_start_timestamp);
974 r = manager_enumerate(m);
975 dual_timestamp_get(&m->units_load_finish_timestamp);
977 /* Second, deserialize if there is something to deserialize */
979 q = manager_deserialize(m, serialization, fds);
984 /* Any fds left? Find some unit which wants them. This is
985 * useful to allow container managers to pass some file
986 * descriptors to us pre-initialized. This enables
987 * socket-based activation of entire containers. */
988 if (fdset_size(fds) > 0) {
989 q = manager_distribute_fds(m, fds);
994 /* We might have deserialized the notify fd, but if we didn't
995 * then let's create the bus now */
996 manager_setup_notify(m);
998 /* We might have deserialized the kdbus control fd, but if we
999 * didn't, then let's create the bus now. */
1000 manager_setup_kdbus(m);
1001 manager_connect_bus(m, !!serialization);
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 int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1323 Manager *m = userdata;
1327 assert(m->notify_fd == fd);
1329 if (revents != EPOLLIN) {
1330 log_warning("Got unexpected poll event for notify fd.");
1336 struct iovec iovec = {
1338 .iov_len = sizeof(buf)-1,
1342 struct cmsghdr cmsghdr;
1343 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1346 struct msghdr msghdr = {
1349 .msg_control = &control,
1350 .msg_controllen = sizeof(control),
1352 struct ucred *ucred;
1354 _cleanup_strv_free_ char **tags = NULL;
1356 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1361 if (errno == EAGAIN || errno == EINTR)
1367 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1368 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1369 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1370 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1371 log_warning("Received notify message without credentials. Ignoring.");
1375 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1377 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1379 u = manager_get_unit_by_pid(m, ucred->pid);
1381 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1386 assert((size_t) n < sizeof(buf));
1388 tags = strv_split(buf, "\n\r");
1392 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1394 if (UNIT_VTABLE(u)->notify_message)
1395 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1401 static int manager_dispatch_sigchld(Manager *m) {
1408 /* First we call waitd() for a PID and do not reap the
1409 * zombie. That way we can still access /proc/$PID for
1410 * it while it is a zombie. */
1411 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1413 if (errno == ECHILD)
1425 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1426 _cleanup_free_ char *name = NULL;
1428 get_process_comm(si.si_pid, &name);
1429 log_debug("Got SIGCHLD for process "PID_FMT" (%s)", si.si_pid, strna(name));
1432 /* And now figure out the unit this belongs to */
1433 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1435 u = manager_get_unit_by_pid(m, si.si_pid);
1437 /* And now, we actually reap the zombie. */
1438 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1445 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1448 log_debug("Child %lu died (code=%s, status=%i/%s)",
1449 (long unsigned) si.si_pid,
1450 sigchld_code_to_string(si.si_code),
1452 strna(si.si_code == CLD_EXITED
1453 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1454 : signal_to_string(si.si_status)));
1459 log_debug_unit(u->id,
1460 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1462 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1463 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1469 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1470 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1473 log_debug_unit(name, "Activating special unit %s", name);
1475 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1477 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1482 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1483 Manager *m = userdata;
1485 struct signalfd_siginfo sfsi;
1486 bool sigchld = false;
1489 assert(m->signal_fd == fd);
1491 if (revents != EPOLLIN) {
1492 log_warning("Got unexpected events from signal file descriptor.");
1497 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1498 if (n != sizeof(sfsi)) {
1503 if (errno == EINTR || errno == EAGAIN)
1509 if (sfsi.ssi_pid > 0) {
1510 _cleanup_free_ char *p = NULL;
1512 get_process_comm(sfsi.ssi_pid, &p);
1514 log_full(sfsi.ssi_signo == SIGCHLD ||
1515 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1516 ? LOG_DEBUG : LOG_INFO,
1517 "Received SIG%s from PID "PID_FMT" (%s).",
1518 signal_to_string(sfsi.ssi_signo),
1519 sfsi.ssi_pid, strna(p));
1521 log_full(sfsi.ssi_signo == SIGCHLD ||
1522 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1523 ? LOG_DEBUG : LOG_INFO,
1525 signal_to_string(sfsi.ssi_signo));
1527 switch (sfsi.ssi_signo) {
1534 if (m->running_as == SYSTEMD_SYSTEM) {
1535 /* This is for compatibility with the
1536 * original sysvinit */
1537 m->exit_code = MANAGER_REEXECUTE;
1544 if (m->running_as == SYSTEMD_SYSTEM) {
1545 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1549 /* Run the exit target if there is one, if not, just exit. */
1550 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1551 m->exit_code = MANAGER_EXIT;
1558 if (m->running_as == SYSTEMD_SYSTEM)
1559 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1561 /* This is a nop on non-init */
1565 if (m->running_as == SYSTEMD_SYSTEM)
1566 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1568 /* This is a nop on non-init */
1574 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1576 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1577 log_info("Trying to reconnect to bus...");
1581 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1582 log_info("Loading D-Bus service...");
1583 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1590 _cleanup_free_ char *dump = NULL;
1591 _cleanup_fclose_ FILE *f = NULL;
1594 f = open_memstream(&dump, &size);
1596 log_warning("Failed to allocate memory stream.");
1600 manager_dump_units(m, f, "\t");
1601 manager_dump_jobs(m, f, "\t");
1604 log_warning("Failed to write status stream");
1608 log_dump(LOG_INFO, dump);
1613 m->exit_code = MANAGER_RELOAD;
1618 /* Starting SIGRTMIN+0 */
1619 static const char * const target_table[] = {
1620 [0] = SPECIAL_DEFAULT_TARGET,
1621 [1] = SPECIAL_RESCUE_TARGET,
1622 [2] = SPECIAL_EMERGENCY_TARGET,
1623 [3] = SPECIAL_HALT_TARGET,
1624 [4] = SPECIAL_POWEROFF_TARGET,
1625 [5] = SPECIAL_REBOOT_TARGET,
1626 [6] = SPECIAL_KEXEC_TARGET
1629 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1630 static const ManagerExitCode code_table[] = {
1632 [1] = MANAGER_POWEROFF,
1633 [2] = MANAGER_REBOOT,
1637 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1638 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1639 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1640 manager_start_target(m, target_table[idx],
1641 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1645 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1646 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1647 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1651 switch (sfsi.ssi_signo - SIGRTMIN) {
1654 log_debug("Enabling showing of status.");
1655 manager_set_show_status(m, SHOW_STATUS_YES);
1659 log_debug("Disabling showing of status.");
1660 manager_set_show_status(m, SHOW_STATUS_NO);
1664 log_set_max_level(LOG_DEBUG);
1665 log_notice("Setting log level to debug.");
1669 log_set_max_level(LOG_INFO);
1670 log_notice("Setting log level to info.");
1674 if (m->running_as == SYSTEMD_USER) {
1675 m->exit_code = MANAGER_EXIT;
1679 /* This is a nop on init */
1683 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1684 log_notice("Setting log target to journal-or-kmsg.");
1688 log_set_target(LOG_TARGET_CONSOLE);
1689 log_notice("Setting log target to console.");
1693 log_set_target(LOG_TARGET_KMSG);
1694 log_notice("Setting log target to kmsg.");
1698 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1699 log_notice("Setting log target to syslog-or-kmsg.");
1703 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1710 manager_dispatch_sigchld(m);
1715 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1716 Manager *m = userdata;
1721 assert(m->time_change_fd == fd);
1723 log_struct(LOG_INFO,
1724 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1725 "MESSAGE=Time has been changed",
1728 /* Restart the watch */
1729 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1731 close_nointr_nofail(m->time_change_fd);
1732 m->time_change_fd = -1;
1734 manager_setup_time_change(m);
1736 HASHMAP_FOREACH(u, m->units, i)
1737 if (UNIT_VTABLE(u)->time_change)
1738 UNIT_VTABLE(u)->time_change(u);
1743 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1744 Manager *m = userdata;
1747 assert(m->idle_pipe[2] == fd);
1749 m->no_console_output = m->n_on_console > 0;
1751 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1752 manager_close_idle_pipe(m);
1757 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1758 Manager *m = userdata;
1765 manager_print_jobs_in_progress(m);
1767 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1768 r = sd_event_source_set_time(source, next);
1772 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1775 int manager_loop(Manager *m) {
1778 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1781 m->exit_code = MANAGER_RUNNING;
1783 /* Release the path cache */
1784 set_free_free(m->unit_path_cache);
1785 m->unit_path_cache = NULL;
1787 manager_check_finished(m);
1789 /* There might still be some zombies hanging around from
1790 * before we were exec()'ed. Let's reap them. */
1791 r = manager_dispatch_sigchld(m);
1795 while (m->exit_code == MANAGER_RUNNING) {
1798 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1801 if (!ratelimit_test(&rl)) {
1802 /* Yay, something is going seriously wrong, pause a little */
1803 log_warning("Looping too fast. Throttling execution a little.");
1808 if (manager_dispatch_load_queue(m) > 0)
1811 if (manager_dispatch_gc_queue(m) > 0)
1814 if (manager_dispatch_cleanup_queue(m) > 0)
1817 if (manager_dispatch_cgroup_queue(m) > 0)
1820 if (manager_dispatch_dbus_queue(m) > 0)
1823 /* Sleep for half the watchdog time */
1824 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1825 wait_usec = m->runtime_watchdog / 2;
1829 wait_usec = (usec_t) -1;
1831 r = sd_event_run(m->event, wait_usec);
1833 log_error("Failed to run event loop: %s", strerror(-r));
1838 return m->exit_code;
1841 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1842 _cleanup_free_ char *n = NULL;
1850 r = unit_name_from_dbus_path(s, &n);
1854 r = manager_load_unit(m, n, NULL, e, &u);
1863 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1873 p = startswith(s, "/org/freedesktop/systemd1/job/");
1877 r = safe_atou(p, &id);
1881 j = manager_get_job(m, id);
1890 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1896 audit_fd = get_audit_fd();
1900 /* Don't generate audit events if the service was already
1901 * started and we're just deserializing */
1902 if (m->n_reloading > 0)
1905 if (m->running_as != SYSTEMD_SYSTEM)
1908 if (u->type != UNIT_SERVICE)
1911 p = unit_name_to_prefix_and_instance(u->id);
1913 log_error_unit(u->id,
1914 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1918 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1919 if (errno == EPERM) {
1920 /* We aren't allowed to send audit messages?
1921 * Then let's not retry again. */
1924 log_warning("Failed to send audit message: %m");
1932 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1934 union sockaddr_union sa;
1936 char *message = NULL;
1938 /* Don't generate plymouth events if the service was already
1939 * started and we're just deserializing */
1940 if (m->n_reloading > 0)
1943 if (m->running_as != SYSTEMD_SYSTEM)
1946 if (detect_container(NULL) > 0)
1949 if (u->type != UNIT_SERVICE &&
1950 u->type != UNIT_MOUNT &&
1951 u->type != UNIT_SWAP)
1954 /* We set SOCK_NONBLOCK here so that we rather drop the
1955 * message then wait for plymouth */
1956 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1958 log_error("socket() failed: %m");
1963 sa.sa.sa_family = AF_UNIX;
1964 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1965 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1967 if (errno != EPIPE &&
1970 errno != ECONNREFUSED &&
1971 errno != ECONNRESET &&
1972 errno != ECONNABORTED)
1973 log_error("connect() failed: %m");
1978 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1984 if (write(fd, message, n + 1) != n + 1) {
1986 if (errno != EPIPE &&
1989 errno != ECONNREFUSED &&
1990 errno != ECONNRESET &&
1991 errno != ECONNABORTED)
1992 log_error("Failed to write Plymouth message: %m");
1999 close_nointr_nofail(fd);
2004 void manager_dispatch_bus_name_owner_changed(
2007 const char* old_owner,
2008 const char *new_owner) {
2015 u = hashmap_get(m->watch_bus, name);
2019 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2022 int manager_open_serialization(Manager *m, FILE **_f) {
2029 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2030 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2034 log_debug("Serializing state to %s", path);
2036 f = fdopen(fd, "w+");
2038 close_nointr_nofail(fd);
2047 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2060 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2061 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2062 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2063 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2065 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2066 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2067 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2068 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2071 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2072 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2073 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2074 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2075 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2076 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2077 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2078 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2081 if (!switching_root) {
2082 STRV_FOREACH(e, m->environment) {
2083 _cleanup_free_ char *ce;
2089 fprintf(f, "env=%s\n", *e);
2093 if (m->notify_fd >= 0) {
2096 copy = fdset_put_dup(fds, m->notify_fd);
2100 fprintf(f, "notify-fd=%i\n", copy);
2101 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2104 if (m->kdbus_fd >= 0) {
2107 copy = fdset_put_dup(fds, m->kdbus_fd);
2111 fprintf(f, "kdbus-fd=%i\n", copy);
2114 bus_serialize(m, f);
2118 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2122 if (!unit_can_serialize(u))
2129 r = unit_serialize(u, f, fds, !switching_root);
2136 assert(m->n_reloading > 0);
2142 r = bus_fdset_add_all(m, fds);
2149 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2155 log_debug("Deserializing state...");
2160 char line[LINE_MAX], *l;
2162 if (!fgets(line, sizeof(line), f)) {
2177 if (startswith(l, "current-job-id=")) {
2180 if (safe_atou32(l+15, &id) < 0)
2181 log_debug("Failed to parse current job id value %s", l+15);
2183 m->current_job_id = MAX(m->current_job_id, id);
2185 } else if (startswith(l, "n-installed-jobs=")) {
2188 if (safe_atou32(l+17, &n) < 0)
2189 log_debug("Failed to parse installed jobs counter %s", l+17);
2191 m->n_installed_jobs += n;
2193 } else if (startswith(l, "n-failed-jobs=")) {
2196 if (safe_atou32(l+14, &n) < 0)
2197 log_debug("Failed to parse failed jobs counter %s", l+14);
2199 m->n_failed_jobs += n;
2201 } else if (startswith(l, "taint-usr=")) {
2204 b = parse_boolean(l+10);
2206 log_debug("Failed to parse taint /usr flag %s", l+10);
2208 m->taint_usr = m->taint_usr || b;
2210 } else if (startswith(l, "firmware-timestamp="))
2211 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2212 else if (startswith(l, "loader-timestamp="))
2213 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2214 else if (startswith(l, "kernel-timestamp="))
2215 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2216 else if (startswith(l, "initrd-timestamp="))
2217 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2218 else if (startswith(l, "userspace-timestamp="))
2219 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2220 else if (startswith(l, "finish-timestamp="))
2221 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2222 else if (startswith(l, "security-start-timestamp="))
2223 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2224 else if (startswith(l, "security-finish-timestamp="))
2225 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2226 else if (startswith(l, "generators-start-timestamp="))
2227 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2228 else if (startswith(l, "generators-finish-timestamp="))
2229 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2230 else if (startswith(l, "units-load-start-timestamp="))
2231 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2232 else if (startswith(l, "units-load-finish-timestamp="))
2233 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2234 else if (startswith(l, "env=")) {
2235 _cleanup_free_ char *uce = NULL;
2238 uce = cunescape(l+4);
2244 e = strv_env_set(m->environment, uce);
2250 strv_free(m->environment);
2253 } else if (startswith(l, "notify-fd=")) {
2256 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2257 log_debug("Failed to parse notify fd: %s", l + 10);
2259 if (m->notify_fd >= 0) {
2260 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2261 close_nointr_nofail(m->notify_fd);
2264 m->notify_fd = fdset_remove(fds, fd);
2267 } else if (startswith(l, "notify-socket=")) {
2276 free(m->notify_socket);
2277 m->notify_socket = n;
2279 } else if (startswith(l, "kdbus-fd=")) {
2282 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2283 log_debug("Failed to parse kdbus fd: %s", l + 9);
2285 if (m->kdbus_fd >= 0)
2286 close_nointr_nofail(m->kdbus_fd);
2288 m->kdbus_fd = fdset_remove(fds, fd);
2291 } else if (bus_deserialize_item(m, l) == 0)
2292 log_debug("Unknown serialization item '%s'", l);
2297 char name[UNIT_NAME_MAX+2];
2300 if (!fgets(name, sizeof(name), f)) {
2311 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2315 r = unit_deserialize(u, f, fds);
2324 assert(m->n_reloading > 0);
2330 int manager_reload(Manager *m) {
2332 _cleanup_fclose_ FILE *f = NULL;
2333 _cleanup_fdset_free_ FDSet *fds = NULL;
2337 r = manager_open_serialization(m, &f);
2342 bus_manager_send_reloading(m, true);
2350 r = manager_serialize(m, f, fds, false);
2356 if (fseeko(f, 0, SEEK_SET) < 0) {
2361 /* From here on there is no way back. */
2362 manager_clear_jobs_and_units(m);
2363 manager_undo_generators(m);
2364 lookup_paths_free(&m->lookup_paths);
2366 /* Find new unit paths */
2367 manager_run_generators(m);
2369 q = lookup_paths_init(
2370 &m->lookup_paths, m->running_as, true,
2371 m->generator_unit_path,
2372 m->generator_unit_path_early,
2373 m->generator_unit_path_late);
2377 manager_build_unit_path_cache(m);
2379 /* First, enumerate what we can from all config files */
2380 q = manager_enumerate(m);
2384 /* Second, deserialize our stored data */
2385 q = manager_deserialize(m, f, fds);
2392 /* Re-register notify_fd as event source */
2393 q = manager_setup_notify(m);
2397 /* Third, fire things up! */
2398 q = manager_coldplug(m);
2402 assert(m->n_reloading > 0);
2405 m->send_reloading_done = true;
2410 static bool manager_is_booting_or_shutting_down(Manager *m) {
2415 /* Is the initial job still around? */
2416 if (manager_get_job(m, m->default_unit_job_id))
2419 /* Is there a job for the shutdown target? */
2420 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2427 bool manager_is_reloading_or_reexecuting(Manager *m) {
2430 return m->n_reloading != 0;
2433 void manager_reset_failed(Manager *m) {
2439 HASHMAP_FOREACH(u, m->units, i)
2440 unit_reset_failed(u);
2443 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2449 /* Returns true if the unit is inactive or going down */
2450 u = manager_get_unit(m, name);
2454 return unit_inactive_or_pending(u);
2457 void manager_check_finished(Manager *m) {
2458 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2459 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2463 if (m->n_running_jobs == 0)
2464 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2466 if (hashmap_size(m->jobs) > 0) {
2467 if (m->jobs_in_progress_event_source) {
2468 uint64_t next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
2469 sd_event_source_set_time(m->jobs_in_progress_event_source, next);
2474 manager_flip_auto_status(m, false);
2476 /* Notify Type=idle units that we are done now */
2477 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2478 manager_close_idle_pipe(m);
2480 /* Turn off confirm spawn now */
2481 m->confirm_spawn = false;
2483 if (dual_timestamp_is_set(&m->finish_timestamp))
2486 dual_timestamp_get(&m->finish_timestamp);
2488 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2490 /* Note that m->kernel_usec.monotonic is always at 0,
2491 * and m->firmware_usec.monotonic and
2492 * m->loader_usec.monotonic should be considered
2493 * negative values. */
2495 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2496 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2497 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2498 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2500 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2502 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2503 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2505 if (!log_on_console())
2506 log_struct(LOG_INFO,
2507 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2508 "KERNEL_USEC="USEC_FMT, kernel_usec,
2509 "INITRD_USEC="USEC_FMT, initrd_usec,
2510 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2511 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2512 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2513 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2514 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2515 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2518 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2521 if (!log_on_console())
2522 log_struct(LOG_INFO,
2523 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2524 "KERNEL_USEC="USEC_FMT, kernel_usec,
2525 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2526 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2527 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2528 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2529 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2533 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2534 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2536 if (!log_on_console())
2537 log_struct(LOG_INFO,
2538 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2539 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2540 "MESSAGE=Startup finished in %s.",
2541 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2545 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2548 "READY=1\nSTATUS=Startup finished in %s.",
2549 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2552 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2563 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2564 /* systemd --system, not running --test */
2566 p = strappend("/run/systemd/", name);
2570 r = mkdir_p_label(p, 0755);
2572 log_error("Failed to create generator directory %s: %s",
2577 } else if (m->running_as == SYSTEMD_USER) {
2578 const char *s = NULL;
2580 s = getenv("XDG_RUNTIME_DIR");
2583 p = strjoin(s, "/systemd/", name, NULL);
2587 r = mkdir_p_label(p, 0755);
2589 log_error("Failed to create generator directory %s: %s",
2595 /* systemd --system --test */
2597 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2602 log_error("Failed to create generator directory %s: %m",
2613 static void trim_generator_dir(Manager *m, char **generator) {
2620 if (rmdir(*generator) >= 0) {
2628 void manager_run_generators(Manager *m) {
2629 _cleanup_closedir_ DIR *d = NULL;
2630 const char *generator_path;
2631 const char *argv[5];
2636 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2637 d = opendir(generator_path);
2639 if (errno == ENOENT)
2642 log_error("Failed to enumerate generator directory %s: %m",
2647 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2651 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2655 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2659 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2660 argv[1] = m->generator_unit_path;
2661 argv[2] = m->generator_unit_path_early;
2662 argv[3] = m->generator_unit_path_late;
2665 RUN_WITH_UMASK(0022)
2666 execute_directory(generator_path, d, (char**) argv);
2669 trim_generator_dir(m, &m->generator_unit_path);
2670 trim_generator_dir(m, &m->generator_unit_path_early);
2671 trim_generator_dir(m, &m->generator_unit_path_late);
2674 static void remove_generator_dir(Manager *m, char **generator) {
2681 strv_remove(m->lookup_paths.unit_path, *generator);
2682 rm_rf(*generator, false, true, false);
2688 void manager_undo_generators(Manager *m) {
2691 remove_generator_dir(m, &m->generator_unit_path);
2692 remove_generator_dir(m, &m->generator_unit_path_early);
2693 remove_generator_dir(m, &m->generator_unit_path_late);
2696 int manager_environment_add(Manager *m, char **minus, char **plus) {
2697 char **a = NULL, **b = NULL, **l;
2702 if (!strv_isempty(minus)) {
2703 a = strv_env_delete(l, 1, minus);
2710 if (!strv_isempty(plus)) {
2711 b = strv_env_merge(2, l, plus);
2718 if (m->environment != l)
2719 strv_free(m->environment);
2726 manager_clean_environment(m);
2727 strv_sort(m->environment);
2732 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2737 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2738 if (!default_rlimit[i])
2741 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2749 void manager_recheck_journal(Manager *m) {
2754 if (m->running_as != SYSTEMD_SYSTEM)
2757 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2758 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2759 log_close_journal();
2763 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2764 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2765 log_close_journal();
2769 /* Hmm, OK, so the socket is fully up and the service is up
2770 * too, then let's make use of the thing. */
2774 void manager_set_show_status(Manager *m, ShowStatus mode) {
2776 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2778 if (m->running_as != SYSTEMD_SYSTEM)
2781 m->show_status = mode;
2784 touch("/run/systemd/show-status");
2786 unlink("/run/systemd/show-status");
2789 static bool manager_get_show_status(Manager *m) {
2792 if (m->running_as != SYSTEMD_SYSTEM)
2795 if (m->no_console_output)
2798 if (m->show_status > 0)
2801 /* If Plymouth is running make sure we show the status, so
2802 * that there's something nice to see when people press Esc */
2804 return plymouth_running();
2807 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2810 if (!manager_get_show_status(m))
2813 /* XXX We should totally drop the check for ephemeral here
2814 * and thus effectively make 'Type=idle' pointless. */
2815 if (ephemeral && m->n_on_console > 0)
2818 if (!manager_is_booting_or_shutting_down(m))
2821 va_start(ap, format);
2822 status_vprintf(status, true, ephemeral, format, ap);
2826 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2827 _cleanup_free_ char *p = NULL;
2835 p = unit_name_from_path(path, suffix);
2839 found = manager_get_unit(m, p);
2849 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2850 char p[strlen(path)+1];
2856 path_kill_slashes(p);
2858 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);