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/>.
27 #include <sys/inotify.h>
28 #include <sys/epoll.h>
29 #include <sys/reboot.h>
30 #include <sys/ioctl.h>
34 #include <sys/timerfd.h>
40 #include "sd-daemon.h"
41 #include "sd-messages.h"
44 #include "transaction.h"
51 #include "ratelimit.h"
52 #include "locale-setup.h"
53 #include "unit-name.h"
55 #include "path-lookup.h"
57 #include "exit-status.h"
60 #include "path-util.h"
62 #include "boot-timestamps.h"
64 #include "bus-common-errors.h"
65 #include "bus-error.h"
68 #include "dbus-unit.h"
70 #include "dbus-manager.h"
71 #include "bus-kernel.h"
72 #include "time-util.h"
74 /* Initial delay and the interval for printing status messages about running jobs */
75 #define JOBS_IN_PROGRESS_WAIT_USEC (5*USEC_PER_SEC)
76 #define JOBS_IN_PROGRESS_PERIOD_USEC (USEC_PER_SEC / 3)
77 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
79 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
80 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
81 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
82 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
83 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
84 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
85 static int manager_run_generators(Manager *m);
86 static void manager_undo_generators(Manager *m);
88 static int manager_watch_jobs_in_progress(Manager *m) {
93 if (m->jobs_in_progress_event_source)
96 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
97 return sd_event_add_time(
99 &m->jobs_in_progress_event_source,
102 manager_dispatch_jobs_in_progress, m);
105 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
107 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
110 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
111 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
115 p = mempset(p, ' ', pos-2);
116 p = stpcpy(p, ANSI_RED_ON);
120 if (pos > 0 && pos <= width) {
121 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
125 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
128 p = stpcpy(p, ANSI_RED_ON);
131 p = mempset(p, ' ', width-1-pos);
132 strcpy(p, ANSI_HIGHLIGHT_OFF);
136 void manager_flip_auto_status(Manager *m, bool enable) {
140 if (m->show_status == SHOW_STATUS_AUTO)
141 manager_set_show_status(m, SHOW_STATUS_TEMPORARY);
143 if (m->show_status == SHOW_STATUS_TEMPORARY)
144 manager_set_show_status(m, SHOW_STATUS_AUTO);
148 static void manager_print_jobs_in_progress(Manager *m) {
149 _cleanup_free_ char *job_of_n = NULL;
152 unsigned counter = 0, print_nr;
153 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
155 char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
159 assert(m->n_running_jobs > 0);
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 asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs);
184 format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
185 if (job_get_timeout(j, &x) > 0)
186 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
188 manager_status_printf(m, STATUS_TYPE_EPHEMERAL, cylon,
189 "%sA %s job is running for %s (%s / %s)",
191 job_type_to_string(j->type),
192 unit_description(j->unit),
196 static int have_ask_password(void) {
197 _cleanup_closedir_ DIR *dir;
199 dir = opendir("/run/systemd/ask-password");
212 if (!de && errno != 0)
217 if (startswith(de->d_name, "ask."))
222 static int manager_dispatch_ask_password_fd(sd_event_source *source,
223 int fd, uint32_t revents, void *userdata) {
224 Manager *m = userdata;
230 m->have_ask_password = have_ask_password();
231 if (m->have_ask_password < 0)
232 /* Log error but continue. Negative have_ask_password
233 * is treated as unknown status. */
234 log_error_errno(m->have_ask_password, "Failed to list /run/systemd/ask-password: %m");
239 static void manager_close_ask_password(Manager *m) {
242 m->ask_password_inotify_fd = safe_close(m->ask_password_inotify_fd);
243 m->ask_password_event_source = sd_event_source_unref(m->ask_password_event_source);
244 m->have_ask_password = -EINVAL;
247 static int manager_check_ask_password(Manager *m) {
252 if (!m->ask_password_event_source) {
253 assert(m->ask_password_inotify_fd < 0);
255 mkdir_p_label("/run/systemd/ask-password", 0755);
257 m->ask_password_inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
258 if (m->ask_password_inotify_fd < 0)
259 return log_error_errno(errno, "inotify_init1() failed: %m");
261 if (inotify_add_watch(m->ask_password_inotify_fd, "/run/systemd/ask-password", IN_CREATE|IN_DELETE|IN_MOVE) < 0) {
262 log_error_errno(errno, "Failed to add watch on /run/systemd/ask-password: %m");
263 manager_close_ask_password(m);
267 r = sd_event_add_io(m->event, &m->ask_password_event_source,
268 m->ask_password_inotify_fd, EPOLLIN,
269 manager_dispatch_ask_password_fd, m);
271 log_error_errno(errno, "Failed to add event source for /run/systemd/ask-password: %m");
272 manager_close_ask_password(m);
276 /* Queries might have been added meanwhile... */
277 manager_dispatch_ask_password_fd(m->ask_password_event_source,
278 m->ask_password_inotify_fd, EPOLLIN, m);
281 return m->have_ask_password;
284 static int manager_watch_idle_pipe(Manager *m) {
289 if (m->idle_pipe_event_source)
292 if (m->idle_pipe[2] < 0)
295 r = sd_event_add_io(m->event, &m->idle_pipe_event_source, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m);
297 return log_error_errno(r, "Failed to watch idle pipe: %m");
302 static void manager_close_idle_pipe(Manager *m) {
305 safe_close_pair(m->idle_pipe);
306 safe_close_pair(m->idle_pipe + 2);
309 static int manager_setup_time_change(Manager *m) {
312 /* We only care for the cancellation event, hence we set the
313 * timeout to the latest possible value. */
314 struct itimerspec its = {
315 .it_value.tv_sec = TIME_T_MAX,
319 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
324 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
325 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
327 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
328 if (m->time_change_fd < 0)
329 return log_error_errno(errno, "Failed to create timerfd: %m");
331 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
332 log_debug_errno(errno, "Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
333 m->time_change_fd = safe_close(m->time_change_fd);
337 r = sd_event_add_io(m->event, &m->time_change_event_source, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m);
339 return log_error_errno(r, "Failed to create time change event source: %m");
341 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
346 static int enable_special_signals(Manager *m) {
347 _cleanup_close_ int fd = -1;
351 /* Enable that we get SIGINT on control-alt-del. In containers
352 * this will fail with EPERM (older) or EINVAL (newer), so
354 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
355 log_warning_errno(errno, "Failed to enable ctrl-alt-del handling: %m");
357 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
359 /* Support systems without virtual console */
361 log_warning_errno(errno, "Failed to open /dev/tty0: %m");
363 /* Enable that we get SIGWINCH on kbrequest */
364 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
365 log_warning_errno(errno, "Failed to enable kbrequest handling: %m");
371 static int manager_setup_signals(Manager *m) {
372 struct sigaction sa = {
373 .sa_handler = SIG_DFL,
374 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
381 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
383 /* We make liberal use of realtime signals here. On
384 * Linux/glibc we have 30 of them (with the exception of Linux
385 * on hppa, see below), between SIGRTMIN+0 ... SIGRTMIN+30
388 assert_se(sigemptyset(&mask) == 0);
389 sigset_add_many(&mask,
390 SIGCHLD, /* Child died */
391 SIGTERM, /* Reexecute daemon */
392 SIGHUP, /* Reload configuration */
393 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
394 SIGUSR2, /* systemd: dump status */
395 SIGINT, /* Kernel sends us this on control-alt-del */
396 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
397 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
399 SIGRTMIN+0, /* systemd: start default.target */
400 SIGRTMIN+1, /* systemd: isolate rescue.target */
401 SIGRTMIN+2, /* systemd: isolate emergency.target */
402 SIGRTMIN+3, /* systemd: start halt.target */
403 SIGRTMIN+4, /* systemd: start poweroff.target */
404 SIGRTMIN+5, /* systemd: start reboot.target */
405 SIGRTMIN+6, /* systemd: start kexec.target */
407 /* ... space for more special targets ... */
409 SIGRTMIN+13, /* systemd: Immediate halt */
410 SIGRTMIN+14, /* systemd: Immediate poweroff */
411 SIGRTMIN+15, /* systemd: Immediate reboot */
412 SIGRTMIN+16, /* systemd: Immediate kexec */
414 /* ... space for more immediate system state changes ... */
416 SIGRTMIN+20, /* systemd: enable status messages */
417 SIGRTMIN+21, /* systemd: disable status messages */
418 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
419 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
420 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
422 /* .. one free signal here ... */
424 #if !defined(__hppa64__) && !defined(__hppa__)
425 /* Apparently Linux on hppa has fewer RT
426 * signals (SIGRTMAX is SIGRTMIN+25 there),
427 * hence let's not try to make use of them
428 * here. Since these commands are accessible
429 * by different means and only really a safety
430 * net, the missing functionality on hppa
431 * shouldn't matter. */
433 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
434 SIGRTMIN+27, /* systemd: set log target to console */
435 SIGRTMIN+28, /* systemd: set log target to kmsg */
436 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg (obsolete) */
438 /* ... one free signal here SIGRTMIN+30 ... */
441 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
443 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
444 if (m->signal_fd < 0)
447 r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);
451 /* Process signals a bit earlier than the rest of things, but
452 * later than notify_fd processing, so that the notify
453 * processing can still figure out to which process/service a
454 * message belongs, before we reap the process. */
455 r = sd_event_source_set_priority(m->signal_event_source, -5);
459 if (m->running_as == SYSTEMD_SYSTEM)
460 return enable_special_signals(m);
465 static void manager_clean_environment(Manager *m) {
468 /* Let's remove some environment variables that we
469 * need ourselves to communicate with our clients */
482 static int manager_default_environment(Manager *m) {
485 if (m->running_as == SYSTEMD_SYSTEM) {
486 /* The system manager always starts with a clean
487 * environment for its children. It does not import
488 * the kernel or the parents exported variables.
490 * The initial passed environ is untouched to keep
491 * /proc/self/environ valid; it is used for tagging
492 * the init process inside containers. */
493 m->environment = strv_new("PATH=" DEFAULT_PATH,
496 /* Import locale variables LC_*= from configuration */
497 locale_setup(&m->environment);
499 /* The user manager passes its own environment
500 * along to its children. */
501 m->environment = strv_copy(environ);
507 manager_clean_environment(m);
508 strv_sort(m->environment);
513 int manager_new(SystemdRunningAs running_as, bool test_run, Manager **_m) {
518 assert(running_as >= 0);
519 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
521 m = new0(Manager, 1);
526 if (running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0)
527 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
530 m->running_as = running_as;
531 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
532 m->default_timer_accuracy_usec = USEC_PER_MINUTE;
534 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
536 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 = m->utab_inotify_fd = -1;
537 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
539 m->ask_password_inotify_fd = -1;
540 m->have_ask_password = -EINVAL; /* we don't know */
542 m->test_run = test_run;
544 /* Reboot immediately if the user hits C-A-D more often than 7x per 2s */
545 RATELIMIT_INIT(m->ctrl_alt_del_ratelimit, 2 * USEC_PER_SEC, 7);
547 r = manager_default_environment(m);
551 r = hashmap_ensure_allocated(&m->units, &string_hash_ops);
555 r = hashmap_ensure_allocated(&m->jobs, NULL);
559 r = hashmap_ensure_allocated(&m->cgroup_unit, &string_hash_ops);
563 r = hashmap_ensure_allocated(&m->watch_bus, &string_hash_ops);
567 r = set_ensure_allocated(&m->startup_units, NULL);
571 r = set_ensure_allocated(&m->failed_units, NULL);
575 r = sd_event_default(&m->event);
579 r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
583 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
587 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
591 r = manager_setup_signals(m);
595 r = manager_setup_cgroup(m);
599 r = manager_setup_time_change(m);
603 m->udev = udev_new();
609 /* Note that we set up neither kdbus, nor the notify fd
610 * here. We do that after deserialization, since they might
611 * have gotten serialized across the reexec. */
613 m->taint_usr = dir_is_empty("/usr") > 0;
623 static int manager_setup_notify(Manager *m) {
629 if (m->notify_fd < 0) {
630 _cleanup_close_ int fd = -1;
631 union sockaddr_union sa = {
632 .sa.sa_family = AF_UNIX,
634 static const int one = 1;
636 /* First free all secondary fields */
637 free(m->notify_socket);
638 m->notify_socket = NULL;
639 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
641 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
643 return log_error_errno(errno, "Failed to allocate notification socket: %m");
645 if (m->running_as == SYSTEMD_SYSTEM)
646 m->notify_socket = strdup("/run/systemd/notify");
650 e = getenv("XDG_RUNTIME_DIR");
652 log_error_errno(errno, "XDG_RUNTIME_DIR is not set: %m");
656 m->notify_socket = strappend(e, "/systemd/notify");
658 if (!m->notify_socket)
661 (void) mkdir_parents_label(m->notify_socket, 0755);
662 (void) unlink(m->notify_socket);
664 strncpy(sa.un.sun_path, m->notify_socket, sizeof(sa.un.sun_path)-1);
665 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path));
667 return log_error_errno(errno, "bind(%s) failed: %m", sa.un.sun_path);
669 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
671 return log_error_errno(errno, "SO_PASSCRED failed: %m");
676 log_debug("Using notification socket %s", m->notify_socket);
679 if (!m->notify_event_source) {
680 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
682 return log_error_errno(r, "Failed to allocate notify event source: %m");
684 /* Process signals a bit earlier than SIGCHLD, so that we can
685 * still identify to which service an exit message belongs */
686 r = sd_event_source_set_priority(m->notify_event_source, -7);
688 return log_error_errno(r, "Failed to set priority of notify event source: %m");
694 static int manager_setup_kdbus(Manager *m) {
696 _cleanup_free_ char *p = NULL;
700 if (m->test_run || m->kdbus_fd >= 0)
703 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0)
704 bus_kernel_fix_attach_mask();
706 m->kdbus_fd = bus_kernel_create_bus(
707 m->running_as == SYSTEMD_SYSTEM ? "system" : "user",
708 m->running_as == SYSTEMD_SYSTEM, &p);
711 return log_debug_errno(m->kdbus_fd, "Failed to set up kdbus: %m");
713 log_debug("Successfully set up kdbus on %s", p);
719 static int manager_connect_bus(Manager *m, bool reexecuting) {
720 bool try_bus_connect;
730 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
732 /* Try to connect to the busses, if possible. */
733 return bus_init(m, try_bus_connect);
736 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
742 while ((u = m->cleanup_queue)) {
743 assert(u->in_cleanup_queue);
753 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
754 GC_OFFSET_UNSURE, /* No clue */
755 GC_OFFSET_GOOD, /* We still need this unit */
756 GC_OFFSET_BAD, /* We don't need this unit anymore */
760 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
767 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
768 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
769 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
772 if (u->in_cleanup_queue)
775 if (unit_check_gc(u))
778 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
782 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
783 unit_gc_sweep(other, gc_marker);
785 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
788 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
795 /* We were unable to find anything out about this entry, so
796 * let's investigate it later */
797 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
798 unit_add_to_gc_queue(u);
802 /* We definitely know that this one is not useful anymore, so
803 * let's mark it for deletion */
804 u->gc_marker = gc_marker + GC_OFFSET_BAD;
805 unit_add_to_cleanup_queue(u);
809 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
812 static unsigned manager_dispatch_gc_queue(Manager *m) {
819 /* log_debug("Running GC..."); */
821 m->gc_marker += _GC_OFFSET_MAX;
822 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
825 gc_marker = m->gc_marker;
827 while ((u = m->gc_queue)) {
828 assert(u->in_gc_queue);
830 unit_gc_sweep(u, gc_marker);
832 LIST_REMOVE(gc_queue, m->gc_queue, u);
833 u->in_gc_queue = false;
837 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
838 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
839 log_unit_debug(u->id, "Collecting %s", u->id);
840 u->gc_marker = gc_marker + GC_OFFSET_BAD;
841 unit_add_to_cleanup_queue(u);
845 m->n_in_gc_queue = 0;
850 static void manager_clear_jobs_and_units(Manager *m) {
855 while ((u = hashmap_first(m->units)))
858 manager_dispatch_cleanup_queue(m);
860 assert(!m->load_queue);
861 assert(!m->run_queue);
862 assert(!m->dbus_unit_queue);
863 assert(!m->dbus_job_queue);
864 assert(!m->cleanup_queue);
865 assert(!m->gc_queue);
867 assert(hashmap_isempty(m->jobs));
868 assert(hashmap_isempty(m->units));
871 m->n_running_jobs = 0;
874 Manager* manager_free(Manager *m) {
881 manager_clear_jobs_and_units(m);
883 for (c = 0; c < _UNIT_TYPE_MAX; c++)
884 if (unit_vtable[c]->shutdown)
885 unit_vtable[c]->shutdown(m);
887 /* If we reexecute ourselves, we keep the root cgroup
889 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
891 manager_undo_generators(m);
895 hashmap_free(m->units);
896 hashmap_free(m->jobs);
897 hashmap_free(m->watch_pids1);
898 hashmap_free(m->watch_pids2);
899 hashmap_free(m->watch_bus);
901 set_free(m->startup_units);
902 set_free(m->failed_units);
904 sd_event_source_unref(m->signal_event_source);
905 sd_event_source_unref(m->notify_event_source);
906 sd_event_source_unref(m->time_change_event_source);
907 sd_event_source_unref(m->jobs_in_progress_event_source);
908 sd_event_source_unref(m->idle_pipe_event_source);
909 sd_event_source_unref(m->run_queue_event_source);
911 safe_close(m->signal_fd);
912 safe_close(m->notify_fd);
913 safe_close(m->time_change_fd);
914 safe_close(m->kdbus_fd);
916 manager_close_ask_password(m);
918 manager_close_idle_pipe(m);
921 sd_event_unref(m->event);
923 free(m->notify_socket);
925 lookup_paths_free(&m->lookup_paths);
926 strv_free(m->environment);
928 hashmap_free(m->cgroup_unit);
929 set_free_free(m->unit_path_cache);
931 free(m->switch_root);
932 free(m->switch_root_init);
934 for (i = 0; i < _RLIMIT_MAX; i++)
937 assert(hashmap_isempty(m->units_requiring_mounts_for));
938 hashmap_free(m->units_requiring_mounts_for);
944 int manager_enumerate(Manager *m) {
950 /* Let's ask every type to load all units from disk/kernel
951 * that it might know */
952 for (c = 0; c < _UNIT_TYPE_MAX; c++) {
955 if (unit_vtable[c]->supported && !unit_vtable[c]->supported(m)) {
956 log_debug("Unit type .%s is not supported on this system.", unit_type_to_string(c));
960 if (!unit_vtable[c]->enumerate)
963 q = unit_vtable[c]->enumerate(m);
968 manager_dispatch_load_queue(m);
972 static int manager_coldplug(Manager *m) {
980 /* Then, let's set up their initial state. */
981 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
988 q = unit_coldplug(u);
996 static void manager_build_unit_path_cache(Manager *m) {
998 _cleanup_closedir_ DIR *d = NULL;
1003 set_free_free(m->unit_path_cache);
1005 m->unit_path_cache = set_new(&string_hash_ops);
1006 if (!m->unit_path_cache) {
1007 log_error("Failed to allocate unit path cache.");
1011 /* This simply builds a list of files we know exist, so that
1012 * we don't always have to go to disk */
1014 STRV_FOREACH(i, m->lookup_paths.unit_path) {
1019 if (errno != ENOENT)
1020 log_error_errno(errno, "Failed to open directory %s: %m", *i);
1024 while ((de = readdir(d))) {
1027 if (hidden_file(de->d_name))
1030 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
1036 r = set_consume(m->unit_path_cache, p);
1048 log_error_errno(r, "Failed to build unit path cache: %m");
1050 set_free_free(m->unit_path_cache);
1051 m->unit_path_cache = NULL;
1055 static int manager_distribute_fds(Manager *m, FDSet *fds) {
1062 HASHMAP_FOREACH(u, m->units, i) {
1064 if (fdset_size(fds) <= 0)
1067 if (UNIT_VTABLE(u)->distribute_fds) {
1068 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
1077 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
1082 dual_timestamp_get(&m->generators_start_timestamp);
1083 r = manager_run_generators(m);
1084 dual_timestamp_get(&m->generators_finish_timestamp);
1088 r = lookup_paths_init(
1089 &m->lookup_paths, m->running_as, true,
1091 m->generator_unit_path,
1092 m->generator_unit_path_early,
1093 m->generator_unit_path_late);
1097 manager_build_unit_path_cache(m);
1099 /* If we will deserialize make sure that during enumeration
1100 * this is already known, so we increase the counter here
1105 /* First, enumerate what we can from all config files */
1106 dual_timestamp_get(&m->units_load_start_timestamp);
1107 r = manager_enumerate(m);
1108 dual_timestamp_get(&m->units_load_finish_timestamp);
1110 /* Second, deserialize if there is something to deserialize */
1112 r = manager_deserialize(m, serialization, fds);
1114 /* Any fds left? Find some unit which wants them. This is
1115 * useful to allow container managers to pass some file
1116 * descriptors to us pre-initialized. This enables
1117 * socket-based activation of entire containers. */
1118 if (fdset_size(fds) > 0) {
1119 q = manager_distribute_fds(m, fds);
1120 if (q < 0 && r == 0)
1124 /* We might have deserialized the notify fd, but if we didn't
1125 * then let's create the bus now */
1126 q = manager_setup_notify(m);
1127 if (q < 0 && r == 0)
1130 /* We might have deserialized the kdbus control fd, but if we
1131 * didn't, then let's create the bus now. */
1132 manager_setup_kdbus(m);
1133 manager_connect_bus(m, !!serialization);
1134 bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
1136 /* Third, fire things up! */
1137 q = manager_coldplug(m);
1138 if (q < 0 && r == 0)
1141 if (serialization) {
1142 assert(m->n_reloading > 0);
1145 /* Let's wait for the UnitNew/JobNew messages being
1146 * sent, before we notify that the reload is
1148 m->send_reloading_done = true;
1154 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1159 assert(type < _JOB_TYPE_MAX);
1161 assert(mode < _JOB_MODE_MAX);
1163 if (mode == JOB_ISOLATE && type != JOB_START)
1164 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1166 if (mode == JOB_ISOLATE && !unit->allow_isolate)
1167 return sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1169 log_unit_debug(unit->id,
1170 "Trying to enqueue job %s/%s/%s", unit->id,
1171 job_type_to_string(type), job_mode_to_string(mode));
1173 job_type_collapse(&type, unit);
1175 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1179 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1180 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1181 mode == JOB_IGNORE_DEPENDENCIES, e);
1185 if (mode == JOB_ISOLATE) {
1186 r = transaction_add_isolate_jobs(tr, m);
1191 r = transaction_activate(tr, m, mode, e);
1195 log_unit_debug(unit->id,
1196 "Enqueued job %s/%s as %u", unit->id,
1197 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1200 *_ret = tr->anchor_job;
1202 transaction_free(tr);
1206 transaction_abort(tr);
1207 transaction_free(tr);
1211 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1216 assert(type < _JOB_TYPE_MAX);
1218 assert(mode < _JOB_MODE_MAX);
1220 r = manager_load_unit(m, name, NULL, NULL, &unit);
1224 return manager_add_job(m, type, unit, mode, override, e, _ret);
1227 Job *manager_get_job(Manager *m, uint32_t id) {
1230 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1233 Unit *manager_get_unit(Manager *m, const char *name) {
1237 return hashmap_get(m->units, name);
1240 unsigned manager_dispatch_load_queue(Manager *m) {
1246 /* Make sure we are not run recursively */
1247 if (m->dispatching_load_queue)
1250 m->dispatching_load_queue = true;
1252 /* Dispatches the load queue. Takes a unit from the queue and
1253 * tries to load its data until the queue is empty */
1255 while ((u = m->load_queue)) {
1256 assert(u->in_load_queue);
1262 m->dispatching_load_queue = false;
1266 int manager_load_unit_prepare(
1278 assert(name || path);
1280 /* This will prepare the unit for loading, but not actually
1281 * load anything from disk. */
1283 if (path && !is_path(path))
1284 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1287 name = basename(path);
1289 t = unit_name_to_type(name);
1291 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1292 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1294 ret = manager_get_unit(m, name);
1300 ret = unit_new(m, unit_vtable[t]->object_size);
1305 ret->fragment_path = strdup(path);
1306 if (!ret->fragment_path) {
1312 r = unit_add_name(ret, name);
1318 unit_add_to_load_queue(ret);
1319 unit_add_to_dbus_queue(ret);
1320 unit_add_to_gc_queue(ret);
1328 int manager_load_unit(
1339 /* This will load the service information files, but not actually
1340 * start any services or anything. */
1342 r = manager_load_unit_prepare(m, name, path, e, _ret);
1346 manager_dispatch_load_queue(m);
1349 *_ret = unit_follow_merge(*_ret);
1354 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1361 HASHMAP_FOREACH(j, s->jobs, i)
1362 job_dump(j, f, prefix);
1365 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1373 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1375 unit_dump(u, f, prefix);
1378 void manager_clear_jobs(Manager *m) {
1383 while ((j = hashmap_first(m->jobs)))
1384 /* No need to recurse. We're cancelling all jobs. */
1385 job_finish_and_invalidate(j, JOB_CANCELED, false);
1388 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1389 Manager *m = userdata;
1395 while ((j = m->run_queue)) {
1396 assert(j->installed);
1397 assert(j->in_run_queue);
1399 job_run_and_invalidate(j);
1402 if (m->n_running_jobs > 0)
1403 manager_watch_jobs_in_progress(m);
1405 if (m->n_on_console > 0)
1406 manager_watch_idle_pipe(m);
1411 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1418 if (m->dispatching_dbus_queue)
1421 m->dispatching_dbus_queue = true;
1423 while ((u = m->dbus_unit_queue)) {
1424 assert(u->in_dbus_queue);
1426 bus_unit_send_change_signal(u);
1430 while ((j = m->dbus_job_queue)) {
1431 assert(j->in_dbus_queue);
1433 bus_job_send_change_signal(j);
1437 m->dispatching_dbus_queue = false;
1439 if (m->send_reloading_done) {
1440 m->send_reloading_done = false;
1442 bus_manager_send_reloading(m, false);
1445 if (m->queued_message)
1446 bus_send_queued_message(m);
1451 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n, FDSet *fds) {
1452 _cleanup_strv_free_ char **tags = NULL;
1459 tags = strv_split(buf, "\n\r");
1465 log_unit_debug(u->id, "Got notification message for unit %s", u->id);
1467 if (UNIT_VTABLE(u)->notify_message)
1468 UNIT_VTABLE(u)->notify_message(u, pid, tags, fds);
1471 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1472 Manager *m = userdata;
1477 assert(m->notify_fd == fd);
1479 if (revents != EPOLLIN) {
1480 log_warning("Got unexpected poll event for notify fd.");
1485 _cleanup_fdset_free_ FDSet *fds = NULL;
1486 char buf[NOTIFY_BUFFER_MAX+1];
1487 struct iovec iovec = {
1489 .iov_len = sizeof(buf)-1,
1492 struct cmsghdr cmsghdr;
1493 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
1494 CMSG_SPACE(sizeof(int) * NOTIFY_FD_MAX)];
1496 struct msghdr msghdr = {
1499 .msg_control = &control,
1500 .msg_controllen = sizeof(control),
1502 struct cmsghdr *cmsg;
1503 struct ucred *ucred = NULL;
1506 int *fd_array = NULL;
1509 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
1511 if (errno == EAGAIN || errno == EINTR)
1517 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
1518 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
1520 fd_array = (int*) CMSG_DATA(cmsg);
1521 n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1523 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1524 cmsg->cmsg_type == SCM_CREDENTIALS &&
1525 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
1527 ucred = (struct ucred*) CMSG_DATA(cmsg);
1534 r = fdset_new_array(&fds, fd_array, n_fds);
1536 close_many(fd_array, n_fds);
1541 if (!ucred || ucred->pid <= 0) {
1542 log_warning("Received notify message without valid credentials. Ignoring.");
1546 if ((size_t) n >= sizeof(buf)) {
1547 log_warning("Received notify message exceeded maximum size. Ignoring.");
1553 /* Notify every unit that might be interested, but try
1554 * to avoid notifying the same one multiple times. */
1555 u1 = manager_get_unit_by_pid(m, ucred->pid);
1557 manager_invoke_notify_message(m, u1, ucred->pid, buf, n, fds);
1561 u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1562 if (u2 && u2 != u1) {
1563 manager_invoke_notify_message(m, u2, ucred->pid, buf, n, fds);
1567 u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1568 if (u3 && u3 != u2 && u3 != u1) {
1569 manager_invoke_notify_message(m, u3, ucred->pid, buf, n, fds);
1574 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1576 if (fdset_size(fds) > 0)
1577 log_warning("Got auxiliary fds with notification message, closing all.");
1583 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1588 log_unit_debug(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1590 unit_unwatch_pid(u, si->si_pid);
1591 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1594 static int manager_dispatch_sigchld(Manager *m) {
1600 /* First we call waitd() for a PID and do not reap the
1601 * zombie. That way we can still access /proc/$PID for
1602 * it while it is a zombie. */
1603 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1605 if (errno == ECHILD)
1617 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1618 _cleanup_free_ char *name = NULL;
1621 get_process_comm(si.si_pid, &name);
1623 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1624 si.si_pid, strna(name),
1625 sigchld_code_to_string(si.si_code),
1627 strna(si.si_code == CLD_EXITED
1628 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1629 : signal_to_string(si.si_status)));
1631 /* And now figure out the unit this belongs
1632 * to, it might be multiple... */
1633 u1 = manager_get_unit_by_pid(m, si.si_pid);
1635 invoke_sigchld_event(m, u1, &si);
1636 u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1638 invoke_sigchld_event(m, u2, &si);
1639 u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1640 if (u3 && u3 != u2 && u3 != u1)
1641 invoke_sigchld_event(m, u3, &si);
1644 /* And now, we actually reap the zombie. */
1645 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1656 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1657 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1660 log_unit_debug(name, "Activating special unit %s", name);
1662 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1664 log_unit_error(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1669 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1670 Manager *m = userdata;
1672 struct signalfd_siginfo sfsi;
1673 bool sigchld = false;
1676 assert(m->signal_fd == fd);
1678 if (revents != EPOLLIN) {
1679 log_warning("Got unexpected events from signal file descriptor.");
1684 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1685 if (n != sizeof(sfsi)) {
1690 if (errno == EINTR || errno == EAGAIN)
1696 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1697 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1698 ? LOG_DEBUG : LOG_INFO,
1701 switch (sfsi.ssi_signo) {
1708 if (m->running_as == SYSTEMD_SYSTEM) {
1709 /* This is for compatibility with the
1710 * original sysvinit */
1711 m->exit_code = MANAGER_REEXECUTE;
1718 if (m->running_as == SYSTEMD_SYSTEM) {
1720 /* If the user presses C-A-D more than
1721 * 7 times within 2s, we reboot
1724 if (ratelimit_test(&m->ctrl_alt_del_ratelimit))
1725 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1727 log_notice("Ctrl-Alt-Del was pressed more than 7 times within 2s, rebooting immediately.");
1728 status_printf(NULL, true, false, "Ctrl-Alt-Del was pressed more than 7 times within 2s, rebooting immediately.");
1729 m->exit_code = MANAGER_REBOOT;
1735 /* Run the exit target if there is one, if not, just exit. */
1736 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1737 m->exit_code = MANAGER_EXIT;
1744 if (m->running_as == SYSTEMD_SYSTEM)
1745 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1747 /* This is a nop on non-init */
1751 if (m->running_as == SYSTEMD_SYSTEM)
1752 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1754 /* This is a nop on non-init */
1760 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1762 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1763 log_info("Trying to reconnect to bus...");
1767 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1768 log_info("Loading D-Bus service...");
1769 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1776 _cleanup_free_ char *dump = NULL;
1777 _cleanup_fclose_ FILE *f = NULL;
1780 f = open_memstream(&dump, &size);
1782 log_warning("Failed to allocate memory stream.");
1786 manager_dump_units(m, f, "\t");
1787 manager_dump_jobs(m, f, "\t");
1790 log_warning("Failed to write status stream");
1795 log_warning("Failed to flush status stream");
1799 log_dump(LOG_INFO, dump);
1804 m->exit_code = MANAGER_RELOAD;
1809 /* Starting SIGRTMIN+0 */
1810 static const char * const target_table[] = {
1811 [0] = SPECIAL_DEFAULT_TARGET,
1812 [1] = SPECIAL_RESCUE_TARGET,
1813 [2] = SPECIAL_EMERGENCY_TARGET,
1814 [3] = SPECIAL_HALT_TARGET,
1815 [4] = SPECIAL_POWEROFF_TARGET,
1816 [5] = SPECIAL_REBOOT_TARGET,
1817 [6] = SPECIAL_KEXEC_TARGET
1820 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1821 static const ManagerExitCode code_table[] = {
1823 [1] = MANAGER_POWEROFF,
1824 [2] = MANAGER_REBOOT,
1828 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1829 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1830 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1831 manager_start_target(m, target_table[idx],
1832 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1836 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1837 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1838 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1842 switch (sfsi.ssi_signo - SIGRTMIN) {
1845 log_debug("Enabling showing of status.");
1846 manager_set_show_status(m, SHOW_STATUS_YES);
1850 log_debug("Disabling showing of status.");
1851 manager_set_show_status(m, SHOW_STATUS_NO);
1855 log_set_max_level(LOG_DEBUG);
1856 log_notice("Setting log level to debug.");
1860 log_set_max_level(LOG_INFO);
1861 log_notice("Setting log level to info.");
1865 if (m->running_as == SYSTEMD_USER) {
1866 m->exit_code = MANAGER_EXIT;
1870 /* This is a nop on init */
1874 case 29: /* compatibility: used to be mapped to LOG_TARGET_SYSLOG_OR_KMSG */
1875 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1876 log_notice("Setting log target to journal-or-kmsg.");
1880 log_set_target(LOG_TARGET_CONSOLE);
1881 log_notice("Setting log target to console.");
1885 log_set_target(LOG_TARGET_KMSG);
1886 log_notice("Setting log target to kmsg.");
1890 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1897 manager_dispatch_sigchld(m);
1902 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1903 Manager *m = userdata;
1908 assert(m->time_change_fd == fd);
1910 log_struct(LOG_INFO,
1911 LOG_MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1912 LOG_MESSAGE("Time has been changed"),
1915 /* Restart the watch */
1916 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1917 m->time_change_fd = safe_close(m->time_change_fd);
1919 manager_setup_time_change(m);
1921 HASHMAP_FOREACH(u, m->units, i)
1922 if (UNIT_VTABLE(u)->time_change)
1923 UNIT_VTABLE(u)->time_change(u);
1928 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1929 Manager *m = userdata;
1932 assert(m->idle_pipe[2] == fd);
1934 m->no_console_output = m->n_on_console > 0;
1936 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1937 manager_close_idle_pipe(m);
1942 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1943 Manager *m = userdata;
1950 manager_print_jobs_in_progress(m);
1952 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1953 r = sd_event_source_set_time(source, next);
1957 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1960 int manager_loop(Manager *m) {
1963 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1966 m->exit_code = MANAGER_OK;
1968 /* Release the path cache */
1969 set_free_free(m->unit_path_cache);
1970 m->unit_path_cache = NULL;
1972 manager_check_finished(m);
1974 /* There might still be some zombies hanging around from
1975 * before we were exec()'ed. Let's reap them. */
1976 r = manager_dispatch_sigchld(m);
1980 while (m->exit_code == MANAGER_OK) {
1983 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1986 if (!ratelimit_test(&rl)) {
1987 /* Yay, something is going seriously wrong, pause a little */
1988 log_warning("Looping too fast. Throttling execution a little.");
1993 if (manager_dispatch_load_queue(m) > 0)
1996 if (manager_dispatch_gc_queue(m) > 0)
1999 if (manager_dispatch_cleanup_queue(m) > 0)
2002 if (manager_dispatch_cgroup_queue(m) > 0)
2005 if (manager_dispatch_dbus_queue(m) > 0)
2008 /* Sleep for half the watchdog time */
2009 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
2010 wait_usec = m->runtime_watchdog / 2;
2014 wait_usec = USEC_INFINITY;
2016 r = sd_event_run(m->event, wait_usec);
2018 return log_error_errno(r, "Failed to run event loop: %m");
2021 return m->exit_code;
2024 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
2025 _cleanup_free_ char *n = NULL;
2033 r = unit_name_from_dbus_path(s, &n);
2037 r = manager_load_unit(m, n, NULL, e, &u);
2046 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
2056 p = startswith(s, "/org/freedesktop/systemd1/job/");
2060 r = safe_atou(p, &id);
2064 j = manager_get_job(m, id);
2073 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
2076 _cleanup_free_ char *p = NULL;
2080 audit_fd = get_audit_fd();
2084 /* Don't generate audit events if the service was already
2085 * started and we're just deserializing */
2086 if (m->n_reloading > 0)
2089 if (m->running_as != SYSTEMD_SYSTEM)
2092 if (u->type != UNIT_SERVICE)
2095 p = unit_name_to_prefix_and_instance(u->id);
2101 msg = strjoina("unit=", p);
2102 if (audit_log_user_comm_message(audit_fd, type, msg, "systemd", NULL, NULL, NULL, success) < 0) {
2104 /* We aren't allowed to send audit messages?
2105 * Then let's not retry again. */
2108 log_warning_errno(errno, "Failed to send audit message: %m");
2114 void manager_send_unit_plymouth(Manager *m, Unit *u) {
2115 union sockaddr_union sa = PLYMOUTH_SOCKET;
2118 _cleanup_free_ char *message = NULL;
2119 _cleanup_close_ int fd = -1;
2121 /* Don't generate plymouth events if the service was already
2122 * started and we're just deserializing */
2123 if (m->n_reloading > 0)
2126 if (m->running_as != SYSTEMD_SYSTEM)
2129 if (detect_container(NULL) > 0)
2132 if (u->type != UNIT_SERVICE &&
2133 u->type != UNIT_MOUNT &&
2134 u->type != UNIT_SWAP)
2137 /* We set SOCK_NONBLOCK here so that we rather drop the
2138 * message then wait for plymouth */
2139 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2141 log_error_errno(errno, "socket() failed: %m");
2145 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2147 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2148 log_error_errno(errno, "connect() failed: %m");
2152 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2158 if (write(fd, message, n + 1) != n + 1)
2159 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2160 log_error_errno(errno, "Failed to write Plymouth message: %m");
2163 void manager_dispatch_bus_name_owner_changed(
2166 const char* old_owner,
2167 const char *new_owner) {
2174 u = hashmap_get(m->watch_bus, name);
2178 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2181 int manager_open_serialization(Manager *m, FILE **_f) {
2188 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2189 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2193 log_debug("Serializing state to %s", path);
2195 f = fdopen(fd, "w+");
2206 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2219 fprintf(f, "current-job-id=%"PRIu32"\n", m->current_job_id);
2220 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2221 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2222 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2224 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2225 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2226 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2227 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2230 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2231 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2232 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2233 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2234 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2235 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2236 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2237 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2240 if (!switching_root) {
2241 STRV_FOREACH(e, m->environment) {
2242 _cleanup_free_ char *ce;
2248 fprintf(f, "env=%s\n", *e);
2252 if (m->notify_fd >= 0) {
2255 copy = fdset_put_dup(fds, m->notify_fd);
2259 fprintf(f, "notify-fd=%i\n", copy);
2260 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2263 if (m->kdbus_fd >= 0) {
2266 copy = fdset_put_dup(fds, m->kdbus_fd);
2270 fprintf(f, "kdbus-fd=%i\n", copy);
2273 bus_track_serialize(m->subscribed, f);
2277 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2285 r = unit_serialize(u, f, fds, !switching_root);
2292 assert(m->n_reloading > 0);
2298 r = bus_fdset_add_all(m, fds);
2305 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2311 log_debug("Deserializing state...");
2316 char line[LINE_MAX], *l;
2318 if (!fgets(line, sizeof(line), f)) {
2333 if (startswith(l, "current-job-id=")) {
2336 if (safe_atou32(l+15, &id) < 0)
2337 log_debug("Failed to parse current job id value %s", l+15);
2339 m->current_job_id = MAX(m->current_job_id, id);
2341 } else if (startswith(l, "n-installed-jobs=")) {
2344 if (safe_atou32(l+17, &n) < 0)
2345 log_debug("Failed to parse installed jobs counter %s", l+17);
2347 m->n_installed_jobs += n;
2349 } else if (startswith(l, "n-failed-jobs=")) {
2352 if (safe_atou32(l+14, &n) < 0)
2353 log_debug("Failed to parse failed jobs counter %s", l+14);
2355 m->n_failed_jobs += n;
2357 } else if (startswith(l, "taint-usr=")) {
2360 b = parse_boolean(l+10);
2362 log_debug("Failed to parse taint /usr flag %s", l+10);
2364 m->taint_usr = m->taint_usr || b;
2366 } else if (startswith(l, "firmware-timestamp="))
2367 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2368 else if (startswith(l, "loader-timestamp="))
2369 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2370 else if (startswith(l, "kernel-timestamp="))
2371 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2372 else if (startswith(l, "initrd-timestamp="))
2373 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2374 else if (startswith(l, "userspace-timestamp="))
2375 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2376 else if (startswith(l, "finish-timestamp="))
2377 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2378 else if (startswith(l, "security-start-timestamp="))
2379 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2380 else if (startswith(l, "security-finish-timestamp="))
2381 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2382 else if (startswith(l, "generators-start-timestamp="))
2383 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2384 else if (startswith(l, "generators-finish-timestamp="))
2385 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2386 else if (startswith(l, "units-load-start-timestamp="))
2387 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2388 else if (startswith(l, "units-load-finish-timestamp="))
2389 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2390 else if (startswith(l, "env=")) {
2391 _cleanup_free_ char *uce = NULL;
2394 uce = cunescape(l+4);
2400 e = strv_env_set(m->environment, uce);
2406 strv_free(m->environment);
2409 } else if (startswith(l, "notify-fd=")) {
2412 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2413 log_debug("Failed to parse notify fd: %s", l + 10);
2415 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2416 safe_close(m->notify_fd);
2417 m->notify_fd = fdset_remove(fds, fd);
2420 } else if (startswith(l, "notify-socket=")) {
2429 free(m->notify_socket);
2430 m->notify_socket = n;
2432 } else if (startswith(l, "kdbus-fd=")) {
2435 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2436 log_debug("Failed to parse kdbus fd: %s", l + 9);
2438 safe_close(m->kdbus_fd);
2439 m->kdbus_fd = fdset_remove(fds, fd);
2445 k = bus_track_deserialize_item(&m->deserialized_subscribed, l);
2447 log_debug_errno(k, "Failed to deserialize bus tracker object: %m");
2449 log_debug("Unknown serialization item '%s'", l);
2455 char name[UNIT_NAME_MAX+2];
2458 if (!fgets(name, sizeof(name), f)) {
2469 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2473 r = unit_deserialize(u, f, fds);
2482 assert(m->n_reloading > 0);
2488 int manager_reload(Manager *m) {
2490 _cleanup_fclose_ FILE *f = NULL;
2491 _cleanup_fdset_free_ FDSet *fds = NULL;
2495 r = manager_open_serialization(m, &f);
2500 bus_manager_send_reloading(m, true);
2508 r = manager_serialize(m, f, fds, false);
2514 if (fseeko(f, 0, SEEK_SET) < 0) {
2519 /* From here on there is no way back. */
2520 manager_clear_jobs_and_units(m);
2521 manager_undo_generators(m);
2522 lookup_paths_free(&m->lookup_paths);
2524 /* Find new unit paths */
2525 q = manager_run_generators(m);
2526 if (q < 0 && r >= 0)
2529 q = lookup_paths_init(
2530 &m->lookup_paths, m->running_as, true,
2532 m->generator_unit_path,
2533 m->generator_unit_path_early,
2534 m->generator_unit_path_late);
2535 if (q < 0 && r >= 0)
2538 manager_build_unit_path_cache(m);
2540 /* First, enumerate what we can from all config files */
2541 q = manager_enumerate(m);
2542 if (q < 0 && r >= 0)
2545 /* Second, deserialize our stored data */
2546 q = manager_deserialize(m, f, fds);
2547 if (q < 0 && r >= 0)
2553 /* Re-register notify_fd as event source */
2554 q = manager_setup_notify(m);
2555 if (q < 0 && r >= 0)
2558 /* Third, fire things up! */
2559 q = manager_coldplug(m);
2560 if (q < 0 && r >= 0)
2563 assert(m->n_reloading > 0);
2566 m->send_reloading_done = true;
2571 bool manager_is_reloading_or_reexecuting(Manager *m) {
2574 return m->n_reloading != 0;
2577 void manager_reset_failed(Manager *m) {
2583 HASHMAP_FOREACH(u, m->units, i)
2584 unit_reset_failed(u);
2587 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2593 /* Returns true if the unit is inactive or going down */
2594 u = manager_get_unit(m, name);
2598 return unit_inactive_or_pending(u);
2601 static void manager_notify_finished(Manager *m) {
2602 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2603 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2608 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2610 /* Note that m->kernel_usec.monotonic is always at 0,
2611 * and m->firmware_usec.monotonic and
2612 * m->loader_usec.monotonic should be considered
2613 * negative values. */
2615 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2616 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2617 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2618 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2620 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2622 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2623 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2625 log_struct(LOG_INFO,
2626 LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2627 "KERNEL_USEC="USEC_FMT, kernel_usec,
2628 "INITRD_USEC="USEC_FMT, initrd_usec,
2629 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2630 LOG_MESSAGE("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2631 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2632 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2633 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2634 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2637 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2640 log_struct(LOG_INFO,
2641 LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2642 "KERNEL_USEC="USEC_FMT, kernel_usec,
2643 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2644 LOG_MESSAGE("Startup finished in %s (kernel) + %s (userspace) = %s.",
2645 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2646 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2647 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2651 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2652 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2654 log_struct(LOG_INFO,
2655 LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2656 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2657 LOG_MESSAGE("Startup finished in %s.",
2658 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2662 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2666 "STATUS=Startup finished in %s.",
2667 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2670 void manager_check_finished(Manager *m) {
2676 if (hashmap_size(m->jobs) > 0) {
2678 if (m->jobs_in_progress_event_source)
2679 sd_event_source_set_time(m->jobs_in_progress_event_source, now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2684 manager_flip_auto_status(m, false);
2686 /* Notify Type=idle units that we are done now */
2687 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2688 manager_close_idle_pipe(m);
2690 /* Turn off confirm spawn now */
2691 m->confirm_spawn = false;
2693 /* No need to update ask password status when we're going non-interactive */
2694 manager_close_ask_password(m);
2696 /* This is no longer the first boot */
2697 manager_set_first_boot(m, false);
2699 if (dual_timestamp_is_set(&m->finish_timestamp))
2702 dual_timestamp_get(&m->finish_timestamp);
2704 manager_notify_finished(m);
2706 SET_FOREACH(u, m->startup_units, i)
2708 cgroup_context_apply(unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path, manager_state(m));
2711 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2722 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2723 /* systemd --system, not running --test */
2725 p = strappend("/run/systemd/", name);
2729 r = mkdir_p_label(p, 0755);
2731 log_error_errno(r, "Failed to create generator directory %s: %m", p);
2735 } else if (m->running_as == SYSTEMD_USER) {
2736 const char *s = NULL;
2738 s = getenv("XDG_RUNTIME_DIR");
2741 p = strjoin(s, "/systemd/", name, NULL);
2745 r = mkdir_p_label(p, 0755);
2747 log_error_errno(r, "Failed to create generator directory %s: %m", p);
2752 /* systemd --system --test */
2754 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2759 log_error_errno(errno, "Failed to create generator directory %s: %m",
2770 static void trim_generator_dir(Manager *m, char **generator) {
2777 if (rmdir(*generator) >= 0) {
2785 static int manager_run_generators(Manager *m) {
2786 _cleanup_free_ char **paths = NULL;
2787 const char *argv[5];
2796 paths = generator_paths(m->running_as);
2800 /* Optimize by skipping the whole process by not creating output directories
2801 * if no generators are found. */
2802 STRV_FOREACH(path, paths) {
2803 r = access(*path, F_OK);
2806 if (errno != ENOENT)
2807 log_warning_errno(errno, "Failed to open generator directory %s: %m", *path);
2812 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2816 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2820 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2824 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2825 argv[1] = m->generator_unit_path;
2826 argv[2] = m->generator_unit_path_early;
2827 argv[3] = m->generator_unit_path_late;
2830 RUN_WITH_UMASK(0022)
2831 execute_directories((const char* const*) paths, DEFAULT_TIMEOUT_USEC, (char**) argv);
2834 trim_generator_dir(m, &m->generator_unit_path);
2835 trim_generator_dir(m, &m->generator_unit_path_early);
2836 trim_generator_dir(m, &m->generator_unit_path_late);
2840 static void remove_generator_dir(Manager *m, char **generator) {
2847 strv_remove(m->lookup_paths.unit_path, *generator);
2848 rm_rf(*generator, false, true, false);
2854 static void manager_undo_generators(Manager *m) {
2857 remove_generator_dir(m, &m->generator_unit_path);
2858 remove_generator_dir(m, &m->generator_unit_path_early);
2859 remove_generator_dir(m, &m->generator_unit_path_late);
2862 int manager_environment_add(Manager *m, char **minus, char **plus) {
2863 char **a = NULL, **b = NULL, **l;
2868 if (!strv_isempty(minus)) {
2869 a = strv_env_delete(l, 1, minus);
2876 if (!strv_isempty(plus)) {
2877 b = strv_env_merge(2, l, plus);
2886 if (m->environment != l)
2887 strv_free(m->environment);
2894 manager_clean_environment(m);
2895 strv_sort(m->environment);
2900 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2905 for (i = 0; i < _RLIMIT_MAX; i++) {
2906 if (!default_rlimit[i])
2909 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2917 void manager_recheck_journal(Manager *m) {
2922 if (m->running_as != SYSTEMD_SYSTEM)
2925 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2926 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2927 log_close_journal();
2931 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2932 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2933 log_close_journal();
2937 /* Hmm, OK, so the socket is fully up and the service is up
2938 * too, then let's make use of the thing. */
2942 void manager_set_show_status(Manager *m, ShowStatus mode) {
2944 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2946 if (m->running_as != SYSTEMD_SYSTEM)
2949 m->show_status = mode;
2952 touch("/run/systemd/show-status");
2954 unlink("/run/systemd/show-status");
2957 static bool manager_get_show_status(Manager *m, StatusType type) {
2960 if (m->running_as != SYSTEMD_SYSTEM)
2963 if (m->no_console_output)
2966 if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
2969 /* If we cannot find out the status properly, just proceed. */
2970 if (type != STATUS_TYPE_EMERGENCY && manager_check_ask_password(m) > 0)
2973 if (m->show_status > 0)
2976 /* If Plymouth is running make sure we show the status, so
2977 * that there's something nice to see when people press Esc */
2978 return plymouth_running();
2981 void manager_set_first_boot(Manager *m, bool b) {
2984 if (m->running_as != SYSTEMD_SYSTEM)
2990 touch("/run/systemd/first-boot");
2992 unlink("/run/systemd/first-boot");
2995 void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) {
2998 /* If m is NULL, assume we're after shutdown and let the messages through. */
3000 if (m && !manager_get_show_status(m, type))
3003 /* XXX We should totally drop the check for ephemeral here
3004 * and thus effectively make 'Type=idle' pointless. */
3005 if (type == STATUS_TYPE_EPHEMERAL && m && m->n_on_console > 0)
3008 va_start(ap, format);
3009 status_vprintf(status, true, type == STATUS_TYPE_EPHEMERAL, format, ap);
3013 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
3014 _cleanup_free_ char *p = NULL;
3022 p = unit_name_from_path(path, suffix);
3026 found = manager_get_unit(m, p);
3036 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
3037 char p[strlen(path)+1];
3043 path_kill_slashes(p);
3045 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
3048 const char *manager_get_runtime_prefix(Manager *m) {
3051 return m->running_as == SYSTEMD_SYSTEM ?
3053 getenv("XDG_RUNTIME_DIR");
3056 void manager_update_failed_units(Manager *m, Unit *u, bool failed) {
3060 assert(u->manager == m);
3062 size = set_size(m->failed_units);
3065 set_put(m->failed_units, u);
3067 set_remove(m->failed_units, u);
3069 if (set_size(m->failed_units) != size)
3070 bus_manager_send_change_signal(m);
3073 ManagerState manager_state(Manager *m) {
3078 /* Did we ever finish booting? If not then we are still starting up */
3079 if (!dual_timestamp_is_set(&m->finish_timestamp)) {
3081 u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
3082 if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
3083 return MANAGER_INITIALIZING;
3085 return MANAGER_STARTING;
3088 /* Is the special shutdown target queued? If so, we are in shutdown state */
3089 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
3090 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
3091 return MANAGER_STOPPING;
3093 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
3094 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
3095 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3096 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3097 return MANAGER_MAINTENANCE;
3099 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
3100 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3101 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3102 return MANAGER_MAINTENANCE;
3104 /* Are there any failed units? If so, we are in degraded mode */
3105 if (set_size(m->failed_units) > 0)
3106 return MANAGER_DEGRADED;
3108 return MANAGER_RUNNING;
3111 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
3112 [MANAGER_INITIALIZING] = "initializing",
3113 [MANAGER_STARTING] = "starting",
3114 [MANAGER_RUNNING] = "running",
3115 [MANAGER_DEGRADED] = "degraded",
3116 [MANAGER_MAINTENANCE] = "maintenance",
3117 [MANAGER_STOPPING] = "stopping",
3120 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);