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"
49 #include "fileio-label.h"
50 #include "bus-errors.h"
52 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
53 [UNIT_SERVICE] = &service_vtable,
54 [UNIT_TIMER] = &timer_vtable,
55 [UNIT_SOCKET] = &socket_vtable,
56 [UNIT_TARGET] = &target_vtable,
57 [UNIT_DEVICE] = &device_vtable,
58 [UNIT_MOUNT] = &mount_vtable,
59 [UNIT_AUTOMOUNT] = &automount_vtable,
60 [UNIT_SNAPSHOT] = &snapshot_vtable,
61 [UNIT_SWAP] = &swap_vtable,
62 [UNIT_PATH] = &path_vtable,
63 [UNIT_SLICE] = &slice_vtable,
64 [UNIT_SCOPE] = &scope_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 (isempty(description))
237 s = strdup(description);
242 free(u->description);
245 unit_add_to_dbus_queue(u);
249 bool unit_check_gc(Unit *u) {
252 if (u->load_state == UNIT_STUB)
255 if (UNIT_VTABLE(u)->no_gc)
267 if (unit_active_state(u) != UNIT_INACTIVE)
273 if (UNIT_VTABLE(u)->check_gc)
274 if (UNIT_VTABLE(u)->check_gc(u))
280 void unit_add_to_load_queue(Unit *u) {
282 assert(u->type != _UNIT_TYPE_INVALID);
284 if (u->load_state != UNIT_STUB || u->in_load_queue)
287 LIST_PREPEND(Unit, load_queue, u->manager->load_queue, u);
288 u->in_load_queue = true;
291 void unit_add_to_cleanup_queue(Unit *u) {
294 if (u->in_cleanup_queue)
297 LIST_PREPEND(Unit, cleanup_queue, u->manager->cleanup_queue, u);
298 u->in_cleanup_queue = true;
301 void unit_add_to_gc_queue(Unit *u) {
304 if (u->in_gc_queue || u->in_cleanup_queue)
307 if (unit_check_gc(u))
310 LIST_PREPEND(Unit, gc_queue, u->manager->gc_queue, u);
311 u->in_gc_queue = true;
313 u->manager->n_in_gc_queue ++;
316 void unit_add_to_dbus_queue(Unit *u) {
318 assert(u->type != _UNIT_TYPE_INVALID);
320 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
323 /* Shortcut things if nobody cares */
324 if (!bus_has_subscriber(u->manager)) {
325 u->sent_dbus_new_signal = true;
329 LIST_PREPEND(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
330 u->in_dbus_queue = true;
333 static void bidi_set_free(Unit *u, Set *s) {
339 /* Frees the set and makes sure we are dropped from the
340 * inverse pointers */
342 SET_FOREACH(other, s, i) {
345 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
346 set_remove(other->dependencies[d], u);
348 unit_add_to_gc_queue(other);
354 static void unit_remove_transient(Unit *u) {
362 if (u->fragment_path)
363 unlink(u->fragment_path);
365 STRV_FOREACH(i, u->dropin_paths) {
366 _cleanup_free_ char *p = NULL;
371 r = path_get_parent(*i, &p);
377 void unit_free(Unit *u) {
384 if (u->manager->n_reloading <= 0)
385 unit_remove_transient(u);
387 bus_unit_send_removed_signal(u);
389 if (u->load_state != UNIT_STUB)
390 if (UNIT_VTABLE(u)->done)
391 UNIT_VTABLE(u)->done(u);
393 SET_FOREACH(t, u->names, i)
394 hashmap_remove_value(u->manager->units, t, u);
408 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
409 bidi_set_free(u, u->dependencies[d]);
411 if (u->requires_mounts_for) {
412 LIST_REMOVE(Unit, has_requires_mounts_for, u->manager->has_requires_mounts_for, u);
413 strv_free(u->requires_mounts_for);
416 if (u->type != _UNIT_TYPE_INVALID)
417 LIST_REMOVE(Unit, units_by_type, u->manager->units_by_type[u->type], u);
419 if (u->in_load_queue)
420 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
422 if (u->in_dbus_queue)
423 LIST_REMOVE(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
425 if (u->in_cleanup_queue)
426 LIST_REMOVE(Unit, cleanup_queue, u->manager->cleanup_queue, u);
428 if (u->in_gc_queue) {
429 LIST_REMOVE(Unit, gc_queue, u->manager->gc_queue, u);
430 u->manager->n_in_gc_queue--;
433 if (u->in_cgroup_queue)
434 LIST_REMOVE(Unit, cgroup_queue, u->manager->cgroup_queue, u);
436 if (u->cgroup_path) {
437 hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
438 free(u->cgroup_path);
441 free(u->description);
442 strv_free(u->documentation);
443 free(u->fragment_path);
444 free(u->source_path);
445 strv_free(u->dropin_paths);
448 set_free_free(u->names);
450 condition_free_list(u->conditions);
452 unit_ref_unset(&u->slice);
455 unit_ref_unset(u->refs);
460 UnitActiveState unit_active_state(Unit *u) {
463 if (u->load_state == UNIT_MERGED)
464 return unit_active_state(unit_follow_merge(u));
466 /* After a reload it might happen that a unit is not correctly
467 * loaded but still has a process around. That's why we won't
468 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
470 return UNIT_VTABLE(u)->active_state(u);
473 const char* unit_sub_state_to_string(Unit *u) {
476 return UNIT_VTABLE(u)->sub_state_to_string(u);
479 static void complete_move(Set **s, Set **other) {
487 set_move(*s, *other);
494 static void merge_names(Unit *u, Unit *other) {
501 complete_move(&u->names, &other->names);
503 set_free_free(other->names);
507 SET_FOREACH(t, u->names, i)
508 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
511 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
518 assert(d < _UNIT_DEPENDENCY_MAX);
520 /* Fix backwards pointers */
521 SET_FOREACH(back, other->dependencies[d], i) {
524 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++)
525 if ((r = set_remove_and_put(back->dependencies[k], other, u)) < 0) {
528 set_remove(back->dependencies[k], other);
530 assert(r == -ENOENT);
534 complete_move(&u->dependencies[d], &other->dependencies[d]);
536 set_free(other->dependencies[d]);
537 other->dependencies[d] = NULL;
540 int unit_merge(Unit *u, Unit *other) {
545 assert(u->manager == other->manager);
546 assert(u->type != _UNIT_TYPE_INVALID);
548 other = unit_follow_merge(other);
553 if (u->type != other->type)
556 if (!u->instance != !other->instance)
559 if (other->load_state != UNIT_STUB &&
560 other->load_state != UNIT_NOT_FOUND)
569 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
573 merge_names(u, other);
575 /* Redirect all references */
577 unit_ref_set(other->refs, u);
579 /* Merge dependencies */
580 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
581 merge_dependencies(u, other, d);
583 other->load_state = UNIT_MERGED;
584 other->merged_into = u;
586 /* If there is still some data attached to the other node, we
587 * don't need it anymore, and can free it. */
588 if (other->load_state != UNIT_STUB)
589 if (UNIT_VTABLE(other)->done)
590 UNIT_VTABLE(other)->done(other);
592 unit_add_to_dbus_queue(u);
593 unit_add_to_cleanup_queue(other);
598 int unit_merge_by_name(Unit *u, const char *name) {
606 if (unit_name_is_template(name)) {
610 if (!(s = unit_name_replace_instance(name, u->instance)))
616 other = manager_get_unit(u->manager, name);
618 r = unit_add_name(u, name);
620 r = unit_merge(u, other);
626 Unit* unit_follow_merge(Unit *u) {
629 while (u->load_state == UNIT_MERGED)
630 assert_se(u = u->merged_into);
635 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
641 if (c->std_output != EXEC_OUTPUT_KMSG &&
642 c->std_output != EXEC_OUTPUT_SYSLOG &&
643 c->std_output != EXEC_OUTPUT_JOURNAL &&
644 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
645 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
646 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
647 c->std_error != EXEC_OUTPUT_KMSG &&
648 c->std_error != EXEC_OUTPUT_SYSLOG &&
649 c->std_error != EXEC_OUTPUT_JOURNAL &&
650 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
651 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
652 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
655 /* If syslog or kernel logging is requested, make sure our own
656 * logging daemon is run first. */
658 if (u->manager->running_as == SYSTEMD_SYSTEM) {
659 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
667 const char *unit_description(Unit *u) {
671 return u->description;
676 void unit_dump(Unit *u, FILE *f, const char *prefix) {
683 timestamp1[FORMAT_TIMESTAMP_MAX],
684 timestamp2[FORMAT_TIMESTAMP_MAX],
685 timestamp3[FORMAT_TIMESTAMP_MAX],
686 timestamp4[FORMAT_TIMESTAMP_MAX],
687 timespan[FORMAT_TIMESPAN_MAX];
691 assert(u->type >= 0);
695 p2 = strappend(prefix, "\t");
696 prefix2 = p2 ? p2 : prefix;
700 "%s\tDescription: %s\n"
702 "%s\tUnit Load State: %s\n"
703 "%s\tUnit Active State: %s\n"
704 "%s\tInactive Exit Timestamp: %s\n"
705 "%s\tActive Enter Timestamp: %s\n"
706 "%s\tActive Exit Timestamp: %s\n"
707 "%s\tInactive Enter Timestamp: %s\n"
708 "%s\tGC Check Good: %s\n"
709 "%s\tNeed Daemon Reload: %s\n"
710 "%s\tTransient: %s\n"
713 "%s\tCGroup realized: %s\n"
714 "%s\tCGroup mask: 0x%x\n",
716 prefix, unit_description(u),
717 prefix, strna(u->instance),
718 prefix, unit_load_state_to_string(u->load_state),
719 prefix, unit_active_state_to_string(unit_active_state(u)),
720 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
721 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
722 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
723 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
724 prefix, yes_no(unit_check_gc(u)),
725 prefix, yes_no(unit_need_daemon_reload(u)),
726 prefix, yes_no(u->transient),
727 prefix, strna(unit_slice_name(u)),
728 prefix, strna(u->cgroup_path),
729 prefix, yes_no(u->cgroup_realized),
730 prefix, u->cgroup_mask);
732 SET_FOREACH(t, u->names, i)
733 fprintf(f, "%s\tName: %s\n", prefix, t);
735 STRV_FOREACH(j, u->documentation)
736 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
738 if ((following = unit_following(u)))
739 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
741 if (u->fragment_path)
742 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
745 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
747 STRV_FOREACH(j, u->dropin_paths)
748 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
750 if (u->job_timeout > 0)
751 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
753 condition_dump_list(u->conditions, f, prefix);
755 if (dual_timestamp_is_set(&u->condition_timestamp))
757 "%s\tCondition Timestamp: %s\n"
758 "%s\tCondition Result: %s\n",
759 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
760 prefix, yes_no(u->condition_result));
762 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
765 SET_FOREACH(other, u->dependencies[d], i)
766 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
769 if (!strv_isempty(u->requires_mounts_for)) {
771 "%s\tRequiresMountsFor:", prefix);
773 STRV_FOREACH(j, u->requires_mounts_for)
774 fprintf(f, " %s", *j);
779 if (u->load_state == UNIT_LOADED) {
782 "%s\tStopWhenUnneeded: %s\n"
783 "%s\tRefuseManualStart: %s\n"
784 "%s\tRefuseManualStop: %s\n"
785 "%s\tDefaultDependencies: %s\n"
786 "%s\tOnFailureIsolate: %s\n"
787 "%s\tIgnoreOnIsolate: %s\n"
788 "%s\tIgnoreOnSnapshot: %s\n",
789 prefix, yes_no(u->stop_when_unneeded),
790 prefix, yes_no(u->refuse_manual_start),
791 prefix, yes_no(u->refuse_manual_stop),
792 prefix, yes_no(u->default_dependencies),
793 prefix, yes_no(u->on_failure_isolate),
794 prefix, yes_no(u->ignore_on_isolate),
795 prefix, yes_no(u->ignore_on_snapshot));
797 if (UNIT_VTABLE(u)->dump)
798 UNIT_VTABLE(u)->dump(u, f, prefix2);
800 } else if (u->load_state == UNIT_MERGED)
802 "%s\tMerged into: %s\n",
803 prefix, u->merged_into->id);
804 else if (u->load_state == UNIT_ERROR)
805 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
809 job_dump(u->job, f, prefix2);
812 job_dump(u->nop_job, f, prefix2);
817 /* Common implementation for multiple backends */
818 int unit_load_fragment_and_dropin(Unit *u) {
823 /* Load a .service file */
824 r = unit_load_fragment(u);
828 if (u->load_state == UNIT_STUB)
831 /* Load drop-in directory data */
832 r = unit_load_dropin(unit_follow_merge(u));
839 /* Common implementation for multiple backends */
840 int unit_load_fragment_and_dropin_optional(Unit *u) {
845 /* Same as unit_load_fragment_and_dropin(), but whether
846 * something can be loaded or not doesn't matter. */
848 /* Load a .service file */
849 r = unit_load_fragment(u);
853 if (u->load_state == UNIT_STUB)
854 u->load_state = UNIT_LOADED;
856 /* Load drop-in directory data */
857 r = unit_load_dropin(unit_follow_merge(u));
864 int unit_add_default_target_dependency(Unit *u, Unit *target) {
868 if (target->type != UNIT_TARGET)
871 /* Only add the dependency if both units are loaded, so that
872 * that loop check below is reliable */
873 if (u->load_state != UNIT_LOADED ||
874 target->load_state != UNIT_LOADED)
877 /* If either side wants no automatic dependencies, then let's
879 if (!u->default_dependencies ||
880 !target->default_dependencies)
883 /* Don't create loops */
884 if (set_get(target->dependencies[UNIT_BEFORE], u))
887 return unit_add_dependency(target, UNIT_AFTER, u, true);
890 static int unit_add_default_dependencies(Unit *u) {
892 static const UnitDependency deps[] = {
894 UNIT_REQUIRED_BY_OVERRIDABLE,
906 for (k = 0; k < ELEMENTSOF(deps); k++)
907 SET_FOREACH(target, u->dependencies[deps[k]], i) {
908 r = unit_add_default_target_dependency(u, target);
913 if (u->default_dependencies && unit_get_cgroup_context(u)) {
914 if (UNIT_ISSET(u->slice))
915 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
917 r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
926 int unit_load(Unit *u) {
931 if (u->in_load_queue) {
932 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
933 u->in_load_queue = false;
936 if (u->type == _UNIT_TYPE_INVALID)
939 if (u->load_state != UNIT_STUB)
942 if (UNIT_VTABLE(u)->load) {
943 r = UNIT_VTABLE(u)->load(u);
948 if (u->load_state == UNIT_STUB) {
953 if (u->load_state == UNIT_LOADED) {
955 if (u->default_dependencies) {
956 r = unit_add_default_dependencies(u);
961 r = unit_add_mount_links(u);
965 if (u->on_failure_isolate &&
966 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
968 log_error_unit(u->id,
969 "More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.", u->id);
976 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
978 unit_add_to_dbus_queue(unit_follow_merge(u));
979 unit_add_to_gc_queue(u);
984 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
986 unit_add_to_dbus_queue(u);
987 unit_add_to_gc_queue(u);
989 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
990 u->id, strerror(-r));
995 bool unit_condition_test(Unit *u) {
998 dual_timestamp_get(&u->condition_timestamp);
999 u->condition_result = condition_test_list(u->id, u->conditions);
1001 return u->condition_result;
1004 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1005 const UnitStatusMessageFormats *format_table;
1009 assert(t < _JOB_TYPE_MAX);
1011 if (t != JOB_START && t != JOB_STOP)
1014 format_table = &UNIT_VTABLE(u)->status_message_formats;
1018 return format_table->starting_stopping[t == JOB_STOP];
1021 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1026 assert(t < _JOB_TYPE_MAX);
1028 format = unit_get_status_message_format(u, t);
1032 /* Return generic strings */
1034 return "Starting %s.";
1035 else if (t == JOB_STOP)
1036 return "Stopping %s.";
1037 else if (t == JOB_RELOAD)
1038 return "Reloading %s.";
1043 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1048 /* We only print status messages for selected units on
1049 * selected operations. */
1051 format = unit_get_status_message_format(u, t);
1055 unit_status_printf(u, "", format);
1058 #pragma GCC diagnostic push
1059 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1060 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1067 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1070 if (log_on_console())
1073 /* We log status messages for all units and all operations. */
1075 format = unit_get_status_message_format_try_harder(u, t);
1079 snprintf(buf, sizeof(buf), format, unit_description(u));
1082 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1083 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1084 SD_MESSAGE_UNIT_RELOADING;
1086 log_struct_unit(LOG_INFO,
1092 #pragma GCC diagnostic pop
1095 * -EBADR: This unit type does not support starting.
1096 * -EALREADY: Unit is already started.
1097 * -EAGAIN: An operation is already in progress. Retry later.
1098 * -ECANCELED: Too many requests for now.
1100 int unit_start(Unit *u) {
1101 UnitActiveState state;
1106 if (u->load_state != UNIT_LOADED)
1109 /* If this is already started, then this will succeed. Note
1110 * that this will even succeed if this unit is not startable
1111 * by the user. This is relied on to detect when we need to
1112 * wait for units and when waiting is finished. */
1113 state = unit_active_state(u);
1114 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1117 /* If the conditions failed, don't do anything at all. If we
1118 * already are activating this call might still be useful to
1119 * speed up activation in case there is some hold-off time,
1120 * but we don't want to recheck the condition in that case. */
1121 if (state != UNIT_ACTIVATING &&
1122 !unit_condition_test(u)) {
1123 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1127 /* Forward to the main object, if we aren't it. */
1128 following = unit_following(u);
1130 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1131 u->id, following->id);
1132 return unit_start(following);
1135 unit_status_log_starting_stopping_reloading(u, JOB_START);
1136 unit_status_print_starting_stopping(u, JOB_START);
1138 /* If it is stopped, but we cannot start it, then fail */
1139 if (!UNIT_VTABLE(u)->start)
1142 /* We don't suppress calls to ->start() here when we are
1143 * already starting, to allow this request to be used as a
1144 * "hurry up" call, for example when the unit is in some "auto
1145 * restart" state where it waits for a holdoff timer to elapse
1146 * before it will start again. */
1148 unit_add_to_dbus_queue(u);
1150 return UNIT_VTABLE(u)->start(u);
1153 bool unit_can_start(Unit *u) {
1156 return !!UNIT_VTABLE(u)->start;
1159 bool unit_can_isolate(Unit *u) {
1162 return unit_can_start(u) &&
1167 * -EBADR: This unit type does not support stopping.
1168 * -EALREADY: Unit is already stopped.
1169 * -EAGAIN: An operation is already in progress. Retry later.
1171 int unit_stop(Unit *u) {
1172 UnitActiveState state;
1177 state = unit_active_state(u);
1178 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1181 if ((following = unit_following(u))) {
1182 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1183 u->id, following->id);
1184 return unit_stop(following);
1187 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1188 unit_status_print_starting_stopping(u, JOB_STOP);
1190 if (!UNIT_VTABLE(u)->stop)
1193 unit_add_to_dbus_queue(u);
1195 return UNIT_VTABLE(u)->stop(u);
1199 * -EBADR: This unit type does not support reloading.
1200 * -ENOEXEC: Unit is not started.
1201 * -EAGAIN: An operation is already in progress. Retry later.
1203 int unit_reload(Unit *u) {
1204 UnitActiveState state;
1209 if (u->load_state != UNIT_LOADED)
1212 if (!unit_can_reload(u))
1215 state = unit_active_state(u);
1216 if (state == UNIT_RELOADING)
1219 if (state != UNIT_ACTIVE)
1222 if ((following = unit_following(u))) {
1223 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1224 u->id, following->id);
1225 return unit_reload(following);
1228 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1230 unit_add_to_dbus_queue(u);
1231 return UNIT_VTABLE(u)->reload(u);
1234 bool unit_can_reload(Unit *u) {
1237 if (!UNIT_VTABLE(u)->reload)
1240 if (!UNIT_VTABLE(u)->can_reload)
1243 return UNIT_VTABLE(u)->can_reload(u);
1246 static void unit_check_unneeded(Unit *u) {
1252 /* If this service shall be shut down when unneeded then do
1255 if (!u->stop_when_unneeded)
1258 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1261 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1262 if (unit_active_or_pending(other))
1265 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1266 if (unit_active_or_pending(other))
1269 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1270 if (unit_active_or_pending(other))
1273 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1274 if (unit_active_or_pending(other))
1277 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1279 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1280 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1283 static void retroactively_start_dependencies(Unit *u) {
1288 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1290 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1291 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1292 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1293 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1295 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1296 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1297 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1298 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1300 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1301 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1302 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1303 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1305 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1306 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1307 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1308 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1310 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1311 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1312 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1314 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1315 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1316 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1319 static void retroactively_stop_dependencies(Unit *u) {
1324 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1326 /* Pull down units which are bound to us recursively if enabled */
1327 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1328 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1329 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1332 static void check_unneeded_dependencies(Unit *u) {
1337 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1339 /* Garbage collect services that might not be needed anymore, if enabled */
1340 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1341 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1342 unit_check_unneeded(other);
1343 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1344 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1345 unit_check_unneeded(other);
1346 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1347 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1348 unit_check_unneeded(other);
1349 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1350 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1351 unit_check_unneeded(other);
1352 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1353 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1354 unit_check_unneeded(other);
1355 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1356 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1357 unit_check_unneeded(other);
1360 void unit_start_on_failure(Unit *u) {
1366 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1369 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1371 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1374 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL);
1376 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1380 void unit_trigger_notify(Unit *u) {
1386 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1387 if (UNIT_VTABLE(other)->trigger_notify)
1388 UNIT_VTABLE(other)->trigger_notify(other, u);
1391 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1396 assert(os < _UNIT_ACTIVE_STATE_MAX);
1397 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1399 /* Note that this is called for all low-level state changes,
1400 * even if they might map to the same high-level
1401 * UnitActiveState! That means that ns == os is OK an expected
1402 * behavior here. For example: if a mount point is remounted
1403 * this function will be called too! */
1407 if (m->n_reloading <= 0) {
1410 dual_timestamp_get(&ts);
1412 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1413 u->inactive_exit_timestamp = ts;
1414 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1415 u->inactive_enter_timestamp = ts;
1417 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1418 u->active_enter_timestamp = ts;
1419 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1420 u->active_exit_timestamp = ts;
1423 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1424 unit_destroy_cgroup(u);
1426 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1427 ExecContext *ec = unit_get_exec_context(u);
1428 if (ec && exec_context_may_touch_console(ec)) {
1429 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1432 if (m->n_on_console == 0)
1433 /* unset no_console_output flag, since the console is free */
1434 m->no_console_output = 0;
1443 if (u->job->state == JOB_WAITING)
1445 /* So we reached a different state for this
1446 * job. Let's see if we can run it now if it
1447 * failed previously due to EAGAIN. */
1448 job_add_to_run_queue(u->job);
1450 /* Let's check whether this state change constitutes a
1451 * finished job, or maybe contradicts a running job and
1452 * hence needs to invalidate jobs. */
1454 switch (u->job->type) {
1457 case JOB_VERIFY_ACTIVE:
1459 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1460 job_finish_and_invalidate(u->job, JOB_DONE, true);
1461 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1464 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1465 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1471 case JOB_RELOAD_OR_START:
1473 if (u->job->state == JOB_RUNNING) {
1474 if (ns == UNIT_ACTIVE)
1475 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1476 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1479 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1480 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1488 case JOB_TRY_RESTART:
1490 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1491 job_finish_and_invalidate(u->job, JOB_DONE, true);
1492 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1494 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1500 assert_not_reached("Job type unknown");
1506 if (m->n_reloading <= 0) {
1508 /* If this state change happened without being
1509 * requested by a job, then let's retroactively start
1510 * or stop dependencies. We skip that step when
1511 * deserializing, since we don't want to create any
1512 * additional jobs just because something is already
1516 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1517 retroactively_start_dependencies(u);
1518 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1519 retroactively_stop_dependencies(u);
1522 /* stop unneeded units regardless if going down was expected or not */
1523 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1524 check_unneeded_dependencies(u);
1526 if (ns != os && ns == UNIT_FAILED) {
1527 log_notice_unit(u->id,
1528 "Unit %s entered failed state.", u->id);
1529 unit_start_on_failure(u);
1533 /* Some names are special */
1534 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1536 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1537 /* The bus just might have become available,
1538 * hence try to connect to it, if we aren't
1542 if (u->type == UNIT_SERVICE &&
1543 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1544 m->n_reloading <= 0) {
1545 /* Write audit record if we have just finished starting up */
1546 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1550 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1551 manager_send_unit_plymouth(m, u);
1555 /* We don't care about D-Bus here, since we'll get an
1556 * asynchronous notification for it anyway. */
1558 if (u->type == UNIT_SERVICE &&
1559 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1560 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1561 m->n_reloading <= 0) {
1563 /* Hmm, if there was no start record written
1564 * write it now, so that we always have a nice
1567 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1569 if (ns == UNIT_INACTIVE)
1570 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1572 /* Write audit record if we have just finished shutting down */
1573 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1575 u->in_audit = false;
1579 manager_recheck_journal(m);
1580 unit_trigger_notify(u);
1582 /* Maybe we finished startup and are now ready for being
1583 * stopped because unneeded? */
1584 if (u->manager->n_reloading <= 0)
1585 unit_check_unneeded(u);
1587 unit_add_to_dbus_queue(u);
1588 unit_add_to_gc_queue(u);
1591 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1592 struct epoll_event ev = {
1600 assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1602 if (epoll_ctl(u->manager->epoll_fd,
1603 w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1615 void unit_unwatch_fd(Unit *u, Watch *w) {
1619 if (w->type == WATCH_INVALID)
1622 assert(w->type == WATCH_FD);
1623 assert(w->data.unit == u);
1624 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1627 w->type = WATCH_INVALID;
1628 w->data.unit = NULL;
1631 int unit_watch_pid(Unit *u, pid_t pid) {
1635 /* Watch a specific PID. We only support one unit watching
1636 * each PID for now. */
1638 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1641 void unit_unwatch_pid(Unit *u, pid_t pid) {
1645 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1648 int unit_watch_timer(Unit *u, clockid_t clock_id, bool relative, usec_t usec, Watch *w) {
1649 struct itimerspec its = {};
1655 assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1657 /* This will try to reuse the old timer if there is one */
1659 if (w->type == WATCH_UNIT_TIMER) {
1660 assert(w->data.unit == u);
1665 } else if (w->type == WATCH_INVALID) {
1668 fd = timerfd_create(clock_id, TFD_NONBLOCK|TFD_CLOEXEC);
1672 assert_not_reached("Invalid watch type");
1675 /* Set absolute time in the past, but not 0, since we
1676 * don't want to disarm the timer */
1677 its.it_value.tv_sec = 0;
1678 its.it_value.tv_nsec = 1;
1680 flags = TFD_TIMER_ABSTIME;
1682 timespec_store(&its.it_value, usec);
1683 flags = relative ? 0 : TFD_TIMER_ABSTIME;
1686 /* This will also flush the elapse counter */
1687 if (timerfd_settime(fd, flags, &its, NULL) < 0)
1690 if (w->type == WATCH_INVALID) {
1691 struct epoll_event ev = {
1696 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1700 w->type = WATCH_UNIT_TIMER;
1708 close_nointr_nofail(fd);
1713 void unit_unwatch_timer(Unit *u, Watch *w) {
1717 if (w->type == WATCH_INVALID)
1720 assert(w->type == WATCH_UNIT_TIMER);
1721 assert(w->data.unit == u);
1724 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1725 close_nointr_nofail(w->fd);
1728 w->type = WATCH_INVALID;
1729 w->data.unit = NULL;
1732 bool unit_job_is_applicable(Unit *u, JobType j) {
1734 assert(j >= 0 && j < _JOB_TYPE_MAX);
1738 case JOB_VERIFY_ACTIVE:
1745 case JOB_TRY_RESTART:
1746 return unit_can_start(u);
1749 return unit_can_reload(u);
1751 case JOB_RELOAD_OR_START:
1752 return unit_can_reload(u) && unit_can_start(u);
1755 assert_not_reached("Invalid job type");
1759 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1761 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1762 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1763 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1764 [UNIT_WANTS] = UNIT_WANTED_BY,
1765 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1766 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1767 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1768 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1769 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1770 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1771 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1772 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1773 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1774 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1775 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1776 [UNIT_BEFORE] = UNIT_AFTER,
1777 [UNIT_AFTER] = UNIT_BEFORE,
1778 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1779 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1780 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1781 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1782 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1783 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1784 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1786 int r, q = 0, v = 0, w = 0;
1789 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1792 u = unit_follow_merge(u);
1793 other = unit_follow_merge(other);
1795 /* We won't allow dependencies on ourselves. We will not
1796 * consider them an error however. */
1800 if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1803 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1804 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1808 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1809 (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1812 if ((q = set_put(u->dependencies[d], other)) < 0)
1815 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1816 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1821 if (add_reference) {
1822 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1827 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1831 unit_add_to_dbus_queue(u);
1836 set_remove(u->dependencies[d], other);
1839 set_remove(other->dependencies[inverse_table[d]], u);
1842 set_remove(u->dependencies[UNIT_REFERENCES], other);
1847 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1852 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1855 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1861 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1865 assert(name || path);
1869 name = path_get_file_name(path);
1871 if (!unit_name_is_template(name)) {
1877 s = unit_name_replace_instance(name, u->instance);
1879 _cleanup_free_ char *i = NULL;
1881 i = unit_name_to_prefix(u->id);
1885 s = unit_name_replace_instance(name, i);
1895 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1898 _cleanup_free_ char *s = NULL;
1901 assert(name || path);
1903 name = resolve_template(u, name, path, &s);
1907 r = manager_load_unit(u->manager, name, path, NULL, &other);
1911 return unit_add_dependency(u, d, other, add_reference);
1914 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1920 assert(name || path);
1922 if (!(name = resolve_template(u, name, path, &s)))
1925 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1928 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1935 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1941 assert(name || path);
1943 if (!(name = resolve_template(u, name, path, &s)))
1946 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1949 r = unit_add_dependency(other, d, u, add_reference);
1956 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1962 assert(name || path);
1964 if (!(name = resolve_template(u, name, path, &s)))
1967 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1970 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1978 int set_unit_path(const char *p) {
1979 _cleanup_free_ char *c = NULL;
1981 /* This is mostly for debug purposes */
1982 c = path_make_absolute_cwd(p);
1983 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
1989 char *unit_dbus_path(Unit *u) {
1995 return unit_dbus_path_from_name(u->id);
1998 char *unit_default_cgroup_path(Unit *u) {
1999 _cleanup_free_ char *escaped = NULL, *slice = NULL;
2004 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2005 return strdup(u->manager->cgroup_root);
2007 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2008 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2013 escaped = cg_escape(u->id);
2018 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2020 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2023 int unit_add_default_slice(Unit *u) {
2024 _cleanup_free_ char *b = NULL;
2025 const char *slice_name;
2031 if (UNIT_ISSET(u->slice))
2034 if (!unit_get_cgroup_context(u))
2038 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2040 /* Implicitly place all instantiated units in their
2041 * own per-template slice */
2043 prefix = unit_name_to_prefix(u->id);
2047 /* The prefix is already escaped, but it might include
2048 * "-" which has a special meaning for slice units,
2049 * hence escape it here extra. */
2050 escaped = strreplace(prefix, "-", "\\x2d");
2054 if (u->manager->running_as == SYSTEMD_SYSTEM)
2055 b = strjoin("system-", escaped, ".slice", NULL);
2057 b = strappend(escaped, ".slice");
2064 u->manager->running_as == SYSTEMD_SYSTEM
2065 ? SPECIAL_SYSTEM_SLICE
2066 : SPECIAL_ROOT_SLICE;
2068 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2072 unit_ref_set(&u->slice, slice);
2076 const char *unit_slice_name(Unit *u) {
2079 if (!UNIT_ISSET(u->slice))
2082 return UNIT_DEREF(u->slice)->id;
2085 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2086 _cleanup_free_ char *t = NULL;
2093 t = unit_name_change_suffix(u->id, type);
2097 assert(!unit_has_name(u, t));
2099 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2100 assert(r < 0 || *_found != u);
2104 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2105 _cleanup_free_ char *t = NULL;
2112 t = unit_name_change_suffix(u->id, type);
2116 assert(!unit_has_name(u, t));
2118 found = manager_get_unit(u->manager, t);
2126 int unit_watch_bus_name(Unit *u, const char *name) {
2130 /* Watch a specific name on the bus. We only support one unit
2131 * watching each name for now. */
2133 return hashmap_put(u->manager->watch_bus, name, u);
2136 void unit_unwatch_bus_name(Unit *u, const char *name) {
2140 hashmap_remove_value(u->manager->watch_bus, name, u);
2143 bool unit_can_serialize(Unit *u) {
2146 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2149 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2156 if (!unit_can_serialize(u))
2159 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2164 if (serialize_jobs) {
2166 fprintf(f, "job\n");
2167 job_serialize(u->job, f, fds);
2171 fprintf(f, "job\n");
2172 job_serialize(u->nop_job, f, fds);
2176 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2177 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2178 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2179 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2180 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2182 if (dual_timestamp_is_set(&u->condition_timestamp))
2183 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2185 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2188 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2195 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2206 va_start(ap, format);
2207 vfprintf(f, format, ap);
2213 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2219 fprintf(f, "%s=%s\n", key, value);
2222 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2229 if (!unit_can_serialize(u))
2233 char line[LINE_MAX], *l, *v;
2236 if (!fgets(line, sizeof(line), f)) {
2249 k = strcspn(l, "=");
2257 if (streq(l, "job")) {
2259 /* new-style serialized job */
2260 Job *j = job_new_raw(u);
2264 r = job_deserialize(j, f, fds);
2270 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2276 r = job_install_deserialized(j);
2278 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2283 if (j->state == JOB_RUNNING)
2284 u->manager->n_running_jobs++;
2287 JobType type = job_type_from_string(v);
2289 log_debug("Failed to parse job type value %s", v);
2291 u->deserialized_job = type;
2294 } else if (streq(l, "inactive-exit-timestamp")) {
2295 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2297 } else if (streq(l, "active-enter-timestamp")) {
2298 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2300 } else if (streq(l, "active-exit-timestamp")) {
2301 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2303 } else if (streq(l, "inactive-enter-timestamp")) {
2304 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2306 } else if (streq(l, "condition-timestamp")) {
2307 dual_timestamp_deserialize(v, &u->condition_timestamp);
2309 } else if (streq(l, "condition-result")) {
2312 b = parse_boolean(v);
2314 log_debug("Failed to parse condition result value %s", v);
2316 u->condition_result = b;
2320 } else if (streq(l, "transient")) {
2323 b = parse_boolean(v);
2325 log_debug("Failed to parse transient bool %s", v);
2330 } else if (streq(l, "cgroup")) {
2337 free(u->cgroup_path);
2340 hashmap_put(u->manager->cgroup_unit, s, u);
2344 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2350 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2360 /* Adds in links to the device node that this unit is based on */
2362 if (!is_device_path(what))
2365 e = unit_name_from_path(what, ".device");
2369 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2374 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2379 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2387 int unit_coldplug(Unit *u) {
2392 if (UNIT_VTABLE(u)->coldplug)
2393 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2397 r = job_coldplug(u->job);
2400 } else if (u->deserialized_job >= 0) {
2402 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2406 u->deserialized_job = _JOB_TYPE_INVALID;
2412 #pragma GCC diagnostic push
2413 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
2414 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2415 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2417 #pragma GCC diagnostic pop
2419 bool unit_need_daemon_reload(Unit *u) {
2420 _cleanup_strv_free_ char **t = NULL;
2423 unsigned loaded_cnt, current_cnt;
2427 if (u->fragment_path) {
2429 if (stat(u->fragment_path, &st) < 0)
2430 /* What, cannot access this anymore? */
2433 if (u->fragment_mtime > 0 &&
2434 timespec_load(&st.st_mtim) != u->fragment_mtime)
2438 if (u->source_path) {
2440 if (stat(u->source_path, &st) < 0)
2443 if (u->source_mtime > 0 &&
2444 timespec_load(&st.st_mtim) != u->source_mtime)
2448 t = unit_find_dropin_paths(u);
2449 loaded_cnt = strv_length(t);
2450 current_cnt = strv_length(u->dropin_paths);
2452 if (loaded_cnt == current_cnt) {
2453 if (loaded_cnt == 0)
2456 if (strv_overlap(u->dropin_paths, t)) {
2457 STRV_FOREACH(path, u->dropin_paths) {
2459 if (stat(*path, &st) < 0)
2462 if (u->dropin_mtime > 0 &&
2463 timespec_load(&st.st_mtim) > u->dropin_mtime)
2474 void unit_reset_failed(Unit *u) {
2477 if (UNIT_VTABLE(u)->reset_failed)
2478 UNIT_VTABLE(u)->reset_failed(u);
2481 Unit *unit_following(Unit *u) {
2484 if (UNIT_VTABLE(u)->following)
2485 return UNIT_VTABLE(u)->following(u);
2490 bool unit_stop_pending(Unit *u) {
2493 /* This call does check the current state of the unit. It's
2494 * hence useful to be called from state change calls of the
2495 * unit itself, where the state isn't updated yet. This is
2496 * different from unit_inactive_or_pending() which checks both
2497 * the current state and for a queued job. */
2499 return u->job && u->job->type == JOB_STOP;
2502 bool unit_inactive_or_pending(Unit *u) {
2505 /* Returns true if the unit is inactive or going down */
2507 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2510 if (unit_stop_pending(u))
2516 bool unit_active_or_pending(Unit *u) {
2519 /* Returns true if the unit is active or going up */
2521 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2525 (u->job->type == JOB_START ||
2526 u->job->type == JOB_RELOAD_OR_START ||
2527 u->job->type == JOB_RESTART))
2533 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2535 assert(w >= 0 && w < _KILL_WHO_MAX);
2537 assert(signo < _NSIG);
2539 if (!UNIT_VTABLE(u)->kill)
2542 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2545 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2549 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2553 /* Exclude the main/control pids from being killed via the cgroup */
2555 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2560 if (control_pid > 0) {
2561 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2573 int unit_kill_common(
2583 if (who == KILL_MAIN && main_pid <= 0) {
2585 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2587 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2591 if (who == KILL_CONTROL && control_pid <= 0) {
2592 if (control_pid < 0)
2593 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2595 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2599 if (who == KILL_CONTROL || who == KILL_ALL)
2600 if (control_pid > 0)
2601 if (kill(control_pid, signo) < 0)
2604 if (who == KILL_MAIN || who == KILL_ALL)
2606 if (kill(main_pid, signo) < 0)
2609 if (who == KILL_ALL && u->cgroup_path) {
2610 _cleanup_set_free_ Set *pid_set = NULL;
2613 /* Exclude the main/control pids from being killed via the cgroup */
2614 pid_set = unit_pid_set(main_pid, control_pid);
2618 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2619 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2626 int unit_following_set(Unit *u, Set **s) {
2630 if (UNIT_VTABLE(u)->following_set)
2631 return UNIT_VTABLE(u)->following_set(u, s);
2637 UnitFileState unit_get_unit_file_state(Unit *u) {
2640 if (u->unit_file_state < 0 && u->fragment_path)
2641 u->unit_file_state = unit_file_get_state(
2642 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2643 NULL, path_get_file_name(u->fragment_path));
2645 return u->unit_file_state;
2648 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2653 unit_ref_unset(ref);
2656 LIST_PREPEND(UnitRef, refs, u->refs, ref);
2660 void unit_ref_unset(UnitRef *ref) {
2666 LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2670 int unit_add_one_mount_link(Unit *u, Mount *m) {
2676 if (u->load_state != UNIT_LOADED ||
2677 UNIT(m)->load_state != UNIT_LOADED)
2680 STRV_FOREACH(i, u->requires_mounts_for) {
2685 if (!path_startswith(*i, m->where))
2688 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2694 int unit_add_mount_links(Unit *u) {
2700 LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2701 r = unit_add_one_mount_link(u, MOUNT(other));
2709 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2716 /* This only copies in the ones that need memory */
2717 for (i = 0; i < RLIMIT_NLIMITS; i++)
2718 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2719 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2724 if (u->manager->running_as == SYSTEMD_USER &&
2725 !c->working_directory) {
2727 r = get_home_dir(&c->working_directory);
2735 ExecContext *unit_get_exec_context(Unit *u) {
2739 offset = UNIT_VTABLE(u)->exec_context_offset;
2743 return (ExecContext*) ((uint8_t*) u + offset);
2746 CGroupContext *unit_get_cgroup_context(Unit *u) {
2749 offset = UNIT_VTABLE(u)->cgroup_context_offset;
2753 return (CGroupContext*) ((uint8_t*) u + offset);
2756 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2757 _cleanup_free_ char *b = NULL;
2765 assert(mode & (UNIT_PERSISTENT|UNIT_RUNTIME));
2767 b = xescape(name, "/.");
2771 if (!filename_is_safe(b))
2774 if (u->manager->running_as == SYSTEMD_USER) {
2775 _cleanup_free_ char *c = NULL;
2777 r = user_config_home(&c);
2783 p = strjoin(c, "/", u->id, ".d", NULL);
2784 } else if (mode & UNIT_PERSISTENT)
2785 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2787 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2791 q = strjoin(p, "/90-", b, ".conf", NULL);
2802 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2803 _cleanup_free_ char *p = NULL, *q = NULL;
2810 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2813 r = drop_in_file(u, mode, name, &p, &q);
2818 return write_string_file_atomic_label(q, data);
2821 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2822 _cleanup_free_ char *p = NULL;
2830 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2833 va_start(ap, format);
2834 r = vasprintf(&p, format, ap);
2840 return unit_write_drop_in(u, mode, name, p);
2843 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2844 _cleanup_free_ char *ndata = NULL;
2850 if (!UNIT_VTABLE(u)->private_section)
2853 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2856 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
2860 return unit_write_drop_in(u, mode, name, ndata);
2863 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2864 _cleanup_free_ char *p = NULL;
2872 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2875 va_start(ap, format);
2876 r = vasprintf(&p, format, ap);
2882 return unit_write_drop_in_private(u, mode, name, p);
2885 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
2886 _cleanup_free_ char *p = NULL, *q = NULL;
2891 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2894 r = drop_in_file(u, mode, name, &p, &q);
2896 r = errno == ENOENT ? 0 : -errno;
2904 int unit_make_transient(Unit *u) {
2909 u->load_state = UNIT_STUB;
2911 u->transient = true;
2913 free(u->fragment_path);
2914 u->fragment_path = NULL;
2916 if (u->manager->running_as == SYSTEMD_USER) {
2917 _cleanup_free_ char *c = NULL;
2919 r = user_config_home(&c);
2925 u->fragment_path = strjoin(c, "/", u->id, NULL);
2926 if (!u->fragment_path)
2931 u->fragment_path = strappend("/run/systemd/system/", u->id);
2932 if (!u->fragment_path)
2935 mkdir_p("/run/systemd/system", 0755);
2938 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
2941 int unit_kill_context(
2947 bool main_pid_alien) {
2949 int sig, wait_for_exit = 0, r;
2954 if (c->kill_mode == KILL_NONE)
2957 sig = sigkill ? SIGKILL : c->kill_signal;
2960 r = kill_and_sigcont(main_pid, sig);
2962 if (r < 0 && r != -ESRCH) {
2963 _cleanup_free_ char *comm = NULL;
2964 get_process_comm(main_pid, &comm);
2966 log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2967 (long) main_pid, strna(comm), strerror(-r));
2969 wait_for_exit = !main_pid_alien;
2972 kill(main_pid, SIGHUP);
2976 if (control_pid > 0) {
2977 r = kill_and_sigcont(control_pid, sig);
2979 if (r < 0 && r != -ESRCH) {
2980 _cleanup_free_ char *comm = NULL;
2981 get_process_comm(control_pid, &comm);
2983 log_warning_unit(u->id,
2984 "Failed to kill control process %li (%s): %s",
2985 (long) control_pid, strna(comm), strerror(-r));
2987 wait_for_exit = true;
2990 kill(control_pid, SIGHUP);
2994 if (c->kill_mode == KILL_CONTROL_GROUP && u->cgroup_path) {
2995 _cleanup_set_free_ Set *pid_set = NULL;
2997 /* Exclude the main/control pids from being killed via the cgroup */
2998 pid_set = unit_pid_set(main_pid, control_pid);
3002 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3004 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3005 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3007 wait_for_exit = true;
3008 if (c->send_sighup) {
3011 pid_set = unit_pid_set(main_pid, control_pid);
3015 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, true, true, false, pid_set);
3020 return wait_for_exit;
3023 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3024 [UNIT_ACTIVE] = "active",
3025 [UNIT_RELOADING] = "reloading",
3026 [UNIT_INACTIVE] = "inactive",
3027 [UNIT_FAILED] = "failed",
3028 [UNIT_ACTIVATING] = "activating",
3029 [UNIT_DEACTIVATING] = "deactivating"
3032 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3034 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3035 [UNIT_REQUIRES] = "Requires",
3036 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3037 [UNIT_REQUISITE] = "Requisite",
3038 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3039 [UNIT_WANTS] = "Wants",
3040 [UNIT_BINDS_TO] = "BindsTo",
3041 [UNIT_PART_OF] = "PartOf",
3042 [UNIT_REQUIRED_BY] = "RequiredBy",
3043 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3044 [UNIT_WANTED_BY] = "WantedBy",
3045 [UNIT_BOUND_BY] = "BoundBy",
3046 [UNIT_CONSISTS_OF] = "ConsistsOf",
3047 [UNIT_CONFLICTS] = "Conflicts",
3048 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3049 [UNIT_BEFORE] = "Before",
3050 [UNIT_AFTER] = "After",
3051 [UNIT_ON_FAILURE] = "OnFailure",
3052 [UNIT_TRIGGERS] = "Triggers",
3053 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3054 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3055 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3056 [UNIT_REFERENCES] = "References",
3057 [UNIT_REFERENCED_BY] = "ReferencedBy",
3060 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);