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"
53 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
54 [UNIT_SERVICE] = &service_vtable,
55 [UNIT_TIMER] = &timer_vtable,
56 [UNIT_SOCKET] = &socket_vtable,
57 [UNIT_TARGET] = &target_vtable,
58 [UNIT_DEVICE] = &device_vtable,
59 [UNIT_MOUNT] = &mount_vtable,
60 [UNIT_AUTOMOUNT] = &automount_vtable,
61 [UNIT_SNAPSHOT] = &snapshot_vtable,
62 [UNIT_SWAP] = &swap_vtable,
63 [UNIT_PATH] = &path_vtable,
64 [UNIT_SLICE] = &slice_vtable,
65 [UNIT_SCOPE] = &scope_vtable
68 Unit *unit_new(Manager *m, size_t size) {
72 assert(size >= sizeof(Unit));
78 u->names = set_new(string_hash_func, string_compare_func);
85 u->type = _UNIT_TYPE_INVALID;
86 u->deserialized_job = _JOB_TYPE_INVALID;
87 u->default_dependencies = true;
88 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
93 bool unit_has_name(Unit *u, const char *name) {
97 return !!set_get(u->names, (char*) name);
100 int unit_add_name(Unit *u, const char *text) {
108 if (unit_name_is_template(text)) {
112 s = unit_name_replace_instance(text, u->instance);
119 if (!unit_name_is_valid(s, false)) {
124 assert_se((t = unit_name_to_type(s)) >= 0);
126 if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
131 r = unit_name_to_instance(s, &i);
135 if (i && unit_vtable[t]->no_instances) {
140 /* Ensure that this unit is either instanced or not instanced,
142 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
147 if (unit_vtable[t]->no_alias &&
148 !set_isempty(u->names) &&
149 !set_get(u->names, s)) {
154 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
159 r = set_put(u->names, s);
166 r = hashmap_put(u->manager->units, s, u);
168 set_remove(u->names, s);
172 if (u->type == _UNIT_TYPE_INVALID) {
178 LIST_PREPEND(units_by_type, u->manager->units_by_type[t], u);
180 if (UNIT_VTABLE(u)->init)
181 UNIT_VTABLE(u)->init(u);
185 unit_add_to_dbus_queue(u);
195 int unit_choose_id(Unit *u, const char *name) {
197 _cleanup_free_ char *t = NULL;
203 if (unit_name_is_template(name)) {
208 t = unit_name_replace_instance(name, u->instance);
215 /* Selects one of the names of this unit as the id */
216 s = set_get(u->names, (char*) name);
221 r = unit_name_to_instance(s, &i);
230 unit_add_to_dbus_queue(u);
235 int unit_set_description(Unit *u, const char *description) {
240 if (isempty(description))
243 s = strdup(description);
248 free(u->description);
251 unit_add_to_dbus_queue(u);
255 bool unit_check_gc(Unit *u) {
258 if (u->load_state == UNIT_STUB)
261 if (UNIT_VTABLE(u)->no_gc)
273 if (unit_active_state(u) != UNIT_INACTIVE)
279 if (UNIT_VTABLE(u)->check_gc)
280 if (UNIT_VTABLE(u)->check_gc(u))
286 void unit_add_to_load_queue(Unit *u) {
288 assert(u->type != _UNIT_TYPE_INVALID);
290 if (u->load_state != UNIT_STUB || u->in_load_queue)
293 LIST_PREPEND(load_queue, u->manager->load_queue, u);
294 u->in_load_queue = true;
297 void unit_add_to_cleanup_queue(Unit *u) {
300 if (u->in_cleanup_queue)
303 LIST_PREPEND(cleanup_queue, u->manager->cleanup_queue, u);
304 u->in_cleanup_queue = true;
307 void unit_add_to_gc_queue(Unit *u) {
310 if (u->in_gc_queue || u->in_cleanup_queue)
313 if (unit_check_gc(u))
316 LIST_PREPEND(gc_queue, u->manager->gc_queue, u);
317 u->in_gc_queue = true;
319 u->manager->n_in_gc_queue ++;
322 void unit_add_to_dbus_queue(Unit *u) {
324 assert(u->type != _UNIT_TYPE_INVALID);
326 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
329 /* Shortcut things if nobody cares */
330 if (set_isempty(u->manager->subscribed)) {
331 u->sent_dbus_new_signal = true;
335 LIST_PREPEND(dbus_queue, u->manager->dbus_unit_queue, u);
336 u->in_dbus_queue = true;
339 static void bidi_set_free(Unit *u, Set *s) {
345 /* Frees the set and makes sure we are dropped from the
346 * inverse pointers */
348 SET_FOREACH(other, s, i) {
351 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
352 set_remove(other->dependencies[d], u);
354 unit_add_to_gc_queue(other);
360 static void unit_remove_transient(Unit *u) {
368 if (u->fragment_path)
369 unlink(u->fragment_path);
371 STRV_FOREACH(i, u->dropin_paths) {
372 _cleanup_free_ char *p = NULL;
377 r = path_get_parent(*i, &p);
383 static void unit_free_requires_mounts_for(Unit *u) {
386 STRV_FOREACH(j, u->requires_mounts_for) {
387 char s[strlen(*j) + 1];
389 PATH_FOREACH_PREFIX_MORE(s, *j) {
393 x = hashmap_get2(u->manager->units_requiring_mounts_for, s, (void**) &y);
399 if (set_isempty(x)) {
400 hashmap_remove(u->manager->units_requiring_mounts_for, y);
407 strv_free(u->requires_mounts_for);
408 u->requires_mounts_for = NULL;
411 void unit_free(Unit *u) {
418 if (u->manager->n_reloading <= 0)
419 unit_remove_transient(u);
421 bus_unit_send_removed_signal(u);
423 if (u->load_state != UNIT_STUB)
424 if (UNIT_VTABLE(u)->done)
425 UNIT_VTABLE(u)->done(u);
427 unit_free_requires_mounts_for(u);
429 SET_FOREACH(t, u->names, i)
430 hashmap_remove_value(u->manager->units, t, u);
444 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
445 bidi_set_free(u, u->dependencies[d]);
447 if (u->type != _UNIT_TYPE_INVALID)
448 LIST_REMOVE(units_by_type, u->manager->units_by_type[u->type], u);
450 if (u->in_load_queue)
451 LIST_REMOVE(load_queue, u->manager->load_queue, u);
453 if (u->in_dbus_queue)
454 LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
456 if (u->in_cleanup_queue)
457 LIST_REMOVE(cleanup_queue, u->manager->cleanup_queue, u);
459 if (u->in_gc_queue) {
460 LIST_REMOVE(gc_queue, u->manager->gc_queue, u);
461 u->manager->n_in_gc_queue--;
464 if (u->in_cgroup_queue)
465 LIST_REMOVE(cgroup_queue, u->manager->cgroup_queue, u);
467 if (u->cgroup_path) {
468 hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
469 free(u->cgroup_path);
472 free(u->description);
473 strv_free(u->documentation);
474 free(u->fragment_path);
475 free(u->source_path);
476 strv_free(u->dropin_paths);
479 set_free_free(u->names);
481 condition_free_list(u->conditions);
483 unit_ref_unset(&u->slice);
486 unit_ref_unset(u->refs);
491 UnitActiveState unit_active_state(Unit *u) {
494 if (u->load_state == UNIT_MERGED)
495 return unit_active_state(unit_follow_merge(u));
497 /* After a reload it might happen that a unit is not correctly
498 * loaded but still has a process around. That's why we won't
499 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
501 return UNIT_VTABLE(u)->active_state(u);
504 const char* unit_sub_state_to_string(Unit *u) {
507 return UNIT_VTABLE(u)->sub_state_to_string(u);
510 static void complete_move(Set **s, Set **other) {
518 set_move(*s, *other);
525 static void merge_names(Unit *u, Unit *other) {
532 complete_move(&u->names, &other->names);
534 set_free_free(other->names);
538 SET_FOREACH(t, u->names, i)
539 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
542 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
549 assert(d < _UNIT_DEPENDENCY_MAX);
551 /* Fix backwards pointers */
552 SET_FOREACH(back, other->dependencies[d], i) {
555 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {
556 r = set_remove_and_put(back->dependencies[k], other, u);
558 set_remove(back->dependencies[k], other);
560 assert(r >= 0 || r == -ENOENT);
564 complete_move(&u->dependencies[d], &other->dependencies[d]);
566 set_free(other->dependencies[d]);
567 other->dependencies[d] = NULL;
570 int unit_merge(Unit *u, Unit *other) {
575 assert(u->manager == other->manager);
576 assert(u->type != _UNIT_TYPE_INVALID);
578 other = unit_follow_merge(other);
583 if (u->type != other->type)
586 if (!u->instance != !other->instance)
589 if (other->load_state != UNIT_STUB &&
590 other->load_state != UNIT_NOT_FOUND)
599 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
603 merge_names(u, other);
605 /* Redirect all references */
607 unit_ref_set(other->refs, u);
609 /* Merge dependencies */
610 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
611 merge_dependencies(u, other, d);
613 other->load_state = UNIT_MERGED;
614 other->merged_into = u;
616 /* If there is still some data attached to the other node, we
617 * don't need it anymore, and can free it. */
618 if (other->load_state != UNIT_STUB)
619 if (UNIT_VTABLE(other)->done)
620 UNIT_VTABLE(other)->done(other);
622 unit_add_to_dbus_queue(u);
623 unit_add_to_cleanup_queue(other);
628 int unit_merge_by_name(Unit *u, const char *name) {
631 _cleanup_free_ char *s = NULL;
636 if (unit_name_is_template(name)) {
640 s = unit_name_replace_instance(name, u->instance);
647 other = manager_get_unit(u->manager, name);
649 r = unit_add_name(u, name);
651 r = unit_merge(u, other);
656 Unit* unit_follow_merge(Unit *u) {
659 while (u->load_state == UNIT_MERGED)
660 assert_se(u = u->merged_into);
665 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
671 if (c->std_output != EXEC_OUTPUT_KMSG &&
672 c->std_output != EXEC_OUTPUT_SYSLOG &&
673 c->std_output != EXEC_OUTPUT_JOURNAL &&
674 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
675 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
676 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
677 c->std_error != EXEC_OUTPUT_KMSG &&
678 c->std_error != EXEC_OUTPUT_SYSLOG &&
679 c->std_error != EXEC_OUTPUT_JOURNAL &&
680 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
681 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
682 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
685 /* If syslog or kernel logging is requested, make sure our own
686 * logging daemon is run first. */
688 if (u->manager->running_as == SYSTEMD_SYSTEM) {
689 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
697 const char *unit_description(Unit *u) {
701 return u->description;
706 void unit_dump(Unit *u, FILE *f, const char *prefix) {
710 _cleanup_free_ char *p2 = NULL;
713 timestamp1[FORMAT_TIMESTAMP_MAX],
714 timestamp2[FORMAT_TIMESTAMP_MAX],
715 timestamp3[FORMAT_TIMESTAMP_MAX],
716 timestamp4[FORMAT_TIMESTAMP_MAX],
717 timespan[FORMAT_TIMESPAN_MAX];
721 assert(u->type >= 0);
725 p2 = strappend(prefix, "\t");
726 prefix2 = p2 ? p2 : prefix;
730 "%s\tDescription: %s\n"
732 "%s\tUnit Load State: %s\n"
733 "%s\tUnit Active State: %s\n"
734 "%s\tInactive Exit Timestamp: %s\n"
735 "%s\tActive Enter Timestamp: %s\n"
736 "%s\tActive Exit Timestamp: %s\n"
737 "%s\tInactive Enter Timestamp: %s\n"
738 "%s\tGC Check Good: %s\n"
739 "%s\tNeed Daemon Reload: %s\n"
740 "%s\tTransient: %s\n"
743 "%s\tCGroup realized: %s\n"
744 "%s\tCGroup mask: 0x%x\n"
745 "%s\tCGroup members mask: 0x%x\n",
747 prefix, unit_description(u),
748 prefix, strna(u->instance),
749 prefix, unit_load_state_to_string(u->load_state),
750 prefix, unit_active_state_to_string(unit_active_state(u)),
751 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
752 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
753 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
754 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
755 prefix, yes_no(unit_check_gc(u)),
756 prefix, yes_no(unit_need_daemon_reload(u)),
757 prefix, yes_no(u->transient),
758 prefix, strna(unit_slice_name(u)),
759 prefix, strna(u->cgroup_path),
760 prefix, yes_no(u->cgroup_realized),
761 prefix, u->cgroup_mask,
762 prefix, u->cgroup_members_mask);
764 SET_FOREACH(t, u->names, i)
765 fprintf(f, "%s\tName: %s\n", prefix, t);
767 STRV_FOREACH(j, u->documentation)
768 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
770 if ((following = unit_following(u)))
771 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
773 if (u->fragment_path)
774 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
777 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
779 STRV_FOREACH(j, u->dropin_paths)
780 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
782 if (u->job_timeout > 0)
783 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
785 condition_dump_list(u->conditions, f, prefix);
787 if (dual_timestamp_is_set(&u->condition_timestamp))
789 "%s\tCondition Timestamp: %s\n"
790 "%s\tCondition Result: %s\n",
791 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
792 prefix, yes_no(u->condition_result));
794 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
797 SET_FOREACH(other, u->dependencies[d], i)
798 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
801 if (!strv_isempty(u->requires_mounts_for)) {
803 "%s\tRequiresMountsFor:", prefix);
805 STRV_FOREACH(j, u->requires_mounts_for)
806 fprintf(f, " %s", *j);
811 if (u->load_state == UNIT_LOADED) {
814 "%s\tStopWhenUnneeded: %s\n"
815 "%s\tRefuseManualStart: %s\n"
816 "%s\tRefuseManualStop: %s\n"
817 "%s\tDefaultDependencies: %s\n"
818 "%s\tOnFailureIsolate: %s\n"
819 "%s\tIgnoreOnIsolate: %s\n"
820 "%s\tIgnoreOnSnapshot: %s\n",
821 prefix, yes_no(u->stop_when_unneeded),
822 prefix, yes_no(u->refuse_manual_start),
823 prefix, yes_no(u->refuse_manual_stop),
824 prefix, yes_no(u->default_dependencies),
825 prefix, yes_no(u->on_failure_isolate),
826 prefix, yes_no(u->ignore_on_isolate),
827 prefix, yes_no(u->ignore_on_snapshot));
829 if (UNIT_VTABLE(u)->dump)
830 UNIT_VTABLE(u)->dump(u, f, prefix2);
832 } else if (u->load_state == UNIT_MERGED)
834 "%s\tMerged into: %s\n",
835 prefix, u->merged_into->id);
836 else if (u->load_state == UNIT_ERROR)
837 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
841 job_dump(u->job, f, prefix2);
844 job_dump(u->nop_job, f, prefix2);
848 /* Common implementation for multiple backends */
849 int unit_load_fragment_and_dropin(Unit *u) {
854 /* Load a .{service,socket,...} file */
855 r = unit_load_fragment(u);
859 if (u->load_state == UNIT_STUB)
862 /* Load drop-in directory data */
863 r = unit_load_dropin(unit_follow_merge(u));
870 /* Common implementation for multiple backends */
871 int unit_load_fragment_and_dropin_optional(Unit *u) {
876 /* Same as unit_load_fragment_and_dropin(), but whether
877 * something can be loaded or not doesn't matter. */
879 /* Load a .service file */
880 r = unit_load_fragment(u);
884 if (u->load_state == UNIT_STUB)
885 u->load_state = UNIT_LOADED;
887 /* Load drop-in directory data */
888 r = unit_load_dropin(unit_follow_merge(u));
895 int unit_add_default_target_dependency(Unit *u, Unit *target) {
899 if (target->type != UNIT_TARGET)
902 /* Only add the dependency if both units are loaded, so that
903 * that loop check below is reliable */
904 if (u->load_state != UNIT_LOADED ||
905 target->load_state != UNIT_LOADED)
908 /* If either side wants no automatic dependencies, then let's
910 if (!u->default_dependencies ||
911 !target->default_dependencies)
914 /* Don't create loops */
915 if (set_get(target->dependencies[UNIT_BEFORE], u))
918 return unit_add_dependency(target, UNIT_AFTER, u, true);
921 static int unit_add_default_dependencies(Unit *u) {
923 static const UnitDependency deps[] = {
925 UNIT_REQUIRED_BY_OVERRIDABLE,
937 for (k = 0; k < ELEMENTSOF(deps); k++)
938 SET_FOREACH(target, u->dependencies[deps[k]], i) {
939 r = unit_add_default_target_dependency(u, target);
944 if (u->default_dependencies && unit_get_cgroup_context(u)) {
945 if (UNIT_ISSET(u->slice))
946 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
948 r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
957 static int unit_add_mount_links(Unit *u) {
963 STRV_FOREACH(i, u->requires_mounts_for) {
964 char prefix[strlen(*i) + 1];
966 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
969 r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
977 if (m->load_state != UNIT_LOADED)
980 r = unit_add_dependency(u, UNIT_AFTER, m, true);
984 if (m->fragment_path) {
985 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
995 int unit_load(Unit *u) {
1000 if (u->in_load_queue) {
1001 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1002 u->in_load_queue = false;
1005 if (u->type == _UNIT_TYPE_INVALID)
1008 if (u->load_state != UNIT_STUB)
1011 if (UNIT_VTABLE(u)->load) {
1012 r = UNIT_VTABLE(u)->load(u);
1017 if (u->load_state == UNIT_STUB) {
1022 if (u->load_state == UNIT_LOADED) {
1024 if (u->default_dependencies) {
1025 r = unit_add_default_dependencies(u);
1030 unit_update_member_masks(u);
1032 r = unit_add_mount_links(u);
1036 if (u->on_failure_isolate &&
1037 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1039 log_error_unit(u->id,
1040 "More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.", u->id);
1047 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1049 unit_add_to_dbus_queue(unit_follow_merge(u));
1050 unit_add_to_gc_queue(u);
1055 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1057 unit_add_to_dbus_queue(u);
1058 unit_add_to_gc_queue(u);
1060 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
1061 u->id, strerror(-r));
1066 static bool unit_condition_test(Unit *u) {
1069 dual_timestamp_get(&u->condition_timestamp);
1070 u->condition_result = condition_test_list(u->id, u->conditions);
1072 return u->condition_result;
1075 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1076 const UnitStatusMessageFormats *format_table;
1080 assert(t < _JOB_TYPE_MAX);
1082 if (t != JOB_START && t != JOB_STOP)
1085 format_table = &UNIT_VTABLE(u)->status_message_formats;
1089 return format_table->starting_stopping[t == JOB_STOP];
1092 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1097 assert(t < _JOB_TYPE_MAX);
1099 format = unit_get_status_message_format(u, t);
1103 /* Return generic strings */
1105 return "Starting %s.";
1106 else if (t == JOB_STOP)
1107 return "Stopping %s.";
1108 else if (t == JOB_RELOAD)
1109 return "Reloading %s.";
1114 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1119 /* We only print status messages for selected units on
1120 * selected operations. */
1122 format = unit_get_status_message_format(u, t);
1126 unit_status_printf(u, "", format);
1129 #pragma GCC diagnostic push
1130 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1131 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1138 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1141 if (log_on_console())
1144 /* We log status messages for all units and all operations. */
1146 format = unit_get_status_message_format_try_harder(u, t);
1150 snprintf(buf, sizeof(buf), format, unit_description(u));
1153 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1154 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1155 SD_MESSAGE_UNIT_RELOADING;
1157 log_struct_unit(LOG_INFO,
1163 #pragma GCC diagnostic pop
1166 * -EBADR: This unit type does not support starting.
1167 * -EALREADY: Unit is already started.
1168 * -EAGAIN: An operation is already in progress. Retry later.
1169 * -ECANCELED: Too many requests for now.
1171 int unit_start(Unit *u) {
1172 UnitActiveState state;
1177 if (u->load_state != UNIT_LOADED)
1180 /* If this is already started, then this will succeed. Note
1181 * that this will even succeed if this unit is not startable
1182 * by the user. This is relied on to detect when we need to
1183 * wait for units and when waiting is finished. */
1184 state = unit_active_state(u);
1185 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1188 /* If the conditions failed, don't do anything at all. If we
1189 * already are activating this call might still be useful to
1190 * speed up activation in case there is some hold-off time,
1191 * but we don't want to recheck the condition in that case. */
1192 if (state != UNIT_ACTIVATING &&
1193 !unit_condition_test(u)) {
1194 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1198 /* Forward to the main object, if we aren't it. */
1199 following = unit_following(u);
1201 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1202 u->id, following->id);
1203 return unit_start(following);
1206 unit_status_log_starting_stopping_reloading(u, JOB_START);
1207 unit_status_print_starting_stopping(u, JOB_START);
1209 /* If it is stopped, but we cannot start it, then fail */
1210 if (!UNIT_VTABLE(u)->start)
1213 /* We don't suppress calls to ->start() here when we are
1214 * already starting, to allow this request to be used as a
1215 * "hurry up" call, for example when the unit is in some "auto
1216 * restart" state where it waits for a holdoff timer to elapse
1217 * before it will start again. */
1219 unit_add_to_dbus_queue(u);
1221 return UNIT_VTABLE(u)->start(u);
1224 bool unit_can_start(Unit *u) {
1227 return !!UNIT_VTABLE(u)->start;
1230 bool unit_can_isolate(Unit *u) {
1233 return unit_can_start(u) &&
1238 * -EBADR: This unit type does not support stopping.
1239 * -EALREADY: Unit is already stopped.
1240 * -EAGAIN: An operation is already in progress. Retry later.
1242 int unit_stop(Unit *u) {
1243 UnitActiveState state;
1248 state = unit_active_state(u);
1249 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1252 if ((following = unit_following(u))) {
1253 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1254 u->id, following->id);
1255 return unit_stop(following);
1258 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1259 unit_status_print_starting_stopping(u, JOB_STOP);
1261 if (!UNIT_VTABLE(u)->stop)
1264 unit_add_to_dbus_queue(u);
1266 return UNIT_VTABLE(u)->stop(u);
1270 * -EBADR: This unit type does not support reloading.
1271 * -ENOEXEC: Unit is not started.
1272 * -EAGAIN: An operation is already in progress. Retry later.
1274 int unit_reload(Unit *u) {
1275 UnitActiveState state;
1280 if (u->load_state != UNIT_LOADED)
1283 if (!unit_can_reload(u))
1286 state = unit_active_state(u);
1287 if (state == UNIT_RELOADING)
1290 if (state != UNIT_ACTIVE)
1293 following = unit_following(u);
1295 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1296 u->id, following->id);
1297 return unit_reload(following);
1300 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1302 unit_add_to_dbus_queue(u);
1303 return UNIT_VTABLE(u)->reload(u);
1306 bool unit_can_reload(Unit *u) {
1309 if (!UNIT_VTABLE(u)->reload)
1312 if (!UNIT_VTABLE(u)->can_reload)
1315 return UNIT_VTABLE(u)->can_reload(u);
1318 static void unit_check_unneeded(Unit *u) {
1324 /* If this service shall be shut down when unneeded then do
1327 if (!u->stop_when_unneeded)
1330 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1333 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1334 if (unit_active_or_pending(other))
1337 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1338 if (unit_active_or_pending(other))
1341 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1342 if (unit_active_or_pending(other))
1345 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1346 if (unit_active_or_pending(other))
1349 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1351 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1352 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1355 static void retroactively_start_dependencies(Unit *u) {
1360 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1362 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1363 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1364 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1365 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1367 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1368 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1369 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1370 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1372 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1373 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1374 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1375 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1377 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1378 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1379 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1380 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1382 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1383 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1384 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1386 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1387 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1388 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1391 static void retroactively_stop_dependencies(Unit *u) {
1396 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1398 /* Pull down units which are bound to us recursively if enabled */
1399 SET_FOREACH(other, u->dependencies[UNIT_BOUND_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 check_unneeded_dependencies(Unit *u) {
1409 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1411 /* Garbage collect services that might not be needed anymore, if enabled */
1412 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1413 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1414 unit_check_unneeded(other);
1415 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1416 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1417 unit_check_unneeded(other);
1418 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1419 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1420 unit_check_unneeded(other);
1421 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1422 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1423 unit_check_unneeded(other);
1424 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1425 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1426 unit_check_unneeded(other);
1427 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1428 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1429 unit_check_unneeded(other);
1432 void unit_start_on_failure(Unit *u) {
1438 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1441 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1443 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1446 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL);
1448 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1452 void unit_trigger_notify(Unit *u) {
1458 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1459 if (UNIT_VTABLE(other)->trigger_notify)
1460 UNIT_VTABLE(other)->trigger_notify(other, u);
1463 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1468 assert(os < _UNIT_ACTIVE_STATE_MAX);
1469 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1471 /* Note that this is called for all low-level state changes,
1472 * even if they might map to the same high-level
1473 * UnitActiveState! That means that ns == os is OK an expected
1474 * behavior here. For example: if a mount point is remounted
1475 * this function will be called too! */
1479 if (m->n_reloading <= 0) {
1482 dual_timestamp_get(&ts);
1484 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1485 u->inactive_exit_timestamp = ts;
1486 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1487 u->inactive_enter_timestamp = ts;
1489 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1490 u->active_enter_timestamp = ts;
1491 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1492 u->active_exit_timestamp = ts;
1495 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1496 unit_destroy_cgroup(u);
1498 /* Note that this doesn't apply to RemainAfterExit services exiting
1499 * sucessfully, since there's no change of state in that case. Which is
1500 * why it is handled in service_set_state() */
1501 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1502 ExecContext *ec = unit_get_exec_context(u);
1503 if (ec && exec_context_may_touch_console(ec)) {
1504 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1507 if (m->n_on_console == 0)
1508 /* unset no_console_output flag, since the console is free */
1509 m->no_console_output = false;
1518 if (u->job->state == JOB_WAITING)
1520 /* So we reached a different state for this
1521 * job. Let's see if we can run it now if it
1522 * failed previously due to EAGAIN. */
1523 job_add_to_run_queue(u->job);
1525 /* Let's check whether this state change constitutes a
1526 * finished job, or maybe contradicts a running job and
1527 * hence needs to invalidate jobs. */
1529 switch (u->job->type) {
1532 case JOB_VERIFY_ACTIVE:
1534 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1535 job_finish_and_invalidate(u->job, JOB_DONE, true);
1536 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1539 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1540 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1546 case JOB_RELOAD_OR_START:
1548 if (u->job->state == JOB_RUNNING) {
1549 if (ns == UNIT_ACTIVE)
1550 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1551 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1554 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1555 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1563 case JOB_TRY_RESTART:
1565 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1566 job_finish_and_invalidate(u->job, JOB_DONE, true);
1567 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1569 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1575 assert_not_reached("Job type unknown");
1581 if (m->n_reloading <= 0) {
1583 /* If this state change happened without being
1584 * requested by a job, then let's retroactively start
1585 * or stop dependencies. We skip that step when
1586 * deserializing, since we don't want to create any
1587 * additional jobs just because something is already
1591 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1592 retroactively_start_dependencies(u);
1593 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1594 retroactively_stop_dependencies(u);
1597 /* stop unneeded units regardless if going down was expected or not */
1598 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1599 check_unneeded_dependencies(u);
1601 if (ns != os && ns == UNIT_FAILED) {
1602 log_notice_unit(u->id,
1603 "Unit %s entered failed state.", u->id);
1604 unit_start_on_failure(u);
1608 /* Some names are special */
1609 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1611 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1612 /* The bus just might have become available,
1613 * hence try to connect to it, if we aren't
1617 if (u->type == UNIT_SERVICE &&
1618 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1619 m->n_reloading <= 0) {
1620 /* Write audit record if we have just finished starting up */
1621 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1625 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1626 manager_send_unit_plymouth(m, u);
1630 /* We don't care about D-Bus here, since we'll get an
1631 * asynchronous notification for it anyway. */
1633 if (u->type == UNIT_SERVICE &&
1634 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1635 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1636 m->n_reloading <= 0) {
1638 /* Hmm, if there was no start record written
1639 * write it now, so that we always have a nice
1642 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1644 if (ns == UNIT_INACTIVE)
1645 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1647 /* Write audit record if we have just finished shutting down */
1648 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1650 u->in_audit = false;
1654 manager_recheck_journal(m);
1655 unit_trigger_notify(u);
1657 /* Maybe we finished startup and are now ready for being
1658 * stopped because unneeded? */
1659 if (u->manager->n_reloading <= 0)
1660 unit_check_unneeded(u);
1662 unit_add_to_dbus_queue(u);
1663 unit_add_to_gc_queue(u);
1666 int unit_watch_pid(Unit *u, pid_t pid) {
1670 /* Watch a specific PID. We only support one unit watching
1671 * each PID for now. */
1673 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1676 void unit_unwatch_pid(Unit *u, pid_t pid) {
1680 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1683 bool unit_job_is_applicable(Unit *u, JobType j) {
1685 assert(j >= 0 && j < _JOB_TYPE_MAX);
1689 case JOB_VERIFY_ACTIVE:
1696 case JOB_TRY_RESTART:
1697 return unit_can_start(u);
1700 return unit_can_reload(u);
1702 case JOB_RELOAD_OR_START:
1703 return unit_can_reload(u) && unit_can_start(u);
1706 assert_not_reached("Invalid job type");
1710 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1712 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1713 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1714 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1715 [UNIT_WANTS] = UNIT_WANTED_BY,
1716 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1717 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1718 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1719 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1720 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1721 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1722 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1723 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1724 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1725 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1726 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1727 [UNIT_BEFORE] = UNIT_AFTER,
1728 [UNIT_AFTER] = UNIT_BEFORE,
1729 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1730 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1731 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1732 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1733 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1734 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1735 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1737 int r, q = 0, v = 0, w = 0;
1740 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1743 u = unit_follow_merge(u);
1744 other = unit_follow_merge(other);
1746 /* We won't allow dependencies on ourselves. We will not
1747 * consider them an error however. */
1751 if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1754 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1755 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1759 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1760 (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1763 if ((q = set_put(u->dependencies[d], other)) < 0)
1766 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1767 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1772 if (add_reference) {
1773 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1778 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1782 unit_add_to_dbus_queue(u);
1787 set_remove(u->dependencies[d], other);
1790 set_remove(other->dependencies[inverse_table[d]], u);
1793 set_remove(u->dependencies[UNIT_REFERENCES], other);
1798 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1803 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1806 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1812 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1816 assert(name || path);
1820 name = path_get_file_name(path);
1822 if (!unit_name_is_template(name)) {
1828 s = unit_name_replace_instance(name, u->instance);
1830 _cleanup_free_ char *i = NULL;
1832 i = unit_name_to_prefix(u->id);
1836 s = unit_name_replace_instance(name, i);
1846 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1849 _cleanup_free_ char *s = NULL;
1852 assert(name || path);
1854 name = resolve_template(u, name, path, &s);
1858 r = manager_load_unit(u->manager, name, path, NULL, &other);
1862 return unit_add_dependency(u, d, other, add_reference);
1865 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1868 _cleanup_free_ char *s = NULL;
1871 assert(name || path);
1873 if (!(name = resolve_template(u, name, path, &s)))
1876 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1879 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1884 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1887 _cleanup_free_ char *s = NULL;
1890 assert(name || path);
1892 if (!(name = resolve_template(u, name, path, &s)))
1895 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1898 r = unit_add_dependency(other, d, u, add_reference);
1903 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1906 _cleanup_free_ char *s = NULL;
1909 assert(name || path);
1911 if (!(name = resolve_template(u, name, path, &s)))
1914 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1917 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1923 int set_unit_path(const char *p) {
1924 _cleanup_free_ char *c = NULL;
1926 /* This is mostly for debug purposes */
1927 c = path_make_absolute_cwd(p);
1928 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
1934 char *unit_dbus_path(Unit *u) {
1940 return unit_dbus_path_from_name(u->id);
1943 char *unit_default_cgroup_path(Unit *u) {
1944 _cleanup_free_ char *escaped = NULL, *slice = NULL;
1949 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
1950 return strdup(u->manager->cgroup_root);
1952 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
1953 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
1958 escaped = cg_escape(u->id);
1963 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
1965 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
1968 int unit_add_default_slice(Unit *u) {
1969 _cleanup_free_ char *b = NULL;
1970 const char *slice_name;
1976 if (UNIT_ISSET(u->slice))
1979 if (!unit_get_cgroup_context(u))
1983 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
1985 /* Implicitly place all instantiated units in their
1986 * own per-template slice */
1988 prefix = unit_name_to_prefix(u->id);
1992 /* The prefix is already escaped, but it might include
1993 * "-" which has a special meaning for slice units,
1994 * hence escape it here extra. */
1995 escaped = strreplace(prefix, "-", "\\x2d");
1999 if (u->manager->running_as == SYSTEMD_SYSTEM)
2000 b = strjoin("system-", escaped, ".slice", NULL);
2002 b = strappend(escaped, ".slice");
2009 u->manager->running_as == SYSTEMD_SYSTEM
2010 ? SPECIAL_SYSTEM_SLICE
2011 : SPECIAL_ROOT_SLICE;
2013 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2017 unit_ref_set(&u->slice, slice);
2021 const char *unit_slice_name(Unit *u) {
2024 if (!UNIT_ISSET(u->slice))
2027 return UNIT_DEREF(u->slice)->id;
2030 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2031 _cleanup_free_ char *t = NULL;
2038 t = unit_name_change_suffix(u->id, type);
2042 assert(!unit_has_name(u, t));
2044 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2045 assert(r < 0 || *_found != u);
2049 int unit_watch_bus_name(Unit *u, const char *name) {
2053 /* Watch a specific name on the bus. We only support one unit
2054 * watching each name for now. */
2056 return hashmap_put(u->manager->watch_bus, name, u);
2059 void unit_unwatch_bus_name(Unit *u, const char *name) {
2063 hashmap_remove_value(u->manager->watch_bus, name, u);
2066 bool unit_can_serialize(Unit *u) {
2069 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2072 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2079 if (!unit_can_serialize(u))
2082 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2087 if (serialize_jobs) {
2089 fprintf(f, "job\n");
2090 job_serialize(u->job, f, fds);
2094 fprintf(f, "job\n");
2095 job_serialize(u->nop_job, f, fds);
2099 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2100 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2101 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2102 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2103 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2105 if (dual_timestamp_is_set(&u->condition_timestamp))
2106 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2108 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2111 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2118 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2129 va_start(ap, format);
2130 vfprintf(f, format, ap);
2136 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2142 fprintf(f, "%s=%s\n", key, value);
2145 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2152 if (!unit_can_serialize(u))
2156 char line[LINE_MAX], *l, *v;
2159 if (!fgets(line, sizeof(line), f)) {
2172 k = strcspn(l, "=");
2180 if (streq(l, "job")) {
2182 /* new-style serialized job */
2183 Job *j = job_new_raw(u);
2187 r = job_deserialize(j, f, fds);
2193 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2199 r = job_install_deserialized(j);
2201 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2206 if (j->state == JOB_RUNNING)
2207 u->manager->n_running_jobs++;
2210 JobType type = job_type_from_string(v);
2212 log_debug("Failed to parse job type value %s", v);
2214 u->deserialized_job = type;
2217 } else if (streq(l, "inactive-exit-timestamp")) {
2218 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2220 } else if (streq(l, "active-enter-timestamp")) {
2221 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2223 } else if (streq(l, "active-exit-timestamp")) {
2224 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2226 } else if (streq(l, "inactive-enter-timestamp")) {
2227 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2229 } else if (streq(l, "condition-timestamp")) {
2230 dual_timestamp_deserialize(v, &u->condition_timestamp);
2232 } else if (streq(l, "condition-result")) {
2235 b = parse_boolean(v);
2237 log_debug("Failed to parse condition result value %s", v);
2239 u->condition_result = b;
2243 } else if (streq(l, "transient")) {
2246 b = parse_boolean(v);
2248 log_debug("Failed to parse transient bool %s", v);
2253 } else if (streq(l, "cgroup")) {
2260 free(u->cgroup_path);
2263 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2267 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2273 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2275 _cleanup_free_ char *e = NULL;
2283 /* Adds in links to the device node that this unit is based on */
2285 if (!is_device_path(what))
2288 e = unit_name_from_path(what, ".device");
2292 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2297 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2302 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2310 int unit_coldplug(Unit *u) {
2315 if (UNIT_VTABLE(u)->coldplug)
2316 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2320 r = job_coldplug(u->job);
2323 } else if (u->deserialized_job >= 0) {
2325 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2329 u->deserialized_job = _JOB_TYPE_INVALID;
2335 #pragma GCC diagnostic push
2336 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
2337 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2338 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2340 #pragma GCC diagnostic pop
2342 bool unit_need_daemon_reload(Unit *u) {
2343 _cleanup_strv_free_ char **t = NULL;
2346 unsigned loaded_cnt, current_cnt;
2350 if (u->fragment_path) {
2352 if (stat(u->fragment_path, &st) < 0)
2353 /* What, cannot access this anymore? */
2356 if (u->fragment_mtime > 0 &&
2357 timespec_load(&st.st_mtim) != u->fragment_mtime)
2361 if (u->source_path) {
2363 if (stat(u->source_path, &st) < 0)
2366 if (u->source_mtime > 0 &&
2367 timespec_load(&st.st_mtim) != u->source_mtime)
2371 t = unit_find_dropin_paths(u);
2372 loaded_cnt = strv_length(t);
2373 current_cnt = strv_length(u->dropin_paths);
2375 if (loaded_cnt == current_cnt) {
2376 if (loaded_cnt == 0)
2379 if (strv_overlap(u->dropin_paths, t)) {
2380 STRV_FOREACH(path, u->dropin_paths) {
2382 if (stat(*path, &st) < 0)
2385 if (u->dropin_mtime > 0 &&
2386 timespec_load(&st.st_mtim) > u->dropin_mtime)
2397 void unit_reset_failed(Unit *u) {
2400 if (UNIT_VTABLE(u)->reset_failed)
2401 UNIT_VTABLE(u)->reset_failed(u);
2404 Unit *unit_following(Unit *u) {
2407 if (UNIT_VTABLE(u)->following)
2408 return UNIT_VTABLE(u)->following(u);
2413 bool unit_stop_pending(Unit *u) {
2416 /* This call does check the current state of the unit. It's
2417 * hence useful to be called from state change calls of the
2418 * unit itself, where the state isn't updated yet. This is
2419 * different from unit_inactive_or_pending() which checks both
2420 * the current state and for a queued job. */
2422 return u->job && u->job->type == JOB_STOP;
2425 bool unit_inactive_or_pending(Unit *u) {
2428 /* Returns true if the unit is inactive or going down */
2430 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2433 if (unit_stop_pending(u))
2439 bool unit_active_or_pending(Unit *u) {
2442 /* Returns true if the unit is active or going up */
2444 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2448 (u->job->type == JOB_START ||
2449 u->job->type == JOB_RELOAD_OR_START ||
2450 u->job->type == JOB_RESTART))
2456 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2458 assert(w >= 0 && w < _KILL_WHO_MAX);
2460 assert(signo < _NSIG);
2462 if (!UNIT_VTABLE(u)->kill)
2465 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2468 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2472 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2476 /* Exclude the main/control pids from being killed via the cgroup */
2478 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2483 if (control_pid > 0) {
2484 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2496 int unit_kill_common(
2502 sd_bus_error *error) {
2506 if (who == KILL_MAIN && main_pid <= 0) {
2508 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2510 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2514 if (who == KILL_CONTROL && control_pid <= 0) {
2515 if (control_pid < 0)
2516 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2518 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2522 if (who == KILL_CONTROL || who == KILL_ALL)
2523 if (control_pid > 0)
2524 if (kill(control_pid, signo) < 0)
2527 if (who == KILL_MAIN || who == KILL_ALL)
2529 if (kill(main_pid, signo) < 0)
2532 if (who == KILL_ALL && u->cgroup_path) {
2533 _cleanup_set_free_ Set *pid_set = NULL;
2536 /* Exclude the main/control pids from being killed via the cgroup */
2537 pid_set = unit_pid_set(main_pid, control_pid);
2541 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2542 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2549 int unit_following_set(Unit *u, Set **s) {
2553 if (UNIT_VTABLE(u)->following_set)
2554 return UNIT_VTABLE(u)->following_set(u, s);
2560 UnitFileState unit_get_unit_file_state(Unit *u) {
2563 if (u->unit_file_state < 0 && u->fragment_path)
2564 u->unit_file_state = unit_file_get_state(
2565 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2566 NULL, path_get_file_name(u->fragment_path));
2568 return u->unit_file_state;
2571 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2576 unit_ref_unset(ref);
2579 LIST_PREPEND(refs, u->refs, ref);
2583 void unit_ref_unset(UnitRef *ref) {
2589 LIST_REMOVE(refs, ref->unit->refs, ref);
2593 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2600 /* This only copies in the ones that need memory */
2601 for (i = 0; i < RLIMIT_NLIMITS; i++)
2602 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2603 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2608 if (u->manager->running_as == SYSTEMD_USER &&
2609 !c->working_directory) {
2611 r = get_home_dir(&c->working_directory);
2619 ExecContext *unit_get_exec_context(Unit *u) {
2623 offset = UNIT_VTABLE(u)->exec_context_offset;
2627 return (ExecContext*) ((uint8_t*) u + offset);
2630 KillContext *unit_get_kill_context(Unit *u) {
2634 offset = UNIT_VTABLE(u)->kill_context_offset;
2638 return (KillContext*) ((uint8_t*) u + offset);
2641 CGroupContext *unit_get_cgroup_context(Unit *u) {
2644 offset = UNIT_VTABLE(u)->cgroup_context_offset;
2648 return (CGroupContext*) ((uint8_t*) u + offset);
2651 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2652 _cleanup_free_ char *b = NULL;
2660 assert(mode & (UNIT_PERSISTENT|UNIT_RUNTIME));
2662 b = xescape(name, "/.");
2666 if (!filename_is_safe(b))
2669 if (u->manager->running_as == SYSTEMD_USER) {
2670 _cleanup_free_ char *c = NULL;
2672 r = user_config_home(&c);
2678 p = strjoin(c, "/", u->id, ".d", NULL);
2679 } else if (mode & UNIT_PERSISTENT)
2680 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2682 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2686 q = strjoin(p, "/90-", b, ".conf", NULL);
2697 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2698 _cleanup_free_ char *p = NULL, *q = NULL;
2705 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2708 r = drop_in_file(u, mode, name, &p, &q);
2713 return write_string_file_atomic_label(q, data);
2716 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2717 _cleanup_free_ char *p = NULL;
2725 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2728 va_start(ap, format);
2729 r = vasprintf(&p, format, ap);
2735 return unit_write_drop_in(u, mode, name, p);
2738 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2739 _cleanup_free_ char *ndata = NULL;
2745 if (!UNIT_VTABLE(u)->private_section)
2748 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2751 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
2755 return unit_write_drop_in(u, mode, name, ndata);
2758 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2759 _cleanup_free_ char *p = NULL;
2767 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2770 va_start(ap, format);
2771 r = vasprintf(&p, format, ap);
2777 return unit_write_drop_in_private(u, mode, name, p);
2780 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
2781 _cleanup_free_ char *p = NULL, *q = NULL;
2786 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2789 r = drop_in_file(u, mode, name, &p, &q);
2794 r = errno == ENOENT ? 0 : -errno;
2802 int unit_make_transient(Unit *u) {
2807 u->load_state = UNIT_STUB;
2809 u->transient = true;
2811 free(u->fragment_path);
2812 u->fragment_path = NULL;
2814 if (u->manager->running_as == SYSTEMD_USER) {
2815 _cleanup_free_ char *c = NULL;
2817 r = user_config_home(&c);
2823 u->fragment_path = strjoin(c, "/", u->id, NULL);
2824 if (!u->fragment_path)
2829 u->fragment_path = strappend("/run/systemd/system/", u->id);
2830 if (!u->fragment_path)
2833 mkdir_p("/run/systemd/system", 0755);
2836 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
2839 int unit_kill_context(
2845 bool main_pid_alien) {
2847 int sig, wait_for_exit = 0, r;
2852 if (c->kill_mode == KILL_NONE)
2855 sig = sigkill ? SIGKILL : c->kill_signal;
2858 r = kill_and_sigcont(main_pid, sig);
2860 if (r < 0 && r != -ESRCH) {
2861 _cleanup_free_ char *comm = NULL;
2862 get_process_comm(main_pid, &comm);
2864 log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2865 (long) main_pid, strna(comm), strerror(-r));
2867 wait_for_exit = !main_pid_alien;
2870 kill(main_pid, SIGHUP);
2874 if (control_pid > 0) {
2875 r = kill_and_sigcont(control_pid, sig);
2877 if (r < 0 && r != -ESRCH) {
2878 _cleanup_free_ char *comm = NULL;
2879 get_process_comm(control_pid, &comm);
2881 log_warning_unit(u->id,
2882 "Failed to kill control process %li (%s): %s",
2883 (long) control_pid, strna(comm), strerror(-r));
2885 wait_for_exit = true;
2888 kill(control_pid, SIGHUP);
2892 if (c->kill_mode == KILL_CONTROL_GROUP && u->cgroup_path) {
2893 _cleanup_set_free_ Set *pid_set = NULL;
2895 /* Exclude the main/control pids from being killed via the cgroup */
2896 pid_set = unit_pid_set(main_pid, control_pid);
2900 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
2902 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
2903 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
2905 wait_for_exit = true;
2906 if (c->send_sighup) {
2909 pid_set = unit_pid_set(main_pid, control_pid);
2913 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, true, true, false, pid_set);
2918 return wait_for_exit;
2921 int unit_require_mounts_for(Unit *u, const char *path) {
2922 char prefix[strlen(path) + 1], *p;
2928 /* Registers a unit for requiring a certain path and all its
2929 * prefixes. We keep a simple array of these paths in the
2930 * unit, since its usually short. However, we build a prefix
2931 * table for all possible prefixes so that new appearing mount
2932 * units can easily determine which units to make themselves a
2939 path_kill_slashes(p);
2941 if (!path_is_absolute(p)) {
2946 if (!path_is_safe(p)) {
2951 if (strv_contains(u->requires_mounts_for, p)) {
2956 r = strv_push(&u->requires_mounts_for, p);
2962 PATH_FOREACH_PREFIX_MORE(prefix, p) {
2965 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
2969 if (!u->manager->units_requiring_mounts_for) {
2970 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
2971 if (!u->manager->units_requiring_mounts_for)
2979 x = set_new(NULL, NULL);
2985 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3001 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3002 [UNIT_ACTIVE] = "active",
3003 [UNIT_RELOADING] = "reloading",
3004 [UNIT_INACTIVE] = "inactive",
3005 [UNIT_FAILED] = "failed",
3006 [UNIT_ACTIVATING] = "activating",
3007 [UNIT_DEACTIVATING] = "deactivating"
3010 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3012 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3013 [UNIT_REQUIRES] = "Requires",
3014 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3015 [UNIT_REQUISITE] = "Requisite",
3016 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3017 [UNIT_WANTS] = "Wants",
3018 [UNIT_BINDS_TO] = "BindsTo",
3019 [UNIT_PART_OF] = "PartOf",
3020 [UNIT_REQUIRED_BY] = "RequiredBy",
3021 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3022 [UNIT_WANTED_BY] = "WantedBy",
3023 [UNIT_BOUND_BY] = "BoundBy",
3024 [UNIT_CONSISTS_OF] = "ConsistsOf",
3025 [UNIT_CONFLICTS] = "Conflicts",
3026 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3027 [UNIT_BEFORE] = "Before",
3028 [UNIT_AFTER] = "After",
3029 [UNIT_ON_FAILURE] = "OnFailure",
3030 [UNIT_TRIGGERS] = "Triggers",
3031 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3032 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3033 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3034 [UNIT_REFERENCES] = "References",
3035 [UNIT_REFERENCED_BY] = "ReferencedBy",
3038 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);