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 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
88 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
89 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
90 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
91 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
92 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
93 static int manager_run_generators(Manager *m);
94 static void manager_undo_generators(Manager *m);
96 static int manager_watch_jobs_in_progress(Manager *m) {
101 if (m->jobs_in_progress_event_source)
104 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
105 return sd_event_add_time(
107 &m->jobs_in_progress_event_source,
110 manager_dispatch_jobs_in_progress, m);
113 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
115 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
118 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
119 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
123 p = mempset(p, ' ', pos-2);
124 p = stpcpy(p, ANSI_RED_ON);
128 if (pos > 0 && pos <= width) {
129 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
133 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
136 p = stpcpy(p, ANSI_RED_ON);
139 p = mempset(p, ' ', width-1-pos);
140 strcpy(p, ANSI_HIGHLIGHT_OFF);
144 void manager_flip_auto_status(Manager *m, bool enable) {
148 if (m->show_status == SHOW_STATUS_AUTO)
149 manager_set_show_status(m, SHOW_STATUS_TEMPORARY);
151 if (m->show_status == SHOW_STATUS_TEMPORARY)
152 manager_set_show_status(m, SHOW_STATUS_AUTO);
156 static void manager_print_jobs_in_progress(Manager *m) {
157 _cleanup_free_ char *job_of_n = NULL;
160 unsigned counter = 0, print_nr;
161 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
163 char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
167 assert(m->n_running_jobs > 0);
169 manager_flip_auto_status(m, true);
171 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
173 HASHMAP_FOREACH(j, m->jobs, i)
174 if (j->state == JOB_RUNNING && counter++ == print_nr)
177 /* m->n_running_jobs must be consistent with the contents of m->jobs,
178 * so the above loop must have succeeded in finding j. */
179 assert(counter == print_nr + 1);
182 cylon_pos = m->jobs_in_progress_iteration % 14;
184 cylon_pos = 14 - cylon_pos;
185 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
187 m->jobs_in_progress_iteration++;
189 if (m->n_running_jobs > 1)
190 asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs);
192 format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
193 if (job_get_timeout(j, &x) > 0)
194 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
196 manager_status_printf(m, STATUS_TYPE_EPHEMERAL, cylon,
197 "%sA %s job is running for %s (%s / %s)",
199 job_type_to_string(j->type),
200 unit_description(j->unit),
204 static int have_ask_password(void) {
205 _cleanup_closedir_ DIR *dir;
207 dir = opendir("/run/systemd/ask-password");
220 if (!de && errno != 0)
225 if (startswith(de->d_name, "ask."))
230 static int manager_dispatch_ask_password_fd(sd_event_source *source,
231 int fd, uint32_t revents, void *userdata) {
232 Manager *m = userdata;
238 m->have_ask_password = have_ask_password();
239 if (m->have_ask_password < 0)
240 /* Log error but continue. Negative have_ask_password
241 * is treated as unknown status. */
242 log_error_errno(m->have_ask_password, "Failed to list /run/systemd/ask-password: %m");
247 static void manager_close_ask_password(Manager *m) {
250 m->ask_password_inotify_fd = safe_close(m->ask_password_inotify_fd);
251 m->ask_password_event_source = sd_event_source_unref(m->ask_password_event_source);
252 m->have_ask_password = -EINVAL;
255 static int manager_check_ask_password(Manager *m) {
260 if (!m->ask_password_event_source) {
261 assert(m->ask_password_inotify_fd < 0);
263 mkdir_p_label("/run/systemd/ask-password", 0755);
265 m->ask_password_inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
266 if (m->ask_password_inotify_fd < 0)
267 return log_error_errno(errno, "inotify_init1() failed: %m");
269 if (inotify_add_watch(m->ask_password_inotify_fd, "/run/systemd/ask-password", IN_CREATE|IN_DELETE|IN_MOVE) < 0) {
270 log_error_errno(errno, "Failed to add watch on /run/systemd/ask-password: %m");
271 manager_close_ask_password(m);
275 r = sd_event_add_io(m->event, &m->ask_password_event_source,
276 m->ask_password_inotify_fd, EPOLLIN,
277 manager_dispatch_ask_password_fd, m);
279 log_error_errno(errno, "Failed to add event source for /run/systemd/ask-password: %m");
280 manager_close_ask_password(m);
284 /* Queries might have been added meanwhile... */
285 manager_dispatch_ask_password_fd(m->ask_password_event_source,
286 m->ask_password_inotify_fd, EPOLLIN, m);
289 return m->have_ask_password;
292 static int manager_watch_idle_pipe(Manager *m) {
297 if (m->idle_pipe_event_source)
300 if (m->idle_pipe[2] < 0)
303 r = sd_event_add_io(m->event, &m->idle_pipe_event_source, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m);
305 return log_error_errno(r, "Failed to watch idle pipe: %m");
310 static void manager_close_idle_pipe(Manager *m) {
313 safe_close_pair(m->idle_pipe);
314 safe_close_pair(m->idle_pipe + 2);
317 static int manager_setup_time_change(Manager *m) {
320 /* We only care for the cancellation event, hence we set the
321 * timeout to the latest possible value. */
322 struct itimerspec its = {
323 .it_value.tv_sec = TIME_T_MAX,
327 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
332 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
333 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
335 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
336 if (m->time_change_fd < 0)
337 return log_error_errno(errno, "Failed to create timerfd: %m");
339 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
340 log_debug_errno(errno, "Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
341 m->time_change_fd = safe_close(m->time_change_fd);
345 r = sd_event_add_io(m->event, &m->time_change_event_source, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m);
347 return log_error_errno(r, "Failed to create time change event source: %m");
349 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
354 static int enable_special_signals(Manager *m) {
355 _cleanup_close_ int fd = -1;
359 /* Enable that we get SIGINT on control-alt-del. In containers
360 * this will fail with EPERM (older) or EINVAL (newer), so
362 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
363 log_warning_errno(errno, "Failed to enable ctrl-alt-del handling: %m");
365 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
367 /* Support systems without virtual console */
369 log_warning_errno(errno, "Failed to open /dev/tty0: %m");
371 /* Enable that we get SIGWINCH on kbrequest */
372 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
373 log_warning_errno(errno, "Failed to enable kbrequest handling: %m");
379 static int manager_setup_signals(Manager *m) {
380 struct sigaction sa = {
381 .sa_handler = SIG_DFL,
382 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
389 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
391 /* We make liberal use of realtime signals here. On
392 * Linux/glibc we have 30 of them (with the exception of Linux
393 * on hppa, see below), between SIGRTMIN+0 ... SIGRTMIN+30
396 assert_se(sigemptyset(&mask) == 0);
397 sigset_add_many(&mask,
398 SIGCHLD, /* Child died */
399 SIGTERM, /* Reexecute daemon */
400 SIGHUP, /* Reload configuration */
401 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
402 SIGUSR2, /* systemd: dump status */
403 SIGINT, /* Kernel sends us this on control-alt-del */
404 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
405 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
407 SIGRTMIN+0, /* systemd: start default.target */
408 SIGRTMIN+1, /* systemd: isolate rescue.target */
409 SIGRTMIN+2, /* systemd: isolate emergency.target */
410 SIGRTMIN+3, /* systemd: start halt.target */
411 SIGRTMIN+4, /* systemd: start poweroff.target */
412 SIGRTMIN+5, /* systemd: start reboot.target */
413 SIGRTMIN+6, /* systemd: start kexec.target */
415 /* ... space for more special targets ... */
417 SIGRTMIN+13, /* systemd: Immediate halt */
418 SIGRTMIN+14, /* systemd: Immediate poweroff */
419 SIGRTMIN+15, /* systemd: Immediate reboot */
420 SIGRTMIN+16, /* systemd: Immediate kexec */
422 /* ... space for more immediate system state changes ... */
424 SIGRTMIN+20, /* systemd: enable status messages */
425 SIGRTMIN+21, /* systemd: disable status messages */
426 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
427 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
428 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
430 /* .. one free signal here ... */
432 #if !defined(__hppa64__) && !defined(__hppa__)
433 /* Apparently Linux on hppa has fewer RT
434 * signals (SIGRTMAX is SIGRTMIN+25 there),
435 * hence let's not try to make use of them
436 * here. Since these commands are accessible
437 * by different means and only really a safety
438 * net, the missing functionality on hppa
439 * shouldn't matter. */
441 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
442 SIGRTMIN+27, /* systemd: set log target to console */
443 SIGRTMIN+28, /* systemd: set log target to kmsg */
444 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg (obsolete) */
446 /* ... one free signal here SIGRTMIN+30 ... */
449 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
451 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
452 if (m->signal_fd < 0)
455 r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);
459 /* Process signals a bit earlier than the rest of things, but
460 * later than notify_fd processing, so that the notify
461 * processing can still figure out to which process/service a
462 * message belongs, before we reap the process. */
463 r = sd_event_source_set_priority(m->signal_event_source, -5);
467 if (m->running_as == SYSTEMD_SYSTEM)
468 return enable_special_signals(m);
473 static void manager_clean_environment(Manager *m) {
476 /* Let's remove some environment variables that we
477 * need ourselves to communicate with our clients */
490 static int manager_default_environment(Manager *m) {
493 if (m->running_as == SYSTEMD_SYSTEM) {
494 /* The system manager always starts with a clean
495 * environment for its children. It does not import
496 * the kernel or the parents exported variables.
498 * The initial passed environ is untouched to keep
499 * /proc/self/environ valid; it is used for tagging
500 * the init process inside containers. */
501 m->environment = strv_new("PATH=" DEFAULT_PATH,
504 /* Import locale variables LC_*= from configuration */
505 locale_setup(&m->environment);
507 /* The user manager passes its own environment
508 * along to its children. */
509 m->environment = strv_copy(environ);
515 manager_clean_environment(m);
516 strv_sort(m->environment);
521 int manager_new(SystemdRunningAs running_as, bool test_run, Manager **_m) {
526 assert(running_as >= 0);
527 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
529 m = new0(Manager, 1);
534 if (running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0)
535 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
538 m->running_as = running_as;
539 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
540 m->default_timer_accuracy_usec = USEC_PER_MINUTE;
542 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
544 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;
545 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
547 m->ask_password_inotify_fd = -1;
548 m->have_ask_password = -EINVAL; /* we don't know */
550 m->test_run = test_run;
552 r = manager_default_environment(m);
556 r = hashmap_ensure_allocated(&m->units, &string_hash_ops);
560 r = hashmap_ensure_allocated(&m->jobs, NULL);
564 r = hashmap_ensure_allocated(&m->cgroup_unit, &string_hash_ops);
568 r = hashmap_ensure_allocated(&m->watch_bus, &string_hash_ops);
572 r = set_ensure_allocated(&m->startup_units, NULL);
576 r = set_ensure_allocated(&m->failed_units, NULL);
580 r = sd_event_default(&m->event);
584 r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
588 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
592 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
596 r = manager_setup_signals(m);
600 r = manager_setup_cgroup(m);
604 r = manager_setup_time_change(m);
608 m->udev = udev_new();
614 /* Note that we set up neither kdbus, nor the notify fd
615 * here. We do that after deserialization, since they might
616 * have gotten serialized across the reexec. */
618 m->taint_usr = dir_is_empty("/usr") > 0;
628 static int manager_setup_notify(Manager *m) {
634 if (m->notify_fd < 0) {
635 _cleanup_close_ int fd = -1;
636 union sockaddr_union sa = {
637 .sa.sa_family = AF_UNIX,
639 static const int one = 1;
641 /* First free all secondary fields */
642 free(m->notify_socket);
643 m->notify_socket = NULL;
644 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
646 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
648 return log_error_errno(errno, "Failed to allocate notification socket: %m");
650 if (m->running_as == SYSTEMD_SYSTEM)
651 m->notify_socket = strdup("/run/systemd/notify");
655 e = getenv("XDG_RUNTIME_DIR");
657 log_error_errno(errno, "XDG_RUNTIME_DIR is not set: %m");
661 m->notify_socket = strappend(e, "/systemd/notify");
663 if (!m->notify_socket)
666 (void) mkdir_parents_label(m->notify_socket, 0755);
667 (void) unlink(m->notify_socket);
669 strncpy(sa.un.sun_path, m->notify_socket, sizeof(sa.un.sun_path)-1);
670 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path));
672 return log_error_errno(errno, "bind(%s) failed: %m", sa.un.sun_path);
674 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
676 return log_error_errno(errno, "SO_PASSCRED failed: %m");
681 log_debug("Using notification socket %s", m->notify_socket);
684 if (!m->notify_event_source) {
685 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
687 return log_error_errno(r, "Failed to allocate notify event source: %m");
689 /* Process signals a bit earlier than SIGCHLD, so that we can
690 * still identify to which service an exit message belongs */
691 r = sd_event_source_set_priority(m->notify_event_source, -7);
693 return log_error_errno(r, "Failed to set priority of notify event source: %m");
699 static int manager_setup_kdbus(Manager *m) {
701 _cleanup_free_ char *p = NULL;
705 if (m->test_run || m->kdbus_fd >= 0)
708 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0)
709 bus_kernel_fix_attach_mask();
711 m->kdbus_fd = bus_kernel_create_bus(
712 m->running_as == SYSTEMD_SYSTEM ? "system" : "user",
713 m->running_as == SYSTEMD_SYSTEM, &p);
716 return log_debug_errno(m->kdbus_fd, "Failed to set up kdbus: %m");
718 log_debug("Successfully set up kdbus on %s", p);
724 static int manager_connect_bus(Manager *m, bool reexecuting) {
725 bool try_bus_connect;
735 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
737 /* Try to connect to the busses, if possible. */
738 return bus_init(m, try_bus_connect);
741 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
747 while ((u = m->cleanup_queue)) {
748 assert(u->in_cleanup_queue);
758 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
759 GC_OFFSET_UNSURE, /* No clue */
760 GC_OFFSET_GOOD, /* We still need this unit */
761 GC_OFFSET_BAD, /* We don't need this unit anymore */
765 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
772 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
773 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
774 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
777 if (u->in_cleanup_queue)
780 if (unit_check_gc(u))
783 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
787 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
788 unit_gc_sweep(other, gc_marker);
790 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
793 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
800 /* We were unable to find anything out about this entry, so
801 * let's investigate it later */
802 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
803 unit_add_to_gc_queue(u);
807 /* We definitely know that this one is not useful anymore, so
808 * let's mark it for deletion */
809 u->gc_marker = gc_marker + GC_OFFSET_BAD;
810 unit_add_to_cleanup_queue(u);
814 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
817 static unsigned manager_dispatch_gc_queue(Manager *m) {
824 /* log_debug("Running GC..."); */
826 m->gc_marker += _GC_OFFSET_MAX;
827 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
830 gc_marker = m->gc_marker;
832 while ((u = m->gc_queue)) {
833 assert(u->in_gc_queue);
835 unit_gc_sweep(u, gc_marker);
837 LIST_REMOVE(gc_queue, m->gc_queue, u);
838 u->in_gc_queue = false;
842 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
843 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
844 log_unit_debug(u->id, "Collecting %s", u->id);
845 u->gc_marker = gc_marker + GC_OFFSET_BAD;
846 unit_add_to_cleanup_queue(u);
850 m->n_in_gc_queue = 0;
855 static void manager_clear_jobs_and_units(Manager *m) {
860 while ((u = hashmap_first(m->units)))
863 manager_dispatch_cleanup_queue(m);
865 assert(!m->load_queue);
866 assert(!m->run_queue);
867 assert(!m->dbus_unit_queue);
868 assert(!m->dbus_job_queue);
869 assert(!m->cleanup_queue);
870 assert(!m->gc_queue);
872 assert(hashmap_isempty(m->jobs));
873 assert(hashmap_isempty(m->units));
876 m->n_running_jobs = 0;
879 Manager* manager_free(Manager *m) {
886 manager_clear_jobs_and_units(m);
888 for (c = 0; c < _UNIT_TYPE_MAX; c++)
889 if (unit_vtable[c]->shutdown)
890 unit_vtable[c]->shutdown(m);
892 /* If we reexecute ourselves, we keep the root cgroup
894 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
896 manager_undo_generators(m);
900 hashmap_free(m->units);
901 hashmap_free(m->jobs);
902 hashmap_free(m->watch_pids1);
903 hashmap_free(m->watch_pids2);
904 hashmap_free(m->watch_bus);
906 set_free(m->startup_units);
907 set_free(m->failed_units);
909 sd_event_source_unref(m->signal_event_source);
910 sd_event_source_unref(m->notify_event_source);
911 sd_event_source_unref(m->time_change_event_source);
912 sd_event_source_unref(m->jobs_in_progress_event_source);
913 sd_event_source_unref(m->idle_pipe_event_source);
914 sd_event_source_unref(m->run_queue_event_source);
916 safe_close(m->signal_fd);
917 safe_close(m->notify_fd);
918 safe_close(m->time_change_fd);
919 safe_close(m->kdbus_fd);
921 manager_close_ask_password(m);
923 manager_close_idle_pipe(m);
926 sd_event_unref(m->event);
928 free(m->notify_socket);
930 lookup_paths_free(&m->lookup_paths);
931 strv_free(m->environment);
933 hashmap_free(m->cgroup_unit);
934 set_free_free(m->unit_path_cache);
936 free(m->switch_root);
937 free(m->switch_root_init);
939 for (i = 0; i < _RLIMIT_MAX; i++)
942 assert(hashmap_isempty(m->units_requiring_mounts_for));
943 hashmap_free(m->units_requiring_mounts_for);
949 int manager_enumerate(Manager *m) {
955 /* Let's ask every type to load all units from disk/kernel
956 * that it might know */
957 for (c = 0; c < _UNIT_TYPE_MAX; c++) {
960 if (unit_vtable[c]->supported && !unit_vtable[c]->supported(m)) {
961 log_info("Unit type .%s is not supported on this system.", unit_type_to_string(c));
965 if (!unit_vtable[c]->enumerate)
968 q = unit_vtable[c]->enumerate(m);
973 manager_dispatch_load_queue(m);
977 static int manager_coldplug(Manager *m) {
985 /* Then, let's set up their initial state. */
986 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
993 q = unit_coldplug(u);
1001 static void manager_build_unit_path_cache(Manager *m) {
1003 _cleanup_closedir_ DIR *d = NULL;
1008 set_free_free(m->unit_path_cache);
1010 m->unit_path_cache = set_new(&string_hash_ops);
1011 if (!m->unit_path_cache) {
1012 log_error("Failed to allocate unit path cache.");
1016 /* This simply builds a list of files we know exist, so that
1017 * we don't always have to go to disk */
1019 STRV_FOREACH(i, m->lookup_paths.unit_path) {
1024 if (errno != ENOENT)
1025 log_error_errno(errno, "Failed to open directory %s: %m", *i);
1029 while ((de = readdir(d))) {
1032 if (hidden_file(de->d_name))
1035 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
1041 r = set_consume(m->unit_path_cache, p);
1053 log_error_errno(r, "Failed to build unit path cache: %m");
1055 set_free_free(m->unit_path_cache);
1056 m->unit_path_cache = NULL;
1060 static int manager_distribute_fds(Manager *m, FDSet *fds) {
1067 HASHMAP_FOREACH(u, m->units, i) {
1069 if (fdset_size(fds) <= 0)
1072 if (UNIT_VTABLE(u)->distribute_fds) {
1073 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
1082 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
1087 dual_timestamp_get(&m->generators_start_timestamp);
1088 r = manager_run_generators(m);
1089 dual_timestamp_get(&m->generators_finish_timestamp);
1093 r = lookup_paths_init(
1094 &m->lookup_paths, m->running_as, true,
1096 m->generator_unit_path,
1097 m->generator_unit_path_early,
1098 m->generator_unit_path_late);
1102 manager_build_unit_path_cache(m);
1104 /* If we will deserialize make sure that during enumeration
1105 * this is already known, so we increase the counter here
1110 /* First, enumerate what we can from all config files */
1111 dual_timestamp_get(&m->units_load_start_timestamp);
1112 r = manager_enumerate(m);
1113 dual_timestamp_get(&m->units_load_finish_timestamp);
1115 /* Second, deserialize if there is something to deserialize */
1117 r = manager_deserialize(m, serialization, fds);
1119 /* Any fds left? Find some unit which wants them. This is
1120 * useful to allow container managers to pass some file
1121 * descriptors to us pre-initialized. This enables
1122 * socket-based activation of entire containers. */
1123 if (fdset_size(fds) > 0) {
1124 q = manager_distribute_fds(m, fds);
1125 if (q < 0 && r == 0)
1129 /* We might have deserialized the notify fd, but if we didn't
1130 * then let's create the bus now */
1131 q = manager_setup_notify(m);
1132 if (q < 0 && r == 0)
1135 /* We might have deserialized the kdbus control fd, but if we
1136 * didn't, then let's create the bus now. */
1137 manager_setup_kdbus(m);
1138 manager_connect_bus(m, !!serialization);
1139 bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
1141 /* Third, fire things up! */
1142 q = manager_coldplug(m);
1143 if (q < 0 && r == 0)
1146 if (serialization) {
1147 assert(m->n_reloading > 0);
1150 /* Let's wait for the UnitNew/JobNew messages being
1151 * sent, before we notify that the reload is
1153 m->send_reloading_done = true;
1159 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1164 assert(type < _JOB_TYPE_MAX);
1166 assert(mode < _JOB_MODE_MAX);
1168 if (mode == JOB_ISOLATE && type != JOB_START)
1169 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1171 if (mode == JOB_ISOLATE && !unit->allow_isolate)
1172 return sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1174 log_unit_debug(unit->id,
1175 "Trying to enqueue job %s/%s/%s", unit->id,
1176 job_type_to_string(type), job_mode_to_string(mode));
1178 job_type_collapse(&type, unit);
1180 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1184 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1185 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1186 mode == JOB_IGNORE_DEPENDENCIES, e);
1190 if (mode == JOB_ISOLATE) {
1191 r = transaction_add_isolate_jobs(tr, m);
1196 r = transaction_activate(tr, m, mode, e);
1200 log_unit_debug(unit->id,
1201 "Enqueued job %s/%s as %u", unit->id,
1202 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1205 *_ret = tr->anchor_job;
1207 transaction_free(tr);
1211 transaction_abort(tr);
1212 transaction_free(tr);
1216 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1221 assert(type < _JOB_TYPE_MAX);
1223 assert(mode < _JOB_MODE_MAX);
1225 r = manager_load_unit(m, name, NULL, NULL, &unit);
1229 return manager_add_job(m, type, unit, mode, override, e, _ret);
1232 Job *manager_get_job(Manager *m, uint32_t id) {
1235 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1238 Unit *manager_get_unit(Manager *m, const char *name) {
1242 return hashmap_get(m->units, name);
1245 unsigned manager_dispatch_load_queue(Manager *m) {
1251 /* Make sure we are not run recursively */
1252 if (m->dispatching_load_queue)
1255 m->dispatching_load_queue = true;
1257 /* Dispatches the load queue. Takes a unit from the queue and
1258 * tries to load its data until the queue is empty */
1260 while ((u = m->load_queue)) {
1261 assert(u->in_load_queue);
1267 m->dispatching_load_queue = false;
1271 int manager_load_unit_prepare(
1283 assert(name || path);
1285 /* This will prepare the unit for loading, but not actually
1286 * load anything from disk. */
1288 if (path && !is_path(path))
1289 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1292 name = basename(path);
1294 t = unit_name_to_type(name);
1296 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1297 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1299 ret = manager_get_unit(m, name);
1305 ret = unit_new(m, unit_vtable[t]->object_size);
1310 ret->fragment_path = strdup(path);
1311 if (!ret->fragment_path) {
1317 r = unit_add_name(ret, name);
1323 unit_add_to_load_queue(ret);
1324 unit_add_to_dbus_queue(ret);
1325 unit_add_to_gc_queue(ret);
1333 int manager_load_unit(
1344 /* This will load the service information files, but not actually
1345 * start any services or anything. */
1347 r = manager_load_unit_prepare(m, name, path, e, _ret);
1351 manager_dispatch_load_queue(m);
1354 *_ret = unit_follow_merge(*_ret);
1359 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1366 HASHMAP_FOREACH(j, s->jobs, i)
1367 job_dump(j, f, prefix);
1370 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1378 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1380 unit_dump(u, f, prefix);
1383 void manager_clear_jobs(Manager *m) {
1388 while ((j = hashmap_first(m->jobs)))
1389 /* No need to recurse. We're cancelling all jobs. */
1390 job_finish_and_invalidate(j, JOB_CANCELED, false);
1393 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1394 Manager *m = userdata;
1400 while ((j = m->run_queue)) {
1401 assert(j->installed);
1402 assert(j->in_run_queue);
1404 job_run_and_invalidate(j);
1407 if (m->n_running_jobs > 0)
1408 manager_watch_jobs_in_progress(m);
1410 if (m->n_on_console > 0)
1411 manager_watch_idle_pipe(m);
1416 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1423 if (m->dispatching_dbus_queue)
1426 m->dispatching_dbus_queue = true;
1428 while ((u = m->dbus_unit_queue)) {
1429 assert(u->in_dbus_queue);
1431 bus_unit_send_change_signal(u);
1435 while ((j = m->dbus_job_queue)) {
1436 assert(j->in_dbus_queue);
1438 bus_job_send_change_signal(j);
1442 m->dispatching_dbus_queue = false;
1444 if (m->send_reloading_done) {
1445 m->send_reloading_done = false;
1447 bus_manager_send_reloading(m, false);
1450 if (m->queued_message)
1451 bus_send_queued_message(m);
1456 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n, FDSet *fds) {
1457 _cleanup_strv_free_ char **tags = NULL;
1464 tags = strv_split(buf, "\n\r");
1470 log_unit_debug(u->id, "Got notification message for unit %s", u->id);
1472 if (UNIT_VTABLE(u)->notify_message)
1473 UNIT_VTABLE(u)->notify_message(u, pid, tags, fds);
1476 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1477 Manager *m = userdata;
1482 assert(m->notify_fd == fd);
1484 if (revents != EPOLLIN) {
1485 log_warning("Got unexpected poll event for notify fd.");
1490 _cleanup_fdset_free_ FDSet *fds = NULL;
1491 char buf[NOTIFY_BUFFER_MAX+1];
1492 struct iovec iovec = {
1494 .iov_len = sizeof(buf)-1,
1497 struct cmsghdr cmsghdr;
1498 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
1499 CMSG_SPACE(sizeof(int) * NOTIFY_FD_MAX)];
1501 struct msghdr msghdr = {
1504 .msg_control = &control,
1505 .msg_controllen = sizeof(control),
1507 struct cmsghdr *cmsg;
1508 struct ucred *ucred = NULL;
1511 int *fd_array = NULL;
1514 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
1516 if (errno == EAGAIN || errno == EINTR)
1522 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
1523 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
1525 fd_array = (int*) CMSG_DATA(cmsg);
1526 n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1528 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1529 cmsg->cmsg_type == SCM_CREDENTIALS &&
1530 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
1532 ucred = (struct ucred*) CMSG_DATA(cmsg);
1539 r = fdset_new_array(&fds, fd_array, n_fds);
1541 close_many(fd_array, n_fds);
1546 if (!ucred || ucred->pid <= 0) {
1547 log_warning("Received notify message without valid credentials. Ignoring.");
1551 if ((size_t) n >= sizeof(buf)) {
1552 log_warning("Received notify message exceeded maximum size. Ignoring.");
1558 /* Notify every unit that might be interested, but try
1559 * to avoid notifying the same one multiple times. */
1560 u1 = manager_get_unit_by_pid(m, ucred->pid);
1562 manager_invoke_notify_message(m, u1, ucred->pid, buf, n, fds);
1566 u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1567 if (u2 && u2 != u1) {
1568 manager_invoke_notify_message(m, u2, ucred->pid, buf, n, fds);
1572 u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1573 if (u3 && u3 != u2 && u3 != u1) {
1574 manager_invoke_notify_message(m, u3, ucred->pid, buf, n, fds);
1579 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1581 if (fdset_size(fds) > 0)
1582 log_warning("Got auxiliary fds with notification message, closing all.");
1588 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1593 log_unit_debug(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1595 unit_unwatch_pid(u, si->si_pid);
1596 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1599 static int manager_dispatch_sigchld(Manager *m) {
1605 /* First we call waitd() for a PID and do not reap the
1606 * zombie. That way we can still access /proc/$PID for
1607 * it while it is a zombie. */
1608 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1610 if (errno == ECHILD)
1622 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1623 _cleanup_free_ char *name = NULL;
1626 get_process_comm(si.si_pid, &name);
1628 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1629 si.si_pid, strna(name),
1630 sigchld_code_to_string(si.si_code),
1632 strna(si.si_code == CLD_EXITED
1633 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1634 : signal_to_string(si.si_status)));
1636 /* And now figure out the unit this belongs
1637 * to, it might be multiple... */
1638 u1 = manager_get_unit_by_pid(m, si.si_pid);
1640 invoke_sigchld_event(m, u1, &si);
1641 u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1643 invoke_sigchld_event(m, u2, &si);
1644 u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1645 if (u3 && u3 != u2 && u3 != u1)
1646 invoke_sigchld_event(m, u3, &si);
1649 /* And now, we actually reap the zombie. */
1650 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1661 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1662 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1665 log_unit_debug(name, "Activating special unit %s", name);
1667 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1669 log_unit_error(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1674 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1675 Manager *m = userdata;
1677 struct signalfd_siginfo sfsi;
1678 bool sigchld = false;
1681 assert(m->signal_fd == fd);
1683 if (revents != EPOLLIN) {
1684 log_warning("Got unexpected events from signal file descriptor.");
1689 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1690 if (n != sizeof(sfsi)) {
1695 if (errno == EINTR || errno == EAGAIN)
1701 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1702 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1703 ? LOG_DEBUG : LOG_INFO,
1706 switch (sfsi.ssi_signo) {
1713 if (m->running_as == SYSTEMD_SYSTEM) {
1714 /* This is for compatibility with the
1715 * original sysvinit */
1716 m->exit_code = MANAGER_REEXECUTE;
1723 if (m->running_as == SYSTEMD_SYSTEM) {
1724 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1728 /* Run the exit target if there is one, if not, just exit. */
1729 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1730 m->exit_code = MANAGER_EXIT;
1737 if (m->running_as == SYSTEMD_SYSTEM)
1738 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1740 /* This is a nop on non-init */
1744 if (m->running_as == SYSTEMD_SYSTEM)
1745 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1747 /* This is a nop on non-init */
1753 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1755 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1756 log_info("Trying to reconnect to bus...");
1760 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1761 log_info("Loading D-Bus service...");
1762 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1769 _cleanup_free_ char *dump = NULL;
1770 _cleanup_fclose_ FILE *f = NULL;
1773 f = open_memstream(&dump, &size);
1775 log_warning("Failed to allocate memory stream.");
1779 manager_dump_units(m, f, "\t");
1780 manager_dump_jobs(m, f, "\t");
1783 log_warning("Failed to write status stream");
1788 log_warning("Failed to flush status stream");
1792 log_dump(LOG_INFO, dump);
1797 m->exit_code = MANAGER_RELOAD;
1802 /* Starting SIGRTMIN+0 */
1803 static const char * const target_table[] = {
1804 [0] = SPECIAL_DEFAULT_TARGET,
1805 [1] = SPECIAL_RESCUE_TARGET,
1806 [2] = SPECIAL_EMERGENCY_TARGET,
1807 [3] = SPECIAL_HALT_TARGET,
1808 [4] = SPECIAL_POWEROFF_TARGET,
1809 [5] = SPECIAL_REBOOT_TARGET,
1810 [6] = SPECIAL_KEXEC_TARGET
1813 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1814 static const ManagerExitCode code_table[] = {
1816 [1] = MANAGER_POWEROFF,
1817 [2] = MANAGER_REBOOT,
1821 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1822 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1823 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1824 manager_start_target(m, target_table[idx],
1825 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1829 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1830 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1831 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1835 switch (sfsi.ssi_signo - SIGRTMIN) {
1838 log_debug("Enabling showing of status.");
1839 manager_set_show_status(m, SHOW_STATUS_YES);
1843 log_debug("Disabling showing of status.");
1844 manager_set_show_status(m, SHOW_STATUS_NO);
1848 log_set_max_level(LOG_DEBUG);
1849 log_notice("Setting log level to debug.");
1853 log_set_max_level(LOG_INFO);
1854 log_notice("Setting log level to info.");
1858 if (m->running_as == SYSTEMD_USER) {
1859 m->exit_code = MANAGER_EXIT;
1863 /* This is a nop on init */
1867 case 29: /* compatibility: used to be mapped to LOG_TARGET_SYSLOG_OR_KMSG */
1868 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1869 log_notice("Setting log target to journal-or-kmsg.");
1873 log_set_target(LOG_TARGET_CONSOLE);
1874 log_notice("Setting log target to console.");
1878 log_set_target(LOG_TARGET_KMSG);
1879 log_notice("Setting log target to kmsg.");
1883 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1890 manager_dispatch_sigchld(m);
1895 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1896 Manager *m = userdata;
1901 assert(m->time_change_fd == fd);
1903 log_struct(LOG_INFO,
1904 LOG_MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1905 LOG_MESSAGE("Time has been changed"),
1908 /* Restart the watch */
1909 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1910 m->time_change_fd = safe_close(m->time_change_fd);
1912 manager_setup_time_change(m);
1914 HASHMAP_FOREACH(u, m->units, i)
1915 if (UNIT_VTABLE(u)->time_change)
1916 UNIT_VTABLE(u)->time_change(u);
1921 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1922 Manager *m = userdata;
1925 assert(m->idle_pipe[2] == fd);
1927 m->no_console_output = m->n_on_console > 0;
1929 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1930 manager_close_idle_pipe(m);
1935 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1936 Manager *m = userdata;
1943 manager_print_jobs_in_progress(m);
1945 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1946 r = sd_event_source_set_time(source, next);
1950 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1953 int manager_loop(Manager *m) {
1956 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1959 m->exit_code = MANAGER_OK;
1961 /* Release the path cache */
1962 set_free_free(m->unit_path_cache);
1963 m->unit_path_cache = NULL;
1965 manager_check_finished(m);
1967 /* There might still be some zombies hanging around from
1968 * before we were exec()'ed. Let's reap them. */
1969 r = manager_dispatch_sigchld(m);
1973 while (m->exit_code == MANAGER_OK) {
1976 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1979 if (!ratelimit_test(&rl)) {
1980 /* Yay, something is going seriously wrong, pause a little */
1981 log_warning("Looping too fast. Throttling execution a little.");
1986 if (manager_dispatch_load_queue(m) > 0)
1989 if (manager_dispatch_gc_queue(m) > 0)
1992 if (manager_dispatch_cleanup_queue(m) > 0)
1995 if (manager_dispatch_cgroup_queue(m) > 0)
1998 if (manager_dispatch_dbus_queue(m) > 0)
2001 /* Sleep for half the watchdog time */
2002 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
2003 wait_usec = m->runtime_watchdog / 2;
2007 wait_usec = USEC_INFINITY;
2009 r = sd_event_run(m->event, wait_usec);
2011 return log_error_errno(r, "Failed to run event loop: %m");
2014 return m->exit_code;
2017 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
2018 _cleanup_free_ char *n = NULL;
2026 r = unit_name_from_dbus_path(s, &n);
2030 r = manager_load_unit(m, n, NULL, e, &u);
2039 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
2049 p = startswith(s, "/org/freedesktop/systemd1/job/");
2053 r = safe_atou(p, &id);
2057 j = manager_get_job(m, id);
2066 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
2069 _cleanup_free_ char *p = NULL;
2073 audit_fd = get_audit_fd();
2077 /* Don't generate audit events if the service was already
2078 * started and we're just deserializing */
2079 if (m->n_reloading > 0)
2082 if (m->running_as != SYSTEMD_SYSTEM)
2085 if (u->type != UNIT_SERVICE)
2088 p = unit_name_to_prefix_and_instance(u->id);
2094 msg = strappenda("unit=", p);
2096 if (audit_log_user_comm_message(audit_fd, type, msg, "systemd", NULL, NULL, NULL, success) < 0) {
2098 /* We aren't allowed to send audit messages?
2099 * Then let's not retry again. */
2102 log_warning_errno(errno, "Failed to send audit message: %m");
2108 void manager_send_unit_plymouth(Manager *m, Unit *u) {
2109 union sockaddr_union sa = PLYMOUTH_SOCKET;
2112 _cleanup_free_ char *message = NULL;
2113 _cleanup_close_ int fd = -1;
2115 /* Don't generate plymouth events if the service was already
2116 * started and we're just deserializing */
2117 if (m->n_reloading > 0)
2120 if (m->running_as != SYSTEMD_SYSTEM)
2123 if (detect_container(NULL) > 0)
2126 if (u->type != UNIT_SERVICE &&
2127 u->type != UNIT_MOUNT &&
2128 u->type != UNIT_SWAP)
2131 /* We set SOCK_NONBLOCK here so that we rather drop the
2132 * message then wait for plymouth */
2133 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2135 log_error_errno(errno, "socket() failed: %m");
2139 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2141 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2142 log_error_errno(errno, "connect() failed: %m");
2146 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2152 if (write(fd, message, n + 1) != n + 1)
2153 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2154 log_error_errno(errno, "Failed to write Plymouth message: %m");
2157 void manager_dispatch_bus_name_owner_changed(
2160 const char* old_owner,
2161 const char *new_owner) {
2168 u = hashmap_get(m->watch_bus, name);
2172 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2175 int manager_open_serialization(Manager *m, FILE **_f) {
2182 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2183 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2187 log_debug("Serializing state to %s", path);
2189 f = fdopen(fd, "w+");
2200 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2213 fprintf(f, "current-job-id=%"PRIu32"\n", m->current_job_id);
2214 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2215 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2216 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2218 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2219 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2220 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2221 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2224 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2225 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2226 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2227 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2228 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2229 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2230 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2231 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2234 if (!switching_root) {
2235 STRV_FOREACH(e, m->environment) {
2236 _cleanup_free_ char *ce;
2242 fprintf(f, "env=%s\n", *e);
2246 if (m->notify_fd >= 0) {
2249 copy = fdset_put_dup(fds, m->notify_fd);
2253 fprintf(f, "notify-fd=%i\n", copy);
2254 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2257 if (m->kdbus_fd >= 0) {
2260 copy = fdset_put_dup(fds, m->kdbus_fd);
2264 fprintf(f, "kdbus-fd=%i\n", copy);
2267 bus_track_serialize(m->subscribed, f);
2271 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2279 r = unit_serialize(u, f, fds, !switching_root);
2286 assert(m->n_reloading > 0);
2292 r = bus_fdset_add_all(m, fds);
2299 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2305 log_debug("Deserializing state...");
2310 char line[LINE_MAX], *l;
2312 if (!fgets(line, sizeof(line), f)) {
2327 if (startswith(l, "current-job-id=")) {
2330 if (safe_atou32(l+15, &id) < 0)
2331 log_debug("Failed to parse current job id value %s", l+15);
2333 m->current_job_id = MAX(m->current_job_id, id);
2335 } else if (startswith(l, "n-installed-jobs=")) {
2338 if (safe_atou32(l+17, &n) < 0)
2339 log_debug("Failed to parse installed jobs counter %s", l+17);
2341 m->n_installed_jobs += n;
2343 } else if (startswith(l, "n-failed-jobs=")) {
2346 if (safe_atou32(l+14, &n) < 0)
2347 log_debug("Failed to parse failed jobs counter %s", l+14);
2349 m->n_failed_jobs += n;
2351 } else if (startswith(l, "taint-usr=")) {
2354 b = parse_boolean(l+10);
2356 log_debug("Failed to parse taint /usr flag %s", l+10);
2358 m->taint_usr = m->taint_usr || b;
2360 } else if (startswith(l, "firmware-timestamp="))
2361 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2362 else if (startswith(l, "loader-timestamp="))
2363 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2364 else if (startswith(l, "kernel-timestamp="))
2365 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2366 else if (startswith(l, "initrd-timestamp="))
2367 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2368 else if (startswith(l, "userspace-timestamp="))
2369 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2370 else if (startswith(l, "finish-timestamp="))
2371 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2372 else if (startswith(l, "security-start-timestamp="))
2373 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2374 else if (startswith(l, "security-finish-timestamp="))
2375 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2376 else if (startswith(l, "generators-start-timestamp="))
2377 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2378 else if (startswith(l, "generators-finish-timestamp="))
2379 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2380 else if (startswith(l, "units-load-start-timestamp="))
2381 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2382 else if (startswith(l, "units-load-finish-timestamp="))
2383 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2384 else if (startswith(l, "env=")) {
2385 _cleanup_free_ char *uce = NULL;
2388 uce = cunescape(l+4);
2394 e = strv_env_set(m->environment, uce);
2400 strv_free(m->environment);
2403 } else if (startswith(l, "notify-fd=")) {
2406 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2407 log_debug("Failed to parse notify fd: %s", l + 10);
2409 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2410 safe_close(m->notify_fd);
2411 m->notify_fd = fdset_remove(fds, fd);
2414 } else if (startswith(l, "notify-socket=")) {
2423 free(m->notify_socket);
2424 m->notify_socket = n;
2426 } else if (startswith(l, "kdbus-fd=")) {
2429 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2430 log_debug("Failed to parse kdbus fd: %s", l + 9);
2432 safe_close(m->kdbus_fd);
2433 m->kdbus_fd = fdset_remove(fds, fd);
2439 k = bus_track_deserialize_item(&m->deserialized_subscribed, l);
2441 log_debug_errno(k, "Failed to deserialize bus tracker object: %m");
2443 log_debug("Unknown serialization item '%s'", l);
2449 char name[UNIT_NAME_MAX+2];
2452 if (!fgets(name, sizeof(name), f)) {
2463 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2467 r = unit_deserialize(u, f, fds);
2476 assert(m->n_reloading > 0);
2482 int manager_reload(Manager *m) {
2484 _cleanup_fclose_ FILE *f = NULL;
2485 _cleanup_fdset_free_ FDSet *fds = NULL;
2489 r = manager_open_serialization(m, &f);
2494 bus_manager_send_reloading(m, true);
2502 r = manager_serialize(m, f, fds, false);
2508 if (fseeko(f, 0, SEEK_SET) < 0) {
2513 /* From here on there is no way back. */
2514 manager_clear_jobs_and_units(m);
2515 manager_undo_generators(m);
2516 lookup_paths_free(&m->lookup_paths);
2518 /* Find new unit paths */
2519 q = manager_run_generators(m);
2520 if (q < 0 && r >= 0)
2523 q = lookup_paths_init(
2524 &m->lookup_paths, m->running_as, true,
2526 m->generator_unit_path,
2527 m->generator_unit_path_early,
2528 m->generator_unit_path_late);
2529 if (q < 0 && r >= 0)
2532 manager_build_unit_path_cache(m);
2534 /* First, enumerate what we can from all config files */
2535 q = manager_enumerate(m);
2536 if (q < 0 && r >= 0)
2539 /* Second, deserialize our stored data */
2540 q = manager_deserialize(m, f, fds);
2541 if (q < 0 && r >= 0)
2547 /* Re-register notify_fd as event source */
2548 q = manager_setup_notify(m);
2549 if (q < 0 && r >= 0)
2552 /* Third, fire things up! */
2553 q = manager_coldplug(m);
2554 if (q < 0 && r >= 0)
2557 assert(m->n_reloading > 0);
2560 m->send_reloading_done = true;
2565 bool manager_is_reloading_or_reexecuting(Manager *m) {
2568 return m->n_reloading != 0;
2571 void manager_reset_failed(Manager *m) {
2577 HASHMAP_FOREACH(u, m->units, i)
2578 unit_reset_failed(u);
2581 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2587 /* Returns true if the unit is inactive or going down */
2588 u = manager_get_unit(m, name);
2592 return unit_inactive_or_pending(u);
2595 static void manager_notify_finished(Manager *m) {
2596 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2597 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2602 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2604 /* Note that m->kernel_usec.monotonic is always at 0,
2605 * and m->firmware_usec.monotonic and
2606 * m->loader_usec.monotonic should be considered
2607 * negative values. */
2609 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2610 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2611 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2612 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2614 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2616 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2617 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2619 log_struct(LOG_INFO,
2620 LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2621 "KERNEL_USEC="USEC_FMT, kernel_usec,
2622 "INITRD_USEC="USEC_FMT, initrd_usec,
2623 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2624 LOG_MESSAGE("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2625 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2626 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2627 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2628 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2631 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2634 log_struct(LOG_INFO,
2635 LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2636 "KERNEL_USEC="USEC_FMT, kernel_usec,
2637 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2638 LOG_MESSAGE("Startup finished in %s (kernel) + %s (userspace) = %s.",
2639 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2640 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2641 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2645 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2646 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2648 log_struct(LOG_INFO,
2649 LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2650 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2651 LOG_MESSAGE("Startup finished in %s.",
2652 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2656 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2660 "STATUS=Startup finished in %s.",
2661 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2664 void manager_check_finished(Manager *m) {
2670 if (hashmap_size(m->jobs) > 0) {
2672 if (m->jobs_in_progress_event_source)
2673 sd_event_source_set_time(m->jobs_in_progress_event_source, now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2678 manager_flip_auto_status(m, false);
2680 /* Notify Type=idle units that we are done now */
2681 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2682 manager_close_idle_pipe(m);
2684 /* Turn off confirm spawn now */
2685 m->confirm_spawn = false;
2687 /* No need to update ask password status when we're going non-interactive */
2688 manager_close_ask_password(m);
2690 /* This is no longer the first boot */
2691 manager_set_first_boot(m, false);
2693 if (dual_timestamp_is_set(&m->finish_timestamp))
2696 dual_timestamp_get(&m->finish_timestamp);
2698 manager_notify_finished(m);
2700 SET_FOREACH(u, m->startup_units, i)
2702 cgroup_context_apply(unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path, manager_state(m));
2705 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2716 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2717 /* systemd --system, not running --test */
2719 p = strappend("/run/systemd/", name);
2723 r = mkdir_p_label(p, 0755);
2725 log_error_errno(r, "Failed to create generator directory %s: %m", p);
2729 } else if (m->running_as == SYSTEMD_USER) {
2730 const char *s = NULL;
2732 s = getenv("XDG_RUNTIME_DIR");
2735 p = strjoin(s, "/systemd/", name, NULL);
2739 r = mkdir_p_label(p, 0755);
2741 log_error_errno(r, "Failed to create generator directory %s: %m", p);
2746 /* systemd --system --test */
2748 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2753 log_error_errno(errno, "Failed to create generator directory %s: %m",
2764 static void trim_generator_dir(Manager *m, char **generator) {
2771 if (rmdir(*generator) >= 0) {
2779 static int manager_run_generators(Manager *m) {
2780 _cleanup_free_ char **paths = NULL;
2781 const char *argv[5];
2790 paths = generator_paths(m->running_as);
2794 /* Optimize by skipping the whole process by not creating output directories
2795 * if no generators are found. */
2796 STRV_FOREACH(path, paths) {
2797 r = access(*path, F_OK);
2800 if (errno != ENOENT)
2801 log_warning_errno(errno, "Failed to open generator directory %s: %m", *path);
2806 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2810 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2814 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2818 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2819 argv[1] = m->generator_unit_path;
2820 argv[2] = m->generator_unit_path_early;
2821 argv[3] = m->generator_unit_path_late;
2824 RUN_WITH_UMASK(0022)
2825 execute_directories((const char* const*) paths, DEFAULT_TIMEOUT_USEC, (char**) argv);
2828 trim_generator_dir(m, &m->generator_unit_path);
2829 trim_generator_dir(m, &m->generator_unit_path_early);
2830 trim_generator_dir(m, &m->generator_unit_path_late);
2834 static void remove_generator_dir(Manager *m, char **generator) {
2841 strv_remove(m->lookup_paths.unit_path, *generator);
2842 rm_rf(*generator, false, true, false);
2848 static void manager_undo_generators(Manager *m) {
2851 remove_generator_dir(m, &m->generator_unit_path);
2852 remove_generator_dir(m, &m->generator_unit_path_early);
2853 remove_generator_dir(m, &m->generator_unit_path_late);
2856 int manager_environment_add(Manager *m, char **minus, char **plus) {
2857 char **a = NULL, **b = NULL, **l;
2862 if (!strv_isempty(minus)) {
2863 a = strv_env_delete(l, 1, minus);
2870 if (!strv_isempty(plus)) {
2871 b = strv_env_merge(2, l, plus);
2880 if (m->environment != l)
2881 strv_free(m->environment);
2888 manager_clean_environment(m);
2889 strv_sort(m->environment);
2894 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2899 for (i = 0; i < _RLIMIT_MAX; i++) {
2900 if (!default_rlimit[i])
2903 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2911 void manager_recheck_journal(Manager *m) {
2916 if (m->running_as != SYSTEMD_SYSTEM)
2919 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2920 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2921 log_close_journal();
2925 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2926 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2927 log_close_journal();
2931 /* Hmm, OK, so the socket is fully up and the service is up
2932 * too, then let's make use of the thing. */
2936 void manager_set_show_status(Manager *m, ShowStatus mode) {
2938 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2940 if (m->running_as != SYSTEMD_SYSTEM)
2943 m->show_status = mode;
2946 touch("/run/systemd/show-status");
2948 unlink("/run/systemd/show-status");
2951 static bool manager_get_show_status(Manager *m, StatusType type) {
2954 if (m->running_as != SYSTEMD_SYSTEM)
2957 if (m->no_console_output)
2960 if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
2963 /* If we cannot find out the status properly, just proceed. */
2964 if (type != STATUS_TYPE_EMERGENCY && manager_check_ask_password(m) > 0)
2967 if (m->show_status > 0)
2970 /* If Plymouth is running make sure we show the status, so
2971 * that there's something nice to see when people press Esc */
2972 return plymouth_running();
2975 void manager_set_first_boot(Manager *m, bool b) {
2978 if (m->running_as != SYSTEMD_SYSTEM)
2984 touch("/run/systemd/first-boot");
2986 unlink("/run/systemd/first-boot");
2989 void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) {
2992 /* If m is NULL, assume we're after shutdown and let the messages through. */
2994 if (m && !manager_get_show_status(m, type))
2997 /* XXX We should totally drop the check for ephemeral here
2998 * and thus effectively make 'Type=idle' pointless. */
2999 if (type == STATUS_TYPE_EPHEMERAL && m && m->n_on_console > 0)
3002 va_start(ap, format);
3003 status_vprintf(status, true, type == STATUS_TYPE_EPHEMERAL, format, ap);
3007 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
3008 _cleanup_free_ char *p = NULL;
3016 p = unit_name_from_path(path, suffix);
3020 found = manager_get_unit(m, p);
3030 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
3031 char p[strlen(path)+1];
3037 path_kill_slashes(p);
3039 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
3042 const char *manager_get_runtime_prefix(Manager *m) {
3045 return m->running_as == SYSTEMD_SYSTEM ?
3047 getenv("XDG_RUNTIME_DIR");
3050 ManagerState manager_state(Manager *m) {
3055 /* Did we ever finish booting? If not then we are still starting up */
3056 if (!dual_timestamp_is_set(&m->finish_timestamp)) {
3058 u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
3059 if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
3060 return MANAGER_INITIALIZING;
3062 return MANAGER_STARTING;
3065 /* Is the special shutdown target queued? If so, we are in shutdown state */
3066 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
3067 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
3068 return MANAGER_STOPPING;
3070 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
3071 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
3072 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3073 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3074 return MANAGER_MAINTENANCE;
3076 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
3077 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3078 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3079 return MANAGER_MAINTENANCE;
3081 /* Are there any failed units? If so, we are in degraded mode */
3082 if (set_size(m->failed_units) > 0)
3083 return MANAGER_DEGRADED;
3085 return MANAGER_RUNNING;
3088 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
3089 [MANAGER_INITIALIZING] = "initializing",
3090 [MANAGER_STARTING] = "starting",
3091 [MANAGER_RUNNING] = "running",
3092 [MANAGER_DEGRADED] = "degraded",
3093 [MANAGER_MAINTENANCE] = "maintenance",
3094 [MANAGER_STOPPING] = "stopping",
3097 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);