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;
267 m->signal_watch.fd = m->mount_watch.fd = m->udev_watch.fd = m->epoll_fd = m->dev_autofs_fd = m->swap_watch.fd = -1;
268 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
270 m->environment = strv_copy(environ);
274 manager_strip_environment(m);
276 if (running_as == MANAGER_SYSTEM) {
277 m->default_controllers = strv_new("cpu", NULL);
278 if (!m->default_controllers)
282 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
285 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
288 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
291 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
294 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
297 if ((m->epoll_fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
300 if ((r = lookup_paths_init(&m->lookup_paths, m->running_as, true)) < 0)
303 if ((r = manager_setup_signals(m)) < 0)
306 if ((r = manager_setup_cgroup(m)) < 0)
309 if ((r = manager_setup_notify(m)) < 0)
312 /* Try to connect to the busses, if possible. */
313 if ((r = bus_init(m, running_as != MANAGER_SYSTEM)) < 0)
317 if ((m->audit_fd = audit_open()) < 0 &&
318 /* If the kernel lacks netlink or audit support,
319 * don't worry about it. */
320 errno != EAFNOSUPPORT && errno != EPROTONOSUPPORT)
321 log_error("Failed to connect to audit log: %m");
324 m->taint_usr = dir_is_empty("/usr") > 0;
334 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
340 while ((u = m->cleanup_queue)) {
341 assert(u->in_cleanup_queue);
351 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
352 GC_OFFSET_UNSURE, /* No clue */
353 GC_OFFSET_GOOD, /* We still need this unit */
354 GC_OFFSET_BAD, /* We don't need this unit anymore */
358 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
365 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
366 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
367 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
370 if (u->in_cleanup_queue)
373 if (unit_check_gc(u))
376 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
380 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
381 unit_gc_sweep(other, gc_marker);
383 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
386 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
393 /* We were unable to find anything out about this entry, so
394 * let's investigate it later */
395 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
396 unit_add_to_gc_queue(u);
400 /* We definitely know that this one is not useful anymore, so
401 * let's mark it for deletion */
402 u->gc_marker = gc_marker + GC_OFFSET_BAD;
403 unit_add_to_cleanup_queue(u);
407 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
410 static unsigned manager_dispatch_gc_queue(Manager *m) {
417 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
418 (m->gc_queue_timestamp <= 0 ||
419 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
422 log_debug("Running GC...");
424 m->gc_marker += _GC_OFFSET_MAX;
425 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
428 gc_marker = m->gc_marker;
430 while ((u = m->gc_queue)) {
431 assert(u->in_gc_queue);
433 unit_gc_sweep(u, gc_marker);
435 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
436 u->in_gc_queue = false;
440 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
441 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
442 log_debug("Collecting %s", u->id);
443 u->gc_marker = gc_marker + GC_OFFSET_BAD;
444 unit_add_to_cleanup_queue(u);
448 m->n_in_gc_queue = 0;
449 m->gc_queue_timestamp = 0;
454 static void manager_clear_jobs_and_units(Manager *m) {
459 while ((u = hashmap_first(m->units)))
462 manager_dispatch_cleanup_queue(m);
464 assert(!m->load_queue);
465 assert(!m->run_queue);
466 assert(!m->dbus_unit_queue);
467 assert(!m->dbus_job_queue);
468 assert(!m->cleanup_queue);
469 assert(!m->gc_queue);
471 assert(hashmap_isempty(m->jobs));
472 assert(hashmap_isempty(m->units));
475 void manager_free(Manager *m) {
480 manager_clear_jobs_and_units(m);
482 for (c = 0; c < _UNIT_TYPE_MAX; c++)
483 if (unit_vtable[c]->shutdown)
484 unit_vtable[c]->shutdown(m);
486 /* If we reexecute ourselves, we keep the root cgroup
488 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
490 manager_undo_generators(m);
494 hashmap_free(m->units);
495 hashmap_free(m->jobs);
496 hashmap_free(m->watch_pids);
497 hashmap_free(m->watch_bus);
499 if (m->epoll_fd >= 0)
500 close_nointr_nofail(m->epoll_fd);
501 if (m->signal_watch.fd >= 0)
502 close_nointr_nofail(m->signal_watch.fd);
503 if (m->notify_watch.fd >= 0)
504 close_nointr_nofail(m->notify_watch.fd);
507 if (m->audit_fd >= 0)
508 audit_close(m->audit_fd);
511 free(m->notify_socket);
513 lookup_paths_free(&m->lookup_paths);
514 strv_free(m->environment);
516 strv_free(m->default_controllers);
518 hashmap_free(m->cgroup_bondings);
519 set_free_free(m->unit_path_cache);
524 int manager_enumerate(Manager *m) {
530 /* Let's ask every type to load all units from disk/kernel
531 * that it might know */
532 for (c = 0; c < _UNIT_TYPE_MAX; c++)
533 if (unit_vtable[c]->enumerate)
534 if ((q = unit_vtable[c]->enumerate(m)) < 0)
537 manager_dispatch_load_queue(m);
541 int manager_coldplug(Manager *m) {
549 /* Then, let's set up their initial state. */
550 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
556 if ((q = unit_coldplug(u)) < 0)
563 static void manager_build_unit_path_cache(Manager *m) {
570 set_free_free(m->unit_path_cache);
572 if (!(m->unit_path_cache = set_new(string_hash_func, string_compare_func))) {
573 log_error("Failed to allocate unit path cache.");
577 /* This simply builds a list of files we know exist, so that
578 * we don't always have to go to disk */
580 STRV_FOREACH(i, m->lookup_paths.unit_path) {
583 if (!(d = opendir(*i))) {
584 log_error("Failed to open directory: %m");
588 while ((de = readdir(d))) {
591 if (ignore_file(de->d_name))
594 p = join(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
600 if ((r = set_put(m->unit_path_cache, p)) < 0) {
613 log_error("Failed to build unit path cache: %s", strerror(-r));
615 set_free_free(m->unit_path_cache);
616 m->unit_path_cache = NULL;
622 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
627 manager_run_generators(m);
629 manager_build_unit_path_cache(m);
631 /* If we will deserialize make sure that during enumeration
632 * this is already known, so we increase the counter here
637 /* First, enumerate what we can from all config files */
638 r = manager_enumerate(m);
640 /* Second, deserialize if there is something to deserialize */
642 if ((q = manager_deserialize(m, serialization, fds)) < 0)
645 /* Third, fire things up! */
646 if ((q = manager_coldplug(m)) < 0)
650 assert(m->n_reloading > 0);
657 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
662 assert(type < _JOB_TYPE_MAX);
664 assert(mode < _JOB_MODE_MAX);
666 if (mode == JOB_ISOLATE && type != JOB_START) {
667 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
671 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
672 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
676 log_debug("Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
678 tr = transaction_new();
682 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
683 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
684 mode == JOB_IGNORE_DEPENDENCIES, e);
688 if (mode == JOB_ISOLATE) {
689 r = transaction_add_isolate_jobs(tr, m);
694 r = transaction_activate(tr, m, mode, e);
698 log_debug("Enqueued job %s/%s as %u", unit->id, job_type_to_string(type), (unsigned) tr->anchor_job->id);
701 *_ret = tr->anchor_job;
703 transaction_free(tr);
707 transaction_abort(tr);
708 transaction_free(tr);
712 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
717 assert(type < _JOB_TYPE_MAX);
719 assert(mode < _JOB_MODE_MAX);
721 if ((r = manager_load_unit(m, name, NULL, NULL, &unit)) < 0)
724 return manager_add_job(m, type, unit, mode, override, e, _ret);
727 Job *manager_get_job(Manager *m, uint32_t id) {
730 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
733 Unit *manager_get_unit(Manager *m, const char *name) {
737 return hashmap_get(m->units, name);
740 unsigned manager_dispatch_load_queue(Manager *m) {
746 /* Make sure we are not run recursively */
747 if (m->dispatching_load_queue)
750 m->dispatching_load_queue = true;
752 /* Dispatches the load queue. Takes a unit from the queue and
753 * tries to load its data until the queue is empty */
755 while ((u = m->load_queue)) {
756 assert(u->in_load_queue);
762 m->dispatching_load_queue = false;
766 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
772 assert(name || path);
774 /* This will prepare the unit for loading, but not actually
775 * load anything from disk. */
777 if (path && !is_path(path)) {
778 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
783 name = file_name_from_path(path);
785 t = unit_name_to_type(name);
787 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid_no_type(name, false)) {
788 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
792 ret = manager_get_unit(m, name);
798 ret = unit_new(m, unit_vtable[t]->object_size);
803 ret->fragment_path = strdup(path);
804 if (!ret->fragment_path) {
810 if ((r = unit_add_name(ret, name)) < 0) {
815 unit_add_to_load_queue(ret);
816 unit_add_to_dbus_queue(ret);
817 unit_add_to_gc_queue(ret);
825 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
830 /* This will load the service information files, but not actually
831 * start any services or anything. */
833 if ((r = manager_load_unit_prepare(m, name, path, e, _ret)) != 0)
836 manager_dispatch_load_queue(m);
839 *_ret = unit_follow_merge(*_ret);
844 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
851 HASHMAP_FOREACH(j, s->jobs, i)
852 job_dump(j, f, prefix);
855 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
863 HASHMAP_FOREACH_KEY(u, t, s->units, i)
865 unit_dump(u, f, prefix);
868 void manager_clear_jobs(Manager *m) {
873 while ((j = hashmap_first(m->jobs)))
874 job_finish_and_invalidate(j, JOB_CANCELED);
877 unsigned manager_dispatch_run_queue(Manager *m) {
881 if (m->dispatching_run_queue)
884 m->dispatching_run_queue = true;
886 while ((j = m->run_queue)) {
887 assert(j->installed);
888 assert(j->in_run_queue);
890 job_run_and_invalidate(j);
894 m->dispatching_run_queue = false;
898 unsigned manager_dispatch_dbus_queue(Manager *m) {
905 if (m->dispatching_dbus_queue)
908 m->dispatching_dbus_queue = true;
910 while ((u = m->dbus_unit_queue)) {
911 assert(u->in_dbus_queue);
913 bus_unit_send_change_signal(u);
917 while ((j = m->dbus_job_queue)) {
918 assert(j->in_dbus_queue);
920 bus_job_send_change_signal(j);
924 m->dispatching_dbus_queue = false;
928 static int manager_process_notify_fd(Manager *m) {
935 struct msghdr msghdr;
939 struct cmsghdr cmsghdr;
940 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
946 iovec.iov_base = buf;
947 iovec.iov_len = sizeof(buf)-1;
951 msghdr.msg_iov = &iovec;
952 msghdr.msg_iovlen = 1;
953 msghdr.msg_control = &control;
954 msghdr.msg_controllen = sizeof(control);
956 if ((n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT)) <= 0) {
960 if (errno == EAGAIN || errno == EINTR)
966 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
967 control.cmsghdr.cmsg_level != SOL_SOCKET ||
968 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
969 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
970 log_warning("Received notify message without credentials. Ignoring.");
974 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
976 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid))))
977 if (!(u = cgroup_unit_by_pid(m, ucred->pid))) {
978 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
982 assert((size_t) n < sizeof(buf));
984 if (!(tags = strv_split(buf, "\n\r")))
987 log_debug("Got notification message for unit %s", u->id);
989 if (UNIT_VTABLE(u)->notify_message)
990 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
998 static int manager_dispatch_sigchld(Manager *m) {
1008 /* First we call waitd() for a PID and do not reap the
1009 * zombie. That way we can still access /proc/$PID for
1010 * it while it is a zombie. */
1011 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1013 if (errno == ECHILD)
1025 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1028 get_process_comm(si.si_pid, &name);
1029 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1033 /* Let's flush any message the dying child might still
1034 * have queued for us. This ensures that the process
1035 * still exists in /proc so that we can figure out
1036 * which cgroup and hence unit it belongs to. */
1037 if ((r = manager_process_notify_fd(m)) < 0)
1040 /* And now figure out the unit this belongs to */
1041 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid))))
1042 u = cgroup_unit_by_pid(m, si.si_pid);
1044 /* And now, we actually reap the zombie. */
1045 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1052 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1055 log_debug("Child %lu died (code=%s, status=%i/%s)",
1056 (long unsigned) si.si_pid,
1057 sigchld_code_to_string(si.si_code),
1059 strna(si.si_code == CLD_EXITED
1060 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1061 : signal_to_string(si.si_status)));
1066 log_debug("Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1068 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1069 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1075 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1079 dbus_error_init(&error);
1081 log_debug("Activating special unit %s", name);
1083 if ((r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL)) < 0)
1084 log_error("Failed to enqueue %s job: %s", name, bus_error(&error, r));
1086 dbus_error_free(&error);
1091 static int manager_process_signal_fd(Manager *m) {
1093 struct signalfd_siginfo sfsi;
1094 bool sigchld = false;
1099 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
1104 if (errno == EINTR || errno == EAGAIN)
1110 if (sfsi.ssi_pid > 0) {
1113 get_process_comm(sfsi.ssi_pid, &p);
1115 log_debug("Received SIG%s from PID %lu (%s).",
1116 signal_to_string(sfsi.ssi_signo),
1117 (unsigned long) sfsi.ssi_pid, strna(p));
1120 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1122 switch (sfsi.ssi_signo) {
1129 if (m->running_as == MANAGER_SYSTEM) {
1130 /* This is for compatibility with the
1131 * original sysvinit */
1132 m->exit_code = MANAGER_REEXECUTE;
1139 if (m->running_as == MANAGER_SYSTEM) {
1140 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1144 /* Run the exit target if there is one, if not, just exit. */
1145 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1146 m->exit_code = MANAGER_EXIT;
1153 if (m->running_as == MANAGER_SYSTEM)
1154 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1156 /* This is a nop on non-init */
1160 if (m->running_as == MANAGER_SYSTEM)
1161 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1163 /* This is a nop on non-init */
1169 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1171 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1172 log_info("Trying to reconnect to bus...");
1176 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1177 log_info("Loading D-Bus service...");
1178 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1189 if (!(f = open_memstream(&dump, &size))) {
1190 log_warning("Failed to allocate memory stream.");
1194 manager_dump_units(m, f, "\t");
1195 manager_dump_jobs(m, f, "\t");
1200 log_warning("Failed to write status stream");
1205 log_dump(LOG_INFO, dump);
1212 m->exit_code = MANAGER_RELOAD;
1217 /* Starting SIGRTMIN+0 */
1218 static const char * const target_table[] = {
1219 [0] = SPECIAL_DEFAULT_TARGET,
1220 [1] = SPECIAL_RESCUE_TARGET,
1221 [2] = SPECIAL_EMERGENCY_TARGET,
1222 [3] = SPECIAL_HALT_TARGET,
1223 [4] = SPECIAL_POWEROFF_TARGET,
1224 [5] = SPECIAL_REBOOT_TARGET,
1225 [6] = SPECIAL_KEXEC_TARGET
1228 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1229 static const ManagerExitCode code_table[] = {
1231 [1] = MANAGER_POWEROFF,
1232 [2] = MANAGER_REBOOT,
1236 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1237 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1238 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1239 manager_start_target(m, target_table[idx],
1240 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1244 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1245 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1246 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1250 switch (sfsi.ssi_signo - SIGRTMIN) {
1253 log_debug("Enabling showing of status.");
1254 manager_set_show_status(m, true);
1258 log_debug("Disabling showing of status.");
1259 manager_set_show_status(m, false);
1263 log_set_max_level(LOG_DEBUG);
1264 log_notice("Setting log level to debug.");
1268 log_set_max_level(LOG_INFO);
1269 log_notice("Setting log level to info.");
1273 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1274 log_notice("Setting log target to journal-or-kmsg.");
1278 log_set_target(LOG_TARGET_CONSOLE);
1279 log_notice("Setting log target to console.");
1283 log_set_target(LOG_TARGET_KMSG);
1284 log_notice("Setting log target to kmsg.");
1288 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1289 log_notice("Setting log target to syslog-or-kmsg.");
1293 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1300 return manager_dispatch_sigchld(m);
1305 static int process_event(Manager *m, struct epoll_event *ev) {
1312 assert_se(w = ev->data.ptr);
1314 if (w->type == WATCH_INVALID)
1321 /* An incoming signal? */
1322 if (ev->events != EPOLLIN)
1325 if ((r = manager_process_signal_fd(m)) < 0)
1332 /* An incoming daemon notification event? */
1333 if (ev->events != EPOLLIN)
1336 if ((r = manager_process_notify_fd(m)) < 0)
1343 /* Some fd event, to be dispatched to the units */
1344 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1347 case WATCH_UNIT_TIMER:
1348 case WATCH_JOB_TIMER: {
1352 /* Some timer event, to be dispatched to the units */
1353 if ((k = read(w->fd, &v, sizeof(v))) != sizeof(v)) {
1355 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1358 return k < 0 ? -errno : -EIO;
1361 if (w->type == WATCH_UNIT_TIMER)
1362 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1364 job_timer_event(w->data.job, v, w);
1369 /* Some mount table change, intended for the mount subsystem */
1370 mount_fd_event(m, ev->events);
1374 /* Some swap table change, intended for the swap subsystem */
1375 swap_fd_event(m, ev->events);
1379 /* Some notification from udev, intended for the device subsystem */
1380 device_fd_event(m, ev->events);
1383 case WATCH_DBUS_WATCH:
1384 bus_watch_event(m, w, ev->events);
1387 case WATCH_DBUS_TIMEOUT:
1388 bus_timeout_event(m, w, ev->events);
1392 log_error("event type=%i", w->type);
1393 assert_not_reached("Unknown epoll event type.");
1399 int manager_loop(Manager *m) {
1402 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1405 m->exit_code = MANAGER_RUNNING;
1407 /* Release the path cache */
1408 set_free_free(m->unit_path_cache);
1409 m->unit_path_cache = NULL;
1411 manager_check_finished(m);
1413 /* There might still be some zombies hanging around from
1414 * before we were exec()'ed. Leat's reap them */
1415 r = manager_dispatch_sigchld(m);
1419 while (m->exit_code == MANAGER_RUNNING) {
1420 struct epoll_event event;
1424 if (m->runtime_watchdog > 0 && m->running_as == MANAGER_SYSTEM)
1427 if (!ratelimit_test(&rl)) {
1428 /* Yay, something is going seriously wrong, pause a little */
1429 log_warning("Looping too fast. Throttling execution a little.");
1434 if (manager_dispatch_load_queue(m) > 0)
1437 if (manager_dispatch_run_queue(m) > 0)
1440 if (bus_dispatch(m) > 0)
1443 if (manager_dispatch_cleanup_queue(m) > 0)
1446 if (manager_dispatch_gc_queue(m) > 0)
1449 if (manager_dispatch_dbus_queue(m) > 0)
1452 if (swap_dispatch_reload(m) > 0)
1455 /* Sleep for half the watchdog time */
1456 if (m->runtime_watchdog > 0 && m->running_as == MANAGER_SYSTEM) {
1457 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1463 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1475 r = process_event(m, &event);
1480 return m->exit_code;
1483 int manager_get_unit_from_dbus_path(Manager *m, const char *s, Unit **_u) {
1491 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1494 if (!(n = bus_path_unescape(s+31)))
1497 u = manager_get_unit(m, n);
1508 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1517 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1520 if ((r = safe_atou(s + 30, &id)) < 0)
1523 if (!(j = manager_get_job(m, id)))
1531 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1536 if (m->audit_fd < 0)
1539 /* Don't generate audit events if the service was already
1540 * started and we're just deserializing */
1541 if (m->n_reloading > 0)
1544 if (m->running_as != MANAGER_SYSTEM)
1547 if (u->type != UNIT_SERVICE)
1550 if (!(p = unit_name_to_prefix_and_instance(u->id))) {
1551 log_error("Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1555 if (audit_log_user_comm_message(m->audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1556 if (errno == EPERM) {
1557 /* We aren't allowed to send audit messages?
1558 * Then let's not retry again. */
1559 audit_close(m->audit_fd);
1562 log_warning("Failed to send audit message: %m");
1570 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1572 union sockaddr_union sa;
1574 char *message = NULL;
1576 /* Don't generate plymouth events if the service was already
1577 * started and we're just deserializing */
1578 if (m->n_reloading > 0)
1581 if (m->running_as != MANAGER_SYSTEM)
1584 if (u->type != UNIT_SERVICE &&
1585 u->type != UNIT_MOUNT &&
1586 u->type != UNIT_SWAP)
1589 /* We set SOCK_NONBLOCK here so that we rather drop the
1590 * message then wait for plymouth */
1591 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1592 log_error("socket() failed: %m");
1597 sa.sa.sa_family = AF_UNIX;
1598 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1599 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1601 if (errno != EPIPE &&
1604 errno != ECONNREFUSED &&
1605 errno != ECONNRESET &&
1606 errno != ECONNABORTED)
1607 log_error("connect() failed: %m");
1612 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1613 log_error("Out of memory");
1618 if (write(fd, message, n + 1) != n + 1) {
1620 if (errno != EPIPE &&
1623 errno != ECONNREFUSED &&
1624 errno != ECONNRESET &&
1625 errno != ECONNABORTED)
1626 log_error("Failed to write Plymouth message: %m");
1633 close_nointr_nofail(fd);
1638 void manager_dispatch_bus_name_owner_changed(
1641 const char* old_owner,
1642 const char *new_owner) {
1649 if (!(u = hashmap_get(m->watch_bus, name)))
1652 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1655 void manager_dispatch_bus_query_pid_done(
1666 if (!(u = hashmap_get(m->watch_bus, name)))
1669 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1672 int manager_open_serialization(Manager *m, FILE **_f) {
1680 if (m->running_as == MANAGER_SYSTEM)
1681 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1683 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1688 saved_umask = umask(0077);
1689 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1699 log_debug("Serializing state to %s", path);
1702 if (!(f = fdopen(fd, "w+")))
1710 int manager_serialize(Manager *m, FILE *f, FDSet *fds) {
1722 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1723 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1725 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1726 dual_timestamp_serialize(f, "startup-timestamp", &m->startup_timestamp);
1727 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1731 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1735 if (!unit_can_serialize(u))
1742 if ((r = unit_serialize(u, f, fds)) < 0) {
1748 assert(m->n_reloading > 0);
1754 r = bus_fdset_add_all(m, fds);
1761 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1767 log_debug("Deserializing state...");
1772 char line[LINE_MAX], *l;
1774 if (!fgets(line, sizeof(line), f)) {
1789 if (startswith(l, "current-job-id=")) {
1792 if (safe_atou32(l+15, &id) < 0)
1793 log_debug("Failed to parse current job id value %s", l+15);
1795 m->current_job_id = MAX(m->current_job_id, id);
1796 } else if (startswith(l, "taint-usr=")) {
1799 if ((b = parse_boolean(l+10)) < 0)
1800 log_debug("Failed to parse taint /usr flag %s", l+10);
1802 m->taint_usr = m->taint_usr || b;
1803 } else if (startswith(l, "initrd-timestamp="))
1804 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1805 else if (startswith(l, "startup-timestamp="))
1806 dual_timestamp_deserialize(l+18, &m->startup_timestamp);
1807 else if (startswith(l, "finish-timestamp="))
1808 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1810 log_debug("Unknown serialization item '%s'", l);
1815 char name[UNIT_NAME_MAX+2];
1818 if (!fgets(name, sizeof(name), f)) {
1829 if ((r = manager_load_unit(m, strstrip(name), NULL, NULL, &u)) < 0)
1832 if ((r = unit_deserialize(u, f, fds)) < 0)
1842 assert(m->n_reloading > 0);
1848 int manager_reload(Manager *m) {
1855 if ((r = manager_open_serialization(m, &f)) < 0)
1860 if (!(fds = fdset_new())) {
1866 if ((r = manager_serialize(m, f, fds)) < 0) {
1871 if (fseeko(f, 0, SEEK_SET) < 0) {
1877 /* From here on there is no way back. */
1878 manager_clear_jobs_and_units(m);
1879 manager_undo_generators(m);
1881 /* Find new unit paths */
1882 lookup_paths_free(&m->lookup_paths);
1883 if ((q = lookup_paths_init(&m->lookup_paths, m->running_as, true)) < 0)
1886 manager_run_generators(m);
1888 manager_build_unit_path_cache(m);
1890 /* First, enumerate what we can from all config files */
1891 if ((q = manager_enumerate(m)) < 0)
1894 /* Second, deserialize our stored data */
1895 if ((q = manager_deserialize(m, f, fds)) < 0)
1901 /* Third, fire things up! */
1902 if ((q = manager_coldplug(m)) < 0)
1905 assert(m->n_reloading > 0);
1918 bool manager_is_booting_or_shutting_down(Manager *m) {
1923 /* Is the initial job still around? */
1924 if (manager_get_job(m, m->default_unit_job_id))
1927 /* Is there a job for the shutdown target? */
1928 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
1935 void manager_reset_failed(Manager *m) {
1941 HASHMAP_FOREACH(u, m->units, i)
1942 unit_reset_failed(u);
1945 bool manager_unit_pending_inactive(Manager *m, const char *name) {
1951 /* Returns true if the unit is inactive or going down */
1952 if (!(u = manager_get_unit(m, name)))
1955 return unit_pending_inactive(u);
1958 void manager_check_finished(Manager *m) {
1959 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
1960 usec_t kernel_usec, initrd_usec, userspace_usec, total_usec;
1964 if (dual_timestamp_is_set(&m->finish_timestamp))
1967 if (hashmap_size(m->jobs) > 0)
1970 dual_timestamp_get(&m->finish_timestamp);
1972 if (m->running_as == MANAGER_SYSTEM && detect_container(NULL) <= 0) {
1974 userspace_usec = m->finish_timestamp.monotonic - m->startup_timestamp.monotonic;
1975 total_usec = m->finish_timestamp.monotonic;
1977 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
1979 kernel_usec = m->initrd_timestamp.monotonic;
1980 initrd_usec = m->startup_timestamp.monotonic - m->initrd_timestamp.monotonic;
1982 log_info("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
1983 format_timespan(kernel, sizeof(kernel), kernel_usec),
1984 format_timespan(initrd, sizeof(initrd), initrd_usec),
1985 format_timespan(userspace, sizeof(userspace), userspace_usec),
1986 format_timespan(sum, sizeof(sum), total_usec));
1988 kernel_usec = m->startup_timestamp.monotonic;
1991 log_info("Startup finished in %s (kernel) + %s (userspace) = %s.",
1992 format_timespan(kernel, sizeof(kernel), kernel_usec),
1993 format_timespan(userspace, sizeof(userspace), userspace_usec),
1994 format_timespan(sum, sizeof(sum), total_usec));
1997 userspace_usec = initrd_usec = kernel_usec = 0;
1998 total_usec = m->finish_timestamp.monotonic - m->startup_timestamp.monotonic;
2000 log_debug("Startup finished in %s.",
2001 format_timespan(sum, sizeof(sum), total_usec));
2004 bus_broadcast_finished(m, kernel_usec, initrd_usec, userspace_usec, total_usec);
2007 "READY=1\nSTATUS=Startup finished in %s.",
2008 format_timespan(sum, sizeof(sum), total_usec));
2011 void manager_run_generators(Manager *m) {
2013 const char *generator_path;
2014 const char *argv[3];
2019 generator_path = m->running_as == MANAGER_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2020 if (!(d = opendir(generator_path))) {
2022 if (errno == ENOENT)
2025 log_error("Failed to enumerate generator directory: %m");
2029 if (!m->generator_unit_path) {
2031 char user_path[] = "/tmp/systemd-generator-XXXXXX";
2033 if (m->running_as == MANAGER_SYSTEM && getpid() == 1) {
2034 p = "/run/systemd/generator";
2036 if (mkdir_p(p, 0755) < 0) {
2037 log_error("Failed to create generator directory: %m");
2042 if (!(p = mkdtemp(user_path))) {
2043 log_error("Failed to create generator directory: %m");
2048 if (!(m->generator_unit_path = strdup(p))) {
2049 log_error("Failed to allocate generator unit path.");
2054 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2055 argv[1] = m->generator_unit_path;
2059 execute_directory(generator_path, d, (char**) argv);
2062 if (rmdir(m->generator_unit_path) >= 0) {
2063 /* Uh? we were able to remove this dir? I guess that
2064 * means the directory was empty, hence let's shortcut
2067 free(m->generator_unit_path);
2068 m->generator_unit_path = NULL;
2072 if (!strv_find(m->lookup_paths.unit_path, m->generator_unit_path)) {
2075 if (!(l = strv_append(m->lookup_paths.unit_path, m->generator_unit_path))) {
2076 log_error("Failed to add generator directory to unit search path: %m");
2080 strv_free(m->lookup_paths.unit_path);
2081 m->lookup_paths.unit_path = l;
2083 log_debug("Added generator unit path %s to search path.", m->generator_unit_path);
2091 void manager_undo_generators(Manager *m) {
2094 if (!m->generator_unit_path)
2097 strv_remove(m->lookup_paths.unit_path, m->generator_unit_path);
2098 rm_rf(m->generator_unit_path, false, true, false);
2100 free(m->generator_unit_path);
2101 m->generator_unit_path = NULL;
2104 int manager_set_default_controllers(Manager *m, char **controllers) {
2109 l = strv_copy(controllers);
2113 strv_free(m->default_controllers);
2114 m->default_controllers = l;
2116 cg_shorten_controllers(m->default_controllers);
2121 void manager_recheck_journal(Manager *m) {
2126 if (m->running_as != MANAGER_SYSTEM)
2129 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2130 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2131 log_close_journal();
2135 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2136 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2137 log_close_journal();
2141 /* Hmm, OK, so the socket is fully up and the service is up
2142 * too, then let's make use of the thing. */
2146 void manager_set_show_status(Manager *m, bool b) {
2149 if (m->running_as != MANAGER_SYSTEM)
2155 touch("/run/systemd/show-status");
2157 unlink("/run/systemd/show-status");
2160 bool manager_get_show_status(Manager *m) {
2163 if (m->running_as != MANAGER_SYSTEM)
2169 /* If Plymouth is running make sure we show the status, so
2170 * that there's something nice to see when people press Esc */
2172 return plymouth_running();
2175 static const char* const manager_running_as_table[_MANAGER_RUNNING_AS_MAX] = {
2176 [MANAGER_SYSTEM] = "system",
2177 [MANAGER_USER] = "user"
2180 DEFINE_STRING_TABLE_LOOKUP(manager_running_as, ManagerRunningAs);