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>
53 #include "ratelimit.h"
55 #include "mount-setup.h"
56 #include "unit-name.h"
57 #include "dbus-unit.h"
60 #include "path-lookup.h"
62 #include "bus-errors.h"
63 #include "exit-status.h"
67 /* As soon as 16 units are in our GC queue, make sure to run a gc sweep */
68 #define GC_QUEUE_ENTRIES_MAX 16
70 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
71 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
73 /* Where clients shall send notification messages to */
74 #define NOTIFY_SOCKET_SYSTEM "/run/systemd/notify"
75 #define NOTIFY_SOCKET_USER "@/org/freedesktop/systemd1/notify"
77 static int manager_setup_notify(Manager *m) {
80 struct sockaddr_un un;
82 struct epoll_event ev;
88 m->notify_watch.type = WATCH_NOTIFY;
89 if ((m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
90 log_error("Failed to allocate notification socket: %m");
95 sa.sa.sa_family = AF_UNIX;
98 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET_USER "/%llu", random_ull());
100 unlink(NOTIFY_SOCKET_SYSTEM);
101 strncpy(sa.un.sun_path, NOTIFY_SOCKET_SYSTEM, sizeof(sa.un.sun_path));
104 if (sa.un.sun_path[0] == '@')
105 sa.un.sun_path[0] = 0;
108 r = bind(m->notify_watch.fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
112 log_error("bind() failed: %m");
116 if (setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0) {
117 log_error("SO_PASSCRED failed: %m");
123 ev.data.ptr = &m->notify_watch;
125 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev) < 0)
128 if (sa.un.sun_path[0] == 0)
129 sa.un.sun_path[0] = '@';
131 if (!(m->notify_socket = strdup(sa.un.sun_path)))
134 log_debug("Using notification socket %s", m->notify_socket);
139 static int enable_special_signals(Manager *m) {
144 /* Enable that we get SIGINT on control-alt-del */
145 if (reboot(RB_DISABLE_CAD) < 0)
146 log_warning("Failed to enable ctrl-alt-del handling: %m");
148 if ((fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC)) < 0)
149 log_warning("Failed to open /dev/tty0: %m");
151 /* Enable that we get SIGWINCH on kbrequest */
152 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
153 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
155 close_nointr_nofail(fd);
161 static int manager_setup_signals(Manager *m) {
163 struct epoll_event ev;
168 /* We are not interested in SIGSTOP and friends. */
170 sa.sa_handler = SIG_DFL;
171 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
172 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
174 assert_se(sigemptyset(&mask) == 0);
176 sigset_add_many(&mask,
177 SIGCHLD, /* Child died */
178 SIGTERM, /* Reexecute daemon */
179 SIGHUP, /* Reload configuration */
180 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
181 SIGUSR2, /* systemd: dump status */
182 SIGINT, /* Kernel sends us this on control-alt-del */
183 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
184 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
185 SIGRTMIN+0, /* systemd: start default.target */
186 SIGRTMIN+1, /* systemd: isolate rescue.target */
187 SIGRTMIN+2, /* systemd: isolate emergency.target */
188 SIGRTMIN+3, /* systemd: start halt.target */
189 SIGRTMIN+4, /* systemd: start poweroff.target */
190 SIGRTMIN+5, /* systemd: start reboot.target */
191 SIGRTMIN+6, /* systemd: start kexec.target */
192 SIGRTMIN+13, /* systemd: Immediate halt */
193 SIGRTMIN+14, /* systemd: Immediate poweroff */
194 SIGRTMIN+15, /* systemd: Immediate reboot */
195 SIGRTMIN+16, /* systemd: Immediate kexec */
196 SIGRTMIN+20, /* systemd: enable status messages */
197 SIGRTMIN+21, /* systemd: disable status messages */
198 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
199 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
200 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
201 SIGRTMIN+27, /* systemd: set log target to console */
202 SIGRTMIN+28, /* systemd: set log target to kmsg */
203 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
205 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
207 m->signal_watch.type = WATCH_SIGNAL;
208 if ((m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC)) < 0)
213 ev.data.ptr = &m->signal_watch;
215 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
218 if (m->running_as == MANAGER_SYSTEM)
219 return enable_special_signals(m);
224 static void manager_strip_environment(Manager *m) {
227 /* Remove variables from the inherited set that are part of
228 * the container interface:
229 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
230 strv_remove_prefix(m->environment, "container=");
231 strv_remove_prefix(m->environment, "container_");
233 /* Remove variables from the inherited set that are part of
234 * the initrd interface:
235 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
236 strv_remove_prefix(m->environment, "RD_");
239 int manager_new(ManagerRunningAs running_as, Manager **_m) {
244 assert(running_as >= 0);
245 assert(running_as < _MANAGER_RUNNING_AS_MAX);
247 if (!(m = new0(Manager, 1)))
250 dual_timestamp_get(&m->startup_timestamp);
252 m->running_as = running_as;
253 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
254 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
255 m->pin_cgroupfs_fd = -1;
261 m->signal_watch.fd = m->mount_watch.fd = m->udev_watch.fd = m->epoll_fd = m->dev_autofs_fd = m->swap_watch.fd = -1;
262 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
264 m->environment = strv_copy(environ);
268 manager_strip_environment(m);
270 if (running_as == MANAGER_SYSTEM) {
271 m->default_controllers = strv_new("cpu", NULL);
272 if (!m->default_controllers)
276 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
279 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
282 if (!(m->transaction_jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
285 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
288 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
291 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
294 if ((m->epoll_fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
297 if ((r = lookup_paths_init(&m->lookup_paths, m->running_as, true)) < 0)
300 if ((r = manager_setup_signals(m)) < 0)
303 if ((r = manager_setup_cgroup(m)) < 0)
306 if ((r = manager_setup_notify(m)) < 0)
309 /* Try to connect to the busses, if possible. */
310 if ((r = bus_init(m, running_as != MANAGER_SYSTEM)) < 0)
314 if ((m->audit_fd = audit_open()) < 0 &&
315 /* If the kernel lacks netlink or audit support,
316 * don't worry about it. */
317 errno != EAFNOSUPPORT && errno != EPROTONOSUPPORT)
318 log_error("Failed to connect to audit log: %m");
321 m->taint_usr = dir_is_empty("/usr") > 0;
331 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
337 while ((u = m->cleanup_queue)) {
338 assert(u->in_cleanup_queue);
348 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
349 GC_OFFSET_UNSURE, /* No clue */
350 GC_OFFSET_GOOD, /* We still need this unit */
351 GC_OFFSET_BAD, /* We don't need this unit anymore */
355 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
362 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
363 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
364 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
367 if (u->in_cleanup_queue)
370 if (unit_check_gc(u))
373 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
377 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
378 unit_gc_sweep(other, gc_marker);
380 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
383 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
390 /* We were unable to find anything out about this entry, so
391 * let's investigate it later */
392 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
393 unit_add_to_gc_queue(u);
397 /* We definitely know that this one is not useful anymore, so
398 * let's mark it for deletion */
399 u->gc_marker = gc_marker + GC_OFFSET_BAD;
400 unit_add_to_cleanup_queue(u);
404 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
407 static unsigned manager_dispatch_gc_queue(Manager *m) {
414 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
415 (m->gc_queue_timestamp <= 0 ||
416 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
419 log_debug("Running GC...");
421 m->gc_marker += _GC_OFFSET_MAX;
422 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
425 gc_marker = m->gc_marker;
427 while ((u = m->gc_queue)) {
428 assert(u->in_gc_queue);
430 unit_gc_sweep(u, gc_marker);
432 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
433 u->in_gc_queue = false;
437 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
438 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
439 log_debug("Collecting %s", u->id);
440 u->gc_marker = gc_marker + GC_OFFSET_BAD;
441 unit_add_to_cleanup_queue(u);
445 m->n_in_gc_queue = 0;
446 m->gc_queue_timestamp = 0;
451 static void manager_clear_jobs_and_units(Manager *m) {
457 while ((j = hashmap_first(m->transaction_jobs)))
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->transaction_jobs));
473 assert(hashmap_isempty(m->jobs));
474 assert(hashmap_isempty(m->units));
477 void manager_free(Manager *m) {
482 manager_clear_jobs_and_units(m);
484 for (c = 0; c < _UNIT_TYPE_MAX; c++)
485 if (unit_vtable[c]->shutdown)
486 unit_vtable[c]->shutdown(m);
488 /* If we reexecute ourselves, we keep the root cgroup
490 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
492 manager_undo_generators(m);
496 hashmap_free(m->units);
497 hashmap_free(m->jobs);
498 hashmap_free(m->transaction_jobs);
499 hashmap_free(m->watch_pids);
500 hashmap_free(m->watch_bus);
502 if (m->epoll_fd >= 0)
503 close_nointr_nofail(m->epoll_fd);
504 if (m->signal_watch.fd >= 0)
505 close_nointr_nofail(m->signal_watch.fd);
506 if (m->notify_watch.fd >= 0)
507 close_nointr_nofail(m->notify_watch.fd);
510 if (m->audit_fd >= 0)
511 audit_close(m->audit_fd);
514 free(m->notify_socket);
516 lookup_paths_free(&m->lookup_paths);
517 strv_free(m->environment);
519 strv_free(m->default_controllers);
521 hashmap_free(m->cgroup_bondings);
522 set_free_free(m->unit_path_cache);
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 static void transaction_delete_job(Manager *m, Job *j, bool delete_dependencies) {
664 /* Deletes one job from the transaction */
666 manager_transaction_unlink_job(m, j, delete_dependencies);
672 static void transaction_delete_unit(Manager *m, Unit *u) {
675 /* Deletes all jobs associated with a certain unit from the
678 while ((j = hashmap_get(m->transaction_jobs, u)))
679 transaction_delete_job(m, j, true);
682 static void transaction_clean_dependencies(Manager *m) {
688 /* Drops all dependencies of all installed jobs */
690 HASHMAP_FOREACH(j, m->jobs, i) {
691 while (j->subject_list)
692 job_dependency_free(j->subject_list);
693 while (j->object_list)
694 job_dependency_free(j->object_list);
697 assert(!m->transaction_anchor);
700 static void transaction_abort(Manager *m) {
705 while ((j = hashmap_first(m->transaction_jobs)))
707 transaction_delete_job(m, j, true);
711 assert(hashmap_isempty(m->transaction_jobs));
713 transaction_clean_dependencies(m);
716 static void transaction_find_jobs_that_matter_to_anchor(Manager *m, Job *j, unsigned generation) {
721 /* A recursive sweep through the graph that marks all units
722 * that matter to the anchor job, i.e. are directly or
723 * indirectly a dependency of the anchor job via paths that
724 * are fully marked as mattering. */
729 l = m->transaction_anchor;
731 LIST_FOREACH(subject, l, l) {
733 /* This link does not matter */
737 /* This unit has already been marked */
738 if (l->object->generation == generation)
741 l->object->matters_to_anchor = true;
742 l->object->generation = generation;
744 transaction_find_jobs_that_matter_to_anchor(m, l->object, generation);
748 static void transaction_merge_and_delete_job(Manager *m, Job *j, Job *other, JobType t) {
749 JobDependency *l, *last;
753 assert(j->unit == other->unit);
754 assert(!j->installed);
756 /* Merges 'other' into 'j' and then deletes j. */
759 j->state = JOB_WAITING;
760 j->override = j->override || other->override;
762 j->matters_to_anchor = j->matters_to_anchor || other->matters_to_anchor;
764 /* Patch us in as new owner of the JobDependency objects */
766 LIST_FOREACH(subject, l, other->subject_list) {
767 assert(l->subject == other);
772 /* Merge both lists */
774 last->subject_next = j->subject_list;
776 j->subject_list->subject_prev = last;
777 j->subject_list = other->subject_list;
780 /* Patch us in as new owner of the JobDependency objects */
782 LIST_FOREACH(object, l, other->object_list) {
783 assert(l->object == other);
788 /* Merge both lists */
790 last->object_next = j->object_list;
792 j->object_list->object_prev = last;
793 j->object_list = other->object_list;
796 /* Kill the other job */
797 other->subject_list = NULL;
798 other->object_list = NULL;
799 transaction_delete_job(m, other, true);
801 static bool job_is_conflicted_by(Job *j) {
806 /* Returns true if this job is pulled in by a least one
807 * ConflictedBy dependency. */
809 LIST_FOREACH(object, l, j->object_list)
816 static int delete_one_unmergeable_job(Manager *m, Job *j) {
821 /* Tries to delete one item in the linked list
822 * j->transaction_next->transaction_next->... that conflicts
823 * with another one, in an attempt to make an inconsistent
824 * transaction work. */
826 /* We rely here on the fact that if a merged with b does not
827 * merge with c, either a or b merge with c neither */
828 LIST_FOREACH(transaction, j, j)
829 LIST_FOREACH(transaction, k, j->transaction_next) {
832 /* Is this one mergeable? Then skip it */
833 if (job_type_is_mergeable(j->type, k->type))
836 /* Ok, we found two that conflict, let's see if we can
837 * drop one of them */
838 if (!j->matters_to_anchor && !k->matters_to_anchor) {
840 /* Both jobs don't matter, so let's
841 * find the one that is smarter to
842 * remove. Let's think positive and
843 * rather remove stops then starts --
844 * except if something is being
845 * stopped because it is conflicted by
846 * another unit in which case we
847 * rather remove the start. */
849 log_debug("Looking at job %s/%s conflicted_by=%s", j->unit->id, job_type_to_string(j->type), yes_no(j->type == JOB_STOP && job_is_conflicted_by(j)));
850 log_debug("Looking at job %s/%s conflicted_by=%s", k->unit->id, job_type_to_string(k->type), yes_no(k->type == JOB_STOP && job_is_conflicted_by(k)));
852 if (j->type == JOB_STOP) {
854 if (job_is_conflicted_by(j))
859 } else if (k->type == JOB_STOP) {
861 if (job_is_conflicted_by(k))
868 } else if (!j->matters_to_anchor)
870 else if (!k->matters_to_anchor)
875 /* Ok, we can drop one, so let's do so. */
876 log_debug("Fixing conflicting jobs by deleting job %s/%s", d->unit->id, job_type_to_string(d->type));
877 transaction_delete_job(m, d, true);
884 static int transaction_merge_jobs(Manager *m, DBusError *e) {
891 /* First step, check whether any of the jobs for one specific
892 * task conflict. If so, try to drop one of them. */
893 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
898 LIST_FOREACH(transaction, k, j->transaction_next) {
899 if (job_type_merge(&t, k->type) >= 0)
902 /* OK, we could not merge all jobs for this
903 * action. Let's see if we can get rid of one
906 if ((r = delete_one_unmergeable_job(m, j)) >= 0)
907 /* Ok, we managed to drop one, now
908 * let's ask our callers to call us
909 * again after garbage collecting */
912 /* We couldn't merge anything. Failure */
913 dbus_set_error(e, BUS_ERROR_TRANSACTION_JOBS_CONFLICTING, "Transaction contains conflicting jobs '%s' and '%s' for %s. Probably contradicting requirement dependencies configured.",
914 job_type_to_string(t), job_type_to_string(k->type), k->unit->id);
919 /* Second step, merge the jobs. */
920 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
924 /* Merge all transactions */
925 LIST_FOREACH(transaction, k, j->transaction_next)
926 assert_se(job_type_merge(&t, k->type) == 0);
928 /* If an active job is mergeable, merge it too */
930 job_type_merge(&t, j->unit->job->type); /* Might fail. Which is OK */
932 while ((k = j->transaction_next)) {
934 transaction_merge_and_delete_job(m, k, j, t);
937 transaction_merge_and_delete_job(m, j, k, t);
940 if (j->unit->job && !j->installed)
941 transaction_merge_and_delete_job(m, j, j->unit->job, t);
943 assert(!j->transaction_next);
944 assert(!j->transaction_prev);
950 static void transaction_drop_redundant(Manager *m) {
955 /* Goes through the transaction and removes all jobs that are
964 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
965 bool changes_something = false;
968 LIST_FOREACH(transaction, k, j) {
970 if (!job_is_anchor(k) &&
971 (k->installed || job_type_is_redundant(k->type, unit_active_state(k->unit))) &&
972 (!k->unit->job || !job_type_is_conflicting(k->type, k->unit->job->type)))
975 changes_something = true;
979 if (changes_something)
982 /* log_debug("Found redundant job %s/%s, dropping.", j->unit->id, job_type_to_string(j->type)); */
983 transaction_delete_job(m, j, false);
991 static bool unit_matters_to_anchor(Unit *u, Job *j) {
993 assert(!j->transaction_prev);
995 /* Checks whether at least one of the jobs for this unit
996 * matters to the anchor. */
998 LIST_FOREACH(transaction, j, j)
999 if (j->matters_to_anchor)
1005 static int transaction_verify_order_one(Manager *m, Job *j, Job *from, unsigned generation, DBusError *e) {
1012 assert(!j->transaction_prev);
1014 /* Does a recursive sweep through the ordering graph, looking
1015 * for a cycle. If we find cycle we try to break it. */
1017 /* Have we seen this before? */
1018 if (j->generation == generation) {
1021 /* If the marker is NULL we have been here already and
1022 * decided the job was loop-free from here. Hence
1023 * shortcut things and return right-away. */
1027 /* So, the marker is not NULL and we already have been
1028 * here. We have a cycle. Let's try to break it. We go
1029 * backwards in our path and try to find a suitable
1030 * job to remove. We use the marker to find our way
1031 * back, since smart how we are we stored our way back
1033 log_warning("Found ordering cycle on %s/%s", j->unit->id, job_type_to_string(j->type));
1036 for (k = from; k; k = ((k->generation == generation && k->marker != k) ? k->marker : NULL)) {
1038 log_info("Walked on cycle path to %s/%s", k->unit->id, job_type_to_string(k->type));
1042 !unit_matters_to_anchor(k->unit, k)) {
1043 /* Ok, we can drop this one, so let's
1048 /* Check if this in fact was the beginning of
1056 log_warning("Breaking ordering cycle by deleting job %s/%s", delete->unit->id, job_type_to_string(delete->type));
1057 transaction_delete_unit(m, delete->unit);
1061 log_error("Unable to break cycle");
1063 dbus_set_error(e, BUS_ERROR_TRANSACTION_ORDER_IS_CYCLIC, "Transaction order is cyclic. See system logs for details.");
1067 /* Make the marker point to where we come from, so that we can
1068 * find our way backwards if we want to break a cycle. We use
1069 * a special marker for the beginning: we point to
1071 j->marker = from ? from : j;
1072 j->generation = generation;
1074 /* We assume that the the dependencies are bidirectional, and
1075 * hence can ignore UNIT_AFTER */
1076 SET_FOREACH(u, j->unit->dependencies[UNIT_BEFORE], i) {
1079 /* Is there a job for this unit? */
1080 if (!(o = hashmap_get(m->transaction_jobs, u)))
1082 /* Ok, there is no job for this in the
1083 * transaction, but maybe there is already one
1088 if ((r = transaction_verify_order_one(m, o, j, generation, e)) < 0)
1092 /* Ok, let's backtrack, and remember that this entry is not on
1093 * our path anymore. */
1099 static int transaction_verify_order(Manager *m, unsigned *generation, DBusError *e) {
1108 /* Check if the ordering graph is cyclic. If it is, try to fix
1109 * that up by dropping one of the jobs. */
1111 g = (*generation)++;
1113 HASHMAP_FOREACH(j, m->transaction_jobs, i)
1114 if ((r = transaction_verify_order_one(m, j, NULL, g, e)) < 0)
1120 static void transaction_collect_garbage(Manager *m) {
1125 /* Drop jobs that are not required by any other job */
1133 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
1134 if (j->object_list) {
1135 /* log_debug("Keeping job %s/%s because of %s/%s", */
1136 /* j->unit->id, job_type_to_string(j->type), */
1137 /* j->object_list->subject ? j->object_list->subject->unit->id : "root", */
1138 /* j->object_list->subject ? job_type_to_string(j->object_list->subject->type) : "root"); */
1142 /* log_debug("Garbage collecting job %s/%s", j->unit->id, job_type_to_string(j->type)); */
1143 transaction_delete_job(m, j, true);
1151 static int transaction_is_destructive(Manager *m, DBusError *e) {
1157 /* Checks whether applying this transaction means that
1158 * existing jobs would be replaced */
1160 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
1163 assert(!j->transaction_prev);
1164 assert(!j->transaction_next);
1167 j->unit->job != j &&
1168 !job_type_is_superset(j->type, j->unit->job->type)) {
1170 dbus_set_error(e, BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE, "Transaction is destructive.");
1178 static void transaction_minimize_impact(Manager *m) {
1182 /* Drops all unnecessary jobs that reverse already active jobs
1183 * or that stop a running service. */
1191 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
1192 LIST_FOREACH(transaction, j, j) {
1193 bool stops_running_service, changes_existing_job;
1195 /* If it matters, we shouldn't drop it */
1196 if (j->matters_to_anchor)
1199 /* Would this stop a running service?
1200 * Would this change an existing job?
1201 * If so, let's drop this entry */
1203 stops_running_service =
1204 j->type == JOB_STOP && UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(j->unit));
1206 changes_existing_job =
1208 job_type_is_conflicting(j->type, j->unit->job->type);
1210 if (!stops_running_service && !changes_existing_job)
1213 if (stops_running_service)
1214 log_debug("%s/%s would stop a running service.", j->unit->id, job_type_to_string(j->type));
1216 if (changes_existing_job)
1217 log_debug("%s/%s would change existing job.", j->unit->id, job_type_to_string(j->type));
1219 /* Ok, let's get rid of this */
1220 log_debug("Deleting %s/%s to minimize impact.", j->unit->id, job_type_to_string(j->type));
1222 transaction_delete_job(m, j, true);
1234 static int transaction_apply(Manager *m, JobMode mode) {
1239 /* Moves the transaction jobs to the set of active jobs */
1241 if (mode == JOB_ISOLATE) {
1243 /* When isolating first kill all installed jobs which
1244 * aren't part of the new transaction */
1246 HASHMAP_FOREACH(j, m->jobs, i) {
1247 assert(j->installed);
1249 if (hashmap_get(m->transaction_jobs, j->unit))
1252 /* 'j' itself is safe to remove, but if other jobs
1253 are invalidated recursively, our iterator may become
1254 invalid and we need to start over. */
1255 if (job_finish_and_invalidate(j, JOB_CANCELED) > 0)
1260 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
1262 assert(!j->transaction_prev);
1263 assert(!j->transaction_next);
1268 if ((r = hashmap_put(m->jobs, UINT32_TO_PTR(j->id), j)) < 0)
1272 while ((j = hashmap_steal_first(m->transaction_jobs))) {
1274 /* log_debug("Skipping already installed job %s/%s as %u", j->unit->id, job_type_to_string(j->type), (unsigned) j->id); */
1279 job_free(j->unit->job);
1282 j->installed = true;
1283 m->n_installed_jobs ++;
1285 /* We're fully installed. Now let's free data we don't
1288 assert(!j->transaction_next);
1289 assert(!j->transaction_prev);
1291 job_add_to_run_queue(j);
1292 job_add_to_dbus_queue(j);
1295 log_debug("Installed new job %s/%s as %u", j->unit->id, job_type_to_string(j->type), (unsigned) j->id);
1298 /* As last step, kill all remaining job dependencies. */
1299 transaction_clean_dependencies(m);
1305 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
1309 hashmap_remove(m->jobs, UINT32_TO_PTR(j->id));
1315 static int transaction_activate(Manager *m, JobMode mode, DBusError *e) {
1317 unsigned generation = 1;
1321 /* This applies the changes recorded in transaction_jobs to
1322 * the actual list of jobs, if possible. */
1324 /* First step: figure out which jobs matter */
1325 transaction_find_jobs_that_matter_to_anchor(m, NULL, generation++);
1327 /* Second step: Try not to stop any running services if
1328 * we don't have to. Don't try to reverse running
1329 * jobs if we don't have to. */
1330 if (mode == JOB_FAIL)
1331 transaction_minimize_impact(m);
1333 /* Third step: Drop redundant jobs */
1334 transaction_drop_redundant(m);
1337 /* Fourth step: Let's remove unneeded jobs that might
1339 if (mode != JOB_ISOLATE)
1340 transaction_collect_garbage(m);
1342 /* Fifth step: verify order makes sense and correct
1343 * cycles if necessary and possible */
1344 if ((r = transaction_verify_order(m, &generation, e)) >= 0)
1348 log_warning("Requested transaction contains an unfixable cyclic ordering dependency: %s", bus_error(e, r));
1352 /* Let's see if the resulting transaction ordering
1353 * graph is still cyclic... */
1357 /* Sixth step: let's drop unmergeable entries if
1358 * necessary and possible, merge entries we can
1360 if ((r = transaction_merge_jobs(m, e)) >= 0)
1364 log_warning("Requested transaction contains unmergeable jobs: %s", bus_error(e, r));
1368 /* Seventh step: an entry got dropped, let's garbage
1369 * collect its dependencies. */
1370 if (mode != JOB_ISOLATE)
1371 transaction_collect_garbage(m);
1373 /* Let's see if the resulting transaction still has
1374 * unmergeable entries ... */
1377 /* Eights step: Drop redundant jobs again, if the merging now allows us to drop more. */
1378 transaction_drop_redundant(m);
1380 /* Ninth step: check whether we can actually apply this */
1381 if (mode == JOB_FAIL)
1382 if ((r = transaction_is_destructive(m, e)) < 0) {
1383 log_notice("Requested transaction contradicts existing jobs: %s", bus_error(e, r));
1387 /* Tenth step: apply changes */
1388 if ((r = transaction_apply(m, mode)) < 0) {
1389 log_warning("Failed to apply transaction: %s", strerror(-r));
1393 assert(hashmap_isempty(m->transaction_jobs));
1394 assert(!m->transaction_anchor);
1399 transaction_abort(m);
1403 static Job* transaction_add_one_job(Manager *m, JobType type, Unit *unit, bool override, bool *is_new) {
1409 /* Looks for an existing prospective job and returns that. If
1410 * it doesn't exist it is created and added to the prospective
1413 f = hashmap_get(m->transaction_jobs, unit);
1415 LIST_FOREACH(transaction, j, f) {
1416 assert(j->unit == unit);
1418 if (j->type == type) {
1425 if (unit->job && unit->job->type == type)
1427 else if (!(j = job_new(m, type, unit)))
1432 j->matters_to_anchor = false;
1433 j->override = override;
1435 LIST_PREPEND(Job, transaction, f, j);
1437 if (hashmap_replace(m->transaction_jobs, unit, f) < 0) {
1445 /* log_debug("Added job %s/%s to transaction.", unit->id, job_type_to_string(type)); */
1450 void manager_transaction_unlink_job(Manager *m, Job *j, bool delete_dependencies) {
1454 if (j->transaction_prev)
1455 j->transaction_prev->transaction_next = j->transaction_next;
1456 else if (j->transaction_next)
1457 hashmap_replace(m->transaction_jobs, j->unit, j->transaction_next);
1459 hashmap_remove_value(m->transaction_jobs, j->unit, j);
1461 if (j->transaction_next)
1462 j->transaction_next->transaction_prev = j->transaction_prev;
1464 j->transaction_prev = j->transaction_next = NULL;
1466 while (j->subject_list)
1467 job_dependency_free(j->subject_list);
1469 while (j->object_list) {
1470 Job *other = j->object_list->matters ? j->object_list->subject : NULL;
1472 job_dependency_free(j->object_list);
1474 if (other && delete_dependencies) {
1475 log_debug("Deleting job %s/%s as dependency of job %s/%s",
1476 other->unit->id, job_type_to_string(other->type),
1477 j->unit->id, job_type_to_string(j->type));
1478 transaction_delete_job(m, other, delete_dependencies);
1483 static int transaction_add_job_and_dependencies(
1491 bool ignore_requirements,
1502 assert(type < _JOB_TYPE_MAX);
1505 /* log_debug("Pulling in %s/%s from %s/%s", */
1506 /* unit->id, job_type_to_string(type), */
1507 /* by ? by->unit->id : "NA", */
1508 /* by ? job_type_to_string(by->type) : "NA"); */
1510 if (unit->load_state != UNIT_LOADED &&
1511 unit->load_state != UNIT_ERROR &&
1512 unit->load_state != UNIT_MASKED) {
1513 dbus_set_error(e, BUS_ERROR_LOAD_FAILED, "Unit %s is not loaded properly.", unit->id);
1517 if (type != JOB_STOP && unit->load_state == UNIT_ERROR) {
1518 dbus_set_error(e, BUS_ERROR_LOAD_FAILED,
1519 "Unit %s failed to load: %s. "
1520 "See system logs and 'systemctl status %s' for details.",
1522 strerror(-unit->load_error),
1527 if (type != JOB_STOP && unit->load_state == UNIT_MASKED) {
1528 dbus_set_error(e, BUS_ERROR_MASKED, "Unit %s is masked.", unit->id);
1532 if (!unit_job_is_applicable(unit, type)) {
1533 dbus_set_error(e, BUS_ERROR_JOB_TYPE_NOT_APPLICABLE, "Job type %s is not applicable for unit %s.", job_type_to_string(type), unit->id);
1537 /* First add the job. */
1538 if (!(ret = transaction_add_one_job(m, type, unit, override, &is_new)))
1541 ret->ignore_order = ret->ignore_order || ignore_order;
1543 /* Then, add a link to the job. */
1544 if (!job_dependency_new(by, ret, matters, conflicts))
1547 if (is_new && !ignore_requirements) {
1550 /* If we are following some other unit, make sure we
1551 * add all dependencies of everybody following. */
1552 if (unit_following_set(ret->unit, &following) > 0) {
1553 SET_FOREACH(dep, following, i)
1554 if ((r = transaction_add_job_and_dependencies(m, type, dep, ret, false, override, false, false, ignore_order, e, NULL)) < 0) {
1555 log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1561 set_free(following);
1564 /* Finally, recursively add in all dependencies. */
1565 if (type == JOB_START || type == JOB_RELOAD_OR_START) {
1566 SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUIRES], i)
1567 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, true, override, false, false, ignore_order, e, NULL)) < 0) {
1575 SET_FOREACH(dep, ret->unit->dependencies[UNIT_BIND_TO], i)
1576 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, true, override, false, false, ignore_order, e, NULL)) < 0) {
1585 SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1586 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, !override, override, false, false, ignore_order, e, NULL)) < 0) {
1587 log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1593 SET_FOREACH(dep, ret->unit->dependencies[UNIT_WANTS], i)
1594 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, false, false, false, false, ignore_order, e, NULL)) < 0) {
1595 log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1601 SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUISITE], i)
1602 if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_ACTIVE, dep, ret, true, override, false, false, ignore_order, e, NULL)) < 0) {
1611 SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1612 if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_ACTIVE, dep, ret, !override, override, false, false, ignore_order, e, NULL)) < 0) {
1613 log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1619 SET_FOREACH(dep, ret->unit->dependencies[UNIT_CONFLICTS], i)
1620 if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, dep, ret, true, override, true, false, ignore_order, e, NULL)) < 0) {
1629 SET_FOREACH(dep, ret->unit->dependencies[UNIT_CONFLICTED_BY], i)
1630 if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, dep, ret, false, override, false, false, ignore_order, e, NULL)) < 0) {
1631 log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1639 if (type == JOB_STOP || type == JOB_RESTART || type == JOB_TRY_RESTART) {
1641 SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUIRED_BY], i)
1642 if ((r = transaction_add_job_and_dependencies(m, type, dep, ret, true, override, false, false, ignore_order, e, NULL)) < 0) {
1651 SET_FOREACH(dep, ret->unit->dependencies[UNIT_BOUND_BY], i)
1652 if ((r = transaction_add_job_and_dependencies(m, type, dep, ret, true, override, false, false, ignore_order, e, NULL)) < 0) {
1662 if (type == JOB_RELOAD || type == JOB_RELOAD_OR_START) {
1664 SET_FOREACH(dep, ret->unit->dependencies[UNIT_PROPAGATE_RELOAD_TO], i) {
1665 r = transaction_add_job_and_dependencies(m, JOB_RELOAD, dep, ret, false, override, false, false, ignore_order, e, NULL);
1668 log_warning("Cannot add dependency reload job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1676 /* JOB_VERIFY_STARTED, JOB_RELOAD require no dependency handling */
1688 static int transaction_add_isolate_jobs(Manager *m) {
1696 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
1698 /* ignore aliases */
1702 if (u->ignore_on_isolate)
1705 /* No need to stop inactive jobs */
1706 if (UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(u)) && !u->job)
1709 /* Is there already something listed for this? */
1710 if (hashmap_get(m->transaction_jobs, u))
1713 if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, u, NULL, true, false, false, false, false, NULL, NULL)) < 0)
1714 log_warning("Cannot add isolate job for unit %s, ignoring: %s", u->id, strerror(-r));
1720 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
1725 assert(type < _JOB_TYPE_MAX);
1727 assert(mode < _JOB_MODE_MAX);
1729 if (mode == JOB_ISOLATE && type != JOB_START) {
1730 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
1734 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1735 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1739 log_debug("Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
1741 if ((r = transaction_add_job_and_dependencies(m, type, unit, NULL, true, override, false,
1742 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1743 mode == JOB_IGNORE_DEPENDENCIES, e, &ret)) < 0) {
1744 transaction_abort(m);
1748 if (mode == JOB_ISOLATE)
1749 if ((r = transaction_add_isolate_jobs(m)) < 0) {
1750 transaction_abort(m);
1754 if ((r = transaction_activate(m, mode, e)) < 0)
1757 log_debug("Enqueued job %s/%s as %u", unit->id, job_type_to_string(type), (unsigned) ret->id);
1765 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
1770 assert(type < _JOB_TYPE_MAX);
1772 assert(mode < _JOB_MODE_MAX);
1774 if ((r = manager_load_unit(m, name, NULL, NULL, &unit)) < 0)
1777 return manager_add_job(m, type, unit, mode, override, e, _ret);
1780 Job *manager_get_job(Manager *m, uint32_t id) {
1783 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1786 Unit *manager_get_unit(Manager *m, const char *name) {
1790 return hashmap_get(m->units, name);
1793 unsigned manager_dispatch_load_queue(Manager *m) {
1799 /* Make sure we are not run recursively */
1800 if (m->dispatching_load_queue)
1803 m->dispatching_load_queue = true;
1805 /* Dispatches the load queue. Takes a unit from the queue and
1806 * tries to load its data until the queue is empty */
1808 while ((u = m->load_queue)) {
1809 assert(u->in_load_queue);
1815 m->dispatching_load_queue = false;
1819 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1825 assert(name || path);
1827 /* This will prepare the unit for loading, but not actually
1828 * load anything from disk. */
1830 if (path && !is_path(path)) {
1831 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1836 name = file_name_from_path(path);
1838 t = unit_name_to_type(name);
1840 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid_no_type(name, false)) {
1841 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1845 ret = manager_get_unit(m, name);
1851 ret = unit_new(m, unit_vtable[t]->object_size);
1856 ret->fragment_path = strdup(path);
1857 if (!ret->fragment_path) {
1863 if ((r = unit_add_name(ret, name)) < 0) {
1868 unit_add_to_load_queue(ret);
1869 unit_add_to_dbus_queue(ret);
1870 unit_add_to_gc_queue(ret);
1878 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1883 /* This will load the service information files, but not actually
1884 * start any services or anything. */
1886 if ((r = manager_load_unit_prepare(m, name, path, e, _ret)) != 0)
1889 manager_dispatch_load_queue(m);
1892 *_ret = unit_follow_merge(*_ret);
1897 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1904 HASHMAP_FOREACH(j, s->jobs, i)
1905 job_dump(j, f, prefix);
1908 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1916 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1918 unit_dump(u, f, prefix);
1921 void manager_clear_jobs(Manager *m) {
1926 transaction_abort(m);
1928 while ((j = hashmap_first(m->jobs)))
1929 job_finish_and_invalidate(j, JOB_CANCELED);
1932 unsigned manager_dispatch_run_queue(Manager *m) {
1936 if (m->dispatching_run_queue)
1939 m->dispatching_run_queue = true;
1941 while ((j = m->run_queue)) {
1942 assert(j->installed);
1943 assert(j->in_run_queue);
1945 job_run_and_invalidate(j);
1949 m->dispatching_run_queue = false;
1953 unsigned manager_dispatch_dbus_queue(Manager *m) {
1960 if (m->dispatching_dbus_queue)
1963 m->dispatching_dbus_queue = true;
1965 while ((u = m->dbus_unit_queue)) {
1966 assert(u->in_dbus_queue);
1968 bus_unit_send_change_signal(u);
1972 while ((j = m->dbus_job_queue)) {
1973 assert(j->in_dbus_queue);
1975 bus_job_send_change_signal(j);
1979 m->dispatching_dbus_queue = false;
1983 static int manager_process_notify_fd(Manager *m) {
1990 struct msghdr msghdr;
1992 struct ucred *ucred;
1994 struct cmsghdr cmsghdr;
1995 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
2001 iovec.iov_base = buf;
2002 iovec.iov_len = sizeof(buf)-1;
2006 msghdr.msg_iov = &iovec;
2007 msghdr.msg_iovlen = 1;
2008 msghdr.msg_control = &control;
2009 msghdr.msg_controllen = sizeof(control);
2011 if ((n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT)) <= 0) {
2015 if (errno == EAGAIN || errno == EINTR)
2021 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
2022 control.cmsghdr.cmsg_level != SOL_SOCKET ||
2023 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
2024 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
2025 log_warning("Received notify message without credentials. Ignoring.");
2029 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
2031 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid))))
2032 if (!(u = cgroup_unit_by_pid(m, ucred->pid))) {
2033 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
2037 assert((size_t) n < sizeof(buf));
2039 if (!(tags = strv_split(buf, "\n\r")))
2042 log_debug("Got notification message for unit %s", u->id);
2044 if (UNIT_VTABLE(u)->notify_message)
2045 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
2053 static int manager_dispatch_sigchld(Manager *m) {
2063 /* First we call waitd() for a PID and do not reap the
2064 * zombie. That way we can still access /proc/$PID for
2065 * it while it is a zombie. */
2066 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
2068 if (errno == ECHILD)
2080 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
2083 get_process_comm(si.si_pid, &name);
2084 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
2088 /* Let's flush any message the dying child might still
2089 * have queued for us. This ensures that the process
2090 * still exists in /proc so that we can figure out
2091 * which cgroup and hence unit it belongs to. */
2092 if ((r = manager_process_notify_fd(m)) < 0)
2095 /* And now figure out the unit this belongs to */
2096 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid))))
2097 u = cgroup_unit_by_pid(m, si.si_pid);
2099 /* And now, we actually reap the zombie. */
2100 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
2107 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
2110 log_debug("Child %lu died (code=%s, status=%i/%s)",
2111 (long unsigned) si.si_pid,
2112 sigchld_code_to_string(si.si_code),
2114 strna(si.si_code == CLD_EXITED
2115 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
2116 : signal_to_string(si.si_status)));
2121 log_debug("Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
2123 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
2124 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
2130 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
2134 dbus_error_init(&error);
2136 log_debug("Activating special unit %s", name);
2138 if ((r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL)) < 0)
2139 log_error("Failed to enqueue %s job: %s", name, bus_error(&error, r));
2141 dbus_error_free(&error);
2146 static int manager_process_signal_fd(Manager *m) {
2148 struct signalfd_siginfo sfsi;
2149 bool sigchld = false;
2154 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
2159 if (errno == EINTR || errno == EAGAIN)
2165 if (sfsi.ssi_pid > 0) {
2168 get_process_comm(sfsi.ssi_pid, &p);
2170 log_debug("Received SIG%s from PID %lu (%s).",
2171 signal_to_string(sfsi.ssi_signo),
2172 (unsigned long) sfsi.ssi_pid, strna(p));
2175 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
2177 switch (sfsi.ssi_signo) {
2184 if (m->running_as == MANAGER_SYSTEM) {
2185 /* This is for compatibility with the
2186 * original sysvinit */
2187 m->exit_code = MANAGER_REEXECUTE;
2194 if (m->running_as == MANAGER_SYSTEM) {
2195 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
2199 /* Run the exit target if there is one, if not, just exit. */
2200 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
2201 m->exit_code = MANAGER_EXIT;
2208 if (m->running_as == MANAGER_SYSTEM)
2209 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
2211 /* This is a nop on non-init */
2215 if (m->running_as == MANAGER_SYSTEM)
2216 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
2218 /* This is a nop on non-init */
2224 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
2226 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
2227 log_info("Trying to reconnect to bus...");
2231 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
2232 log_info("Loading D-Bus service...");
2233 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
2244 if (!(f = open_memstream(&dump, &size))) {
2245 log_warning("Failed to allocate memory stream.");
2249 manager_dump_units(m, f, "\t");
2250 manager_dump_jobs(m, f, "\t");
2255 log_warning("Failed to write status stream");
2260 log_dump(LOG_INFO, dump);
2267 m->exit_code = MANAGER_RELOAD;
2272 /* Starting SIGRTMIN+0 */
2273 static const char * const target_table[] = {
2274 [0] = SPECIAL_DEFAULT_TARGET,
2275 [1] = SPECIAL_RESCUE_TARGET,
2276 [2] = SPECIAL_EMERGENCY_TARGET,
2277 [3] = SPECIAL_HALT_TARGET,
2278 [4] = SPECIAL_POWEROFF_TARGET,
2279 [5] = SPECIAL_REBOOT_TARGET,
2280 [6] = SPECIAL_KEXEC_TARGET
2283 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
2284 static const ManagerExitCode code_table[] = {
2286 [1] = MANAGER_POWEROFF,
2287 [2] = MANAGER_REBOOT,
2291 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
2292 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
2293 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
2294 manager_start_target(m, target_table[idx],
2295 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
2299 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
2300 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
2301 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
2305 switch (sfsi.ssi_signo - SIGRTMIN) {
2308 log_debug("Enabling showing of status.");
2309 manager_set_show_status(m, true);
2313 log_debug("Disabling showing of status.");
2314 manager_set_show_status(m, false);
2318 log_set_max_level(LOG_DEBUG);
2319 log_notice("Setting log level to debug.");
2323 log_set_max_level(LOG_INFO);
2324 log_notice("Setting log level to info.");
2328 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
2329 log_notice("Setting log target to journal-or-kmsg.");
2333 log_set_target(LOG_TARGET_CONSOLE);
2334 log_notice("Setting log target to console.");
2338 log_set_target(LOG_TARGET_KMSG);
2339 log_notice("Setting log target to kmsg.");
2343 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
2344 log_notice("Setting log target to syslog-or-kmsg.");
2348 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
2355 return manager_dispatch_sigchld(m);
2360 static int process_event(Manager *m, struct epoll_event *ev) {
2367 assert_se(w = ev->data.ptr);
2369 if (w->type == WATCH_INVALID)
2376 /* An incoming signal? */
2377 if (ev->events != EPOLLIN)
2380 if ((r = manager_process_signal_fd(m)) < 0)
2387 /* An incoming daemon notification event? */
2388 if (ev->events != EPOLLIN)
2391 if ((r = manager_process_notify_fd(m)) < 0)
2398 /* Some fd event, to be dispatched to the units */
2399 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
2402 case WATCH_UNIT_TIMER:
2403 case WATCH_JOB_TIMER: {
2407 /* Some timer event, to be dispatched to the units */
2408 if ((k = read(w->fd, &v, sizeof(v))) != sizeof(v)) {
2410 if (k < 0 && (errno == EINTR || errno == EAGAIN))
2413 return k < 0 ? -errno : -EIO;
2416 if (w->type == WATCH_UNIT_TIMER)
2417 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
2419 job_timer_event(w->data.job, v, w);
2424 /* Some mount table change, intended for the mount subsystem */
2425 mount_fd_event(m, ev->events);
2429 /* Some swap table change, intended for the swap subsystem */
2430 swap_fd_event(m, ev->events);
2434 /* Some notification from udev, intended for the device subsystem */
2435 device_fd_event(m, ev->events);
2438 case WATCH_DBUS_WATCH:
2439 bus_watch_event(m, w, ev->events);
2442 case WATCH_DBUS_TIMEOUT:
2443 bus_timeout_event(m, w, ev->events);
2447 log_error("event type=%i", w->type);
2448 assert_not_reached("Unknown epoll event type.");
2454 int manager_loop(Manager *m) {
2458 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
2461 m->exit_code = MANAGER_RUNNING;
2463 /* Release the path cache */
2464 set_free_free(m->unit_path_cache);
2465 m->unit_path_cache = NULL;
2467 manager_check_finished(m);
2469 /* There might still be some zombies hanging around from
2470 * before we were exec()'ed. Leat's reap them */
2471 r = manager_dispatch_sigchld(m);
2475 /* Sleep for half the watchdog time */
2476 if (m->runtime_watchdog > 0 && m->running_as == MANAGER_SYSTEM) {
2477 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
2482 while (m->exit_code == MANAGER_RUNNING) {
2483 struct epoll_event event;
2489 if (!ratelimit_test(&rl)) {
2490 /* Yay, something is going seriously wrong, pause a little */
2491 log_warning("Looping too fast. Throttling execution a little.");
2496 if (manager_dispatch_load_queue(m) > 0)
2499 if (manager_dispatch_run_queue(m) > 0)
2502 if (bus_dispatch(m) > 0)
2505 if (manager_dispatch_cleanup_queue(m) > 0)
2508 if (manager_dispatch_gc_queue(m) > 0)
2511 if (manager_dispatch_dbus_queue(m) > 0)
2514 if (swap_dispatch_reload(m) > 0)
2517 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
2529 r = process_event(m, &event);
2534 return m->exit_code;
2537 int manager_get_unit_from_dbus_path(Manager *m, const char *s, Unit **_u) {
2545 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
2548 if (!(n = bus_path_unescape(s+31)))
2551 u = manager_get_unit(m, n);
2562 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
2571 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
2574 if ((r = safe_atou(s + 30, &id)) < 0)
2577 if (!(j = manager_get_job(m, id)))
2585 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
2590 if (m->audit_fd < 0)
2593 /* Don't generate audit events if the service was already
2594 * started and we're just deserializing */
2595 if (m->n_reloading > 0)
2598 if (m->running_as != MANAGER_SYSTEM)
2601 if (u->type != UNIT_SERVICE)
2604 if (!(p = unit_name_to_prefix_and_instance(u->id))) {
2605 log_error("Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
2609 if (audit_log_user_comm_message(m->audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
2610 log_warning("Failed to send audit message: %m");
2612 if (errno == EPERM) {
2613 /* We aren't allowed to send audit messages?
2614 * Then let's not retry again, to avoid
2615 * spamming the user with the same and same
2616 * messages over and over. */
2618 audit_close(m->audit_fd);
2628 void manager_send_unit_plymouth(Manager *m, Unit *u) {
2630 union sockaddr_union sa;
2632 char *message = NULL;
2634 /* Don't generate plymouth events if the service was already
2635 * started and we're just deserializing */
2636 if (m->n_reloading > 0)
2639 if (m->running_as != MANAGER_SYSTEM)
2642 if (u->type != UNIT_SERVICE &&
2643 u->type != UNIT_MOUNT &&
2644 u->type != UNIT_SWAP)
2647 /* We set SOCK_NONBLOCK here so that we rather drop the
2648 * message then wait for plymouth */
2649 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
2650 log_error("socket() failed: %m");
2655 sa.sa.sa_family = AF_UNIX;
2656 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
2657 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2659 if (errno != EPIPE &&
2662 errno != ECONNREFUSED &&
2663 errno != ECONNRESET &&
2664 errno != ECONNABORTED)
2665 log_error("connect() failed: %m");
2670 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2671 log_error("Out of memory");
2676 if (write(fd, message, n + 1) != n + 1) {
2678 if (errno != EPIPE &&
2681 errno != ECONNREFUSED &&
2682 errno != ECONNRESET &&
2683 errno != ECONNABORTED)
2684 log_error("Failed to write Plymouth message: %m");
2691 close_nointr_nofail(fd);
2696 void manager_dispatch_bus_name_owner_changed(
2699 const char* old_owner,
2700 const char *new_owner) {
2707 if (!(u = hashmap_get(m->watch_bus, name)))
2710 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2713 void manager_dispatch_bus_query_pid_done(
2724 if (!(u = hashmap_get(m->watch_bus, name)))
2727 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
2730 int manager_open_serialization(Manager *m, FILE **_f) {
2738 if (m->running_as == MANAGER_SYSTEM)
2739 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
2741 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
2746 saved_umask = umask(0077);
2747 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2757 log_debug("Serializing state to %s", path);
2760 if (!(f = fdopen(fd, "w+")))
2768 int manager_serialize(Manager *m, FILE *f, FDSet *fds) {
2780 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2781 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2783 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2784 dual_timestamp_serialize(f, "startup-timestamp", &m->startup_timestamp);
2785 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2789 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2793 if (!unit_can_serialize(u))
2800 if ((r = unit_serialize(u, f, fds)) < 0) {
2806 assert(m->n_reloading > 0);
2812 r = bus_fdset_add_all(m, fds);
2819 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2825 log_debug("Deserializing state...");
2830 char line[LINE_MAX], *l;
2832 if (!fgets(line, sizeof(line), f)) {
2847 if (startswith(l, "current-job-id=")) {
2850 if (safe_atou32(l+15, &id) < 0)
2851 log_debug("Failed to parse current job id value %s", l+15);
2853 m->current_job_id = MAX(m->current_job_id, id);
2854 } else if (startswith(l, "taint-usr=")) {
2857 if ((b = parse_boolean(l+10)) < 0)
2858 log_debug("Failed to parse taint /usr flag %s", l+10);
2860 m->taint_usr = m->taint_usr || b;
2861 } else if (startswith(l, "initrd-timestamp="))
2862 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2863 else if (startswith(l, "startup-timestamp="))
2864 dual_timestamp_deserialize(l+18, &m->startup_timestamp);
2865 else if (startswith(l, "finish-timestamp="))
2866 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2868 log_debug("Unknown serialization item '%s'", l);
2873 char name[UNIT_NAME_MAX+2];
2876 if (!fgets(name, sizeof(name), f)) {
2887 if ((r = manager_load_unit(m, strstrip(name), NULL, NULL, &u)) < 0)
2890 if ((r = unit_deserialize(u, f, fds)) < 0)
2900 assert(m->n_reloading > 0);
2906 int manager_reload(Manager *m) {
2913 if ((r = manager_open_serialization(m, &f)) < 0)
2918 if (!(fds = fdset_new())) {
2924 if ((r = manager_serialize(m, f, fds)) < 0) {
2929 if (fseeko(f, 0, SEEK_SET) < 0) {
2935 /* From here on there is no way back. */
2936 manager_clear_jobs_and_units(m);
2937 manager_undo_generators(m);
2939 /* Find new unit paths */
2940 lookup_paths_free(&m->lookup_paths);
2941 if ((q = lookup_paths_init(&m->lookup_paths, m->running_as, true)) < 0)
2944 manager_run_generators(m);
2946 manager_build_unit_path_cache(m);
2948 /* First, enumerate what we can from all config files */
2949 if ((q = manager_enumerate(m)) < 0)
2952 /* Second, deserialize our stored data */
2953 if ((q = manager_deserialize(m, f, fds)) < 0)
2959 /* Third, fire things up! */
2960 if ((q = manager_coldplug(m)) < 0)
2963 assert(m->n_reloading > 0);
2976 bool manager_is_booting_or_shutting_down(Manager *m) {
2981 /* Is the initial job still around? */
2982 if (manager_get_job(m, m->default_unit_job_id))
2985 /* Is there a job for the shutdown target? */
2986 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2993 void manager_reset_failed(Manager *m) {
2999 HASHMAP_FOREACH(u, m->units, i)
3000 unit_reset_failed(u);
3003 bool manager_unit_pending_inactive(Manager *m, const char *name) {
3009 /* Returns true if the unit is inactive or going down */
3010 if (!(u = manager_get_unit(m, name)))
3013 return unit_pending_inactive(u);
3016 void manager_check_finished(Manager *m) {
3017 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
3018 usec_t kernel_usec = 0, initrd_usec = 0, userspace_usec = 0, total_usec = 0;
3022 if (dual_timestamp_is_set(&m->finish_timestamp))
3025 if (hashmap_size(m->jobs) > 0)
3028 dual_timestamp_get(&m->finish_timestamp);
3030 if (m->running_as == MANAGER_SYSTEM && detect_container(NULL) <= 0) {
3032 userspace_usec = m->finish_timestamp.monotonic - m->startup_timestamp.monotonic;
3033 total_usec = m->finish_timestamp.monotonic;
3035 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
3037 kernel_usec = m->initrd_timestamp.monotonic;
3038 initrd_usec = m->startup_timestamp.monotonic - m->initrd_timestamp.monotonic;
3040 log_info("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
3041 format_timespan(kernel, sizeof(kernel), kernel_usec),
3042 format_timespan(initrd, sizeof(initrd), initrd_usec),
3043 format_timespan(userspace, sizeof(userspace), userspace_usec),
3044 format_timespan(sum, sizeof(sum), total_usec));
3046 kernel_usec = m->startup_timestamp.monotonic;
3049 log_info("Startup finished in %s (kernel) + %s (userspace) = %s.",
3050 format_timespan(kernel, sizeof(kernel), kernel_usec),
3051 format_timespan(userspace, sizeof(userspace), userspace_usec),
3052 format_timespan(sum, sizeof(sum), total_usec));
3055 userspace_usec = initrd_usec = kernel_usec = 0;
3056 total_usec = m->finish_timestamp.monotonic - m->startup_timestamp.monotonic;
3058 log_debug("Startup finished in %s.",
3059 format_timespan(sum, sizeof(sum), total_usec));
3062 bus_broadcast_finished(m, kernel_usec, initrd_usec, userspace_usec, total_usec);
3065 "READY=1\nSTATUS=Startup finished in %s.",
3066 format_timespan(sum, sizeof(sum), total_usec));
3069 void manager_run_generators(Manager *m) {
3071 const char *generator_path;
3072 const char *argv[3];
3077 generator_path = m->running_as == MANAGER_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
3078 if (!(d = opendir(generator_path))) {
3080 if (errno == ENOENT)
3083 log_error("Failed to enumerate generator directory: %m");
3087 if (!m->generator_unit_path) {
3089 char user_path[] = "/tmp/systemd-generator-XXXXXX";
3091 if (m->running_as == MANAGER_SYSTEM && getpid() == 1) {
3092 p = "/run/systemd/generator";
3094 if (mkdir_p(p, 0755) < 0) {
3095 log_error("Failed to create generator directory: %m");
3100 if (!(p = mkdtemp(user_path))) {
3101 log_error("Failed to create generator directory: %m");
3106 if (!(m->generator_unit_path = strdup(p))) {
3107 log_error("Failed to allocate generator unit path.");
3112 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
3113 argv[1] = m->generator_unit_path;
3117 execute_directory(generator_path, d, (char**) argv);
3120 if (rmdir(m->generator_unit_path) >= 0) {
3121 /* Uh? we were able to remove this dir? I guess that
3122 * means the directory was empty, hence let's shortcut
3125 free(m->generator_unit_path);
3126 m->generator_unit_path = NULL;
3130 if (!strv_find(m->lookup_paths.unit_path, m->generator_unit_path)) {
3133 if (!(l = strv_append(m->lookup_paths.unit_path, m->generator_unit_path))) {
3134 log_error("Failed to add generator directory to unit search path: %m");
3138 strv_free(m->lookup_paths.unit_path);
3139 m->lookup_paths.unit_path = l;
3141 log_debug("Added generator unit path %s to search path.", m->generator_unit_path);
3149 void manager_undo_generators(Manager *m) {
3152 if (!m->generator_unit_path)
3155 strv_remove(m->lookup_paths.unit_path, m->generator_unit_path);
3156 rm_rf(m->generator_unit_path, false, true, false);
3158 free(m->generator_unit_path);
3159 m->generator_unit_path = NULL;
3162 int manager_set_default_controllers(Manager *m, char **controllers) {
3167 if (!(l = strv_copy(controllers)))
3170 strv_free(m->default_controllers);
3171 m->default_controllers = l;
3176 void manager_recheck_journal(Manager *m) {
3181 if (m->running_as != MANAGER_SYSTEM)
3184 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
3185 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
3186 log_close_journal();
3190 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
3191 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
3192 log_close_journal();
3196 /* Hmm, OK, so the socket is fully up and the service is up
3197 * too, then let's make use of the thing. */
3201 void manager_set_show_status(Manager *m, bool b) {
3204 if (m->running_as != MANAGER_SYSTEM)
3210 touch("/run/systemd/show-status");
3212 unlink("/run/systemd/show-status");
3215 bool manager_get_show_status(Manager *m) {
3218 if (m->running_as != MANAGER_SYSTEM)
3224 /* If Plymouth is running make sure we show the status, so
3225 * that there's something nice to see when people press Esc */
3227 return plymouth_running();
3230 static const char* const manager_running_as_table[_MANAGER_RUNNING_AS_MAX] = {
3231 [MANAGER_SYSTEM] = "system",
3232 [MANAGER_USER] = "user"
3235 DEFINE_STRING_TABLE_LOOKUP(manager_running_as, ManagerRunningAs);