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 "sd-daemon.h"
47 #include "sd-messages.h"
50 #include "transaction.h"
57 #include "ratelimit.h"
58 #include "locale-setup.h"
59 #include "mount-setup.h"
60 #include "unit-name.h"
62 #include "path-lookup.h"
64 #include "exit-status.h"
67 #include "cgroup-util.h"
68 #include "path-util.h"
70 #include "boot-timestamps.h"
72 #include "bus-errors.h"
73 #include "bus-error.h"
76 #include "dbus-unit.h"
78 #include "dbus-manager.h"
80 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
81 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
83 /* Initial delay and the interval for printing status messages about running jobs */
84 #define JOBS_IN_PROGRESS_WAIT_SEC 5
85 #define JOBS_IN_PROGRESS_PERIOD_SEC 1
86 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
88 /* Where clients shall send notification messages to */
89 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
91 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
93 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
94 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
95 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
96 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
97 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
98 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
100 static int manager_setup_notify(Manager *m) {
103 struct sockaddr_un un;
105 .sa.sa_family = AF_UNIX,
109 m->notify_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
110 if (m->notify_fd < 0) {
111 log_error("Failed to allocate notification socket: %m");
115 if (getpid() != 1 || detect_container(NULL) > 0)
116 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
118 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
119 sa.un.sun_path[0] = 0;
121 r = bind(m->notify_fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
123 log_error("bind() failed: %m");
127 r = setsockopt(m->notify_fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
129 log_error("SO_PASSCRED failed: %m");
133 r = sd_event_add_io(m->event, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m, &m->notify_event_source);
135 log_error("Failed to allocate notify event source: %s", strerror(-r));
139 sa.un.sun_path[0] = '@';
140 m->notify_socket = strdup(sa.un.sun_path);
141 if (!m->notify_socket)
144 log_debug("Using notification socket %s", m->notify_socket);
149 static int manager_watch_jobs_in_progress(Manager *m) {
152 if (m->jobs_in_progress_event_source)
155 return sd_event_add_monotonic(m->event, JOBS_IN_PROGRESS_WAIT_SEC, 0, manager_dispatch_jobs_in_progress, m, &m->jobs_in_progress_event_source);
158 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
160 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
163 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
164 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
168 p = mempset(p, ' ', pos-2);
169 p = stpcpy(p, ANSI_RED_ON);
173 if (pos > 0 && pos <= width) {
174 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
178 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
181 p = stpcpy(p, ANSI_RED_ON);
184 p = mempset(p, ' ', width-1-pos);
185 strcpy(p, ANSI_HIGHLIGHT_OFF);
189 static void manager_print_jobs_in_progress(Manager *m) {
190 _cleanup_free_ char *job_of_n = NULL;
193 unsigned counter = 0, print_nr;
194 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
199 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
201 HASHMAP_FOREACH(j, m->jobs, i)
202 if (j->state == JOB_RUNNING && counter++ == print_nr)
205 /* m->n_running_jobs must be consistent with the contents of m->jobs,
206 * so the above loop must have succeeded in finding j. */
207 assert(counter == print_nr + 1);
210 cylon_pos = m->jobs_in_progress_iteration % 14;
212 cylon_pos = 14 - cylon_pos;
213 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
215 if (m->n_running_jobs > 1)
216 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
219 manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
220 strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
222 m->jobs_in_progress_iteration++;
225 static int manager_watch_idle_pipe(Manager *m) {
230 if (m->idle_pipe_event_source)
233 if (m->idle_pipe[2] < 0)
236 r = sd_event_add_io(m->event, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m, &m->idle_pipe_event_source);
238 log_error("Failed to watch idle pipe: %s", strerror(-r));
245 static void manager_close_idle_pipe(Manager *m) {
248 close_pipe(m->idle_pipe);
249 close_pipe(m->idle_pipe + 2);
252 static int manager_setup_time_change(Manager *m) {
255 /* We only care for the cancellation event, hence we set the
256 * timeout to the latest possible value. */
257 struct itimerspec its = {
258 .it_value.tv_sec = TIME_T_MAX,
262 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
264 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
265 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
267 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
268 if (m->time_change_fd < 0) {
269 log_error("Failed to create timerfd: %m");
273 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
274 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
275 close_nointr_nofail(m->time_change_fd);
276 m->time_change_fd = -1;
280 r = sd_event_add_io(m->event, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m, &m->time_change_event_source);
282 log_error("Failed to create time change event source: %s", strerror(-r));
286 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
291 static int enable_special_signals(Manager *m) {
292 _cleanup_close_ int fd = -1;
296 /* Enable that we get SIGINT on control-alt-del. In containers
297 * this will fail with EPERM (older) or EINVAL (newer), so
299 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
300 log_warning("Failed to enable ctrl-alt-del handling: %m");
302 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
304 /* Support systems without virtual console */
306 log_warning("Failed to open /dev/tty0: %m");
308 /* Enable that we get SIGWINCH on kbrequest */
309 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
310 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
316 static int manager_setup_signals(Manager *m) {
317 struct sigaction sa = {
318 .sa_handler = SIG_DFL,
319 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
326 /* We are not interested in SIGSTOP and friends. */
327 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
329 assert_se(sigemptyset(&mask) == 0);
331 sigset_add_many(&mask,
332 SIGCHLD, /* Child died */
333 SIGTERM, /* Reexecute daemon */
334 SIGHUP, /* Reload configuration */
335 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
336 SIGUSR2, /* systemd: dump status */
337 SIGINT, /* Kernel sends us this on control-alt-del */
338 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
339 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
340 SIGRTMIN+0, /* systemd: start default.target */
341 SIGRTMIN+1, /* systemd: isolate rescue.target */
342 SIGRTMIN+2, /* systemd: isolate emergency.target */
343 SIGRTMIN+3, /* systemd: start halt.target */
344 SIGRTMIN+4, /* systemd: start poweroff.target */
345 SIGRTMIN+5, /* systemd: start reboot.target */
346 SIGRTMIN+6, /* systemd: start kexec.target */
347 SIGRTMIN+13, /* systemd: Immediate halt */
348 SIGRTMIN+14, /* systemd: Immediate poweroff */
349 SIGRTMIN+15, /* systemd: Immediate reboot */
350 SIGRTMIN+16, /* systemd: Immediate kexec */
351 SIGRTMIN+20, /* systemd: enable status messages */
352 SIGRTMIN+21, /* systemd: disable status messages */
353 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
354 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
355 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
356 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
357 SIGRTMIN+27, /* systemd: set log target to console */
358 SIGRTMIN+28, /* systemd: set log target to kmsg */
359 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
361 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
363 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
364 if (m->signal_fd < 0)
367 r = sd_event_add_io(m->event, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m, &m->signal_event_source);
371 if (m->running_as == SYSTEMD_SYSTEM)
372 return enable_special_signals(m);
377 static int manager_default_environment(Manager *m) {
380 if (m->running_as == SYSTEMD_SYSTEM) {
381 /* The system manager always starts with a clean
382 * environment for its children. It does not import
383 * the kernel or the parents exported variables.
385 * The initial passed environ is untouched to keep
386 * /proc/self/environ valid; it is used for tagging
387 * the init process inside containers. */
388 m->environment = strv_new("PATH=" DEFAULT_PATH,
391 /* Import locale variables LC_*= from configuration */
392 locale_setup(&m->environment);
394 /* The user manager passes its own environment
395 * along to its children. */
396 m->environment = strv_copy(environ);
401 strv_sort(m->environment);
406 int manager_new(SystemdRunningAs running_as, bool reexecuting, Manager **_m) {
409 bool try_bus_connect = false;
412 assert(running_as >= 0);
413 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
415 m = new0(Manager, 1);
420 if (detect_container(NULL) <= 0)
421 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
424 m->running_as = running_as;
425 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
427 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
429 m->pin_cgroupfs_fd = m->notify_fd = m->signal_fd = m->time_change_fd = m->dev_autofs_fd = m->private_listen_fd = -1;
430 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
432 r = manager_default_environment(m);
436 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
440 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
444 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
448 r = hashmap_ensure_allocated(&m->watch_pids, trivial_hash_func, trivial_compare_func);
452 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
456 r = sd_event_default(&m->event);
460 r = sd_event_add_defer(m->event, manager_dispatch_run_queue, m, &m->run_queue_event_source);
464 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
468 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
472 r = manager_setup_signals(m);
476 r = manager_setup_cgroup(m);
480 r = manager_setup_notify(m);
484 r = manager_setup_time_change(m);
488 if (running_as == SYSTEMD_SYSTEM)
489 try_bus_connect = reexecuting;
490 else if (getenv("DBUS_SESSION_BUS_ADDRESS"))
491 try_bus_connect = true;
493 log_debug("Skipping DBus session bus connection attempt - no DBUS_SESSION_BUS_ADDRESS set...");
495 /* Try to connect to the busses, if possible. */
496 r = bus_init(m, try_bus_connect);
500 m->taint_usr = dir_is_empty("/usr") > 0;
510 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
516 while ((u = m->cleanup_queue)) {
517 assert(u->in_cleanup_queue);
527 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
528 GC_OFFSET_UNSURE, /* No clue */
529 GC_OFFSET_GOOD, /* We still need this unit */
530 GC_OFFSET_BAD, /* We don't need this unit anymore */
534 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
541 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
542 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
543 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
546 if (u->in_cleanup_queue)
549 if (unit_check_gc(u))
552 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
556 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
557 unit_gc_sweep(other, gc_marker);
559 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
562 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
569 /* We were unable to find anything out about this entry, so
570 * let's investigate it later */
571 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
572 unit_add_to_gc_queue(u);
576 /* We definitely know that this one is not useful anymore, so
577 * let's mark it for deletion */
578 u->gc_marker = gc_marker + GC_OFFSET_BAD;
579 unit_add_to_cleanup_queue(u);
583 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
586 static unsigned manager_dispatch_gc_queue(Manager *m) {
593 /* log_debug("Running GC..."); */
595 m->gc_marker += _GC_OFFSET_MAX;
596 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
599 gc_marker = m->gc_marker;
601 while ((u = m->gc_queue)) {
602 assert(u->in_gc_queue);
604 unit_gc_sweep(u, gc_marker);
606 LIST_REMOVE(gc_queue, m->gc_queue, u);
607 u->in_gc_queue = false;
611 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
612 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
613 log_debug_unit(u->id, "Collecting %s", u->id);
614 u->gc_marker = gc_marker + GC_OFFSET_BAD;
615 unit_add_to_cleanup_queue(u);
619 m->n_in_gc_queue = 0;
624 static void manager_clear_jobs_and_units(Manager *m) {
629 while ((u = hashmap_first(m->units)))
632 manager_dispatch_cleanup_queue(m);
634 assert(!m->load_queue);
635 assert(!m->run_queue);
636 assert(!m->dbus_unit_queue);
637 assert(!m->dbus_job_queue);
638 assert(!m->cleanup_queue);
639 assert(!m->gc_queue);
641 assert(hashmap_isempty(m->jobs));
642 assert(hashmap_isempty(m->units));
645 m->n_running_jobs = 0;
648 void manager_free(Manager *m) {
654 manager_clear_jobs_and_units(m);
656 for (c = 0; c < _UNIT_TYPE_MAX; c++)
657 if (unit_vtable[c]->shutdown)
658 unit_vtable[c]->shutdown(m);
660 /* If we reexecute ourselves, we keep the root cgroup
662 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
664 manager_undo_generators(m);
668 hashmap_free(m->units);
669 hashmap_free(m->jobs);
670 hashmap_free(m->watch_pids);
671 hashmap_free(m->watch_bus);
673 sd_event_source_unref(m->signal_event_source);
674 sd_event_source_unref(m->notify_event_source);
675 sd_event_source_unref(m->time_change_event_source);
676 sd_event_source_unref(m->jobs_in_progress_event_source);
677 sd_event_source_unref(m->idle_pipe_event_source);
678 sd_event_source_unref(m->run_queue_event_source);
680 if (m->signal_fd >= 0)
681 close_nointr_nofail(m->signal_fd);
682 if (m->notify_fd >= 0)
683 close_nointr_nofail(m->notify_fd);
684 if (m->time_change_fd >= 0)
685 close_nointr_nofail(m->time_change_fd);
687 manager_close_idle_pipe(m);
689 sd_event_unref(m->event);
691 free(m->notify_socket);
693 lookup_paths_free(&m->lookup_paths);
694 strv_free(m->environment);
696 hashmap_free(m->cgroup_unit);
697 set_free_free(m->unit_path_cache);
699 free(m->switch_root);
700 free(m->switch_root_init);
702 for (i = 0; i < RLIMIT_NLIMITS; i++)
705 assert(hashmap_isempty(m->units_requiring_mounts_for));
706 hashmap_free(m->units_requiring_mounts_for);
711 int manager_enumerate(Manager *m) {
717 /* Let's ask every type to load all units from disk/kernel
718 * that it might know */
719 for (c = 0; c < _UNIT_TYPE_MAX; c++)
720 if (unit_vtable[c]->enumerate) {
721 q = unit_vtable[c]->enumerate(m);
726 manager_dispatch_load_queue(m);
730 static int manager_coldplug(Manager *m) {
738 /* Then, let's set up their initial state. */
739 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
745 if ((q = unit_coldplug(u)) < 0)
752 static void manager_build_unit_path_cache(Manager *m) {
754 _cleanup_free_ DIR *d = NULL;
759 set_free_free(m->unit_path_cache);
761 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
762 if (!m->unit_path_cache) {
763 log_error("Failed to allocate unit path cache.");
767 /* This simply builds a list of files we know exist, so that
768 * we don't always have to go to disk */
770 STRV_FOREACH(i, m->lookup_paths.unit_path) {
776 log_error("Failed to open directory %s: %m", *i);
780 while ((de = readdir(d))) {
783 if (ignore_file(de->d_name))
786 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
792 r = set_consume(m->unit_path_cache, p);
804 log_error("Failed to build unit path cache: %s", strerror(-r));
806 set_free_free(m->unit_path_cache);
807 m->unit_path_cache = NULL;
811 static int manager_distribute_fds(Manager *m, FDSet *fds) {
818 HASHMAP_FOREACH(u, m->units, i) {
820 if (fdset_size(fds) <= 0)
823 if (UNIT_VTABLE(u)->distribute_fds) {
824 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
833 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
838 dual_timestamp_get(&m->generators_start_timestamp);
839 manager_run_generators(m);
840 dual_timestamp_get(&m->generators_finish_timestamp);
842 r = lookup_paths_init(
843 &m->lookup_paths, m->running_as, true,
844 m->generator_unit_path,
845 m->generator_unit_path_early,
846 m->generator_unit_path_late);
850 manager_build_unit_path_cache(m);
852 /* If we will deserialize make sure that during enumeration
853 * this is already known, so we increase the counter here
858 /* First, enumerate what we can from all config files */
859 dual_timestamp_get(&m->units_load_start_timestamp);
860 r = manager_enumerate(m);
861 dual_timestamp_get(&m->units_load_finish_timestamp);
863 /* Second, deserialize if there is something to deserialize */
865 q = manager_deserialize(m, serialization, fds);
870 /* Any fds left? Find some unit which wants them. This is
871 * useful to allow container managers to pass some file
872 * descriptors to us pre-initialized. This enables
873 * socket-based activation of entire containers. */
874 if (fdset_size(fds) > 0) {
875 q = manager_distribute_fds(m, fds);
880 /* Third, fire things up! */
881 q = manager_coldplug(m);
886 assert(m->n_reloading > 0);
889 /* Let's wait for the UnitNew/JobNew messages being
890 * sent, before we notify that the reload is
892 m->send_reloading_done = true;
898 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
903 assert(type < _JOB_TYPE_MAX);
905 assert(mode < _JOB_MODE_MAX);
907 if (mode == JOB_ISOLATE && type != JOB_START) {
908 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
912 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
913 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
917 log_debug_unit(unit->id,
918 "Trying to enqueue job %s/%s/%s", unit->id,
919 job_type_to_string(type), job_mode_to_string(mode));
921 job_type_collapse(&type, unit);
923 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
927 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
928 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
929 mode == JOB_IGNORE_DEPENDENCIES, e);
933 if (mode == JOB_ISOLATE) {
934 r = transaction_add_isolate_jobs(tr, m);
939 r = transaction_activate(tr, m, mode, e);
943 log_debug_unit(unit->id,
944 "Enqueued job %s/%s as %u", unit->id,
945 job_type_to_string(type), (unsigned) tr->anchor_job->id);
948 *_ret = tr->anchor_job;
950 transaction_free(tr);
954 transaction_abort(tr);
955 transaction_free(tr);
959 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
964 assert(type < _JOB_TYPE_MAX);
966 assert(mode < _JOB_MODE_MAX);
968 r = manager_load_unit(m, name, NULL, NULL, &unit);
972 return manager_add_job(m, type, unit, mode, override, e, _ret);
975 Job *manager_get_job(Manager *m, uint32_t id) {
978 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
981 Unit *manager_get_unit(Manager *m, const char *name) {
985 return hashmap_get(m->units, name);
988 unsigned manager_dispatch_load_queue(Manager *m) {
994 /* Make sure we are not run recursively */
995 if (m->dispatching_load_queue)
998 m->dispatching_load_queue = true;
1000 /* Dispatches the load queue. Takes a unit from the queue and
1001 * tries to load its data until the queue is empty */
1003 while ((u = m->load_queue)) {
1004 assert(u->in_load_queue);
1010 m->dispatching_load_queue = false;
1014 int manager_load_unit_prepare(
1026 assert(name || path);
1028 /* This will prepare the unit for loading, but not actually
1029 * load anything from disk. */
1031 if (path && !is_path(path))
1032 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1035 name = path_get_file_name(path);
1037 t = unit_name_to_type(name);
1039 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false))
1040 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1042 ret = manager_get_unit(m, name);
1048 ret = unit_new(m, unit_vtable[t]->object_size);
1053 ret->fragment_path = strdup(path);
1054 if (!ret->fragment_path) {
1060 r = unit_add_name(ret, name);
1066 unit_add_to_load_queue(ret);
1067 unit_add_to_dbus_queue(ret);
1068 unit_add_to_gc_queue(ret);
1076 int manager_load_unit(
1087 /* This will load the service information files, but not actually
1088 * start any services or anything. */
1090 r = manager_load_unit_prepare(m, name, path, e, _ret);
1094 manager_dispatch_load_queue(m);
1097 *_ret = unit_follow_merge(*_ret);
1102 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1109 HASHMAP_FOREACH(j, s->jobs, i)
1110 job_dump(j, f, prefix);
1113 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1121 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1123 unit_dump(u, f, prefix);
1126 void manager_clear_jobs(Manager *m) {
1131 while ((j = hashmap_first(m->jobs)))
1132 /* No need to recurse. We're cancelling all jobs. */
1133 job_finish_and_invalidate(j, JOB_CANCELED, false);
1136 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1137 Manager *m = userdata;
1143 while ((j = m->run_queue)) {
1144 assert(j->installed);
1145 assert(j->in_run_queue);
1147 job_run_and_invalidate(j);
1150 if (m->n_running_jobs > 0)
1151 manager_watch_jobs_in_progress(m);
1153 if (m->n_on_console > 0)
1154 manager_watch_idle_pipe(m);
1159 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1166 if (m->dispatching_dbus_queue)
1169 m->dispatching_dbus_queue = true;
1171 while ((u = m->dbus_unit_queue)) {
1172 assert(u->in_dbus_queue);
1174 bus_unit_send_change_signal(u);
1178 while ((j = m->dbus_job_queue)) {
1179 assert(j->in_dbus_queue);
1181 bus_job_send_change_signal(j);
1185 m->dispatching_dbus_queue = false;
1187 if (m->send_reloading_done) {
1188 m->send_reloading_done = false;
1190 bus_manager_send_reloading(m, false);
1193 if (m->queued_message)
1194 bus_send_queued_message(m);
1199 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1200 Manager *m = userdata;
1204 assert(m->notify_fd == fd);
1206 if (revents != EPOLLIN) {
1207 log_warning("Got unexpected poll event for notify fd.");
1213 struct iovec iovec = {
1215 .iov_len = sizeof(buf)-1,
1219 struct cmsghdr cmsghdr;
1220 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1223 struct msghdr msghdr = {
1226 .msg_control = &control,
1227 .msg_controllen = sizeof(control),
1229 struct ucred *ucred;
1231 _cleanup_strv_free_ char **tags = NULL;
1233 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1238 if (errno == EAGAIN || errno == EINTR)
1244 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1245 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1246 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1247 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1248 log_warning("Received notify message without credentials. Ignoring.");
1252 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1254 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1256 u = manager_get_unit_by_pid(m, ucred->pid);
1258 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1263 assert((size_t) n < sizeof(buf));
1265 tags = strv_split(buf, "\n\r");
1269 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1271 if (UNIT_VTABLE(u)->notify_message)
1272 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1278 static int manager_dispatch_sigchld(Manager *m) {
1286 /* First we call waitd() for a PID and do not reap the
1287 * zombie. That way we can still access /proc/$PID for
1288 * it while it is a zombie. */
1289 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1291 if (errno == ECHILD)
1303 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1304 _cleanup_free_ char *name = NULL;
1306 get_process_comm(si.si_pid, &name);
1307 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1310 /* Let's flush any message the dying child might still
1311 * have queued for us. This ensures that the process
1312 * still exists in /proc so that we can figure out
1313 * which cgroup and hence unit it belongs to. */
1314 r = manager_dispatch_notify_fd(m->notify_event_source, m->notify_fd, EPOLLIN, m);
1318 /* And now figure out the unit this belongs to */
1319 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1321 u = manager_get_unit_by_pid(m, si.si_pid);
1323 /* And now, we actually reap the zombie. */
1324 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1331 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1334 log_debug("Child %lu died (code=%s, status=%i/%s)",
1335 (long unsigned) si.si_pid,
1336 sigchld_code_to_string(si.si_code),
1338 strna(si.si_code == CLD_EXITED
1339 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1340 : signal_to_string(si.si_status)));
1345 log_debug_unit(u->id,
1346 "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1348 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1349 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1355 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1356 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1359 log_debug_unit(name, "Activating special unit %s", name);
1361 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1363 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1368 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1369 Manager *m = userdata;
1371 struct signalfd_siginfo sfsi;
1372 bool sigchld = false;
1375 assert(m->signal_fd == fd);
1377 if (revents != EPOLLIN) {
1378 log_warning("Got unexpected events from signal file descriptor.");
1383 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1384 if (n != sizeof(sfsi)) {
1389 if (errno == EINTR || errno == EAGAIN)
1395 if (sfsi.ssi_pid > 0) {
1398 get_process_comm(sfsi.ssi_pid, &p);
1400 log_debug("Received SIG%s from PID %lu (%s).",
1401 signal_to_string(sfsi.ssi_signo),
1402 (unsigned long) sfsi.ssi_pid, strna(p));
1405 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1407 switch (sfsi.ssi_signo) {
1414 if (m->running_as == SYSTEMD_SYSTEM) {
1415 /* This is for compatibility with the
1416 * original sysvinit */
1417 m->exit_code = MANAGER_REEXECUTE;
1424 if (m->running_as == SYSTEMD_SYSTEM) {
1425 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1429 /* Run the exit target if there is one, if not, just exit. */
1430 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1431 m->exit_code = MANAGER_EXIT;
1438 if (m->running_as == SYSTEMD_SYSTEM)
1439 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1441 /* This is a nop on non-init */
1445 if (m->running_as == SYSTEMD_SYSTEM)
1446 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1448 /* This is a nop on non-init */
1454 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1456 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1457 log_info("Trying to reconnect to bus...");
1461 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1462 log_info("Loading D-Bus service...");
1463 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1470 _cleanup_free_ char *dump = NULL;
1471 _cleanup_fclose_ FILE *f = NULL;
1474 f = open_memstream(&dump, &size);
1476 log_warning("Failed to allocate memory stream.");
1480 manager_dump_units(m, f, "\t");
1481 manager_dump_jobs(m, f, "\t");
1484 log_warning("Failed to write status stream");
1488 log_dump(LOG_INFO, dump);
1493 m->exit_code = MANAGER_RELOAD;
1498 /* Starting SIGRTMIN+0 */
1499 static const char * const target_table[] = {
1500 [0] = SPECIAL_DEFAULT_TARGET,
1501 [1] = SPECIAL_RESCUE_TARGET,
1502 [2] = SPECIAL_EMERGENCY_TARGET,
1503 [3] = SPECIAL_HALT_TARGET,
1504 [4] = SPECIAL_POWEROFF_TARGET,
1505 [5] = SPECIAL_REBOOT_TARGET,
1506 [6] = SPECIAL_KEXEC_TARGET
1509 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1510 static const ManagerExitCode code_table[] = {
1512 [1] = MANAGER_POWEROFF,
1513 [2] = MANAGER_REBOOT,
1517 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1518 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1519 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1520 manager_start_target(m, target_table[idx],
1521 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1525 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1526 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1527 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1531 switch (sfsi.ssi_signo - SIGRTMIN) {
1534 log_debug("Enabling showing of status.");
1535 manager_set_show_status(m, true);
1539 log_debug("Disabling showing of status.");
1540 manager_set_show_status(m, false);
1544 log_set_max_level(LOG_DEBUG);
1545 log_notice("Setting log level to debug.");
1549 log_set_max_level(LOG_INFO);
1550 log_notice("Setting log level to info.");
1554 if (m->running_as == SYSTEMD_USER) {
1555 m->exit_code = MANAGER_EXIT;
1559 /* This is a nop on init */
1563 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1564 log_notice("Setting log target to journal-or-kmsg.");
1568 log_set_target(LOG_TARGET_CONSOLE);
1569 log_notice("Setting log target to console.");
1573 log_set_target(LOG_TARGET_KMSG);
1574 log_notice("Setting log target to kmsg.");
1578 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1579 log_notice("Setting log target to syslog-or-kmsg.");
1583 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1590 return manager_dispatch_sigchld(m);
1595 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1596 Manager *m = userdata;
1601 assert(m->time_change_fd == fd);
1603 log_struct(LOG_INFO,
1604 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1605 "MESSAGE=Time has been changed",
1608 /* Restart the watch */
1609 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1611 close_nointr_nofail(m->time_change_fd);
1612 m->time_change_fd = -1;
1614 manager_setup_time_change(m);
1616 HASHMAP_FOREACH(u, m->units, i)
1617 if (UNIT_VTABLE(u)->time_change)
1618 UNIT_VTABLE(u)->time_change(u);
1623 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1624 Manager *m = userdata;
1627 assert(m->idle_pipe[2] == fd);
1629 m->no_console_output = m->n_on_console > 0;
1631 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1632 manager_close_idle_pipe(m);
1637 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1638 Manager *m = userdata;
1642 manager_print_jobs_in_progress(m);
1646 int manager_loop(Manager *m) {
1649 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1652 m->exit_code = MANAGER_RUNNING;
1654 /* Release the path cache */
1655 set_free_free(m->unit_path_cache);
1656 m->unit_path_cache = NULL;
1658 manager_check_finished(m);
1660 /* There might still be some zombies hanging around from
1661 * before we were exec()'ed. Let's reap them. */
1662 r = manager_dispatch_sigchld(m);
1666 while (m->exit_code == MANAGER_RUNNING) {
1669 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1672 if (!ratelimit_test(&rl)) {
1673 /* Yay, something is going seriously wrong, pause a little */
1674 log_warning("Looping too fast. Throttling execution a little.");
1679 if (manager_dispatch_load_queue(m) > 0)
1682 if (manager_dispatch_gc_queue(m) > 0)
1685 if (manager_dispatch_cleanup_queue(m) > 0)
1688 if (manager_dispatch_cgroup_queue(m) > 0)
1691 if (manager_dispatch_dbus_queue(m) > 0)
1694 /* Sleep for half the watchdog time */
1695 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1696 wait_usec = m->runtime_watchdog / 2;
1700 wait_usec = (usec_t) -1;
1702 r = sd_event_run(m->event, wait_usec);
1704 log_error("Failed to run event loop: %s", strerror(-r));
1709 return m->exit_code;
1712 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1713 _cleanup_free_ char *n = NULL;
1721 r = unit_name_from_dbus_path(s, &n);
1725 r = manager_load_unit(m, n, NULL, e, &u);
1734 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1744 p = startswith(s, "/org/freedesktop/systemd1/job/");
1748 r = safe_atou(p, &id);
1752 j = manager_get_job(m, id);
1761 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1767 audit_fd = get_audit_fd();
1771 /* Don't generate audit events if the service was already
1772 * started and we're just deserializing */
1773 if (m->n_reloading > 0)
1776 if (m->running_as != SYSTEMD_SYSTEM)
1779 if (u->type != UNIT_SERVICE)
1782 p = unit_name_to_prefix_and_instance(u->id);
1784 log_error_unit(u->id,
1785 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1789 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1790 if (errno == EPERM) {
1791 /* We aren't allowed to send audit messages?
1792 * Then let's not retry again. */
1795 log_warning("Failed to send audit message: %m");
1803 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1805 union sockaddr_union sa;
1807 char *message = NULL;
1809 /* Don't generate plymouth events if the service was already
1810 * started and we're just deserializing */
1811 if (m->n_reloading > 0)
1814 if (m->running_as != SYSTEMD_SYSTEM)
1817 if (detect_container(NULL) > 0)
1820 if (u->type != UNIT_SERVICE &&
1821 u->type != UNIT_MOUNT &&
1822 u->type != UNIT_SWAP)
1825 /* We set SOCK_NONBLOCK here so that we rather drop the
1826 * message then wait for plymouth */
1827 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1829 log_error("socket() failed: %m");
1834 sa.sa.sa_family = AF_UNIX;
1835 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1836 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1838 if (errno != EPIPE &&
1841 errno != ECONNREFUSED &&
1842 errno != ECONNRESET &&
1843 errno != ECONNABORTED)
1844 log_error("connect() failed: %m");
1849 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1855 if (write(fd, message, n + 1) != n + 1) {
1857 if (errno != EPIPE &&
1860 errno != ECONNREFUSED &&
1861 errno != ECONNRESET &&
1862 errno != ECONNABORTED)
1863 log_error("Failed to write Plymouth message: %m");
1870 close_nointr_nofail(fd);
1875 void manager_dispatch_bus_name_owner_changed(
1878 const char* old_owner,
1879 const char *new_owner) {
1886 u = hashmap_get(m->watch_bus, name);
1890 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1893 int manager_open_serialization(Manager *m, FILE **_f) {
1900 if (m->running_as == SYSTEMD_SYSTEM)
1901 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1903 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1908 RUN_WITH_UMASK(0077) {
1909 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1919 log_debug("Serializing state to %s", path);
1922 f = fdopen(fd, "w+");
1931 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
1944 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1945 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1946 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1947 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1949 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1950 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1951 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1952 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1955 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1956 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1957 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
1958 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
1959 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
1960 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
1961 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
1962 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
1965 if (!switching_root) {
1966 STRV_FOREACH(e, m->environment) {
1967 _cleanup_free_ char *ce;
1971 fprintf(f, "env=%s\n", *e);
1975 bus_serialize(m, f);
1979 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1983 if (!unit_can_serialize(u))
1990 r = unit_serialize(u, f, fds, !switching_root);
1997 assert(m->n_reloading > 0);
2003 r = bus_fdset_add_all(m, fds);
2010 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2016 log_debug("Deserializing state...");
2021 char line[LINE_MAX], *l;
2023 if (!fgets(line, sizeof(line), f)) {
2038 if (startswith(l, "current-job-id=")) {
2041 if (safe_atou32(l+15, &id) < 0)
2042 log_debug("Failed to parse current job id value %s", l+15);
2044 m->current_job_id = MAX(m->current_job_id, id);
2046 } else if (startswith(l, "n-installed-jobs=")) {
2049 if (safe_atou32(l+17, &n) < 0)
2050 log_debug("Failed to parse installed jobs counter %s", l+17);
2052 m->n_installed_jobs += n;
2054 } else if (startswith(l, "n-failed-jobs=")) {
2057 if (safe_atou32(l+14, &n) < 0)
2058 log_debug("Failed to parse failed jobs counter %s", l+14);
2060 m->n_failed_jobs += n;
2062 } else if (startswith(l, "taint-usr=")) {
2065 if ((b = parse_boolean(l+10)) < 0)
2066 log_debug("Failed to parse taint /usr flag %s", l+10);
2068 m->taint_usr = m->taint_usr || b;
2070 } else if (startswith(l, "firmware-timestamp="))
2071 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2072 else if (startswith(l, "loader-timestamp="))
2073 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2074 else if (startswith(l, "kernel-timestamp="))
2075 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2076 else if (startswith(l, "initrd-timestamp="))
2077 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2078 else if (startswith(l, "userspace-timestamp="))
2079 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2080 else if (startswith(l, "finish-timestamp="))
2081 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2082 else if (startswith(l, "security-start-timestamp="))
2083 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2084 else if (startswith(l, "security-finish-timestamp="))
2085 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2086 else if (startswith(l, "generators-start-timestamp="))
2087 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2088 else if (startswith(l, "generators-finish-timestamp="))
2089 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2090 else if (startswith(l, "units-load-start-timestamp="))
2091 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2092 else if (startswith(l, "units-load-finish-timestamp="))
2093 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2094 else if (startswith(l, "env=")) {
2095 _cleanup_free_ char *uce = NULL;
2098 uce = cunescape(l+4);
2104 e = strv_env_set(m->environment, uce);
2110 strv_free(m->environment);
2112 } else if (bus_deserialize_item(m, l) == 0)
2113 log_debug("Unknown serialization item '%s'", l);
2118 char name[UNIT_NAME_MAX+2];
2121 if (!fgets(name, sizeof(name), f)) {
2132 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2136 r = unit_deserialize(u, f, fds);
2147 assert(m->n_reloading > 0);
2153 int manager_reload(Manager *m) {
2155 _cleanup_fclose_ FILE *f = NULL;
2156 _cleanup_fdset_free_ FDSet *fds = NULL;
2160 r = manager_open_serialization(m, &f);
2165 bus_manager_send_reloading(m, true);
2173 r = manager_serialize(m, f, fds, false);
2179 if (fseeko(f, 0, SEEK_SET) < 0) {
2184 /* From here on there is no way back. */
2185 manager_clear_jobs_and_units(m);
2186 manager_undo_generators(m);
2187 lookup_paths_free(&m->lookup_paths);
2189 /* Find new unit paths */
2190 manager_run_generators(m);
2192 q = lookup_paths_init(
2193 &m->lookup_paths, m->running_as, true,
2194 m->generator_unit_path,
2195 m->generator_unit_path_early,
2196 m->generator_unit_path_late);
2200 manager_build_unit_path_cache(m);
2202 /* First, enumerate what we can from all config files */
2203 q = manager_enumerate(m);
2207 /* Second, deserialize our stored data */
2208 q = manager_deserialize(m, f, fds);
2215 /* Third, fire things up! */
2216 q = manager_coldplug(m);
2220 assert(m->n_reloading > 0);
2223 m->send_reloading_done = true;
2228 static bool manager_is_booting_or_shutting_down(Manager *m) {
2233 /* Is the initial job still around? */
2234 if (manager_get_job(m, m->default_unit_job_id))
2237 /* Is there a job for the shutdown target? */
2238 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2245 bool manager_is_reloading_or_reexecuting(Manager *m) {
2248 return m->n_reloading != 0;
2251 void manager_reset_failed(Manager *m) {
2257 HASHMAP_FOREACH(u, m->units, i)
2258 unit_reset_failed(u);
2261 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2267 /* Returns true if the unit is inactive or going down */
2268 u = manager_get_unit(m, name);
2272 return unit_inactive_or_pending(u);
2275 void manager_check_finished(Manager *m) {
2276 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2277 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2281 if (m->n_running_jobs == 0)
2282 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2284 if (hashmap_size(m->jobs) > 0) {
2285 if (m->jobs_in_progress_event_source)
2286 sd_event_source_set_time(m->jobs_in_progress_event_source, JOBS_IN_PROGRESS_PERIOD_SEC);
2290 /* Notify Type=idle units that we are done now */
2291 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2292 manager_close_idle_pipe(m);
2294 /* Turn off confirm spawn now */
2295 m->confirm_spawn = false;
2297 if (dual_timestamp_is_set(&m->finish_timestamp))
2300 dual_timestamp_get(&m->finish_timestamp);
2302 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2304 /* Note that m->kernel_usec.monotonic is always at 0,
2305 * and m->firmware_usec.monotonic and
2306 * m->loader_usec.monotonic should be considered
2307 * negative values. */
2309 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2310 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2311 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2312 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2314 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2316 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2317 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2319 if (!log_on_console())
2320 log_struct(LOG_INFO,
2321 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2322 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2323 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2324 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2325 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2326 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2327 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2328 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2329 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2332 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2335 if (!log_on_console())
2336 log_struct(LOG_INFO,
2337 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2338 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2339 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2340 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2341 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2342 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2343 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2347 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2348 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2350 if (!log_on_console())
2351 log_struct(LOG_INFO,
2352 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2353 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2354 "MESSAGE=Startup finished in %s.",
2355 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2359 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2362 "READY=1\nSTATUS=Startup finished in %s.",
2363 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2366 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2377 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2379 p = strappend("/run/systemd/", name);
2383 r = mkdir_p_label(p, 0755);
2385 log_error("Failed to create generator directory %s: %s",
2391 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2396 log_error("Failed to create generator directory %s: %m",
2407 static void trim_generator_dir(Manager *m, char **generator) {
2414 if (rmdir(*generator) >= 0) {
2422 void manager_run_generators(Manager *m) {
2423 _cleanup_closedir_ DIR *d = NULL;
2424 const char *generator_path;
2425 const char *argv[5];
2430 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2431 d = opendir(generator_path);
2433 if (errno == ENOENT)
2436 log_error("Failed to enumerate generator directory %s: %m",
2441 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2445 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2449 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2453 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2454 argv[1] = m->generator_unit_path;
2455 argv[2] = m->generator_unit_path_early;
2456 argv[3] = m->generator_unit_path_late;
2459 RUN_WITH_UMASK(0022)
2460 execute_directory(generator_path, d, (char**) argv);
2463 trim_generator_dir(m, &m->generator_unit_path);
2464 trim_generator_dir(m, &m->generator_unit_path_early);
2465 trim_generator_dir(m, &m->generator_unit_path_late);
2468 static void remove_generator_dir(Manager *m, char **generator) {
2475 strv_remove(m->lookup_paths.unit_path, *generator);
2476 rm_rf(*generator, false, true, false);
2482 void manager_undo_generators(Manager *m) {
2485 remove_generator_dir(m, &m->generator_unit_path);
2486 remove_generator_dir(m, &m->generator_unit_path_early);
2487 remove_generator_dir(m, &m->generator_unit_path_late);
2490 int manager_environment_add(Manager *m, char **minus, char **plus) {
2491 char **a = NULL, **b = NULL, **l;
2496 if (!strv_isempty(minus)) {
2497 a = strv_env_delete(l, 1, minus);
2504 if (!strv_isempty(plus)) {
2505 b = strv_env_merge(2, l, plus);
2512 if (m->environment != l)
2513 strv_free(m->environment);
2519 m->environment = strv_sort(l);
2523 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2528 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2529 if (!default_rlimit[i])
2532 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2540 void manager_recheck_journal(Manager *m) {
2545 if (m->running_as != SYSTEMD_SYSTEM)
2548 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2549 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2550 log_close_journal();
2554 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2555 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2556 log_close_journal();
2560 /* Hmm, OK, so the socket is fully up and the service is up
2561 * too, then let's make use of the thing. */
2565 void manager_set_show_status(Manager *m, bool b) {
2568 if (m->running_as != SYSTEMD_SYSTEM)
2574 touch("/run/systemd/show-status");
2576 unlink("/run/systemd/show-status");
2579 static bool manager_get_show_status(Manager *m) {
2582 if (m->running_as != SYSTEMD_SYSTEM)
2585 if (m->no_console_output)
2591 /* If Plymouth is running make sure we show the status, so
2592 * that there's something nice to see when people press Esc */
2594 return plymouth_running();
2597 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2600 if (!manager_get_show_status(m))
2603 /* XXX We should totally drop the check for ephemeral here
2604 * and thus effectively make 'Type=idle' pointless. */
2605 if (ephemeral && m->n_on_console > 0)
2608 if (!manager_is_booting_or_shutting_down(m))
2611 va_start(ap, format);
2612 status_vprintf(status, true, ephemeral, format, ap);
2616 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2617 _cleanup_free_ char *p = NULL;
2625 p = unit_name_from_path(path, suffix);
2629 found = manager_get_unit(m, p);
2639 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2640 char p[strlen(path)+1];
2646 path_kill_slashes(p);
2648 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);