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;
124 cc->cpu_quota_period_usec = u->manager->default_cpu_quota_period_usec;
127 ec = unit_get_exec_context(u);
129 exec_context_init(ec);
131 kc = unit_get_kill_context(u);
133 kill_context_init(kc);
135 if (UNIT_VTABLE(u)->init)
136 UNIT_VTABLE(u)->init(u);
139 int unit_add_name(Unit *u, const char *text) {
140 _cleanup_free_ char *s = NULL, *i = NULL;
147 if (unit_name_is_template(text)) {
152 s = unit_name_replace_instance(text, u->instance);
158 if (!unit_name_is_valid(s, TEMPLATE_INVALID))
161 assert_se((t = unit_name_to_type(s)) >= 0);
163 if (u->type != _UNIT_TYPE_INVALID && t != u->type)
166 r = unit_name_to_instance(s, &i);
170 if (i && unit_vtable[t]->no_instances)
173 /* Ensure that this unit is either instanced or not instanced,
175 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i)
178 if (unit_vtable[t]->no_alias &&
179 !set_isempty(u->names) &&
180 !set_get(u->names, s))
183 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES)
186 r = set_put(u->names, s);
194 r = hashmap_put(u->manager->units, s, u);
196 set_remove(u->names, s);
200 if (u->type == _UNIT_TYPE_INVALID) {
205 LIST_PREPEND(units_by_type, u->manager->units_by_type[t], u);
214 unit_add_to_dbus_queue(u);
218 int unit_choose_id(Unit *u, const char *name) {
219 _cleanup_free_ char *t = NULL;
226 if (unit_name_is_template(name)) {
231 t = unit_name_replace_instance(name, u->instance);
238 /* Selects one of the names of this unit as the id */
239 s = set_get(u->names, (char*) name);
243 r = unit_name_to_instance(s, &i);
252 unit_add_to_dbus_queue(u);
257 int unit_set_description(Unit *u, const char *description) {
262 if (isempty(description))
265 s = strdup(description);
270 free(u->description);
273 unit_add_to_dbus_queue(u);
277 bool unit_check_gc(Unit *u) {
280 if (UNIT_VTABLE(u)->no_gc)
292 if (unit_active_state(u) != UNIT_INACTIVE)
298 if (UNIT_VTABLE(u)->check_gc)
299 if (UNIT_VTABLE(u)->check_gc(u))
305 void unit_add_to_load_queue(Unit *u) {
307 assert(u->type != _UNIT_TYPE_INVALID);
309 if (u->load_state != UNIT_STUB || u->in_load_queue)
312 LIST_PREPEND(load_queue, u->manager->load_queue, u);
313 u->in_load_queue = true;
316 void unit_add_to_cleanup_queue(Unit *u) {
319 if (u->in_cleanup_queue)
322 LIST_PREPEND(cleanup_queue, u->manager->cleanup_queue, u);
323 u->in_cleanup_queue = true;
326 void unit_add_to_gc_queue(Unit *u) {
329 if (u->in_gc_queue || u->in_cleanup_queue)
332 if (unit_check_gc(u))
335 LIST_PREPEND(gc_queue, u->manager->gc_queue, u);
336 u->in_gc_queue = true;
338 u->manager->n_in_gc_queue ++;
341 void unit_add_to_dbus_queue(Unit *u) {
343 assert(u->type != _UNIT_TYPE_INVALID);
345 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
348 /* Shortcut things if nobody cares */
349 if (sd_bus_track_count(u->manager->subscribed) <= 0 &&
350 set_isempty(u->manager->private_buses)) {
351 u->sent_dbus_new_signal = true;
355 LIST_PREPEND(dbus_queue, u->manager->dbus_unit_queue, u);
356 u->in_dbus_queue = true;
359 static void bidi_set_free(Unit *u, Set *s) {
365 /* Frees the set and makes sure we are dropped from the
366 * inverse pointers */
368 SET_FOREACH(other, s, i) {
371 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
372 set_remove(other->dependencies[d], u);
374 unit_add_to_gc_queue(other);
380 static void unit_remove_transient(Unit *u) {
388 if (u->fragment_path)
389 unlink(u->fragment_path);
391 STRV_FOREACH(i, u->dropin_paths) {
392 _cleanup_free_ char *p = NULL;
397 r = path_get_parent(*i, &p);
403 static void unit_free_requires_mounts_for(Unit *u) {
406 STRV_FOREACH(j, u->requires_mounts_for) {
407 char s[strlen(*j) + 1];
409 PATH_FOREACH_PREFIX_MORE(s, *j) {
413 x = hashmap_get2(u->manager->units_requiring_mounts_for, s, (void**) &y);
419 if (set_isempty(x)) {
420 hashmap_remove(u->manager->units_requiring_mounts_for, y);
427 strv_free(u->requires_mounts_for);
428 u->requires_mounts_for = NULL;
431 static void unit_done(Unit *u) {
440 if (UNIT_VTABLE(u)->done)
441 UNIT_VTABLE(u)->done(u);
443 ec = unit_get_exec_context(u);
445 exec_context_done(ec);
447 cc = unit_get_cgroup_context(u);
449 cgroup_context_done(cc);
452 void unit_free(Unit *u) {
459 if (u->manager->n_reloading <= 0)
460 unit_remove_transient(u);
462 bus_unit_send_removed_signal(u);
466 unit_free_requires_mounts_for(u);
468 SET_FOREACH(t, u->names, i)
469 hashmap_remove_value(u->manager->units, t, u);
483 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
484 bidi_set_free(u, u->dependencies[d]);
486 if (u->type != _UNIT_TYPE_INVALID)
487 LIST_REMOVE(units_by_type, u->manager->units_by_type[u->type], u);
489 if (u->in_load_queue)
490 LIST_REMOVE(load_queue, u->manager->load_queue, u);
492 if (u->in_dbus_queue)
493 LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
495 if (u->in_cleanup_queue)
496 LIST_REMOVE(cleanup_queue, u->manager->cleanup_queue, u);
498 if (u->in_gc_queue) {
499 LIST_REMOVE(gc_queue, u->manager->gc_queue, u);
500 u->manager->n_in_gc_queue--;
503 if (u->in_cgroup_queue)
504 LIST_REMOVE(cgroup_queue, u->manager->cgroup_queue, u);
506 if (u->cgroup_path) {
507 hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
508 free(u->cgroup_path);
511 set_remove(u->manager->failed_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 int unit_load(Unit *u) {
1079 if (u->in_load_queue) {
1080 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1081 u->in_load_queue = false;
1084 if (u->type == _UNIT_TYPE_INVALID)
1087 if (u->load_state != UNIT_STUB)
1090 if (UNIT_VTABLE(u)->load) {
1091 r = UNIT_VTABLE(u)->load(u);
1096 if (u->load_state == UNIT_STUB) {
1101 if (u->load_state == UNIT_LOADED) {
1103 r = unit_add_target_dependencies(u);
1107 r = unit_add_slice_dependencies(u);
1111 r = unit_add_mount_dependencies(u);
1115 if (u->on_failure_job_mode == JOB_ISOLATE && set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1116 log_error_unit(u->id, "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
1121 unit_update_cgroup_members_masks(u);
1124 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1126 unit_add_to_dbus_queue(unit_follow_merge(u));
1127 unit_add_to_gc_queue(u);
1132 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1134 unit_add_to_dbus_queue(u);
1135 unit_add_to_gc_queue(u);
1137 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
1138 u->id, strerror(-r));
1143 static bool unit_condition_test(Unit *u) {
1146 dual_timestamp_get(&u->condition_timestamp);
1147 u->condition_result = condition_test_list(u->id, u->conditions);
1149 return u->condition_result;
1152 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1153 const UnitStatusMessageFormats *format_table;
1157 assert(t < _JOB_TYPE_MAX);
1159 if (t != JOB_START && t != JOB_STOP)
1162 format_table = &UNIT_VTABLE(u)->status_message_formats;
1166 return format_table->starting_stopping[t == JOB_STOP];
1169 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1174 assert(t < _JOB_TYPE_MAX);
1176 format = unit_get_status_message_format(u, t);
1180 /* Return generic strings */
1182 return "Starting %s.";
1183 else if (t == JOB_STOP)
1184 return "Stopping %s.";
1185 else if (t == JOB_RELOAD)
1186 return "Reloading %s.";
1191 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1196 /* We only print status messages for selected units on
1197 * selected operations. */
1199 format = unit_get_status_message_format(u, t);
1203 DISABLE_WARNING_FORMAT_NONLITERAL;
1204 unit_status_printf(u, "", format);
1208 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1215 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1218 if (log_on_console())
1221 /* We log status messages for all units and all operations. */
1223 format = unit_get_status_message_format_try_harder(u, t);
1227 DISABLE_WARNING_FORMAT_NONLITERAL;
1228 snprintf(buf, sizeof(buf), format, unit_description(u));
1232 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1233 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1234 SD_MESSAGE_UNIT_RELOADING;
1236 log_struct_unit(LOG_INFO,
1244 * -EBADR: This unit type does not support starting.
1245 * -EALREADY: Unit is already started.
1246 * -EAGAIN: An operation is already in progress. Retry later.
1247 * -ECANCELED: Too many requests for now.
1249 int unit_start(Unit *u) {
1250 UnitActiveState state;
1255 if (u->load_state != UNIT_LOADED)
1258 /* If this is already started, then this will succeed. Note
1259 * that this will even succeed if this unit is not startable
1260 * by the user. This is relied on to detect when we need to
1261 * wait for units and when waiting is finished. */
1262 state = unit_active_state(u);
1263 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1266 /* If the conditions failed, don't do anything at all. If we
1267 * already are activating this call might still be useful to
1268 * speed up activation in case there is some hold-off time,
1269 * but we don't want to recheck the condition in that case. */
1270 if (state != UNIT_ACTIVATING &&
1271 !unit_condition_test(u)) {
1272 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1276 /* Forward to the main object, if we aren't it. */
1277 following = unit_following(u);
1279 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1280 u->id, following->id);
1281 return unit_start(following);
1284 unit_status_log_starting_stopping_reloading(u, JOB_START);
1285 unit_status_print_starting_stopping(u, JOB_START);
1287 /* If it is stopped, but we cannot start it, then fail */
1288 if (!UNIT_VTABLE(u)->start)
1291 /* We don't suppress calls to ->start() here when we are
1292 * already starting, to allow this request to be used as a
1293 * "hurry up" call, for example when the unit is in some "auto
1294 * restart" state where it waits for a holdoff timer to elapse
1295 * before it will start again. */
1297 unit_add_to_dbus_queue(u);
1299 return UNIT_VTABLE(u)->start(u);
1302 bool unit_can_start(Unit *u) {
1305 return !!UNIT_VTABLE(u)->start;
1308 bool unit_can_isolate(Unit *u) {
1311 return unit_can_start(u) &&
1316 * -EBADR: This unit type does not support stopping.
1317 * -EALREADY: Unit is already stopped.
1318 * -EAGAIN: An operation is already in progress. Retry later.
1320 int unit_stop(Unit *u) {
1321 UnitActiveState state;
1326 state = unit_active_state(u);
1327 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1330 if ((following = unit_following(u))) {
1331 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1332 u->id, following->id);
1333 return unit_stop(following);
1336 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1337 unit_status_print_starting_stopping(u, JOB_STOP);
1339 if (!UNIT_VTABLE(u)->stop)
1342 unit_add_to_dbus_queue(u);
1344 return UNIT_VTABLE(u)->stop(u);
1348 * -EBADR: This unit type does not support reloading.
1349 * -ENOEXEC: Unit is not started.
1350 * -EAGAIN: An operation is already in progress. Retry later.
1352 int unit_reload(Unit *u) {
1353 UnitActiveState state;
1358 if (u->load_state != UNIT_LOADED)
1361 if (!unit_can_reload(u))
1364 state = unit_active_state(u);
1365 if (state == UNIT_RELOADING)
1368 if (state != UNIT_ACTIVE) {
1369 log_warning_unit(u->id, "Unit %s cannot be reloaded because it is inactive.",
1374 following = unit_following(u);
1376 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1377 u->id, following->id);
1378 return unit_reload(following);
1381 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1383 unit_add_to_dbus_queue(u);
1384 return UNIT_VTABLE(u)->reload(u);
1387 bool unit_can_reload(Unit *u) {
1390 if (!UNIT_VTABLE(u)->reload)
1393 if (!UNIT_VTABLE(u)->can_reload)
1396 return UNIT_VTABLE(u)->can_reload(u);
1399 static void unit_check_unneeded(Unit *u) {
1405 /* If this service shall be shut down when unneeded then do
1408 if (!u->stop_when_unneeded)
1411 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1414 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1415 if (unit_active_or_pending(other))
1418 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1419 if (unit_active_or_pending(other))
1422 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1423 if (unit_active_or_pending(other))
1426 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1427 if (unit_active_or_pending(other))
1430 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1432 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1433 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1436 static void retroactively_start_dependencies(Unit *u) {
1441 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1443 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1444 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1445 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1446 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1448 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1449 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1450 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1451 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1453 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1454 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1455 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1456 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1458 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1459 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1460 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1461 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1463 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1464 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1465 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1467 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1468 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1469 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1472 static void retroactively_stop_dependencies(Unit *u) {
1477 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1479 /* Pull down units which are bound to us recursively if enabled */
1480 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1481 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1482 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1485 static void check_unneeded_dependencies(Unit *u) {
1490 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1492 /* Garbage collect services that might not be needed anymore, if enabled */
1493 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1494 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1495 unit_check_unneeded(other);
1496 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1497 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1498 unit_check_unneeded(other);
1499 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1500 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1501 unit_check_unneeded(other);
1502 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1503 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1504 unit_check_unneeded(other);
1505 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1506 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1507 unit_check_unneeded(other);
1508 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1509 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1510 unit_check_unneeded(other);
1513 void unit_start_on_failure(Unit *u) {
1519 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1522 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1524 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1527 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1529 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1533 void unit_trigger_notify(Unit *u) {
1539 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1540 if (UNIT_VTABLE(other)->trigger_notify)
1541 UNIT_VTABLE(other)->trigger_notify(other, u);
1544 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1549 assert(os < _UNIT_ACTIVE_STATE_MAX);
1550 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1552 /* Note that this is called for all low-level state changes,
1553 * even if they might map to the same high-level
1554 * UnitActiveState! That means that ns == os is OK an expected
1555 * behavior here. For example: if a mount point is remounted
1556 * this function will be called too! */
1560 /* Update timestamps for state changes */
1561 if (m->n_reloading <= 0) {
1564 dual_timestamp_get(&ts);
1566 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1567 u->inactive_exit_timestamp = ts;
1568 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1569 u->inactive_enter_timestamp = ts;
1571 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1572 u->active_enter_timestamp = ts;
1573 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1574 u->active_exit_timestamp = ts;
1577 /* Keep track of failed of units */
1578 if (ns == UNIT_FAILED && os != UNIT_FAILED)
1579 set_put(u->manager->failed_units, u);
1580 else if (os == UNIT_FAILED && ns != UNIT_FAILED)
1581 set_remove(u->manager->failed_units, u);
1583 /* Make sure the cgroup is always removed when we become inactive */
1584 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1585 unit_destroy_cgroup(u);
1587 /* Note that this doesn't apply to RemainAfterExit services exiting
1588 * successfully, since there's no change of state in that case. Which is
1589 * why it is handled in service_set_state() */
1590 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1593 ec = unit_get_exec_context(u);
1594 if (ec && exec_context_may_touch_console(ec)) {
1595 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1598 if (m->n_on_console == 0)
1599 /* unset no_console_output flag, since the console is free */
1600 m->no_console_output = false;
1609 if (u->job->state == JOB_WAITING)
1611 /* So we reached a different state for this
1612 * job. Let's see if we can run it now if it
1613 * failed previously due to EAGAIN. */
1614 job_add_to_run_queue(u->job);
1616 /* Let's check whether this state change constitutes a
1617 * finished job, or maybe contradicts a running job and
1618 * hence needs to invalidate jobs. */
1620 switch (u->job->type) {
1623 case JOB_VERIFY_ACTIVE:
1625 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1626 job_finish_and_invalidate(u->job, JOB_DONE, true);
1627 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1630 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1631 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1637 case JOB_RELOAD_OR_START:
1639 if (u->job->state == JOB_RUNNING) {
1640 if (ns == UNIT_ACTIVE)
1641 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1642 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1645 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1646 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1654 case JOB_TRY_RESTART:
1656 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1657 job_finish_and_invalidate(u->job, JOB_DONE, true);
1658 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1660 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1666 assert_not_reached("Job type unknown");
1672 if (m->n_reloading <= 0) {
1674 /* If this state change happened without being
1675 * requested by a job, then let's retroactively start
1676 * or stop dependencies. We skip that step when
1677 * deserializing, since we don't want to create any
1678 * additional jobs just because something is already
1682 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1683 retroactively_start_dependencies(u);
1684 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1685 retroactively_stop_dependencies(u);
1688 /* stop unneeded units regardless if going down was expected or not */
1689 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1690 check_unneeded_dependencies(u);
1692 if (ns != os && ns == UNIT_FAILED) {
1693 log_notice_unit(u->id, "Unit %s entered failed state.", u->id);
1694 unit_start_on_failure(u);
1698 /* Some names are special */
1699 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1701 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1702 /* The bus just might have become available,
1703 * hence try to connect to it, if we aren't
1707 if (u->type == UNIT_SERVICE &&
1708 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1709 m->n_reloading <= 0) {
1710 /* Write audit record if we have just finished starting up */
1711 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1715 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1716 manager_send_unit_plymouth(m, u);
1720 /* We don't care about D-Bus here, since we'll get an
1721 * asynchronous notification for it anyway. */
1723 if (u->type == UNIT_SERVICE &&
1724 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1725 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1726 m->n_reloading <= 0) {
1728 /* Hmm, if there was no start record written
1729 * write it now, so that we always have a nice
1732 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1734 if (ns == UNIT_INACTIVE)
1735 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1737 /* Write audit record if we have just finished shutting down */
1738 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1740 u->in_audit = false;
1744 manager_recheck_journal(m);
1745 unit_trigger_notify(u);
1747 /* Maybe we finished startup and are now ready for being
1748 * stopped because unneeded? */
1749 if (u->manager->n_reloading <= 0)
1750 unit_check_unneeded(u);
1752 unit_add_to_dbus_queue(u);
1753 unit_add_to_gc_queue(u);
1756 int unit_watch_pid(Unit *u, pid_t pid) {
1762 /* Watch a specific PID. We only support one or two units
1763 * watching each PID for now, not more. */
1765 r = set_ensure_allocated(&u->pids, trivial_hash_func, trivial_compare_func);
1769 r = hashmap_ensure_allocated(&u->manager->watch_pids1, trivial_hash_func, trivial_compare_func);
1773 r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1775 r = hashmap_ensure_allocated(&u->manager->watch_pids2, trivial_hash_func, trivial_compare_func);
1779 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1782 q = set_put(u->pids, LONG_TO_PTR(pid));
1789 void unit_unwatch_pid(Unit *u, pid_t pid) {
1793 hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1794 hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1795 set_remove(u->pids, LONG_TO_PTR(pid));
1798 void unit_unwatch_all_pids(Unit *u) {
1801 while (!set_isempty(u->pids))
1802 unit_unwatch_pid(u, PTR_TO_LONG(set_first(u->pids)));
1808 static int unit_watch_pids_in_path(Unit *u, const char *path) {
1809 _cleanup_closedir_ DIR *d = NULL;
1810 _cleanup_fclose_ FILE *f = NULL;
1816 /* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
1818 r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
1822 while ((r = cg_read_pid(f, &pid)) > 0) {
1823 r = unit_watch_pid(u, pid);
1824 if (r < 0 && ret >= 0)
1827 if (r < 0 && ret >= 0)
1830 } else if (ret >= 0)
1833 r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
1837 while ((r = cg_read_subgroup(d, &fn)) > 0) {
1838 _cleanup_free_ char *p = NULL;
1840 p = strjoin(path, "/", fn, NULL);
1846 r = unit_watch_pids_in_path(u, p);
1847 if (r < 0 && ret >= 0)
1850 if (r < 0 && ret >= 0)
1853 } else if (ret >= 0)
1859 int unit_watch_all_pids(Unit *u) {
1862 /* Adds all PIDs from our cgroup to the set of PIDs we watch */
1864 if (!u->cgroup_path)
1867 return unit_watch_pids_in_path(u, u->cgroup_path);
1870 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
1876 /* Cleans dead PIDs from our list */
1878 SET_FOREACH(e, u->pids, i) {
1879 pid_t pid = PTR_TO_LONG(e);
1881 if (pid == except1 || pid == except2)
1884 if (!pid_is_unwaited(pid))
1885 unit_unwatch_pid(u, pid);
1889 bool unit_job_is_applicable(Unit *u, JobType j) {
1891 assert(j >= 0 && j < _JOB_TYPE_MAX);
1895 case JOB_VERIFY_ACTIVE:
1902 case JOB_TRY_RESTART:
1903 return unit_can_start(u);
1906 return unit_can_reload(u);
1908 case JOB_RELOAD_OR_START:
1909 return unit_can_reload(u) && unit_can_start(u);
1912 assert_not_reached("Invalid job type");
1916 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1918 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1919 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1920 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1921 [UNIT_WANTS] = UNIT_WANTED_BY,
1922 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1923 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1924 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1925 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1926 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1927 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1928 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1929 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1930 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1931 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1932 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1933 [UNIT_BEFORE] = UNIT_AFTER,
1934 [UNIT_AFTER] = UNIT_BEFORE,
1935 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1936 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1937 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1938 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1939 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1940 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1941 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1942 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
1944 int r, q = 0, v = 0, w = 0;
1947 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1950 u = unit_follow_merge(u);
1951 other = unit_follow_merge(other);
1953 /* We won't allow dependencies on ourselves. We will not
1954 * consider them an error however. */
1958 r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func);
1962 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
1963 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func);
1968 if (add_reference) {
1969 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func);
1973 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func);
1978 q = set_put(u->dependencies[d], other);
1982 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
1983 v = set_put(other->dependencies[inverse_table[d]], u);
1990 if (add_reference) {
1991 w = set_put(u->dependencies[UNIT_REFERENCES], other);
1997 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
2002 unit_add_to_dbus_queue(u);
2007 set_remove(u->dependencies[d], other);
2010 set_remove(other->dependencies[inverse_table[d]], u);
2013 set_remove(u->dependencies[UNIT_REFERENCES], other);
2018 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
2023 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
2026 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
2032 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
2036 assert(name || path);
2040 name = basename(path);
2042 if (!unit_name_is_template(name)) {
2048 s = unit_name_replace_instance(name, u->instance);
2050 _cleanup_free_ char *i = NULL;
2052 i = unit_name_to_prefix(u->id);
2056 s = unit_name_replace_instance(name, i);
2066 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2069 _cleanup_free_ char *s = NULL;
2072 assert(name || path);
2074 name = resolve_template(u, name, path, &s);
2078 r = manager_load_unit(u->manager, name, path, NULL, &other);
2082 return unit_add_dependency(u, d, other, add_reference);
2085 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2088 _cleanup_free_ char *s = NULL;
2091 assert(name || path);
2093 if (!(name = resolve_template(u, name, path, &s)))
2096 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2099 r = unit_add_two_dependencies(u, d, e, other, add_reference);
2104 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2107 _cleanup_free_ char *s = NULL;
2110 assert(name || path);
2112 if (!(name = resolve_template(u, name, path, &s)))
2115 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2118 r = unit_add_dependency(other, d, u, add_reference);
2123 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2126 _cleanup_free_ char *s = NULL;
2129 assert(name || path);
2131 if (!(name = resolve_template(u, name, path, &s)))
2134 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2137 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
2143 int set_unit_path(const char *p) {
2144 _cleanup_free_ char *c = NULL;
2146 /* This is mostly for debug purposes */
2147 c = path_make_absolute_cwd(p);
2148 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
2154 char *unit_dbus_path(Unit *u) {
2160 return unit_dbus_path_from_name(u->id);
2163 char *unit_default_cgroup_path(Unit *u) {
2164 _cleanup_free_ char *escaped = NULL, *slice = NULL;
2169 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2170 return strdup(u->manager->cgroup_root);
2172 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2173 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2178 escaped = cg_escape(u->id);
2183 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2185 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2188 int unit_add_default_slice(Unit *u, CGroupContext *c) {
2189 _cleanup_free_ char *b = NULL;
2190 const char *slice_name;
2197 if (UNIT_ISSET(u->slice))
2201 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2203 /* Implicitly place all instantiated units in their
2204 * own per-template slice */
2206 prefix = unit_name_to_prefix(u->id);
2210 /* The prefix is already escaped, but it might include
2211 * "-" which has a special meaning for slice units,
2212 * hence escape it here extra. */
2213 escaped = strreplace(prefix, "-", "\\x2d");
2217 if (u->manager->running_as == SYSTEMD_SYSTEM)
2218 b = strjoin("system-", escaped, ".slice", NULL);
2220 b = strappend(escaped, ".slice");
2227 u->manager->running_as == SYSTEMD_SYSTEM
2228 ? SPECIAL_SYSTEM_SLICE
2229 : SPECIAL_ROOT_SLICE;
2231 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2235 unit_ref_set(&u->slice, slice);
2239 const char *unit_slice_name(Unit *u) {
2242 if (!UNIT_ISSET(u->slice))
2245 return UNIT_DEREF(u->slice)->id;
2248 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2249 _cleanup_free_ char *t = NULL;
2256 t = unit_name_change_suffix(u->id, type);
2260 assert(!unit_has_name(u, t));
2262 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2263 assert(r < 0 || *_found != u);
2267 int unit_watch_bus_name(Unit *u, const char *name) {
2271 /* Watch a specific name on the bus. We only support one unit
2272 * watching each name for now. */
2274 return hashmap_put(u->manager->watch_bus, name, u);
2277 void unit_unwatch_bus_name(Unit *u, const char *name) {
2281 hashmap_remove_value(u->manager->watch_bus, name, u);
2284 bool unit_can_serialize(Unit *u) {
2287 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2290 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2297 if (unit_can_serialize(u)) {
2300 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2304 rt = unit_get_exec_runtime(u);
2306 r = exec_runtime_serialize(rt, u, f, fds);
2312 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2313 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2314 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2315 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2316 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2318 if (dual_timestamp_is_set(&u->condition_timestamp))
2319 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2321 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2324 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2326 if (serialize_jobs) {
2328 fprintf(f, "job\n");
2329 job_serialize(u->job, f, fds);
2333 fprintf(f, "job\n");
2334 job_serialize(u->nop_job, f, fds);
2343 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2354 va_start(ap, format);
2355 vfprintf(f, format, ap);
2361 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2367 fprintf(f, "%s=%s\n", key, value);
2370 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2371 ExecRuntime **rt = NULL;
2379 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2381 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2384 char line[LINE_MAX], *l, *v;
2387 if (!fgets(line, sizeof(line), f)) {
2400 k = strcspn(l, "=");
2408 if (streq(l, "job")) {
2410 /* new-style serialized job */
2411 Job *j = job_new_raw(u);
2415 r = job_deserialize(j, f, fds);
2421 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2427 r = job_install_deserialized(j);
2429 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2434 if (j->state == JOB_RUNNING)
2435 u->manager->n_running_jobs++;
2438 JobType type = job_type_from_string(v);
2440 log_debug("Failed to parse job type value %s", v);
2442 u->deserialized_job = type;
2445 } else if (streq(l, "inactive-exit-timestamp")) {
2446 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2448 } else if (streq(l, "active-enter-timestamp")) {
2449 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2451 } else if (streq(l, "active-exit-timestamp")) {
2452 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2454 } else if (streq(l, "inactive-enter-timestamp")) {
2455 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2457 } else if (streq(l, "condition-timestamp")) {
2458 dual_timestamp_deserialize(v, &u->condition_timestamp);
2460 } else if (streq(l, "condition-result")) {
2463 b = parse_boolean(v);
2465 log_debug("Failed to parse condition result value %s", v);
2467 u->condition_result = b;
2471 } else if (streq(l, "transient")) {
2474 b = parse_boolean(v);
2476 log_debug("Failed to parse transient bool %s", v);
2481 } else if (streq(l, "cgroup")) {
2488 if (u->cgroup_path) {
2491 p = hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
2492 log_info("Removing cgroup_path %s from hashmap (%p)",
2494 free(u->cgroup_path);
2498 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2503 if (unit_can_serialize(u)) {
2505 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2512 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2519 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2521 _cleanup_free_ char *e = NULL;
2529 /* Adds in links to the device node that this unit is based on */
2531 if (!is_device_path(what))
2534 e = unit_name_from_path(what, ".device");
2538 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2543 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2548 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2556 int unit_coldplug(Unit *u) {
2561 if (UNIT_VTABLE(u)->coldplug)
2562 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2566 r = job_coldplug(u->job);
2569 } else if (u->deserialized_job >= 0) {
2571 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2575 u->deserialized_job = _JOB_TYPE_INVALID;
2581 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2582 DISABLE_WARNING_FORMAT_NONLITERAL;
2583 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2587 bool unit_need_daemon_reload(Unit *u) {
2588 _cleanup_strv_free_ char **t = NULL;
2591 unsigned loaded_cnt, current_cnt;
2595 if (u->fragment_path) {
2597 if (stat(u->fragment_path, &st) < 0)
2598 /* What, cannot access this anymore? */
2601 if (u->fragment_mtime > 0 &&
2602 timespec_load(&st.st_mtim) != u->fragment_mtime)
2606 if (u->source_path) {
2608 if (stat(u->source_path, &st) < 0)
2611 if (u->source_mtime > 0 &&
2612 timespec_load(&st.st_mtim) != u->source_mtime)
2616 t = unit_find_dropin_paths(u);
2617 loaded_cnt = strv_length(t);
2618 current_cnt = strv_length(u->dropin_paths);
2620 if (loaded_cnt == current_cnt) {
2621 if (loaded_cnt == 0)
2624 if (strv_overlap(u->dropin_paths, t)) {
2625 STRV_FOREACH(path, u->dropin_paths) {
2627 if (stat(*path, &st) < 0)
2630 if (u->dropin_mtime > 0 &&
2631 timespec_load(&st.st_mtim) > u->dropin_mtime)
2642 void unit_reset_failed(Unit *u) {
2645 if (UNIT_VTABLE(u)->reset_failed)
2646 UNIT_VTABLE(u)->reset_failed(u);
2649 Unit *unit_following(Unit *u) {
2652 if (UNIT_VTABLE(u)->following)
2653 return UNIT_VTABLE(u)->following(u);
2658 bool unit_stop_pending(Unit *u) {
2661 /* This call does check the current state of the unit. It's
2662 * hence useful to be called from state change calls of the
2663 * unit itself, where the state isn't updated yet. This is
2664 * different from unit_inactive_or_pending() which checks both
2665 * the current state and for a queued job. */
2667 return u->job && u->job->type == JOB_STOP;
2670 bool unit_inactive_or_pending(Unit *u) {
2673 /* Returns true if the unit is inactive or going down */
2675 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2678 if (unit_stop_pending(u))
2684 bool unit_active_or_pending(Unit *u) {
2687 /* Returns true if the unit is active or going up */
2689 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2693 (u->job->type == JOB_START ||
2694 u->job->type == JOB_RELOAD_OR_START ||
2695 u->job->type == JOB_RESTART))
2701 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2703 assert(w >= 0 && w < _KILL_WHO_MAX);
2705 assert(signo < _NSIG);
2707 if (!UNIT_VTABLE(u)->kill)
2710 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2713 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2717 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2721 /* Exclude the main/control pids from being killed via the cgroup */
2723 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2728 if (control_pid > 0) {
2729 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2741 int unit_kill_common(
2747 sd_bus_error *error) {
2751 if (who == KILL_MAIN && main_pid <= 0) {
2753 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2755 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2759 if (who == KILL_CONTROL && control_pid <= 0) {
2760 if (control_pid < 0)
2761 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2763 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2767 if (who == KILL_CONTROL || who == KILL_ALL)
2768 if (control_pid > 0)
2769 if (kill(control_pid, signo) < 0)
2772 if (who == KILL_MAIN || who == KILL_ALL)
2774 if (kill(main_pid, signo) < 0)
2777 if (who == KILL_ALL && u->cgroup_path) {
2778 _cleanup_set_free_ Set *pid_set = NULL;
2781 /* Exclude the main/control pids from being killed via the cgroup */
2782 pid_set = unit_pid_set(main_pid, control_pid);
2786 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2787 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2794 int unit_following_set(Unit *u, Set **s) {
2798 if (UNIT_VTABLE(u)->following_set)
2799 return UNIT_VTABLE(u)->following_set(u, s);
2805 UnitFileState unit_get_unit_file_state(Unit *u) {
2808 if (u->unit_file_state < 0 && u->fragment_path)
2809 u->unit_file_state = unit_file_get_state(
2810 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2811 NULL, basename(u->fragment_path));
2813 return u->unit_file_state;
2816 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2821 unit_ref_unset(ref);
2824 LIST_PREPEND(refs, u->refs, ref);
2828 void unit_ref_unset(UnitRef *ref) {
2834 LIST_REMOVE(refs, ref->unit->refs, ref);
2838 int unit_patch_contexts(Unit *u) {
2846 /* Patch in the manager defaults into the exec and cgroup
2847 * contexts, _after_ the rest of the settings have been
2850 ec = unit_get_exec_context(u);
2852 /* This only copies in the ones that need memory */
2853 for (i = 0; i < _RLIMIT_MAX; i++)
2854 if (u->manager->rlimit[i] && !ec->rlimit[i]) {
2855 ec->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2860 if (u->manager->running_as == SYSTEMD_USER &&
2861 !ec->working_directory) {
2863 r = get_home_dir(&ec->working_directory);
2868 if (u->manager->running_as == SYSTEMD_USER &&
2869 (ec->syscall_whitelist ||
2870 !set_isempty(ec->syscall_filter) ||
2871 !set_isempty(ec->syscall_archs) ||
2872 ec->address_families_whitelist ||
2873 !set_isempty(ec->address_families)))
2874 ec->no_new_privileges = true;
2876 if (ec->private_devices)
2877 ec->capability_bounding_set_drop |= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD;
2880 cc = unit_get_cgroup_context(u);
2884 ec->private_devices &&
2885 cc->device_policy == CGROUP_AUTO)
2886 cc->device_policy = CGROUP_CLOSED;
2892 ExecContext *unit_get_exec_context(Unit *u) {
2899 offset = UNIT_VTABLE(u)->exec_context_offset;
2903 return (ExecContext*) ((uint8_t*) u + offset);
2906 KillContext *unit_get_kill_context(Unit *u) {
2913 offset = UNIT_VTABLE(u)->kill_context_offset;
2917 return (KillContext*) ((uint8_t*) u + offset);
2920 CGroupContext *unit_get_cgroup_context(Unit *u) {
2926 offset = UNIT_VTABLE(u)->cgroup_context_offset;
2930 return (CGroupContext*) ((uint8_t*) u + offset);
2933 ExecRuntime *unit_get_exec_runtime(Unit *u) {
2939 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2943 return *(ExecRuntime**) ((uint8_t*) u + offset);
2946 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2947 _cleanup_free_ char *b = NULL;
2956 b = xescape(name, "/.");
2960 if (!filename_is_safe(b))
2963 if (u->manager->running_as == SYSTEMD_USER) {
2964 _cleanup_free_ char *c = NULL;
2966 r = user_config_home(&c);
2972 p = strjoin(c, "/", u->id, ".d", NULL);
2973 } else if (mode == UNIT_PERSISTENT && !u->transient)
2974 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2976 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2980 q = strjoin(p, "/90-", b, ".conf", NULL);
2991 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2992 _cleanup_free_ char *p = NULL, *q = NULL;
2999 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3002 r = drop_in_file(u, mode, name, &p, &q);
3007 return write_string_file_atomic_label(q, data);
3010 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3011 _cleanup_free_ char *p = NULL;
3019 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3022 va_start(ap, format);
3023 r = vasprintf(&p, format, ap);
3029 return unit_write_drop_in(u, mode, name, p);
3032 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3033 _cleanup_free_ char *ndata = NULL;
3039 if (!UNIT_VTABLE(u)->private_section)
3042 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3045 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
3049 return unit_write_drop_in(u, mode, name, ndata);
3052 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3053 _cleanup_free_ char *p = NULL;
3061 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3064 va_start(ap, format);
3065 r = vasprintf(&p, format, ap);
3071 return unit_write_drop_in_private(u, mode, name, p);
3074 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
3075 _cleanup_free_ char *p = NULL, *q = NULL;
3080 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3083 r = drop_in_file(u, mode, name, &p, &q);
3088 r = errno == ENOENT ? 0 : -errno;
3096 int unit_make_transient(Unit *u) {
3101 u->load_state = UNIT_STUB;
3103 u->transient = true;
3105 free(u->fragment_path);
3106 u->fragment_path = NULL;
3108 if (u->manager->running_as == SYSTEMD_USER) {
3109 _cleanup_free_ char *c = NULL;
3111 r = user_config_home(&c);
3117 u->fragment_path = strjoin(c, "/", u->id, NULL);
3118 if (!u->fragment_path)
3123 u->fragment_path = strappend("/run/systemd/system/", u->id);
3124 if (!u->fragment_path)
3127 mkdir_p("/run/systemd/system", 0755);
3130 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3133 int unit_kill_context(
3139 bool main_pid_alien) {
3141 int sig, wait_for_exit = false, r;
3146 if (c->kill_mode == KILL_NONE)
3149 sig = sigkill ? SIGKILL : c->kill_signal;
3152 r = kill_and_sigcont(main_pid, sig);
3154 if (r < 0 && r != -ESRCH) {
3155 _cleanup_free_ char *comm = NULL;
3156 get_process_comm(main_pid, &comm);
3158 log_warning_unit(u->id, "Failed to kill main process " PID_FMT " (%s): %s", main_pid, strna(comm), strerror(-r));
3160 if (!main_pid_alien)
3161 wait_for_exit = true;
3163 if (c->send_sighup && !sigkill)
3164 kill(main_pid, SIGHUP);
3168 if (control_pid > 0) {
3169 r = kill_and_sigcont(control_pid, sig);
3171 if (r < 0 && r != -ESRCH) {
3172 _cleanup_free_ char *comm = NULL;
3173 get_process_comm(control_pid, &comm);
3175 log_warning_unit(u->id, "Failed to kill control process " PID_FMT " (%s): %s", control_pid, strna(comm), strerror(-r));
3177 wait_for_exit = true;
3179 if (c->send_sighup && !sigkill)
3180 kill(control_pid, SIGHUP);
3184 if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && sigkill)) && u->cgroup_path) {
3185 _cleanup_set_free_ Set *pid_set = NULL;
3187 /* Exclude the main/control pids from being killed via the cgroup */
3188 pid_set = unit_pid_set(main_pid, control_pid);
3192 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3194 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3195 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3198 /* FIXME: For now, we will not wait for the
3199 * cgroup members to die, simply because
3200 * cgroup notification is unreliable. It
3201 * doesn't work at all in containers, and
3202 * outside of containers it can be confused
3203 * easily by leaving directories in the
3206 /* wait_for_exit = true; */
3208 if (c->send_sighup && !sigkill) {
3211 pid_set = unit_pid_set(main_pid, control_pid);
3215 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3220 return wait_for_exit;
3223 int unit_require_mounts_for(Unit *u, const char *path) {
3224 char prefix[strlen(path) + 1], *p;
3230 /* Registers a unit for requiring a certain path and all its
3231 * prefixes. We keep a simple array of these paths in the
3232 * unit, since its usually short. However, we build a prefix
3233 * table for all possible prefixes so that new appearing mount
3234 * units can easily determine which units to make themselves a
3237 if (!path_is_absolute(path))
3244 path_kill_slashes(p);
3246 if (!path_is_safe(p)) {
3251 if (strv_contains(u->requires_mounts_for, p)) {
3256 r = strv_consume(&u->requires_mounts_for, p);
3260 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3263 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3267 if (!u->manager->units_requiring_mounts_for) {
3268 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
3269 if (!u->manager->units_requiring_mounts_for)
3277 x = set_new(NULL, NULL);
3283 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3299 int unit_setup_exec_runtime(Unit *u) {
3305 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3308 /* Check if ther already is an ExecRuntime for this unit? */
3309 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3313 /* Try to get it from somebody else */
3314 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3316 *rt = unit_get_exec_runtime(other);
3318 exec_runtime_ref(*rt);
3323 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3326 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3327 [UNIT_ACTIVE] = "active",
3328 [UNIT_RELOADING] = "reloading",
3329 [UNIT_INACTIVE] = "inactive",
3330 [UNIT_FAILED] = "failed",
3331 [UNIT_ACTIVATING] = "activating",
3332 [UNIT_DEACTIVATING] = "deactivating"
3335 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3337 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3338 [UNIT_REQUIRES] = "Requires",
3339 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3340 [UNIT_REQUISITE] = "Requisite",
3341 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3342 [UNIT_WANTS] = "Wants",
3343 [UNIT_BINDS_TO] = "BindsTo",
3344 [UNIT_PART_OF] = "PartOf",
3345 [UNIT_REQUIRED_BY] = "RequiredBy",
3346 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3347 [UNIT_WANTED_BY] = "WantedBy",
3348 [UNIT_BOUND_BY] = "BoundBy",
3349 [UNIT_CONSISTS_OF] = "ConsistsOf",
3350 [UNIT_CONFLICTS] = "Conflicts",
3351 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3352 [UNIT_BEFORE] = "Before",
3353 [UNIT_AFTER] = "After",
3354 [UNIT_ON_FAILURE] = "OnFailure",
3355 [UNIT_TRIGGERS] = "Triggers",
3356 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3357 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3358 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3359 [UNIT_JOINS_NAMESPACE_OF] = "JoinsNamespaceOf",
3360 [UNIT_REFERENCES] = "References",
3361 [UNIT_REFERENCED_BY] = "ReferencedBy",
3364 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);