1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
27 #include <sys/inotify.h>
28 #include <sys/epoll.h>
29 #include <sys/reboot.h>
30 #include <sys/ioctl.h>
34 #include <sys/timerfd.h>
40 #include "sd-daemon.h"
41 #include "sd-messages.h"
44 #include "transaction.h"
51 #include "ratelimit.h"
52 #include "locale-setup.h"
53 #include "unit-name.h"
55 #include "path-lookup.h"
57 #include "exit-status.h"
60 #include "path-util.h"
62 #include "boot-timestamps.h"
64 #include "bus-common-errors.h"
65 #include "bus-error.h"
68 #include "dbus-unit.h"
70 #include "dbus-manager.h"
71 #include "bus-kernel.h"
72 #include "time-util.h"
74 /* Initial delay and the interval for printing status messages about running jobs */
75 #define JOBS_IN_PROGRESS_WAIT_USEC (5*USEC_PER_SEC)
76 #define JOBS_IN_PROGRESS_PERIOD_USEC (USEC_PER_SEC / 3)
77 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
79 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
80 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
81 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
82 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
83 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
84 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
85 static int manager_run_generators(Manager *m);
86 static void manager_undo_generators(Manager *m);
88 static int manager_watch_jobs_in_progress(Manager *m) {
93 if (m->jobs_in_progress_event_source)
96 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
97 return sd_event_add_time(
99 &m->jobs_in_progress_event_source,
102 manager_dispatch_jobs_in_progress, m);
105 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
107 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
110 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
111 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
115 p = mempset(p, ' ', pos-2);
116 p = stpcpy(p, ANSI_RED_ON);
120 if (pos > 0 && pos <= width) {
121 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
125 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
128 p = stpcpy(p, ANSI_RED_ON);
131 p = mempset(p, ' ', width-1-pos);
132 strcpy(p, ANSI_HIGHLIGHT_OFF);
136 void manager_flip_auto_status(Manager *m, bool enable) {
140 if (m->show_status == SHOW_STATUS_AUTO)
141 manager_set_show_status(m, SHOW_STATUS_TEMPORARY);
143 if (m->show_status == SHOW_STATUS_TEMPORARY)
144 manager_set_show_status(m, SHOW_STATUS_AUTO);
148 static void manager_print_jobs_in_progress(Manager *m) {
149 _cleanup_free_ char *job_of_n = NULL;
152 unsigned counter = 0, print_nr;
153 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
155 char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
159 assert(m->n_running_jobs > 0);
161 manager_flip_auto_status(m, true);
163 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
165 HASHMAP_FOREACH(j, m->jobs, i)
166 if (j->state == JOB_RUNNING && counter++ == print_nr)
169 /* m->n_running_jobs must be consistent with the contents of m->jobs,
170 * so the above loop must have succeeded in finding j. */
171 assert(counter == print_nr + 1);
174 cylon_pos = m->jobs_in_progress_iteration % 14;
176 cylon_pos = 14 - cylon_pos;
177 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
179 m->jobs_in_progress_iteration++;
181 if (m->n_running_jobs > 1)
182 asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs);
184 format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
185 if (job_get_timeout(j, &x) > 0)
186 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
188 manager_status_printf(m, STATUS_TYPE_EPHEMERAL, cylon,
189 "%sA %s job is running for %s (%s / %s)",
191 job_type_to_string(j->type),
192 unit_description(j->unit),
196 static int have_ask_password(void) {
197 _cleanup_closedir_ DIR *dir;
199 dir = opendir("/run/systemd/ask-password");
212 if (!de && errno != 0)
217 if (startswith(de->d_name, "ask."))
222 static int manager_dispatch_ask_password_fd(sd_event_source *source,
223 int fd, uint32_t revents, void *userdata) {
224 Manager *m = userdata;
230 m->have_ask_password = have_ask_password();
231 if (m->have_ask_password < 0)
232 /* Log error but continue. Negative have_ask_password
233 * is treated as unknown status. */
234 log_error_errno(m->have_ask_password, "Failed to list /run/systemd/ask-password: %m");
239 static void manager_close_ask_password(Manager *m) {
242 m->ask_password_inotify_fd = safe_close(m->ask_password_inotify_fd);
243 m->ask_password_event_source = sd_event_source_unref(m->ask_password_event_source);
244 m->have_ask_password = -EINVAL;
247 static int manager_check_ask_password(Manager *m) {
252 if (!m->ask_password_event_source) {
253 assert(m->ask_password_inotify_fd < 0);
255 mkdir_p_label("/run/systemd/ask-password", 0755);
257 m->ask_password_inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
258 if (m->ask_password_inotify_fd < 0)
259 return log_error_errno(errno, "inotify_init1() failed: %m");
261 if (inotify_add_watch(m->ask_password_inotify_fd, "/run/systemd/ask-password", IN_CREATE|IN_DELETE|IN_MOVE) < 0) {
262 log_error_errno(errno, "Failed to add watch on /run/systemd/ask-password: %m");
263 manager_close_ask_password(m);
267 r = sd_event_add_io(m->event, &m->ask_password_event_source,
268 m->ask_password_inotify_fd, EPOLLIN,
269 manager_dispatch_ask_password_fd, m);
271 log_error_errno(errno, "Failed to add event source for /run/systemd/ask-password: %m");
272 manager_close_ask_password(m);
276 /* Queries might have been added meanwhile... */
277 manager_dispatch_ask_password_fd(m->ask_password_event_source,
278 m->ask_password_inotify_fd, EPOLLIN, m);
281 return m->have_ask_password;
284 static int manager_watch_idle_pipe(Manager *m) {
289 if (m->idle_pipe_event_source)
292 if (m->idle_pipe[2] < 0)
295 r = sd_event_add_io(m->event, &m->idle_pipe_event_source, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m);
297 return log_error_errno(r, "Failed to watch idle pipe: %m");
302 static void manager_close_idle_pipe(Manager *m) {
305 safe_close_pair(m->idle_pipe);
306 safe_close_pair(m->idle_pipe + 2);
309 static int manager_setup_time_change(Manager *m) {
312 /* We only care for the cancellation event, hence we set the
313 * timeout to the latest possible value. */
314 struct itimerspec its = {
315 .it_value.tv_sec = TIME_T_MAX,
319 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
324 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
325 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
327 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
328 if (m->time_change_fd < 0)
329 return log_error_errno(errno, "Failed to create timerfd: %m");
331 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
332 log_debug_errno(errno, "Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
333 m->time_change_fd = safe_close(m->time_change_fd);
337 r = sd_event_add_io(m->event, &m->time_change_event_source, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m);
339 return log_error_errno(r, "Failed to create time change event source: %m");
341 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
346 static int enable_special_signals(Manager *m) {
347 _cleanup_close_ int fd = -1;
351 /* Enable that we get SIGINT on control-alt-del. In containers
352 * this will fail with EPERM (older) or EINVAL (newer), so
354 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
355 log_warning_errno(errno, "Failed to enable ctrl-alt-del handling: %m");
357 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
359 /* Support systems without virtual console */
361 log_warning_errno(errno, "Failed to open /dev/tty0: %m");
363 /* Enable that we get SIGWINCH on kbrequest */
364 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
365 log_warning_errno(errno, "Failed to enable kbrequest handling: %m");
371 static int manager_setup_signals(Manager *m) {
372 struct sigaction sa = {
373 .sa_handler = SIG_DFL,
374 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
381 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
383 /* We make liberal use of realtime signals here. On
384 * Linux/glibc we have 30 of them (with the exception of Linux
385 * on hppa, see below), between SIGRTMIN+0 ... SIGRTMIN+30
388 assert_se(sigemptyset(&mask) == 0);
389 sigset_add_many(&mask,
390 SIGCHLD, /* Child died */
391 SIGTERM, /* Reexecute daemon */
392 SIGHUP, /* Reload configuration */
393 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
394 SIGUSR2, /* systemd: dump status */
395 SIGINT, /* Kernel sends us this on control-alt-del */
396 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
397 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
399 SIGRTMIN+0, /* systemd: start default.target */
400 SIGRTMIN+1, /* systemd: isolate rescue.target */
401 SIGRTMIN+2, /* systemd: isolate emergency.target */
402 SIGRTMIN+3, /* systemd: start halt.target */
403 SIGRTMIN+4, /* systemd: start poweroff.target */
404 SIGRTMIN+5, /* systemd: start reboot.target */
405 SIGRTMIN+6, /* systemd: start kexec.target */
407 /* ... space for more special targets ... */
409 SIGRTMIN+13, /* systemd: Immediate halt */
410 SIGRTMIN+14, /* systemd: Immediate poweroff */
411 SIGRTMIN+15, /* systemd: Immediate reboot */
412 SIGRTMIN+16, /* systemd: Immediate kexec */
414 /* ... space for more immediate system state changes ... */
416 SIGRTMIN+20, /* systemd: enable status messages */
417 SIGRTMIN+21, /* systemd: disable status messages */
418 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
419 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
420 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
422 /* .. one free signal here ... */
424 #if !defined(__hppa64__) && !defined(__hppa__)
425 /* Apparently Linux on hppa has fewer RT
426 * signals (SIGRTMAX is SIGRTMIN+25 there),
427 * hence let's not try to make use of them
428 * here. Since these commands are accessible
429 * by different means and only really a safety
430 * net, the missing functionality on hppa
431 * shouldn't matter. */
433 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
434 SIGRTMIN+27, /* systemd: set log target to console */
435 SIGRTMIN+28, /* systemd: set log target to kmsg */
436 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg (obsolete) */
438 /* ... one free signal here SIGRTMIN+30 ... */
441 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
443 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
444 if (m->signal_fd < 0)
447 r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);
451 /* Process signals a bit earlier than the rest of things, but
452 * later than notify_fd processing, so that the notify
453 * processing can still figure out to which process/service a
454 * message belongs, before we reap the process. */
455 r = sd_event_source_set_priority(m->signal_event_source, -5);
459 if (m->running_as == SYSTEMD_SYSTEM)
460 return enable_special_signals(m);
465 static void manager_clean_environment(Manager *m) {
468 /* Let's remove some environment variables that we
469 * need ourselves to communicate with our clients */
482 static int manager_default_environment(Manager *m) {
485 if (m->running_as == SYSTEMD_SYSTEM) {
486 /* The system manager always starts with a clean
487 * environment for its children. It does not import
488 * the kernel or the parents exported variables.
490 * The initial passed environ is untouched to keep
491 * /proc/self/environ valid; it is used for tagging
492 * the init process inside containers. */
493 m->environment = strv_new("PATH=" DEFAULT_PATH,
496 /* Import locale variables LC_*= from configuration */
497 locale_setup(&m->environment);
499 /* The user manager passes its own environment
500 * along to its children. */
501 m->environment = strv_copy(environ);
507 manager_clean_environment(m);
508 strv_sort(m->environment);
513 int manager_new(SystemdRunningAs running_as, bool test_run, Manager **_m) {
518 assert(running_as >= 0);
519 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
521 m = new0(Manager, 1);
526 if (running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0)
527 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
530 m->running_as = running_as;
531 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
532 m->default_timer_accuracy_usec = USEC_PER_MINUTE;
534 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
536 m->pin_cgroupfs_fd = m->notify_fd = m->signal_fd = m->time_change_fd = m->dev_autofs_fd = m->private_listen_fd = m->kdbus_fd = m->utab_inotify_fd = -1;
537 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
539 m->ask_password_inotify_fd = -1;
540 m->have_ask_password = -EINVAL; /* we don't know */
542 m->test_run = test_run;
544 /* Reboot immediately if the user hits C-A-D more often than 7x per 2s */
545 RATELIMIT_INIT(m->ctrl_alt_del_ratelimit, 2 * USEC_PER_SEC, 7);
547 r = manager_default_environment(m);
551 r = hashmap_ensure_allocated(&m->units, &string_hash_ops);
555 r = hashmap_ensure_allocated(&m->jobs, NULL);
559 r = hashmap_ensure_allocated(&m->cgroup_unit, &string_hash_ops);
563 r = hashmap_ensure_allocated(&m->watch_bus, &string_hash_ops);
567 r = set_ensure_allocated(&m->startup_units, NULL);
571 r = set_ensure_allocated(&m->failed_units, NULL);
575 r = sd_event_default(&m->event);
579 r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
583 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
587 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
591 r = manager_setup_signals(m);
595 r = manager_setup_cgroup(m);
599 r = manager_setup_time_change(m);
603 m->udev = udev_new();
609 /* Note that we set up neither kdbus, nor the notify fd
610 * here. We do that after deserialization, since they might
611 * have gotten serialized across the reexec. */
613 m->taint_usr = dir_is_empty("/usr") > 0;
623 static int manager_setup_notify(Manager *m) {
629 if (m->notify_fd < 0) {
630 _cleanup_close_ int fd = -1;
631 union sockaddr_union sa = {
632 .sa.sa_family = AF_UNIX,
634 static const int one = 1;
636 /* First free all secondary fields */
637 free(m->notify_socket);
638 m->notify_socket = NULL;
639 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
641 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
643 return log_error_errno(errno, "Failed to allocate notification socket: %m");
645 if (m->running_as == SYSTEMD_SYSTEM)
646 m->notify_socket = strdup("/run/systemd/notify");
650 e = getenv("XDG_RUNTIME_DIR");
652 log_error_errno(errno, "XDG_RUNTIME_DIR is not set: %m");
656 m->notify_socket = strappend(e, "/systemd/notify");
658 if (!m->notify_socket)
661 (void) mkdir_parents_label(m->notify_socket, 0755);
662 (void) unlink(m->notify_socket);
664 strncpy(sa.un.sun_path, m->notify_socket, sizeof(sa.un.sun_path)-1);
665 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path));
667 return log_error_errno(errno, "bind(%s) failed: %m", sa.un.sun_path);
669 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
671 return log_error_errno(errno, "SO_PASSCRED failed: %m");
676 log_debug("Using notification socket %s", m->notify_socket);
679 if (!m->notify_event_source) {
680 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
682 return log_error_errno(r, "Failed to allocate notify event source: %m");
684 /* Process signals a bit earlier than SIGCHLD, so that we can
685 * still identify to which service an exit message belongs */
686 r = sd_event_source_set_priority(m->notify_event_source, -7);
688 return log_error_errno(r, "Failed to set priority of notify event source: %m");
694 static int manager_setup_kdbus(Manager *m) {
696 _cleanup_free_ char *p = NULL;
700 if (m->test_run || m->kdbus_fd >= 0)
703 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0)
704 bus_kernel_fix_attach_mask();
706 m->kdbus_fd = bus_kernel_create_bus(
707 m->running_as == SYSTEMD_SYSTEM ? "system" : "user",
708 m->running_as == SYSTEMD_SYSTEM, &p);
711 return log_debug_errno(m->kdbus_fd, "Failed to set up kdbus: %m");
713 log_debug("Successfully set up kdbus on %s", p);
719 static int manager_connect_bus(Manager *m, bool reexecuting) {
720 bool try_bus_connect;
730 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
732 /* Try to connect to the busses, if possible. */
733 return bus_init(m, try_bus_connect);
736 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
742 while ((u = m->cleanup_queue)) {
743 assert(u->in_cleanup_queue);
753 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
754 GC_OFFSET_UNSURE, /* No clue */
755 GC_OFFSET_GOOD, /* We still need this unit */
756 GC_OFFSET_BAD, /* We don't need this unit anymore */
760 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
767 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
768 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
769 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
772 if (u->in_cleanup_queue)
775 if (unit_check_gc(u))
778 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
782 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
783 unit_gc_sweep(other, gc_marker);
785 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
788 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
795 /* We were unable to find anything out about this entry, so
796 * let's investigate it later */
797 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
798 unit_add_to_gc_queue(u);
802 /* We definitely know that this one is not useful anymore, so
803 * let's mark it for deletion */
804 u->gc_marker = gc_marker + GC_OFFSET_BAD;
805 unit_add_to_cleanup_queue(u);
809 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
812 static unsigned manager_dispatch_gc_queue(Manager *m) {
819 /* log_debug("Running GC..."); */
821 m->gc_marker += _GC_OFFSET_MAX;
822 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
825 gc_marker = m->gc_marker;
827 while ((u = m->gc_queue)) {
828 assert(u->in_gc_queue);
830 unit_gc_sweep(u, gc_marker);
832 LIST_REMOVE(gc_queue, m->gc_queue, u);
833 u->in_gc_queue = false;
837 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
838 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
839 log_unit_debug(u->id, "Collecting %s", u->id);
840 u->gc_marker = gc_marker + GC_OFFSET_BAD;
841 unit_add_to_cleanup_queue(u);
845 m->n_in_gc_queue = 0;
850 static void manager_clear_jobs_and_units(Manager *m) {
855 while ((u = hashmap_first(m->units)))
858 manager_dispatch_cleanup_queue(m);
860 assert(!m->load_queue);
861 assert(!m->run_queue);
862 assert(!m->dbus_unit_queue);
863 assert(!m->dbus_job_queue);
864 assert(!m->cleanup_queue);
865 assert(!m->gc_queue);
867 assert(hashmap_isempty(m->jobs));
868 assert(hashmap_isempty(m->units));
871 m->n_running_jobs = 0;
874 Manager* manager_free(Manager *m) {
881 manager_clear_jobs_and_units(m);
883 for (c = 0; c < _UNIT_TYPE_MAX; c++)
884 if (unit_vtable[c]->shutdown)
885 unit_vtable[c]->shutdown(m);
887 /* If we reexecute ourselves, we keep the root cgroup
889 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
891 manager_undo_generators(m);
895 hashmap_free(m->units);
896 hashmap_free(m->jobs);
897 hashmap_free(m->watch_pids1);
898 hashmap_free(m->watch_pids2);
899 hashmap_free(m->watch_bus);
901 set_free(m->startup_units);
902 set_free(m->failed_units);
904 sd_event_source_unref(m->signal_event_source);
905 sd_event_source_unref(m->notify_event_source);
906 sd_event_source_unref(m->time_change_event_source);
907 sd_event_source_unref(m->jobs_in_progress_event_source);
908 sd_event_source_unref(m->idle_pipe_event_source);
909 sd_event_source_unref(m->run_queue_event_source);
911 safe_close(m->signal_fd);
912 safe_close(m->notify_fd);
913 safe_close(m->time_change_fd);
914 safe_close(m->kdbus_fd);
916 manager_close_ask_password(m);
918 manager_close_idle_pipe(m);
921 sd_event_unref(m->event);
923 free(m->notify_socket);
925 lookup_paths_free(&m->lookup_paths);
926 strv_free(m->environment);
928 hashmap_free(m->cgroup_unit);
929 set_free_free(m->unit_path_cache);
931 free(m->switch_root);
932 free(m->switch_root_init);
934 for (i = 0; i < _RLIMIT_MAX; i++)
937 assert(hashmap_isempty(m->units_requiring_mounts_for));
938 hashmap_free(m->units_requiring_mounts_for);
944 int manager_enumerate(Manager *m) {
950 /* Let's ask every type to load all units from disk/kernel
951 * that it might know */
952 for (c = 0; c < _UNIT_TYPE_MAX; c++) {
955 if (unit_vtable[c]->supported && !unit_vtable[c]->supported(m)) {
956 log_debug("Unit type .%s is not supported on this system.", unit_type_to_string(c));
960 if (!unit_vtable[c]->enumerate)
963 q = unit_vtable[c]->enumerate(m);
968 manager_dispatch_load_queue(m);
972 static int manager_coldplug(Manager *m) {
979 * Some unit types tend to spawn jobs or check other units' state
980 * during coldplug. This is wrong because it is undefined whether the
981 * units in question have been already coldplugged (i. e. their state
982 * restored). This way, we can easily re-start an already started unit
983 * or otherwise make a wrong decision based on the unit's state.
985 * Solve this by providing a way for coldplug functions to defer
986 * such actions until after all units have been coldplugged.
988 * We store Unit* -> int(*)(Unit*).
990 * https://bugs.freedesktop.org/show_bug.cgi?id=88401
992 _cleanup_hashmap_free_ Hashmap *deferred_work = NULL;
997 deferred_work = hashmap_new(&trivial_hash_ops);
1001 /* Then, let's set up their initial state. */
1002 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
1005 /* ignore aliases */
1009 q = unit_coldplug(u, deferred_work);
1014 /* After coldplugging and setting up initial state of the units,
1015 * let's perform operations which spawn jobs or query units' state. */
1016 HASHMAP_FOREACH_KEY(proc, u, deferred_work, i) {
1027 static void manager_build_unit_path_cache(Manager *m) {
1029 _cleanup_closedir_ DIR *d = NULL;
1034 set_free_free(m->unit_path_cache);
1036 m->unit_path_cache = set_new(&string_hash_ops);
1037 if (!m->unit_path_cache) {
1038 log_error("Failed to allocate unit path cache.");
1042 /* This simply builds a list of files we know exist, so that
1043 * we don't always have to go to disk */
1045 STRV_FOREACH(i, m->lookup_paths.unit_path) {
1050 if (errno != ENOENT)
1051 log_error_errno(errno, "Failed to open directory %s: %m", *i);
1055 while ((de = readdir(d))) {
1058 if (hidden_file(de->d_name))
1061 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
1067 r = set_consume(m->unit_path_cache, p);
1079 log_error_errno(r, "Failed to build unit path cache: %m");
1081 set_free_free(m->unit_path_cache);
1082 m->unit_path_cache = NULL;
1086 static int manager_distribute_fds(Manager *m, FDSet *fds) {
1093 HASHMAP_FOREACH(u, m->units, i) {
1095 if (fdset_size(fds) <= 0)
1098 if (UNIT_VTABLE(u)->distribute_fds) {
1099 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
1108 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
1113 dual_timestamp_get(&m->generators_start_timestamp);
1114 r = manager_run_generators(m);
1115 dual_timestamp_get(&m->generators_finish_timestamp);
1119 r = lookup_paths_init(
1120 &m->lookup_paths, m->running_as, true,
1122 m->generator_unit_path,
1123 m->generator_unit_path_early,
1124 m->generator_unit_path_late);
1128 manager_build_unit_path_cache(m);
1130 /* If we will deserialize make sure that during enumeration
1131 * this is already known, so we increase the counter here
1136 /* First, enumerate what we can from all config files */
1137 dual_timestamp_get(&m->units_load_start_timestamp);
1138 r = manager_enumerate(m);
1139 dual_timestamp_get(&m->units_load_finish_timestamp);
1141 /* Second, deserialize if there is something to deserialize */
1143 r = manager_deserialize(m, serialization, fds);
1145 /* Any fds left? Find some unit which wants them. This is
1146 * useful to allow container managers to pass some file
1147 * descriptors to us pre-initialized. This enables
1148 * socket-based activation of entire containers. */
1149 if (fdset_size(fds) > 0) {
1150 q = manager_distribute_fds(m, fds);
1151 if (q < 0 && r == 0)
1155 /* We might have deserialized the notify fd, but if we didn't
1156 * then let's create the bus now */
1157 q = manager_setup_notify(m);
1158 if (q < 0 && r == 0)
1161 /* We might have deserialized the kdbus control fd, but if we
1162 * didn't, then let's create the bus now. */
1163 manager_setup_kdbus(m);
1164 manager_connect_bus(m, !!serialization);
1165 bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
1167 /* Third, fire things up! */
1168 q = manager_coldplug(m);
1169 if (q < 0 && r == 0)
1172 if (serialization) {
1173 assert(m->n_reloading > 0);
1176 /* Let's wait for the UnitNew/JobNew messages being
1177 * sent, before we notify that the reload is
1179 m->send_reloading_done = true;
1185 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1190 assert(type < _JOB_TYPE_MAX);
1192 assert(mode < _JOB_MODE_MAX);
1194 if (mode == JOB_ISOLATE && type != JOB_START)
1195 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1197 if (mode == JOB_ISOLATE && !unit->allow_isolate)
1198 return sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1200 log_unit_debug(unit->id,
1201 "Trying to enqueue job %s/%s/%s", unit->id,
1202 job_type_to_string(type), job_mode_to_string(mode));
1204 job_type_collapse(&type, unit);
1206 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1210 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1211 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1212 mode == JOB_IGNORE_DEPENDENCIES, e);
1216 if (mode == JOB_ISOLATE) {
1217 r = transaction_add_isolate_jobs(tr, m);
1222 r = transaction_activate(tr, m, mode, e);
1226 log_unit_debug(unit->id,
1227 "Enqueued job %s/%s as %u", unit->id,
1228 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1231 *_ret = tr->anchor_job;
1233 transaction_free(tr);
1237 transaction_abort(tr);
1238 transaction_free(tr);
1242 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1247 assert(type < _JOB_TYPE_MAX);
1249 assert(mode < _JOB_MODE_MAX);
1251 r = manager_load_unit(m, name, NULL, NULL, &unit);
1255 return manager_add_job(m, type, unit, mode, override, e, _ret);
1258 Job *manager_get_job(Manager *m, uint32_t id) {
1261 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1264 Unit *manager_get_unit(Manager *m, const char *name) {
1268 return hashmap_get(m->units, name);
1271 unsigned manager_dispatch_load_queue(Manager *m) {
1277 /* Make sure we are not run recursively */
1278 if (m->dispatching_load_queue)
1281 m->dispatching_load_queue = true;
1283 /* Dispatches the load queue. Takes a unit from the queue and
1284 * tries to load its data until the queue is empty */
1286 while ((u = m->load_queue)) {
1287 assert(u->in_load_queue);
1293 m->dispatching_load_queue = false;
1297 int manager_load_unit_prepare(
1309 assert(name || path);
1311 /* This will prepare the unit for loading, but not actually
1312 * load anything from disk. */
1314 if (path && !is_path(path))
1315 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1318 name = basename(path);
1320 t = unit_name_to_type(name);
1322 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1323 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1325 ret = manager_get_unit(m, name);
1331 ret = unit_new(m, unit_vtable[t]->object_size);
1336 ret->fragment_path = strdup(path);
1337 if (!ret->fragment_path) {
1343 r = unit_add_name(ret, name);
1349 unit_add_to_load_queue(ret);
1350 unit_add_to_dbus_queue(ret);
1351 unit_add_to_gc_queue(ret);
1359 int manager_load_unit(
1370 /* This will load the service information files, but not actually
1371 * start any services or anything. */
1373 r = manager_load_unit_prepare(m, name, path, e, _ret);
1377 manager_dispatch_load_queue(m);
1380 *_ret = unit_follow_merge(*_ret);
1385 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1392 HASHMAP_FOREACH(j, s->jobs, i)
1393 job_dump(j, f, prefix);
1396 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1404 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1406 unit_dump(u, f, prefix);
1409 void manager_clear_jobs(Manager *m) {
1414 while ((j = hashmap_first(m->jobs)))
1415 /* No need to recurse. We're cancelling all jobs. */
1416 job_finish_and_invalidate(j, JOB_CANCELED, false);
1419 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1420 Manager *m = userdata;
1426 while ((j = m->run_queue)) {
1427 assert(j->installed);
1428 assert(j->in_run_queue);
1430 job_run_and_invalidate(j);
1433 if (m->n_running_jobs > 0)
1434 manager_watch_jobs_in_progress(m);
1436 if (m->n_on_console > 0)
1437 manager_watch_idle_pipe(m);
1442 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1449 if (m->dispatching_dbus_queue)
1452 m->dispatching_dbus_queue = true;
1454 while ((u = m->dbus_unit_queue)) {
1455 assert(u->in_dbus_queue);
1457 bus_unit_send_change_signal(u);
1461 while ((j = m->dbus_job_queue)) {
1462 assert(j->in_dbus_queue);
1464 bus_job_send_change_signal(j);
1468 m->dispatching_dbus_queue = false;
1470 if (m->send_reloading_done) {
1471 m->send_reloading_done = false;
1473 bus_manager_send_reloading(m, false);
1476 if (m->queued_message)
1477 bus_send_queued_message(m);
1482 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n, FDSet *fds) {
1483 _cleanup_strv_free_ char **tags = NULL;
1490 tags = strv_split(buf, "\n\r");
1496 log_unit_debug(u->id, "Got notification message for unit %s", u->id);
1498 if (UNIT_VTABLE(u)->notify_message)
1499 UNIT_VTABLE(u)->notify_message(u, pid, tags, fds);
1502 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1503 Manager *m = userdata;
1508 assert(m->notify_fd == fd);
1510 if (revents != EPOLLIN) {
1511 log_warning("Got unexpected poll event for notify fd.");
1516 _cleanup_fdset_free_ FDSet *fds = NULL;
1517 char buf[NOTIFY_BUFFER_MAX+1];
1518 struct iovec iovec = {
1520 .iov_len = sizeof(buf)-1,
1523 struct cmsghdr cmsghdr;
1524 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
1525 CMSG_SPACE(sizeof(int) * NOTIFY_FD_MAX)];
1527 struct msghdr msghdr = {
1530 .msg_control = &control,
1531 .msg_controllen = sizeof(control),
1533 struct cmsghdr *cmsg;
1534 struct ucred *ucred = NULL;
1537 int *fd_array = NULL;
1540 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
1542 if (errno == EAGAIN || errno == EINTR)
1548 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
1549 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
1551 fd_array = (int*) CMSG_DATA(cmsg);
1552 n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1554 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1555 cmsg->cmsg_type == SCM_CREDENTIALS &&
1556 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
1558 ucred = (struct ucred*) CMSG_DATA(cmsg);
1565 r = fdset_new_array(&fds, fd_array, n_fds);
1567 close_many(fd_array, n_fds);
1572 if (!ucred || ucred->pid <= 0) {
1573 log_warning("Received notify message without valid credentials. Ignoring.");
1577 if ((size_t) n >= sizeof(buf)) {
1578 log_warning("Received notify message exceeded maximum size. Ignoring.");
1584 /* Notify every unit that might be interested, but try
1585 * to avoid notifying the same one multiple times. */
1586 u1 = manager_get_unit_by_pid(m, ucred->pid);
1588 manager_invoke_notify_message(m, u1, ucred->pid, buf, n, fds);
1592 u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1593 if (u2 && u2 != u1) {
1594 manager_invoke_notify_message(m, u2, ucred->pid, buf, n, fds);
1598 u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1599 if (u3 && u3 != u2 && u3 != u1) {
1600 manager_invoke_notify_message(m, u3, ucred->pid, buf, n, fds);
1605 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1607 if (fdset_size(fds) > 0)
1608 log_warning("Got auxiliary fds with notification message, closing all.");
1614 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1619 log_unit_debug(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1621 unit_unwatch_pid(u, si->si_pid);
1622 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1625 static int manager_dispatch_sigchld(Manager *m) {
1631 /* First we call waitd() for a PID and do not reap the
1632 * zombie. That way we can still access /proc/$PID for
1633 * it while it is a zombie. */
1634 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1636 if (errno == ECHILD)
1648 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1649 _cleanup_free_ char *name = NULL;
1652 get_process_comm(si.si_pid, &name);
1654 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1655 si.si_pid, strna(name),
1656 sigchld_code_to_string(si.si_code),
1658 strna(si.si_code == CLD_EXITED
1659 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1660 : signal_to_string(si.si_status)));
1662 /* And now figure out the unit this belongs
1663 * to, it might be multiple... */
1664 u1 = manager_get_unit_by_pid(m, si.si_pid);
1666 invoke_sigchld_event(m, u1, &si);
1667 u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1669 invoke_sigchld_event(m, u2, &si);
1670 u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1671 if (u3 && u3 != u2 && u3 != u1)
1672 invoke_sigchld_event(m, u3, &si);
1675 /* And now, we actually reap the zombie. */
1676 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1687 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1688 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1691 log_unit_debug(name, "Activating special unit %s", name);
1693 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1695 log_unit_error(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1700 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1701 Manager *m = userdata;
1703 struct signalfd_siginfo sfsi;
1704 bool sigchld = false;
1707 assert(m->signal_fd == fd);
1709 if (revents != EPOLLIN) {
1710 log_warning("Got unexpected events from signal file descriptor.");
1715 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1716 if (n != sizeof(sfsi)) {
1721 if (errno == EINTR || errno == EAGAIN)
1727 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1728 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1729 ? LOG_DEBUG : LOG_INFO,
1732 switch (sfsi.ssi_signo) {
1739 if (m->running_as == SYSTEMD_SYSTEM) {
1740 /* This is for compatibility with the
1741 * original sysvinit */
1742 m->exit_code = MANAGER_REEXECUTE;
1749 if (m->running_as == SYSTEMD_SYSTEM) {
1751 /* If the user presses C-A-D more than
1752 * 7 times within 2s, we reboot
1755 if (ratelimit_test(&m->ctrl_alt_del_ratelimit))
1756 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1758 log_notice("Ctrl-Alt-Del was pressed more than 7 times within 2s, rebooting immediately.");
1759 status_printf(NULL, true, false, "Ctrl-Alt-Del was pressed more than 7 times within 2s, rebooting immediately.");
1760 m->exit_code = MANAGER_REBOOT;
1766 /* Run the exit target if there is one, if not, just exit. */
1767 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1768 m->exit_code = MANAGER_EXIT;
1775 if (m->running_as == SYSTEMD_SYSTEM)
1776 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1778 /* This is a nop on non-init */
1782 if (m->running_as == SYSTEMD_SYSTEM)
1783 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1785 /* This is a nop on non-init */
1791 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1793 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1794 log_info("Trying to reconnect to bus...");
1798 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1799 log_info("Loading D-Bus service...");
1800 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1807 _cleanup_free_ char *dump = NULL;
1808 _cleanup_fclose_ FILE *f = NULL;
1811 f = open_memstream(&dump, &size);
1813 log_warning("Failed to allocate memory stream.");
1817 manager_dump_units(m, f, "\t");
1818 manager_dump_jobs(m, f, "\t");
1821 log_warning("Failed to write status stream");
1826 log_warning("Failed to flush status stream");
1830 log_dump(LOG_INFO, dump);
1835 m->exit_code = MANAGER_RELOAD;
1840 /* Starting SIGRTMIN+0 */
1841 static const char * const target_table[] = {
1842 [0] = SPECIAL_DEFAULT_TARGET,
1843 [1] = SPECIAL_RESCUE_TARGET,
1844 [2] = SPECIAL_EMERGENCY_TARGET,
1845 [3] = SPECIAL_HALT_TARGET,
1846 [4] = SPECIAL_POWEROFF_TARGET,
1847 [5] = SPECIAL_REBOOT_TARGET,
1848 [6] = SPECIAL_KEXEC_TARGET
1851 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1852 static const ManagerExitCode code_table[] = {
1854 [1] = MANAGER_POWEROFF,
1855 [2] = MANAGER_REBOOT,
1859 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1860 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1861 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1862 manager_start_target(m, target_table[idx],
1863 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1867 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1868 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1869 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1873 switch (sfsi.ssi_signo - SIGRTMIN) {
1876 log_debug("Enabling showing of status.");
1877 manager_set_show_status(m, SHOW_STATUS_YES);
1881 log_debug("Disabling showing of status.");
1882 manager_set_show_status(m, SHOW_STATUS_NO);
1886 log_set_max_level(LOG_DEBUG);
1887 log_notice("Setting log level to debug.");
1891 log_set_max_level(LOG_INFO);
1892 log_notice("Setting log level to info.");
1896 if (m->running_as == SYSTEMD_USER) {
1897 m->exit_code = MANAGER_EXIT;
1901 /* This is a nop on init */
1905 case 29: /* compatibility: used to be mapped to LOG_TARGET_SYSLOG_OR_KMSG */
1906 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1907 log_notice("Setting log target to journal-or-kmsg.");
1911 log_set_target(LOG_TARGET_CONSOLE);
1912 log_notice("Setting log target to console.");
1916 log_set_target(LOG_TARGET_KMSG);
1917 log_notice("Setting log target to kmsg.");
1921 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1928 manager_dispatch_sigchld(m);
1933 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1934 Manager *m = userdata;
1939 assert(m->time_change_fd == fd);
1941 log_struct(LOG_INFO,
1942 LOG_MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1943 LOG_MESSAGE("Time has been changed"),
1946 /* Restart the watch */
1947 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1948 m->time_change_fd = safe_close(m->time_change_fd);
1950 manager_setup_time_change(m);
1952 HASHMAP_FOREACH(u, m->units, i)
1953 if (UNIT_VTABLE(u)->time_change)
1954 UNIT_VTABLE(u)->time_change(u);
1959 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1960 Manager *m = userdata;
1963 assert(m->idle_pipe[2] == fd);
1965 m->no_console_output = m->n_on_console > 0;
1967 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1968 manager_close_idle_pipe(m);
1973 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1974 Manager *m = userdata;
1981 manager_print_jobs_in_progress(m);
1983 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1984 r = sd_event_source_set_time(source, next);
1988 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1991 int manager_loop(Manager *m) {
1994 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1997 m->exit_code = MANAGER_OK;
1999 /* Release the path cache */
2000 set_free_free(m->unit_path_cache);
2001 m->unit_path_cache = NULL;
2003 manager_check_finished(m);
2005 /* There might still be some zombies hanging around from
2006 * before we were exec()'ed. Let's reap them. */
2007 r = manager_dispatch_sigchld(m);
2011 while (m->exit_code == MANAGER_OK) {
2014 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
2017 if (!ratelimit_test(&rl)) {
2018 /* Yay, something is going seriously wrong, pause a little */
2019 log_warning("Looping too fast. Throttling execution a little.");
2024 if (manager_dispatch_load_queue(m) > 0)
2027 if (manager_dispatch_gc_queue(m) > 0)
2030 if (manager_dispatch_cleanup_queue(m) > 0)
2033 if (manager_dispatch_cgroup_queue(m) > 0)
2036 if (manager_dispatch_dbus_queue(m) > 0)
2039 /* Sleep for half the watchdog time */
2040 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
2041 wait_usec = m->runtime_watchdog / 2;
2045 wait_usec = USEC_INFINITY;
2047 r = sd_event_run(m->event, wait_usec);
2049 return log_error_errno(r, "Failed to run event loop: %m");
2052 return m->exit_code;
2055 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
2056 _cleanup_free_ char *n = NULL;
2064 r = unit_name_from_dbus_path(s, &n);
2068 r = manager_load_unit(m, n, NULL, e, &u);
2077 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
2087 p = startswith(s, "/org/freedesktop/systemd1/job/");
2091 r = safe_atou(p, &id);
2095 j = manager_get_job(m, id);
2104 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
2107 _cleanup_free_ char *p = NULL;
2111 audit_fd = get_audit_fd();
2115 /* Don't generate audit 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 (u->type != UNIT_SERVICE)
2126 p = unit_name_to_prefix_and_instance(u->id);
2132 msg = strjoina("unit=", p);
2133 if (audit_log_user_comm_message(audit_fd, type, msg, "systemd", NULL, NULL, NULL, success) < 0) {
2135 /* We aren't allowed to send audit messages?
2136 * Then let's not retry again. */
2139 log_warning_errno(errno, "Failed to send audit message: %m");
2145 void manager_send_unit_plymouth(Manager *m, Unit *u) {
2146 union sockaddr_union sa = PLYMOUTH_SOCKET;
2149 _cleanup_free_ char *message = NULL;
2150 _cleanup_close_ int fd = -1;
2152 /* Don't generate plymouth events if the service was already
2153 * started and we're just deserializing */
2154 if (m->n_reloading > 0)
2157 if (m->running_as != SYSTEMD_SYSTEM)
2160 if (detect_container(NULL) > 0)
2163 if (u->type != UNIT_SERVICE &&
2164 u->type != UNIT_MOUNT &&
2165 u->type != UNIT_SWAP)
2168 /* We set SOCK_NONBLOCK here so that we rather drop the
2169 * message then wait for plymouth */
2170 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2172 log_error_errno(errno, "socket() failed: %m");
2176 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2178 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2179 log_error_errno(errno, "connect() failed: %m");
2183 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2189 if (write(fd, message, n + 1) != n + 1)
2190 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2191 log_error_errno(errno, "Failed to write Plymouth message: %m");
2194 void manager_dispatch_bus_name_owner_changed(
2197 const char* old_owner,
2198 const char *new_owner) {
2205 u = hashmap_get(m->watch_bus, name);
2209 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2212 int manager_open_serialization(Manager *m, FILE **_f) {
2219 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2220 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2224 log_debug("Serializing state to %s", path);
2226 f = fdopen(fd, "w+");
2237 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2250 fprintf(f, "current-job-id=%"PRIu32"\n", m->current_job_id);
2251 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2252 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2253 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2255 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2256 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2257 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2258 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2261 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2262 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2263 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2264 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2265 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2266 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2267 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2268 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2271 if (!switching_root) {
2272 STRV_FOREACH(e, m->environment) {
2273 _cleanup_free_ char *ce;
2279 fprintf(f, "env=%s\n", *e);
2283 if (m->notify_fd >= 0) {
2286 copy = fdset_put_dup(fds, m->notify_fd);
2290 fprintf(f, "notify-fd=%i\n", copy);
2291 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2294 if (m->kdbus_fd >= 0) {
2297 copy = fdset_put_dup(fds, m->kdbus_fd);
2301 fprintf(f, "kdbus-fd=%i\n", copy);
2304 bus_track_serialize(m->subscribed, f);
2308 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2316 r = unit_serialize(u, f, fds, !switching_root);
2323 assert(m->n_reloading > 0);
2329 r = bus_fdset_add_all(m, fds);
2336 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2342 log_debug("Deserializing state...");
2347 char line[LINE_MAX], *l;
2349 if (!fgets(line, sizeof(line), f)) {
2364 if (startswith(l, "current-job-id=")) {
2367 if (safe_atou32(l+15, &id) < 0)
2368 log_debug("Failed to parse current job id value %s", l+15);
2370 m->current_job_id = MAX(m->current_job_id, id);
2372 } else if (startswith(l, "n-installed-jobs=")) {
2375 if (safe_atou32(l+17, &n) < 0)
2376 log_debug("Failed to parse installed jobs counter %s", l+17);
2378 m->n_installed_jobs += n;
2380 } else if (startswith(l, "n-failed-jobs=")) {
2383 if (safe_atou32(l+14, &n) < 0)
2384 log_debug("Failed to parse failed jobs counter %s", l+14);
2386 m->n_failed_jobs += n;
2388 } else if (startswith(l, "taint-usr=")) {
2391 b = parse_boolean(l+10);
2393 log_debug("Failed to parse taint /usr flag %s", l+10);
2395 m->taint_usr = m->taint_usr || b;
2397 } else if (startswith(l, "firmware-timestamp="))
2398 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2399 else if (startswith(l, "loader-timestamp="))
2400 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2401 else if (startswith(l, "kernel-timestamp="))
2402 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2403 else if (startswith(l, "initrd-timestamp="))
2404 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2405 else if (startswith(l, "userspace-timestamp="))
2406 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2407 else if (startswith(l, "finish-timestamp="))
2408 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2409 else if (startswith(l, "security-start-timestamp="))
2410 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2411 else if (startswith(l, "security-finish-timestamp="))
2412 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2413 else if (startswith(l, "generators-start-timestamp="))
2414 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2415 else if (startswith(l, "generators-finish-timestamp="))
2416 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2417 else if (startswith(l, "units-load-start-timestamp="))
2418 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2419 else if (startswith(l, "units-load-finish-timestamp="))
2420 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2421 else if (startswith(l, "env=")) {
2422 _cleanup_free_ char *uce = NULL;
2425 uce = cunescape(l+4);
2431 e = strv_env_set(m->environment, uce);
2437 strv_free(m->environment);
2440 } else if (startswith(l, "notify-fd=")) {
2443 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2444 log_debug("Failed to parse notify fd: %s", l + 10);
2446 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2447 safe_close(m->notify_fd);
2448 m->notify_fd = fdset_remove(fds, fd);
2451 } else if (startswith(l, "notify-socket=")) {
2460 free(m->notify_socket);
2461 m->notify_socket = n;
2463 } else if (startswith(l, "kdbus-fd=")) {
2466 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2467 log_debug("Failed to parse kdbus fd: %s", l + 9);
2469 safe_close(m->kdbus_fd);
2470 m->kdbus_fd = fdset_remove(fds, fd);
2476 k = bus_track_deserialize_item(&m->deserialized_subscribed, l);
2478 log_debug_errno(k, "Failed to deserialize bus tracker object: %m");
2480 log_debug("Unknown serialization item '%s'", l);
2486 char name[UNIT_NAME_MAX+2];
2489 if (!fgets(name, sizeof(name), f)) {
2500 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2504 r = unit_deserialize(u, f, fds);
2513 assert(m->n_reloading > 0);
2519 int manager_reload(Manager *m) {
2521 _cleanup_fclose_ FILE *f = NULL;
2522 _cleanup_fdset_free_ FDSet *fds = NULL;
2526 r = manager_open_serialization(m, &f);
2531 bus_manager_send_reloading(m, true);
2539 r = manager_serialize(m, f, fds, false);
2545 if (fseeko(f, 0, SEEK_SET) < 0) {
2550 /* From here on there is no way back. */
2551 manager_clear_jobs_and_units(m);
2552 manager_undo_generators(m);
2553 lookup_paths_free(&m->lookup_paths);
2555 /* Find new unit paths */
2556 q = manager_run_generators(m);
2557 if (q < 0 && r >= 0)
2560 q = lookup_paths_init(
2561 &m->lookup_paths, m->running_as, true,
2563 m->generator_unit_path,
2564 m->generator_unit_path_early,
2565 m->generator_unit_path_late);
2566 if (q < 0 && r >= 0)
2569 manager_build_unit_path_cache(m);
2571 /* First, enumerate what we can from all config files */
2572 q = manager_enumerate(m);
2573 if (q < 0 && r >= 0)
2576 /* Second, deserialize our stored data */
2577 q = manager_deserialize(m, f, fds);
2578 if (q < 0 && r >= 0)
2584 /* Re-register notify_fd as event source */
2585 q = manager_setup_notify(m);
2586 if (q < 0 && r >= 0)
2589 /* Third, fire things up! */
2590 q = manager_coldplug(m);
2591 if (q < 0 && r >= 0)
2594 assert(m->n_reloading > 0);
2597 m->send_reloading_done = true;
2602 bool manager_is_reloading_or_reexecuting(Manager *m) {
2605 return m->n_reloading != 0;
2608 void manager_reset_failed(Manager *m) {
2614 HASHMAP_FOREACH(u, m->units, i)
2615 unit_reset_failed(u);
2618 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2624 /* Returns true if the unit is inactive or going down */
2625 u = manager_get_unit(m, name);
2629 return unit_inactive_or_pending(u);
2632 static void manager_notify_finished(Manager *m) {
2633 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2634 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2639 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2641 /* Note that m->kernel_usec.monotonic is always at 0,
2642 * and m->firmware_usec.monotonic and
2643 * m->loader_usec.monotonic should be considered
2644 * negative values. */
2646 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2647 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2648 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2649 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2651 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2653 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2654 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2656 log_struct(LOG_INFO,
2657 LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2658 "KERNEL_USEC="USEC_FMT, kernel_usec,
2659 "INITRD_USEC="USEC_FMT, initrd_usec,
2660 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2661 LOG_MESSAGE("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2662 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2663 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2664 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2665 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2668 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2671 log_struct(LOG_INFO,
2672 LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2673 "KERNEL_USEC="USEC_FMT, kernel_usec,
2674 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2675 LOG_MESSAGE("Startup finished in %s (kernel) + %s (userspace) = %s.",
2676 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2677 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2678 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2682 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2683 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2685 log_struct(LOG_INFO,
2686 LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2687 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2688 LOG_MESSAGE("Startup finished in %s.",
2689 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2693 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2697 "STATUS=Startup finished in %s.",
2698 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2701 void manager_check_finished(Manager *m) {
2707 if (hashmap_size(m->jobs) > 0) {
2709 if (m->jobs_in_progress_event_source)
2710 sd_event_source_set_time(m->jobs_in_progress_event_source, now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2715 manager_flip_auto_status(m, false);
2717 /* Notify Type=idle units that we are done now */
2718 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2719 manager_close_idle_pipe(m);
2721 /* Turn off confirm spawn now */
2722 m->confirm_spawn = false;
2724 /* No need to update ask password status when we're going non-interactive */
2725 manager_close_ask_password(m);
2727 /* This is no longer the first boot */
2728 manager_set_first_boot(m, false);
2730 if (dual_timestamp_is_set(&m->finish_timestamp))
2733 dual_timestamp_get(&m->finish_timestamp);
2735 manager_notify_finished(m);
2737 SET_FOREACH(u, m->startup_units, i)
2739 cgroup_context_apply(unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path, manager_state(m));
2742 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2753 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2754 /* systemd --system, not running --test */
2756 p = strappend("/run/systemd/", name);
2760 r = mkdir_p_label(p, 0755);
2762 log_error_errno(r, "Failed to create generator directory %s: %m", p);
2766 } else if (m->running_as == SYSTEMD_USER) {
2767 const char *s = NULL;
2769 s = getenv("XDG_RUNTIME_DIR");
2772 p = strjoin(s, "/systemd/", name, NULL);
2776 r = mkdir_p_label(p, 0755);
2778 log_error_errno(r, "Failed to create generator directory %s: %m", p);
2783 /* systemd --system --test */
2785 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2790 log_error_errno(errno, "Failed to create generator directory %s: %m",
2801 static void trim_generator_dir(Manager *m, char **generator) {
2808 if (rmdir(*generator) >= 0) {
2816 static int manager_run_generators(Manager *m) {
2817 _cleanup_free_ char **paths = NULL;
2818 const char *argv[5];
2827 paths = generator_paths(m->running_as);
2831 /* Optimize by skipping the whole process by not creating output directories
2832 * if no generators are found. */
2833 STRV_FOREACH(path, paths) {
2834 r = access(*path, F_OK);
2837 if (errno != ENOENT)
2838 log_warning_errno(errno, "Failed to open generator directory %s: %m", *path);
2843 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2847 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2851 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2855 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2856 argv[1] = m->generator_unit_path;
2857 argv[2] = m->generator_unit_path_early;
2858 argv[3] = m->generator_unit_path_late;
2861 RUN_WITH_UMASK(0022)
2862 execute_directories((const char* const*) paths, DEFAULT_TIMEOUT_USEC, (char**) argv);
2865 trim_generator_dir(m, &m->generator_unit_path);
2866 trim_generator_dir(m, &m->generator_unit_path_early);
2867 trim_generator_dir(m, &m->generator_unit_path_late);
2871 static void remove_generator_dir(Manager *m, char **generator) {
2878 strv_remove(m->lookup_paths.unit_path, *generator);
2879 rm_rf(*generator, false, true, false);
2885 static void manager_undo_generators(Manager *m) {
2888 remove_generator_dir(m, &m->generator_unit_path);
2889 remove_generator_dir(m, &m->generator_unit_path_early);
2890 remove_generator_dir(m, &m->generator_unit_path_late);
2893 int manager_environment_add(Manager *m, char **minus, char **plus) {
2894 char **a = NULL, **b = NULL, **l;
2899 if (!strv_isempty(minus)) {
2900 a = strv_env_delete(l, 1, minus);
2907 if (!strv_isempty(plus)) {
2908 b = strv_env_merge(2, l, plus);
2917 if (m->environment != l)
2918 strv_free(m->environment);
2925 manager_clean_environment(m);
2926 strv_sort(m->environment);
2931 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2936 for (i = 0; i < _RLIMIT_MAX; i++) {
2937 if (!default_rlimit[i])
2940 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2948 void manager_recheck_journal(Manager *m) {
2953 if (m->running_as != SYSTEMD_SYSTEM)
2956 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2957 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2958 log_close_journal();
2962 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2963 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2964 log_close_journal();
2968 /* Hmm, OK, so the socket is fully up and the service is up
2969 * too, then let's make use of the thing. */
2973 void manager_set_show_status(Manager *m, ShowStatus mode) {
2975 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2977 if (m->running_as != SYSTEMD_SYSTEM)
2980 m->show_status = mode;
2983 touch("/run/systemd/show-status");
2985 unlink("/run/systemd/show-status");
2988 static bool manager_get_show_status(Manager *m, StatusType type) {
2991 if (m->running_as != SYSTEMD_SYSTEM)
2994 if (m->no_console_output)
2997 if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
3000 /* If we cannot find out the status properly, just proceed. */
3001 if (type != STATUS_TYPE_EMERGENCY && manager_check_ask_password(m) > 0)
3004 if (m->show_status > 0)
3007 /* If Plymouth is running make sure we show the status, so
3008 * that there's something nice to see when people press Esc */
3009 return plymouth_running();
3012 void manager_set_first_boot(Manager *m, bool b) {
3015 if (m->running_as != SYSTEMD_SYSTEM)
3021 touch("/run/systemd/first-boot");
3023 unlink("/run/systemd/first-boot");
3026 void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) {
3029 /* If m is NULL, assume we're after shutdown and let the messages through. */
3031 if (m && !manager_get_show_status(m, type))
3034 /* XXX We should totally drop the check for ephemeral here
3035 * and thus effectively make 'Type=idle' pointless. */
3036 if (type == STATUS_TYPE_EPHEMERAL && m && m->n_on_console > 0)
3039 va_start(ap, format);
3040 status_vprintf(status, true, type == STATUS_TYPE_EPHEMERAL, format, ap);
3044 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
3045 _cleanup_free_ char *p = NULL;
3053 p = unit_name_from_path(path, suffix);
3057 found = manager_get_unit(m, p);
3067 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
3068 char p[strlen(path)+1];
3074 path_kill_slashes(p);
3076 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
3079 const char *manager_get_runtime_prefix(Manager *m) {
3082 return m->running_as == SYSTEMD_SYSTEM ?
3084 getenv("XDG_RUNTIME_DIR");
3087 void manager_update_failed_units(Manager *m, Unit *u, bool failed) {
3091 assert(u->manager == m);
3093 size = set_size(m->failed_units);
3096 set_put(m->failed_units, u);
3098 set_remove(m->failed_units, u);
3100 if (set_size(m->failed_units) != size)
3101 bus_manager_send_change_signal(m);
3104 ManagerState manager_state(Manager *m) {
3109 /* Did we ever finish booting? If not then we are still starting up */
3110 if (!dual_timestamp_is_set(&m->finish_timestamp)) {
3112 u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
3113 if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
3114 return MANAGER_INITIALIZING;
3116 return MANAGER_STARTING;
3119 /* Is the special shutdown target queued? If so, we are in shutdown state */
3120 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
3121 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
3122 return MANAGER_STOPPING;
3124 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
3125 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
3126 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3127 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3128 return MANAGER_MAINTENANCE;
3130 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
3131 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3132 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3133 return MANAGER_MAINTENANCE;
3135 /* Are there any failed units? If so, we are in degraded mode */
3136 if (set_size(m->failed_units) > 0)
3137 return MANAGER_DEGRADED;
3139 return MANAGER_RUNNING;
3142 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
3143 [MANAGER_INITIALIZING] = "initializing",
3144 [MANAGER_STARTING] = "starting",
3145 [MANAGER_RUNNING] = "running",
3146 [MANAGER_DEGRADED] = "degraded",
3147 [MANAGER_MAINTENANCE] = "maintenance",
3148 [MANAGER_STOPPING] = "stopping",
3151 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);