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>
39 #include <sys/timerfd.h>
45 #include "systemd/sd-daemon.h"
46 #include "systemd/sd-id128.h"
47 #include "systemd/sd-messages.h"
50 #include "transaction.h"
57 #include "ratelimit.h"
58 #include "mount-setup.h"
59 #include "unit-name.h"
60 #include "dbus-unit.h"
63 #include "path-lookup.h"
65 #include "bus-errors.h"
66 #include "exit-status.h"
69 #include "cgroup-util.h"
70 #include "path-util.h"
75 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
76 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
78 /* Initial delay and the interval for printing status messages about running jobs */
79 #define JOBS_IN_PROGRESS_WAIT_SEC 5
80 #define JOBS_IN_PROGRESS_PERIOD_SEC 1
81 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
83 /* Where clients shall send notification messages to */
84 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
86 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
88 static int manager_setup_notify(Manager *m) {
91 struct sockaddr_un un;
93 .sa.sa_family = AF_UNIX,
95 struct epoll_event ev = {
97 .data.ptr = &m->notify_watch,
101 m->notify_watch.type = WATCH_NOTIFY;
102 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
103 if (m->notify_watch.fd < 0) {
104 log_error("Failed to allocate notification socket: %m");
108 if (getpid() != 1 || detect_container(NULL) > 0)
109 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
111 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
113 sa.un.sun_path[0] = 0;
115 r = bind(m->notify_watch.fd, &sa.sa,
116 offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
118 log_error("bind() failed: %m");
122 r = setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
124 log_error("SO_PASSCRED failed: %m");
128 r = epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev);
130 log_error("Failed to add notification socket fd to epoll: %m");
134 sa.un.sun_path[0] = '@';
135 m->notify_socket = strdup(sa.un.sun_path);
136 if (!m->notify_socket)
139 log_debug("Using notification socket %s", m->notify_socket);
144 static int manager_jobs_in_progress_mod_timer(Manager *m) {
145 struct itimerspec its = {
146 .it_value.tv_sec = JOBS_IN_PROGRESS_WAIT_SEC,
147 .it_interval.tv_sec = JOBS_IN_PROGRESS_PERIOD_SEC,
150 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
153 if (timerfd_settime(m->jobs_in_progress_watch.fd, 0, &its, NULL) < 0)
159 static int manager_watch_jobs_in_progress(Manager *m) {
160 struct epoll_event ev = {
162 .data.ptr = &m->jobs_in_progress_watch,
166 if (m->jobs_in_progress_watch.type != WATCH_INVALID)
169 m->jobs_in_progress_watch.type = WATCH_JOBS_IN_PROGRESS;
170 m->jobs_in_progress_watch.fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
171 if (m->jobs_in_progress_watch.fd < 0) {
172 log_error("Failed to create timerfd: %m");
177 r = manager_jobs_in_progress_mod_timer(m);
179 log_error("Failed to set up timer for jobs progress watch: %s", strerror(-r));
183 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->jobs_in_progress_watch.fd, &ev) < 0) {
184 log_error("Failed to add jobs progress timer fd to epoll: %m");
189 log_debug("Set up jobs progress timerfd.");
194 if (m->jobs_in_progress_watch.fd >= 0)
195 close_nointr_nofail(m->jobs_in_progress_watch.fd);
196 watch_init(&m->jobs_in_progress_watch);
200 static void manager_unwatch_jobs_in_progress(Manager *m) {
201 if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
204 assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->jobs_in_progress_watch.fd, NULL) >= 0);
205 close_nointr_nofail(m->jobs_in_progress_watch.fd);
206 watch_init(&m->jobs_in_progress_watch);
207 m->jobs_in_progress_iteration = 0;
209 log_debug("Closed jobs progress timerfd.");
212 #define CYLON_BUFFER_EXTRA (2*strlen(ANSI_RED_ON) + strlen(ANSI_HIGHLIGHT_RED_ON) + 2*strlen(ANSI_HIGHLIGHT_OFF))
213 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
216 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
217 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
221 p = mempset(p, ' ', pos-2);
222 p = stpcpy(p, ANSI_RED_ON);
226 if (pos > 0 && pos <= width) {
227 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
231 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
234 p = stpcpy(p, ANSI_RED_ON);
237 p = mempset(p, ' ', width-1-pos);
238 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
242 static void manager_print_jobs_in_progress(Manager *m) {
245 char *job_of_n = NULL;
246 unsigned counter = 0, print_nr;
247 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
250 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
252 HASHMAP_FOREACH(j, m->jobs, i)
253 if (j->state == JOB_RUNNING && counter++ == print_nr)
256 /* m->n_running_jobs must be consistent with the contents of m->jobs,
257 * so the above loop must have succeeded in finding j. */
258 assert(counter == print_nr + 1);
260 cylon_pos = m->jobs_in_progress_iteration % 14;
262 cylon_pos = 14 - cylon_pos;
263 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
265 if (m->n_running_jobs > 1)
266 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
269 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
270 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
273 m->jobs_in_progress_iteration++;
276 static int manager_setup_time_change(Manager *m) {
277 struct epoll_event ev = {
279 .data.ptr = &m->time_change_watch,
282 /* We only care for the cancellation event, hence we set the
283 * timeout to the latest possible value. */
284 struct itimerspec its = {
285 .it_value.tv_sec = TIME_T_MAX,
287 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
289 assert(m->time_change_watch.type == WATCH_INVALID);
291 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
292 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
294 m->time_change_watch.type = WATCH_TIME_CHANGE;
295 m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
296 if (m->time_change_watch.fd < 0) {
297 log_error("Failed to create timerfd: %m");
301 if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
302 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
303 close_nointr_nofail(m->time_change_watch.fd);
304 watch_init(&m->time_change_watch);
308 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
309 log_error("Failed to add timer change fd to epoll: %m");
313 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
318 static int enable_special_signals(Manager *m) {
323 /* Enable that we get SIGINT on control-alt-del. In containers
324 * this will fail with EPERM (older) or EINVAL (newer), so
326 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
327 log_warning("Failed to enable ctrl-alt-del handling: %m");
329 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
331 /* Support systems without virtual console */
333 log_warning("Failed to open /dev/tty0: %m");
335 /* Enable that we get SIGWINCH on kbrequest */
336 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
337 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
339 close_nointr_nofail(fd);
345 static int manager_setup_signals(Manager *m) {
347 struct epoll_event ev = {
349 .data.ptr = &m->signal_watch,
351 struct sigaction sa = {
352 .sa_handler = SIG_DFL,
353 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
358 /* We are not interested in SIGSTOP and friends. */
359 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
361 assert_se(sigemptyset(&mask) == 0);
363 sigset_add_many(&mask,
364 SIGCHLD, /* Child died */
365 SIGTERM, /* Reexecute daemon */
366 SIGHUP, /* Reload configuration */
367 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
368 SIGUSR2, /* systemd: dump status */
369 SIGINT, /* Kernel sends us this on control-alt-del */
370 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
371 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
372 SIGRTMIN+0, /* systemd: start default.target */
373 SIGRTMIN+1, /* systemd: isolate rescue.target */
374 SIGRTMIN+2, /* systemd: isolate emergency.target */
375 SIGRTMIN+3, /* systemd: start halt.target */
376 SIGRTMIN+4, /* systemd: start poweroff.target */
377 SIGRTMIN+5, /* systemd: start reboot.target */
378 SIGRTMIN+6, /* systemd: start kexec.target */
379 SIGRTMIN+13, /* systemd: Immediate halt */
380 SIGRTMIN+14, /* systemd: Immediate poweroff */
381 SIGRTMIN+15, /* systemd: Immediate reboot */
382 SIGRTMIN+16, /* systemd: Immediate kexec */
383 SIGRTMIN+20, /* systemd: enable status messages */
384 SIGRTMIN+21, /* systemd: disable status messages */
385 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
386 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
387 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
388 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
389 SIGRTMIN+27, /* systemd: set log target to console */
390 SIGRTMIN+28, /* systemd: set log target to kmsg */
391 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
393 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
395 m->signal_watch.type = WATCH_SIGNAL;
396 m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
397 if (m->signal_watch.fd < 0)
400 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
403 if (m->running_as == SYSTEMD_SYSTEM)
404 return enable_special_signals(m);
409 static void manager_strip_environment(Manager *m) {
412 /* Remove variables from the inherited set that are part of
413 * the container interface:
414 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
415 strv_remove_prefix(m->environment, "container=");
416 strv_remove_prefix(m->environment, "container_");
418 /* Remove variables from the inherited set that are part of
419 * the initrd interface:
420 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
421 strv_remove_prefix(m->environment, "RD_");
423 /* Drop invalid entries */
424 strv_env_clean(m->environment);
427 int manager_new(SystemdRunningAs running_as, Manager **_m) {
432 assert(running_as >= 0);
433 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
435 m = new0(Manager, 1);
440 if (detect_container(NULL) <= 0)
441 efi_get_boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
444 m->running_as = running_as;
445 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
446 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
447 m->pin_cgroupfs_fd = -1;
448 m->idle_pipe[0] = m->idle_pipe[1] = -1;
450 watch_init(&m->signal_watch);
451 watch_init(&m->mount_watch);
452 watch_init(&m->swap_watch);
453 watch_init(&m->udev_watch);
454 watch_init(&m->time_change_watch);
455 watch_init(&m->jobs_in_progress_watch);
457 m->epoll_fd = m->dev_autofs_fd = -1;
458 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
460 m->environment = strv_copy(environ);
464 manager_strip_environment(m);
466 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
469 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
472 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
475 m->cgroup_unit = hashmap_new(string_hash_func, string_compare_func);
479 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
482 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
486 r = manager_setup_signals(m);
490 r = manager_setup_cgroup(m);
494 r = manager_setup_notify(m);
498 r = manager_setup_time_change(m);
502 /* Try to connect to the busses, if possible. */
503 if ((running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS")) ||
504 running_as == SYSTEMD_SYSTEM) {
505 r = bus_init(m, running_as != SYSTEMD_SYSTEM);
509 log_debug("Skipping DBus session bus connection attempt - no DBUS_SESSION_BUS_ADDRESS set...");
511 m->taint_usr = dir_is_empty("/usr") > 0;
521 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
527 while ((u = m->cleanup_queue)) {
528 assert(u->in_cleanup_queue);
538 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
539 GC_OFFSET_UNSURE, /* No clue */
540 GC_OFFSET_GOOD, /* We still need this unit */
541 GC_OFFSET_BAD, /* We don't need this unit anymore */
545 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
552 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
553 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
554 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
557 if (u->in_cleanup_queue)
560 if (unit_check_gc(u))
563 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
567 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
568 unit_gc_sweep(other, gc_marker);
570 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
573 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
580 /* We were unable to find anything out about this entry, so
581 * let's investigate it later */
582 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
583 unit_add_to_gc_queue(u);
587 /* We definitely know that this one is not useful anymore, so
588 * let's mark it for deletion */
589 u->gc_marker = gc_marker + GC_OFFSET_BAD;
590 unit_add_to_cleanup_queue(u);
594 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
597 static unsigned manager_dispatch_gc_queue(Manager *m) {
604 /* log_debug("Running GC..."); */
606 m->gc_marker += _GC_OFFSET_MAX;
607 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
610 gc_marker = m->gc_marker;
612 while ((u = m->gc_queue)) {
613 assert(u->in_gc_queue);
615 unit_gc_sweep(u, gc_marker);
617 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
618 u->in_gc_queue = false;
622 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
623 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
624 log_debug_unit(u->id, "Collecting %s", u->id);
625 u->gc_marker = gc_marker + GC_OFFSET_BAD;
626 unit_add_to_cleanup_queue(u);
630 m->n_in_gc_queue = 0;
635 static void manager_clear_jobs_and_units(Manager *m) {
640 while ((u = hashmap_first(m->units)))
643 manager_dispatch_cleanup_queue(m);
645 assert(!m->load_queue);
646 assert(!m->run_queue);
647 assert(!m->dbus_unit_queue);
648 assert(!m->dbus_job_queue);
649 assert(!m->cleanup_queue);
650 assert(!m->gc_queue);
652 assert(hashmap_isempty(m->jobs));
653 assert(hashmap_isempty(m->units));
656 m->n_running_jobs = 0;
659 void manager_free(Manager *m) {
665 manager_clear_jobs_and_units(m);
667 for (c = 0; c < _UNIT_TYPE_MAX; c++)
668 if (unit_vtable[c]->shutdown)
669 unit_vtable[c]->shutdown(m);
671 /* If we reexecute ourselves, we keep the root cgroup
673 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
675 manager_undo_generators(m);
679 hashmap_free(m->units);
680 hashmap_free(m->jobs);
681 hashmap_free(m->watch_pids);
682 hashmap_free(m->watch_bus);
684 if (m->epoll_fd >= 0)
685 close_nointr_nofail(m->epoll_fd);
686 if (m->signal_watch.fd >= 0)
687 close_nointr_nofail(m->signal_watch.fd);
688 if (m->notify_watch.fd >= 0)
689 close_nointr_nofail(m->notify_watch.fd);
690 if (m->time_change_watch.fd >= 0)
691 close_nointr_nofail(m->time_change_watch.fd);
692 if (m->jobs_in_progress_watch.fd >= 0)
693 close_nointr_nofail(m->jobs_in_progress_watch.fd);
695 free(m->notify_socket);
697 lookup_paths_free(&m->lookup_paths);
698 strv_free(m->environment);
700 hashmap_free(m->cgroup_unit);
701 set_free_free(m->unit_path_cache);
703 close_pipe(m->idle_pipe);
705 free(m->switch_root);
706 free(m->switch_root_init);
708 for (i = 0; i < RLIMIT_NLIMITS; i++)
714 int manager_enumerate(Manager *m) {
720 /* Let's ask every type to load all units from disk/kernel
721 * that it might know */
722 for (c = 0; c < _UNIT_TYPE_MAX; c++)
723 if (unit_vtable[c]->enumerate)
724 if ((q = unit_vtable[c]->enumerate(m)) < 0)
727 manager_dispatch_load_queue(m);
731 int manager_coldplug(Manager *m) {
739 /* Then, let's set up their initial state. */
740 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
746 if ((q = unit_coldplug(u)) < 0)
753 static void manager_build_unit_path_cache(Manager *m) {
755 _cleanup_free_ DIR *d = NULL;
760 set_free_free(m->unit_path_cache);
762 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
763 if (!m->unit_path_cache) {
764 log_error("Failed to allocate unit path cache.");
768 /* This simply builds a list of files we know exist, so that
769 * we don't always have to go to disk */
771 STRV_FOREACH(i, m->lookup_paths.unit_path) {
777 log_error("Failed to open directory %s: %m", *i);
781 while ((de = readdir(d))) {
784 if (ignore_file(de->d_name))
787 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
793 r = set_consume(m->unit_path_cache, p);
805 log_error("Failed to build unit path cache: %s", strerror(-r));
807 set_free_free(m->unit_path_cache);
808 m->unit_path_cache = NULL;
811 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
816 dual_timestamp_get(&m->generators_start_timestamp);
817 manager_run_generators(m);
818 dual_timestamp_get(&m->generators_finish_timestamp);
820 r = lookup_paths_init(
821 &m->lookup_paths, m->running_as, true,
822 m->generator_unit_path,
823 m->generator_unit_path_early,
824 m->generator_unit_path_late);
828 manager_build_unit_path_cache(m);
830 /* If we will deserialize make sure that during enumeration
831 * this is already known, so we increase the counter here
836 /* First, enumerate what we can from all config files */
837 dual_timestamp_get(&m->unitsload_start_timestamp);
838 r = manager_enumerate(m);
839 dual_timestamp_get(&m->unitsload_finish_timestamp);
841 /* Second, deserialize if there is something to deserialize */
843 q = manager_deserialize(m, serialization, fds);
848 /* Any fds left? Find some unit which wants them. This is
849 * useful to allow container managers to pass some file
850 * descriptors to us pre-initialized. This enables
851 * socket-based activation of entire containers. */
852 if (fdset_size(fds) > 0) {
853 q = manager_distribute_fds(m, fds);
858 /* Third, fire things up! */
859 q = manager_coldplug(m);
864 assert(m->n_reloading > 0);
871 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
876 assert(type < _JOB_TYPE_MAX);
878 assert(mode < _JOB_MODE_MAX);
880 if (mode == JOB_ISOLATE && type != JOB_START) {
881 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
885 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
886 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
890 log_debug_unit(unit->id,
891 "Trying to enqueue job %s/%s/%s", unit->id,
892 job_type_to_string(type), job_mode_to_string(mode));
894 job_type_collapse(&type, unit);
896 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
900 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
901 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
902 mode == JOB_IGNORE_DEPENDENCIES, e);
906 if (mode == JOB_ISOLATE) {
907 r = transaction_add_isolate_jobs(tr, m);
912 r = transaction_activate(tr, m, mode, e);
916 log_debug_unit(unit->id,
917 "Enqueued job %s/%s as %u", unit->id,
918 job_type_to_string(type), (unsigned) tr->anchor_job->id);
921 *_ret = tr->anchor_job;
923 transaction_free(tr);
927 transaction_abort(tr);
928 transaction_free(tr);
932 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
937 assert(type < _JOB_TYPE_MAX);
939 assert(mode < _JOB_MODE_MAX);
941 r = manager_load_unit(m, name, NULL, NULL, &unit);
945 return manager_add_job(m, type, unit, mode, override, e, _ret);
948 Job *manager_get_job(Manager *m, uint32_t id) {
951 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
954 Unit *manager_get_unit(Manager *m, const char *name) {
958 return hashmap_get(m->units, name);
961 unsigned manager_dispatch_load_queue(Manager *m) {
967 /* Make sure we are not run recursively */
968 if (m->dispatching_load_queue)
971 m->dispatching_load_queue = true;
973 /* Dispatches the load queue. Takes a unit from the queue and
974 * tries to load its data until the queue is empty */
976 while ((u = m->load_queue)) {
977 assert(u->in_load_queue);
983 m->dispatching_load_queue = false;
987 int manager_load_unit_prepare(
999 assert(name || path);
1001 /* This will prepare the unit for loading, but not actually
1002 * load anything from disk. */
1004 if (path && !is_path(path)) {
1005 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1010 name = path_get_file_name(path);
1012 t = unit_name_to_type(name);
1014 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
1015 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1019 ret = manager_get_unit(m, name);
1025 ret = unit_new(m, unit_vtable[t]->object_size);
1030 ret->fragment_path = strdup(path);
1031 if (!ret->fragment_path) {
1037 r = unit_add_name(ret, name);
1043 unit_add_to_load_queue(ret);
1044 unit_add_to_dbus_queue(ret);
1045 unit_add_to_gc_queue(ret);
1053 int manager_load_unit(
1064 /* This will load the service information files, but not actually
1065 * start any services or anything. */
1067 r = manager_load_unit_prepare(m, name, path, e, _ret);
1071 manager_dispatch_load_queue(m);
1074 *_ret = unit_follow_merge(*_ret);
1079 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1086 HASHMAP_FOREACH(j, s->jobs, i)
1087 job_dump(j, f, prefix);
1090 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1098 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1100 unit_dump(u, f, prefix);
1103 void manager_clear_jobs(Manager *m) {
1108 while ((j = hashmap_first(m->jobs)))
1109 /* No need to recurse. We're cancelling all jobs. */
1110 job_finish_and_invalidate(j, JOB_CANCELED, false);
1113 unsigned manager_dispatch_run_queue(Manager *m) {
1117 if (m->dispatching_run_queue)
1120 m->dispatching_run_queue = true;
1122 while ((j = m->run_queue)) {
1123 assert(j->installed);
1124 assert(j->in_run_queue);
1126 job_run_and_invalidate(j);
1130 m->dispatching_run_queue = false;
1132 if (m->n_running_jobs > 0)
1133 manager_watch_jobs_in_progress(m);
1138 unsigned manager_dispatch_dbus_queue(Manager *m) {
1145 if (m->dispatching_dbus_queue)
1148 m->dispatching_dbus_queue = true;
1150 while ((u = m->dbus_unit_queue)) {
1151 assert(u->in_dbus_queue);
1153 bus_unit_send_change_signal(u);
1157 while ((j = m->dbus_job_queue)) {
1158 assert(j->in_dbus_queue);
1160 bus_job_send_change_signal(j);
1164 m->dispatching_dbus_queue = false;
1168 static int manager_process_notify_fd(Manager *m) {
1175 struct iovec iovec = {
1177 .iov_len = sizeof(buf)-1,
1181 struct cmsghdr cmsghdr;
1182 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1185 struct msghdr msghdr = {
1188 .msg_control = &control,
1189 .msg_controllen = sizeof(control),
1191 struct ucred *ucred;
1193 _cleanup_strv_free_ char **tags = NULL;
1195 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1200 if (errno == EAGAIN || errno == EINTR)
1206 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1207 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1208 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1209 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1210 log_warning("Received notify message without credentials. Ignoring.");
1214 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1216 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1218 u = manager_get_unit_by_pid(m, ucred->pid);
1220 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1225 assert((size_t) n < sizeof(buf));
1227 tags = strv_split(buf, "\n\r");
1231 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1233 if (UNIT_VTABLE(u)->notify_message)
1234 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1240 static int manager_dispatch_sigchld(Manager *m) {
1248 /* First we call waitd() for a PID and do not reap the
1249 * zombie. That way we can still access /proc/$PID for
1250 * it while it is a zombie. */
1251 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1253 if (errno == ECHILD)
1265 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1266 _cleanup_free_ char *name = NULL;
1268 get_process_comm(si.si_pid, &name);
1269 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1272 /* Let's flush any message the dying child might still
1273 * have queued for us. This ensures that the process
1274 * still exists in /proc so that we can figure out
1275 * which cgroup and hence unit it belongs to. */
1276 r = manager_process_notify_fd(m);
1280 /* And now figure out the unit this belongs to */
1281 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1283 u = manager_get_unit_by_pid(m, si.si_pid);
1285 /* And now, we actually reap the zombie. */
1286 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1293 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1296 log_debug("Child %lu died (code=%s, status=%i/%s)",
1297 (long unsigned) si.si_pid,
1298 sigchld_code_to_string(si.si_code),
1300 strna(si.si_code == CLD_EXITED
1301 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1302 : signal_to_string(si.si_status)));
1307 log_debug_unit(u->id,
1308 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1310 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1311 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1317 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1321 dbus_error_init(&error);
1323 log_debug_unit(name, "Activating special unit %s", name);
1325 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1327 log_error_unit(name,
1328 "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1330 dbus_error_free(&error);
1335 static int manager_process_signal_fd(Manager *m) {
1337 struct signalfd_siginfo sfsi;
1338 bool sigchld = false;
1343 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1344 if (n != sizeof(sfsi)) {
1349 if (errno == EINTR || errno == EAGAIN)
1355 if (sfsi.ssi_pid > 0) {
1358 get_process_comm(sfsi.ssi_pid, &p);
1360 log_debug("Received SIG%s from PID %lu (%s).",
1361 signal_to_string(sfsi.ssi_signo),
1362 (unsigned long) sfsi.ssi_pid, strna(p));
1365 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1367 switch (sfsi.ssi_signo) {
1374 if (m->running_as == SYSTEMD_SYSTEM) {
1375 /* This is for compatibility with the
1376 * original sysvinit */
1377 m->exit_code = MANAGER_REEXECUTE;
1384 if (m->running_as == SYSTEMD_SYSTEM) {
1385 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1389 /* Run the exit target if there is one, if not, just exit. */
1390 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1391 m->exit_code = MANAGER_EXIT;
1398 if (m->running_as == SYSTEMD_SYSTEM)
1399 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1401 /* This is a nop on non-init */
1405 if (m->running_as == SYSTEMD_SYSTEM)
1406 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1408 /* This is a nop on non-init */
1414 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1416 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1417 log_info("Trying to reconnect to bus...");
1421 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1422 log_info("Loading D-Bus service...");
1423 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1434 if (!(f = open_memstream(&dump, &size))) {
1435 log_warning("Failed to allocate memory stream.");
1439 manager_dump_units(m, f, "\t");
1440 manager_dump_jobs(m, f, "\t");
1445 log_warning("Failed to write status stream");
1450 log_dump(LOG_INFO, dump);
1457 m->exit_code = MANAGER_RELOAD;
1462 /* Starting SIGRTMIN+0 */
1463 static const char * const target_table[] = {
1464 [0] = SPECIAL_DEFAULT_TARGET,
1465 [1] = SPECIAL_RESCUE_TARGET,
1466 [2] = SPECIAL_EMERGENCY_TARGET,
1467 [3] = SPECIAL_HALT_TARGET,
1468 [4] = SPECIAL_POWEROFF_TARGET,
1469 [5] = SPECIAL_REBOOT_TARGET,
1470 [6] = SPECIAL_KEXEC_TARGET
1473 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1474 static const ManagerExitCode code_table[] = {
1476 [1] = MANAGER_POWEROFF,
1477 [2] = MANAGER_REBOOT,
1481 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1482 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1483 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1484 manager_start_target(m, target_table[idx],
1485 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1489 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1490 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1491 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1495 switch (sfsi.ssi_signo - SIGRTMIN) {
1498 log_debug("Enabling showing of status.");
1499 manager_set_show_status(m, true);
1503 log_debug("Disabling showing of status.");
1504 manager_set_show_status(m, false);
1508 log_set_max_level(LOG_DEBUG);
1509 log_notice("Setting log level to debug.");
1513 log_set_max_level(LOG_INFO);
1514 log_notice("Setting log level to info.");
1518 if (m->running_as == SYSTEMD_USER) {
1519 m->exit_code = MANAGER_EXIT;
1523 /* This is a nop on init */
1527 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1528 log_notice("Setting log target to journal-or-kmsg.");
1532 log_set_target(LOG_TARGET_CONSOLE);
1533 log_notice("Setting log target to console.");
1537 log_set_target(LOG_TARGET_KMSG);
1538 log_notice("Setting log target to kmsg.");
1542 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1543 log_notice("Setting log target to syslog-or-kmsg.");
1547 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1554 return manager_dispatch_sigchld(m);
1559 static int process_event(Manager *m, struct epoll_event *ev) {
1566 assert_se(w = ev->data.ptr);
1568 if (w->type == WATCH_INVALID)
1575 /* An incoming signal? */
1576 if (ev->events != EPOLLIN)
1579 if ((r = manager_process_signal_fd(m)) < 0)
1586 /* An incoming daemon notification event? */
1587 if (ev->events != EPOLLIN)
1590 if ((r = manager_process_notify_fd(m)) < 0)
1597 /* Some fd event, to be dispatched to the units */
1598 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1601 case WATCH_UNIT_TIMER:
1602 case WATCH_JOB_TIMER: {
1606 /* Some timer event, to be dispatched to the units */
1607 k = read(w->fd, &v, sizeof(v));
1608 if (k != sizeof(v)) {
1610 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1613 log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1614 return k < 0 ? -errno : -EIO;
1617 if (w->type == WATCH_UNIT_TIMER)
1618 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1620 job_timer_event(w->data.job, v, w);
1625 /* Some mount table change, intended for the mount subsystem */
1626 mount_fd_event(m, ev->events);
1630 /* Some swap table change, intended for the swap subsystem */
1631 swap_fd_event(m, ev->events);
1635 /* Some notification from udev, intended for the device subsystem */
1636 device_fd_event(m, ev->events);
1639 case WATCH_DBUS_WATCH:
1640 bus_watch_event(m, w, ev->events);
1643 case WATCH_DBUS_TIMEOUT:
1644 bus_timeout_event(m, w, ev->events);
1647 case WATCH_TIME_CHANGE: {
1651 log_struct(LOG_INFO,
1652 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1653 "MESSAGE=Time has been changed",
1656 /* Restart the watch */
1657 epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->time_change_watch.fd,
1659 close_nointr_nofail(m->time_change_watch.fd);
1660 watch_init(&m->time_change_watch);
1661 manager_setup_time_change(m);
1663 HASHMAP_FOREACH(u, m->units, i) {
1664 if (UNIT_VTABLE(u)->time_change)
1665 UNIT_VTABLE(u)->time_change(u);
1671 case WATCH_JOBS_IN_PROGRESS: {
1674 /* not interested in the data */
1675 read(w->fd, &v, sizeof(v));
1677 manager_print_jobs_in_progress(m);
1682 log_error("event type=%i", w->type);
1683 assert_not_reached("Unknown epoll event type.");
1689 int manager_loop(Manager *m) {
1692 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1695 m->exit_code = MANAGER_RUNNING;
1697 /* Release the path cache */
1698 set_free_free(m->unit_path_cache);
1699 m->unit_path_cache = NULL;
1701 manager_check_finished(m);
1703 /* There might still be some zombies hanging around from
1704 * before we were exec()'ed. Leat's reap them */
1705 r = manager_dispatch_sigchld(m);
1709 while (m->exit_code == MANAGER_RUNNING) {
1710 struct epoll_event event;
1714 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1717 if (!ratelimit_test(&rl)) {
1718 /* Yay, something is going seriously wrong, pause a little */
1719 log_warning("Looping too fast. Throttling execution a little.");
1724 if (manager_dispatch_load_queue(m) > 0)
1727 if (manager_dispatch_gc_queue(m) > 0)
1730 if (manager_dispatch_cleanup_queue(m) > 0)
1733 if (manager_dispatch_cgroup_queue(m) > 0)
1736 if (manager_dispatch_run_queue(m) > 0)
1739 if (bus_dispatch(m) > 0)
1742 if (manager_dispatch_dbus_queue(m) > 0)
1745 if (swap_dispatch_reload(m) > 0)
1748 /* Sleep for half the watchdog time */
1749 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1750 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1756 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1768 r = process_event(m, &event);
1773 return m->exit_code;
1776 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1777 _cleanup_free_ char *n = NULL;
1785 r = unit_name_from_dbus_path(s, &n);
1789 r = manager_load_unit(m, n, NULL, e, &u);
1798 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1807 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1810 r = safe_atou(s + 30, &id);
1814 j = manager_get_job(m, id);
1823 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1829 audit_fd = get_audit_fd();
1833 /* Don't generate audit events if the service was already
1834 * started and we're just deserializing */
1835 if (m->n_reloading > 0)
1838 if (m->running_as != SYSTEMD_SYSTEM)
1841 if (u->type != UNIT_SERVICE)
1844 p = unit_name_to_prefix_and_instance(u->id);
1846 log_error_unit(u->id,
1847 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1851 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1852 if (errno == EPERM) {
1853 /* We aren't allowed to send audit messages?
1854 * Then let's not retry again. */
1857 log_warning("Failed to send audit message: %m");
1865 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1867 union sockaddr_union sa;
1869 char *message = NULL;
1871 /* Don't generate plymouth events if the service was already
1872 * started and we're just deserializing */
1873 if (m->n_reloading > 0)
1876 if (m->running_as != SYSTEMD_SYSTEM)
1879 if (u->type != UNIT_SERVICE &&
1880 u->type != UNIT_MOUNT &&
1881 u->type != UNIT_SWAP)
1884 /* We set SOCK_NONBLOCK here so that we rather drop the
1885 * message then wait for plymouth */
1886 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1888 log_error("socket() failed: %m");
1893 sa.sa.sa_family = AF_UNIX;
1894 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1895 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1897 if (errno != EPIPE &&
1900 errno != ECONNREFUSED &&
1901 errno != ECONNRESET &&
1902 errno != ECONNABORTED)
1903 log_error("connect() failed: %m");
1908 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1914 if (write(fd, message, n + 1) != n + 1) {
1916 if (errno != EPIPE &&
1919 errno != ECONNREFUSED &&
1920 errno != ECONNRESET &&
1921 errno != ECONNABORTED)
1922 log_error("Failed to write Plymouth message: %m");
1929 close_nointr_nofail(fd);
1934 void manager_dispatch_bus_name_owner_changed(
1937 const char* old_owner,
1938 const char *new_owner) {
1945 if (!(u = hashmap_get(m->watch_bus, name)))
1948 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1951 void manager_dispatch_bus_query_pid_done(
1962 if (!(u = hashmap_get(m->watch_bus, name)))
1965 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1968 int manager_open_serialization(Manager *m, FILE **_f) {
1975 if (m->running_as == SYSTEMD_SYSTEM)
1976 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1978 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1983 RUN_WITH_UMASK(0077) {
1984 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1994 log_debug("Serializing state to %s", path);
1997 f = fdopen(fd, "w+");
2006 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2019 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2020 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2021 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2022 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2024 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2025 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2026 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2027 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2030 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2031 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2034 if (!switching_root) {
2035 STRV_FOREACH(e, m->environment) {
2036 _cleanup_free_ char *ce;
2040 fprintf(f, "env=%s\n", *e);
2046 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2050 if (!unit_can_serialize(u))
2057 if ((r = unit_serialize(u, f, fds, !switching_root)) < 0) {
2063 assert(m->n_reloading > 0);
2069 r = bus_fdset_add_all(m, fds);
2076 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2082 log_debug("Deserializing state...");
2087 char line[LINE_MAX], *l;
2089 if (!fgets(line, sizeof(line), f)) {
2104 if (startswith(l, "current-job-id=")) {
2107 if (safe_atou32(l+15, &id) < 0)
2108 log_debug("Failed to parse current job id value %s", l+15);
2110 m->current_job_id = MAX(m->current_job_id, id);
2111 } else if (startswith(l, "n-installed-jobs=")) {
2114 if (safe_atou32(l+17, &n) < 0)
2115 log_debug("Failed to parse installed jobs counter %s", l+17);
2117 m->n_installed_jobs += n;
2118 } else if (startswith(l, "n-failed-jobs=")) {
2121 if (safe_atou32(l+14, &n) < 0)
2122 log_debug("Failed to parse failed jobs counter %s", l+14);
2124 m->n_failed_jobs += n;
2125 } else if (startswith(l, "taint-usr=")) {
2128 if ((b = parse_boolean(l+10)) < 0)
2129 log_debug("Failed to parse taint /usr flag %s", l+10);
2131 m->taint_usr = m->taint_usr || b;
2132 } else if (startswith(l, "firmware-timestamp="))
2133 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2134 else if (startswith(l, "loader-timestamp="))
2135 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2136 else if (startswith(l, "kernel-timestamp="))
2137 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2138 else if (startswith(l, "initrd-timestamp="))
2139 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2140 else if (startswith(l, "userspace-timestamp="))
2141 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2142 else if (startswith(l, "finish-timestamp="))
2143 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2144 else if (startswith(l, "env=")) {
2145 _cleanup_free_ char *uce = NULL;
2148 uce = cunescape(l+4);
2154 e = strv_env_set(m->environment, uce);
2160 strv_free(m->environment);
2163 log_debug("Unknown serialization item '%s'", l);
2168 char name[UNIT_NAME_MAX+2];
2171 if (!fgets(name, sizeof(name), f)) {
2182 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2186 r = unit_deserialize(u, f, fds);
2197 assert(m->n_reloading > 0);
2203 int manager_distribute_fds(Manager *m, FDSet *fds) {
2210 HASHMAP_FOREACH(u, m->units, i) {
2212 if (fdset_size(fds) <= 0)
2215 if (UNIT_VTABLE(u)->distribute_fds) {
2216 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2225 int manager_reload(Manager *m) {
2232 r = manager_open_serialization(m, &f);
2245 r = manager_serialize(m, f, fds, false);
2251 if (fseeko(f, 0, SEEK_SET) < 0) {
2257 /* From here on there is no way back. */
2258 manager_clear_jobs_and_units(m);
2259 manager_undo_generators(m);
2260 lookup_paths_free(&m->lookup_paths);
2262 /* Find new unit paths */
2263 manager_run_generators(m);
2265 q = lookup_paths_init(
2266 &m->lookup_paths, m->running_as, true,
2267 m->generator_unit_path,
2268 m->generator_unit_path_early,
2269 m->generator_unit_path_late);
2273 manager_build_unit_path_cache(m);
2275 /* First, enumerate what we can from all config files */
2276 q = manager_enumerate(m);
2280 /* Second, deserialize our stored data */
2281 q = manager_deserialize(m, f, fds);
2288 /* Third, fire things up! */
2289 q = manager_coldplug(m);
2293 assert(m->n_reloading > 0);
2306 static bool manager_is_booting_or_shutting_down(Manager *m) {
2311 /* Is the initial job still around? */
2312 if (manager_get_job(m, m->default_unit_job_id))
2315 /* Is there a job for the shutdown target? */
2316 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2323 bool manager_is_reloading_or_reexecuting(Manager *m) {
2326 return m->n_reloading != 0;
2329 void manager_reset_failed(Manager *m) {
2335 HASHMAP_FOREACH(u, m->units, i)
2336 unit_reset_failed(u);
2339 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2345 /* Returns true if the unit is inactive or going down */
2346 u = manager_get_unit(m, name);
2350 return unit_inactive_or_pending(u);
2353 void manager_check_finished(Manager *m) {
2354 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2355 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2359 if (m->n_running_jobs == 0)
2360 manager_unwatch_jobs_in_progress(m);
2362 if (hashmap_size(m->jobs) > 0) {
2363 manager_jobs_in_progress_mod_timer(m);
2367 /* Notify Type=idle units that we are done now */
2368 close_pipe(m->idle_pipe);
2370 /* Turn off confirm spawn now */
2371 m->confirm_spawn = false;
2373 if (dual_timestamp_is_set(&m->finish_timestamp))
2376 dual_timestamp_get(&m->finish_timestamp);
2378 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2380 /* Note that m->kernel_usec.monotonic is always at 0,
2381 * and m->firmware_usec.monotonic and
2382 * m->loader_usec.monotonic should be considered
2383 * negative values. */
2385 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2386 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2387 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2388 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2390 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2392 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2393 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2395 if (!log_on_console())
2396 log_struct(LOG_INFO,
2397 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2398 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2399 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2400 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2401 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2402 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2403 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2404 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2405 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2408 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2411 if (!log_on_console())
2412 log_struct(LOG_INFO,
2413 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2414 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2415 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2416 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2417 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2418 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2419 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2423 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2424 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2426 if (!log_on_console())
2427 log_struct(LOG_INFO,
2428 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2429 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2430 "MESSAGE=Startup finished in %s.",
2431 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2435 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2438 "READY=1\nSTATUS=Startup finished in %s.",
2439 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2442 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2453 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2455 p = strappend("/run/systemd/", name);
2459 r = mkdir_p_label(p, 0755);
2461 log_error("Failed to create generator directory %s: %s",
2467 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2472 log_error("Failed to create generator directory %s: %m",
2483 static void trim_generator_dir(Manager *m, char **generator) {
2490 if (rmdir(*generator) >= 0) {
2498 void manager_run_generators(Manager *m) {
2500 const char *generator_path;
2501 const char *argv[5];
2506 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2507 d = opendir(generator_path);
2509 if (errno == ENOENT)
2512 log_error("Failed to enumerate generator directory %s: %m",
2517 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2521 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2525 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2529 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2530 argv[1] = m->generator_unit_path;
2531 argv[2] = m->generator_unit_path_early;
2532 argv[3] = m->generator_unit_path_late;
2535 RUN_WITH_UMASK(0022) {
2536 execute_directory(generator_path, d, (char**) argv);
2539 trim_generator_dir(m, &m->generator_unit_path);
2540 trim_generator_dir(m, &m->generator_unit_path_early);
2541 trim_generator_dir(m, &m->generator_unit_path_late);
2548 static void remove_generator_dir(Manager *m, char **generator) {
2555 strv_remove(m->lookup_paths.unit_path, *generator);
2556 rm_rf(*generator, false, true, false);
2562 void manager_undo_generators(Manager *m) {
2565 remove_generator_dir(m, &m->generator_unit_path);
2566 remove_generator_dir(m, &m->generator_unit_path_early);
2567 remove_generator_dir(m, &m->generator_unit_path_late);
2570 int manager_set_default_environment(Manager *m, char **environment) {
2574 e = strv_env_merge(2, m->environment, environment);
2577 strv_free(m->environment);
2582 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2587 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2588 if (!default_rlimit[i])
2591 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2599 void manager_recheck_journal(Manager *m) {
2604 if (m->running_as != SYSTEMD_SYSTEM)
2607 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2608 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2609 log_close_journal();
2613 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2614 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2615 log_close_journal();
2619 /* Hmm, OK, so the socket is fully up and the service is up
2620 * too, then let's make use of the thing. */
2624 void manager_set_show_status(Manager *m, bool b) {
2627 if (m->running_as != SYSTEMD_SYSTEM)
2633 touch("/run/systemd/show-status");
2635 unlink("/run/systemd/show-status");
2638 static bool manager_get_show_status(Manager *m) {
2641 if (m->running_as != SYSTEMD_SYSTEM)
2647 /* If Plymouth is running make sure we show the status, so
2648 * that there's something nice to see when people press Esc */
2650 return plymouth_running();
2653 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2656 if (!manager_get_show_status(m))
2659 /* XXX We should totally drop the check for ephemeral here
2660 * and thus effectively make 'Type=idle' pointless. */
2661 if (ephemeral && m->n_on_console > 0)
2664 if (!manager_is_booting_or_shutting_down(m))
2667 va_start(ap, format);
2668 status_vprintf(status, true, ephemeral, format, ap);
2672 void watch_init(Watch *w) {
2675 w->type = WATCH_INVALID;