1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
25 #include <sys/epoll.h>
26 #include <sys/timerfd.h>
33 #include "sd-messages.h"
38 #include "path-util.h"
39 #include "load-fragment.h"
40 #include "load-dropin.h"
42 #include "unit-name.h"
43 #include "dbus-unit.h"
45 #include "cgroup-util.h"
49 #include "fileio-label.h"
50 #include "bus-errors.h"
54 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
55 [UNIT_SERVICE] = &service_vtable,
56 [UNIT_TIMER] = &timer_vtable,
57 [UNIT_SOCKET] = &socket_vtable,
58 [UNIT_TARGET] = &target_vtable,
59 [UNIT_DEVICE] = &device_vtable,
60 [UNIT_MOUNT] = &mount_vtable,
61 [UNIT_AUTOMOUNT] = &automount_vtable,
62 [UNIT_SNAPSHOT] = &snapshot_vtable,
63 [UNIT_SWAP] = &swap_vtable,
64 [UNIT_PATH] = &path_vtable,
65 [UNIT_SLICE] = &slice_vtable,
66 [UNIT_SCOPE] = &scope_vtable
69 Unit *unit_new(Manager *m, size_t size) {
73 assert(size >= sizeof(Unit));
79 u->names = set_new(string_hash_func, string_compare_func);
86 u->type = _UNIT_TYPE_INVALID;
87 u->deserialized_job = _JOB_TYPE_INVALID;
88 u->default_dependencies = true;
89 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
90 u->on_failure_job_mode = JOB_REPLACE;
95 bool unit_has_name(Unit *u, const char *name) {
99 return !!set_get(u->names, (char*) name);
102 int unit_add_name(Unit *u, const char *text) {
110 if (unit_name_is_template(text)) {
114 s = unit_name_replace_instance(text, u->instance);
121 if (!unit_name_is_valid(s, false)) {
126 assert_se((t = unit_name_to_type(s)) >= 0);
128 if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
133 r = unit_name_to_instance(s, &i);
137 if (i && unit_vtable[t]->no_instances) {
142 /* Ensure that this unit is either instanced or not instanced,
144 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
149 if (unit_vtable[t]->no_alias &&
150 !set_isempty(u->names) &&
151 !set_get(u->names, s)) {
156 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
161 r = set_put(u->names, s);
168 r = hashmap_put(u->manager->units, s, u);
170 set_remove(u->names, s);
174 if (u->type == _UNIT_TYPE_INVALID) {
180 LIST_PREPEND(units_by_type, u->manager->units_by_type[t], u);
182 if (UNIT_VTABLE(u)->init)
183 UNIT_VTABLE(u)->init(u);
187 unit_add_to_dbus_queue(u);
197 int unit_choose_id(Unit *u, const char *name) {
199 _cleanup_free_ char *t = NULL;
205 if (unit_name_is_template(name)) {
210 t = unit_name_replace_instance(name, u->instance);
217 /* Selects one of the names of this unit as the id */
218 s = set_get(u->names, (char*) name);
223 r = unit_name_to_instance(s, &i);
232 unit_add_to_dbus_queue(u);
237 int unit_set_description(Unit *u, const char *description) {
242 if (isempty(description))
245 s = strdup(description);
250 free(u->description);
253 unit_add_to_dbus_queue(u);
257 bool unit_check_gc(Unit *u) {
260 if (u->load_state == UNIT_STUB)
263 if (UNIT_VTABLE(u)->no_gc)
275 if (unit_active_state(u) != UNIT_INACTIVE)
281 if (UNIT_VTABLE(u)->check_gc)
282 if (UNIT_VTABLE(u)->check_gc(u))
288 void unit_add_to_load_queue(Unit *u) {
290 assert(u->type != _UNIT_TYPE_INVALID);
292 if (u->load_state != UNIT_STUB || u->in_load_queue)
295 LIST_PREPEND(load_queue, u->manager->load_queue, u);
296 u->in_load_queue = true;
299 void unit_add_to_cleanup_queue(Unit *u) {
302 if (u->in_cleanup_queue)
305 LIST_PREPEND(cleanup_queue, u->manager->cleanup_queue, u);
306 u->in_cleanup_queue = true;
309 void unit_add_to_gc_queue(Unit *u) {
312 if (u->in_gc_queue || u->in_cleanup_queue)
315 if (unit_check_gc(u))
318 LIST_PREPEND(gc_queue, u->manager->gc_queue, u);
319 u->in_gc_queue = true;
321 u->manager->n_in_gc_queue ++;
324 void unit_add_to_dbus_queue(Unit *u) {
326 assert(u->type != _UNIT_TYPE_INVALID);
328 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
331 /* Shortcut things if nobody cares */
332 if (set_isempty(u->manager->subscribed)) {
333 u->sent_dbus_new_signal = true;
337 LIST_PREPEND(dbus_queue, u->manager->dbus_unit_queue, u);
338 u->in_dbus_queue = true;
341 static void bidi_set_free(Unit *u, Set *s) {
347 /* Frees the set and makes sure we are dropped from the
348 * inverse pointers */
350 SET_FOREACH(other, s, i) {
353 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
354 set_remove(other->dependencies[d], u);
356 unit_add_to_gc_queue(other);
362 static void unit_remove_transient(Unit *u) {
370 if (u->fragment_path)
371 unlink(u->fragment_path);
373 STRV_FOREACH(i, u->dropin_paths) {
374 _cleanup_free_ char *p = NULL;
379 r = path_get_parent(*i, &p);
385 static void unit_free_requires_mounts_for(Unit *u) {
388 STRV_FOREACH(j, u->requires_mounts_for) {
389 char s[strlen(*j) + 1];
391 PATH_FOREACH_PREFIX_MORE(s, *j) {
395 x = hashmap_get2(u->manager->units_requiring_mounts_for, s, (void**) &y);
401 if (set_isempty(x)) {
402 hashmap_remove(u->manager->units_requiring_mounts_for, y);
409 strv_free(u->requires_mounts_for);
410 u->requires_mounts_for = NULL;
413 void unit_free(Unit *u) {
420 if (u->manager->n_reloading <= 0)
421 unit_remove_transient(u);
423 bus_unit_send_removed_signal(u);
425 if (u->load_state != UNIT_STUB)
426 if (UNIT_VTABLE(u)->done)
427 UNIT_VTABLE(u)->done(u);
429 unit_free_requires_mounts_for(u);
431 SET_FOREACH(t, u->names, i)
432 hashmap_remove_value(u->manager->units, t, u);
446 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
447 bidi_set_free(u, u->dependencies[d]);
449 if (u->type != _UNIT_TYPE_INVALID)
450 LIST_REMOVE(units_by_type, u->manager->units_by_type[u->type], u);
452 if (u->in_load_queue)
453 LIST_REMOVE(load_queue, u->manager->load_queue, u);
455 if (u->in_dbus_queue)
456 LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
458 if (u->in_cleanup_queue)
459 LIST_REMOVE(cleanup_queue, u->manager->cleanup_queue, u);
461 if (u->in_gc_queue) {
462 LIST_REMOVE(gc_queue, u->manager->gc_queue, u);
463 u->manager->n_in_gc_queue--;
466 if (u->in_cgroup_queue)
467 LIST_REMOVE(cgroup_queue, u->manager->cgroup_queue, u);
469 if (u->cgroup_path) {
470 hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
471 free(u->cgroup_path);
474 free(u->description);
475 strv_free(u->documentation);
476 free(u->fragment_path);
477 free(u->source_path);
478 strv_free(u->dropin_paths);
481 set_free_free(u->names);
483 condition_free_list(u->conditions);
485 unit_ref_unset(&u->slice);
488 unit_ref_unset(u->refs);
493 UnitActiveState unit_active_state(Unit *u) {
496 if (u->load_state == UNIT_MERGED)
497 return unit_active_state(unit_follow_merge(u));
499 /* After a reload it might happen that a unit is not correctly
500 * loaded but still has a process around. That's why we won't
501 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
503 return UNIT_VTABLE(u)->active_state(u);
506 const char* unit_sub_state_to_string(Unit *u) {
509 return UNIT_VTABLE(u)->sub_state_to_string(u);
512 static void complete_move(Set **s, Set **other) {
520 set_move(*s, *other);
527 static void merge_names(Unit *u, Unit *other) {
534 complete_move(&u->names, &other->names);
536 set_free_free(other->names);
540 SET_FOREACH(t, u->names, i)
541 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
544 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
551 assert(d < _UNIT_DEPENDENCY_MAX);
553 /* Fix backwards pointers */
554 SET_FOREACH(back, other->dependencies[d], i) {
557 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {
558 r = set_remove_and_put(back->dependencies[k], other, u);
560 set_remove(back->dependencies[k], other);
562 assert(r >= 0 || r == -ENOENT);
566 complete_move(&u->dependencies[d], &other->dependencies[d]);
568 set_free(other->dependencies[d]);
569 other->dependencies[d] = NULL;
572 int unit_merge(Unit *u, Unit *other) {
577 assert(u->manager == other->manager);
578 assert(u->type != _UNIT_TYPE_INVALID);
580 other = unit_follow_merge(other);
585 if (u->type != other->type)
588 if (!u->instance != !other->instance)
591 if (other->load_state != UNIT_STUB &&
592 other->load_state != UNIT_NOT_FOUND)
601 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
605 merge_names(u, other);
607 /* Redirect all references */
609 unit_ref_set(other->refs, u);
611 /* Merge dependencies */
612 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
613 merge_dependencies(u, other, d);
615 other->load_state = UNIT_MERGED;
616 other->merged_into = u;
618 /* If there is still some data attached to the other node, we
619 * don't need it anymore, and can free it. */
620 if (other->load_state != UNIT_STUB)
621 if (UNIT_VTABLE(other)->done)
622 UNIT_VTABLE(other)->done(other);
624 unit_add_to_dbus_queue(u);
625 unit_add_to_cleanup_queue(other);
630 int unit_merge_by_name(Unit *u, const char *name) {
633 _cleanup_free_ char *s = NULL;
638 if (unit_name_is_template(name)) {
642 s = unit_name_replace_instance(name, u->instance);
649 other = manager_get_unit(u->manager, name);
651 r = unit_add_name(u, name);
653 r = unit_merge(u, other);
658 Unit* unit_follow_merge(Unit *u) {
661 while (u->load_state == UNIT_MERGED)
662 assert_se(u = u->merged_into);
667 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
673 if (c->std_output != EXEC_OUTPUT_KMSG &&
674 c->std_output != EXEC_OUTPUT_SYSLOG &&
675 c->std_output != EXEC_OUTPUT_JOURNAL &&
676 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
677 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
678 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
679 c->std_error != EXEC_OUTPUT_KMSG &&
680 c->std_error != EXEC_OUTPUT_SYSLOG &&
681 c->std_error != EXEC_OUTPUT_JOURNAL &&
682 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
683 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
684 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
687 /* If syslog or kernel logging is requested, make sure our own
688 * logging daemon is run first. */
690 if (u->manager->running_as == SYSTEMD_SYSTEM) {
691 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
699 const char *unit_description(Unit *u) {
703 return u->description;
708 void unit_dump(Unit *u, FILE *f, const char *prefix) {
712 _cleanup_free_ char *p2 = NULL;
715 timestamp1[FORMAT_TIMESTAMP_MAX],
716 timestamp2[FORMAT_TIMESTAMP_MAX],
717 timestamp3[FORMAT_TIMESTAMP_MAX],
718 timestamp4[FORMAT_TIMESTAMP_MAX],
719 timespan[FORMAT_TIMESPAN_MAX];
721 _cleanup_set_free_ Set *following_set = NULL;
725 assert(u->type >= 0);
729 p2 = strappend(prefix, "\t");
730 prefix2 = p2 ? p2 : prefix;
734 "%s\tDescription: %s\n"
736 "%s\tUnit Load State: %s\n"
737 "%s\tUnit Active State: %s\n"
738 "%s\tInactive Exit Timestamp: %s\n"
739 "%s\tActive Enter Timestamp: %s\n"
740 "%s\tActive Exit Timestamp: %s\n"
741 "%s\tInactive Enter Timestamp: %s\n"
742 "%s\tGC Check Good: %s\n"
743 "%s\tNeed Daemon Reload: %s\n"
744 "%s\tTransient: %s\n"
747 "%s\tCGroup realized: %s\n"
748 "%s\tCGroup mask: 0x%x\n"
749 "%s\tCGroup members mask: 0x%x\n",
751 prefix, unit_description(u),
752 prefix, strna(u->instance),
753 prefix, unit_load_state_to_string(u->load_state),
754 prefix, unit_active_state_to_string(unit_active_state(u)),
755 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
756 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
757 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
758 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
759 prefix, yes_no(unit_check_gc(u)),
760 prefix, yes_no(unit_need_daemon_reload(u)),
761 prefix, yes_no(u->transient),
762 prefix, strna(unit_slice_name(u)),
763 prefix, strna(u->cgroup_path),
764 prefix, yes_no(u->cgroup_realized),
765 prefix, u->cgroup_mask,
766 prefix, u->cgroup_members_mask);
768 SET_FOREACH(t, u->names, i)
769 fprintf(f, "%s\tName: %s\n", prefix, t);
771 STRV_FOREACH(j, u->documentation)
772 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
774 following = unit_following(u);
776 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
778 r = unit_following_set(u, &following_set);
782 SET_FOREACH(other, following_set, i)
783 fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
786 if (u->fragment_path)
787 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
790 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
792 STRV_FOREACH(j, u->dropin_paths)
793 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
795 if (u->job_timeout > 0)
796 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
798 condition_dump_list(u->conditions, f, prefix);
800 if (dual_timestamp_is_set(&u->condition_timestamp))
802 "%s\tCondition Timestamp: %s\n"
803 "%s\tCondition Result: %s\n",
804 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
805 prefix, yes_no(u->condition_result));
807 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
810 SET_FOREACH(other, u->dependencies[d], i)
811 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
814 if (!strv_isempty(u->requires_mounts_for)) {
816 "%s\tRequiresMountsFor:", prefix);
818 STRV_FOREACH(j, u->requires_mounts_for)
819 fprintf(f, " %s", *j);
824 if (u->load_state == UNIT_LOADED) {
827 "%s\tStopWhenUnneeded: %s\n"
828 "%s\tRefuseManualStart: %s\n"
829 "%s\tRefuseManualStop: %s\n"
830 "%s\tDefaultDependencies: %s\n"
831 "%s\tOnFailureJobMode: %s\n"
832 "%s\tIgnoreOnIsolate: %s\n"
833 "%s\tIgnoreOnSnapshot: %s\n",
834 prefix, yes_no(u->stop_when_unneeded),
835 prefix, yes_no(u->refuse_manual_start),
836 prefix, yes_no(u->refuse_manual_stop),
837 prefix, yes_no(u->default_dependencies),
838 prefix, job_mode_to_string(u->on_failure_job_mode),
839 prefix, yes_no(u->ignore_on_isolate),
840 prefix, yes_no(u->ignore_on_snapshot));
842 if (UNIT_VTABLE(u)->dump)
843 UNIT_VTABLE(u)->dump(u, f, prefix2);
845 } else if (u->load_state == UNIT_MERGED)
847 "%s\tMerged into: %s\n",
848 prefix, u->merged_into->id);
849 else if (u->load_state == UNIT_ERROR)
850 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
854 job_dump(u->job, f, prefix2);
857 job_dump(u->nop_job, f, prefix2);
861 /* Common implementation for multiple backends */
862 int unit_load_fragment_and_dropin(Unit *u) {
867 /* Load a .{service,socket,...} file */
868 r = unit_load_fragment(u);
872 if (u->load_state == UNIT_STUB)
875 /* Load drop-in directory data */
876 r = unit_load_dropin(unit_follow_merge(u));
883 /* Common implementation for multiple backends */
884 int unit_load_fragment_and_dropin_optional(Unit *u) {
889 /* Same as unit_load_fragment_and_dropin(), but whether
890 * something can be loaded or not doesn't matter. */
892 /* Load a .service file */
893 r = unit_load_fragment(u);
897 if (u->load_state == UNIT_STUB)
898 u->load_state = UNIT_LOADED;
900 /* Load drop-in directory data */
901 r = unit_load_dropin(unit_follow_merge(u));
908 int unit_add_default_target_dependency(Unit *u, Unit *target) {
912 if (target->type != UNIT_TARGET)
915 /* Only add the dependency if both units are loaded, so that
916 * that loop check below is reliable */
917 if (u->load_state != UNIT_LOADED ||
918 target->load_state != UNIT_LOADED)
921 /* If either side wants no automatic dependencies, then let's
923 if (!u->default_dependencies ||
924 !target->default_dependencies)
927 /* Don't create loops */
928 if (set_get(target->dependencies[UNIT_BEFORE], u))
931 return unit_add_dependency(target, UNIT_AFTER, u, true);
934 static int unit_add_default_dependencies(Unit *u) {
936 static const UnitDependency deps[] = {
938 UNIT_REQUIRED_BY_OVERRIDABLE,
950 for (k = 0; k < ELEMENTSOF(deps); k++)
951 SET_FOREACH(target, u->dependencies[deps[k]], i) {
952 r = unit_add_default_target_dependency(u, target);
957 if (u->default_dependencies && unit_get_cgroup_context(u)) {
958 if (UNIT_ISSET(u->slice))
959 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
961 r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
970 static int unit_add_mount_links(Unit *u) {
976 STRV_FOREACH(i, u->requires_mounts_for) {
977 char prefix[strlen(*i) + 1];
979 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
982 r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
990 if (m->load_state != UNIT_LOADED)
993 r = unit_add_dependency(u, UNIT_AFTER, m, true);
997 if (m->fragment_path) {
998 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
1008 int unit_load(Unit *u) {
1013 if (u->in_load_queue) {
1014 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1015 u->in_load_queue = false;
1018 if (u->type == _UNIT_TYPE_INVALID)
1021 if (u->load_state != UNIT_STUB)
1024 if (UNIT_VTABLE(u)->load) {
1025 r = UNIT_VTABLE(u)->load(u);
1030 if (u->load_state == UNIT_STUB) {
1035 if (u->load_state == UNIT_LOADED) {
1037 if (u->default_dependencies) {
1038 r = unit_add_default_dependencies(u);
1043 unit_update_member_masks(u);
1045 r = unit_add_mount_links(u);
1049 if (u->on_failure_job_mode == JOB_ISOLATE &&
1050 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1052 log_error_unit(u->id,
1053 "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
1060 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1062 unit_add_to_dbus_queue(unit_follow_merge(u));
1063 unit_add_to_gc_queue(u);
1068 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1070 unit_add_to_dbus_queue(u);
1071 unit_add_to_gc_queue(u);
1073 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
1074 u->id, strerror(-r));
1079 static bool unit_condition_test(Unit *u) {
1082 dual_timestamp_get(&u->condition_timestamp);
1083 u->condition_result = condition_test_list(u->id, u->conditions);
1085 return u->condition_result;
1088 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1089 const UnitStatusMessageFormats *format_table;
1093 assert(t < _JOB_TYPE_MAX);
1095 if (t != JOB_START && t != JOB_STOP)
1098 format_table = &UNIT_VTABLE(u)->status_message_formats;
1102 return format_table->starting_stopping[t == JOB_STOP];
1105 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1110 assert(t < _JOB_TYPE_MAX);
1112 format = unit_get_status_message_format(u, t);
1116 /* Return generic strings */
1118 return "Starting %s.";
1119 else if (t == JOB_STOP)
1120 return "Stopping %s.";
1121 else if (t == JOB_RELOAD)
1122 return "Reloading %s.";
1127 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1132 /* We only print status messages for selected units on
1133 * selected operations. */
1135 format = unit_get_status_message_format(u, t);
1139 unit_status_printf(u, "", format);
1142 #pragma GCC diagnostic push
1143 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1144 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1151 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1154 if (log_on_console())
1157 /* We log status messages for all units and all operations. */
1159 format = unit_get_status_message_format_try_harder(u, t);
1163 snprintf(buf, sizeof(buf), format, unit_description(u));
1166 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1167 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1168 SD_MESSAGE_UNIT_RELOADING;
1170 log_struct_unit(LOG_INFO,
1176 #pragma GCC diagnostic pop
1179 * -EBADR: This unit type does not support starting.
1180 * -EALREADY: Unit is already started.
1181 * -EAGAIN: An operation is already in progress. Retry later.
1182 * -ECANCELED: Too many requests for now.
1184 int unit_start(Unit *u) {
1185 UnitActiveState state;
1190 if (u->load_state != UNIT_LOADED)
1193 /* If this is already started, then this will succeed. Note
1194 * that this will even succeed if this unit is not startable
1195 * by the user. This is relied on to detect when we need to
1196 * wait for units and when waiting is finished. */
1197 state = unit_active_state(u);
1198 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1201 /* If the conditions failed, don't do anything at all. If we
1202 * already are activating this call might still be useful to
1203 * speed up activation in case there is some hold-off time,
1204 * but we don't want to recheck the condition in that case. */
1205 if (state != UNIT_ACTIVATING &&
1206 !unit_condition_test(u)) {
1207 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1211 /* Forward to the main object, if we aren't it. */
1212 following = unit_following(u);
1214 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1215 u->id, following->id);
1216 return unit_start(following);
1219 unit_status_log_starting_stopping_reloading(u, JOB_START);
1220 unit_status_print_starting_stopping(u, JOB_START);
1222 /* If it is stopped, but we cannot start it, then fail */
1223 if (!UNIT_VTABLE(u)->start)
1226 /* We don't suppress calls to ->start() here when we are
1227 * already starting, to allow this request to be used as a
1228 * "hurry up" call, for example when the unit is in some "auto
1229 * restart" state where it waits for a holdoff timer to elapse
1230 * before it will start again. */
1232 unit_add_to_dbus_queue(u);
1234 return UNIT_VTABLE(u)->start(u);
1237 bool unit_can_start(Unit *u) {
1240 return !!UNIT_VTABLE(u)->start;
1243 bool unit_can_isolate(Unit *u) {
1246 return unit_can_start(u) &&
1251 * -EBADR: This unit type does not support stopping.
1252 * -EALREADY: Unit is already stopped.
1253 * -EAGAIN: An operation is already in progress. Retry later.
1255 int unit_stop(Unit *u) {
1256 UnitActiveState state;
1261 state = unit_active_state(u);
1262 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1265 if ((following = unit_following(u))) {
1266 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1267 u->id, following->id);
1268 return unit_stop(following);
1271 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1272 unit_status_print_starting_stopping(u, JOB_STOP);
1274 if (!UNIT_VTABLE(u)->stop)
1277 unit_add_to_dbus_queue(u);
1279 return UNIT_VTABLE(u)->stop(u);
1283 * -EBADR: This unit type does not support reloading.
1284 * -ENOEXEC: Unit is not started.
1285 * -EAGAIN: An operation is already in progress. Retry later.
1287 int unit_reload(Unit *u) {
1288 UnitActiveState state;
1293 if (u->load_state != UNIT_LOADED)
1296 if (!unit_can_reload(u))
1299 state = unit_active_state(u);
1300 if (state == UNIT_RELOADING)
1303 if (state != UNIT_ACTIVE)
1306 following = unit_following(u);
1308 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1309 u->id, following->id);
1310 return unit_reload(following);
1313 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1315 unit_add_to_dbus_queue(u);
1316 return UNIT_VTABLE(u)->reload(u);
1319 bool unit_can_reload(Unit *u) {
1322 if (!UNIT_VTABLE(u)->reload)
1325 if (!UNIT_VTABLE(u)->can_reload)
1328 return UNIT_VTABLE(u)->can_reload(u);
1331 static void unit_check_unneeded(Unit *u) {
1337 /* If this service shall be shut down when unneeded then do
1340 if (!u->stop_when_unneeded)
1343 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1346 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1347 if (unit_active_or_pending(other))
1350 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1351 if (unit_active_or_pending(other))
1354 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1355 if (unit_active_or_pending(other))
1358 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1359 if (unit_active_or_pending(other))
1362 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1364 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1365 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1368 static void retroactively_start_dependencies(Unit *u) {
1373 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1375 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1376 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1377 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1378 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1380 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1381 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1382 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1383 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1385 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1386 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1387 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1388 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1390 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1391 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1392 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1393 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1395 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1396 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1397 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1399 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1400 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1401 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1404 static void retroactively_stop_dependencies(Unit *u) {
1409 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1411 /* Pull down units which are bound to us recursively if enabled */
1412 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1413 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1414 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1417 static void check_unneeded_dependencies(Unit *u) {
1422 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1424 /* Garbage collect services that might not be needed anymore, if enabled */
1425 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1426 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1427 unit_check_unneeded(other);
1428 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1429 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1430 unit_check_unneeded(other);
1431 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1432 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1433 unit_check_unneeded(other);
1434 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1435 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1436 unit_check_unneeded(other);
1437 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1438 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1439 unit_check_unneeded(other);
1440 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1441 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1442 unit_check_unneeded(other);
1445 void unit_start_on_failure(Unit *u) {
1451 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1454 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1456 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1459 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1461 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1465 void unit_trigger_notify(Unit *u) {
1471 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1472 if (UNIT_VTABLE(other)->trigger_notify)
1473 UNIT_VTABLE(other)->trigger_notify(other, u);
1476 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1481 assert(os < _UNIT_ACTIVE_STATE_MAX);
1482 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1484 /* Note that this is called for all low-level state changes,
1485 * even if they might map to the same high-level
1486 * UnitActiveState! That means that ns == os is OK an expected
1487 * behavior here. For example: if a mount point is remounted
1488 * this function will be called too! */
1492 if (m->n_reloading <= 0) {
1495 dual_timestamp_get(&ts);
1497 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1498 u->inactive_exit_timestamp = ts;
1499 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1500 u->inactive_enter_timestamp = ts;
1502 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1503 u->active_enter_timestamp = ts;
1504 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1505 u->active_exit_timestamp = ts;
1508 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1509 unit_destroy_cgroup(u);
1511 /* Note that this doesn't apply to RemainAfterExit services exiting
1512 * sucessfully, since there's no change of state in that case. Which is
1513 * why it is handled in service_set_state() */
1514 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1515 ExecContext *ec = unit_get_exec_context(u);
1516 if (ec && exec_context_may_touch_console(ec)) {
1517 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1520 if (m->n_on_console == 0)
1521 /* unset no_console_output flag, since the console is free */
1522 m->no_console_output = false;
1531 if (u->job->state == JOB_WAITING)
1533 /* So we reached a different state for this
1534 * job. Let's see if we can run it now if it
1535 * failed previously due to EAGAIN. */
1536 job_add_to_run_queue(u->job);
1538 /* Let's check whether this state change constitutes a
1539 * finished job, or maybe contradicts a running job and
1540 * hence needs to invalidate jobs. */
1542 switch (u->job->type) {
1545 case JOB_VERIFY_ACTIVE:
1547 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1548 job_finish_and_invalidate(u->job, JOB_DONE, true);
1549 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1552 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1553 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1559 case JOB_RELOAD_OR_START:
1561 if (u->job->state == JOB_RUNNING) {
1562 if (ns == UNIT_ACTIVE)
1563 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1564 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1567 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1568 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1576 case JOB_TRY_RESTART:
1578 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1579 job_finish_and_invalidate(u->job, JOB_DONE, true);
1580 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1582 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1588 assert_not_reached("Job type unknown");
1594 if (m->n_reloading <= 0) {
1596 /* If this state change happened without being
1597 * requested by a job, then let's retroactively start
1598 * or stop dependencies. We skip that step when
1599 * deserializing, since we don't want to create any
1600 * additional jobs just because something is already
1604 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1605 retroactively_start_dependencies(u);
1606 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1607 retroactively_stop_dependencies(u);
1610 /* stop unneeded units regardless if going down was expected or not */
1611 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1612 check_unneeded_dependencies(u);
1614 if (ns != os && ns == UNIT_FAILED) {
1615 log_notice_unit(u->id,
1616 "Unit %s entered failed state.", u->id);
1617 unit_start_on_failure(u);
1621 /* Some names are special */
1622 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1624 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1625 /* The bus just might have become available,
1626 * hence try to connect to it, if we aren't
1630 if (u->type == UNIT_SERVICE &&
1631 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1632 m->n_reloading <= 0) {
1633 /* Write audit record if we have just finished starting up */
1634 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1638 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1639 manager_send_unit_plymouth(m, u);
1643 /* We don't care about D-Bus here, since we'll get an
1644 * asynchronous notification for it anyway. */
1646 if (u->type == UNIT_SERVICE &&
1647 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1648 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1649 m->n_reloading <= 0) {
1651 /* Hmm, if there was no start record written
1652 * write it now, so that we always have a nice
1655 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1657 if (ns == UNIT_INACTIVE)
1658 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1660 /* Write audit record if we have just finished shutting down */
1661 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1663 u->in_audit = false;
1667 manager_recheck_journal(m);
1668 unit_trigger_notify(u);
1670 /* Maybe we finished startup and are now ready for being
1671 * stopped because unneeded? */
1672 if (u->manager->n_reloading <= 0)
1673 unit_check_unneeded(u);
1675 unit_add_to_dbus_queue(u);
1676 unit_add_to_gc_queue(u);
1679 int unit_watch_pid(Unit *u, pid_t pid) {
1683 /* Watch a specific PID. We only support one unit watching
1684 * each PID for now. */
1686 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1689 void unit_unwatch_pid(Unit *u, pid_t pid) {
1693 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1696 bool unit_job_is_applicable(Unit *u, JobType j) {
1698 assert(j >= 0 && j < _JOB_TYPE_MAX);
1702 case JOB_VERIFY_ACTIVE:
1709 case JOB_TRY_RESTART:
1710 return unit_can_start(u);
1713 return unit_can_reload(u);
1715 case JOB_RELOAD_OR_START:
1716 return unit_can_reload(u) && unit_can_start(u);
1719 assert_not_reached("Invalid job type");
1723 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1725 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1726 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1727 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1728 [UNIT_WANTS] = UNIT_WANTED_BY,
1729 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1730 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1731 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1732 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1733 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1734 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1735 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1736 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1737 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1738 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1739 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1740 [UNIT_BEFORE] = UNIT_AFTER,
1741 [UNIT_AFTER] = UNIT_BEFORE,
1742 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1743 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1744 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1745 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1746 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1747 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1748 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1749 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
1751 int r, q = 0, v = 0, w = 0;
1754 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1757 u = unit_follow_merge(u);
1758 other = unit_follow_merge(other);
1760 /* We won't allow dependencies on ourselves. We will not
1761 * consider them an error however. */
1765 r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func);
1769 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
1770 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func);
1775 if (add_reference) {
1776 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func);
1780 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func);
1785 q = set_put(u->dependencies[d], other);
1789 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
1790 v = set_put(other->dependencies[inverse_table[d]], u);
1797 if (add_reference) {
1798 w = set_put(u->dependencies[UNIT_REFERENCES], other);
1804 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
1809 unit_add_to_dbus_queue(u);
1814 set_remove(u->dependencies[d], other);
1817 set_remove(other->dependencies[inverse_table[d]], u);
1820 set_remove(u->dependencies[UNIT_REFERENCES], other);
1825 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1830 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1833 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1839 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1843 assert(name || path);
1847 name = path_get_file_name(path);
1849 if (!unit_name_is_template(name)) {
1855 s = unit_name_replace_instance(name, u->instance);
1857 _cleanup_free_ char *i = NULL;
1859 i = unit_name_to_prefix(u->id);
1863 s = unit_name_replace_instance(name, i);
1873 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1876 _cleanup_free_ char *s = NULL;
1879 assert(name || path);
1881 name = resolve_template(u, name, path, &s);
1885 r = manager_load_unit(u->manager, name, path, NULL, &other);
1889 return unit_add_dependency(u, d, other, add_reference);
1892 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1895 _cleanup_free_ char *s = NULL;
1898 assert(name || path);
1900 if (!(name = resolve_template(u, name, path, &s)))
1903 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1906 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1911 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1914 _cleanup_free_ char *s = NULL;
1917 assert(name || path);
1919 if (!(name = resolve_template(u, name, path, &s)))
1922 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1925 r = unit_add_dependency(other, d, u, add_reference);
1930 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1933 _cleanup_free_ char *s = NULL;
1936 assert(name || path);
1938 if (!(name = resolve_template(u, name, path, &s)))
1941 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1944 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1950 int set_unit_path(const char *p) {
1951 _cleanup_free_ char *c = NULL;
1953 /* This is mostly for debug purposes */
1954 c = path_make_absolute_cwd(p);
1955 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
1961 char *unit_dbus_path(Unit *u) {
1967 return unit_dbus_path_from_name(u->id);
1970 char *unit_default_cgroup_path(Unit *u) {
1971 _cleanup_free_ char *escaped = NULL, *slice = NULL;
1976 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
1977 return strdup(u->manager->cgroup_root);
1979 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
1980 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
1985 escaped = cg_escape(u->id);
1990 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
1992 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
1995 int unit_add_default_slice(Unit *u) {
1996 _cleanup_free_ char *b = NULL;
1997 const char *slice_name;
2003 if (UNIT_ISSET(u->slice))
2006 if (!unit_get_cgroup_context(u))
2010 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2012 /* Implicitly place all instantiated units in their
2013 * own per-template slice */
2015 prefix = unit_name_to_prefix(u->id);
2019 /* The prefix is already escaped, but it might include
2020 * "-" which has a special meaning for slice units,
2021 * hence escape it here extra. */
2022 escaped = strreplace(prefix, "-", "\\x2d");
2026 if (u->manager->running_as == SYSTEMD_SYSTEM)
2027 b = strjoin("system-", escaped, ".slice", NULL);
2029 b = strappend(escaped, ".slice");
2036 u->manager->running_as == SYSTEMD_SYSTEM
2037 ? SPECIAL_SYSTEM_SLICE
2038 : SPECIAL_ROOT_SLICE;
2040 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2044 unit_ref_set(&u->slice, slice);
2048 const char *unit_slice_name(Unit *u) {
2051 if (!UNIT_ISSET(u->slice))
2054 return UNIT_DEREF(u->slice)->id;
2057 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2058 _cleanup_free_ char *t = NULL;
2065 t = unit_name_change_suffix(u->id, type);
2069 assert(!unit_has_name(u, t));
2071 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2072 assert(r < 0 || *_found != u);
2076 int unit_watch_bus_name(Unit *u, const char *name) {
2080 /* Watch a specific name on the bus. We only support one unit
2081 * watching each name for now. */
2083 return hashmap_put(u->manager->watch_bus, name, u);
2086 void unit_unwatch_bus_name(Unit *u, const char *name) {
2090 hashmap_remove_value(u->manager->watch_bus, name, u);
2093 bool unit_can_serialize(Unit *u) {
2096 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2099 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2107 if (!unit_can_serialize(u))
2110 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2114 rt = unit_get_exec_runtime(u);
2116 r = exec_runtime_serialize(rt, u, f, fds);
2121 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2122 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2123 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2124 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2125 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2127 if (dual_timestamp_is_set(&u->condition_timestamp))
2128 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2130 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2133 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2135 if (serialize_jobs) {
2137 fprintf(f, "job\n");
2138 job_serialize(u->job, f, fds);
2142 fprintf(f, "job\n");
2143 job_serialize(u->nop_job, f, fds);
2152 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2163 va_start(ap, format);
2164 vfprintf(f, format, ap);
2170 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2176 fprintf(f, "%s=%s\n", key, value);
2179 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2181 ExecRuntime **rt = NULL;
2188 if (!unit_can_serialize(u))
2191 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2193 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2196 char line[LINE_MAX], *l, *v;
2199 if (!fgets(line, sizeof(line), f)) {
2212 k = strcspn(l, "=");
2220 if (streq(l, "job")) {
2222 /* new-style serialized job */
2223 Job *j = job_new_raw(u);
2227 r = job_deserialize(j, f, fds);
2233 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2239 r = job_install_deserialized(j);
2241 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2246 if (j->state == JOB_RUNNING)
2247 u->manager->n_running_jobs++;
2250 JobType type = job_type_from_string(v);
2252 log_debug("Failed to parse job type value %s", v);
2254 u->deserialized_job = type;
2257 } else if (streq(l, "inactive-exit-timestamp")) {
2258 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2260 } else if (streq(l, "active-enter-timestamp")) {
2261 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2263 } else if (streq(l, "active-exit-timestamp")) {
2264 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2266 } else if (streq(l, "inactive-enter-timestamp")) {
2267 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2269 } else if (streq(l, "condition-timestamp")) {
2270 dual_timestamp_deserialize(v, &u->condition_timestamp);
2272 } else if (streq(l, "condition-result")) {
2275 b = parse_boolean(v);
2277 log_debug("Failed to parse condition result value %s", v);
2279 u->condition_result = b;
2283 } else if (streq(l, "transient")) {
2286 b = parse_boolean(v);
2288 log_debug("Failed to parse transient bool %s", v);
2293 } else if (streq(l, "cgroup")) {
2300 free(u->cgroup_path);
2303 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2308 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2315 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2321 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2323 _cleanup_free_ char *e = NULL;
2331 /* Adds in links to the device node that this unit is based on */
2333 if (!is_device_path(what))
2336 e = unit_name_from_path(what, ".device");
2340 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2345 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2350 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2358 int unit_coldplug(Unit *u) {
2363 if (UNIT_VTABLE(u)->coldplug)
2364 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2368 r = job_coldplug(u->job);
2371 } else if (u->deserialized_job >= 0) {
2373 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2377 u->deserialized_job = _JOB_TYPE_INVALID;
2383 #pragma GCC diagnostic push
2384 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
2385 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2386 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2388 #pragma GCC diagnostic pop
2390 bool unit_need_daemon_reload(Unit *u) {
2391 _cleanup_strv_free_ char **t = NULL;
2394 unsigned loaded_cnt, current_cnt;
2398 if (u->fragment_path) {
2400 if (stat(u->fragment_path, &st) < 0)
2401 /* What, cannot access this anymore? */
2404 if (u->fragment_mtime > 0 &&
2405 timespec_load(&st.st_mtim) != u->fragment_mtime)
2409 if (u->source_path) {
2411 if (stat(u->source_path, &st) < 0)
2414 if (u->source_mtime > 0 &&
2415 timespec_load(&st.st_mtim) != u->source_mtime)
2419 t = unit_find_dropin_paths(u);
2420 loaded_cnt = strv_length(t);
2421 current_cnt = strv_length(u->dropin_paths);
2423 if (loaded_cnt == current_cnt) {
2424 if (loaded_cnt == 0)
2427 if (strv_overlap(u->dropin_paths, t)) {
2428 STRV_FOREACH(path, u->dropin_paths) {
2430 if (stat(*path, &st) < 0)
2433 if (u->dropin_mtime > 0 &&
2434 timespec_load(&st.st_mtim) > u->dropin_mtime)
2445 void unit_reset_failed(Unit *u) {
2448 if (UNIT_VTABLE(u)->reset_failed)
2449 UNIT_VTABLE(u)->reset_failed(u);
2452 Unit *unit_following(Unit *u) {
2455 if (UNIT_VTABLE(u)->following)
2456 return UNIT_VTABLE(u)->following(u);
2461 bool unit_stop_pending(Unit *u) {
2464 /* This call does check the current state of the unit. It's
2465 * hence useful to be called from state change calls of the
2466 * unit itself, where the state isn't updated yet. This is
2467 * different from unit_inactive_or_pending() which checks both
2468 * the current state and for a queued job. */
2470 return u->job && u->job->type == JOB_STOP;
2473 bool unit_inactive_or_pending(Unit *u) {
2476 /* Returns true if the unit is inactive or going down */
2478 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2481 if (unit_stop_pending(u))
2487 bool unit_active_or_pending(Unit *u) {
2490 /* Returns true if the unit is active or going up */
2492 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2496 (u->job->type == JOB_START ||
2497 u->job->type == JOB_RELOAD_OR_START ||
2498 u->job->type == JOB_RESTART))
2504 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2506 assert(w >= 0 && w < _KILL_WHO_MAX);
2508 assert(signo < _NSIG);
2510 if (!UNIT_VTABLE(u)->kill)
2513 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2516 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2520 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2524 /* Exclude the main/control pids from being killed via the cgroup */
2526 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2531 if (control_pid > 0) {
2532 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2544 int unit_kill_common(
2550 sd_bus_error *error) {
2554 if (who == KILL_MAIN && main_pid <= 0) {
2556 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2558 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2562 if (who == KILL_CONTROL && control_pid <= 0) {
2563 if (control_pid < 0)
2564 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2566 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2570 if (who == KILL_CONTROL || who == KILL_ALL)
2571 if (control_pid > 0)
2572 if (kill(control_pid, signo) < 0)
2575 if (who == KILL_MAIN || who == KILL_ALL)
2577 if (kill(main_pid, signo) < 0)
2580 if (who == KILL_ALL && u->cgroup_path) {
2581 _cleanup_set_free_ Set *pid_set = NULL;
2584 /* Exclude the main/control pids from being killed via the cgroup */
2585 pid_set = unit_pid_set(main_pid, control_pid);
2589 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2590 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2597 int unit_following_set(Unit *u, Set **s) {
2601 if (UNIT_VTABLE(u)->following_set)
2602 return UNIT_VTABLE(u)->following_set(u, s);
2608 UnitFileState unit_get_unit_file_state(Unit *u) {
2611 if (u->unit_file_state < 0 && u->fragment_path)
2612 u->unit_file_state = unit_file_get_state(
2613 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2614 NULL, path_get_file_name(u->fragment_path));
2616 return u->unit_file_state;
2619 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2624 unit_ref_unset(ref);
2627 LIST_PREPEND(refs, u->refs, ref);
2631 void unit_ref_unset(UnitRef *ref) {
2637 LIST_REMOVE(refs, ref->unit->refs, ref);
2641 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2648 /* This only copies in the ones that need memory */
2649 for (i = 0; i < RLIMIT_NLIMITS; i++)
2650 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2651 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2656 if (u->manager->running_as == SYSTEMD_USER &&
2657 !c->working_directory) {
2659 r = get_home_dir(&c->working_directory);
2667 ExecContext *unit_get_exec_context(Unit *u) {
2671 offset = UNIT_VTABLE(u)->exec_context_offset;
2675 return (ExecContext*) ((uint8_t*) u + offset);
2678 KillContext *unit_get_kill_context(Unit *u) {
2682 offset = UNIT_VTABLE(u)->kill_context_offset;
2686 return (KillContext*) ((uint8_t*) u + offset);
2689 CGroupContext *unit_get_cgroup_context(Unit *u) {
2692 offset = UNIT_VTABLE(u)->cgroup_context_offset;
2696 return (CGroupContext*) ((uint8_t*) u + offset);
2699 ExecRuntime *unit_get_exec_runtime(Unit *u) {
2702 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2706 return *(ExecRuntime**) ((uint8_t*) u + offset);
2709 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2710 _cleanup_free_ char *b = NULL;
2718 assert(mode & (UNIT_PERSISTENT|UNIT_RUNTIME));
2720 b = xescape(name, "/.");
2724 if (!filename_is_safe(b))
2727 if (u->manager->running_as == SYSTEMD_USER) {
2728 _cleanup_free_ char *c = NULL;
2730 r = user_config_home(&c);
2736 p = strjoin(c, "/", u->id, ".d", NULL);
2737 } else if (mode & UNIT_PERSISTENT)
2738 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2740 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2744 q = strjoin(p, "/90-", b, ".conf", NULL);
2755 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2756 _cleanup_free_ char *p = NULL, *q = NULL;
2763 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2766 r = drop_in_file(u, mode, name, &p, &q);
2771 return write_string_file_atomic_label(q, data);
2774 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2775 _cleanup_free_ char *p = NULL;
2783 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2786 va_start(ap, format);
2787 r = vasprintf(&p, format, ap);
2793 return unit_write_drop_in(u, mode, name, p);
2796 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2797 _cleanup_free_ char *ndata = NULL;
2803 if (!UNIT_VTABLE(u)->private_section)
2806 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2809 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
2813 return unit_write_drop_in(u, mode, name, ndata);
2816 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2817 _cleanup_free_ char *p = NULL;
2825 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2828 va_start(ap, format);
2829 r = vasprintf(&p, format, ap);
2835 return unit_write_drop_in_private(u, mode, name, p);
2838 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
2839 _cleanup_free_ char *p = NULL, *q = NULL;
2844 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2847 r = drop_in_file(u, mode, name, &p, &q);
2852 r = errno == ENOENT ? 0 : -errno;
2860 int unit_make_transient(Unit *u) {
2865 u->load_state = UNIT_STUB;
2867 u->transient = true;
2869 free(u->fragment_path);
2870 u->fragment_path = NULL;
2872 if (u->manager->running_as == SYSTEMD_USER) {
2873 _cleanup_free_ char *c = NULL;
2875 r = user_config_home(&c);
2881 u->fragment_path = strjoin(c, "/", u->id, NULL);
2882 if (!u->fragment_path)
2887 u->fragment_path = strappend("/run/systemd/system/", u->id);
2888 if (!u->fragment_path)
2891 mkdir_p("/run/systemd/system", 0755);
2894 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
2897 int unit_kill_context(
2903 bool main_pid_alien) {
2905 int sig, wait_for_exit = 0, r;
2910 if (c->kill_mode == KILL_NONE)
2913 sig = sigkill ? SIGKILL : c->kill_signal;
2916 r = kill_and_sigcont(main_pid, sig);
2918 if (r < 0 && r != -ESRCH) {
2919 _cleanup_free_ char *comm = NULL;
2920 get_process_comm(main_pid, &comm);
2922 log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2923 (long) main_pid, strna(comm), strerror(-r));
2925 wait_for_exit = !main_pid_alien;
2928 kill(main_pid, SIGHUP);
2932 if (control_pid > 0) {
2933 r = kill_and_sigcont(control_pid, sig);
2935 if (r < 0 && r != -ESRCH) {
2936 _cleanup_free_ char *comm = NULL;
2937 get_process_comm(control_pid, &comm);
2939 log_warning_unit(u->id,
2940 "Failed to kill control process %li (%s): %s",
2941 (long) control_pid, strna(comm), strerror(-r));
2943 wait_for_exit = true;
2946 kill(control_pid, SIGHUP);
2950 if (c->kill_mode == KILL_CONTROL_GROUP && u->cgroup_path) {
2951 _cleanup_set_free_ Set *pid_set = NULL;
2953 /* Exclude the main/control pids from being killed via the cgroup */
2954 pid_set = unit_pid_set(main_pid, control_pid);
2958 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
2960 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
2961 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
2963 wait_for_exit = true;
2964 if (c->send_sighup) {
2967 pid_set = unit_pid_set(main_pid, control_pid);
2971 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, true, true, false, pid_set);
2976 return wait_for_exit;
2979 int unit_require_mounts_for(Unit *u, const char *path) {
2980 char prefix[strlen(path) + 1], *p;
2986 /* Registers a unit for requiring a certain path and all its
2987 * prefixes. We keep a simple array of these paths in the
2988 * unit, since its usually short. However, we build a prefix
2989 * table for all possible prefixes so that new appearing mount
2990 * units can easily determine which units to make themselves a
2997 path_kill_slashes(p);
2999 if (!path_is_absolute(p)) {
3004 if (!path_is_safe(p)) {
3009 if (strv_contains(u->requires_mounts_for, p)) {
3014 r = strv_push(&u->requires_mounts_for, p);
3020 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3023 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3027 if (!u->manager->units_requiring_mounts_for) {
3028 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
3029 if (!u->manager->units_requiring_mounts_for)
3037 x = set_new(NULL, NULL);
3043 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3059 int unit_setup_exec_runtime(Unit *u) {
3065 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3068 /* Check if ther already is an ExecRuntime for this unit? */
3069 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3073 /* Try to get it from somebody else */
3074 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3076 *rt = unit_get_exec_runtime(other);
3078 exec_runtime_ref(*rt);
3083 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3086 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3087 [UNIT_ACTIVE] = "active",
3088 [UNIT_RELOADING] = "reloading",
3089 [UNIT_INACTIVE] = "inactive",
3090 [UNIT_FAILED] = "failed",
3091 [UNIT_ACTIVATING] = "activating",
3092 [UNIT_DEACTIVATING] = "deactivating"
3095 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3097 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3098 [UNIT_REQUIRES] = "Requires",
3099 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3100 [UNIT_REQUISITE] = "Requisite",
3101 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3102 [UNIT_WANTS] = "Wants",
3103 [UNIT_BINDS_TO] = "BindsTo",
3104 [UNIT_PART_OF] = "PartOf",
3105 [UNIT_REQUIRED_BY] = "RequiredBy",
3106 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3107 [UNIT_WANTED_BY] = "WantedBy",
3108 [UNIT_BOUND_BY] = "BoundBy",
3109 [UNIT_CONSISTS_OF] = "ConsistsOf",
3110 [UNIT_CONFLICTS] = "Conflicts",
3111 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3112 [UNIT_BEFORE] = "Before",
3113 [UNIT_AFTER] = "After",
3114 [UNIT_ON_FAILURE] = "OnFailure",
3115 [UNIT_TRIGGERS] = "Triggers",
3116 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3117 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3118 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3119 [UNIT_REFERENCES] = "References",
3120 [UNIT_REFERENCED_BY] = "ReferencedBy",
3121 [UNIT_JOINS_NAMESPACE_OF] = "JoinsNamespaceOf",
3124 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);