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 static void unit_init(Unit *u) {
111 assert(u->type >= 0);
113 cc = unit_get_cgroup_context(u);
115 cgroup_context_init(cc);
117 /* Copy in the manager defaults into the cgroup
118 * context, _before_ the rest of the settings have
119 * been initialized */
121 cc->cpu_accounting = u->manager->default_cpu_accounting;
122 cc->blockio_accounting = u->manager->default_blockio_accounting;
123 cc->memory_accounting = u->manager->default_memory_accounting;
126 ec = unit_get_exec_context(u);
128 exec_context_init(ec);
130 kc = unit_get_kill_context(u);
132 kill_context_init(kc);
134 if (UNIT_VTABLE(u)->init)
135 UNIT_VTABLE(u)->init(u);
138 int unit_add_name(Unit *u, const char *text) {
139 _cleanup_free_ char *s = NULL, *i = NULL;
146 if (unit_name_is_template(text)) {
151 s = unit_name_replace_instance(text, u->instance);
157 if (!unit_name_is_valid(s, TEMPLATE_INVALID))
160 assert_se((t = unit_name_to_type(s)) >= 0);
162 if (u->type != _UNIT_TYPE_INVALID && t != u->type)
165 r = unit_name_to_instance(s, &i);
169 if (i && unit_vtable[t]->no_instances)
172 /* Ensure that this unit is either instanced or not instanced,
174 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i)
177 if (unit_vtable[t]->no_alias &&
178 !set_isempty(u->names) &&
179 !set_get(u->names, s))
182 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES)
185 r = set_put(u->names, s);
193 r = hashmap_put(u->manager->units, s, u);
195 set_remove(u->names, s);
199 if (u->type == _UNIT_TYPE_INVALID) {
204 LIST_PREPEND(units_by_type, u->manager->units_by_type[t], u);
213 unit_add_to_dbus_queue(u);
217 int unit_choose_id(Unit *u, const char *name) {
218 _cleanup_free_ char *t = NULL;
225 if (unit_name_is_template(name)) {
230 t = unit_name_replace_instance(name, u->instance);
237 /* Selects one of the names of this unit as the id */
238 s = set_get(u->names, (char*) name);
242 r = unit_name_to_instance(s, &i);
251 unit_add_to_dbus_queue(u);
256 int unit_set_description(Unit *u, const char *description) {
261 if (isempty(description))
264 s = strdup(description);
269 free(u->description);
272 unit_add_to_dbus_queue(u);
276 bool unit_check_gc(Unit *u) {
279 if (UNIT_VTABLE(u)->no_gc)
291 if (unit_active_state(u) != UNIT_INACTIVE)
297 if (UNIT_VTABLE(u)->check_gc)
298 if (UNIT_VTABLE(u)->check_gc(u))
304 void unit_add_to_load_queue(Unit *u) {
306 assert(u->type != _UNIT_TYPE_INVALID);
308 if (u->load_state != UNIT_STUB || u->in_load_queue)
311 LIST_PREPEND(load_queue, u->manager->load_queue, u);
312 u->in_load_queue = true;
315 void unit_add_to_cleanup_queue(Unit *u) {
318 if (u->in_cleanup_queue)
321 LIST_PREPEND(cleanup_queue, u->manager->cleanup_queue, u);
322 u->in_cleanup_queue = true;
325 void unit_add_to_gc_queue(Unit *u) {
328 if (u->in_gc_queue || u->in_cleanup_queue)
331 if (unit_check_gc(u))
334 LIST_PREPEND(gc_queue, u->manager->gc_queue, u);
335 u->in_gc_queue = true;
337 u->manager->n_in_gc_queue ++;
340 void unit_add_to_dbus_queue(Unit *u) {
342 assert(u->type != _UNIT_TYPE_INVALID);
344 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
347 /* Shortcut things if nobody cares */
348 if (sd_bus_track_count(u->manager->subscribed) <= 0 &&
349 set_isempty(u->manager->private_buses)) {
350 u->sent_dbus_new_signal = true;
354 LIST_PREPEND(dbus_queue, u->manager->dbus_unit_queue, u);
355 u->in_dbus_queue = true;
358 static void bidi_set_free(Unit *u, Set *s) {
364 /* Frees the set and makes sure we are dropped from the
365 * inverse pointers */
367 SET_FOREACH(other, s, i) {
370 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
371 set_remove(other->dependencies[d], u);
373 unit_add_to_gc_queue(other);
379 static void unit_remove_transient(Unit *u) {
387 if (u->fragment_path)
388 unlink(u->fragment_path);
390 STRV_FOREACH(i, u->dropin_paths) {
391 _cleanup_free_ char *p = NULL;
396 r = path_get_parent(*i, &p);
402 static void unit_free_requires_mounts_for(Unit *u) {
405 STRV_FOREACH(j, u->requires_mounts_for) {
406 char s[strlen(*j) + 1];
408 PATH_FOREACH_PREFIX_MORE(s, *j) {
412 x = hashmap_get2(u->manager->units_requiring_mounts_for, s, (void**) &y);
418 if (set_isempty(x)) {
419 hashmap_remove(u->manager->units_requiring_mounts_for, y);
426 strv_free(u->requires_mounts_for);
427 u->requires_mounts_for = NULL;
430 static void unit_done(Unit *u) {
439 if (UNIT_VTABLE(u)->done)
440 UNIT_VTABLE(u)->done(u);
442 ec = unit_get_exec_context(u);
444 exec_context_done(ec);
446 cc = unit_get_cgroup_context(u);
448 cgroup_context_done(cc);
451 void unit_free(Unit *u) {
458 if (u->manager->n_reloading <= 0)
459 unit_remove_transient(u);
461 bus_unit_send_removed_signal(u);
465 unit_free_requires_mounts_for(u);
467 SET_FOREACH(t, u->names, i)
468 hashmap_remove_value(u->manager->units, t, u);
482 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
483 bidi_set_free(u, u->dependencies[d]);
485 if (u->type != _UNIT_TYPE_INVALID)
486 LIST_REMOVE(units_by_type, u->manager->units_by_type[u->type], u);
488 if (u->in_load_queue)
489 LIST_REMOVE(load_queue, u->manager->load_queue, u);
491 if (u->in_dbus_queue)
492 LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
494 if (u->in_cleanup_queue)
495 LIST_REMOVE(cleanup_queue, u->manager->cleanup_queue, u);
497 if (u->in_gc_queue) {
498 LIST_REMOVE(gc_queue, u->manager->gc_queue, u);
499 u->manager->n_in_gc_queue--;
502 if (u->in_cgroup_queue)
503 LIST_REMOVE(cgroup_queue, u->manager->cgroup_queue, u);
505 if (u->cgroup_path) {
506 hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
507 free(u->cgroup_path);
510 set_remove(u->manager->failed_units, u);
511 set_remove(u->manager->startup_units, u);
513 free(u->description);
514 strv_free(u->documentation);
515 free(u->fragment_path);
516 free(u->source_path);
517 strv_free(u->dropin_paths);
520 set_free_free(u->names);
522 unit_unwatch_all_pids(u);
524 condition_free_list(u->conditions);
526 unit_ref_unset(&u->slice);
529 unit_ref_unset(u->refs);
534 UnitActiveState unit_active_state(Unit *u) {
537 if (u->load_state == UNIT_MERGED)
538 return unit_active_state(unit_follow_merge(u));
540 /* After a reload it might happen that a unit is not correctly
541 * loaded but still has a process around. That's why we won't
542 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
544 return UNIT_VTABLE(u)->active_state(u);
547 const char* unit_sub_state_to_string(Unit *u) {
550 return UNIT_VTABLE(u)->sub_state_to_string(u);
553 static void complete_move(Set **s, Set **other) {
561 set_move(*s, *other);
568 static void merge_names(Unit *u, Unit *other) {
575 complete_move(&u->names, &other->names);
577 set_free_free(other->names);
581 SET_FOREACH(t, u->names, i)
582 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
585 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
592 assert(d < _UNIT_DEPENDENCY_MAX);
594 /* Fix backwards pointers */
595 SET_FOREACH(back, other->dependencies[d], i) {
598 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {
599 r = set_remove_and_put(back->dependencies[k], other, u);
601 set_remove(back->dependencies[k], other);
603 assert(r >= 0 || r == -ENOENT);
607 complete_move(&u->dependencies[d], &other->dependencies[d]);
609 set_free(other->dependencies[d]);
610 other->dependencies[d] = NULL;
613 int unit_merge(Unit *u, Unit *other) {
618 assert(u->manager == other->manager);
619 assert(u->type != _UNIT_TYPE_INVALID);
621 other = unit_follow_merge(other);
626 if (u->type != other->type)
629 if (!u->instance != !other->instance)
632 if (other->load_state != UNIT_STUB &&
633 other->load_state != UNIT_NOT_FOUND)
642 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
646 merge_names(u, other);
648 /* Redirect all references */
650 unit_ref_set(other->refs, u);
652 /* Merge dependencies */
653 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
654 merge_dependencies(u, other, d);
656 other->load_state = UNIT_MERGED;
657 other->merged_into = u;
659 /* If there is still some data attached to the other node, we
660 * don't need it anymore, and can free it. */
661 if (other->load_state != UNIT_STUB)
662 if (UNIT_VTABLE(other)->done)
663 UNIT_VTABLE(other)->done(other);
665 unit_add_to_dbus_queue(u);
666 unit_add_to_cleanup_queue(other);
671 int unit_merge_by_name(Unit *u, const char *name) {
674 _cleanup_free_ char *s = NULL;
679 if (unit_name_is_template(name)) {
683 s = unit_name_replace_instance(name, u->instance);
690 other = manager_get_unit(u->manager, name);
692 r = unit_add_name(u, name);
694 r = unit_merge(u, other);
699 Unit* unit_follow_merge(Unit *u) {
702 while (u->load_state == UNIT_MERGED)
703 assert_se(u = u->merged_into);
708 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
714 if (c->working_directory) {
715 r = unit_require_mounts_for(u, c->working_directory);
720 if (c->root_directory) {
721 r = unit_require_mounts_for(u, c->root_directory);
726 if (u->manager->running_as != SYSTEMD_SYSTEM)
729 if (c->private_tmp) {
730 r = unit_require_mounts_for(u, "/tmp");
734 r = unit_require_mounts_for(u, "/var/tmp");
739 if (c->std_output != EXEC_OUTPUT_KMSG &&
740 c->std_output != EXEC_OUTPUT_SYSLOG &&
741 c->std_output != EXEC_OUTPUT_JOURNAL &&
742 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
743 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
744 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
745 c->std_error != EXEC_OUTPUT_KMSG &&
746 c->std_error != EXEC_OUTPUT_SYSLOG &&
747 c->std_error != EXEC_OUTPUT_JOURNAL &&
748 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
749 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
750 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
753 /* If syslog or kernel logging is requested, make sure our own
754 * logging daemon is run first. */
756 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
763 const char *unit_description(Unit *u) {
767 return u->description;
772 void unit_dump(Unit *u, FILE *f, const char *prefix) {
776 _cleanup_free_ char *p2 = NULL;
779 timestamp1[FORMAT_TIMESTAMP_MAX],
780 timestamp2[FORMAT_TIMESTAMP_MAX],
781 timestamp3[FORMAT_TIMESTAMP_MAX],
782 timestamp4[FORMAT_TIMESTAMP_MAX],
783 timespan[FORMAT_TIMESPAN_MAX];
785 _cleanup_set_free_ Set *following_set = NULL;
789 assert(u->type >= 0);
793 p2 = strappend(prefix, "\t");
794 prefix2 = p2 ? p2 : prefix;
798 "%s\tDescription: %s\n"
800 "%s\tUnit Load State: %s\n"
801 "%s\tUnit Active State: %s\n"
802 "%s\tInactive Exit Timestamp: %s\n"
803 "%s\tActive Enter Timestamp: %s\n"
804 "%s\tActive Exit Timestamp: %s\n"
805 "%s\tInactive Enter Timestamp: %s\n"
806 "%s\tGC Check Good: %s\n"
807 "%s\tNeed Daemon Reload: %s\n"
808 "%s\tTransient: %s\n"
811 "%s\tCGroup realized: %s\n"
812 "%s\tCGroup mask: 0x%x\n"
813 "%s\tCGroup members mask: 0x%x\n",
815 prefix, unit_description(u),
816 prefix, strna(u->instance),
817 prefix, unit_load_state_to_string(u->load_state),
818 prefix, unit_active_state_to_string(unit_active_state(u)),
819 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
820 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
821 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
822 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
823 prefix, yes_no(unit_check_gc(u)),
824 prefix, yes_no(unit_need_daemon_reload(u)),
825 prefix, yes_no(u->transient),
826 prefix, strna(unit_slice_name(u)),
827 prefix, strna(u->cgroup_path),
828 prefix, yes_no(u->cgroup_realized),
829 prefix, u->cgroup_realized_mask,
830 prefix, u->cgroup_members_mask);
832 SET_FOREACH(t, u->names, i)
833 fprintf(f, "%s\tName: %s\n", prefix, t);
835 STRV_FOREACH(j, u->documentation)
836 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
838 following = unit_following(u);
840 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
842 r = unit_following_set(u, &following_set);
846 SET_FOREACH(other, following_set, i)
847 fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
850 if (u->fragment_path)
851 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
854 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
856 STRV_FOREACH(j, u->dropin_paths)
857 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
859 if (u->job_timeout > 0)
860 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
862 condition_dump_list(u->conditions, f, prefix);
864 if (dual_timestamp_is_set(&u->condition_timestamp))
866 "%s\tCondition Timestamp: %s\n"
867 "%s\tCondition Result: %s\n",
868 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
869 prefix, yes_no(u->condition_result));
871 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
874 SET_FOREACH(other, u->dependencies[d], i)
875 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
878 if (!strv_isempty(u->requires_mounts_for)) {
880 "%s\tRequiresMountsFor:", prefix);
882 STRV_FOREACH(j, u->requires_mounts_for)
883 fprintf(f, " %s", *j);
888 if (u->load_state == UNIT_LOADED) {
891 "%s\tStopWhenUnneeded: %s\n"
892 "%s\tRefuseManualStart: %s\n"
893 "%s\tRefuseManualStop: %s\n"
894 "%s\tDefaultDependencies: %s\n"
895 "%s\tOnFailureJobMode: %s\n"
896 "%s\tIgnoreOnIsolate: %s\n"
897 "%s\tIgnoreOnSnapshot: %s\n",
898 prefix, yes_no(u->stop_when_unneeded),
899 prefix, yes_no(u->refuse_manual_start),
900 prefix, yes_no(u->refuse_manual_stop),
901 prefix, yes_no(u->default_dependencies),
902 prefix, job_mode_to_string(u->on_failure_job_mode),
903 prefix, yes_no(u->ignore_on_isolate),
904 prefix, yes_no(u->ignore_on_snapshot));
906 if (UNIT_VTABLE(u)->dump)
907 UNIT_VTABLE(u)->dump(u, f, prefix2);
909 } else if (u->load_state == UNIT_MERGED)
911 "%s\tMerged into: %s\n",
912 prefix, u->merged_into->id);
913 else if (u->load_state == UNIT_ERROR)
914 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
918 job_dump(u->job, f, prefix2);
921 job_dump(u->nop_job, f, prefix2);
925 /* Common implementation for multiple backends */
926 int unit_load_fragment_and_dropin(Unit *u) {
931 /* Load a .{service,socket,...} file */
932 r = unit_load_fragment(u);
936 if (u->load_state == UNIT_STUB)
939 /* Load drop-in directory data */
940 r = unit_load_dropin(unit_follow_merge(u));
947 /* Common implementation for multiple backends */
948 int unit_load_fragment_and_dropin_optional(Unit *u) {
953 /* Same as unit_load_fragment_and_dropin(), but whether
954 * something can be loaded or not doesn't matter. */
956 /* Load a .service file */
957 r = unit_load_fragment(u);
961 if (u->load_state == UNIT_STUB)
962 u->load_state = UNIT_LOADED;
964 /* Load drop-in directory data */
965 r = unit_load_dropin(unit_follow_merge(u));
972 int unit_add_default_target_dependency(Unit *u, Unit *target) {
976 if (target->type != UNIT_TARGET)
979 /* Only add the dependency if both units are loaded, so that
980 * that loop check below is reliable */
981 if (u->load_state != UNIT_LOADED ||
982 target->load_state != UNIT_LOADED)
985 /* If either side wants no automatic dependencies, then let's
987 if (!u->default_dependencies ||
988 !target->default_dependencies)
991 /* Don't create loops */
992 if (set_get(target->dependencies[UNIT_BEFORE], u))
995 return unit_add_dependency(target, UNIT_AFTER, u, true);
998 static int unit_add_target_dependencies(Unit *u) {
1000 static const UnitDependency deps[] = {
1002 UNIT_REQUIRED_BY_OVERRIDABLE,
1014 for (k = 0; k < ELEMENTSOF(deps); k++)
1015 SET_FOREACH(target, u->dependencies[deps[k]], i) {
1016 r = unit_add_default_target_dependency(u, target);
1024 static int unit_add_slice_dependencies(Unit *u) {
1027 if (!unit_get_cgroup_context(u))
1030 if (UNIT_ISSET(u->slice))
1031 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
1033 return unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
1036 static int unit_add_mount_dependencies(Unit *u) {
1042 STRV_FOREACH(i, u->requires_mounts_for) {
1043 char prefix[strlen(*i) + 1];
1045 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
1048 r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
1056 if (m->load_state != UNIT_LOADED)
1059 r = unit_add_dependency(u, UNIT_AFTER, m, true);
1063 if (m->fragment_path) {
1064 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
1074 static int unit_add_startup_units(Unit *u) {
1078 c = unit_get_cgroup_context(u);
1082 if (c->startup_cpu_shares == (unsigned long) -1 &&
1083 c->startup_blockio_weight == (unsigned long) -1)
1086 r = set_put(u->manager->startup_units, u);
1093 int unit_load(Unit *u) {
1098 if (u->in_load_queue) {
1099 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1100 u->in_load_queue = false;
1103 if (u->type == _UNIT_TYPE_INVALID)
1106 if (u->load_state != UNIT_STUB)
1109 if (UNIT_VTABLE(u)->load) {
1110 r = UNIT_VTABLE(u)->load(u);
1115 if (u->load_state == UNIT_STUB) {
1120 if (u->load_state == UNIT_LOADED) {
1122 r = unit_add_target_dependencies(u);
1126 r = unit_add_slice_dependencies(u);
1130 r = unit_add_mount_dependencies(u);
1134 r = unit_add_startup_units(u);
1138 if (u->on_failure_job_mode == JOB_ISOLATE && set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1139 log_error_unit(u->id, "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
1144 unit_update_cgroup_members_masks(u);
1147 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1149 unit_add_to_dbus_queue(unit_follow_merge(u));
1150 unit_add_to_gc_queue(u);
1155 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1157 unit_add_to_dbus_queue(u);
1158 unit_add_to_gc_queue(u);
1160 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
1161 u->id, strerror(-r));
1166 static bool unit_condition_test(Unit *u) {
1169 dual_timestamp_get(&u->condition_timestamp);
1170 u->condition_result = condition_test_list(u->id, u->conditions);
1172 return u->condition_result;
1175 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1176 const UnitStatusMessageFormats *format_table;
1180 assert(t < _JOB_TYPE_MAX);
1182 if (t != JOB_START && t != JOB_STOP)
1185 format_table = &UNIT_VTABLE(u)->status_message_formats;
1189 return format_table->starting_stopping[t == JOB_STOP];
1192 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1197 assert(t < _JOB_TYPE_MAX);
1199 format = unit_get_status_message_format(u, t);
1203 /* Return generic strings */
1205 return "Starting %s.";
1206 else if (t == JOB_STOP)
1207 return "Stopping %s.";
1208 else if (t == JOB_RELOAD)
1209 return "Reloading %s.";
1214 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1219 /* We only print status messages for selected units on
1220 * selected operations. */
1222 format = unit_get_status_message_format(u, t);
1226 DISABLE_WARNING_FORMAT_NONLITERAL;
1227 unit_status_printf(u, "", format);
1231 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1238 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1241 if (log_on_console())
1244 /* We log status messages for all units and all operations. */
1246 format = unit_get_status_message_format_try_harder(u, t);
1250 DISABLE_WARNING_FORMAT_NONLITERAL;
1251 snprintf(buf, sizeof(buf), format, unit_description(u));
1255 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1256 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1257 SD_MESSAGE_UNIT_RELOADING;
1259 log_struct_unit(LOG_INFO,
1267 * -EBADR: This unit type does not support starting.
1268 * -EALREADY: Unit is already started.
1269 * -EAGAIN: An operation is already in progress. Retry later.
1270 * -ECANCELED: Too many requests for now.
1272 int unit_start(Unit *u) {
1273 UnitActiveState state;
1278 if (u->load_state != UNIT_LOADED)
1281 /* If this is already started, then this will succeed. Note
1282 * that this will even succeed if this unit is not startable
1283 * by the user. This is relied on to detect when we need to
1284 * wait for units and when waiting is finished. */
1285 state = unit_active_state(u);
1286 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1289 /* If the conditions failed, don't do anything at all. If we
1290 * already are activating this call might still be useful to
1291 * speed up activation in case there is some hold-off time,
1292 * but we don't want to recheck the condition in that case. */
1293 if (state != UNIT_ACTIVATING &&
1294 !unit_condition_test(u)) {
1295 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1299 /* Forward to the main object, if we aren't it. */
1300 following = unit_following(u);
1302 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1303 u->id, following->id);
1304 return unit_start(following);
1307 unit_status_log_starting_stopping_reloading(u, JOB_START);
1308 unit_status_print_starting_stopping(u, JOB_START);
1310 /* If it is stopped, but we cannot start it, then fail */
1311 if (!UNIT_VTABLE(u)->start)
1314 /* We don't suppress calls to ->start() here when we are
1315 * already starting, to allow this request to be used as a
1316 * "hurry up" call, for example when the unit is in some "auto
1317 * restart" state where it waits for a holdoff timer to elapse
1318 * before it will start again. */
1320 unit_add_to_dbus_queue(u);
1322 return UNIT_VTABLE(u)->start(u);
1325 bool unit_can_start(Unit *u) {
1328 return !!UNIT_VTABLE(u)->start;
1331 bool unit_can_isolate(Unit *u) {
1334 return unit_can_start(u) &&
1339 * -EBADR: This unit type does not support stopping.
1340 * -EALREADY: Unit is already stopped.
1341 * -EAGAIN: An operation is already in progress. Retry later.
1343 int unit_stop(Unit *u) {
1344 UnitActiveState state;
1349 state = unit_active_state(u);
1350 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1353 if ((following = unit_following(u))) {
1354 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1355 u->id, following->id);
1356 return unit_stop(following);
1359 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1360 unit_status_print_starting_stopping(u, JOB_STOP);
1362 if (!UNIT_VTABLE(u)->stop)
1365 unit_add_to_dbus_queue(u);
1367 return UNIT_VTABLE(u)->stop(u);
1371 * -EBADR: This unit type does not support reloading.
1372 * -ENOEXEC: Unit is not started.
1373 * -EAGAIN: An operation is already in progress. Retry later.
1375 int unit_reload(Unit *u) {
1376 UnitActiveState state;
1381 if (u->load_state != UNIT_LOADED)
1384 if (!unit_can_reload(u))
1387 state = unit_active_state(u);
1388 if (state == UNIT_RELOADING)
1391 if (state != UNIT_ACTIVE) {
1392 log_warning_unit(u->id, "Unit %s cannot be reloaded because it is inactive.",
1397 following = unit_following(u);
1399 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1400 u->id, following->id);
1401 return unit_reload(following);
1404 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1406 unit_add_to_dbus_queue(u);
1407 return UNIT_VTABLE(u)->reload(u);
1410 bool unit_can_reload(Unit *u) {
1413 if (!UNIT_VTABLE(u)->reload)
1416 if (!UNIT_VTABLE(u)->can_reload)
1419 return UNIT_VTABLE(u)->can_reload(u);
1422 static void unit_check_unneeded(Unit *u) {
1428 /* If this service shall be shut down when unneeded then do
1431 if (!u->stop_when_unneeded)
1434 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1437 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1438 if (unit_active_or_pending(other))
1441 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1442 if (unit_active_or_pending(other))
1445 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1446 if (unit_active_or_pending(other))
1449 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1450 if (unit_active_or_pending(other))
1453 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1455 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1456 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1459 static void retroactively_start_dependencies(Unit *u) {
1464 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1466 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1467 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1468 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1469 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1471 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1472 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1473 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1474 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1476 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1477 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1478 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1479 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1481 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1482 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1483 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1484 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1486 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1487 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1488 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1490 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1491 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1492 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1495 static void retroactively_stop_dependencies(Unit *u) {
1500 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1502 /* Pull down units which are bound to us recursively if enabled */
1503 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1504 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1505 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1508 static void check_unneeded_dependencies(Unit *u) {
1513 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1515 /* Garbage collect services that might not be needed anymore, if enabled */
1516 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1517 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1518 unit_check_unneeded(other);
1519 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1520 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1521 unit_check_unneeded(other);
1522 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1523 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1524 unit_check_unneeded(other);
1525 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1526 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1527 unit_check_unneeded(other);
1528 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1529 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1530 unit_check_unneeded(other);
1531 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1532 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1533 unit_check_unneeded(other);
1536 void unit_start_on_failure(Unit *u) {
1542 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1545 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1547 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1550 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1552 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1556 void unit_trigger_notify(Unit *u) {
1562 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1563 if (UNIT_VTABLE(other)->trigger_notify)
1564 UNIT_VTABLE(other)->trigger_notify(other, u);
1567 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1572 assert(os < _UNIT_ACTIVE_STATE_MAX);
1573 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1575 /* Note that this is called for all low-level state changes,
1576 * even if they might map to the same high-level
1577 * UnitActiveState! That means that ns == os is an expected
1578 * behavior here. For example: if a mount point is remounted
1579 * this function will be called too! */
1583 /* Update timestamps for state changes */
1584 if (m->n_reloading <= 0) {
1587 dual_timestamp_get(&ts);
1589 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1590 u->inactive_exit_timestamp = ts;
1591 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1592 u->inactive_enter_timestamp = ts;
1594 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1595 u->active_enter_timestamp = ts;
1596 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1597 u->active_exit_timestamp = ts;
1600 /* Keep track of failed units */
1601 if (ns == UNIT_FAILED && os != UNIT_FAILED)
1602 set_put(u->manager->failed_units, u);
1603 else if (os == UNIT_FAILED && ns != UNIT_FAILED)
1604 set_remove(u->manager->failed_units, u);
1606 /* Make sure the cgroup is always removed when we become inactive */
1607 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1608 unit_destroy_cgroup(u);
1610 /* Note that this doesn't apply to RemainAfterExit services exiting
1611 * successfully, since there's no change of state in that case. Which is
1612 * why it is handled in service_set_state() */
1613 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1616 ec = unit_get_exec_context(u);
1617 if (ec && exec_context_may_touch_console(ec)) {
1618 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1621 if (m->n_on_console == 0)
1622 /* unset no_console_output flag, since the console is free */
1623 m->no_console_output = false;
1632 if (u->job->state == JOB_WAITING)
1634 /* So we reached a different state for this
1635 * job. Let's see if we can run it now if it
1636 * failed previously due to EAGAIN. */
1637 job_add_to_run_queue(u->job);
1639 /* Let's check whether this state change constitutes a
1640 * finished job, or maybe contradicts a running job and
1641 * hence needs to invalidate jobs. */
1643 switch (u->job->type) {
1646 case JOB_VERIFY_ACTIVE:
1648 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1649 job_finish_and_invalidate(u->job, JOB_DONE, true);
1650 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1653 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1654 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1660 case JOB_RELOAD_OR_START:
1662 if (u->job->state == JOB_RUNNING) {
1663 if (ns == UNIT_ACTIVE)
1664 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1665 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1668 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1669 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1677 case JOB_TRY_RESTART:
1679 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1680 job_finish_and_invalidate(u->job, JOB_DONE, true);
1681 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1683 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1689 assert_not_reached("Job type unknown");
1695 if (m->n_reloading <= 0) {
1697 /* If this state change happened without being
1698 * requested by a job, then let's retroactively start
1699 * or stop dependencies. We skip that step when
1700 * deserializing, since we don't want to create any
1701 * additional jobs just because something is already
1705 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1706 retroactively_start_dependencies(u);
1707 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1708 retroactively_stop_dependencies(u);
1711 /* stop unneeded units regardless if going down was expected or not */
1712 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1713 check_unneeded_dependencies(u);
1715 if (ns != os && ns == UNIT_FAILED) {
1716 log_notice_unit(u->id, "Unit %s entered failed state.", u->id);
1717 unit_start_on_failure(u);
1721 /* Some names are special */
1722 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1724 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1725 /* The bus might have just become available,
1726 * hence try to connect to it, if we aren't
1730 if (u->type == UNIT_SERVICE &&
1731 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1732 m->n_reloading <= 0) {
1733 /* Write audit record if we have just finished starting up */
1734 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1738 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1739 manager_send_unit_plymouth(m, u);
1743 /* We don't care about D-Bus here, since we'll get an
1744 * asynchronous notification for it anyway. */
1746 if (u->type == UNIT_SERVICE &&
1747 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1748 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1749 m->n_reloading <= 0) {
1751 /* Hmm, if there was no start record written
1752 * write it now, so that we always have a nice
1755 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1757 if (ns == UNIT_INACTIVE)
1758 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1760 /* Write audit record if we have just finished shutting down */
1761 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1763 u->in_audit = false;
1767 manager_recheck_journal(m);
1768 unit_trigger_notify(u);
1770 /* Maybe we finished startup and are now ready for being
1771 * stopped because unneeded? */
1772 if (u->manager->n_reloading <= 0)
1773 unit_check_unneeded(u);
1775 unit_add_to_dbus_queue(u);
1776 unit_add_to_gc_queue(u);
1779 int unit_watch_pid(Unit *u, pid_t pid) {
1785 /* Watch a specific PID. We only support one or two units
1786 * watching each PID for now, not more. */
1788 r = set_ensure_allocated(&u->pids, trivial_hash_func, trivial_compare_func);
1792 r = hashmap_ensure_allocated(&u->manager->watch_pids1, trivial_hash_func, trivial_compare_func);
1796 r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1798 r = hashmap_ensure_allocated(&u->manager->watch_pids2, trivial_hash_func, trivial_compare_func);
1802 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1805 q = set_put(u->pids, LONG_TO_PTR(pid));
1812 void unit_unwatch_pid(Unit *u, pid_t pid) {
1816 hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1817 hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1818 set_remove(u->pids, LONG_TO_PTR(pid));
1821 void unit_unwatch_all_pids(Unit *u) {
1824 while (!set_isempty(u->pids))
1825 unit_unwatch_pid(u, PTR_TO_LONG(set_first(u->pids)));
1831 static int unit_watch_pids_in_path(Unit *u, const char *path) {
1832 _cleanup_closedir_ DIR *d = NULL;
1833 _cleanup_fclose_ FILE *f = NULL;
1839 /* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
1841 r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
1845 while ((r = cg_read_pid(f, &pid)) > 0) {
1846 r = unit_watch_pid(u, pid);
1847 if (r < 0 && ret >= 0)
1850 if (r < 0 && ret >= 0)
1853 } else if (ret >= 0)
1856 r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
1860 while ((r = cg_read_subgroup(d, &fn)) > 0) {
1861 _cleanup_free_ char *p = NULL;
1863 p = strjoin(path, "/", fn, NULL);
1869 r = unit_watch_pids_in_path(u, p);
1870 if (r < 0 && ret >= 0)
1873 if (r < 0 && ret >= 0)
1876 } else if (ret >= 0)
1882 int unit_watch_all_pids(Unit *u) {
1885 /* Adds all PIDs from our cgroup to the set of PIDs we watch */
1887 if (!u->cgroup_path)
1890 return unit_watch_pids_in_path(u, u->cgroup_path);
1893 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
1899 /* Cleans dead PIDs from our list */
1901 SET_FOREACH(e, u->pids, i) {
1902 pid_t pid = PTR_TO_LONG(e);
1904 if (pid == except1 || pid == except2)
1907 if (!pid_is_unwaited(pid))
1908 unit_unwatch_pid(u, pid);
1912 bool unit_job_is_applicable(Unit *u, JobType j) {
1914 assert(j >= 0 && j < _JOB_TYPE_MAX);
1918 case JOB_VERIFY_ACTIVE:
1925 case JOB_TRY_RESTART:
1926 return unit_can_start(u);
1929 return unit_can_reload(u);
1931 case JOB_RELOAD_OR_START:
1932 return unit_can_reload(u) && unit_can_start(u);
1935 assert_not_reached("Invalid job type");
1939 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1941 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1942 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1943 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1944 [UNIT_WANTS] = UNIT_WANTED_BY,
1945 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1946 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1947 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1948 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1949 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1950 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1951 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1952 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1953 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1954 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1955 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1956 [UNIT_BEFORE] = UNIT_AFTER,
1957 [UNIT_AFTER] = UNIT_BEFORE,
1958 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1959 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1960 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1961 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1962 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1963 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1964 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1965 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
1967 int r, q = 0, v = 0, w = 0;
1970 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1973 u = unit_follow_merge(u);
1974 other = unit_follow_merge(other);
1976 /* We won't allow dependencies on ourselves. We will not
1977 * consider them an error however. */
1981 r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func);
1985 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
1986 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func);
1991 if (add_reference) {
1992 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func);
1996 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func);
2001 q = set_put(u->dependencies[d], other);
2005 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
2006 v = set_put(other->dependencies[inverse_table[d]], u);
2013 if (add_reference) {
2014 w = set_put(u->dependencies[UNIT_REFERENCES], other);
2020 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
2025 unit_add_to_dbus_queue(u);
2030 set_remove(u->dependencies[d], other);
2033 set_remove(other->dependencies[inverse_table[d]], u);
2036 set_remove(u->dependencies[UNIT_REFERENCES], other);
2041 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
2046 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
2049 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
2055 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
2059 assert(name || path);
2063 name = basename(path);
2065 if (!unit_name_is_template(name)) {
2071 s = unit_name_replace_instance(name, u->instance);
2073 _cleanup_free_ char *i = NULL;
2075 i = unit_name_to_prefix(u->id);
2079 s = unit_name_replace_instance(name, i);
2089 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2092 _cleanup_free_ char *s = NULL;
2095 assert(name || path);
2097 name = resolve_template(u, name, path, &s);
2101 r = manager_load_unit(u->manager, name, path, NULL, &other);
2105 return unit_add_dependency(u, d, other, add_reference);
2108 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2111 _cleanup_free_ char *s = NULL;
2114 assert(name || path);
2116 if (!(name = resolve_template(u, name, path, &s)))
2119 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2122 r = unit_add_two_dependencies(u, d, e, other, add_reference);
2127 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2130 _cleanup_free_ char *s = NULL;
2133 assert(name || path);
2135 if (!(name = resolve_template(u, name, path, &s)))
2138 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2141 r = unit_add_dependency(other, d, u, add_reference);
2146 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2149 _cleanup_free_ char *s = NULL;
2152 assert(name || path);
2154 if (!(name = resolve_template(u, name, path, &s)))
2157 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2160 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
2166 int set_unit_path(const char *p) {
2167 _cleanup_free_ char *c = NULL;
2169 /* This is mostly for debug purposes */
2170 c = path_make_absolute_cwd(p);
2171 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
2177 char *unit_dbus_path(Unit *u) {
2183 return unit_dbus_path_from_name(u->id);
2186 char *unit_default_cgroup_path(Unit *u) {
2187 _cleanup_free_ char *escaped = NULL, *slice = NULL;
2192 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2193 return strdup(u->manager->cgroup_root);
2195 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2196 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2201 escaped = cg_escape(u->id);
2206 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2208 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2211 int unit_add_default_slice(Unit *u, CGroupContext *c) {
2212 _cleanup_free_ char *b = NULL;
2213 const char *slice_name;
2220 if (UNIT_ISSET(u->slice))
2224 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2226 /* Implicitly place all instantiated units in their
2227 * own per-template slice */
2229 prefix = unit_name_to_prefix(u->id);
2233 /* The prefix is already escaped, but it might include
2234 * "-" which has a special meaning for slice units,
2235 * hence escape it here extra. */
2236 escaped = strreplace(prefix, "-", "\\x2d");
2240 if (u->manager->running_as == SYSTEMD_SYSTEM)
2241 b = strjoin("system-", escaped, ".slice", NULL);
2243 b = strappend(escaped, ".slice");
2250 u->manager->running_as == SYSTEMD_SYSTEM
2251 ? SPECIAL_SYSTEM_SLICE
2252 : SPECIAL_ROOT_SLICE;
2254 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2258 unit_ref_set(&u->slice, slice);
2262 const char *unit_slice_name(Unit *u) {
2265 if (!UNIT_ISSET(u->slice))
2268 return UNIT_DEREF(u->slice)->id;
2271 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2272 _cleanup_free_ char *t = NULL;
2279 t = unit_name_change_suffix(u->id, type);
2283 assert(!unit_has_name(u, t));
2285 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2286 assert(r < 0 || *_found != u);
2290 int unit_watch_bus_name(Unit *u, const char *name) {
2294 /* Watch a specific name on the bus. We only support one unit
2295 * watching each name for now. */
2297 return hashmap_put(u->manager->watch_bus, name, u);
2300 void unit_unwatch_bus_name(Unit *u, const char *name) {
2304 hashmap_remove_value(u->manager->watch_bus, name, u);
2307 bool unit_can_serialize(Unit *u) {
2310 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2313 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2320 if (unit_can_serialize(u)) {
2323 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2327 rt = unit_get_exec_runtime(u);
2329 r = exec_runtime_serialize(rt, u, f, fds);
2335 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2336 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2337 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2338 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2339 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2341 if (dual_timestamp_is_set(&u->condition_timestamp))
2342 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2344 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2347 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2349 if (serialize_jobs) {
2351 fprintf(f, "job\n");
2352 job_serialize(u->job, f, fds);
2356 fprintf(f, "job\n");
2357 job_serialize(u->nop_job, f, fds);
2366 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2377 va_start(ap, format);
2378 vfprintf(f, format, ap);
2384 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2390 fprintf(f, "%s=%s\n", key, value);
2393 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2394 ExecRuntime **rt = NULL;
2402 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2404 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2407 char line[LINE_MAX], *l, *v;
2410 if (!fgets(line, sizeof(line), f)) {
2423 k = strcspn(l, "=");
2431 if (streq(l, "job")) {
2433 /* new-style serialized job */
2434 Job *j = job_new_raw(u);
2438 r = job_deserialize(j, f, fds);
2444 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2450 r = job_install_deserialized(j);
2452 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2457 if (j->state == JOB_RUNNING)
2458 u->manager->n_running_jobs++;
2461 JobType type = job_type_from_string(v);
2463 log_debug("Failed to parse job type value %s", v);
2465 u->deserialized_job = type;
2468 } else if (streq(l, "inactive-exit-timestamp")) {
2469 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2471 } else if (streq(l, "active-enter-timestamp")) {
2472 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2474 } else if (streq(l, "active-exit-timestamp")) {
2475 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2477 } else if (streq(l, "inactive-enter-timestamp")) {
2478 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2480 } else if (streq(l, "condition-timestamp")) {
2481 dual_timestamp_deserialize(v, &u->condition_timestamp);
2483 } else if (streq(l, "condition-result")) {
2486 b = parse_boolean(v);
2488 log_debug("Failed to parse condition result value %s", v);
2490 u->condition_result = b;
2494 } else if (streq(l, "transient")) {
2497 b = parse_boolean(v);
2499 log_debug("Failed to parse transient bool %s", v);
2504 } else if (streq(l, "cgroup")) {
2511 if (u->cgroup_path) {
2514 p = hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
2515 log_info("Removing cgroup_path %s from hashmap (%p)",
2517 free(u->cgroup_path);
2521 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2526 if (unit_can_serialize(u)) {
2528 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2535 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2542 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2544 _cleanup_free_ char *e = NULL;
2552 /* Adds in links to the device node that this unit is based on */
2554 if (!is_device_path(what))
2557 e = unit_name_from_path(what, ".device");
2561 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2566 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2571 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2579 int unit_coldplug(Unit *u) {
2584 if (UNIT_VTABLE(u)->coldplug)
2585 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2589 r = job_coldplug(u->job);
2592 } else if (u->deserialized_job >= 0) {
2594 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2598 u->deserialized_job = _JOB_TYPE_INVALID;
2604 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2605 DISABLE_WARNING_FORMAT_NONLITERAL;
2606 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2610 bool unit_need_daemon_reload(Unit *u) {
2611 _cleanup_strv_free_ char **t = NULL;
2614 unsigned loaded_cnt, current_cnt;
2618 if (u->fragment_path) {
2620 if (stat(u->fragment_path, &st) < 0)
2621 /* What, cannot access this anymore? */
2624 if (u->fragment_mtime > 0 &&
2625 timespec_load(&st.st_mtim) != u->fragment_mtime)
2629 if (u->source_path) {
2631 if (stat(u->source_path, &st) < 0)
2634 if (u->source_mtime > 0 &&
2635 timespec_load(&st.st_mtim) != u->source_mtime)
2639 t = unit_find_dropin_paths(u);
2640 loaded_cnt = strv_length(t);
2641 current_cnt = strv_length(u->dropin_paths);
2643 if (loaded_cnt == current_cnt) {
2644 if (loaded_cnt == 0)
2647 if (strv_overlap(u->dropin_paths, t)) {
2648 STRV_FOREACH(path, u->dropin_paths) {
2650 if (stat(*path, &st) < 0)
2653 if (u->dropin_mtime > 0 &&
2654 timespec_load(&st.st_mtim) > u->dropin_mtime)
2665 void unit_reset_failed(Unit *u) {
2668 if (UNIT_VTABLE(u)->reset_failed)
2669 UNIT_VTABLE(u)->reset_failed(u);
2672 Unit *unit_following(Unit *u) {
2675 if (UNIT_VTABLE(u)->following)
2676 return UNIT_VTABLE(u)->following(u);
2681 bool unit_stop_pending(Unit *u) {
2684 /* This call does check the current state of the unit. It's
2685 * hence useful to be called from state change calls of the
2686 * unit itself, where the state isn't updated yet. This is
2687 * different from unit_inactive_or_pending() which checks both
2688 * the current state and for a queued job. */
2690 return u->job && u->job->type == JOB_STOP;
2693 bool unit_inactive_or_pending(Unit *u) {
2696 /* Returns true if the unit is inactive or going down */
2698 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2701 if (unit_stop_pending(u))
2707 bool unit_active_or_pending(Unit *u) {
2710 /* Returns true if the unit is active or going up */
2712 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2716 (u->job->type == JOB_START ||
2717 u->job->type == JOB_RELOAD_OR_START ||
2718 u->job->type == JOB_RESTART))
2724 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2726 assert(w >= 0 && w < _KILL_WHO_MAX);
2728 assert(signo < _NSIG);
2730 if (!UNIT_VTABLE(u)->kill)
2733 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2736 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2740 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2744 /* Exclude the main/control pids from being killed via the cgroup */
2746 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2751 if (control_pid > 0) {
2752 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2764 int unit_kill_common(
2770 sd_bus_error *error) {
2774 if (who == KILL_MAIN && main_pid <= 0) {
2776 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2778 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2782 if (who == KILL_CONTROL && control_pid <= 0) {
2783 if (control_pid < 0)
2784 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2786 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2790 if (who == KILL_CONTROL || who == KILL_ALL)
2791 if (control_pid > 0)
2792 if (kill(control_pid, signo) < 0)
2795 if (who == KILL_MAIN || who == KILL_ALL)
2797 if (kill(main_pid, signo) < 0)
2800 if (who == KILL_ALL && u->cgroup_path) {
2801 _cleanup_set_free_ Set *pid_set = NULL;
2804 /* Exclude the main/control pids from being killed via the cgroup */
2805 pid_set = unit_pid_set(main_pid, control_pid);
2809 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2810 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2817 int unit_following_set(Unit *u, Set **s) {
2821 if (UNIT_VTABLE(u)->following_set)
2822 return UNIT_VTABLE(u)->following_set(u, s);
2828 UnitFileState unit_get_unit_file_state(Unit *u) {
2831 if (u->unit_file_state < 0 && u->fragment_path)
2832 u->unit_file_state = unit_file_get_state(
2833 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2834 NULL, basename(u->fragment_path));
2836 return u->unit_file_state;
2839 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2844 unit_ref_unset(ref);
2847 LIST_PREPEND(refs, u->refs, ref);
2851 void unit_ref_unset(UnitRef *ref) {
2857 LIST_REMOVE(refs, ref->unit->refs, ref);
2861 int unit_patch_contexts(Unit *u) {
2869 /* Patch in the manager defaults into the exec and cgroup
2870 * contexts, _after_ the rest of the settings have been
2873 ec = unit_get_exec_context(u);
2875 /* This only copies in the ones that need memory */
2876 for (i = 0; i < _RLIMIT_MAX; i++)
2877 if (u->manager->rlimit[i] && !ec->rlimit[i]) {
2878 ec->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2883 if (u->manager->running_as == SYSTEMD_USER &&
2884 !ec->working_directory) {
2886 r = get_home_dir(&ec->working_directory);
2891 if (u->manager->running_as == SYSTEMD_USER &&
2892 (ec->syscall_whitelist ||
2893 !set_isempty(ec->syscall_filter) ||
2894 !set_isempty(ec->syscall_archs) ||
2895 ec->address_families_whitelist ||
2896 !set_isempty(ec->address_families)))
2897 ec->no_new_privileges = true;
2899 if (ec->private_devices)
2900 ec->capability_bounding_set_drop |= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD;
2903 cc = unit_get_cgroup_context(u);
2907 ec->private_devices &&
2908 cc->device_policy == CGROUP_AUTO)
2909 cc->device_policy = CGROUP_CLOSED;
2915 ExecContext *unit_get_exec_context(Unit *u) {
2922 offset = UNIT_VTABLE(u)->exec_context_offset;
2926 return (ExecContext*) ((uint8_t*) u + offset);
2929 KillContext *unit_get_kill_context(Unit *u) {
2936 offset = UNIT_VTABLE(u)->kill_context_offset;
2940 return (KillContext*) ((uint8_t*) u + offset);
2943 CGroupContext *unit_get_cgroup_context(Unit *u) {
2949 offset = UNIT_VTABLE(u)->cgroup_context_offset;
2953 return (CGroupContext*) ((uint8_t*) u + offset);
2956 ExecRuntime *unit_get_exec_runtime(Unit *u) {
2962 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2966 return *(ExecRuntime**) ((uint8_t*) u + offset);
2969 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2970 _cleanup_free_ char *b = NULL;
2979 b = xescape(name, "/.");
2983 if (!filename_is_safe(b))
2986 if (u->manager->running_as == SYSTEMD_USER) {
2987 _cleanup_free_ char *c = NULL;
2989 r = user_config_home(&c);
2995 p = strjoin(c, "/", u->id, ".d", NULL);
2996 } else if (mode == UNIT_PERSISTENT && !u->transient)
2997 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2999 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
3003 q = strjoin(p, "/90-", b, ".conf", NULL);
3014 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3015 _cleanup_free_ char *p = NULL, *q = NULL;
3022 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3025 r = drop_in_file(u, mode, name, &p, &q);
3030 return write_string_file_atomic_label(q, data);
3033 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3034 _cleanup_free_ char *p = NULL;
3042 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3045 va_start(ap, format);
3046 r = vasprintf(&p, format, ap);
3052 return unit_write_drop_in(u, mode, name, p);
3055 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3056 _cleanup_free_ char *ndata = NULL;
3062 if (!UNIT_VTABLE(u)->private_section)
3065 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3068 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
3072 return unit_write_drop_in(u, mode, name, ndata);
3075 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3076 _cleanup_free_ char *p = NULL;
3084 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3087 va_start(ap, format);
3088 r = vasprintf(&p, format, ap);
3094 return unit_write_drop_in_private(u, mode, name, p);
3097 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
3098 _cleanup_free_ char *p = NULL, *q = NULL;
3103 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3106 r = drop_in_file(u, mode, name, &p, &q);
3111 r = errno == ENOENT ? 0 : -errno;
3119 int unit_make_transient(Unit *u) {
3124 u->load_state = UNIT_STUB;
3126 u->transient = true;
3128 free(u->fragment_path);
3129 u->fragment_path = NULL;
3131 if (u->manager->running_as == SYSTEMD_USER) {
3132 _cleanup_free_ char *c = NULL;
3134 r = user_config_home(&c);
3140 u->fragment_path = strjoin(c, "/", u->id, NULL);
3141 if (!u->fragment_path)
3146 u->fragment_path = strappend("/run/systemd/system/", u->id);
3147 if (!u->fragment_path)
3150 mkdir_p("/run/systemd/system", 0755);
3153 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3156 int unit_kill_context(
3162 bool main_pid_alien) {
3164 int sig, wait_for_exit = false, r;
3169 if (c->kill_mode == KILL_NONE)
3172 sig = sigkill ? SIGKILL : c->kill_signal;
3175 r = kill_and_sigcont(main_pid, sig);
3177 if (r < 0 && r != -ESRCH) {
3178 _cleanup_free_ char *comm = NULL;
3179 get_process_comm(main_pid, &comm);
3181 log_warning_unit(u->id, "Failed to kill main process " PID_FMT " (%s): %s", main_pid, strna(comm), strerror(-r));
3183 if (!main_pid_alien)
3184 wait_for_exit = true;
3186 if (c->send_sighup && !sigkill)
3187 kill(main_pid, SIGHUP);
3191 if (control_pid > 0) {
3192 r = kill_and_sigcont(control_pid, sig);
3194 if (r < 0 && r != -ESRCH) {
3195 _cleanup_free_ char *comm = NULL;
3196 get_process_comm(control_pid, &comm);
3198 log_warning_unit(u->id, "Failed to kill control process " PID_FMT " (%s): %s", control_pid, strna(comm), strerror(-r));
3200 wait_for_exit = true;
3202 if (c->send_sighup && !sigkill)
3203 kill(control_pid, SIGHUP);
3207 if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && sigkill)) && u->cgroup_path) {
3208 _cleanup_set_free_ Set *pid_set = NULL;
3210 /* Exclude the main/control pids from being killed via the cgroup */
3211 pid_set = unit_pid_set(main_pid, control_pid);
3215 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3217 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3218 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3221 /* FIXME: For now, we will not wait for the
3222 * cgroup members to die, simply because
3223 * cgroup notification is unreliable. It
3224 * doesn't work at all in containers, and
3225 * outside of containers it can be confused
3226 * easily by leaving directories in the
3229 /* wait_for_exit = true; */
3231 if (c->send_sighup && !sigkill) {
3234 pid_set = unit_pid_set(main_pid, control_pid);
3238 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3243 return wait_for_exit;
3246 int unit_require_mounts_for(Unit *u, const char *path) {
3247 char prefix[strlen(path) + 1], *p;
3253 /* Registers a unit for requiring a certain path and all its
3254 * prefixes. We keep a simple array of these paths in the
3255 * unit, since its usually short. However, we build a prefix
3256 * table for all possible prefixes so that new appearing mount
3257 * units can easily determine which units to make themselves a
3260 if (!path_is_absolute(path))
3267 path_kill_slashes(p);
3269 if (!path_is_safe(p)) {
3274 if (strv_contains(u->requires_mounts_for, p)) {
3279 r = strv_consume(&u->requires_mounts_for, p);
3283 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3286 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3290 if (!u->manager->units_requiring_mounts_for) {
3291 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
3292 if (!u->manager->units_requiring_mounts_for)
3300 x = set_new(NULL, NULL);
3306 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3322 int unit_setup_exec_runtime(Unit *u) {
3328 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3331 /* Check if ther already is an ExecRuntime for this unit? */
3332 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3336 /* Try to get it from somebody else */
3337 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3339 *rt = unit_get_exec_runtime(other);
3341 exec_runtime_ref(*rt);
3346 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3349 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3350 [UNIT_ACTIVE] = "active",
3351 [UNIT_RELOADING] = "reloading",
3352 [UNIT_INACTIVE] = "inactive",
3353 [UNIT_FAILED] = "failed",
3354 [UNIT_ACTIVATING] = "activating",
3355 [UNIT_DEACTIVATING] = "deactivating"
3358 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3360 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3361 [UNIT_REQUIRES] = "Requires",
3362 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3363 [UNIT_REQUISITE] = "Requisite",
3364 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3365 [UNIT_WANTS] = "Wants",
3366 [UNIT_BINDS_TO] = "BindsTo",
3367 [UNIT_PART_OF] = "PartOf",
3368 [UNIT_REQUIRED_BY] = "RequiredBy",
3369 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3370 [UNIT_WANTED_BY] = "WantedBy",
3371 [UNIT_BOUND_BY] = "BoundBy",
3372 [UNIT_CONSISTS_OF] = "ConsistsOf",
3373 [UNIT_CONFLICTS] = "Conflicts",
3374 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3375 [UNIT_BEFORE] = "Before",
3376 [UNIT_AFTER] = "After",
3377 [UNIT_ON_FAILURE] = "OnFailure",
3378 [UNIT_TRIGGERS] = "Triggers",
3379 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3380 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3381 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3382 [UNIT_JOINS_NAMESPACE_OF] = "JoinsNamespaceOf",
3383 [UNIT_REFERENCES] = "References",
3384 [UNIT_REFERENCED_BY] = "ReferencedBy",
3387 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);