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"
55 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
56 [UNIT_SERVICE] = &service_vtable,
57 [UNIT_SOCKET] = &socket_vtable,
58 [UNIT_BUSNAME] = &busname_vtable,
59 [UNIT_TARGET] = &target_vtable,
60 [UNIT_SNAPSHOT] = &snapshot_vtable,
61 [UNIT_DEVICE] = &device_vtable,
62 [UNIT_MOUNT] = &mount_vtable,
63 [UNIT_AUTOMOUNT] = &automount_vtable,
64 [UNIT_SWAP] = &swap_vtable,
65 [UNIT_TIMER] = &timer_vtable,
66 [UNIT_PATH] = &path_vtable,
67 [UNIT_SLICE] = &slice_vtable,
68 [UNIT_SCOPE] = &scope_vtable
71 Unit *unit_new(Manager *m, size_t size) {
75 assert(size >= sizeof(Unit));
81 u->names = set_new(string_hash_func, string_compare_func);
88 u->type = _UNIT_TYPE_INVALID;
89 u->deserialized_job = _JOB_TYPE_INVALID;
90 u->default_dependencies = true;
91 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
92 u->on_failure_job_mode = JOB_REPLACE;
97 bool unit_has_name(Unit *u, const char *name) {
101 return !!set_get(u->names, (char*) name);
104 int unit_add_name(Unit *u, const char *text) {
112 if (unit_name_is_template(text)) {
116 s = unit_name_replace_instance(text, u->instance);
123 if (!unit_name_is_valid(s, TEMPLATE_INVALID)) {
128 assert_se((t = unit_name_to_type(s)) >= 0);
130 if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
135 r = unit_name_to_instance(s, &i);
139 if (i && unit_vtable[t]->no_instances) {
144 /* Ensure that this unit is either instanced or not instanced,
146 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
151 if (unit_vtable[t]->no_alias &&
152 !set_isempty(u->names) &&
153 !set_get(u->names, s)) {
158 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
163 r = set_put(u->names, s);
170 r = hashmap_put(u->manager->units, s, u);
172 set_remove(u->names, s);
176 if (u->type == _UNIT_TYPE_INVALID) {
182 LIST_PREPEND(units_by_type, u->manager->units_by_type[t], u);
184 if (UNIT_VTABLE(u)->init)
185 UNIT_VTABLE(u)->init(u);
189 unit_add_to_dbus_queue(u);
199 int unit_choose_id(Unit *u, const char *name) {
201 _cleanup_free_ char *t = NULL;
207 if (unit_name_is_template(name)) {
212 t = unit_name_replace_instance(name, u->instance);
219 /* Selects one of the names of this unit as the id */
220 s = set_get(u->names, (char*) name);
225 r = unit_name_to_instance(s, &i);
234 unit_add_to_dbus_queue(u);
239 int unit_set_description(Unit *u, const char *description) {
244 if (isempty(description))
247 s = strdup(description);
252 free(u->description);
255 unit_add_to_dbus_queue(u);
259 bool unit_check_gc(Unit *u) {
262 if (u->load_state == UNIT_STUB)
265 if (UNIT_VTABLE(u)->no_gc)
277 if (unit_active_state(u) != UNIT_INACTIVE)
283 if (UNIT_VTABLE(u)->check_gc)
284 if (UNIT_VTABLE(u)->check_gc(u))
290 void unit_add_to_load_queue(Unit *u) {
292 assert(u->type != _UNIT_TYPE_INVALID);
294 if (u->load_state != UNIT_STUB || u->in_load_queue)
297 LIST_PREPEND(load_queue, u->manager->load_queue, u);
298 u->in_load_queue = true;
301 void unit_add_to_cleanup_queue(Unit *u) {
304 if (u->in_cleanup_queue)
307 LIST_PREPEND(cleanup_queue, u->manager->cleanup_queue, u);
308 u->in_cleanup_queue = true;
311 void unit_add_to_gc_queue(Unit *u) {
314 if (u->in_gc_queue || u->in_cleanup_queue)
317 if (unit_check_gc(u))
320 LIST_PREPEND(gc_queue, u->manager->gc_queue, u);
321 u->in_gc_queue = true;
323 u->manager->n_in_gc_queue ++;
326 void unit_add_to_dbus_queue(Unit *u) {
328 assert(u->type != _UNIT_TYPE_INVALID);
330 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
333 /* Shortcut things if nobody cares */
334 if (set_isempty(u->manager->subscribed)) {
335 u->sent_dbus_new_signal = true;
339 LIST_PREPEND(dbus_queue, u->manager->dbus_unit_queue, u);
340 u->in_dbus_queue = true;
343 static void bidi_set_free(Unit *u, Set *s) {
349 /* Frees the set and makes sure we are dropped from the
350 * inverse pointers */
352 SET_FOREACH(other, s, i) {
355 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
356 set_remove(other->dependencies[d], u);
358 unit_add_to_gc_queue(other);
364 static void unit_remove_transient(Unit *u) {
372 if (u->fragment_path)
373 unlink(u->fragment_path);
375 STRV_FOREACH(i, u->dropin_paths) {
376 _cleanup_free_ char *p = NULL;
381 r = path_get_parent(*i, &p);
387 static void unit_free_requires_mounts_for(Unit *u) {
390 STRV_FOREACH(j, u->requires_mounts_for) {
391 char s[strlen(*j) + 1];
393 PATH_FOREACH_PREFIX_MORE(s, *j) {
397 x = hashmap_get2(u->manager->units_requiring_mounts_for, s, (void**) &y);
403 if (set_isempty(x)) {
404 hashmap_remove(u->manager->units_requiring_mounts_for, y);
411 strv_free(u->requires_mounts_for);
412 u->requires_mounts_for = NULL;
415 void unit_free(Unit *u) {
422 if (u->manager->n_reloading <= 0)
423 unit_remove_transient(u);
425 bus_unit_send_removed_signal(u);
427 if (u->load_state != UNIT_STUB)
428 if (UNIT_VTABLE(u)->done)
429 UNIT_VTABLE(u)->done(u);
431 unit_free_requires_mounts_for(u);
433 SET_FOREACH(t, u->names, i)
434 hashmap_remove_value(u->manager->units, t, u);
448 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
449 bidi_set_free(u, u->dependencies[d]);
451 if (u->type != _UNIT_TYPE_INVALID)
452 LIST_REMOVE(units_by_type, u->manager->units_by_type[u->type], u);
454 if (u->in_load_queue)
455 LIST_REMOVE(load_queue, u->manager->load_queue, u);
457 if (u->in_dbus_queue)
458 LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
460 if (u->in_cleanup_queue)
461 LIST_REMOVE(cleanup_queue, u->manager->cleanup_queue, u);
463 if (u->in_gc_queue) {
464 LIST_REMOVE(gc_queue, u->manager->gc_queue, u);
465 u->manager->n_in_gc_queue--;
468 if (u->in_cgroup_queue)
469 LIST_REMOVE(cgroup_queue, u->manager->cgroup_queue, u);
471 if (u->cgroup_path) {
472 hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
473 free(u->cgroup_path);
476 free(u->description);
477 strv_free(u->documentation);
478 free(u->fragment_path);
479 free(u->source_path);
480 strv_free(u->dropin_paths);
483 set_free_free(u->names);
485 condition_free_list(u->conditions);
487 unit_ref_unset(&u->slice);
490 unit_ref_unset(u->refs);
495 UnitActiveState unit_active_state(Unit *u) {
498 if (u->load_state == UNIT_MERGED)
499 return unit_active_state(unit_follow_merge(u));
501 /* After a reload it might happen that a unit is not correctly
502 * loaded but still has a process around. That's why we won't
503 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
505 return UNIT_VTABLE(u)->active_state(u);
508 const char* unit_sub_state_to_string(Unit *u) {
511 return UNIT_VTABLE(u)->sub_state_to_string(u);
514 static void complete_move(Set **s, Set **other) {
522 set_move(*s, *other);
529 static void merge_names(Unit *u, Unit *other) {
536 complete_move(&u->names, &other->names);
538 set_free_free(other->names);
542 SET_FOREACH(t, u->names, i)
543 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
546 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
553 assert(d < _UNIT_DEPENDENCY_MAX);
555 /* Fix backwards pointers */
556 SET_FOREACH(back, other->dependencies[d], i) {
559 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {
560 r = set_remove_and_put(back->dependencies[k], other, u);
562 set_remove(back->dependencies[k], other);
564 assert(r >= 0 || r == -ENOENT);
568 complete_move(&u->dependencies[d], &other->dependencies[d]);
570 set_free(other->dependencies[d]);
571 other->dependencies[d] = NULL;
574 int unit_merge(Unit *u, Unit *other) {
579 assert(u->manager == other->manager);
580 assert(u->type != _UNIT_TYPE_INVALID);
582 other = unit_follow_merge(other);
587 if (u->type != other->type)
590 if (!u->instance != !other->instance)
593 if (other->load_state != UNIT_STUB &&
594 other->load_state != UNIT_NOT_FOUND)
603 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
607 merge_names(u, other);
609 /* Redirect all references */
611 unit_ref_set(other->refs, u);
613 /* Merge dependencies */
614 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
615 merge_dependencies(u, other, d);
617 other->load_state = UNIT_MERGED;
618 other->merged_into = u;
620 /* If there is still some data attached to the other node, we
621 * don't need it anymore, and can free it. */
622 if (other->load_state != UNIT_STUB)
623 if (UNIT_VTABLE(other)->done)
624 UNIT_VTABLE(other)->done(other);
626 unit_add_to_dbus_queue(u);
627 unit_add_to_cleanup_queue(other);
632 int unit_merge_by_name(Unit *u, const char *name) {
635 _cleanup_free_ char *s = NULL;
640 if (unit_name_is_template(name)) {
644 s = unit_name_replace_instance(name, u->instance);
651 other = manager_get_unit(u->manager, name);
653 r = unit_add_name(u, name);
655 r = unit_merge(u, other);
660 Unit* unit_follow_merge(Unit *u) {
663 while (u->load_state == UNIT_MERGED)
664 assert_se(u = u->merged_into);
669 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
675 if (c->working_directory) {
676 r = unit_require_mounts_for(u, c->working_directory);
681 if (c->root_directory) {
682 r = unit_require_mounts_for(u, c->root_directory);
687 if (c->std_output != EXEC_OUTPUT_KMSG &&
688 c->std_output != EXEC_OUTPUT_SYSLOG &&
689 c->std_output != EXEC_OUTPUT_JOURNAL &&
690 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
691 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
692 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
693 c->std_error != EXEC_OUTPUT_KMSG &&
694 c->std_error != EXEC_OUTPUT_SYSLOG &&
695 c->std_error != EXEC_OUTPUT_JOURNAL &&
696 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
697 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
698 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
701 /* If syslog or kernel logging is requested, make sure our own
702 * logging daemon is run first. */
704 if (u->manager->running_as == SYSTEMD_SYSTEM) {
705 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
713 const char *unit_description(Unit *u) {
717 return u->description;
722 void unit_dump(Unit *u, FILE *f, const char *prefix) {
726 _cleanup_free_ char *p2 = NULL;
729 timestamp1[FORMAT_TIMESTAMP_MAX],
730 timestamp2[FORMAT_TIMESTAMP_MAX],
731 timestamp3[FORMAT_TIMESTAMP_MAX],
732 timestamp4[FORMAT_TIMESTAMP_MAX],
733 timespan[FORMAT_TIMESPAN_MAX];
735 _cleanup_set_free_ Set *following_set = NULL;
739 assert(u->type >= 0);
743 p2 = strappend(prefix, "\t");
744 prefix2 = p2 ? p2 : prefix;
748 "%s\tDescription: %s\n"
750 "%s\tUnit Load State: %s\n"
751 "%s\tUnit Active State: %s\n"
752 "%s\tInactive Exit Timestamp: %s\n"
753 "%s\tActive Enter Timestamp: %s\n"
754 "%s\tActive Exit Timestamp: %s\n"
755 "%s\tInactive Enter Timestamp: %s\n"
756 "%s\tGC Check Good: %s\n"
757 "%s\tNeed Daemon Reload: %s\n"
758 "%s\tTransient: %s\n"
761 "%s\tCGroup realized: %s\n"
762 "%s\tCGroup mask: 0x%x\n"
763 "%s\tCGroup members mask: 0x%x\n",
765 prefix, unit_description(u),
766 prefix, strna(u->instance),
767 prefix, unit_load_state_to_string(u->load_state),
768 prefix, unit_active_state_to_string(unit_active_state(u)),
769 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
770 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
771 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
772 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
773 prefix, yes_no(unit_check_gc(u)),
774 prefix, yes_no(unit_need_daemon_reload(u)),
775 prefix, yes_no(u->transient),
776 prefix, strna(unit_slice_name(u)),
777 prefix, strna(u->cgroup_path),
778 prefix, yes_no(u->cgroup_realized),
779 prefix, u->cgroup_mask,
780 prefix, u->cgroup_members_mask);
782 SET_FOREACH(t, u->names, i)
783 fprintf(f, "%s\tName: %s\n", prefix, t);
785 STRV_FOREACH(j, u->documentation)
786 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
788 following = unit_following(u);
790 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
792 r = unit_following_set(u, &following_set);
796 SET_FOREACH(other, following_set, i)
797 fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
800 if (u->fragment_path)
801 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
804 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
806 STRV_FOREACH(j, u->dropin_paths)
807 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
809 if (u->job_timeout > 0)
810 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
812 condition_dump_list(u->conditions, f, prefix);
814 if (dual_timestamp_is_set(&u->condition_timestamp))
816 "%s\tCondition Timestamp: %s\n"
817 "%s\tCondition Result: %s\n",
818 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
819 prefix, yes_no(u->condition_result));
821 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
824 SET_FOREACH(other, u->dependencies[d], i)
825 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
828 if (!strv_isempty(u->requires_mounts_for)) {
830 "%s\tRequiresMountsFor:", prefix);
832 STRV_FOREACH(j, u->requires_mounts_for)
833 fprintf(f, " %s", *j);
838 if (u->load_state == UNIT_LOADED) {
841 "%s\tStopWhenUnneeded: %s\n"
842 "%s\tRefuseManualStart: %s\n"
843 "%s\tRefuseManualStop: %s\n"
844 "%s\tDefaultDependencies: %s\n"
845 "%s\tOnFailureJobMode: %s\n"
846 "%s\tIgnoreOnIsolate: %s\n"
847 "%s\tIgnoreOnSnapshot: %s\n",
848 prefix, yes_no(u->stop_when_unneeded),
849 prefix, yes_no(u->refuse_manual_start),
850 prefix, yes_no(u->refuse_manual_stop),
851 prefix, yes_no(u->default_dependencies),
852 prefix, job_mode_to_string(u->on_failure_job_mode),
853 prefix, yes_no(u->ignore_on_isolate),
854 prefix, yes_no(u->ignore_on_snapshot));
856 if (UNIT_VTABLE(u)->dump)
857 UNIT_VTABLE(u)->dump(u, f, prefix2);
859 } else if (u->load_state == UNIT_MERGED)
861 "%s\tMerged into: %s\n",
862 prefix, u->merged_into->id);
863 else if (u->load_state == UNIT_ERROR)
864 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
868 job_dump(u->job, f, prefix2);
871 job_dump(u->nop_job, f, prefix2);
875 /* Common implementation for multiple backends */
876 int unit_load_fragment_and_dropin(Unit *u) {
881 /* Load a .{service,socket,...} file */
882 r = unit_load_fragment(u);
886 if (u->load_state == UNIT_STUB)
889 /* Load drop-in directory data */
890 r = unit_load_dropin(unit_follow_merge(u));
897 /* Common implementation for multiple backends */
898 int unit_load_fragment_and_dropin_optional(Unit *u) {
903 /* Same as unit_load_fragment_and_dropin(), but whether
904 * something can be loaded or not doesn't matter. */
906 /* Load a .service file */
907 r = unit_load_fragment(u);
911 if (u->load_state == UNIT_STUB)
912 u->load_state = UNIT_LOADED;
914 /* Load drop-in directory data */
915 r = unit_load_dropin(unit_follow_merge(u));
922 int unit_add_default_target_dependency(Unit *u, Unit *target) {
926 if (target->type != UNIT_TARGET)
929 /* Only add the dependency if both units are loaded, so that
930 * that loop check below is reliable */
931 if (u->load_state != UNIT_LOADED ||
932 target->load_state != UNIT_LOADED)
935 /* If either side wants no automatic dependencies, then let's
937 if (!u->default_dependencies ||
938 !target->default_dependencies)
941 /* Don't create loops */
942 if (set_get(target->dependencies[UNIT_BEFORE], u))
945 return unit_add_dependency(target, UNIT_AFTER, u, true);
948 static int unit_add_default_dependencies(Unit *u) {
950 static const UnitDependency deps[] = {
952 UNIT_REQUIRED_BY_OVERRIDABLE,
964 for (k = 0; k < ELEMENTSOF(deps); k++)
965 SET_FOREACH(target, u->dependencies[deps[k]], i) {
966 r = unit_add_default_target_dependency(u, target);
971 if (u->default_dependencies && unit_get_cgroup_context(u)) {
972 if (UNIT_ISSET(u->slice))
973 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
975 r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
984 static int unit_add_mount_links(Unit *u) {
990 STRV_FOREACH(i, u->requires_mounts_for) {
991 char prefix[strlen(*i) + 1];
993 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
996 r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
1004 if (m->load_state != UNIT_LOADED)
1007 r = unit_add_dependency(u, UNIT_AFTER, m, true);
1011 if (m->fragment_path) {
1012 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
1022 int unit_load(Unit *u) {
1027 if (u->in_load_queue) {
1028 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1029 u->in_load_queue = false;
1032 if (u->type == _UNIT_TYPE_INVALID)
1035 if (u->load_state != UNIT_STUB)
1038 if (UNIT_VTABLE(u)->load) {
1039 r = UNIT_VTABLE(u)->load(u);
1044 if (u->load_state == UNIT_STUB) {
1049 if (u->load_state == UNIT_LOADED) {
1051 if (u->default_dependencies) {
1052 r = unit_add_default_dependencies(u);
1057 unit_update_member_masks(u);
1059 r = unit_add_mount_links(u);
1063 if (u->on_failure_job_mode == JOB_ISOLATE &&
1064 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1066 log_error_unit(u->id,
1067 "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
1074 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1076 unit_add_to_dbus_queue(unit_follow_merge(u));
1077 unit_add_to_gc_queue(u);
1082 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1084 unit_add_to_dbus_queue(u);
1085 unit_add_to_gc_queue(u);
1087 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
1088 u->id, strerror(-r));
1093 static bool unit_condition_test(Unit *u) {
1096 dual_timestamp_get(&u->condition_timestamp);
1097 u->condition_result = condition_test_list(u->id, u->conditions);
1099 return u->condition_result;
1102 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1103 const UnitStatusMessageFormats *format_table;
1107 assert(t < _JOB_TYPE_MAX);
1109 if (t != JOB_START && t != JOB_STOP)
1112 format_table = &UNIT_VTABLE(u)->status_message_formats;
1116 return format_table->starting_stopping[t == JOB_STOP];
1119 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1124 assert(t < _JOB_TYPE_MAX);
1126 format = unit_get_status_message_format(u, t);
1130 /* Return generic strings */
1132 return "Starting %s.";
1133 else if (t == JOB_STOP)
1134 return "Stopping %s.";
1135 else if (t == JOB_RELOAD)
1136 return "Reloading %s.";
1141 #pragma GCC diagnostic push
1142 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1143 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1148 /* We only print status messages for selected units on
1149 * selected operations. */
1151 format = unit_get_status_message_format(u, t);
1155 unit_status_printf(u, "", format);
1157 #pragma GCC diagnostic pop
1159 #pragma GCC diagnostic push
1160 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1161 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1168 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1171 if (log_on_console())
1174 /* We log status messages for all units and all operations. */
1176 format = unit_get_status_message_format_try_harder(u, t);
1180 snprintf(buf, sizeof(buf), format, unit_description(u));
1183 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1184 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1185 SD_MESSAGE_UNIT_RELOADING;
1187 log_struct_unit(LOG_INFO,
1193 #pragma GCC diagnostic pop
1196 * -EBADR: This unit type does not support starting.
1197 * -EALREADY: Unit is already started.
1198 * -EAGAIN: An operation is already in progress. Retry later.
1199 * -ECANCELED: Too many requests for now.
1201 int unit_start(Unit *u) {
1202 UnitActiveState state;
1207 if (u->load_state != UNIT_LOADED)
1210 /* If this is already started, then this will succeed. Note
1211 * that this will even succeed if this unit is not startable
1212 * by the user. This is relied on to detect when we need to
1213 * wait for units and when waiting is finished. */
1214 state = unit_active_state(u);
1215 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1218 /* If the conditions failed, don't do anything at all. If we
1219 * already are activating this call might still be useful to
1220 * speed up activation in case there is some hold-off time,
1221 * but we don't want to recheck the condition in that case. */
1222 if (state != UNIT_ACTIVATING &&
1223 !unit_condition_test(u)) {
1224 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1228 /* Forward to the main object, if we aren't it. */
1229 following = unit_following(u);
1231 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1232 u->id, following->id);
1233 return unit_start(following);
1236 unit_status_log_starting_stopping_reloading(u, JOB_START);
1237 unit_status_print_starting_stopping(u, JOB_START);
1239 /* If it is stopped, but we cannot start it, then fail */
1240 if (!UNIT_VTABLE(u)->start)
1243 /* We don't suppress calls to ->start() here when we are
1244 * already starting, to allow this request to be used as a
1245 * "hurry up" call, for example when the unit is in some "auto
1246 * restart" state where it waits for a holdoff timer to elapse
1247 * before it will start again. */
1249 unit_add_to_dbus_queue(u);
1251 return UNIT_VTABLE(u)->start(u);
1254 bool unit_can_start(Unit *u) {
1257 return !!UNIT_VTABLE(u)->start;
1260 bool unit_can_isolate(Unit *u) {
1263 return unit_can_start(u) &&
1268 * -EBADR: This unit type does not support stopping.
1269 * -EALREADY: Unit is already stopped.
1270 * -EAGAIN: An operation is already in progress. Retry later.
1272 int unit_stop(Unit *u) {
1273 UnitActiveState state;
1278 state = unit_active_state(u);
1279 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1282 if ((following = unit_following(u))) {
1283 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1284 u->id, following->id);
1285 return unit_stop(following);
1288 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1289 unit_status_print_starting_stopping(u, JOB_STOP);
1291 if (!UNIT_VTABLE(u)->stop)
1294 unit_add_to_dbus_queue(u);
1296 return UNIT_VTABLE(u)->stop(u);
1300 * -EBADR: This unit type does not support reloading.
1301 * -ENOEXEC: Unit is not started.
1302 * -EAGAIN: An operation is already in progress. Retry later.
1304 int unit_reload(Unit *u) {
1305 UnitActiveState state;
1310 if (u->load_state != UNIT_LOADED)
1313 if (!unit_can_reload(u))
1316 state = unit_active_state(u);
1317 if (state == UNIT_RELOADING)
1320 if (state != UNIT_ACTIVE) {
1321 log_warning_unit(u->id, "Unit %s cannot be reloaded because it is inactive.",
1326 following = unit_following(u);
1328 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1329 u->id, following->id);
1330 return unit_reload(following);
1333 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1335 unit_add_to_dbus_queue(u);
1336 return UNIT_VTABLE(u)->reload(u);
1339 bool unit_can_reload(Unit *u) {
1342 if (!UNIT_VTABLE(u)->reload)
1345 if (!UNIT_VTABLE(u)->can_reload)
1348 return UNIT_VTABLE(u)->can_reload(u);
1351 static void unit_check_unneeded(Unit *u) {
1357 /* If this service shall be shut down when unneeded then do
1360 if (!u->stop_when_unneeded)
1363 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1366 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1367 if (unit_active_or_pending(other))
1370 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1371 if (unit_active_or_pending(other))
1374 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1375 if (unit_active_or_pending(other))
1378 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1379 if (unit_active_or_pending(other))
1382 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1384 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1385 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1388 static void retroactively_start_dependencies(Unit *u) {
1393 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1395 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1396 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1397 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1398 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1400 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1401 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1402 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1403 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1405 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1406 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1407 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1408 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1410 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1411 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1412 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1413 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1415 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1416 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1417 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1419 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1420 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1421 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1424 static void retroactively_stop_dependencies(Unit *u) {
1429 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1431 /* Pull down units which are bound to us recursively if enabled */
1432 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1433 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1434 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1437 static void check_unneeded_dependencies(Unit *u) {
1442 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1444 /* Garbage collect services that might not be needed anymore, if enabled */
1445 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1446 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1447 unit_check_unneeded(other);
1448 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1449 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1450 unit_check_unneeded(other);
1451 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1452 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1453 unit_check_unneeded(other);
1454 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1455 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1456 unit_check_unneeded(other);
1457 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1458 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1459 unit_check_unneeded(other);
1460 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1461 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1462 unit_check_unneeded(other);
1465 void unit_start_on_failure(Unit *u) {
1471 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1474 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1476 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1479 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1481 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1485 void unit_trigger_notify(Unit *u) {
1491 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1492 if (UNIT_VTABLE(other)->trigger_notify)
1493 UNIT_VTABLE(other)->trigger_notify(other, u);
1496 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1501 assert(os < _UNIT_ACTIVE_STATE_MAX);
1502 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1504 /* Note that this is called for all low-level state changes,
1505 * even if they might map to the same high-level
1506 * UnitActiveState! That means that ns == os is OK an expected
1507 * behavior here. For example: if a mount point is remounted
1508 * this function will be called too! */
1512 if (m->n_reloading <= 0) {
1515 dual_timestamp_get(&ts);
1517 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1518 u->inactive_exit_timestamp = ts;
1519 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1520 u->inactive_enter_timestamp = ts;
1522 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1523 u->active_enter_timestamp = ts;
1524 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1525 u->active_exit_timestamp = ts;
1528 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1529 unit_destroy_cgroup(u);
1531 /* Note that this doesn't apply to RemainAfterExit services exiting
1532 * sucessfully, since there's no change of state in that case. Which is
1533 * why it is handled in service_set_state() */
1534 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1535 ExecContext *ec = unit_get_exec_context(u);
1536 if (ec && exec_context_may_touch_console(ec)) {
1537 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1540 if (m->n_on_console == 0)
1541 /* unset no_console_output flag, since the console is free */
1542 m->no_console_output = false;
1551 if (u->job->state == JOB_WAITING)
1553 /* So we reached a different state for this
1554 * job. Let's see if we can run it now if it
1555 * failed previously due to EAGAIN. */
1556 job_add_to_run_queue(u->job);
1558 /* Let's check whether this state change constitutes a
1559 * finished job, or maybe contradicts a running job and
1560 * hence needs to invalidate jobs. */
1562 switch (u->job->type) {
1565 case JOB_VERIFY_ACTIVE:
1567 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1568 job_finish_and_invalidate(u->job, JOB_DONE, true);
1569 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1572 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1573 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1579 case JOB_RELOAD_OR_START:
1581 if (u->job->state == JOB_RUNNING) {
1582 if (ns == UNIT_ACTIVE)
1583 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1584 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1587 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1588 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1596 case JOB_TRY_RESTART:
1598 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1599 job_finish_and_invalidate(u->job, JOB_DONE, true);
1600 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1602 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1608 assert_not_reached("Job type unknown");
1614 if (m->n_reloading <= 0) {
1616 /* If this state change happened without being
1617 * requested by a job, then let's retroactively start
1618 * or stop dependencies. We skip that step when
1619 * deserializing, since we don't want to create any
1620 * additional jobs just because something is already
1624 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1625 retroactively_start_dependencies(u);
1626 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1627 retroactively_stop_dependencies(u);
1630 /* stop unneeded units regardless if going down was expected or not */
1631 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1632 check_unneeded_dependencies(u);
1634 if (ns != os && ns == UNIT_FAILED) {
1635 log_notice_unit(u->id,
1636 "Unit %s entered failed state.", u->id);
1637 unit_start_on_failure(u);
1641 /* Some names are special */
1642 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1644 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1645 /* The bus just might have become available,
1646 * hence try to connect to it, if we aren't
1650 if (u->type == UNIT_SERVICE &&
1651 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1652 m->n_reloading <= 0) {
1653 /* Write audit record if we have just finished starting up */
1654 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1658 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1659 manager_send_unit_plymouth(m, u);
1663 /* We don't care about D-Bus here, since we'll get an
1664 * asynchronous notification for it anyway. */
1666 if (u->type == UNIT_SERVICE &&
1667 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1668 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1669 m->n_reloading <= 0) {
1671 /* Hmm, if there was no start record written
1672 * write it now, so that we always have a nice
1675 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1677 if (ns == UNIT_INACTIVE)
1678 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1680 /* Write audit record if we have just finished shutting down */
1681 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1683 u->in_audit = false;
1687 manager_recheck_journal(m);
1688 unit_trigger_notify(u);
1690 /* Maybe we finished startup and are now ready for being
1691 * stopped because unneeded? */
1692 if (u->manager->n_reloading <= 0)
1693 unit_check_unneeded(u);
1695 unit_add_to_dbus_queue(u);
1696 unit_add_to_gc_queue(u);
1699 int unit_watch_pid(Unit *u, pid_t pid) {
1703 /* Watch a specific PID. We only support one unit watching
1704 * each PID for now. */
1706 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1709 void unit_unwatch_pid(Unit *u, pid_t pid) {
1713 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1716 bool unit_job_is_applicable(Unit *u, JobType j) {
1718 assert(j >= 0 && j < _JOB_TYPE_MAX);
1722 case JOB_VERIFY_ACTIVE:
1729 case JOB_TRY_RESTART:
1730 return unit_can_start(u);
1733 return unit_can_reload(u);
1735 case JOB_RELOAD_OR_START:
1736 return unit_can_reload(u) && unit_can_start(u);
1739 assert_not_reached("Invalid job type");
1743 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1745 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1746 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1747 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1748 [UNIT_WANTS] = UNIT_WANTED_BY,
1749 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1750 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1751 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1752 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1753 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1754 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1755 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1756 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1757 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1758 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1759 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1760 [UNIT_BEFORE] = UNIT_AFTER,
1761 [UNIT_AFTER] = UNIT_BEFORE,
1762 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1763 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1764 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1765 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1766 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1767 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1768 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1769 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
1771 int r, q = 0, v = 0, w = 0;
1774 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1777 u = unit_follow_merge(u);
1778 other = unit_follow_merge(other);
1780 /* We won't allow dependencies on ourselves. We will not
1781 * consider them an error however. */
1785 r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func);
1789 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
1790 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func);
1795 if (add_reference) {
1796 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func);
1800 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func);
1805 q = set_put(u->dependencies[d], other);
1809 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
1810 v = set_put(other->dependencies[inverse_table[d]], u);
1817 if (add_reference) {
1818 w = set_put(u->dependencies[UNIT_REFERENCES], other);
1824 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
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 = basename(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_watch_bus_name(Unit *u, const char *name) {
2100 /* Watch a specific name on the bus. We only support one unit
2101 * watching each name for now. */
2103 return hashmap_put(u->manager->watch_bus, name, u);
2106 void unit_unwatch_bus_name(Unit *u, const char *name) {
2110 hashmap_remove_value(u->manager->watch_bus, name, u);
2113 bool unit_can_serialize(Unit *u) {
2116 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2119 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2127 if (!unit_can_serialize(u))
2130 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2134 rt = unit_get_exec_runtime(u);
2136 r = exec_runtime_serialize(rt, u, f, fds);
2141 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2142 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2143 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2144 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2145 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2147 if (dual_timestamp_is_set(&u->condition_timestamp))
2148 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2150 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2153 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2155 if (serialize_jobs) {
2157 fprintf(f, "job\n");
2158 job_serialize(u->job, f, fds);
2162 fprintf(f, "job\n");
2163 job_serialize(u->nop_job, f, fds);
2172 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2183 va_start(ap, format);
2184 vfprintf(f, format, ap);
2190 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2196 fprintf(f, "%s=%s\n", key, value);
2199 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2201 ExecRuntime **rt = NULL;
2208 if (!unit_can_serialize(u))
2211 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2213 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2216 char line[LINE_MAX], *l, *v;
2219 if (!fgets(line, sizeof(line), f)) {
2232 k = strcspn(l, "=");
2240 if (streq(l, "job")) {
2242 /* new-style serialized job */
2243 Job *j = job_new_raw(u);
2247 r = job_deserialize(j, f, fds);
2253 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2259 r = job_install_deserialized(j);
2261 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2266 if (j->state == JOB_RUNNING)
2267 u->manager->n_running_jobs++;
2270 JobType type = job_type_from_string(v);
2272 log_debug("Failed to parse job type value %s", v);
2274 u->deserialized_job = type;
2277 } else if (streq(l, "inactive-exit-timestamp")) {
2278 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2280 } else if (streq(l, "active-enter-timestamp")) {
2281 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2283 } else if (streq(l, "active-exit-timestamp")) {
2284 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2286 } else if (streq(l, "inactive-enter-timestamp")) {
2287 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2289 } else if (streq(l, "condition-timestamp")) {
2290 dual_timestamp_deserialize(v, &u->condition_timestamp);
2292 } else if (streq(l, "condition-result")) {
2295 b = parse_boolean(v);
2297 log_debug("Failed to parse condition result value %s", v);
2299 u->condition_result = b;
2303 } else if (streq(l, "transient")) {
2306 b = parse_boolean(v);
2308 log_debug("Failed to parse transient bool %s", v);
2313 } else if (streq(l, "cgroup")) {
2320 free(u->cgroup_path);
2323 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2328 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2335 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2341 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2343 _cleanup_free_ char *e = NULL;
2351 /* Adds in links to the device node that this unit is based on */
2353 if (!is_device_path(what))
2356 e = unit_name_from_path(what, ".device");
2360 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2365 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2370 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2378 int unit_coldplug(Unit *u) {
2383 if (UNIT_VTABLE(u)->coldplug)
2384 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2388 r = job_coldplug(u->job);
2391 } else if (u->deserialized_job >= 0) {
2393 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2397 u->deserialized_job = _JOB_TYPE_INVALID;
2403 #pragma GCC diagnostic push
2404 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
2405 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2406 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2408 #pragma GCC diagnostic pop
2410 bool unit_need_daemon_reload(Unit *u) {
2411 _cleanup_strv_free_ char **t = NULL;
2414 unsigned loaded_cnt, current_cnt;
2418 if (u->fragment_path) {
2420 if (stat(u->fragment_path, &st) < 0)
2421 /* What, cannot access this anymore? */
2424 if (u->fragment_mtime > 0 &&
2425 timespec_load(&st.st_mtim) != u->fragment_mtime)
2429 if (u->source_path) {
2431 if (stat(u->source_path, &st) < 0)
2434 if (u->source_mtime > 0 &&
2435 timespec_load(&st.st_mtim) != u->source_mtime)
2439 t = unit_find_dropin_paths(u);
2440 loaded_cnt = strv_length(t);
2441 current_cnt = strv_length(u->dropin_paths);
2443 if (loaded_cnt == current_cnt) {
2444 if (loaded_cnt == 0)
2447 if (strv_overlap(u->dropin_paths, t)) {
2448 STRV_FOREACH(path, u->dropin_paths) {
2450 if (stat(*path, &st) < 0)
2453 if (u->dropin_mtime > 0 &&
2454 timespec_load(&st.st_mtim) > u->dropin_mtime)
2465 void unit_reset_failed(Unit *u) {
2468 if (UNIT_VTABLE(u)->reset_failed)
2469 UNIT_VTABLE(u)->reset_failed(u);
2472 Unit *unit_following(Unit *u) {
2475 if (UNIT_VTABLE(u)->following)
2476 return UNIT_VTABLE(u)->following(u);
2481 bool unit_stop_pending(Unit *u) {
2484 /* This call does check the current state of the unit. It's
2485 * hence useful to be called from state change calls of the
2486 * unit itself, where the state isn't updated yet. This is
2487 * different from unit_inactive_or_pending() which checks both
2488 * the current state and for a queued job. */
2490 return u->job && u->job->type == JOB_STOP;
2493 bool unit_inactive_or_pending(Unit *u) {
2496 /* Returns true if the unit is inactive or going down */
2498 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2501 if (unit_stop_pending(u))
2507 bool unit_active_or_pending(Unit *u) {
2510 /* Returns true if the unit is active or going up */
2512 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2516 (u->job->type == JOB_START ||
2517 u->job->type == JOB_RELOAD_OR_START ||
2518 u->job->type == JOB_RESTART))
2524 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2526 assert(w >= 0 && w < _KILL_WHO_MAX);
2528 assert(signo < _NSIG);
2530 if (!UNIT_VTABLE(u)->kill)
2533 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2536 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2540 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2544 /* Exclude the main/control pids from being killed via the cgroup */
2546 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2551 if (control_pid > 0) {
2552 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2564 int unit_kill_common(
2570 sd_bus_error *error) {
2574 if (who == KILL_MAIN && main_pid <= 0) {
2576 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2578 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2582 if (who == KILL_CONTROL && control_pid <= 0) {
2583 if (control_pid < 0)
2584 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2586 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2590 if (who == KILL_CONTROL || who == KILL_ALL)
2591 if (control_pid > 0)
2592 if (kill(control_pid, signo) < 0)
2595 if (who == KILL_MAIN || who == KILL_ALL)
2597 if (kill(main_pid, signo) < 0)
2600 if (who == KILL_ALL && u->cgroup_path) {
2601 _cleanup_set_free_ Set *pid_set = NULL;
2604 /* Exclude the main/control pids from being killed via the cgroup */
2605 pid_set = unit_pid_set(main_pid, control_pid);
2609 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2610 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2617 int unit_following_set(Unit *u, Set **s) {
2621 if (UNIT_VTABLE(u)->following_set)
2622 return UNIT_VTABLE(u)->following_set(u, s);
2628 UnitFileState unit_get_unit_file_state(Unit *u) {
2631 if (u->unit_file_state < 0 && u->fragment_path)
2632 u->unit_file_state = unit_file_get_state(
2633 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2634 NULL, basename(u->fragment_path));
2636 return u->unit_file_state;
2639 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2644 unit_ref_unset(ref);
2647 LIST_PREPEND(refs, u->refs, ref);
2651 void unit_ref_unset(UnitRef *ref) {
2657 LIST_REMOVE(refs, ref->unit->refs, ref);
2661 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2668 /* This only copies in the ones that need memory */
2669 for (i = 0; i < RLIMIT_NLIMITS; i++)
2670 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2671 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2676 if (u->manager->running_as == SYSTEMD_USER &&
2677 !c->working_directory) {
2679 r = get_home_dir(&c->working_directory);
2687 ExecContext *unit_get_exec_context(Unit *u) {
2691 offset = UNIT_VTABLE(u)->exec_context_offset;
2695 return (ExecContext*) ((uint8_t*) u + offset);
2698 KillContext *unit_get_kill_context(Unit *u) {
2702 offset = UNIT_VTABLE(u)->kill_context_offset;
2706 return (KillContext*) ((uint8_t*) u + offset);
2709 CGroupContext *unit_get_cgroup_context(Unit *u) {
2712 offset = UNIT_VTABLE(u)->cgroup_context_offset;
2716 return (CGroupContext*) ((uint8_t*) u + offset);
2719 ExecRuntime *unit_get_exec_runtime(Unit *u) {
2722 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2726 return *(ExecRuntime**) ((uint8_t*) u + offset);
2729 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2730 _cleanup_free_ char *b = NULL;
2738 assert(mode & (UNIT_PERSISTENT|UNIT_RUNTIME));
2740 b = xescape(name, "/.");
2744 if (!filename_is_safe(b))
2747 if (u->manager->running_as == SYSTEMD_USER) {
2748 _cleanup_free_ char *c = NULL;
2750 r = user_config_home(&c);
2756 p = strjoin(c, "/", u->id, ".d", NULL);
2757 } else if (mode & UNIT_PERSISTENT)
2758 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2760 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2764 q = strjoin(p, "/90-", b, ".conf", NULL);
2775 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2776 _cleanup_free_ char *p = NULL, *q = NULL;
2783 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2786 r = drop_in_file(u, mode, name, &p, &q);
2791 return write_string_file_atomic_label(q, data);
2794 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2795 _cleanup_free_ char *p = NULL;
2803 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2806 va_start(ap, format);
2807 r = vasprintf(&p, format, ap);
2813 return unit_write_drop_in(u, mode, name, p);
2816 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2817 _cleanup_free_ char *ndata = NULL;
2823 if (!UNIT_VTABLE(u)->private_section)
2826 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2829 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
2833 return unit_write_drop_in(u, mode, name, ndata);
2836 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2837 _cleanup_free_ char *p = NULL;
2845 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2848 va_start(ap, format);
2849 r = vasprintf(&p, format, ap);
2855 return unit_write_drop_in_private(u, mode, name, p);
2858 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
2859 _cleanup_free_ char *p = NULL, *q = NULL;
2864 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2867 r = drop_in_file(u, mode, name, &p, &q);
2872 r = errno == ENOENT ? 0 : -errno;
2880 int unit_make_transient(Unit *u) {
2885 u->load_state = UNIT_STUB;
2887 u->transient = true;
2889 free(u->fragment_path);
2890 u->fragment_path = NULL;
2892 if (u->manager->running_as == SYSTEMD_USER) {
2893 _cleanup_free_ char *c = NULL;
2895 r = user_config_home(&c);
2901 u->fragment_path = strjoin(c, "/", u->id, NULL);
2902 if (!u->fragment_path)
2907 u->fragment_path = strappend("/run/systemd/system/", u->id);
2908 if (!u->fragment_path)
2911 mkdir_p("/run/systemd/system", 0755);
2914 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
2917 int unit_kill_context(
2923 bool main_pid_alien) {
2925 int sig, wait_for_exit = false, r;
2930 if (c->kill_mode == KILL_NONE)
2933 sig = sigkill ? SIGKILL : c->kill_signal;
2936 r = kill_and_sigcont(main_pid, sig);
2938 if (r < 0 && r != -ESRCH) {
2939 _cleanup_free_ char *comm = NULL;
2940 get_process_comm(main_pid, &comm);
2942 log_warning_unit(u->id, "Failed to kill main process " PID_FMT " (%s): %s", main_pid, strna(comm), strerror(-r));
2944 if (!main_pid_alien)
2945 wait_for_exit = true;
2948 kill(main_pid, SIGHUP);
2952 if (control_pid > 0) {
2953 r = kill_and_sigcont(control_pid, sig);
2955 if (r < 0 && r != -ESRCH) {
2956 _cleanup_free_ char *comm = NULL;
2957 get_process_comm(control_pid, &comm);
2959 log_warning_unit(u->id, "Failed to kill control process " PID_FMT " (%s): %s", control_pid, strna(comm), strerror(-r));
2961 wait_for_exit = true;
2964 kill(control_pid, SIGHUP);
2968 if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && sigkill)) && u->cgroup_path) {
2969 _cleanup_set_free_ Set *pid_set = NULL;
2971 /* Exclude the main/control pids from being killed via the cgroup */
2972 pid_set = unit_pid_set(main_pid, control_pid);
2976 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
2978 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
2979 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
2982 /* FIXME: Now, this is a terrible hack: in
2983 * containers cgroup empty notifications don't
2984 * work. Hence we'll not wait for them to run
2985 * empty for now, since there is no way to
2986 * detect when a service ends with no main PID
2989 if (detect_container(NULL) <= 0)
2990 wait_for_exit = true;
2992 if (c->send_sighup) {
2995 pid_set = unit_pid_set(main_pid, control_pid);
2999 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, true, true, false, pid_set);
3004 return wait_for_exit;
3007 int unit_require_mounts_for(Unit *u, const char *path) {
3008 char prefix[strlen(path) + 1], *p;
3014 /* Registers a unit for requiring a certain path and all its
3015 * prefixes. We keep a simple array of these paths in the
3016 * unit, since its usually short. However, we build a prefix
3017 * table for all possible prefixes so that new appearing mount
3018 * units can easily determine which units to make themselves a
3021 if (!path_is_absolute(path))
3028 path_kill_slashes(p);
3030 if (!path_is_safe(p)) {
3035 if (strv_contains(u->requires_mounts_for, p)) {
3040 r = strv_push(&u->requires_mounts_for, p);
3046 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3049 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3053 if (!u->manager->units_requiring_mounts_for) {
3054 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
3055 if (!u->manager->units_requiring_mounts_for)
3063 x = set_new(NULL, NULL);
3069 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3085 int unit_setup_exec_runtime(Unit *u) {
3091 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3094 /* Check if ther already is an ExecRuntime for this unit? */
3095 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3099 /* Try to get it from somebody else */
3100 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3102 *rt = unit_get_exec_runtime(other);
3104 exec_runtime_ref(*rt);
3109 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3112 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3113 [UNIT_ACTIVE] = "active",
3114 [UNIT_RELOADING] = "reloading",
3115 [UNIT_INACTIVE] = "inactive",
3116 [UNIT_FAILED] = "failed",
3117 [UNIT_ACTIVATING] = "activating",
3118 [UNIT_DEACTIVATING] = "deactivating"
3121 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3123 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3124 [UNIT_REQUIRES] = "Requires",
3125 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3126 [UNIT_REQUISITE] = "Requisite",
3127 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3128 [UNIT_WANTS] = "Wants",
3129 [UNIT_BINDS_TO] = "BindsTo",
3130 [UNIT_PART_OF] = "PartOf",
3131 [UNIT_REQUIRED_BY] = "RequiredBy",
3132 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3133 [UNIT_WANTED_BY] = "WantedBy",
3134 [UNIT_BOUND_BY] = "BoundBy",
3135 [UNIT_CONSISTS_OF] = "ConsistsOf",
3136 [UNIT_CONFLICTS] = "Conflicts",
3137 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3138 [UNIT_BEFORE] = "Before",
3139 [UNIT_AFTER] = "After",
3140 [UNIT_ON_FAILURE] = "OnFailure",
3141 [UNIT_TRIGGERS] = "Triggers",
3142 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3143 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3144 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3145 [UNIT_REFERENCES] = "References",
3146 [UNIT_REFERENCED_BY] = "ReferencedBy",
3147 [UNIT_JOINS_NAMESPACE_OF] = "JoinsNamespaceOf",
3150 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);