1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
25 #include <sys/epoll.h>
26 #include <sys/timerfd.h>
32 #include "systemd/sd-id128.h"
33 #include "systemd/sd-messages.h"
38 #include "path-util.h"
39 #include "load-fragment.h"
40 #include "load-dropin.h"
42 #include "unit-name.h"
43 #include "dbus-unit.h"
45 #include "cgroup-util.h"
49 #include "fileio-label.h"
50 #include "bus-errors.h"
52 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
53 [UNIT_SERVICE] = &service_vtable,
54 [UNIT_TIMER] = &timer_vtable,
55 [UNIT_SOCKET] = &socket_vtable,
56 [UNIT_TARGET] = &target_vtable,
57 [UNIT_DEVICE] = &device_vtable,
58 [UNIT_MOUNT] = &mount_vtable,
59 [UNIT_AUTOMOUNT] = &automount_vtable,
60 [UNIT_SNAPSHOT] = &snapshot_vtable,
61 [UNIT_SWAP] = &swap_vtable,
62 [UNIT_PATH] = &path_vtable,
63 [UNIT_SLICE] = &slice_vtable,
64 [UNIT_SCOPE] = &scope_vtable
67 Unit *unit_new(Manager *m, size_t size) {
71 assert(size >= sizeof(Unit));
77 u->names = set_new(string_hash_func, string_compare_func);
84 u->type = _UNIT_TYPE_INVALID;
85 u->deserialized_job = _JOB_TYPE_INVALID;
86 u->default_dependencies = true;
87 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
92 bool unit_has_name(Unit *u, const char *name) {
96 return !!set_get(u->names, (char*) name);
99 int unit_add_name(Unit *u, const char *text) {
107 if (unit_name_is_template(text)) {
111 s = unit_name_replace_instance(text, u->instance);
118 if (!unit_name_is_valid(s, false)) {
123 assert_se((t = unit_name_to_type(s)) >= 0);
125 if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
130 r = unit_name_to_instance(s, &i);
134 if (i && unit_vtable[t]->no_instances) {
139 /* Ensure that this unit is either instanced or not instanced,
141 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
146 if (unit_vtable[t]->no_alias &&
147 !set_isempty(u->names) &&
148 !set_get(u->names, s)) {
153 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
158 r = set_put(u->names, s);
165 r = hashmap_put(u->manager->units, s, u);
167 set_remove(u->names, s);
171 if (u->type == _UNIT_TYPE_INVALID) {
177 LIST_PREPEND(units_by_type, u->manager->units_by_type[t], u);
179 if (UNIT_VTABLE(u)->init)
180 UNIT_VTABLE(u)->init(u);
184 unit_add_to_dbus_queue(u);
194 int unit_choose_id(Unit *u, const char *name) {
196 _cleanup_free_ char *t = NULL;
202 if (unit_name_is_template(name)) {
207 t = unit_name_replace_instance(name, u->instance);
214 /* Selects one of the names of this unit as the id */
215 s = set_get(u->names, (char*) name);
220 r = unit_name_to_instance(s, &i);
229 unit_add_to_dbus_queue(u);
234 int unit_set_description(Unit *u, const char *description) {
239 if (isempty(description))
242 s = strdup(description);
247 free(u->description);
250 unit_add_to_dbus_queue(u);
254 bool unit_check_gc(Unit *u) {
257 if (u->load_state == UNIT_STUB)
260 if (UNIT_VTABLE(u)->no_gc)
272 if (unit_active_state(u) != UNIT_INACTIVE)
278 if (UNIT_VTABLE(u)->check_gc)
279 if (UNIT_VTABLE(u)->check_gc(u))
285 void unit_add_to_load_queue(Unit *u) {
287 assert(u->type != _UNIT_TYPE_INVALID);
289 if (u->load_state != UNIT_STUB || u->in_load_queue)
292 LIST_PREPEND(load_queue, u->manager->load_queue, u);
293 u->in_load_queue = true;
296 void unit_add_to_cleanup_queue(Unit *u) {
299 if (u->in_cleanup_queue)
302 LIST_PREPEND(cleanup_queue, u->manager->cleanup_queue, u);
303 u->in_cleanup_queue = true;
306 void unit_add_to_gc_queue(Unit *u) {
309 if (u->in_gc_queue || u->in_cleanup_queue)
312 if (unit_check_gc(u))
315 LIST_PREPEND(gc_queue, u->manager->gc_queue, u);
316 u->in_gc_queue = true;
318 u->manager->n_in_gc_queue ++;
321 void unit_add_to_dbus_queue(Unit *u) {
323 assert(u->type != _UNIT_TYPE_INVALID);
325 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
328 /* Shortcut things if nobody cares */
329 if (!bus_has_subscriber(u->manager)) {
330 u->sent_dbus_new_signal = true;
334 LIST_PREPEND(dbus_queue, u->manager->dbus_unit_queue, u);
335 u->in_dbus_queue = true;
338 static void bidi_set_free(Unit *u, Set *s) {
344 /* Frees the set and makes sure we are dropped from the
345 * inverse pointers */
347 SET_FOREACH(other, s, i) {
350 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
351 set_remove(other->dependencies[d], u);
353 unit_add_to_gc_queue(other);
359 static void unit_remove_transient(Unit *u) {
367 if (u->fragment_path)
368 unlink(u->fragment_path);
370 STRV_FOREACH(i, u->dropin_paths) {
371 _cleanup_free_ char *p = NULL;
376 r = path_get_parent(*i, &p);
382 static void unit_free_requires_mounts_for(Unit *u) {
385 STRV_FOREACH(j, u->requires_mounts_for) {
386 char s[strlen(*j) + 1];
388 PATH_FOREACH_PREFIX_MORE(s, *j) {
392 x = hashmap_get2(u->manager->units_requiring_mounts_for, s, (void**) &y);
398 if (set_isempty(x)) {
399 hashmap_remove(u->manager->units_requiring_mounts_for, y);
406 strv_free(u->requires_mounts_for);
407 u->requires_mounts_for = NULL;
410 void unit_free(Unit *u) {
417 if (u->manager->n_reloading <= 0)
418 unit_remove_transient(u);
420 bus_unit_send_removed_signal(u);
422 if (u->load_state != UNIT_STUB)
423 if (UNIT_VTABLE(u)->done)
424 UNIT_VTABLE(u)->done(u);
426 unit_free_requires_mounts_for(u);
428 SET_FOREACH(t, u->names, i)
429 hashmap_remove_value(u->manager->units, t, u);
443 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
444 bidi_set_free(u, u->dependencies[d]);
446 if (u->type != _UNIT_TYPE_INVALID)
447 LIST_REMOVE(units_by_type, u->manager->units_by_type[u->type], u);
449 if (u->in_load_queue)
450 LIST_REMOVE(load_queue, u->manager->load_queue, u);
452 if (u->in_dbus_queue)
453 LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
455 if (u->in_cleanup_queue)
456 LIST_REMOVE(cleanup_queue, u->manager->cleanup_queue, u);
458 if (u->in_gc_queue) {
459 LIST_REMOVE(gc_queue, u->manager->gc_queue, u);
460 u->manager->n_in_gc_queue--;
463 if (u->in_cgroup_queue)
464 LIST_REMOVE(cgroup_queue, u->manager->cgroup_queue, u);
466 if (u->cgroup_path) {
467 hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
468 free(u->cgroup_path);
471 free(u->description);
472 strv_free(u->documentation);
473 free(u->fragment_path);
474 free(u->source_path);
475 strv_free(u->dropin_paths);
478 set_free_free(u->names);
480 condition_free_list(u->conditions);
482 unit_ref_unset(&u->slice);
485 unit_ref_unset(u->refs);
490 UnitActiveState unit_active_state(Unit *u) {
493 if (u->load_state == UNIT_MERGED)
494 return unit_active_state(unit_follow_merge(u));
496 /* After a reload it might happen that a unit is not correctly
497 * loaded but still has a process around. That's why we won't
498 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
500 return UNIT_VTABLE(u)->active_state(u);
503 const char* unit_sub_state_to_string(Unit *u) {
506 return UNIT_VTABLE(u)->sub_state_to_string(u);
509 static void complete_move(Set **s, Set **other) {
517 set_move(*s, *other);
524 static void merge_names(Unit *u, Unit *other) {
531 complete_move(&u->names, &other->names);
533 set_free_free(other->names);
537 SET_FOREACH(t, u->names, i)
538 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
541 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
548 assert(d < _UNIT_DEPENDENCY_MAX);
550 /* Fix backwards pointers */
551 SET_FOREACH(back, other->dependencies[d], i) {
554 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {
555 r = set_remove_and_put(back->dependencies[k], other, u);
557 set_remove(back->dependencies[k], other);
559 assert(r >= 0 || r == -ENOENT);
563 complete_move(&u->dependencies[d], &other->dependencies[d]);
565 set_free(other->dependencies[d]);
566 other->dependencies[d] = NULL;
569 int unit_merge(Unit *u, Unit *other) {
574 assert(u->manager == other->manager);
575 assert(u->type != _UNIT_TYPE_INVALID);
577 other = unit_follow_merge(other);
582 if (u->type != other->type)
585 if (!u->instance != !other->instance)
588 if (other->load_state != UNIT_STUB &&
589 other->load_state != UNIT_NOT_FOUND)
598 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
602 merge_names(u, other);
604 /* Redirect all references */
606 unit_ref_set(other->refs, u);
608 /* Merge dependencies */
609 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
610 merge_dependencies(u, other, d);
612 other->load_state = UNIT_MERGED;
613 other->merged_into = u;
615 /* If there is still some data attached to the other node, we
616 * don't need it anymore, and can free it. */
617 if (other->load_state != UNIT_STUB)
618 if (UNIT_VTABLE(other)->done)
619 UNIT_VTABLE(other)->done(other);
621 unit_add_to_dbus_queue(u);
622 unit_add_to_cleanup_queue(other);
627 int unit_merge_by_name(Unit *u, const char *name) {
630 _cleanup_free_ char *s = NULL;
635 if (unit_name_is_template(name)) {
639 s = unit_name_replace_instance(name, u->instance);
646 other = manager_get_unit(u->manager, name);
648 r = unit_add_name(u, name);
650 r = unit_merge(u, other);
655 Unit* unit_follow_merge(Unit *u) {
658 while (u->load_state == UNIT_MERGED)
659 assert_se(u = u->merged_into);
664 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
670 if (c->std_output != EXEC_OUTPUT_KMSG &&
671 c->std_output != EXEC_OUTPUT_SYSLOG &&
672 c->std_output != EXEC_OUTPUT_JOURNAL &&
673 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
674 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
675 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
676 c->std_error != EXEC_OUTPUT_KMSG &&
677 c->std_error != EXEC_OUTPUT_SYSLOG &&
678 c->std_error != EXEC_OUTPUT_JOURNAL &&
679 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
680 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
681 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
684 /* If syslog or kernel logging is requested, make sure our own
685 * logging daemon is run first. */
687 if (u->manager->running_as == SYSTEMD_SYSTEM) {
688 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
696 const char *unit_description(Unit *u) {
700 return u->description;
705 void unit_dump(Unit *u, FILE *f, const char *prefix) {
709 _cleanup_free_ char *p2 = NULL;
712 timestamp1[FORMAT_TIMESTAMP_MAX],
713 timestamp2[FORMAT_TIMESTAMP_MAX],
714 timestamp3[FORMAT_TIMESTAMP_MAX],
715 timestamp4[FORMAT_TIMESTAMP_MAX],
716 timespan[FORMAT_TIMESPAN_MAX];
720 assert(u->type >= 0);
724 p2 = strappend(prefix, "\t");
725 prefix2 = p2 ? p2 : prefix;
729 "%s\tDescription: %s\n"
731 "%s\tUnit Load State: %s\n"
732 "%s\tUnit Active State: %s\n"
733 "%s\tInactive Exit Timestamp: %s\n"
734 "%s\tActive Enter Timestamp: %s\n"
735 "%s\tActive Exit Timestamp: %s\n"
736 "%s\tInactive Enter Timestamp: %s\n"
737 "%s\tGC Check Good: %s\n"
738 "%s\tNeed Daemon Reload: %s\n"
739 "%s\tTransient: %s\n"
742 "%s\tCGroup realized: %s\n"
743 "%s\tCGroup mask: 0x%x\n",
745 prefix, unit_description(u),
746 prefix, strna(u->instance),
747 prefix, unit_load_state_to_string(u->load_state),
748 prefix, unit_active_state_to_string(unit_active_state(u)),
749 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
750 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
751 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
752 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
753 prefix, yes_no(unit_check_gc(u)),
754 prefix, yes_no(unit_need_daemon_reload(u)),
755 prefix, yes_no(u->transient),
756 prefix, strna(unit_slice_name(u)),
757 prefix, strna(u->cgroup_path),
758 prefix, yes_no(u->cgroup_realized),
759 prefix, u->cgroup_mask);
761 SET_FOREACH(t, u->names, i)
762 fprintf(f, "%s\tName: %s\n", prefix, t);
764 STRV_FOREACH(j, u->documentation)
765 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
767 if ((following = unit_following(u)))
768 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
770 if (u->fragment_path)
771 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
774 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
776 STRV_FOREACH(j, u->dropin_paths)
777 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
779 if (u->job_timeout > 0)
780 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
782 condition_dump_list(u->conditions, f, prefix);
784 if (dual_timestamp_is_set(&u->condition_timestamp))
786 "%s\tCondition Timestamp: %s\n"
787 "%s\tCondition Result: %s\n",
788 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
789 prefix, yes_no(u->condition_result));
791 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
794 SET_FOREACH(other, u->dependencies[d], i)
795 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
798 if (!strv_isempty(u->requires_mounts_for)) {
800 "%s\tRequiresMountsFor:", prefix);
802 STRV_FOREACH(j, u->requires_mounts_for)
803 fprintf(f, " %s", *j);
808 if (u->load_state == UNIT_LOADED) {
811 "%s\tStopWhenUnneeded: %s\n"
812 "%s\tRefuseManualStart: %s\n"
813 "%s\tRefuseManualStop: %s\n"
814 "%s\tDefaultDependencies: %s\n"
815 "%s\tOnFailureIsolate: %s\n"
816 "%s\tIgnoreOnIsolate: %s\n"
817 "%s\tIgnoreOnSnapshot: %s\n",
818 prefix, yes_no(u->stop_when_unneeded),
819 prefix, yes_no(u->refuse_manual_start),
820 prefix, yes_no(u->refuse_manual_stop),
821 prefix, yes_no(u->default_dependencies),
822 prefix, yes_no(u->on_failure_isolate),
823 prefix, yes_no(u->ignore_on_isolate),
824 prefix, yes_no(u->ignore_on_snapshot));
826 if (UNIT_VTABLE(u)->dump)
827 UNIT_VTABLE(u)->dump(u, f, prefix2);
829 } else if (u->load_state == UNIT_MERGED)
831 "%s\tMerged into: %s\n",
832 prefix, u->merged_into->id);
833 else if (u->load_state == UNIT_ERROR)
834 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
838 job_dump(u->job, f, prefix2);
841 job_dump(u->nop_job, f, prefix2);
845 /* Common implementation for multiple backends */
846 int unit_load_fragment_and_dropin(Unit *u) {
851 /* Load a .{service,socket,...} file */
852 r = unit_load_fragment(u);
856 if (u->load_state == UNIT_STUB)
859 /* Load drop-in directory data */
860 r = unit_load_dropin(unit_follow_merge(u));
867 /* Common implementation for multiple backends */
868 int unit_load_fragment_and_dropin_optional(Unit *u) {
873 /* Same as unit_load_fragment_and_dropin(), but whether
874 * something can be loaded or not doesn't matter. */
876 /* Load a .service file */
877 r = unit_load_fragment(u);
881 if (u->load_state == UNIT_STUB)
882 u->load_state = UNIT_LOADED;
884 /* Load drop-in directory data */
885 r = unit_load_dropin(unit_follow_merge(u));
892 int unit_add_default_target_dependency(Unit *u, Unit *target) {
896 if (target->type != UNIT_TARGET)
899 /* Only add the dependency if both units are loaded, so that
900 * that loop check below is reliable */
901 if (u->load_state != UNIT_LOADED ||
902 target->load_state != UNIT_LOADED)
905 /* If either side wants no automatic dependencies, then let's
907 if (!u->default_dependencies ||
908 !target->default_dependencies)
911 /* Don't create loops */
912 if (set_get(target->dependencies[UNIT_BEFORE], u))
915 return unit_add_dependency(target, UNIT_AFTER, u, true);
918 static int unit_add_default_dependencies(Unit *u) {
920 static const UnitDependency deps[] = {
922 UNIT_REQUIRED_BY_OVERRIDABLE,
934 for (k = 0; k < ELEMENTSOF(deps); k++)
935 SET_FOREACH(target, u->dependencies[deps[k]], i) {
936 r = unit_add_default_target_dependency(u, target);
941 if (u->default_dependencies && unit_get_cgroup_context(u)) {
942 if (UNIT_ISSET(u->slice))
943 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
945 r = unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
954 static int unit_add_mount_links(Unit *u) {
960 STRV_FOREACH(i, u->requires_mounts_for) {
961 char prefix[strlen(*i) + 1];
963 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
966 r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
974 if (m->load_state != UNIT_LOADED)
977 r = unit_add_dependency(u, UNIT_AFTER, m, true);
981 if (m->fragment_path) {
982 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
992 int unit_load(Unit *u) {
997 if (u->in_load_queue) {
998 LIST_REMOVE(load_queue, u->manager->load_queue, u);
999 u->in_load_queue = false;
1002 if (u->type == _UNIT_TYPE_INVALID)
1005 if (u->load_state != UNIT_STUB)
1008 if (UNIT_VTABLE(u)->load) {
1009 r = UNIT_VTABLE(u)->load(u);
1014 if (u->load_state == UNIT_STUB) {
1019 if (u->load_state == UNIT_LOADED) {
1021 if (u->default_dependencies) {
1022 r = unit_add_default_dependencies(u);
1027 r = unit_add_mount_links(u);
1031 if (u->on_failure_isolate &&
1032 set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1034 log_error_unit(u->id,
1035 "More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.", u->id);
1042 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1044 unit_add_to_dbus_queue(unit_follow_merge(u));
1045 unit_add_to_gc_queue(u);
1050 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1052 unit_add_to_dbus_queue(u);
1053 unit_add_to_gc_queue(u);
1055 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
1056 u->id, strerror(-r));
1061 static bool unit_condition_test(Unit *u) {
1064 dual_timestamp_get(&u->condition_timestamp);
1065 u->condition_result = condition_test_list(u->id, u->conditions);
1067 return u->condition_result;
1070 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1071 const UnitStatusMessageFormats *format_table;
1075 assert(t < _JOB_TYPE_MAX);
1077 if (t != JOB_START && t != JOB_STOP)
1080 format_table = &UNIT_VTABLE(u)->status_message_formats;
1084 return format_table->starting_stopping[t == JOB_STOP];
1087 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1092 assert(t < _JOB_TYPE_MAX);
1094 format = unit_get_status_message_format(u, t);
1098 /* Return generic strings */
1100 return "Starting %s.";
1101 else if (t == JOB_STOP)
1102 return "Stopping %s.";
1103 else if (t == JOB_RELOAD)
1104 return "Reloading %s.";
1109 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1114 /* We only print status messages for selected units on
1115 * selected operations. */
1117 format = unit_get_status_message_format(u, t);
1121 unit_status_printf(u, "", format);
1124 #pragma GCC diagnostic push
1125 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1126 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1133 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1136 if (log_on_console())
1139 /* We log status messages for all units and all operations. */
1141 format = unit_get_status_message_format_try_harder(u, t);
1145 snprintf(buf, sizeof(buf), format, unit_description(u));
1148 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1149 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1150 SD_MESSAGE_UNIT_RELOADING;
1152 log_struct_unit(LOG_INFO,
1158 #pragma GCC diagnostic pop
1161 * -EBADR: This unit type does not support starting.
1162 * -EALREADY: Unit is already started.
1163 * -EAGAIN: An operation is already in progress. Retry later.
1164 * -ECANCELED: Too many requests for now.
1166 int unit_start(Unit *u) {
1167 UnitActiveState state;
1172 if (u->load_state != UNIT_LOADED)
1175 /* If this is already started, then this will succeed. Note
1176 * that this will even succeed if this unit is not startable
1177 * by the user. This is relied on to detect when we need to
1178 * wait for units and when waiting is finished. */
1179 state = unit_active_state(u);
1180 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1183 /* If the conditions failed, don't do anything at all. If we
1184 * already are activating this call might still be useful to
1185 * speed up activation in case there is some hold-off time,
1186 * but we don't want to recheck the condition in that case. */
1187 if (state != UNIT_ACTIVATING &&
1188 !unit_condition_test(u)) {
1189 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1193 /* Forward to the main object, if we aren't it. */
1194 following = unit_following(u);
1196 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1197 u->id, following->id);
1198 return unit_start(following);
1201 unit_status_log_starting_stopping_reloading(u, JOB_START);
1202 unit_status_print_starting_stopping(u, JOB_START);
1204 /* If it is stopped, but we cannot start it, then fail */
1205 if (!UNIT_VTABLE(u)->start)
1208 /* We don't suppress calls to ->start() here when we are
1209 * already starting, to allow this request to be used as a
1210 * "hurry up" call, for example when the unit is in some "auto
1211 * restart" state where it waits for a holdoff timer to elapse
1212 * before it will start again. */
1214 unit_add_to_dbus_queue(u);
1216 return UNIT_VTABLE(u)->start(u);
1219 bool unit_can_start(Unit *u) {
1222 return !!UNIT_VTABLE(u)->start;
1225 bool unit_can_isolate(Unit *u) {
1228 return unit_can_start(u) &&
1233 * -EBADR: This unit type does not support stopping.
1234 * -EALREADY: Unit is already stopped.
1235 * -EAGAIN: An operation is already in progress. Retry later.
1237 int unit_stop(Unit *u) {
1238 UnitActiveState state;
1243 state = unit_active_state(u);
1244 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1247 if ((following = unit_following(u))) {
1248 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1249 u->id, following->id);
1250 return unit_stop(following);
1253 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1254 unit_status_print_starting_stopping(u, JOB_STOP);
1256 if (!UNIT_VTABLE(u)->stop)
1259 unit_add_to_dbus_queue(u);
1261 return UNIT_VTABLE(u)->stop(u);
1265 * -EBADR: This unit type does not support reloading.
1266 * -ENOEXEC: Unit is not started.
1267 * -EAGAIN: An operation is already in progress. Retry later.
1269 int unit_reload(Unit *u) {
1270 UnitActiveState state;
1275 if (u->load_state != UNIT_LOADED)
1278 if (!unit_can_reload(u))
1281 state = unit_active_state(u);
1282 if (state == UNIT_RELOADING)
1285 if (state != UNIT_ACTIVE)
1288 following = unit_following(u);
1290 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1291 u->id, following->id);
1292 return unit_reload(following);
1295 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1297 unit_add_to_dbus_queue(u);
1298 return UNIT_VTABLE(u)->reload(u);
1301 bool unit_can_reload(Unit *u) {
1304 if (!UNIT_VTABLE(u)->reload)
1307 if (!UNIT_VTABLE(u)->can_reload)
1310 return UNIT_VTABLE(u)->can_reload(u);
1313 static void unit_check_unneeded(Unit *u) {
1319 /* If this service shall be shut down when unneeded then do
1322 if (!u->stop_when_unneeded)
1325 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1328 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1329 if (unit_active_or_pending(other))
1332 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1333 if (unit_active_or_pending(other))
1336 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1337 if (unit_active_or_pending(other))
1340 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1341 if (unit_active_or_pending(other))
1344 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1346 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1347 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1350 static void retroactively_start_dependencies(Unit *u) {
1355 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1357 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1358 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1359 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1360 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1362 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1363 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1364 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1365 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1367 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1368 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1369 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1370 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1372 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1373 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1374 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1375 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1377 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1378 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1379 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1381 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1382 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1383 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1386 static void retroactively_stop_dependencies(Unit *u) {
1391 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1393 /* Pull down units which are bound to us recursively if enabled */
1394 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1395 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1396 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1399 static void check_unneeded_dependencies(Unit *u) {
1404 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1406 /* Garbage collect services that might not be needed anymore, if enabled */
1407 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1408 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1409 unit_check_unneeded(other);
1410 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1411 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1412 unit_check_unneeded(other);
1413 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1414 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1415 unit_check_unneeded(other);
1416 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1417 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1418 unit_check_unneeded(other);
1419 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1420 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1421 unit_check_unneeded(other);
1422 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1423 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1424 unit_check_unneeded(other);
1427 void unit_start_on_failure(Unit *u) {
1433 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1436 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1438 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1441 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL);
1443 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1447 void unit_trigger_notify(Unit *u) {
1453 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1454 if (UNIT_VTABLE(other)->trigger_notify)
1455 UNIT_VTABLE(other)->trigger_notify(other, u);
1458 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1463 assert(os < _UNIT_ACTIVE_STATE_MAX);
1464 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1466 /* Note that this is called for all low-level state changes,
1467 * even if they might map to the same high-level
1468 * UnitActiveState! That means that ns == os is OK an expected
1469 * behavior here. For example: if a mount point is remounted
1470 * this function will be called too! */
1474 if (m->n_reloading <= 0) {
1477 dual_timestamp_get(&ts);
1479 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1480 u->inactive_exit_timestamp = ts;
1481 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1482 u->inactive_enter_timestamp = ts;
1484 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1485 u->active_enter_timestamp = ts;
1486 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1487 u->active_exit_timestamp = ts;
1490 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1491 unit_destroy_cgroup(u);
1493 /* Note that this doesn't apply to RemainAfterExit services exiting
1494 * sucessfully, since there's no change of state in that case. Which is
1495 * why it is handled in service_set_state() */
1496 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1497 ExecContext *ec = unit_get_exec_context(u);
1498 if (ec && exec_context_may_touch_console(ec)) {
1499 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1502 if (m->n_on_console == 0)
1503 /* unset no_console_output flag, since the console is free */
1504 m->no_console_output = false;
1513 if (u->job->state == JOB_WAITING)
1515 /* So we reached a different state for this
1516 * job. Let's see if we can run it now if it
1517 * failed previously due to EAGAIN. */
1518 job_add_to_run_queue(u->job);
1520 /* Let's check whether this state change constitutes a
1521 * finished job, or maybe contradicts a running job and
1522 * hence needs to invalidate jobs. */
1524 switch (u->job->type) {
1527 case JOB_VERIFY_ACTIVE:
1529 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1530 job_finish_and_invalidate(u->job, JOB_DONE, true);
1531 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1534 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1535 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1541 case JOB_RELOAD_OR_START:
1543 if (u->job->state == JOB_RUNNING) {
1544 if (ns == UNIT_ACTIVE)
1545 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1546 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1549 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1550 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1558 case JOB_TRY_RESTART:
1560 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1561 job_finish_and_invalidate(u->job, JOB_DONE, true);
1562 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1564 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1570 assert_not_reached("Job type unknown");
1576 if (m->n_reloading <= 0) {
1578 /* If this state change happened without being
1579 * requested by a job, then let's retroactively start
1580 * or stop dependencies. We skip that step when
1581 * deserializing, since we don't want to create any
1582 * additional jobs just because something is already
1586 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1587 retroactively_start_dependencies(u);
1588 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1589 retroactively_stop_dependencies(u);
1592 /* stop unneeded units regardless if going down was expected or not */
1593 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1594 check_unneeded_dependencies(u);
1596 if (ns != os && ns == UNIT_FAILED) {
1597 log_notice_unit(u->id,
1598 "Unit %s entered failed state.", u->id);
1599 unit_start_on_failure(u);
1603 /* Some names are special */
1604 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1606 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1607 /* The bus just might have become available,
1608 * hence try to connect to it, if we aren't
1612 if (u->type == UNIT_SERVICE &&
1613 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1614 m->n_reloading <= 0) {
1615 /* Write audit record if we have just finished starting up */
1616 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1620 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1621 manager_send_unit_plymouth(m, u);
1625 /* We don't care about D-Bus here, since we'll get an
1626 * asynchronous notification for it anyway. */
1628 if (u->type == UNIT_SERVICE &&
1629 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1630 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1631 m->n_reloading <= 0) {
1633 /* Hmm, if there was no start record written
1634 * write it now, so that we always have a nice
1637 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1639 if (ns == UNIT_INACTIVE)
1640 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1642 /* Write audit record if we have just finished shutting down */
1643 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1645 u->in_audit = false;
1649 manager_recheck_journal(m);
1650 unit_trigger_notify(u);
1652 /* Maybe we finished startup and are now ready for being
1653 * stopped because unneeded? */
1654 if (u->manager->n_reloading <= 0)
1655 unit_check_unneeded(u);
1657 unit_add_to_dbus_queue(u);
1658 unit_add_to_gc_queue(u);
1661 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1662 struct epoll_event ev = {
1670 assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1672 if (epoll_ctl(u->manager->epoll_fd,
1673 w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1685 void unit_unwatch_fd(Unit *u, Watch *w) {
1689 if (w->type == WATCH_INVALID)
1692 assert(w->type == WATCH_FD);
1693 assert(w->data.unit == u);
1694 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1697 w->type = WATCH_INVALID;
1698 w->data.unit = NULL;
1701 int unit_watch_pid(Unit *u, pid_t pid) {
1705 /* Watch a specific PID. We only support one unit watching
1706 * each PID for now. */
1708 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1711 void unit_unwatch_pid(Unit *u, pid_t pid) {
1715 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1718 int unit_watch_timer(Unit *u, clockid_t clock_id, bool relative, usec_t usec, Watch *w) {
1719 struct itimerspec its = {};
1725 assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1727 /* This will try to reuse the old timer if there is one */
1729 if (w->type == WATCH_UNIT_TIMER) {
1730 assert(w->data.unit == u);
1735 } else if (w->type == WATCH_INVALID) {
1738 fd = timerfd_create(clock_id, TFD_NONBLOCK|TFD_CLOEXEC);
1742 assert_not_reached("Invalid watch type");
1745 /* Set absolute time in the past, but not 0, since we
1746 * don't want to disarm the timer */
1747 its.it_value.tv_sec = 0;
1748 its.it_value.tv_nsec = 1;
1750 flags = TFD_TIMER_ABSTIME;
1752 timespec_store(&its.it_value, usec);
1753 flags = relative ? 0 : TFD_TIMER_ABSTIME;
1756 /* This will also flush the elapse counter */
1757 if (timerfd_settime(fd, flags, &its, NULL) < 0)
1760 if (w->type == WATCH_INVALID) {
1761 struct epoll_event ev = {
1766 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1770 w->type = WATCH_UNIT_TIMER;
1778 close_nointr_nofail(fd);
1783 void unit_unwatch_timer(Unit *u, Watch *w) {
1787 if (w->type == WATCH_INVALID)
1790 assert(w->type == WATCH_UNIT_TIMER);
1791 assert(w->data.unit == u);
1794 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1795 close_nointr_nofail(w->fd);
1798 w->type = WATCH_INVALID;
1799 w->data.unit = NULL;
1802 bool unit_job_is_applicable(Unit *u, JobType j) {
1804 assert(j >= 0 && j < _JOB_TYPE_MAX);
1808 case JOB_VERIFY_ACTIVE:
1815 case JOB_TRY_RESTART:
1816 return unit_can_start(u);
1819 return unit_can_reload(u);
1821 case JOB_RELOAD_OR_START:
1822 return unit_can_reload(u) && unit_can_start(u);
1825 assert_not_reached("Invalid job type");
1829 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1831 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1832 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1833 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1834 [UNIT_WANTS] = UNIT_WANTED_BY,
1835 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1836 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1837 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1838 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1839 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1840 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1841 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1842 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1843 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1844 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1845 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1846 [UNIT_BEFORE] = UNIT_AFTER,
1847 [UNIT_AFTER] = UNIT_BEFORE,
1848 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1849 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1850 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1851 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1852 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1853 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1854 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1856 int r, q = 0, v = 0, w = 0;
1859 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1862 u = unit_follow_merge(u);
1863 other = unit_follow_merge(other);
1865 /* We won't allow dependencies on ourselves. We will not
1866 * consider them an error however. */
1870 if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1873 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1874 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1878 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1879 (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1882 if ((q = set_put(u->dependencies[d], other)) < 0)
1885 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1886 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1891 if (add_reference) {
1892 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1897 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1901 unit_add_to_dbus_queue(u);
1906 set_remove(u->dependencies[d], other);
1909 set_remove(other->dependencies[inverse_table[d]], u);
1912 set_remove(u->dependencies[UNIT_REFERENCES], other);
1917 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1922 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1925 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1931 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1935 assert(name || path);
1939 name = path_get_file_name(path);
1941 if (!unit_name_is_template(name)) {
1947 s = unit_name_replace_instance(name, u->instance);
1949 _cleanup_free_ char *i = NULL;
1951 i = unit_name_to_prefix(u->id);
1955 s = unit_name_replace_instance(name, i);
1965 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1968 _cleanup_free_ char *s = NULL;
1971 assert(name || path);
1973 name = resolve_template(u, name, path, &s);
1977 r = manager_load_unit(u->manager, name, path, NULL, &other);
1981 return unit_add_dependency(u, d, other, add_reference);
1984 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1987 _cleanup_free_ char *s = NULL;
1990 assert(name || path);
1992 if (!(name = resolve_template(u, name, path, &s)))
1995 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1998 r = unit_add_two_dependencies(u, d, e, other, add_reference);
2003 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2006 _cleanup_free_ char *s = NULL;
2009 assert(name || path);
2011 if (!(name = resolve_template(u, name, path, &s)))
2014 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2017 r = unit_add_dependency(other, d, u, add_reference);
2022 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2025 _cleanup_free_ char *s = NULL;
2028 assert(name || path);
2030 if (!(name = resolve_template(u, name, path, &s)))
2033 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2036 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
2042 int set_unit_path(const char *p) {
2043 _cleanup_free_ char *c = NULL;
2045 /* This is mostly for debug purposes */
2046 c = path_make_absolute_cwd(p);
2047 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
2053 char *unit_dbus_path(Unit *u) {
2059 return unit_dbus_path_from_name(u->id);
2062 char *unit_default_cgroup_path(Unit *u) {
2063 _cleanup_free_ char *escaped = NULL, *slice = NULL;
2068 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2069 return strdup(u->manager->cgroup_root);
2071 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2072 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2077 escaped = cg_escape(u->id);
2082 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2084 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2087 int unit_add_default_slice(Unit *u) {
2088 _cleanup_free_ char *b = NULL;
2089 const char *slice_name;
2095 if (UNIT_ISSET(u->slice))
2098 if (!unit_get_cgroup_context(u))
2102 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2104 /* Implicitly place all instantiated units in their
2105 * own per-template slice */
2107 prefix = unit_name_to_prefix(u->id);
2111 /* The prefix is already escaped, but it might include
2112 * "-" which has a special meaning for slice units,
2113 * hence escape it here extra. */
2114 escaped = strreplace(prefix, "-", "\\x2d");
2118 if (u->manager->running_as == SYSTEMD_SYSTEM)
2119 b = strjoin("system-", escaped, ".slice", NULL);
2121 b = strappend(escaped, ".slice");
2128 u->manager->running_as == SYSTEMD_SYSTEM
2129 ? SPECIAL_SYSTEM_SLICE
2130 : SPECIAL_ROOT_SLICE;
2132 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2136 unit_ref_set(&u->slice, slice);
2140 const char *unit_slice_name(Unit *u) {
2143 if (!UNIT_ISSET(u->slice))
2146 return UNIT_DEREF(u->slice)->id;
2149 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2150 _cleanup_free_ char *t = NULL;
2157 t = unit_name_change_suffix(u->id, type);
2161 assert(!unit_has_name(u, t));
2163 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2164 assert(r < 0 || *_found != u);
2168 int unit_watch_bus_name(Unit *u, const char *name) {
2172 /* Watch a specific name on the bus. We only support one unit
2173 * watching each name for now. */
2175 return hashmap_put(u->manager->watch_bus, name, u);
2178 void unit_unwatch_bus_name(Unit *u, const char *name) {
2182 hashmap_remove_value(u->manager->watch_bus, name, u);
2185 bool unit_can_serialize(Unit *u) {
2188 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2191 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2198 if (!unit_can_serialize(u))
2201 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2206 if (serialize_jobs) {
2208 fprintf(f, "job\n");
2209 job_serialize(u->job, f, fds);
2213 fprintf(f, "job\n");
2214 job_serialize(u->nop_job, f, fds);
2218 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2219 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2220 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2221 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2222 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2224 if (dual_timestamp_is_set(&u->condition_timestamp))
2225 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2227 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2230 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2237 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2248 va_start(ap, format);
2249 vfprintf(f, format, ap);
2255 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2261 fprintf(f, "%s=%s\n", key, value);
2264 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2271 if (!unit_can_serialize(u))
2275 char line[LINE_MAX], *l, *v;
2278 if (!fgets(line, sizeof(line), f)) {
2291 k = strcspn(l, "=");
2299 if (streq(l, "job")) {
2301 /* new-style serialized job */
2302 Job *j = job_new_raw(u);
2306 r = job_deserialize(j, f, fds);
2312 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2318 r = job_install_deserialized(j);
2320 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2325 if (j->state == JOB_RUNNING)
2326 u->manager->n_running_jobs++;
2329 JobType type = job_type_from_string(v);
2331 log_debug("Failed to parse job type value %s", v);
2333 u->deserialized_job = type;
2336 } else if (streq(l, "inactive-exit-timestamp")) {
2337 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2339 } else if (streq(l, "active-enter-timestamp")) {
2340 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2342 } else if (streq(l, "active-exit-timestamp")) {
2343 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2345 } else if (streq(l, "inactive-enter-timestamp")) {
2346 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2348 } else if (streq(l, "condition-timestamp")) {
2349 dual_timestamp_deserialize(v, &u->condition_timestamp);
2351 } else if (streq(l, "condition-result")) {
2354 b = parse_boolean(v);
2356 log_debug("Failed to parse condition result value %s", v);
2358 u->condition_result = b;
2362 } else if (streq(l, "transient")) {
2365 b = parse_boolean(v);
2367 log_debug("Failed to parse transient bool %s", v);
2372 } else if (streq(l, "cgroup")) {
2379 free(u->cgroup_path);
2382 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2386 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2392 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2394 _cleanup_free_ char *e = NULL;
2402 /* Adds in links to the device node that this unit is based on */
2404 if (!is_device_path(what))
2407 e = unit_name_from_path(what, ".device");
2411 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2416 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2421 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2429 int unit_coldplug(Unit *u) {
2434 if (UNIT_VTABLE(u)->coldplug)
2435 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2439 r = job_coldplug(u->job);
2442 } else if (u->deserialized_job >= 0) {
2444 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2448 u->deserialized_job = _JOB_TYPE_INVALID;
2454 #pragma GCC diagnostic push
2455 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
2456 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2457 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2459 #pragma GCC diagnostic pop
2461 bool unit_need_daemon_reload(Unit *u) {
2462 _cleanup_strv_free_ char **t = NULL;
2465 unsigned loaded_cnt, current_cnt;
2469 if (u->fragment_path) {
2471 if (stat(u->fragment_path, &st) < 0)
2472 /* What, cannot access this anymore? */
2475 if (u->fragment_mtime > 0 &&
2476 timespec_load(&st.st_mtim) != u->fragment_mtime)
2480 if (u->source_path) {
2482 if (stat(u->source_path, &st) < 0)
2485 if (u->source_mtime > 0 &&
2486 timespec_load(&st.st_mtim) != u->source_mtime)
2490 t = unit_find_dropin_paths(u);
2491 loaded_cnt = strv_length(t);
2492 current_cnt = strv_length(u->dropin_paths);
2494 if (loaded_cnt == current_cnt) {
2495 if (loaded_cnt == 0)
2498 if (strv_overlap(u->dropin_paths, t)) {
2499 STRV_FOREACH(path, u->dropin_paths) {
2501 if (stat(*path, &st) < 0)
2504 if (u->dropin_mtime > 0 &&
2505 timespec_load(&st.st_mtim) > u->dropin_mtime)
2516 void unit_reset_failed(Unit *u) {
2519 if (UNIT_VTABLE(u)->reset_failed)
2520 UNIT_VTABLE(u)->reset_failed(u);
2523 Unit *unit_following(Unit *u) {
2526 if (UNIT_VTABLE(u)->following)
2527 return UNIT_VTABLE(u)->following(u);
2532 bool unit_stop_pending(Unit *u) {
2535 /* This call does check the current state of the unit. It's
2536 * hence useful to be called from state change calls of the
2537 * unit itself, where the state isn't updated yet. This is
2538 * different from unit_inactive_or_pending() which checks both
2539 * the current state and for a queued job. */
2541 return u->job && u->job->type == JOB_STOP;
2544 bool unit_inactive_or_pending(Unit *u) {
2547 /* Returns true if the unit is inactive or going down */
2549 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2552 if (unit_stop_pending(u))
2558 bool unit_active_or_pending(Unit *u) {
2561 /* Returns true if the unit is active or going up */
2563 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2567 (u->job->type == JOB_START ||
2568 u->job->type == JOB_RELOAD_OR_START ||
2569 u->job->type == JOB_RESTART))
2575 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2577 assert(w >= 0 && w < _KILL_WHO_MAX);
2579 assert(signo < _NSIG);
2581 if (!UNIT_VTABLE(u)->kill)
2584 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2587 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2591 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2595 /* Exclude the main/control pids from being killed via the cgroup */
2597 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2602 if (control_pid > 0) {
2603 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2615 int unit_kill_common(
2625 if (who == KILL_MAIN && main_pid <= 0) {
2627 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2629 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2633 if (who == KILL_CONTROL && control_pid <= 0) {
2634 if (control_pid < 0)
2635 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2637 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2641 if (who == KILL_CONTROL || who == KILL_ALL)
2642 if (control_pid > 0)
2643 if (kill(control_pid, signo) < 0)
2646 if (who == KILL_MAIN || who == KILL_ALL)
2648 if (kill(main_pid, signo) < 0)
2651 if (who == KILL_ALL && u->cgroup_path) {
2652 _cleanup_set_free_ Set *pid_set = NULL;
2655 /* Exclude the main/control pids from being killed via the cgroup */
2656 pid_set = unit_pid_set(main_pid, control_pid);
2660 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2661 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2668 int unit_following_set(Unit *u, Set **s) {
2672 if (UNIT_VTABLE(u)->following_set)
2673 return UNIT_VTABLE(u)->following_set(u, s);
2679 UnitFileState unit_get_unit_file_state(Unit *u) {
2682 if (u->unit_file_state < 0 && u->fragment_path)
2683 u->unit_file_state = unit_file_get_state(
2684 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2685 NULL, path_get_file_name(u->fragment_path));
2687 return u->unit_file_state;
2690 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2695 unit_ref_unset(ref);
2698 LIST_PREPEND(refs, u->refs, ref);
2702 void unit_ref_unset(UnitRef *ref) {
2708 LIST_REMOVE(refs, ref->unit->refs, ref);
2712 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2719 /* This only copies in the ones that need memory */
2720 for (i = 0; i < RLIMIT_NLIMITS; i++)
2721 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2722 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2727 if (u->manager->running_as == SYSTEMD_USER &&
2728 !c->working_directory) {
2730 r = get_home_dir(&c->working_directory);
2738 ExecContext *unit_get_exec_context(Unit *u) {
2742 offset = UNIT_VTABLE(u)->exec_context_offset;
2746 return (ExecContext*) ((uint8_t*) u + offset);
2749 CGroupContext *unit_get_cgroup_context(Unit *u) {
2752 offset = UNIT_VTABLE(u)->cgroup_context_offset;
2756 return (CGroupContext*) ((uint8_t*) u + offset);
2759 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2760 _cleanup_free_ char *b = NULL;
2768 assert(mode & (UNIT_PERSISTENT|UNIT_RUNTIME));
2770 b = xescape(name, "/.");
2774 if (!filename_is_safe(b))
2777 if (u->manager->running_as == SYSTEMD_USER) {
2778 _cleanup_free_ char *c = NULL;
2780 r = user_config_home(&c);
2786 p = strjoin(c, "/", u->id, ".d", NULL);
2787 } else if (mode & UNIT_PERSISTENT)
2788 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2790 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2794 q = strjoin(p, "/90-", b, ".conf", NULL);
2805 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2806 _cleanup_free_ char *p = NULL, *q = NULL;
2813 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2816 r = drop_in_file(u, mode, name, &p, &q);
2821 return write_string_file_atomic_label(q, data);
2824 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2825 _cleanup_free_ char *p = NULL;
2833 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2836 va_start(ap, format);
2837 r = vasprintf(&p, format, ap);
2843 return unit_write_drop_in(u, mode, name, p);
2846 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2847 _cleanup_free_ char *ndata = NULL;
2853 if (!UNIT_VTABLE(u)->private_section)
2856 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2859 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
2863 return unit_write_drop_in(u, mode, name, ndata);
2866 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2867 _cleanup_free_ char *p = NULL;
2875 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2878 va_start(ap, format);
2879 r = vasprintf(&p, format, ap);
2885 return unit_write_drop_in_private(u, mode, name, p);
2888 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
2889 _cleanup_free_ char *p = NULL, *q = NULL;
2894 if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2897 r = drop_in_file(u, mode, name, &p, &q);
2902 r = errno == ENOENT ? 0 : -errno;
2910 int unit_make_transient(Unit *u) {
2915 u->load_state = UNIT_STUB;
2917 u->transient = true;
2919 free(u->fragment_path);
2920 u->fragment_path = NULL;
2922 if (u->manager->running_as == SYSTEMD_USER) {
2923 _cleanup_free_ char *c = NULL;
2925 r = user_config_home(&c);
2931 u->fragment_path = strjoin(c, "/", u->id, NULL);
2932 if (!u->fragment_path)
2937 u->fragment_path = strappend("/run/systemd/system/", u->id);
2938 if (!u->fragment_path)
2941 mkdir_p("/run/systemd/system", 0755);
2944 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
2947 int unit_kill_context(
2953 bool main_pid_alien) {
2955 int sig, wait_for_exit = 0, r;
2960 if (c->kill_mode == KILL_NONE)
2963 sig = sigkill ? SIGKILL : c->kill_signal;
2966 r = kill_and_sigcont(main_pid, sig);
2968 if (r < 0 && r != -ESRCH) {
2969 _cleanup_free_ char *comm = NULL;
2970 get_process_comm(main_pid, &comm);
2972 log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2973 (long) main_pid, strna(comm), strerror(-r));
2975 wait_for_exit = !main_pid_alien;
2978 kill(main_pid, SIGHUP);
2982 if (control_pid > 0) {
2983 r = kill_and_sigcont(control_pid, sig);
2985 if (r < 0 && r != -ESRCH) {
2986 _cleanup_free_ char *comm = NULL;
2987 get_process_comm(control_pid, &comm);
2989 log_warning_unit(u->id,
2990 "Failed to kill control process %li (%s): %s",
2991 (long) control_pid, strna(comm), strerror(-r));
2993 wait_for_exit = true;
2996 kill(control_pid, SIGHUP);
3000 if (c->kill_mode == KILL_CONTROL_GROUP && u->cgroup_path) {
3001 _cleanup_set_free_ Set *pid_set = NULL;
3003 /* Exclude the main/control pids from being killed via the cgroup */
3004 pid_set = unit_pid_set(main_pid, control_pid);
3008 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3010 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3011 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3013 wait_for_exit = true;
3014 if (c->send_sighup) {
3017 pid_set = unit_pid_set(main_pid, control_pid);
3021 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, true, true, false, pid_set);
3026 return wait_for_exit;
3029 int unit_require_mounts_for(Unit *u, const char *path) {
3030 char prefix[strlen(path) + 1], *p;
3036 /* Registers a unit for requiring a certain path and all its
3037 * prefixes. We keep a simple array of these paths in the
3038 * unit, since its usually short. However, we build a prefix
3039 * table for all possible prefixes so that new appearing mount
3040 * units can easily determine which units to make themselves a
3047 path_kill_slashes(p);
3049 if (!path_is_absolute(p)) {
3054 if (!path_is_safe(p)) {
3059 if (strv_contains(u->requires_mounts_for, p)) {
3064 r = strv_push(&u->requires_mounts_for, p);
3070 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3073 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3077 if (!u->manager->units_requiring_mounts_for) {
3078 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
3079 if (!u->manager->units_requiring_mounts_for)
3087 x = set_new(NULL, NULL);
3093 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3109 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3110 [UNIT_ACTIVE] = "active",
3111 [UNIT_RELOADING] = "reloading",
3112 [UNIT_INACTIVE] = "inactive",
3113 [UNIT_FAILED] = "failed",
3114 [UNIT_ACTIVATING] = "activating",
3115 [UNIT_DEACTIVATING] = "deactivating"
3118 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3120 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3121 [UNIT_REQUIRES] = "Requires",
3122 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3123 [UNIT_REQUISITE] = "Requisite",
3124 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3125 [UNIT_WANTS] = "Wants",
3126 [UNIT_BINDS_TO] = "BindsTo",
3127 [UNIT_PART_OF] = "PartOf",
3128 [UNIT_REQUIRED_BY] = "RequiredBy",
3129 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3130 [UNIT_WANTED_BY] = "WantedBy",
3131 [UNIT_BOUND_BY] = "BoundBy",
3132 [UNIT_CONSISTS_OF] = "ConsistsOf",
3133 [UNIT_CONFLICTS] = "Conflicts",
3134 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3135 [UNIT_BEFORE] = "Before",
3136 [UNIT_AFTER] = "After",
3137 [UNIT_ON_FAILURE] = "OnFailure",
3138 [UNIT_TRIGGERS] = "Triggers",
3139 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3140 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3141 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3142 [UNIT_REFERENCES] = "References",
3143 [UNIT_REFERENCED_BY] = "ReferencedBy",
3146 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);