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/>.
25 #include <sys/epoll.h>
27 #include <sys/signalfd.h>
31 #include <sys/reboot.h>
32 #include <sys/ioctl.h>
36 #include <sys/types.h>
44 #include <systemd/sd-daemon.h>
47 #include "transaction.h"
54 #include "ratelimit.h"
56 #include "mount-setup.h"
57 #include "unit-name.h"
58 #include "dbus-unit.h"
61 #include "path-lookup.h"
63 #include "bus-errors.h"
64 #include "exit-status.h"
67 #include "cgroup-util.h"
69 /* As soon as 16 units are in our GC queue, make sure to run a gc sweep */
70 #define GC_QUEUE_ENTRIES_MAX 16
72 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
73 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
75 /* Where clients shall send notification messages to */
76 #define NOTIFY_SOCKET_SYSTEM "/run/systemd/notify"
77 #define NOTIFY_SOCKET_USER "@/org/freedesktop/systemd1/notify"
79 static int manager_setup_notify(Manager *m) {
82 struct sockaddr_un un;
84 struct epoll_event ev;
90 m->notify_watch.type = WATCH_NOTIFY;
91 if ((m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
92 log_error("Failed to allocate notification socket: %m");
97 sa.sa.sa_family = AF_UNIX;
100 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET_USER "/%llu", random_ull());
102 unlink(NOTIFY_SOCKET_SYSTEM);
103 strncpy(sa.un.sun_path, NOTIFY_SOCKET_SYSTEM, sizeof(sa.un.sun_path));
106 if (sa.un.sun_path[0] == '@')
107 sa.un.sun_path[0] = 0;
110 r = bind(m->notify_watch.fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
114 log_error("bind() failed: %m");
118 if (setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0) {
119 log_error("SO_PASSCRED failed: %m");
125 ev.data.ptr = &m->notify_watch;
127 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev) < 0)
130 if (sa.un.sun_path[0] == 0)
131 sa.un.sun_path[0] = '@';
133 if (!(m->notify_socket = strdup(sa.un.sun_path)))
136 log_debug("Using notification socket %s", m->notify_socket);
141 static int enable_special_signals(Manager *m) {
146 /* Enable that we get SIGINT on control-alt-del. In containers
147 * this will fail with EPERM, so ignore that. */
148 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM)
149 log_warning("Failed to enable ctrl-alt-del handling: %m");
151 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
153 /* Support systems without virtual console */
155 log_warning("Failed to open /dev/tty0: %m");
157 /* Enable that we get SIGWINCH on kbrequest */
158 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
159 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
161 close_nointr_nofail(fd);
167 static int manager_setup_signals(Manager *m) {
169 struct epoll_event ev;
174 /* We are not interested in SIGSTOP and friends. */
176 sa.sa_handler = SIG_DFL;
177 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
178 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
180 assert_se(sigemptyset(&mask) == 0);
182 sigset_add_many(&mask,
183 SIGCHLD, /* Child died */
184 SIGTERM, /* Reexecute daemon */
185 SIGHUP, /* Reload configuration */
186 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
187 SIGUSR2, /* systemd: dump status */
188 SIGINT, /* Kernel sends us this on control-alt-del */
189 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
190 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
191 SIGRTMIN+0, /* systemd: start default.target */
192 SIGRTMIN+1, /* systemd: isolate rescue.target */
193 SIGRTMIN+2, /* systemd: isolate emergency.target */
194 SIGRTMIN+3, /* systemd: start halt.target */
195 SIGRTMIN+4, /* systemd: start poweroff.target */
196 SIGRTMIN+5, /* systemd: start reboot.target */
197 SIGRTMIN+6, /* systemd: start kexec.target */
198 SIGRTMIN+13, /* systemd: Immediate halt */
199 SIGRTMIN+14, /* systemd: Immediate poweroff */
200 SIGRTMIN+15, /* systemd: Immediate reboot */
201 SIGRTMIN+16, /* systemd: Immediate kexec */
202 SIGRTMIN+20, /* systemd: enable status messages */
203 SIGRTMIN+21, /* systemd: disable status messages */
204 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
205 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
206 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
207 SIGRTMIN+27, /* systemd: set log target to console */
208 SIGRTMIN+28, /* systemd: set log target to kmsg */
209 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
211 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
213 m->signal_watch.type = WATCH_SIGNAL;
214 if ((m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC)) < 0)
219 ev.data.ptr = &m->signal_watch;
221 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
224 if (m->running_as == MANAGER_SYSTEM)
225 return enable_special_signals(m);
230 static void manager_strip_environment(Manager *m) {
233 /* Remove variables from the inherited set that are part of
234 * the container interface:
235 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
236 strv_remove_prefix(m->environment, "container=");
237 strv_remove_prefix(m->environment, "container_");
239 /* Remove variables from the inherited set that are part of
240 * the initrd interface:
241 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
242 strv_remove_prefix(m->environment, "RD_");
245 int manager_new(ManagerRunningAs running_as, Manager **_m) {
250 assert(running_as >= 0);
251 assert(running_as < _MANAGER_RUNNING_AS_MAX);
253 if (!(m = new0(Manager, 1)))
256 dual_timestamp_get(&m->startup_timestamp);
258 m->running_as = running_as;
259 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
260 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
261 m->pin_cgroupfs_fd = -1;
262 m->idle_pipe[0] = m->idle_pipe[1] = -1;
268 m->signal_watch.fd = m->mount_watch.fd = m->udev_watch.fd = m->epoll_fd = m->dev_autofs_fd = m->swap_watch.fd = -1;
269 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
271 m->environment = strv_copy(environ);
275 manager_strip_environment(m);
277 if (running_as == MANAGER_SYSTEM) {
278 m->default_controllers = strv_new("cpu", NULL);
279 if (!m->default_controllers)
283 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
286 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
289 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
292 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
295 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
298 if ((m->epoll_fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
301 if ((r = lookup_paths_init(&m->lookup_paths, m->running_as, true)) < 0)
304 if ((r = manager_setup_signals(m)) < 0)
307 if ((r = manager_setup_cgroup(m)) < 0)
310 if ((r = manager_setup_notify(m)) < 0)
313 /* Try to connect to the busses, if possible. */
314 if ((r = bus_init(m, running_as != MANAGER_SYSTEM)) < 0)
318 if ((m->audit_fd = audit_open()) < 0 &&
319 /* If the kernel lacks netlink or audit support,
320 * don't worry about it. */
321 errno != EAFNOSUPPORT && errno != EPROTONOSUPPORT)
322 log_error("Failed to connect to audit log: %m");
325 m->taint_usr = dir_is_empty("/usr") > 0;
335 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
341 while ((u = m->cleanup_queue)) {
342 assert(u->in_cleanup_queue);
352 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
353 GC_OFFSET_UNSURE, /* No clue */
354 GC_OFFSET_GOOD, /* We still need this unit */
355 GC_OFFSET_BAD, /* We don't need this unit anymore */
359 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
366 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
367 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
368 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
371 if (u->in_cleanup_queue)
374 if (unit_check_gc(u))
377 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
381 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
382 unit_gc_sweep(other, gc_marker);
384 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
387 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
394 /* We were unable to find anything out about this entry, so
395 * let's investigate it later */
396 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
397 unit_add_to_gc_queue(u);
401 /* We definitely know that this one is not useful anymore, so
402 * let's mark it for deletion */
403 u->gc_marker = gc_marker + GC_OFFSET_BAD;
404 unit_add_to_cleanup_queue(u);
408 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
411 static unsigned manager_dispatch_gc_queue(Manager *m) {
418 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
419 (m->gc_queue_timestamp <= 0 ||
420 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
423 log_debug("Running GC...");
425 m->gc_marker += _GC_OFFSET_MAX;
426 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
429 gc_marker = m->gc_marker;
431 while ((u = m->gc_queue)) {
432 assert(u->in_gc_queue);
434 unit_gc_sweep(u, gc_marker);
436 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
437 u->in_gc_queue = false;
441 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
442 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
443 log_debug("Collecting %s", u->id);
444 u->gc_marker = gc_marker + GC_OFFSET_BAD;
445 unit_add_to_cleanup_queue(u);
449 m->n_in_gc_queue = 0;
450 m->gc_queue_timestamp = 0;
455 static void manager_clear_jobs_and_units(Manager *m) {
460 while ((u = hashmap_first(m->units)))
463 manager_dispatch_cleanup_queue(m);
465 assert(!m->load_queue);
466 assert(!m->run_queue);
467 assert(!m->dbus_unit_queue);
468 assert(!m->dbus_job_queue);
469 assert(!m->cleanup_queue);
470 assert(!m->gc_queue);
472 assert(hashmap_isempty(m->jobs));
473 assert(hashmap_isempty(m->units));
476 void manager_free(Manager *m) {
481 manager_clear_jobs_and_units(m);
483 for (c = 0; c < _UNIT_TYPE_MAX; c++)
484 if (unit_vtable[c]->shutdown)
485 unit_vtable[c]->shutdown(m);
487 /* If we reexecute ourselves, we keep the root cgroup
489 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
491 manager_undo_generators(m);
495 hashmap_free(m->units);
496 hashmap_free(m->jobs);
497 hashmap_free(m->watch_pids);
498 hashmap_free(m->watch_bus);
500 if (m->epoll_fd >= 0)
501 close_nointr_nofail(m->epoll_fd);
502 if (m->signal_watch.fd >= 0)
503 close_nointr_nofail(m->signal_watch.fd);
504 if (m->notify_watch.fd >= 0)
505 close_nointr_nofail(m->notify_watch.fd);
508 if (m->audit_fd >= 0)
509 audit_close(m->audit_fd);
512 free(m->notify_socket);
514 lookup_paths_free(&m->lookup_paths);
515 strv_free(m->environment);
517 strv_free(m->default_controllers);
519 hashmap_free(m->cgroup_bondings);
520 set_free_free(m->unit_path_cache);
522 close_pipe(m->idle_pipe);
527 int manager_enumerate(Manager *m) {
533 /* Let's ask every type to load all units from disk/kernel
534 * that it might know */
535 for (c = 0; c < _UNIT_TYPE_MAX; c++)
536 if (unit_vtable[c]->enumerate)
537 if ((q = unit_vtable[c]->enumerate(m)) < 0)
540 manager_dispatch_load_queue(m);
544 int manager_coldplug(Manager *m) {
552 /* Then, let's set up their initial state. */
553 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
559 if ((q = unit_coldplug(u)) < 0)
566 static void manager_build_unit_path_cache(Manager *m) {
573 set_free_free(m->unit_path_cache);
575 if (!(m->unit_path_cache = set_new(string_hash_func, string_compare_func))) {
576 log_error("Failed to allocate unit path cache.");
580 /* This simply builds a list of files we know exist, so that
581 * we don't always have to go to disk */
583 STRV_FOREACH(i, m->lookup_paths.unit_path) {
586 if (!(d = opendir(*i))) {
587 log_error("Failed to open directory: %m");
591 while ((de = readdir(d))) {
594 if (ignore_file(de->d_name))
597 p = join(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
603 if ((r = set_put(m->unit_path_cache, p)) < 0) {
616 log_error("Failed to build unit path cache: %s", strerror(-r));
618 set_free_free(m->unit_path_cache);
619 m->unit_path_cache = NULL;
625 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
630 manager_run_generators(m);
632 manager_build_unit_path_cache(m);
634 /* If we will deserialize make sure that during enumeration
635 * this is already known, so we increase the counter here
640 /* First, enumerate what we can from all config files */
641 r = manager_enumerate(m);
643 /* Second, deserialize if there is something to deserialize */
645 if ((q = manager_deserialize(m, serialization, fds)) < 0)
648 /* Third, fire things up! */
649 if ((q = manager_coldplug(m)) < 0)
653 assert(m->n_reloading > 0);
660 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
665 assert(type < _JOB_TYPE_MAX);
667 assert(mode < _JOB_MODE_MAX);
669 if (mode == JOB_ISOLATE && type != JOB_START) {
670 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
674 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
675 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
679 log_debug("Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
681 job_type_collapse(&type, unit);
683 tr = transaction_new();
687 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
688 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
689 mode == JOB_IGNORE_DEPENDENCIES, e);
693 if (mode == JOB_ISOLATE) {
694 r = transaction_add_isolate_jobs(tr, m);
699 r = transaction_activate(tr, m, mode, e);
703 log_debug("Enqueued job %s/%s as %u", unit->id, job_type_to_string(type), (unsigned) tr->anchor_job->id);
706 *_ret = tr->anchor_job;
708 transaction_free(tr);
712 transaction_abort(tr);
713 transaction_free(tr);
717 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
722 assert(type < _JOB_TYPE_MAX);
724 assert(mode < _JOB_MODE_MAX);
726 if ((r = manager_load_unit(m, name, NULL, NULL, &unit)) < 0)
729 return manager_add_job(m, type, unit, mode, override, e, _ret);
732 Job *manager_get_job(Manager *m, uint32_t id) {
735 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
738 Unit *manager_get_unit(Manager *m, const char *name) {
742 return hashmap_get(m->units, name);
745 unsigned manager_dispatch_load_queue(Manager *m) {
751 /* Make sure we are not run recursively */
752 if (m->dispatching_load_queue)
755 m->dispatching_load_queue = true;
757 /* Dispatches the load queue. Takes a unit from the queue and
758 * tries to load its data until the queue is empty */
760 while ((u = m->load_queue)) {
761 assert(u->in_load_queue);
767 m->dispatching_load_queue = false;
771 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
777 assert(name || path);
779 /* This will prepare the unit for loading, but not actually
780 * load anything from disk. */
782 if (path && !is_path(path)) {
783 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
788 name = file_name_from_path(path);
790 t = unit_name_to_type(name);
792 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid_no_type(name, false)) {
793 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
797 ret = manager_get_unit(m, name);
803 ret = unit_new(m, unit_vtable[t]->object_size);
808 ret->fragment_path = strdup(path);
809 if (!ret->fragment_path) {
815 if ((r = unit_add_name(ret, name)) < 0) {
820 unit_add_to_load_queue(ret);
821 unit_add_to_dbus_queue(ret);
822 unit_add_to_gc_queue(ret);
830 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
835 /* This will load the service information files, but not actually
836 * start any services or anything. */
838 if ((r = manager_load_unit_prepare(m, name, path, e, _ret)) != 0)
841 manager_dispatch_load_queue(m);
844 *_ret = unit_follow_merge(*_ret);
849 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
856 HASHMAP_FOREACH(j, s->jobs, i)
857 job_dump(j, f, prefix);
860 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
868 HASHMAP_FOREACH_KEY(u, t, s->units, i)
870 unit_dump(u, f, prefix);
873 void manager_clear_jobs(Manager *m) {
878 while ((j = hashmap_first(m->jobs)))
879 /* No need to recurse. We're cancelling all jobs. */
880 job_finish_and_invalidate(j, JOB_CANCELED, false);
883 unsigned manager_dispatch_run_queue(Manager *m) {
887 if (m->dispatching_run_queue)
890 m->dispatching_run_queue = true;
892 while ((j = m->run_queue)) {
893 assert(j->installed);
894 assert(j->in_run_queue);
896 job_run_and_invalidate(j);
900 m->dispatching_run_queue = false;
904 unsigned manager_dispatch_dbus_queue(Manager *m) {
911 if (m->dispatching_dbus_queue)
914 m->dispatching_dbus_queue = true;
916 while ((u = m->dbus_unit_queue)) {
917 assert(u->in_dbus_queue);
919 bus_unit_send_change_signal(u);
923 while ((j = m->dbus_job_queue)) {
924 assert(j->in_dbus_queue);
926 bus_job_send_change_signal(j);
930 m->dispatching_dbus_queue = false;
934 static int manager_process_notify_fd(Manager *m) {
941 struct msghdr msghdr;
945 struct cmsghdr cmsghdr;
946 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
952 iovec.iov_base = buf;
953 iovec.iov_len = sizeof(buf)-1;
957 msghdr.msg_iov = &iovec;
958 msghdr.msg_iovlen = 1;
959 msghdr.msg_control = &control;
960 msghdr.msg_controllen = sizeof(control);
962 if ((n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT)) <= 0) {
966 if (errno == EAGAIN || errno == EINTR)
972 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
973 control.cmsghdr.cmsg_level != SOL_SOCKET ||
974 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
975 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
976 log_warning("Received notify message without credentials. Ignoring.");
980 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
982 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid))))
983 if (!(u = cgroup_unit_by_pid(m, ucred->pid))) {
984 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
988 assert((size_t) n < sizeof(buf));
990 if (!(tags = strv_split(buf, "\n\r")))
993 log_debug("Got notification message for unit %s", u->id);
995 if (UNIT_VTABLE(u)->notify_message)
996 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1004 static int manager_dispatch_sigchld(Manager *m) {
1014 /* First we call waitd() for a PID and do not reap the
1015 * zombie. That way we can still access /proc/$PID for
1016 * it while it is a zombie. */
1017 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1019 if (errno == ECHILD)
1031 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1034 get_process_comm(si.si_pid, &name);
1035 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1039 /* Let's flush any message the dying child might still
1040 * have queued for us. This ensures that the process
1041 * still exists in /proc so that we can figure out
1042 * which cgroup and hence unit it belongs to. */
1043 if ((r = manager_process_notify_fd(m)) < 0)
1046 /* And now figure out the unit this belongs to */
1047 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid))))
1048 u = cgroup_unit_by_pid(m, si.si_pid);
1050 /* And now, we actually reap the zombie. */
1051 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1058 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1061 log_debug("Child %lu died (code=%s, status=%i/%s)",
1062 (long unsigned) si.si_pid,
1063 sigchld_code_to_string(si.si_code),
1065 strna(si.si_code == CLD_EXITED
1066 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1067 : signal_to_string(si.si_status)));
1072 log_debug("Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1074 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1075 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1081 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1085 dbus_error_init(&error);
1087 log_debug("Activating special unit %s", name);
1089 if ((r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL)) < 0)
1090 log_error("Failed to enqueue %s job: %s", name, bus_error(&error, r));
1092 dbus_error_free(&error);
1097 static int manager_process_signal_fd(Manager *m) {
1099 struct signalfd_siginfo sfsi;
1100 bool sigchld = false;
1105 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
1110 if (errno == EINTR || errno == EAGAIN)
1116 if (sfsi.ssi_pid > 0) {
1119 get_process_comm(sfsi.ssi_pid, &p);
1121 log_debug("Received SIG%s from PID %lu (%s).",
1122 signal_to_string(sfsi.ssi_signo),
1123 (unsigned long) sfsi.ssi_pid, strna(p));
1126 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1128 switch (sfsi.ssi_signo) {
1135 if (m->running_as == MANAGER_SYSTEM) {
1136 /* This is for compatibility with the
1137 * original sysvinit */
1138 m->exit_code = MANAGER_REEXECUTE;
1145 if (m->running_as == MANAGER_SYSTEM) {
1146 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1150 /* Run the exit target if there is one, if not, just exit. */
1151 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1152 m->exit_code = MANAGER_EXIT;
1159 if (m->running_as == MANAGER_SYSTEM)
1160 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1162 /* This is a nop on non-init */
1166 if (m->running_as == MANAGER_SYSTEM)
1167 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1169 /* This is a nop on non-init */
1175 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1177 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1178 log_info("Trying to reconnect to bus...");
1182 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1183 log_info("Loading D-Bus service...");
1184 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1195 if (!(f = open_memstream(&dump, &size))) {
1196 log_warning("Failed to allocate memory stream.");
1200 manager_dump_units(m, f, "\t");
1201 manager_dump_jobs(m, f, "\t");
1206 log_warning("Failed to write status stream");
1211 log_dump(LOG_INFO, dump);
1218 m->exit_code = MANAGER_RELOAD;
1223 /* Starting SIGRTMIN+0 */
1224 static const char * const target_table[] = {
1225 [0] = SPECIAL_DEFAULT_TARGET,
1226 [1] = SPECIAL_RESCUE_TARGET,
1227 [2] = SPECIAL_EMERGENCY_TARGET,
1228 [3] = SPECIAL_HALT_TARGET,
1229 [4] = SPECIAL_POWEROFF_TARGET,
1230 [5] = SPECIAL_REBOOT_TARGET,
1231 [6] = SPECIAL_KEXEC_TARGET
1234 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1235 static const ManagerExitCode code_table[] = {
1237 [1] = MANAGER_POWEROFF,
1238 [2] = MANAGER_REBOOT,
1242 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1243 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1244 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1245 manager_start_target(m, target_table[idx],
1246 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1250 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1251 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1252 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1256 switch (sfsi.ssi_signo - SIGRTMIN) {
1259 log_debug("Enabling showing of status.");
1260 manager_set_show_status(m, true);
1264 log_debug("Disabling showing of status.");
1265 manager_set_show_status(m, false);
1269 log_set_max_level(LOG_DEBUG);
1270 log_notice("Setting log level to debug.");
1274 log_set_max_level(LOG_INFO);
1275 log_notice("Setting log level to info.");
1279 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1280 log_notice("Setting log target to journal-or-kmsg.");
1284 log_set_target(LOG_TARGET_CONSOLE);
1285 log_notice("Setting log target to console.");
1289 log_set_target(LOG_TARGET_KMSG);
1290 log_notice("Setting log target to kmsg.");
1294 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1295 log_notice("Setting log target to syslog-or-kmsg.");
1299 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1306 return manager_dispatch_sigchld(m);
1311 static int process_event(Manager *m, struct epoll_event *ev) {
1318 assert_se(w = ev->data.ptr);
1320 if (w->type == WATCH_INVALID)
1327 /* An incoming signal? */
1328 if (ev->events != EPOLLIN)
1331 if ((r = manager_process_signal_fd(m)) < 0)
1338 /* An incoming daemon notification event? */
1339 if (ev->events != EPOLLIN)
1342 if ((r = manager_process_notify_fd(m)) < 0)
1349 /* Some fd event, to be dispatched to the units */
1350 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1353 case WATCH_UNIT_TIMER:
1354 case WATCH_JOB_TIMER: {
1358 /* Some timer event, to be dispatched to the units */
1359 if ((k = read(w->fd, &v, sizeof(v))) != sizeof(v)) {
1361 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1364 return k < 0 ? -errno : -EIO;
1367 if (w->type == WATCH_UNIT_TIMER)
1368 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1370 job_timer_event(w->data.job, v, w);
1375 /* Some mount table change, intended for the mount subsystem */
1376 mount_fd_event(m, ev->events);
1380 /* Some swap table change, intended for the swap subsystem */
1381 swap_fd_event(m, ev->events);
1385 /* Some notification from udev, intended for the device subsystem */
1386 device_fd_event(m, ev->events);
1389 case WATCH_DBUS_WATCH:
1390 bus_watch_event(m, w, ev->events);
1393 case WATCH_DBUS_TIMEOUT:
1394 bus_timeout_event(m, w, ev->events);
1398 log_error("event type=%i", w->type);
1399 assert_not_reached("Unknown epoll event type.");
1405 int manager_loop(Manager *m) {
1408 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1411 m->exit_code = MANAGER_RUNNING;
1413 /* Release the path cache */
1414 set_free_free(m->unit_path_cache);
1415 m->unit_path_cache = NULL;
1417 manager_check_finished(m);
1419 /* There might still be some zombies hanging around from
1420 * before we were exec()'ed. Leat's reap them */
1421 r = manager_dispatch_sigchld(m);
1425 while (m->exit_code == MANAGER_RUNNING) {
1426 struct epoll_event event;
1430 if (m->runtime_watchdog > 0 && m->running_as == MANAGER_SYSTEM)
1433 if (!ratelimit_test(&rl)) {
1434 /* Yay, something is going seriously wrong, pause a little */
1435 log_warning("Looping too fast. Throttling execution a little.");
1440 if (manager_dispatch_load_queue(m) > 0)
1443 if (manager_dispatch_run_queue(m) > 0)
1446 if (bus_dispatch(m) > 0)
1449 if (manager_dispatch_cleanup_queue(m) > 0)
1452 if (manager_dispatch_gc_queue(m) > 0)
1455 if (manager_dispatch_dbus_queue(m) > 0)
1458 if (swap_dispatch_reload(m) > 0)
1461 /* Sleep for half the watchdog time */
1462 if (m->runtime_watchdog > 0 && m->running_as == MANAGER_SYSTEM) {
1463 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1469 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1481 r = process_event(m, &event);
1486 return m->exit_code;
1489 int manager_get_unit_from_dbus_path(Manager *m, const char *s, Unit **_u) {
1497 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1500 if (!(n = bus_path_unescape(s+31)))
1503 u = manager_get_unit(m, n);
1514 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1523 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1526 if ((r = safe_atou(s + 30, &id)) < 0)
1529 if (!(j = manager_get_job(m, id)))
1537 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1542 if (m->audit_fd < 0)
1545 /* Don't generate audit events if the service was already
1546 * started and we're just deserializing */
1547 if (m->n_reloading > 0)
1550 if (m->running_as != MANAGER_SYSTEM)
1553 if (u->type != UNIT_SERVICE)
1556 if (!(p = unit_name_to_prefix_and_instance(u->id))) {
1557 log_error("Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1561 if (audit_log_user_comm_message(m->audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1562 if (errno == EPERM) {
1563 /* We aren't allowed to send audit messages?
1564 * Then let's not retry again. */
1565 audit_close(m->audit_fd);
1568 log_warning("Failed to send audit message: %m");
1576 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1578 union sockaddr_union sa;
1580 char *message = NULL;
1582 /* Don't generate plymouth events if the service was already
1583 * started and we're just deserializing */
1584 if (m->n_reloading > 0)
1587 if (m->running_as != MANAGER_SYSTEM)
1590 if (u->type != UNIT_SERVICE &&
1591 u->type != UNIT_MOUNT &&
1592 u->type != UNIT_SWAP)
1595 /* We set SOCK_NONBLOCK here so that we rather drop the
1596 * message then wait for plymouth */
1597 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1598 log_error("socket() failed: %m");
1603 sa.sa.sa_family = AF_UNIX;
1604 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1605 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1607 if (errno != EPIPE &&
1610 errno != ECONNREFUSED &&
1611 errno != ECONNRESET &&
1612 errno != ECONNABORTED)
1613 log_error("connect() failed: %m");
1618 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1619 log_error("Out of memory");
1624 if (write(fd, message, n + 1) != n + 1) {
1626 if (errno != EPIPE &&
1629 errno != ECONNREFUSED &&
1630 errno != ECONNRESET &&
1631 errno != ECONNABORTED)
1632 log_error("Failed to write Plymouth message: %m");
1639 close_nointr_nofail(fd);
1644 void manager_dispatch_bus_name_owner_changed(
1647 const char* old_owner,
1648 const char *new_owner) {
1655 if (!(u = hashmap_get(m->watch_bus, name)))
1658 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1661 void manager_dispatch_bus_query_pid_done(
1672 if (!(u = hashmap_get(m->watch_bus, name)))
1675 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1678 int manager_open_serialization(Manager *m, FILE **_f) {
1686 if (m->running_as == MANAGER_SYSTEM)
1687 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1689 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1694 saved_umask = umask(0077);
1695 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1705 log_debug("Serializing state to %s", path);
1708 if (!(f = fdopen(fd, "w+")))
1716 int manager_serialize(Manager *m, FILE *f, FDSet *fds) {
1728 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1729 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1731 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1732 dual_timestamp_serialize(f, "startup-timestamp", &m->startup_timestamp);
1733 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1737 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1741 if (!unit_can_serialize(u))
1748 if ((r = unit_serialize(u, f, fds)) < 0) {
1754 assert(m->n_reloading > 0);
1760 r = bus_fdset_add_all(m, fds);
1767 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1773 log_debug("Deserializing state...");
1778 char line[LINE_MAX], *l;
1780 if (!fgets(line, sizeof(line), f)) {
1795 if (startswith(l, "current-job-id=")) {
1798 if (safe_atou32(l+15, &id) < 0)
1799 log_debug("Failed to parse current job id value %s", l+15);
1801 m->current_job_id = MAX(m->current_job_id, id);
1802 } else if (startswith(l, "taint-usr=")) {
1805 if ((b = parse_boolean(l+10)) < 0)
1806 log_debug("Failed to parse taint /usr flag %s", l+10);
1808 m->taint_usr = m->taint_usr || b;
1809 } else if (startswith(l, "initrd-timestamp="))
1810 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1811 else if (startswith(l, "startup-timestamp="))
1812 dual_timestamp_deserialize(l+18, &m->startup_timestamp);
1813 else if (startswith(l, "finish-timestamp="))
1814 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1816 log_debug("Unknown serialization item '%s'", l);
1821 char name[UNIT_NAME_MAX+2];
1824 if (!fgets(name, sizeof(name), f)) {
1835 if ((r = manager_load_unit(m, strstrip(name), NULL, NULL, &u)) < 0)
1838 if ((r = unit_deserialize(u, f, fds)) < 0)
1848 assert(m->n_reloading > 0);
1854 int manager_reload(Manager *m) {
1861 if ((r = manager_open_serialization(m, &f)) < 0)
1866 if (!(fds = fdset_new())) {
1872 if ((r = manager_serialize(m, f, fds)) < 0) {
1877 if (fseeko(f, 0, SEEK_SET) < 0) {
1883 /* From here on there is no way back. */
1884 manager_clear_jobs_and_units(m);
1885 manager_undo_generators(m);
1887 /* Find new unit paths */
1888 lookup_paths_free(&m->lookup_paths);
1889 if ((q = lookup_paths_init(&m->lookup_paths, m->running_as, true)) < 0)
1892 manager_run_generators(m);
1894 manager_build_unit_path_cache(m);
1896 /* First, enumerate what we can from all config files */
1897 if ((q = manager_enumerate(m)) < 0)
1900 /* Second, deserialize our stored data */
1901 if ((q = manager_deserialize(m, f, fds)) < 0)
1907 /* Third, fire things up! */
1908 if ((q = manager_coldplug(m)) < 0)
1911 assert(m->n_reloading > 0);
1924 bool manager_is_booting_or_shutting_down(Manager *m) {
1929 /* Is the initial job still around? */
1930 if (manager_get_job(m, m->default_unit_job_id))
1933 /* Is there a job for the shutdown target? */
1934 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
1941 void manager_reset_failed(Manager *m) {
1947 HASHMAP_FOREACH(u, m->units, i)
1948 unit_reset_failed(u);
1951 bool manager_unit_pending_inactive(Manager *m, const char *name) {
1957 /* Returns true if the unit is inactive or going down */
1958 if (!(u = manager_get_unit(m, name)))
1961 return unit_pending_inactive(u);
1964 void manager_check_finished(Manager *m) {
1965 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
1966 usec_t kernel_usec, initrd_usec, userspace_usec, total_usec;
1970 if (hashmap_size(m->jobs) > 0)
1973 /* Notify Type=idle units that we are done now */
1974 close_pipe(m->idle_pipe);
1976 if (dual_timestamp_is_set(&m->finish_timestamp))
1979 dual_timestamp_get(&m->finish_timestamp);
1981 if (m->running_as == MANAGER_SYSTEM && detect_container(NULL) <= 0) {
1983 userspace_usec = m->finish_timestamp.monotonic - m->startup_timestamp.monotonic;
1984 total_usec = m->finish_timestamp.monotonic;
1986 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
1988 kernel_usec = m->initrd_timestamp.monotonic;
1989 initrd_usec = m->startup_timestamp.monotonic - m->initrd_timestamp.monotonic;
1991 log_info("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
1992 format_timespan(kernel, sizeof(kernel), kernel_usec),
1993 format_timespan(initrd, sizeof(initrd), initrd_usec),
1994 format_timespan(userspace, sizeof(userspace), userspace_usec),
1995 format_timespan(sum, sizeof(sum), total_usec));
1997 kernel_usec = m->startup_timestamp.monotonic;
2000 log_info("Startup finished in %s (kernel) + %s (userspace) = %s.",
2001 format_timespan(kernel, sizeof(kernel), kernel_usec),
2002 format_timespan(userspace, sizeof(userspace), userspace_usec),
2003 format_timespan(sum, sizeof(sum), total_usec));
2006 userspace_usec = initrd_usec = kernel_usec = 0;
2007 total_usec = m->finish_timestamp.monotonic - m->startup_timestamp.monotonic;
2009 log_debug("Startup finished in %s.",
2010 format_timespan(sum, sizeof(sum), total_usec));
2013 bus_broadcast_finished(m, kernel_usec, initrd_usec, userspace_usec, total_usec);
2016 "READY=1\nSTATUS=Startup finished in %s.",
2017 format_timespan(sum, sizeof(sum), total_usec));
2020 void manager_run_generators(Manager *m) {
2022 const char *generator_path;
2023 const char *argv[3];
2028 generator_path = m->running_as == MANAGER_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2029 if (!(d = opendir(generator_path))) {
2031 if (errno == ENOENT)
2034 log_error("Failed to enumerate generator directory: %m");
2038 if (!m->generator_unit_path) {
2040 char user_path[] = "/tmp/systemd-generator-XXXXXX";
2042 if (m->running_as == MANAGER_SYSTEM && getpid() == 1) {
2043 p = "/run/systemd/generator";
2045 if (mkdir_p(p, 0755) < 0) {
2046 log_error("Failed to create generator directory: %m");
2051 if (!(p = mkdtemp(user_path))) {
2052 log_error("Failed to create generator directory: %m");
2057 if (!(m->generator_unit_path = strdup(p))) {
2058 log_error("Failed to allocate generator unit path.");
2063 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2064 argv[1] = m->generator_unit_path;
2068 execute_directory(generator_path, d, (char**) argv);
2071 if (rmdir(m->generator_unit_path) >= 0) {
2072 /* Uh? we were able to remove this dir? I guess that
2073 * means the directory was empty, hence let's shortcut
2076 free(m->generator_unit_path);
2077 m->generator_unit_path = NULL;
2081 if (!strv_find(m->lookup_paths.unit_path, m->generator_unit_path)) {
2084 if (!(l = strv_append(m->lookup_paths.unit_path, m->generator_unit_path))) {
2085 log_error("Failed to add generator directory to unit search path: %m");
2089 strv_free(m->lookup_paths.unit_path);
2090 m->lookup_paths.unit_path = l;
2092 log_debug("Added generator unit path %s to search path.", m->generator_unit_path);
2100 void manager_undo_generators(Manager *m) {
2103 if (!m->generator_unit_path)
2106 strv_remove(m->lookup_paths.unit_path, m->generator_unit_path);
2107 rm_rf(m->generator_unit_path, false, true, false);
2109 free(m->generator_unit_path);
2110 m->generator_unit_path = NULL;
2113 int manager_set_default_controllers(Manager *m, char **controllers) {
2118 l = strv_copy(controllers);
2122 strv_free(m->default_controllers);
2123 m->default_controllers = l;
2125 cg_shorten_controllers(m->default_controllers);
2130 void manager_recheck_journal(Manager *m) {
2135 if (m->running_as != MANAGER_SYSTEM)
2138 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2139 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2140 log_close_journal();
2144 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2145 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2146 log_close_journal();
2150 /* Hmm, OK, so the socket is fully up and the service is up
2151 * too, then let's make use of the thing. */
2155 void manager_set_show_status(Manager *m, bool b) {
2158 if (m->running_as != MANAGER_SYSTEM)
2164 touch("/run/systemd/show-status");
2166 unlink("/run/systemd/show-status");
2169 bool manager_get_show_status(Manager *m) {
2172 if (m->running_as != MANAGER_SYSTEM)
2178 /* If Plymouth is running make sure we show the status, so
2179 * that there's something nice to see when people press Esc */
2181 return plymouth_running();
2184 static const char* const manager_running_as_table[_MANAGER_RUNNING_AS_MAX] = {
2185 [MANAGER_SYSTEM] = "system",
2186 [MANAGER_USER] = "user"
2189 DEFINE_STRING_TABLE_LOOKUP(manager_running_as, ManagerRunningAs);