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);
512 free(u->description);
513 strv_free(u->documentation);
514 free(u->fragment_path);
515 free(u->source_path);
516 strv_free(u->dropin_paths);
519 set_free_free(u->names);
521 unit_unwatch_all_pids(u);
523 condition_free_list(u->conditions);
525 unit_ref_unset(&u->slice);
528 unit_ref_unset(u->refs);
533 UnitActiveState unit_active_state(Unit *u) {
536 if (u->load_state == UNIT_MERGED)
537 return unit_active_state(unit_follow_merge(u));
539 /* After a reload it might happen that a unit is not correctly
540 * loaded but still has a process around. That's why we won't
541 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
543 return UNIT_VTABLE(u)->active_state(u);
546 const char* unit_sub_state_to_string(Unit *u) {
549 return UNIT_VTABLE(u)->sub_state_to_string(u);
552 static void complete_move(Set **s, Set **other) {
560 set_move(*s, *other);
567 static void merge_names(Unit *u, Unit *other) {
574 complete_move(&u->names, &other->names);
576 set_free_free(other->names);
580 SET_FOREACH(t, u->names, i)
581 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
584 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
591 assert(d < _UNIT_DEPENDENCY_MAX);
593 /* Fix backwards pointers */
594 SET_FOREACH(back, other->dependencies[d], i) {
597 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {
598 r = set_remove_and_put(back->dependencies[k], other, u);
600 set_remove(back->dependencies[k], other);
602 assert(r >= 0 || r == -ENOENT);
606 complete_move(&u->dependencies[d], &other->dependencies[d]);
608 set_free(other->dependencies[d]);
609 other->dependencies[d] = NULL;
612 int unit_merge(Unit *u, Unit *other) {
617 assert(u->manager == other->manager);
618 assert(u->type != _UNIT_TYPE_INVALID);
620 other = unit_follow_merge(other);
625 if (u->type != other->type)
628 if (!u->instance != !other->instance)
631 if (other->load_state != UNIT_STUB &&
632 other->load_state != UNIT_NOT_FOUND)
641 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
645 merge_names(u, other);
647 /* Redirect all references */
649 unit_ref_set(other->refs, u);
651 /* Merge dependencies */
652 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
653 merge_dependencies(u, other, d);
655 other->load_state = UNIT_MERGED;
656 other->merged_into = u;
658 /* If there is still some data attached to the other node, we
659 * don't need it anymore, and can free it. */
660 if (other->load_state != UNIT_STUB)
661 if (UNIT_VTABLE(other)->done)
662 UNIT_VTABLE(other)->done(other);
664 unit_add_to_dbus_queue(u);
665 unit_add_to_cleanup_queue(other);
670 int unit_merge_by_name(Unit *u, const char *name) {
673 _cleanup_free_ char *s = NULL;
678 if (unit_name_is_template(name)) {
682 s = unit_name_replace_instance(name, u->instance);
689 other = manager_get_unit(u->manager, name);
691 r = unit_add_name(u, name);
693 r = unit_merge(u, other);
698 Unit* unit_follow_merge(Unit *u) {
701 while (u->load_state == UNIT_MERGED)
702 assert_se(u = u->merged_into);
707 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
713 if (c->working_directory) {
714 r = unit_require_mounts_for(u, c->working_directory);
719 if (c->root_directory) {
720 r = unit_require_mounts_for(u, c->root_directory);
725 if (u->manager->running_as != SYSTEMD_SYSTEM)
728 if (c->private_tmp) {
729 r = unit_require_mounts_for(u, "/tmp");
733 r = unit_require_mounts_for(u, "/var/tmp");
738 if (c->std_output != EXEC_OUTPUT_KMSG &&
739 c->std_output != EXEC_OUTPUT_SYSLOG &&
740 c->std_output != EXEC_OUTPUT_JOURNAL &&
741 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
742 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
743 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
744 c->std_error != EXEC_OUTPUT_KMSG &&
745 c->std_error != EXEC_OUTPUT_SYSLOG &&
746 c->std_error != EXEC_OUTPUT_JOURNAL &&
747 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
748 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
749 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
752 /* If syslog or kernel logging is requested, make sure our own
753 * logging daemon is run first. */
755 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
762 const char *unit_description(Unit *u) {
766 return u->description;
771 void unit_dump(Unit *u, FILE *f, const char *prefix) {
775 _cleanup_free_ char *p2 = NULL;
778 timestamp1[FORMAT_TIMESTAMP_MAX],
779 timestamp2[FORMAT_TIMESTAMP_MAX],
780 timestamp3[FORMAT_TIMESTAMP_MAX],
781 timestamp4[FORMAT_TIMESTAMP_MAX],
782 timespan[FORMAT_TIMESPAN_MAX];
784 _cleanup_set_free_ Set *following_set = NULL;
788 assert(u->type >= 0);
792 p2 = strappend(prefix, "\t");
793 prefix2 = p2 ? p2 : prefix;
797 "%s\tDescription: %s\n"
799 "%s\tUnit Load State: %s\n"
800 "%s\tUnit Active State: %s\n"
801 "%s\tInactive Exit Timestamp: %s\n"
802 "%s\tActive Enter Timestamp: %s\n"
803 "%s\tActive Exit Timestamp: %s\n"
804 "%s\tInactive Enter Timestamp: %s\n"
805 "%s\tGC Check Good: %s\n"
806 "%s\tNeed Daemon Reload: %s\n"
807 "%s\tTransient: %s\n"
810 "%s\tCGroup realized: %s\n"
811 "%s\tCGroup mask: 0x%x\n"
812 "%s\tCGroup members mask: 0x%x\n",
814 prefix, unit_description(u),
815 prefix, strna(u->instance),
816 prefix, unit_load_state_to_string(u->load_state),
817 prefix, unit_active_state_to_string(unit_active_state(u)),
818 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
819 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
820 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
821 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
822 prefix, yes_no(unit_check_gc(u)),
823 prefix, yes_no(unit_need_daemon_reload(u)),
824 prefix, yes_no(u->transient),
825 prefix, strna(unit_slice_name(u)),
826 prefix, strna(u->cgroup_path),
827 prefix, yes_no(u->cgroup_realized),
828 prefix, u->cgroup_realized_mask,
829 prefix, u->cgroup_members_mask);
831 SET_FOREACH(t, u->names, i)
832 fprintf(f, "%s\tName: %s\n", prefix, t);
834 STRV_FOREACH(j, u->documentation)
835 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
837 following = unit_following(u);
839 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
841 r = unit_following_set(u, &following_set);
845 SET_FOREACH(other, following_set, i)
846 fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
849 if (u->fragment_path)
850 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
853 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
855 STRV_FOREACH(j, u->dropin_paths)
856 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
858 if (u->job_timeout > 0)
859 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
861 condition_dump_list(u->conditions, f, prefix);
863 if (dual_timestamp_is_set(&u->condition_timestamp))
865 "%s\tCondition Timestamp: %s\n"
866 "%s\tCondition Result: %s\n",
867 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
868 prefix, yes_no(u->condition_result));
870 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
873 SET_FOREACH(other, u->dependencies[d], i)
874 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
877 if (!strv_isempty(u->requires_mounts_for)) {
879 "%s\tRequiresMountsFor:", prefix);
881 STRV_FOREACH(j, u->requires_mounts_for)
882 fprintf(f, " %s", *j);
887 if (u->load_state == UNIT_LOADED) {
890 "%s\tStopWhenUnneeded: %s\n"
891 "%s\tRefuseManualStart: %s\n"
892 "%s\tRefuseManualStop: %s\n"
893 "%s\tDefaultDependencies: %s\n"
894 "%s\tOnFailureJobMode: %s\n"
895 "%s\tIgnoreOnIsolate: %s\n"
896 "%s\tIgnoreOnSnapshot: %s\n",
897 prefix, yes_no(u->stop_when_unneeded),
898 prefix, yes_no(u->refuse_manual_start),
899 prefix, yes_no(u->refuse_manual_stop),
900 prefix, yes_no(u->default_dependencies),
901 prefix, job_mode_to_string(u->on_failure_job_mode),
902 prefix, yes_no(u->ignore_on_isolate),
903 prefix, yes_no(u->ignore_on_snapshot));
905 if (UNIT_VTABLE(u)->dump)
906 UNIT_VTABLE(u)->dump(u, f, prefix2);
908 } else if (u->load_state == UNIT_MERGED)
910 "%s\tMerged into: %s\n",
911 prefix, u->merged_into->id);
912 else if (u->load_state == UNIT_ERROR)
913 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
917 job_dump(u->job, f, prefix2);
920 job_dump(u->nop_job, f, prefix2);
924 /* Common implementation for multiple backends */
925 int unit_load_fragment_and_dropin(Unit *u) {
930 /* Load a .{service,socket,...} file */
931 r = unit_load_fragment(u);
935 if (u->load_state == UNIT_STUB)
938 /* Load drop-in directory data */
939 r = unit_load_dropin(unit_follow_merge(u));
946 /* Common implementation for multiple backends */
947 int unit_load_fragment_and_dropin_optional(Unit *u) {
952 /* Same as unit_load_fragment_and_dropin(), but whether
953 * something can be loaded or not doesn't matter. */
955 /* Load a .service file */
956 r = unit_load_fragment(u);
960 if (u->load_state == UNIT_STUB)
961 u->load_state = UNIT_LOADED;
963 /* Load drop-in directory data */
964 r = unit_load_dropin(unit_follow_merge(u));
971 int unit_add_default_target_dependency(Unit *u, Unit *target) {
975 if (target->type != UNIT_TARGET)
978 /* Only add the dependency if both units are loaded, so that
979 * that loop check below is reliable */
980 if (u->load_state != UNIT_LOADED ||
981 target->load_state != UNIT_LOADED)
984 /* If either side wants no automatic dependencies, then let's
986 if (!u->default_dependencies ||
987 !target->default_dependencies)
990 /* Don't create loops */
991 if (set_get(target->dependencies[UNIT_BEFORE], u))
994 return unit_add_dependency(target, UNIT_AFTER, u, true);
997 static int unit_add_target_dependencies(Unit *u) {
999 static const UnitDependency deps[] = {
1001 UNIT_REQUIRED_BY_OVERRIDABLE,
1013 for (k = 0; k < ELEMENTSOF(deps); k++)
1014 SET_FOREACH(target, u->dependencies[deps[k]], i) {
1015 r = unit_add_default_target_dependency(u, target);
1023 static int unit_add_slice_dependencies(Unit *u) {
1026 if (!unit_get_cgroup_context(u))
1029 if (UNIT_ISSET(u->slice))
1030 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
1032 return unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
1035 static int unit_add_mount_dependencies(Unit *u) {
1041 STRV_FOREACH(i, u->requires_mounts_for) {
1042 char prefix[strlen(*i) + 1];
1044 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
1047 r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
1055 if (m->load_state != UNIT_LOADED)
1058 r = unit_add_dependency(u, UNIT_AFTER, m, true);
1062 if (m->fragment_path) {
1063 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
1073 int unit_load(Unit *u) {
1078 if (u->in_load_queue) {
1079 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1080 u->in_load_queue = false;
1083 if (u->type == _UNIT_TYPE_INVALID)
1086 if (u->load_state != UNIT_STUB)
1089 if (UNIT_VTABLE(u)->load) {
1090 r = UNIT_VTABLE(u)->load(u);
1095 if (u->load_state == UNIT_STUB) {
1100 if (u->load_state == UNIT_LOADED) {
1102 r = unit_add_target_dependencies(u);
1106 r = unit_add_slice_dependencies(u);
1110 r = unit_add_mount_dependencies(u);
1114 if (u->on_failure_job_mode == JOB_ISOLATE && set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1115 log_error_unit(u->id, "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
1120 unit_update_cgroup_members_masks(u);
1123 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1125 unit_add_to_dbus_queue(unit_follow_merge(u));
1126 unit_add_to_gc_queue(u);
1131 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1133 unit_add_to_dbus_queue(u);
1134 unit_add_to_gc_queue(u);
1136 log_debug_unit(u->id, "Failed to load configuration for %s: %s",
1137 u->id, strerror(-r));
1142 static bool unit_condition_test(Unit *u) {
1145 dual_timestamp_get(&u->condition_timestamp);
1146 u->condition_result = condition_test_list(u->id, u->conditions);
1148 return u->condition_result;
1151 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1152 const UnitStatusMessageFormats *format_table;
1156 assert(t < _JOB_TYPE_MAX);
1158 if (t != JOB_START && t != JOB_STOP)
1161 format_table = &UNIT_VTABLE(u)->status_message_formats;
1165 return format_table->starting_stopping[t == JOB_STOP];
1168 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1173 assert(t < _JOB_TYPE_MAX);
1175 format = unit_get_status_message_format(u, t);
1179 /* Return generic strings */
1181 return "Starting %s.";
1182 else if (t == JOB_STOP)
1183 return "Stopping %s.";
1184 else if (t == JOB_RELOAD)
1185 return "Reloading %s.";
1190 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1195 /* We only print status messages for selected units on
1196 * selected operations. */
1198 format = unit_get_status_message_format(u, t);
1202 DISABLE_WARNING_FORMAT_NONLITERAL;
1203 unit_status_printf(u, "", format);
1207 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1214 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1217 if (log_on_console())
1220 /* We log status messages for all units and all operations. */
1222 format = unit_get_status_message_format_try_harder(u, t);
1226 DISABLE_WARNING_FORMAT_NONLITERAL;
1227 snprintf(buf, sizeof(buf), format, unit_description(u));
1231 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1232 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1233 SD_MESSAGE_UNIT_RELOADING;
1235 log_struct_unit(LOG_INFO,
1243 * -EBADR: This unit type does not support starting.
1244 * -EALREADY: Unit is already started.
1245 * -EAGAIN: An operation is already in progress. Retry later.
1246 * -ECANCELED: Too many requests for now.
1248 int unit_start(Unit *u) {
1249 UnitActiveState state;
1254 if (u->load_state != UNIT_LOADED)
1257 /* If this is already started, then this will succeed. Note
1258 * that this will even succeed if this unit is not startable
1259 * by the user. This is relied on to detect when we need to
1260 * wait for units and when waiting is finished. */
1261 state = unit_active_state(u);
1262 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1265 /* If the conditions failed, don't do anything at all. If we
1266 * already are activating this call might still be useful to
1267 * speed up activation in case there is some hold-off time,
1268 * but we don't want to recheck the condition in that case. */
1269 if (state != UNIT_ACTIVATING &&
1270 !unit_condition_test(u)) {
1271 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1275 /* Forward to the main object, if we aren't it. */
1276 following = unit_following(u);
1278 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1279 u->id, following->id);
1280 return unit_start(following);
1283 unit_status_log_starting_stopping_reloading(u, JOB_START);
1284 unit_status_print_starting_stopping(u, JOB_START);
1286 /* If it is stopped, but we cannot start it, then fail */
1287 if (!UNIT_VTABLE(u)->start)
1290 /* We don't suppress calls to ->start() here when we are
1291 * already starting, to allow this request to be used as a
1292 * "hurry up" call, for example when the unit is in some "auto
1293 * restart" state where it waits for a holdoff timer to elapse
1294 * before it will start again. */
1296 unit_add_to_dbus_queue(u);
1298 return UNIT_VTABLE(u)->start(u);
1301 bool unit_can_start(Unit *u) {
1304 return !!UNIT_VTABLE(u)->start;
1307 bool unit_can_isolate(Unit *u) {
1310 return unit_can_start(u) &&
1315 * -EBADR: This unit type does not support stopping.
1316 * -EALREADY: Unit is already stopped.
1317 * -EAGAIN: An operation is already in progress. Retry later.
1319 int unit_stop(Unit *u) {
1320 UnitActiveState state;
1325 state = unit_active_state(u);
1326 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1329 if ((following = unit_following(u))) {
1330 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1331 u->id, following->id);
1332 return unit_stop(following);
1335 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1336 unit_status_print_starting_stopping(u, JOB_STOP);
1338 if (!UNIT_VTABLE(u)->stop)
1341 unit_add_to_dbus_queue(u);
1343 return UNIT_VTABLE(u)->stop(u);
1347 * -EBADR: This unit type does not support reloading.
1348 * -ENOEXEC: Unit is not started.
1349 * -EAGAIN: An operation is already in progress. Retry later.
1351 int unit_reload(Unit *u) {
1352 UnitActiveState state;
1357 if (u->load_state != UNIT_LOADED)
1360 if (!unit_can_reload(u))
1363 state = unit_active_state(u);
1364 if (state == UNIT_RELOADING)
1367 if (state != UNIT_ACTIVE) {
1368 log_warning_unit(u->id, "Unit %s cannot be reloaded because it is inactive.",
1373 following = unit_following(u);
1375 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1376 u->id, following->id);
1377 return unit_reload(following);
1380 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1382 unit_add_to_dbus_queue(u);
1383 return UNIT_VTABLE(u)->reload(u);
1386 bool unit_can_reload(Unit *u) {
1389 if (!UNIT_VTABLE(u)->reload)
1392 if (!UNIT_VTABLE(u)->can_reload)
1395 return UNIT_VTABLE(u)->can_reload(u);
1398 static void unit_check_unneeded(Unit *u) {
1404 /* If this service shall be shut down when unneeded then do
1407 if (!u->stop_when_unneeded)
1410 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1413 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1414 if (unit_active_or_pending(other))
1417 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1418 if (unit_active_or_pending(other))
1421 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1422 if (unit_active_or_pending(other))
1425 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1426 if (unit_active_or_pending(other))
1429 log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1431 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1432 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1435 static void retroactively_start_dependencies(Unit *u) {
1440 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1442 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1443 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1444 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1445 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1447 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1448 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1449 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1450 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1452 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1453 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1454 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1455 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1457 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1458 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1459 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1460 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1462 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1463 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1464 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1466 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1467 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1468 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1471 static void retroactively_stop_dependencies(Unit *u) {
1476 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1478 /* Pull down units which are bound to us recursively if enabled */
1479 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1480 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1481 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1484 static void check_unneeded_dependencies(Unit *u) {
1489 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1491 /* Garbage collect services that might not be needed anymore, if enabled */
1492 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1493 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1494 unit_check_unneeded(other);
1495 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1496 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1497 unit_check_unneeded(other);
1498 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1499 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1500 unit_check_unneeded(other);
1501 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1502 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1503 unit_check_unneeded(other);
1504 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1505 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1506 unit_check_unneeded(other);
1507 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1508 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1509 unit_check_unneeded(other);
1512 void unit_start_on_failure(Unit *u) {
1518 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1521 log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1523 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1526 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1528 log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1532 void unit_trigger_notify(Unit *u) {
1538 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1539 if (UNIT_VTABLE(other)->trigger_notify)
1540 UNIT_VTABLE(other)->trigger_notify(other, u);
1543 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1548 assert(os < _UNIT_ACTIVE_STATE_MAX);
1549 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1551 /* Note that this is called for all low-level state changes,
1552 * even if they might map to the same high-level
1553 * UnitActiveState! That means that ns == os is OK an expected
1554 * behavior here. For example: if a mount point is remounted
1555 * this function will be called too! */
1559 /* Update timestamps for state changes */
1560 if (m->n_reloading <= 0) {
1563 dual_timestamp_get(&ts);
1565 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1566 u->inactive_exit_timestamp = ts;
1567 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1568 u->inactive_enter_timestamp = ts;
1570 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1571 u->active_enter_timestamp = ts;
1572 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1573 u->active_exit_timestamp = ts;
1576 /* Keep track of failed of units */
1577 if (ns == UNIT_FAILED && os != UNIT_FAILED)
1578 set_put(u->manager->failed_units, u);
1579 else if (os == UNIT_FAILED && ns != UNIT_FAILED)
1580 set_remove(u->manager->failed_units, u);
1582 /* Make sure the cgroup is always removed when we become inactive */
1583 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1584 unit_destroy_cgroup(u);
1586 /* Note that this doesn't apply to RemainAfterExit services exiting
1587 * successfully, since there's no change of state in that case. Which is
1588 * why it is handled in service_set_state() */
1589 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1592 ec = unit_get_exec_context(u);
1593 if (ec && exec_context_may_touch_console(ec)) {
1594 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1597 if (m->n_on_console == 0)
1598 /* unset no_console_output flag, since the console is free */
1599 m->no_console_output = false;
1608 if (u->job->state == JOB_WAITING)
1610 /* So we reached a different state for this
1611 * job. Let's see if we can run it now if it
1612 * failed previously due to EAGAIN. */
1613 job_add_to_run_queue(u->job);
1615 /* Let's check whether this state change constitutes a
1616 * finished job, or maybe contradicts a running job and
1617 * hence needs to invalidate jobs. */
1619 switch (u->job->type) {
1622 case JOB_VERIFY_ACTIVE:
1624 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1625 job_finish_and_invalidate(u->job, JOB_DONE, true);
1626 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1629 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1630 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1636 case JOB_RELOAD_OR_START:
1638 if (u->job->state == JOB_RUNNING) {
1639 if (ns == UNIT_ACTIVE)
1640 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1641 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1644 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1645 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1653 case JOB_TRY_RESTART:
1655 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1656 job_finish_and_invalidate(u->job, JOB_DONE, true);
1657 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1659 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1665 assert_not_reached("Job type unknown");
1671 if (m->n_reloading <= 0) {
1673 /* If this state change happened without being
1674 * requested by a job, then let's retroactively start
1675 * or stop dependencies. We skip that step when
1676 * deserializing, since we don't want to create any
1677 * additional jobs just because something is already
1681 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1682 retroactively_start_dependencies(u);
1683 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1684 retroactively_stop_dependencies(u);
1687 /* stop unneeded units regardless if going down was expected or not */
1688 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1689 check_unneeded_dependencies(u);
1691 if (ns != os && ns == UNIT_FAILED) {
1692 log_notice_unit(u->id, "Unit %s entered failed state.", u->id);
1693 unit_start_on_failure(u);
1697 /* Some names are special */
1698 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1700 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1701 /* The bus just might have become available,
1702 * hence try to connect to it, if we aren't
1706 if (u->type == UNIT_SERVICE &&
1707 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1708 m->n_reloading <= 0) {
1709 /* Write audit record if we have just finished starting up */
1710 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1714 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1715 manager_send_unit_plymouth(m, u);
1719 /* We don't care about D-Bus here, since we'll get an
1720 * asynchronous notification for it anyway. */
1722 if (u->type == UNIT_SERVICE &&
1723 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1724 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1725 m->n_reloading <= 0) {
1727 /* Hmm, if there was no start record written
1728 * write it now, so that we always have a nice
1731 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1733 if (ns == UNIT_INACTIVE)
1734 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1736 /* Write audit record if we have just finished shutting down */
1737 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1739 u->in_audit = false;
1743 manager_recheck_journal(m);
1744 unit_trigger_notify(u);
1746 /* Maybe we finished startup and are now ready for being
1747 * stopped because unneeded? */
1748 if (u->manager->n_reloading <= 0)
1749 unit_check_unneeded(u);
1751 unit_add_to_dbus_queue(u);
1752 unit_add_to_gc_queue(u);
1755 int unit_watch_pid(Unit *u, pid_t pid) {
1761 /* Watch a specific PID. We only support one or two units
1762 * watching each PID for now, not more. */
1764 r = set_ensure_allocated(&u->pids, trivial_hash_func, trivial_compare_func);
1768 r = hashmap_ensure_allocated(&u->manager->watch_pids1, trivial_hash_func, trivial_compare_func);
1772 r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1774 r = hashmap_ensure_allocated(&u->manager->watch_pids2, trivial_hash_func, trivial_compare_func);
1778 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1781 q = set_put(u->pids, LONG_TO_PTR(pid));
1788 void unit_unwatch_pid(Unit *u, pid_t pid) {
1792 hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1793 hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1794 set_remove(u->pids, LONG_TO_PTR(pid));
1797 void unit_unwatch_all_pids(Unit *u) {
1800 while (!set_isempty(u->pids))
1801 unit_unwatch_pid(u, PTR_TO_LONG(set_first(u->pids)));
1807 static int unit_watch_pids_in_path(Unit *u, const char *path) {
1808 _cleanup_closedir_ DIR *d = NULL;
1809 _cleanup_fclose_ FILE *f = NULL;
1815 /* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
1817 r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
1821 while ((r = cg_read_pid(f, &pid)) > 0) {
1822 r = unit_watch_pid(u, pid);
1823 if (r < 0 && ret >= 0)
1826 if (r < 0 && ret >= 0)
1829 } else if (ret >= 0)
1832 r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
1836 while ((r = cg_read_subgroup(d, &fn)) > 0) {
1837 _cleanup_free_ char *p = NULL;
1839 p = strjoin(path, "/", fn, NULL);
1845 r = unit_watch_pids_in_path(u, p);
1846 if (r < 0 && ret >= 0)
1849 if (r < 0 && ret >= 0)
1852 } else if (ret >= 0)
1858 int unit_watch_all_pids(Unit *u) {
1861 /* Adds all PIDs from our cgroup to the set of PIDs we watch */
1863 if (!u->cgroup_path)
1866 return unit_watch_pids_in_path(u, u->cgroup_path);
1869 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
1875 /* Cleans dead PIDs from our list */
1877 SET_FOREACH(e, u->pids, i) {
1878 pid_t pid = PTR_TO_LONG(e);
1880 if (pid == except1 || pid == except2)
1883 if (!pid_is_unwaited(pid))
1884 unit_unwatch_pid(u, pid);
1888 bool unit_job_is_applicable(Unit *u, JobType j) {
1890 assert(j >= 0 && j < _JOB_TYPE_MAX);
1894 case JOB_VERIFY_ACTIVE:
1901 case JOB_TRY_RESTART:
1902 return unit_can_start(u);
1905 return unit_can_reload(u);
1907 case JOB_RELOAD_OR_START:
1908 return unit_can_reload(u) && unit_can_start(u);
1911 assert_not_reached("Invalid job type");
1915 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1917 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1918 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1919 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1920 [UNIT_WANTS] = UNIT_WANTED_BY,
1921 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1922 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1923 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1924 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1925 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1926 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1927 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1928 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1929 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1930 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1931 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1932 [UNIT_BEFORE] = UNIT_AFTER,
1933 [UNIT_AFTER] = UNIT_BEFORE,
1934 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1935 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1936 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1937 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1938 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1939 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1940 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1941 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
1943 int r, q = 0, v = 0, w = 0;
1946 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1949 u = unit_follow_merge(u);
1950 other = unit_follow_merge(other);
1952 /* We won't allow dependencies on ourselves. We will not
1953 * consider them an error however. */
1957 r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func);
1961 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
1962 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func);
1967 if (add_reference) {
1968 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func);
1972 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func);
1977 q = set_put(u->dependencies[d], other);
1981 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
1982 v = set_put(other->dependencies[inverse_table[d]], u);
1989 if (add_reference) {
1990 w = set_put(u->dependencies[UNIT_REFERENCES], other);
1996 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
2001 unit_add_to_dbus_queue(u);
2006 set_remove(u->dependencies[d], other);
2009 set_remove(other->dependencies[inverse_table[d]], u);
2012 set_remove(u->dependencies[UNIT_REFERENCES], other);
2017 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
2022 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
2025 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
2031 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
2035 assert(name || path);
2039 name = basename(path);
2041 if (!unit_name_is_template(name)) {
2047 s = unit_name_replace_instance(name, u->instance);
2049 _cleanup_free_ char *i = NULL;
2051 i = unit_name_to_prefix(u->id);
2055 s = unit_name_replace_instance(name, i);
2065 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2068 _cleanup_free_ char *s = NULL;
2071 assert(name || path);
2073 name = resolve_template(u, name, path, &s);
2077 r = manager_load_unit(u->manager, name, path, NULL, &other);
2081 return unit_add_dependency(u, d, other, add_reference);
2084 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2087 _cleanup_free_ char *s = NULL;
2090 assert(name || path);
2092 if (!(name = resolve_template(u, name, path, &s)))
2095 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2098 r = unit_add_two_dependencies(u, d, e, other, add_reference);
2103 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2106 _cleanup_free_ char *s = NULL;
2109 assert(name || path);
2111 if (!(name = resolve_template(u, name, path, &s)))
2114 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2117 r = unit_add_dependency(other, d, u, add_reference);
2122 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2125 _cleanup_free_ char *s = NULL;
2128 assert(name || path);
2130 if (!(name = resolve_template(u, name, path, &s)))
2133 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2136 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
2142 int set_unit_path(const char *p) {
2143 _cleanup_free_ char *c = NULL;
2145 /* This is mostly for debug purposes */
2146 c = path_make_absolute_cwd(p);
2147 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
2153 char *unit_dbus_path(Unit *u) {
2159 return unit_dbus_path_from_name(u->id);
2162 char *unit_default_cgroup_path(Unit *u) {
2163 _cleanup_free_ char *escaped = NULL, *slice = NULL;
2168 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2169 return strdup(u->manager->cgroup_root);
2171 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2172 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2177 escaped = cg_escape(u->id);
2182 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2184 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2187 int unit_add_default_slice(Unit *u, CGroupContext *c) {
2188 _cleanup_free_ char *b = NULL;
2189 const char *slice_name;
2196 if (UNIT_ISSET(u->slice))
2200 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2202 /* Implicitly place all instantiated units in their
2203 * own per-template slice */
2205 prefix = unit_name_to_prefix(u->id);
2209 /* The prefix is already escaped, but it might include
2210 * "-" which has a special meaning for slice units,
2211 * hence escape it here extra. */
2212 escaped = strreplace(prefix, "-", "\\x2d");
2216 if (u->manager->running_as == SYSTEMD_SYSTEM)
2217 b = strjoin("system-", escaped, ".slice", NULL);
2219 b = strappend(escaped, ".slice");
2226 u->manager->running_as == SYSTEMD_SYSTEM
2227 ? SPECIAL_SYSTEM_SLICE
2228 : SPECIAL_ROOT_SLICE;
2230 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2234 unit_ref_set(&u->slice, slice);
2238 const char *unit_slice_name(Unit *u) {
2241 if (!UNIT_ISSET(u->slice))
2244 return UNIT_DEREF(u->slice)->id;
2247 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2248 _cleanup_free_ char *t = NULL;
2255 t = unit_name_change_suffix(u->id, type);
2259 assert(!unit_has_name(u, t));
2261 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2262 assert(r < 0 || *_found != u);
2266 int unit_watch_bus_name(Unit *u, const char *name) {
2270 /* Watch a specific name on the bus. We only support one unit
2271 * watching each name for now. */
2273 return hashmap_put(u->manager->watch_bus, name, u);
2276 void unit_unwatch_bus_name(Unit *u, const char *name) {
2280 hashmap_remove_value(u->manager->watch_bus, name, u);
2283 bool unit_can_serialize(Unit *u) {
2286 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2289 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);
2311 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2312 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2313 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2314 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2315 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2317 if (dual_timestamp_is_set(&u->condition_timestamp))
2318 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2320 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2323 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2325 if (serialize_jobs) {
2327 fprintf(f, "job\n");
2328 job_serialize(u->job, f, fds);
2332 fprintf(f, "job\n");
2333 job_serialize(u->nop_job, f, fds);
2342 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2353 va_start(ap, format);
2354 vfprintf(f, format, ap);
2360 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2366 fprintf(f, "%s=%s\n", key, value);
2369 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2371 ExecRuntime **rt = NULL;
2378 if (!unit_can_serialize(u))
2381 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2383 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2386 char line[LINE_MAX], *l, *v;
2389 if (!fgets(line, sizeof(line), f)) {
2402 k = strcspn(l, "=");
2410 if (streq(l, "job")) {
2412 /* new-style serialized job */
2413 Job *j = job_new_raw(u);
2417 r = job_deserialize(j, f, fds);
2423 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2429 r = job_install_deserialized(j);
2431 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2436 if (j->state == JOB_RUNNING)
2437 u->manager->n_running_jobs++;
2440 JobType type = job_type_from_string(v);
2442 log_debug("Failed to parse job type value %s", v);
2444 u->deserialized_job = type;
2447 } else if (streq(l, "inactive-exit-timestamp")) {
2448 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2450 } else if (streq(l, "active-enter-timestamp")) {
2451 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2453 } else if (streq(l, "active-exit-timestamp")) {
2454 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2456 } else if (streq(l, "inactive-enter-timestamp")) {
2457 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2459 } else if (streq(l, "condition-timestamp")) {
2460 dual_timestamp_deserialize(v, &u->condition_timestamp);
2462 } else if (streq(l, "condition-result")) {
2465 b = parse_boolean(v);
2467 log_debug("Failed to parse condition result value %s", v);
2469 u->condition_result = b;
2473 } else if (streq(l, "transient")) {
2476 b = parse_boolean(v);
2478 log_debug("Failed to parse transient bool %s", v);
2483 } else if (streq(l, "cgroup")) {
2490 free(u->cgroup_path);
2493 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2498 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2505 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2511 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2513 _cleanup_free_ char *e = NULL;
2521 /* Adds in links to the device node that this unit is based on */
2523 if (!is_device_path(what))
2526 e = unit_name_from_path(what, ".device");
2530 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2535 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2540 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2548 int unit_coldplug(Unit *u) {
2553 if (UNIT_VTABLE(u)->coldplug)
2554 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2558 r = job_coldplug(u->job);
2561 } else if (u->deserialized_job >= 0) {
2563 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2567 u->deserialized_job = _JOB_TYPE_INVALID;
2573 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2574 DISABLE_WARNING_FORMAT_NONLITERAL;
2575 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2579 bool unit_need_daemon_reload(Unit *u) {
2580 _cleanup_strv_free_ char **t = NULL;
2583 unsigned loaded_cnt, current_cnt;
2587 if (u->fragment_path) {
2589 if (stat(u->fragment_path, &st) < 0)
2590 /* What, cannot access this anymore? */
2593 if (u->fragment_mtime > 0 &&
2594 timespec_load(&st.st_mtim) != u->fragment_mtime)
2598 if (u->source_path) {
2600 if (stat(u->source_path, &st) < 0)
2603 if (u->source_mtime > 0 &&
2604 timespec_load(&st.st_mtim) != u->source_mtime)
2608 t = unit_find_dropin_paths(u);
2609 loaded_cnt = strv_length(t);
2610 current_cnt = strv_length(u->dropin_paths);
2612 if (loaded_cnt == current_cnt) {
2613 if (loaded_cnt == 0)
2616 if (strv_overlap(u->dropin_paths, t)) {
2617 STRV_FOREACH(path, u->dropin_paths) {
2619 if (stat(*path, &st) < 0)
2622 if (u->dropin_mtime > 0 &&
2623 timespec_load(&st.st_mtim) > u->dropin_mtime)
2634 void unit_reset_failed(Unit *u) {
2637 if (UNIT_VTABLE(u)->reset_failed)
2638 UNIT_VTABLE(u)->reset_failed(u);
2641 Unit *unit_following(Unit *u) {
2644 if (UNIT_VTABLE(u)->following)
2645 return UNIT_VTABLE(u)->following(u);
2650 bool unit_stop_pending(Unit *u) {
2653 /* This call does check the current state of the unit. It's
2654 * hence useful to be called from state change calls of the
2655 * unit itself, where the state isn't updated yet. This is
2656 * different from unit_inactive_or_pending() which checks both
2657 * the current state and for a queued job. */
2659 return u->job && u->job->type == JOB_STOP;
2662 bool unit_inactive_or_pending(Unit *u) {
2665 /* Returns true if the unit is inactive or going down */
2667 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2670 if (unit_stop_pending(u))
2676 bool unit_active_or_pending(Unit *u) {
2679 /* Returns true if the unit is active or going up */
2681 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2685 (u->job->type == JOB_START ||
2686 u->job->type == JOB_RELOAD_OR_START ||
2687 u->job->type == JOB_RESTART))
2693 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2695 assert(w >= 0 && w < _KILL_WHO_MAX);
2697 assert(signo < _NSIG);
2699 if (!UNIT_VTABLE(u)->kill)
2702 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2705 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2709 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2713 /* Exclude the main/control pids from being killed via the cgroup */
2715 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2720 if (control_pid > 0) {
2721 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2733 int unit_kill_common(
2739 sd_bus_error *error) {
2743 if (who == KILL_MAIN && main_pid <= 0) {
2745 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2747 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2751 if (who == KILL_CONTROL && control_pid <= 0) {
2752 if (control_pid < 0)
2753 sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2755 sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2759 if (who == KILL_CONTROL || who == KILL_ALL)
2760 if (control_pid > 0)
2761 if (kill(control_pid, signo) < 0)
2764 if (who == KILL_MAIN || who == KILL_ALL)
2766 if (kill(main_pid, signo) < 0)
2769 if (who == KILL_ALL && u->cgroup_path) {
2770 _cleanup_set_free_ Set *pid_set = NULL;
2773 /* Exclude the main/control pids from being killed via the cgroup */
2774 pid_set = unit_pid_set(main_pid, control_pid);
2778 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2779 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2786 int unit_following_set(Unit *u, Set **s) {
2790 if (UNIT_VTABLE(u)->following_set)
2791 return UNIT_VTABLE(u)->following_set(u, s);
2797 UnitFileState unit_get_unit_file_state(Unit *u) {
2800 if (u->unit_file_state < 0 && u->fragment_path)
2801 u->unit_file_state = unit_file_get_state(
2802 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2803 NULL, basename(u->fragment_path));
2805 return u->unit_file_state;
2808 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2813 unit_ref_unset(ref);
2816 LIST_PREPEND(refs, u->refs, ref);
2820 void unit_ref_unset(UnitRef *ref) {
2826 LIST_REMOVE(refs, ref->unit->refs, ref);
2830 int unit_patch_contexts(Unit *u) {
2838 /* Patch in the manager defaults into the exec and cgroup
2839 * contexts, _after_ the rest of the settings have been
2842 ec = unit_get_exec_context(u);
2844 /* This only copies in the ones that need memory */
2845 for (i = 0; i < _RLIMIT_MAX; i++)
2846 if (u->manager->rlimit[i] && !ec->rlimit[i]) {
2847 ec->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2852 if (u->manager->running_as == SYSTEMD_USER &&
2853 !ec->working_directory) {
2855 r = get_home_dir(&ec->working_directory);
2860 if (u->manager->running_as == SYSTEMD_USER &&
2861 (ec->syscall_whitelist ||
2862 !set_isempty(ec->syscall_filter) ||
2863 !set_isempty(ec->syscall_archs) ||
2864 ec->address_families_whitelist ||
2865 !set_isempty(ec->address_families)))
2866 ec->no_new_privileges = true;
2868 if (ec->private_devices)
2869 ec->capability_bounding_set_drop |= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD;
2872 cc = unit_get_cgroup_context(u);
2876 ec->private_devices &&
2877 cc->device_policy == CGROUP_AUTO)
2878 cc->device_policy = CGROUP_CLOSED;
2884 ExecContext *unit_get_exec_context(Unit *u) {
2891 offset = UNIT_VTABLE(u)->exec_context_offset;
2895 return (ExecContext*) ((uint8_t*) u + offset);
2898 KillContext *unit_get_kill_context(Unit *u) {
2905 offset = UNIT_VTABLE(u)->kill_context_offset;
2909 return (KillContext*) ((uint8_t*) u + offset);
2912 CGroupContext *unit_get_cgroup_context(Unit *u) {
2918 offset = UNIT_VTABLE(u)->cgroup_context_offset;
2922 return (CGroupContext*) ((uint8_t*) u + offset);
2925 ExecRuntime *unit_get_exec_runtime(Unit *u) {
2931 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2935 return *(ExecRuntime**) ((uint8_t*) u + offset);
2938 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2939 _cleanup_free_ char *b = NULL;
2948 b = xescape(name, "/.");
2952 if (!filename_is_safe(b))
2955 if (u->manager->running_as == SYSTEMD_USER) {
2956 _cleanup_free_ char *c = NULL;
2958 r = user_config_home(&c);
2964 p = strjoin(c, "/", u->id, ".d", NULL);
2965 } else if (mode == UNIT_PERSISTENT && !u->transient)
2966 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2968 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2972 q = strjoin(p, "/90-", b, ".conf", NULL);
2983 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2984 _cleanup_free_ char *p = NULL, *q = NULL;
2991 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
2994 r = drop_in_file(u, mode, name, &p, &q);
2999 return write_string_file_atomic_label(q, data);
3002 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3003 _cleanup_free_ char *p = NULL;
3011 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3014 va_start(ap, format);
3015 r = vasprintf(&p, format, ap);
3021 return unit_write_drop_in(u, mode, name, p);
3024 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3025 _cleanup_free_ char *ndata = NULL;
3031 if (!UNIT_VTABLE(u)->private_section)
3034 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3037 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
3041 return unit_write_drop_in(u, mode, name, ndata);
3044 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3045 _cleanup_free_ char *p = NULL;
3053 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3056 va_start(ap, format);
3057 r = vasprintf(&p, format, ap);
3063 return unit_write_drop_in_private(u, mode, name, p);
3066 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
3067 _cleanup_free_ char *p = NULL, *q = NULL;
3072 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3075 r = drop_in_file(u, mode, name, &p, &q);
3080 r = errno == ENOENT ? 0 : -errno;
3088 int unit_make_transient(Unit *u) {
3093 u->load_state = UNIT_STUB;
3095 u->transient = true;
3097 free(u->fragment_path);
3098 u->fragment_path = NULL;
3100 if (u->manager->running_as == SYSTEMD_USER) {
3101 _cleanup_free_ char *c = NULL;
3103 r = user_config_home(&c);
3109 u->fragment_path = strjoin(c, "/", u->id, NULL);
3110 if (!u->fragment_path)
3115 u->fragment_path = strappend("/run/systemd/system/", u->id);
3116 if (!u->fragment_path)
3119 mkdir_p("/run/systemd/system", 0755);
3122 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3125 int unit_kill_context(
3131 bool main_pid_alien) {
3133 int sig, wait_for_exit = false, r;
3138 if (c->kill_mode == KILL_NONE)
3141 sig = sigkill ? SIGKILL : c->kill_signal;
3144 r = kill_and_sigcont(main_pid, sig);
3146 if (r < 0 && r != -ESRCH) {
3147 _cleanup_free_ char *comm = NULL;
3148 get_process_comm(main_pid, &comm);
3150 log_warning_unit(u->id, "Failed to kill main process " PID_FMT " (%s): %s", main_pid, strna(comm), strerror(-r));
3152 if (!main_pid_alien)
3153 wait_for_exit = true;
3155 if (c->send_sighup && !sigkill)
3156 kill(main_pid, SIGHUP);
3160 if (control_pid > 0) {
3161 r = kill_and_sigcont(control_pid, sig);
3163 if (r < 0 && r != -ESRCH) {
3164 _cleanup_free_ char *comm = NULL;
3165 get_process_comm(control_pid, &comm);
3167 log_warning_unit(u->id, "Failed to kill control process " PID_FMT " (%s): %s", control_pid, strna(comm), strerror(-r));
3169 wait_for_exit = true;
3171 if (c->send_sighup && !sigkill)
3172 kill(control_pid, SIGHUP);
3176 if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && sigkill)) && u->cgroup_path) {
3177 _cleanup_set_free_ Set *pid_set = NULL;
3179 /* Exclude the main/control pids from being killed via the cgroup */
3180 pid_set = unit_pid_set(main_pid, control_pid);
3184 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3186 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3187 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3190 /* FIXME: For now, we will not wait for the
3191 * cgroup members to die, simply because
3192 * cgroup notification is unreliable. It
3193 * doesn't work at all in containers, and
3194 * outside of containers it can be confused
3195 * easily by leaving directories in the
3198 /* wait_for_exit = true; */
3200 if (c->send_sighup && !sigkill) {
3203 pid_set = unit_pid_set(main_pid, control_pid);
3207 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3212 return wait_for_exit;
3215 int unit_require_mounts_for(Unit *u, const char *path) {
3216 char prefix[strlen(path) + 1], *p;
3222 /* Registers a unit for requiring a certain path and all its
3223 * prefixes. We keep a simple array of these paths in the
3224 * unit, since its usually short. However, we build a prefix
3225 * table for all possible prefixes so that new appearing mount
3226 * units can easily determine which units to make themselves a
3229 if (!path_is_absolute(path))
3236 path_kill_slashes(p);
3238 if (!path_is_safe(p)) {
3243 if (strv_contains(u->requires_mounts_for, p)) {
3248 r = strv_consume(&u->requires_mounts_for, p);
3252 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3255 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3259 if (!u->manager->units_requiring_mounts_for) {
3260 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
3261 if (!u->manager->units_requiring_mounts_for)
3269 x = set_new(NULL, NULL);
3275 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3291 int unit_setup_exec_runtime(Unit *u) {
3297 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3300 /* Check if ther already is an ExecRuntime for this unit? */
3301 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3305 /* Try to get it from somebody else */
3306 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3308 *rt = unit_get_exec_runtime(other);
3310 exec_runtime_ref(*rt);
3315 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3318 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3319 [UNIT_ACTIVE] = "active",
3320 [UNIT_RELOADING] = "reloading",
3321 [UNIT_INACTIVE] = "inactive",
3322 [UNIT_FAILED] = "failed",
3323 [UNIT_ACTIVATING] = "activating",
3324 [UNIT_DEACTIVATING] = "deactivating"
3327 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3329 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3330 [UNIT_REQUIRES] = "Requires",
3331 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3332 [UNIT_REQUISITE] = "Requisite",
3333 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3334 [UNIT_WANTS] = "Wants",
3335 [UNIT_BINDS_TO] = "BindsTo",
3336 [UNIT_PART_OF] = "PartOf",
3337 [UNIT_REQUIRED_BY] = "RequiredBy",
3338 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3339 [UNIT_WANTED_BY] = "WantedBy",
3340 [UNIT_BOUND_BY] = "BoundBy",
3341 [UNIT_CONSISTS_OF] = "ConsistsOf",
3342 [UNIT_CONFLICTS] = "Conflicts",
3343 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3344 [UNIT_BEFORE] = "Before",
3345 [UNIT_AFTER] = "After",
3346 [UNIT_ON_FAILURE] = "OnFailure",
3347 [UNIT_TRIGGERS] = "Triggers",
3348 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3349 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3350 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3351 [UNIT_JOINS_NAMESPACE_OF] = "JoinsNamespaceOf",
3352 [UNIT_REFERENCES] = "References",
3353 [UNIT_REFERENCED_BY] = "ReferencedBy",
3356 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);