#include <assert.h>
#include <errno.h>
#include <string.h>
+#include <sys/epoll.h>
+#include <sys/timerfd.h>
+#include <sys/poll.h>
#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;
assert(n);
+ if (strlen(n) >= NAME_MAX)
+ return false;
+
t = name_type_from_string(n);
if (t < 0 || t >= _NAME_TYPE_MAX)
return false;
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;
}
+int name_add_name(Name *n, const char *text) {
+ NameType t;
+ char *s;
+ int r;
+
+ assert(n);
+ assert(text);
+
+ if ((t = name_type_from_string(text)) == _NAME_TYPE_INVALID)
+ return -EINVAL;
+
+ if (n->meta.type != _NAME_TYPE_INVALID && t != n->meta.type)
+ return -EINVAL;
+
+ if (!(s = strdup(text)))
+ return -ENOMEM;
+
+ if ((r = set_put(n->meta.names, s)) < 0) {
+ free(s);
+ return r;
+ }
+
+ n->meta.type = t;
+
+ if (!n->meta.id)
+ n->meta.id = s;
+
+ return 0;
+}
+
/* FIXME: Does not rollback on failure! */
int name_link_names(Name *n, bool replace) {
char *t;
- void *state;
+ Iterator i;
int r;
assert(n);
/* Link all names that aren't linked yet. */
- SET_FOREACH(t, n->meta.names, state)
+ SET_FOREACH(t, n->meta.names, i)
if (replace) {
if ((r = hashmap_replace(n->meta.manager->names, t, n)) < 0)
return r;
assert(!set_isempty(n->meta.names));
assert(!n->meta.linked);
+ if ((r = name_sanitize(n)) < 0)
+ return r;
+
n->meta.linked = true;
- if ((r = name_link_names(n, false) < 0)) {
+ if ((r = name_link_names(n, false)) < 0) {
char *t;
- void *state;
+ Iterator i;
/* Rollback the registered names */
- SET_FOREACH(t, n->meta.names, state)
+ SET_FOREACH(t, n->meta.names, i)
hashmap_remove_value(n->meta.manager->names, t, n);
n->meta.linked = false;
return r;
}
- if (n->meta.state == NAME_STUB)
- LIST_PREPEND(Meta, n->meta.manager->load_queue, &n->meta);
+ if (n->meta.load_state == NAME_STUB) {
+ LIST_PREPEND(Meta, load_queue, n->meta.manager->load_queue, &n->meta);
+ n->meta.in_load_queue = true;
+ }
return 0;
}
static void bidi_set_free(Name *name, Set *s) {
- void *state;
+ Iterator i;
Name *other;
assert(name);
/* Frees the set and makes sure we are dropped from the
* inverse pointers */
- SET_FOREACH(other, s, state) {
- NameDependency d;
+ if (name->meta.linked) {
+ SET_FOREACH(other, s, i) {
+ NameDependency d;
- for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
- set_remove(other->meta.dependencies[d], name);
+ for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
+ set_remove(other->meta.dependencies[d], name);
+ }
}
set_free(s);
/* Detach from next 'bigger' objects */
if (name->meta.linked) {
char *t;
- void *state;
+ Iterator i;
- SET_FOREACH(t, name->meta.names, state)
+ 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)
job_free(name->meta.job);
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;
+
+ return 0;
+}
+
+/* FIXME: Does not rollback on failure! */
+int name_merge(Name *name, Name *other) {
+ int r;
+ NameDependency d;
+
+ 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;
+
+ /* Hookup new deps and names */
+ if (name->meta.linked) {
+ if ((r = name_sanitize(name)) < 0)
+ return r;
+
+ if ((r = name_link_names(name, true)) < 0)
+ return r;
}
- free(name->meta.description);
+ return 0;
+}
- while ((t = set_steal_first(name->meta.names)))
- free(t);
- set_free(name->meta.names);
+int name_sanitize(Name *n) {
+ NameDependency d;
- free(name);
+ assert(n);
+
+ /* Remove loops */
+ for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
+ set_remove(n->meta.dependencies[d], n);
+
+ 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",
+ };
+
+ char *t;
+ NameDependency d;
+ Iterator i;
+ char *prefix2;
- case NAME_MILESTONE:
- return MILESTONE(name)->state == MILESTONE_ACTIVE;
+ assert(n);
- case NAME_DEVICE:
- return DEVICE(name)->state == DEVICE_AVAILABLE;
+ if (!prefix)
+ prefix = "";
+ prefix2 = strappend(prefix, "\t");
+ if (!prefix2)
+ prefix2 = "";
- case NAME_MOUNT:
- return MOUNT(name)->state == MOUNT_MOUNTED;
+ 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)]);
+
+ SET_FOREACH(t, n->meta.names, i)
+ fprintf(f, "%s\tName: %s\n", prefix, t);
+
+ for (d = 0; d < _NAME_DEPENDENCY_MAX; d++) {
+ Name *other;
+
+ if (set_isempty(n->meta.dependencies[d]))
+ continue;
+
+ SET_FOREACH(other, n->meta.dependencies[d], i)
+ fprintf(f, "%s\t%s: %s\n", prefix, dependency_table[d], name_id(other));
+ }
- case NAME_AUTOMOUNT: {
- Automount *a = AUTOMOUNT(name);
+ if (NAME_VTABLE(n)->dump)
+ NAME_VTABLE(n)->dump(n, f, prefix2);
- return
- a->state == AUTOMOUNT_WAITING ||
- a->state == AUTOMOUNT_RUNNING;
- }
+ if (n->meta.job)
+ job_dump(n->meta.job, f, prefix2);
- case NAME_SNAPSHOT:
- return SNAPSHOT(name)->state == SNAPSHOT_ACTIVE;
+ free(prefix2);
+}
+
+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;
- case _NAME_TYPE_MAX:
- case _NAME_TYPE_INVALID:
- ;
+ 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;
}
- assert_not_reached("Unknown name type.");
- return false;
+ if (name->meta.type == _NAME_TYPE_INVALID)
+ return -EINVAL;
+
+ return 0;
}
-static int ensure_in_set(Set **s, void *data) {
+/* 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;
+
+ if ((r = name_sanitize(name)) < 0)
+ goto fail_undo_init;
+
+ if ((r = name_link_names(name, false)) < 0)
+ goto fail_undo_init;
+
+ name->meta.load_state = NAME_LOADED;
+ return 0;
+
+fail_undo_init:
+ if (NAME_VTABLE(name)->done)
+ NAME_VTABLE(name)->done(name);
+
+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) {
+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);
- fprintf(f,
- "Name %s\n"
- "\tDescription: %s\n"
- "\tName State: %s\n",
- name_id(n),
- n->meta.description ? n->meta.description : name_id(n),
- state_table[n->meta.state]);
-
- fprintf(f, "\tNames: ");
- 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,
- "\tAddress: %s\n"
- "\tSocket State: %s\n",
- t,
- socket_state_table[n->socket.state]);
-
- free(s);
- break;
- }
+ switch (j) {
+ case JOB_VERIFY_ACTIVE:
+ case JOB_START:
+ return true;
+
+ 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) {
- fprintf(f, "\t");
- job_dump(n->meta.job, f);
+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;
+
+ assert(n);
+ assert(d >= 0 && d < _NAME_DEPENDENCY_MAX);
+ assert(inverse_table[d] != _NAME_DEPENDENCY_INVALID);
+ assert(other);
+
+ 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;
}
~ianmdlvl / elogind.git / blobdiff