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/>.
28 #include <sys/inotify.h>
29 #include <sys/epoll.h>
31 #include <sys/reboot.h>
32 #include <sys/ioctl.h>
36 #include <sys/types.h>
39 #include <sys/timerfd.h>
45 #include "sd-daemon.h"
47 #include "sd-messages.h"
50 #include "transaction.h"
57 #include "ratelimit.h"
58 #include "locale-setup.h"
59 #include "mount-setup.h"
60 #include "unit-name.h"
62 #include "path-lookup.h"
64 #include "exit-status.h"
67 #include "cgroup-util.h"
68 #include "path-util.h"
70 #include "boot-timestamps.h"
72 #include "bus-common-errors.h"
73 #include "bus-error.h"
76 #include "dbus-unit.h"
78 #include "dbus-manager.h"
79 #include "bus-kernel.h"
80 #include "time-util.h"
82 /* Initial delay and the interval for printing status messages about running jobs */
83 #define JOBS_IN_PROGRESS_WAIT_USEC (5*USEC_PER_SEC)
84 #define JOBS_IN_PROGRESS_PERIOD_USEC (USEC_PER_SEC / 3)
85 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
87 #define NOTIFY_FD_MAX 768
88 #define NOTIFY_BUFFER_MAX PIPE_BUF
90 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
91 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
92 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
93 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
94 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
95 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
97 static int manager_watch_jobs_in_progress(Manager *m) {
102 if (m->jobs_in_progress_event_source)
105 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
106 return sd_event_add_time(
108 &m->jobs_in_progress_event_source,
111 manager_dispatch_jobs_in_progress, m);
114 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
116 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
119 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
120 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
124 p = mempset(p, ' ', pos-2);
125 p = stpcpy(p, ANSI_RED_ON);
129 if (pos > 0 && pos <= width) {
130 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
134 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
137 p = stpcpy(p, ANSI_RED_ON);
140 p = mempset(p, ' ', width-1-pos);
141 strcpy(p, ANSI_HIGHLIGHT_OFF);
145 void manager_flip_auto_status(Manager *m, bool enable) {
149 if (m->show_status == SHOW_STATUS_AUTO)
150 manager_set_show_status(m, SHOW_STATUS_TEMPORARY);
152 if (m->show_status == SHOW_STATUS_TEMPORARY)
153 manager_set_show_status(m, SHOW_STATUS_AUTO);
157 static void manager_print_jobs_in_progress(Manager *m) {
158 _cleanup_free_ char *job_of_n = NULL;
161 unsigned counter = 0, print_nr;
162 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
164 char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
168 assert(m->n_running_jobs > 0);
170 manager_flip_auto_status(m, true);
172 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
174 HASHMAP_FOREACH(j, m->jobs, i)
175 if (j->state == JOB_RUNNING && counter++ == print_nr)
178 /* m->n_running_jobs must be consistent with the contents of m->jobs,
179 * so the above loop must have succeeded in finding j. */
180 assert(counter == print_nr + 1);
183 cylon_pos = m->jobs_in_progress_iteration % 14;
185 cylon_pos = 14 - cylon_pos;
186 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
188 m->jobs_in_progress_iteration++;
190 if (m->n_running_jobs > 1)
191 asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs);
193 format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
194 if (job_get_timeout(j, &x) > 0)
195 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
197 manager_status_printf(m, STATUS_TYPE_EPHEMERAL, cylon,
198 "%sA %s job is running for %s (%s / %s)",
200 job_type_to_string(j->type),
201 unit_description(j->unit),
205 static int have_ask_password(void) {
206 _cleanup_closedir_ DIR *dir;
208 dir = opendir("/run/systemd/ask-password");
221 if (!de && errno != 0)
226 if (startswith(de->d_name, "ask."))
231 static int manager_dispatch_ask_password_fd(sd_event_source *source,
232 int fd, uint32_t revents, void *userdata) {
233 Manager *m = userdata;
239 m->have_ask_password = have_ask_password();
240 if (m->have_ask_password < 0)
241 /* Log error but continue. Negative have_ask_password
242 * is treated as unknown status. */
243 log_error_errno(m->have_ask_password, "Failed to list /run/systemd/ask-password: %m");
248 static void manager_close_ask_password(Manager *m) {
251 m->ask_password_inotify_fd = safe_close(m->ask_password_inotify_fd);
252 m->ask_password_event_source = sd_event_source_unref(m->ask_password_event_source);
253 m->have_ask_password = -EINVAL;
256 static int manager_check_ask_password(Manager *m) {
261 if (!m->ask_password_event_source) {
262 assert(m->ask_password_inotify_fd < 0);
264 mkdir_p_label("/run/systemd/ask-password", 0755);
266 m->ask_password_inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
267 if (m->ask_password_inotify_fd < 0)
268 return log_error_errno(errno, "inotify_init1() failed: %m");
270 if (inotify_add_watch(m->ask_password_inotify_fd, "/run/systemd/ask-password", IN_CREATE|IN_DELETE|IN_MOVE) < 0) {
271 log_error_errno(errno, "Failed to add watch on /run/systemd/ask-password: %m");
272 manager_close_ask_password(m);
276 r = sd_event_add_io(m->event, &m->ask_password_event_source,
277 m->ask_password_inotify_fd, EPOLLIN,
278 manager_dispatch_ask_password_fd, m);
280 log_error_errno(errno, "Failed to add event source for /run/systemd/ask-password: %m");
281 manager_close_ask_password(m);
285 /* Queries might have been added meanwhile... */
286 manager_dispatch_ask_password_fd(m->ask_password_event_source,
287 m->ask_password_inotify_fd, EPOLLIN, m);
290 return m->have_ask_password;
293 static int manager_watch_idle_pipe(Manager *m) {
298 if (m->idle_pipe_event_source)
301 if (m->idle_pipe[2] < 0)
304 r = sd_event_add_io(m->event, &m->idle_pipe_event_source, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m);
306 return log_error_errno(r, "Failed to watch idle pipe: %m");
311 static void manager_close_idle_pipe(Manager *m) {
314 safe_close_pair(m->idle_pipe);
315 safe_close_pair(m->idle_pipe + 2);
318 static int manager_setup_time_change(Manager *m) {
321 /* We only care for the cancellation event, hence we set the
322 * timeout to the latest possible value. */
323 struct itimerspec its = {
324 .it_value.tv_sec = TIME_T_MAX,
328 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
333 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
334 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
336 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
337 if (m->time_change_fd < 0)
338 return log_error_errno(errno, "Failed to create timerfd: %m");
340 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
341 log_debug_errno(errno, "Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
342 m->time_change_fd = safe_close(m->time_change_fd);
346 r = sd_event_add_io(m->event, &m->time_change_event_source, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m);
348 return log_error_errno(r, "Failed to create time change event source: %m");
350 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
355 static int enable_special_signals(Manager *m) {
356 _cleanup_close_ int fd = -1;
360 /* Enable that we get SIGINT on control-alt-del. In containers
361 * this will fail with EPERM (older) or EINVAL (newer), so
363 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
364 log_warning_errno(errno, "Failed to enable ctrl-alt-del handling: %m");
366 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
368 /* Support systems without virtual console */
370 log_warning_errno(errno, "Failed to open /dev/tty0: %m");
372 /* Enable that we get SIGWINCH on kbrequest */
373 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
374 log_warning_errno(errno, "Failed to enable kbrequest handling: %m");
380 static int manager_setup_signals(Manager *m) {
381 struct sigaction sa = {
382 .sa_handler = SIG_DFL,
383 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
390 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
392 /* We make liberal use of realtime signals here. On
393 * Linux/glibc we have 30 of them (with the exception of Linux
394 * on hppa, see below), between SIGRTMIN+0 ... SIGRTMIN+30
397 assert_se(sigemptyset(&mask) == 0);
398 sigset_add_many(&mask,
399 SIGCHLD, /* Child died */
400 SIGTERM, /* Reexecute daemon */
401 SIGHUP, /* Reload configuration */
402 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
403 SIGUSR2, /* systemd: dump status */
404 SIGINT, /* Kernel sends us this on control-alt-del */
405 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
406 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
408 SIGRTMIN+0, /* systemd: start default.target */
409 SIGRTMIN+1, /* systemd: isolate rescue.target */
410 SIGRTMIN+2, /* systemd: isolate emergency.target */
411 SIGRTMIN+3, /* systemd: start halt.target */
412 SIGRTMIN+4, /* systemd: start poweroff.target */
413 SIGRTMIN+5, /* systemd: start reboot.target */
414 SIGRTMIN+6, /* systemd: start kexec.target */
416 /* ... space for more special targets ... */
418 SIGRTMIN+13, /* systemd: Immediate halt */
419 SIGRTMIN+14, /* systemd: Immediate poweroff */
420 SIGRTMIN+15, /* systemd: Immediate reboot */
421 SIGRTMIN+16, /* systemd: Immediate kexec */
423 /* ... space for more immediate system state changes ... */
425 SIGRTMIN+20, /* systemd: enable status messages */
426 SIGRTMIN+21, /* systemd: disable status messages */
427 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
428 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
429 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
431 /* .. one free signal here ... */
433 #if !defined(__hppa64__) && !defined(__hppa__)
434 /* Apparently Linux on hppa has fewer RT
435 * signals (SIGRTMAX is SIGRTMIN+25 there),
436 * hence let's not try to make use of them
437 * here. Since these commands are accessible
438 * by different means and only really a safety
439 * net, the missing functionality on hppa
440 * shouldn't matter. */
442 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
443 SIGRTMIN+27, /* systemd: set log target to console */
444 SIGRTMIN+28, /* systemd: set log target to kmsg */
445 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg (obsolete) */
447 /* ... one free signal here SIGRTMIN+30 ... */
450 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
452 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
453 if (m->signal_fd < 0)
456 r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);
460 /* Process signals a bit earlier than the rest of things, but
461 * later than notify_fd processing, so that the notify
462 * processing can still figure out to which process/service a
463 * message belongs, before we reap the process. */
464 r = sd_event_source_set_priority(m->signal_event_source, -5);
468 if (m->running_as == SYSTEMD_SYSTEM)
469 return enable_special_signals(m);
474 static void manager_clean_environment(Manager *m) {
477 /* Let's remove some environment variables that we
478 * need ourselves to communicate with our clients */
491 static int manager_default_environment(Manager *m) {
494 if (m->running_as == SYSTEMD_SYSTEM) {
495 /* The system manager always starts with a clean
496 * environment for its children. It does not import
497 * the kernel or the parents exported variables.
499 * The initial passed environ is untouched to keep
500 * /proc/self/environ valid; it is used for tagging
501 * the init process inside containers. */
502 m->environment = strv_new("PATH=" DEFAULT_PATH,
505 /* Import locale variables LC_*= from configuration */
506 locale_setup(&m->environment);
508 /* The user manager passes its own environment
509 * along to its children. */
510 m->environment = strv_copy(environ);
516 manager_clean_environment(m);
517 strv_sort(m->environment);
522 int manager_new(SystemdRunningAs running_as, bool test_run, Manager **_m) {
527 assert(running_as >= 0);
528 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
530 m = new0(Manager, 1);
535 if (running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0)
536 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
539 m->running_as = running_as;
540 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
541 m->default_timer_accuracy_usec = USEC_PER_MINUTE;
543 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
545 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;
546 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
548 m->ask_password_inotify_fd = -1;
549 m->have_ask_password = -EINVAL; /* we don't know */
551 m->test_run = test_run;
553 r = manager_default_environment(m);
557 r = hashmap_ensure_allocated(&m->units, &string_hash_ops);
561 r = hashmap_ensure_allocated(&m->jobs, NULL);
565 r = hashmap_ensure_allocated(&m->cgroup_unit, &string_hash_ops);
569 r = hashmap_ensure_allocated(&m->watch_bus, &string_hash_ops);
573 r = set_ensure_allocated(&m->startup_units, NULL);
577 r = set_ensure_allocated(&m->failed_units, NULL);
581 r = sd_event_default(&m->event);
585 r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
589 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
593 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
597 r = manager_setup_signals(m);
601 r = manager_setup_cgroup(m);
605 r = manager_setup_time_change(m);
609 m->udev = udev_new();
615 /* Note that we set up neither kdbus, nor the notify fd
616 * here. We do that after deserialization, since they might
617 * have gotten serialized across the reexec. */
619 m->taint_usr = dir_is_empty("/usr") > 0;
629 static int manager_setup_notify(Manager *m) {
635 if (m->notify_fd < 0) {
636 _cleanup_close_ int fd = -1;
637 union sockaddr_union sa = {
638 .sa.sa_family = AF_UNIX,
640 static const int one = 1;
642 /* First free all secondary fields */
643 free(m->notify_socket);
644 m->notify_socket = NULL;
645 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
647 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
649 return log_error_errno(errno, "Failed to allocate notification socket: %m");
651 if (m->running_as == SYSTEMD_SYSTEM)
652 m->notify_socket = strdup("/run/systemd/notify");
656 e = getenv("XDG_RUNTIME_DIR");
658 log_error_errno(errno, "XDG_RUNTIME_DIR is not set: %m");
662 m->notify_socket = strappend(e, "/systemd/notify");
664 if (!m->notify_socket)
667 (void) mkdir_parents_label(m->notify_socket, 0755);
668 (void) unlink(m->notify_socket);
670 strncpy(sa.un.sun_path, m->notify_socket, sizeof(sa.un.sun_path)-1);
671 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path));
673 return log_error_errno(errno, "bind(%s) failed: %m", sa.un.sun_path);
675 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
677 return log_error_errno(errno, "SO_PASSCRED failed: %m");
682 log_debug("Using notification socket %s", m->notify_socket);
685 if (!m->notify_event_source) {
686 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
688 return log_error_errno(r, "Failed to allocate notify event source: %m");
690 /* Process signals a bit earlier than SIGCHLD, so that we can
691 * still identify to which service an exit message belongs */
692 r = sd_event_source_set_priority(m->notify_event_source, -7);
694 return log_error_errno(r, "Failed to set priority of notify event source: %m");
700 static int manager_setup_kdbus(Manager *m) {
702 _cleanup_free_ char *p = NULL;
706 if (m->test_run || m->kdbus_fd >= 0)
710 bus_kernel_fix_attach_mask();
712 m->kdbus_fd = bus_kernel_create_bus(
713 m->running_as == SYSTEMD_SYSTEM ? "system" : "user",
714 m->running_as == SYSTEMD_SYSTEM, &p);
717 return log_debug_errno(m->kdbus_fd, "Failed to set up kdbus: %m");
719 log_debug("Successfully set up kdbus on %s", p);
725 static int manager_connect_bus(Manager *m, bool reexecuting) {
726 bool try_bus_connect;
736 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
738 /* Try to connect to the busses, if possible. */
739 return bus_init(m, try_bus_connect);
742 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
748 while ((u = m->cleanup_queue)) {
749 assert(u->in_cleanup_queue);
759 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
760 GC_OFFSET_UNSURE, /* No clue */
761 GC_OFFSET_GOOD, /* We still need this unit */
762 GC_OFFSET_BAD, /* We don't need this unit anymore */
766 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
773 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
774 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
775 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
778 if (u->in_cleanup_queue)
781 if (unit_check_gc(u))
784 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
788 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
789 unit_gc_sweep(other, gc_marker);
791 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
794 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
801 /* We were unable to find anything out about this entry, so
802 * let's investigate it later */
803 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
804 unit_add_to_gc_queue(u);
808 /* We definitely know that this one is not useful anymore, so
809 * let's mark it for deletion */
810 u->gc_marker = gc_marker + GC_OFFSET_BAD;
811 unit_add_to_cleanup_queue(u);
815 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
818 static unsigned manager_dispatch_gc_queue(Manager *m) {
825 /* log_debug("Running GC..."); */
827 m->gc_marker += _GC_OFFSET_MAX;
828 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
831 gc_marker = m->gc_marker;
833 while ((u = m->gc_queue)) {
834 assert(u->in_gc_queue);
836 unit_gc_sweep(u, gc_marker);
838 LIST_REMOVE(gc_queue, m->gc_queue, u);
839 u->in_gc_queue = false;
843 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
844 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
845 log_unit_debug(u->id, "Collecting %s", u->id);
846 u->gc_marker = gc_marker + GC_OFFSET_BAD;
847 unit_add_to_cleanup_queue(u);
851 m->n_in_gc_queue = 0;
856 static void manager_clear_jobs_and_units(Manager *m) {
861 while ((u = hashmap_first(m->units)))
864 manager_dispatch_cleanup_queue(m);
866 assert(!m->load_queue);
867 assert(!m->run_queue);
868 assert(!m->dbus_unit_queue);
869 assert(!m->dbus_job_queue);
870 assert(!m->cleanup_queue);
871 assert(!m->gc_queue);
873 assert(hashmap_isempty(m->jobs));
874 assert(hashmap_isempty(m->units));
877 m->n_running_jobs = 0;
880 Manager* manager_free(Manager *m) {
887 manager_clear_jobs_and_units(m);
889 for (c = 0; c < _UNIT_TYPE_MAX; c++)
890 if (unit_vtable[c]->shutdown)
891 unit_vtable[c]->shutdown(m);
893 /* If we reexecute ourselves, we keep the root cgroup
895 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
897 manager_undo_generators(m);
901 hashmap_free(m->units);
902 hashmap_free(m->jobs);
903 hashmap_free(m->watch_pids1);
904 hashmap_free(m->watch_pids2);
905 hashmap_free(m->watch_bus);
907 set_free(m->startup_units);
908 set_free(m->failed_units);
910 sd_event_source_unref(m->signal_event_source);
911 sd_event_source_unref(m->notify_event_source);
912 sd_event_source_unref(m->time_change_event_source);
913 sd_event_source_unref(m->jobs_in_progress_event_source);
914 sd_event_source_unref(m->idle_pipe_event_source);
915 sd_event_source_unref(m->run_queue_event_source);
917 safe_close(m->signal_fd);
918 safe_close(m->notify_fd);
919 safe_close(m->time_change_fd);
920 safe_close(m->kdbus_fd);
922 manager_close_ask_password(m);
924 manager_close_idle_pipe(m);
927 sd_event_unref(m->event);
929 free(m->notify_socket);
931 lookup_paths_free(&m->lookup_paths);
932 strv_free(m->environment);
934 hashmap_free(m->cgroup_unit);
935 set_free_free(m->unit_path_cache);
937 free(m->switch_root);
938 free(m->switch_root_init);
940 for (i = 0; i < _RLIMIT_MAX; i++)
943 assert(hashmap_isempty(m->units_requiring_mounts_for));
944 hashmap_free(m->units_requiring_mounts_for);
950 int manager_enumerate(Manager *m) {
956 /* Let's ask every type to load all units from disk/kernel
957 * that it might know */
958 for (c = 0; c < _UNIT_TYPE_MAX; c++) {
961 if (unit_vtable[c]->supported && !unit_vtable[c]->supported(m)) {
962 log_info("Unit type .%s is not supported on this system.", unit_type_to_string(c));
966 if (!unit_vtable[c]->enumerate)
969 q = unit_vtable[c]->enumerate(m);
974 manager_dispatch_load_queue(m);
978 static int manager_coldplug(Manager *m) {
986 /* Then, let's set up their initial state. */
987 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
994 q = unit_coldplug(u);
1002 static void manager_build_unit_path_cache(Manager *m) {
1004 _cleanup_closedir_ DIR *d = NULL;
1009 set_free_free(m->unit_path_cache);
1011 m->unit_path_cache = set_new(&string_hash_ops);
1012 if (!m->unit_path_cache) {
1013 log_error("Failed to allocate unit path cache.");
1017 /* This simply builds a list of files we know exist, so that
1018 * we don't always have to go to disk */
1020 STRV_FOREACH(i, m->lookup_paths.unit_path) {
1025 if (errno != ENOENT)
1026 log_error_errno(errno, "Failed to open directory %s: %m", *i);
1030 while ((de = readdir(d))) {
1033 if (hidden_file(de->d_name))
1036 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
1042 r = set_consume(m->unit_path_cache, p);
1054 log_error_errno(r, "Failed to build unit path cache: %m");
1056 set_free_free(m->unit_path_cache);
1057 m->unit_path_cache = NULL;
1061 static int manager_distribute_fds(Manager *m, FDSet *fds) {
1068 HASHMAP_FOREACH(u, m->units, i) {
1070 if (fdset_size(fds) <= 0)
1073 if (UNIT_VTABLE(u)->distribute_fds) {
1074 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
1083 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
1088 dual_timestamp_get(&m->generators_start_timestamp);
1089 manager_run_generators(m);
1090 dual_timestamp_get(&m->generators_finish_timestamp);
1092 r = lookup_paths_init(
1093 &m->lookup_paths, m->running_as, true,
1095 m->generator_unit_path,
1096 m->generator_unit_path_early,
1097 m->generator_unit_path_late);
1101 manager_build_unit_path_cache(m);
1103 /* If we will deserialize make sure that during enumeration
1104 * this is already known, so we increase the counter here
1109 /* First, enumerate what we can from all config files */
1110 dual_timestamp_get(&m->units_load_start_timestamp);
1111 r = manager_enumerate(m);
1112 dual_timestamp_get(&m->units_load_finish_timestamp);
1114 /* Second, deserialize if there is something to deserialize */
1116 r = manager_deserialize(m, serialization, fds);
1118 /* Any fds left? Find some unit which wants them. This is
1119 * useful to allow container managers to pass some file
1120 * descriptors to us pre-initialized. This enables
1121 * socket-based activation of entire containers. */
1122 if (fdset_size(fds) > 0) {
1123 q = manager_distribute_fds(m, fds);
1124 if (q < 0 && r == 0)
1128 /* We might have deserialized the notify fd, but if we didn't
1129 * then let's create the bus now */
1130 q = manager_setup_notify(m);
1131 if (q < 0 && r == 0)
1134 /* We might have deserialized the kdbus control fd, but if we
1135 * didn't, then let's create the bus now. */
1136 manager_setup_kdbus(m);
1137 manager_connect_bus(m, !!serialization);
1138 bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
1140 /* Third, fire things up! */
1141 q = manager_coldplug(m);
1142 if (q < 0 && r == 0)
1145 if (serialization) {
1146 assert(m->n_reloading > 0);
1149 /* Let's wait for the UnitNew/JobNew messages being
1150 * sent, before we notify that the reload is
1152 m->send_reloading_done = true;
1158 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1163 assert(type < _JOB_TYPE_MAX);
1165 assert(mode < _JOB_MODE_MAX);
1167 if (mode == JOB_ISOLATE && type != JOB_START)
1168 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1170 if (mode == JOB_ISOLATE && !unit->allow_isolate)
1171 return sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1173 log_unit_debug(unit->id,
1174 "Trying to enqueue job %s/%s/%s", unit->id,
1175 job_type_to_string(type), job_mode_to_string(mode));
1177 job_type_collapse(&type, unit);
1179 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1183 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1184 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1185 mode == JOB_IGNORE_DEPENDENCIES, e);
1189 if (mode == JOB_ISOLATE) {
1190 r = transaction_add_isolate_jobs(tr, m);
1195 r = transaction_activate(tr, m, mode, e);
1199 log_unit_debug(unit->id,
1200 "Enqueued job %s/%s as %u", unit->id,
1201 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1204 *_ret = tr->anchor_job;
1206 transaction_free(tr);
1210 transaction_abort(tr);
1211 transaction_free(tr);
1215 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1220 assert(type < _JOB_TYPE_MAX);
1222 assert(mode < _JOB_MODE_MAX);
1224 r = manager_load_unit(m, name, NULL, NULL, &unit);
1228 return manager_add_job(m, type, unit, mode, override, e, _ret);
1231 Job *manager_get_job(Manager *m, uint32_t id) {
1234 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1237 Unit *manager_get_unit(Manager *m, const char *name) {
1241 return hashmap_get(m->units, name);
1244 unsigned manager_dispatch_load_queue(Manager *m) {
1250 /* Make sure we are not run recursively */
1251 if (m->dispatching_load_queue)
1254 m->dispatching_load_queue = true;
1256 /* Dispatches the load queue. Takes a unit from the queue and
1257 * tries to load its data until the queue is empty */
1259 while ((u = m->load_queue)) {
1260 assert(u->in_load_queue);
1266 m->dispatching_load_queue = false;
1270 int manager_load_unit_prepare(
1282 assert(name || path);
1284 /* This will prepare the unit for loading, but not actually
1285 * load anything from disk. */
1287 if (path && !is_path(path))
1288 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1291 name = basename(path);
1293 t = unit_name_to_type(name);
1295 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1296 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1298 ret = manager_get_unit(m, name);
1304 ret = unit_new(m, unit_vtable[t]->object_size);
1309 ret->fragment_path = strdup(path);
1310 if (!ret->fragment_path) {
1316 r = unit_add_name(ret, name);
1322 unit_add_to_load_queue(ret);
1323 unit_add_to_dbus_queue(ret);
1324 unit_add_to_gc_queue(ret);
1332 int manager_load_unit(
1343 /* This will load the service information files, but not actually
1344 * start any services or anything. */
1346 r = manager_load_unit_prepare(m, name, path, e, _ret);
1350 manager_dispatch_load_queue(m);
1353 *_ret = unit_follow_merge(*_ret);
1358 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1365 HASHMAP_FOREACH(j, s->jobs, i)
1366 job_dump(j, f, prefix);
1369 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1377 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1379 unit_dump(u, f, prefix);
1382 void manager_clear_jobs(Manager *m) {
1387 while ((j = hashmap_first(m->jobs)))
1388 /* No need to recurse. We're cancelling all jobs. */
1389 job_finish_and_invalidate(j, JOB_CANCELED, false);
1392 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1393 Manager *m = userdata;
1399 while ((j = m->run_queue)) {
1400 assert(j->installed);
1401 assert(j->in_run_queue);
1403 job_run_and_invalidate(j);
1406 if (m->n_running_jobs > 0)
1407 manager_watch_jobs_in_progress(m);
1409 if (m->n_on_console > 0)
1410 manager_watch_idle_pipe(m);
1415 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1422 if (m->dispatching_dbus_queue)
1425 m->dispatching_dbus_queue = true;
1427 while ((u = m->dbus_unit_queue)) {
1428 assert(u->in_dbus_queue);
1430 bus_unit_send_change_signal(u);
1434 while ((j = m->dbus_job_queue)) {
1435 assert(j->in_dbus_queue);
1437 bus_job_send_change_signal(j);
1441 m->dispatching_dbus_queue = false;
1443 if (m->send_reloading_done) {
1444 m->send_reloading_done = false;
1446 bus_manager_send_reloading(m, false);
1449 if (m->queued_message)
1450 bus_send_queued_message(m);
1455 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n, FDSet *fds) {
1456 _cleanup_strv_free_ char **tags = NULL;
1463 tags = strv_split(buf, "\n\r");
1469 log_unit_debug(u->id, "Got notification message for unit %s", u->id);
1471 if (UNIT_VTABLE(u)->notify_message)
1472 UNIT_VTABLE(u)->notify_message(u, pid, tags, fds);
1475 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1476 Manager *m = userdata;
1481 assert(m->notify_fd == fd);
1483 if (revents != EPOLLIN) {
1484 log_warning("Got unexpected poll event for notify fd.");
1489 _cleanup_fdset_free_ FDSet *fds = NULL;
1490 char buf[NOTIFY_BUFFER_MAX+1];
1491 struct iovec iovec = {
1493 .iov_len = sizeof(buf)-1,
1496 struct cmsghdr cmsghdr;
1497 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
1498 CMSG_SPACE(sizeof(int) * NOTIFY_FD_MAX)];
1500 struct msghdr msghdr = {
1503 .msg_control = &control,
1504 .msg_controllen = sizeof(control),
1506 struct cmsghdr *cmsg;
1507 struct ucred *ucred = NULL;
1510 int *fd_array = NULL;
1513 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
1515 if (errno == EAGAIN || errno == EINTR)
1523 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
1524 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
1526 fd_array = (int*) CMSG_DATA(cmsg);
1527 n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1529 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1530 cmsg->cmsg_type == SCM_CREDENTIALS &&
1531 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
1533 ucred = (struct ucred*) CMSG_DATA(cmsg);
1540 r = fdset_new_array(&fds, fd_array, n_fds);
1542 close_many(fd_array, n_fds);
1547 if (!ucred || ucred->pid <= 0) {
1548 log_warning("Received notify message without valid credentials. Ignoring.");
1552 if ((size_t) n >= sizeof(buf)) {
1553 log_warning("Received notify message exceeded maximum size. Ignoring.");
1559 /* Notify every unit that might be interested, but try
1560 * to avoid notifying the same one multiple times. */
1561 u1 = manager_get_unit_by_pid(m, ucred->pid);
1563 manager_invoke_notify_message(m, u1, ucred->pid, buf, n, fds);
1567 u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1568 if (u2 && u2 != u1) {
1569 manager_invoke_notify_message(m, u2, ucred->pid, buf, n, fds);
1573 u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1574 if (u3 && u3 != u2 && u3 != u1) {
1575 manager_invoke_notify_message(m, u3, ucred->pid, buf, n, fds);
1580 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1582 if (fdset_size(fds) > 0)
1583 log_warning("Got auxiliary fds with notification message, closing all.");
1589 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1594 log_unit_debug(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1596 unit_unwatch_pid(u, si->si_pid);
1597 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1600 static int manager_dispatch_sigchld(Manager *m) {
1606 /* First we call waitd() for a PID and do not reap the
1607 * zombie. That way we can still access /proc/$PID for
1608 * it while it is a zombie. */
1609 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1611 if (errno == ECHILD)
1623 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1624 _cleanup_free_ char *name = NULL;
1627 get_process_comm(si.si_pid, &name);
1629 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1630 si.si_pid, strna(name),
1631 sigchld_code_to_string(si.si_code),
1633 strna(si.si_code == CLD_EXITED
1634 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1635 : signal_to_string(si.si_status)));
1637 /* And now figure out the unit this belongs
1638 * to, it might be multiple... */
1639 u1 = manager_get_unit_by_pid(m, si.si_pid);
1641 invoke_sigchld_event(m, u1, &si);
1642 u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1644 invoke_sigchld_event(m, u2, &si);
1645 u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1646 if (u3 && u3 != u2 && u3 != u1)
1647 invoke_sigchld_event(m, u3, &si);
1650 /* And now, we actually reap the zombie. */
1651 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1662 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1663 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1666 log_unit_debug(name, "Activating special unit %s", name);
1668 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1670 log_unit_error(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1675 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1676 Manager *m = userdata;
1678 struct signalfd_siginfo sfsi;
1679 bool sigchld = false;
1682 assert(m->signal_fd == fd);
1684 if (revents != EPOLLIN) {
1685 log_warning("Got unexpected events from signal file descriptor.");
1690 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1691 if (n != sizeof(sfsi)) {
1696 if (errno == EINTR || errno == EAGAIN)
1702 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1703 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1704 ? LOG_DEBUG : LOG_INFO,
1707 switch (sfsi.ssi_signo) {
1714 if (m->running_as == SYSTEMD_SYSTEM) {
1715 /* This is for compatibility with the
1716 * original sysvinit */
1717 m->exit_code = MANAGER_REEXECUTE;
1724 if (m->running_as == SYSTEMD_SYSTEM) {
1725 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1729 /* Run the exit target if there is one, if not, just exit. */
1730 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1731 m->exit_code = MANAGER_EXIT;
1738 if (m->running_as == SYSTEMD_SYSTEM)
1739 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1741 /* This is a nop on non-init */
1745 if (m->running_as == SYSTEMD_SYSTEM)
1746 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1748 /* This is a nop on non-init */
1754 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1756 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1757 log_info("Trying to reconnect to bus...");
1761 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1762 log_info("Loading D-Bus service...");
1763 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1770 _cleanup_free_ char *dump = NULL;
1771 _cleanup_fclose_ FILE *f = NULL;
1774 f = open_memstream(&dump, &size);
1776 log_warning("Failed to allocate memory stream.");
1780 manager_dump_units(m, f, "\t");
1781 manager_dump_jobs(m, f, "\t");
1784 log_warning("Failed to write status stream");
1789 log_warning("Failed to flush status stream");
1793 log_dump(LOG_INFO, dump);
1798 m->exit_code = MANAGER_RELOAD;
1803 /* Starting SIGRTMIN+0 */
1804 static const char * const target_table[] = {
1805 [0] = SPECIAL_DEFAULT_TARGET,
1806 [1] = SPECIAL_RESCUE_TARGET,
1807 [2] = SPECIAL_EMERGENCY_TARGET,
1808 [3] = SPECIAL_HALT_TARGET,
1809 [4] = SPECIAL_POWEROFF_TARGET,
1810 [5] = SPECIAL_REBOOT_TARGET,
1811 [6] = SPECIAL_KEXEC_TARGET
1814 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1815 static const ManagerExitCode code_table[] = {
1817 [1] = MANAGER_POWEROFF,
1818 [2] = MANAGER_REBOOT,
1822 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1823 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1824 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1825 manager_start_target(m, target_table[idx],
1826 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1830 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1831 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1832 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1836 switch (sfsi.ssi_signo - SIGRTMIN) {
1839 log_debug("Enabling showing of status.");
1840 manager_set_show_status(m, SHOW_STATUS_YES);
1844 log_debug("Disabling showing of status.");
1845 manager_set_show_status(m, SHOW_STATUS_NO);
1849 log_set_max_level(LOG_DEBUG);
1850 log_notice("Setting log level to debug.");
1854 log_set_max_level(LOG_INFO);
1855 log_notice("Setting log level to info.");
1859 if (m->running_as == SYSTEMD_USER) {
1860 m->exit_code = MANAGER_EXIT;
1864 /* This is a nop on init */
1868 case 29: /* compatibility: used to be mapped to LOG_TARGET_SYSLOG_OR_KMSG */
1869 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1870 log_notice("Setting log target to journal-or-kmsg.");
1874 log_set_target(LOG_TARGET_CONSOLE);
1875 log_notice("Setting log target to console.");
1879 log_set_target(LOG_TARGET_KMSG);
1880 log_notice("Setting log target to kmsg.");
1884 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1891 manager_dispatch_sigchld(m);
1896 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1897 Manager *m = userdata;
1902 assert(m->time_change_fd == fd);
1904 log_struct(LOG_INFO,
1905 LOG_MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1906 LOG_MESSAGE("Time has been changed"),
1909 /* Restart the watch */
1910 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1911 m->time_change_fd = safe_close(m->time_change_fd);
1913 manager_setup_time_change(m);
1915 HASHMAP_FOREACH(u, m->units, i)
1916 if (UNIT_VTABLE(u)->time_change)
1917 UNIT_VTABLE(u)->time_change(u);
1922 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1923 Manager *m = userdata;
1926 assert(m->idle_pipe[2] == fd);
1928 m->no_console_output = m->n_on_console > 0;
1930 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1931 manager_close_idle_pipe(m);
1936 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1937 Manager *m = userdata;
1944 manager_print_jobs_in_progress(m);
1946 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1947 r = sd_event_source_set_time(source, next);
1951 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1954 int manager_loop(Manager *m) {
1957 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1960 m->exit_code = MANAGER_OK;
1962 /* Release the path cache */
1963 set_free_free(m->unit_path_cache);
1964 m->unit_path_cache = NULL;
1966 manager_check_finished(m);
1968 /* There might still be some zombies hanging around from
1969 * before we were exec()'ed. Let's reap them. */
1970 r = manager_dispatch_sigchld(m);
1974 while (m->exit_code == MANAGER_OK) {
1977 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1980 if (!ratelimit_test(&rl)) {
1981 /* Yay, something is going seriously wrong, pause a little */
1982 log_warning("Looping too fast. Throttling execution a little.");
1987 if (manager_dispatch_load_queue(m) > 0)
1990 if (manager_dispatch_gc_queue(m) > 0)
1993 if (manager_dispatch_cleanup_queue(m) > 0)
1996 if (manager_dispatch_cgroup_queue(m) > 0)
1999 if (manager_dispatch_dbus_queue(m) > 0)
2002 /* Sleep for half the watchdog time */
2003 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
2004 wait_usec = m->runtime_watchdog / 2;
2008 wait_usec = USEC_INFINITY;
2010 r = sd_event_run(m->event, wait_usec);
2012 return log_error_errno(r, "Failed to run event loop: %m");
2015 return m->exit_code;
2018 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
2019 _cleanup_free_ char *n = NULL;
2027 r = unit_name_from_dbus_path(s, &n);
2031 r = manager_load_unit(m, n, NULL, e, &u);
2040 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
2050 p = startswith(s, "/org/freedesktop/systemd1/job/");
2054 r = safe_atou(p, &id);
2058 j = manager_get_job(m, id);
2067 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
2070 _cleanup_free_ char *p = NULL;
2074 audit_fd = get_audit_fd();
2078 /* Don't generate audit events if the service was already
2079 * started and we're just deserializing */
2080 if (m->n_reloading > 0)
2083 if (m->running_as != SYSTEMD_SYSTEM)
2086 if (u->type != UNIT_SERVICE)
2089 p = unit_name_to_prefix_and_instance(u->id);
2095 msg = strappenda("unit=", p);
2097 if (audit_log_user_comm_message(audit_fd, type, msg, "systemd", NULL, NULL, NULL, success) < 0) {
2099 /* We aren't allowed to send audit messages?
2100 * Then let's not retry again. */
2103 log_warning_errno(errno, "Failed to send audit message: %m");
2109 void manager_send_unit_plymouth(Manager *m, Unit *u) {
2110 union sockaddr_union sa = PLYMOUTH_SOCKET;
2113 _cleanup_free_ char *message = NULL;
2114 _cleanup_close_ int fd = -1;
2116 /* Don't generate plymouth events if the service was already
2117 * started and we're just deserializing */
2118 if (m->n_reloading > 0)
2121 if (m->running_as != SYSTEMD_SYSTEM)
2124 if (detect_container(NULL) > 0)
2127 if (u->type != UNIT_SERVICE &&
2128 u->type != UNIT_MOUNT &&
2129 u->type != UNIT_SWAP)
2132 /* We set SOCK_NONBLOCK here so that we rather drop the
2133 * message then wait for plymouth */
2134 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2136 log_error_errno(errno, "socket() failed: %m");
2140 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2142 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2143 log_error_errno(errno, "connect() failed: %m");
2147 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2153 if (write(fd, message, n + 1) != n + 1)
2154 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2155 log_error_errno(errno, "Failed to write Plymouth message: %m");
2158 void manager_dispatch_bus_name_owner_changed(
2161 const char* old_owner,
2162 const char *new_owner) {
2169 u = hashmap_get(m->watch_bus, name);
2173 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2176 int manager_open_serialization(Manager *m, FILE **_f) {
2183 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2184 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2188 log_debug("Serializing state to %s", path);
2190 f = fdopen(fd, "w+");
2201 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2214 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2215 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2216 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2217 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2219 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2220 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2221 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2222 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2225 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2226 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2227 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2228 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2229 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2230 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2231 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2232 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2235 if (!switching_root) {
2236 STRV_FOREACH(e, m->environment) {
2237 _cleanup_free_ char *ce;
2243 fprintf(f, "env=%s\n", *e);
2247 if (m->notify_fd >= 0) {
2250 copy = fdset_put_dup(fds, m->notify_fd);
2254 fprintf(f, "notify-fd=%i\n", copy);
2255 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2258 if (m->kdbus_fd >= 0) {
2261 copy = fdset_put_dup(fds, m->kdbus_fd);
2265 fprintf(f, "kdbus-fd=%i\n", copy);
2268 bus_track_serialize(m->subscribed, f);
2272 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2280 r = unit_serialize(u, f, fds, !switching_root);
2287 assert(m->n_reloading > 0);
2293 r = bus_fdset_add_all(m, fds);
2300 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2306 log_debug("Deserializing state...");
2311 char line[LINE_MAX], *l;
2313 if (!fgets(line, sizeof(line), f)) {
2328 if (startswith(l, "current-job-id=")) {
2331 if (safe_atou32(l+15, &id) < 0)
2332 log_debug("Failed to parse current job id value %s", l+15);
2334 m->current_job_id = MAX(m->current_job_id, id);
2336 } else if (startswith(l, "n-installed-jobs=")) {
2339 if (safe_atou32(l+17, &n) < 0)
2340 log_debug("Failed to parse installed jobs counter %s", l+17);
2342 m->n_installed_jobs += n;
2344 } else if (startswith(l, "n-failed-jobs=")) {
2347 if (safe_atou32(l+14, &n) < 0)
2348 log_debug("Failed to parse failed jobs counter %s", l+14);
2350 m->n_failed_jobs += n;
2352 } else if (startswith(l, "taint-usr=")) {
2355 b = parse_boolean(l+10);
2357 log_debug("Failed to parse taint /usr flag %s", l+10);
2359 m->taint_usr = m->taint_usr || b;
2361 } else if (startswith(l, "firmware-timestamp="))
2362 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2363 else if (startswith(l, "loader-timestamp="))
2364 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2365 else if (startswith(l, "kernel-timestamp="))
2366 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2367 else if (startswith(l, "initrd-timestamp="))
2368 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2369 else if (startswith(l, "userspace-timestamp="))
2370 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2371 else if (startswith(l, "finish-timestamp="))
2372 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2373 else if (startswith(l, "security-start-timestamp="))
2374 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2375 else if (startswith(l, "security-finish-timestamp="))
2376 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2377 else if (startswith(l, "generators-start-timestamp="))
2378 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2379 else if (startswith(l, "generators-finish-timestamp="))
2380 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2381 else if (startswith(l, "units-load-start-timestamp="))
2382 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2383 else if (startswith(l, "units-load-finish-timestamp="))
2384 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2385 else if (startswith(l, "env=")) {
2386 _cleanup_free_ char *uce = NULL;
2389 uce = cunescape(l+4);
2395 e = strv_env_set(m->environment, uce);
2401 strv_free(m->environment);
2404 } else if (startswith(l, "notify-fd=")) {
2407 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2408 log_debug("Failed to parse notify fd: %s", l + 10);
2410 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2411 safe_close(m->notify_fd);
2412 m->notify_fd = fdset_remove(fds, fd);
2415 } else if (startswith(l, "notify-socket=")) {
2424 free(m->notify_socket);
2425 m->notify_socket = n;
2427 } else if (startswith(l, "kdbus-fd=")) {
2430 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2431 log_debug("Failed to parse kdbus fd: %s", l + 9);
2433 safe_close(m->kdbus_fd);
2434 m->kdbus_fd = fdset_remove(fds, fd);
2440 k = bus_track_deserialize_item(&m->deserialized_subscribed, l);
2442 log_debug_errno(k, "Failed to deserialize bus tracker object: %m");
2444 log_debug("Unknown serialization item '%s'", l);
2450 char name[UNIT_NAME_MAX+2];
2453 if (!fgets(name, sizeof(name), f)) {
2464 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2468 r = unit_deserialize(u, f, fds);
2477 assert(m->n_reloading > 0);
2483 int manager_reload(Manager *m) {
2485 _cleanup_fclose_ FILE *f = NULL;
2486 _cleanup_fdset_free_ FDSet *fds = NULL;
2490 r = manager_open_serialization(m, &f);
2495 bus_manager_send_reloading(m, true);
2503 r = manager_serialize(m, f, fds, false);
2509 if (fseeko(f, 0, SEEK_SET) < 0) {
2514 /* From here on there is no way back. */
2515 manager_clear_jobs_and_units(m);
2516 manager_undo_generators(m);
2517 lookup_paths_free(&m->lookup_paths);
2519 /* Find new unit paths */
2520 manager_run_generators(m);
2522 q = lookup_paths_init(
2523 &m->lookup_paths, m->running_as, true,
2525 m->generator_unit_path,
2526 m->generator_unit_path_early,
2527 m->generator_unit_path_late);
2531 manager_build_unit_path_cache(m);
2533 /* First, enumerate what we can from all config files */
2534 q = manager_enumerate(m);
2538 /* Second, deserialize our stored data */
2539 q = manager_deserialize(m, f, fds);
2546 /* Re-register notify_fd as event source */
2547 q = manager_setup_notify(m);
2551 /* Third, fire things up! */
2552 q = manager_coldplug(m);
2556 assert(m->n_reloading > 0);
2559 m->send_reloading_done = true;
2564 bool manager_is_reloading_or_reexecuting(Manager *m) {
2567 return m->n_reloading != 0;
2570 void manager_reset_failed(Manager *m) {
2576 HASHMAP_FOREACH(u, m->units, i)
2577 unit_reset_failed(u);
2580 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2586 /* Returns true if the unit is inactive or going down */
2587 u = manager_get_unit(m, name);
2591 return unit_inactive_or_pending(u);
2594 static void manager_notify_finished(Manager *m) {
2595 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2596 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2601 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2603 /* Note that m->kernel_usec.monotonic is always at 0,
2604 * and m->firmware_usec.monotonic and
2605 * m->loader_usec.monotonic should be considered
2606 * negative values. */
2608 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2609 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2610 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2611 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2613 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2615 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2616 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2618 log_struct(LOG_INFO,
2619 LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2620 "KERNEL_USEC="USEC_FMT, kernel_usec,
2621 "INITRD_USEC="USEC_FMT, initrd_usec,
2622 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2623 LOG_MESSAGE("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2624 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2625 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2626 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2627 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2630 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2633 log_struct(LOG_INFO,
2634 LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2635 "KERNEL_USEC="USEC_FMT, kernel_usec,
2636 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2637 LOG_MESSAGE("Startup finished in %s (kernel) + %s (userspace) = %s.",
2638 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2639 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2640 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2644 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2645 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2647 log_struct(LOG_INFO,
2648 LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2649 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2650 LOG_MESSAGE("Startup finished in %s.",
2651 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2655 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2659 "STATUS=Startup finished in %s.",
2660 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2663 void manager_check_finished(Manager *m) {
2669 if (hashmap_size(m->jobs) > 0) {
2671 if (m->jobs_in_progress_event_source)
2672 sd_event_source_set_time(m->jobs_in_progress_event_source, now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2677 manager_flip_auto_status(m, false);
2679 /* Notify Type=idle units that we are done now */
2680 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2681 manager_close_idle_pipe(m);
2683 /* Turn off confirm spawn now */
2684 m->confirm_spawn = false;
2686 /* No need to update ask password status when we're going non-interactive */
2687 manager_close_ask_password(m);
2689 /* This is no longer the first boot */
2690 manager_set_first_boot(m, false);
2692 if (dual_timestamp_is_set(&m->finish_timestamp))
2695 dual_timestamp_get(&m->finish_timestamp);
2697 manager_notify_finished(m);
2699 SET_FOREACH(u, m->startup_units, i)
2701 cgroup_context_apply(unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path, manager_state(m));
2704 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2715 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2716 /* systemd --system, not running --test */
2718 p = strappend("/run/systemd/", name);
2722 r = mkdir_p_label(p, 0755);
2724 log_error_errno(r, "Failed to create generator directory %s: %m", p);
2728 } else if (m->running_as == SYSTEMD_USER) {
2729 const char *s = NULL;
2731 s = getenv("XDG_RUNTIME_DIR");
2734 p = strjoin(s, "/systemd/", name, NULL);
2738 r = mkdir_p_label(p, 0755);
2740 log_error_errno(r, "Failed to create generator directory %s: %m", p);
2745 /* systemd --system --test */
2747 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2752 log_error_errno(errno, "Failed to create generator directory %s: %m",
2763 static void trim_generator_dir(Manager *m, char **generator) {
2770 if (rmdir(*generator) >= 0) {
2778 void manager_run_generators(Manager *m) {
2779 _cleanup_closedir_ DIR *d = NULL;
2780 const char *generator_path;
2781 const char *argv[5];
2789 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2790 d = opendir(generator_path);
2792 if (errno == ENOENT)
2795 log_error_errno(errno, "Failed to enumerate generator directory %s: %m",
2800 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2804 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2808 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2812 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2813 argv[1] = m->generator_unit_path;
2814 argv[2] = m->generator_unit_path_early;
2815 argv[3] = m->generator_unit_path_late;
2818 RUN_WITH_UMASK(0022)
2819 execute_directory(generator_path, d, DEFAULT_TIMEOUT_USEC, (char**) argv);
2822 trim_generator_dir(m, &m->generator_unit_path);
2823 trim_generator_dir(m, &m->generator_unit_path_early);
2824 trim_generator_dir(m, &m->generator_unit_path_late);
2827 static void remove_generator_dir(Manager *m, char **generator) {
2834 strv_remove(m->lookup_paths.unit_path, *generator);
2835 rm_rf(*generator, false, true, false);
2841 void manager_undo_generators(Manager *m) {
2844 remove_generator_dir(m, &m->generator_unit_path);
2845 remove_generator_dir(m, &m->generator_unit_path_early);
2846 remove_generator_dir(m, &m->generator_unit_path_late);
2849 int manager_environment_add(Manager *m, char **minus, char **plus) {
2850 char **a = NULL, **b = NULL, **l;
2855 if (!strv_isempty(minus)) {
2856 a = strv_env_delete(l, 1, minus);
2863 if (!strv_isempty(plus)) {
2864 b = strv_env_merge(2, l, plus);
2873 if (m->environment != l)
2874 strv_free(m->environment);
2881 manager_clean_environment(m);
2882 strv_sort(m->environment);
2887 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2892 for (i = 0; i < _RLIMIT_MAX; i++) {
2893 if (!default_rlimit[i])
2896 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2904 void manager_recheck_journal(Manager *m) {
2909 if (m->running_as != SYSTEMD_SYSTEM)
2912 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2913 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2914 log_close_journal();
2918 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2919 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2920 log_close_journal();
2924 /* Hmm, OK, so the socket is fully up and the service is up
2925 * too, then let's make use of the thing. */
2929 void manager_set_show_status(Manager *m, ShowStatus mode) {
2931 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2933 if (m->running_as != SYSTEMD_SYSTEM)
2936 m->show_status = mode;
2939 touch("/run/systemd/show-status");
2941 unlink("/run/systemd/show-status");
2944 static bool manager_get_show_status(Manager *m, StatusType type) {
2947 if (m->running_as != SYSTEMD_SYSTEM)
2950 if (m->no_console_output)
2953 if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
2956 /* If we cannot find out the status properly, just proceed. */
2957 if (type != STATUS_TYPE_EMERGENCY && manager_check_ask_password(m) > 0)
2960 if (m->show_status > 0)
2963 /* If Plymouth is running make sure we show the status, so
2964 * that there's something nice to see when people press Esc */
2965 return plymouth_running();
2968 void manager_set_first_boot(Manager *m, bool b) {
2971 if (m->running_as != SYSTEMD_SYSTEM)
2977 touch("/run/systemd/first-boot");
2979 unlink("/run/systemd/first-boot");
2982 void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) {
2985 /* If m is NULL, assume we're after shutdown and let the messages through. */
2987 if (m && !manager_get_show_status(m, type))
2990 /* XXX We should totally drop the check for ephemeral here
2991 * and thus effectively make 'Type=idle' pointless. */
2992 if (type == STATUS_TYPE_EPHEMERAL && m && m->n_on_console > 0)
2995 va_start(ap, format);
2996 status_vprintf(status, true, type == STATUS_TYPE_EPHEMERAL, format, ap);
3000 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
3001 _cleanup_free_ char *p = NULL;
3009 p = unit_name_from_path(path, suffix);
3013 found = manager_get_unit(m, p);
3023 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
3024 char p[strlen(path)+1];
3030 path_kill_slashes(p);
3032 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
3035 const char *manager_get_runtime_prefix(Manager *m) {
3038 return m->running_as == SYSTEMD_SYSTEM ?
3040 getenv("XDG_RUNTIME_DIR");
3043 ManagerState manager_state(Manager *m) {
3048 /* Did we ever finish booting? If not then we are still starting up */
3049 if (!dual_timestamp_is_set(&m->finish_timestamp)) {
3051 u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
3052 if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
3053 return MANAGER_INITIALIZING;
3055 return MANAGER_STARTING;
3058 /* Is the special shutdown target queued? If so, we are in shutdown state */
3059 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
3060 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
3061 return MANAGER_STOPPING;
3063 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
3064 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
3065 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3066 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3067 return MANAGER_MAINTENANCE;
3069 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
3070 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3071 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3072 return MANAGER_MAINTENANCE;
3074 /* Are there any failed units? If so, we are in degraded mode */
3075 if (set_size(m->failed_units) > 0)
3076 return MANAGER_DEGRADED;
3078 return MANAGER_RUNNING;
3081 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
3082 [MANAGER_INITIALIZING] = "initializing",
3083 [MANAGER_STARTING] = "starting",
3084 [MANAGER_RUNNING] = "running",
3085 [MANAGER_DEGRADED] = "degraded",
3086 [MANAGER_MAINTENANCE] = "maintenance",
3087 [MANAGER_STOPPING] = "stopping",
3090 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);