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++) {
959 if (unit_vtable[c]->supported && !unit_vtable[c]->supported(m)) {
960 log_info("Unit type .%s is not supported on this system.", unit_type_to_string(c));
964 if (!unit_vtable[c]->enumerate)
967 q = unit_vtable[c]->enumerate(m);
972 manager_dispatch_load_queue(m);
976 static int manager_coldplug(Manager *m) {
984 /* Then, let's set up their initial state. */
985 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
992 q = unit_coldplug(u);
1000 static void manager_build_unit_path_cache(Manager *m) {
1002 _cleanup_closedir_ DIR *d = NULL;
1007 set_free_free(m->unit_path_cache);
1009 m->unit_path_cache = set_new(&string_hash_ops);
1010 if (!m->unit_path_cache) {
1011 log_error("Failed to allocate unit path cache.");
1015 /* This simply builds a list of files we know exist, so that
1016 * we don't always have to go to disk */
1018 STRV_FOREACH(i, m->lookup_paths.unit_path) {
1023 if (errno != ENOENT)
1024 log_error_errno(errno, "Failed to open directory %s: %m", *i);
1028 while ((de = readdir(d))) {
1031 if (hidden_file(de->d_name))
1034 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
1040 r = set_consume(m->unit_path_cache, p);
1052 log_error_errno(r, "Failed to build unit path cache: %m");
1054 set_free_free(m->unit_path_cache);
1055 m->unit_path_cache = NULL;
1059 static int manager_distribute_fds(Manager *m, FDSet *fds) {
1066 HASHMAP_FOREACH(u, m->units, i) {
1068 if (fdset_size(fds) <= 0)
1071 if (UNIT_VTABLE(u)->distribute_fds) {
1072 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
1081 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
1086 dual_timestamp_get(&m->generators_start_timestamp);
1087 manager_run_generators(m);
1088 dual_timestamp_get(&m->generators_finish_timestamp);
1090 r = lookup_paths_init(
1091 &m->lookup_paths, m->running_as, true,
1093 m->generator_unit_path,
1094 m->generator_unit_path_early,
1095 m->generator_unit_path_late);
1099 manager_build_unit_path_cache(m);
1101 /* If we will deserialize make sure that during enumeration
1102 * this is already known, so we increase the counter here
1107 /* First, enumerate what we can from all config files */
1108 dual_timestamp_get(&m->units_load_start_timestamp);
1109 r = manager_enumerate(m);
1110 dual_timestamp_get(&m->units_load_finish_timestamp);
1112 /* Second, deserialize if there is something to deserialize */
1114 r = manager_deserialize(m, serialization, fds);
1116 /* Any fds left? Find some unit which wants them. This is
1117 * useful to allow container managers to pass some file
1118 * descriptors to us pre-initialized. This enables
1119 * socket-based activation of entire containers. */
1120 if (fdset_size(fds) > 0) {
1121 q = manager_distribute_fds(m, fds);
1122 if (q < 0 && r == 0)
1126 /* We might have deserialized the notify fd, but if we didn't
1127 * then let's create the bus now */
1128 q = manager_setup_notify(m);
1129 if (q < 0 && r == 0)
1132 /* We might have deserialized the kdbus control fd, but if we
1133 * didn't, then let's create the bus now. */
1134 manager_setup_kdbus(m);
1135 manager_connect_bus(m, !!serialization);
1136 bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
1138 /* Third, fire things up! */
1139 q = manager_coldplug(m);
1140 if (q < 0 && r == 0)
1143 if (serialization) {
1144 assert(m->n_reloading > 0);
1147 /* Let's wait for the UnitNew/JobNew messages being
1148 * sent, before we notify that the reload is
1150 m->send_reloading_done = true;
1156 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1161 assert(type < _JOB_TYPE_MAX);
1163 assert(mode < _JOB_MODE_MAX);
1165 if (mode == JOB_ISOLATE && type != JOB_START)
1166 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1168 if (mode == JOB_ISOLATE && !unit->allow_isolate)
1169 return sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1171 log_unit_debug(unit->id,
1172 "Trying to enqueue job %s/%s/%s", unit->id,
1173 job_type_to_string(type), job_mode_to_string(mode));
1175 job_type_collapse(&type, unit);
1177 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1181 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1182 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1183 mode == JOB_IGNORE_DEPENDENCIES, e);
1187 if (mode == JOB_ISOLATE) {
1188 r = transaction_add_isolate_jobs(tr, m);
1193 r = transaction_activate(tr, m, mode, e);
1197 log_unit_debug(unit->id,
1198 "Enqueued job %s/%s as %u", unit->id,
1199 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1202 *_ret = tr->anchor_job;
1204 transaction_free(tr);
1208 transaction_abort(tr);
1209 transaction_free(tr);
1213 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1218 assert(type < _JOB_TYPE_MAX);
1220 assert(mode < _JOB_MODE_MAX);
1222 r = manager_load_unit(m, name, NULL, NULL, &unit);
1226 return manager_add_job(m, type, unit, mode, override, e, _ret);
1229 Job *manager_get_job(Manager *m, uint32_t id) {
1232 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1235 Unit *manager_get_unit(Manager *m, const char *name) {
1239 return hashmap_get(m->units, name);
1242 unsigned manager_dispatch_load_queue(Manager *m) {
1248 /* Make sure we are not run recursively */
1249 if (m->dispatching_load_queue)
1252 m->dispatching_load_queue = true;
1254 /* Dispatches the load queue. Takes a unit from the queue and
1255 * tries to load its data until the queue is empty */
1257 while ((u = m->load_queue)) {
1258 assert(u->in_load_queue);
1264 m->dispatching_load_queue = false;
1268 int manager_load_unit_prepare(
1280 assert(name || path);
1282 /* This will prepare the unit for loading, but not actually
1283 * load anything from disk. */
1285 if (path && !is_path(path))
1286 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1289 name = basename(path);
1291 t = unit_name_to_type(name);
1293 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1294 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1296 ret = manager_get_unit(m, name);
1302 ret = unit_new(m, unit_vtable[t]->object_size);
1307 ret->fragment_path = strdup(path);
1308 if (!ret->fragment_path) {
1314 r = unit_add_name(ret, name);
1320 unit_add_to_load_queue(ret);
1321 unit_add_to_dbus_queue(ret);
1322 unit_add_to_gc_queue(ret);
1330 int manager_load_unit(
1341 /* This will load the service information files, but not actually
1342 * start any services or anything. */
1344 r = manager_load_unit_prepare(m, name, path, e, _ret);
1348 manager_dispatch_load_queue(m);
1351 *_ret = unit_follow_merge(*_ret);
1356 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1363 HASHMAP_FOREACH(j, s->jobs, i)
1364 job_dump(j, f, prefix);
1367 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1375 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1377 unit_dump(u, f, prefix);
1380 void manager_clear_jobs(Manager *m) {
1385 while ((j = hashmap_first(m->jobs)))
1386 /* No need to recurse. We're cancelling all jobs. */
1387 job_finish_and_invalidate(j, JOB_CANCELED, false);
1390 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1391 Manager *m = userdata;
1397 while ((j = m->run_queue)) {
1398 assert(j->installed);
1399 assert(j->in_run_queue);
1401 job_run_and_invalidate(j);
1404 if (m->n_running_jobs > 0)
1405 manager_watch_jobs_in_progress(m);
1407 if (m->n_on_console > 0)
1408 manager_watch_idle_pipe(m);
1413 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1420 if (m->dispatching_dbus_queue)
1423 m->dispatching_dbus_queue = true;
1425 while ((u = m->dbus_unit_queue)) {
1426 assert(u->in_dbus_queue);
1428 bus_unit_send_change_signal(u);
1432 while ((j = m->dbus_job_queue)) {
1433 assert(j->in_dbus_queue);
1435 bus_job_send_change_signal(j);
1439 m->dispatching_dbus_queue = false;
1441 if (m->send_reloading_done) {
1442 m->send_reloading_done = false;
1444 bus_manager_send_reloading(m, false);
1447 if (m->queued_message)
1448 bus_send_queued_message(m);
1453 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n) {
1454 _cleanup_strv_free_ char **tags = NULL;
1461 tags = strv_split(buf, "\n\r");
1467 log_unit_debug(u->id, "Got notification message for unit %s", u->id);
1469 if (UNIT_VTABLE(u)->notify_message)
1470 UNIT_VTABLE(u)->notify_message(u, pid, tags);
1473 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1474 Manager *m = userdata;
1478 assert(m->notify_fd == fd);
1480 if (revents != EPOLLIN) {
1481 log_warning("Got unexpected poll event for notify fd.");
1487 struct iovec iovec = {
1489 .iov_len = sizeof(buf)-1,
1494 struct cmsghdr cmsghdr;
1495 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1498 struct msghdr msghdr = {
1501 .msg_control = &control,
1502 .msg_controllen = sizeof(control),
1504 struct ucred *ucred;
1507 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1512 if (errno == EAGAIN || errno == EINTR)
1518 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1519 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1520 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1521 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1522 log_warning("Received notify message without credentials. Ignoring.");
1526 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1528 assert((size_t) n < sizeof(buf));
1531 /* Notify every unit that might be interested, but try
1532 * to avoid notifying the same one multiple times. */
1533 u1 = manager_get_unit_by_pid(m, ucred->pid);
1535 manager_invoke_notify_message(m, u1, ucred->pid, buf, n);
1539 u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1540 if (u2 && u2 != u1) {
1541 manager_invoke_notify_message(m, u2, ucred->pid, buf, n);
1545 u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1546 if (u3 && u3 != u2 && u3 != u1) {
1547 manager_invoke_notify_message(m, u3, ucred->pid, buf, n);
1552 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1558 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1563 log_unit_debug(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1565 unit_unwatch_pid(u, si->si_pid);
1566 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1569 static int manager_dispatch_sigchld(Manager *m) {
1575 /* First we call waitd() for a PID and do not reap the
1576 * zombie. That way we can still access /proc/$PID for
1577 * it while it is a zombie. */
1578 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1580 if (errno == ECHILD)
1592 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1593 _cleanup_free_ char *name = NULL;
1596 get_process_comm(si.si_pid, &name);
1598 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1599 si.si_pid, strna(name),
1600 sigchld_code_to_string(si.si_code),
1602 strna(si.si_code == CLD_EXITED
1603 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1604 : signal_to_string(si.si_status)));
1606 /* And now figure out the unit this belongs
1607 * to, it might be multiple... */
1608 u1 = manager_get_unit_by_pid(m, si.si_pid);
1610 invoke_sigchld_event(m, u1, &si);
1611 u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1613 invoke_sigchld_event(m, u2, &si);
1614 u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1615 if (u3 && u3 != u2 && u3 != u1)
1616 invoke_sigchld_event(m, u3, &si);
1619 /* And now, we actually reap the zombie. */
1620 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1631 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1632 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1635 log_unit_debug(name, "Activating special unit %s", name);
1637 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1639 log_unit_error(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1644 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1645 Manager *m = userdata;
1647 struct signalfd_siginfo sfsi;
1648 bool sigchld = false;
1651 assert(m->signal_fd == fd);
1653 if (revents != EPOLLIN) {
1654 log_warning("Got unexpected events from signal file descriptor.");
1659 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1660 if (n != sizeof(sfsi)) {
1665 if (errno == EINTR || errno == EAGAIN)
1671 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1672 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1673 ? LOG_DEBUG : LOG_INFO,
1676 switch (sfsi.ssi_signo) {
1683 if (m->running_as == SYSTEMD_SYSTEM) {
1684 /* This is for compatibility with the
1685 * original sysvinit */
1686 m->exit_code = MANAGER_REEXECUTE;
1693 if (m->running_as == SYSTEMD_SYSTEM) {
1694 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1698 /* Run the exit target if there is one, if not, just exit. */
1699 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1700 m->exit_code = MANAGER_EXIT;
1707 if (m->running_as == SYSTEMD_SYSTEM)
1708 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1710 /* This is a nop on non-init */
1714 if (m->running_as == SYSTEMD_SYSTEM)
1715 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1717 /* This is a nop on non-init */
1723 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1725 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1726 log_info("Trying to reconnect to bus...");
1730 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1731 log_info("Loading D-Bus service...");
1732 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1739 _cleanup_free_ char *dump = NULL;
1740 _cleanup_fclose_ FILE *f = NULL;
1743 f = open_memstream(&dump, &size);
1745 log_warning("Failed to allocate memory stream.");
1749 manager_dump_units(m, f, "\t");
1750 manager_dump_jobs(m, f, "\t");
1753 log_warning("Failed to write status stream");
1758 log_warning("Failed to flush status stream");
1762 log_dump(LOG_INFO, dump);
1767 m->exit_code = MANAGER_RELOAD;
1772 /* Starting SIGRTMIN+0 */
1773 static const char * const target_table[] = {
1774 [0] = SPECIAL_DEFAULT_TARGET,
1775 [1] = SPECIAL_RESCUE_TARGET,
1776 [2] = SPECIAL_EMERGENCY_TARGET,
1777 [3] = SPECIAL_HALT_TARGET,
1778 [4] = SPECIAL_POWEROFF_TARGET,
1779 [5] = SPECIAL_REBOOT_TARGET,
1780 [6] = SPECIAL_KEXEC_TARGET
1783 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1784 static const ManagerExitCode code_table[] = {
1786 [1] = MANAGER_POWEROFF,
1787 [2] = MANAGER_REBOOT,
1791 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1792 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1793 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1794 manager_start_target(m, target_table[idx],
1795 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1799 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1800 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1801 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1805 switch (sfsi.ssi_signo - SIGRTMIN) {
1808 log_debug("Enabling showing of status.");
1809 manager_set_show_status(m, SHOW_STATUS_YES);
1813 log_debug("Disabling showing of status.");
1814 manager_set_show_status(m, SHOW_STATUS_NO);
1818 log_set_max_level(LOG_DEBUG);
1819 log_notice("Setting log level to debug.");
1823 log_set_max_level(LOG_INFO);
1824 log_notice("Setting log level to info.");
1828 if (m->running_as == SYSTEMD_USER) {
1829 m->exit_code = MANAGER_EXIT;
1833 /* This is a nop on init */
1837 case 29: /* compatibility: used to be mapped to LOG_TARGET_SYSLOG_OR_KMSG */
1838 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1839 log_notice("Setting log target to journal-or-kmsg.");
1843 log_set_target(LOG_TARGET_CONSOLE);
1844 log_notice("Setting log target to console.");
1848 log_set_target(LOG_TARGET_KMSG);
1849 log_notice("Setting log target to kmsg.");
1853 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1860 manager_dispatch_sigchld(m);
1865 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1866 Manager *m = userdata;
1871 assert(m->time_change_fd == fd);
1873 log_struct(LOG_INFO,
1874 LOG_MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1875 LOG_MESSAGE("Time has been changed"),
1878 /* Restart the watch */
1879 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1880 m->time_change_fd = safe_close(m->time_change_fd);
1882 manager_setup_time_change(m);
1884 HASHMAP_FOREACH(u, m->units, i)
1885 if (UNIT_VTABLE(u)->time_change)
1886 UNIT_VTABLE(u)->time_change(u);
1891 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1892 Manager *m = userdata;
1895 assert(m->idle_pipe[2] == fd);
1897 m->no_console_output = m->n_on_console > 0;
1899 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1900 manager_close_idle_pipe(m);
1905 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1906 Manager *m = userdata;
1913 manager_print_jobs_in_progress(m);
1915 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1916 r = sd_event_source_set_time(source, next);
1920 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1923 int manager_loop(Manager *m) {
1926 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1929 m->exit_code = MANAGER_OK;
1931 /* Release the path cache */
1932 set_free_free(m->unit_path_cache);
1933 m->unit_path_cache = NULL;
1935 manager_check_finished(m);
1937 /* There might still be some zombies hanging around from
1938 * before we were exec()'ed. Let's reap them. */
1939 r = manager_dispatch_sigchld(m);
1943 while (m->exit_code == MANAGER_OK) {
1946 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1949 if (!ratelimit_test(&rl)) {
1950 /* Yay, something is going seriously wrong, pause a little */
1951 log_warning("Looping too fast. Throttling execution a little.");
1956 if (manager_dispatch_load_queue(m) > 0)
1959 if (manager_dispatch_gc_queue(m) > 0)
1962 if (manager_dispatch_cleanup_queue(m) > 0)
1965 if (manager_dispatch_cgroup_queue(m) > 0)
1968 if (manager_dispatch_dbus_queue(m) > 0)
1971 /* Sleep for half the watchdog time */
1972 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1973 wait_usec = m->runtime_watchdog / 2;
1977 wait_usec = USEC_INFINITY;
1979 r = sd_event_run(m->event, wait_usec);
1981 return log_error_errno(r, "Failed to run event loop: %m");
1984 return m->exit_code;
1987 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1988 _cleanup_free_ char *n = NULL;
1996 r = unit_name_from_dbus_path(s, &n);
2000 r = manager_load_unit(m, n, NULL, e, &u);
2009 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
2019 p = startswith(s, "/org/freedesktop/systemd1/job/");
2023 r = safe_atou(p, &id);
2027 j = manager_get_job(m, id);
2036 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
2039 _cleanup_free_ char *p = NULL;
2043 audit_fd = get_audit_fd();
2047 /* Don't generate audit events if the service was already
2048 * started and we're just deserializing */
2049 if (m->n_reloading > 0)
2052 if (m->running_as != SYSTEMD_SYSTEM)
2055 if (u->type != UNIT_SERVICE)
2058 p = unit_name_to_prefix_and_instance(u->id);
2064 msg = strappenda("unit=", p);
2066 if (audit_log_user_comm_message(audit_fd, type, msg, "systemd", NULL, NULL, NULL, success) < 0) {
2068 /* We aren't allowed to send audit messages?
2069 * Then let's not retry again. */
2072 log_warning_errno(errno, "Failed to send audit message: %m");
2078 void manager_send_unit_plymouth(Manager *m, Unit *u) {
2079 union sockaddr_union sa = PLYMOUTH_SOCKET;
2082 _cleanup_free_ char *message = NULL;
2083 _cleanup_close_ int fd = -1;
2085 /* Don't generate plymouth events if the service was already
2086 * started and we're just deserializing */
2087 if (m->n_reloading > 0)
2090 if (m->running_as != SYSTEMD_SYSTEM)
2093 if (detect_container(NULL) > 0)
2096 if (u->type != UNIT_SERVICE &&
2097 u->type != UNIT_MOUNT &&
2098 u->type != UNIT_SWAP)
2101 /* We set SOCK_NONBLOCK here so that we rather drop the
2102 * message then wait for plymouth */
2103 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2105 log_error_errno(errno, "socket() failed: %m");
2109 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2111 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2112 log_error_errno(errno, "connect() failed: %m");
2116 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2122 if (write(fd, message, n + 1) != n + 1)
2123 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2124 log_error_errno(errno, "Failed to write Plymouth message: %m");
2127 void manager_dispatch_bus_name_owner_changed(
2130 const char* old_owner,
2131 const char *new_owner) {
2138 u = hashmap_get(m->watch_bus, name);
2142 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2145 int manager_open_serialization(Manager *m, FILE **_f) {
2152 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2153 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2157 log_debug("Serializing state to %s", path);
2159 f = fdopen(fd, "w+");
2170 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2183 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2184 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2185 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2186 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2188 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2189 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2190 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2191 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2194 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2195 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2196 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2197 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2198 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2199 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2200 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2201 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2204 if (!switching_root) {
2205 STRV_FOREACH(e, m->environment) {
2206 _cleanup_free_ char *ce;
2212 fprintf(f, "env=%s\n", *e);
2216 if (m->notify_fd >= 0) {
2219 copy = fdset_put_dup(fds, m->notify_fd);
2223 fprintf(f, "notify-fd=%i\n", copy);
2224 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2227 if (m->kdbus_fd >= 0) {
2230 copy = fdset_put_dup(fds, m->kdbus_fd);
2234 fprintf(f, "kdbus-fd=%i\n", copy);
2237 bus_track_serialize(m->subscribed, f);
2241 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2249 r = unit_serialize(u, f, fds, !switching_root);
2256 assert(m->n_reloading > 0);
2262 r = bus_fdset_add_all(m, fds);
2269 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2275 log_debug("Deserializing state...");
2280 char line[LINE_MAX], *l;
2282 if (!fgets(line, sizeof(line), f)) {
2297 if (startswith(l, "current-job-id=")) {
2300 if (safe_atou32(l+15, &id) < 0)
2301 log_debug("Failed to parse current job id value %s", l+15);
2303 m->current_job_id = MAX(m->current_job_id, id);
2305 } else if (startswith(l, "n-installed-jobs=")) {
2308 if (safe_atou32(l+17, &n) < 0)
2309 log_debug("Failed to parse installed jobs counter %s", l+17);
2311 m->n_installed_jobs += n;
2313 } else if (startswith(l, "n-failed-jobs=")) {
2316 if (safe_atou32(l+14, &n) < 0)
2317 log_debug("Failed to parse failed jobs counter %s", l+14);
2319 m->n_failed_jobs += n;
2321 } else if (startswith(l, "taint-usr=")) {
2324 b = parse_boolean(l+10);
2326 log_debug("Failed to parse taint /usr flag %s", l+10);
2328 m->taint_usr = m->taint_usr || b;
2330 } else if (startswith(l, "firmware-timestamp="))
2331 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2332 else if (startswith(l, "loader-timestamp="))
2333 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2334 else if (startswith(l, "kernel-timestamp="))
2335 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2336 else if (startswith(l, "initrd-timestamp="))
2337 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2338 else if (startswith(l, "userspace-timestamp="))
2339 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2340 else if (startswith(l, "finish-timestamp="))
2341 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2342 else if (startswith(l, "security-start-timestamp="))
2343 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2344 else if (startswith(l, "security-finish-timestamp="))
2345 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2346 else if (startswith(l, "generators-start-timestamp="))
2347 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2348 else if (startswith(l, "generators-finish-timestamp="))
2349 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2350 else if (startswith(l, "units-load-start-timestamp="))
2351 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2352 else if (startswith(l, "units-load-finish-timestamp="))
2353 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2354 else if (startswith(l, "env=")) {
2355 _cleanup_free_ char *uce = NULL;
2358 uce = cunescape(l+4);
2364 e = strv_env_set(m->environment, uce);
2370 strv_free(m->environment);
2373 } else if (startswith(l, "notify-fd=")) {
2376 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2377 log_debug("Failed to parse notify fd: %s", l + 10);
2379 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2380 safe_close(m->notify_fd);
2381 m->notify_fd = fdset_remove(fds, fd);
2384 } else if (startswith(l, "notify-socket=")) {
2393 free(m->notify_socket);
2394 m->notify_socket = n;
2396 } else if (startswith(l, "kdbus-fd=")) {
2399 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2400 log_debug("Failed to parse kdbus fd: %s", l + 9);
2402 safe_close(m->kdbus_fd);
2403 m->kdbus_fd = fdset_remove(fds, fd);
2409 k = bus_track_deserialize_item(&m->deserialized_subscribed, l);
2411 log_debug_errno(k, "Failed to deserialize bus tracker object: %m");
2413 log_debug("Unknown serialization item '%s'", l);
2419 char name[UNIT_NAME_MAX+2];
2422 if (!fgets(name, sizeof(name), f)) {
2433 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2437 r = unit_deserialize(u, f, fds);
2446 assert(m->n_reloading > 0);
2452 int manager_reload(Manager *m) {
2454 _cleanup_fclose_ FILE *f = NULL;
2455 _cleanup_fdset_free_ FDSet *fds = NULL;
2459 r = manager_open_serialization(m, &f);
2464 bus_manager_send_reloading(m, true);
2472 r = manager_serialize(m, f, fds, false);
2478 if (fseeko(f, 0, SEEK_SET) < 0) {
2483 /* From here on there is no way back. */
2484 manager_clear_jobs_and_units(m);
2485 manager_undo_generators(m);
2486 lookup_paths_free(&m->lookup_paths);
2488 /* Find new unit paths */
2489 manager_run_generators(m);
2491 q = lookup_paths_init(
2492 &m->lookup_paths, m->running_as, true,
2494 m->generator_unit_path,
2495 m->generator_unit_path_early,
2496 m->generator_unit_path_late);
2500 manager_build_unit_path_cache(m);
2502 /* First, enumerate what we can from all config files */
2503 q = manager_enumerate(m);
2507 /* Second, deserialize our stored data */
2508 q = manager_deserialize(m, f, fds);
2515 /* Re-register notify_fd as event source */
2516 q = manager_setup_notify(m);
2520 /* Third, fire things up! */
2521 q = manager_coldplug(m);
2525 assert(m->n_reloading > 0);
2528 m->send_reloading_done = true;
2533 bool manager_is_reloading_or_reexecuting(Manager *m) {
2536 return m->n_reloading != 0;
2539 void manager_reset_failed(Manager *m) {
2545 HASHMAP_FOREACH(u, m->units, i)
2546 unit_reset_failed(u);
2549 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2555 /* Returns true if the unit is inactive or going down */
2556 u = manager_get_unit(m, name);
2560 return unit_inactive_or_pending(u);
2563 static void manager_notify_finished(Manager *m) {
2564 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2565 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2570 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2572 /* Note that m->kernel_usec.monotonic is always at 0,
2573 * and m->firmware_usec.monotonic and
2574 * m->loader_usec.monotonic should be considered
2575 * negative values. */
2577 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2578 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2579 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2580 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2582 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2584 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2585 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2587 log_struct(LOG_INFO,
2588 LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2589 "KERNEL_USEC="USEC_FMT, kernel_usec,
2590 "INITRD_USEC="USEC_FMT, initrd_usec,
2591 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2592 LOG_MESSAGE("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2593 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2594 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2595 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2596 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2599 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2602 log_struct(LOG_INFO,
2603 LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2604 "KERNEL_USEC="USEC_FMT, kernel_usec,
2605 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2606 LOG_MESSAGE("Startup finished in %s (kernel) + %s (userspace) = %s.",
2607 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2608 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2609 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2613 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2614 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2616 log_struct(LOG_INFO,
2617 LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2618 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2619 LOG_MESSAGE("Startup finished in %s.",
2620 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2624 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2628 "STATUS=Startup finished in %s.",
2629 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2632 void manager_check_finished(Manager *m) {
2638 if (m->n_running_jobs == 0)
2639 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2641 if (hashmap_size(m->jobs) > 0) {
2643 if (m->jobs_in_progress_event_source)
2644 sd_event_source_set_time(m->jobs_in_progress_event_source, now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2649 manager_flip_auto_status(m, false);
2651 /* Notify Type=idle units that we are done now */
2652 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2653 manager_close_idle_pipe(m);
2655 /* Turn off confirm spawn now */
2656 m->confirm_spawn = false;
2658 /* No need to update ask password status when we're going non-interactive */
2659 manager_close_ask_password(m);
2661 /* This is no longer the first boot */
2662 manager_set_first_boot(m, false);
2664 if (dual_timestamp_is_set(&m->finish_timestamp))
2667 dual_timestamp_get(&m->finish_timestamp);
2669 manager_notify_finished(m);
2671 SET_FOREACH(u, m->startup_units, i)
2673 cgroup_context_apply(unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path, manager_state(m));
2676 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2687 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2688 /* systemd --system, not running --test */
2690 p = strappend("/run/systemd/", name);
2694 r = mkdir_p_label(p, 0755);
2696 log_error_errno(r, "Failed to create generator directory %s: %m", p);
2700 } else if (m->running_as == SYSTEMD_USER) {
2701 const char *s = NULL;
2703 s = getenv("XDG_RUNTIME_DIR");
2706 p = strjoin(s, "/systemd/", name, NULL);
2710 r = mkdir_p_label(p, 0755);
2712 log_error_errno(r, "Failed to create generator directory %s: %m", p);
2717 /* systemd --system --test */
2719 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2724 log_error_errno(errno, "Failed to create generator directory %s: %m",
2735 static void trim_generator_dir(Manager *m, char **generator) {
2742 if (rmdir(*generator) >= 0) {
2750 void manager_run_generators(Manager *m) {
2751 _cleanup_closedir_ DIR *d = NULL;
2752 const char *generator_path;
2753 const char *argv[5];
2761 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2762 d = opendir(generator_path);
2764 if (errno == ENOENT)
2767 log_error_errno(errno, "Failed to enumerate generator directory %s: %m",
2772 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2776 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2780 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2784 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2785 argv[1] = m->generator_unit_path;
2786 argv[2] = m->generator_unit_path_early;
2787 argv[3] = m->generator_unit_path_late;
2790 RUN_WITH_UMASK(0022)
2791 execute_directory(generator_path, d, DEFAULT_TIMEOUT_USEC, (char**) argv);
2794 trim_generator_dir(m, &m->generator_unit_path);
2795 trim_generator_dir(m, &m->generator_unit_path_early);
2796 trim_generator_dir(m, &m->generator_unit_path_late);
2799 static void remove_generator_dir(Manager *m, char **generator) {
2806 strv_remove(m->lookup_paths.unit_path, *generator);
2807 rm_rf(*generator, false, true, false);
2813 void manager_undo_generators(Manager *m) {
2816 remove_generator_dir(m, &m->generator_unit_path);
2817 remove_generator_dir(m, &m->generator_unit_path_early);
2818 remove_generator_dir(m, &m->generator_unit_path_late);
2821 int manager_environment_add(Manager *m, char **minus, char **plus) {
2822 char **a = NULL, **b = NULL, **l;
2827 if (!strv_isempty(minus)) {
2828 a = strv_env_delete(l, 1, minus);
2835 if (!strv_isempty(plus)) {
2836 b = strv_env_merge(2, l, plus);
2845 if (m->environment != l)
2846 strv_free(m->environment);
2853 manager_clean_environment(m);
2854 strv_sort(m->environment);
2859 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2864 for (i = 0; i < _RLIMIT_MAX; i++) {
2865 if (!default_rlimit[i])
2868 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2876 void manager_recheck_journal(Manager *m) {
2881 if (m->running_as != SYSTEMD_SYSTEM)
2884 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2885 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2886 log_close_journal();
2890 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2891 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2892 log_close_journal();
2896 /* Hmm, OK, so the socket is fully up and the service is up
2897 * too, then let's make use of the thing. */
2901 void manager_set_show_status(Manager *m, ShowStatus mode) {
2903 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2905 if (m->running_as != SYSTEMD_SYSTEM)
2908 m->show_status = mode;
2911 touch("/run/systemd/show-status");
2913 unlink("/run/systemd/show-status");
2916 static bool manager_get_show_status(Manager *m, StatusType type) {
2919 if (m->running_as != SYSTEMD_SYSTEM)
2922 if (m->no_console_output)
2925 if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
2928 /* If we cannot find out the status properly, just proceed. */
2929 if (type != STATUS_TYPE_EMERGENCY && manager_check_ask_password(m) > 0)
2932 if (m->show_status > 0)
2935 /* If Plymouth is running make sure we show the status, so
2936 * that there's something nice to see when people press Esc */
2937 return plymouth_running();
2940 void manager_set_first_boot(Manager *m, bool b) {
2943 if (m->running_as != SYSTEMD_SYSTEM)
2949 touch("/run/systemd/first-boot");
2951 unlink("/run/systemd/first-boot");
2954 void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) {
2957 /* If m is NULL, assume we're after shutdown and let the messages through. */
2959 if (m && !manager_get_show_status(m, type))
2962 /* XXX We should totally drop the check for ephemeral here
2963 * and thus effectively make 'Type=idle' pointless. */
2964 if (type == STATUS_TYPE_EPHEMERAL && m && m->n_on_console > 0)
2967 va_start(ap, format);
2968 status_vprintf(status, true, type == STATUS_TYPE_EPHEMERAL, format, ap);
2972 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2973 _cleanup_free_ char *p = NULL;
2981 p = unit_name_from_path(path, suffix);
2985 found = manager_get_unit(m, p);
2995 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2996 char p[strlen(path)+1];
3002 path_kill_slashes(p);
3004 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
3007 const char *manager_get_runtime_prefix(Manager *m) {
3010 return m->running_as == SYSTEMD_SYSTEM ?
3012 getenv("XDG_RUNTIME_DIR");
3015 ManagerState manager_state(Manager *m) {
3020 /* Did we ever finish booting? If not then we are still starting up */
3021 if (!dual_timestamp_is_set(&m->finish_timestamp)) {
3023 u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
3024 if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
3025 return MANAGER_INITIALIZING;
3027 return MANAGER_STARTING;
3030 /* Is the special shutdown target queued? If so, we are in shutdown state */
3031 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
3032 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
3033 return MANAGER_STOPPING;
3035 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
3036 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
3037 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3038 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3039 return MANAGER_MAINTENANCE;
3041 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
3042 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3043 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3044 return MANAGER_MAINTENANCE;
3046 /* Are there any failed units? If so, we are in degraded mode */
3047 if (set_size(m->failed_units) > 0)
3048 return MANAGER_DEGRADED;
3050 return MANAGER_RUNNING;
3053 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
3054 [MANAGER_INITIALIZING] = "initializing",
3055 [MANAGER_STARTING] = "starting",
3056 [MANAGER_RUNNING] = "running",
3057 [MANAGER_DEGRADED] = "degraded",
3058 [MANAGER_MAINTENANCE] = "maintenance",
3059 [MANAGER_STOPPING] = "stopping",
3062 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);