1 /*-*- Mode: C; c-basic-offset: 8 -*-*/
7 #include <sys/timerfd.h>
14 #include "load-fragment.h"
15 #include "load-dropin.h"
17 const NameVTable * const name_vtable[_NAME_TYPE_MAX] = {
18 [NAME_SERVICE] = &service_vtable,
19 [NAME_TIMER] = &timer_vtable,
20 [NAME_SOCKET] = &socket_vtable,
21 [NAME_MILESTONE] = &milestone_vtable,
22 [NAME_DEVICE] = &device_vtable,
23 [NAME_MOUNT] = &mount_vtable,
24 [NAME_AUTOMOUNT] = &automount_vtable,
25 [NAME_SNAPSHOT] = &snapshot_vtable
28 NameType name_type_from_string(const char *n) {
33 for (t = 0; t < _NAME_TYPE_MAX; t++)
34 if (endswith(n, name_vtable[t]->suffix))
37 return _NAME_TYPE_INVALID;
42 "abcdefghijklmnopqrstuvwxyz" \
43 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
46 bool name_is_valid(const char *n) {
52 if (strlen(n) >= NAME_MAX)
55 t = name_type_from_string(n);
56 if (t < 0 || t >= _NAME_TYPE_MAX)
59 if (!(e = strrchr(n, '.')))
62 for (i = n; i < e; i++)
63 if (!strchr(VALID_CHARS, *i))
69 Name *name_new(Manager *m) {
74 if (!(n = new0(Name, 1)))
77 if (!(n->meta.names = set_new(string_hash_func, string_compare_func))) {
83 n->meta.type = _NAME_TYPE_INVALID;
85 /* We don't link the name here, that is left for name_link() */
90 int name_add_name(Name *n, const char *text) {
98 if ((t = name_type_from_string(text)) == _NAME_TYPE_INVALID)
101 if (n->meta.type != _NAME_TYPE_INVALID && t != n->meta.type)
104 if (!(s = strdup(text)))
107 if ((r = set_put(n->meta.names, s)) < 0) {
120 /* FIXME: Does not rollback on failure! */
121 int name_link_names(Name *n, bool replace) {
131 /* Link all names that aren't linked yet. */
133 SET_FOREACH(t, n->meta.names, i)
135 if ((r = hashmap_replace(n->meta.manager->names, t, n)) < 0)
138 if ((r = hashmap_put(n->meta.manager->names, t, n)) < 0)
145 int name_link(Name *n) {
149 assert(!set_isempty(n->meta.names));
150 assert(!n->meta.linked);
152 if ((r = name_sanitize(n)) < 0)
155 n->meta.linked = true;
157 if ((r = name_link_names(n, false)) < 0) {
161 /* Rollback the registered names */
162 SET_FOREACH(t, n->meta.names, i)
163 hashmap_remove_value(n->meta.manager->names, t, n);
165 n->meta.linked = false;
169 if (n->meta.load_state == NAME_STUB) {
170 LIST_PREPEND(Meta, load_queue, n->meta.manager->load_queue, &n->meta);
171 n->meta.in_load_queue = true;
177 static void bidi_set_free(Name *name, Set *s) {
183 /* Frees the set and makes sure we are dropped from the
184 * inverse pointers */
186 SET_FOREACH(other, s, i) {
189 for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
190 set_remove(other->meta.dependencies[d], name);
196 void name_free(Name *name) {
202 /* Detach from next 'bigger' objects */
203 if (name->meta.linked) {
207 SET_FOREACH(t, name->meta.names, i)
208 hashmap_remove_value(name->meta.manager->names, t, name);
210 if (name->meta.in_load_queue)
211 LIST_REMOVE(Meta, load_queue, name->meta.manager->load_queue, &name->meta);
214 /* Free data and next 'smaller' objects */
216 job_free(name->meta.job);
218 for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
219 bidi_set_free(name, name->meta.dependencies[d]);
221 if (NAME_VTABLE(name)->done)
222 NAME_VTABLE(name)->done(name);
224 free(name->meta.description);
226 while ((t = set_steal_first(name->meta.names)))
228 set_free(name->meta.names);
233 NameActiveState name_active_state(Name *name) {
236 if (name->meta.load_state != NAME_LOADED)
237 return NAME_INACTIVE;
239 return NAME_VTABLE(name)->active_state(name);
242 static int ensure_in_set(Set **s, void *data) {
248 if ((r = set_ensure_allocated(s, trivial_hash_func, trivial_compare_func)) < 0)
251 if ((r = set_put(*s, data)) < 0)
257 static int ensure_merge(Set **s, Set *other) {
263 return set_merge(*s, other);
265 if (!(*s = set_copy(other)))
271 /* FIXME: Does not rollback on failure! */
272 int name_merge(Name *name, Name *other) {
278 assert(name->meta.manager == other->meta.manager);
280 /* This merges 'other' into 'name'. FIXME: This does not
281 * rollback on failure. */
283 if (name->meta.type != other->meta.type)
286 if (other->meta.load_state != NAME_STUB)
290 if ((r = ensure_merge(&name->meta.names, other->meta.names)) < 0)
293 /* Merge dependencies */
294 for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
295 if ((r = ensure_merge(&name->meta.dependencies[d], other->meta.dependencies[d])) < 0)
298 /* Hookup new deps and names */
299 if (name->meta.linked) {
300 if ((r = name_sanitize(name)) < 0)
303 if ((r = name_link_names(name, true)) < 0)
310 /* FIXME: Does not rollback on failure! */
311 static int augment(Name *n) {
318 /* Adds in the missing links to make all dependencies
321 SET_FOREACH(other, n->meta.dependencies[NAME_BEFORE], i)
322 if ((r = ensure_in_set(&other->meta.dependencies[NAME_AFTER], n)) < 0)
324 SET_FOREACH(other, n->meta.dependencies[NAME_AFTER], i)
325 if ((r = ensure_in_set(&other->meta.dependencies[NAME_BEFORE], n)) < 0)
328 SET_FOREACH(other, n->meta.dependencies[NAME_CONFLICTS], i)
329 if ((r = ensure_in_set(&other->meta.dependencies[NAME_CONFLICTS], n)) < 0)
332 SET_FOREACH(other, n->meta.dependencies[NAME_REQUIRES], i)
333 if ((r = ensure_in_set(&other->meta.dependencies[NAME_REQUIRED_BY], n)) < 0)
335 SET_FOREACH(other, n->meta.dependencies[NAME_REQUISITE], i)
336 if ((r = ensure_in_set(&other->meta.dependencies[NAME_REQUIRED_BY], n)) < 0)
339 SET_FOREACH(other, n->meta.dependencies[NAME_SOFT_REQUIRES], i)
340 if ((r = ensure_in_set(&other->meta.dependencies[NAME_SOFT_REQUIRED_BY], n)) < 0)
343 SET_FOREACH(other, n->meta.dependencies[NAME_WANTS], i)
344 if ((r = ensure_in_set(&other->meta.dependencies[NAME_WANTED_BY], n)) < 0)
350 int name_sanitize(Name *n) {
356 for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
357 set_remove(n->meta.dependencies[d], n);
362 const char* name_id(Name *n) {
368 return set_first(n->meta.names);
371 const char *name_description(Name *n) {
374 if (n->meta.description)
375 return n->meta.description;
380 void name_dump(Name *n, FILE *f, const char *prefix) {
382 static const char* const load_state_table[_NAME_LOAD_STATE_MAX] = {
383 [NAME_STUB] = "stub",
384 [NAME_LOADED] = "loaded",
385 [NAME_FAILED] = "failed"
388 static const char* const active_state_table[_NAME_ACTIVE_STATE_MAX] = {
389 [NAME_ACTIVE] = "active",
390 [NAME_INACTIVE] = "inactive",
391 [NAME_ACTIVATING] = "activating",
392 [NAME_DEACTIVATING] = "deactivating"
395 static const char* const dependency_table[_NAME_DEPENDENCY_MAX] = {
396 [NAME_REQUIRES] = "Requires",
397 [NAME_SOFT_REQUIRES] = "SoftRequires",
398 [NAME_WANTS] = "Wants",
399 [NAME_REQUISITE] = "Requisite",
400 [NAME_SOFT_REQUISITE] = "SoftRequisite",
401 [NAME_REQUIRED_BY] = "RequiredBy",
402 [NAME_SOFT_REQUIRED_BY] = "SoftRequiredBy",
403 [NAME_WANTED_BY] = "WantedBy",
404 [NAME_CONFLICTS] = "Conflicts",
405 [NAME_BEFORE] = "Before",
406 [NAME_AFTER] = "After",
420 "%s\tDescription: %s\n"
421 "%s\tName Load State: %s\n"
422 "%s\tName Active State: %s\n",
424 prefix, name_description(n),
425 prefix, load_state_table[n->meta.load_state],
426 prefix, active_state_table[name_active_state(n)]);
428 SET_FOREACH(t, n->meta.names, i)
429 fprintf(f, "%s\tName: %s\n", prefix, t);
431 for (d = 0; d < _NAME_DEPENDENCY_MAX; d++) {
434 if (set_isempty(n->meta.dependencies[d]))
437 SET_FOREACH(other, n->meta.dependencies[d], i)
438 fprintf(f, "%s\t%s: %s\n", prefix, dependency_table[d], name_id(other));
441 if (NAME_VTABLE(n)->dump)
442 NAME_VTABLE(n)->dump(n, f, prefix);
447 if (asprintf(&p, "%s\t", prefix) >= 0)
452 job_dump(n->meta.job, f, prefix);
457 static int verify_type(Name *name) {
463 /* Checks that all aliases of this name have the same and valid type */
465 SET_FOREACH(n, name->meta.names, i) {
468 if ((t = name_type_from_string(n)) == _NAME_TYPE_INVALID)
471 if (name->meta.type == _NAME_TYPE_INVALID) {
476 if (name->meta.type != t)
480 if (name->meta.type == _NAME_TYPE_INVALID)
486 /* Common implementation for multiple backends */
487 int name_load_fragment_and_dropin(Name *n) {
492 /* Load a .socket file */
493 if ((r = name_load_fragment(n)) < 0)
496 /* Load drop-in directory data */
497 if ((r = name_load_dropin(n)) < 0)
503 int name_load(Name *name) {
508 if (name->meta.in_load_queue) {
509 LIST_REMOVE(Meta, load_queue, name->meta.manager->load_queue, &name->meta);
510 name->meta.in_load_queue = false;
513 if (name->meta.load_state != NAME_STUB)
516 if ((r = verify_type(name)) < 0)
519 if (NAME_VTABLE(name)->init)
520 if ((r = NAME_VTABLE(name)->init(name)) < 0)
523 if ((r = name_sanitize(name)) < 0)
526 if ((r = name_link_names(name, false)) < 0)
529 name->meta.load_state = NAME_LOADED;
533 name->meta.load_state = NAME_FAILED;
538 * -EBADR: This name type does not support starting.
539 * -EALREADY: Name is already started.
540 * -EAGAIN: An operation is already in progress. Retry later.
542 int name_start(Name *n) {
543 NameActiveState state;
547 if (!NAME_VTABLE(n)->start)
550 state = name_active_state(n);
551 if (NAME_IS_ACTIVE_OR_RELOADING(state))
554 /* We don't suppress calls to ->start() here when we are
555 * already starting, to allow this request to be used as a
556 * "hurry up" call, for example when the name is in some "auto
557 * restart" state where it waits for a holdoff timer to elapse
558 * before it will start again. */
560 return NAME_VTABLE(n)->start(n);
563 bool name_type_can_start(NameType t) {
564 assert(t >= 0 && t < _NAME_TYPE_MAX);
566 return !!name_vtable[t]->start;
570 * -EBADR: This name type does not support stopping.
571 * -EALREADY: Name is already stopped.
572 * -EAGAIN: An operation is already in progress. Retry later.
574 int name_stop(Name *n) {
575 NameActiveState state;
579 if (!NAME_VTABLE(n)->stop)
582 state = name_active_state(n);
583 if (state == NAME_INACTIVE)
586 if (state == NAME_DEACTIVATING)
589 return NAME_VTABLE(n)->stop(n);
593 * -EBADR: This name type does not support reloading.
594 * -ENOEXEC: Name is not started.
595 * -EAGAIN: An operation is already in progress. Retry later.
597 int name_reload(Name *n) {
598 NameActiveState state;
602 if (!name_can_reload(n))
605 state = name_active_state(n);
606 if (name_active_state(n) == NAME_ACTIVE_RELOADING)
609 if (name_active_state(n) != NAME_ACTIVE)
612 return NAME_VTABLE(n)->reload(n);
615 bool name_type_can_reload(NameType t) {
616 assert(t >= 0 && t < _NAME_TYPE_MAX);
618 return !!name_vtable[t]->reload;
621 bool name_can_reload(Name *n) {
624 if (!name_type_can_reload(n->meta.type))
627 if (!NAME_VTABLE(n)->can_reload)
630 return NAME_VTABLE(n)->can_reload(n);
633 static void retroactively_start_dependencies(Name *n) {
638 assert(NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(n)));
640 SET_FOREACH(other, n->meta.dependencies[NAME_REQUIRES], i)
641 if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other)))
642 manager_add_job(n->meta.manager, JOB_START, other, JOB_REPLACE, true, NULL);
644 SET_FOREACH(other, n->meta.dependencies[NAME_SOFT_REQUIRES], i)
645 if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other)))
646 manager_add_job(n->meta.manager, JOB_START, other, JOB_FAIL, false, NULL);
648 SET_FOREACH(other, n->meta.dependencies[NAME_REQUISITE], i)
649 if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other)))
650 manager_add_job(n->meta.manager, JOB_START, other, JOB_REPLACE, true, NULL);
652 SET_FOREACH(other, n->meta.dependencies[NAME_WANTS], i)
653 if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other)))
654 manager_add_job(n->meta.manager, JOB_START, other, JOB_FAIL, false, NULL);
656 SET_FOREACH(other, n->meta.dependencies[NAME_CONFLICTS], i)
657 if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other)))
658 manager_add_job(n->meta.manager, JOB_STOP, other, JOB_REPLACE, true, NULL);
661 static void retroactively_stop_dependencies(Name *n) {
666 assert(NAME_IS_INACTIVE_OR_DEACTIVATING(name_active_state(n)));
668 SET_FOREACH(other, n->meta.dependencies[NAME_REQUIRED_BY], i)
669 if (!NAME_IS_INACTIVE_OR_DEACTIVATING(name_active_state(other)))
670 manager_add_job(n->meta.manager, JOB_STOP, other, JOB_REPLACE, true, NULL);
673 void name_notify(Name *n, NameActiveState os, NameActiveState ns) {
675 assert(os < _NAME_ACTIVE_STATE_MAX);
676 assert(ns < _NAME_ACTIVE_STATE_MAX);
677 assert(!(os == NAME_ACTIVE && ns == NAME_ACTIVATING));
678 assert(!(os == NAME_INACTIVE && ns == NAME_DEACTIVATING));
683 if (!NAME_IS_ACTIVE_OR_RELOADING(os) && NAME_IS_ACTIVE_OR_RELOADING(ns))
684 n->meta.active_enter_timestamp = now(CLOCK_REALTIME);
685 else if (NAME_IS_ACTIVE_OR_RELOADING(os) && !NAME_IS_ACTIVE_OR_RELOADING(ns))
686 n->meta.active_exit_timestamp = now(CLOCK_REALTIME);
690 if (n->meta.job->state == JOB_WAITING)
692 /* So we reached a different state for this
693 * job. Let's see if we can run it now if it
694 * failed previously due to EAGAIN. */
695 job_schedule_run(n->meta.job);
698 assert(n->meta.job->state == JOB_RUNNING);
700 /* Let's check of this state change
701 * constitutes a finished job, or maybe
702 * cotradicts a running job and hence needs to
703 * invalidate jobs. */
705 switch (n->meta.job->type) {
708 case JOB_VERIFY_ACTIVE:
710 if (NAME_IS_ACTIVE_OR_RELOADING(ns)) {
711 job_finish_and_invalidate(n->meta.job, true);
713 } else if (ns == NAME_ACTIVATING)
716 job_finish_and_invalidate(n->meta.job, false);
721 case JOB_RELOAD_OR_START:
723 if (ns == NAME_ACTIVE) {
724 job_finish_and_invalidate(n->meta.job, true);
726 } else if (ns == NAME_ACTIVATING || ns == NAME_ACTIVE_RELOADING)
729 job_finish_and_invalidate(n->meta.job, false);
735 case JOB_TRY_RESTART:
737 if (ns == NAME_INACTIVE) {
738 job_finish_and_invalidate(n->meta.job, true);
740 } else if (ns == NAME_DEACTIVATING)
743 job_finish_and_invalidate(n->meta.job, false);
748 assert_not_reached("Job type unknown");
753 /* If this state change happened without being requested by a
754 * job, then let's retroactively start or stop dependencies */
756 if (NAME_IS_INACTIVE_OR_DEACTIVATING(os) && NAME_IS_ACTIVE_OR_ACTIVATING(ns))
757 retroactively_start_dependencies(n);
758 else if (NAME_IS_ACTIVE_OR_ACTIVATING(os) && NAME_IS_INACTIVE_OR_DEACTIVATING(ns))
759 retroactively_stop_dependencies(n);
762 int name_watch_fd(Name *n, int fd, uint32_t events) {
763 struct epoll_event ev;
771 ev.data.u32 = MANAGER_FD;
774 if (epoll_ctl(n->meta.manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) >= 0)
778 if (epoll_ctl(n->meta.manager->epoll_fd, EPOLL_CTL_MOD, fd, &ev) >= 0)
784 void name_unwatch_fd(Name *n, int fd) {
788 assert_se(epoll_ctl(n->meta.manager->epoll_fd, EPOLL_CTL_DEL, fd, NULL) >= 0 || errno == ENOENT);
791 int name_watch_pid(Name *n, pid_t pid) {
795 return hashmap_put(n->meta.manager->watch_pids, UINT32_TO_PTR(pid), n);
798 void name_unwatch_pid(Name *n, pid_t pid) {
802 hashmap_remove(n->meta.manager->watch_pids, UINT32_TO_PTR(pid));
805 int name_watch_timer(Name *n, usec_t delay, int *id) {
806 struct epoll_event ev;
808 struct itimerspec its;
815 /* This will try to reuse the old timer if there is one */
824 if ((fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC)) < 0)
831 /* Set absolute time in the past, but not 0, since we
832 * don't want to disarm the timer */
833 its.it_value.tv_sec = 0;
834 its.it_value.tv_nsec = 1;
836 flags = TFD_TIMER_ABSTIME;
838 timespec_store(&its.it_value, delay);
842 /* This will also flush the elapse counter */
843 if (timerfd_settime(fd, flags, &its, NULL) < 0)
849 ev.data.u32 = MANAGER_TIMER;
852 if (epoll_ctl(n->meta.manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
860 assert_se(close_nointr(fd) == 0);
865 void name_unwatch_timer(Name *n, int *id) {
870 assert_se(epoll_ctl(n->meta.manager->epoll_fd, EPOLL_CTL_DEL, *id, NULL) >= 0);
871 assert_se(close_nointr(*id) == 0);
877 char *name_change_suffix(const char *t, const char *suffix) {
882 assert(name_is_valid(t));
885 assert_se(e = strrchr(t, '.'));
889 if (!(n = new(char, a + b + 1)))
898 bool name_job_is_applicable(Name *n, JobType j) {
900 assert(j >= 0 && j < _JOB_TYPE_MAX);
903 case JOB_VERIFY_ACTIVE:
909 case JOB_TRY_RESTART:
910 return name_can_start(n);
913 return name_can_reload(n);
915 case JOB_RELOAD_OR_START:
916 return name_can_reload(n) && name_can_start(n);
919 assert_not_reached("Invalid job type");