X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fmanager.c;h=df75eca8c48d6167bcc468b33d3662c7309d93d1;hp=a643263213a2988c563a03f5f6d7b7f9d76075d5;hb=e03ae6615a1fe9a2aee854d00c3fc7397a06983d;hpb=1e001f52d20a4685c9e8cf3cfa690021ca05c9e7 diff --git a/src/manager.c b/src/manager.c index a64326321..df75eca8c 100644 --- a/src/manager.c +++ b/src/manager.c @@ -1,4 +1,4 @@ -/*-*- Mode: C; c-basic-offset: 8 -*-*/ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ /*** This file is part of systemd. @@ -27,7 +27,6 @@ #include #include #include -#include #include #include #include @@ -36,6 +35,11 @@ #include #include #include +#include + +#ifdef HAVE_AUDIT +#include +#endif #include "manager.h" #include "hashmap.h" @@ -46,7 +50,6 @@ #include "ratelimit.h" #include "cgroup.h" #include "mount-setup.h" -#include "utmp-wtmp.h" #include "unit-name.h" #include "dbus-unit.h" #include "dbus-job.h" @@ -54,6 +57,7 @@ #include "path-lookup.h" #include "special.h" #include "bus-errors.h" +#include "exit-status.h" /* As soon as 16 units are in our GC queue, make sure to run a gc sweep */ #define GC_QUEUE_ENTRIES_MAX 16 @@ -62,7 +66,8 @@ #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC) /* Where clients shall send notification messages to */ -#define NOTIFY_SOCKET "/org/freedesktop/systemd1/notify" +#define NOTIFY_SOCKET_SYSTEM "/dev/.run/systemd/notify" +#define NOTIFY_SOCKET_USER "@/org/freedesktop/systemd1/notify" static int manager_setup_notify(Manager *m) { union { @@ -84,11 +89,16 @@ static int manager_setup_notify(Manager *m) { sa.sa.sa_family = AF_UNIX; if (getpid() != 1) - snprintf(sa.un.sun_path+1, sizeof(sa.un.sun_path)-1, NOTIFY_SOCKET "/%llu", random_ull()); - else - strncpy(sa.un.sun_path+1, NOTIFY_SOCKET, sizeof(sa.un.sun_path)-1); + snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET_USER "/%llu", random_ull()); + else { + unlink(NOTIFY_SOCKET_SYSTEM); + strncpy(sa.un.sun_path, NOTIFY_SOCKET_SYSTEM, sizeof(sa.un.sun_path)); + } + + if (sa.un.sun_path[0] == '@') + sa.un.sun_path[0] = 0; - if (bind(m->notify_watch.fd, &sa.sa, sizeof(sa)) < 0) { + if (bind(m->notify_watch.fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) { log_error("bind() failed: %m"); return -errno; } @@ -105,9 +115,14 @@ static int manager_setup_notify(Manager *m) { if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev) < 0) return -errno; - if (!(m->notify_socket = strdup(sa.un.sun_path+1))) + if (sa.un.sun_path[0] == 0) + sa.un.sun_path[0] = '@'; + + if (!(m->notify_socket = strdup(sa.un.sun_path))) return -ENOMEM; + log_debug("Using notification socket %s", m->notify_socket); + return 0; } @@ -158,11 +173,18 @@ static int manager_setup_signals(Manager *m) { SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */ SIGPWR, /* Some kernel drivers and upsd send us this on power failure */ SIGRTMIN+0, /* systemd: start default.target */ - SIGRTMIN+1, /* systemd: start rescue.target */ + SIGRTMIN+1, /* systemd: isolate rescue.target */ SIGRTMIN+2, /* systemd: isolate emergency.target */ SIGRTMIN+3, /* systemd: start halt.target */ SIGRTMIN+4, /* systemd: start poweroff.target */ SIGRTMIN+5, /* systemd: start reboot.target */ + SIGRTMIN+6, /* systemd: start kexec.target */ + SIGRTMIN+13, /* systemd: Immediate halt */ + SIGRTMIN+14, /* systemd: Immediate poweroff */ + SIGRTMIN+15, /* systemd: Immediate reboot */ + SIGRTMIN+16, /* systemd: Immediate kexec */ + SIGRTMIN+20, /* systemd: enable status messages */ + SIGRTMIN+21, /* systemd: disable status messages */ -1); assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0); @@ -186,7 +208,6 @@ static int manager_setup_signals(Manager *m) { int manager_new(ManagerRunningAs running_as, Manager **_m) { Manager *m; int r = -ENOMEM; - char *p; assert(_m); assert(running_as >= 0); @@ -202,12 +223,19 @@ int manager_new(ManagerRunningAs running_as, Manager **_m) { m->exit_code = _MANAGER_EXIT_CODE_INVALID; m->pin_cgroupfs_fd = -1; - m->signal_watch.fd = m->mount_watch.fd = m->udev_watch.fd = m->epoll_fd = m->dev_autofs_fd = -1; +#ifdef HAVE_AUDIT + m->audit_fd = -1; +#endif + + m->signal_watch.fd = m->mount_watch.fd = m->udev_watch.fd = m->epoll_fd = m->dev_autofs_fd = m->swap_watch.fd = -1; m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */ if (!(m->environment = strv_copy(environ))) goto fail; + if (!(m->default_controllers = strv_new("cpu", NULL))) + goto fail; + if (!(m->units = hashmap_new(string_hash_func, string_compare_func))) goto fail; @@ -242,16 +270,13 @@ int manager_new(ManagerRunningAs running_as, Manager **_m) { goto fail; /* Try to connect to the busses, if possible. */ - if ((r = bus_init(m)) < 0) + if ((r = bus_init(m, running_as != MANAGER_SYSTEM)) < 0) goto fail; - if (asprintf(&p, "%s/%s", m->cgroup_mount_point, m->cgroup_hierarchy) < 0) { - r = -ENOMEM; - goto fail; - } - - m->pin_cgroupfs_fd = open(p, O_RDONLY|O_CLOEXEC|O_DIRECTORY|O_NOCTTY|O_NONBLOCK); - free(p); +#ifdef HAVE_AUDIT + if ((m->audit_fd = audit_open()) < 0) + log_error("Failed to connect to audit log: %m"); +#endif *_m = m; return 0; @@ -278,7 +303,7 @@ static unsigned manager_dispatch_cleanup_queue(Manager *m) { } enum { - GC_OFFSET_IN_PATH, /* This one is on the path we were travelling */ + GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */ GC_OFFSET_UNSURE, /* No clue */ GC_OFFSET_GOOD, /* We still need this unit */ GC_OFFSET_BAD, /* We don't need this unit anymore */ @@ -420,8 +445,9 @@ void manager_free(Manager *m) { /* If we reexecute ourselves, we keep the root cgroup * around */ - if (m->exit_code != MANAGER_REEXECUTE) - manager_shutdown_cgroup(m); + manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE); + + manager_undo_generators(m); bus_done(m); @@ -438,19 +464,20 @@ void manager_free(Manager *m) { if (m->notify_watch.fd >= 0) close_nointr_nofail(m->notify_watch.fd); +#ifdef HAVE_AUDIT + if (m->audit_fd >= 0) + audit_close(m->audit_fd); +#endif + free(m->notify_socket); lookup_paths_free(&m->lookup_paths); strv_free(m->environment); - free(m->cgroup_controller); - free(m->cgroup_hierarchy); - free(m->cgroup_mount_point); + strv_free(m->default_controllers); hashmap_free(m->cgroup_bondings); - - if (m->pin_cgroupfs_fd >= 0) - close_nointr_nofail(m->pin_cgroupfs_fd); + set_free_free(m->unit_path_cache); free(m); } @@ -494,11 +521,79 @@ int manager_coldplug(Manager *m) { return r; } +static void manager_build_unit_path_cache(Manager *m) { + char **i; + DIR *d = NULL; + int r; + + assert(m); + + set_free_free(m->unit_path_cache); + + if (!(m->unit_path_cache = set_new(string_hash_func, string_compare_func))) { + log_error("Failed to allocate unit path cache."); + return; + } + + /* This simply builds a list of files we know exist, so that + * we don't always have to go to disk */ + + STRV_FOREACH(i, m->lookup_paths.unit_path) { + struct dirent *de; + + if (!(d = opendir(*i))) { + log_error("Failed to open directory: %m"); + continue; + } + + while ((de = readdir(d))) { + char *p; + + if (ignore_file(de->d_name)) + continue; + + if (asprintf(&p, "%s/%s", streq(*i, "/") ? "" : *i, de->d_name) < 0) { + r = -ENOMEM; + goto fail; + } + + if ((r = set_put(m->unit_path_cache, p)) < 0) { + free(p); + goto fail; + } + } + + closedir(d); + d = NULL; + } + + return; + +fail: + log_error("Failed to build unit path cache: %s", strerror(-r)); + + set_free_free(m->unit_path_cache); + m->unit_path_cache = NULL; + + if (d) + closedir(d); +} + int manager_startup(Manager *m, FILE *serialization, FDSet *fds) { int r, q; assert(m); + manager_run_generators(m); + + manager_build_unit_path_cache(m); + + /* If we will deserialize make sure that during enumeration + * this is already known, so we increase the counter here + * already */ + if (serialization) + m->n_deserializing ++; + /* First, enumerate what we can from all config files */ r = manager_enumerate(m); @@ -511,9 +606,10 @@ int manager_startup(Manager *m, FILE *serialization, FDSet *fds) { if ((q = manager_coldplug(m)) < 0) r = q; - /* Now that the initial devices are available, let's see if we - * can write the utmp file */ - manager_write_utmp_reboot(m); + if (serialization) { + assert(m->n_deserializing > 0); + m->n_deserializing --; + } return r; } @@ -659,6 +755,20 @@ static void transaction_merge_and_delete_job(Manager *m, Job *j, Job *other, Job other->object_list = NULL; transaction_delete_job(m, other, true); } +static bool job_is_conflicted_by(Job *j) { + JobDependency *l; + + assert(j); + + /* Returns true if this job is pulled in by a least one + * ConflictedBy dependency. */ + + LIST_FOREACH(object, l, j->object_list) + if (l->conflicts) + return true; + + return false; +} static int delete_one_unmergeable_job(Manager *m, Job *j) { Job *k; @@ -667,7 +777,7 @@ static int delete_one_unmergeable_job(Manager *m, Job *j) { /* Tries to delete one item in the linked list * j->transaction_next->transaction_next->... that conflicts - * whith another one, in an attempt to make an inconsistent + * with another one, in an attempt to make an inconsistent * transaction work. */ /* We rely here on the fact that if a merged with b does not @@ -682,7 +792,37 @@ static int delete_one_unmergeable_job(Manager *m, Job *j) { /* Ok, we found two that conflict, let's see if we can * drop one of them */ - if (!j->matters_to_anchor) + if (!j->matters_to_anchor && !k->matters_to_anchor) { + + /* Both jobs don't matter, so let's + * find the one that is smarter to + * remove. Let's think positive and + * rather remove stops then starts -- + * except if something is being + * stopped because it is conflicted by + * another unit in which case we + * rather remove the start. */ + + log_debug("Looking at job %s/%s conflicted_by=%s", j->unit->meta.id, job_type_to_string(j->type), yes_no(j->type == JOB_STOP && job_is_conflicted_by(j))); + log_debug("Looking at job %s/%s conflicted_by=%s", k->unit->meta.id, job_type_to_string(k->type), yes_no(k->type == JOB_STOP && job_is_conflicted_by(k))); + + if (j->type == JOB_STOP) { + + if (job_is_conflicted_by(j)) + d = k; + else + d = j; + + } else if (k->type == JOB_STOP) { + + if (job_is_conflicted_by(k)) + d = j; + else + d = k; + } else + d = j; + + } else if (!j->matters_to_anchor) d = j; else if (!k->matters_to_anchor) d = k; @@ -690,7 +830,7 @@ static int delete_one_unmergeable_job(Manager *m, Job *j) { return -ENOEXEC; /* Ok, we can drop one, so let's do so. */ - log_notice("Trying to fix job merging by deleting job %s/%s", d->unit->meta.id, job_type_to_string(d->type)); + log_debug("Fixing conflicting jobs by deleting job %s/%s", d->unit->meta.id, job_type_to_string(d->type)); transaction_delete_job(m, d, true); return 0; } @@ -713,7 +853,7 @@ static int transaction_merge_jobs(Manager *m, DBusError *e) { t = j->type; LIST_FOREACH(transaction, k, j->transaction_next) { - if ((r = job_type_merge(&t, k->type)) >= 0) + if (job_type_merge(&t, k->type) >= 0) continue; /* OK, we could not merge all jobs for this @@ -782,7 +922,8 @@ static void transaction_drop_redundant(Manager *m) { LIST_FOREACH(transaction, k, j) { if (!job_is_anchor(k) && - job_type_is_redundant(k->type, unit_active_state(k->unit))) + (k->installed || job_type_is_redundant(k->type, unit_active_state(k->unit))) && + (!k->unit->meta.job || !job_type_is_conflicting(k->type, k->unit->meta.job->type))) continue; changes_something = true; @@ -792,7 +933,7 @@ static void transaction_drop_redundant(Manager *m) { if (changes_something) continue; - log_debug("Found redundant job %s/%s, dropping.", j->unit->meta.id, job_type_to_string(j->type)); + /* log_debug("Found redundant job %s/%s, dropping.", j->unit->meta.id, job_type_to_string(j->type)); */ transaction_delete_job(m, j, false); again = true; break; @@ -829,7 +970,7 @@ static int transaction_verify_order_one(Manager *m, Job *j, Job *from, unsigned /* Have we seen this before? */ if (j->generation == generation) { - Job *k; + Job *k, *delete; /* If the marker is NULL we have been here already and * decided the job was loop-free from here. Hence @@ -845,17 +986,17 @@ static int transaction_verify_order_one(Manager *m, Job *j, Job *from, unsigned * in there. */ log_warning("Found ordering cycle on %s/%s", j->unit->meta.id, job_type_to_string(j->type)); + delete = NULL; for (k = from; k; k = ((k->generation == generation && k->marker != k) ? k->marker : NULL)) { log_info("Walked on cycle path to %s/%s", k->unit->meta.id, job_type_to_string(k->type)); - if (!k->installed && + if (!delete && + !k->installed && !unit_matters_to_anchor(k->unit, k)) { /* Ok, we can drop this one, so let's * do so. */ - log_warning("Breaking order cycle by deleting job %s/%s", k->unit->meta.id, job_type_to_string(k->type)); - transaction_delete_unit(m, k->unit); - return -EAGAIN; + delete = k; } /* Check if this in fact was the beginning of @@ -864,9 +1005,16 @@ static int transaction_verify_order_one(Manager *m, Job *j, Job *from, unsigned break; } + + if (delete) { + log_warning("Breaking ordering cycle by deleting job %s/%s", delete->unit->meta.id, job_type_to_string(delete->type)); + transaction_delete_unit(m, delete->unit); + return -EAGAIN; + } + log_error("Unable to break cycle"); - dbus_set_error(e, BUS_ERROR_TRANSACTION_ORDER_IS_CYCLIC, "Transaction order is cyclic. See logs for details."); + dbus_set_error(e, BUS_ERROR_TRANSACTION_ORDER_IS_CYCLIC, "Transaction order is cyclic. See system logs for details."); return -ENOEXEC; } @@ -937,10 +1085,15 @@ static void transaction_collect_garbage(Manager *m) { again = false; HASHMAP_FOREACH(j, m->transaction_jobs, i) { - if (j->object_list) + if (j->object_list) { + /* log_debug("Keeping job %s/%s because of %s/%s", */ + /* j->unit->meta.id, job_type_to_string(j->type), */ + /* j->object_list->subject ? j->object_list->subject->unit->meta.id : "root", */ + /* j->object_list->subject ? job_type_to_string(j->object_list->subject->type) : "root"); */ continue; + } - log_debug("Garbage collecting job %s/%s", j->unit->meta.id, job_type_to_string(j->type)); + /* log_debug("Garbage collecting job %s/%s", j->unit->meta.id, job_type_to_string(j->type)); */ transaction_delete_job(m, j, true); again = true; break; @@ -1005,7 +1158,8 @@ static void transaction_minimize_impact(Manager *m) { j->type == JOB_STOP && UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(j->unit)); changes_existing_job = - j->unit->meta.job && job_type_is_conflicting(j->type, j->unit->meta.job->state); + j->unit->meta.job && + job_type_is_conflicting(j->type, j->unit->meta.job->type); if (!stops_running_service && !changes_existing_job) continue; @@ -1051,14 +1205,17 @@ static int transaction_apply(Manager *m) { } while ((j = hashmap_steal_first(m->transaction_jobs))) { - if (j->installed) + if (j->installed) { + /* log_debug("Skipping already installed job %s/%s as %u", j->unit->meta.id, job_type_to_string(j->type), (unsigned) j->id); */ continue; + } if (j->unit->meta.job) job_free(j->unit->meta.job); j->unit->meta.job = j; j->installed = true; + m->n_installed_jobs ++; /* We're fully installed. Now let's free data we don't * need anymore. */ @@ -1068,6 +1225,9 @@ static int transaction_apply(Manager *m) { job_add_to_run_queue(j); job_add_to_dbus_queue(j); + job_start_timer(j); + + log_debug("Installed new job %s/%s as %u", j->unit->meta.id, job_type_to_string(j->type), (unsigned) j->id); } /* As last step, kill all remaining job dependencies. */ @@ -1102,7 +1262,8 @@ static int transaction_activate(Manager *m, JobMode mode, DBusError *e) { /* Second step: Try not to stop any running services if * we don't have to. Don't try to reverse running * jobs if we don't have to. */ - transaction_minimize_impact(m); + if (mode == JOB_FAIL) + transaction_minimize_impact(m); /* Third step: Drop redundant jobs */ transaction_drop_redundant(m); @@ -1134,7 +1295,7 @@ static int transaction_activate(Manager *m, JobMode mode, DBusError *e) { break; if (r != -EAGAIN) { - log_warning("Requested transaction contains unmergable jobs: %s", bus_error(e, r)); + log_warning("Requested transaction contains unmergeable jobs: %s", bus_error(e, r)); goto rollback; } @@ -1174,12 +1335,11 @@ rollback: static Job* transaction_add_one_job(Manager *m, JobType type, Unit *unit, bool override, bool *is_new) { Job *j, *f; - int r; assert(m); assert(unit); - /* Looks for an axisting prospective job and returns that. If + /* Looks for an existing prospective job and returns that. If * it doesn't exist it is created and added to the prospective * jobs list. */ @@ -1207,7 +1367,7 @@ static Job* transaction_add_one_job(Manager *m, JobType type, Unit *unit, bool o LIST_PREPEND(Job, transaction, f, j); - if ((r = hashmap_replace(m->transaction_jobs, unit, f)) < 0) { + if (hashmap_replace(m->transaction_jobs, unit, f) < 0) { job_free(j); return NULL; } @@ -1215,7 +1375,7 @@ static Job* transaction_add_one_job(Manager *m, JobType type, Unit *unit, bool o if (is_new) *is_new = true; - log_debug("Added job %s/%s to transaction.", unit->meta.id, job_type_to_string(type)); + /* log_debug("Added job %s/%s to transaction.", unit->meta.id, job_type_to_string(type)); */ return j; } @@ -1245,7 +1405,7 @@ void manager_transaction_unlink_job(Manager *m, Job *j, bool delete_dependencies job_dependency_free(j->object_list); if (other && delete_dependencies) { - log_info("Deleting job %s/%s as dependency of job %s/%s", + log_debug("Deleting job %s/%s as dependency of job %s/%s", other->unit->meta.id, job_type_to_string(other->type), j->unit->meta.id, job_type_to_string(j->type)); transaction_delete_job(m, other, delete_dependencies); @@ -1260,6 +1420,8 @@ static int transaction_add_job_and_dependencies( Job *by, bool matters, bool override, + bool conflicts, + bool ignore_deps, DBusError *e, Job **_ret) { Job *ret; @@ -1272,8 +1434,29 @@ static int transaction_add_job_and_dependencies( assert(type < _JOB_TYPE_MAX); assert(unit); - if (unit->meta.load_state != UNIT_LOADED) { - dbus_set_error(e, BUS_ERROR_LOAD_FAILED, "Unit %s failed to load. See logs for details.", unit->meta.id); + /* log_debug("Pulling in %s/%s from %s/%s", */ + /* unit->meta.id, job_type_to_string(type), */ + /* by ? by->unit->meta.id : "NA", */ + /* by ? job_type_to_string(by->type) : "NA"); */ + + if (unit->meta.load_state != UNIT_LOADED && + unit->meta.load_state != UNIT_ERROR && + unit->meta.load_state != UNIT_MASKED) { + dbus_set_error(e, BUS_ERROR_LOAD_FAILED, "Unit %s is not loaded properly.", unit->meta.id); + return -EINVAL; + } + + if (type != JOB_STOP && unit->meta.load_state == UNIT_ERROR) { + dbus_set_error(e, BUS_ERROR_LOAD_FAILED, + "Unit %s failed to load: %s. " + "See system logs and 'systemctl status' for details.", + unit->meta.id, + strerror(-unit->meta.load_error)); + return -EINVAL; + } + + if (type != JOB_STOP && unit->meta.load_state == UNIT_MASKED) { + dbus_set_error(e, BUS_ERROR_MASKED, "Unit %s is masked.", unit->meta.id); return -EINVAL; } @@ -1286,42 +1469,123 @@ static int transaction_add_job_and_dependencies( if (!(ret = transaction_add_one_job(m, type, unit, override, &is_new))) return -ENOMEM; + ret->ignore_deps = ret->ignore_deps || ignore_deps; + /* Then, add a link to the job. */ - if (!job_dependency_new(by, ret, matters)) + if (!job_dependency_new(by, ret, matters, conflicts)) return -ENOMEM; - if (is_new) { + if (is_new && !ignore_deps) { + Set *following; + + /* If we are following some other unit, make sure we + * add all dependencies of everybody following. */ + if (unit_following_set(ret->unit, &following) > 0) { + SET_FOREACH(dep, following, i) + if ((r = transaction_add_job_and_dependencies(m, type, dep, ret, false, override, false, false, e, NULL)) < 0) { + log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->meta.id, bus_error(e, r)); + + if (e) + dbus_error_free(e); + } + + set_free(following); + } + /* Finally, recursively add in all dependencies. */ if (type == JOB_START || type == JOB_RELOAD_OR_START) { SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_REQUIRES], i) - if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, true, override, e, NULL)) < 0 && r != -EBADR) - goto fail; + if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, true, override, false, false, e, NULL)) < 0) { + if (r != -EBADR) + goto fail; + + if (e) + dbus_error_free(e); + } + + SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_BIND_TO], i) + if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, true, override, false, false, e, NULL)) < 0) { + + if (r != -EBADR) + goto fail; + + if (e) + dbus_error_free(e); + } SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_REQUIRES_OVERRIDABLE], i) - if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, !override, override, e, NULL)) < 0 && r != -EBADR) - log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->meta.id, strerror(-r)); + if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, !override, override, false, false, e, NULL)) < 0) { + log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->meta.id, bus_error(e, r)); + + if (e) + dbus_error_free(e); + } SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_WANTS], i) - if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, false, false, e, NULL)) < 0) - log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->meta.id, strerror(-r)); + if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, false, false, false, false, e, NULL)) < 0) { + log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->meta.id, bus_error(e, r)); + + if (e) + dbus_error_free(e); + } SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_REQUISITE], i) - if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_ACTIVE, dep, ret, true, override, e, NULL)) < 0 && r != -EBADR) - goto fail; + if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_ACTIVE, dep, ret, true, override, false, false, e, NULL)) < 0) { + + if (r != -EBADR) + goto fail; + + if (e) + dbus_error_free(e); + } SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_REQUISITE_OVERRIDABLE], i) - if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_ACTIVE, dep, ret, !override, override, e, NULL)) < 0 && r != -EBADR) - log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->meta.id, strerror(-r)); + if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_ACTIVE, dep, ret, !override, override, false, false, e, NULL)) < 0) { + log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->meta.id, bus_error(e, r)); + + if (e) + dbus_error_free(e); + } SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_CONFLICTS], i) - if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, dep, ret, true, override, e, NULL)) < 0 && r != -EBADR) - goto fail; + if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, dep, ret, true, override, true, false, e, NULL)) < 0) { + + if (r != -EBADR) + goto fail; + + if (e) + dbus_error_free(e); + } + + SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_CONFLICTED_BY], i) + if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, dep, ret, false, override, false, false, e, NULL)) < 0) { + log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->meta.id, bus_error(e, r)); + + if (e) + dbus_error_free(e); + } } else if (type == JOB_STOP || type == JOB_RESTART || type == JOB_TRY_RESTART) { SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_REQUIRED_BY], i) - if ((r = transaction_add_job_and_dependencies(m, type, dep, ret, true, override, e, NULL)) < 0 && r != -EBADR) - goto fail; + if ((r = transaction_add_job_and_dependencies(m, type, dep, ret, true, override, false, false, e, NULL)) < 0) { + + if (r != -EBADR) + goto fail; + + if (e) + dbus_error_free(e); + } + + SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_BOUND_BY], i) + if ((r = transaction_add_job_and_dependencies(m, type, dep, ret, true, override, false, false, e, NULL)) < 0) { + + if (r != -EBADR) + goto fail; + + if (e) + dbus_error_free(e); + } } /* JOB_VERIFY_STARTED, JOB_RELOAD require no dependency handling */ @@ -1354,14 +1618,14 @@ static int transaction_add_isolate_jobs(Manager *m) { continue; /* No need to stop inactive jobs */ - if (UNIT_IS_INACTIVE_OR_MAINTENANCE(unit_active_state(u))) + if (UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(u)) && !u->meta.job) continue; /* Is there already something listed for this? */ if (hashmap_get(m->transaction_jobs, u)) continue; - if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, u, NULL, true, false, NULL, NULL)) < 0) + if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, u, NULL, true, false, false, false, NULL, NULL)) < 0) log_warning("Cannot add isolate job for unit %s, ignoring: %s", u->meta.id, strerror(-r)); } @@ -1382,9 +1646,14 @@ int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool ove return -EINVAL; } - log_debug("Trying to enqueue job %s/%s", unit->meta.id, job_type_to_string(type)); + if (mode == JOB_ISOLATE && !unit->meta.allow_isolate) { + dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated."); + return -EPERM; + } + + log_debug("Trying to enqueue job %s/%s/%s", unit->meta.id, job_type_to_string(type), job_mode_to_string(mode)); - if ((r = transaction_add_job_and_dependencies(m, type, unit, NULL, true, override, e, &ret)) < 0) { + if ((r = transaction_add_job_and_dependencies(m, type, unit, NULL, true, override, false, mode == JOB_IGNORE_DEPENDENCIES, e, &ret)) < 0) { transaction_abort(m); return r; } @@ -1478,7 +1747,7 @@ int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DB if (!name) name = file_name_from_path(path); - if (!unit_name_is_valid(name)) { + if (!unit_name_is_valid(name, false)) { dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name); return -EINVAL; } @@ -1563,7 +1832,7 @@ void manager_clear_jobs(Manager *m) { transaction_abort(m); while ((j = hashmap_first(m->jobs))) - job_free(j); + job_finish_and_invalidate(j, JOB_CANCELED); } unsigned manager_dispatch_run_queue(Manager *m) { @@ -1649,7 +1918,7 @@ static int manager_process_notify_fd(Manager *m) { if (n >= 0) return -EIO; - if (errno == EAGAIN) + if (errno == EAGAIN || errno == EINTR) break; return -errno; @@ -1665,7 +1934,7 @@ static int manager_process_notify_fd(Manager *m) { ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr); - if (!(u = hashmap_get(m->watch_pids, UINT32_TO_PTR(ucred->pid)))) + if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid)))) if (!(u = cgroup_unit_by_pid(m, ucred->pid))) { log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid); continue; @@ -1730,7 +1999,7 @@ static int manager_dispatch_sigchld(Manager *m) { return r; /* And now figure out the unit this belongs to */ - if (!(u = hashmap_get(m->watch_pids, UINT32_TO_PTR(si.si_pid)))) + if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid)))) u = cgroup_unit_by_pid(m, si.si_pid); /* And now, we actually reap the zombie. */ @@ -1748,14 +2017,16 @@ static int manager_dispatch_sigchld(Manager *m) { (long unsigned) si.si_pid, sigchld_code_to_string(si.si_code), si.si_status, - strna(si.si_code == CLD_EXITED ? exit_status_to_string(si.si_status) : strsignal(si.si_status))); + strna(si.si_code == CLD_EXITED + ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL) + : signal_to_string(si.si_status))); if (!u) continue; - log_debug("Child %llu belongs to %s", (long long unsigned) si.si_pid, u->meta.id); + log_debug("Child %lu belongs to %s", (long unsigned) si.si_pid, u->meta.id); - hashmap_remove(m->watch_pids, UINT32_TO_PTR(si.si_pid)); + hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid)); UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status); } @@ -1768,7 +2039,7 @@ static int manager_start_target(Manager *m, const char *name, JobMode mode) { dbus_error_init(&error); - log_info("Activating special unit %s", name); + log_debug("Activating special unit %s", name); if ((r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL)) < 0) log_error("Failed to enqueue %s job: %s", name, bus_error(&error, r)); @@ -1786,18 +2057,24 @@ static int manager_process_signal_fd(Manager *m) { assert(m); for (;;) { + char *p = NULL; + if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) { if (n >= 0) return -EIO; - if (errno == EAGAIN) + if (errno == EINTR || errno == EAGAIN) break; return -errno; } - log_debug("Received SIG%s", strna(signal_to_string(sfsi.ssi_signo))); + get_process_name(sfsi.ssi_pid, &p); + log_debug("Received SIG%s from PID %lu (%s)", + strna(signal_to_string(sfsi.ssi_signo)), + (unsigned long) sfsi.ssi_pid, strna(p)); + free(p); switch (sfsi.ssi_signo) { @@ -1822,7 +2099,7 @@ static int manager_process_signal_fd(Manager *m) { } /* Run the exit target if there is one, if not, just exit. */ - if (manager_start_target(m, SPECIAL_EXIT_SERVICE, JOB_REPLACE) < 0) { + if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) { m->exit_code = MANAGER_EXIT; return 0; } @@ -1850,7 +2127,7 @@ static int manager_process_signal_fd(Manager *m) { if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) { log_info("Trying to reconnect to bus..."); - bus_init(m); + bus_init(m, true); } if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) { @@ -1893,23 +2170,53 @@ static int manager_process_signal_fd(Manager *m) { break; default: { - static const char * const table[] = { + /* Starting SIGRTMIN+0 */ + static const char * const target_table[] = { [0] = SPECIAL_DEFAULT_TARGET, [1] = SPECIAL_RESCUE_TARGET, - [2] = SPECIAL_EMERGENCY_SERVICE, + [2] = SPECIAL_EMERGENCY_TARGET, [3] = SPECIAL_HALT_TARGET, [4] = SPECIAL_POWEROFF_TARGET, - [5] = SPECIAL_REBOOT_TARGET + [5] = SPECIAL_REBOOT_TARGET, + [6] = SPECIAL_KEXEC_TARGET + }; + + /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */ + static const ManagerExitCode code_table[] = { + [0] = MANAGER_HALT, + [1] = MANAGER_POWEROFF, + [2] = MANAGER_REBOOT, + [3] = MANAGER_KEXEC }; if ((int) sfsi.ssi_signo >= SIGRTMIN+0 && - (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(table)) { - manager_start_target(m, table[sfsi.ssi_signo - SIGRTMIN], + (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) { + manager_start_target(m, target_table[sfsi.ssi_signo - SIGRTMIN], (sfsi.ssi_signo == 1 || sfsi.ssi_signo == 2) ? JOB_ISOLATE : JOB_REPLACE); break; } - log_warning("Got unhandled signal <%s>.", strna(signal_to_string(sfsi.ssi_signo))); + if ((int) sfsi.ssi_signo >= SIGRTMIN+13 && + (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) { + m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13]; + break; + } + + switch (sfsi.ssi_signo - SIGRTMIN) { + + case 20: + log_debug("Enabling showing of status."); + m->show_status = true; + break; + + case 21: + log_debug("Disabling showing of status."); + m->show_status = false; + break; + + default: + log_warning("Got unhandled signal <%s>.", strna(signal_to_string(sfsi.ssi_signo))); + } } } } @@ -1929,6 +2236,9 @@ static int process_event(Manager *m, struct epoll_event *ev) { assert(w = ev->data.ptr); + if (w->type == WATCH_INVALID) + return 0; + switch (w->type) { case WATCH_SIGNAL: @@ -1959,7 +2269,8 @@ static int process_event(Manager *m, struct epoll_event *ev) { UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w); break; - case WATCH_TIMER: { + case WATCH_UNIT_TIMER: + case WATCH_JOB_TIMER: { uint64_t v; ssize_t k; @@ -1972,7 +2283,10 @@ static int process_event(Manager *m, struct epoll_event *ev) { return k < 0 ? -errno : -EIO; } - UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w); + if (w->type == WATCH_UNIT_TIMER) + UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w); + else + job_timer_event(w->data.job, v, w); break; } @@ -1981,6 +2295,11 @@ static int process_event(Manager *m, struct epoll_event *ev) { mount_fd_event(m, ev->events); break; + case WATCH_SWAP: + /* Some swap table change, intended for the swap subsystem */ + swap_fd_event(m, ev->events); + break; + case WATCH_UDEV: /* Some notification from udev, intended for the device subsystem */ device_fd_event(m, ev->events); @@ -1995,6 +2314,7 @@ static int process_event(Manager *m, struct epoll_event *ev) { break; default: + log_error("event type=%i", w->type); assert_not_reached("Unknown epoll event type."); } @@ -2009,6 +2329,12 @@ int manager_loop(Manager *m) { assert(m); m->exit_code = MANAGER_RUNNING; + /* Release the path cache */ + set_free_free(m->unit_path_cache); + m->unit_path_cache = NULL; + + manager_check_finished(m); + /* There might still be some zombies hanging around from * before we were exec()'ed. Leat's reap them */ if ((r = manager_dispatch_sigchld(m)) < 0) @@ -2042,6 +2368,9 @@ int manager_loop(Manager *m) { if (manager_dispatch_dbus_queue(m) > 0) continue; + if (swap_dispatch_reload(m) > 0) + continue; + if ((n = epoll_wait(m->epoll_fd, &event, 1, -1)) < 0) { if (errno == EINTR) @@ -2107,70 +2436,109 @@ int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) { return 0; } -static bool manager_utmp_good(Manager *m) { - int r; +void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) { - assert(m); +#ifdef HAVE_AUDIT + char *p; + + if (m->audit_fd < 0) + return; + + /* Don't generate audit events if the service was already + * started and we're just deserializing */ + if (m->n_deserializing > 0) + return; - if ((r = mount_path_is_mounted(m, _PATH_UTMPX)) <= 0) { + if (!(p = unit_name_to_prefix_and_instance(u->meta.id))) { + log_error("Failed to allocate unit name for audit message: %s", strerror(ENOMEM)); + return; + } - if (r < 0) - log_warning("Failed to determine whether " _PATH_UTMPX " is mounted: %s", strerror(-r)); + if (audit_log_user_comm_message(m->audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) { + log_warning("Failed to send audit message: %m"); - return false; + if (errno == EPERM) { + /* We aren't allowed to send audit messages? + * Then let's not retry again, to avoid + * spamming the user with the same and same + * messages over and over. */ + + audit_close(m->audit_fd); + m->audit_fd = -1; + } } - return true; -} + free(p); +#endif -void manager_write_utmp_reboot(Manager *m) { - int r; +} - assert(m); +void manager_send_unit_plymouth(Manager *m, Unit *u) { + int fd = -1; + union sockaddr_union sa; + int n = 0; + char *message = NULL; - if (m->utmp_reboot_written) + /* Don't generate plymouth events if the service was already + * started and we're just deserializing */ + if (m->n_deserializing > 0) return; if (m->running_as != MANAGER_SYSTEM) return; - if (!manager_utmp_good(m)) + if (u->meta.type != UNIT_SERVICE && + u->meta.type != UNIT_MOUNT && + u->meta.type != UNIT_SWAP) return; - if ((r = utmp_put_reboot(m->startup_timestamp.realtime)) < 0) { - - if (r != -ENOENT && r != -EROFS) - log_warning("Failed to write utmp/wtmp: %s", strerror(-r)); - + /* We set SOCK_NONBLOCK here so that we rather drop the + * message then wait for plymouth */ + if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) { + log_error("socket() failed: %m"); return; } - m->utmp_reboot_written = true; -} + zero(sa); + sa.sa.sa_family = AF_UNIX; + strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1); + if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) { -void manager_write_utmp_runlevel(Manager *m, Unit *u) { - int runlevel, r; + if (errno != EPIPE && + errno != EAGAIN && + errno != ENOENT && + errno != ECONNREFUSED && + errno != ECONNRESET && + errno != ECONNABORTED) + log_error("connect() failed: %m"); - assert(m); - assert(u); + goto finish; + } - if (u->meta.type != UNIT_TARGET) - return; + if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->meta.id) + 1), u->meta.id, &n) < 0) { + log_error("Out of memory"); + goto finish; + } - if (m->running_as != MANAGER_SYSTEM) - return; + errno = 0; + if (write(fd, message, n + 1) != n + 1) { - if (!manager_utmp_good(m)) - return; + if (errno != EPIPE && + errno != EAGAIN && + errno != ENOENT && + errno != ECONNREFUSED && + errno != ECONNRESET && + errno != ECONNABORTED) + log_error("Failed to write Plymouth message: %m"); - if ((runlevel = target_get_runlevel(TARGET(u))) <= 0) - return; + goto finish; + } - if ((r = utmp_put_runlevel(0, runlevel, 0)) < 0) { +finish: + if (fd >= 0) + close_nointr_nofail(fd); - if (r != -ENOENT && r != -EROFS) - log_warning("Failed to write utmp/wtmp: %s", strerror(-r)); - } + free(message); } void manager_dispatch_bus_name_owner_changed( @@ -2207,15 +2575,20 @@ void manager_dispatch_bus_query_pid_done( UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid); } -int manager_open_serialization(FILE **_f) { - char *path; +int manager_open_serialization(Manager *m, FILE **_f) { + char *path = NULL; mode_t saved_umask; int fd; FILE *f; assert(_f); - if (asprintf(&path, "/dev/shm/systemd-%u.dump-XXXXXX", (unsigned) getpid()) < 0) + if (m->running_as == MANAGER_SYSTEM) + asprintf(&path, "/dev/.run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid()); + else + asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid()); + + if (!path) return -ENOMEM; saved_umask = umask(0077); @@ -2250,6 +2623,12 @@ int manager_serialize(Manager *m, FILE *f, FDSet *fds) { assert(f); assert(fds); + dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp); + dual_timestamp_serialize(f, "startup-timestamp", &m->startup_timestamp); + dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp); + + fputc('\n', f); + HASHMAP_FOREACH_KEY(u, t, m->units, i) { if (u->meta.id != t) continue; @@ -2279,6 +2658,36 @@ int manager_deserialize(Manager *m, FILE *f, FDSet *fds) { log_debug("Deserializing state..."); + m->n_deserializing ++; + + for (;;) { + char line[1024], *l; + + if (!fgets(line, sizeof(line), f)) { + if (feof(f)) + r = 0; + else + r = -errno; + + goto finish; + } + + char_array_0(line); + l = strstrip(line); + + if (l[0] == 0) + break; + + if (startswith(l, "initrd-timestamp=")) + dual_timestamp_deserialize(l+17, &m->initrd_timestamp); + else if (startswith(l, "startup-timestamp=")) + dual_timestamp_deserialize(l+18, &m->startup_timestamp); + else if (startswith(l, "finish-timestamp=")) + dual_timestamp_deserialize(l+17, &m->finish_timestamp); + else + log_debug("Unknown serialization item '%s'", l); + } + for (;;) { Unit *u; char name[UNIT_NAME_MAX+2]; @@ -2286,24 +2695,32 @@ int manager_deserialize(Manager *m, FILE *f, FDSet *fds) { /* Start marker */ if (!fgets(name, sizeof(name), f)) { if (feof(f)) - break; + r = 0; + else + r = -errno; - return -errno; + goto finish; } char_array_0(name); if ((r = manager_load_unit(m, strstrip(name), NULL, NULL, &u)) < 0) - return r; + goto finish; if ((r = unit_deserialize(u, f, fds)) < 0) - return r; + goto finish; } - if (ferror(f)) - return -EIO; +finish: + if (ferror(f)) { + r = -EIO; + goto finish; + } - return 0; + assert(m->n_deserializing > 0); + m->n_deserializing --; + + return r; } int manager_reload(Manager *m) { @@ -2313,7 +2730,7 @@ int manager_reload(Manager *m) { assert(m); - if ((r = manager_open_serialization(&f)) < 0) + if ((r = manager_open_serialization(m, &f)) < 0) return r; if (!(fds = fdset_new())) { @@ -2331,12 +2748,19 @@ int manager_reload(Manager *m) { /* From here on there is no way back. */ manager_clear_jobs_and_units(m); + manager_undo_generators(m); /* Find new unit paths */ lookup_paths_free(&m->lookup_paths); if ((q = lookup_paths_init(&m->lookup_paths, m->running_as)) < 0) r = q; + manager_run_generators(m); + + manager_build_unit_path_cache(m); + + m->n_deserializing ++; + /* First, enumerate what we can from all config files */ if ((q = manager_enumerate(m)) < 0) r = q; @@ -2352,6 +2776,9 @@ int manager_reload(Manager *m) { if ((q = manager_coldplug(m)) < 0) r = q; + assert(m->n_deserializing > 0); + m->n_deserializing ++; + finish: if (f) fclose(f); @@ -2378,9 +2805,167 @@ bool manager_is_booting_or_shutting_down(Manager *m) { return false; } +void manager_reset_failed(Manager *m) { + Unit *u; + Iterator i; + + assert(m); + + HASHMAP_FOREACH(u, m->units, i) + unit_reset_failed(u); +} + +bool manager_unit_pending_inactive(Manager *m, const char *name) { + Unit *u; + + assert(m); + assert(name); + + /* Returns true if the unit is inactive or going down */ + if (!(u = manager_get_unit(m, name))) + return true; + + return unit_pending_inactive(u); +} + +void manager_check_finished(Manager *m) { + char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX]; + + assert(m); + + if (dual_timestamp_is_set(&m->finish_timestamp)) + return; + + if (hashmap_size(m->jobs) > 0) + return; + + dual_timestamp_get(&m->finish_timestamp); + + if (m->running_as == MANAGER_SYSTEM && detect_container(NULL) <= 0) { + + if (dual_timestamp_is_set(&m->initrd_timestamp)) { + log_info("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.", + format_timespan(kernel, sizeof(kernel), + m->initrd_timestamp.monotonic), + format_timespan(initrd, sizeof(initrd), + m->startup_timestamp.monotonic - m->initrd_timestamp.monotonic), + format_timespan(userspace, sizeof(userspace), + m->finish_timestamp.monotonic - m->startup_timestamp.monotonic), + format_timespan(sum, sizeof(sum), + m->finish_timestamp.monotonic)); + } else + log_info("Startup finished in %s (kernel) + %s (userspace) = %s.", + format_timespan(kernel, sizeof(kernel), + m->startup_timestamp.monotonic), + format_timespan(userspace, sizeof(userspace), + m->finish_timestamp.monotonic - m->startup_timestamp.monotonic), + format_timespan(sum, sizeof(sum), + m->finish_timestamp.monotonic)); + } else + log_debug("Startup finished in %s.", + format_timespan(userspace, sizeof(userspace), + m->finish_timestamp.monotonic - m->startup_timestamp.monotonic)); + +} + +void manager_run_generators(Manager *m) { + DIR *d = NULL; + const char *generator_path; + const char *argv[3]; + + assert(m); + + generator_path = m->running_as == MANAGER_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH; + if (!(d = opendir(generator_path))) { + + if (errno == ENOENT) + return; + + log_error("Failed to enumerate generator directory: %m"); + return; + } + + if (!m->generator_unit_path) { + char *p; + char system_path[] = "/dev/.run/systemd/generator-XXXXXX", + user_path[] = "/tmp/systemd-generator-XXXXXX"; + + if (!(p = mkdtemp(m->running_as == MANAGER_SYSTEM ? system_path : user_path))) { + log_error("Failed to generate generator directory: %m"); + goto finish; + } + + if (!(m->generator_unit_path = strdup(p))) { + log_error("Failed to allocate generator unit path."); + goto finish; + } + } + + argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */ + argv[1] = m->generator_unit_path; + argv[2] = NULL; + + execute_directory(generator_path, d, (char**) argv); + + if (rmdir(m->generator_unit_path) >= 0) { + /* Uh? we were able to remove this dir? I guess that + * means the directory was empty, hence let's shortcut + * this */ + + free(m->generator_unit_path); + m->generator_unit_path = NULL; + goto finish; + } + + if (!strv_find(m->lookup_paths.unit_path, m->generator_unit_path)) { + char **l; + + if (!(l = strv_append(m->lookup_paths.unit_path, m->generator_unit_path))) { + log_error("Failed to add generator directory to unit search path: %m"); + goto finish; + } + + strv_free(m->lookup_paths.unit_path); + m->lookup_paths.unit_path = l; + + log_debug("Added generator unit path %s to search path.", m->generator_unit_path); + } + +finish: + if (d) + closedir(d); +} + +void manager_undo_generators(Manager *m) { + assert(m); + + if (!m->generator_unit_path) + return; + + strv_remove(m->lookup_paths.unit_path, m->generator_unit_path); + rm_rf(m->generator_unit_path, false, true); + + free(m->generator_unit_path); + m->generator_unit_path = NULL; +} + +int manager_set_default_controllers(Manager *m, char **controllers) { + char **l; + + assert(m); + + if (!(l = strv_copy(controllers))) + return -ENOMEM; + + strv_free(m->default_controllers); + m->default_controllers = l; + + return 0; +} + static const char* const manager_running_as_table[_MANAGER_RUNNING_AS_MAX] = { [MANAGER_SYSTEM] = "system", - [MANAGER_SESSION] = "session" + [MANAGER_USER] = "user" }; DEFINE_STRING_TABLE_LOOKUP(manager_running_as, ManagerRunningAs);