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);
94 static int manager_watch_jobs_in_progress(Manager *m) {
99 if (m->jobs_in_progress_event_source)
102 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
103 return sd_event_add_time(
105 &m->jobs_in_progress_event_source,
108 manager_dispatch_jobs_in_progress, m);
111 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
113 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
116 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
117 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
121 p = mempset(p, ' ', pos-2);
122 p = stpcpy(p, ANSI_RED_ON);
126 if (pos > 0 && pos <= width) {
127 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
131 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
134 p = stpcpy(p, ANSI_RED_ON);
137 p = mempset(p, ' ', width-1-pos);
138 strcpy(p, ANSI_HIGHLIGHT_OFF);
142 void manager_flip_auto_status(Manager *m, bool enable) {
146 if (m->show_status == SHOW_STATUS_AUTO)
147 manager_set_show_status(m, SHOW_STATUS_TEMPORARY);
149 if (m->show_status == SHOW_STATUS_TEMPORARY)
150 manager_set_show_status(m, SHOW_STATUS_AUTO);
154 static void manager_print_jobs_in_progress(Manager *m) {
155 _cleanup_free_ char *job_of_n = NULL;
158 unsigned counter = 0, print_nr;
159 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
161 char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
166 manager_flip_auto_status(m, true);
168 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
170 HASHMAP_FOREACH(j, m->jobs, i)
171 if (j->state == JOB_RUNNING && counter++ == print_nr)
174 /* m->n_running_jobs must be consistent with the contents of m->jobs,
175 * so the above loop must have succeeded in finding j. */
176 assert(counter == print_nr + 1);
179 cylon_pos = m->jobs_in_progress_iteration % 14;
181 cylon_pos = 14 - cylon_pos;
182 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
184 m->jobs_in_progress_iteration++;
186 if (m->n_running_jobs > 1)
187 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
190 format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
191 if (job_get_timeout(j, &x) > 0)
192 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
194 manager_status_printf(m, STATUS_TYPE_EPHEMERAL, cylon,
195 "%sA %s job is running for %s (%s / %s)",
197 job_type_to_string(j->type),
198 unit_description(j->unit),
203 static int have_ask_password(void) {
204 _cleanup_closedir_ DIR *dir;
206 dir = opendir("/run/systemd/ask-password");
219 if (!de && errno != 0)
224 if (startswith(de->d_name, "ask."))
229 static int manager_dispatch_ask_password_fd(sd_event_source *source,
230 int fd, uint32_t revents, void *userdata) {
231 Manager *m = userdata;
237 m->have_ask_password = have_ask_password();
238 if (m->have_ask_password < 0)
239 /* Log error but continue. Negative have_ask_password
240 * is treated as unknown status. */
241 log_error_errno(m->have_ask_password, "Failed to list /run/systemd/ask-password: %m");
246 static void manager_close_ask_password(Manager *m) {
249 m->ask_password_inotify_fd = safe_close(m->ask_password_inotify_fd);
250 m->ask_password_event_source = sd_event_source_unref(m->ask_password_event_source);
251 m->have_ask_password = -EINVAL;
254 static int manager_check_ask_password(Manager *m) {
259 if (!m->ask_password_event_source) {
260 assert(m->ask_password_inotify_fd < 0);
262 mkdir_p_label("/run/systemd/ask-password", 0755);
264 m->ask_password_inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
265 if (m->ask_password_inotify_fd < 0)
266 return log_error_errno(errno, "inotify_init1() failed: %m");
268 if (inotify_add_watch(m->ask_password_inotify_fd, "/run/systemd/ask-password", IN_CREATE|IN_DELETE|IN_MOVE) < 0) {
269 log_error_errno(errno, "Failed to add watch on /run/systemd/ask-password: %m");
270 manager_close_ask_password(m);
274 r = sd_event_add_io(m->event, &m->ask_password_event_source,
275 m->ask_password_inotify_fd, EPOLLIN,
276 manager_dispatch_ask_password_fd, m);
278 log_error_errno(errno, "Failed to add event source for /run/systemd/ask-password: %m");
279 manager_close_ask_password(m);
283 /* Queries might have been added meanwhile... */
284 manager_dispatch_ask_password_fd(m->ask_password_event_source,
285 m->ask_password_inotify_fd, EPOLLIN, m);
288 return m->have_ask_password;
291 static int manager_watch_idle_pipe(Manager *m) {
296 if (m->idle_pipe_event_source)
299 if (m->idle_pipe[2] < 0)
302 r = sd_event_add_io(m->event, &m->idle_pipe_event_source, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m);
304 return log_error_errno(r, "Failed to watch idle pipe: %m");
309 static void manager_close_idle_pipe(Manager *m) {
312 safe_close_pair(m->idle_pipe);
313 safe_close_pair(m->idle_pipe + 2);
316 static int manager_setup_time_change(Manager *m) {
319 /* We only care for the cancellation event, hence we set the
320 * timeout to the latest possible value. */
321 struct itimerspec its = {
322 .it_value.tv_sec = TIME_T_MAX,
326 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
331 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
332 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
334 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
335 if (m->time_change_fd < 0)
336 return log_error_errno(errno, "Failed to create timerfd: %m");
338 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
339 log_debug_errno(errno, "Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
340 m->time_change_fd = safe_close(m->time_change_fd);
344 r = sd_event_add_io(m->event, &m->time_change_event_source, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m);
346 return log_error_errno(r, "Failed to create time change event source: %m");
348 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
353 static int enable_special_signals(Manager *m) {
354 _cleanup_close_ int fd = -1;
358 /* Enable that we get SIGINT on control-alt-del. In containers
359 * this will fail with EPERM (older) or EINVAL (newer), so
361 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
362 log_warning_errno(errno, "Failed to enable ctrl-alt-del handling: %m");
364 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
366 /* Support systems without virtual console */
368 log_warning_errno(errno, "Failed to open /dev/tty0: %m");
370 /* Enable that we get SIGWINCH on kbrequest */
371 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
372 log_warning_errno(errno, "Failed to enable kbrequest handling: %m");
378 static int manager_setup_signals(Manager *m) {
379 struct sigaction sa = {
380 .sa_handler = SIG_DFL,
381 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
388 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
390 /* We make liberal use of realtime signals here. On
391 * Linux/glibc we have 30 of them (with the exception of Linux
392 * on hppa, see below), between SIGRTMIN+0 ... SIGRTMIN+30
395 assert_se(sigemptyset(&mask) == 0);
396 sigset_add_many(&mask,
397 SIGCHLD, /* Child died */
398 SIGTERM, /* Reexecute daemon */
399 SIGHUP, /* Reload configuration */
400 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
401 SIGUSR2, /* systemd: dump status */
402 SIGINT, /* Kernel sends us this on control-alt-del */
403 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
404 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
406 SIGRTMIN+0, /* systemd: start default.target */
407 SIGRTMIN+1, /* systemd: isolate rescue.target */
408 SIGRTMIN+2, /* systemd: isolate emergency.target */
409 SIGRTMIN+3, /* systemd: start halt.target */
410 SIGRTMIN+4, /* systemd: start poweroff.target */
411 SIGRTMIN+5, /* systemd: start reboot.target */
412 SIGRTMIN+6, /* systemd: start kexec.target */
414 /* ... space for more special targets ... */
416 SIGRTMIN+13, /* systemd: Immediate halt */
417 SIGRTMIN+14, /* systemd: Immediate poweroff */
418 SIGRTMIN+15, /* systemd: Immediate reboot */
419 SIGRTMIN+16, /* systemd: Immediate kexec */
421 /* ... space for more immediate system state changes ... */
423 SIGRTMIN+20, /* systemd: enable status messages */
424 SIGRTMIN+21, /* systemd: disable status messages */
425 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
426 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
427 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
429 /* .. one free signal here ... */
431 #if !defined(__hppa64__) && !defined(__hppa__)
432 /* Apparently Linux on hppa has fewer RT
433 * signals (SIGRTMAX is SIGRTMIN+25 there),
434 * hence let's not try to make use of them
435 * here. Since these commands are accessible
436 * by different means and only really a safety
437 * net, the missing functionality on hppa
438 * shouldn't matter. */
440 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
441 SIGRTMIN+27, /* systemd: set log target to console */
442 SIGRTMIN+28, /* systemd: set log target to kmsg */
443 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg (obsolete) */
445 /* ... one free signal here SIGRTMIN+30 ... */
448 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
450 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
451 if (m->signal_fd < 0)
454 r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);
458 /* Process signals a bit earlier than the rest of things, but
459 * later than notify_fd processing, so that the notify
460 * processing can still figure out to which process/service a
461 * message belongs, before we reap the process. */
462 r = sd_event_source_set_priority(m->signal_event_source, -5);
466 if (m->running_as == SYSTEMD_SYSTEM)
467 return enable_special_signals(m);
472 static void manager_clean_environment(Manager *m) {
475 /* Let's remove some environment variables that we
476 * need ourselves to communicate with our clients */
489 static int manager_default_environment(Manager *m) {
492 if (m->running_as == SYSTEMD_SYSTEM) {
493 /* The system manager always starts with a clean
494 * environment for its children. It does not import
495 * the kernel or the parents exported variables.
497 * The initial passed environ is untouched to keep
498 * /proc/self/environ valid; it is used for tagging
499 * the init process inside containers. */
500 m->environment = strv_new("PATH=" DEFAULT_PATH,
503 /* Import locale variables LC_*= from configuration */
504 locale_setup(&m->environment);
506 /* The user manager passes its own environment
507 * along to its children. */
508 m->environment = strv_copy(environ);
514 manager_clean_environment(m);
515 strv_sort(m->environment);
520 int manager_new(SystemdRunningAs running_as, bool test_run, Manager **_m) {
525 assert(running_as >= 0);
526 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
528 m = new0(Manager, 1);
533 if (running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0)
534 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
537 m->running_as = running_as;
538 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
539 m->default_timer_accuracy_usec = USEC_PER_MINUTE;
541 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
543 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;
544 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
546 m->ask_password_inotify_fd = -1;
547 m->have_ask_password = -EINVAL; /* we don't know */
549 m->test_run = test_run;
551 r = manager_default_environment(m);
555 r = hashmap_ensure_allocated(&m->units, &string_hash_ops);
559 r = hashmap_ensure_allocated(&m->jobs, NULL);
563 r = hashmap_ensure_allocated(&m->cgroup_unit, &string_hash_ops);
567 r = hashmap_ensure_allocated(&m->watch_bus, &string_hash_ops);
571 r = set_ensure_allocated(&m->startup_units, NULL);
575 r = set_ensure_allocated(&m->failed_units, NULL);
579 r = sd_event_default(&m->event);
583 r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
587 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
591 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
595 r = manager_setup_signals(m);
599 r = manager_setup_cgroup(m);
603 r = manager_setup_time_change(m);
607 m->udev = udev_new();
613 /* Note that we set up neither kdbus, nor the notify fd
614 * here. We do that after deserialization, since they might
615 * have gotten serialized across the reexec. */
617 m->taint_usr = dir_is_empty("/usr") > 0;
627 static int manager_setup_notify(Manager *m) {
633 if (m->notify_fd < 0) {
634 _cleanup_close_ int fd = -1;
635 union sockaddr_union sa = {
636 .sa.sa_family = AF_UNIX,
638 static const int one = 1;
640 /* First free all secondary fields */
641 free(m->notify_socket);
642 m->notify_socket = NULL;
643 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
645 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
647 return log_error_errno(errno, "Failed to allocate notification socket: %m");
649 if (m->running_as == SYSTEMD_SYSTEM)
650 m->notify_socket = strdup("/run/systemd/notify");
654 e = getenv("XDG_RUNTIME_DIR");
656 log_error_errno(errno, "XDG_RUNTIME_DIR is not set: %m");
660 m->notify_socket = strappend(e, "/systemd/notify");
662 if (!m->notify_socket)
665 (void) mkdir_parents_label(m->notify_socket, 0755);
666 (void) unlink(m->notify_socket);
668 strncpy(sa.un.sun_path, m->notify_socket, sizeof(sa.un.sun_path)-1);
669 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path));
671 return log_error_errno(errno, "bind(%s) failed: %m", sa.un.sun_path);
673 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
675 return log_error_errno(errno, "SO_PASSCRED failed: %m");
680 log_debug("Using notification socket %s", m->notify_socket);
683 if (!m->notify_event_source) {
684 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
686 return log_error_errno(r, "Failed to allocate notify event source: %m");
688 /* Process signals a bit earlier than SIGCHLD, so that we can
689 * still identify to which service an exit message belongs */
690 r = sd_event_source_set_priority(m->notify_event_source, -7);
692 return log_error_errno(r, "Failed to set priority of notify event source: %m");
698 static int manager_setup_kdbus(Manager *m) {
700 _cleanup_free_ char *p = NULL;
704 if (m->test_run || m->kdbus_fd >= 0)
708 bus_kernel_fix_attach_mask();
710 m->kdbus_fd = bus_kernel_create_bus(
711 m->running_as == SYSTEMD_SYSTEM ? "system" : "user",
712 m->running_as == SYSTEMD_SYSTEM, &p);
715 return log_debug_errno(m->kdbus_fd, "Failed to set up kdbus: %m");
717 log_debug("Successfully set up kdbus on %s", p);
723 static int manager_connect_bus(Manager *m, bool reexecuting) {
724 bool try_bus_connect;
734 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
736 /* Try to connect to the busses, if possible. */
737 return bus_init(m, try_bus_connect);
740 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
746 while ((u = m->cleanup_queue)) {
747 assert(u->in_cleanup_queue);
757 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
758 GC_OFFSET_UNSURE, /* No clue */
759 GC_OFFSET_GOOD, /* We still need this unit */
760 GC_OFFSET_BAD, /* We don't need this unit anymore */
764 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
771 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
772 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
773 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
776 if (u->in_cleanup_queue)
779 if (unit_check_gc(u))
782 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
786 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
787 unit_gc_sweep(other, gc_marker);
789 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
792 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
799 /* We were unable to find anything out about this entry, so
800 * let's investigate it later */
801 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
802 unit_add_to_gc_queue(u);
806 /* We definitely know that this one is not useful anymore, so
807 * let's mark it for deletion */
808 u->gc_marker = gc_marker + GC_OFFSET_BAD;
809 unit_add_to_cleanup_queue(u);
813 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
816 static unsigned manager_dispatch_gc_queue(Manager *m) {
823 /* log_debug("Running GC..."); */
825 m->gc_marker += _GC_OFFSET_MAX;
826 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
829 gc_marker = m->gc_marker;
831 while ((u = m->gc_queue)) {
832 assert(u->in_gc_queue);
834 unit_gc_sweep(u, gc_marker);
836 LIST_REMOVE(gc_queue, m->gc_queue, u);
837 u->in_gc_queue = false;
841 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
842 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
843 log_unit_debug(u->id, "Collecting %s", u->id);
844 u->gc_marker = gc_marker + GC_OFFSET_BAD;
845 unit_add_to_cleanup_queue(u);
849 m->n_in_gc_queue = 0;
854 static void manager_clear_jobs_and_units(Manager *m) {
859 while ((u = hashmap_first(m->units)))
862 manager_dispatch_cleanup_queue(m);
864 assert(!m->load_queue);
865 assert(!m->run_queue);
866 assert(!m->dbus_unit_queue);
867 assert(!m->dbus_job_queue);
868 assert(!m->cleanup_queue);
869 assert(!m->gc_queue);
871 assert(hashmap_isempty(m->jobs));
872 assert(hashmap_isempty(m->units));
875 m->n_running_jobs = 0;
878 Manager* manager_free(Manager *m) {
885 manager_clear_jobs_and_units(m);
887 for (c = 0; c < _UNIT_TYPE_MAX; c++)
888 if (unit_vtable[c]->shutdown)
889 unit_vtable[c]->shutdown(m);
891 /* If we reexecute ourselves, we keep the root cgroup
893 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
895 manager_undo_generators(m);
899 hashmap_free(m->units);
900 hashmap_free(m->jobs);
901 hashmap_free(m->watch_pids1);
902 hashmap_free(m->watch_pids2);
903 hashmap_free(m->watch_bus);
905 set_free(m->startup_units);
906 set_free(m->failed_units);
908 sd_event_source_unref(m->signal_event_source);
909 sd_event_source_unref(m->notify_event_source);
910 sd_event_source_unref(m->time_change_event_source);
911 sd_event_source_unref(m->jobs_in_progress_event_source);
912 sd_event_source_unref(m->idle_pipe_event_source);
913 sd_event_source_unref(m->run_queue_event_source);
915 safe_close(m->signal_fd);
916 safe_close(m->notify_fd);
917 safe_close(m->time_change_fd);
918 safe_close(m->kdbus_fd);
920 manager_close_ask_password(m);
922 manager_close_idle_pipe(m);
925 sd_event_unref(m->event);
927 free(m->notify_socket);
929 lookup_paths_free(&m->lookup_paths);
930 strv_free(m->environment);
932 hashmap_free(m->cgroup_unit);
933 set_free_free(m->unit_path_cache);
935 free(m->switch_root);
936 free(m->switch_root_init);
938 for (i = 0; i < _RLIMIT_MAX; i++)
941 assert(hashmap_isempty(m->units_requiring_mounts_for));
942 hashmap_free(m->units_requiring_mounts_for);
948 int manager_enumerate(Manager *m) {
954 /* Let's ask every type to load all units from disk/kernel
955 * that it might know */
956 for (c = 0; c < _UNIT_TYPE_MAX; c++)
957 if (unit_vtable[c]->enumerate) {
958 q = unit_vtable[c]->enumerate(m);
963 manager_dispatch_load_queue(m);
967 static int manager_coldplug(Manager *m) {
975 /* Then, let's set up their initial state. */
976 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
983 q = unit_coldplug(u);
991 static void manager_build_unit_path_cache(Manager *m) {
993 _cleanup_closedir_ DIR *d = NULL;
998 set_free_free(m->unit_path_cache);
1000 m->unit_path_cache = set_new(&string_hash_ops);
1001 if (!m->unit_path_cache) {
1002 log_error("Failed to allocate unit path cache.");
1006 /* This simply builds a list of files we know exist, so that
1007 * we don't always have to go to disk */
1009 STRV_FOREACH(i, m->lookup_paths.unit_path) {
1014 if (errno != ENOENT)
1015 log_error_errno(errno, "Failed to open directory %s: %m", *i);
1019 while ((de = readdir(d))) {
1022 if (ignore_file(de->d_name))
1025 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
1031 r = set_consume(m->unit_path_cache, p);
1043 log_error_errno(r, "Failed to build unit path cache: %m");
1045 set_free_free(m->unit_path_cache);
1046 m->unit_path_cache = NULL;
1050 static int manager_distribute_fds(Manager *m, FDSet *fds) {
1057 HASHMAP_FOREACH(u, m->units, i) {
1059 if (fdset_size(fds) <= 0)
1062 if (UNIT_VTABLE(u)->distribute_fds) {
1063 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
1072 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
1077 dual_timestamp_get(&m->generators_start_timestamp);
1078 manager_run_generators(m);
1079 dual_timestamp_get(&m->generators_finish_timestamp);
1081 r = lookup_paths_init(
1082 &m->lookup_paths, m->running_as, true,
1084 m->generator_unit_path,
1085 m->generator_unit_path_early,
1086 m->generator_unit_path_late);
1090 manager_build_unit_path_cache(m);
1092 /* If we will deserialize make sure that during enumeration
1093 * this is already known, so we increase the counter here
1098 /* First, enumerate what we can from all config files */
1099 dual_timestamp_get(&m->units_load_start_timestamp);
1100 r = manager_enumerate(m);
1101 dual_timestamp_get(&m->units_load_finish_timestamp);
1103 /* Second, deserialize if there is something to deserialize */
1105 r = manager_deserialize(m, serialization, fds);
1107 /* Any fds left? Find some unit which wants them. This is
1108 * useful to allow container managers to pass some file
1109 * descriptors to us pre-initialized. This enables
1110 * socket-based activation of entire containers. */
1111 if (fdset_size(fds) > 0) {
1112 q = manager_distribute_fds(m, fds);
1113 if (q < 0 && r == 0)
1117 /* We might have deserialized the notify fd, but if we didn't
1118 * then let's create the bus now */
1119 q = manager_setup_notify(m);
1120 if (q < 0 && r == 0)
1123 /* We might have deserialized the kdbus control fd, but if we
1124 * didn't, then let's create the bus now. */
1125 manager_setup_kdbus(m);
1126 manager_connect_bus(m, !!serialization);
1127 bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
1129 /* Third, fire things up! */
1130 q = manager_coldplug(m);
1131 if (q < 0 && r == 0)
1134 if (serialization) {
1135 assert(m->n_reloading > 0);
1138 /* Let's wait for the UnitNew/JobNew messages being
1139 * sent, before we notify that the reload is
1141 m->send_reloading_done = true;
1147 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1152 assert(type < _JOB_TYPE_MAX);
1154 assert(mode < _JOB_MODE_MAX);
1156 if (mode == JOB_ISOLATE && type != JOB_START)
1157 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1159 if (mode == JOB_ISOLATE && !unit->allow_isolate)
1160 return sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1162 log_unit_debug(unit->id,
1163 "Trying to enqueue job %s/%s/%s", unit->id,
1164 job_type_to_string(type), job_mode_to_string(mode));
1166 job_type_collapse(&type, unit);
1168 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1172 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1173 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1174 mode == JOB_IGNORE_DEPENDENCIES, e);
1178 if (mode == JOB_ISOLATE) {
1179 r = transaction_add_isolate_jobs(tr, m);
1184 r = transaction_activate(tr, m, mode, e);
1188 log_unit_debug(unit->id,
1189 "Enqueued job %s/%s as %u", unit->id,
1190 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1193 *_ret = tr->anchor_job;
1195 transaction_free(tr);
1199 transaction_abort(tr);
1200 transaction_free(tr);
1204 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1209 assert(type < _JOB_TYPE_MAX);
1211 assert(mode < _JOB_MODE_MAX);
1213 r = manager_load_unit(m, name, NULL, NULL, &unit);
1217 return manager_add_job(m, type, unit, mode, override, e, _ret);
1220 Job *manager_get_job(Manager *m, uint32_t id) {
1223 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1226 Unit *manager_get_unit(Manager *m, const char *name) {
1230 return hashmap_get(m->units, name);
1233 unsigned manager_dispatch_load_queue(Manager *m) {
1239 /* Make sure we are not run recursively */
1240 if (m->dispatching_load_queue)
1243 m->dispatching_load_queue = true;
1245 /* Dispatches the load queue. Takes a unit from the queue and
1246 * tries to load its data until the queue is empty */
1248 while ((u = m->load_queue)) {
1249 assert(u->in_load_queue);
1255 m->dispatching_load_queue = false;
1259 int manager_load_unit_prepare(
1271 assert(name || path);
1273 /* This will prepare the unit for loading, but not actually
1274 * load anything from disk. */
1276 if (path && !is_path(path))
1277 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1280 name = basename(path);
1282 t = unit_name_to_type(name);
1284 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1285 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1287 ret = manager_get_unit(m, name);
1293 ret = unit_new(m, unit_vtable[t]->object_size);
1298 ret->fragment_path = strdup(path);
1299 if (!ret->fragment_path) {
1305 r = unit_add_name(ret, name);
1311 unit_add_to_load_queue(ret);
1312 unit_add_to_dbus_queue(ret);
1313 unit_add_to_gc_queue(ret);
1321 int manager_load_unit(
1332 /* This will load the service information files, but not actually
1333 * start any services or anything. */
1335 r = manager_load_unit_prepare(m, name, path, e, _ret);
1339 manager_dispatch_load_queue(m);
1342 *_ret = unit_follow_merge(*_ret);
1347 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1354 HASHMAP_FOREACH(j, s->jobs, i)
1355 job_dump(j, f, prefix);
1358 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1366 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1368 unit_dump(u, f, prefix);
1371 void manager_clear_jobs(Manager *m) {
1376 while ((j = hashmap_first(m->jobs)))
1377 /* No need to recurse. We're cancelling all jobs. */
1378 job_finish_and_invalidate(j, JOB_CANCELED, false);
1381 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1382 Manager *m = userdata;
1388 while ((j = m->run_queue)) {
1389 assert(j->installed);
1390 assert(j->in_run_queue);
1392 job_run_and_invalidate(j);
1395 if (m->n_running_jobs > 0)
1396 manager_watch_jobs_in_progress(m);
1398 if (m->n_on_console > 0)
1399 manager_watch_idle_pipe(m);
1404 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1411 if (m->dispatching_dbus_queue)
1414 m->dispatching_dbus_queue = true;
1416 while ((u = m->dbus_unit_queue)) {
1417 assert(u->in_dbus_queue);
1419 bus_unit_send_change_signal(u);
1423 while ((j = m->dbus_job_queue)) {
1424 assert(j->in_dbus_queue);
1426 bus_job_send_change_signal(j);
1430 m->dispatching_dbus_queue = false;
1432 if (m->send_reloading_done) {
1433 m->send_reloading_done = false;
1435 bus_manager_send_reloading(m, false);
1438 if (m->queued_message)
1439 bus_send_queued_message(m);
1444 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n) {
1445 _cleanup_strv_free_ char **tags = NULL;
1452 tags = strv_split(buf, "\n\r");
1458 log_unit_debug(u->id, "Got notification message for unit %s", u->id);
1460 if (UNIT_VTABLE(u)->notify_message)
1461 UNIT_VTABLE(u)->notify_message(u, pid, tags);
1464 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1465 Manager *m = userdata;
1469 assert(m->notify_fd == fd);
1471 if (revents != EPOLLIN) {
1472 log_warning("Got unexpected poll event for notify fd.");
1478 struct iovec iovec = {
1480 .iov_len = sizeof(buf)-1,
1485 struct cmsghdr cmsghdr;
1486 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1489 struct msghdr msghdr = {
1492 .msg_control = &control,
1493 .msg_controllen = sizeof(control),
1495 struct ucred *ucred;
1498 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1503 if (errno == EAGAIN || errno == EINTR)
1509 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1510 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1511 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1512 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1513 log_warning("Received notify message without credentials. Ignoring.");
1517 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1519 assert((size_t) n < sizeof(buf));
1522 /* Notify every unit that might be interested, but try
1523 * to avoid notifying the same one multiple times. */
1524 u1 = manager_get_unit_by_pid(m, ucred->pid);
1526 manager_invoke_notify_message(m, u1, ucred->pid, buf, n);
1530 u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1531 if (u2 && u2 != u1) {
1532 manager_invoke_notify_message(m, u2, ucred->pid, buf, n);
1536 u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1537 if (u3 && u3 != u2 && u3 != u1) {
1538 manager_invoke_notify_message(m, u3, ucred->pid, buf, n);
1543 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1549 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1554 log_unit_debug(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1556 unit_unwatch_pid(u, si->si_pid);
1557 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1560 static int manager_dispatch_sigchld(Manager *m) {
1566 /* First we call waitd() for a PID and do not reap the
1567 * zombie. That way we can still access /proc/$PID for
1568 * it while it is a zombie. */
1569 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1571 if (errno == ECHILD)
1583 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1584 _cleanup_free_ char *name = NULL;
1587 get_process_comm(si.si_pid, &name);
1589 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1590 si.si_pid, strna(name),
1591 sigchld_code_to_string(si.si_code),
1593 strna(si.si_code == CLD_EXITED
1594 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1595 : signal_to_string(si.si_status)));
1597 /* And now figure out the unit this belongs
1598 * to, it might be multiple... */
1599 u1 = manager_get_unit_by_pid(m, si.si_pid);
1601 invoke_sigchld_event(m, u1, &si);
1602 u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1604 invoke_sigchld_event(m, u2, &si);
1605 u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1606 if (u3 && u3 != u2 && u3 != u1)
1607 invoke_sigchld_event(m, u3, &si);
1610 /* And now, we actually reap the zombie. */
1611 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1622 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1623 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1626 log_unit_debug(name, "Activating special unit %s", name);
1628 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1630 log_unit_error(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1635 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1636 Manager *m = userdata;
1638 struct signalfd_siginfo sfsi;
1639 bool sigchld = false;
1642 assert(m->signal_fd == fd);
1644 if (revents != EPOLLIN) {
1645 log_warning("Got unexpected events from signal file descriptor.");
1650 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1651 if (n != sizeof(sfsi)) {
1656 if (errno == EINTR || errno == EAGAIN)
1662 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1663 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1664 ? LOG_DEBUG : LOG_INFO,
1667 switch (sfsi.ssi_signo) {
1674 if (m->running_as == SYSTEMD_SYSTEM) {
1675 /* This is for compatibility with the
1676 * original sysvinit */
1677 m->exit_code = MANAGER_REEXECUTE;
1684 if (m->running_as == SYSTEMD_SYSTEM) {
1685 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1689 /* Run the exit target if there is one, if not, just exit. */
1690 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1691 m->exit_code = MANAGER_EXIT;
1698 if (m->running_as == SYSTEMD_SYSTEM)
1699 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1701 /* This is a nop on non-init */
1705 if (m->running_as == SYSTEMD_SYSTEM)
1706 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1708 /* This is a nop on non-init */
1714 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1716 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1717 log_info("Trying to reconnect to bus...");
1721 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1722 log_info("Loading D-Bus service...");
1723 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1730 _cleanup_free_ char *dump = NULL;
1731 _cleanup_fclose_ FILE *f = NULL;
1734 f = open_memstream(&dump, &size);
1736 log_warning("Failed to allocate memory stream.");
1740 manager_dump_units(m, f, "\t");
1741 manager_dump_jobs(m, f, "\t");
1744 log_warning("Failed to write status stream");
1749 log_warning("Failed to flush status stream");
1753 log_dump(LOG_INFO, dump);
1758 m->exit_code = MANAGER_RELOAD;
1763 /* Starting SIGRTMIN+0 */
1764 static const char * const target_table[] = {
1765 [0] = SPECIAL_DEFAULT_TARGET,
1766 [1] = SPECIAL_RESCUE_TARGET,
1767 [2] = SPECIAL_EMERGENCY_TARGET,
1768 [3] = SPECIAL_HALT_TARGET,
1769 [4] = SPECIAL_POWEROFF_TARGET,
1770 [5] = SPECIAL_REBOOT_TARGET,
1771 [6] = SPECIAL_KEXEC_TARGET
1774 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1775 static const ManagerExitCode code_table[] = {
1777 [1] = MANAGER_POWEROFF,
1778 [2] = MANAGER_REBOOT,
1782 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1783 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1784 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1785 manager_start_target(m, target_table[idx],
1786 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1790 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1791 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1792 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1796 switch (sfsi.ssi_signo - SIGRTMIN) {
1799 log_debug("Enabling showing of status.");
1800 manager_set_show_status(m, SHOW_STATUS_YES);
1804 log_debug("Disabling showing of status.");
1805 manager_set_show_status(m, SHOW_STATUS_NO);
1809 log_set_max_level(LOG_DEBUG);
1810 log_notice("Setting log level to debug.");
1814 log_set_max_level(LOG_INFO);
1815 log_notice("Setting log level to info.");
1819 if (m->running_as == SYSTEMD_USER) {
1820 m->exit_code = MANAGER_EXIT;
1824 /* This is a nop on init */
1828 case 29: /* compatibility: used to be mapped to LOG_TARGET_SYSLOG_OR_KMSG */
1829 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1830 log_notice("Setting log target to journal-or-kmsg.");
1834 log_set_target(LOG_TARGET_CONSOLE);
1835 log_notice("Setting log target to console.");
1839 log_set_target(LOG_TARGET_KMSG);
1840 log_notice("Setting log target to kmsg.");
1844 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1851 manager_dispatch_sigchld(m);
1856 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1857 Manager *m = userdata;
1862 assert(m->time_change_fd == fd);
1864 log_struct(LOG_INFO,
1865 LOG_MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1866 LOG_MESSAGE("Time has been changed"),
1869 /* Restart the watch */
1870 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1871 m->time_change_fd = safe_close(m->time_change_fd);
1873 manager_setup_time_change(m);
1875 HASHMAP_FOREACH(u, m->units, i)
1876 if (UNIT_VTABLE(u)->time_change)
1877 UNIT_VTABLE(u)->time_change(u);
1882 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1883 Manager *m = userdata;
1886 assert(m->idle_pipe[2] == fd);
1888 m->no_console_output = m->n_on_console > 0;
1890 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1891 manager_close_idle_pipe(m);
1896 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1897 Manager *m = userdata;
1904 manager_print_jobs_in_progress(m);
1906 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1907 r = sd_event_source_set_time(source, next);
1911 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1914 int manager_loop(Manager *m) {
1917 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1920 m->exit_code = MANAGER_OK;
1922 /* Release the path cache */
1923 set_free_free(m->unit_path_cache);
1924 m->unit_path_cache = NULL;
1926 manager_check_finished(m);
1928 /* There might still be some zombies hanging around from
1929 * before we were exec()'ed. Let's reap them. */
1930 r = manager_dispatch_sigchld(m);
1934 while (m->exit_code == MANAGER_OK) {
1937 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1940 if (!ratelimit_test(&rl)) {
1941 /* Yay, something is going seriously wrong, pause a little */
1942 log_warning("Looping too fast. Throttling execution a little.");
1947 if (manager_dispatch_load_queue(m) > 0)
1950 if (manager_dispatch_gc_queue(m) > 0)
1953 if (manager_dispatch_cleanup_queue(m) > 0)
1956 if (manager_dispatch_cgroup_queue(m) > 0)
1959 if (manager_dispatch_dbus_queue(m) > 0)
1962 /* Sleep for half the watchdog time */
1963 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1964 wait_usec = m->runtime_watchdog / 2;
1968 wait_usec = USEC_INFINITY;
1970 r = sd_event_run(m->event, wait_usec);
1972 return log_error_errno(r, "Failed to run event loop: %m");
1975 return m->exit_code;
1978 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1979 _cleanup_free_ char *n = NULL;
1987 r = unit_name_from_dbus_path(s, &n);
1991 r = manager_load_unit(m, n, NULL, e, &u);
2000 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
2010 p = startswith(s, "/org/freedesktop/systemd1/job/");
2014 r = safe_atou(p, &id);
2018 j = manager_get_job(m, id);
2027 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
2030 _cleanup_free_ char *p = NULL;
2034 audit_fd = get_audit_fd();
2038 /* Don't generate audit events if the service was already
2039 * started and we're just deserializing */
2040 if (m->n_reloading > 0)
2043 if (m->running_as != SYSTEMD_SYSTEM)
2046 if (u->type != UNIT_SERVICE)
2049 p = unit_name_to_prefix_and_instance(u->id);
2055 msg = strappenda("unit=", p);
2057 if (audit_log_user_comm_message(audit_fd, type, msg, "systemd", NULL, NULL, NULL, success) < 0) {
2059 /* We aren't allowed to send audit messages?
2060 * Then let's not retry again. */
2063 log_warning_errno(errno, "Failed to send audit message: %m");
2069 void manager_send_unit_plymouth(Manager *m, Unit *u) {
2070 union sockaddr_union sa = PLYMOUTH_SOCKET;
2073 _cleanup_free_ char *message = NULL;
2074 _cleanup_close_ int fd = -1;
2076 /* Don't generate plymouth events if the service was already
2077 * started and we're just deserializing */
2078 if (m->n_reloading > 0)
2081 if (m->running_as != SYSTEMD_SYSTEM)
2084 if (detect_container(NULL) > 0)
2087 if (u->type != UNIT_SERVICE &&
2088 u->type != UNIT_MOUNT &&
2089 u->type != UNIT_SWAP)
2092 /* We set SOCK_NONBLOCK here so that we rather drop the
2093 * message then wait for plymouth */
2094 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2096 log_error_errno(errno, "socket() failed: %m");
2100 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2102 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2103 log_error_errno(errno, "connect() failed: %m");
2107 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2113 if (write(fd, message, n + 1) != n + 1)
2114 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2115 log_error_errno(errno, "Failed to write Plymouth message: %m");
2118 void manager_dispatch_bus_name_owner_changed(
2121 const char* old_owner,
2122 const char *new_owner) {
2129 u = hashmap_get(m->watch_bus, name);
2133 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2136 int manager_open_serialization(Manager *m, FILE **_f) {
2143 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2144 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2148 log_debug("Serializing state to %s", path);
2150 f = fdopen(fd, "w+");
2161 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2174 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2175 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2176 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2177 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2179 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2180 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2181 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2182 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2185 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2186 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2187 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2188 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2189 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2190 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2191 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2192 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2195 if (!switching_root) {
2196 STRV_FOREACH(e, m->environment) {
2197 _cleanup_free_ char *ce;
2203 fprintf(f, "env=%s\n", *e);
2207 if (m->notify_fd >= 0) {
2210 copy = fdset_put_dup(fds, m->notify_fd);
2214 fprintf(f, "notify-fd=%i\n", copy);
2215 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2218 if (m->kdbus_fd >= 0) {
2221 copy = fdset_put_dup(fds, m->kdbus_fd);
2225 fprintf(f, "kdbus-fd=%i\n", copy);
2228 bus_track_serialize(m->subscribed, f);
2232 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2240 r = unit_serialize(u, f, fds, !switching_root);
2247 assert(m->n_reloading > 0);
2253 r = bus_fdset_add_all(m, fds);
2260 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2266 log_debug("Deserializing state...");
2271 char line[LINE_MAX], *l;
2273 if (!fgets(line, sizeof(line), f)) {
2288 if (startswith(l, "current-job-id=")) {
2291 if (safe_atou32(l+15, &id) < 0)
2292 log_debug("Failed to parse current job id value %s", l+15);
2294 m->current_job_id = MAX(m->current_job_id, id);
2296 } else if (startswith(l, "n-installed-jobs=")) {
2299 if (safe_atou32(l+17, &n) < 0)
2300 log_debug("Failed to parse installed jobs counter %s", l+17);
2302 m->n_installed_jobs += n;
2304 } else if (startswith(l, "n-failed-jobs=")) {
2307 if (safe_atou32(l+14, &n) < 0)
2308 log_debug("Failed to parse failed jobs counter %s", l+14);
2310 m->n_failed_jobs += n;
2312 } else if (startswith(l, "taint-usr=")) {
2315 b = parse_boolean(l+10);
2317 log_debug("Failed to parse taint /usr flag %s", l+10);
2319 m->taint_usr = m->taint_usr || b;
2321 } else if (startswith(l, "firmware-timestamp="))
2322 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2323 else if (startswith(l, "loader-timestamp="))
2324 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2325 else if (startswith(l, "kernel-timestamp="))
2326 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2327 else if (startswith(l, "initrd-timestamp="))
2328 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2329 else if (startswith(l, "userspace-timestamp="))
2330 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2331 else if (startswith(l, "finish-timestamp="))
2332 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2333 else if (startswith(l, "security-start-timestamp="))
2334 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2335 else if (startswith(l, "security-finish-timestamp="))
2336 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2337 else if (startswith(l, "generators-start-timestamp="))
2338 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2339 else if (startswith(l, "generators-finish-timestamp="))
2340 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2341 else if (startswith(l, "units-load-start-timestamp="))
2342 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2343 else if (startswith(l, "units-load-finish-timestamp="))
2344 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2345 else if (startswith(l, "env=")) {
2346 _cleanup_free_ char *uce = NULL;
2349 uce = cunescape(l+4);
2355 e = strv_env_set(m->environment, uce);
2361 strv_free(m->environment);
2364 } else if (startswith(l, "notify-fd=")) {
2367 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2368 log_debug("Failed to parse notify fd: %s", l + 10);
2370 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2371 safe_close(m->notify_fd);
2372 m->notify_fd = fdset_remove(fds, fd);
2375 } else if (startswith(l, "notify-socket=")) {
2384 free(m->notify_socket);
2385 m->notify_socket = n;
2387 } else if (startswith(l, "kdbus-fd=")) {
2390 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2391 log_debug("Failed to parse kdbus fd: %s", l + 9);
2393 safe_close(m->kdbus_fd);
2394 m->kdbus_fd = fdset_remove(fds, fd);
2400 k = bus_track_deserialize_item(&m->deserialized_subscribed, l);
2402 log_debug_errno(k, "Failed to deserialize bus tracker object: %m");
2404 log_debug("Unknown serialization item '%s'", l);
2410 char name[UNIT_NAME_MAX+2];
2413 if (!fgets(name, sizeof(name), f)) {
2424 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2428 r = unit_deserialize(u, f, fds);
2437 assert(m->n_reloading > 0);
2443 int manager_reload(Manager *m) {
2445 _cleanup_fclose_ FILE *f = NULL;
2446 _cleanup_fdset_free_ FDSet *fds = NULL;
2450 r = manager_open_serialization(m, &f);
2455 bus_manager_send_reloading(m, true);
2463 r = manager_serialize(m, f, fds, false);
2469 if (fseeko(f, 0, SEEK_SET) < 0) {
2474 /* From here on there is no way back. */
2475 manager_clear_jobs_and_units(m);
2476 manager_undo_generators(m);
2477 lookup_paths_free(&m->lookup_paths);
2479 /* Find new unit paths */
2480 manager_run_generators(m);
2482 q = lookup_paths_init(
2483 &m->lookup_paths, m->running_as, true,
2485 m->generator_unit_path,
2486 m->generator_unit_path_early,
2487 m->generator_unit_path_late);
2491 manager_build_unit_path_cache(m);
2493 /* First, enumerate what we can from all config files */
2494 q = manager_enumerate(m);
2498 /* Second, deserialize our stored data */
2499 q = manager_deserialize(m, f, fds);
2506 /* Re-register notify_fd as event source */
2507 q = manager_setup_notify(m);
2511 /* Third, fire things up! */
2512 q = manager_coldplug(m);
2516 assert(m->n_reloading > 0);
2519 m->send_reloading_done = true;
2524 bool manager_is_reloading_or_reexecuting(Manager *m) {
2527 return m->n_reloading != 0;
2530 void manager_reset_failed(Manager *m) {
2536 HASHMAP_FOREACH(u, m->units, i)
2537 unit_reset_failed(u);
2540 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2546 /* Returns true if the unit is inactive or going down */
2547 u = manager_get_unit(m, name);
2551 return unit_inactive_or_pending(u);
2554 static void manager_notify_finished(Manager *m) {
2555 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2556 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2561 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2563 /* Note that m->kernel_usec.monotonic is always at 0,
2564 * and m->firmware_usec.monotonic and
2565 * m->loader_usec.monotonic should be considered
2566 * negative values. */
2568 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2569 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2570 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2571 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2573 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2575 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2576 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2578 log_struct(LOG_INFO,
2579 LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2580 "KERNEL_USEC="USEC_FMT, kernel_usec,
2581 "INITRD_USEC="USEC_FMT, initrd_usec,
2582 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2583 LOG_MESSAGE("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2584 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2585 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2586 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2587 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2590 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2593 log_struct(LOG_INFO,
2594 LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2595 "KERNEL_USEC="USEC_FMT, kernel_usec,
2596 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2597 LOG_MESSAGE("Startup finished in %s (kernel) + %s (userspace) = %s.",
2598 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2599 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2600 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2604 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2605 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2607 log_struct(LOG_INFO,
2608 LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2609 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2610 LOG_MESSAGE("Startup finished in %s.",
2611 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2615 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2619 "STATUS=Startup finished in %s.",
2620 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2623 void manager_check_finished(Manager *m) {
2629 if (m->n_running_jobs == 0)
2630 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2632 if (hashmap_size(m->jobs) > 0) {
2634 if (m->jobs_in_progress_event_source)
2635 sd_event_source_set_time(m->jobs_in_progress_event_source, now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2640 manager_flip_auto_status(m, false);
2642 /* Notify Type=idle units that we are done now */
2643 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2644 manager_close_idle_pipe(m);
2646 /* Turn off confirm spawn now */
2647 m->confirm_spawn = false;
2649 /* No need to update ask password status when we're going non-interactive */
2650 manager_close_ask_password(m);
2652 /* This is no longer the first boot */
2653 manager_set_first_boot(m, false);
2655 if (dual_timestamp_is_set(&m->finish_timestamp))
2658 dual_timestamp_get(&m->finish_timestamp);
2660 manager_notify_finished(m);
2662 SET_FOREACH(u, m->startup_units, i)
2664 cgroup_context_apply(unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path, manager_state(m));
2667 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2678 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2679 /* systemd --system, not running --test */
2681 p = strappend("/run/systemd/", name);
2685 r = mkdir_p_label(p, 0755);
2687 log_error_errno(r, "Failed to create generator directory %s: %m", p);
2691 } else if (m->running_as == SYSTEMD_USER) {
2692 const char *s = NULL;
2694 s = getenv("XDG_RUNTIME_DIR");
2697 p = strjoin(s, "/systemd/", name, NULL);
2701 r = mkdir_p_label(p, 0755);
2703 log_error_errno(r, "Failed to create generator directory %s: %m", p);
2708 /* systemd --system --test */
2710 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2715 log_error_errno(errno, "Failed to create generator directory %s: %m",
2726 static void trim_generator_dir(Manager *m, char **generator) {
2733 if (rmdir(*generator) >= 0) {
2741 void manager_run_generators(Manager *m) {
2742 _cleanup_closedir_ DIR *d = NULL;
2743 const char *generator_path;
2744 const char *argv[5];
2752 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2753 d = opendir(generator_path);
2755 if (errno == ENOENT)
2758 log_error_errno(errno, "Failed to enumerate generator directory %s: %m",
2763 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2767 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2771 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2775 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2776 argv[1] = m->generator_unit_path;
2777 argv[2] = m->generator_unit_path_early;
2778 argv[3] = m->generator_unit_path_late;
2781 RUN_WITH_UMASK(0022)
2782 execute_directory(generator_path, d, DEFAULT_TIMEOUT_USEC, (char**) argv);
2785 trim_generator_dir(m, &m->generator_unit_path);
2786 trim_generator_dir(m, &m->generator_unit_path_early);
2787 trim_generator_dir(m, &m->generator_unit_path_late);
2790 static void remove_generator_dir(Manager *m, char **generator) {
2797 strv_remove(m->lookup_paths.unit_path, *generator);
2798 rm_rf(*generator, false, true, false);
2804 void manager_undo_generators(Manager *m) {
2807 remove_generator_dir(m, &m->generator_unit_path);
2808 remove_generator_dir(m, &m->generator_unit_path_early);
2809 remove_generator_dir(m, &m->generator_unit_path_late);
2812 int manager_environment_add(Manager *m, char **minus, char **plus) {
2813 char **a = NULL, **b = NULL, **l;
2818 if (!strv_isempty(minus)) {
2819 a = strv_env_delete(l, 1, minus);
2826 if (!strv_isempty(plus)) {
2827 b = strv_env_merge(2, l, plus);
2836 if (m->environment != l)
2837 strv_free(m->environment);
2844 manager_clean_environment(m);
2845 strv_sort(m->environment);
2850 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2855 for (i = 0; i < _RLIMIT_MAX; i++) {
2856 if (!default_rlimit[i])
2859 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2867 void manager_recheck_journal(Manager *m) {
2872 if (m->running_as != SYSTEMD_SYSTEM)
2875 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2876 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2877 log_close_journal();
2881 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2882 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2883 log_close_journal();
2887 /* Hmm, OK, so the socket is fully up and the service is up
2888 * too, then let's make use of the thing. */
2892 void manager_set_show_status(Manager *m, ShowStatus mode) {
2894 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2896 if (m->running_as != SYSTEMD_SYSTEM)
2899 m->show_status = mode;
2902 touch("/run/systemd/show-status");
2904 unlink("/run/systemd/show-status");
2907 static bool manager_get_show_status(Manager *m, StatusType type) {
2910 if (m->running_as != SYSTEMD_SYSTEM)
2913 if (m->no_console_output)
2916 if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
2919 /* If we cannot find out the status properly, just proceed. */
2920 if (type != STATUS_TYPE_EMERGENCY && manager_check_ask_password(m) > 0)
2923 if (m->show_status > 0)
2926 /* If Plymouth is running make sure we show the status, so
2927 * that there's something nice to see when people press Esc */
2928 return plymouth_running();
2931 void manager_set_first_boot(Manager *m, bool b) {
2934 if (m->running_as != SYSTEMD_SYSTEM)
2940 touch("/run/systemd/first-boot");
2942 unlink("/run/systemd/first-boot");
2945 void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) {
2948 /* If m is NULL, assume we're after shutdown and let the messages through. */
2950 if (m && !manager_get_show_status(m, type))
2953 /* XXX We should totally drop the check for ephemeral here
2954 * and thus effectively make 'Type=idle' pointless. */
2955 if (type == STATUS_TYPE_EPHEMERAL && m && m->n_on_console > 0)
2958 va_start(ap, format);
2959 status_vprintf(status, true, type == STATUS_TYPE_EPHEMERAL, format, ap);
2963 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2964 _cleanup_free_ char *p = NULL;
2972 p = unit_name_from_path(path, suffix);
2976 found = manager_get_unit(m, p);
2986 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2987 char p[strlen(path)+1];
2993 path_kill_slashes(p);
2995 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
2998 const char *manager_get_runtime_prefix(Manager *m) {
3001 return m->running_as == SYSTEMD_SYSTEM ?
3003 getenv("XDG_RUNTIME_DIR");
3006 ManagerState manager_state(Manager *m) {
3011 /* Did we ever finish booting? If not then we are still starting up */
3012 if (!dual_timestamp_is_set(&m->finish_timestamp)) {
3014 u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
3015 if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
3016 return MANAGER_INITIALIZING;
3018 return MANAGER_STARTING;
3021 /* Is the special shutdown target queued? If so, we are in shutdown state */
3022 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
3023 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
3024 return MANAGER_STOPPING;
3026 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
3027 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
3028 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3029 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3030 return MANAGER_MAINTENANCE;
3032 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
3033 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3034 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3035 return MANAGER_MAINTENANCE;
3037 /* Are there any failed units? If so, we are in degraded mode */
3038 if (set_size(m->failed_units) > 0)
3039 return MANAGER_DEGRADED;
3041 return MANAGER_RUNNING;
3044 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
3045 [MANAGER_INITIALIZING] = "initializing",
3046 [MANAGER_STARTING] = "starting",
3047 [MANAGER_RUNNING] = "running",
3048 [MANAGER_DEGRADED] = "degraded",
3049 [MANAGER_MAINTENANCE] = "maintenance",
3050 [MANAGER_STOPPING] = "stopping",
3053 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);