1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
25 #include <sys/epoll.h>
26 #include <sys/timerfd.h>
33 #include "sd-messages.h"
38 #include "path-util.h"
39 #include "load-fragment.h"
40 #include "load-dropin.h"
42 #include "unit-name.h"
43 #include "dbus-unit.h"
45 #include "cgroup-util.h"
49 #include "fileio-label.h"
50 #include "bus-errors.h"
54 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
55 [UNIT_SERVICE] = &service_vtable,
56 [UNIT_SOCKET] = &socket_vtable,
57 [UNIT_BUSNAME] = &busname_vtable,
58 [UNIT_TARGET] = &target_vtable,
59 [UNIT_SNAPSHOT] = &snapshot_vtable,
60 [UNIT_DEVICE] = &device_vtable,
61 [UNIT_MOUNT] = &mount_vtable,
62 [UNIT_AUTOMOUNT] = &automount_vtable,
63 [UNIT_SWAP] = &swap_vtable,
64 [UNIT_TIMER] = &timer_vtable,
65 [UNIT_PATH] = &path_vtable,
66 [UNIT_SLICE] = &slice_vtable,
67 [UNIT_SCOPE] = &scope_vtable
70 Unit *unit_new(Manager *m, size_t size) {
74 assert(size >= sizeof(Unit));
80 u->names = set_new(string_hash_func, string_compare_func);
87 u->type = _UNIT_TYPE_INVALID;
88 u->deserialized_job = _JOB_TYPE_INVALID;
89 u->default_dependencies = true;
90 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
91 u->on_failure_job_mode = JOB_REPLACE;
96 bool unit_has_name(Unit *u, const char *name) {
100 return !!set_get(u->names, (char*) name);
103 int unit_add_name(Unit *u, const char *text) {
111 if (unit_name_is_template(text)) {
115 s = unit_name_replace_instance(text, u->instance);
122 if (!unit_name_is_valid(s, false)) {
127 assert_se((t = unit_name_to_type(s)) >= 0);
129 if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
134 r = unit_name_to_instance(s, &i);
138 if (i && unit_vtable[t]->no_instances) {
143 /* Ensure that this unit is either instanced or not instanced,
145 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
150 if (unit_vtable[t]->no_alias &&
151 !set_isempty(u->names) &&
152 !set_get(u->names, s)) {
157 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
162 r = set_put(u->names, s);
169 r = hashmap_put(u->manager->units, s, u);
171 set_remove(u->names, s);
175 if (u->type == _UNIT_TYPE_INVALID) {
181 LIST_PREPEND(units_by_type, u->manager->units_by_type[t], u);
183 if (UNIT_VTABLE(u)->init)
184 UNIT_VTABLE(u)->init(u);
188 unit_add_to_dbus_queue(u);
198 int unit_choose_id(Unit *u, const char *name) {
200 _cleanup_free_ char *t = NULL;
206 if (unit_name_is_template(name)) {
211 t = unit_name_replace_instance(name, u->instance);
218 /* Selects one of the names of this unit as the id */
219 s = set_get(u->names, (char*) name);
224 r = unit_name_to_instance(s, &i);
233 unit_add_to_dbus_queue(u);
238 int unit_set_description(Unit *u, const char *description) {
243 if (isempty(description))
246 s = strdup(description);
251 free(u->description);
254 unit_add_to_dbus_queue(u);
258 bool unit_check_gc(Unit *u) {
261 if (u->load_state == UNIT_STUB)
264 if (UNIT_VTABLE(u)->no_gc)
276 if (unit_active_state(u) != UNIT_INACTIVE)
282 if (UNIT_VTABLE(u)->check_gc)
283 if (UNIT_VTABLE(u)->check_gc(u))
289 void unit_add_to_load_queue(Unit *u) {
291 assert(u->type != _UNIT_TYPE_INVALID);
293 if (u->load_state != UNIT_STUB || u->in_load_queue)
296 LIST_PREPEND(load_queue, u->manager->load_queue, u);
297 u->in_load_queue = true;
300 void unit_add_to_cleanup_queue(Unit *u) {
303 if (u->in_cleanup_queue)
306 LIST_PREPEND(cleanup_queue, u->manager->cleanup_queue, u);
307 u->in_cleanup_queue = true;
310 void unit_add_to_gc_queue(Unit *u) {
313 if (u->in_gc_queue || u->in_cleanup_queue)
316 if (unit_check_gc(u))
319 LIST_PREPEND(gc_queue, u->manager->gc_queue, u);
320 u->in_gc_queue = true;
322 u->manager->n_in_gc_queue ++;
325 void unit_add_to_dbus_queue(Unit *u) {
327 assert(u->type != _UNIT_TYPE_INVALID);
329 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
332 /* Shortcut things if nobody cares */
333 if (set_isempty(u->manager->subscribed)) {
334 u->sent_dbus_new_signal = true;
338 LIST_PREPEND(dbus_queue, u->manager->dbus_unit_queue, u);
339 u->in_dbus_queue = true;
342 static void bidi_set_free(Unit *u, Set *s) {
348 /* Frees the set and makes sure we are dropped from the
349 * inverse pointers */
351 SET_FOREACH(other, s, i) {
354 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
355 set_remove(other->dependencies[d], u);
357 unit_add_to_gc_queue(other);
363 static void unit_remove_transient(Unit *u) {
371 if (u->fragment_path)
372 unlink(u->fragment_path);
374 STRV_FOREACH(i, u->dropin_paths) {
375 _cleanup_free_ char *p = NULL;
380 r = path_get_parent(*i, &p);
386 static void unit_free_requires_mounts_for(Unit *u) {
389 STRV_FOREACH(j, u->requires_mounts_for) {
390 char s[strlen(*j) + 1];
392 PATH_FOREACH_PREFIX_MORE(s, *j) {
396 x = hashmap_get2(u->manager->units_requiring_mounts_for, s, (void**) &y);
402 if (set_isempty(x)) {
403 hashmap_remove(u->manager->units_requiring_mounts_for, y);
410 strv_free(u->requires_mounts_for);
411 u->requires_mounts_for = NULL;
414 void unit_free(Unit *u) {
421 if (u->manager->n_reloading <= 0)
422 unit_remove_transient(u);
424 bus_unit_send_removed_signal(u);
426 if (u->load_state != UNIT_STUB)
427 if (UNIT_VTABLE(u)->done)
428 UNIT_VTABLE(u)->done(u);
430 unit_free_requires_mounts_for(u);
432 SET_FOREACH(t, u->names, i)
433 hashmap_remove_value(u->manager->units, t, u);
447 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
448 bidi_set_free(u, u->dependencies[d]);
450 if (u->type != _UNIT_TYPE_INVALID)
451 LIST_REMOVE(units_by_type, u->manager->units_by_type[u->type], u);
453 if (u->in_load_queue)
454 LIST_REMOVE(load_queue, u->manager->load_queue, u);
456 if (u->in_dbus_queue)
457 LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
459 if (u->in_cleanup_queue)
460 LIST_REMOVE(cleanup_queue, u->manager->cleanup_queue, u);
462 if (u->in_gc_queue) {
463 LIST_REMOVE(gc_queue, u->manager->gc_queue, u);
464 u->manager->n_in_gc_queue--;
467 if (u->in_cgroup_queue)
468 LIST_REMOVE(cgroup_queue, u->manager->cgroup_queue, u);
470 if (u->cgroup_path) {
471 hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
472 free(u->cgroup_path);
475 free(u->description);
476 strv_free(u->documentation);
477 free(u->fragment_path);
478 free(u->source_path);
479 strv_free(u->dropin_paths);
482 set_free_free(u->names);
484 condition_free_list(u->conditions);
486 unit_ref_unset(&u->slice);
489 unit_ref_unset(u->refs);
494 UnitActiveState unit_active_state(Unit *u) {
497 if (u->load_state == UNIT_MERGED)
498 return unit_active_state(unit_follow_merge(u));
500 /* After a reload it might happen that a unit is not correctly
501 * loaded but still has a process around. That's why we won't
502 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
504 return UNIT_VTABLE(u)->active_state(u);
507 const char* unit_sub_state_to_string(Unit *u) {
510 return UNIT_VTABLE(u)->sub_state_to_string(u);
513 static void complete_move(Set **s, Set **other) {
521 set_move(*s, *other);
528 static void merge_names(Unit *u, Unit *other) {
535 complete_move(&u->names, &other->names);
537 set_free_free(other->names);
541 SET_FOREACH(t, u->names, i)
542 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
545 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
552 assert(d < _UNIT_DEPENDENCY_MAX);
554 /* Fix backwards pointers */
555 SET_FOREACH(back, other->dependencies[d], i) {
558 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {
559 r = set_remove_and_put(back->dependencies[k], other, u);
561 set_remove(back->dependencies[k], other);
563 assert(r >= 0 || r == -ENOENT);
567 complete_move(&u->dependencies[d], &other->dependencies[d]);
569 set_free(other->dependencies[d]);
570 other->dependencies[d] = NULL;
573 int unit_merge(Unit *u, Unit *other) {
578 assert(u->manager == other->manager);
579 assert(u->type != _UNIT_TYPE_INVALID);
581 other = unit_follow_merge(other);
586 if (u->type != other->type)
589 if (!u->instance != !other->instance)
592 if (other->load_state != UNIT_STUB &&
593 other->load_state != UNIT_NOT_FOUND)
602 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
606 merge_names(u, other);
608 /* Redirect all references */
610 unit_ref_set(other->refs, u);
612 /* Merge dependencies */
613 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
614 merge_dependencies(u, other, d);
616 other->load_state = UNIT_MERGED;
617 other->merged_into = u;
619 /* If there is still some data attached to the other node, we
620 * don't need it anymore, and can free it. */
621 if (other->load_state != UNIT_STUB)
622 if (UNIT_VTABLE(other)->done)
623 UNIT_VTABLE(other)->done(other);
625 unit_add_to_dbus_queue(u);
626 unit_add_to_cleanup_queue(other);
631 int unit_merge_by_name(Unit *u, const char *name) {
634 _cleanup_free_ char *s = NULL;
639 if (unit_name_is_template(name)) {
643 s = unit_name_replace_instance(name, u->instance);
650 other = manager_get_unit(u->manager, name);
652 r = unit_add_name(u, name);
654 r = unit_merge(u, other);
659 Unit* unit_follow_merge(Unit *u) {
662 while (u->load_state == UNIT_MERGED)
663 assert_se(u = u->merged_into);
668 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
674 if (c->std_output != EXEC_OUTPUT_KMSG &&
675 c->std_output != EXEC_OUTPUT_SYSLOG &&
676 c->std_output != EXEC_OUTPUT_JOURNAL &&
677 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
678 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
679 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
680 c->std_error != EXEC_OUTPUT_KMSG &&
681 c->std_error != EXEC_OUTPUT_SYSLOG &&
682 c->std_error != EXEC_OUTPUT_JOURNAL &&
683 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
684 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
685 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
688 /* If syslog or kernel logging is requested, make sure our own
689 * logging daemon is run first. */
691 if (u->manager->running_as == SYSTEMD_SYSTEM) {
692 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
700 const char *unit_description(Unit *u) {
704 return u->description;
709 void unit_dump(Unit *u, FILE *f, const char *prefix) {
713 _cleanup_free_ char *p2 = NULL;
716 timestamp1[FORMAT_TIMESTAMP_MAX],
717 timestamp2[FORMAT_TIMESTAMP_MAX],
718 timestamp3[FORMAT_TIMESTAMP_MAX],
719 timestamp4[FORMAT_TIMESTAMP_MAX],
720 timespan[FORMAT_TIMESPAN_MAX];
722 _cleanup_set_free_ Set *following_set = NULL;
726 assert(u->type >= 0);
730 p2 = strappend(prefix, "\t");
731 prefix2 = p2 ? p2 : prefix;
735 "%s\tDescription: %s\n"
737 "%s\tUnit Load State: %s\n"
738 "%s\tUnit Active State: %s\n"
739 "%s\tInactive Exit Timestamp: %s\n"
740 "%s\tActive Enter Timestamp: %s\n"
741 "%s\tActive Exit Timestamp: %s\n"
742 "%s\tInactive Enter Timestamp: %s\n"
743 "%s\tGC Check Good: %s\n"
744 "%s\tNeed Daemon Reload: %s\n"
745 "%s\tTransient: %s\n"
748 "%s\tCGroup realized: %s\n"
749 "%s\tCGroup mask: 0x%x\n"
750 "%s\tCGroup members mask: 0x%x\n",
752 prefix, unit_description(u),
753 prefix, strna(u->instance),
754 prefix, unit_load_state_to_string(u->load_state),
755 prefix, unit_active_state_to_string(unit_active_state(u)),
756 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
757 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
758 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
759 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
760 prefix, yes_no(unit_check_gc(u)),
761 prefix, yes_no(unit_need_daemon_reload(u)),
762 prefix, yes_no(u->transient),
763 prefix, strna(unit_slice_name(u)),
764 prefix, strna(u->cgroup_path),
765 prefix, yes_no(u->cgroup_realized),
766 prefix, u->cgroup_mask,
767 prefix, u->cgroup_members_mask);
769 SET_FOREACH(t, u->names, i)
770 fprintf(f, "%s\tName: %s\n", prefix, t);
772 STRV_FOREACH(j, u->documentation)
773 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
775 following = unit_following(u);
777 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
779 r = unit_following_set(u, &following_set);
783 SET_FOREACH(other, following_set, i)
784 fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
787 if (u->fragment_path)
788 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
791 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
793 STRV_FOREACH(j, u->dropin_paths)
794 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
796 if (u->job_timeout > 0)
797 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
799 condition_dump_list(u->conditions, f, prefix);
801 if (dual_timestamp_is_set(&u->condition_timestamp))
803 "%s\tCondition Timestamp: %s\n"
804 "%s\tCondition Result: %s\n",
805 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
806 prefix, yes_no(u->condition_result));
808 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
811 SET_FOREACH(other, u->dependencies[d], i)
812 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
815 if (!strv_isempty(u->requires_mounts_for)) {
817 "%s\tRequiresMountsFor:", prefix);
819 STRV_FOREACH(j, u->requires_mounts_for)
820 fprintf(f, " %s", *j);
825 if (u->load_state == UNIT_LOADED) {
828 "%s\tStopWhenUnneeded: %s\n"
829 "%s\tRefuseManualStart: %s\n"
830 "%s\tRefuseManualStop: %s\n"
831 "%s\tDefaultDependencies: %s\n"
832 "%s\tOnFailureJobMode: %s\n"
833 "%s\tIgnoreOnIsolate: %s\n"
834 "%s\tIgnoreOnSnapshot: %s\n",
835 prefix, yes_no(u->stop_when_unneeded),
836 prefix, yes_no(u->refuse_manual_start),
837 prefix, yes_no(u->refuse_manual_stop),
838 prefix, yes_no(u->default_dependencies),
839 prefix, job_mode_to_string(u->on_failure_job_mode),
840 prefix, yes_no(u->ignore_on_isolate),
841 prefix, yes_no(u->ignore_on_snapshot));
843 if (UNIT_VTABLE(u)->dump)
844 UNIT_VTABLE(u)->dump(u, f, prefix2);
846 } else if (u->load_state == UNIT_MERGED)
848 "%s\tMerged into: %s\n",
849 prefix, u->merged_into->id);
850 else if (u->load_state == UNIT_ERROR)
851 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
855 job_dump(u->job, f, prefix2);
858 job_dump(u->nop_job, f, prefix2);
862 /* Common implementation for multiple backends */
863 int unit_load_fragment_and_dropin(Unit *u) {
868 /* Load a .{service,socket,...} file */
869 r = unit_load_fragment(u);
873 if (u->load_state == UNIT_STUB)
876 /* Load drop-in directory data */
877 r = unit_load_dropin(unit_follow_merge(u));
884 /* Common implementation for multiple backends */
885 int unit_load_fragment_and_dropin_optional(Unit *u) {
890 /* Same as unit_load_fragment_and_dropin(), but whether
891 * something can be loaded or not doesn't matter. */
893 /* Load a .service file */
894 r = unit_load_fragment(u);
898 if (u->load_state == UNIT_STUB)
899 u->load_state = UNIT_LOADED;
901 /* Load drop-in directory data */
902 r = unit_load_dropin(unit_follow_merge(u));
909 int unit_add_default_target_dependency(Unit *u, Unit *target) {
913 if (target->type != UNIT_TARGET)
916 /* Only add the dependency if both units are loaded, so that
917 * that loop check below is reliable */
918 if (u->load_state != UNIT_LOADED ||
919 target->load_state != UNIT_LOADED)
922 /* If either side wants no automatic dependencies, then let's
924 if (!u->default_dependencies ||
925 !target->default_dependencies)
928 /* Don't create loops */
929 if (set_get(target->dependencies[UNIT_BEFORE], u))
932 return unit_add_dependency(target, UNIT_AFTER, u, true);
935 static int unit_add_default_dependencies(Unit *u) {
937 static const UnitDependency deps[] = {
939 UNIT_REQUIRED_BY_OVERRIDABLE,
951 for (k = 0; k < ELEMENTSOF(deps); k++)
952 SET_FOREACH(target, u->dependencies[deps[k]], i) {
953 r = unit_add_default_target_dependency(u, target);
958 if (u->default_dependencies && unit_get_cgroup_context(u)) {
959 if (UNIT_ISSET(u->slice))
960 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
962 r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
971 static int unit_add_mount_links(Unit *u) {
977 STRV_FOREACH(i, u->requires_mounts_for) {
978 char prefix[strlen(*i) + 1];
980 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
983 r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
991 if (m->load_state != UNIT_LOADED)
994 r = unit_add_dependency(u, UNIT_AFTER, m, true);
998 if (m->fragment_path) {
999 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
1009 int unit_load(Unit *u) {
1014 if (u->in_load_queue) {
1015 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1016 u->in_load_queue = false;
1019 if (u->type == _UNIT_TYPE_INVALID)
1022 if (u->load_state != UNIT_STUB)
1025 if (UNIT_VTABLE(u)->load) {
1026 r = UNIT_VTABLE(u)->load(u);
1031 if (u->load_state == UNIT_STUB) {
1036 if (u->load_state == UNIT_LOADED) {
1038 if (u->default_dependencies) {
1039 r = unit_add_default_dependencies(u);
1044 unit_update_member_masks(u);
1046 r = unit_add_mount_links(u);
1050 if (u->on_failure_job_mode == JOB_ISOLATE &&
1051 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1053 log_error_unit(u->id,
1054 "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
1061 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1063 unit_add_to_dbus_queue(unit_follow_merge(u));
1064 unit_add_to_gc_queue(u);
1069 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1071 unit_add_to_dbus_queue(u);
1072 unit_add_to_gc_queue(u);
1074 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
1075 u->id, strerror(-r));
1080 static bool unit_condition_test(Unit *u) {
1083 dual_timestamp_get(&u->condition_timestamp);
1084 u->condition_result = condition_test_list(u->id, u->conditions);
1086 return u->condition_result;
1089 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1090 const UnitStatusMessageFormats *format_table;
1094 assert(t < _JOB_TYPE_MAX);
1096 if (t != JOB_START && t != JOB_STOP)
1099 format_table = &UNIT_VTABLE(u)->status_message_formats;
1103 return format_table->starting_stopping[t == JOB_STOP];
1106 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1111 assert(t < _JOB_TYPE_MAX);
1113 format = unit_get_status_message_format(u, t);
1117 /* Return generic strings */
1119 return "Starting %s.";
1120 else if (t == JOB_STOP)
1121 return "Stopping %s.";
1122 else if (t == JOB_RELOAD)
1123 return "Reloading %s.";
1128 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1133 /* We only print status messages for selected units on
1134 * selected operations. */
1136 format = unit_get_status_message_format(u, t);
1140 unit_status_printf(u, "", format);
1143 #pragma GCC diagnostic push
1144 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1145 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1152 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1155 if (log_on_console())
1158 /* We log status messages for all units and all operations. */
1160 format = unit_get_status_message_format_try_harder(u, t);
1164 snprintf(buf, sizeof(buf), format, unit_description(u));
1167 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1168 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1169 SD_MESSAGE_UNIT_RELOADING;
1171 log_struct_unit(LOG_INFO,
1177 #pragma GCC diagnostic pop
1180 * -EBADR: This unit type does not support starting.
1181 * -EALREADY: Unit is already started.
1182 * -EAGAIN: An operation is already in progress. Retry later.
1183 * -ECANCELED: Too many requests for now.
1185 int unit_start(Unit *u) {
1186 UnitActiveState state;
1191 if (u->load_state != UNIT_LOADED)
1194 /* If this is already started, then this will succeed. Note
1195 * that this will even succeed if this unit is not startable
1196 * by the user. This is relied on to detect when we need to
1197 * wait for units and when waiting is finished. */
1198 state = unit_active_state(u);
1199 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1202 /* If the conditions failed, don't do anything at all. If we
1203 * already are activating this call might still be useful to
1204 * speed up activation in case there is some hold-off time,
1205 * but we don't want to recheck the condition in that case. */
1206 if (state != UNIT_ACTIVATING &&
1207 !unit_condition_test(u)) {
1208 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1212 /* Forward to the main object, if we aren't it. */
1213 following = unit_following(u);
1215 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1216 u->id, following->id);
1217 return unit_start(following);
1220 unit_status_log_starting_stopping_reloading(u, JOB_START);
1221 unit_status_print_starting_stopping(u, JOB_START);
1223 /* If it is stopped, but we cannot start it, then fail */
1224 if (!UNIT_VTABLE(u)->start)
1227 /* We don't suppress calls to ->start() here when we are
1228 * already starting, to allow this request to be used as a
1229 * "hurry up" call, for example when the unit is in some "auto
1230 * restart" state where it waits for a holdoff timer to elapse
1231 * before it will start again. */
1233 unit_add_to_dbus_queue(u);
1235 return UNIT_VTABLE(u)->start(u);
1238 bool unit_can_start(Unit *u) {
1241 return !!UNIT_VTABLE(u)->start;
1244 bool unit_can_isolate(Unit *u) {
1247 return unit_can_start(u) &&
1252 * -EBADR: This unit type does not support stopping.
1253 * -EALREADY: Unit is already stopped.
1254 * -EAGAIN: An operation is already in progress. Retry later.
1256 int unit_stop(Unit *u) {
1257 UnitActiveState state;
1262 state = unit_active_state(u);
1263 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1266 if ((following = unit_following(u))) {
1267 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1268 u->id, following->id);
1269 return unit_stop(following);
1272 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1273 unit_status_print_starting_stopping(u, JOB_STOP);
1275 if (!UNIT_VTABLE(u)->stop)
1278 unit_add_to_dbus_queue(u);
1280 return UNIT_VTABLE(u)->stop(u);
1284 * -EBADR: This unit type does not support reloading.
1285 * -ENOEXEC: Unit is not started.
1286 * -EAGAIN: An operation is already in progress. Retry later.
1288 int unit_reload(Unit *u) {
1289 UnitActiveState state;
1294 if (u->load_state != UNIT_LOADED)
1297 if (!unit_can_reload(u))
1300 state = unit_active_state(u);
1301 if (state == UNIT_RELOADING)
1304 if (state != UNIT_ACTIVE) {
1305 log_warning_unit(u->id, "Unit %s cannot be reloaded because it is inactive.",
1310 following = unit_following(u);
1312 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1313 u->id, following->id);
1314 return unit_reload(following);
1317 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1319 unit_add_to_dbus_queue(u);
1320 return UNIT_VTABLE(u)->reload(u);
1323 bool unit_can_reload(Unit *u) {
1326 if (!UNIT_VTABLE(u)->reload)
1329 if (!UNIT_VTABLE(u)->can_reload)
1332 return UNIT_VTABLE(u)->can_reload(u);
1335 static void unit_check_unneeded(Unit *u) {
1341 /* If this service shall be shut down when unneeded then do
1344 if (!u->stop_when_unneeded)
1347 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1350 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1351 if (unit_active_or_pending(other))
1354 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1355 if (unit_active_or_pending(other))
1358 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1359 if (unit_active_or_pending(other))
1362 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1363 if (unit_active_or_pending(other))
1366 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1368 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1369 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1372 static void retroactively_start_dependencies(Unit *u) {
1377 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1379 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1380 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1381 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1382 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1384 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1385 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1386 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1387 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1389 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1390 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1391 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1392 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1394 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1395 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1396 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1397 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1399 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1400 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1401 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1403 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1404 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1405 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1408 static void retroactively_stop_dependencies(Unit *u) {
1413 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1415 /* Pull down units which are bound to us recursively if enabled */
1416 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1417 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1418 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1421 static void check_unneeded_dependencies(Unit *u) {
1426 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1428 /* Garbage collect services that might not be needed anymore, if enabled */
1429 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1430 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1431 unit_check_unneeded(other);
1432 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1433 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1434 unit_check_unneeded(other);
1435 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1436 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1437 unit_check_unneeded(other);
1438 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1439 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1440 unit_check_unneeded(other);
1441 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1442 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1443 unit_check_unneeded(other);
1444 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1445 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1446 unit_check_unneeded(other);
1449 void unit_start_on_failure(Unit *u) {
1455 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1458 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1460 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1463 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1465 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1469 void unit_trigger_notify(Unit *u) {
1475 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1476 if (UNIT_VTABLE(other)->trigger_notify)
1477 UNIT_VTABLE(other)->trigger_notify(other, u);
1480 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1485 assert(os < _UNIT_ACTIVE_STATE_MAX);
1486 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1488 /* Note that this is called for all low-level state changes,
1489 * even if they might map to the same high-level
1490 * UnitActiveState! That means that ns == os is OK an expected
1491 * behavior here. For example: if a mount point is remounted
1492 * this function will be called too! */
1496 if (m->n_reloading <= 0) {
1499 dual_timestamp_get(&ts);
1501 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1502 u->inactive_exit_timestamp = ts;
1503 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1504 u->inactive_enter_timestamp = ts;
1506 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1507 u->active_enter_timestamp = ts;
1508 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1509 u->active_exit_timestamp = ts;
1512 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1513 unit_destroy_cgroup(u);
1515 /* Note that this doesn't apply to RemainAfterExit services exiting
1516 * sucessfully, since there's no change of state in that case. Which is
1517 * why it is handled in service_set_state() */
1518 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1519 ExecContext *ec = unit_get_exec_context(u);
1520 if (ec && exec_context_may_touch_console(ec)) {
1521 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1524 if (m->n_on_console == 0)
1525 /* unset no_console_output flag, since the console is free */
1526 m->no_console_output = false;
1535 if (u->job->state == JOB_WAITING)
1537 /* So we reached a different state for this
1538 * job. Let's see if we can run it now if it
1539 * failed previously due to EAGAIN. */
1540 job_add_to_run_queue(u->job);
1542 /* Let's check whether this state change constitutes a
1543 * finished job, or maybe contradicts a running job and
1544 * hence needs to invalidate jobs. */
1546 switch (u->job->type) {
1549 case JOB_VERIFY_ACTIVE:
1551 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1552 job_finish_and_invalidate(u->job, JOB_DONE, true);
1553 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1556 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1557 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1563 case JOB_RELOAD_OR_START:
1565 if (u->job->state == JOB_RUNNING) {
1566 if (ns == UNIT_ACTIVE)
1567 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1568 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1571 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1572 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1580 case JOB_TRY_RESTART:
1582 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1583 job_finish_and_invalidate(u->job, JOB_DONE, true);
1584 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1586 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1592 assert_not_reached("Job type unknown");
1598 if (m->n_reloading <= 0) {
1600 /* If this state change happened without being
1601 * requested by a job, then let's retroactively start
1602 * or stop dependencies. We skip that step when
1603 * deserializing, since we don't want to create any
1604 * additional jobs just because something is already
1608 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1609 retroactively_start_dependencies(u);
1610 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1611 retroactively_stop_dependencies(u);
1614 /* stop unneeded units regardless if going down was expected or not */
1615 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1616 check_unneeded_dependencies(u);
1618 if (ns != os && ns == UNIT_FAILED) {
1619 log_notice_unit(u->id,
1620 "Unit %s entered failed state.", u->id);
1621 unit_start_on_failure(u);
1625 /* Some names are special */
1626 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1628 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1629 /* The bus just might have become available,
1630 * hence try to connect to it, if we aren't
1634 if (u->type == UNIT_SERVICE &&
1635 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1636 m->n_reloading <= 0) {
1637 /* Write audit record if we have just finished starting up */
1638 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1642 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1643 manager_send_unit_plymouth(m, u);
1647 /* We don't care about D-Bus here, since we'll get an
1648 * asynchronous notification for it anyway. */
1650 if (u->type == UNIT_SERVICE &&
1651 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1652 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1653 m->n_reloading <= 0) {
1655 /* Hmm, if there was no start record written
1656 * write it now, so that we always have a nice
1659 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1661 if (ns == UNIT_INACTIVE)
1662 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1664 /* Write audit record if we have just finished shutting down */
1665 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1667 u->in_audit = false;
1671 manager_recheck_journal(m);
1672 unit_trigger_notify(u);
1674 /* Maybe we finished startup and are now ready for being
1675 * stopped because unneeded? */
1676 if (u->manager->n_reloading <= 0)
1677 unit_check_unneeded(u);
1679 unit_add_to_dbus_queue(u);
1680 unit_add_to_gc_queue(u);
1683 int unit_watch_pid(Unit *u, pid_t pid) {
1687 /* Watch a specific PID. We only support one unit watching
1688 * each PID for now. */
1690 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1693 void unit_unwatch_pid(Unit *u, pid_t pid) {
1697 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1700 bool unit_job_is_applicable(Unit *u, JobType j) {
1702 assert(j >= 0 && j < _JOB_TYPE_MAX);
1706 case JOB_VERIFY_ACTIVE:
1713 case JOB_TRY_RESTART:
1714 return unit_can_start(u);
1717 return unit_can_reload(u);
1719 case JOB_RELOAD_OR_START:
1720 return unit_can_reload(u) && unit_can_start(u);
1723 assert_not_reached("Invalid job type");
1727 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1729 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1730 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1731 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1732 [UNIT_WANTS] = UNIT_WANTED_BY,
1733 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1734 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1735 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1736 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1737 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1738 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1739 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1740 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1741 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1742 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1743 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1744 [UNIT_BEFORE] = UNIT_AFTER,
1745 [UNIT_AFTER] = UNIT_BEFORE,
1746 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1747 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1748 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1749 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1750 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1751 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1752 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1753 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
1755 int r, q = 0, v = 0, w = 0;
1758 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1761 u = unit_follow_merge(u);
1762 other = unit_follow_merge(other);
1764 /* We won't allow dependencies on ourselves. We will not
1765 * consider them an error however. */
1769 r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func);
1773 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
1774 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func);
1779 if (add_reference) {
1780 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func);
1784 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func);
1789 q = set_put(u->dependencies[d], other);
1793 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
1794 v = set_put(other->dependencies[inverse_table[d]], u);
1801 if (add_reference) {
1802 w = set_put(u->dependencies[UNIT_REFERENCES], other);
1808 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
1813 unit_add_to_dbus_queue(u);
1818 set_remove(u->dependencies[d], other);
1821 set_remove(other->dependencies[inverse_table[d]], u);
1824 set_remove(u->dependencies[UNIT_REFERENCES], other);
1829 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1834 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1837 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1843 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1847 assert(name || path);
1851 name = basename(path);
1853 if (!unit_name_is_template(name)) {
1859 s = unit_name_replace_instance(name, u->instance);
1861 _cleanup_free_ char *i = NULL;
1863 i = unit_name_to_prefix(u->id);
1867 s = unit_name_replace_instance(name, i);
1877 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1880 _cleanup_free_ char *s = NULL;
1883 assert(name || path);
1885 name = resolve_template(u, name, path, &s);
1889 r = manager_load_unit(u->manager, name, path, NULL, &other);
1893 return unit_add_dependency(u, d, other, add_reference);
1896 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1899 _cleanup_free_ char *s = NULL;
1902 assert(name || path);
1904 if (!(name = resolve_template(u, name, path, &s)))
1907 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1910 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1915 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1918 _cleanup_free_ char *s = NULL;
1921 assert(name || path);
1923 if (!(name = resolve_template(u, name, path, &s)))
1926 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1929 r = unit_add_dependency(other, d, u, add_reference);
1934 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1937 _cleanup_free_ char *s = NULL;
1940 assert(name || path);
1942 if (!(name = resolve_template(u, name, path, &s)))
1945 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1948 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1954 int set_unit_path(const char *p) {
1955 _cleanup_free_ char *c = NULL;
1957 /* This is mostly for debug purposes */
1958 c = path_make_absolute_cwd(p);
1959 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
1965 char *unit_dbus_path(Unit *u) {
1971 return unit_dbus_path_from_name(u->id);
1974 char *unit_default_cgroup_path(Unit *u) {
1975 _cleanup_free_ char *escaped = NULL, *slice = NULL;
1980 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
1981 return strdup(u->manager->cgroup_root);
1983 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
1984 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
1989 escaped = cg_escape(u->id);
1994 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
1996 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
1999 int unit_add_default_slice(Unit *u) {
2000 _cleanup_free_ char *b = NULL;
2001 const char *slice_name;
2007 if (UNIT_ISSET(u->slice))
2010 if (!unit_get_cgroup_context(u))
2014 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2016 /* Implicitly place all instantiated units in their
2017 * own per-template slice */
2019 prefix = unit_name_to_prefix(u->id);
2023 /* The prefix is already escaped, but it might include
2024 * "-" which has a special meaning for slice units,
2025 * hence escape it here extra. */
2026 escaped = strreplace(prefix, "-", "\\x2d");
2030 if (u->manager->running_as == SYSTEMD_SYSTEM)
2031 b = strjoin("system-", escaped, ".slice", NULL);
2033 b = strappend(escaped, ".slice");
2040 u->manager->running_as == SYSTEMD_SYSTEM
2041 ? SPECIAL_SYSTEM_SLICE
2042 : SPECIAL_ROOT_SLICE;
2044 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2048 unit_ref_set(&u->slice, slice);
2052 const char *unit_slice_name(Unit *u) {
2055 if (!UNIT_ISSET(u->slice))
2058 return UNIT_DEREF(u->slice)->id;
2061 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2062 _cleanup_free_ char *t = NULL;
2069 t = unit_name_change_suffix(u->id, type);
2073 assert(!unit_has_name(u, t));
2075 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2076 assert(r < 0 || *_found != u);
2080 int unit_watch_bus_name(Unit *u, const char *name) {
2084 /* Watch a specific name on the bus. We only support one unit
2085 * watching each name for now. */
2087 return hashmap_put(u->manager->watch_bus, name, u);
2090 void unit_unwatch_bus_name(Unit *u, const char *name) {
2094 hashmap_remove_value(u->manager->watch_bus, name, u);
2097 bool unit_can_serialize(Unit *u) {
2100 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2103 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2111 if (!unit_can_serialize(u))
2114 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2118 rt = unit_get_exec_runtime(u);
2120 r = exec_runtime_serialize(rt, u, f, fds);
2125 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2126 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2127 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2128 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2129 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2131 if (dual_timestamp_is_set(&u->condition_timestamp))
2132 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2134 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2137 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2139 if (serialize_jobs) {
2141 fprintf(f, "job\n");
2142 job_serialize(u->job, f, fds);
2146 fprintf(f, "job\n");
2147 job_serialize(u->nop_job, f, fds);
2156 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2167 va_start(ap, format);
2168 vfprintf(f, format, ap);
2174 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2180 fprintf(f, "%s=%s\n", key, value);
2183 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2185 ExecRuntime **rt = NULL;
2192 if (!unit_can_serialize(u))
2195 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2197 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2200 char line[LINE_MAX], *l, *v;
2203 if (!fgets(line, sizeof(line), f)) {
2216 k = strcspn(l, "=");
2224 if (streq(l, "job")) {
2226 /* new-style serialized job */
2227 Job *j = job_new_raw(u);
2231 r = job_deserialize(j, f, fds);
2237 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2243 r = job_install_deserialized(j);
2245 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2250 if (j->state == JOB_RUNNING)
2251 u->manager->n_running_jobs++;
2254 JobType type = job_type_from_string(v);
2256 log_debug("Failed to parse job type value %s", v);
2258 u->deserialized_job = type;
2261 } else if (streq(l, "inactive-exit-timestamp")) {
2262 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2264 } else if (streq(l, "active-enter-timestamp")) {
2265 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2267 } else if (streq(l, "active-exit-timestamp")) {
2268 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2270 } else if (streq(l, "inactive-enter-timestamp")) {
2271 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2273 } else if (streq(l, "condition-timestamp")) {
2274 dual_timestamp_deserialize(v, &u->condition_timestamp);
2276 } else if (streq(l, "condition-result")) {
2279 b = parse_boolean(v);
2281 log_debug("Failed to parse condition result value %s", v);
2283 u->condition_result = b;
2287 } else if (streq(l, "transient")) {
2290 b = parse_boolean(v);
2292 log_debug("Failed to parse transient bool %s", v);
2297 } else if (streq(l, "cgroup")) {
2304 free(u->cgroup_path);
2307 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2312 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2319 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2325 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2327 _cleanup_free_ char *e = NULL;
2335 /* Adds in links to the device node that this unit is based on */
2337 if (!is_device_path(what))
2340 e = unit_name_from_path(what, ".device");
2344 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2349 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2354 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2362 int unit_coldplug(Unit *u) {
2367 if (UNIT_VTABLE(u)->coldplug)
2368 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2372 r = job_coldplug(u->job);
2375 } else if (u->deserialized_job >= 0) {
2377 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2381 u->deserialized_job = _JOB_TYPE_INVALID;
2387 #pragma GCC diagnostic push
2388 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
2389 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2390 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2392 #pragma GCC diagnostic pop
2394 bool unit_need_daemon_reload(Unit *u) {
2395 _cleanup_strv_free_ char **t = NULL;
2398 unsigned loaded_cnt, current_cnt;
2402 if (u->fragment_path) {
2404 if (stat(u->fragment_path, &st) < 0)
2405 /* What, cannot access this anymore? */
2408 if (u->fragment_mtime > 0 &&
2409 timespec_load(&st.st_mtim) != u->fragment_mtime)
2413 if (u->source_path) {
2415 if (stat(u->source_path, &st) < 0)
2418 if (u->source_mtime > 0 &&
2419 timespec_load(&st.st_mtim) != u->source_mtime)
2423 t = unit_find_dropin_paths(u);
2424 loaded_cnt = strv_length(t);
2425 current_cnt = strv_length(u->dropin_paths);
2427 if (loaded_cnt == current_cnt) {
2428 if (loaded_cnt == 0)
2431 if (strv_overlap(u->dropin_paths, t)) {
2432 STRV_FOREACH(path, u->dropin_paths) {
2434 if (stat(*path, &st) < 0)
2437 if (u->dropin_mtime > 0 &&
2438 timespec_load(&st.st_mtim) > u->dropin_mtime)
2449 void unit_reset_failed(Unit *u) {
2452 if (UNIT_VTABLE(u)->reset_failed)
2453 UNIT_VTABLE(u)->reset_failed(u);
2456 Unit *unit_following(Unit *u) {
2459 if (UNIT_VTABLE(u)->following)
2460 return UNIT_VTABLE(u)->following(u);
2465 bool unit_stop_pending(Unit *u) {
2468 /* This call does check the current state of the unit. It's
2469 * hence useful to be called from state change calls of the
2470 * unit itself, where the state isn't updated yet. This is
2471 * different from unit_inactive_or_pending() which checks both
2472 * the current state and for a queued job. */
2474 return u->job && u->job->type == JOB_STOP;
2477 bool unit_inactive_or_pending(Unit *u) {
2480 /* Returns true if the unit is inactive or going down */
2482 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2485 if (unit_stop_pending(u))
2491 bool unit_active_or_pending(Unit *u) {
2494 /* Returns true if the unit is active or going up */
2496 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2500 (u->job->type == JOB_START ||
2501 u->job->type == JOB_RELOAD_OR_START ||
2502 u->job->type == JOB_RESTART))
2508 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2510 assert(w >= 0 && w < _KILL_WHO_MAX);
2512 assert(signo < _NSIG);
2514 if (!UNIT_VTABLE(u)->kill)
2517 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2520 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2524 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2528 /* Exclude the main/control pids from being killed via the cgroup */
2530 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2535 if (control_pid > 0) {
2536 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2548 int unit_kill_common(
2554 sd_bus_error *error) {
2558 if (who == KILL_MAIN && main_pid <= 0) {
2560 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2562 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2566 if (who == KILL_CONTROL && control_pid <= 0) {
2567 if (control_pid < 0)
2568 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2570 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2574 if (who == KILL_CONTROL || who == KILL_ALL)
2575 if (control_pid > 0)
2576 if (kill(control_pid, signo) < 0)
2579 if (who == KILL_MAIN || who == KILL_ALL)
2581 if (kill(main_pid, signo) < 0)
2584 if (who == KILL_ALL && u->cgroup_path) {
2585 _cleanup_set_free_ Set *pid_set = NULL;
2588 /* Exclude the main/control pids from being killed via the cgroup */
2589 pid_set = unit_pid_set(main_pid, control_pid);
2593 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2594 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2601 int unit_following_set(Unit *u, Set **s) {
2605 if (UNIT_VTABLE(u)->following_set)
2606 return UNIT_VTABLE(u)->following_set(u, s);
2612 UnitFileState unit_get_unit_file_state(Unit *u) {
2615 if (u->unit_file_state < 0 && u->fragment_path)
2616 u->unit_file_state = unit_file_get_state(
2617 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2618 NULL, basename(u->fragment_path));
2620 return u->unit_file_state;
2623 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2628 unit_ref_unset(ref);
2631 LIST_PREPEND(refs, u->refs, ref);
2635 void unit_ref_unset(UnitRef *ref) {
2641 LIST_REMOVE(refs, ref->unit->refs, ref);
2645 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2652 /* This only copies in the ones that need memory */
2653 for (i = 0; i < RLIMIT_NLIMITS; i++)
2654 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2655 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2660 if (u->manager->running_as == SYSTEMD_USER &&
2661 !c->working_directory) {
2663 r = get_home_dir(&c->working_directory);
2671 ExecContext *unit_get_exec_context(Unit *u) {
2675 offset = UNIT_VTABLE(u)->exec_context_offset;
2679 return (ExecContext*) ((uint8_t*) u + offset);
2682 KillContext *unit_get_kill_context(Unit *u) {
2686 offset = UNIT_VTABLE(u)->kill_context_offset;
2690 return (KillContext*) ((uint8_t*) u + offset);
2693 CGroupContext *unit_get_cgroup_context(Unit *u) {
2696 offset = UNIT_VTABLE(u)->cgroup_context_offset;
2700 return (CGroupContext*) ((uint8_t*) u + offset);
2703 ExecRuntime *unit_get_exec_runtime(Unit *u) {
2706 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2710 return *(ExecRuntime**) ((uint8_t*) u + offset);
2713 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2714 _cleanup_free_ char *b = NULL;
2722 assert(mode & (UNIT_PERSISTENT|UNIT_RUNTIME));
2724 b = xescape(name, "/.");
2728 if (!filename_is_safe(b))
2731 if (u->manager->running_as == SYSTEMD_USER) {
2732 _cleanup_free_ char *c = NULL;
2734 r = user_config_home(&c);
2740 p = strjoin(c, "/", u->id, ".d", NULL);
2741 } else if (mode & UNIT_PERSISTENT)
2742 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2744 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2748 q = strjoin(p, "/90-", b, ".conf", NULL);
2759 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2760 _cleanup_free_ char *p = NULL, *q = NULL;
2767 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2770 r = drop_in_file(u, mode, name, &p, &q);
2775 return write_string_file_atomic_label(q, data);
2778 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2779 _cleanup_free_ char *p = NULL;
2787 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2790 va_start(ap, format);
2791 r = vasprintf(&p, format, ap);
2797 return unit_write_drop_in(u, mode, name, p);
2800 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2801 _cleanup_free_ char *ndata = NULL;
2807 if (!UNIT_VTABLE(u)->private_section)
2810 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2813 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
2817 return unit_write_drop_in(u, mode, name, ndata);
2820 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2821 _cleanup_free_ char *p = NULL;
2829 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2832 va_start(ap, format);
2833 r = vasprintf(&p, format, ap);
2839 return unit_write_drop_in_private(u, mode, name, p);
2842 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
2843 _cleanup_free_ char *p = NULL, *q = NULL;
2848 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2851 r = drop_in_file(u, mode, name, &p, &q);
2856 r = errno == ENOENT ? 0 : -errno;
2864 int unit_make_transient(Unit *u) {
2869 u->load_state = UNIT_STUB;
2871 u->transient = true;
2873 free(u->fragment_path);
2874 u->fragment_path = NULL;
2876 if (u->manager->running_as == SYSTEMD_USER) {
2877 _cleanup_free_ char *c = NULL;
2879 r = user_config_home(&c);
2885 u->fragment_path = strjoin(c, "/", u->id, NULL);
2886 if (!u->fragment_path)
2891 u->fragment_path = strappend("/run/systemd/system/", u->id);
2892 if (!u->fragment_path)
2895 mkdir_p("/run/systemd/system", 0755);
2898 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
2901 int unit_kill_context(
2907 bool main_pid_alien) {
2909 int sig, wait_for_exit = 0, r;
2914 if (c->kill_mode == KILL_NONE)
2917 sig = sigkill ? SIGKILL : c->kill_signal;
2920 r = kill_and_sigcont(main_pid, sig);
2922 if (r < 0 && r != -ESRCH) {
2923 _cleanup_free_ char *comm = NULL;
2924 get_process_comm(main_pid, &comm);
2926 log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2927 (long) main_pid, strna(comm), strerror(-r));
2929 wait_for_exit = !main_pid_alien;
2932 kill(main_pid, SIGHUP);
2936 if (control_pid > 0) {
2937 r = kill_and_sigcont(control_pid, sig);
2939 if (r < 0 && r != -ESRCH) {
2940 _cleanup_free_ char *comm = NULL;
2941 get_process_comm(control_pid, &comm);
2943 log_warning_unit(u->id,
2944 "Failed to kill control process %li (%s): %s",
2945 (long) control_pid, strna(comm), strerror(-r));
2947 wait_for_exit = true;
2950 kill(control_pid, SIGHUP);
2954 if (c->kill_mode == KILL_CONTROL_GROUP && u->cgroup_path) {
2955 _cleanup_set_free_ Set *pid_set = NULL;
2957 /* Exclude the main/control pids from being killed via the cgroup */
2958 pid_set = unit_pid_set(main_pid, control_pid);
2962 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
2964 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
2965 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
2967 wait_for_exit = true;
2968 if (c->send_sighup) {
2971 pid_set = unit_pid_set(main_pid, control_pid);
2975 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, true, true, false, pid_set);
2980 return wait_for_exit;
2983 int unit_require_mounts_for(Unit *u, const char *path) {
2984 char prefix[strlen(path) + 1], *p;
2990 /* Registers a unit for requiring a certain path and all its
2991 * prefixes. We keep a simple array of these paths in the
2992 * unit, since its usually short. However, we build a prefix
2993 * table for all possible prefixes so that new appearing mount
2994 * units can easily determine which units to make themselves a
3001 path_kill_slashes(p);
3003 if (!path_is_absolute(p)) {
3008 if (!path_is_safe(p)) {
3013 if (strv_contains(u->requires_mounts_for, p)) {
3018 r = strv_push(&u->requires_mounts_for, p);
3024 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3027 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3031 if (!u->manager->units_requiring_mounts_for) {
3032 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
3033 if (!u->manager->units_requiring_mounts_for)
3041 x = set_new(NULL, NULL);
3047 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3063 int unit_setup_exec_runtime(Unit *u) {
3069 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3072 /* Check if ther already is an ExecRuntime for this unit? */
3073 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3077 /* Try to get it from somebody else */
3078 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3080 *rt = unit_get_exec_runtime(other);
3082 exec_runtime_ref(*rt);
3087 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3090 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3091 [UNIT_ACTIVE] = "active",
3092 [UNIT_RELOADING] = "reloading",
3093 [UNIT_INACTIVE] = "inactive",
3094 [UNIT_FAILED] = "failed",
3095 [UNIT_ACTIVATING] = "activating",
3096 [UNIT_DEACTIVATING] = "deactivating"
3099 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3101 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3102 [UNIT_REQUIRES] = "Requires",
3103 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3104 [UNIT_REQUISITE] = "Requisite",
3105 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3106 [UNIT_WANTS] = "Wants",
3107 [UNIT_BINDS_TO] = "BindsTo",
3108 [UNIT_PART_OF] = "PartOf",
3109 [UNIT_REQUIRED_BY] = "RequiredBy",
3110 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3111 [UNIT_WANTED_BY] = "WantedBy",
3112 [UNIT_BOUND_BY] = "BoundBy",
3113 [UNIT_CONSISTS_OF] = "ConsistsOf",
3114 [UNIT_CONFLICTS] = "Conflicts",
3115 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3116 [UNIT_BEFORE] = "Before",
3117 [UNIT_AFTER] = "After",
3118 [UNIT_ON_FAILURE] = "OnFailure",
3119 [UNIT_TRIGGERS] = "Triggers",
3120 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3121 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3122 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3123 [UNIT_REFERENCES] = "References",
3124 [UNIT_REFERENCED_BY] = "ReferencedBy",
3125 [UNIT_JOINS_NAMESPACE_OF] = "JoinsNamespaceOf",
3128 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);