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>
32 #include "systemd/sd-id128.h"
33 #include "systemd/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"
47 #include "cgroup-attr.h"
50 #include "fileio-label.h"
51 #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
67 Unit *unit_new(Manager *m, size_t size) {
71 assert(size >= sizeof(Unit));
77 u->names = set_new(string_hash_func, string_compare_func);
84 u->type = _UNIT_TYPE_INVALID;
85 u->deserialized_job = _JOB_TYPE_INVALID;
86 u->default_dependencies = true;
87 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
92 bool unit_has_name(Unit *u, const char *name) {
96 return !!set_get(u->names, (char*) name);
99 int unit_add_name(Unit *u, const char *text) {
107 if (unit_name_is_template(text)) {
111 s = unit_name_replace_instance(text, u->instance);
118 if (!unit_name_is_valid(s, false)) {
123 assert_se((t = unit_name_to_type(s)) >= 0);
125 if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
130 if ((r = unit_name_to_instance(s, &i)) < 0)
133 if (i && unit_vtable[t]->no_instances) {
138 /* Ensure that this unit is either instanced or not instanced,
140 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
145 if (unit_vtable[t]->no_alias &&
146 !set_isempty(u->names) &&
147 !set_get(u->names, s)) {
152 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
157 if ((r = set_put(u->names, s)) < 0) {
163 if ((r = hashmap_put(u->manager->units, s, u)) < 0) {
164 set_remove(u->names, s);
168 if (u->type == _UNIT_TYPE_INVALID) {
174 LIST_PREPEND(Unit, units_by_type, u->manager->units_by_type[t], u);
176 if (UNIT_VTABLE(u)->init)
177 UNIT_VTABLE(u)->init(u);
181 unit_add_to_dbus_queue(u);
191 int unit_choose_id(Unit *u, const char *name) {
192 char *s, *t = NULL, *i;
198 if (unit_name_is_template(name)) {
203 if (!(t = unit_name_replace_instance(name, u->instance)))
209 /* Selects one of the names of this unit as the id */
210 s = set_get(u->names, (char*) name);
216 if ((r = unit_name_to_instance(s, &i)) < 0)
224 unit_add_to_dbus_queue(u);
229 int unit_set_description(Unit *u, const char *description) {
234 if (!(s = strdup(description)))
237 free(u->description);
240 unit_add_to_dbus_queue(u);
244 bool unit_check_gc(Unit *u) {
247 if (u->load_state == UNIT_STUB)
250 if (UNIT_VTABLE(u)->no_gc)
262 if (unit_active_state(u) != UNIT_INACTIVE)
268 if (UNIT_VTABLE(u)->check_gc)
269 if (UNIT_VTABLE(u)->check_gc(u))
275 void unit_add_to_load_queue(Unit *u) {
277 assert(u->type != _UNIT_TYPE_INVALID);
279 if (u->load_state != UNIT_STUB || u->in_load_queue)
282 LIST_PREPEND(Unit, load_queue, u->manager->load_queue, u);
283 u->in_load_queue = true;
286 void unit_add_to_cleanup_queue(Unit *u) {
289 if (u->in_cleanup_queue)
292 LIST_PREPEND(Unit, cleanup_queue, u->manager->cleanup_queue, u);
293 u->in_cleanup_queue = true;
296 void unit_add_to_gc_queue(Unit *u) {
299 if (u->in_gc_queue || u->in_cleanup_queue)
302 if (unit_check_gc(u))
305 LIST_PREPEND(Unit, gc_queue, u->manager->gc_queue, u);
306 u->in_gc_queue = true;
308 u->manager->n_in_gc_queue ++;
310 if (u->manager->gc_queue_timestamp <= 0)
311 u->manager->gc_queue_timestamp = now(CLOCK_MONOTONIC);
314 void unit_add_to_dbus_queue(Unit *u) {
316 assert(u->type != _UNIT_TYPE_INVALID);
318 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
321 /* Shortcut things if nobody cares */
322 if (!bus_has_subscriber(u->manager)) {
323 u->sent_dbus_new_signal = true;
327 LIST_PREPEND(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
328 u->in_dbus_queue = true;
331 static void bidi_set_free(Unit *u, Set *s) {
337 /* Frees the set and makes sure we are dropped from the
338 * inverse pointers */
340 SET_FOREACH(other, s, i) {
343 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
344 set_remove(other->dependencies[d], u);
346 unit_add_to_gc_queue(other);
352 void unit_free(Unit *u) {
359 bus_unit_send_removed_signal(u);
361 if (u->load_state != UNIT_STUB)
362 if (UNIT_VTABLE(u)->done)
363 UNIT_VTABLE(u)->done(u);
365 SET_FOREACH(t, u->names, i)
366 hashmap_remove_value(u->manager->units, t, u);
380 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
381 bidi_set_free(u, u->dependencies[d]);
383 if (u->requires_mounts_for) {
384 LIST_REMOVE(Unit, has_requires_mounts_for, u->manager->has_requires_mounts_for, u);
385 strv_free(u->requires_mounts_for);
388 if (u->type != _UNIT_TYPE_INVALID)
389 LIST_REMOVE(Unit, units_by_type, u->manager->units_by_type[u->type], u);
391 if (u->in_load_queue)
392 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
394 if (u->in_dbus_queue)
395 LIST_REMOVE(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
397 if (u->in_cleanup_queue)
398 LIST_REMOVE(Unit, cleanup_queue, u->manager->cleanup_queue, u);
400 if (u->in_gc_queue) {
401 LIST_REMOVE(Unit, gc_queue, u->manager->gc_queue, u);
402 u->manager->n_in_gc_queue--;
405 cgroup_bonding_free_list(u->cgroup_bondings, u->manager->n_reloading <= 0);
406 cgroup_attribute_free_list(u->cgroup_attributes);
408 free(u->description);
409 strv_free(u->documentation);
410 free(u->fragment_path);
411 free(u->source_path);
412 strv_free(u->dropin_paths);
415 set_free_free(u->names);
417 condition_free_list(u->conditions);
419 unit_ref_unset(&u->slice);
422 unit_ref_unset(u->refs);
427 UnitActiveState unit_active_state(Unit *u) {
430 if (u->load_state == UNIT_MERGED)
431 return unit_active_state(unit_follow_merge(u));
433 /* After a reload it might happen that a unit is not correctly
434 * loaded but still has a process around. That's why we won't
435 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
437 return UNIT_VTABLE(u)->active_state(u);
440 const char* unit_sub_state_to_string(Unit *u) {
443 return UNIT_VTABLE(u)->sub_state_to_string(u);
446 static void complete_move(Set **s, Set **other) {
454 set_move(*s, *other);
461 static void merge_names(Unit *u, Unit *other) {
468 complete_move(&u->names, &other->names);
470 set_free_free(other->names);
474 SET_FOREACH(t, u->names, i)
475 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
478 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
485 assert(d < _UNIT_DEPENDENCY_MAX);
487 /* Fix backwards pointers */
488 SET_FOREACH(back, other->dependencies[d], i) {
491 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++)
492 if ((r = set_remove_and_put(back->dependencies[k], other, u)) < 0) {
495 set_remove(back->dependencies[k], other);
497 assert(r == -ENOENT);
501 complete_move(&u->dependencies[d], &other->dependencies[d]);
503 set_free(other->dependencies[d]);
504 other->dependencies[d] = NULL;
507 int unit_merge(Unit *u, Unit *other) {
512 assert(u->manager == other->manager);
513 assert(u->type != _UNIT_TYPE_INVALID);
515 other = unit_follow_merge(other);
520 if (u->type != other->type)
523 if (!u->instance != !other->instance)
526 if (other->load_state != UNIT_STUB &&
527 other->load_state != UNIT_ERROR)
536 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
540 merge_names(u, other);
542 /* Redirect all references */
544 unit_ref_set(other->refs, u);
546 /* Merge dependencies */
547 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
548 merge_dependencies(u, other, d);
550 other->load_state = UNIT_MERGED;
551 other->merged_into = u;
553 /* If there is still some data attached to the other node, we
554 * don't need it anymore, and can free it. */
555 if (other->load_state != UNIT_STUB)
556 if (UNIT_VTABLE(other)->done)
557 UNIT_VTABLE(other)->done(other);
559 unit_add_to_dbus_queue(u);
560 unit_add_to_cleanup_queue(other);
565 int unit_merge_by_name(Unit *u, const char *name) {
573 if (unit_name_is_template(name)) {
577 if (!(s = unit_name_replace_instance(name, u->instance)))
583 if (!(other = manager_get_unit(u->manager, name)))
584 r = unit_add_name(u, name);
586 r = unit_merge(u, other);
592 Unit* unit_follow_merge(Unit *u) {
595 while (u->load_state == UNIT_MERGED)
596 assert_se(u = u->merged_into);
601 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
607 if (c->std_output != EXEC_OUTPUT_KMSG &&
608 c->std_output != EXEC_OUTPUT_SYSLOG &&
609 c->std_output != EXEC_OUTPUT_JOURNAL &&
610 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
611 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
612 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
613 c->std_error != EXEC_OUTPUT_KMSG &&
614 c->std_error != EXEC_OUTPUT_SYSLOG &&
615 c->std_error != EXEC_OUTPUT_JOURNAL &&
616 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
617 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
618 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
621 /* If syslog or kernel logging is requested, make sure our own
622 * logging daemon is run first. */
624 if (u->manager->running_as == SYSTEMD_SYSTEM) {
625 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
633 const char *unit_description(Unit *u) {
637 return u->description;
642 void unit_dump(Unit *u, FILE *f, const char *prefix) {
649 timestamp1[FORMAT_TIMESTAMP_MAX],
650 timestamp2[FORMAT_TIMESTAMP_MAX],
651 timestamp3[FORMAT_TIMESTAMP_MAX],
652 timestamp4[FORMAT_TIMESTAMP_MAX],
653 timespan[FORMAT_TIMESPAN_MAX];
657 assert(u->type >= 0);
661 p2 = strappend(prefix, "\t");
662 prefix2 = p2 ? p2 : prefix;
666 "%s\tDescription: %s\n"
668 "%s\tUnit Load State: %s\n"
669 "%s\tUnit Active State: %s\n"
670 "%s\tInactive Exit Timestamp: %s\n"
671 "%s\tActive Enter Timestamp: %s\n"
672 "%s\tActive Exit Timestamp: %s\n"
673 "%s\tInactive Enter Timestamp: %s\n"
674 "%s\tGC Check Good: %s\n"
675 "%s\tNeed Daemon Reload: %s\n"
678 prefix, unit_description(u),
679 prefix, strna(u->instance),
680 prefix, unit_load_state_to_string(u->load_state),
681 prefix, unit_active_state_to_string(unit_active_state(u)),
682 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
683 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
684 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
685 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
686 prefix, yes_no(unit_check_gc(u)),
687 prefix, yes_no(unit_need_daemon_reload(u)),
688 prefix, strna(unit_slice_name(u)));
690 SET_FOREACH(t, u->names, i)
691 fprintf(f, "%s\tName: %s\n", prefix, t);
693 STRV_FOREACH(j, u->documentation)
694 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
696 if ((following = unit_following(u)))
697 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
699 if (u->fragment_path)
700 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
703 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
705 STRV_FOREACH(j, u->dropin_paths)
706 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
708 if (u->job_timeout > 0)
709 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
711 condition_dump_list(u->conditions, f, prefix);
713 if (dual_timestamp_is_set(&u->condition_timestamp))
715 "%s\tCondition Timestamp: %s\n"
716 "%s\tCondition Result: %s\n",
717 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
718 prefix, yes_no(u->condition_result));
720 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
723 SET_FOREACH(other, u->dependencies[d], i)
724 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
727 if (!strv_isempty(u->requires_mounts_for)) {
729 "%s\tRequiresMountsFor:", prefix);
731 STRV_FOREACH(j, u->requires_mounts_for)
732 fprintf(f, " %s", *j);
737 if (u->load_state == UNIT_LOADED) {
742 "%s\tStopWhenUnneeded: %s\n"
743 "%s\tRefuseManualStart: %s\n"
744 "%s\tRefuseManualStop: %s\n"
745 "%s\tDefaultDependencies: %s\n"
746 "%s\tOnFailureIsolate: %s\n"
747 "%s\tIgnoreOnIsolate: %s\n"
748 "%s\tIgnoreOnSnapshot: %s\n",
749 prefix, yes_no(u->stop_when_unneeded),
750 prefix, yes_no(u->refuse_manual_start),
751 prefix, yes_no(u->refuse_manual_stop),
752 prefix, yes_no(u->default_dependencies),
753 prefix, yes_no(u->on_failure_isolate),
754 prefix, yes_no(u->ignore_on_isolate),
755 prefix, yes_no(u->ignore_on_snapshot));
757 LIST_FOREACH(by_unit, b, u->cgroup_bondings)
758 fprintf(f, "%s\tControlGroup: %s:%s\n",
759 prefix, b->controller, b->path);
761 LIST_FOREACH(by_unit, a, u->cgroup_attributes) {
762 _cleanup_free_ char *v = NULL;
764 if (a->semantics && a->semantics->map_write)
765 a->semantics->map_write(a->semantics, a->value, &v);
767 fprintf(f, "%s\tControlGroupAttribute: %s %s \"%s\"\n",
768 prefix, a->controller, a->name, v ? v : a->value);
771 if (UNIT_VTABLE(u)->dump)
772 UNIT_VTABLE(u)->dump(u, f, prefix2);
774 } else if (u->load_state == UNIT_MERGED)
776 "%s\tMerged into: %s\n",
777 prefix, u->merged_into->id);
778 else if (u->load_state == UNIT_ERROR)
779 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
783 job_dump(u->job, f, prefix2);
786 job_dump(u->nop_job, f, prefix2);
791 /* Common implementation for multiple backends */
792 int unit_load_fragment_and_dropin(Unit *u) {
797 /* Load a .service file */
798 if ((r = unit_load_fragment(u)) < 0)
801 if (u->load_state == UNIT_STUB)
804 /* Load drop-in directory data */
805 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
811 /* Common implementation for multiple backends */
812 int unit_load_fragment_and_dropin_optional(Unit *u) {
817 /* Same as unit_load_fragment_and_dropin(), but whether
818 * something can be loaded or not doesn't matter. */
820 /* Load a .service file */
821 if ((r = unit_load_fragment(u)) < 0)
824 if (u->load_state == UNIT_STUB)
825 u->load_state = UNIT_LOADED;
827 /* Load drop-in directory data */
828 if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
834 int unit_add_default_target_dependency(Unit *u, Unit *target) {
838 if (target->type != UNIT_TARGET)
841 /* Only add the dependency if both units are loaded, so that
842 * that loop check below is reliable */
843 if (u->load_state != UNIT_LOADED ||
844 target->load_state != UNIT_LOADED)
847 /* If either side wants no automatic dependencies, then let's
849 if (!u->default_dependencies ||
850 !target->default_dependencies)
853 /* Don't create loops */
854 if (set_get(target->dependencies[UNIT_BEFORE], u))
857 return unit_add_dependency(target, UNIT_AFTER, u, true);
860 static int unit_add_default_dependencies(Unit *u) {
862 static const UnitDependency deps[] = {
864 UNIT_REQUIRED_BY_OVERRIDABLE,
876 for (k = 0; k < ELEMENTSOF(deps); k++)
877 SET_FOREACH(target, u->dependencies[deps[k]], i) {
878 r = unit_add_default_target_dependency(u, target);
883 if (u->default_dependencies && UNIT_ISSET(u->slice)) {
884 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
892 int unit_load(Unit *u) {
897 if (u->in_load_queue) {
898 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
899 u->in_load_queue = false;
902 if (u->type == _UNIT_TYPE_INVALID)
905 if (u->load_state != UNIT_STUB)
908 if (UNIT_VTABLE(u)->load)
909 if ((r = UNIT_VTABLE(u)->load(u)) < 0)
912 if (u->load_state == UNIT_STUB) {
917 if (u->load_state == UNIT_LOADED &&
918 u->default_dependencies)
919 if ((r = unit_add_default_dependencies(u)) < 0)
922 if (u->load_state == UNIT_LOADED) {
923 r = unit_add_mount_links(u);
928 if (u->on_failure_isolate &&
929 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
931 log_error_unit(u->id,
932 "More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.", u->id);
938 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
940 unit_add_to_dbus_queue(unit_follow_merge(u));
941 unit_add_to_gc_queue(u);
946 u->load_state = UNIT_ERROR;
948 unit_add_to_dbus_queue(u);
949 unit_add_to_gc_queue(u);
951 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
952 u->id, strerror(-r));
957 bool unit_condition_test(Unit *u) {
960 dual_timestamp_get(&u->condition_timestamp);
961 u->condition_result = condition_test_list(u->conditions);
963 return u->condition_result;
966 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
967 const UnitStatusMessageFormats *format_table;
971 assert(t < _JOB_TYPE_MAX);
973 if (t != JOB_START && t != JOB_STOP)
976 format_table = &UNIT_VTABLE(u)->status_message_formats;
980 return format_table->starting_stopping[t == JOB_STOP];
983 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
988 assert(t < _JOB_TYPE_MAX);
990 format = unit_get_status_message_format(u, t);
994 /* Return generic strings */
996 return "Starting %s.";
997 else if (t == JOB_STOP)
998 return "Stopping %s.";
999 else if (t == JOB_RELOAD)
1000 return "Reloading %s.";
1005 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1010 /* We only print status messages for selected units on
1011 * selected operations. */
1013 format = unit_get_status_message_format(u, t);
1017 unit_status_printf(u, "", format);
1020 #pragma GCC diagnostic push
1021 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1022 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1029 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1032 if (log_on_console())
1035 /* We log status messages for all units and all operations. */
1037 format = unit_get_status_message_format_try_harder(u, t);
1041 snprintf(buf, sizeof(buf), format, unit_description(u));
1044 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1045 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1046 SD_MESSAGE_UNIT_RELOADING;
1048 log_struct_unit(LOG_INFO,
1054 #pragma GCC diagnostic pop
1057 * -EBADR: This unit type does not support starting.
1058 * -EALREADY: Unit is already started.
1059 * -EAGAIN: An operation is already in progress. Retry later.
1060 * -ECANCELED: Too many requests for now.
1062 int unit_start(Unit *u) {
1063 UnitActiveState state;
1068 if (u->load_state != UNIT_LOADED)
1071 /* If this is already started, then this will succeed. Note
1072 * that this will even succeed if this unit is not startable
1073 * by the user. This is relied on to detect when we need to
1074 * wait for units and when waiting is finished. */
1075 state = unit_active_state(u);
1076 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1079 /* If the conditions failed, don't do anything at all. If we
1080 * already are activating this call might still be useful to
1081 * speed up activation in case there is some hold-off time,
1082 * but we don't want to recheck the condition in that case. */
1083 if (state != UNIT_ACTIVATING &&
1084 !unit_condition_test(u)) {
1085 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1089 /* Forward to the main object, if we aren't it. */
1090 if ((following = unit_following(u))) {
1091 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1092 u->id, following->id);
1093 return unit_start(following);
1096 unit_status_log_starting_stopping_reloading(u, JOB_START);
1097 unit_status_print_starting_stopping(u, JOB_START);
1099 /* If it is stopped, but we cannot start it, then fail */
1100 if (!UNIT_VTABLE(u)->start)
1103 /* We don't suppress calls to ->start() here when we are
1104 * already starting, to allow this request to be used as a
1105 * "hurry up" call, for example when the unit is in some "auto
1106 * restart" state where it waits for a holdoff timer to elapse
1107 * before it will start again. */
1109 unit_add_to_dbus_queue(u);
1111 return UNIT_VTABLE(u)->start(u);
1114 bool unit_can_start(Unit *u) {
1117 return !!UNIT_VTABLE(u)->start;
1120 bool unit_can_isolate(Unit *u) {
1123 return unit_can_start(u) &&
1128 * -EBADR: This unit type does not support stopping.
1129 * -EALREADY: Unit is already stopped.
1130 * -EAGAIN: An operation is already in progress. Retry later.
1132 int unit_stop(Unit *u) {
1133 UnitActiveState state;
1138 state = unit_active_state(u);
1139 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1142 if ((following = unit_following(u))) {
1143 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1144 u->id, following->id);
1145 return unit_stop(following);
1148 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1149 unit_status_print_starting_stopping(u, JOB_STOP);
1151 if (!UNIT_VTABLE(u)->stop)
1154 unit_add_to_dbus_queue(u);
1156 return UNIT_VTABLE(u)->stop(u);
1160 * -EBADR: This unit type does not support reloading.
1161 * -ENOEXEC: Unit is not started.
1162 * -EAGAIN: An operation is already in progress. Retry later.
1164 int unit_reload(Unit *u) {
1165 UnitActiveState state;
1170 if (u->load_state != UNIT_LOADED)
1173 if (!unit_can_reload(u))
1176 state = unit_active_state(u);
1177 if (state == UNIT_RELOADING)
1180 if (state != UNIT_ACTIVE)
1183 if ((following = unit_following(u))) {
1184 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1185 u->id, following->id);
1186 return unit_reload(following);
1189 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1191 unit_add_to_dbus_queue(u);
1192 return UNIT_VTABLE(u)->reload(u);
1195 bool unit_can_reload(Unit *u) {
1198 if (!UNIT_VTABLE(u)->reload)
1201 if (!UNIT_VTABLE(u)->can_reload)
1204 return UNIT_VTABLE(u)->can_reload(u);
1207 static void unit_check_unneeded(Unit *u) {
1213 /* If this service shall be shut down when unneeded then do
1216 if (!u->stop_when_unneeded)
1219 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1222 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1223 if (unit_active_or_pending(other))
1226 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1227 if (unit_active_or_pending(other))
1230 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1231 if (unit_active_or_pending(other))
1234 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1235 if (unit_active_or_pending(other))
1238 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1240 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1241 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1244 static void retroactively_start_dependencies(Unit *u) {
1249 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1251 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1252 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1253 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1254 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1256 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1257 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1258 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1259 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1261 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1262 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1263 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1264 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1266 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1267 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1268 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1269 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1271 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1272 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1273 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1275 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1276 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1277 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1280 static void retroactively_stop_dependencies(Unit *u) {
1285 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1287 /* Pull down units which are bound to us recursively if enabled */
1288 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1289 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1290 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1293 static void check_unneeded_dependencies(Unit *u) {
1298 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1300 /* Garbage collect services that might not be needed anymore, if enabled */
1301 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1302 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1303 unit_check_unneeded(other);
1304 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1305 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1306 unit_check_unneeded(other);
1307 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1308 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1309 unit_check_unneeded(other);
1310 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1311 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1312 unit_check_unneeded(other);
1313 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1314 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1315 unit_check_unneeded(other);
1316 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1317 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1318 unit_check_unneeded(other);
1321 void unit_start_on_failure(Unit *u) {
1327 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1330 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1332 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1335 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL);
1337 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1341 void unit_trigger_notify(Unit *u) {
1347 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1348 if (UNIT_VTABLE(other)->trigger_notify)
1349 UNIT_VTABLE(other)->trigger_notify(other, u);
1352 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1357 assert(os < _UNIT_ACTIVE_STATE_MAX);
1358 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1360 /* Note that this is called for all low-level state changes,
1361 * even if they might map to the same high-level
1362 * UnitActiveState! That means that ns == os is OK an expected
1363 * behavior here. For example: if a mount point is remounted
1364 * this function will be called too! */
1368 if (m->n_reloading <= 0) {
1371 dual_timestamp_get(&ts);
1373 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1374 u->inactive_exit_timestamp = ts;
1375 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1376 u->inactive_enter_timestamp = ts;
1378 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1379 u->active_enter_timestamp = ts;
1380 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1381 u->active_exit_timestamp = ts;
1384 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1385 cgroup_bonding_trim_list(u->cgroup_bondings, true);
1387 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1388 ExecContext *ec = unit_get_exec_context(u);
1389 if (ec && exec_context_may_touch_console(ec)) {
1390 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1400 if (u->job->state == JOB_WAITING)
1402 /* So we reached a different state for this
1403 * job. Let's see if we can run it now if it
1404 * failed previously due to EAGAIN. */
1405 job_add_to_run_queue(u->job);
1407 /* Let's check whether this state change constitutes a
1408 * finished job, or maybe contradicts a running job and
1409 * hence needs to invalidate jobs. */
1411 switch (u->job->type) {
1414 case JOB_VERIFY_ACTIVE:
1416 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1417 job_finish_and_invalidate(u->job, JOB_DONE, true);
1418 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1421 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1422 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1428 case JOB_RELOAD_OR_START:
1430 if (u->job->state == JOB_RUNNING) {
1431 if (ns == UNIT_ACTIVE)
1432 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1433 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1436 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1437 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1445 case JOB_TRY_RESTART:
1447 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1448 job_finish_and_invalidate(u->job, JOB_DONE, true);
1449 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1451 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1457 assert_not_reached("Job type unknown");
1463 if (m->n_reloading <= 0) {
1465 /* If this state change happened without being
1466 * requested by a job, then let's retroactively start
1467 * or stop dependencies. We skip that step when
1468 * deserializing, since we don't want to create any
1469 * additional jobs just because something is already
1473 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1474 retroactively_start_dependencies(u);
1475 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1476 retroactively_stop_dependencies(u);
1479 /* stop unneeded units regardless if going down was expected or not */
1480 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1481 check_unneeded_dependencies(u);
1483 if (ns != os && ns == UNIT_FAILED) {
1484 log_notice_unit(u->id,
1485 "Unit %s entered failed state.", u->id);
1486 unit_start_on_failure(u);
1490 /* Some names are special */
1491 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1493 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1494 /* The bus just might have become available,
1495 * hence try to connect to it, if we aren't
1499 if (u->type == UNIT_SERVICE &&
1500 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1501 m->n_reloading <= 0) {
1502 /* Write audit record if we have just finished starting up */
1503 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1507 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1508 manager_send_unit_plymouth(m, u);
1512 /* We don't care about D-Bus here, since we'll get an
1513 * asynchronous notification for it anyway. */
1515 if (u->type == UNIT_SERVICE &&
1516 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1517 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1518 m->n_reloading <= 0) {
1520 /* Hmm, if there was no start record written
1521 * write it now, so that we always have a nice
1524 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1526 if (ns == UNIT_INACTIVE)
1527 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1529 /* Write audit record if we have just finished shutting down */
1530 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1532 u->in_audit = false;
1536 manager_recheck_journal(m);
1537 unit_trigger_notify(u);
1539 /* Maybe we finished startup and are now ready for being
1540 * stopped because unneeded? */
1541 if (u->manager->n_reloading <= 0)
1542 unit_check_unneeded(u);
1544 unit_add_to_dbus_queue(u);
1545 unit_add_to_gc_queue(u);
1548 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1549 struct epoll_event ev = {
1557 assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1559 if (epoll_ctl(u->manager->epoll_fd,
1560 w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1572 void unit_unwatch_fd(Unit *u, Watch *w) {
1576 if (w->type == WATCH_INVALID)
1579 assert(w->type == WATCH_FD);
1580 assert(w->data.unit == u);
1581 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1584 w->type = WATCH_INVALID;
1585 w->data.unit = NULL;
1588 int unit_watch_pid(Unit *u, pid_t pid) {
1592 /* Watch a specific PID. We only support one unit watching
1593 * each PID for now. */
1595 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1598 void unit_unwatch_pid(Unit *u, pid_t pid) {
1602 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1605 int unit_watch_timer(Unit *u, clockid_t clock_id, bool relative, usec_t usec, Watch *w) {
1606 struct itimerspec its = {};
1612 assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1614 /* This will try to reuse the old timer if there is one */
1616 if (w->type == WATCH_UNIT_TIMER) {
1617 assert(w->data.unit == u);
1622 } else if (w->type == WATCH_INVALID) {
1625 fd = timerfd_create(clock_id, TFD_NONBLOCK|TFD_CLOEXEC);
1629 assert_not_reached("Invalid watch type");
1632 /* Set absolute time in the past, but not 0, since we
1633 * don't want to disarm the timer */
1634 its.it_value.tv_sec = 0;
1635 its.it_value.tv_nsec = 1;
1637 flags = TFD_TIMER_ABSTIME;
1639 timespec_store(&its.it_value, usec);
1640 flags = relative ? 0 : TFD_TIMER_ABSTIME;
1643 /* This will also flush the elapse counter */
1644 if (timerfd_settime(fd, flags, &its, NULL) < 0)
1647 if (w->type == WATCH_INVALID) {
1648 struct epoll_event ev = {
1653 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1657 w->type = WATCH_UNIT_TIMER;
1665 close_nointr_nofail(fd);
1670 void unit_unwatch_timer(Unit *u, Watch *w) {
1674 if (w->type == WATCH_INVALID)
1677 assert(w->type == WATCH_UNIT_TIMER);
1678 assert(w->data.unit == u);
1681 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1682 close_nointr_nofail(w->fd);
1685 w->type = WATCH_INVALID;
1686 w->data.unit = NULL;
1689 bool unit_job_is_applicable(Unit *u, JobType j) {
1691 assert(j >= 0 && j < _JOB_TYPE_MAX);
1695 case JOB_VERIFY_ACTIVE:
1702 case JOB_TRY_RESTART:
1703 return unit_can_start(u);
1706 return unit_can_reload(u);
1708 case JOB_RELOAD_OR_START:
1709 return unit_can_reload(u) && unit_can_start(u);
1712 assert_not_reached("Invalid job type");
1716 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1718 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1719 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1720 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1721 [UNIT_WANTS] = UNIT_WANTED_BY,
1722 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1723 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1724 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1725 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1726 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1727 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1728 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1729 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1730 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1731 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1732 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1733 [UNIT_BEFORE] = UNIT_AFTER,
1734 [UNIT_AFTER] = UNIT_BEFORE,
1735 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1736 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1737 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1738 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1739 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1740 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1741 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1743 int r, q = 0, v = 0, w = 0;
1746 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1749 u = unit_follow_merge(u);
1750 other = unit_follow_merge(other);
1752 /* We won't allow dependencies on ourselves. We will not
1753 * consider them an error however. */
1757 if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1760 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1761 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1765 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1766 (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1769 if ((q = set_put(u->dependencies[d], other)) < 0)
1772 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1773 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1778 if (add_reference) {
1779 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1784 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1788 unit_add_to_dbus_queue(u);
1793 set_remove(u->dependencies[d], other);
1796 set_remove(other->dependencies[inverse_table[d]], u);
1799 set_remove(u->dependencies[UNIT_REFERENCES], other);
1804 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1809 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1812 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1818 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1822 assert(name || path);
1826 name = path_get_file_name(path);
1828 if (!unit_name_is_template(name)) {
1834 s = unit_name_replace_instance(name, u->instance);
1836 _cleanup_free_ char *i = NULL;
1838 i = unit_name_to_prefix(u->id);
1842 s = unit_name_replace_instance(name, i);
1852 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1855 _cleanup_free_ char *s = NULL;
1858 assert(name || path);
1860 name = resolve_template(u, name, path, &s);
1864 r = manager_load_unit(u->manager, name, path, NULL, &other);
1868 return unit_add_dependency(u, d, other, add_reference);
1871 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1877 assert(name || path);
1879 if (!(name = resolve_template(u, name, path, &s)))
1882 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1885 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1892 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
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_dependency(other, d, u, add_reference);
1913 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1919 assert(name || path);
1921 if (!(name = resolve_template(u, name, path, &s)))
1924 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1927 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1935 int set_unit_path(const char *p) {
1936 _cleanup_free_ char *c = NULL;
1938 /* This is mostly for debug purposes */
1939 c = path_make_absolute_cwd(p);
1940 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
1946 char *unit_dbus_path(Unit *u) {
1952 return unit_dbus_path_from_name(u->id);
1955 static int unit_add_cgroup(Unit *u, CGroupBonding *b) {
1963 if (!b->controller) {
1964 b->controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
1971 /* Ensure this hasn't been added yet */
1974 if (streq(b->controller, SYSTEMD_CGROUP_CONTROLLER)) {
1977 l = hashmap_get(u->manager->cgroup_bondings, b->path);
1978 LIST_PREPEND(CGroupBonding, by_path, l, b);
1980 r = hashmap_replace(u->manager->cgroup_bondings, b->path, l);
1982 LIST_REMOVE(CGroupBonding, by_path, l, b);
1987 LIST_PREPEND(CGroupBonding, by_unit, u->cgroup_bondings, b);
1993 char *unit_default_cgroup_path(Unit *u) {
1994 _cleanup_free_ char *escaped_instance = NULL, *slice = NULL;
1999 if (UNIT_ISSET(u->slice)) {
2000 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2005 escaped_instance = cg_escape(u->id);
2006 if (!escaped_instance)
2010 _cleanup_free_ char *t = NULL, *escaped_template = NULL;
2012 t = unit_name_template(u->id);
2016 escaped_template = cg_escape(t);
2017 if (!escaped_template)
2020 return strjoin(u->manager->cgroup_root, "/",
2021 slice ? slice : "", slice ? "/" : "",
2022 escaped_template, "/", escaped_instance, NULL);
2024 return strjoin(u->manager->cgroup_root, "/",
2025 slice ? slice : "", slice ? "/" : "",
2026 escaped_instance, NULL);
2029 int unit_add_cgroup_from_text(Unit *u, const char *name, bool overwrite, CGroupBonding **ret) {
2030 char *controller = NULL, *path = NULL;
2031 CGroupBonding *b = NULL;
2038 r = cg_split_spec(name, &controller, &path);
2043 path = unit_default_cgroup_path(u);
2048 controller = strdup("systemd");
2052 if (!path || !controller) {
2058 if (streq(controller, "systemd")) {
2059 /* Within the systemd unit hierarchy we do not allow changes. */
2060 if (path_startswith(path, "/system")) {
2061 log_warning_unit(u->id, "Manipulating the systemd:/system cgroup hierarchy is not permitted.");
2068 b = cgroup_bonding_find_list(u->cgroup_bondings, controller);
2070 if (streq(path, b->path)) {
2079 if (overwrite && !b->essential) {
2086 b->realized = false;
2099 b = new0(CGroupBonding, 1);
2105 b->controller = controller;
2108 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2110 r = unit_add_cgroup(u, b);
2127 static int unit_add_one_default_cgroup(Unit *u, const char *controller) {
2128 CGroupBonding *b = NULL;
2133 if (controller && !cg_controller_is_valid(controller, true))
2137 controller = SYSTEMD_CGROUP_CONTROLLER;
2139 if (cgroup_bonding_find_list(u->cgroup_bondings, controller))
2142 b = new0(CGroupBonding, 1);
2146 b->controller = strdup(controller);
2150 b->path = unit_default_cgroup_path(u);
2155 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2157 r = unit_add_cgroup(u, b);
2165 free(b->controller);
2171 int unit_add_default_slice(Unit *u) {
2177 if (UNIT_ISSET(u->slice))
2180 if (u->manager->running_as != SYSTEMD_SYSTEM)
2183 r = manager_load_unit(u->manager, SPECIAL_SYSTEM_SLICE, NULL, NULL, &slice);
2187 unit_ref_set(&u->slice, slice);
2191 const char *unit_slice_name(Unit *u) {
2194 if (!UNIT_ISSET(u->slice))
2197 return UNIT_DEREF(u->slice)->id;
2200 int unit_add_default_cgroups(Unit *u) {
2207 /* Adds in the default cgroups, if they weren't specified
2210 if (!u->manager->cgroup_root)
2213 r = unit_add_one_default_cgroup(u, NULL);
2217 STRV_FOREACH(c, u->manager->default_controllers)
2218 unit_add_one_default_cgroup(u, *c);
2220 LIST_FOREACH(by_unit, a, u->cgroup_attributes)
2221 unit_add_one_default_cgroup(u, a->controller);
2226 CGroupBonding* unit_get_default_cgroup(Unit *u) {
2229 return cgroup_bonding_find_list(u->cgroup_bondings, NULL);
2232 int unit_add_cgroup_attribute(
2234 const CGroupSemantics *semantics,
2235 const char *controller,
2238 CGroupAttribute **ret) {
2240 _cleanup_free_ char *c = NULL;
2248 /* Semantics always take precedence */
2249 if (semantics->name)
2250 name = semantics->name;
2252 if (semantics->controller)
2253 controller = semantics->controller;
2260 r = cg_controller_from_attr(name, &c);
2268 streq(controller, SYSTEMD_CGROUP_CONTROLLER) ||
2269 streq(controller, "systemd"))
2272 if (!filename_is_safe(name))
2275 if (!cg_controller_is_valid(controller, false))
2278 /* Check if this attribute already exists. Note that we will
2279 * explicitly check for the value here too, as there are
2280 * attributes which accept multiple values. */
2281 a = cgroup_attribute_find_list(u->cgroup_attributes, controller, name);
2283 if (streq(value, a->value)) {
2284 /* Exactly the same value is always OK, let's ignore this */
2291 if (semantics && !semantics->multiple) {
2294 /* If this is a single-item entry, we can
2295 * simply patch the existing attribute */
2310 a = new0(CGroupAttribute, 1);
2318 a->controller = strdup(controller);
2320 a->name = strdup(name);
2321 a->value = strdup(value);
2323 if (!a->controller || !a->name || !a->value) {
2324 free(a->controller);
2331 a->semantics = semantics;
2334 LIST_PREPEND(CGroupAttribute, by_unit, u->cgroup_attributes, a);
2342 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2343 _cleanup_free_ char *t = NULL;
2350 t = unit_name_change_suffix(u->id, type);
2354 assert(!unit_has_name(u, t));
2356 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2357 assert(r < 0 || *_found != u);
2361 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2362 _cleanup_free_ char *t = NULL;
2369 t = unit_name_change_suffix(u->id, type);
2373 assert(!unit_has_name(u, t));
2375 found = manager_get_unit(u->manager, t);
2383 int unit_watch_bus_name(Unit *u, const char *name) {
2387 /* Watch a specific name on the bus. We only support one unit
2388 * watching each name for now. */
2390 return hashmap_put(u->manager->watch_bus, name, u);
2393 void unit_unwatch_bus_name(Unit *u, const char *name) {
2397 hashmap_remove_value(u->manager->watch_bus, name, u);
2400 bool unit_can_serialize(Unit *u) {
2403 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2406 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2413 if (!unit_can_serialize(u))
2416 if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2420 if (serialize_jobs) {
2422 fprintf(f, "job\n");
2423 job_serialize(u->job, f, fds);
2427 fprintf(f, "job\n");
2428 job_serialize(u->nop_job, f, fds);
2432 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2433 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2434 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2435 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2436 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2438 if (dual_timestamp_is_set(&u->condition_timestamp))
2439 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2446 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2457 va_start(ap, format);
2458 vfprintf(f, format, ap);
2464 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2470 fprintf(f, "%s=%s\n", key, value);
2473 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2480 if (!unit_can_serialize(u))
2484 char line[LINE_MAX], *l, *v;
2487 if (!fgets(line, sizeof(line), f)) {
2500 k = strcspn(l, "=");
2508 if (streq(l, "job")) {
2510 /* new-style serialized job */
2511 Job *j = job_new_raw(u);
2515 r = job_deserialize(j, f, fds);
2521 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2527 r = job_install_deserialized(j);
2529 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2534 if (j->state == JOB_RUNNING)
2535 u->manager->n_running_jobs++;
2538 JobType type = job_type_from_string(v);
2540 log_debug("Failed to parse job type value %s", v);
2542 u->deserialized_job = type;
2545 } else if (streq(l, "inactive-exit-timestamp")) {
2546 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2548 } else if (streq(l, "active-enter-timestamp")) {
2549 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2551 } else if (streq(l, "active-exit-timestamp")) {
2552 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2554 } else if (streq(l, "inactive-enter-timestamp")) {
2555 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2557 } else if (streq(l, "condition-timestamp")) {
2558 dual_timestamp_deserialize(v, &u->condition_timestamp);
2560 } else if (streq(l, "condition-result")) {
2563 if ((b = parse_boolean(v)) < 0)
2564 log_debug("Failed to parse condition result value %s", v);
2566 u->condition_result = b;
2571 if ((r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds)) < 0)
2576 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2586 /* Adds in links to the device node that this unit is based on */
2588 if (!is_device_path(what))
2591 e = unit_name_from_path(what, ".device");
2595 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2600 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2605 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2613 int unit_coldplug(Unit *u) {
2618 if (UNIT_VTABLE(u)->coldplug)
2619 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2623 r = job_coldplug(u->job);
2626 } else if (u->deserialized_job >= 0) {
2628 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2632 u->deserialized_job = _JOB_TYPE_INVALID;
2638 #pragma GCC diagnostic push
2639 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
2640 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2641 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2643 #pragma GCC diagnostic pop
2645 bool unit_need_daemon_reload(Unit *u) {
2646 _cleanup_strv_free_ char **t = NULL;
2649 unsigned loaded_cnt, current_cnt;
2653 if (u->fragment_path) {
2655 if (stat(u->fragment_path, &st) < 0)
2656 /* What, cannot access this anymore? */
2659 if (u->fragment_mtime > 0 &&
2660 timespec_load(&st.st_mtim) != u->fragment_mtime)
2664 if (u->source_path) {
2666 if (stat(u->source_path, &st) < 0)
2669 if (u->source_mtime > 0 &&
2670 timespec_load(&st.st_mtim) != u->source_mtime)
2674 t = unit_find_dropin_paths(u);
2675 loaded_cnt = strv_length(t);
2676 current_cnt = strv_length(u->dropin_paths);
2678 if (loaded_cnt == current_cnt) {
2679 if (loaded_cnt == 0)
2682 if (strv_overlap(u->dropin_paths, t)) {
2683 STRV_FOREACH(path, u->dropin_paths) {
2685 if (stat(*path, &st) < 0)
2688 if (u->dropin_mtime > 0 &&
2689 timespec_load(&st.st_mtim) > u->dropin_mtime)
2700 void unit_reset_failed(Unit *u) {
2703 if (UNIT_VTABLE(u)->reset_failed)
2704 UNIT_VTABLE(u)->reset_failed(u);
2707 Unit *unit_following(Unit *u) {
2710 if (UNIT_VTABLE(u)->following)
2711 return UNIT_VTABLE(u)->following(u);
2716 bool unit_stop_pending(Unit *u) {
2719 /* This call does check the current state of the unit. It's
2720 * hence useful to be called from state change calls of the
2721 * unit itself, where the state isn't updated yet. This is
2722 * different from unit_inactive_or_pending() which checks both
2723 * the current state and for a queued job. */
2725 return u->job && u->job->type == JOB_STOP;
2728 bool unit_inactive_or_pending(Unit *u) {
2731 /* Returns true if the unit is inactive or going down */
2733 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2736 if (unit_stop_pending(u))
2742 bool unit_active_or_pending(Unit *u) {
2745 /* Returns true if the unit is active or going up */
2747 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2751 (u->job->type == JOB_START ||
2752 u->job->type == JOB_RELOAD_OR_START ||
2753 u->job->type == JOB_RESTART))
2759 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2761 assert(w >= 0 && w < _KILL_WHO_MAX);
2763 assert(signo < _NSIG);
2765 if (!UNIT_VTABLE(u)->kill)
2768 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2771 int unit_kill_common(
2781 if (who == KILL_MAIN && main_pid <= 0) {
2783 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2785 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2789 if (who == KILL_CONTROL && control_pid <= 0) {
2790 if (control_pid < 0)
2791 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2793 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2797 if (who == KILL_CONTROL || who == KILL_ALL)
2798 if (control_pid > 0)
2799 if (kill(control_pid, signo) < 0)
2802 if (who == KILL_MAIN || who == KILL_ALL)
2804 if (kill(main_pid, signo) < 0)
2807 if (who == KILL_ALL) {
2808 _cleanup_set_free_ Set *pid_set = NULL;
2811 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2815 /* Exclude the control/main pid from being killed via the cgroup */
2816 if (control_pid > 0) {
2817 q = set_put(pid_set, LONG_TO_PTR(control_pid));
2823 q = set_put(pid_set, LONG_TO_PTR(main_pid));
2828 q = cgroup_bonding_kill_list(u->cgroup_bondings, signo, false, false, pid_set, NULL);
2829 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2836 int unit_following_set(Unit *u, Set **s) {
2840 if (UNIT_VTABLE(u)->following_set)
2841 return UNIT_VTABLE(u)->following_set(u, s);
2847 UnitFileState unit_get_unit_file_state(Unit *u) {
2850 if (u->unit_file_state < 0 && u->fragment_path)
2851 u->unit_file_state = unit_file_get_state(
2852 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2853 NULL, path_get_file_name(u->fragment_path));
2855 return u->unit_file_state;
2858 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2863 unit_ref_unset(ref);
2866 LIST_PREPEND(UnitRef, refs, u->refs, ref);
2870 void unit_ref_unset(UnitRef *ref) {
2876 LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2880 int unit_add_one_mount_link(Unit *u, Mount *m) {
2886 if (u->load_state != UNIT_LOADED ||
2887 UNIT(m)->load_state != UNIT_LOADED)
2890 STRV_FOREACH(i, u->requires_mounts_for) {
2895 if (!path_startswith(*i, m->where))
2898 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2904 int unit_add_mount_links(Unit *u) {
2910 LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2911 r = unit_add_one_mount_link(u, MOUNT(other));
2919 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2926 /* This only copies in the ones that need memory */
2928 for (i = 0; i < RLIMIT_NLIMITS; i++)
2929 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2930 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2935 if (u->manager->running_as == SYSTEMD_USER &&
2936 !c->working_directory) {
2938 r = get_home_dir(&c->working_directory);
2946 ExecContext *unit_get_exec_context(Unit *u) {
2950 offset = UNIT_VTABLE(u)->exec_context_offset;
2954 return (ExecContext*) ((uint8_t*) u + offset);
2957 static int drop_in_file(Unit *u, bool runtime, const char *name, char **_p, char **_q) {
2966 if (u->manager->running_as == SYSTEMD_USER && runtime)
2969 if (!filename_is_safe(name))
2972 if (u->manager->running_as == SYSTEMD_USER) {
2973 _cleanup_free_ char *c = NULL;
2975 r = user_config_home(&c);
2981 p = strjoin(c, "/", u->id, ".d", NULL);
2983 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2985 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2989 q = strjoin(p, "/50-", name, ".conf", NULL);
3000 int unit_write_drop_in(Unit *u, bool runtime, const char *name, const char *data) {
3001 _cleanup_free_ char *p = NULL, *q = NULL;
3006 r = drop_in_file(u, runtime, name, &p, &q);
3011 return write_string_file_atomic_label(q, data);
3014 int unit_remove_drop_in(Unit *u, bool runtime, const char *name) {
3015 _cleanup_free_ char *p = NULL, *q = NULL;
3020 r = drop_in_file(u, runtime, name, &p, &q);
3030 int unit_kill_context(
3036 bool main_pid_alien) {
3038 int sig, wait_for_exit = 0, r;
3043 if (c->kill_mode == KILL_NONE)
3046 sig = sigkill ? SIGKILL : c->kill_signal;
3049 r = kill_and_sigcont(main_pid, sig);
3051 if (r < 0 && r != -ESRCH) {
3052 _cleanup_free_ char *comm = NULL;
3053 get_process_comm(main_pid, &comm);
3055 log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
3056 (long) main_pid, strna(comm), strerror(-r));
3058 wait_for_exit = !main_pid_alien;
3061 if (control_pid > 0) {
3062 r = kill_and_sigcont(control_pid, sig);
3064 if (r < 0 && r != -ESRCH) {
3065 _cleanup_free_ char *comm = NULL;
3066 get_process_comm(control_pid, &comm);
3068 log_warning_unit(u->id,
3069 "Failed to kill control process %li (%s): %s",
3070 (long) control_pid, strna(comm), strerror(-r));
3072 wait_for_exit = true;
3075 if (c->kill_mode == KILL_CONTROL_GROUP) {
3076 _cleanup_set_free_ Set *pid_set = NULL;
3078 pid_set = set_new(trivial_hash_func, trivial_compare_func);
3082 /* Exclude the main/control pids from being killed via the cgroup */
3084 r = set_put(pid_set, LONG_TO_PTR(main_pid));
3089 if (control_pid > 0) {
3090 r = set_put(pid_set, LONG_TO_PTR(control_pid));
3095 r = cgroup_bonding_kill_list(u->cgroup_bondings, sig, true, false, pid_set, NULL);
3097 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3098 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3100 wait_for_exit = true;
3103 return wait_for_exit;
3106 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3107 [UNIT_ACTIVE] = "active",
3108 [UNIT_RELOADING] = "reloading",
3109 [UNIT_INACTIVE] = "inactive",
3110 [UNIT_FAILED] = "failed",
3111 [UNIT_ACTIVATING] = "activating",
3112 [UNIT_DEACTIVATING] = "deactivating"
3115 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3117 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3118 [UNIT_REQUIRES] = "Requires",
3119 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3120 [UNIT_REQUISITE] = "Requisite",
3121 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3122 [UNIT_WANTS] = "Wants",
3123 [UNIT_BINDS_TO] = "BindsTo",
3124 [UNIT_PART_OF] = "PartOf",
3125 [UNIT_REQUIRED_BY] = "RequiredBy",
3126 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3127 [UNIT_WANTED_BY] = "WantedBy",
3128 [UNIT_BOUND_BY] = "BoundBy",
3129 [UNIT_CONSISTS_OF] = "ConsistsOf",
3130 [UNIT_CONFLICTS] = "Conflicts",
3131 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3132 [UNIT_BEFORE] = "Before",
3133 [UNIT_AFTER] = "After",
3134 [UNIT_ON_FAILURE] = "OnFailure",
3135 [UNIT_TRIGGERS] = "Triggers",
3136 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3137 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3138 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3139 [UNIT_REFERENCES] = "References",
3140 [UNIT_REFERENCED_BY] = "ReferencedBy",
3143 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);