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) {
193 _cleanup_free_ char *t = NULL;
199 if (unit_name_is_template(name)) {
204 if (!(t = unit_name_replace_instance(name, u->instance)))
210 /* Selects one of the names of this unit as the id */
211 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) {
601 _cleanup_free_ char *s = NULL;
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);
625 Unit* unit_follow_merge(Unit *u) {
628 while (u->load_state == UNIT_MERGED)
629 assert_se(u = u->merged_into);
634 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
640 if (c->std_output != EXEC_OUTPUT_KMSG &&
641 c->std_output != EXEC_OUTPUT_SYSLOG &&
642 c->std_output != EXEC_OUTPUT_JOURNAL &&
643 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
644 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
645 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
646 c->std_error != EXEC_OUTPUT_KMSG &&
647 c->std_error != EXEC_OUTPUT_SYSLOG &&
648 c->std_error != EXEC_OUTPUT_JOURNAL &&
649 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
650 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
651 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
654 /* If syslog or kernel logging is requested, make sure our own
655 * logging daemon is run first. */
657 if (u->manager->running_as == SYSTEMD_SYSTEM) {
658 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
666 const char *unit_description(Unit *u) {
670 return u->description;
675 void unit_dump(Unit *u, FILE *f, const char *prefix) {
679 _cleanup_free_ char *p2 = NULL;
682 timestamp1[FORMAT_TIMESTAMP_MAX],
683 timestamp2[FORMAT_TIMESTAMP_MAX],
684 timestamp3[FORMAT_TIMESTAMP_MAX],
685 timestamp4[FORMAT_TIMESTAMP_MAX],
686 timespan[FORMAT_TIMESPAN_MAX];
690 assert(u->type >= 0);
694 p2 = strappend(prefix, "\t");
695 prefix2 = p2 ? p2 : prefix;
699 "%s\tDescription: %s\n"
701 "%s\tUnit Load State: %s\n"
702 "%s\tUnit Active State: %s\n"
703 "%s\tInactive Exit Timestamp: %s\n"
704 "%s\tActive Enter Timestamp: %s\n"
705 "%s\tActive Exit Timestamp: %s\n"
706 "%s\tInactive Enter Timestamp: %s\n"
707 "%s\tGC Check Good: %s\n"
708 "%s\tNeed Daemon Reload: %s\n"
709 "%s\tTransient: %s\n"
712 "%s\tCGroup realized: %s\n"
713 "%s\tCGroup mask: 0x%x\n",
715 prefix, unit_description(u),
716 prefix, strna(u->instance),
717 prefix, unit_load_state_to_string(u->load_state),
718 prefix, unit_active_state_to_string(unit_active_state(u)),
719 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
720 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
721 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
722 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
723 prefix, yes_no(unit_check_gc(u)),
724 prefix, yes_no(unit_need_daemon_reload(u)),
725 prefix, yes_no(u->transient),
726 prefix, strna(unit_slice_name(u)),
727 prefix, strna(u->cgroup_path),
728 prefix, yes_no(u->cgroup_realized),
729 prefix, u->cgroup_mask);
731 SET_FOREACH(t, u->names, i)
732 fprintf(f, "%s\tName: %s\n", prefix, t);
734 STRV_FOREACH(j, u->documentation)
735 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
737 if ((following = unit_following(u)))
738 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
740 if (u->fragment_path)
741 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
744 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
746 STRV_FOREACH(j, u->dropin_paths)
747 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
749 if (u->job_timeout > 0)
750 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
752 condition_dump_list(u->conditions, f, prefix);
754 if (dual_timestamp_is_set(&u->condition_timestamp))
756 "%s\tCondition Timestamp: %s\n"
757 "%s\tCondition Result: %s\n",
758 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
759 prefix, yes_no(u->condition_result));
761 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
764 SET_FOREACH(other, u->dependencies[d], i)
765 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
768 if (!strv_isempty(u->requires_mounts_for)) {
770 "%s\tRequiresMountsFor:", prefix);
772 STRV_FOREACH(j, u->requires_mounts_for)
773 fprintf(f, " %s", *j);
778 if (u->load_state == UNIT_LOADED) {
781 "%s\tStopWhenUnneeded: %s\n"
782 "%s\tRefuseManualStart: %s\n"
783 "%s\tRefuseManualStop: %s\n"
784 "%s\tDefaultDependencies: %s\n"
785 "%s\tOnFailureIsolate: %s\n"
786 "%s\tIgnoreOnIsolate: %s\n"
787 "%s\tIgnoreOnSnapshot: %s\n",
788 prefix, yes_no(u->stop_when_unneeded),
789 prefix, yes_no(u->refuse_manual_start),
790 prefix, yes_no(u->refuse_manual_stop),
791 prefix, yes_no(u->default_dependencies),
792 prefix, yes_no(u->on_failure_isolate),
793 prefix, yes_no(u->ignore_on_isolate),
794 prefix, yes_no(u->ignore_on_snapshot));
796 if (UNIT_VTABLE(u)->dump)
797 UNIT_VTABLE(u)->dump(u, f, prefix2);
799 } else if (u->load_state == UNIT_MERGED)
801 "%s\tMerged into: %s\n",
802 prefix, u->merged_into->id);
803 else if (u->load_state == UNIT_ERROR)
804 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
808 job_dump(u->job, f, prefix2);
811 job_dump(u->nop_job, f, prefix2);
815 /* Common implementation for multiple backends */
816 int unit_load_fragment_and_dropin(Unit *u) {
821 /* Load a .service file */
822 r = unit_load_fragment(u);
826 if (u->load_state == UNIT_STUB)
829 /* Load drop-in directory data */
830 r = unit_load_dropin(unit_follow_merge(u));
837 /* Common implementation for multiple backends */
838 int unit_load_fragment_and_dropin_optional(Unit *u) {
843 /* Same as unit_load_fragment_and_dropin(), but whether
844 * something can be loaded or not doesn't matter. */
846 /* Load a .service file */
847 r = unit_load_fragment(u);
851 if (u->load_state == UNIT_STUB)
852 u->load_state = UNIT_LOADED;
854 /* Load drop-in directory data */
855 r = unit_load_dropin(unit_follow_merge(u));
862 int unit_add_default_target_dependency(Unit *u, Unit *target) {
866 if (target->type != UNIT_TARGET)
869 /* Only add the dependency if both units are loaded, so that
870 * that loop check below is reliable */
871 if (u->load_state != UNIT_LOADED ||
872 target->load_state != UNIT_LOADED)
875 /* If either side wants no automatic dependencies, then let's
877 if (!u->default_dependencies ||
878 !target->default_dependencies)
881 /* Don't create loops */
882 if (set_get(target->dependencies[UNIT_BEFORE], u))
885 return unit_add_dependency(target, UNIT_AFTER, u, true);
888 static int unit_add_default_dependencies(Unit *u) {
890 static const UnitDependency deps[] = {
892 UNIT_REQUIRED_BY_OVERRIDABLE,
904 for (k = 0; k < ELEMENTSOF(deps); k++)
905 SET_FOREACH(target, u->dependencies[deps[k]], i) {
906 r = unit_add_default_target_dependency(u, target);
911 if (u->default_dependencies && unit_get_cgroup_context(u)) {
912 if (UNIT_ISSET(u->slice))
913 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
915 r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
924 int unit_load(Unit *u) {
929 if (u->in_load_queue) {
930 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
931 u->in_load_queue = false;
934 if (u->type == _UNIT_TYPE_INVALID)
937 if (u->load_state != UNIT_STUB)
940 if (UNIT_VTABLE(u)->load) {
941 r = UNIT_VTABLE(u)->load(u);
946 if (u->load_state == UNIT_STUB) {
951 if (u->load_state == UNIT_LOADED) {
953 if (u->default_dependencies) {
954 r = unit_add_default_dependencies(u);
959 r = unit_add_mount_links(u);
963 if (u->on_failure_isolate &&
964 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
966 log_error_unit(u->id,
967 "More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.", u->id);
974 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
976 unit_add_to_dbus_queue(unit_follow_merge(u));
977 unit_add_to_gc_queue(u);
982 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
984 unit_add_to_dbus_queue(u);
985 unit_add_to_gc_queue(u);
987 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
988 u->id, strerror(-r));
993 bool unit_condition_test(Unit *u) {
996 dual_timestamp_get(&u->condition_timestamp);
997 u->condition_result = condition_test_list(u->id, u->conditions);
999 return u->condition_result;
1002 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1003 const UnitStatusMessageFormats *format_table;
1007 assert(t < _JOB_TYPE_MAX);
1009 if (t != JOB_START && t != JOB_STOP)
1012 format_table = &UNIT_VTABLE(u)->status_message_formats;
1016 return format_table->starting_stopping[t == JOB_STOP];
1019 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1024 assert(t < _JOB_TYPE_MAX);
1026 format = unit_get_status_message_format(u, t);
1030 /* Return generic strings */
1032 return "Starting %s.";
1033 else if (t == JOB_STOP)
1034 return "Stopping %s.";
1035 else if (t == JOB_RELOAD)
1036 return "Reloading %s.";
1041 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1046 /* We only print status messages for selected units on
1047 * selected operations. */
1049 format = unit_get_status_message_format(u, t);
1053 unit_status_printf(u, "", format);
1056 #pragma GCC diagnostic push
1057 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1058 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1065 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1068 if (log_on_console())
1071 /* We log status messages for all units and all operations. */
1073 format = unit_get_status_message_format_try_harder(u, t);
1077 snprintf(buf, sizeof(buf), format, unit_description(u));
1080 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1081 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1082 SD_MESSAGE_UNIT_RELOADING;
1084 log_struct_unit(LOG_INFO,
1090 #pragma GCC diagnostic pop
1093 * -EBADR: This unit type does not support starting.
1094 * -EALREADY: Unit is already started.
1095 * -EAGAIN: An operation is already in progress. Retry later.
1096 * -ECANCELED: Too many requests for now.
1098 int unit_start(Unit *u) {
1099 UnitActiveState state;
1104 if (u->load_state != UNIT_LOADED)
1107 /* If this is already started, then this will succeed. Note
1108 * that this will even succeed if this unit is not startable
1109 * by the user. This is relied on to detect when we need to
1110 * wait for units and when waiting is finished. */
1111 state = unit_active_state(u);
1112 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1115 /* If the conditions failed, don't do anything at all. If we
1116 * already are activating this call might still be useful to
1117 * speed up activation in case there is some hold-off time,
1118 * but we don't want to recheck the condition in that case. */
1119 if (state != UNIT_ACTIVATING &&
1120 !unit_condition_test(u)) {
1121 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1125 /* Forward to the main object, if we aren't it. */
1126 following = unit_following(u);
1128 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1129 u->id, following->id);
1130 return unit_start(following);
1133 unit_status_log_starting_stopping_reloading(u, JOB_START);
1134 unit_status_print_starting_stopping(u, JOB_START);
1136 /* If it is stopped, but we cannot start it, then fail */
1137 if (!UNIT_VTABLE(u)->start)
1140 /* We don't suppress calls to ->start() here when we are
1141 * already starting, to allow this request to be used as a
1142 * "hurry up" call, for example when the unit is in some "auto
1143 * restart" state where it waits for a holdoff timer to elapse
1144 * before it will start again. */
1146 unit_add_to_dbus_queue(u);
1148 return UNIT_VTABLE(u)->start(u);
1151 bool unit_can_start(Unit *u) {
1154 return !!UNIT_VTABLE(u)->start;
1157 bool unit_can_isolate(Unit *u) {
1160 return unit_can_start(u) &&
1165 * -EBADR: This unit type does not support stopping.
1166 * -EALREADY: Unit is already stopped.
1167 * -EAGAIN: An operation is already in progress. Retry later.
1169 int unit_stop(Unit *u) {
1170 UnitActiveState state;
1175 state = unit_active_state(u);
1176 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1179 if ((following = unit_following(u))) {
1180 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1181 u->id, following->id);
1182 return unit_stop(following);
1185 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1186 unit_status_print_starting_stopping(u, JOB_STOP);
1188 if (!UNIT_VTABLE(u)->stop)
1191 unit_add_to_dbus_queue(u);
1193 return UNIT_VTABLE(u)->stop(u);
1197 * -EBADR: This unit type does not support reloading.
1198 * -ENOEXEC: Unit is not started.
1199 * -EAGAIN: An operation is already in progress. Retry later.
1201 int unit_reload(Unit *u) {
1202 UnitActiveState state;
1207 if (u->load_state != UNIT_LOADED)
1210 if (!unit_can_reload(u))
1213 state = unit_active_state(u);
1214 if (state == UNIT_RELOADING)
1217 if (state != UNIT_ACTIVE)
1220 if ((following = unit_following(u))) {
1221 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1222 u->id, following->id);
1223 return unit_reload(following);
1226 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1228 unit_add_to_dbus_queue(u);
1229 return UNIT_VTABLE(u)->reload(u);
1232 bool unit_can_reload(Unit *u) {
1235 if (!UNIT_VTABLE(u)->reload)
1238 if (!UNIT_VTABLE(u)->can_reload)
1241 return UNIT_VTABLE(u)->can_reload(u);
1244 static void unit_check_unneeded(Unit *u) {
1250 /* If this service shall be shut down when unneeded then do
1253 if (!u->stop_when_unneeded)
1256 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1259 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1260 if (unit_active_or_pending(other))
1263 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1264 if (unit_active_or_pending(other))
1267 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1268 if (unit_active_or_pending(other))
1271 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1272 if (unit_active_or_pending(other))
1275 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1277 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1278 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1281 static void retroactively_start_dependencies(Unit *u) {
1286 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1288 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1289 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1290 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1291 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1293 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1294 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1295 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1296 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1298 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1299 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1300 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1301 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1303 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1304 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1305 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1306 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1308 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1309 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1310 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1312 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1313 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1314 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1317 static void retroactively_stop_dependencies(Unit *u) {
1322 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1324 /* Pull down units which are bound to us recursively if enabled */
1325 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1326 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1327 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1330 static void check_unneeded_dependencies(Unit *u) {
1335 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1337 /* Garbage collect services that might not be needed anymore, if enabled */
1338 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1339 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1340 unit_check_unneeded(other);
1341 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1342 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1343 unit_check_unneeded(other);
1344 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1345 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1346 unit_check_unneeded(other);
1347 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1348 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1349 unit_check_unneeded(other);
1350 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1351 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1352 unit_check_unneeded(other);
1353 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1354 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1355 unit_check_unneeded(other);
1358 void unit_start_on_failure(Unit *u) {
1364 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1367 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1369 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1372 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL);
1374 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1378 void unit_trigger_notify(Unit *u) {
1384 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1385 if (UNIT_VTABLE(other)->trigger_notify)
1386 UNIT_VTABLE(other)->trigger_notify(other, u);
1389 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1394 assert(os < _UNIT_ACTIVE_STATE_MAX);
1395 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1397 /* Note that this is called for all low-level state changes,
1398 * even if they might map to the same high-level
1399 * UnitActiveState! That means that ns == os is OK an expected
1400 * behavior here. For example: if a mount point is remounted
1401 * this function will be called too! */
1405 if (m->n_reloading <= 0) {
1408 dual_timestamp_get(&ts);
1410 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1411 u->inactive_exit_timestamp = ts;
1412 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1413 u->inactive_enter_timestamp = ts;
1415 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1416 u->active_enter_timestamp = ts;
1417 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1418 u->active_exit_timestamp = ts;
1421 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1422 unit_destroy_cgroup(u);
1424 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1425 ExecContext *ec = unit_get_exec_context(u);
1426 if (ec && exec_context_may_touch_console(ec)) {
1427 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1430 if (m->n_on_console == 0)
1431 /* unset no_console_output flag, since the console is free */
1432 m->no_console_output = 0;
1441 if (u->job->state == JOB_WAITING)
1443 /* So we reached a different state for this
1444 * job. Let's see if we can run it now if it
1445 * failed previously due to EAGAIN. */
1446 job_add_to_run_queue(u->job);
1448 /* Let's check whether this state change constitutes a
1449 * finished job, or maybe contradicts a running job and
1450 * hence needs to invalidate jobs. */
1452 switch (u->job->type) {
1455 case JOB_VERIFY_ACTIVE:
1457 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1458 job_finish_and_invalidate(u->job, JOB_DONE, true);
1459 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1462 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1463 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1469 case JOB_RELOAD_OR_START:
1471 if (u->job->state == JOB_RUNNING) {
1472 if (ns == UNIT_ACTIVE)
1473 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1474 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1477 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1478 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1486 case JOB_TRY_RESTART:
1488 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1489 job_finish_and_invalidate(u->job, JOB_DONE, true);
1490 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1492 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1498 assert_not_reached("Job type unknown");
1504 if (m->n_reloading <= 0) {
1506 /* If this state change happened without being
1507 * requested by a job, then let's retroactively start
1508 * or stop dependencies. We skip that step when
1509 * deserializing, since we don't want to create any
1510 * additional jobs just because something is already
1514 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1515 retroactively_start_dependencies(u);
1516 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1517 retroactively_stop_dependencies(u);
1520 /* stop unneeded units regardless if going down was expected or not */
1521 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1522 check_unneeded_dependencies(u);
1524 if (ns != os && ns == UNIT_FAILED) {
1525 log_notice_unit(u->id,
1526 "Unit %s entered failed state.", u->id);
1527 unit_start_on_failure(u);
1531 /* Some names are special */
1532 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1534 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1535 /* The bus just might have become available,
1536 * hence try to connect to it, if we aren't
1540 if (u->type == UNIT_SERVICE &&
1541 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1542 m->n_reloading <= 0) {
1543 /* Write audit record if we have just finished starting up */
1544 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1548 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1549 manager_send_unit_plymouth(m, u);
1553 /* We don't care about D-Bus here, since we'll get an
1554 * asynchronous notification for it anyway. */
1556 if (u->type == UNIT_SERVICE &&
1557 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1558 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1559 m->n_reloading <= 0) {
1561 /* Hmm, if there was no start record written
1562 * write it now, so that we always have a nice
1565 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1567 if (ns == UNIT_INACTIVE)
1568 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1570 /* Write audit record if we have just finished shutting down */
1571 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1573 u->in_audit = false;
1577 manager_recheck_journal(m);
1578 unit_trigger_notify(u);
1580 /* Maybe we finished startup and are now ready for being
1581 * stopped because unneeded? */
1582 if (u->manager->n_reloading <= 0)
1583 unit_check_unneeded(u);
1585 unit_add_to_dbus_queue(u);
1586 unit_add_to_gc_queue(u);
1589 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1590 struct epoll_event ev = {
1598 assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1600 if (epoll_ctl(u->manager->epoll_fd,
1601 w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1613 void unit_unwatch_fd(Unit *u, Watch *w) {
1617 if (w->type == WATCH_INVALID)
1620 assert(w->type == WATCH_FD);
1621 assert(w->data.unit == u);
1622 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1625 w->type = WATCH_INVALID;
1626 w->data.unit = NULL;
1629 int unit_watch_pid(Unit *u, pid_t pid) {
1633 /* Watch a specific PID. We only support one unit watching
1634 * each PID for now. */
1636 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1639 void unit_unwatch_pid(Unit *u, pid_t pid) {
1643 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1646 int unit_watch_timer(Unit *u, clockid_t clock_id, bool relative, usec_t usec, Watch *w) {
1647 struct itimerspec its = {};
1653 assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1655 /* This will try to reuse the old timer if there is one */
1657 if (w->type == WATCH_UNIT_TIMER) {
1658 assert(w->data.unit == u);
1663 } else if (w->type == WATCH_INVALID) {
1666 fd = timerfd_create(clock_id, TFD_NONBLOCK|TFD_CLOEXEC);
1670 assert_not_reached("Invalid watch type");
1673 /* Set absolute time in the past, but not 0, since we
1674 * don't want to disarm the timer */
1675 its.it_value.tv_sec = 0;
1676 its.it_value.tv_nsec = 1;
1678 flags = TFD_TIMER_ABSTIME;
1680 timespec_store(&its.it_value, usec);
1681 flags = relative ? 0 : TFD_TIMER_ABSTIME;
1684 /* This will also flush the elapse counter */
1685 if (timerfd_settime(fd, flags, &its, NULL) < 0)
1688 if (w->type == WATCH_INVALID) {
1689 struct epoll_event ev = {
1694 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1698 w->type = WATCH_UNIT_TIMER;
1706 close_nointr_nofail(fd);
1711 void unit_unwatch_timer(Unit *u, Watch *w) {
1715 if (w->type == WATCH_INVALID)
1718 assert(w->type == WATCH_UNIT_TIMER);
1719 assert(w->data.unit == u);
1722 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1723 close_nointr_nofail(w->fd);
1726 w->type = WATCH_INVALID;
1727 w->data.unit = NULL;
1730 bool unit_job_is_applicable(Unit *u, JobType j) {
1732 assert(j >= 0 && j < _JOB_TYPE_MAX);
1736 case JOB_VERIFY_ACTIVE:
1743 case JOB_TRY_RESTART:
1744 return unit_can_start(u);
1747 return unit_can_reload(u);
1749 case JOB_RELOAD_OR_START:
1750 return unit_can_reload(u) && unit_can_start(u);
1753 assert_not_reached("Invalid job type");
1757 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1759 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1760 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1761 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1762 [UNIT_WANTS] = UNIT_WANTED_BY,
1763 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1764 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1765 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1766 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1767 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1768 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1769 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1770 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1771 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1772 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1773 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1774 [UNIT_BEFORE] = UNIT_AFTER,
1775 [UNIT_AFTER] = UNIT_BEFORE,
1776 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1777 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1778 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1779 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1780 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1781 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1782 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1784 int r, q = 0, v = 0, w = 0;
1787 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1790 u = unit_follow_merge(u);
1791 other = unit_follow_merge(other);
1793 /* We won't allow dependencies on ourselves. We will not
1794 * consider them an error however. */
1798 if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1801 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1802 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1806 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1807 (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1810 if ((q = set_put(u->dependencies[d], other)) < 0)
1813 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1814 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1819 if (add_reference) {
1820 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1825 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1829 unit_add_to_dbus_queue(u);
1834 set_remove(u->dependencies[d], other);
1837 set_remove(other->dependencies[inverse_table[d]], u);
1840 set_remove(u->dependencies[UNIT_REFERENCES], other);
1845 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1850 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1853 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1859 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1863 assert(name || path);
1867 name = path_get_file_name(path);
1869 if (!unit_name_is_template(name)) {
1875 s = unit_name_replace_instance(name, u->instance);
1877 _cleanup_free_ char *i = NULL;
1879 i = unit_name_to_prefix(u->id);
1883 s = unit_name_replace_instance(name, i);
1893 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1896 _cleanup_free_ char *s = NULL;
1899 assert(name || path);
1901 name = resolve_template(u, name, path, &s);
1905 r = manager_load_unit(u->manager, name, path, NULL, &other);
1909 return unit_add_dependency(u, d, other, add_reference);
1912 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1915 _cleanup_free_ char *s = NULL;
1918 assert(name || path);
1920 if (!(name = resolve_template(u, name, path, &s)))
1923 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1926 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1931 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1934 _cleanup_free_ char *s = NULL;
1937 assert(name || path);
1939 if (!(name = resolve_template(u, name, path, &s)))
1942 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1945 r = unit_add_dependency(other, d, u, add_reference);
1950 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1953 _cleanup_free_ char *s = NULL;
1956 assert(name || path);
1958 if (!(name = resolve_template(u, name, path, &s)))
1961 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1964 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1970 int set_unit_path(const char *p) {
1971 _cleanup_free_ char *c = NULL;
1973 /* This is mostly for debug purposes */
1974 c = path_make_absolute_cwd(p);
1975 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
1981 char *unit_dbus_path(Unit *u) {
1987 return unit_dbus_path_from_name(u->id);
1990 char *unit_default_cgroup_path(Unit *u) {
1991 _cleanup_free_ char *escaped = NULL, *slice = NULL;
1996 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
1997 return strdup(u->manager->cgroup_root);
1999 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2000 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2005 escaped = cg_escape(u->id);
2010 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2012 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2015 int unit_add_default_slice(Unit *u) {
2016 _cleanup_free_ char *b = NULL;
2017 const char *slice_name;
2023 if (UNIT_ISSET(u->slice))
2026 if (!unit_get_cgroup_context(u))
2030 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2032 /* Implicitly place all instantiated units in their
2033 * own per-template slice */
2035 prefix = unit_name_to_prefix(u->id);
2039 /* The prefix is already escaped, but it might include
2040 * "-" which has a special meaning for slice units,
2041 * hence escape it here extra. */
2042 escaped = strreplace(prefix, "-", "\\x2d");
2046 if (u->manager->running_as == SYSTEMD_SYSTEM)
2047 b = strjoin("system-", escaped, ".slice", NULL);
2049 b = strappend(escaped, ".slice");
2056 u->manager->running_as == SYSTEMD_SYSTEM
2057 ? SPECIAL_SYSTEM_SLICE
2058 : SPECIAL_ROOT_SLICE;
2060 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2064 unit_ref_set(&u->slice, slice);
2068 const char *unit_slice_name(Unit *u) {
2071 if (!UNIT_ISSET(u->slice))
2074 return UNIT_DEREF(u->slice)->id;
2077 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2078 _cleanup_free_ char *t = NULL;
2085 t = unit_name_change_suffix(u->id, type);
2089 assert(!unit_has_name(u, t));
2091 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2092 assert(r < 0 || *_found != u);
2096 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2097 _cleanup_free_ char *t = NULL;
2104 t = unit_name_change_suffix(u->id, type);
2108 assert(!unit_has_name(u, t));
2110 found = manager_get_unit(u->manager, t);
2118 int unit_watch_bus_name(Unit *u, const char *name) {
2122 /* Watch a specific name on the bus. We only support one unit
2123 * watching each name for now. */
2125 return hashmap_put(u->manager->watch_bus, name, u);
2128 void unit_unwatch_bus_name(Unit *u, const char *name) {
2132 hashmap_remove_value(u->manager->watch_bus, name, u);
2135 bool unit_can_serialize(Unit *u) {
2138 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2141 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2148 if (!unit_can_serialize(u))
2151 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2156 if (serialize_jobs) {
2158 fprintf(f, "job\n");
2159 job_serialize(u->job, f, fds);
2163 fprintf(f, "job\n");
2164 job_serialize(u->nop_job, f, fds);
2168 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2169 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2170 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2171 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2172 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2174 if (dual_timestamp_is_set(&u->condition_timestamp))
2175 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2177 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2180 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2187 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2198 va_start(ap, format);
2199 vfprintf(f, format, ap);
2205 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2211 fprintf(f, "%s=%s\n", key, value);
2214 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2221 if (!unit_can_serialize(u))
2225 char line[LINE_MAX], *l, *v;
2228 if (!fgets(line, sizeof(line), f)) {
2241 k = strcspn(l, "=");
2249 if (streq(l, "job")) {
2251 /* new-style serialized job */
2252 Job *j = job_new_raw(u);
2256 r = job_deserialize(j, f, fds);
2262 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2268 r = job_install_deserialized(j);
2270 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2275 if (j->state == JOB_RUNNING)
2276 u->manager->n_running_jobs++;
2279 JobType type = job_type_from_string(v);
2281 log_debug("Failed to parse job type value %s", v);
2283 u->deserialized_job = type;
2286 } else if (streq(l, "inactive-exit-timestamp")) {
2287 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2289 } else if (streq(l, "active-enter-timestamp")) {
2290 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2292 } else if (streq(l, "active-exit-timestamp")) {
2293 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2295 } else if (streq(l, "inactive-enter-timestamp")) {
2296 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2298 } else if (streq(l, "condition-timestamp")) {
2299 dual_timestamp_deserialize(v, &u->condition_timestamp);
2301 } else if (streq(l, "condition-result")) {
2304 b = parse_boolean(v);
2306 log_debug("Failed to parse condition result value %s", v);
2308 u->condition_result = b;
2312 } else if (streq(l, "transient")) {
2315 b = parse_boolean(v);
2317 log_debug("Failed to parse transient bool %s", v);
2322 } else if (streq(l, "cgroup")) {
2329 free(u->cgroup_path);
2332 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2336 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2342 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2344 _cleanup_free_ char *e = NULL;
2352 /* Adds in links to the device node that this unit is based on */
2354 if (!is_device_path(what))
2357 e = unit_name_from_path(what, ".device");
2361 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2366 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2371 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2379 int unit_coldplug(Unit *u) {
2384 if (UNIT_VTABLE(u)->coldplug)
2385 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2389 r = job_coldplug(u->job);
2392 } else if (u->deserialized_job >= 0) {
2394 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2398 u->deserialized_job = _JOB_TYPE_INVALID;
2404 #pragma GCC diagnostic push
2405 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
2406 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2407 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2409 #pragma GCC diagnostic pop
2411 bool unit_need_daemon_reload(Unit *u) {
2412 _cleanup_strv_free_ char **t = NULL;
2415 unsigned loaded_cnt, current_cnt;
2419 if (u->fragment_path) {
2421 if (stat(u->fragment_path, &st) < 0)
2422 /* What, cannot access this anymore? */
2425 if (u->fragment_mtime > 0 &&
2426 timespec_load(&st.st_mtim) != u->fragment_mtime)
2430 if (u->source_path) {
2432 if (stat(u->source_path, &st) < 0)
2435 if (u->source_mtime > 0 &&
2436 timespec_load(&st.st_mtim) != u->source_mtime)
2440 t = unit_find_dropin_paths(u);
2441 loaded_cnt = strv_length(t);
2442 current_cnt = strv_length(u->dropin_paths);
2444 if (loaded_cnt == current_cnt) {
2445 if (loaded_cnt == 0)
2448 if (strv_overlap(u->dropin_paths, t)) {
2449 STRV_FOREACH(path, u->dropin_paths) {
2451 if (stat(*path, &st) < 0)
2454 if (u->dropin_mtime > 0 &&
2455 timespec_load(&st.st_mtim) > u->dropin_mtime)
2466 void unit_reset_failed(Unit *u) {
2469 if (UNIT_VTABLE(u)->reset_failed)
2470 UNIT_VTABLE(u)->reset_failed(u);
2473 Unit *unit_following(Unit *u) {
2476 if (UNIT_VTABLE(u)->following)
2477 return UNIT_VTABLE(u)->following(u);
2482 bool unit_stop_pending(Unit *u) {
2485 /* This call does check the current state of the unit. It's
2486 * hence useful to be called from state change calls of the
2487 * unit itself, where the state isn't updated yet. This is
2488 * different from unit_inactive_or_pending() which checks both
2489 * the current state and for a queued job. */
2491 return u->job && u->job->type == JOB_STOP;
2494 bool unit_inactive_or_pending(Unit *u) {
2497 /* Returns true if the unit is inactive or going down */
2499 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2502 if (unit_stop_pending(u))
2508 bool unit_active_or_pending(Unit *u) {
2511 /* Returns true if the unit is active or going up */
2513 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2517 (u->job->type == JOB_START ||
2518 u->job->type == JOB_RELOAD_OR_START ||
2519 u->job->type == JOB_RESTART))
2525 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2527 assert(w >= 0 && w < _KILL_WHO_MAX);
2529 assert(signo < _NSIG);
2531 if (!UNIT_VTABLE(u)->kill)
2534 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2537 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2541 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2545 /* Exclude the main/control pids from being killed via the cgroup */
2547 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2552 if (control_pid > 0) {
2553 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2565 int unit_kill_common(
2575 if (who == KILL_MAIN && main_pid <= 0) {
2577 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2579 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2583 if (who == KILL_CONTROL && control_pid <= 0) {
2584 if (control_pid < 0)
2585 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2587 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2591 if (who == KILL_CONTROL || who == KILL_ALL)
2592 if (control_pid > 0)
2593 if (kill(control_pid, signo) < 0)
2596 if (who == KILL_MAIN || who == KILL_ALL)
2598 if (kill(main_pid, signo) < 0)
2601 if (who == KILL_ALL && u->cgroup_path) {
2602 _cleanup_set_free_ Set *pid_set = NULL;
2605 /* Exclude the main/control pids from being killed via the cgroup */
2606 pid_set = unit_pid_set(main_pid, control_pid);
2610 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2611 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2618 int unit_following_set(Unit *u, Set **s) {
2622 if (UNIT_VTABLE(u)->following_set)
2623 return UNIT_VTABLE(u)->following_set(u, s);
2629 UnitFileState unit_get_unit_file_state(Unit *u) {
2632 if (u->unit_file_state < 0 && u->fragment_path)
2633 u->unit_file_state = unit_file_get_state(
2634 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2635 NULL, path_get_file_name(u->fragment_path));
2637 return u->unit_file_state;
2640 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2645 unit_ref_unset(ref);
2648 LIST_PREPEND(UnitRef, refs, u->refs, ref);
2652 void unit_ref_unset(UnitRef *ref) {
2658 LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2662 int unit_add_one_mount_link(Unit *u, Mount *m) {
2668 if (u->load_state != UNIT_LOADED ||
2669 UNIT(m)->load_state != UNIT_LOADED)
2672 STRV_FOREACH(i, u->requires_mounts_for) {
2677 if (!path_startswith(*i, m->where))
2680 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2686 int unit_add_mount_links(Unit *u) {
2692 LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2693 r = unit_add_one_mount_link(u, MOUNT(other));
2701 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2708 /* This only copies in the ones that need memory */
2709 for (i = 0; i < RLIMIT_NLIMITS; i++)
2710 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2711 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2716 if (u->manager->running_as == SYSTEMD_USER &&
2717 !c->working_directory) {
2719 r = get_home_dir(&c->working_directory);
2727 ExecContext *unit_get_exec_context(Unit *u) {
2731 offset = UNIT_VTABLE(u)->exec_context_offset;
2735 return (ExecContext*) ((uint8_t*) u + offset);
2738 CGroupContext *unit_get_cgroup_context(Unit *u) {
2741 offset = UNIT_VTABLE(u)->cgroup_context_offset;
2745 return (CGroupContext*) ((uint8_t*) u + offset);
2748 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2749 _cleanup_free_ char *b = NULL;
2757 assert(mode & (UNIT_PERSISTENT|UNIT_RUNTIME));
2759 b = xescape(name, "/.");
2763 if (!filename_is_safe(b))
2766 if (u->manager->running_as == SYSTEMD_USER) {
2767 _cleanup_free_ char *c = NULL;
2769 r = user_config_home(&c);
2775 p = strjoin(c, "/", u->id, ".d", NULL);
2776 } else if (mode & UNIT_PERSISTENT)
2777 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2779 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2783 q = strjoin(p, "/90-", b, ".conf", NULL);
2794 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2795 _cleanup_free_ char *p = NULL, *q = NULL;
2802 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2805 r = drop_in_file(u, mode, name, &p, &q);
2810 return write_string_file_atomic_label(q, data);
2813 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2814 _cleanup_free_ char *p = NULL;
2822 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2825 va_start(ap, format);
2826 r = vasprintf(&p, format, ap);
2832 return unit_write_drop_in(u, mode, name, p);
2835 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2836 _cleanup_free_ char *ndata = NULL;
2842 if (!UNIT_VTABLE(u)->private_section)
2845 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2848 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
2852 return unit_write_drop_in(u, mode, name, ndata);
2855 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2856 _cleanup_free_ char *p = NULL;
2864 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2867 va_start(ap, format);
2868 r = vasprintf(&p, format, ap);
2874 return unit_write_drop_in_private(u, mode, name, p);
2877 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
2878 _cleanup_free_ char *p = NULL, *q = NULL;
2883 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2886 r = drop_in_file(u, mode, name, &p, &q);
2888 r = errno == ENOENT ? 0 : -errno;
2896 int unit_make_transient(Unit *u) {
2901 u->load_state = UNIT_STUB;
2903 u->transient = true;
2905 free(u->fragment_path);
2906 u->fragment_path = NULL;
2908 if (u->manager->running_as == SYSTEMD_USER) {
2909 _cleanup_free_ char *c = NULL;
2911 r = user_config_home(&c);
2917 u->fragment_path = strjoin(c, "/", u->id, NULL);
2918 if (!u->fragment_path)
2923 u->fragment_path = strappend("/run/systemd/system/", u->id);
2924 if (!u->fragment_path)
2927 mkdir_p("/run/systemd/system", 0755);
2930 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
2933 int unit_kill_context(
2939 bool main_pid_alien) {
2941 int sig, wait_for_exit = 0, r;
2946 if (c->kill_mode == KILL_NONE)
2949 sig = sigkill ? SIGKILL : c->kill_signal;
2952 r = kill_and_sigcont(main_pid, sig);
2954 if (r < 0 && r != -ESRCH) {
2955 _cleanup_free_ char *comm = NULL;
2956 get_process_comm(main_pid, &comm);
2958 log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2959 (long) main_pid, strna(comm), strerror(-r));
2961 wait_for_exit = !main_pid_alien;
2964 kill(main_pid, SIGHUP);
2968 if (control_pid > 0) {
2969 r = kill_and_sigcont(control_pid, sig);
2971 if (r < 0 && r != -ESRCH) {
2972 _cleanup_free_ char *comm = NULL;
2973 get_process_comm(control_pid, &comm);
2975 log_warning_unit(u->id,
2976 "Failed to kill control process %li (%s): %s",
2977 (long) control_pid, strna(comm), strerror(-r));
2979 wait_for_exit = true;
2982 kill(control_pid, SIGHUP);
2986 if (c->kill_mode == KILL_CONTROL_GROUP && u->cgroup_path) {
2987 _cleanup_set_free_ Set *pid_set = NULL;
2989 /* Exclude the main/control pids from being killed via the cgroup */
2990 pid_set = unit_pid_set(main_pid, control_pid);
2994 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
2996 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
2997 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
2999 wait_for_exit = true;
3000 if (c->send_sighup) {
3003 pid_set = unit_pid_set(main_pid, control_pid);
3007 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, true, true, false, pid_set);
3012 return wait_for_exit;
3015 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3016 [UNIT_ACTIVE] = "active",
3017 [UNIT_RELOADING] = "reloading",
3018 [UNIT_INACTIVE] = "inactive",
3019 [UNIT_FAILED] = "failed",
3020 [UNIT_ACTIVATING] = "activating",
3021 [UNIT_DEACTIVATING] = "deactivating"
3024 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3026 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3027 [UNIT_REQUIRES] = "Requires",
3028 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3029 [UNIT_REQUISITE] = "Requisite",
3030 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3031 [UNIT_WANTS] = "Wants",
3032 [UNIT_BINDS_TO] = "BindsTo",
3033 [UNIT_PART_OF] = "PartOf",
3034 [UNIT_REQUIRED_BY] = "RequiredBy",
3035 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3036 [UNIT_WANTED_BY] = "WantedBy",
3037 [UNIT_BOUND_BY] = "BoundBy",
3038 [UNIT_CONSISTS_OF] = "ConsistsOf",
3039 [UNIT_CONFLICTS] = "Conflicts",
3040 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3041 [UNIT_BEFORE] = "Before",
3042 [UNIT_AFTER] = "After",
3043 [UNIT_ON_FAILURE] = "OnFailure",
3044 [UNIT_TRIGGERS] = "Triggers",
3045 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3046 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3047 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3048 [UNIT_REFERENCES] = "References",
3049 [UNIT_REFERENCED_BY] = "ReferencedBy",
3052 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);