X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=name.c;h=e88dc85839a4e5b5fa5d2d05decf9be158f00e08;hp=ace552975316703d2c2b48cfe1fcced4f5075da2;hb=ac1135be1f18443981211e38fc66437f147c6aee;hpb=ceed357001a7543c62468c5b943cf80c2a644252 diff --git a/name.c b/name.c index ace552975..e88dc8583 100644 --- a/name.c +++ b/name.c @@ -3,29 +3,36 @@ #include #include #include +#include +#include +#include #include "set.h" #include "name.h" #include "macro.h" #include "strv.h" +#include "load-fragment.h" +#include "load-dropin.h" +#include "log.h" + +const NameVTable * const name_vtable[_NAME_TYPE_MAX] = { + [NAME_SERVICE] = &service_vtable, + [NAME_TIMER] = &timer_vtable, + [NAME_SOCKET] = &socket_vtable, + [NAME_TARGET] = &target_vtable, + [NAME_DEVICE] = &device_vtable, + [NAME_MOUNT] = &mount_vtable, + [NAME_AUTOMOUNT] = &automount_vtable, + [NAME_SNAPSHOT] = &snapshot_vtable +}; NameType name_type_from_string(const char *n) { NameType t; - static const char* suffixes[_NAME_TYPE_MAX] = { - [NAME_SERVICE] = ".service", - [NAME_TIMER] = ".timer", - [NAME_SOCKET] = ".socket", - [NAME_MILESTONE] = ".milestone", - [NAME_DEVICE] = ".device", - [NAME_MOUNT] = ".mount", - [NAME_AUTOMOUNT] = ".automount", - [NAME_SNAPSHOT] = ".snapshot", - }; assert(n); for (t = 0; t < _NAME_TYPE_MAX; t++) - if (endswith(n, suffixes[t])) + if (endswith(n, name_vtable[t]->suffix)) return t; return _NAME_TYPE_INVALID; @@ -43,6 +50,9 @@ bool name_is_valid(const char *n) { assert(n); + if (strlen(n) >= NAME_MAX) + return false; + t = name_type_from_string(n); if (t < 0 || t >= _NAME_TYPE_MAX) return false; @@ -70,70 +80,60 @@ Name *name_new(Manager *m) { return NULL; } - /* Not much initialization happening here at this time */ n->meta.manager = m; n->meta.type = _NAME_TYPE_INVALID; - n->meta.state = NAME_STUB; - - /* We don't link the name here, that is left for name_link() */ return n; } -/* FIXME: Does not rollback on failure! */ -int name_link_names(Name *n, bool replace) { - char *t; - void *state; +int name_add_name(Name *n, const char *text) { + NameType t; + char *s; int r; assert(n); + assert(text); - if (!n->meta.linked) - return 0; - - /* Link all names that aren't linked yet. */ + if ((t = name_type_from_string(text)) == _NAME_TYPE_INVALID) + return -EINVAL; - SET_FOREACH(t, n->meta.names, state) - if (replace) { - if ((r = hashmap_replace(n->meta.manager->names, t, n)) < 0) - return r; - } else { - if ((r = hashmap_put(n->meta.manager->names, t, n)) < 0) - return r; - } + if (n->meta.type != _NAME_TYPE_INVALID && t != n->meta.type) + return -EINVAL; - return 0; -} + if (!(s = strdup(text))) + return -ENOMEM; -int name_link(Name *n) { - int r; + if ((r = set_put(n->meta.names, s)) < 0) { + free(s); + return r; + } - assert(n); - assert(!set_isempty(n->meta.names)); - assert(!n->meta.linked); + if ((r = hashmap_put(n->meta.manager->names, s, n)) < 0) { + set_remove(n->meta.names, s); + free(s); + return r; + } - n->meta.linked = true; + n->meta.type = t; - if ((r = name_link_names(n, false) < 0)) { - char *t; - void *state; + if (!n->meta.id) + n->meta.id = s; - /* Rollback the registered names */ - SET_FOREACH(t, n->meta.names, state) - hashmap_remove_value(n->meta.manager->names, t, n); + return 0; +} - n->meta.linked = false; - return r; - } +void name_add_to_load_queue(Name *n) { + assert(n); - if (n->meta.state == NAME_STUB) - LIST_PREPEND(Meta, n->meta.manager->load_queue, &n->meta); + if (n->meta.load_state != NAME_STUB || n->meta.in_load_queue) + return; - return 0; + LIST_PREPEND(Meta, load_queue, n->meta.manager->load_queue, &n->meta); + n->meta.in_load_queue = true; } static void bidi_set_free(Name *name, Set *s) { - void *state; + Iterator i; Name *other; assert(name); @@ -141,7 +141,7 @@ static void bidi_set_free(Name *name, Set *s) { /* Frees the set and makes sure we are dropped from the * inverse pointers */ - SET_FOREACH(other, s, state) { + SET_FOREACH(other, s, i) { NameDependency d; for (d = 0; d < _NAME_DEPENDENCY_MAX; d++) @@ -153,21 +153,22 @@ static void bidi_set_free(Name *name, Set *s) { void name_free(Name *name) { NameDependency d; + Iterator i; char *t; assert(name); /* Detach from next 'bigger' objects */ - if (name->meta.linked) { - char *t; - void *state; - SET_FOREACH(t, name->meta.names, state) - hashmap_remove_value(name->meta.manager->names, t, name); + SET_FOREACH(t, name->meta.names, i) + hashmap_remove_value(name->meta.manager->names, t, name); - if (name->meta.state == NAME_STUB) - LIST_REMOVE(Meta, name->meta.manager->load_queue, &name->meta); - } + if (name->meta.in_load_queue) + LIST_REMOVE(Meta, load_queue, name->meta.manager->load_queue, &name->meta); + + if (name->meta.load_state == NAME_LOADED) + if (NAME_VTABLE(name)->done) + NAME_VTABLE(name)->done(name); /* Free data and next 'smaller' objects */ if (name->meta.job) @@ -176,312 +177,659 @@ void name_free(Name *name) { for (d = 0; d < _NAME_DEPENDENCY_MAX; d++) bidi_set_free(name, name->meta.dependencies[d]); - switch (name->meta.type) { + free(name->meta.description); - case NAME_SOCKET: { - unsigned i; - Socket *s = SOCKET(name); + while ((t = set_steal_first(name->meta.names))) + free(t); + set_free(name->meta.names); - for (i = 0; i < s->n_fds; i++) - close_nointr(s->fds[i]); - break; - } + free(name); +} - case NAME_DEVICE: { - Device *d = DEVICE(name); +NameActiveState name_active_state(Name *name) { + assert(name); - free(d->sysfs); - break; - } + if (name->meta.load_state != NAME_LOADED) + return NAME_INACTIVE; - case NAME_MOUNT: { - Mount *m = MOUNT(name); + return NAME_VTABLE(name)->active_state(name); +} - free(m->path); - break; - } +static int ensure_merge(Set **s, Set *other) { - case NAME_AUTOMOUNT: { - Automount *a = AUTOMOUNT(name); + if (!other) + return 0; - free(a->path); - break; - } + if (*s) + return set_merge(*s, other); - default: - ; - } + if (!(*s = set_copy(other))) + return -ENOMEM; - free(name->meta.description); + return 0; +} - while ((t = set_steal_first(name->meta.names))) - free(t); - set_free(name->meta.names); +/* FIXME: Does not rollback on failure! */ +int name_merge(Name *name, Name *other) { + int r; + NameDependency d; - free(name); + assert(name); + assert(other); + assert(name->meta.manager == other->meta.manager); + + /* This merges 'other' into 'name'. FIXME: This does not + * rollback on failure. */ + + if (name->meta.type != other->meta.type) + return -EINVAL; + + if (other->meta.load_state != NAME_STUB) + return -EINVAL; + + /* Merge names */ + if ((r = ensure_merge(&name->meta.names, other->meta.names)) < 0) + return r; + + /* Merge dependencies */ + for (d = 0; d < _NAME_DEPENDENCY_MAX; d++) + /* fixme, the inverse mapping is missing */ + if ((r = ensure_merge(&name->meta.dependencies[d], other->meta.dependencies[d])) < 0) + return r; + + return 0; } -bool name_is_ready(Name *name) { +const char* name_id(Name *n) { + assert(n); - assert(name); + if (n->meta.id) + return n->meta.id; - if (name->meta.state != NAME_LOADED) - return false; + return set_first(n->meta.names); +} - assert(name->meta.type < _NAME_TYPE_MAX); +const char *name_description(Name *n) { + assert(n); - switch (name->meta.type) { - case NAME_SERVICE: { - Service *s = SERVICE(name); + if (n->meta.description) + return n->meta.description; - return - s->state == SERVICE_RUNNING || - s->state == SERVICE_RELOAD_PRE || - s->state == SERVICE_RELOAD || - s->state == SERVICE_RELOAD_POST; - } + return name_id(n); +} - case NAME_TIMER: { - Timer *t = TIMER(name); +void name_dump(Name *n, FILE *f, const char *prefix) { - return - t->state == TIMER_WAITING || - t->state == TIMER_RUNNING; - } + static const char* const load_state_table[_NAME_LOAD_STATE_MAX] = { + [NAME_STUB] = "stub", + [NAME_LOADED] = "loaded", + [NAME_FAILED] = "failed" + }; - case NAME_SOCKET: { - Socket *s = SOCKET(name); + static const char* const active_state_table[_NAME_ACTIVE_STATE_MAX] = { + [NAME_ACTIVE] = "active", + [NAME_INACTIVE] = "inactive", + [NAME_ACTIVATING] = "activating", + [NAME_DEACTIVATING] = "deactivating" + }; - return - s->state == SOCKET_LISTENING || - s->state == SOCKET_RUNNING; - } + static const char* const dependency_table[_NAME_DEPENDENCY_MAX] = { + [NAME_REQUIRES] = "Requires", + [NAME_SOFT_REQUIRES] = "SoftRequires", + [NAME_WANTS] = "Wants", + [NAME_REQUISITE] = "Requisite", + [NAME_SOFT_REQUISITE] = "SoftRequisite", + [NAME_REQUIRED_BY] = "RequiredBy", + [NAME_SOFT_REQUIRED_BY] = "SoftRequiredBy", + [NAME_WANTED_BY] = "WantedBy", + [NAME_CONFLICTS] = "Conflicts", + [NAME_BEFORE] = "Before", + [NAME_AFTER] = "After", + }; - case NAME_MILESTONE: - return MILESTONE(name)->state == MILESTONE_ACTIVE; + char *t; + NameDependency d; + Iterator i; + char *prefix2; - case NAME_DEVICE: - return DEVICE(name)->state == DEVICE_AVAILABLE; + assert(n); - case NAME_MOUNT: - return MOUNT(name)->state == MOUNT_MOUNTED; + if (!prefix) + prefix = ""; + prefix2 = strappend(prefix, "\t"); + if (!prefix2) + prefix2 = ""; - case NAME_AUTOMOUNT: { - Automount *a = AUTOMOUNT(name); + fprintf(f, + "%s→ Name %s:\n" + "%s\tDescription: %s\n" + "%s\tName Load State: %s\n" + "%s\tName Active State: %s\n", + prefix, name_id(n), + prefix, name_description(n), + prefix, load_state_table[n->meta.load_state], + prefix, active_state_table[name_active_state(n)]); - return - a->state == AUTOMOUNT_WAITING || - a->state == AUTOMOUNT_RUNNING; - } + SET_FOREACH(t, n->meta.names, i) + fprintf(f, "%s\tName: %s\n", prefix, t); - case NAME_SNAPSHOT: - return SNAPSHOT(name)->state == SNAPSHOT_ACTIVE; + for (d = 0; d < _NAME_DEPENDENCY_MAX; d++) { + Name *other; + if (set_isempty(n->meta.dependencies[d])) + continue; - case _NAME_TYPE_MAX: - case _NAME_TYPE_INVALID: - ; + SET_FOREACH(other, n->meta.dependencies[d], i) + fprintf(f, "%s\t%s: %s\n", prefix, dependency_table[d], name_id(other)); } - assert_not_reached("Unknown name type."); - return false; + if (NAME_VTABLE(n)->dump) + NAME_VTABLE(n)->dump(n, f, prefix2); + + if (n->meta.job) + job_dump(n->meta.job, f, prefix2); + + free(prefix2); } -static int ensure_in_set(Set **s, void *data) { +static int verify_type(Name *name) { + char *n; + Iterator i; + + assert(name); + + /* Checks that all aliases of this name have the same and valid type */ + + SET_FOREACH(n, name->meta.names, i) { + NameType t; + + if ((t = name_type_from_string(n)) == _NAME_TYPE_INVALID) + return -EINVAL; + + if (name->meta.type == _NAME_TYPE_INVALID) { + name->meta.type = t; + continue; + } + + if (name->meta.type != t) + return -EINVAL; + } + + if (name->meta.type == _NAME_TYPE_INVALID) + return -EINVAL; + + return 0; +} + +/* Common implementation for multiple backends */ +int name_load_fragment_and_dropin(Name *n) { int r; - assert(s); - assert(data); + assert(n); - if (!*s) - if (!(*s = set_new(trivial_hash_func, trivial_compare_func))) - return -ENOMEM; + /* Load a .socket file */ + if ((r = name_load_fragment(n)) < 0) + return r; - if ((r = set_put(*s, data) < 0)) - if (r != -EEXIST) - return r; + /* Load drop-in directory data */ + if ((r = name_load_dropin(n)) < 0) + return r; return 0; } -/* FIXME: Does not rollback on failure! */ -int name_augment(Name *n) { +int name_load(Name *name) { int r; - void* state; + + assert(name); + + if (name->meta.in_load_queue) { + LIST_REMOVE(Meta, load_queue, name->meta.manager->load_queue, &name->meta); + name->meta.in_load_queue = false; + } + + if (name->meta.load_state != NAME_STUB) + return 0; + + if ((r = verify_type(name)) < 0) + return r; + + if (NAME_VTABLE(name)->init) + if ((r = NAME_VTABLE(name)->init(name)) < 0) + goto fail; + + name->meta.load_state = NAME_LOADED; + return 0; + +fail: + name->meta.load_state = NAME_FAILED; + return r; +} + +/* Errors: + * -EBADR: This name type does not support starting. + * -EALREADY: Name is already started. + * -EAGAIN: An operation is already in progress. Retry later. + */ +int name_start(Name *n) { + NameActiveState state; + + assert(n); + + if (!NAME_VTABLE(n)->start) + return -EBADR; + + state = name_active_state(n); + if (NAME_IS_ACTIVE_OR_RELOADING(state)) + return -EALREADY; + + /* We don't suppress calls to ->start() here when we are + * already starting, to allow this request to be used as a + * "hurry up" call, for example when the name is in some "auto + * restart" state where it waits for a holdoff timer to elapse + * before it will start again. */ + + return NAME_VTABLE(n)->start(n); +} + +bool name_type_can_start(NameType t) { + assert(t >= 0 && t < _NAME_TYPE_MAX); + + return !!name_vtable[t]->start; +} + +/* Errors: + * -EBADR: This name type does not support stopping. + * -EALREADY: Name is already stopped. + * -EAGAIN: An operation is already in progress. Retry later. + */ +int name_stop(Name *n) { + NameActiveState state; + + assert(n); + + if (!NAME_VTABLE(n)->stop) + return -EBADR; + + state = name_active_state(n); + if (state == NAME_INACTIVE) + return -EALREADY; + + if (state == NAME_DEACTIVATING) + return 0; + + return NAME_VTABLE(n)->stop(n); +} + +/* Errors: + * -EBADR: This name type does not support reloading. + * -ENOEXEC: Name is not started. + * -EAGAIN: An operation is already in progress. Retry later. + */ +int name_reload(Name *n) { + NameActiveState state; + + assert(n); + + if (!name_can_reload(n)) + return -EBADR; + + state = name_active_state(n); + if (name_active_state(n) == NAME_ACTIVE_RELOADING) + return -EALREADY; + + if (name_active_state(n) != NAME_ACTIVE) + return -ENOEXEC; + + return NAME_VTABLE(n)->reload(n); +} + +bool name_type_can_reload(NameType t) { + assert(t >= 0 && t < _NAME_TYPE_MAX); + + return !!name_vtable[t]->reload; +} + +bool name_can_reload(Name *n) { + assert(n); + + if (!name_type_can_reload(n->meta.type)) + return false; + + if (!NAME_VTABLE(n)->can_reload) + return true; + + return NAME_VTABLE(n)->can_reload(n); +} + +static void retroactively_start_dependencies(Name *n) { + Iterator i; Name *other; assert(n); + assert(NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(n))); - /* Adds in the missing links to make all dependencies - * bidirectional. */ + SET_FOREACH(other, n->meta.dependencies[NAME_REQUIRES], i) + if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other))) + manager_add_job(n->meta.manager, JOB_START, other, JOB_REPLACE, true, NULL); - SET_FOREACH(other, n->meta.dependencies[NAME_BEFORE], state) - if ((r = ensure_in_set(&other->meta.dependencies[NAME_AFTER], n) < 0)) - return r; - SET_FOREACH(other, n->meta.dependencies[NAME_AFTER], state) - if ((r = ensure_in_set(&other->meta.dependencies[NAME_BEFORE], n) < 0)) - return r; + SET_FOREACH(other, n->meta.dependencies[NAME_SOFT_REQUIRES], i) + if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other))) + manager_add_job(n->meta.manager, JOB_START, other, JOB_FAIL, false, NULL); - SET_FOREACH(other, n->meta.dependencies[NAME_CONFLICTS], state) - if ((r = ensure_in_set(&other->meta.dependencies[NAME_CONFLICTS], n) < 0)) - return r; + SET_FOREACH(other, n->meta.dependencies[NAME_REQUISITE], i) + if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other))) + manager_add_job(n->meta.manager, JOB_START, other, JOB_REPLACE, true, NULL); - SET_FOREACH(other, n->meta.dependencies[NAME_REQUIRES], state) - if ((r = ensure_in_set(&other->meta.dependencies[NAME_REQUIRED_BY], n) < 0)) - return r; - SET_FOREACH(other, n->meta.dependencies[NAME_REQUISITE], state) - if ((r = ensure_in_set(&other->meta.dependencies[NAME_REQUIRED_BY], n) < 0)) - return r; + SET_FOREACH(other, n->meta.dependencies[NAME_WANTS], i) + if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other))) + manager_add_job(n->meta.manager, JOB_START, other, JOB_FAIL, false, NULL); - SET_FOREACH(other, n->meta.dependencies[NAME_WANTS], state) - if ((r = ensure_in_set(&other->meta.dependencies[NAME_WANTED_BY], n) < 0)) - return r; - SET_FOREACH(other, n->meta.dependencies[NAME_SOFT_REQUIRES], state) - if ((r = ensure_in_set(&other->meta.dependencies[NAME_WANTED_BY], n) < 0)) - return r; - SET_FOREACH(other, n->meta.dependencies[NAME_SOFT_REQUISITE], state) - if ((r = ensure_in_set(&other->meta.dependencies[NAME_WANTED_BY], n) < 0)) - return r; + SET_FOREACH(other, n->meta.dependencies[NAME_CONFLICTS], i) + if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other))) + manager_add_job(n->meta.manager, JOB_STOP, other, JOB_REPLACE, true, NULL); +} - return r; +static void retroactively_stop_dependencies(Name *n) { + Iterator i; + Name *other; + + assert(n); + assert(NAME_IS_INACTIVE_OR_DEACTIVATING(name_active_state(n))); + + SET_FOREACH(other, n->meta.dependencies[NAME_REQUIRED_BY], i) + if (!NAME_IS_INACTIVE_OR_DEACTIVATING(name_active_state(other))) + manager_add_job(n->meta.manager, JOB_STOP, other, JOB_REPLACE, true, NULL); } -static int ensure_merge(Set **s, Set *other) { +void name_notify(Name *n, NameActiveState os, NameActiveState ns) { + assert(n); + assert(os < _NAME_ACTIVE_STATE_MAX); + assert(ns < _NAME_ACTIVE_STATE_MAX); + assert(!(os == NAME_ACTIVE && ns == NAME_ACTIVATING)); + assert(!(os == NAME_INACTIVE && ns == NAME_DEACTIVATING)); - if (!other) + if (os == ns) + return; + + if (!NAME_IS_ACTIVE_OR_RELOADING(os) && NAME_IS_ACTIVE_OR_RELOADING(ns)) + n->meta.active_enter_timestamp = now(CLOCK_REALTIME); + else if (NAME_IS_ACTIVE_OR_RELOADING(os) && !NAME_IS_ACTIVE_OR_RELOADING(ns)) + n->meta.active_exit_timestamp = now(CLOCK_REALTIME); + + if (n->meta.job) { + + if (n->meta.job->state == JOB_WAITING) + + /* So we reached a different state for this + * job. Let's see if we can run it now if it + * failed previously due to EAGAIN. */ + job_schedule_run(n->meta.job); + + else { + assert(n->meta.job->state == JOB_RUNNING); + + /* Let's check of this state change + * constitutes a finished job, or maybe + * cotradicts a running job and hence needs to + * invalidate jobs. */ + + switch (n->meta.job->type) { + + case JOB_START: + case JOB_VERIFY_ACTIVE: + + if (NAME_IS_ACTIVE_OR_RELOADING(ns)) { + job_finish_and_invalidate(n->meta.job, true); + return; + } else if (ns == NAME_ACTIVATING) + return; + else + job_finish_and_invalidate(n->meta.job, false); + + break; + + case JOB_RELOAD: + case JOB_RELOAD_OR_START: + + if (ns == NAME_ACTIVE) { + job_finish_and_invalidate(n->meta.job, true); + return; + } else if (ns == NAME_ACTIVATING || ns == NAME_ACTIVE_RELOADING) + return; + else + job_finish_and_invalidate(n->meta.job, false); + + break; + + case JOB_STOP: + case JOB_RESTART: + case JOB_TRY_RESTART: + + if (ns == NAME_INACTIVE) { + job_finish_and_invalidate(n->meta.job, true); + return; + } else if (ns == NAME_DEACTIVATING) + return; + else + job_finish_and_invalidate(n->meta.job, false); + + break; + + default: + assert_not_reached("Job type unknown"); + } + } + } + + /* If this state change happened without being requested by a + * job, then let's retroactively start or stop dependencies */ + + if (NAME_IS_INACTIVE_OR_DEACTIVATING(os) && NAME_IS_ACTIVE_OR_ACTIVATING(ns)) + retroactively_start_dependencies(n); + else if (NAME_IS_ACTIVE_OR_ACTIVATING(os) && NAME_IS_INACTIVE_OR_DEACTIVATING(ns)) + retroactively_stop_dependencies(n); +} + +int name_watch_fd(Name *n, int fd, uint32_t events) { + struct epoll_event ev; + + assert(n); + assert(fd >= 0); + + zero(ev); + ev.data.fd = fd; + ev.data.ptr = n; + ev.data.u32 = MANAGER_FD; + ev.events = events; + + if (epoll_ctl(n->meta.manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) >= 0) return 0; - if (*s) - return set_merge(*s, other); + if (errno == EEXIST) + if (epoll_ctl(n->meta.manager->epoll_fd, EPOLL_CTL_MOD, fd, &ev) >= 0) + return 0; - if (!(*s = set_copy(other))) - return -ENOMEM; + return -errno; +} - return 0; +void name_unwatch_fd(Name *n, int fd) { + assert(n); + assert(fd >= 0); + + assert_se(epoll_ctl(n->meta.manager->epoll_fd, EPOLL_CTL_DEL, fd, NULL) >= 0 || errno == ENOENT); } -/* FIXME: Does not rollback on failure! */ -int name_merge(Name *name, Name *other) { - int r; - NameDependency d; +int name_watch_pid(Name *n, pid_t pid) { + assert(n); + assert(pid >= 1); - assert(name); - assert(other); - assert(name->meta.manager == other->meta.manager); + return hashmap_put(n->meta.manager->watch_pids, UINT32_TO_PTR(pid), n); +} - /* This merges 'other' into 'name'. FIXME: This does not - * rollback on failure. */ +void name_unwatch_pid(Name *n, pid_t pid) { + assert(n); + assert(pid >= 1); - if (name->meta.type != other->meta.type) - return -EINVAL; + hashmap_remove(n->meta.manager->watch_pids, UINT32_TO_PTR(pid)); +} - if (other->meta.state != NAME_STUB) - return -EINVAL; +int name_watch_timer(Name *n, usec_t delay, int *id) { + struct epoll_event ev; + int fd; + struct itimerspec its; + int flags; + bool ours; - /* Merge names */ - if ((r = ensure_merge(&name->meta.names, other->meta.names)) < 0) - return r; + assert(n); + assert(id); - /* Merge dependencies */ - for (d = 0; d < _NAME_DEPENDENCY_MAX; d++) - if ((r = ensure_merge(&name->meta.dependencies[d], other->meta.dependencies[d])) < 0) - return r; + /* This will try to reuse the old timer if there is one */ - /* Hookup new deps and names */ - if (name->meta.linked) { - if ((r = name_augment(name)) < 0) - return r; + if (*id >= 0) { + ours = false; + fd = *id; - if ((r = name_link_names(name, true)) < 0) - return r; + } else { + ours = true; + + if ((fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC)) < 0) + return -errno; } + zero(its); + + if (delay <= 0) { + /* Set absolute time in the past, but not 0, since we + * don't want to disarm the timer */ + its.it_value.tv_sec = 0; + its.it_value.tv_nsec = 1; + + flags = TFD_TIMER_ABSTIME; + } else { + timespec_store(&its.it_value, delay); + flags = 0; + } + + /* This will also flush the elapse counter */ + if (timerfd_settime(fd, flags, &its, NULL) < 0) + goto fail; + + zero(ev); + ev.data.fd = fd; + ev.data.ptr = n; + ev.data.u32 = MANAGER_TIMER; + ev.events = POLLIN; + + if (epoll_ctl(n->meta.manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0) + goto fail; + + *id = fd; return 0; + +fail: + if (ours) + assert_se(close_nointr(fd) == 0); + + return -errno; } -const char* name_id(Name *n) { +void name_unwatch_timer(Name *n, int *id) { assert(n); + assert(id); - return set_first(n->meta.names); + if (*id >= 0) { + assert_se(epoll_ctl(n->meta.manager->epoll_fd, EPOLL_CTL_DEL, *id, NULL) >= 0); + assert_se(close_nointr(*id) == 0); + + *id = -1; + } } -void name_dump(Name *n, FILE *f, const char *prefix) { +char *name_change_suffix(const char *t, const char *suffix) { + char *e, *n; + size_t a, b; - static const char* const state_table[_NAME_STATE_MAX] = { - [NAME_STUB] = "stub", - [NAME_LOADED] = "loaded", - [NAME_FAILED] = "failed" - }; + assert(t); + assert(name_is_valid(t)); + assert(suffix); - static const char* const socket_state_table[_SOCKET_STATE_MAX] = { - [SOCKET_DEAD] = "dead", - [SOCKET_BEFORE] = "before", - [SOCKET_START_PRE] = "start-pre", - [SOCKET_START] = "start", - [SOCKET_START_POST] = "start-post", - [SOCKET_LISTENING] = "listening", - [SOCKET_RUNNING] = "running", - [SOCKET_STOP_PRE] = "stop-pre", - [SOCKET_STOP] = "stop", - [SOCKET_STOP_POST] = "stop-post", - [SOCKET_MAINTAINANCE] = "maintainance" - }; + assert_se(e = strrchr(t, '.')); + a = e - t; + b = strlen(suffix); - void *state; - char *t; + if (!(n = new(char, a + b + 1))) + return NULL; + memcpy(n, t, a); + memcpy(n+a, suffix, b+1); + + return n; +} + +bool name_job_is_applicable(Name *n, JobType j) { assert(n); + assert(j >= 0 && j < _JOB_TYPE_MAX); - if (!prefix) - prefix = ""; + switch (j) { + case JOB_VERIFY_ACTIVE: + case JOB_START: + return true; - fprintf(f, - "%sName %s:\n" - "%s\tDescription: %s\n" - "%s\tName State: %s\n", - prefix, name_id(n), - prefix, n->meta.description ? n->meta.description : name_id(n), - prefix, state_table[n->meta.state]); - - fprintf(f, "%s\tNames: ", prefix); - SET_FOREACH(t, n->meta.names, state) - fprintf(f, "%s ", t); - fprintf(f, "\n"); - - switch (n->meta.type) { - case NAME_SOCKET: { - int r; - char *s = NULL; - const char *t; - - if ((r = address_print(&n->socket.address, &s)) < 0) - t = strerror(-r); - else - t = s; - - fprintf(f, - "%s\tAddress: %s\n" - "%s\tSocket State: %s\n", - prefix, t, - prefix, socket_state_table[n->socket.state]); - - free(s); - break; - } + case JOB_STOP: + case JOB_RESTART: + case JOB_TRY_RESTART: + return name_can_start(n); + + case JOB_RELOAD: + return name_can_reload(n); + + case JOB_RELOAD_OR_START: + return name_can_reload(n) && name_can_start(n); default: - ; + assert_not_reached("Invalid job type"); } +} - if (n->meta.job) { - char *p; +int name_add_dependency(Name *n, NameDependency d, Name *other) { + + static const NameDependency inverse_table[_NAME_DEPENDENCY_MAX] = { + [NAME_REQUIRES] = NAME_REQUIRED_BY, + [NAME_SOFT_REQUIRES] = NAME_SOFT_REQUIRED_BY, + [NAME_WANTS] = NAME_WANTED_BY, + [NAME_REQUISITE] = NAME_REQUIRED_BY, + [NAME_SOFT_REQUISITE] = NAME_SOFT_REQUIRED_BY, + [NAME_REQUIRED_BY] = _NAME_DEPENDENCY_INVALID, + [NAME_SOFT_REQUIRED_BY] = _NAME_DEPENDENCY_INVALID, + [NAME_WANTED_BY] = _NAME_DEPENDENCY_INVALID, + [NAME_CONFLICTS] = NAME_CONFLICTS, + [NAME_BEFORE] = NAME_AFTER, + [NAME_AFTER] = NAME_BEFORE + }; + int r; - if (asprintf(&p, "%s\t", prefix) >= 0) - prefix = p; - else - p = NULL; + assert(n); + assert(d >= 0 && d < _NAME_DEPENDENCY_MAX); + assert(inverse_table[d] != _NAME_DEPENDENCY_INVALID); + assert(other); + + if (n == other) + return 0; - job_dump(n->meta.job, f, prefix); - free(p); + if ((r = set_ensure_allocated(&n->meta.dependencies[d], trivial_hash_func, trivial_compare_func)) < 0) + return r; + + if ((r = set_ensure_allocated(&other->meta.dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0) + return r; + + if ((r = set_put(n->meta.dependencies[d], other)) < 0) + return r; + + if ((r = set_put(other->meta.dependencies[inverse_table[d]], n)) < 0) { + set_remove(n->meta.dependencies[d], other); + return r; } + + return 0; }