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/>.
29 #include <sys/reboot.h>
30 #include <sys/ioctl.h>
34 #include <sys/types.h>
37 #include <sys/timerfd.h>
43 #include "sd-daemon.h"
45 #include "sd-messages.h"
48 #include "transaction.h"
55 #include "ratelimit.h"
56 #include "locale-setup.h"
57 #include "mount-setup.h"
58 #include "unit-name.h"
60 #include "path-lookup.h"
62 #include "exit-status.h"
65 #include "cgroup-util.h"
66 #include "path-util.h"
68 #include "boot-timestamps.h"
70 #include "bus-errors.h"
71 #include "bus-error.h"
74 #include "dbus-unit.h"
76 #include "dbus-manager.h"
77 #include "bus-kernel.h"
79 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
80 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
82 /* Initial delay and the interval for printing status messages about running jobs */
83 #define JOBS_IN_PROGRESS_WAIT_USEC (5*USEC_PER_SEC)
84 #define JOBS_IN_PROGRESS_PERIOD_USEC (USEC_PER_SEC / 3)
85 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
87 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
89 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
90 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
91 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
92 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
93 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
94 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
96 static int manager_watch_jobs_in_progress(Manager *m) {
101 if (m->jobs_in_progress_event_source)
104 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
105 return sd_event_add_time(
107 &m->jobs_in_progress_event_source,
110 manager_dispatch_jobs_in_progress, m);
113 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
115 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
118 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
119 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
123 p = mempset(p, ' ', pos-2);
124 p = stpcpy(p, ANSI_RED_ON);
128 if (pos > 0 && pos <= width) {
129 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
133 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
136 p = stpcpy(p, ANSI_RED_ON);
139 p = mempset(p, ' ', width-1-pos);
140 strcpy(p, ANSI_HIGHLIGHT_OFF);
144 void manager_flip_auto_status(Manager *m, bool enable) {
148 if (m->show_status == SHOW_STATUS_AUTO)
149 manager_set_show_status(m, SHOW_STATUS_TEMPORARY);
151 if (m->show_status == SHOW_STATUS_TEMPORARY)
152 manager_set_show_status(m, SHOW_STATUS_AUTO);
156 static void manager_print_jobs_in_progress(Manager *m) {
157 _cleanup_free_ char *job_of_n = NULL;
160 unsigned counter = 0, print_nr;
161 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
163 char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
168 manager_flip_auto_status(m, true);
170 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
172 HASHMAP_FOREACH(j, m->jobs, i)
173 if (j->state == JOB_RUNNING && counter++ == print_nr)
176 /* m->n_running_jobs must be consistent with the contents of m->jobs,
177 * so the above loop must have succeeded in finding j. */
178 assert(counter == print_nr + 1);
181 cylon_pos = m->jobs_in_progress_iteration % 14;
183 cylon_pos = 14 - cylon_pos;
184 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
186 m->jobs_in_progress_iteration++;
188 if (m->n_running_jobs > 1)
189 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
192 format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
193 if (job_get_timeout(j, &x) > 0)
194 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
196 manager_status_printf(m, true, cylon,
197 "%sA %s job is running for %s (%s / %s)",
199 job_type_to_string(j->type),
200 unit_description(j->unit),
205 static int manager_watch_idle_pipe(Manager *m) {
210 if (m->idle_pipe_event_source)
213 if (m->idle_pipe[2] < 0)
216 r = sd_event_add_io(m->event, &m->idle_pipe_event_source, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m);
218 log_error("Failed to watch idle pipe: %s", strerror(-r));
225 static void manager_close_idle_pipe(Manager *m) {
228 safe_close_pair(m->idle_pipe);
229 safe_close_pair(m->idle_pipe + 2);
232 static int manager_setup_time_change(Manager *m) {
235 /* We only care for the cancellation event, hence we set the
236 * timeout to the latest possible value. */
237 struct itimerspec its = {
238 .it_value.tv_sec = TIME_T_MAX,
242 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
247 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
248 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
250 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
251 if (m->time_change_fd < 0) {
252 log_error("Failed to create timerfd: %m");
256 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
257 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
258 m->time_change_fd = safe_close(m->time_change_fd);
262 r = sd_event_add_io(m->event, &m->time_change_event_source, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m);
264 log_error("Failed to create time change event source: %s", strerror(-r));
268 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
273 static int enable_special_signals(Manager *m) {
274 _cleanup_close_ int fd = -1;
278 /* Enable that we get SIGINT on control-alt-del. In containers
279 * this will fail with EPERM (older) or EINVAL (newer), so
281 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
282 log_warning("Failed to enable ctrl-alt-del handling: %m");
284 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
286 /* Support systems without virtual console */
288 log_warning("Failed to open /dev/tty0: %m");
290 /* Enable that we get SIGWINCH on kbrequest */
291 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
292 log_warning("Failed to enable kbrequest handling: %m");
298 static int manager_setup_signals(Manager *m) {
299 struct sigaction sa = {
300 .sa_handler = SIG_DFL,
301 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
311 /* We are not interested in SIGSTOP and friends. */
312 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
314 assert_se(sigemptyset(&mask) == 0);
316 sigset_add_many(&mask,
317 SIGCHLD, /* Child died */
318 SIGTERM, /* Reexecute daemon */
319 SIGHUP, /* Reload configuration */
320 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
321 SIGUSR2, /* systemd: dump status */
322 SIGINT, /* Kernel sends us this on control-alt-del */
323 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
324 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
325 SIGRTMIN+0, /* systemd: start default.target */
326 SIGRTMIN+1, /* systemd: isolate rescue.target */
327 SIGRTMIN+2, /* systemd: isolate emergency.target */
328 SIGRTMIN+3, /* systemd: start halt.target */
329 SIGRTMIN+4, /* systemd: start poweroff.target */
330 SIGRTMIN+5, /* systemd: start reboot.target */
331 SIGRTMIN+6, /* systemd: start kexec.target */
332 SIGRTMIN+13, /* systemd: Immediate halt */
333 SIGRTMIN+14, /* systemd: Immediate poweroff */
334 SIGRTMIN+15, /* systemd: Immediate reboot */
335 SIGRTMIN+16, /* systemd: Immediate kexec */
336 SIGRTMIN+20, /* systemd: enable status messages */
337 SIGRTMIN+21, /* systemd: disable status messages */
338 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
339 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
340 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
341 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
342 SIGRTMIN+27, /* systemd: set log target to console */
343 SIGRTMIN+28, /* systemd: set log target to kmsg */
344 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg (obsolete)*/
346 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
348 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
349 if (m->signal_fd < 0)
352 r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);
356 /* Process signals a bit earlier than the rest of things, but
357 * later that notify_fd processing, so that the notify
358 * processing can still figure out to which process/service a
359 * message belongs, before we reap the process. */
360 r = sd_event_source_set_priority(m->signal_event_source, -5);
364 if (m->running_as == SYSTEMD_SYSTEM)
365 return enable_special_signals(m);
370 static void manager_clean_environment(Manager *m) {
373 /* Let's remove some environment variables that we
374 * need ourselves to communicate with our clients */
387 static int manager_default_environment(Manager *m) {
390 if (m->running_as == SYSTEMD_SYSTEM) {
391 /* The system manager always starts with a clean
392 * environment for its children. It does not import
393 * the kernel or the parents exported variables.
395 * The initial passed environ is untouched to keep
396 * /proc/self/environ valid; it is used for tagging
397 * the init process inside containers. */
398 m->environment = strv_new("PATH=" DEFAULT_PATH,
401 /* Import locale variables LC_*= from configuration */
402 locale_setup(&m->environment);
404 /* The user manager passes its own environment
405 * along to its children. */
406 m->environment = strv_copy(environ);
412 manager_clean_environment(m);
413 strv_sort(m->environment);
418 int manager_new(SystemdRunningAs running_as, bool test_run, Manager **_m) {
423 assert(running_as >= 0);
424 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
426 m = new0(Manager, 1);
431 if (running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0)
432 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
435 m->running_as = running_as;
436 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
437 m->default_timer_accuracy_usec = USEC_PER_MINUTE;
438 m->start_timeout_usec = DEFAULT_MANAGER_START_TIMEOUT_USEC;
439 m->start_timeout_action = FAILURE_ACTION_POWEROFF_FORCE;
441 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
443 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 = -1;
444 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
446 m->test_run = test_run;
448 r = manager_default_environment(m);
452 r = hashmap_ensure_allocated(&m->units, &string_hash_ops);
456 r = hashmap_ensure_allocated(&m->jobs, NULL);
460 r = hashmap_ensure_allocated(&m->cgroup_unit, &string_hash_ops);
464 r = hashmap_ensure_allocated(&m->watch_bus, &string_hash_ops);
468 r = set_ensure_allocated(&m->startup_units, NULL);
472 r = set_ensure_allocated(&m->failed_units, NULL);
476 r = sd_event_default(&m->event);
480 r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
484 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
488 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
492 r = manager_setup_signals(m);
496 r = manager_setup_cgroup(m);
500 r = manager_setup_time_change(m);
504 m->udev = udev_new();
510 /* Note that we set up neither kdbus, nor the notify fd
511 * here. We do that after deserialization, since they might
512 * have gotten serialized across the reexec. */
514 m->taint_usr = dir_is_empty("/usr") > 0;
524 static int manager_setup_notify(Manager *m) {
530 if (m->notify_fd < 0) {
531 _cleanup_close_ int fd = -1;
532 union sockaddr_union sa = {
533 .sa.sa_family = AF_UNIX,
535 static const int one = 1;
537 /* First free all secondary fields */
538 free(m->notify_socket);
539 m->notify_socket = NULL;
540 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
542 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
544 log_error("Failed to allocate notification socket: %m");
548 if (m->running_as == SYSTEMD_SYSTEM)
549 m->notify_socket = strdup("/run/systemd/notify");
553 e = getenv("XDG_RUNTIME_DIR");
555 log_error("XDG_RUNTIME_DIR is not set: %m");
559 m->notify_socket = strappend(e, "/systemd/notify");
561 if (!m->notify_socket)
564 strncpy(sa.un.sun_path, m->notify_socket, sizeof(sa.un.sun_path)-1);
565 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path));
567 log_error("bind(%s) failed: %m", sa.un.sun_path);
571 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
573 log_error("SO_PASSCRED failed: %m");
580 log_debug("Using notification socket %s", m->notify_socket);
583 if (!m->notify_event_source) {
584 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
586 log_error("Failed to allocate notify event source: %s", strerror(-r));
590 /* Process signals a bit earlier than SIGCHLD, so that we can
591 * still identify to which service an exit message belongs */
592 r = sd_event_source_set_priority(m->notify_event_source, -7);
594 log_error("Failed to set priority of notify event source: %s", strerror(-r));
602 static int manager_setup_kdbus(Manager *m) {
604 _cleanup_free_ char *p = NULL;
608 if (m->test_run || m->kdbus_fd >= 0)
611 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
612 if (m->kdbus_fd < 0) {
613 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
617 log_debug("Successfully set up kdbus on %s", p);
619 /* Create the namespace directory here, so that the contents
620 * of that directory is not visible to non-root users. This is
621 * necessary to ensure that users cannot get access to busses
622 * of virtualized users when no UID namespacing is used. */
623 if (m->running_as == SYSTEMD_SYSTEM)
624 mkdir_p_label("/dev/kdbus/domain", 0700);
630 static int manager_connect_bus(Manager *m, bool reexecuting) {
631 bool try_bus_connect;
641 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
643 /* Try to connect to the busses, if possible. */
644 return bus_init(m, try_bus_connect);
647 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
653 while ((u = m->cleanup_queue)) {
654 assert(u->in_cleanup_queue);
664 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
665 GC_OFFSET_UNSURE, /* No clue */
666 GC_OFFSET_GOOD, /* We still need this unit */
667 GC_OFFSET_BAD, /* We don't need this unit anymore */
671 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
678 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
679 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
680 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
683 if (u->in_cleanup_queue)
686 if (unit_check_gc(u))
689 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
693 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
694 unit_gc_sweep(other, gc_marker);
696 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
699 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
706 /* We were unable to find anything out about this entry, so
707 * let's investigate it later */
708 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
709 unit_add_to_gc_queue(u);
713 /* We definitely know that this one is not useful anymore, so
714 * let's mark it for deletion */
715 u->gc_marker = gc_marker + GC_OFFSET_BAD;
716 unit_add_to_cleanup_queue(u);
720 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
723 static unsigned manager_dispatch_gc_queue(Manager *m) {
730 /* log_debug("Running GC..."); */
732 m->gc_marker += _GC_OFFSET_MAX;
733 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
736 gc_marker = m->gc_marker;
738 while ((u = m->gc_queue)) {
739 assert(u->in_gc_queue);
741 unit_gc_sweep(u, gc_marker);
743 LIST_REMOVE(gc_queue, m->gc_queue, u);
744 u->in_gc_queue = false;
748 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
749 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
750 log_debug_unit(u->id, "Collecting %s", u->id);
751 u->gc_marker = gc_marker + GC_OFFSET_BAD;
752 unit_add_to_cleanup_queue(u);
756 m->n_in_gc_queue = 0;
761 static void manager_clear_jobs_and_units(Manager *m) {
766 while ((u = hashmap_first(m->units)))
769 manager_dispatch_cleanup_queue(m);
771 assert(!m->load_queue);
772 assert(!m->run_queue);
773 assert(!m->dbus_unit_queue);
774 assert(!m->dbus_job_queue);
775 assert(!m->cleanup_queue);
776 assert(!m->gc_queue);
778 assert(hashmap_isempty(m->jobs));
779 assert(hashmap_isempty(m->units));
782 m->n_running_jobs = 0;
785 void manager_free(Manager *m) {
791 manager_clear_jobs_and_units(m);
793 for (c = 0; c < _UNIT_TYPE_MAX; c++)
794 if (unit_vtable[c]->shutdown)
795 unit_vtable[c]->shutdown(m);
797 /* If we reexecute ourselves, we keep the root cgroup
799 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
801 manager_undo_generators(m);
805 hashmap_free(m->units);
806 hashmap_free(m->jobs);
807 hashmap_free(m->watch_pids1);
808 hashmap_free(m->watch_pids2);
809 hashmap_free(m->watch_bus);
811 set_free(m->startup_units);
812 set_free(m->failed_units);
814 sd_event_source_unref(m->signal_event_source);
815 sd_event_source_unref(m->notify_event_source);
816 sd_event_source_unref(m->time_change_event_source);
817 sd_event_source_unref(m->jobs_in_progress_event_source);
818 sd_event_source_unref(m->idle_pipe_event_source);
819 sd_event_source_unref(m->run_queue_event_source);
821 safe_close(m->signal_fd);
822 safe_close(m->notify_fd);
823 safe_close(m->time_change_fd);
824 safe_close(m->kdbus_fd);
826 manager_close_idle_pipe(m);
828 sd_event_source_unref(m->start_timeout_event_source);
829 free(m->start_timeout_reboot_arg);
832 sd_event_unref(m->event);
834 free(m->notify_socket);
836 lookup_paths_free(&m->lookup_paths);
837 strv_free(m->environment);
839 hashmap_free(m->cgroup_unit);
840 set_free_free(m->unit_path_cache);
842 free(m->switch_root);
843 free(m->switch_root_init);
845 for (i = 0; i < _RLIMIT_MAX; i++)
848 assert(hashmap_isempty(m->units_requiring_mounts_for));
849 hashmap_free(m->units_requiring_mounts_for);
854 int manager_enumerate(Manager *m) {
860 /* Let's ask every type to load all units from disk/kernel
861 * that it might know */
862 for (c = 0; c < _UNIT_TYPE_MAX; c++)
863 if (unit_vtable[c]->enumerate) {
864 q = unit_vtable[c]->enumerate(m);
869 manager_dispatch_load_queue(m);
873 static int manager_coldplug(Manager *m) {
881 /* Then, let's set up their initial state. */
882 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
889 q = unit_coldplug(u);
897 static void manager_build_unit_path_cache(Manager *m) {
899 _cleanup_closedir_ DIR *d = NULL;
904 set_free_free(m->unit_path_cache);
906 m->unit_path_cache = set_new(&string_hash_ops);
907 if (!m->unit_path_cache) {
908 log_error("Failed to allocate unit path cache.");
912 /* This simply builds a list of files we know exist, so that
913 * we don't always have to go to disk */
915 STRV_FOREACH(i, m->lookup_paths.unit_path) {
921 log_error("Failed to open directory %s: %m", *i);
925 while ((de = readdir(d))) {
928 if (ignore_file(de->d_name))
931 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
937 r = set_consume(m->unit_path_cache, p);
949 log_error("Failed to build unit path cache: %s", strerror(-r));
951 set_free_free(m->unit_path_cache);
952 m->unit_path_cache = NULL;
956 static int manager_distribute_fds(Manager *m, FDSet *fds) {
963 HASHMAP_FOREACH(u, m->units, i) {
965 if (fdset_size(fds) <= 0)
968 if (UNIT_VTABLE(u)->distribute_fds) {
969 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
978 static int on_start_timeout(sd_event_source *s, usec_t usec, void *userdata) {
979 Manager *m = userdata;
984 m->start_timeout_event_source = sd_event_source_unref(m->start_timeout_event_source);
986 log_error("Startup timed out.");
988 failure_action(m, m->start_timeout_action, m->start_timeout_reboot_arg);
992 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
997 dual_timestamp_get(&m->generators_start_timestamp);
998 manager_run_generators(m);
999 dual_timestamp_get(&m->generators_finish_timestamp);
1001 r = lookup_paths_init(
1002 &m->lookup_paths, m->running_as, true,
1004 m->generator_unit_path,
1005 m->generator_unit_path_early,
1006 m->generator_unit_path_late);
1010 manager_build_unit_path_cache(m);
1012 /* If we will deserialize make sure that during enumeration
1013 * this is already known, so we increase the counter here
1018 /* First, enumerate what we can from all config files */
1019 dual_timestamp_get(&m->units_load_start_timestamp);
1020 r = manager_enumerate(m);
1021 dual_timestamp_get(&m->units_load_finish_timestamp);
1023 /* Second, deserialize if there is something to deserialize */
1025 r = manager_deserialize(m, serialization, fds);
1027 /* Any fds left? Find some unit which wants them. This is
1028 * useful to allow container managers to pass some file
1029 * descriptors to us pre-initialized. This enables
1030 * socket-based activation of entire containers. */
1031 if (fdset_size(fds) > 0) {
1032 q = manager_distribute_fds(m, fds);
1033 if (q < 0 && r == 0)
1037 /* We might have deserialized the notify fd, but if we didn't
1038 * then let's create the bus now */
1039 q = manager_setup_notify(m);
1040 if (q < 0 && r == 0)
1043 /* We might have deserialized the kdbus control fd, but if we
1044 * didn't, then let's create the bus now. */
1045 manager_setup_kdbus(m);
1046 manager_connect_bus(m, !!serialization);
1047 bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
1049 /* Third, fire things up! */
1050 q = manager_coldplug(m);
1051 if (q < 0 && r == 0)
1054 if (serialization) {
1055 assert(m->n_reloading > 0);
1058 /* Let's wait for the UnitNew/JobNew messages being
1059 * sent, before we notify that the reload is
1061 m->send_reloading_done = true;
1064 /* Possibly set up a start timeout */
1065 if (!dual_timestamp_is_set(&m->finish_timestamp)) {
1066 m->start_timeout_event_source = sd_event_source_unref(m->start_timeout_event_source);
1068 if (m->start_timeout_usec) {
1069 r = sd_event_add_time(
1071 &m->start_timeout_event_source,
1073 now(CLOCK_MONOTONIC) + m->start_timeout_usec, 0,
1074 on_start_timeout, m);
1076 log_error("Failed to add start timeout event: %s", strerror(-r));
1083 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1088 assert(type < _JOB_TYPE_MAX);
1090 assert(mode < _JOB_MODE_MAX);
1092 if (mode == JOB_ISOLATE && type != JOB_START) {
1093 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1097 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1098 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1102 log_debug_unit(unit->id,
1103 "Trying to enqueue job %s/%s/%s", unit->id,
1104 job_type_to_string(type), job_mode_to_string(mode));
1106 job_type_collapse(&type, unit);
1108 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1112 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1113 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1114 mode == JOB_IGNORE_DEPENDENCIES, e);
1118 if (mode == JOB_ISOLATE) {
1119 r = transaction_add_isolate_jobs(tr, m);
1124 r = transaction_activate(tr, m, mode, e);
1128 log_debug_unit(unit->id,
1129 "Enqueued job %s/%s as %u", unit->id,
1130 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1133 *_ret = tr->anchor_job;
1135 transaction_free(tr);
1139 transaction_abort(tr);
1140 transaction_free(tr);
1144 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1149 assert(type < _JOB_TYPE_MAX);
1151 assert(mode < _JOB_MODE_MAX);
1153 r = manager_load_unit(m, name, NULL, NULL, &unit);
1157 return manager_add_job(m, type, unit, mode, override, e, _ret);
1160 Job *manager_get_job(Manager *m, uint32_t id) {
1163 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1166 Unit *manager_get_unit(Manager *m, const char *name) {
1170 return hashmap_get(m->units, name);
1173 unsigned manager_dispatch_load_queue(Manager *m) {
1179 /* Make sure we are not run recursively */
1180 if (m->dispatching_load_queue)
1183 m->dispatching_load_queue = true;
1185 /* Dispatches the load queue. Takes a unit from the queue and
1186 * tries to load its data until the queue is empty */
1188 while ((u = m->load_queue)) {
1189 assert(u->in_load_queue);
1195 m->dispatching_load_queue = false;
1199 int manager_load_unit_prepare(
1211 assert(name || path);
1213 /* This will prepare the unit for loading, but not actually
1214 * load anything from disk. */
1216 if (path && !is_path(path))
1217 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1220 name = basename(path);
1222 t = unit_name_to_type(name);
1224 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1225 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1227 ret = manager_get_unit(m, name);
1233 ret = unit_new(m, unit_vtable[t]->object_size);
1238 ret->fragment_path = strdup(path);
1239 if (!ret->fragment_path) {
1245 r = unit_add_name(ret, name);
1251 unit_add_to_load_queue(ret);
1252 unit_add_to_dbus_queue(ret);
1253 unit_add_to_gc_queue(ret);
1261 int manager_load_unit(
1272 /* This will load the service information files, but not actually
1273 * start any services or anything. */
1275 r = manager_load_unit_prepare(m, name, path, e, _ret);
1279 manager_dispatch_load_queue(m);
1282 *_ret = unit_follow_merge(*_ret);
1287 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1294 HASHMAP_FOREACH(j, s->jobs, i)
1295 job_dump(j, f, prefix);
1298 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1306 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1308 unit_dump(u, f, prefix);
1311 void manager_clear_jobs(Manager *m) {
1316 while ((j = hashmap_first(m->jobs)))
1317 /* No need to recurse. We're cancelling all jobs. */
1318 job_finish_and_invalidate(j, JOB_CANCELED, false);
1321 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1322 Manager *m = userdata;
1328 while ((j = m->run_queue)) {
1329 assert(j->installed);
1330 assert(j->in_run_queue);
1332 job_run_and_invalidate(j);
1335 if (m->n_running_jobs > 0)
1336 manager_watch_jobs_in_progress(m);
1338 if (m->n_on_console > 0)
1339 manager_watch_idle_pipe(m);
1344 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1351 if (m->dispatching_dbus_queue)
1354 m->dispatching_dbus_queue = true;
1356 while ((u = m->dbus_unit_queue)) {
1357 assert(u->in_dbus_queue);
1359 bus_unit_send_change_signal(u);
1363 while ((j = m->dbus_job_queue)) {
1364 assert(j->in_dbus_queue);
1366 bus_job_send_change_signal(j);
1370 m->dispatching_dbus_queue = false;
1372 if (m->send_reloading_done) {
1373 m->send_reloading_done = false;
1375 bus_manager_send_reloading(m, false);
1378 if (m->queued_message)
1379 bus_send_queued_message(m);
1384 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n) {
1385 _cleanup_strv_free_ char **tags = NULL;
1392 tags = strv_split(buf, "\n\r");
1398 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1400 if (UNIT_VTABLE(u)->notify_message)
1401 UNIT_VTABLE(u)->notify_message(u, pid, tags);
1404 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1405 Manager *m = userdata;
1409 assert(m->notify_fd == fd);
1411 if (revents != EPOLLIN) {
1412 log_warning("Got unexpected poll event for notify fd.");
1418 struct iovec iovec = {
1420 .iov_len = sizeof(buf)-1,
1425 struct cmsghdr cmsghdr;
1426 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1429 struct msghdr msghdr = {
1432 .msg_control = &control,
1433 .msg_controllen = sizeof(control),
1435 struct ucred *ucred;
1438 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1443 if (errno == EAGAIN || errno == EINTR)
1449 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1450 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1451 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1452 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1453 log_warning("Received notify message without credentials. Ignoring.");
1457 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1459 assert((size_t) n < sizeof(buf));
1462 /* Notify every unit that might be interested, but try
1463 * to avoid notifying the same one multiple times. */
1464 u1 = manager_get_unit_by_pid(m, ucred->pid);
1466 manager_invoke_notify_message(m, u1, ucred->pid, buf, n);
1470 u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1471 if (u2 && u2 != u1) {
1472 manager_invoke_notify_message(m, u2, ucred->pid, buf, n);
1476 u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1477 if (u3 && u3 != u2 && u3 != u1) {
1478 manager_invoke_notify_message(m, u3, ucred->pid, buf, n);
1483 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1489 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1494 log_debug_unit(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1496 unit_unwatch_pid(u, si->si_pid);
1497 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1500 static int manager_dispatch_sigchld(Manager *m) {
1506 /* First we call waitd() for a PID and do not reap the
1507 * zombie. That way we can still access /proc/$PID for
1508 * it while it is a zombie. */
1509 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1511 if (errno == ECHILD)
1523 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1524 _cleanup_free_ char *name = NULL;
1527 get_process_comm(si.si_pid, &name);
1529 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1530 si.si_pid, strna(name),
1531 sigchld_code_to_string(si.si_code),
1533 strna(si.si_code == CLD_EXITED
1534 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1535 : signal_to_string(si.si_status)));
1537 /* And now figure out the unit this belongs
1538 * to, it might be multiple... */
1539 u1 = manager_get_unit_by_pid(m, si.si_pid);
1541 invoke_sigchld_event(m, u1, &si);
1542 u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1544 invoke_sigchld_event(m, u2, &si);
1545 u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1546 if (u3 && u3 != u2 && u3 != u1)
1547 invoke_sigchld_event(m, u3, &si);
1550 /* And now, we actually reap the zombie. */
1551 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1562 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1563 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1566 log_debug_unit(name, "Activating special unit %s", name);
1568 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1570 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1575 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1576 Manager *m = userdata;
1578 struct signalfd_siginfo sfsi;
1579 bool sigchld = false;
1582 assert(m->signal_fd == fd);
1584 if (revents != EPOLLIN) {
1585 log_warning("Got unexpected events from signal file descriptor.");
1590 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1591 if (n != sizeof(sfsi)) {
1596 if (errno == EINTR || errno == EAGAIN)
1602 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1603 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1604 ? LOG_DEBUG : LOG_INFO,
1607 switch (sfsi.ssi_signo) {
1614 if (m->running_as == SYSTEMD_SYSTEM) {
1615 /* This is for compatibility with the
1616 * original sysvinit */
1617 m->exit_code = MANAGER_REEXECUTE;
1624 if (m->running_as == SYSTEMD_SYSTEM) {
1625 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1629 /* Run the exit target if there is one, if not, just exit. */
1630 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1631 m->exit_code = MANAGER_EXIT;
1638 if (m->running_as == SYSTEMD_SYSTEM)
1639 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1641 /* This is a nop on non-init */
1645 if (m->running_as == SYSTEMD_SYSTEM)
1646 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1648 /* This is a nop on non-init */
1654 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1656 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1657 log_info("Trying to reconnect to bus...");
1661 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1662 log_info("Loading D-Bus service...");
1663 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1670 _cleanup_free_ char *dump = NULL;
1671 _cleanup_fclose_ FILE *f = NULL;
1674 f = open_memstream(&dump, &size);
1676 log_warning("Failed to allocate memory stream.");
1680 manager_dump_units(m, f, "\t");
1681 manager_dump_jobs(m, f, "\t");
1684 log_warning("Failed to write status stream");
1689 log_warning("Failed to flush status stream");
1693 log_dump(LOG_INFO, dump);
1698 m->exit_code = MANAGER_RELOAD;
1703 /* Starting SIGRTMIN+0 */
1704 static const char * const target_table[] = {
1705 [0] = SPECIAL_DEFAULT_TARGET,
1706 [1] = SPECIAL_RESCUE_TARGET,
1707 [2] = SPECIAL_EMERGENCY_TARGET,
1708 [3] = SPECIAL_HALT_TARGET,
1709 [4] = SPECIAL_POWEROFF_TARGET,
1710 [5] = SPECIAL_REBOOT_TARGET,
1711 [6] = SPECIAL_KEXEC_TARGET
1714 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1715 static const ManagerExitCode code_table[] = {
1717 [1] = MANAGER_POWEROFF,
1718 [2] = MANAGER_REBOOT,
1722 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1723 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1724 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1725 manager_start_target(m, target_table[idx],
1726 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1730 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1731 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1732 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1736 switch (sfsi.ssi_signo - SIGRTMIN) {
1739 log_debug("Enabling showing of status.");
1740 manager_set_show_status(m, SHOW_STATUS_YES);
1744 log_debug("Disabling showing of status.");
1745 manager_set_show_status(m, SHOW_STATUS_NO);
1749 log_set_max_level(LOG_DEBUG);
1750 log_notice("Setting log level to debug.");
1754 log_set_max_level(LOG_INFO);
1755 log_notice("Setting log level to info.");
1759 if (m->running_as == SYSTEMD_USER) {
1760 m->exit_code = MANAGER_EXIT;
1764 /* This is a nop on init */
1768 case 29: /* compatibility: used to be mapped to LOG_TARGET_SYSLOG_OR_KMSG */
1769 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1770 log_notice("Setting log target to journal-or-kmsg.");
1774 log_set_target(LOG_TARGET_CONSOLE);
1775 log_notice("Setting log target to console.");
1779 log_set_target(LOG_TARGET_KMSG);
1780 log_notice("Setting log target to kmsg.");
1784 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1791 manager_dispatch_sigchld(m);
1796 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1797 Manager *m = userdata;
1802 assert(m->time_change_fd == fd);
1804 log_struct(LOG_INFO,
1805 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1806 "MESSAGE=Time has been changed",
1809 /* Restart the watch */
1810 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1811 m->time_change_fd = safe_close(m->time_change_fd);
1813 manager_setup_time_change(m);
1815 HASHMAP_FOREACH(u, m->units, i)
1816 if (UNIT_VTABLE(u)->time_change)
1817 UNIT_VTABLE(u)->time_change(u);
1822 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1823 Manager *m = userdata;
1826 assert(m->idle_pipe[2] == fd);
1828 m->no_console_output = m->n_on_console > 0;
1830 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1831 manager_close_idle_pipe(m);
1836 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1837 Manager *m = userdata;
1844 manager_print_jobs_in_progress(m);
1846 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1847 r = sd_event_source_set_time(source, next);
1851 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1854 int manager_loop(Manager *m) {
1857 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1860 m->exit_code = MANAGER_OK;
1862 /* Release the path cache */
1863 set_free_free(m->unit_path_cache);
1864 m->unit_path_cache = NULL;
1866 manager_check_finished(m);
1868 /* There might still be some zombies hanging around from
1869 * before we were exec()'ed. Let's reap them. */
1870 r = manager_dispatch_sigchld(m);
1874 while (m->exit_code == MANAGER_OK) {
1877 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1880 if (!ratelimit_test(&rl)) {
1881 /* Yay, something is going seriously wrong, pause a little */
1882 log_warning("Looping too fast. Throttling execution a little.");
1887 if (manager_dispatch_load_queue(m) > 0)
1890 if (manager_dispatch_gc_queue(m) > 0)
1893 if (manager_dispatch_cleanup_queue(m) > 0)
1896 if (manager_dispatch_cgroup_queue(m) > 0)
1899 if (manager_dispatch_dbus_queue(m) > 0)
1902 /* Sleep for half the watchdog time */
1903 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1904 wait_usec = m->runtime_watchdog / 2;
1908 wait_usec = USEC_INFINITY;
1910 r = sd_event_run(m->event, wait_usec);
1912 log_error("Failed to run event loop: %s", strerror(-r));
1917 return m->exit_code;
1920 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1921 _cleanup_free_ char *n = NULL;
1929 r = unit_name_from_dbus_path(s, &n);
1933 r = manager_load_unit(m, n, NULL, e, &u);
1942 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1952 p = startswith(s, "/org/freedesktop/systemd1/job/");
1956 r = safe_atou(p, &id);
1960 j = manager_get_job(m, id);
1969 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1972 _cleanup_free_ char *p = NULL;
1975 audit_fd = get_audit_fd();
1979 /* Don't generate audit events if the service was already
1980 * started and we're just deserializing */
1981 if (m->n_reloading > 0)
1984 if (m->running_as != SYSTEMD_SYSTEM)
1987 if (u->type != UNIT_SERVICE)
1990 p = unit_name_to_prefix_and_instance(u->id);
1992 log_error_unit(u->id,
1993 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1997 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1998 if (errno == EPERM) {
1999 /* We aren't allowed to send audit messages?
2000 * Then let's not retry again. */
2003 log_warning("Failed to send audit message: %m");
2009 void manager_send_unit_plymouth(Manager *m, Unit *u) {
2010 union sockaddr_union sa = PLYMOUTH_SOCKET;
2013 _cleanup_free_ char *message = NULL;
2014 _cleanup_close_ int fd = -1;
2016 /* Don't generate plymouth events if the service was already
2017 * started and we're just deserializing */
2018 if (m->n_reloading > 0)
2021 if (m->running_as != SYSTEMD_SYSTEM)
2024 if (detect_container(NULL) > 0)
2027 if (u->type != UNIT_SERVICE &&
2028 u->type != UNIT_MOUNT &&
2029 u->type != UNIT_SWAP)
2032 /* We set SOCK_NONBLOCK here so that we rather drop the
2033 * message then wait for plymouth */
2034 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2036 log_error("socket() failed: %m");
2040 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2042 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2043 log_error("connect() failed: %m");
2047 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2053 if (write(fd, message, n + 1) != n + 1)
2054 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2055 log_error("Failed to write Plymouth message: %m");
2058 void manager_dispatch_bus_name_owner_changed(
2061 const char* old_owner,
2062 const char *new_owner) {
2069 u = hashmap_get(m->watch_bus, name);
2073 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2076 int manager_open_serialization(Manager *m, FILE **_f) {
2083 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2084 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2088 log_debug("Serializing state to %s", path);
2090 f = fdopen(fd, "w+");
2101 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2114 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2115 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2116 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2117 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2119 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2120 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2121 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2122 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2125 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2126 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2127 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2128 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2129 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2130 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2131 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2132 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2135 if (!switching_root) {
2136 STRV_FOREACH(e, m->environment) {
2137 _cleanup_free_ char *ce;
2143 fprintf(f, "env=%s\n", *e);
2147 if (m->notify_fd >= 0) {
2150 copy = fdset_put_dup(fds, m->notify_fd);
2154 fprintf(f, "notify-fd=%i\n", copy);
2155 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2158 if (m->kdbus_fd >= 0) {
2161 copy = fdset_put_dup(fds, m->kdbus_fd);
2165 fprintf(f, "kdbus-fd=%i\n", copy);
2168 bus_track_serialize(m->subscribed, f);
2172 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2180 r = unit_serialize(u, f, fds, !switching_root);
2187 assert(m->n_reloading > 0);
2193 r = bus_fdset_add_all(m, fds);
2200 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2206 log_debug("Deserializing state...");
2211 char line[LINE_MAX], *l;
2213 if (!fgets(line, sizeof(line), f)) {
2228 if (startswith(l, "current-job-id=")) {
2231 if (safe_atou32(l+15, &id) < 0)
2232 log_debug("Failed to parse current job id value %s", l+15);
2234 m->current_job_id = MAX(m->current_job_id, id);
2236 } else if (startswith(l, "n-installed-jobs=")) {
2239 if (safe_atou32(l+17, &n) < 0)
2240 log_debug("Failed to parse installed jobs counter %s", l+17);
2242 m->n_installed_jobs += n;
2244 } else if (startswith(l, "n-failed-jobs=")) {
2247 if (safe_atou32(l+14, &n) < 0)
2248 log_debug("Failed to parse failed jobs counter %s", l+14);
2250 m->n_failed_jobs += n;
2252 } else if (startswith(l, "taint-usr=")) {
2255 b = parse_boolean(l+10);
2257 log_debug("Failed to parse taint /usr flag %s", l+10);
2259 m->taint_usr = m->taint_usr || b;
2261 } else if (startswith(l, "firmware-timestamp="))
2262 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2263 else if (startswith(l, "loader-timestamp="))
2264 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2265 else if (startswith(l, "kernel-timestamp="))
2266 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2267 else if (startswith(l, "initrd-timestamp="))
2268 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2269 else if (startswith(l, "userspace-timestamp="))
2270 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2271 else if (startswith(l, "finish-timestamp="))
2272 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2273 else if (startswith(l, "security-start-timestamp="))
2274 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2275 else if (startswith(l, "security-finish-timestamp="))
2276 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2277 else if (startswith(l, "generators-start-timestamp="))
2278 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2279 else if (startswith(l, "generators-finish-timestamp="))
2280 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2281 else if (startswith(l, "units-load-start-timestamp="))
2282 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2283 else if (startswith(l, "units-load-finish-timestamp="))
2284 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2285 else if (startswith(l, "env=")) {
2286 _cleanup_free_ char *uce = NULL;
2289 uce = cunescape(l+4);
2295 e = strv_env_set(m->environment, uce);
2301 strv_free(m->environment);
2304 } else if (startswith(l, "notify-fd=")) {
2307 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2308 log_debug("Failed to parse notify fd: %s", l + 10);
2310 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2311 safe_close(m->notify_fd);
2312 m->notify_fd = fdset_remove(fds, fd);
2315 } else if (startswith(l, "notify-socket=")) {
2324 free(m->notify_socket);
2325 m->notify_socket = n;
2327 } else if (startswith(l, "kdbus-fd=")) {
2330 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2331 log_debug("Failed to parse kdbus fd: %s", l + 9);
2333 safe_close(m->kdbus_fd);
2334 m->kdbus_fd = fdset_remove(fds, fd);
2337 } else if (bus_track_deserialize_item(&m->deserialized_subscribed, l) == 0)
2338 log_debug("Unknown serialization item '%s'", l);
2343 char name[UNIT_NAME_MAX+2];
2346 if (!fgets(name, sizeof(name), f)) {
2357 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2361 r = unit_deserialize(u, f, fds);
2370 assert(m->n_reloading > 0);
2376 int manager_reload(Manager *m) {
2378 _cleanup_fclose_ FILE *f = NULL;
2379 _cleanup_fdset_free_ FDSet *fds = NULL;
2383 r = manager_open_serialization(m, &f);
2388 bus_manager_send_reloading(m, true);
2396 r = manager_serialize(m, f, fds, false);
2402 if (fseeko(f, 0, SEEK_SET) < 0) {
2407 /* From here on there is no way back. */
2408 manager_clear_jobs_and_units(m);
2409 manager_undo_generators(m);
2410 lookup_paths_free(&m->lookup_paths);
2412 /* Find new unit paths */
2413 manager_run_generators(m);
2415 q = lookup_paths_init(
2416 &m->lookup_paths, m->running_as, true,
2418 m->generator_unit_path,
2419 m->generator_unit_path_early,
2420 m->generator_unit_path_late);
2424 manager_build_unit_path_cache(m);
2426 /* First, enumerate what we can from all config files */
2427 q = manager_enumerate(m);
2431 /* Second, deserialize our stored data */
2432 q = manager_deserialize(m, f, fds);
2439 /* Re-register notify_fd as event source */
2440 q = manager_setup_notify(m);
2444 /* Third, fire things up! */
2445 q = manager_coldplug(m);
2449 assert(m->n_reloading > 0);
2452 m->send_reloading_done = true;
2457 bool manager_is_reloading_or_reexecuting(Manager *m) {
2460 return m->n_reloading != 0;
2463 void manager_reset_failed(Manager *m) {
2469 HASHMAP_FOREACH(u, m->units, i)
2470 unit_reset_failed(u);
2473 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2479 /* Returns true if the unit is inactive or going down */
2480 u = manager_get_unit(m, name);
2484 return unit_inactive_or_pending(u);
2487 void manager_check_finished(Manager *m) {
2488 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2489 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2495 if (m->n_running_jobs == 0)
2496 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2498 if (hashmap_size(m->jobs) > 0) {
2500 if (m->jobs_in_progress_event_source)
2501 sd_event_source_set_time(m->jobs_in_progress_event_source, now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2506 manager_flip_auto_status(m, false);
2508 /* Notify Type=idle units that we are done now */
2509 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2510 manager_close_idle_pipe(m);
2512 /* Turn off confirm spawn now */
2513 m->confirm_spawn = false;
2515 /* This is no longer the first boot */
2516 manager_set_first_boot(m, false);
2518 if (dual_timestamp_is_set(&m->finish_timestamp))
2521 dual_timestamp_get(&m->finish_timestamp);
2523 m->start_timeout_event_source = sd_event_source_unref(m->start_timeout_event_source);
2525 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2527 /* Note that m->kernel_usec.monotonic is always at 0,
2528 * and m->firmware_usec.monotonic and
2529 * m->loader_usec.monotonic should be considered
2530 * negative values. */
2532 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2533 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2534 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2535 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2537 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2539 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2540 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2542 log_struct(LOG_INFO,
2543 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2544 "KERNEL_USEC="USEC_FMT, kernel_usec,
2545 "INITRD_USEC="USEC_FMT, initrd_usec,
2546 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2547 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2548 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2549 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2550 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2551 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2554 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2557 log_struct(LOG_INFO,
2558 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2559 "KERNEL_USEC="USEC_FMT, kernel_usec,
2560 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2561 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2562 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2563 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2564 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2568 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2569 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2571 log_struct(LOG_INFO,
2572 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2573 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2574 "MESSAGE=Startup finished in %s.",
2575 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2579 SET_FOREACH(u, m->startup_units, i)
2581 cgroup_context_apply(unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path, manager_state(m));
2583 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2587 "STATUS=Startup finished in %s.",
2588 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2591 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2602 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2603 /* systemd --system, not running --test */
2605 p = strappend("/run/systemd/", name);
2609 r = mkdir_p_label(p, 0755);
2611 log_error("Failed to create generator directory %s: %s",
2616 } else if (m->running_as == SYSTEMD_USER) {
2617 const char *s = NULL;
2619 s = getenv("XDG_RUNTIME_DIR");
2622 p = strjoin(s, "/systemd/", name, NULL);
2626 r = mkdir_p_label(p, 0755);
2628 log_error("Failed to create generator directory %s: %s",
2634 /* systemd --system --test */
2636 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2641 log_error("Failed to create generator directory %s: %m",
2652 static void trim_generator_dir(Manager *m, char **generator) {
2659 if (rmdir(*generator) >= 0) {
2667 void manager_run_generators(Manager *m) {
2668 _cleanup_closedir_ DIR *d = NULL;
2669 const char *generator_path;
2670 const char *argv[5];
2678 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2679 d = opendir(generator_path);
2681 if (errno == ENOENT)
2684 log_error("Failed to enumerate generator directory %s: %m",
2689 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2693 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2697 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2701 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2702 argv[1] = m->generator_unit_path;
2703 argv[2] = m->generator_unit_path_early;
2704 argv[3] = m->generator_unit_path_late;
2707 RUN_WITH_UMASK(0022)
2708 execute_directory(generator_path, d, DEFAULT_TIMEOUT_USEC, (char**) argv);
2711 trim_generator_dir(m, &m->generator_unit_path);
2712 trim_generator_dir(m, &m->generator_unit_path_early);
2713 trim_generator_dir(m, &m->generator_unit_path_late);
2716 static void remove_generator_dir(Manager *m, char **generator) {
2723 strv_remove(m->lookup_paths.unit_path, *generator);
2724 rm_rf(*generator, false, true, false);
2730 void manager_undo_generators(Manager *m) {
2733 remove_generator_dir(m, &m->generator_unit_path);
2734 remove_generator_dir(m, &m->generator_unit_path_early);
2735 remove_generator_dir(m, &m->generator_unit_path_late);
2738 int manager_environment_add(Manager *m, char **minus, char **plus) {
2739 char **a = NULL, **b = NULL, **l;
2744 if (!strv_isempty(minus)) {
2745 a = strv_env_delete(l, 1, minus);
2752 if (!strv_isempty(plus)) {
2753 b = strv_env_merge(2, l, plus);
2762 if (m->environment != l)
2763 strv_free(m->environment);
2770 manager_clean_environment(m);
2771 strv_sort(m->environment);
2776 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2781 for (i = 0; i < _RLIMIT_MAX; i++) {
2782 if (!default_rlimit[i])
2785 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2793 void manager_recheck_journal(Manager *m) {
2798 if (m->running_as != SYSTEMD_SYSTEM)
2801 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2802 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2803 log_close_journal();
2807 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2808 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2809 log_close_journal();
2813 /* Hmm, OK, so the socket is fully up and the service is up
2814 * too, then let's make use of the thing. */
2818 void manager_set_show_status(Manager *m, ShowStatus mode) {
2820 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2822 if (m->running_as != SYSTEMD_SYSTEM)
2825 m->show_status = mode;
2828 touch("/run/systemd/show-status");
2830 unlink("/run/systemd/show-status");
2833 static bool manager_get_show_status(Manager *m) {
2836 if (m->running_as != SYSTEMD_SYSTEM)
2839 if (m->no_console_output)
2842 if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
2845 if (m->show_status > 0)
2848 /* If Plymouth is running make sure we show the status, so
2849 * that there's something nice to see when people press Esc */
2851 return plymouth_running();
2854 void manager_set_first_boot(Manager *m, bool b) {
2857 if (m->running_as != SYSTEMD_SYSTEM)
2863 touch("/run/systemd/first-boot");
2865 unlink("/run/systemd/first-boot");
2868 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2871 if (!manager_get_show_status(m))
2874 /* XXX We should totally drop the check for ephemeral here
2875 * and thus effectively make 'Type=idle' pointless. */
2876 if (ephemeral && m->n_on_console > 0)
2879 va_start(ap, format);
2880 status_vprintf(status, true, ephemeral, format, ap);
2884 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2885 _cleanup_free_ char *p = NULL;
2893 p = unit_name_from_path(path, suffix);
2897 found = manager_get_unit(m, p);
2907 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2908 char p[strlen(path)+1];
2914 path_kill_slashes(p);
2916 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
2919 const char *manager_get_runtime_prefix(Manager *m) {
2922 return m->running_as == SYSTEMD_SYSTEM ?
2924 getenv("XDG_RUNTIME_DIR");
2927 ManagerState manager_state(Manager *m) {
2932 /* Did we ever finish booting? If not then we are still starting up */
2933 if (!dual_timestamp_is_set(&m->finish_timestamp)) {
2935 u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
2936 if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
2937 return MANAGER_INITIALIZING;
2939 return MANAGER_STARTING;
2942 /* Is the special shutdown target queued? If so, we are in shutdown state */
2943 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2944 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
2945 return MANAGER_STOPPING;
2947 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
2948 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
2949 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2950 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2951 return MANAGER_MAINTENANCE;
2953 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
2954 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2955 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2956 return MANAGER_MAINTENANCE;
2958 /* Are there any failed units? If so, we are in degraded mode */
2959 if (set_size(m->failed_units) > 0)
2960 return MANAGER_DEGRADED;
2962 return MANAGER_RUNNING;
2965 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
2966 [MANAGER_INITIALIZING] = "initializing",
2967 [MANAGER_STARTING] = "starting",
2968 [MANAGER_RUNNING] = "running",
2969 [MANAGER_DEGRADED] = "degraded",
2970 [MANAGER_MAINTENANCE] = "maintenance",
2971 [MANAGER_STOPPING] = "stopping",
2974 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);